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 = r1bindex(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) (maxfolders * sizeof(*foldersToDo)));
 150
 151         /* no sequences yet */
 152         numsequences = 0;
 153
 154         /* parse arguments */
 155         while ((cp = *argp++)) {
 156                 if (*cp == '-') {
 157                         switch (smatch(++cp, switches)) {
 158                         case AMBIGSW:
 159                                 ambigsw(cp, switches);
 160                                 done(1);
 161                         case UNKWNSW:
 162                                 adios(NULL, "-%s unknown", cp);
 163
 164                         case HELPSW:
 165                                 snprintf(buf, sizeof(buf), "%s [+folder1 [+folder2 ...]][switches]",
 166                                                 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", argp[-2]);
 176
 177                                 /* check if too many sequences specified */
 178                                 if (numsequences >= NUMATTRS)
 179                                         adios (NULL, "too many sequences (more than %d) specified", NUMATTRS);
 180                                 sequencesToDo[numsequences++] = cp;
 181                                 break;
 182
 183                         case ALLSW:
 184                                 all = TRUE;
 185                                 break;
 186                         case NOALLSW:
 187                                 all = FALSE;
 188                                 break;
 189
 190                         case SHOWZERO:
 191                                 showzero = TRUE;
 192                                 break;
 193                         case NOSHOWZERO:
 194                                 showzero = FALSE;
 195                                 break;
 196
 197                         case ALPHASW:
 198                                 alphaOrder = TRUE;
 199                                 break;
 200                         case NOALPHASW:
 201                                 alphaOrder = FALSE;
 202                                 break;
 203
 204                         case NOFASTSW:
 205                         case TOTALSW:
 206                                 Total = TRUE;
 207                                 break;
 208
 209                         case FASTSW:
 210                         case NOTOTALSW:
 211                                 Total = FALSE;
 212                                 break;
 213
 214                         case RECURSE:
 215                                 recurse = TRUE;
 216                                 break;
 217                         case NORECURSE:
 218                                 recurse = FALSE;
 219                                 break;
 220                         }
 221                 } else {
 222                         /*
 223                         ** Check if we need to allocate more space
 224                         ** for folder names.
 225                         */
 226                         if (numfolders >= maxfolders) {
 227                                 maxfolders += MAXFOLDERS;
 228                                 foldersToDo = (char **) mh_xrealloc (foldersToDo,
 229                                         (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         if (!context_find ("path"))
 240                 free (path ("./", TFOLDER));
 241
 242         /* get current folder */
 243         strncpy (curfolder, getfolder(1), sizeof(curfolder));
 244
 245         /* get nmh base directory */
 246         nmhdir = m_maildir ("");
 247
 248         /*
 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.
 254         */
 255         if (numsequences == 0) {
 256                 if ((cp = context_find(usequence)) && *cp) {
 257                         char **ap, *dp;
 258
 259                         dp = getcpy(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",
 264                                                    NUMATTRS, usequence);
 265                                 else
 266                                         sequencesToDo[numsequences++] = *ap;
 267                         }
 268                 } else {
 269                         adios (NULL, "no sequence specified or %s profile entry found", usequence);
 270                 }
 271         }
 272
 273         GetFolderOrder();
 274         ScanFolders();
 275         qsort(folders, nFolders, sizeof(struct Folder), (qsort_comp) CompareFolders);
 276         PrintFolders();
 277         done (0);
 278         return 1;
 279 }
 280
 281 /*
 282 ** Read the Flist-Order profile entry to determine
 283 ** how to sort folders for output.
 284 */
 285
 286 void
 287 GetFolderOrder(void)
 288 {
 289         unsigned char *p, *s;
 290         int priority = 1;
 291         struct Folder *o;
 292
 293         if (!(p = context_find("Flist-Order")))
 294                 return;
 295         for (;;) {
 296                 while (isspace(*p))
 297                         ++p;
 298                 s = p;
 299                 while (*p && !isspace(*p))
 300                         ++p;
 301                 if (p != s) {
 302                         /* Found one. */
 303                         AllocFolders(&orders, &nOrdersAlloced, nOrders + 1);
 304                         o = &orders[nOrders++];
 305                         o->priority = priority++;
 306                         o->name = (char *) mh_xmalloc(p - s + 1);
 307                         strncpy(o->name, s, p - s);
 308                         o->name[p - s] = 0;
 309                 } else
 310                         break;
 311         }
 312 }
 313
 314 /*
 315 ** Scan all the necessary folders
 316 */
 317
 318 void
 319 ScanFolders(void)
 320 {
 321         int i;
 322
 323         /*
 324          * change directory to base of nmh directory
 325          */
 326         if (chdir (nmhdir) == NOTOK)
 327                 adios (nmhdir, "unable to change directory to");
 328
 329         if (numfolders > 0) {
 330                 /* Update context */
 331                 strncpy (curfolder, foldersToDo[numfolders - 1], sizeof(curfolder));
 332                 context_replace (pfolder, curfolder);/* update current folder */
 333                 context_save ();  /* save the context file */
 334
 335                 /*
 336                 ** Scan each given folder.  If -all is given,
 337                 ** then also scan the 1st level subfolders under
 338                 ** each given folder.
 339                 */
 340                 for (i = 0; i < numfolders; ++i)
 341                         BuildFolderList(foldersToDo[i], all ? 1 : 0);
 342         } else {
 343                 if (all) {
 344                         /*
 345                         ** Do the readonly folders
 346                         */
 347                         do_readonly_folders();
 348
 349                         /*
 350                         ** Now scan the entire nmh directory for folders
 351                         */
 352                         BuildFolderList(".", 0);
 353                 } else {
 354                         /*
 355                         ** Else scan current folder
 356                         */
 357                         BuildFolderList(curfolder, 0);
 358                 }
 359         }
 360 }
 361
 362 /*
 363 ** Initial building of folder list for
 364 ** the top of our search tree.
 365 */
 366
 367 void
 368 BuildFolderList(char *dirName, int searchdepth)
 369 {
 370         struct stat st;
 371
 372         /* Make sure we have a directory */
 373         if ((stat(dirName, &st) == -1) || !S_ISDIR(st.st_mode))
 374                 return;
 375
 376         /*
 377         ** If base directory, don't add it to the
 378         ** folder list. We just recurse into it.
 379         */
 380         if (!strcmp (dirName, ".")) {
 381                 BuildFolderListRecurse (".", &st, 0);
 382                 return;
 383         }
 384
 385         /*
 386         ** Add this folder to the list.
 387         ** If recursing and directory has subfolders,
 388         ** then build folder list for subfolders.
 389         */
 390         if (AddFolder(dirName, showzero) && (recurse || searchdepth) && st.st_nlink > 2)
 391                 BuildFolderListRecurse(dirName, &st, searchdepth - 1);
 392 }
 393
 394 /*
 395 ** Recursive building of folder list
 396 */
 397
 398 void
 399 BuildFolderListRecurse(char *dirName, struct stat *s, int searchdepth)
 400 {
 401         char *base, name[PATH_MAX];
 402         unsigned char *n;
 403         int nlinks;
 404         DIR *dir;
 405         struct dirent *dp;
 406         struct stat st;
 407
 408         /*
 409         ** Keep track of number of directories we've seen so we can
 410         ** stop stat'ing entries in this directory once we've seen
 411         ** them all.  This optimization will fail if you have extra
 412         ** directories beginning with ".", since we don't bother to
 413         ** stat them.  But that shouldn't generally be a problem.
 414         */
 415         nlinks = s->st_nlink;
 416
 417         if (!(dir = opendir(dirName)))
 418                 adios(dirName, "can't open directory");
 419
 420         /*
 421         ** A hack so that we don't see a
 422         ** leading "./" in folder names.
 423         */
 424         base = strcmp (dirName, ".") ? dirName : dirName + 1;
 425
 426         while (nlinks && (dp = readdir(dir))) {
 427                 if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) {
 428                         nlinks--;
 429                         continue;
 430                 }
 431                 if (dp->d_name[0] == '.')
 432                         continue;
 433                 /* Check to see if the name of the file is a number
 434                 ** if it is, we assume it's a mail file and skip it
 435                 */
 436                 for (n = dp->d_name; *n && isdigit(*n); n++);
 437                 if (!*n)
 438                         continue;
 439                 strncpy (name, base, sizeof(name) - 2);
 440                 if (*base)
 441                         strcat(name, "/");
 442                 strncat(name, dp->d_name, sizeof(name) - strlen(name) - 1);
 443                 if ((stat(name, &st) != -1) && S_ISDIR(st.st_mode)) {
 444                         /*
 445                         ** Check if this was really a symbolic link pointing
 446                         ** to a directory.  If not, then decrement link count.
 447                         */
 448                         if (lstat (name, &st) == -1)
 449                                 nlinks--;
 450                         /* Add this folder to the list */
 451                         if (AddFolder(name, showzero) &&
 452                                         (recurse || searchdepth) &&
 453                                         st.st_nlink > 2)
 454                                 BuildFolderListRecurse(name, &st, searchdepth - 1);
 455                 }
 456         }
 457         closedir(dir);
 458 }
 459
 460 /*
 461 ** Add this folder to our list, counting the total number of
 462 ** messages and the number of messages in each sequence.
 463 */
 464
 465 int
 466 AddFolder(char *name, int force)
 467 {
 468         int i, msgnum, nonzero;
 469         int seqnum[NUMATTRS], nSeq[NUMATTRS];
 470         struct Folder *f;
 471         struct msgs *mp;
 472
 473         /* Read folder and create message structure */
 474         if (!(mp = folder_read (name))) {
 475                 /* Oops, error occurred.  Record it and continue. */
 476                 AllocFolders(&folders, &nFoldersAlloced, nFolders + 1);
 477                 f = &folders[nFolders++];
 478                 f->name = getcpy(name);
 479                 f->error = 1;
 480                 f->priority = AssignPriority(f->name);
 481                 return 0;
 482         }
 483
 484         for (i = 0; i < numsequences; i++) {
 485                 /* Convert sequences to their sequence numbers */
 486                 if (sequencesToDo[i])
 487                         seqnum[i] = seq_getnum(mp, sequencesToDo[i]);
 488                 else
 489                         seqnum[i] = -1;
 490
 491                 /* Now count messages in this sequence */
 492                 nSeq[i] = 0;
 493                 if (mp->nummsg > 0 && seqnum[i] != -1) {
 494                         for (msgnum = mp->lowmsg; msgnum <= mp->hghmsg; msgnum++) {
 495                                 if (in_sequence(mp, seqnum[i], msgnum))
 496                                         nSeq[i]++;
 497                         }
 498                 }
 499         }
 500
 501         /* Check if any of the sequence checks were nonzero */
 502         nonzero = 0;
 503         for (i = 0; i < numsequences; i++) {
 504                 if (nSeq[i] > 0) {
 505                         nonzero = 1;
 506                         break;
 507                 }
 508         }
 509
 510         if (nonzero || force) {
 511                 /* save general folder information */
 512                 AllocFolders(&folders, &nFoldersAlloced, nFolders + 1);
 513                 f = &folders[nFolders++];
 514                 f->name = getcpy(name);
 515                 f->nMsgs = mp->nummsg;
 516                 f->error = 0;
 517                 f->priority = AssignPriority(f->name);
 518
 519                 /* record the sequence information */
 520                 for (i = 0; i < numsequences; i++) {
 521                         f->nSeq[i] = nSeq[i];
 522                         f->private[i] = (seqnum[i] != -1) ? 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) && (len > maxseqlen))
 569                                 maxseqlen = len;
 570
 571                         /* find the maximum number of messages in sequence */
 572                         if (folders[i].nSeq[j] > maxseq)
 573                                 maxseq = folders[i].nSeq[j];
 574
 575                         /* check if this sequence is private in any of the folders */
 576                         if (folders[i].private[j])
 577                                 has_private = 1;
 578                 }
 579         }
 580
 581         /* Now print all the folder/sequence information */
 582         for (i = 0; i < nFolders; i++) {
 583                 for (j = 0; j < numsequences; j++) {
 584                         if (folders[i].nSeq[j] > 0 || showzero) {
 585                                 /* Add `+' to end of name of current folder */
 586                                 if (strcmp(curfolder, folders[i].name))
 587                                         snprintf(tmpname, sizeof(tmpname), "%s", folders[i].name);
 588                                 else
 589                                         snprintf(tmpname, sizeof(tmpname), "%s+", folders[i].name);
 590
 591                                 if (folders[i].error) {
 592                                         printf("%-*s is unreadable\n", maxfolderlen+1, tmpname);
 593                                         continue;
 594                                 }
 595
 596                                 printf("%-*s has %*d in sequence %-*s%s; out of %*d\n",
 597                                            maxfolderlen+1, tmpname,
 598                                            num_digits(maxseq), folders[i].nSeq[j],
 599                                            maxseqlen, sequencesToDo[j],
 600                                            !has_private ? "" : folders[i].private[j] ? " (private)" : "          ",
 601                                            num_digits(maxnum), folders[i].nMsgs);
 602                         }
 603                 }
 604         }
 605 }
 606
 607 /*
 608 ** Put them in priority order.
 609 */
 610
 611 int
 612 CompareFolders(struct Folder *f1, struct Folder *f2)
 613 {
 614         if (!alphaOrder && f1->priority != f2->priority)
 615                 return f1->priority - f2->priority;
 616         else
 617                 return strcmp(f1->name, f2->name);
 618 }
 619
 620 /*
 621 ** Make sure we have at least n folders allocated.
 622 */
 623
 624 void
 625 AllocFolders(struct Folder **f, int *nfa, int n)
 626 {
 627         if (n <= *nfa)
 628                 return;
 629         if (*f == NULL) {
 630                 *nfa = 10;
 631                 *f = (struct Folder *) mh_xmalloc (*nfa * (sizeof(struct Folder)));
 632         } else {
 633                 *nfa *= 2;
 634                 *f = (struct Folder *) mh_xrealloc (*f, *nfa * (sizeof(struct Folder)));
 635         }
 636 }
 637
 638 /*
 639 ** Return the priority for a name.  The highest comes from an exact match.
 640 ** After that, the longest match (then first) assigns the priority.
 641 */
 642 int
 643 AssignPriority(char *name)
 644 {
 645         int i, ol, nl;
 646         int best = nOrders;
 647         int bestLen = 0;
 648         struct Folder *o;
 649
 650         nl = strlen(name);
 651         for (i = 0; i < nOrders; ++i) {
 652                 o = &orders[i];
 653                 if (!strcmp(name, o->name))
 654                         return o->priority;
 655                 ol = strlen(o->name);
 656                 if (nl < ol - 1)
 657                         continue;
 658                 if (ol < bestLen)
 659                         continue;
 660                 if (o->name[0] == '*' && !strcmp(o->name + 1, name + (nl - ol + 1))) {
 661                         best = o->priority;
 662                         bestLen = ol;
 663                 } else if (o->name[ol - 1] == '*' && strncmp(o->name, name, ol - 1) == 0) {
 664                         best = o->priority;
 665                         bestLen = ol;
 666                 }
 667         }
 668         return best;
 669 }
 670
 671 /*
 672 ** Do the read only folders
 673 */
 674
 675 static void
 676 do_readonly_folders (void)
 677 {
 678         int atrlen;
 679         char atrcur[BUFSIZ];
 680         register struct node *np;
 681
 682         snprintf (atrcur, sizeof(atrcur), "atr-%s-", current);
 683         atrlen = strlen (atrcur);
 684
 685         for (np = m_defs; np; np = np->n_next)
 686                 if (ssequal (atrcur, np->n_name)
 687                                 && !ssequal (nmhdir, np->n_name + atrlen))
 688                         BuildFolderList (np->n_name + atrlen, 0);
 689 }