1 #include <sys/types.h>

     2 #include <sys/stat.h>

     3 #include "readwrite.h"

     4 #include "sig.h"

     5 #include "direntry.h"

     6 #include "control.h"

     7 #include "select.h"

     8 #include "open.h"

     9 #include "seek.h"

    10 #include "exit.h"

    11 #include "lock.h"

    12 #include "ndelay.h"

    13 #include "now.h"

    14 #include "getln.h"

    15 #include "substdio.h"

    16 #include "alloc.h"

    17 #include "error.h"

    18 #include "stralloc.h"

    19 #include "str.h"

    20 #include "byte.h"

    21 #include "fmt.h"

    22 #include "scan.h"

    23 #include "case.h"

    24 #include "auto_qmail.h"

    25 #include "trigger.h"

    26 #include "newfield.h"

    27 #include "quote.h"

    28 #include "qmail.h"

    29 #include "qsutil.h"

    30 #include "prioq.h"

    31 #include "constmap.h"

    32 #include "fmtqfn.h"

    33 #include "readsubdir.h"

    34 

    35 /* critical timing feature #1: if not triggered, do not busy-loop */

    36 /* critical timing feature #2: if triggered, respond within fixed time */

    37 /* important timing feature: when triggered, respond instantly */

    38 #define SLEEP_TODO 1500 /* check todo/ every 25 minutes in any case */

    39 #define SLEEP_FUZZ 1 /* slop a bit on sleeps to avoid zeno effect */

    40 #define SLEEP_FOREVER 86400 /* absolute maximum time spent in select() */

    41 #define SLEEP_CLEANUP 76431 /* time between cleanups */

    42 #define SLEEP_SYSFAIL 123

    43 #define OSSIFIED 129600 /* 36 hours; _must_ exceed q-q's DEATH (24 hours) */

    44 

    45 int lifetime = 604800;

    46 

    47 stralloc percenthack = {0};

    48 struct constmap mappercenthack;

    49 stralloc locals = {0};

    50 struct constmap maplocals;

    51 stralloc vdoms = {0};

    52 struct constmap mapvdoms;

    53 stralloc envnoathost = {0};

    54 stralloc bouncefrom = {0};

    55 stralloc bouncehost = {0};

    56 stralloc doublebounceto = {0};

    57 stralloc doublebouncehost = {0};

    58 

    59 char strnum2[FMT_ULONG];

    60 char strnum3[FMT_ULONG];

    61 

    62 #define CHANNELS 2

    63 char *chanaddr[CHANNELS] = { "local/", "remote/" };

    64 char *chanstatusmsg[CHANNELS] = { " local ", " remote " };

    65 char *tochan[CHANNELS] = { " to local ", " to remote " };

    66 int chanfdout[CHANNELS] = { 1, 3 };

    67 int chanfdin[CHANNELS] = { 2, 4 };

    68 int chanskip[CHANNELS] = { 10, 20 };

    69 

    70 int flagexitasap = 0; void sigterm() { flagexitasap = 1; }

    71 int flagrunasap = 0; void sigalrm() { flagrunasap = 1; }

    72 int flagreadasap = 0; void sighup() { flagreadasap = 1; }

    73 

    74 void cleandied() { log1("alert: oh no! lost qmail-clean connection! dying...\n");

    75  flagexitasap = 1; }

    76 

    77 int flagspawnalive[CHANNELS];

    78 void spawndied(c) int c; { log1("alert: oh no! lost spawn connection! dying...\n");

    79  flagspawnalive[c] = 0; flagexitasap = 1; }

    80 

    81 #define REPORTMAX 10000

    82 

    83 datetime_sec recent;

    84 

    85 

    86 /* this file is too long ----------------------------------------- FILENAMES */

    87 

    88 stralloc fn = {0};

    89 stralloc fn2 = {0};

    90 char fnmake_strnum[FMT_ULONG];

    91 

    92 void fnmake_init()

    93 {

    94  while (!stralloc_ready(&fn,FMTQFN)) nomem();

    95  while (!stralloc_ready(&fn2,FMTQFN)) nomem();

    96 }

    97 

    98 void fnmake_info(id) unsigned long id; { fn.len = fmtqfn(fn.s,"info/",id,1); }

    99 void fnmake_todo(id) unsigned long id; { fn.len = fmtqfn(fn.s,"todo/",id,0); }

   100 void fnmake_mess(id) unsigned long id; { fn.len = fmtqfn(fn.s,"mess/",id,1); }

   101 void fnmake_foop(id) unsigned long id; { fn.len = fmtqfn(fn.s,"foop/",id,0); }

   102 void fnmake_split(id) unsigned long id; { fn.len = fmtqfn(fn.s,"",id,1); }

   103 void fnmake2_bounce(id) unsigned long id;

   104 { fn2.len = fmtqfn(fn2.s,"bounce/",id,0); }

   105 void fnmake_chanaddr(id,c) unsigned long id; int c;

   106 { fn.len = fmtqfn(fn.s,chanaddr[c],id,1); }

   107 

   108 

   109 /* this file is too long ----------------------------------------- REWRITING */

   110 

   111 stralloc rwline = {0};

   112 

   113 /* 1 if by land, 2 if by sea, 0 if out of memory. not allowed to barf. */

   114 /* may trash recip. must set up rwline, between a T and a \0. */

   115 int rewrite(recip)

   116 char *recip;

   117 {

   118   int i;

   119   int j;

   120   char *x;

   121   static stralloc addr = {0};

   122   int at;

   123 

   124   if (!stralloc_copys(&rwline,"T")) return 0;

   125   if (!stralloc_copys(&addr,recip)) return 0;

   126 

   127   i = byte_rchr(addr.s,addr.len,'@');

   128   if (i == addr.len) {

   129     if (!stralloc_cats(&addr,"@")) return 0;

   130     if (!stralloc_cat(&addr,&envnoathost)) return 0;

   131   }

   132 

   133   while (constmap(&mappercenthack,addr.s + i + 1,addr.len - i - 1)) {

   134     j = byte_rchr(addr.s,i,'%');

   135     if (j == i) break;

   136     addr.len = i;

   137     i = j;

   138     addr.s[i] = '@';

   139   }

   140 

   141   at = byte_rchr(addr.s,addr.len,'@');

   142 

   143   if (constmap(&maplocals,addr.s + at + 1,addr.len - at - 1)) {

   144     if (!stralloc_cat(&rwline,&addr)) return 0;

   145     if (!stralloc_0(&rwline)) return 0;

   146     return 1;

   147   }

   148 

   149   for (i = 0;i <= addr.len;++i)

   150     if (!i || (i == at + 1) || (i == addr.len) || ((i > at) && (addr.s[i] == '.')))

   151       if (x = constmap(&mapvdoms,addr.s + i,addr.len - i)) {

   152         if (!*x) break;

   153         if (!stralloc_cats(&rwline,x)) return 0;

   154         if (!stralloc_cats(&rwline,"-")) return 0;

   155         if (!stralloc_cat(&rwline,&addr)) return 0;

   156         if (!stralloc_0(&rwline)) return 0;

   157         return 1;

   158       }

   159  

   160   if (!stralloc_cat(&rwline,&addr)) return 0;

   161   if (!stralloc_0(&rwline)) return 0;

   162   return 2;

   163 }

   164 

   165 void senderadd(sa,sender,recip)

   166 stralloc *sa;

   167 char *sender;

   168 char *recip;

   169 {

   170  int i;

   171  int j;

   172  int k;

   173 

   174  i = str_len(sender);

   175  if (i >= 4)

   176    if (str_equal(sender + i - 4,"-@[]"))

   177     {

   178      j = byte_rchr(sender,i - 4,'@');

   179      k = str_rchr(recip,'@');

   180      if (recip[k] && (j + 5 <= i))

   181       {

   182        /* owner-@host-@[] -> owner-recipbox=reciphost@host */

   183        while (!stralloc_catb(sa,sender,j)) nomem();

   184        while (!stralloc_catb(sa,recip,k)) nomem();

   185        while (!stralloc_cats(sa,"=")) nomem();

   186        while (!stralloc_cats(sa,recip + k + 1)) nomem();

   187        while (!stralloc_cats(sa,"@")) nomem();

   188        while (!stralloc_catb(sa,sender + j + 1,i - 5 - j)) nomem();

   189        return;

   190       }

   191     }

   192  while (!stralloc_cats(sa,sender)) nomem();

   193 }

   194 

   195 

   196 /* this file is too long ---------------------------------------------- INFO */

   197 

   198 int getinfo(sa,dt,id)

   199 stralloc *sa;

   200 datetime_sec *dt;

   201 unsigned long id;

   202 {

   203  int fdinfo;

   204  struct stat st;

   205  static stralloc line = {0};

   206  int match;

   207  substdio ss;

   208  char buf[128];

   209 

   210  fnmake_info(id);

   211  fdinfo = open_read(fn.s);

   212  if (fdinfo == -1) return 0;

   213  if (fstat(fdinfo,&st) == -1) { close(fdinfo); return 0; }

   214  substdio_fdbuf(&ss,read,fdinfo,buf,sizeof(buf));

   215  if (getln(&ss,&line,&match,'\0') == -1) { close(fdinfo); return 0; }

   216  close(fdinfo);

   217  if (!match) return 0;

   218  if (line.s[0] != 'F') return 0;

   219 

   220  *dt = st.st_mtime;

   221  while (!stralloc_copys(sa,line.s + 1)) nomem();

   222  while (!stralloc_0(sa)) nomem();

   223  return 1;

   224 }

   225 

   226 

   227 /* this file is too long ------------------------------------- COMMUNICATION */

   228 

   229 substdio sstoqc; char sstoqcbuf[1024];

   230 substdio ssfromqc; char ssfromqcbuf[1024];

   231 stralloc comm_buf[CHANNELS] = { {0}, {0} };

   232 int comm_pos[CHANNELS];

   233 

   234 void comm_init()

   235 {

   236  int c;

   237  substdio_fdbuf(&sstoqc,write,5,sstoqcbuf,sizeof(sstoqcbuf));

   238  substdio_fdbuf(&ssfromqc,read,6,ssfromqcbuf,sizeof(ssfromqcbuf));

   239  for (c = 0;c < CHANNELS;++c)

   240    if (ndelay_on(chanfdout[c]) == -1)

   241    /* this is so stupid: NDELAY semantics should be default on write */

   242      spawndied(c); /* drastic, but better than risking deadlock */

   243 }

   244 

   245 int comm_canwrite(c)

   246 int c;

   247 {

   248  /* XXX: could allow a bigger buffer; say 10 recipients */

   249  if (comm_buf[c].s && comm_buf[c].len) return 0;

   250  return 1;

   251 }

   252 

   253 void comm_write(c,delnum,id,sender,recip)

   254 int c;

   255 int delnum;

   256 unsigned long id;

   257 char *sender;

   258 char *recip;

   259 {

   260  char ch;

   261  if (comm_buf[c].s && comm_buf[c].len) return;

   262  while (!stralloc_copys(&comm_buf[c],"")) nomem();

   263  ch = delnum;

   264  while (!stralloc_append(&comm_buf[c],&ch)) nomem();

   265  fnmake_split(id);

   266  while (!stralloc_cats(&comm_buf[c],fn.s)) nomem();

   267  while (!stralloc_0(&comm_buf[c])) nomem();

   268  senderadd(&comm_buf[c],sender,recip);

   269  while (!stralloc_0(&comm_buf[c])) nomem();

   270  while (!stralloc_cats(&comm_buf[c],recip)) nomem();

   271  while (!stralloc_0(&comm_buf[c])) nomem();

   272  comm_pos[c] = 0;

   273 }

   274 

   275 void comm_selprep(nfds,wfds)

   276 int *nfds;

   277 fd_set *wfds;

   278 {

   279  int c;

   280  for (c = 0;c < CHANNELS;++c)

   281    if (flagspawnalive[c])

   282      if (comm_buf[c].s && comm_buf[c].len)

   283       {

   284        FD_SET(chanfdout[c],wfds);

   285        if (*nfds <= chanfdout[c])

   286          *nfds = chanfdout[c] + 1;

   287       }

   288 }

   289 

   290 void comm_do(wfds)

   291 fd_set *wfds;

   292 {

   293  int c;

   294  for (c = 0;c < CHANNELS;++c)

   295    if (flagspawnalive[c])

   296      if (comm_buf[c].s && comm_buf[c].len)

   297        if (FD_ISSET(chanfdout[c],wfds))

   298         {

   299          int w;

   300          int len;

   301          len = comm_buf[c].len;

   302          w = write(chanfdout[c],comm_buf[c].s + comm_pos[c],len - comm_pos[c]);

   303          if (w <= 0)

   304 	  {

   305 	   if ((w == -1) && (errno == error_pipe))

   306 	     spawndied(c);

   307 	   else

   308 	     continue; /* kernel select() bug; can't avoid busy-looping */

   309 	  }

   310 	 else

   311 	  {

   312 	   comm_pos[c] += w;

   313 	   if (comm_pos[c] == len)

   314 	     comm_buf[c].len = 0;

   315 	  }

   316         }

   317 }

   318 

   319 

   320 /* this file is too long ------------------------------------------ CLEANUPS */

   321 

   322 int flagcleanup; /* if 1, cleanupdir is initialized and ready */

   323 readsubdir cleanupdir;

   324 datetime_sec cleanuptime;

   325 

   326 void cleanup_init()

   327 {

   328  flagcleanup = 0;

   329  cleanuptime = now();

   330 }

   331 

   332 void cleanup_selprep(wakeup)

   333 datetime_sec *wakeup;

   334 {

   335  if (flagcleanup) *wakeup = 0;

   336  if (*wakeup > cleanuptime) *wakeup = cleanuptime;

   337 }

   338 

   339 void cleanup_do()

   340 {

   341  char ch;

   342  struct stat st;

   343  unsigned long id;

   344 

   345  if (!flagcleanup)

   346   {

   347    if (recent < cleanuptime) return;

   348    readsubdir_init(&cleanupdir,"mess",pausedir);

   349    flagcleanup = 1;

   350   }

   351 

   352  switch(readsubdir_next(&cleanupdir,&id))

   353   {

   354    case 1:

   355      break;

   356    case 0:

   357      flagcleanup = 0;

   358      cleanuptime = recent + SLEEP_CLEANUP;

   359    default:

   360      return;

   361   }

   362 

   363  fnmake_mess(id);

   364  if (stat(fn.s,&st) == -1) return; /* probably qmail-queue deleted it */

   365  if (recent <= st.st_atime + OSSIFIED) return;

   366 

   367  fnmake_info(id);

   368  if (stat(fn.s,&st) == 0) return;

   369  if (errno != error_noent) return;

   370  fnmake_todo(id);

   371  if (stat(fn.s,&st) == 0) return;

   372  if (errno != error_noent) return;

   373 

   374  fnmake_foop(id);

   375  if (substdio_putflush(&sstoqc,fn.s,fn.len) == -1) { cleandied(); return; }

   376  if (substdio_get(&ssfromqc,&ch,1) != 1) { cleandied(); return; }

   377  if (ch != '+')

   378    log3("warning: qmail-clean unable to clean up ",fn.s,"\n");

   379 }

   380 

   381 

   382 /* this file is too long ----------------------------------- PRIORITY QUEUES */

   383 

   384 prioq pqdone = {0}; /* -todo +info; HOPEFULLY -local -remote */

   385 prioq pqchan[CHANNELS] = { {0}, {0} };

   386 /* pqchan 0: -todo +info +local ?remote */

   387 /* pqchan 1: -todo +info ?local +remote */

   388 prioq pqfail = {0}; /* stat() failure; has to be pqadded again */

   389 

   390 void pqadd(id)

   391 unsigned long id;

   392 {

   393  struct prioq_elt pe;

   394  struct prioq_elt pechan[CHANNELS];

   395  int flagchan[CHANNELS];

   396  struct stat st;

   397  int c;

   398 

   399 #define CHECKSTAT if (errno != error_noent) goto fail;

   400 

   401  fnmake_info(id);

   402  if (stat(fn.s,&st) == -1)

   403   {

   404    CHECKSTAT

   405    return; /* someone yanking our chain */

   406   }

   407 

   408  fnmake_todo(id);

   409  if (stat(fn.s,&st) != -1) return; /* look, ma, dad crashed writing info! */

   410  CHECKSTAT

   411 

   412  for (c = 0;c < CHANNELS;++c)

   413   {

   414    fnmake_chanaddr(id,c);

   415    if (stat(fn.s,&st) == -1) { flagchan[c] = 0; CHECKSTAT }

   416    else { flagchan[c] = 1; pechan[c].id = id; pechan[c].dt = st.st_mtime; }

   417   }

   418 

   419  for (c = 0;c < CHANNELS;++c)

   420    if (flagchan[c])

   421      while (!prioq_insert(&pqchan[c],&pechan[c])) nomem();

   422 

   423  for (c = 0;c < CHANNELS;++c) if (flagchan[c]) break;

   424  if (c == CHANNELS)

   425   {

   426    pe.id = id; pe.dt = now();

   427    while (!prioq_insert(&pqdone,&pe)) nomem();

   428   }

   429 

   430  return;

   431 

   432  fail:

   433  log3("warning: unable to stat ",fn.s,"; will try again later\n");

   434  pe.id = id; pe.dt = now() + SLEEP_SYSFAIL;

   435  while (!prioq_insert(&pqfail,&pe)) nomem();

   436 }

   437 

   438 void pqstart()

   439 {

   440  readsubdir rs;

   441  int x;

   442  unsigned long id;

   443 

   444  readsubdir_init(&rs,"info",pausedir);

   445 

   446  while (x = readsubdir_next(&rs,&id))

   447    if (x > 0)

   448      pqadd(id);

   449 }

   450 

   451 void pqfinish()

   452 {

   453  int c;

   454  struct prioq_elt pe;

   455  time_t ut[2]; /* XXX: more portable than utimbuf, but still worrisome */

   456 

   457  for (c = 0;c < CHANNELS;++c)

   458    while (prioq_min(&pqchan[c],&pe))

   459     {

   460      prioq_delmin(&pqchan[c]);

   461      fnmake_chanaddr(pe.id,c);

   462      ut[0] = ut[1] = pe.dt;

   463      if (utime(fn.s,ut) == -1)

   464        log3("warning: unable to utime ",fn.s,"; message will be retried too soon\n");

   465     }

   466 }

   467 

   468 void pqrun()

   469 {

   470  int c;

   471  int i;

   472  for (c = 0;c < CHANNELS;++c)

   473    if (pqchan[c].p)

   474      if (pqchan[c].len)

   475        for (i = 0;i < pqchan[c].len;++i)

   476 	 pqchan[c].p[i].dt = recent;

   477 }

   478 

   479 

   480 /* this file is too long ---------------------------------------------- JOBS */

   481 

   482 struct job

   483  {

   484   int refs; /* if 0, this struct is unused */

   485   unsigned long id;

   486   int channel;

   487   datetime_sec retry;

   488   stralloc sender;

   489   int numtodo;

   490   int flaghiteof;

   491   int flagdying;

   492  }

   493 ;

   494 

   495 int numjobs;

   496 struct job *jo;

   497 

   498 void job_init()

   499 {

   500  int j;

   501  while (!(jo = (struct job *) alloc(numjobs * sizeof(struct job)))) nomem();

   502  for (j = 0;j < numjobs;++j)

   503   {

   504    jo[j].refs = 0;

   505    jo[j].sender.s = 0;

   506   }

   507 }

   508 

   509 int job_avail()

   510 {

   511  int j;

   512  for (j = 0;j < numjobs;++j) if (!jo[j].refs) return 1;

   513  return 0;

   514 }

   515 

   516 int job_open(id,channel)

   517 unsigned long id;

   518 int channel;

   519 {

   520  int j;

   521  for (j = 0;j < numjobs;++j) if (!jo[j].refs) break;

   522  if (j == numjobs) return -1;

   523  jo[j].refs = 1;

   524  jo[j].id = id;

   525  jo[j].channel = channel;

   526  jo[j].numtodo = 0;

   527  jo[j].flaghiteof = 0;

   528  return j;

   529 }

   530 

   531 void job_close(j)

   532 int j;

   533 {

   534  struct prioq_elt pe;

   535  struct stat st;

   536 

   537  if (0 < --jo[j].refs) return;

   538 

   539  pe.id = jo[j].id;

   540  pe.dt = jo[j].retry;

   541  if (jo[j].flaghiteof && !jo[j].numtodo)

   542   {

   543    fnmake_chanaddr(jo[j].id,jo[j].channel);

   544    if (unlink(fn.s) == -1)

   545     {

   546      log3("warning: unable to unlink ",fn.s,"; will try again later\n");

   547      pe.dt = now() + SLEEP_SYSFAIL;

   548     }

   549    else

   550     {

   551      int c;

   552      for (c = 0;c < CHANNELS;++c) if (c != jo[j].channel)

   553       {

   554        fnmake_chanaddr(jo[j].id,c);

   555        if (stat(fn.s,&st) == 0) return; /* more channels going */

   556        if (errno != error_noent)

   557 	{

   558          log3("warning: unable to stat ",fn.s,"\n");

   559 	 break; /* this is the only reason for HOPEFULLY */

   560 	}

   561       }

   562      pe.dt = now();

   563      while (!prioq_insert(&pqdone,&pe)) nomem();

   564      return;

   565     }

   566   }

   567 

   568  while (!prioq_insert(&pqchan[jo[j].channel],&pe)) nomem();

   569 }

   570 

   571 

   572 /* this file is too long ------------------------------------------- BOUNCES */

   573 

   574 char *stripvdomprepend(recip)

   575 char *recip;

   576 {

   577  int i;

   578  char *domain;

   579  int domainlen;

   580  char *prepend;

   581 

   582  i = str_rchr(recip,'@');

   583  if (!recip[i]) return recip;

   584  domain = recip + i + 1;

   585  domainlen = str_len(domain);

   586 

   587  for (i = 0;i <= domainlen;++i)

   588    if ((i == 0) || (i == domainlen) || (domain[i] == '.'))

   589      if (prepend = constmap(&mapvdoms,domain + i,domainlen - i))

   590       {

   591        if (!*prepend) break;

   592        i = str_len(prepend);

   593        if (str_diffn(recip,prepend,i)) break;

   594        if (recip[i] != '-') break;

   595        return recip + i + 1;

   596       }

   597  return recip;

   598 }

   599 

   600 stralloc bouncetext = {0};

   601 

   602 void addbounce(id,recip,report)

   603 unsigned long id;

   604 char *recip;

   605 char *report;

   606 {

   607  int fd;

   608  int pos;

   609  int w;

   610  while (!stralloc_copys(&bouncetext,"<")) nomem();

   611  while (!stralloc_cats(&bouncetext,stripvdomprepend(recip))) nomem();

   612  for (pos = 0;pos < bouncetext.len;++pos)

   613    if (bouncetext.s[pos] == '\n')

   614      bouncetext.s[pos] = '_';

   615  while (!stralloc_cats(&bouncetext,">:\n")) nomem();

   616  while (!stralloc_cats(&bouncetext,report)) nomem();

   617  if (report[0])

   618    if (report[str_len(report) - 1] != '\n')

   619      while (!stralloc_cats(&bouncetext,"\n")) nomem();

   620  for (pos = bouncetext.len - 2;pos > 0;--pos)

   621    if (bouncetext.s[pos] == '\n')

   622      if (bouncetext.s[pos - 1] == '\n')

   623        bouncetext.s[pos] = '/';

   624  while (!stralloc_cats(&bouncetext,"\n")) nomem();

   625  fnmake2_bounce(id);

   626  for (;;)

   627   {

   628    fd = open_append(fn2.s);

   629    if (fd != -1) break;

   630    log1("alert: unable to append to bounce message; HELP! sleeping...\n");

   631    sleep(10);

   632   }

   633  pos = 0;

   634  while (pos < bouncetext.len)

   635   {

   636    w = write(fd,bouncetext.s + pos,bouncetext.len - pos);

   637    if (w <= 0)

   638     {

   639      log1("alert: unable to append to bounce message; HELP! sleeping...\n");

   640      sleep(10);

   641     }

   642    else

   643      pos += w;

   644   }

   645  close(fd);

   646 }

   647 

   648 int injectbounce(id)

   649 unsigned long id;

   650 {

   651  struct qmail qqt;

   652  struct stat st;

   653  char *bouncesender;

   654  char *bouncerecip;

   655  int r;

   656  int fd;

   657  substdio ssread;

   658  char buf[128];

   659  char inbuf[128];

   660  static stralloc sender = {0};

   661  static stralloc quoted = {0};

   662  datetime_sec birth;

   663  unsigned long qp;

   664 

   665  if (!getinfo(&sender,&birth,id)) return 0; /* XXX: print warning */

   666 

   667  /* owner-@host-@[] -> owner-@host */

   668  if (sender.len >= 5)

   669    if (str_equal(sender.s + sender.len - 5,"-@[]"))

   670     {

   671      sender.len -= 4;

   672      sender.s[sender.len - 1] = 0;

   673     }

   674 

   675  fnmake2_bounce(id);

   676  fnmake_mess(id);

   677  if (stat(fn2.s,&st) == -1)

   678   {

   679    if (errno == error_noent)

   680      return 1;

   681    log3("warning: unable to stat ",fn2.s,"\n");

   682    return 0;

   683   }

   684  if (str_equal(sender.s,"#@[]"))

   685    log3("triple bounce: discarding ",fn2.s,"\n");

   686  else

   687   {

   688    if (qmail_open(&qqt) == -1)

   689     { log1("warning: unable to start qmail-queue, will try later\n"); return 0; }

   690    qp = qmail_qp(&qqt);

   691 

   692    if (*sender.s) { bouncesender = ""; bouncerecip = sender.s; }

   693    else { bouncesender = "#@[]"; bouncerecip = doublebounceto.s; }

   694 

   695    while (!newfield_datemake(now())) nomem();

   696    qmail_put(&qqt,newfield_date.s,newfield_date.len);

   697    qmail_puts(&qqt,"From: ");

   698    while (!quote(&quoted,&bouncefrom)) nomem();

   699    qmail_put(&qqt,quoted.s,quoted.len);

   700    qmail_puts(&qqt,"@");

   701    qmail_put(&qqt,bouncehost.s,bouncehost.len);

   702    qmail_puts(&qqt,"\nTo: ");

   703    while (!quote2(&quoted,bouncerecip)) nomem();

   704    qmail_put(&qqt,quoted.s,quoted.len);

   705    qmail_puts(&qqt,"\n\

   706 Subject: failure notice\n\

   707 \n\

   708 Hi. This is the qmail-send program at ");

   709    qmail_put(&qqt,bouncehost.s,bouncehost.len);

   710    qmail_puts(&qqt,*sender.s ? ".\n\

   711 I'm afraid I wasn't able to deliver your message to the following addresses.\n\

   712 This is a permanent error; I've given up. Sorry it didn't work out.\n\

   713 \n\

   714 " : ".\n\

   715 I tried to deliver a bounce message to this address, but the bounce bounced!\n\

   716 \n\

   717 ");

   718 

   719    fd = open_read(fn2.s);

   720    if (fd == -1)

   721      qmail_fail(&qqt);

   722    else

   723     {

   724      substdio_fdbuf(&ssread,read,fd,inbuf,sizeof(inbuf));

   725      while ((r = substdio_get(&ssread,buf,sizeof(buf))) > 0)

   726        qmail_put(&qqt,buf,r);

   727      close(fd);

   728      if (r == -1)

   729        qmail_fail(&qqt);

   730     }

   731 

   732    qmail_puts(&qqt,*sender.s ? "--- Below this line is a copy of the message.\n\n" : "--- Below this line is the original bounce.\n\n");

   733    qmail_puts(&qqt,"Return-Path: <");

   734    while (!quote2(&quoted,sender.s)) nomem();

   735    qmail_put(&qqt,quoted.s,quoted.len);

   736    qmail_puts(&qqt,">\n");

   737 

   738    fd = open_read(fn.s);

   739    if (fd == -1)

   740      qmail_fail(&qqt);

   741    else

   742     {

   743      substdio_fdbuf(&ssread,read,fd,inbuf,sizeof(inbuf));

   744      while ((r = substdio_get(&ssread,buf,sizeof(buf))) > 0)

   745        qmail_put(&qqt,buf,r);

   746      close(fd);

   747      if (r == -1)

   748        qmail_fail(&qqt);

   749     }

   750 

   751    qmail_from(&qqt,bouncesender);

   752    qmail_to(&qqt,bouncerecip);

   753    if (*qmail_close(&qqt))

   754     { log1("warning: trouble injecting bounce message, will try later\n"); return 0; }

   755 

   756    strnum2[fmt_ulong(strnum2,id)] = 0;

   757    log2("bounce msg ",strnum2);

   758    strnum2[fmt_ulong(strnum2,qp)] = 0;

   759    log3(" qp ",strnum2,"\n");

   760   }

   761  if (unlink(fn2.s) == -1)

   762   {

   763    log3("warning: unable to unlink ",fn2.s,"\n");

   764    return 0;

   765   }

   766  return 1;

   767 }

   768 

   769 

   770 /* this file is too long ---------------------------------------- DELIVERIES */

   771 

   772 struct del

   773  {

   774   int used;

   775   int j;

   776   unsigned long delid;

   777   seek_pos mpos;

   778   stralloc recip;

   779  }

   780 ;

   781 

   782 unsigned long masterdelid = 1;

   783 unsigned int concurrency[CHANNELS] = { 10, 20 };

   784 unsigned int concurrencyused[CHANNELS] = { 0, 0 };

   785 struct del *d[CHANNELS];

   786 stralloc dline[CHANNELS];

   787 char delbuf[2048];

   788 

   789 void del_status()

   790 {

   791   int c;

   792 

   793   log1("status:");

   794   for (c = 0;c < CHANNELS;++c) {

   795     strnum2[fmt_ulong(strnum2,(unsigned long) concurrencyused[c])] = 0;

   796     strnum3[fmt_ulong(strnum3,(unsigned long) concurrency[c])] = 0;

   797     log2(chanstatusmsg[c],strnum2);

   798     log2("/",strnum3);

   799   }

   800   if (flagexitasap) log1(" exitasap");

   801   log1("\n");

   802 }

   803 

   804 void del_init()

   805 {

   806  int c;

   807  int i;

   808  for (c = 0;c < CHANNELS;++c)

   809   {

   810    flagspawnalive[c] = 1;

   811    while (!(d[c] = (struct del *) alloc(concurrency[c] * sizeof(struct del))))

   812      nomem();

   813    for (i = 0;i < concurrency[c];++i)

   814     { d[c][i].used = 0; d[c][i].recip.s = 0; }

   815    dline[c].s = 0;

   816    while (!stralloc_copys(&dline[c],"")) nomem();

   817   }

   818  del_status();

   819 }

   820 

   821 int del_canexit()

   822 {

   823  int c;

   824  for (c = 0;c < CHANNELS;++c)

   825    if (flagspawnalive[c]) /* if dead, nothing we can do about its jobs */

   826      if (concurrencyused[c]) return 0;

   827  return 1;

   828 }

   829 

   830 int del_avail(c)

   831 int c;

   832 {

   833   return flagspawnalive[c] && comm_canwrite(c) && (concurrencyused[c] < concurrency[c]);

   834 }

   835 

   836 void del_start(j,mpos,recip)

   837 int j;

   838 seek_pos mpos;

   839 char *recip;

   840 {

   841  int i;

   842  int c;

   843 

   844  c = jo[j].channel;

   845  if (!flagspawnalive[c]) return;

   846  if (!comm_canwrite(c)) return;

   847 

   848  for (i = 0;i < concurrency[c];++i) if (!d[c][i].used) break;

   849  if (i == concurrency[c]) return;

   850 

   851  if (!stralloc_copys(&d[c][i].recip,recip)) { nomem(); return; }

   852  if (!stralloc_0(&d[c][i].recip)) { nomem(); return; }

   853  d[c][i].j = j; ++jo[j].refs;

   854  d[c][i].delid = masterdelid++;

   855  d[c][i].mpos = mpos;

   856  d[c][i].used = 1; ++concurrencyused[c];

   857 

   858  comm_write(c,i,jo[j].id,jo[j].sender.s,recip);

   859 

   860  strnum2[fmt_ulong(strnum2,d[c][i].delid)] = 0;

   861  strnum3[fmt_ulong(strnum3,jo[j].id)] = 0;

   862  log2("starting delivery ",strnum2);

   863  log3(": msg ",strnum3,tochan[c]);

   864  logsafe(recip);

   865  log1("\n");

   866  del_status();

   867 }

   868 

   869 void markdone(c,id,pos)

   870 int c;

   871 unsigned long id;

   872 seek_pos pos;

   873 {

   874  struct stat st;

   875  int fd;

   876  fnmake_chanaddr(id,c);

   877  for (;;)

   878   {

   879    fd = open_write(fn.s);

   880    if (fd == -1) break;

   881    if (fstat(fd,&st) == -1) { close(fd); break; }

   882    if (seek_set(fd,pos) == -1) { close(fd); break; }

   883    if (write(fd,"D",1) != 1) { close(fd); break; }

   884    /* further errors -> double delivery without us knowing about it, oh well */

   885    close(fd);

   886    return;

   887   }

   888  log3("warning: trouble marking ",fn.s,"; message will be delivered twice!\n");

   889 }

   890 

   891 void del_dochan(c)

   892 int c;

   893 {

   894  int r;

   895  char ch;

   896  int i;

   897  int delnum;

   898  r = read(chanfdin[c],delbuf,sizeof(delbuf));

   899  if (r == -1) return;

   900  if (r == 0) { spawndied(c); return; }

   901  for (i = 0;i < r;++i)

   902   {

   903    ch = delbuf[i];

   904    while (!stralloc_append(&dline[c],&ch)) nomem();

   905    if (dline[c].len > REPORTMAX)

   906      dline[c].len = REPORTMAX;

   907      /* qmail-lspawn and qmail-rspawn are responsible for keeping it short */

   908      /* but from a security point of view, we don't trust rspawn */

   909    if (!ch && (dline[c].len > 1))

   910     {

   911      delnum = (unsigned int) (unsigned char) dline[c].s[0];

   912      if ((delnum < 0) || (delnum >= concurrency[c]) || !d[c][delnum].used)

   913        log1("warning: internal error: delivery report out of range\n");

   914      else

   915       {

   916        strnum3[fmt_ulong(strnum3,d[c][delnum].delid)] = 0;

   917        if (dline[c].s[1] == 'Z')

   918 	 if (jo[d[c][delnum].j].flagdying)

   919 	  {

   920 	   dline[c].s[1] = 'D';

   921 	   --dline[c].len;

   922 	   while (!stralloc_cats(&dline[c],"I'm not going to try again; this message has been in the queue too long.\n")) nomem();

   923 	   while (!stralloc_0(&dline[c])) nomem();

   924 	  }

   925        switch(dline[c].s[1])

   926 	{

   927 	 case 'K':

   928 	   log3("delivery ",strnum3,": success: ");

   929 	   logsafe(dline[c].s + 2);

   930 	   log1("\n");

   931 	   markdone(c,jo[d[c][delnum].j].id,d[c][delnum].mpos);

   932 	   --jo[d[c][delnum].j].numtodo;

   933 	   break;

   934 	 case 'Z':

   935 	   log3("delivery ",strnum3,": deferral: ");

   936 	   logsafe(dline[c].s + 2);

   937 	   log1("\n");

   938 	   break;

   939 	 case 'D':

   940 	   log3("delivery ",strnum3,": failure: ");

   941 	   logsafe(dline[c].s + 2);

   942 	   log1("\n");

   943 	   addbounce(jo[d[c][delnum].j].id,d[c][delnum].recip.s,dline[c].s + 2);

   944 	   markdone(c,jo[d[c][delnum].j].id,d[c][delnum].mpos);

   945 	   --jo[d[c][delnum].j].numtodo;

   946 	   break;

   947 	 default:

   948 	   log3("delivery ",strnum3,": report mangled, will defer\n");

   949 	}

   950        job_close(d[c][delnum].j);

   951        d[c][delnum].used = 0; --concurrencyused[c];

   952        del_status();

   953       }

   954      dline[c].len = 0;

   955     }

   956   }

   957 }

   958 

   959 void del_selprep(nfds,rfds)

   960 int *nfds;

   961 fd_set *rfds;

   962 {

   963  int c;

   964  for (c = 0;c < CHANNELS;++c)

   965    if (flagspawnalive[c])

   966     {

   967      FD_SET(chanfdin[c],rfds);

   968      if (*nfds <= chanfdin[c])

   969        *nfds = chanfdin[c] + 1;

   970     }

   971 }

   972 

   973 void del_do(rfds)

   974 fd_set *rfds;

   975 {

   976  int c;

   977  for (c = 0;c < CHANNELS;++c)

   978    if (flagspawnalive[c])

   979      if (FD_ISSET(chanfdin[c],rfds))

   980        del_dochan(c);

   981 }

   982 

   983 

   984 /* this file is too long -------------------------------------------- PASSES */

   985 

   986 struct

   987  {

   988   unsigned long id; /* if 0, need a new pass */

   989   int j; /* defined if id; job number */

   990   int fd; /* defined if id; reading from {local,remote} */

   991   seek_pos mpos; /* defined if id; mark position */

   992   substdio ss;

   993   char buf[128];

   994  }

   995 pass[CHANNELS];

   996 

   997 void pass_init()

   998 {

   999  int c;

  1000  for (c = 0;c < CHANNELS;++c) pass[c].id = 0;

  1001 }

  1002 

  1003 void pass_selprep(wakeup)

  1004 datetime_sec *wakeup;

  1005 {

  1006  int c;

  1007  struct prioq_elt pe;

  1008  if (flagexitasap) return;

  1009  for (c = 0;c < CHANNELS;++c)

  1010    if (pass[c].id)

  1011      if (del_avail(c))

  1012       { *wakeup = 0; return; }

  1013  if (job_avail())

  1014    for (c = 0;c < CHANNELS;++c)

  1015      if (!pass[c].id)

  1016        if (prioq_min(&pqchan[c],&pe))

  1017          if (*wakeup > pe.dt)

  1018            *wakeup = pe.dt;

  1019  if (prioq_min(&pqfail,&pe))

  1020    if (*wakeup > pe.dt)

  1021      *wakeup = pe.dt;

  1022  if (prioq_min(&pqdone,&pe))

  1023    if (*wakeup > pe.dt)

  1024      *wakeup = pe.dt;

  1025 }

  1026 

  1027 static datetime_sec squareroot(x) /* result^2 <= x < (result + 1)^2 */

  1028 datetime_sec x; /* assuming: >= 0 */

  1029 {

  1030  datetime_sec y;

  1031  datetime_sec yy;

  1032  datetime_sec y21;

  1033  int j;

  1034 

  1035  y = 0; yy = 0;

  1036  for (j = 15;j >= 0;--j)

  1037   {

  1038    y21 = (y << (j + 1)) + (1 << (j + j));

  1039    if (y21 <= x - yy) { y += (1 << j); yy += y21; }

  1040   }

  1041  return y;

  1042 }

  1043 

  1044 datetime_sec nextretry(birth,c)

  1045 datetime_sec birth;

  1046 int c;

  1047 {

  1048  int n;

  1049 

  1050  if (birth > recent) n = 0;

  1051  else n = squareroot(recent - birth); /* no need to add fuzz to recent */

  1052  n += chanskip[c];

  1053  return birth + n * n;

  1054 }

  1055 

  1056 void pass_dochan(c)

  1057 int c;

  1058 {

  1059  datetime_sec birth;

  1060  struct prioq_elt pe;

  1061  static stralloc line = {0};

  1062  int match;

  1063 

  1064  if (flagexitasap) return;

  1065 

  1066  if (!pass[c].id)

  1067   {

  1068    if (!job_avail()) return;

  1069    if (!prioq_min(&pqchan[c],&pe)) return;

  1070    if (pe.dt > recent) return;

  1071    fnmake_chanaddr(pe.id,c);

  1072 

  1073    prioq_delmin(&pqchan[c]);

  1074    pass[c].mpos = 0;

  1075    pass[c].fd = open_read(fn.s);

  1076    if (pass[c].fd == -1) goto trouble;

  1077    if (!getinfo(&line,&birth,pe.id)) { close(pass[c].fd); goto trouble; }

  1078    pass[c].id = pe.id;

  1079    substdio_fdbuf(&pass[c].ss,read,pass[c].fd,pass[c].buf,sizeof(pass[c].buf));

  1080    pass[c].j = job_open(pe.id,c);

  1081    jo[pass[c].j].retry = nextretry(birth,c);

  1082    jo[pass[c].j].flagdying = (recent > birth + lifetime);

  1083    while (!stralloc_copy(&jo[pass[c].j].sender,&line)) nomem();

  1084   }

  1085 

  1086  if (!del_avail(c)) return;

  1087 

  1088  if (getln(&pass[c].ss,&line,&match,'\0') == -1)

  1089   {

  1090    fnmake_chanaddr(pass[c].id,c);

  1091    log3("warning: trouble reading ",fn.s,"; will try again later\n");

  1092    close(pass[c].fd);

  1093    job_close(pass[c].j);

  1094    pass[c].id = 0;

  1095    return;

  1096   }

  1097  if (!match)

  1098   {

  1099    close(pass[c].fd);

  1100    jo[pass[c].j].flaghiteof = 1;

  1101    job_close(pass[c].j);

  1102    pass[c].id = 0;

  1103    return;

  1104   }

  1105  switch(line.s[0])

  1106   {

  1107    case 'T':

  1108      ++jo[pass[c].j].numtodo;

  1109      del_start(pass[c].j,pass[c].mpos,line.s + 1);

  1110      break;

  1111    case 'D':

  1112      break;

  1113    default:

  1114      fnmake_chanaddr(pass[c].id,c);

  1115      log3("warning: unknown record type in ",fn.s,"!\n");

  1116      close(pass[c].fd);

  1117      job_close(pass[c].j);

  1118      pass[c].id = 0;

  1119      return;

  1120   }

  1121 

  1122  pass[c].mpos += line.len;

  1123  return;

  1124 

  1125  trouble:

  1126  log3("warning: trouble opening ",fn.s,"; will try again later\n");

  1127  pe.dt = recent + SLEEP_SYSFAIL;

  1128  while (!prioq_insert(&pqchan[c],&pe)) nomem();

  1129 }

  1130 

  1131 void messdone(id)

  1132 unsigned long id;

  1133 {

  1134  char ch;

  1135  int c;

  1136  struct prioq_elt pe;