qmail-inject.c

Go to the documentation of this file.

#include <unistd.h>
#include "sig.h"
#include "buffer.h"
#include "genalloc.h"
#include "stralloc.h"
#include "getoptb.h"
#include "getln.h"
#include "alloc.h"
#include "str.h"
#include "fmt.h"
#include "hfield.h"
#include "token822.h"
#include "control.h"
#include "env.h"
#include "qmail.h"
#include "now.h"
#include "exit.h"
#include "error.h"
#include "quote.h"
#include "headerbody.h"
#include "auto_qmail.h"
#include "newfield.h"
#include "constmap.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;
 
static void out(char *s,int len)
{
  if (flagqueue) qmail_put(&qqt,s,len); 
  else buffer_putflush(buffer_1,s,len); 
}
 
static void outs(char *s) { out(s,str_len(s)); }
 
static void perm() { _exit(100); }
static void temp() { _exit(111); }
 
static void die_nomem() 
{
  buffer_putsflush(buffer_2,"qmail-inject: fatal: out of memory\n"); 
  temp(); 
}
static void die_invalid(stralloc *sa) 
{
  buffer_putsflush(buffer_2,"qmail-inject: fatal: invalid header field: ");
  buffer_putflush(buffer_2,sa->s,sa->len); 
  perm(); 
}
static void die_qqt() 
{
  buffer_putsflush(buffer_2,"qmail-inject: fatal: unable to run qmail-queue\n"); 
  temp(); 
}
static void die_chdir() 
{
  buffer_putsflush(buffer_2,"qmail-inject: fatal: internal bug\n"); 
  temp(); 
}
static void die_read() 
{
  if (errno == ENOMEM) die_nomem();
  buffer_putsflush(buffer_2,"qmail-inject: fatal: read error\n"); 
  temp(); 
}
static 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;
 
static 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);
}
 
static 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;
}
 
static 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};
 
static 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;
}
 
static 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];
   }
}
 
static 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];
  }
}
 
static 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];
}
 
static 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];
}
 
static 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];
}
 
static 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);
}
 
static 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;
}
 
static int rwreturn(token822_alloc *addr)
{
  rwgeneric(addr);
  setreturn(addr);
  return 1;
}
 
static int rwsender(token822_alloc *addr)
{
  rwgeneric(addr);
  return 1;
}
 
static 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);
}
 
static int rwhrr(token822_alloc *addr)
{ 
  rwgeneric(addr); 
  rwappend(addr,&hrrlist); 
  return 1; 
}
 
static int rwhr(token822_alloc *addr)
{ 
  rwgeneric(addr); 
  rwappend(addr,&hrlist); 
  return 1; 
}
 
static 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};
 
static 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);
}
 
static void dobody(stralloc *h)
{
  out(h->s,h->len);
}
 
stralloc torecip = {0};
token822_alloc tr = {0};
 
static 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};
 
static 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];
 
static 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;
 
static 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;
}
 
static 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");
}
 
static 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();
}
 
static 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 * const *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 = getoptb(argc,(char **)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();
}