2 ** flist.c -- list nmh folders containing messages
3 ** -- in a given sequence
6 ** David Nichols, Xerox-PARC, November, 1992
8 ** Copyright (c) 1994 Xerox Corporation.
9 ** Use and copying of this software and preparation of derivative works based
10 ** upon this software are permitted. Any distribution of this software or
11 ** derivative works must comply with all applicable United States export
12 ** control laws. This software is made available AS IS, and Xerox Corporation
13 ** makes no warranty about the software, its performance or its conformity to
24 ** We allocate space to record the names of folders
25 ** (foldersToDo array), this number of elements at a time.
27 #define MAXFOLDERS 100
30 static struct swit switches[] = {
32 { "sequence name", 0 },
65 char *name; /* name of folder */
67 int error; /* error == 1 for unreadable folder */
68 int nMsgs; /* number of messages in folder */
69 int nSeq[NUMATTRS]; /* number of messages in each sequence */
70 int private[NUMATTRS]; /* is given sequence, public or private */
73 static struct Folder *orders = NULL;
74 static int nOrders = 0;
75 static int nOrdersAlloced = 0;
76 static struct Folder *folders = NULL;
77 static int nFolders = 0;
78 static int nFoldersAlloced = 0;
80 /* info on folders to search */
81 static char **foldersToDo;
82 static int numfolders;
83 static int maxfolders;
85 /* info on sequences to search for */
86 static char *sequencesToDo[NUMATTRS];
87 static int numsequences;
89 static int all = FALSE; /* scan all folders in top level? */
90 static int alphaOrder = FALSE; /* want alphabetical order only */
91 static int recurse = FALSE; /* show nested folders? */
92 static int showzero = TRUE; /* show folders even if no messages in seq? */
93 static int Total = TRUE; /* display info on number of messages in
94 * sequence found, and total num messages */
96 static char curfolder[BUFSIZ]; /* name of the current folder */
97 static char *nmhdir; /* base nmh mail directory */
100 ** Type for a compare function for qsort. This keeps
101 ** the compiler happy.
103 typedef int (*qsort_comp) (const void *, const void *);
108 int CompareFolders(struct Folder *, struct Folder *);
109 void GetFolderOrder(void);
110 void ScanFolders(void);
111 int AddFolder(char *, int);
112 void BuildFolderList(char *, int);
113 void BuildFolderListRecurse(char *, struct stat *, int);
114 void PrintFolders(void);
115 void AllocFolders(struct Folder **, int *, int);
116 int AssignPriority(char *);
117 static void do_readonly_folders(void);
122 main(int argc, char **argv)
129 setlocale(LC_ALL, "");
131 invo_name = r1bindex(argv[0], '/');
133 /* read user profile/context */
137 ** If program was invoked with name ending
138 ** in `s', then add switch `-all'.
140 if (argv[0][strlen(argv[0]) - 1] == 's')
143 arguments = getarguments(invo_name, argc, argv, 1);
146 /* allocate the initial space to record the folder names */
148 maxfolders = MAXFOLDERS;
149 foldersToDo = (char **) mh_xmalloc((size_t)
150 (maxfolders * sizeof(*foldersToDo)));
152 /* no sequences yet */
155 /* parse arguments */
156 while ((cp = *argp++)) {
158 switch (smatch(++cp, switches)) {
160 ambigsw(cp, switches);
163 adios(NULL, "-%s unknown", cp);
166 snprintf(buf, sizeof(buf), "%s [+folder1 [+folder2 ...]][switches]", invo_name);
167 print_help(buf, switches, 1);
170 print_version(invo_name);
174 if (!(cp = *argp++) || *cp == '-')
175 adios(NULL, "missing argument to %s",
178 /* check if too many sequences specified */
179 if (numsequences >= NUMATTRS)
180 adios(NULL, "too many sequences (more than %d) specified", NUMATTRS);
181 sequencesToDo[numsequences++] = cp;
224 ** Check if we need to allocate more space
227 if (numfolders >= maxfolders) {
228 maxfolders += MAXFOLDERS;
229 foldersToDo = (char **) mh_xrealloc(foldersToDo, (size_t) (maxfolders * sizeof(*foldersToDo)));
231 if (*cp == '+' || *cp == '@') {
232 foldersToDo[numfolders++] =
235 foldersToDo[numfolders++] = cp;
239 if (!context_find("path"))
240 free(path("./", TFOLDER));
242 /* get current folder */
243 strncpy(curfolder, getfolder(1), sizeof(curfolder));
245 /* get nmh base directory */
246 nmhdir = m_maildir("");
249 ** If we didn't specify any sequences, we search
250 ** for the "Unseen-Sequence" profile entry and use
251 ** all the sequences defined there. We check to
252 ** make sure that the Unseen-Sequence entry doesn't
253 ** contain more than NUMATTRS sequences.
255 if (numsequences == 0) {
256 if ((cp = context_find(usequence)) && *cp) {
260 ap = brkstring(dp, " ", "\n");
261 for (; ap && *ap; ap++) {
262 if (numsequences >= NUMATTRS)
263 adios(NULL, "too many sequences (more than %d) in %s profile entry", NUMATTRS, usequence);
265 sequencesToDo[numsequences++] = *ap;
268 adios(NULL, "no sequence specified or %s profile entry found", usequence);
274 qsort(folders, nFolders, sizeof(struct Folder), (qsort_comp) CompareFolders);
281 ** Read the Flist-Order profile entry to determine
282 ** how to sort folders for output.
288 unsigned char *p, *s;
292 if (!(p = context_find("Flist-Order")))
298 while (*p && !isspace(*p))
302 AllocFolders(&orders, &nOrdersAlloced, nOrders + 1);
303 o = &orders[nOrders++];
304 o->priority = priority++;
305 o->name = (char *) mh_xmalloc(p - s + 1);
306 strncpy(o->name, s, p - s);
314 ** Scan all the necessary folders
323 * change directory to base of nmh directory
325 if (chdir(nmhdir) == NOTOK)
326 adios(nmhdir, "unable to change directory to");
328 if (numfolders > 0) {
330 strncpy(curfolder, foldersToDo[numfolders - 1],
332 context_replace(pfolder, curfolder);/* update current folder */
333 context_save(); /* save the context file */
336 ** Scan each given folder. If -all is given,
337 ** then also scan the 1st level subfolders under
338 ** each given folder.
340 for (i = 0; i < numfolders; ++i)
341 BuildFolderList(foldersToDo[i], all ? 1 : 0);
345 ** Do the readonly folders
347 do_readonly_folders();
350 ** Now scan the entire nmh directory for folders
352 BuildFolderList(".", 0);
355 ** Else scan current folder
357 BuildFolderList(curfolder, 0);
363 ** Initial building of folder list for
364 ** the top of our search tree.
368 BuildFolderList(char *dirName, int searchdepth)
372 /* Make sure we have a directory */
373 if ((stat(dirName, &st) == -1) || !S_ISDIR(st.st_mode))
377 ** If base directory, don't add it to the
378 ** folder list. We just recurse into it.
380 if (!strcmp(dirName, ".")) {
381 BuildFolderListRecurse(".", &st, 0);
386 ** Add this folder to the list.
387 ** If recursing and directory has subfolders,
388 ** then build folder list for subfolders.
390 if (AddFolder(dirName, showzero) && (recurse || searchdepth) &&
392 BuildFolderListRecurse(dirName, &st, searchdepth - 1);
396 ** Recursive building of folder list
400 BuildFolderListRecurse(char *dirName, struct stat *s, int searchdepth)
402 char *base, name[PATH_MAX];
410 ** Keep track of number of directories we've seen so we can
411 ** stop stat'ing entries in this directory once we've seen
412 ** them all. This optimization will fail if you have extra
413 ** directories beginning with ".", since we don't bother to
414 ** stat them. But that shouldn't generally be a problem.
416 nlinks = s->st_nlink;
418 if (!(dir = opendir(dirName)))
419 adios(dirName, "can't open directory");
422 ** A hack so that we don't see a
423 ** leading "./" in folder names.
425 base = strcmp(dirName, ".") ? dirName : dirName + 1;
427 while (nlinks && (dp = readdir(dir))) {
428 if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) {
432 if (dp->d_name[0] == '.')
434 /* Check to see if the name of the file is a number
435 ** if it is, we assume it's a mail file and skip it
437 for (n = dp->d_name; *n && isdigit(*n); n++);
440 strncpy(name, base, sizeof(name) - 2);
443 strncat(name, dp->d_name, sizeof(name) - strlen(name) - 1);
444 if ((stat(name, &st) != -1) && S_ISDIR(st.st_mode)) {
446 ** Check if this was really a symbolic link pointing
447 ** to a directory. If not, then decrement link count.
449 if (lstat(name, &st) == -1)
451 /* Add this folder to the list */
452 if (AddFolder(name, showzero) &&
453 (recurse || searchdepth) &&
455 BuildFolderListRecurse(name, &st, searchdepth - 1);
462 ** Add this folder to our list, counting the total number of
463 ** messages and the number of messages in each sequence.
467 AddFolder(char *name, int force)
469 int i, msgnum, nonzero;
470 int seqnum[NUMATTRS], nSeq[NUMATTRS];
474 /* Read folder and create message structure */
475 if (!(mp = folder_read(name))) {
476 /* Oops, error occurred. Record it and continue. */
477 AllocFolders(&folders, &nFoldersAlloced, nFolders + 1);
478 f = &folders[nFolders++];
479 f->name = getcpy(name);
481 f->priority = AssignPriority(f->name);
485 for (i = 0; i < numsequences; i++) {
486 /* Convert sequences to their sequence numbers */
487 if (sequencesToDo[i])
488 seqnum[i] = seq_getnum(mp, sequencesToDo[i]);
492 /* Now count messages in this sequence */
494 if (mp->nummsg > 0 && seqnum[i] != -1) {
495 for (msgnum = mp->lowmsg; msgnum <= mp->hghmsg;
497 if (in_sequence(mp, seqnum[i], msgnum))
503 /* Check if any of the sequence checks were nonzero */
505 for (i = 0; i < numsequences; i++) {
512 if (nonzero || force) {
513 /* save general folder information */
514 AllocFolders(&folders, &nFoldersAlloced, nFolders + 1);
515 f = &folders[nFolders++];
516 f->name = getcpy(name);
517 f->nMsgs = mp->nummsg;
519 f->priority = AssignPriority(f->name);
521 /* record the sequence information */
522 for (i = 0; i < numsequences; i++) {
523 f->nSeq[i] = nSeq[i];
524 f->private[i] = (seqnum[i] != -1) ?
525 is_seq_private(mp, seqnum[i]) : 0;
529 folder_free(mp); /* free folder/message structure */
534 ** Print the folder/sequence information
540 char tmpname[BUFSIZ];
541 int i, j, len, has_private = 0;
542 int maxfolderlen = 0, maxseqlen = 0;
543 int maxnum = 0, maxseq = 0;
546 for (i = 0; i < nFolders; i++)
547 printf("%s\n", folders[i].name);
552 ** Find the width we need for various fields
554 for (i = 0; i < nFolders; ++i) {
555 /* find the length of longest folder name */
556 len = strlen(folders[i].name);
557 if (len > maxfolderlen)
560 /* If folder had error, skip the rest */
561 if (folders[i].error)
564 /* find the maximum total messages */
565 if (folders[i].nMsgs > maxnum)
566 maxnum = folders[i].nMsgs;
568 for (j = 0; j < numsequences; j++) {
569 /* find maximum width of sequence name */
570 len = strlen(sequencesToDo[j]);
571 if ((folders[i].nSeq[j] > 0 || showzero) &&
575 /* find the maximum number of messages in sequence */
576 if (folders[i].nSeq[j] > maxseq)
577 maxseq = folders[i].nSeq[j];
579 /* check if this sequence is private in any of the folders */
580 if (folders[i].private[j])
585 /* Now print all the folder/sequence information */
586 for (i = 0; i < nFolders; i++) {
587 for (j = 0; j < numsequences; j++) {
588 if (folders[i].nSeq[j] > 0 || showzero) {
589 /* Add `+' to end of name of current folder */
590 if (strcmp(curfolder, folders[i].name))
591 snprintf(tmpname, sizeof(tmpname),
592 "%s", folders[i].name);
594 snprintf(tmpname, sizeof(tmpname),
598 if (folders[i].error) {
599 printf("%-*s is unreadable\n",
605 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);
612 ** Put them in priority order.
616 CompareFolders(struct Folder *f1, struct Folder *f2)
618 if (!alphaOrder && f1->priority != f2->priority)
619 return f1->priority - f2->priority;
621 return strcmp(f1->name, f2->name);
625 ** Make sure we have at least n folders allocated.
629 AllocFolders(struct Folder **f, int *nfa, int n)
635 *f = (struct Folder *) mh_xmalloc(
636 *nfa * (sizeof(struct Folder)));
639 *f = (struct Folder *) mh_xrealloc(
640 *f, *nfa * (sizeof(struct Folder)));
645 ** Return the priority for a name. The highest comes from an exact match.
646 ** After that, the longest match (then first) assigns the priority.
649 AssignPriority(char *name)
657 for (i = 0; i < nOrders; ++i) {
659 if (!strcmp(name, o->name))
661 ol = strlen(o->name);
666 if (o->name[0] == '*' && !strcmp(o->name + 1,
667 name + (nl - ol + 1))) {
670 } else if (o->name[ol - 1] == '*' &&
671 strncmp(o->name, name, ol - 1) == 0) {
680 ** Do the read only folders
684 do_readonly_folders(void)
688 register struct node *np;
690 snprintf(atrcur, sizeof(atrcur), "atr-%s-", current);
691 atrlen = strlen(atrcur);
693 for (np = m_defs; np; np = np->n_next)
694 if (ssequal(atrcur, np->n_name)
695 && !ssequal(nmhdir, np->n_name + atrlen))
696 BuildFolderList(np->n_name + atrlen, 0);