ezmlm-warn.c

Go to the documentation of this file.

#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <unistd.h>
#include "direntry.h"
#include "readwrite.h"
#include "getln.h"
#include "buffer.h"
#include "stralloc.h"
#include "readclose.h"
#include "getoptb.h"
#include "getconf.h"
#include "byte.h"
#include "error.h"
#include "str.h"
#include "sig.h"
#include "now.h"
#include "datetime.h"
#include "fmt.h"
#include "cookie.h"
#include "qmail.h"
#include "errtxt.h"
#include "quote.h"
#include "open.h"
#include "scan.h"
#include "lock.h"
#include "ezcopy.h"
#include "mime.h"
#include "auto_version.h"
#include "hdr.h"
#include "idx.h"
#include "subscribe.h"
#include "logmsg.h"
#include "lockfile.h"
#include "ezmlm.h"
#include "errno.h"
 
#define WHO "ezmlm-warn"

 
static void die_usage() { logmsg(WHO,100,USAGE,"ezmlm-warn -dD -l secs -t days dir"); }
static void die_nomem() { logmsg(WHO,111,FATAL,ERR_NOMEM); }
 
stralloc outhost = {0};
stralloc outlocal = {0};
 
stralloc key = {0};
stralloc mailinglist = {0};
stralloc digdir = {0};
stralloc charset = {0};
char hboundary[COOKIE];
 
buffer bo;
char outbuf[16];
 
unsigned long when;
char *dir;
char *workdir;
int flagdig = 0;
char flagcd = '\0';          /* default: don't use transfer encoding */
stralloc fn = {0};
stralloc bdname = {0};
stralloc fnlasth = {0};
stralloc fnlastd = {0};
stralloc lasth = {0};
stralloc lastd = {0};
struct stat st;
 
void die_read() { logmsg(WHO,111,FATAL,B(ERR_READ,fn.s)); }
 
void makedir(char *s)
{
  if (mkdir(s,0755) == -1)
    if (errno != EEXIST)
      logmsg(WHO,111,FATAL,B(ERR_CREATE,s));
}
 
char inbuf[1024];
buffer bi;
char textbuf[1024];
buffer bt;
 
stralloc addr = {0};
char strnum[FMT_ULONG];
char hash[COOKIE];
stralloc fnhash = {0};
stralloc quoted = {0};
stralloc line = {0};
stralloc qline = {0};
 
struct qmail qq;
ssize_t qqwrite(int fd,char *buf,unsigned int len)
{
  qmail_put(&qq,buf,len);
  return len;
}
char qqbuf[1];
buffer bq = BUFFER_INIT(qqwrite,-1,qqbuf,sizeof(qqbuf));
 
void code_qput(char *s,unsigned int n)
{
    if (!flagcd)
      qmail_put(&qq,s,n);
    else {
      if (flagcd == 'B')
        encode_b64(s,n,&qline,0);
      else
        encode_qp(s,n,&qline);
      qmail_put(&qq,qline.s,qline.len);
    }
}
 
void doit(int flagw)
{
  unsigned int i;
  int fd;
  int match;
  int fdhash;
  const char *err;
 
  fd = open_read(fn.s);
  if (fd == -1) die_read();
  buffer_init(&bi,buffer_unixread,fd,inbuf,sizeof(inbuf));
 
  if (getln(&bi,&addr,&match,'\0') == -1) die_read();
  if (!match) { close(fd); return; }
  if (!issub(workdir,addr.s,(char *) 0)) { 
     close(fd);
     /*XXX*/unlink(fn.s); 
     return; 
  }
  cookie(hash,"",0,"",addr.s,"");
  if (!stralloc_copys(&fnhash,workdir)) die_nomem();
  if (!stralloc_cats(&fnhash,"/bounce/h/")) die_nomem();
  if (!stralloc_catb(&fnhash,hash,1)) die_nomem();
  if (!stralloc_cats(&fnhash,"/h")) die_nomem();
  if (!stralloc_catb(&fnhash,hash+1,COOKIE-1)) die_nomem();
  if (!stralloc_0(&fnhash)) die_nomem();
 
  if (qmail_open(&qq,(stralloc *) 0) == -1)
    logmsg(WHO,111,FATAL,ERR_QMAIL_QUEUE);
 
  hdr_add2("Mailing-List: ",mailinglist.s,mailinglist.len);
  if (getconf_line(&line,"listid",0,dir))
    hdr_add2("\nList-ID: ",line.s,line.len);
  hdr_datemsgid(now());
  if (flagcd) {
    if (!stralloc_0(&line)) die_nomem();
  }
  hdr_from("-help");
  if (!quote2(&quoted,addr.s)) die_nomem();
  hdr_add2("To: ",quoted.s,quoted.len);
                                       /* to accomodate transfer-encoding */
  hdr_mime(flagcd ? CTYPE_MULTIPART : CTYPE_TEXT);
  hdr_listsubject1(flagw ? "probe from " : "warning from ");
 
  if (flagcd) {                        /* first part for QP/base64 multipart msg */
    hdr_boundary(0);
    hdr_ctype(CTYPE_TEXT);
    hdr_transferenc();
  } else
    qmail_puts(&qq,"\n");
 
  ezcopy(&qq,"text/top",flagcd);
  ezcopy(&qq,flagw ? "text/bounce-probe" : "text/bounce-warn",flagcd);
 
  if (!flagw) {
    if (flagdig)
      ezcopy(&qq,"text/dig-bounce-num",flagcd);
    else
      ezcopy(&qq,"text/bounce-num",flagcd);
    if (!flagcd) {
      fdhash = open_read(fnhash.s);
      if (fdhash == -1) {
        if (errno != ENOENT)
          logmsg(WHO,111,FATAL,B(ERR_OPEN,fnhash.s));
      } else {
        buffer_init(&bt,buffer_unixread,fdhash,textbuf,sizeof(textbuf));
        for(;;) {
          if (getln(&bt,&line,&match,'\n') == -1)
            logmsg(WHO,111,FATAL,B(ERR_READ,fnhash.s));
          if (!match) break;
          code_qput(line.s,line.len);
        }
      }
      close(fdhash);
    } else {
      if (!stralloc_copys(&line,"")) die_nomem();
      if (openreadclose(fnhash.s,&line,256) < 0)
        logmsg(WHO,111,FATAL,B(ERR_OPEN,fnhash.s));
      code_qput(line.s,line.len);
    }
  }
 
  ezcopy(&qq,"text/bounce-bottom",flagcd);
  if (flagcd) {
    if (flagcd == 'B') {
      encode_b64("",0,&line,2);
      qmail_put(&qq,line.s,line.len);                 /* flush */
    }
    hdr_boundary(0);
    hdr_ctype(CTYPE_MESSAGE);
    qmail_puts(&qq,"\n");
  }
  if (buffer_copy(&bq,&bi) < 0) die_read();
  close(fd);
 
  if (flagcd)                                         /* end multipart/mixed */
    hdr_boundary(1);
 
  strnum[fmt_ulong(strnum,when)] = 0;
  cookie(hash,key.s,key.len,strnum,addr.s,flagw ? "P" : "W");
  if (!stralloc_copy(&line,&outlocal)) die_nomem();
  if (!stralloc_cats(&line,flagw ? "-return-probe-" : "-return-warn-"))
    die_nomem();
  if (!stralloc_cats(&line,strnum)) die_nomem();
  if (!stralloc_cats(&line,".")) die_nomem();
  if (!stralloc_catb(&line,hash,COOKIE)) die_nomem();
  if (!stralloc_cats(&line,"-")) die_nomem();
  i = str_chr(addr.s,'@');
  if (!stralloc_catb(&line,addr.s,i)) die_nomem();
  if (addr.s[i]) {
    if (!stralloc_cats(&line,"=")) die_nomem();
    if (!stralloc_cats(&line,addr.s + i + 1)) die_nomem();
  }
  if (!stralloc_cats(&line,"@")) die_nomem();
  if (!stralloc_cat(&line,&outhost)) die_nomem();
  if (!stralloc_0(&line)) die_nomem();
  qmail_from(&qq,line.s);
 
  qmail_to(&qq,addr.s);
  if (*(err = qmail_close(&qq)) != '\0')
    logmsg(WHO,111,FATAL,B(ERR_TMP_QMAIL_QUEUE,err + 1));
 
  strnum[fmt_ulong(strnum,qmail_qp(&qq))] = 0;
  logmsg(WHO,0,INFO,B("qp ",strnum));
 
  if (!flagw) {
    if (unlink(fnhash.s) == -1)
      if (errno != ENOENT)
        logmsg(WHO,111,FATAL,B(ERR_DELETE,fnhash.s));
  }
  if (unlink(fn.s) == -1)
    logmsg(WHO,111,FATAL,B(ERR_DELETE,fn.s));
}
 
int main(int argc,char **argv)
{
  DIR *bouncedir, *bsdir, *hdir;
  direntry *d, *ds;
  unsigned long bouncedate;
  unsigned long bouncetimeout = BOUNCE_TIMEOUT;
  unsigned long lockout = 0L;
  unsigned long ld;
  unsigned long ddir, dfile;
  int fdlock, fd;
  int opt;
  char ch;
 
  umask(022);
  sig_pipeignore();
  when = (unsigned long) now();
  while ((opt = getoptb(argc,argv,"dDl:t:vV")) != opteof)
    switch(opt) {
      case 'd': flagdig = 1; break;
      case 'D': flagdig = 0; break;
      case 'l': if (optarg) {    /* lockout in seconds */
                  scan_ulong(optarg,&lockout);
                }
                break;
      case 't': if (optarg) {    /* bouncetimeout in days */
                  scan_ulong(optarg,&bouncetimeout);
                  bouncetimeout *= 3600L * 24L;
                }
                break;
      case 'v':
      case 'V': logmsg(WHO,0,VERSION,auto_version);
      default:  die_usage();
    }
  dir = argv[optind];
  if (!dir) die_usage();
  if (chdir(dir) == -1)
    logmsg(WHO,111,FATAL,B(ERR_SWITCH,dir));
  if (flagdig) {
    if (!stralloc_copys(&digdir,dir)) die_nomem();
    if (!stralloc_cats(&digdir,"/digest")) die_nomem();
    if (!stralloc_0(&digdir)) die_nomem();
    workdir = digdir.s;
  } else
    workdir = dir;
 
  if (!stralloc_copys(&fnlastd,workdir)) die_nomem();
  if (!stralloc_cats(&fnlastd,"/bounce/lastd")) die_nomem();
  if (!stralloc_0(&fnlastd)) die_nomem();
  if (openreadclose(fnlastd.s,&lastd,16) == -1)       /* last time d was scanned */
      logmsg(WHO,111,FATAL,B(ERR_READ,fnlastd.s));
  if (!stralloc_0(&lastd)) die_nomem();
  scan_ulong(lastd.s,&ld);
  if (!lockout)
    lockout = bouncetimeout / 50;                     /* 5.6 h for default timeout */
  if (ld + lockout > when && ld < when)
    _exit(0);                                         /* exit silently. */ 
                                                      /*Second check is to prevent lockup if lastd gets corrupted */
 
  if (!stralloc_copy(&fnlasth,&fnlastd)) die_nomem();
  fnlasth.s[fnlasth.len - 2] = 'h';                   /* bad, but feels good ... */
 
  switch (openreadclose("key",&key,32)) {
    case -1: logmsg(WHO,111,FATAL,B(ERR_READ,"/key: ",dir));
    case 0:  logmsg(WHO,100,FATAL,B(dir,"/key",ERR_NOEXIST));
  }
  getconf_line(&outhost,"outhost",1,dir);
  getconf_line(&outlocal,"outlocal",1,dir);
  if (flagdig)
    if (!stralloc_cats(&outlocal,"-digest")) die_nomem();
  getconf_line(&mailinglist,"mailinglist",1,dir);
  if (getconf_line(&charset,"charset",0,dir)) {
    if (charset.len >= 2 && charset.s[charset.len - 2] == ':') {
      if (charset.s[charset.len - 1] == 'B' ||
        charset.s[charset.len - 1] == 'Q') {
        flagcd = charset.s[charset.len - 1];
        charset.s[charset.len - 2] = '\0';
      }
    }
  } else
    if (!stralloc_copys(&charset,TXT_DEF_CHARSET)) die_nomem();
  if (!stralloc_0(&charset)) die_nomem();
 
  set_cpoutlocal(&outlocal);                          /* for copy */
  set_cpouthost(&outhost);                            /* for copy */
  ddir = when / 10000;
  dfile = when - 10000 * ddir;
 
  if (!stralloc_copys(&line,workdir)) die_nomem();
  if (!stralloc_cats(&line,"/lockbounce")) die_nomem();
  if (!stralloc_0(&line)) die_nomem();
  fdlock = lockfile(line.s);
 
  if (!stralloc_copys(&line,workdir)) die_nomem();
  if (!stralloc_cats(&line,"/bounce/d")) die_nomem();
  if (!stralloc_0(&line)) die_nomem();
  bouncedir = opendir(line.s);
  if (!bouncedir)
    if (errno != ENOENT)
      logmsg(WHO,111,FATAL,B(ERR_OPEN,line.s));
    else
      _exit(0);                                       /* no bouncedir - no bounces! */
 
  while ((d = readdir(bouncedir))) {                  /* dxxx/ */
    if (str_equal(d->d_name,".")) continue;
    if (str_equal(d->d_name,"..")) continue;
 
    scan_ulong(d->d_name,&bouncedate);
 
    /* since we do entire dir, we do files that are not old enough. */
    /* to not do this and accept a delay of 10000s (2.8h) of the oldest */
    /* bounce we add to bouncedate. We don't if bouncetimeout=0 so that */
    /* that setting still processes _all_ bounces. */
 
    if (bouncetimeout) ++bouncedate;
    if (when >= bouncedate * 10000 + bouncetimeout) {
      if (!stralloc_copys(&bdname,workdir)) die_nomem();
      if (!stralloc_cats(&bdname,"/bounce/d/")) die_nomem();
      if (!stralloc_cats(&bdname,d->d_name)) die_nomem();
      if (!stralloc_0(&bdname)) die_nomem();
      bsdir = opendir(bdname.s);
      if (!bsdir) {
        if (errno != ENOTDIR)
          logmsg(WHO,111,FATAL,B(ERR_OPEN,bdname.s,"y "));
    else {                                            /* leftover nnnnn_dmmmmm file */
      if (unlink(bdname.s) == -1)
        logmsg(WHO,111,FATAL,B(ERR_DELETE,bdname.s));
      continue;
    }
      }
      while ((ds = readdir(bsdir))) {                 /* dxxxx/yyyy */
    if (str_equal(ds->d_name,".")) continue;
    if (str_equal(ds->d_name,"..")) continue;
    if (!stralloc_copy(&fn,&bdname)) die_nomem();     /* '\0' at end */
      fn.s[fn.len - 1] = '/';
    if (!stralloc_cats(&fn,ds->d_name)) die_nomem();
    if (!stralloc_0(&fn)) die_nomem();
    if ((ds->d_name[0] == 'd') || (ds->d_name[0] == 'w'))
      doit(ds->d_name[0] == 'w');
        else                                          /* other stuff is junk */
      if (unlink(fn.s) == -1)
        logmsg(WHO,111,FATAL,B(ERR_DELETE,fn.s));
      }
      closedir(bsdir);
      if (rmdir(bdname.s) == -1)                      /* the directory itself */
      if (errno != ENOENT)
       logmsg(WHO,111,FATAL,B(ERR_DELETE,bdname.s));
    }
  }
  closedir(bouncedir);
 
  if (!stralloc_copy(&line,&fnlastd)) die_nomem();
  line.s[line.len - 2] = 'D';
  fd = open_trunc(line.s);                            /* write lastd. Do safe */
                                                      /* since we read before lock*/
  if (fd == -1) 
    logmsg(WHO,111,FATAL,B(ERR_OPEN,line.s));
  buffer_init(&bo,buffer_unixwrite,fd,outbuf,sizeof(outbuf));
  if (buffer_put(&bo,strnum,fmt_ulong(strnum,when)) == -1)
    logmsg(WHO,111,FATAL,B(ERR_WRITE,line.s));
  if (buffer_put(&bo,"\n",1) == -1)                   /* prettier */
    logmsg(WHO,111,FATAL,B(ERR_WRITE,line.s));
  if (buffer_flush(&bo) == -1)
    logmsg(WHO,111,FATAL,B(ERR_FLUSH,line.s));
  if (fsync(fd) == -1)
    logmsg(WHO,111,FATAL,B(ERR_SYNC,line.s));
  if (close(fd) == -1)
    logmsg(WHO,111,FATAL,B(ERR_CLOSE,line.s));
 
  if (rename(line.s,fnlastd.s) == -1)
    logmsg(WHO,111,FATAL,B(ERR_MOVE,fnlastd.s));
 
                /* no need to do h dir cleaning more than */
                /* once per 1-2 days (17-30 days for all) */
 
  if (stat(fnlasth.s,&st) == -1) {
    if (errno != ENOENT)
      logmsg(WHO,111,FATAL,B(ERR_STAT,fnlasth.s));
  } else if (when < st.st_mtime + 100000 && when > st.st_mtime)
    _exit(0);                                         /* 2nd comp to guard against corruption */
 
  if (openreadclose(fnlasth.s,&lasth,16) == -1)       /* last h cleaned */
      logmsg(WHO,111,FATAL,B(ERR_READ,fnlasth.s));
  if (!stralloc_0(&lasth)) die_nomem();
 
  ch = lasth.s[0];                                    /* clean h */
  if (ch >= 'a' && ch <= 'o')
    ++ch;
  else
    ch = 'a';
  lasth.s[0] = ch;
  if (!stralloc_copys(&line,workdir)) die_nomem();
  if (!stralloc_cats(&line,"/bounce/h/")) die_nomem();
  if (!stralloc_catb(&line,lasth.s,1)) die_nomem();
  if (!stralloc_0(&line)) die_nomem();
  hdir = opendir(line.s);                             /* clean ./h/xxxxxx */
 
  if (!hdir) {
    if (errno != ENOENT)
    logmsg(WHO,111,FATAL,B(ERR_OPEN,line.s));
  } else {
    while ((d = readdir(hdir))) {
      if (str_equal(d->d_name,".")) continue;
      if (str_equal(d->d_name,"..")) continue;
      if (!stralloc_copys(&fn,line.s)) die_nomem();
      if (!stralloc_append(&fn,"/")) die_nomem();
      if (!stralloc_cats(&fn,d->d_name)) die_nomem();
      if (!stralloc_0(&fn)) die_nomem();
      if (stat(fn.s,&st) == -1) {
        if (errno == ENOENT) continue;
          logmsg(WHO,111,FATAL,B(ERR_STAT,fn.s));
      }
      if (when > st.st_mtime + 3 * bouncetimeout)
        if (unlink(fn.s) == -1)
          logmsg(WHO,111,FATAL,B(ERR_DELETE,fn.s));
    }
    closedir(hdir);
  }
 
  fd = open_trunc(fnlasth.s);                         /* write lasth */
  if (fd == -1) 
    logmsg(WHO,111,FATAL,B(ERR_OPEN,fnlasth.s));
 
  buffer_init(&bo,buffer_unixwrite,fd,outbuf,sizeof(outbuf));
  if (buffer_put(&bo,lasth.s,1) == -1)
    logmsg(WHO,111,FATAL,B(ERR_OPEN,fnlasth.s));
  if (buffer_put(&bo,"\n",1) == -1)                   /* prettier */
    logmsg(WHO,111,FATAL,B(ERR_OPEN,fnlasth.s));
  if (buffer_flush(&bo) == -1)
    logmsg(WHO,111,FATAL,B(ERR_FLUSH,fnlasth.s));
 
  close(fd);                                          /* no big loss. No reason to flush/sync */
                                                      /* See check of ld above to guard against */
                                                      /* it being corrupted and > when */
  closesql();
  _exit(0);
 
  return 0;
}