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