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

   1
   2 /*
   3  * forw.c -- forward a message, or group of messages.
   4  *
   5  * This code is Copyright (c) 2002, by the authors of nmh.  See the
   6  * COPYRIGHT file in the root directory of the nmh distribution for
   7  * complete copyright information.
   8  */
   9
  10 #include <h/mh.h>
  11 #include <fcntl.h>
  12 #include <h/fmt_scan.h>
  13 #include <h/tws.h>
  14 #include <h/utils.h>
  15
  16
  17 #define IFORMAT "digest-issue-%s"
  18 #define VFORMAT "digest-volume-%s"
  19
  20 static struct swit switches[] = {
  21 #define ANNOSW                 0
  22     { "annotate", 0 },
  23 #define NANNOSW                1
  24     { "noannotate", 0 },
  25 #define DFOLDSW                2
  26     { "draftfolder +folder", 0 },
  27 #define DMSGSW                 3
  28     { "draftmessage msg", 0 },
  29 #define NDFLDSW                4
  30     { "nodraftfolder", 0 },
  31 #define EDITRSW                5
  32     { "editor editor", 0 },
  33 #define NEDITSW                6
  34     { "noedit", 0 },
  35 #define FILTSW                 7
  36     { "filter filterfile", 0 },
  37 #define FORMSW                 8
  38     { "form formfile", 0 },
  39 #define FRMTSW                 9
  40     { "format", 5 },
  41 #define NFRMTSW               10
  42     { "noformat", 7 },
  43 #define INPLSW                11
  44     { "inplace", 0 },
  45 #define NINPLSW               12
  46     { "noinplace", 0 },
  47 #define MIMESW                13
  48     { "mime", 0 },
  49 #define NMIMESW               14
  50     { "nomime", 0 },
  51 #define DGSTSW                15
  52     { "digest list", 0 },
  53 #define ISSUESW               16
  54     { "issue number", 0 },
  55 #define VOLUMSW               17
  56     { "volume number", 0 },
  57 #define WHATSW                18
  58     { "whatnowproc program", 0 },
  59 #define NWHATSW               19
  60     { "nowhatnowproc", 0 },
  61 #define BITSTUFFSW            20
  62     { "dashstuffing", 0 },              /* interface to mhl */
  63 #define NBITSTUFFSW           21
  64     { "nodashstuffing", 0 },
  65 #define VERSIONSW             22
  66     { "version", 0 },
  67 #define HELPSW                23
  68     { "help", 0 },
  69 #define FILESW                24
  70     { "file file", 4 },                 /* interface from msh */
  71 #define BILDSW                25
  72     { "build", 5 },                     /* interface from mhe */
  73
  74     { NULL, 0 }
  75 };
  76
  77 static struct swit aqrnl[] = {
  78 #define NOSW         0
  79     { "quit", 0 },
  80 #define YESW         1
  81     { "replace", 0 },
  82 #define LISTDSW      2
  83     { "list", 0 },
  84 #define REFILSW      3
  85     { "refile +folder", 0 },
  86 #define NEWSW        4
  87     { "new", 0 },
  88     { NULL, 0 }
  89 };
  90
  91 static struct swit aqrl[] = {
  92     { "quit", 0 },
  93     { "replace", 0 },
  94     { "list", 0 },
  95     { "refile +folder", 0 },
  96     { NULL, 0 }
  97 };
  98
  99 static char drft[BUFSIZ];
 100
 101 static char delim3[] =
 102     "\n------------------------------------------------------------\n\n";
 103 static char delim4[] = "\n------------------------------\n\n";
 104
 105
 106 static struct msgs *mp = NULL;          /* used a lot */
 107
 108
 109 /*
 110  * static prototypes
 111  */
 112 static void mhl_draft (int, char *, int, int, char *, char *, int);
 113 static void copy_draft (int, char *, char *, int, int, int);
 114 static void copy_mime_draft (int);
 115 static int build_form (char *, char *, int, int);
 116
 117
 118 int
 119 main (int argc, char **argv)
 120 {
 121     int msgp = 0, anot = 0, inplace = 1, mime = 0;
 122     int issue = 0, volume = 0, dashstuff = 0;
 123     int nedit = 0, nwhat = 0, i, in;
 124     int out, isdf = 0, msgnum;
 125     char *cp, *cwd, *maildir, *dfolder = NULL;
 126     char *dmsg = NULL, *digest = NULL, *ed = NULL;
 127     char *file = NULL, *filter = NULL, *folder = NULL;
 128     char *form = NULL, buf[BUFSIZ], value[10];
 129     char **argp, **arguments, *msgs[MAXARGS];
 130     struct stat st;
 131
 132     int buildsw = 0;
 133
 134 #ifdef LOCALE
 135     setlocale(LC_ALL, "");
 136 #endif
 137     invo_name = r1bindex (argv[0], '/');
 138
 139     /* read user profile/context */
 140     context_read();
 141
 142     arguments = getarguments (invo_name, argc, argv, 1);
 143     argp = arguments;
 144
 145     while ((cp = *argp++)) {
 146         if (*cp == '-') {
 147             switch (smatch (++cp, switches)) {
 148                 case AMBIGSW:
 149                     ambigsw (cp, switches);
 150                     done (1);
 151                 case UNKWNSW:
 152                     adios (NULL, "-%s unknown", cp);
 153
 154                 case HELPSW:
 155                     snprintf (buf, sizeof(buf), "%s [+folder] [msgs] [switches]",
 156                         invo_name);
 157                     print_help (buf, switches, 1);
 158                     done (1);
 159                 case VERSIONSW:
 160                     print_version(invo_name);
 161                     done (1);
 162
 163                 case ANNOSW:
 164                     anot++;
 165                     continue;
 166                 case NANNOSW:
 167                     anot = 0;
 168                     continue;
 169
 170                 case EDITRSW:
 171                     if (!(ed = *argp++) || *ed == '-')
 172                         adios (NULL, "missing argument to %s", argp[-2]);
 173                     nedit = 0;
 174                     continue;
 175                 case NEDITSW:
 176                     nedit++;
 177                     continue;
 178
 179                 case WHATSW:
 180                     if (!(whatnowproc = *argp++) || *whatnowproc == '-')
 181                         adios (NULL, "missing argument to %s", argp[-2]);
 182                     nwhat = 0;
 183                     continue;
 184                 case BILDSW:
 185                     buildsw++;  /* fall... */
 186                 case NWHATSW:
 187                     nwhat++;
 188                     continue;
 189
 190                 case FILESW:
 191                     if (file)
 192                         adios (NULL, "only one file at a time!");
 193                     if (!(cp = *argp++) || *cp == '-')
 194                         adios (NULL, "missing argument to %s", argp[-2]);
 195                     file = path (cp, TFILE);
 196                     continue;
 197                 case FILTSW:
 198                     if (!(cp = *argp++) || *cp == '-')
 199                         adios (NULL, "missing argument to %s", argp[-2]);
 200                     filter = getcpy (etcpath (cp));
 201                     mime = 0;
 202                     continue;
 203                 case FORMSW:
 204                     if (!(form = *argp++) || *form == '-')
 205                         adios (NULL, "missing argument to %s", argp[-2]);
 206                     continue;
 207
 208                 case FRMTSW:
 209                     filter = getcpy (etcpath (mhlforward));
 210                     continue;
 211                 case NFRMTSW:
 212                     filter = NULL;
 213                     continue;
 214
 215                 case INPLSW:
 216                     inplace++;
 217                     continue;
 218                 case NINPLSW:
 219                     inplace = 0;
 220                     continue;
 221
 222                 case MIMESW:
 223                     mime++;
 224                     filter = NULL;
 225                     continue;
 226                 case NMIMESW:
 227                     mime = 0;
 228                     continue;
 229
 230                 case DGSTSW:
 231                     if (!(digest = *argp++) || *digest == '-')
 232                         adios (NULL, "missing argument to %s", argp[-2]);
 233                     mime = 0;
 234                     continue;
 235                 case ISSUESW:
 236                     if (!(cp = *argp++) || *cp == '-')
 237                         adios (NULL, "missing argument to %s", argp[-2]);
 238                     if ((issue = atoi (cp)) < 1)
 239                         adios (NULL, "bad argument %s %s", argp[-2], cp);
 240                     continue;
 241                 case VOLUMSW:
 242                     if (!(cp = *argp++) || *cp == '-')
 243                         adios (NULL, "missing argument to %s", argp[-2]);
 244                     if ((volume = atoi (cp)) < 1)
 245                         adios (NULL, "bad argument %s %s", argp[-2], cp);
 246                     continue;
 247
 248                 case DFOLDSW:
 249                     if (dfolder)
 250                         adios (NULL, "only one draft folder at a time!");
 251                     if (!(cp = *argp++) || *cp == '-')
 252                         adios (NULL, "missing argument to %s", argp[-2]);
 253                     dfolder = path (*cp == '+' || *cp == '@' ? cp + 1 : cp,
 254                                     *cp != '@' ? TFOLDER : TSUBCWF);
 255                     continue;
 256                 case DMSGSW:
 257                     if (dmsg)
 258                         adios (NULL, "only one draft message at a time!");
 259                     if (!(dmsg = *argp++) || *dmsg == '-')
 260                         adios (NULL, "missing argument to %s", argp[-2]);
 261                     continue;
 262                 case NDFLDSW:
 263                     dfolder = NULL;
 264                     isdf = NOTOK;
 265                     continue;
 266
 267                 case BITSTUFFSW:
 268                     dashstuff = 1;      /* trinary logic */
 269                     continue;
 270                 case NBITSTUFFSW:
 271                     dashstuff = -1;     /* trinary logic */
 272                     continue;
 273             }
 274         }
 275         if (*cp == '+' || *cp == '@') {
 276             if (folder)
 277                 adios (NULL, "only one folder at a time!");
 278             else
 279                 folder = pluspath (cp);
 280         } else {
 281             msgs[msgp++] = cp;
 282         }
 283     }
 284
 285     cwd = getcpy (pwd ());
 286
 287     if (!context_find ("path"))
 288         free (path ("./", TFOLDER));
 289     if (file && (msgp || folder))
 290         adios (NULL, "can't mix files and folders/msgs");
 291
 292 try_it_again:
 293
 294     strncpy (drft, buildsw ? m_maildir ("draft")
 295                           : m_draft (dfolder, NULL, NOUSE, &isdf), sizeof(drft));
 296
 297     /* Check if a draft already exists */
 298     if (!buildsw && stat (drft, &st) != NOTOK) {
 299         printf ("Draft \"%s\" exists (%ld bytes).", drft, (long) st.st_size);
 300         for (i = LISTDSW; i != YESW;) {
 301             if (!(argp = getans ("\nDisposition? ", isdf ? aqrnl : aqrl)))
 302                 done (1);
 303             switch (i = smatch (*argp, isdf ? aqrnl : aqrl)) {
 304                 case NOSW:
 305                     done (0);
 306                 case NEWSW:
 307                     dmsg = NULL;
 308                     goto try_it_again;
 309                 case YESW:
 310                     break;
 311                 case LISTDSW:
 312                     showfile (++argp, drft);
 313                     break;
 314                 case REFILSW:
 315                     if (refile (++argp, drft) == 0)
 316                         i = YESW;
 317                     break;
 318                 default:
 319                     advise (NULL, "say what?");
 320                     break;
 321             }
 322         }
 323     }
 324
 325     if (file) {
 326         /*
 327          * Forwarding a file.
 328          */
 329         anot = 0;       /* don't want to annotate a file */
 330     } else {
 331         /*
 332          * Forwarding a message.
 333          */
 334         if (!msgp)
 335             msgs[msgp++] = "cur";
 336         if (!folder)
 337             folder = getfolder (1);
 338         maildir = m_maildir (folder);
 339
 340         if (chdir (maildir) == NOTOK)
 341             adios (maildir, "unable to change directory to");
 342
 343         /* read folder and create message structure */
 344         if (!(mp = folder_read (folder)))
 345             adios (NULL, "unable to read folder %s", folder);
 346
 347         /* check for empty folder */
 348         if (mp->nummsg == 0)
 349             adios (NULL, "no messages in %s", folder);
 350
 351         /* parse all the message ranges/sequences and set SELECTED */
 352         for (msgnum = 0; msgnum < msgp; msgnum++)
 353             if (!m_convert (mp, msgs[msgnum]))
 354                 done (1);
 355         seq_setprev (mp);       /* set the previous sequence */
 356     }
 357
 358     if (filter && access (filter, R_OK) == NOTOK)
 359         adios (filter, "unable to read");
 360
 361     /*
 362      * Open form (component) file.
 363      */
 364     if (digest) {
 365         if (issue == 0) {
 366             snprintf (buf, sizeof(buf), IFORMAT, digest);
 367             if (volume == 0
 368                     && (cp = context_find (buf))
 369                     && ((issue = atoi (cp)) < 0))
 370                 issue = 0;
 371             issue++;
 372         }
 373         if (volume == 0)
 374             snprintf (buf, sizeof(buf), VFORMAT, digest);
 375         if ((cp = context_find (buf)) == NULL || (volume = atoi (cp)) <= 0)
 376             volume = 1;
 377         if (!form)
 378             form = digestcomps;
 379         in = build_form (form, digest, volume, issue);
 380     } else
 381         in = open_form(&form, forwcomps);
 382
 383     if ((out = creat (drft, m_gmprot ())) == NOTOK)
 384         adios (drft, "unable to create");
 385
 386     /*
 387      * copy the components into the draft
 388      */
 389     cpydata (in, out, form, drft);
 390     close (in);
 391
 392     if (file) {
 393         /* just copy the file into the draft */
 394         if ((in = open (file, O_RDONLY)) == NOTOK)
 395             adios (file, "unable to open");
 396         cpydata (in, out, file, drft);
 397         close (in);
 398         close (out);
 399     } else {
 400         /*
 401          * If filter file is defined, then format the
 402          * messages into the draft using mhlproc.
 403          */
 404         if (filter)
 405             mhl_draft (out, digest, volume, issue, drft, filter, dashstuff);
 406         else if (mime)
 407             copy_mime_draft (out);
 408         else
 409             copy_draft (out, digest, drft, volume, issue, dashstuff);
 410         close (out);
 411
 412         if (digest) {
 413             snprintf (buf, sizeof(buf), IFORMAT, digest);
 414             snprintf (value, sizeof(value), "%d", issue);
 415             context_replace (buf, getcpy (value));
 416             snprintf (buf, sizeof(buf), VFORMAT, digest);
 417             snprintf (value, sizeof(value), "%d", volume);
 418             context_replace (buf, getcpy (value));
 419         }
 420
 421         context_replace (pfolder, folder);      /* update current folder   */
 422         seq_setcur (mp, mp->lowsel);            /* update current message  */
 423         seq_save (mp);                          /* synchronize sequences   */
 424         context_save ();                        /* save the context file   */
 425     }
 426
 427     if (nwhat)
 428         done (0);
 429     what_now (ed, nedit, NOUSE, drft, NULL, 0, mp,
 430         anot ? "Forwarded" : NULL, inplace, cwd);
 431     done (1);
 432     return 1;
 433 }
 434
 435
 436 /*
 437  * Filter the messages you are forwarding, into the
 438  * draft calling the mhlproc, and reading its output
 439  * from a pipe.
 440  */
 441
 442 static void
 443 mhl_draft (int out, char *digest, int volume, int issue,
 444             char *file, char *filter, int dashstuff)
 445 {
 446     pid_t child_id;
 447     int i, msgnum, pd[2];
 448     char *vec[MAXARGS];
 449     char buf1[BUFSIZ];
 450     char buf2[BUFSIZ];
 451
 452     if (pipe (pd) == NOTOK)
 453         adios ("pipe", "unable to create");
 454
 455     vec[0] = r1bindex (mhlproc, '/');
 456
 457     for (i = 0; (child_id = fork()) == NOTOK && i < 5; i++)
 458         sleep (5);
 459     switch (child_id) {
 460         case NOTOK:
 461             adios ("fork", "unable to");
 462
 463         case OK:
 464             close (pd[0]);
 465             dup2 (pd[1], 1);
 466             close (pd[1]);
 467
 468             i = 1;
 469             vec[i++] = "-forwall";
 470             vec[i++] = "-form";
 471             vec[i++] = filter;
 472
 473             if (digest) {
 474                 vec[i++] = "-digest";
 475                 vec[i++] = digest;
 476                 vec[i++] = "-issue";
 477                 snprintf (buf1, sizeof(buf1), "%d", issue);
 478                 vec[i++] = buf1;
 479                 vec[i++] = "-volume";
 480                 snprintf (buf2, sizeof(buf2), "%d", volume);
 481                 vec[i++] = buf2;
 482             }
 483
 484             /*
 485              * Are we dashstuffing (quoting) the lines that begin
 486              * with `-'.  We use the mhl default (don't add any flag)
 487              * unless the user has specified a specific flag.
 488              */
 489             if (dashstuff > 0)
 490                 vec[i++] = "-dashstuffing";
 491             else if (dashstuff < 0)
 492                 vec[i++] = "-nodashstuffing";
 493
 494             if (mp->numsel >= MAXARGS - i)
 495                 adios (NULL, "more than %d messages for %s exec",
 496                         MAXARGS - i, vec[0]);
 497
 498             /*
 499              * Now add the message names to filter.  We can only
 500              * handle about 995 messages (because vec is fixed size),
 501              * but that should be plenty.
 502              */
 503             for (msgnum = mp->lowsel;
 504                  msgnum <= mp->hghsel && i < (int) sizeof(vec) - 1;
 505                  msgnum++)
 506                 if (is_selected (mp, msgnum))
 507                     vec[i++] = getcpy (m_name (msgnum));
 508             vec[i] = NULL;
 509
 510             execvp (mhlproc, vec);
 511             fprintf (stderr, "unable to exec ");
 512             perror (mhlproc);
 513             _exit (-1);
 514
 515         default:
 516             close (pd[1]);
 517             cpydata (pd[0], out, vec[0], file);
 518             close (pd[0]);
 519             pidXwait(child_id, mhlproc);
 520             break;
 521     }
 522 }
 523
 524
 525 /*
 526  * Copy the messages into the draft.  The messages are
 527  * not filtered through the mhlproc.  Do dashstuffing if
 528  * necessary.
 529  */
 530
 531 static void
 532 copy_draft (int out, char *digest, char *file, int volume, int issue, int dashstuff)
 533 {
 534     int fd,i, msgcnt, msgnum;
 535     int len, buflen;
 536     register char *bp, *msgnam;
 537     char buffer[BUFSIZ];
 538
 539     msgcnt = 1;
 540     for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
 541         if (is_selected (mp, msgnum)) {
 542             if (digest) {
 543                 strncpy (buffer, msgnum == mp->lowsel ? delim3 : delim4,
 544                         sizeof(buffer));
 545             } else {
 546                 /* Get buffer ready to go */
 547                 bp = buffer;
 548                 buflen = sizeof(buffer);
 549
 550                 strncpy (bp, "\n-------", buflen);
 551                 len = strlen (bp);
 552                 bp += len;
 553                 buflen -= len;
 554
 555                 if (msgnum == mp->lowsel) {
 556                     snprintf (bp, buflen, " Forwarded Message%s",
 557                         mp->numsel > 1 ? "s" : "");
 558                 } else {
 559                     snprintf (bp, buflen, " Message %d", msgcnt);
 560                 }
 561                 len = strlen (bp);
 562                 bp += len;
 563                 buflen -= len;
 564
 565                 strncpy (bp, "\n\n", buflen);
 566             }
 567             write (out, buffer, strlen (buffer));
 568
 569             if ((fd = open (msgnam = m_name (msgnum), O_RDONLY)) == NOTOK) {
 570                 admonish (msgnam, "unable to read message");
 571                 continue;
 572             }
 573
 574             /*
 575              * Copy the message.  Add RFC934 quoting (dashstuffing)
 576              * unless given the -nodashstuffing flag.
 577              */
 578             if (dashstuff >= 0)
 579                 cpydgst (fd, out, msgnam, file);
 580             else
 581                 cpydata (fd, out, msgnam, file);
 582
 583             close (fd);
 584             msgcnt++;
 585         }
 586     }
 587
 588     if (digest) {
 589         strncpy (buffer, delim4, sizeof(buffer));
 590     } else {
 591         snprintf (buffer, sizeof(buffer), "\n------- End of Forwarded Message%s\n\n",
 592                 mp->numsel > 1 ? "s" : "");
 593     }
 594     write (out, buffer, strlen (buffer));
 595
 596     if (digest) {
 597         snprintf (buffer, sizeof(buffer), "End of %s Digest [Volume %d Issue %d]\n",
 598                 digest, volume, issue);
 599         i = strlen (buffer);
 600         for (bp = buffer + i; i > 1; i--)
 601             *bp++ = '*';
 602         *bp++ = '\n';
 603         *bp = 0;
 604         write (out, buffer, strlen (buffer));
 605     }
 606 }
 607
 608
 609 /*
 610  * Create a mhn composition file for forwarding message.
 611  */
 612
 613 static void
 614 copy_mime_draft (int out)
 615 {
 616     int msgnum;
 617     char buffer[BUFSIZ];
 618
 619     snprintf (buffer, sizeof(buffer), "#forw [forwarded message%s] +%s",
 620         mp->numsel == 1 ? "" : "s", mp->foldpath);
 621     write (out, buffer, strlen (buffer));
 622     for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
 623         if (is_selected (mp, msgnum)) {
 624             snprintf (buffer, sizeof(buffer), " %s", m_name (msgnum));
 625             write (out, buffer, strlen (buffer));
 626         }
 627     write (out, "\n", 1);
 628 }
 629
 630
 631 static int
 632 build_form (char *form, char *digest, int volume, int issue)
 633 {
 634     int in;
 635     int fmtsize;
 636     register char *nfs;
 637     char *line, tmpfil[BUFSIZ];
 638     FILE *tmp;
 639     register struct comp *cptr;
 640     struct format *fmt;
 641     int dat[5];
 642     char *cp = NULL;
 643
 644     /* Get new format string */
 645     nfs = new_fs (form, NULL, NULL);
 646     fmtsize = strlen (nfs) + 256;
 647
 648     /* Compile format string */
 649     fmt_compile (nfs, &fmt);
 650
 651     FINDCOMP (cptr, "digest");
 652     if (cptr)
 653         cptr->c_text = digest;
 654     FINDCOMP (cptr, "date");
 655     if (cptr)
 656         cptr->c_text = getcpy(dtimenow (0));
 657
 658     dat[0] = issue;
 659     dat[1] = volume;
 660     dat[2] = 0;
 661     dat[3] = fmtsize;
 662     dat[4] = 0;
 663
 664     cp = m_mktemp2(NULL, invo_name, NULL, &tmp);
 665     if (cp == NULL) adios("forw", "unable to create temporary file");
 666     strncpy (tmpfil, cp, sizeof(tmpfil));
 667     unlink (tmpfil);
 668     if ((in = dup (fileno (tmp))) == NOTOK)
 669         adios ("dup", "unable to");
 670
 671     line = mh_xmalloc ((unsigned) fmtsize);
 672     fmt_scan (fmt, line, fmtsize, dat);
 673     fputs (line, tmp);
 674     free (line);
 675     if (fclose (tmp))
 676         adios (tmpfil, "error writing");
 677
 678     lseek (in, (off_t) 0, SEEK_SET);
 679     return in;
 680 }