#include <unistd.h>

#include "alloc.h"
#include "buffer.h"
#include "constmap.h"
#include "env.h"
#include "error.h"
#include "exit.h"
#include "fmt.h"
#include "genalloc.h"
#include "getln.h"
#include "getoptb.h"
#include "sig.h"
#include "str.h"
#include "stralloc.h"

#include "auto_qmail.h"
#include "control.h"
#include "headerbody.h"
#include "hfield.h"
#include "newfield.h"
#include "now.h"
#include "qmail.h"
#include "quote.h"
#include "token822.h"

#define LINELEN 80

datetime_sec starttime;

char *qmopts;
int flagdeletesender = 0;
int flagdeletefrom = 0;
int flagdeletemessid = 0;
int flagnamecomment = 0;
int flaghackmess = 0;
int flaghackrecip = 0;
char *mailhost;
char *mailuser;
int mailusertokentype;
char *mailrhost;
char *mailruser;

stralloc control_idhost = {0};
stralloc control_defaultdomain = {0};
stralloc control_defaulthost = {0};
stralloc control_plusdomain = {0};

stralloc sender = {0};
stralloc envsbuf = {0};
token822_alloc envs = {0};
int flagrh;

int flagqueue;
struct qmail qqt;

void out(char *s, int len)
{
  if (flagqueue)
    qmail_put(&qqt, s, len);
  else
    buffer_putflush(buffer_1, s, len);
}

void outs(char *s)
{
  out(s, str_len(s));
}

void perm()
{
  _exit(100);
}

void temp()
{
  _exit(111);
}

void die_nomem()
{
  buffer_putsflush(buffer_2, "qmail-inject: fatal: out of memory\n");
  temp();
}

void die_invalid(stralloc *sa)
{
  buffer_putsflush(buffer_2, "qmail-inject: fatal: invalid header field: ");
  buffer_putflush(buffer_2, sa->s, sa->len);
  perm();
}

void die_qqt()
{
  buffer_putsflush(buffer_2, "qmail-inject: fatal: unable to run qmail-queue\n");
  temp();
}

void die_chdir()
{
  buffer_putsflush(buffer_2, "qmail-inject: fatal: internal bug\n");
  temp();
}

void die_read()
{
  if (errno == ENOMEM) die_nomem();
  buffer_putsflush(buffer_2, "qmail-inject: fatal: read error\n");
  temp();
}

void doordie(stralloc *sa, int r)
{
  if (r == 1) return;
  if (r == -1) die_nomem();
  buffer_putsflush(buffer_2, "qmail-inject: fatal: unable to parse this line:\n");
  buffer_putflush(buffer_2, sa->s, sa->len);
  perm();
}

GEN_ALLOC_typedef(saa, stralloc, sa, len, a);
GEN_ALLOC_readyplus(saa, stralloc, sa, len, a, i, n, x, 10, saa_readyplus);

static stralloc sauninit = {0};

saa savedh = {0};
saa hrlist = {0};
saa tocclist = {0};
saa hrrlist = {0};
saa reciplist = {0};
int flagresent;

void exitnicely()
{
  char *qqx;

  if (!flagqueue) buffer_flush(buffer_1);

  if (flagqueue) {
    int i;

    if (!stralloc_0(&sender)) die_nomem();
    qmail_from(&qqt, sender.s);

    for (i = 0; i < reciplist.len; ++i) {
      if (!stralloc_0(&reciplist.sa[i])) die_nomem();
      qmail_to(&qqt, reciplist.sa[i].s);
    }
    if (flagrh) {
      if (flagresent) {
        for (i = 0; i < hrrlist.len; ++i) {
          if (!stralloc_0(&hrrlist.sa[i])) die_nomem();
          qmail_to(&qqt, hrrlist.sa[i].s);
        }
      } else {
        for (i = 0; i < hrlist.len; ++i) {
          if (!stralloc_0(&hrlist.sa[i])) die_nomem();
          qmail_to(&qqt, hrlist.sa[i].s);
        }
      }
    }

    qqx = qmail_close(&qqt);
    if (*qqx) {
      if (*qqx == 'D') {
        buffer_puts(buffer_2, "qmail-inject: fatal: ");
        buffer_puts(buffer_2, qqx + 1);
        buffer_puts(buffer_2, "\n");
        buffer_flush(buffer_2);
        perm();
      } else {
        buffer_puts(buffer_2, "qmail-inject: fatal: ");
        buffer_puts(buffer_2, qqx + 1);
        buffer_puts(buffer_2, "\n");
        buffer_flush(buffer_2);
        temp();
      }
    }
  }

  _exit(0);
}

void savedh_append(stralloc *h)
{
  if (!saa_readyplus(&savedh, 1)) die_nomem();
  savedh.sa[savedh.len] = sauninit;
  if (!stralloc_copy(savedh.sa + savedh.len, h)) die_nomem();
  ++savedh.len;
}

void savedh_print()
{
  int i;

  for (i = 0; i < savedh.len; ++i) out(savedh.sa[i].s, savedh.sa[i].len);
}

stralloc defaultdomainbuf = {0};
token822_alloc defaultdomain = {0};
stralloc defaulthostbuf = {0};
token822_alloc defaulthost = {0};
stralloc plusdomainbuf = {0};
token822_alloc plusdomain = {0};

void rwroute(token822_alloc *addr)
{
  if (addr->t[addr->len - 1].type == TOKEN822_AT)
    while (addr->len)
      if (addr->t[--addr->len].type == TOKEN822_COLON) return;
}

void rwextraat(token822_alloc *addr)
{
  int i;

  if (addr->t[0].type == TOKEN822_AT) {
    --addr->len;
    for (i = 0; i < addr->len; ++i) addr->t[i] = addr->t[i + 1];
  }
}

void rwextradot(token822_alloc *addr)
{
  int i;

  if (addr->t[0].type == TOKEN822_DOT) {
    --addr->len;
    for (i = 0; i < addr->len; ++i) addr->t[i] = addr->t[i + 1];
  }
}

void rwnoat(token822_alloc *addr)
{
  int i;
  int shift;

  for (i = 0; i < addr->len; ++i)
    if (addr->t[i].type == TOKEN822_AT) return;
  shift = defaulthost.len;
  if (!token822_readyplus(addr, shift)) die_nomem();
  for (i = addr->len - 1; i >= 0; --i) addr->t[i + shift] = addr->t[i];

  addr->len += shift;

  for (i = 0; i < shift; ++i) addr->t[i] = defaulthost.t[shift - 1 - i];
}

void rwnodot(token822_alloc *addr)
{
  int i;
  int shift;

  for (i = 0; i < addr->len; ++i) {
    if (addr->t[i].type == TOKEN822_DOT) return;
    if (addr->t[i].type == TOKEN822_AT) break;
  }
  for (i = 0; i < addr->len; ++i) {
    if (addr->t[i].type == TOKEN822_LITERAL) return;
    if (addr->t[i].type == TOKEN822_AT) break;
  }
  shift = defaultdomain.len;
  if (!token822_readyplus(addr, shift)) die_nomem();

  for (i = addr->len - 1; i >= 0; --i) addr->t[i + shift] = addr->t[i];

  addr->len += shift;

  for (i = 0; i < shift; ++i) addr->t[i] = defaultdomain.t[shift - 1 - i];
}

void rwplus(token822_alloc *addr)
{
  int i;
  int shift;

  if (addr->t[0].type != TOKEN822_ATOM) return;
  if (!addr->t[0].slen) return;
  if (addr->t[0].s[addr->t[0].slen - 1] != '+') return;

  --addr->t[0].slen; /* remove + */

  shift = plusdomain.len;
  if (!token822_readyplus(addr, shift)) die_nomem();

  for (i = addr->len - 1; i >= 0; --i) addr->t[i + shift] = addr->t[i];

  addr->len += shift;

  for (i = 0; i < shift; ++i) addr->t[i] = plusdomain.t[shift - 1 - i];
}

void rwgeneric(token822_alloc *addr)
{
  if (!addr->len) return; /* don't rewrite <> */
  if (addr->len >= 2)
    if (addr->t[1].type == TOKEN822_AT)
      if (addr->t[0].type == TOKEN822_LITERAL)
        if (!addr->t[0].slen) /* don't rewrite <foo@[]> */
          return;

  rwroute(addr);
  if (!addr->len) return; /* <@foo:> -> <> */
  rwextradot(addr);
  if (!addr->len) return; /* <.> -> <> */
  rwextraat(addr);
  if (!addr->len) return; /* <@> -> <> */
  rwnoat(addr);
  rwplus(addr);
  rwnodot(addr);
}

int setreturn(token822_alloc *addr)
{
  if (!sender.s) {
    token822_reverse(addr);
    if (token822_unquote(&sender, addr) != 1) die_nomem();
    if (flaghackrecip)
      if (!stralloc_cats(&sender, "-@[]")) die_nomem();
    token822_reverse(addr);
  }
  return 1;
}

int rwreturn(token822_alloc *addr)
{
  rwgeneric(addr);
  setreturn(addr);
  return 1;
}

int rwsender(token822_alloc *addr)
{
  rwgeneric(addr);
  return 1;
}

void rwappend(token822_alloc *addr, saa *xl)
{
  token822_reverse(addr);
  if (!saa_readyplus(xl, 1)) die_nomem();
  xl->sa[xl->len] = sauninit;
  if (token822_unquote(&xl->sa[xl->len], addr) != 1) die_nomem();
  ++xl->len;
  token822_reverse(addr);
}

int rwhrr(token822_alloc *addr)
{
  rwgeneric(addr);
  rwappend(addr, &hrrlist);
  return 1;
}

int rwhr(token822_alloc *addr)
{
  rwgeneric(addr);
  rwappend(addr, &hrlist);
  return 1;
}

int rwtocc(token822_alloc *addr)
{
  rwgeneric(addr);
  rwappend(addr, &hrlist);
  rwappend(addr, &tocclist);
  return 1;
}

int htypeseen[H_NUM];
stralloc hfbuf = {0};
token822_alloc hfin = {0};
token822_alloc hfrewrite = {0};
token822_alloc hfaddr = {0};

void doheaderfield(stralloc *h)
{
  int htype;
  int (*rw)() = 0;

  htype = hfield_known(h->s, h->len);
  if (flagdeletefrom)
    if (htype == H_FROM) return;
  if (flagdeletemessid)
    if (htype == H_MESSAGEID) return;
  if (flagdeletesender)
    if (htype == H_RETURNPATH) return;

  if (htype)
    htypeseen[htype] = 1;
  else if (!hfield_valid(h->s, h->len))
    die_invalid(h);

  switch (htype) {
    case H_TO:
    case H_CC:              rw = rwtocc; break;
    case H_BCC:
    case H_APPARENTLYTO:    rw = rwhr; break;
    case H_R_TO:
    case H_R_CC:
    case H_R_BCC:           rw = rwhrr; break;
    case H_RETURNPATH:      rw = rwreturn; break;
    case H_SENDER:
    case H_FROM:
    case H_REPLYTO:
    case H_RETURNRECEIPTTO:
    case H_ERRORSTO:
    case H_R_SENDER:
    case H_R_FROM:
    case H_R_REPLYTO:       rw = rwsender; break;
  }

  if (rw) {
    doordie(h, token822_parse(&hfin, h, &hfbuf));
    doordie(h, token822_addrlist(&hfrewrite, &hfaddr, &hfin, rw));
    if (token822_unparse(h, &hfrewrite, LINELEN) != 1) die_nomem();
  }

  if (htype == H_BCC) return;
  if (htype == H_R_BCC) return;
  if (htype == H_RETURNPATH) return;
  if (htype == H_CONTENTLENGTH) return; /* some things are just too stupid */
  savedh_append(h);
}

void dobody(stralloc *h)
{
  out(h->s, h->len);
}

stralloc torecip = {0};
token822_alloc tr = {0};

void dorecip(char *s)
{
  if (!quote2(&torecip, s)) die_nomem();

  switch (token822_parse(&tr, &torecip, &hfbuf)) {
    case -1: die_nomem();
    case 0:
      buffer_puts(buffer_2, "qmail-inject: fatal: unable to parse address: ");
      buffer_puts(buffer_2, s);
      buffer_putsflush(buffer_2, "\n");
      perm();
  }
  token822_reverse(&tr);
  rwgeneric(&tr);
  rwappend(&tr, &reciplist);
}

stralloc defaultfrom = {0};
token822_alloc df = {0};

void defaultfrommake()
{
  char *fullname;
  fullname = env_get("QMAILNAME");
  if (!fullname) fullname = env_get("MAILNAME");
  if (!fullname) fullname = env_get("NAME");
  if (!token822_ready(&df, 20)) die_nomem();

  df.len = 0;
  df.t[df.len].type = TOKEN822_ATOM;
  df.t[df.len].s = "From";
  df.t[df.len].slen = 4;
  ++df.len;
  df.t[df.len].type = TOKEN822_COLON;
  ++df.len;

  if (fullname && !flagnamecomment) {
    df.t[df.len].type = TOKEN822_QUOTE;
    df.t[df.len].s = fullname;
    df.t[df.len].slen = str_len(fullname);
    ++df.len;
    df.t[df.len].type = TOKEN822_LEFT;
    ++df.len;
  }

  df.t[df.len].type = mailusertokentype;
  df.t[df.len].s = mailuser;
  df.t[df.len].slen = str_len(mailuser);
  ++df.len;

  if (mailhost) {
    df.t[df.len].type = TOKEN822_AT;
    ++df.len;
    df.t[df.len].type = TOKEN822_ATOM;
    df.t[df.len].s = mailhost;
    df.t[df.len].slen = str_len(mailhost);
    ++df.len;
  }

  if (fullname && !flagnamecomment) {
    df.t[df.len].type = TOKEN822_RIGHT;
    ++df.len;
  }

  if (fullname && flagnamecomment) {
    df.t[df.len].type = TOKEN822_COMMENT;
    df.t[df.len].s = fullname;
    df.t[df.len].slen = str_len(fullname);
    ++df.len;
  }

  if (token822_unparse(&defaultfrom, &df, LINELEN) != 1) die_nomem();
  doordie(&defaultfrom, token822_parse(&df, &defaultfrom, &hfbuf));
  doordie(&defaultfrom, token822_addrlist(&hfrewrite, &hfaddr, &df, rwsender));
  if (token822_unparse(&defaultfrom, &hfrewrite, LINELEN) != 1) die_nomem();
}

stralloc defaultreturnpath = {0};
token822_alloc drp = {0};
stralloc hackedruser = {0};
char strnum[FMT_ULONG];

void dodefaultreturnpath()
{
  if (!stralloc_copys(&hackedruser, mailruser)) die_nomem();

  if (flaghackmess) {
    if (!stralloc_cats(&hackedruser, "-")) die_nomem();
    if (!stralloc_catb(&hackedruser, strnum, fmt_ulong(strnum, (unsigned long)starttime))) die_nomem();
    if (!stralloc_cats(&hackedruser, ".")) die_nomem();
    if (!stralloc_catb(&hackedruser, strnum, fmt_ulong(strnum, (unsigned long)getpid()))) die_nomem();
  }
  if (flaghackrecip)
    if (!stralloc_cats(&hackedruser, "-")) die_nomem();

  if (!token822_ready(&drp, 10)) die_nomem();

  drp.len = 0;
  drp.t[drp.len].type = TOKEN822_ATOM;
  drp.t[drp.len].s = "Return-Path";
  drp.t[drp.len].slen = 11;
  ++drp.len;
  drp.t[drp.len].type = TOKEN822_COLON;
  ++drp.len;
  drp.t[drp.len].type = TOKEN822_QUOTE;
  drp.t[drp.len].s = hackedruser.s;
  drp.t[drp.len].slen = hackedruser.len;
  ++drp.len;

  if (mailrhost) {
    drp.t[drp.len].type = TOKEN822_AT;
    ++drp.len;
    drp.t[drp.len].type = TOKEN822_ATOM;
    drp.t[drp.len].s = mailrhost;
    drp.t[drp.len].slen = str_len(mailrhost);
    ++drp.len;
  }

  if (token822_unparse(&defaultreturnpath, &drp, LINELEN) != 1) die_nomem();
  doordie(&defaultreturnpath, token822_parse(&drp, &defaultreturnpath, &hfbuf));
  doordie(&defaultreturnpath, token822_addrlist(&hfrewrite, &hfaddr, &drp, rwreturn));
  if (token822_unparse(&defaultreturnpath, &hfrewrite, LINELEN) != 1) die_nomem();
}

int flagmft = 0;
stralloc mft = {0};
struct constmap mapmft;

void mft_init()
{
  char *x;
  int r;

  x = env_get("QMAILMFTFILE");
  if (!x) return;

  r = control_readfile(&mft, x, 0);
  if (r == -1) die_read(); /*XXX*/
  if (!r) return;

  if (!constmap_init(&mapmft, mft.s, mft.len, 0)) die_nomem();
  flagmft = 1;
}

void finishmft()
{
  int i;
  static stralloc sa = {0};
  static stralloc sa2 = {0};

  if (!flagmft) return;
  if (htypeseen[H_MAILFOLLOWUPTO]) return;

  for (i = 0; i < tocclist.len; ++i)
    if (constmap(&mapmft, tocclist.sa[i].s, tocclist.sa[i].len)) break;

  if (i == tocclist.len) return;

  outs("Mail-Followup-To: ");
  i = tocclist.len;
  while (i--) {
    if (!stralloc_copy(&sa, &tocclist.sa[i])) die_nomem();
    if (!stralloc_0(&sa)) die_nomem();
    if (!quote2(&sa2, sa.s)) die_nomem();
    out(sa2.s, sa2.len);
    if (i) outs(",\n  ");
  }
  outs("\n");
}

void finishheader()
{
  flagresent =
      htypeseen[H_R_SENDER] || htypeseen[H_R_FROM] || htypeseen[H_R_REPLYTO] || htypeseen[H_R_TO]
      || htypeseen[H_R_CC] || htypeseen[H_R_BCC] || htypeseen[H_R_DATE] || htypeseen[H_R_MESSAGEID];

  if (!sender.s) dodefaultreturnpath();

  if (!flagqueue) {
    static stralloc sa = {0};
    static stralloc sa2 = {0};

    if (!stralloc_copy(&sa, &sender)) die_nomem();
    if (!stralloc_0(&sa)) die_nomem();
    if (!quote2(&sa2, sa.s)) die_nomem();

    outs("Return-Path: <");
    out(sa2.s, sa2.len);
    outs(">\n");
  }

  /* could check at this point whether there are any recipients */
  if (flagqueue)
    if (qmail_open(&qqt) == -1) die_qqt();

  if (flagresent) {
    if (!htypeseen[H_R_DATE]) {
      if (!newfield_datemake(starttime)) die_nomem();
      outs("Resent-");
      out(newfield_date.s, newfield_date.len);
    }
    if (!htypeseen[H_R_MESSAGEID]) {
      if (!newfield_msgidmake(control_idhost.s, control_idhost.len, starttime)) die_nomem();
      outs("Resent-");
      out(newfield_msgid.s, newfield_msgid.len);
    }
    if (!htypeseen[H_R_FROM]) {
      defaultfrommake();
      outs("Resent-");
      out(defaultfrom.s, defaultfrom.len);
    }
    if (!htypeseen[H_R_TO] && !htypeseen[H_R_CC]) outs("Resent-Cc: recipient list not shown: ;\n");
  } else {
    if (!htypeseen[H_DATE]) {
      if (!newfield_datemake(starttime)) die_nomem();
      out(newfield_date.s, newfield_date.len);
    }
    if (!htypeseen[H_MESSAGEID]) {
      if (!newfield_msgidmake(control_idhost.s, control_idhost.len, starttime)) die_nomem();
      out(newfield_msgid.s, newfield_msgid.len);
    }
    if (!htypeseen[H_FROM]) {
      defaultfrommake();
      out(defaultfrom.s, defaultfrom.len);
    }
    if (!htypeseen[H_TO] && !htypeseen[H_CC]) outs("Cc: recipient list not shown: ;\n");
    finishmft();
  }

  savedh_print();
}

void getcontrols()
{
  static stralloc sa = {0};
  char *x;

  mft_init();

  if (chdir(auto_qmail) == -1) die_chdir();
  if (control_init() == -1) die_read();

  if (control_rldef(&control_defaultdomain, "control/defaultdomain", 1, "defaultdomain") != 1)
    die_read();
  x = env_get("QMAILDEFAULTDOMAIN");
  if (x)
    if (!stralloc_copys(&control_defaultdomain, x)) die_nomem();
  if (!stralloc_copys(&sa, ".")) die_nomem();
  if (!stralloc_cat(&sa, &control_defaultdomain)) die_nomem();
  doordie(&sa, token822_parse(&defaultdomain, &sa, &defaultdomainbuf));

  if (control_rldef(&control_defaulthost, "control/defaulthost", 1, "defaulthost") != 1) die_read();
  x = env_get("QMAILDEFAULTHOST");
  if (x)
    if (!stralloc_copys(&control_defaulthost, x)) die_nomem();
  if (!stralloc_copys(&sa, "@")) die_nomem();
  if (!stralloc_cat(&sa, &control_defaulthost)) die_nomem();
  doordie(&sa, token822_parse(&defaulthost, &sa, &defaulthostbuf));

  if (control_rldef(&control_plusdomain, "control/plusdomain", 1, "plusdomain") != 1) die_read();
  x = env_get("QMAILPLUSDOMAIN");
  if (x)
    if (!stralloc_copys(&control_plusdomain, x)) die_nomem();
  if (!stralloc_copys(&sa, ".")) die_nomem();
  if (!stralloc_cat(&sa, &control_plusdomain)) die_nomem();
  doordie(&sa, token822_parse(&plusdomain, &sa, &plusdomainbuf));

  if (control_rldef(&control_idhost, "control/idhost", 1, "idhost") != 1) die_read();
  x = env_get("QMAILIDHOST");
  if (x)
    if (!stralloc_copys(&control_idhost, x)) die_nomem();
}

#define RECIP_DEFAULT 1
#define RECIP_ARGS    2
#define RECIP_HEADER  3
#define RECIP_AH      4

int main(int argc, char **argv)
{
  int i;
  int opt;
  int recipstrategy;

  sig_pipeignore();

  starttime = now();

  qmopts = env_get("QMAILINJECT");
  if (qmopts) {
    while (*qmopts) {
      switch (*qmopts++) {
        case 'c': flagnamecomment = 1; break;
        case 's': flagdeletesender = 1; break;
        case 'f': flagdeletefrom = 1; break;
        case 'i': flagdeletemessid = 1; break;
        case 'r': flaghackrecip = 1; break;
        case 'm': flaghackmess = 1; break;
      }
    }
  }

  mailhost = env_get("QMAILHOST");
  if (!mailhost) mailhost = env_get("MAILHOST");
  mailrhost = env_get("QMAILSHOST");
  if (!mailrhost) mailrhost = mailhost;

  mailuser = env_get("QMAILUSER");
  if (!mailuser) mailuser = env_get("MAILUSER");
  if (!mailuser) mailuser = env_get("USER");
  if (!mailuser) mailuser = env_get("LOGNAME");
  if (!mailuser) mailuser = "anonymous";
  mailusertokentype = TOKEN822_ATOM;
  if (quote_need(mailuser, str_len(mailuser))) mailusertokentype = TOKEN822_QUOTE;
  mailruser = env_get("QMAILSUSER");
  if (!mailruser) mailruser = mailuser;

  for (i = 0; i < H_NUM; ++i) htypeseen[i] = 0;

  recipstrategy = RECIP_DEFAULT;
  flagqueue = 1;

  getcontrols();

  if (!saa_readyplus(&hrlist, 1)) die_nomem();
  if (!saa_readyplus(&tocclist, 1)) die_nomem();
  if (!saa_readyplus(&hrrlist, 1)) die_nomem();
  if (!saa_readyplus(&reciplist, 1)) die_nomem();

  while ((opt = getopt(argc, argv, "aAhHnNf:")) != opteof) {
    switch (opt) {
      case 'a': recipstrategy = RECIP_ARGS; break;
      case 'A': recipstrategy = RECIP_DEFAULT; break;
      case 'h': recipstrategy = RECIP_HEADER; break;
      case 'H': recipstrategy = RECIP_AH; break;
      case 'n': flagqueue = 0; break;
      case 'N': flagqueue = 1; break;
      case 'f':
        if (!quote2(&sender, optarg)) die_nomem();
        doordie(&sender, token822_parse(&envs, &sender, &envsbuf));
        token822_reverse(&envs);
        rwgeneric(&envs);
        token822_reverse(&envs);
        if (token822_unquote(&sender, &envs) != 1) die_nomem();
        break;
      case '?':
      default:  perm();
    }
  }

  argc -= optind;
  argv += optind;

  if (recipstrategy == RECIP_DEFAULT) recipstrategy = (*argv ? RECIP_ARGS : RECIP_HEADER);

  if (recipstrategy != RECIP_HEADER)
    while (*argv) dorecip(*argv++);

  flagrh = (recipstrategy != RECIP_ARGS);

  if (headerbody(buffer_0, doheaderfield, finishheader, dobody) == -1) die_read();

  exitnicely();
}