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

   1
   2 /*
   3  * folder(s).c -- set/list the current message and/or folder
   4  *             -- push/pop a folder onto/from the folder stack
   5  *             -- list the folder stack
   6  *
   7  * $Id$
   8  *
   9  * This code is Copyright (c) 2002, by the authors of nmh.  See the
  10  * COPYRIGHT file in the root directory of the nmh distribution for
  11  * complete copyright information.
  12  */
  13
  14 #include <h/mh.h>
  15 #include <h/utils.h>
  16 #include <errno.h>
  17
  18 static struct swit switches[] = {
  19 #define ALLSW           0
  20     { "all", 0 },
  21 #define NALLSW          1
  22     { "noall", 0 },
  23 #define CREATSW         2
  24     { "create", 0 },
  25 #define NCREATSW        3
  26     { "nocreate", 0 },
  27 #define FASTSW          4
  28     { "fast", 0 },
  29 #define NFASTSW         5
  30     { "nofast", 0 },
  31 #define HDRSW           6
  32     { "header", 0 },
  33 #define NHDRSW          7
  34     { "noheader", 0 },
  35 #define PACKSW          8
  36     { "pack", 0 },
  37 #define NPACKSW         9
  38     { "nopack", 0 },
  39 #define VERBSW         10
  40     { "verbose", 0 },
  41 #define NVERBSW        11
  42     { "noverbose", 0 },
  43 #define RECURSW        12
  44     { "recurse", 0 },
  45 #define NRECRSW        13
  46     { "norecurse", 0 },
  47 #define TOTALSW        14
  48     { "total", 0 },
  49 #define NTOTLSW        15
  50     { "nototal", 0 },
  51 #define LISTSW         16
  52     { "list", 0 },
  53 #define NLISTSW        17
  54     { "nolist", 0 },
  55 #define PRNTSW         18
  56     { "print", 0 },
  57 #define NPRNTSW        19
  58     { "noprint", -4 },
  59 #define PUSHSW         20
  60     { "push", 0 },
  61 #define POPSW          21
  62     { "pop", 0 },
  63 #define VERSIONSW      22
  64     { "version", 0 },
  65 #define HELPSW         23
  66     { "help", 0 },
  67     { NULL, 0 }
  68 };
  69
  70 static int fshort   = 0;        /* output only folder names                 */
  71 static int fcreat   = 0;        /* should we ask to create new folders?     */
  72 static int fpack    = 0;        /* are we packing the folder?               */
  73 static int fverb    = 0;        /* print actions taken while packing folder */
  74 static int fheader  = 0;        /* should we output a header?               */
  75 static int frecurse = 0;        /* recurse through subfolders               */
  76 static int ftotal   = 0;        /* should we output the totals?             */
  77 static int all      = 0;        /* should we output all folders             */
  78
  79 static int total_folders = 0;   /* total number of folders                  */
  80
  81 static int start = 0;
  82 static int foldp = 0;
  83
  84 static char *nmhdir;
  85 static char *stack = "Folder-Stack";
  86 static char folder[BUFSIZ];
  87
  88 #define NUMFOLDERS 100
  89
  90 /*
  91  * This is how many folders we currently can hold in the array
  92  * `folds'.  We increase this amount by NUMFOLDERS at a time.
  93  */
  94 static int maxfolders;
  95 static char **folds;
  96
  97 /*
  98  * Structure to hold information about
  99  * folders as we scan them.
 100  */
 101 struct FolderInfo {
 102     char *name;
 103     int nummsg;
 104     int curmsg;
 105     int lowmsg;
 106     int hghmsg;
 107     int others;         /* others == 1 if other files in folder */
 108     int error;          /* error == 1 for unreadable folder     */
 109 };
 110
 111 /*
 112  * Dynamically allocated space to hold
 113  * all the folder information.
 114  */
 115 static struct FolderInfo *fi;
 116 static int maxFolderInfo;
 117
 118 /*
 119  * static prototypes
 120  */
 121 static void dodir (char *);
 122 static int get_folder_info (char *, char *);
 123 static void print_folders (void);
 124 static int sfold (struct msgs *, char *);
 125 static void addir (char *);
 126 static void addfold (char *);
 127 static int compare (char *, char *);
 128 static void readonly_folders (void);
 129
 130
 131 int
 132 main (int argc, char **argv)
 133 {
 134     int printsw = 0, listsw = 0;
 135     int pushsw = 0, popsw = 0;
 136     char *cp, *dp, *msg = NULL, *argfolder = NULL;
 137     char **ap, **argp, buf[BUFSIZ], **arguments;
 138
 139 #ifdef LOCALE
 140     setlocale(LC_ALL, "");
 141 #endif
 142     invo_name = r1bindex (argv[0], '/');
 143
 144     /* read user profile/context */
 145     context_read();
 146
 147     /*
 148      * If program was invoked with name ending
 149      * in `s', then add switch `-all'.
 150      */
 151     if (argv[0][strlen (argv[0]) - 1] == 's')
 152         all = 1;
 153
 154     arguments = getarguments (invo_name, argc, argv, 1);
 155     argp = arguments;
 156
 157     while ((cp = *argp++)) {
 158         if (*cp == '-') {
 159             switch (smatch (++cp, switches)) {
 160                 case AMBIGSW:
 161                     ambigsw (cp, switches);
 162                     done (1);
 163                 case UNKWNSW:
 164                     adios (NULL, "-%s unknown", cp);
 165
 166                 case HELPSW:
 167                     snprintf (buf, sizeof(buf), "%s [+folder] [msg] [switches]",
 168                         invo_name);
 169                     print_help (buf, switches, 1);
 170                     done (1);
 171                 case VERSIONSW:
 172                     print_version(invo_name);
 173                     done (1);
 174
 175                 case ALLSW:
 176                     all = 1;
 177                     continue;
 178
 179                 case NALLSW:
 180                     all = 0;
 181                     continue;
 182
 183                 case CREATSW:
 184                     fcreat = 1;
 185                     continue;
 186                 case NCREATSW:
 187                     fcreat = -1;
 188                     continue;
 189
 190                 case FASTSW:
 191                     fshort++;
 192                     continue;
 193                 case NFASTSW:
 194                     fshort = 0;
 195                     continue;
 196
 197                 case HDRSW:
 198                     fheader = 1;
 199                     continue;
 200                 case NHDRSW:
 201                     fheader = -1;
 202                     continue;
 203
 204                 case PACKSW:
 205                     fpack++;
 206                     continue;
 207                 case NPACKSW:
 208                     fpack = 0;
 209                     continue;
 210
 211                 case VERBSW:
 212                     fverb++;
 213                     continue;
 214                 case NVERBSW:
 215                     fverb = 0;
 216                     continue;
 217
 218                 case RECURSW:
 219                     frecurse++;
 220                     continue;
 221                 case NRECRSW:
 222                     frecurse = 0;
 223                     continue;
 224
 225                 case TOTALSW:
 226                     ftotal = 1;
 227                     continue;
 228                 case NTOTLSW:
 229                     ftotal = -1;
 230                     continue;
 231
 232                 case PRNTSW:
 233                     printsw = 1;
 234                     continue;
 235                 case NPRNTSW:
 236                     printsw = 0;
 237                     continue;
 238
 239                 case LISTSW:
 240                     listsw = 1;
 241                     continue;
 242                 case NLISTSW:
 243                     listsw = 0;
 244                     continue;
 245
 246                 case PUSHSW:
 247                     pushsw = 1;
 248                     listsw = 1;
 249                     popsw  = 0;
 250                     continue;
 251                 case POPSW:
 252                     popsw  = 1;
 253                     listsw = 1;
 254                     pushsw = 0;
 255                     continue;
 256             }
 257         }
 258         if (*cp == '+' || *cp == '@') {
 259             if (argfolder)
 260                 adios (NULL, "only one folder at a time!");
 261             else
 262                 argfolder = pluspath (cp);
 263         } else {
 264             if (msg)
 265                 adios (NULL, "only one (current) message at a time!");
 266             else
 267                 msg = cp;
 268         }
 269     }
 270
 271     if (!context_find ("path"))
 272         free (path ("./", TFOLDER));
 273     nmhdir = concat (m_maildir (""), "/", NULL);
 274
 275     /*
 276      * If we aren't working with the folder stack
 277      * (-push, -pop, -list) then the default is to print.
 278      */
 279     if (pushsw == 0 && popsw == 0 && listsw == 0)
 280         printsw++;
 281
 282     /* Pushing a folder onto the folder stack */
 283     if (pushsw) {
 284         if (!argfolder) {
 285             /* If no folder is given, the current folder and */
 286             /* the top of the folder stack are swapped.      */
 287             if ((cp = context_find (stack))) {
 288                 dp = getcpy (cp);
 289                 ap = brkstring (dp, " ", "\n");
 290                 argfolder = getcpy(*ap++);
 291             } else {
 292                 adios (NULL, "no other folder");
 293             }
 294             for (cp = getcpy (getfolder (1)); *ap; ap++)
 295                 cp = add (*ap, add (" ", cp));
 296             free (dp);
 297             context_replace (stack, cp);        /* update folder stack */
 298         } else {
 299             /* update folder stack */
 300             context_replace (stack,
 301                     (cp = context_find (stack))
 302                     ? concat (getfolder (1), " ", cp, NULL)
 303                     : getcpy (getfolder (1)));
 304         }
 305     }
 306
 307     /* Popping a folder off of the folder stack */
 308     if (popsw) {
 309         if (argfolder)
 310             adios (NULL, "sorry, no folders allowed with -pop");
 311         if ((cp = context_find (stack))) {
 312             dp = getcpy (cp);
 313             ap = brkstring (dp, " ", "\n");
 314             argfolder = getcpy(*ap++);
 315         } else {
 316             adios (NULL, "folder stack empty");
 317         }
 318         if (*ap) {
 319             /* if there's anything left in the stack */
 320             cp = getcpy (*ap++);
 321             for (; *ap; ap++)
 322                 cp = add (*ap, add (" ", cp));
 323             context_replace (stack, cp);        /* update folder stack */
 324         } else {
 325             context_del (stack);        /* delete folder stack entry from context */
 326         }
 327         free (dp);
 328     }
 329     if (pushsw || popsw) {
 330         cp = m_maildir(argfolder);
 331         if (access (cp, F_OK) == NOTOK)
 332             adios (cp, "unable to find folder");
 333         context_replace (pfolder, argfolder);   /* update current folder   */
 334         context_save ();                /* save the context file   */
 335         argfolder = NULL;
 336     }
 337
 338     /* Listing the folder stack */
 339     if (listsw) {
 340         printf ("%s", argfolder ? argfolder : getfolder (1));
 341         if ((cp = context_find (stack))) {
 342             dp = getcpy (cp);
 343             for (ap = brkstring (dp, " ", "\n"); *ap; ap++)
 344                 printf (" %s", *ap);
 345             free (dp);
 346         }
 347         printf ("\n");
 348
 349         if (!printsw)
 350             done (0);
 351     }
 352
 353     /* Allocate initial space to record folder names */
 354     maxfolders = NUMFOLDERS;
 355     folds = mh_xmalloc (maxfolders * sizeof(char *));
 356
 357     /* Allocate initial space to record folder information */
 358     maxFolderInfo = NUMFOLDERS;
 359     fi = mh_xmalloc (maxFolderInfo * sizeof(*fi));
 360
 361     /*
 362      * Scan the folders
 363      */
 364     if (all || ftotal > 0) {
 365         /*
 366          * If no folder is given, do them all
 367          */
 368         /* change directory to base of nmh directory for dodir */
 369         if (chdir (nmhdir) == NOTOK)
 370             adios (nmhdir, "unable to change directory to");
 371         if (!argfolder) {
 372             if (msg)
 373                 admonish (NULL, "no folder given for message %s", msg);
 374             readonly_folders (); /* do any readonly folders */
 375             strncpy (folder, (cp = context_find (pfolder)) ? cp : "", sizeof(folder));
 376             dodir (".");
 377         } else {
 378             strncpy (folder, argfolder, sizeof(folder));
 379             if (get_folder_info (argfolder, msg)) {
 380                 context_replace (pfolder, argfolder);/* update current folder */
 381                 context_save ();                     /* save the context file */
 382             }
 383             /*
 384              * Since recurse wasn't done in get_folder_info(),
 385              * we still need to list all level-1 sub-folders.
 386              */
 387             if (!frecurse)
 388                 dodir (folder);
 389         }
 390     } else {
 391         strncpy (folder, argfolder ? argfolder : getfolder (1), sizeof(folder));
 392
 393         /*
 394          * Check if folder exists.  If not, then see if
 395          * we should create it, or just exit.
 396          */
 397         create_folder (m_maildir (folder), fcreat, done);
 398
 399         if (get_folder_info (folder, msg) && argfolder) {
 400             /* update current folder */
 401             context_replace (pfolder, argfolder);
 402             }
 403     }
 404
 405     /*
 406      * Print out folder information
 407      */
 408     print_folders();
 409
 410     context_save ();    /* save the context file */
 411     done (0);
 412     return 1;
 413 }
 414
 415 /*
 416  * Base routine for scanning a folder
 417  */
 418
 419 static void
 420 dodir (char *dir)
 421 {
 422     int i;
 423     int os = start;
 424     int of = foldp;
 425
 426     start = foldp;
 427
 428     addir (dir);
 429
 430     for (i = start; i < foldp; i++) {
 431         get_folder_info (folds[i], NULL);
 432         fflush (stdout);
 433     }
 434
 435     start = os;
 436     foldp = of;
 437 }
 438
 439 static int
 440 get_folder_info (char *fold, char *msg)
 441 {
 442     int i, retval = 1;
 443     struct msgs *mp = NULL;
 444
 445     i = total_folders++;
 446
 447     /*
 448      * if necessary, reallocate the space
 449      * for folder information
 450      */
 451     if (total_folders >= maxFolderInfo) {
 452         maxFolderInfo += NUMFOLDERS;
 453         fi = mh_xrealloc (fi, maxFolderInfo * sizeof(*fi));
 454     }
 455
 456     fi[i].name   = fold;
 457     fi[i].nummsg = 0;
 458     fi[i].curmsg = 0;
 459     fi[i].lowmsg = 0;
 460     fi[i].hghmsg = 0;
 461     fi[i].others = 0;
 462     fi[i].error  = 0;
 463
 464     if ((ftotal > 0) || !fshort || msg || fpack) {
 465         /*
 466          * create message structure and get folder info
 467          */
 468         if (!(mp = folder_read (fold))) {
 469             admonish (NULL, "unable to read folder %s", fold);
 470             return 0;
 471         }
 472
 473         /* set the current message */
 474         if (msg && !sfold (mp, msg))
 475             retval = 0;
 476
 477         if (fpack) {
 478             if (folder_pack (&mp, fverb) == -1)
 479                 done (1);
 480             seq_save (mp);              /* synchronize the sequences */
 481             context_save ();    /* save the context file     */
 482         }
 483
 484         /* record info for this folder */
 485         if ((ftotal > 0) || !fshort) {
 486             fi[i].nummsg = mp->nummsg;
 487             fi[i].curmsg = mp->curmsg;
 488             fi[i].lowmsg = mp->lowmsg;
 489             fi[i].hghmsg = mp->hghmsg;
 490             fi[i].others = other_files (mp);
 491         }
 492
 493         folder_free (mp); /* free folder/message structure */
 494     }
 495
 496     if (frecurse && (fshort || fi[i].others) && (fi[i].error == 0))
 497         dodir (fold);
 498     return retval;
 499 }
 500
 501 /*
 502  * Print folder information
 503  */
 504
 505 static void
 506 print_folders (void)
 507 {
 508     int i, len, hasempty = 0, curprinted;
 509     int maxlen = 0, maxnummsg = 0, maxlowmsg = 0;
 510     int maxhghmsg = 0, maxcurmsg = 0, total_msgs = 0;
 511     int nummsgdigits, lowmsgdigits;
 512     int hghmsgdigits, curmsgdigits;
 513     char tmpname[BUFSIZ];
 514
 515     /*
 516      * compute a few values needed to for
 517      * printing various fields
 518      */
 519     for (i = 0; i < total_folders; i++) {
 520         /* length of folder name */
 521         len = strlen (fi[i].name);
 522         if (len > maxlen)
 523             maxlen = len;
 524
 525         /* If folder has error, skip the rest */
 526         if (fi[i].error)
 527             continue;
 528
 529         /* calculate total number of messages */
 530         total_msgs += fi[i].nummsg;
 531
 532         /* maximum number of messages */
 533         if (fi[i].nummsg > maxnummsg)
 534             maxnummsg = fi[i].nummsg;
 535
 536         /* maximum low message */
 537         if (fi[i].lowmsg > maxlowmsg)
 538             maxlowmsg = fi[i].lowmsg;
 539
 540         /* maximum high message */
 541         if (fi[i].hghmsg > maxhghmsg)
 542             maxhghmsg = fi[i].hghmsg;
 543
 544         /* maximum current message */
 545         if (fi[i].curmsg >= fi[i].lowmsg &&
 546             fi[i].curmsg <= fi[i].hghmsg &&
 547             fi[i].curmsg > maxcurmsg)
 548             maxcurmsg = fi[i].curmsg;
 549
 550         /* check for empty folders */
 551         if (fi[i].nummsg == 0)
 552             hasempty = 1;
 553     }
 554     nummsgdigits = num_digits (maxnummsg);
 555     lowmsgdigits = num_digits (maxlowmsg);
 556     hghmsgdigits = num_digits (maxhghmsg);
 557     curmsgdigits = num_digits (maxcurmsg);
 558
 559     if (hasempty && nummsgdigits < 2)
 560         nummsgdigits = 2;
 561
 562     /*
 563      * Print the header
 564      */
 565     if (fheader > 0 || (all && !fshort && fheader >= 0))
 566         printf ("%-*s %*s %-*s; %-*s %*s\n",
 567                 maxlen+1, "FOLDER",
 568                 nummsgdigits + 13, "# MESSAGES",
 569                 lowmsgdigits + hghmsgdigits + 4, " RANGE",
 570                 curmsgdigits + 4, "CUR",
 571                 9, "(OTHERS)");
 572
 573     /*
 574      * Print folder information
 575      */
 576     if (all || fshort || ftotal < 1) {
 577         for (i = 0; i < total_folders; i++) {
 578             if (fshort) {
 579                 printf ("%s\n", fi[i].name);
 580                 continue;
 581             }
 582
 583             /* Add `+' to end of name, if folder is current */
 584             if (strcmp (folder, fi[i].name))
 585                 snprintf (tmpname, sizeof(tmpname), "%s", fi[i].name);
 586             else
 587                 snprintf (tmpname, sizeof(tmpname), "%s+", fi[i].name);
 588
 589             if (fi[i].error) {
 590                 printf ("%-*s is unreadable\n", maxlen+1, tmpname);
 591                 continue;
 592             }
 593
 594             printf ("%-*s ", maxlen+1, tmpname);
 595
 596             curprinted = 0; /* remember if we print cur */
 597             if (fi[i].nummsg == 0) {
 598                 printf ("has %*s messages%*s",
 599                         nummsgdigits, "no",
 600                         fi[i].others ? lowmsgdigits + hghmsgdigits + 5 : 0, "");
 601             } else {
 602                 printf ("has %*d message%s  (%*d-%*d)",
 603                         nummsgdigits, fi[i].nummsg,
 604                         (fi[i].nummsg == 1) ? " " : "s",
 605                         lowmsgdigits, fi[i].lowmsg,
 606                         hghmsgdigits, fi[i].hghmsg);
 607                 if (fi[i].curmsg >= fi[i].lowmsg && fi[i].curmsg <= fi[i].hghmsg) {
 608                     curprinted = 1;
 609                     printf ("; cur=%*d", curmsgdigits, fi[i].curmsg);
 610                 }
 611             }
 612
 613             if (fi[i].others)
 614                 printf (";%*s (others)", curprinted ? 0 : curmsgdigits + 6, "");
 615             printf (".\n");
 616         }
 617     }
 618
 619     /*
 620      * Print folder/message totals
 621      */
 622     if (ftotal > 0 || (all && !fshort && ftotal >= 0)) {
 623         if (all)
 624             printf ("\n");
 625         printf ("TOTAL = %d message%c in %d folder%s.\n",
 626                 total_msgs, total_msgs != 1 ? 's' : ' ',
 627                 total_folders, total_folders != 1 ? "s" : "");
 628     }
 629
 630     fflush (stdout);
 631 }
 632
 633 /*
 634  * Set the current message and sychronize sequences
 635  */
 636
 637 static int
 638 sfold (struct msgs *mp, char *msg)
 639 {
 640     /* parse the message range/sequence/name and set SELECTED */
 641     if (!m_convert (mp, msg))
 642         return 0;
 643
 644     if (mp->numsel > 1) {
 645         admonish (NULL, "only one message at a time!");
 646         return 0;
 647     }
 648     seq_setprev (mp);           /* set the previous-sequence     */
 649     seq_setcur (mp, mp->lowsel);/* set current message           */
 650     seq_save (mp);              /* synchronize message sequences */
 651     context_save ();            /* save the context file         */
 652
 653     return 1;
 654 }
 655
 656
 657 static void
 658 addir (char *name)
 659 {
 660     char *prefix, *child;
 661     struct stat st;
 662     struct dirent *dp;
 663     DIR * dd;
 664     int child_is_folder;
 665
 666     if (!(dd = opendir (name))) {
 667         admonish (name, "unable to read directory ");
 668         return;
 669     }
 670
 671     if (strcmp (name, ".") == 0) {
 672         prefix = getcpy ("");
 673     } else {
 674         prefix = concat (name, "/", (void *)NULL);
 675     }
 676
 677     while ((dp = readdir (dd))) {
 678         /* If the system supports it, try to skip processing of children we
 679          * know are not directories or symlinks. */
 680         child_is_folder = -1;
 681 #if defined(HAVE_STRUCT_DIRENT_D_TYPE)
 682         if (dp->d_type == DT_DIR) {
 683             child_is_folder = 1;
 684         } else if (dp->d_type != DT_LNK && dp->d_type != DT_UNKNOWN) {
 685             continue;
 686         }
 687 #endif
 688         if (!strcmp (dp->d_name, ".") || !strcmp (dp->d_name, "..")) {
 689             continue;
 690         }
 691         child = concat (prefix, dp->d_name, (void *)NULL);
 692         /* If we have no d_type or d_type is DT_LNK or DT_UNKNOWN, stat the
 693          * child to see what it is. */
 694         if (child_is_folder == -1) {
 695             child_is_folder = (stat (child, &st) != -1 && S_ISDIR(st.st_mode));
 696         }
 697         if (child_is_folder) {
 698             /* addfold saves child in the list, don't free it */
 699             addfold (child);
 700         } else {
 701             free (child);
 702         }
 703     }
 704
 705     closedir (dd);
 706     free(prefix);
 707 }
 708
 709 /*
 710  * Add the folder name into the
 711  * list in a sorted fashion.
 712  */
 713
 714 static void
 715 addfold (char *fold)
 716 {
 717     register int i, j;
 718
 719     /* if necessary, reallocate the space for folder names */
 720     if (foldp >= maxfolders) {
 721         maxfolders += NUMFOLDERS;
 722         folds = mh_xrealloc (folds, maxfolders * sizeof(char *));
 723     }
 724
 725     for (i = start; i < foldp; i++)
 726         if (compare (fold, folds[i]) < 0) {
 727             for (j = foldp - 1; j >= i; j--)
 728                 folds[j + 1] = folds[j];
 729             foldp++;
 730             folds[i] = fold;
 731             return;
 732         }
 733
 734     folds[foldp++] = fold;
 735 }
 736
 737
 738 static int
 739 compare (char *s1, char *s2)
 740 {
 741     register int i;
 742
 743     while (*s1 || *s2)
 744         if ((i = *s1++ - *s2++))
 745             return i;
 746
 747     return 0;
 748 }
 749
 750 /*
 751  * Do the read only folders
 752  */
 753
 754 static void
 755 readonly_folders (void)
 756 {
 757     int atrlen;
 758     char atrcur[BUFSIZ];
 759     register struct node *np;
 760
 761     snprintf (atrcur, sizeof(atrcur), "atr-%s-", current);
 762     atrlen = strlen (atrcur);
 763
 764     for (np = m_defs; np; np = np->n_next)
 765         if (ssequal (atrcur, np->n_name)
 766                 && !ssequal (nmhdir, np->n_name + atrlen))
 767             get_folder_info (np->n_name + atrlen, NULL);
 768 }