diplodocus.org Git - nmh/blob - uip/flist.c

   1 /*
   2  * flist.c -- list nmh folders containing messages
   3  *         -- in a given sequence
   4  *
   5  * originally by
   6  * David Nichols, Xerox-PARC, November, 1992
   7  *
   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
  14  * any specification.
  15  */
  16
  17 #include <h/mh.h>
  18 #include <h/utils.h>
  19
  20 #define FALSE   0
  21 #define TRUE    1
  22
  23 /*
  24  * We allocate space to record the names of folders
  25  * (foldersToDo array), this number of elements at a time.
  26  */
  27 #define MAXFOLDERS  100
  28
  29
  30 #define FLIST_SWITCHES \
  31     X("sequence name", 0, SEQSW) \
  32     X("all", 0, ALLSW) \
  33     X("noall", 0, NOALLSW) \
  34     X("recurse", 0, RECURSE) \
  35     X("norecurse", 0, NORECURSE) \
  36     X("showzero", 0, SHOWZERO) \
  37     X("noshowzero", 0, NOSHOWZERO) \
  38     X("alpha", 0, ALPHASW) \
  39     X("noalpha", 0, NOALPHASW) \
  40     X("fast", 0, FASTSW) \
  41     X("nofast", 0, NOFASTSW) \
  42     X("total", -5, TOTALSW) \
  43     X("nototal", -7, NOTOTALSW) \
  44     X("version", 0, VERSIONSW) \
  45     X("help", 0, HELPSW) \
  46
  47 #define X(sw, minchars, id) id,
  48 DEFINE_SWITCH_ENUM(FLIST);
  49 #undef X
  50
  51 #define X(sw, minchars, id) { sw, minchars, id },
  52 DEFINE_SWITCH_ARRAY(FLIST, switches);
  53 #undef X
  54
  55 struct Folder {
  56     char *name;                 /* name of folder */
  57     int priority;
  58     int error;                  /* error == 1 for unreadable folder     */
  59     int nMsgs;                  /* number of messages in folder         */
  60     ivector_t nSeq;             /* number of messages in each sequence  */
  61     ivector_t private;          /* is given sequence, public or private */
  62 };
  63
  64 static struct Folder *orders = NULL;
  65 static int nOrders = 0;
  66 static int nOrdersAlloced = 0;
  67 static struct Folder *folders = NULL;
  68 static unsigned int nFolders = 0;
  69 static int nFoldersAlloced = 0;
  70
  71 /* info on folders to search */
  72 static char **foldersToDo;
  73 static int numfolders;
  74 static int maxfolders;
  75
  76 /* info on sequences to search for */
  77 static svector_t sequencesToDo;
  78
  79 static int all        = FALSE;  /* scan all folders in top level?           */
  80 static int alphaOrder = FALSE;  /* want alphabetical order only             */
  81 static int recurse    = FALSE;  /* show nested folders?                     */
  82 static int showzero   = TRUE;   /* show folders even if no messages in seq? */
  83 static int Total      = TRUE;   /* display info on number of messages in    *
  84                                  * sequence found, and total num messages   */
  85
  86 static char curfolder[BUFSIZ];  /* name of the current folder */
  87 static char *nmhdir;            /* base nmh mail directory    */
  88
  89 /*
  90  * Type for a compare function for qsort.  This keeps
  91  * the compiler happy.
  92  */
  93 typedef int (*qsort_comp) (const void *, const void *);
  94
  95 /*
  96  * prototypes
  97  */
  98 int CompareFolders(struct Folder *, struct Folder *);
  99 void GetFolderOrder(void);
 100 void ScanFolders(void);
 101 int AddFolder(char *, int);
 102 void BuildFolderList(char *, int);
 103 void BuildFolderListRecurse(char *, struct stat *, int);
 104 void PrintFolders(void);
 105 void AllocFolders(struct Folder **, int *, int);
 106 int AssignPriority(char *);
 107 static void do_readonly_folders(void);
 108
 109
 110
 111 int
 112 main(int argc, char **argv)
 113 {
 114     char *cp, **argp;
 115     char **arguments;
 116     char buf[BUFSIZ];
 117
 118     if (nmh_init(argv[0], 1)) { return 1; }
 119
 120     /*
 121      * If program was invoked with name ending
 122      * in `s', then add switch `-all'.
 123      */
 124     if (argv[0][strlen (argv[0]) - 1] == 's')
 125         all = TRUE;
 126
 127     arguments = getarguments (invo_name, argc, argv, 1);
 128     argp = arguments;
 129
 130     /* allocate the initial space to record the folder names */
 131     numfolders = 0;
 132     maxfolders = MAXFOLDERS;
 133     foldersToDo = (char **) mh_xmalloc ((size_t) (maxfolders * sizeof(*foldersToDo)));
 134
 135     /* no sequences yet */
 136     sequencesToDo = svector_create (0);
 137
 138     /* parse arguments */
 139     while ((cp = *argp++)) {
 140         if (*cp == '-') {
 141             switch (smatch(++cp, switches)) {
 142             case AMBIGSW:
 143                 ambigsw(cp, switches);
 144                 done(1);
 145             case UNKWNSW:
 146                 adios(NULL, "-%s unknown", cp);
 147
 148             case HELPSW:
 149                 snprintf(buf, sizeof(buf), "%s [+folder1 [+folder2 ...]][switches]",
 150                         invo_name);
 151                 print_help(buf, switches, 1);
 152                 done(0);
 153             case VERSIONSW:
 154                 print_version(invo_name);
 155                 done (0);
 156
 157             case SEQSW:
 158                 if (!(cp = *argp++) || *cp == '-')
 159                     adios (NULL, "missing argument to %s", argp[-2]);
 160
 161                 svector_push_back (sequencesToDo, cp);
 162                 break;
 163
 164             case ALLSW:
 165                 all = TRUE;
 166                 break;
 167             case NOALLSW:
 168                 all = FALSE;
 169                 break;
 170
 171             case SHOWZERO:
 172                 showzero = TRUE;
 173                 break;
 174             case NOSHOWZERO:
 175                 showzero = FALSE;
 176                 break;
 177
 178             case ALPHASW:
 179                 alphaOrder = TRUE;
 180                 break;
 181             case NOALPHASW:
 182                 alphaOrder = FALSE;
 183                 break;
 184
 185             case NOFASTSW:
 186             case TOTALSW:
 187                 Total = TRUE;
 188                 break;
 189
 190             case FASTSW:
 191             case NOTOTALSW:
 192                 Total = FALSE;
 193                 break;
 194
 195             case RECURSE:
 196                 recurse = TRUE;
 197                 break;
 198             case NORECURSE:
 199                 recurse = FALSE;
 200                 break;
 201             }
 202         } else {
 203             /*
 204              * Check if we need to allocate more space
 205              * for folder names.
 206              */
 207             if (numfolders >= maxfolders) {
 208                 maxfolders += MAXFOLDERS;
 209                 foldersToDo = (char **) mh_xrealloc (foldersToDo,
 210                     (size_t) (maxfolders * sizeof(*foldersToDo)));
 211             }
 212             if (*cp == '+' || *cp == '@') {
 213                 foldersToDo[numfolders++] =
 214                     pluspath (cp);
 215             } else
 216                 foldersToDo[numfolders++] = cp;
 217         }
 218     }
 219
 220     if (!context_find ("path"))
 221         free (path ("./", TFOLDER));
 222
 223     /* get current folder */
 224     strncpy (curfolder, getfolder(1), sizeof(curfolder));
 225
 226     /* get nmh base directory */
 227     nmhdir = m_maildir ("");
 228
 229     /*
 230      * If we didn't specify any sequences, we search
 231      * for the "Unseen-Sequence" profile entry and use
 232      * all the sequences defined there.
 233      */
 234     if (svector_size (sequencesToDo) == 0) {
 235         if ((cp = context_find(usequence)) && *cp) {
 236             char **ap, *dp;
 237
 238             dp = getcpy(cp);
 239             ap = brkstring (dp, " ", "\n");
 240             for (; ap && *ap; ap++)
 241                 svector_push_back (sequencesToDo, *ap);
 242         } else {
 243             adios (NULL, "no sequence specified or %s profile entry found", usequence);
 244         }
 245     }
 246
 247     GetFolderOrder();
 248     ScanFolders();
 249     qsort(folders, nFolders, sizeof(struct Folder), (qsort_comp) CompareFolders);
 250     PrintFolders();
 251     svector_free (sequencesToDo);
 252     done (0);
 253     return 1;
 254 }
 255
 256 /*
 257  * Read the Flist-Order profile entry to determine
 258  * how to sort folders for output.
 259  */
 260
 261 void
 262 GetFolderOrder(void)
 263 {
 264     char *p, *s;
 265     int priority = 1;
 266     struct Folder *o;
 267
 268     if (!(p = context_find("Flist-Order")))
 269         return;
 270     for (;;) {
 271         while (isspace((unsigned char) *p))
 272             ++p;
 273         s = p;
 274         while (*p && !isspace((unsigned char) *p))
 275             ++p;
 276         if (p != s) {
 277             /* Found one. */
 278             AllocFolders(&orders, &nOrdersAlloced, nOrders + 1);
 279             o = &orders[nOrders++];
 280             o->priority = priority++;
 281             o->name = (char *) mh_xmalloc(p - s + 1);
 282             strncpy(o->name, s, p - s);
 283             o->name[p - s] = 0;
 284         } else
 285             break;
 286     }
 287 }
 288
 289 /*
 290  * Scan all the necessary folders
 291  */
 292
 293 void
 294 ScanFolders(void)
 295 {
 296     int i;
 297
 298     /*
 299      * change directory to base of nmh directory
 300      */
 301     if (chdir (nmhdir) == NOTOK)
 302         adios (nmhdir, "unable to change directory to");
 303
 304     if (numfolders > 0) {
 305         /* Update context */
 306         strncpy (curfolder, foldersToDo[numfolders - 1], sizeof(curfolder));
 307         context_replace (pfolder, curfolder);/* update current folder */
 308         context_save ();                     /* save the context file */
 309
 310         /*
 311          * Scan each given folder.  If -all is given,
 312          * then also scan the 1st level subfolders under
 313          * each given folder.
 314          */
 315         for (i = 0; i < numfolders; ++i)
 316             BuildFolderList(foldersToDo[i], all ? 1 : 0);
 317     } else {
 318         if (all) {
 319             /*
 320              * Do the readonly folders
 321              */
 322             do_readonly_folders();
 323
 324             /*
 325              * Now scan the entire nmh directory for folders
 326              */
 327             BuildFolderList(".", 0);
 328         } else {
 329             /*
 330              * Else scan current folder
 331              */
 332             BuildFolderList(curfolder, 0);
 333         }
 334     }
 335 }
 336
 337 /*
 338  * Initial building of folder list for
 339  * the top of our search tree.
 340  */
 341
 342 void
 343 BuildFolderList(char *dirName, int searchdepth)
 344 {
 345     struct stat st;
 346
 347     /* Make sure we have a directory */
 348     if ((stat(dirName, &st) == -1) || !S_ISDIR(st.st_mode))
 349         return;
 350
 351     /*
 352      * If base directory, don't add it to the
 353      * folder list. We just recurse into it.
 354      */
 355     if (!strcmp (dirName, ".")) {
 356         BuildFolderListRecurse (".", &st, 0);
 357         return;
 358     }
 359
 360     /*
 361      * Add this folder to the list.
 362      * If recursing and directory has subfolders,
 363      * then build folder list for subfolders.
 364      */
 365     if (AddFolder(dirName, showzero) && (recurse || searchdepth) && st.st_nlink > 2)
 366         BuildFolderListRecurse(dirName, &st, searchdepth - 1);
 367 }
 368
 369 /*
 370  * Recursive building of folder list
 371  */
 372
 373 void
 374 BuildFolderListRecurse(char *dirName, struct stat *s, int searchdepth)
 375 {
 376     char *base, name[PATH_MAX];
 377     char *n;
 378     int nlinks;
 379     DIR *dir;
 380     struct dirent *dp;
 381     struct stat st;
 382
 383     /*
 384      * Keep track of number of directories we've seen so we can
 385      * stop stat'ing entries in this directory once we've seen
 386      * them all.  This optimization will fail if you have extra
 387      * directories beginning with ".", since we don't bother to
 388      * stat them.  But that shouldn't generally be a problem.
 389      */
 390     nlinks = s->st_nlink;
 391     if (nlinks == 1) {
 392       /* Disable the optimization under conditions where st_nlink
 393          is set to 1.  That happens on Cygwin, for example:
 394          http://cygwin.com/ml/cygwin-apps/2008-08/msg00264.html */
 395       nlinks = INT_MAX;
 396     }
 397
 398     if (!(dir = opendir(dirName)))
 399         adios(dirName, "can't open directory");
 400
 401     /*
 402      * A hack so that we don't see a
 403      * leading "./" in folder names.
 404      */
 405     base = strcmp (dirName, ".") ? dirName : dirName + 1;
 406
 407     while (nlinks && (dp = readdir(dir))) {
 408         if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) {
 409             nlinks--;
 410             continue;
 411         }
 412         if (dp->d_name[0] == '.')
 413             continue;
 414         /* Check to see if the name of the file is a number
 415          * if it is, we assume it's a mail file and skip it
 416          */
 417         for (n = dp->d_name; *n && isdigit((unsigned char) *n); n++);
 418         if (!*n)
 419             continue;
 420         strncpy (name, base, sizeof(name) - 2);
 421         if (*base)
 422             strcat(name, "/");
 423         strncat(name, dp->d_name, sizeof(name) - strlen(name) - 1);
 424         if ((stat(name, &st) != -1) && S_ISDIR(st.st_mode)) {
 425             /*
 426              * Check if this was really a symbolic link pointing
 427              * to a directory.  If not, then decrement link count.
 428              */
 429             if (lstat (name, &st) == -1)
 430                 nlinks--;
 431             /* Add this folder to the list */
 432             if (AddFolder(name, showzero) &&
 433                         (recurse || searchdepth) && st.st_nlink > 2)
 434                 BuildFolderListRecurse(name, &st, searchdepth - 1);
 435         }
 436     }
 437     closedir(dir);
 438 }
 439
 440 /*
 441  * Add this folder to our list, counting the total number of
 442  * messages and the number of messages in each sequence.
 443  */
 444
 445 int
 446 AddFolder(char *name, int force)
 447 {
 448     unsigned int i;
 449     int msgnum, nonzero;
 450     ivector_t seqnum = ivector_create (0), nSeq = ivector_create (0);
 451     struct Folder *f;
 452     struct msgs *mp;
 453     char *cp;
 454
 455     /* Read folder and create message structure */
 456     if (!(mp = folder_read (name, 0))) {
 457         /* Oops, error occurred.  Record it and continue. */
 458         AllocFolders(&folders, &nFoldersAlloced, nFolders + 1);
 459         f = &folders[nFolders++];
 460         f->name = getcpy(name);
 461         f->error = 1;
 462         f->priority = AssignPriority(f->name);
 463         return 0;
 464     }
 465
 466     for (i = 0; i < svector_size (sequencesToDo); i++) {
 467         /* Convert sequences to their sequence numbers */
 468         if ((cp = svector_at (sequencesToDo, i)))
 469             ivector_push_back (seqnum, seq_getnum(mp, cp));
 470         else
 471             ivector_push_back (seqnum, -1);
 472
 473         /* Now count messages in this sequence */
 474         ivector_push_back (nSeq, 0);
 475         if (mp->nummsg > 0 && ivector_at (seqnum, i) != -1) {
 476             for (msgnum = mp->lowmsg; msgnum <= mp->hghmsg; msgnum++) {
 477                 if (in_sequence(mp, ivector_at (seqnum, i), msgnum))
 478                     (*ivector_atp (nSeq, i))++;
 479             }
 480         }
 481     }
 482
 483     /* Check if any of the sequence checks were nonzero */
 484     nonzero = 0;
 485     for (i = 0; i < svector_size (sequencesToDo); i++) {
 486         if (ivector_at (nSeq, i) > 0) {
 487             nonzero = 1;
 488             break;
 489         }
 490     }
 491
 492     if (nonzero || force) {
 493         /* save general folder information */
 494         AllocFolders(&folders, &nFoldersAlloced, nFolders + 1);
 495         f = &folders[nFolders++];
 496         f->name = getcpy(name);
 497         f->nMsgs = mp->nummsg;
 498         f->nSeq = ivector_create (0);
 499         f->private = ivector_create (0);
 500         f->error = 0;
 501         f->priority = AssignPriority(f->name);
 502
 503         /* record the sequence information */
 504         for (i = 0; i < svector_size (sequencesToDo); i++) {
 505             *ivector_atp (f->nSeq, i) = ivector_at (nSeq, i);
 506             ivector_push_back (f->private,
 507                                ivector_at (seqnum, i) != -1
 508                                ? is_seq_private(mp, ivector_at (seqnum, i))
 509                                : 0);
 510         }
 511     }
 512
 513     ivector_free (nSeq);
 514     ivector_free (seqnum);
 515     folder_free (mp);   /* free folder/message structure */
 516     return 1;
 517 }
 518
 519 /*
 520  * Print the folder/sequence information
 521  */
 522
 523 void
 524 PrintFolders(void)
 525 {
 526     char tmpname[BUFSIZ];
 527     unsigned int i, j, len, has_private = 0;
 528     unsigned int maxfolderlen = 0, maxseqlen = 0;
 529     int maxnum = 0, maxseq = 0;
 530
 531     if (!Total) {
 532         for (i = 0; i < nFolders; i++)
 533             printf("%s\n", folders[i].name);
 534         return;
 535     }
 536
 537     /*
 538      * Find the width we need for various fields
 539      */
 540     for (i = 0; i < nFolders; ++i) {
 541         /* find the length of longest folder name */
 542         len = strlen(folders[i].name);
 543         if (len > maxfolderlen)
 544             maxfolderlen = len;
 545
 546         /* If folder had error, skip the rest */
 547         if (folders[i].error)
 548             continue;
 549
 550         /* find the maximum total messages */
 551         if (folders[i].nMsgs > maxnum)
 552             maxnum = folders[i].nMsgs;
 553
 554         for (j = 0; j < svector_size (sequencesToDo); j++) {
 555             /* find maximum width of sequence name */
 556             len = strlen (svector_at (sequencesToDo, j));
 557             if ((ivector_at (folders[i].nSeq, j) > 0 || showzero) &&
 558                 (len > maxseqlen))
 559                 maxseqlen = len;
 560
 561             /* find the maximum number of messages in sequence */
 562             if (ivector_at (folders[i].nSeq, j) > maxseq)
 563                 maxseq = ivector_at (folders[i].nSeq, j);
 564
 565             /* check if this sequence is private in any of the folders */
 566             if (ivector_at (folders[i].private, j))
 567                 has_private = 1;
 568         }
 569     }
 570
 571     /* Now print all the folder/sequence information */
 572     for (i = 0; i < nFolders; i++) {
 573         for (j = 0; j < svector_size (sequencesToDo); j++) {
 574             if (ivector_at (folders[i].nSeq, j) > 0 || showzero) {
 575                 /* Add `+' to end of name of current folder */
 576                 if (strcmp(curfolder, folders[i].name))
 577                     snprintf(tmpname, sizeof(tmpname), "%s", folders[i].name);
 578                 else
 579                     snprintf(tmpname, sizeof(tmpname), "%s+", folders[i].name);
 580
 581                 if (folders[i].error) {
 582                     printf("%-*s is unreadable\n", maxfolderlen+1, tmpname);
 583                     continue;
 584                 }
 585
 586                 printf("%-*s has %*d in sequence %-*s%s; out of %*d\n",
 587                        maxfolderlen+1, tmpname,
 588                        num_digits(maxseq), ivector_at (folders[i].nSeq, j),
 589                        maxseqlen, svector_at (sequencesToDo, j),
 590                        !has_private ? "" : ivector_at (folders[i].private, j)
 591                            ? " (private)" : "          ",
 592                        num_digits(maxnum), folders[i].nMsgs);
 593             }
 594         }
 595     }
 596 }
 597
 598 /*
 599  * Put them in priority order.
 600  */
 601
 602 int
 603 CompareFolders(struct Folder *f1, struct Folder *f2)
 604 {
 605     if (!alphaOrder && f1->priority != f2->priority)
 606         return f1->priority - f2->priority;
 607     else
 608         return strcmp(f1->name, f2->name);
 609 }
 610
 611 /*
 612  * Make sure we have at least n folders allocated.
 613  */
 614
 615 void
 616 AllocFolders(struct Folder **f, int *nfa, int n)
 617 {
 618     if (n <= *nfa)
 619         return;
 620     if (*f == NULL) {
 621         *nfa = 10;
 622         *f = (struct Folder *) mh_xmalloc (*nfa * (sizeof(struct Folder)));
 623     } else {
 624         *nfa *= 2;
 625         *f = (struct Folder *) mh_xrealloc (*f, *nfa * (sizeof(struct Folder)));
 626     }
 627 }
 628
 629 /*
 630  * Return the priority for a name.  The highest comes from an exact match.
 631  * After that, the longest match (then first) assigns the priority.
 632  */
 633 int
 634 AssignPriority(char *name)
 635 {
 636     int i, ol, nl;
 637     int best = nOrders;
 638     int bestLen = 0;
 639     struct Folder *o;
 640
 641     nl = strlen(name);
 642     for (i = 0; i < nOrders; ++i) {
 643         o = &orders[i];
 644         if (!strcmp(name, o->name))
 645             return o->priority;
 646         ol = strlen(o->name);
 647         if (nl < ol - 1)
 648             continue;
 649         if (ol < bestLen)
 650             continue;
 651         if (o->name[0] == '*' && !strcmp(o->name + 1, name + (nl - ol + 1))) {
 652             best = o->priority;
 653             bestLen = ol;
 654         } else if (o->name[ol - 1] == '*' && strncmp(o->name, name, ol - 1) == 0) {
 655             best = o->priority;
 656             bestLen = ol;
 657         }
 658     }
 659     return best;
 660 }
 661
 662 /*
 663  * Do the read only folders
 664  */
 665
 666 static void
 667 do_readonly_folders (void)
 668 {
 669     int atrlen;
 670     char atrcur[BUFSIZ];
 671     register struct node *np;
 672
 673     snprintf (atrcur, sizeof(atrcur), "atr-%s-", current);
 674     atrlen = strlen (atrcur);
 675
 676     for (np = m_defs; np; np = np->n_next)
 677         if (ssequal (atrcur, np->n_name)
 678                 && !ssequal (nmhdir, np->n_name + atrlen))
 679             BuildFolderList (np->n_name + atrlen, 0);
 680 }