cmd-resend.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ All sorts of `reply', `resend', `forward', and similar user commands.
   3  *
   4  * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
   5  * Copyright (c) 2012 - 2017 Steffen (Daode) Nurpmeso <steffen@sdaoden.eu>.
   6  */
   7 /*
   8  * Copyright (c) 1980, 1993
   9  *      The Regents of the University of California.  All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35 #undef n_FILE
  36 #define n_FILE cmd_resend
  37
  38 #ifndef HAVE_AMALGAMATION
  39 # include "nail.h"
  40 #endif
  41
  42 /* Modify subject we reply to to begin with Re: if it does not already */
  43 static char *a_crese_reedit(char const *subj);
  44
  45 static void       make_ref_and_cs(struct message *mp, struct header *head);
  46
  47 /* `reply' and `Lreply' workhorse */
  48 static int        _list_reply(int *msgvec, enum header_flags hf);
  49
  50 /* Get PTF to implementation of command c (i.e., take care for *flipr*) */
  51 static int (*     _reply_or_Reply(char c))(int *, bool_t);
  52
  53 /* Reply to a single message.  Extract each name from the message header and
  54  * send them off to mail1() */
  55 static int        _reply(int *msgvec, bool_t recipient_record);
  56
  57 /* Reply to a series of messages by simply mailing to the senders and not
  58  * messing around with the To: and Cc: lists as in normal reply */
  59 static int        _Reply(int *msgvec, bool_t recipient_record);
  60
  61 /* Forward a message to a new recipient, in the sense of RFC 2822 */
  62 static int        _fwd(char *str, int recipient_record);
  63
  64 /* Modify the subject we are replying to to begin with Fwd: */
  65 static char *     __fwdedit(char *subj);
  66
  67 /* Do the real work of resending */
  68 static int        _resend1(void *v, bool_t add_resent);
  69
  70 static char *
  71 a_crese_reedit(char const *subj){
  72    char *newsubj;
  73    NYD_ENTER;
  74
  75    newsubj = NULL;
  76
  77    if(subj != NULL && *subj != '\0'){
  78       struct str in, out;
  79       size_t i;
  80       char const *cp;
  81
  82       in.l = strlen(in.s = n_UNCONST(subj));
  83       mime_fromhdr(&in, &out, TD_ISPR | TD_ICONV);
  84
  85       i = strlen(cp = subject_re_trim(out.s)) +1;
  86       /* RFC mandates english "Re: " */
  87       newsubj = salloc(sizeof("Re: ") -1 + i);
  88       memcpy(newsubj, "Re: ", sizeof("Re: ") -1);
  89       memcpy(&newsubj[sizeof("Re: ") -1], cp, i);
  90
  91       free(out.s);
  92    }
  93    NYD_LEAVE;
  94    return newsubj;
  95 }
  96
  97 static void
  98 make_ref_and_cs(struct message *mp, struct header *head) /* TODO rewrite FAST */
  99 {
 100    char *oldref, *oldmsgid, *newref, *cp;
 101    size_t oldreflen = 0, oldmsgidlen = 0, reflen;
 102    unsigned i;
 103    struct name *n;
 104    NYD_ENTER;
 105
 106    oldref = hfield1("references", mp);
 107    oldmsgid = hfield1("message-id", mp);
 108    if (oldmsgid == NULL || *oldmsgid == '\0') {
 109       head->h_ref = NULL;
 110       goto jleave;
 111    }
 112
 113    reflen = 1;
 114    if (oldref) {
 115       oldreflen = strlen(oldref);
 116       reflen += oldreflen + 2;
 117    }
 118    if (oldmsgid) {
 119       oldmsgidlen = strlen(oldmsgid);
 120       reflen += oldmsgidlen;
 121    }
 122
 123    newref = smalloc(reflen);
 124    if (oldref != NULL) {
 125       memcpy(newref, oldref, oldreflen +1);
 126       if (oldmsgid != NULL) {
 127          newref[oldreflen++] = ',';
 128          newref[oldreflen++] = ' ';
 129          memcpy(newref + oldreflen, oldmsgid, oldmsgidlen +1);
 130       }
 131    } else if (oldmsgid)
 132       memcpy(newref, oldmsgid, oldmsgidlen +1);
 133    n = extract(newref, GREF);
 134    free(newref);
 135
 136    /* Limit number of references TODO better on parser side */
 137    while (n->n_flink != NULL)
 138       n = n->n_flink;
 139    for (i = 1; i <= REFERENCES_MAX; ++i) {
 140       if (n->n_blink != NULL)
 141          n = n->n_blink;
 142       else
 143          break;
 144    }
 145    n->n_blink = NULL;
 146    head->h_ref = n;
 147    if (ok_blook(reply_in_same_charset) &&
 148          (cp = hfield1("content-type", mp)) != NULL){
 149       if((head->h_charset = cp = mime_param_get("charset", cp)) != NULL){
 150          char *cpo, c;
 151
 152          for(cpo = cp; (c = *cpo) != '\0'; ++cpo)
 153             *cpo = lowerconv(c);
 154
 155          head->h_charset = n_charsetalias_expand(cp);
 156       }
 157    }
 158 jleave:
 159    NYD_LEAVE;
 160 }
 161
 162 static int
 163 _list_reply(int *msgvec, enum header_flags hf)
 164 {
 165    struct header head;
 166    struct message *mp;
 167    char const *reply_to, *rcv, *cp;
 168    enum gfield gf;
 169    struct name *rt, *mft, *np;
 170    int *save_msgvec;
 171    NYD_ENTER;
 172
 173    /* TODO Since we may recur and do stuff with message lists we need to save
 174     * TODO away the argument vector as long as that isn't done by machinery */
 175    {
 176       size_t i;
 177       for (i = 0; msgvec[i] != 0; ++i)
 178          ;
 179       ++i;
 180       save_msgvec = ac_alloc(sizeof(*save_msgvec) * i);
 181       while (i-- > 0)
 182          save_msgvec[i] = msgvec[i];
 183       msgvec = save_msgvec;
 184    }
 185
 186    gf = ok_blook(fullnames) ? GFULL | GSKIN : GSKIN;
 187
 188 jnext_msg:
 189    n_autorec_relax_create();
 190    mp = &message[*msgvec - 1];
 191    touch(mp);
 192    setdot(mp);
 193
 194    memset(&head, 0, sizeof head);
 195    head.h_flags = hf;
 196    head.h_subject = a_crese_reedit(hfield1("subject", mp));
 197    head.h_mailx_command = "reply";
 198    head.h_mailx_orig_from = lextract(hfield1("from", mp), GIDENT | gf);
 199    head.h_mailx_orig_to = lextract(hfield1("to", mp), GTO | gf);
 200    head.h_mailx_orig_cc = lextract(hfield1("cc", mp), GCC | gf);
 201    head.h_mailx_orig_bcc = lextract(hfield1("bcc", mp), GBCC | gf);
 202    rt = mft = NULL;
 203
 204    rcv = NULL;
 205    if ((reply_to = hfield1("reply-to", mp)) != NULL &&
 206          (cp = ok_vlook(reply_to_honour)) != NULL &&
 207          (rt = checkaddrs(lextract(reply_to, GTO | gf), EACM_STRICT, NULL)
 208          ) != NULL) {
 209       char *sp;
 210       size_t l;
 211       char const *tr;
 212
 213       tr = _("Reply-To %s%s");
 214       l = strlen(tr) + strlen(rt->n_name) + 3 +1;
 215       sp = n_autorec_alloc(l);
 216       snprintf(sp, l, tr, rt->n_name, (rt->n_flink != NULL ? "..." : n_empty));
 217
 218       if(quadify(cp, UIZ_MAX, sp, TRU1) > FAL0)
 219          rcv = reply_to;
 220    }
 221
 222    if (rcv == NULL && (rcv = hfield1("from", mp)) == NULL)
 223       rcv = nameof(mp, 1);
 224
 225    /* Cc: */
 226    np = NULL;
 227    if (ok_blook(recipients_in_cc) && (cp = hfield1("to", mp)) != NULL)
 228       np = lextract(cp, GCC | gf);
 229    if ((cp = hfield1("cc", mp)) != NULL) {
 230       struct name *x;
 231
 232       if((x = lextract(cp, GCC | gf)) != NULL)
 233          np = cat(np, x);
 234    }
 235    if (np != NULL) {
 236       head.h_mailx_raw_cc = namelist_dup(np, GCC | gf);
 237       head.h_cc = n_alternates_remove(np, FAL0);
 238    }
 239
 240    /* To: */
 241    np = NULL;
 242    if (rcv != NULL)
 243       np = (rcv == reply_to) ? namelist_dup(rt, GTO | gf)
 244             : lextract(rcv, GTO | gf);
 245    if (!ok_blook(recipients_in_cc) && (cp = hfield1("to", mp)) != NULL) {
 246       struct name *x;
 247
 248       if((x = lextract(cp, GTO | gf)) != NULL)
 249          np = cat(np, x);
 250    }
 251    /* Delete my name from reply list, and with it, all my alternate names */
 252    if(np != NULL){
 253       head.h_mailx_raw_to = namelist_dup(np, GTO | gf);
 254       np = n_alternates_remove(np, FAL0);
 255       if(count(np) == 0){
 256          np = lextract(rcv, GTO | gf);
 257          head.h_mailx_raw_to = namelist_dup(np, GTO | gf);
 258       }
 259    }
 260    head.h_to = np;
 261
 262    /* The user may have send this to himself, don't ignore that */
 263    namelist_vaporise_head(&head, EACM_NORMAL, FAL0, NULL);
 264    if (head.h_to == NULL)
 265       head.h_to = np;
 266
 267    /* Mail-Followup-To: */
 268    mft = NULL;
 269    if (ok_vlook(followup_to_honour) != NULL &&
 270          (cp = hfield1("mail-followup-to", mp)) != NULL &&
 271          (mft = np = checkaddrs(lextract(cp, GTO | gf), EACM_STRICT, NULL)
 272          ) != NULL) {
 273       char *sp;
 274       size_t l;
 275       char const *tr;
 276
 277       tr = _("Followup-To %s%s");
 278       l = strlen(tr) + strlen(np->n_name) + 3 +1;
 279       sp = n_autorec_alloc(l);
 280       snprintf(sp, l, tr, np->n_name, (np->n_flink != NULL ? "..." : n_empty));
 281
 282       if(quadify(ok_vlook(followup_to_honour), UIZ_MAX, sp, TRU1) > FAL0){
 283          head.h_cc = NULL;
 284          head.h_to = np;
 285          head.h_mft =
 286          mft = namelist_vaporise_head(&head, EACM_STRICT, FAL0, NULL);
 287       }else
 288          mft = NULL;
 289    }
 290
 291    /* Special massage for list (follow-up) messages */
 292    if (mft != NULL || (hf & HF_LIST_REPLY) || ok_blook(followup_to)) {
 293       /* Learn about a possibly sending mailing list; use do for break; */
 294       if ((cp = hfield1("list-post", mp)) != NULL) do {
 295          struct name *x;
 296
 297          if ((x = lextract(cp, GEXTRA | GSKIN)) == NULL || x->n_flink != NULL ||
 298                (cp = url_mailto_to_address(x->n_name)) == NULL ||
 299                /* XXX terribly wasteful to create a new name, and can't we find
 300                 * XXX a way to mitigate that?? */
 301                is_addr_invalid(x = nalloc(cp, GEXTRA | GSKIN), EACM_STRICT)) {
 302             if(n_poption & n_PO_D_V)
 303                n_err(_("Message contains invalid List-Post: header\n"));
 304             cp = NULL;
 305             break;
 306          }
 307          cp = x->n_name;
 308
 309          /* A special case has been seen on e.g. ietf-announce@ietf.org:
 310           * these usually post to multiple groups, with ietf-announce@
 311           * in List-Post:, but with Reply-To: set to ietf@ietf.org (since
 312           * -announce@ is only used for announcements, say).
 313           * So our desire is to honour this request and actively overwrite
 314           * List-Post: for our purpose; but only if its a single address.
 315           * However, to avoid ambiguities with users that place themselve in
 316           * Reply-To: and mailing lists which don't overwrite this (or only
 317           * extend this, shall such exist), only do so if reply_to exists of
 318           * a single address which points to the same domain as List-Post: */
 319          if (reply_to != NULL && rt->n_flink == NULL &&
 320                name_is_same_domain(x, rt))
 321             cp = rt->n_name; /* rt is EACM_STRICT tested */
 322
 323          /* "Automatically `mlist'" the List-Post: address temporarily */
 324          if (is_mlist(cp, FAL0) == MLIST_OTHER)
 325             head.h_list_post = cp;
 326          else
 327             cp = NULL;
 328       } while (0);
 329
 330       /* In case of list replies we actively sort out any non-list recipient,
 331        * but _only_ if we did not honour a MFT:, assuming that members of MFT
 332        * were there for a reason; cp is still List-Post:/eqivalent */
 333       if ((hf & HF_LIST_REPLY) && mft == NULL) {
 334          struct name *nhp = head.h_to;
 335          head.h_to = NULL;
 336 j_lt_redo:
 337          while (nhp != NULL) {
 338             np = nhp;
 339             nhp = nhp->n_flink;
 340
 341             if ((cp != NULL && !asccasecmp(cp, np->n_name)) ||
 342                   is_mlist(np->n_name, FAL0) != MLIST_OTHER) {
 343                np->n_type = (np->n_type & ~GMASK) | GTO;
 344                np->n_flink = head.h_to;
 345                head.h_to = np;
 346             }
 347          }
 348          if ((nhp = head.h_cc) != NULL) {
 349             head.h_cc = NULL;
 350             goto j_lt_redo;
 351          }
 352       }
 353    }
 354
 355    make_ref_and_cs(mp, &head);
 356
 357    if (ok_blook(quote_as_attachment)) {
 358       head.h_attach = csalloc(1, sizeof *head.h_attach);
 359       head.h_attach->a_msgno = *msgvec;
 360       head.h_attach->a_content_description = _("Original message content");
 361    }
 362
 363    if (mail1(&head, 1, mp, NULL, !!(hf & HF_RECIPIENT_RECORD), 0) != OKAY) {
 364       msgvec = NULL;
 365       goto jleave;
 366    }
 367    if(ok_blook(markanswered) && !(mp->m_flag & MANSWERED))
 368       mp->m_flag |= MANSWER | MANSWERED;
 369    n_autorec_relax_gut();
 370
 371    if (*++msgvec != 0) {
 372       /* TODO message (error) ring.., less sleep */
 373       if(n_psonce & n_PSO_INTERACTIVE){
 374          fprintf(n_stdout,
 375             _("Waiting a second before proceeding to the next message..\n"));
 376          fflush(n_stdout);
 377          n_msleep(1000, FAL0);
 378       }
 379       goto jnext_msg;
 380    }
 381
 382 jleave:
 383    ac_free(save_msgvec);
 384    NYD_LEAVE;
 385    return (msgvec == NULL);
 386 }
 387
 388 static int
 389 (*_reply_or_Reply(char c))(int *, bool_t)
 390 {
 391    int (*rv)(int*, bool_t);
 392    NYD_ENTER;
 393
 394    rv = (ok_blook(flipr) ^ (c == 'R')) ? &_Reply : &_reply;
 395    NYD_LEAVE;
 396    return rv;
 397 }
 398
 399 static int
 400 _reply(int *msgvec, bool_t recipient_record)
 401 {
 402    int rv;
 403    NYD_ENTER;
 404
 405    rv = _list_reply(msgvec, recipient_record ? HF_RECIPIENT_RECORD : HF_NONE);
 406    NYD_LEAVE;
 407    return rv;
 408 }
 409
 410 static int
 411 _Reply(int *msgvec, bool_t recipient_record)
 412 {
 413    struct header head;
 414    struct message *mp;
 415    int *ap;
 416    char *cp;
 417    enum gfield gf;
 418    NYD_ENTER;
 419
 420    memset(&head, 0, sizeof head);
 421    gf = ok_blook(fullnames) ? GFULL | GSKIN : GSKIN;
 422
 423    for (ap = msgvec; *ap != 0; ++ap) {
 424       char const *rp;
 425       struct name *rt;
 426
 427       mp = &message[*ap - 1];
 428       touch(mp);
 429       setdot(mp);
 430
 431       if ((rp = hfield1("reply-to", mp)) != NULL &&
 432             (cp = ok_vlook(reply_to_honour)) != NULL &&
 433             (rt = checkaddrs(lextract(rp, GTO | gf), EACM_STRICT, NULL)
 434             ) != NULL) {
 435          char *sp;
 436          size_t l;
 437          char const *tr;
 438
 439          tr = _("Reply-To %s%s");
 440          l = strlen(tr) + strlen(rt->n_name) + 3 +1;
 441          sp = n_autorec_alloc(l);
 442          snprintf(sp, l, tr, rt->n_name, (rt->n_flink != NULL ? "..."
 443             : n_empty));
 444
 445          if(quadify(cp, UIZ_MAX, sp, TRU1) > FAL0){
 446             head.h_to = cat(head.h_to, rt);
 447             continue;
 448          }
 449       }
 450
 451       if ((cp = hfield1("from", mp)) == NULL)
 452          cp = nameof(mp, 2);
 453       head.h_to = cat(head.h_to, lextract(cp, GTO | gf));
 454    }
 455    if (head.h_to == NULL) /* XXX no recipients? */
 456       goto jleave;
 457    head.h_mailx_raw_to = namelist_dup(head.h_to, GTO | gf);
 458
 459    mp = &message[msgvec[0] - 1];
 460    head.h_subject = hfield1("subject", mp);
 461    head.h_subject = a_crese_reedit(head.h_subject);
 462    make_ref_and_cs(mp, &head);
 463    head.h_mailx_command = "reply";
 464    head.h_mailx_orig_from = lextract(hfield1("from", mp), GIDENT | gf);
 465    head.h_mailx_orig_to = lextract(hfield1("to", mp), GTO | gf);
 466    head.h_mailx_orig_cc = lextract(hfield1("cc", mp), GCC | gf);
 467    head.h_mailx_orig_bcc = lextract(hfield1("bcc", mp), GBCC | gf);
 468
 469    if (ok_blook(quote_as_attachment)) {
 470       head.h_attach = csalloc(1, sizeof *head.h_attach);
 471       head.h_attach->a_msgno = *msgvec;
 472       head.h_attach->a_content_description = _("Original message content");
 473    }
 474
 475    if (mail1(&head, 1, mp, NULL, recipient_record, 0) != OKAY) {
 476       msgvec = NULL;
 477       goto jleave;
 478    }
 479
 480    if(ok_blook(markanswered) && !(mp->m_flag & MANSWERED))
 481       mp->m_flag |= MANSWER | MANSWERED;
 482 jleave:
 483    NYD_LEAVE;
 484    return (msgvec == NULL);
 485 }
 486
 487 static int
 488 _fwd(char *str, int recipient_record)
 489 {
 490    struct header head;
 491    int *msgvec, rv = 1;
 492    struct message *mp;
 493    enum gfield gf;
 494    bool_t f, forward_as_attachment;
 495    char *recipient;
 496    NYD_ENTER;
 497
 498    if ((recipient = laststring(str, &f, TRU1)) == NULL) {
 499       fputs(_("No recipient specified.\n"), n_stdout);
 500       goto jleave;
 501    }
 502
 503    forward_as_attachment = ok_blook(forward_as_attachment);
 504    gf = ok_blook(fullnames) ? GFULL | GSKIN : GSKIN;
 505    msgvec = salloc((msgCount + 2) * sizeof *msgvec);
 506
 507    if (!f) {
 508       *msgvec = first(0, MMNORM);
 509       if (*msgvec == 0) {
 510          if (n_pstate & (n_PS_HOOK_MASK | n_PS_ROBOT)) {
 511             rv = 0;
 512             goto jleave;
 513          }
 514          fprintf(n_stdout, _("No messages to forward.\n"));
 515          goto jleave;
 516       }
 517       msgvec[1] = 0;
 518    } else if (getmsglist(str, msgvec, 0) < 0)
 519       goto jleave;
 520
 521    if (*msgvec == 0) {
 522       if (n_pstate & (n_PS_HOOK_MASK | n_PS_ROBOT)) {
 523          rv = 0;
 524          goto jleave;
 525       }
 526       fprintf(n_stdout, _("No applicable messages.\n"));
 527       goto jleave;
 528    }
 529    if (msgvec[1] != 0) {
 530       fprintf(n_stdout, _("Cannot forward multiple messages at once\n"));
 531       goto jleave;
 532    }
 533
 534    memset(&head, 0, sizeof head);
 535    if ((head.h_to = lextract(recipient,
 536          (GTO | (ok_blook(fullnames) ? GFULL : GSKIN)))) == NULL)
 537       goto jleave;
 538
 539    mp = &message[*msgvec - 1];
 540    touch(mp);
 541    setdot(mp);
 542    head.h_subject = hfield1("subject", mp);
 543    head.h_subject = __fwdedit(head.h_subject);
 544    head.h_mailx_command = "forward";
 545    head.h_mailx_raw_to = namelist_dup(head.h_to, GTO | gf);
 546    head.h_mailx_orig_from = lextract(hfield1("from", mp), GIDENT | gf);
 547    head.h_mailx_orig_to = lextract(hfield1("to", mp), GTO | gf);
 548    head.h_mailx_orig_cc = lextract(hfield1("cc", mp), GCC | gf);
 549    head.h_mailx_orig_bcc = lextract(hfield1("bcc", mp), GBCC | gf);
 550
 551    if (forward_as_attachment) {
 552       head.h_attach = csalloc(1, sizeof *head.h_attach);
 553       head.h_attach->a_msgno = *msgvec;
 554       head.h_attach->a_content_description = _("Forwarded message");
 555    }
 556    rv = (mail1(&head, 1, (forward_as_attachment ? NULL : mp), NULL,
 557          recipient_record, 1) != OKAY); /* reverse! */
 558 jleave:
 559    NYD_LEAVE;
 560    return rv;
 561 }
 562
 563 static char *
 564 __fwdedit(char *subj)
 565 {
 566    struct str in, out;
 567    char *newsubj = NULL;
 568    NYD_ENTER;
 569
 570    if (subj == NULL || *subj == '\0')
 571       goto jleave;
 572
 573    in.s = subj;
 574    in.l = strlen(subj);
 575    mime_fromhdr(&in, &out, TD_ISPR | TD_ICONV);
 576
 577    newsubj = salloc(out.l + 6);
 578    memcpy(newsubj, "Fwd: ", 5); /* XXX localizable */
 579    memcpy(newsubj + 5, out.s, out.l +1);
 580    free(out.s);
 581 jleave:
 582    NYD_LEAVE;
 583    return newsubj;
 584 }
 585
 586 static int
 587 _resend1(void *v, bool_t add_resent)
 588 {
 589    struct header head;
 590    struct name *myto, *myrawto;
 591    enum gfield gf;
 592    char *name, *str;
 593    int *ip, *msgvec;
 594    bool_t f = TRU1;
 595    NYD_ENTER;
 596
 597    str = v;
 598    msgvec = salloc((msgCount + 2) * sizeof *msgvec);
 599    name = laststring(str, &f, TRU1);
 600    if (name == NULL) {
 601       fputs(_("No recipient specified.\n"), n_stdout);
 602       goto jleave;
 603    }
 604
 605    if (!f) {
 606       *msgvec = first(0, MMNORM);
 607       if (*msgvec == 0) {
 608          if (n_pstate & (n_PS_HOOK_MASK | n_PS_ROBOT)) {
 609             f = FAL0;
 610             goto jleave;
 611          }
 612          fputs(_("No applicable messages.\n"), n_stdout);
 613          goto jleave;
 614       }
 615       msgvec[1] = 0;
 616    } else if (getmsglist(str, msgvec, 0) < 0)
 617       goto jleave;
 618
 619    if (*msgvec == 0) {
 620       if (n_pstate & (n_PS_HOOK_MASK | n_PS_ROBOT)) {
 621          f = FAL0;
 622          goto jleave;
 623       }
 624       fprintf(n_stdout, "No applicable messages.\n");
 625       goto jleave;
 626    }
 627
 628    f = TRU1;
 629    gf = ok_blook(fullnames) ? GFULL | GSKIN : GSKIN;
 630
 631    myrawto = nalloc(name, GTO | gf);
 632    myto = usermap(namelist_dup(myrawto, myrawto->n_type), FAL0);
 633    myto = n_alternates_remove(myto, TRU1);
 634    if(myto == NULL){
 635       n_err(_("No recipients specified\n"));
 636       goto jleave;
 637    }
 638
 639    n_autorec_relax_create();
 640    for (ip = msgvec; *ip != 0 && UICMP(z, PTR2SIZE(ip - msgvec), <, msgCount);
 641          ++ip){
 642       struct message *mp;
 643
 644       mp = &message[*ip - 1];
 645       touch(mp);
 646       setdot(mp);
 647
 648       memset(&head, 0, sizeof head);
 649       head.h_to = myto;
 650       head.h_mailx_command = "resend";
 651       head.h_mailx_raw_to = myrawto;
 652       head.h_mailx_orig_from = lextract(hfield1("from", mp), GIDENT | gf);
 653       head.h_mailx_orig_to = lextract(hfield1("to", mp), GTO | gf);
 654       head.h_mailx_orig_cc = lextract(hfield1("cc", mp), GCC | gf);
 655       head.h_mailx_orig_bcc = lextract(hfield1("bcc", mp), GBCC | gf);
 656
 657       if(resend_msg(mp, &head, add_resent) != OKAY){
 658          /* n_autorec_relax_gut(); XXX but is handled automatically? */
 659          goto jleave;
 660       }
 661       n_autorec_relax_unroll();
 662    }
 663    n_autorec_relax_gut();
 664    f = FAL0;
 665 jleave:
 666    NYD_LEAVE;
 667    return (f != FAL0);
 668 }
 669
 670 FL int
 671 c_reply(void *v)
 672 {
 673    int rv;
 674    NYD_ENTER;
 675
 676    rv = (*_reply_or_Reply('r'))(v, FAL0);
 677    NYD_LEAVE;
 678    return rv;
 679 }
 680
 681 FL int
 682 c_replyall(void *v)
 683 {
 684    int rv;
 685    NYD_ENTER;
 686
 687    rv = _reply(v, FAL0);
 688    NYD_LEAVE;
 689    return rv;
 690 }
 691
 692 FL int
 693 c_replysender(void *v)
 694 {
 695    int rv;
 696    NYD_ENTER;
 697
 698    rv = _Reply(v, FAL0);
 699    NYD_LEAVE;
 700    return rv;
 701 }
 702
 703 FL int
 704 c_Reply(void *v)
 705 {
 706    int rv;
 707    NYD_ENTER;
 708
 709    rv = (*_reply_or_Reply('R'))(v, FAL0);
 710    NYD_LEAVE;
 711    return rv;
 712 }
 713
 714 FL int
 715 c_Lreply(void *v)
 716 {
 717    int rv;
 718    NYD_ENTER;
 719
 720    rv = _list_reply(v, HF_LIST_REPLY);
 721    NYD_LEAVE;
 722    return rv;
 723 }
 724
 725 FL int
 726 c_followup(void *v)
 727 {
 728    int rv;
 729    NYD_ENTER;
 730
 731    rv = (*_reply_or_Reply('r'))(v, TRU1);
 732    NYD_LEAVE;
 733    return rv;
 734 }
 735
 736 FL int
 737 c_followupall(void *v)
 738 {
 739    int rv;
 740    NYD_ENTER;
 741
 742    rv = _reply(v, TRU1);
 743    NYD_LEAVE;
 744    return rv;
 745 }
 746
 747 FL int
 748 c_followupsender(void *v)
 749 {
 750    int rv;
 751    NYD_ENTER;
 752
 753    rv = _Reply(v, TRU1);
 754    NYD_LEAVE;
 755    return rv;
 756 }
 757
 758 FL int
 759 c_Followup(void *v)
 760 {
 761    int rv;
 762    NYD_ENTER;
 763
 764    rv = (*_reply_or_Reply('R'))(v, TRU1);
 765    NYD_LEAVE;
 766    return rv;
 767 }
 768
 769 FL int
 770 c_forward(void *v)
 771 {
 772    int rv;
 773    NYD_ENTER;
 774
 775    rv = _fwd(v, 0);
 776    NYD_LEAVE;
 777    return rv;
 778 }
 779
 780 FL int
 781 c_Forward(void *v)
 782 {
 783    int rv;
 784    NYD_ENTER;
 785
 786    rv = _fwd(v, 1);
 787    NYD_LEAVE;
 788    return rv;
 789 }
 790
 791 FL int
 792 c_resend(void *v)
 793 {
 794    int rv;
 795    NYD_ENTER;
 796
 797    rv = _resend1(v, TRU1);
 798    NYD_LEAVE;
 799    return rv;
 800 }
 801
 802 FL int
 803 c_Resend(void *v)
 804 {
 805    int rv;
 806    NYD_ENTER;
 807
 808    rv = _resend1(v, FAL0);
 809    NYD_LEAVE;
 810    return rv;
 811 }
 812
 813 /* s-it-mode */