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) && st.st_nlink > 2)
 453                                 BuildFolderListRecurse(name, &st, searchdepth - 1);
 454                 }
 455         }
 456         closedir(dir);
 457 }
 458
 459 /*
 460  * Add this folder to our list, counting the total number of
 461  * messages and the number of messages in each sequence.
 462  */
 463
 464 int
 465 AddFolder(char *name, int force)
 466 {
 467         int i, msgnum, nonzero;
 468         int seqnum[NUMATTRS], nSeq[NUMATTRS];
 469         struct Folder *f;
 470         struct msgs *mp;
 471
 472         /* Read folder and create message structure */
 473         if (!(mp = folder_read (name))) {
 474                 /* Oops, error occurred.  Record it and continue. */
 475                 AllocFolders(&folders, &nFoldersAlloced, nFolders + 1);
 476                 f = &folders[nFolders++];
 477                 f->name = getcpy(name);
 478                 f->error = 1;
 479                 f->priority = AssignPriority(f->name);
 480                 return 0;
 481         }
 482
 483         for (i = 0; i < numsequences; i++) {
 484                 /* Convert sequences to their sequence numbers */
 485                 if (sequencesToDo[i])
 486                         seqnum[i] = seq_getnum(mp, sequencesToDo[i]);
 487                 else
 488                         seqnum[i] = -1;
 489
 490                 /* Now count messages in this sequence */
 491                 nSeq[i] = 0;
 492                 if (mp->nummsg > 0 && seqnum[i] != -1) {
 493                         for (msgnum = mp->lowmsg; msgnum <= mp->hghmsg; 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) ? is_seq_private(mp, seqnum[i]) : 0;
 522                 }
 523         }
 524
 525         folder_free (mp);  /* free folder/message structure */
 526         return 1;
 527 }
 528
 529 /*
 530  * Print the folder/sequence information
 531  */
 532
 533 void
 534 PrintFolders(void)
 535 {
 536         char tmpname[BUFSIZ];
 537         int i, j, len, has_private = 0;
 538         int maxfolderlen = 0, maxseqlen = 0;
 539         int maxnum = 0, maxseq = 0;
 540
 541         if (!Total) {
 542                 for (i = 0; i < nFolders; i++)
 543                         printf("%s\n", folders[i].name);
 544                 return;
 545         }
 546
 547         /*
 548          * Find the width we need for various fields
 549          */
 550         for (i = 0; i < nFolders; ++i) {
 551                 /* find the length of longest folder name */
 552                 len = strlen(folders[i].name);
 553                 if (len > maxfolderlen)
 554                         maxfolderlen = len;
 555
 556                 /* If folder had error, skip the rest */
 557                 if (folders[i].error)
 558                         continue;
 559
 560                 /* find the maximum total messages */
 561                 if (folders[i].nMsgs > maxnum)
 562                         maxnum = folders[i].nMsgs;
 563
 564                 for (j = 0; j < numsequences; j++) {
 565                         /* find maximum width of sequence name */
 566                         len = strlen (sequencesToDo[j]);
 567                         if ((folders[i].nSeq[j] > 0 || showzero) && (len > maxseqlen))
 568                                 maxseqlen = len;
 569
 570                         /* find the maximum number of messages in sequence */
 571                         if (folders[i].nSeq[j] > maxseq)
 572                                 maxseq = folders[i].nSeq[j];
 573
 574                         /* check if this sequence is private in any of the folders */
 575                         if (folders[i].private[j])
 576                                 has_private = 1;
 577                 }
 578         }
 579
 580         /* Now print all the folder/sequence information */
 581         for (i = 0; i < nFolders; i++) {
 582                 for (j = 0; j < numsequences; j++) {
 583                         if (folders[i].nSeq[j] > 0 || showzero) {
 584                                 /* Add `+' to end of name of current folder */
 585                                 if (strcmp(curfolder, folders[i].name))
 586                                         snprintf(tmpname, sizeof(tmpname), "%s", folders[i].name);
 587                                 else
 588                                         snprintf(tmpname, sizeof(tmpname), "%s+", folders[i].name);
 589
 590                                 if (folders[i].error) {
 591                                         printf("%-*s is unreadable\n", maxfolderlen+1, tmpname);
 592                                         continue;
 593                                 }
 594
 595                                 printf("%-*s has %*d in sequence %-*s%s; out of %*d\n",
 596                                            maxfolderlen+1, tmpname,
 597                                            num_digits(maxseq), folders[i].nSeq[j],
 598                                            maxseqlen, sequencesToDo[j],
 599                                            !has_private ? "" : folders[i].private[j] ? " (private)" : "          ",
 600                                            num_digits(maxnum), folders[i].nMsgs);
 601                         }
 602                 }
 603         }
 604 }
 605
 606 /*
 607  * Put them in priority order.
 608  */
 609
 610 int
 611 CompareFolders(struct Folder *f1, struct Folder *f2)
 612 {
 613         if (!alphaOrder && f1->priority != f2->priority)
 614                 return f1->priority - f2->priority;
 615         else
 616                 return strcmp(f1->name, f2->name);
 617 }
 618
 619 /*
 620  * Make sure we have at least n folders allocated.
 621  */
 622
 623 void
 624 AllocFolders(struct Folder **f, int *nfa, int n)
 625 {
 626         if (n <= *nfa)
 627                 return;
 628         if (*f == NULL) {
 629                 *nfa = 10;
 630                 *f = (struct Folder *) mh_xmalloc (*nfa * (sizeof(struct Folder)));
 631         } else {
 632                 *nfa *= 2;
 633                 *f = (struct Folder *) mh_xrealloc (*f, *nfa * (sizeof(struct Folder)));
 634         }
 635 }
 636
 637 /*
 638  * Return the priority for a name.  The highest comes from an exact match.
 639  * After that, the longest match (then first) assigns the priority.
 640  */
 641 int
 642 AssignPriority(char *name)
 643 {
 644         int i, ol, nl;
 645         int best = nOrders;
 646         int bestLen = 0;
 647         struct Folder *o;
 648
 649         nl = strlen(name);
 650         for (i = 0; i < nOrders; ++i) {
 651                 o = &orders[i];
 652                 if (!strcmp(name, o->name))
 653                         return o->priority;
 654                 ol = strlen(o->name);
 655                 if (nl < ol - 1)
 656                         continue;
 657                 if (ol < bestLen)
 658                         continue;
 659                 if (o->name[0] == '*' && !strcmp(o->name + 1, name + (nl - ol + 1))) {
 660                         best = o->priority;
 661                         bestLen = ol;
 662                 } else if (o->name[ol - 1] == '*' && strncmp(o->name, name, ol - 1) == 0) {
 663                         best = o->priority;
 664                         bestLen = ol;
 665                 }
 666         }
 667         return best;
 668 }
 669
 670 /*
 671  * Do the read only folders
 672  */
 673
 674 static void
 675 do_readonly_folders (void)
 676 {
 677         int atrlen;
 678         char atrcur[BUFSIZ];
 679         register struct node *np;
 680
 681         snprintf (atrcur, sizeof(atrcur), "atr-%s-", current);
 682         atrlen = strlen (atrcur);
 683
 684         for (np = m_defs; np; np = np->n_next)
 685                 if (ssequal (atrcur, np->n_name)
 686                                 && !ssequal (nmhdir, np->n_name + atrlen))
 687                         BuildFolderList (np->n_name + atrlen, 0);
 688 }