/*
* flist.c -- list nmh folders containing messages
* -- in a given sequence
*
* originally by
* David Nichols, Xerox-PARC, November, 1992
*
* Copyright (c) 1994 Xerox Corporation.
* Use and copying of this software and preparation of derivative works based
* upon this software are permitted. Any distribution of this software or
* derivative works must comply with all applicable United States export
* control laws. This software is made available AS IS, and Xerox Corporation
* makes no warranty about the software, its performance or its conformity to
* any specification.
*
* $Id: flist.c,v 1.6 2005/11/02 17:22:27 opk Exp $
*/
#include <h/mh.h>
#define FALSE 0
#define TRUE 1
/*
* We allocate space to record the names of folders
* (foldersToDo array), this number of elements at a time.
*/
#define MAXFOLDERS 100
static struct swit switches[] = {
#define SEQSW 0
{ "sequence name", 0 },
#define ALLSW 1
{ "all", 0 },
#define NOALLSW 2
{ "noall", 0 },
#define RECURSE 3
{ "recurse", 0 },
#define NORECURSE 4
{ "norecurse", 0 },
#define SHOWZERO 5
{ "showzero", 0 },
#define NOSHOWZERO 6
{ "noshowzero", 0 },
#define ALPHASW 7
{ "alpha", 0 },
#define NOALPHASW 8
{ "noalpha", 0 },
#define FASTSW 9
{ "fast", 0 },
#define NOFASTSW 10
{ "nofast", 0 },
#define TOTALSW 11
{ "total", -5 },
#define NOTOTALSW 12
{ "nototal", -7 },
#define VERSIONSW 13
{ "version", 0 },
#define HELPSW 14
{ "help", 0 },
{ NULL, 0 }
};
struct Folder {
char *name; /* name of folder */
int priority;
int error; /* error == 1 for unreadable folder */
int nMsgs; /* number of messages in folder */
int nSeq[NUMATTRS]; /* number of messages in each sequence */
int private[NUMATTRS]; /* is given sequence, public or private */
};
static struct Folder *orders = NULL;
static int nOrders = 0;
static int nOrdersAlloced = 0;
static struct Folder *folders = NULL;
static int nFolders = 0;
static int nFoldersAlloced = 0;
/* info on folders to search */
static char **foldersToDo;
static int numfolders;
static int maxfolders;
/* info on sequences to search for */
static char *sequencesToDo[NUMATTRS];
static int numsequences;
static int all = FALSE; /* scan all folders in top level? */
static int alphaOrder = FALSE; /* want alphabetical order only */
static int recurse = FALSE; /* show nested folders? */
static int showzero = TRUE; /* show folders even if no messages in seq? */
static int Total = TRUE; /* display info on number of messages in *
* sequence found, and total num messages */
static char curfolder[BUFSIZ]; /* name of the current folder */
static char *nmhdir; /* base nmh mail directory */
/*
* Type for a compare function for qsort. This keeps
* the compiler happy.
*/
typedef int (*qsort_comp) (const void *, const void *);
/*
* prototypes
*/
int CompareFolders(struct Folder *, struct Folder *);
void GetFolderOrder(void);
void ScanFolders(void);
int AddFolder(char *, int);
void BuildFolderList(char *, int);
void BuildFolderListRecurse(char *, struct stat *, int);
void PrintFolders(void);
static int num_digits (int);
void AllocFolders(struct Folder **, int *, int);
int AssignPriority(char *);
static void do_readonly_folders(void);
int
main(int argc, char **argv)
{
char *cp, **argp;
char **arguments;
char buf[BUFSIZ];
#ifdef LOCALE
setlocale(LC_ALL, "");
#endif
invo_name = r1bindex(argv[0], '/');
/* read user profile/context */
context_read();
/*
* If program was invoked with name ending
* in `s', then add switch `-all'.
*/
if (argv[0][strlen (argv[0]) - 1] == 's')
all = TRUE;
arguments = getarguments (invo_name, argc, argv, 1);
argp = arguments;
/* allocate the initial space to record the folder names */
numfolders = 0;
maxfolders = MAXFOLDERS;
if (!(foldersToDo = (char **) malloc ((size_t) (maxfolders * sizeof(*foldersToDo)))))
adios (NULL, "unable to allocate folder storage");
/* no sequences yet */
numsequences = 0;
/* parse arguments */
while ((cp = *argp++)) {
if (*cp == '-') {
switch (smatch(++cp, switches)) {
case AMBIGSW:
ambigsw(cp, switches);
done(1);
case UNKWNSW:
adios(NULL, "-%s unknown", cp);
case HELPSW:
snprintf(buf, sizeof(buf), "%s [+folder1 [+folder2 ...]][switches]",
invo_name);
print_help(buf, switches, 1);
done(1);
case VERSIONSW:
print_version(invo_name);
done (1);
case SEQSW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
/* check if too many sequences specified */
if (numsequences >= NUMATTRS)
adios (NULL, "too many sequences (more than %d) specified", NUMATTRS);
sequencesToDo[numsequences++] = cp;
break;
case ALLSW:
all = TRUE;
break;
case NOALLSW:
all = FALSE;
break;
case SHOWZERO:
showzero = TRUE;
break;
case NOSHOWZERO:
showzero = FALSE;
break;
case ALPHASW:
alphaOrder = TRUE;
break;
case NOALPHASW:
alphaOrder = FALSE;
break;
case NOFASTSW:
case TOTALSW:
Total = TRUE;
break;
case FASTSW:
case NOTOTALSW:
Total = FALSE;
break;
case RECURSE:
recurse = TRUE;
break;
case NORECURSE:
recurse = FALSE;
break;
}
} else {
/*
* Check if we need to allocate more space
* for folder names.
*/
if (numfolders >= maxfolders) {
maxfolders += MAXFOLDERS;
if (!(foldersToDo = (char **) realloc (foldersToDo,
(size_t) (maxfolders * sizeof(*foldersToDo)))))
adios (NULL, "unable to reallocate folder name storage");
}
if (*cp == '+' || *cp == '@') {
foldersToDo[numfolders++] =
path (cp + 1, *cp == '+' ? TFOLDER : TSUBCWF);
} else
foldersToDo[numfolders++] = cp;
}
}
if (!context_find ("path"))
free (path ("./", TFOLDER));
/* get current folder */
strncpy (curfolder, getfolder(1), sizeof(curfolder));
/* get nmh base directory */
nmhdir = m_maildir ("");
/*
* If we didn't specify any sequences, we search
* for the "Unseen-Sequence" profile entry and use
* all the sequences defined there. We check to
* make sure that the Unseen-Sequence entry doesn't
* contain more than NUMATTRS sequences.
*/
if (numsequences == 0) {
if ((cp = context_find(usequence)) && *cp) {
char **ap, *dp;
dp = getcpy(cp);
ap = brkstring (dp, " ", "\n");
for (; ap && *ap; ap++) {
if (numsequences >= NUMATTRS)
adios (NULL, "too many sequences (more than %d) in %s profile entry",
NUMATTRS, usequence);
else
sequencesToDo[numsequences++] = *ap;
}
} else {
adios (NULL, "no sequence specified or %s profile entry found", usequence);
}
}
GetFolderOrder();
ScanFolders();
qsort(folders, nFolders, sizeof(struct Folder), (qsort_comp) CompareFolders);
PrintFolders();
return done (0);
}
/*
* Read the Flist-Order profile entry to determine
* how to sort folders for output.
*/
void
GetFolderOrder(void)
{
char *p, *s;
int priority = 1;
struct Folder *o;
if (!(p = context_find("Flist-Order")))
return;
for (;;) {
while (isspace(*p))
++p;
s = p;
while (*p && !isspace(*p))
++p;
if (p != s) {
/* Found one. */
AllocFolders(&orders, &nOrdersAlloced, nOrders + 1);
o = &orders[nOrders++];
o->priority = priority++;
o->name = (char *) malloc(p - s + 1);
strncpy(o->name, s, p - s);
o->name[p - s] = 0;
} else
break;
}
}
/*
* Scan all the necessary folders
*/
void
ScanFolders(void)
{
int i;
/*
* change directory to base of nmh directory
*/
if (chdir (nmhdir) == NOTOK)
adios (nmhdir, "unable to change directory to");
if (numfolders > 0) {
/* Update context */
strncpy (curfolder, foldersToDo[numfolders - 1], sizeof(curfolder));
context_replace (pfolder, curfolder);/* update current folder */
context_save (); /* save the context file */
/*
* Scan each given folder. If -all is given,
* then also scan the 1st level subfolders under
* each given folder.
*/
for (i = 0; i < numfolders; ++i)
BuildFolderList(foldersToDo[i], all ? 1 : 0);
} else {
if (all) {
/*
* Do the readonly folders
*/
do_readonly_folders();
/*
* Now scan the entire nmh directory for folders
*/
BuildFolderList(".", 0);
} else {
/*
* Else scan current folder
*/
BuildFolderList(curfolder, 0);
}
}
}
/*
* Initial building of folder list for
* the top of our search tree.
*/
void
BuildFolderList(char *dirName, int searchdepth)
{
struct stat st;
/* Make sure we have a directory */
if ((stat(dirName, &st) == -1) || !S_ISDIR(st.st_mode))
return;
/*
* If base directory, don't add it to the
* folder list. We just recurse into it.
*/
if (!strcmp (dirName, ".")) {
BuildFolderListRecurse (".", &st, 0);
return;
}
/*
* Add this folder to the list.
* If recursing and directory has subfolders,
* then build folder list for subfolders.
*/
if (AddFolder(dirName, showzero) && (recurse || searchdepth) && st.st_nlink > 2)
BuildFolderListRecurse(dirName, &st, searchdepth - 1);
}
/*
* Recursive building of folder list
*/
void
BuildFolderListRecurse(char *dirName, struct stat *s, int searchdepth)
{
char *base, *n, name[PATH_MAX];
int nlinks;
DIR *dir;
struct dirent *dp;
struct stat st;
/*
* Keep track of number of directories we've seen so we can
* stop stat'ing entries in this directory once we've seen
* them all. This optimization will fail if you have extra
* directories beginning with ".", since we don't bother to
* stat them. But that shouldn't generally be a problem.
*/
nlinks = s->st_nlink;
if (!(dir = opendir(dirName)))
adios(dirName, "can't open directory");
/*
* A hack so that we don't see a
* leading "./" in folder names.
*/
base = strcmp (dirName, ".") ? dirName : dirName + 1;
while (nlinks && (dp = readdir(dir))) {
if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) {
nlinks--;
continue;
}
if (dp->d_name[0] == '.')
continue;
/* Check to see if the name of the file is a number
* if it is, we assume it's a mail file and skip it
*/
for (n = dp->d_name; *n && isdigit(*n); n++);
if (!*n)
continue;
strncpy (name, base, sizeof(name) - 2);
if (*base)
strcat(name, "/");
strncat(name, dp->d_name, sizeof(name) - strlen(name) - 1);
if ((stat(name, &st) != -1) && S_ISDIR(st.st_mode)) {
/*
* Check if this was really a symbolic link pointing
* to a directory. If not, then decrement link count.
*/
if (lstat (name, &st) == -1)
nlinks--;
/* Add this folder to the list */
if (AddFolder(name, showzero) &&
(recurse || searchdepth) && st.st_nlink > 2)
BuildFolderListRecurse(name, &st, searchdepth - 1);
}
}
closedir(dir);
}
/*
* Add this folder to our list, counting the total number of
* messages and the number of messages in each sequence.
*/
int
AddFolder(char *name, int force)
{
int i, msgnum, nonzero;
int seqnum[NUMATTRS], nSeq[NUMATTRS];
struct Folder *f;
struct msgs *mp;
/* Read folder and create message structure */
if (!(mp = folder_read (name))) {
/* Oops, error occurred. Record it and continue. */
AllocFolders(&folders, &nFoldersAlloced, nFolders + 1);
f = &folders[nFolders++];
f->name = getcpy(name);
f->error = 1;
f->priority = AssignPriority(f->name);
return 0;
}
for (i = 0; i < numsequences; i++) {
/* Convert sequences to their sequence numbers */
if (sequencesToDo[i])
seqnum[i] = seq_getnum(mp, sequencesToDo[i]);
else
seqnum[i] = -1;
/* Now count messages in this sequence */
nSeq[i] = 0;
if (mp->nummsg > 0 && seqnum[i] != -1) {
for (msgnum = mp->lowmsg; msgnum <= mp->hghmsg; msgnum++) {
if (in_sequence(mp, seqnum[i], msgnum))
nSeq[i]++;
}
}
}
/* Check if any of the sequence checks were nonzero */
nonzero = 0;
for (i = 0; i < numsequences; i++) {
if (nSeq[i] > 0) {
nonzero = 1;
break;
}
}
if (nonzero || force) {
/* save general folder information */
AllocFolders(&folders, &nFoldersAlloced, nFolders + 1);
f = &folders[nFolders++];
f->name = getcpy(name);
f->nMsgs = mp->nummsg;
f->error = 0;
f->priority = AssignPriority(f->name);
/* record the sequence information */
for (i = 0; i < numsequences; i++) {
f->nSeq[i] = nSeq[i];
f->private[i] = (seqnum[i] != -1) ? is_seq_private(mp, seqnum[i]) : 0;
}
}
folder_free (mp); /* free folder/message structure */
return 1;
}
/*
* Print the folder/sequence information
*/
void
PrintFolders(void)
{
char tmpname[BUFSIZ];
int i, j, len, has_private = 0;
int maxfolderlen = 0, maxseqlen = 0;
int maxnum = 0, maxseq = 0;
if (!Total) {
for (i = 0; i < nFolders; i++)
printf("%s\n", folders[i].name);
return;
}
/*
* Find the width we need for various fields
*/
for (i = 0; i < nFolders; ++i) {
/* find the length of longest folder name */
len = strlen(folders[i].name);
if (len > maxfolderlen)
maxfolderlen = len;
/* If folder had error, skip the rest */
if (folders[i].error)
continue;
/* find the maximum total messages */
if (folders[i].nMsgs > maxnum)
maxnum = folders[i].nMsgs;
for (j = 0; j < numsequences; j++) {
/* find maximum width of sequence name */
len = strlen (sequencesToDo[j]);
if ((folders[i].nSeq[j] > 0 || showzero) && (len > maxseqlen))
maxseqlen = len;
/* find the maximum number of messages in sequence */
if (folders[i].nSeq[j] > maxseq)
maxseq = folders[i].nSeq[j];
/* check if this sequence is private in any of the folders */
if (folders[i].private[j])
has_private = 1;
}
}
/* Now print all the folder/sequence information */
for (i = 0; i < nFolders; i++) {
for (j = 0; j < numsequences; j++) {
if (folders[i].nSeq[j] > 0 || showzero) {
/* Add `+' to end of name of current folder */
if (strcmp(curfolder, folders[i].name))
snprintf(tmpname, sizeof(tmpname), "%s", folders[i].name);
else
snprintf(tmpname, sizeof(tmpname), "%s+", folders[i].name);
if (folders[i].error) {
printf("%-*s is unreadable\n", maxfolderlen+1, tmpname);
continue;
}
printf("%-*s has %*d in sequence %-*s%s; out of %*d\n",
maxfolderlen+1, tmpname,
num_digits(maxseq), folders[i].nSeq[j],
maxseqlen, sequencesToDo[j],
!has_private ? "" : folders[i].private[j] ? " (private)" : " ",
num_digits(maxnum), folders[i].nMsgs);
}
}
}
}
/*
* Calculate the number of digits in a nonnegative integer
*/
static int
num_digits (int n)
{
int ndigits = 0;
/* Sanity check */
if (n < 0)
adios (NULL, "oops, num_digits called with negative value");
if (n == 0)
return 1;
while (n) {
n /= 10;
ndigits++;
}
return ndigits;
}
/*
* Put them in priority order.
*/
int
CompareFolders(struct Folder *f1, struct Folder *f2)
{
if (!alphaOrder && f1->priority != f2->priority)
return f1->priority - f2->priority;
else
return strcmp(f1->name, f2->name);
}
/*
* Make sure we have at least n folders allocated.
*/
void
AllocFolders(struct Folder **f, int *nfa, int n)
{
if (n <= *nfa)
return;
if (*f == NULL) {
*nfa = 10;
*f = (struct Folder *) malloc (*nfa * (sizeof(struct Folder)));
} else {
*nfa *= 2;
*f = (struct Folder *) realloc (*f, *nfa * (sizeof(struct Folder)));
}
}
/*
* Return the priority for a name. The highest comes from an exact match.
* After that, the longest match (then first) assigns the priority.
*/
int
AssignPriority(char *name)
{
int i, ol, nl;
int best = nOrders;
int bestLen = 0;
struct Folder *o;
nl = strlen(name);
for (i = 0; i < nOrders; ++i) {
o = &orders[i];
if (!strcmp(name, o->name))
return o->priority;
ol = strlen(o->name);
if (nl < ol - 1)
continue;
if (ol < bestLen)
continue;
if (o->name[0] == '*' && !strcmp(o->name + 1, name + (nl - ol + 1))) {
best = o->priority;
bestLen = ol;
} else if (o->name[ol - 1] == '*' && strncmp(o->name, name, ol - 1) == 0) {
best = o->priority;
bestLen = ol;
}
}
return best;
}
/*
* Do the read only folders
*/
static void
do_readonly_folders (void)
{
int atrlen;
char atrcur[BUFSIZ];
register struct node *np;
snprintf (atrcur, sizeof(atrcur), "atr-%s-", current);
atrlen = strlen (atrcur);
for (np = m_defs; np; np = np->n_next)
if (ssequal (atrcur, np->n_name)
&& !ssequal (nmhdir, np->n_name + atrlen))
BuildFolderList (np->n_name + atrlen, 0);
}
syntax highlighted by Code2HTML, v. 0.9.1