ezmlm-make.c

Go to the documentation of this file.

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <unistd.h>
#include "getoptb.h"
#include "stralloc.h"
#include "exit.h"
#include "readwrite.h"
#include "open.h"
#include "buffer.h"
#include "str.h"
#include "auto_bin.h"
#include "getln.h"
#include "error.h"
#include "lock.h"
#include "errtxt.h"
#include "idx.h"
#include "auto_version.h"
#include "logmsg.h"
#include "lockfile.h"
#include "case.h"
 
#define WHO "ezmlm-make"

 
#define NO_FLAGS ('z' - 'a' + 1)
 
const char *defflags = "ap";           /* archived list -a */
int flags[NO_FLAGS];                   /* holds flags */
 
const char *popt[10];
stralloc dotplus = {0};
stralloc dirplus = {0};
stralloc line = {0};
 
static void die_usage() { logmsg(WHO,100,USAGE,"ezmlm-make [-+] [ -a..zA..Z03..9 ] dir dot local host"); }
static void die_nomem() { logmsg(WHO,111,FATAL,ERR_NOMEM); }
 
stralloc cmdline = {0};
stralloc outline = {0};
buffer bi;
char textbuf[1024];
 
stralloc fname = {0};        /* file name */
stralloc oldfname = {0};     /* file name from prevoius tag */
stralloc dname = {0};        /* directory name */
stralloc lname = {0};        /* link name */
stralloc template = {0};     /* template file name */
stralloc ext1 = {0};         /* dot = dir/.qmail-ext1-ext2-list */
stralloc ext2 = {0};
stralloc flag = {0};
stralloc key = {0};
struct timeval tv;
char sz[2] = "?";
 
void keyadd(unsigned long u)
{
  char ch;
  ch = (char) u; if (!stralloc_append(&key,&ch)) die_nomem(); u >>= 8;
  ch = (char) u; if (!stralloc_append(&key,&ch)) die_nomem(); u >>= 8;
  ch = (char) u; if (!stralloc_append(&key,&ch)) die_nomem(); u >>= 8;
  ch = (char) u; if (!stralloc_append(&key,&ch)) die_nomem();
}
 
void keyaddtime()
{
  gettimeofday(&tv,(struct timezone *) 0);
  keyadd(tv.tv_usec);
}
 
char *dir;
char *dot;
char *local = (char *) 0;
char *host = (char *) 0;
 
void dirplusmake(char *slash)
{
  if (!stralloc_copys(&dirplus,dir)) die_nomem();
  if (!stralloc_cats(&dirplus,slash)) die_nomem();
  if (!stralloc_0(&dirplus)) die_nomem();
}
 
void linkdotdir(const char *dash,char *slash)
{
  if (!stralloc_copys(&dotplus,dot)) die_nomem();
  if (!stralloc_cats(&dotplus,dash)) die_nomem();
  if (!stralloc_0(&dotplus)) die_nomem();
  dirplusmake(slash);
  if (flags['e' - 'a'])
    if (unlink(dotplus.s) == -1)
      if (errno != ENOENT)
        logmsg(WHO,111,FATAL,B(ERR_DELETE,dotplus.s));
  if (symlink(dirplus.s,dotplus.s) == -1)
    logmsg(WHO,111,FATAL,B(ERR_CREATE,dotplus.s));
  keyaddtime();
}
 
void dcreate(char *slash)
{
  dirplusmake(slash);
  if (mkdir(dirplus.s,0755) == -1)
    if ((errno != EEXIST) || !flags['e' - 'a'])
      logmsg(WHO,111,FATAL,B(ERR_CREATE,dirplus.s));
  keyaddtime();
}
 
buffer bo;
char outbuf[BUFFER_OUTSIZE];
 
void f_open(char *slash)
{
  int fd;
 
  dirplusmake(slash);
  fd = open_trunc(dirplus.s);
  if (fd == -1)
    logmsg(WHO,111,FATAL,B(ERR_READ,dirplus.s));
 
  buffer_init(&bo,buffer_unixwrite,fd,outbuf,sizeof(outbuf));
}
 
void f_put(const char *buf,unsigned int len)
{
  if (buffer_put(&bo,buf,len) == -1)
    logmsg(WHO,111,FATAL,B(ERR_WRITE,dirplus.s));
}
void f_puts(char *buf)
{
  if (buffer_puts(&bo,buf) == -1)
    logmsg(WHO,111,FATAL,B(ERR_WRITE,dirplus.s));
}
 
void f_close()
{
  if (buffer_flush(&bo) == -1)
    logmsg(WHO,111,FATAL,B(ERR_FLUSH,dirplus.s));
  if (fsync(bo.fd) == -1)
    logmsg(WHO,111,FATAL,B(ERR_SYNC,dirplus.s));
  if (close(bo.fd) == -1)              /* NFS stupidity */
    logmsg(WHO,111,FATAL,B(ERR_CLOSE,dirplus.s));
  keyaddtime();
}
 
void frm(char *slash)
{
  dirplusmake(slash);
  if (unlink(dirplus.s) == -1)
    if (errno != ENOENT)
      logmsg(WHO,111,FATAL,B(ERR_DELETE,dirplus.s));
}
 
 
int main(int argc,char **argv)
{
  unsigned long euid;
  int opt;
  int flagdo;
  int flagnot;
  int flagover;
  int flagnotexist = 0;
  int flagforce = 0;
  int flagforce_p = 0;
  int usecfg = 0;
  int match;
  unsigned int next, i, j;
  int last;
  unsigned int slpos,hashpos,pos;
  int fdin, fdlock, fdtmp;
  char *p;
  char *oldflags = (char *) 0;
  char *code = (char *) 0;
  const char *cfname = (char *) 0;     /* config file if spec as -C cf_file */
  unsigned char ch;
 
  keyadd((unsigned long) getpid());
  keyadd((unsigned long) getppid());
  euid = (unsigned long) geteuid();
  keyadd(euid);
  keyadd((unsigned long) getgid());
  gettimeofday(&tv,(struct timezone *) 0);
  keyadd(tv.tv_sec);
 
  (void) umask(077);         /* flags with defined use. vV for version. Others free */
 
  for (pos = 0; pos < (unsigned int) NO_FLAGS; pos++) {
    flags[pos] = 0;
  }
  for (pos = 0; pos < 10; popt[pos++] = (char *) 0);
 
  while ((opt = getoptb(argc,(char **)argv,
   "+aAbBcC:dDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0:3:4:5:6:7:8:9:")) != opteof) {
    if (opt == 'v' || opt == 'V')
      logmsg(WHO,0,VERSION,auto_version);
    if (opt == 'C')                    /* treat this like nl switch to allow override of -c */
      cfname = optarg; 
 
    if (opt >= 'a' && opt <= 'z') {
      flags[opt - 'a'] = 3;            /* Dominant "set" */
      if (opt == 'e') flagforce++;     /* two 'e' => ignore 'E' */
    } else if (opt >= 'A' && opt <= 'Z') {
      flags[opt - 'A'] = 2;            /* Dominant "unset" */
    } else if (opt >= '0' && opt <= '9') {
      popt[opt - '0'] = optarg;
    } else if (opt == '+') {
      flagforce_p++;                   /* two '+' => ignore 'E' */
      flags['e' - 'a'] = 3;            /* -+ implies -e */
      usecfg = 1;
    } else
      die_usage();
  }
  argv += optind;
 
  if (flagforce_p > 1 || flagforce > 1)
    flagforce = 1;
  else
    flagforce = 0;
 
  if (!(dir = *argv++)) die_usage();
  if (dir[0] != '/') logmsg(WHO,100,FATAL,B(ERR_SLASH,dir));
  if (dir[str_chr(dir,'\'')]) logmsg(WHO,100,FATAL,ERR_QUOTE); 
  if (dir[str_chr(dir,'\n')]) logmsg(WHO,100,FATAL,ERR_NEWLINE); 
 
  if (flags['e' - 'a'] & 1) {          /* lock for edit */
    dirplusmake("/lock");
    fdlock = lockfile(dirplus.s);
 
    dirplusmake("/config");            /* for edit, try to get args from dir/config */
    if ((fdin = open_read(dirplus.s)) == -1) {
      if (errno != ENOENT) { logmsg(WHO,111,FATAL,B(ERR_READ,dirplus.s)); }
    } else {
      buffer_init(&bi,buffer_unixread,fdin,textbuf,sizeof(textbuf));
 
      for (;;) {
        if (getln(&bi,&line,&match,'\n') == -1) 
          logmsg(WHO,111,FATAL,B(ERR_READ,dirplus.s)); 
        if (!match) break;
        if (line.s[0] == '#') continue;
        if (line.len == 1) break;
        if (line.s[1] != ':') break;
        line.s[line.len - 1] = '\0';
        if (!stralloc_cat(&cmdline,&line)) die_nomem();
      }
      close(fdin);
 
      pos = 0;
      while (pos < cmdline.len) {
        ch = cmdline.s[pos];
        pos += 2;
 
        switch (ch) {
          case 'X': if (euid && !flags['c' - 'a'] && (!cfname))
                      cfname = cmdline.s + pos;      /* cmdline overrides */
                    break;                           /* for safety: ignore if root */
          case 'T': dot = cmdline.s + pos; break;
          case 'L': local = cmdline.s + pos; break;
          case 'H': host = cmdline.s + pos; break;
          case 'C': code = cmdline.s + pos; break;
          case 'D': break;                           /* no reason to check */
          case 'F': oldflags = cmdline.s + pos; break;
          default: if (ch == '0' || (ch >= '3' && ch <= '9')) {
                     if (usecfg && !popt[ch - '0'])
                       popt[ch - '0'] = cmdline.s + pos;
                   } else
                     logmsg(WHO,111,FATAL,B(ERR_SYNTAX,dirplus.s," ",cmdline.s + pos));
                   break;
        }
        pos += str_len(cmdline.s + pos) + 1;
      }
    }
  }
 
  if ((p = *argv++) != 0) {
    dot = p;
    if ((p = *argv++) != 0) {
      if (!local || str_diff(local,p))
        flagforce = 1;                 /* must rewrite if list name changed */
      local = p;
      if ((p = *argv++) != 0) {
        if (!host || str_diff(host,p))
        flagforce = 1;                 /* must rewrite if list name changed */
        host = p;
        if ((p = *argv++) != 0) {
          code = p;
        }
      }
    }
  }
 
  if (!dot || !local || !host) die_usage();
  if (dot[0] != '/') logmsg(WHO,100,FATAL,B(ERR_SLASH,dot)); /* force absolute dot */
 
            /* use flags from config, overridden with new values */
            /* if there are old flags, we're in "edit" and "-+" */
            /* Previous versions only wrote _set_ flags to */
            /* to DIR/config. We need to make sure that we */
            /* don't apply the defaults for non-specified ones! */
 
  if (usecfg && oldflags && flags['e' - 'a']) {
    while ((ch = *(oldflags++))) {
      if (ch >= 'a' && ch <= 'z') {    /* unset flags ignored */
        if (ch != 'e')
          if (!flags[ch - 'a'])        /* cmd line overrides */
        flags[ch - 'a'] = 1;
      }
    }
  }
 
  if (!usecfg) {                       /* apply defaults */
    while (( ch = *(defflags++))) {    /* gets used up! */
      if (ch >= 'a' && ch <= 'z') {    /* defensive! */
    if (!flags[ch - 'a'])              /* cmdline still overrides */
      flags[ch - 'a'] = 1;
      }
    }
  }
 
  for (pos = 0; pos < (unsigned int) NO_FLAGS; pos++) {    /* set real flags */
    if (flags[pos] & 2)                /* 2 = "dominant" 0 */
      flags[pos] = flags[pos] & 1;     /* 3 = "dominant" 1 */
  }
 
  if (local[str_chr(local,'\n')]) logmsg(WHO,100,FATAL,ERR_NEWLINE); 
  if (host[str_chr(host,'\n')]) logmsg(WHO,100,FATAL,ERR_NEWLINE); 
 
  /* build 'f' for <#F#> */
 
  if (!stralloc_ready(&flag,28)) die_nomem();
  if (!stralloc_copys(&flag,"-")) die_nomem();
  for (ch = 0; ch <= 'z' - 'a'; ch++) {          /* build string with flags */
    if (flags[ch])
      sz[0] = 'a' + ch;
    else
      sz[0] = 'A' + ch;
    if (!stralloc_append(&flag,sz)) die_nomem();
  }
 
  fdin = -1;       /* aboure failure for .ezmlmrc in case flags['c'-'a'] = 0 */
  slpos = str_len(dot);
  while ((--slpos > 0) && dot[slpos] != '/');
  if (dot[slpos] == '/') {
    if (!stralloc_copyb(&template,dot,slpos + 1)) die_nomem();         /* dot dir */
    slpos += str_chr(dot+slpos,'-');
    if (dot[slpos]) {
      slpos++;
      pos = slpos + str_chr(dot+slpos,'-');
      if (dot[pos]) {
        if (!stralloc_copyb(&ext1,dot + slpos,pos - slpos)) die_nomem();
        pos++;
        slpos = pos + str_chr(dot+pos,'-');
        if (dot[slpos])
          if (!stralloc_copyb(&ext2,dot + pos,slpos - pos)) die_nomem();
      }
    }
  }
  if (!stralloc_0(&ext1)) die_nomem();
  if (!stralloc_0(&ext2)) die_nomem();
  popt[1] = ext1.s;
  popt[2] = ext2.s;
 
  /* if 'c', template already has the dot directory. If 'C', cfname */
  /* (if exists and != '') points to the file name to use instead. */
 
  if (flags['c' - 'a'] || (cfname && *cfname)) {
    if (!flags['c' - 'a']) {             /* i.e. there is a cfname specified */
      if (!stralloc_copys(&template,cfname)) die_nomem();
    } else
      if (!stralloc_cats(&template,TXT_DOTEZMLMRC)) die_nomem();
  if (!stralloc_0(&template)) die_nomem();
  if ((fdin = open_read(template.s)) == -1)
    if (errno != ENOENT)
      logmsg(WHO,111,FATAL,B(ERR_OPEN,template.s));
    else
      logmsg(WHO,100,FATAL,B(template.s,ERR_NOEXIST));
  } else {                                       /* /etc/ezmlmrc */
    if (!stralloc_copys(&template,TXT_ETC_EZMLMRC)) die_nomem();
    if (!stralloc_0(&template)) die_nomem();
    if ((fdin = open_read(template.s)) == -1)
      if (errno != ENOENT)
        logmsg(WHO,111,FATAL,B(ERR_OPEN,template.s));
      else {                                     /* ezbin/ezmlmrc */
    if (!stralloc_copys(&template,auto_bin)) die_nomem();
    if (!stralloc_cats(&template,TXT_EZMLMRC)) die_nomem();
    if (!stralloc_0(&template)) die_nomem();
    if ((fdin = open_read(template.s)) == -1)
      if (errno != ENOENT)
        logmsg(WHO,111,FATAL,B(ERR_OPEN,template.s));
      else
        logmsg(WHO,100,FATAL,B(ERR_NOEXIST,template.s));
      }
  }
 
  dcreate("");        
 
  /* This is all we do, the rest is up to ezmlmrc */
  /* do it after opening template to avoid aborts */
  /* with created DIR. Well we also write DIR/key */
  /* at the end except in -e[dit] mode.           */
 
  buffer_init(&bi,buffer_unixread,fdin,textbuf,sizeof(textbuf));
  if (!stralloc_0(&oldfname)) die_nomem();       /* init oldfname */
  flagdo = 0;
 
  if (getln(&bi,&line,&match,'\n') == -1)
    logmsg(WHO,111,FATAL,B(ERR_READ,template.s));
  if (!match)
    logmsg(WHO,111,FATAL,B(ERR_READ,template.s));
 
  if (!case_starts(line.s,auto_version))
    logmsg(WHO,0,WARN,B(ERR_VERSION,auto_version," vs. ezmlmrc"));
 
  for (;;) {
    if (getln(&bi,&line,&match,'\n') == -1)
      logmsg(WHO,111,FATAL,B(ERR_READ,template.s));
    if (!match)
      break;
    if (line.s[0] == '#')                        /* comment */
      continue;
    if (!stralloc_0(&line)) die_nomem();
    if (line.s[0] == '<' && line.s[1] == '/') {  /* tag */
      if (line.s[str_chr(line.s,'.')])
        logmsg(WHO,100,FATAL,B(ERR_PERIOD,line.s));
      flagdo = 1;
      flagover = 0;
      hashpos = 0;
      pos = str_chr(line.s + 2,'#') + 2;
      if (line.s[pos]) {
        hashpos = pos;
        pos++;
        flagnot = 0;
        while ((ch = line.s[pos]) &&
              (line.s[pos] != '/' && line.s[pos+1] != '>')) {
          if (ch == '^') {
            flagnot = 1;
            pos++;
            continue;
          }
      /* E is ignored. For files => create unlebo exists */
 
          if (ch == 'E' && !flagnot || (ch == 'e' && flagnot)) {
            if (flags['e' - 'a'] && !flagforce)
              flagover = 1;                          /* ignore #E & #^e, but set flagover */
          } else if (ch >= 'a' && ch <= 'z') {
            flagdo &= (flags[ch - 'a'] ^ flagnot);
          } else if (ch >= 'A' && ch <= 'Z') {
            flagdo &= !(flags[ch - 'A'] ^ flagnot);
          } else if (ch >= '0' && ch <= '9') {
            flagdo &= (popt[ch - '0'] && *popt[ch - '0']) ^flagnot;
          }
          flagnot = 0;
          pos++;
        }
 
        if (line.s[pos] != '/' || line.s[pos+1] != '>')
          logmsg(WHO,100,FATAL,B(ERR_ENDTAG,line.s));
      } else {
        flagdo = 1;
        pos = 2;                                 /* name needs to be >= 1 char */
        while (line.s[pos = str_chr(line.s+pos,'/')+pos]) {
          if (line.s[pos+1] == '>')
            break;
          pos++;
        }
        if (!line.s[pos])
          logmsg(WHO,100,FATAL,B(ERR_ENDTAG,line.s));
      }
      if (hashpos)
        pos = hashpos;                           /* points to after file name */
 
      if (line.s[2] == '+') {                    /* mkdir */
        if (!flagdo) continue;
        if (!stralloc_copys(&dname,"/")) die_nomem();
        if (!stralloc_catb(&dname,line.s + 3,pos - 3)) die_nomem();
        if (!stralloc_0(&dname)) die_nomem();
        dcreate(dname.s);
        flagdo = 0;
        continue;
      } else if (line.s[2] == ':') {             /* ln -s */
        if (!flagdo) continue;
        slpos = str_chr(line.s + 3,'/') + 3;
        if (slpos >= pos)
          logmsg(WHO,100,FATAL,B(ERR_LINKDIR,line.s));
        if (!stralloc_copyb(&dname,line.s+slpos,pos-slpos)) die_nomem();
        if (!stralloc_copyb(&lname,line.s+3,slpos-3)) die_nomem();
        if (!stralloc_0(&dname)) die_nomem();
        if (!stralloc_0(&lname)) die_nomem();
        linkdotdir(lname.s,dname.s);
        flagdo = 0;
        continue;
      } else if (line.s[2] == '-') {             /* rm */
        if (!flagdo) continue;
        if (!stralloc_copys(&dname,"/")) die_nomem();
        if (!stralloc_catb(&dname,line.s+3,pos-3)) die_nomem();
        if (!stralloc_0(&dname)) die_nomem();
        frm(dname.s);
        flagdo = 0;
        continue;
      }
    
      /* only plain files left;  first get file name */
 
      if (pos > 2) {                             /* </#ai/> => add to open file */
        if (!stralloc_copyb(&fname,line.s+1,pos-1)) die_nomem();
        if (!stralloc_0(&fname)) die_nomem();
      }
 
      if (str_diff(fname.s, oldfname.s)) {
        flagnotexist = 1;
 
        /* Treat special case of #E when editing which _should */
        /* write only if the file does not exist. flagover */
        /* is set if we need to check */
 
        if (flagover) {                          /* skip if exists */
          dirplusmake(fname.s);                  /* decided by FIRST tag for file */
          fdtmp = open_read(dirplus.s);
          if (fdtmp == -1) {
          if (errno != ENOENT)
            logmsg(WHO,111,FATAL,B(ERR_OPEN,dirplus.s));
          } else {
            flagnotexist = 0;                    /* already there - don't do it */
            close(fdtmp);
          }
        }
        if (oldfname.len > 1) {
          f_close();
          if (!stralloc_copys(&oldfname,"")) die_nomem();
          if (!stralloc_0(&oldfname)) die_nomem();
        }
        if (flagdo && flagnotexist) {
          if (!fname.len)
            logmsg(WHO,100,FATAL,B(ERR_FILENAME,line.s));
          f_open(fname.s);
          if (!stralloc_copy(&oldfname,&fname)) die_nomem();
        }
      }
      if (flagdo) flagdo = flagnotexist;
      continue;
    } else if (!flagdo) continue;                                         // part not to go out
 
    last = -1;
    next = 0;
    outline.len = 0;
 
    for (;;) {
      pos = next + str_chr(line.s + next,'<');
      if (line.s[pos] &&
          line.s[pos+1] == '#' &&
          line.s[pos+2] &&
          line.s[pos+3] == '#' &&
          line.s[pos+4] == '>') {                                         // host/local
            if (!stralloc_catb(&outline,line.s + last + 1,pos - last - 1)) die_nomem();
            switch (line.s[pos+2]) {
              case 'B': if (!stralloc_cats(&outline,auto_bin)) die_nomem();
                        last = pos + 4; next = pos + 5; break;            // base path
              case 'C': if (code && *code)                                // digest code
                        if (!stralloc_cats(&outline,code)) die_nomem();
                        last = pos + 4; next = pos + 5; break;
              case 'D': if (!stralloc_cats(&outline,dir)) die_nomem();    // listidr
                        last = pos + 4; next = pos + 5; break;
              case 'F': if (!stralloc_cat(&outline,&flag)) die_nomem();   // flags
                          last = pos + 4; next = pos + 5; break;
              case 'H': if (!stralloc_cats(&outline,host)) die_nomem();   // hostname
                        last = pos + 4; next = pos + 5; break;
              case 'L': if (!stralloc_cats(&outline,local)) die_nomem();  // local
                        last = pos + 4; next = pos + 5; break;
              case 'T': if (!stralloc_cats(&outline,dot)) die_nomem();    // dot
                        last = pos + 4; next = pos + 5; break;
              case 'X': if (cfname)                                       // config file name
                          if (!stralloc_cats(&outline,cfname)) die_nomem(); 
                        last = pos + 4; next = pos + 5; break;
              default:  /* copy unknown tag as is for e.g. <#A#> and*/
                        /* <#R#> to be processed by -manage/store   */
                        /* stuff in args for <#0#> .. <#9#> */
                        if ((line.s[pos+2] >= '0') && (line.s[pos+2] <= '9')) {
                          if (popt[line.s[pos+2] - '0'])
                            if (!stralloc_cats(&outline,popt[line.s[pos+2]-'0'])) 
                              die_nomem();
                        } else
                          if (!stralloc_catb(&outline,line.s+pos,5)) die_nomem();
                          last = pos + 4; next = pos + 5; break;
            }
      } else {            /* not tag */
        if (line.s[pos]) {
          next++;
        } else {
          if (!stralloc_catb(&outline,line.s+last+1,line.len-last-1))
            die_nomem();
          f_puts(outline.s);
          break;
        }
      }
    }  // end for
  }
 
  close(fdin);
  if (oldfname.len > 1)
    f_close();
 
  if (!flags['e' - 'a']) {    /* don't redo key when editing a list */
    f_open("/key");
    f_put(key.s,key.len);
    f_close();
  }
  _exit(0);
  
  return 0;
}