14632Seric # include "sendmail.h" 24632Seric # include <sys/stat.h> 36625Sglickman # include <ndir.h> 44634Seric # include <signal.h> 54632Seric # include <errno.h> 64632Seric 75182Seric # ifndef QUEUE 8*7391Seric SCCSID(@(#)queue.c 3.24 07/14/82 (no queueing)); 95182Seric # else QUEUE 104632Seric 11*7391Seric SCCSID(@(#)queue.c 3.24 07/14/82); 125182Seric 134632Seric /* 144632Seric ** QUEUEUP -- queue a message up for future transmission. 154632Seric ** 164632Seric ** The queued message should already be in the correct place. 174632Seric ** This routine just outputs the control file as appropriate. 184632Seric ** 194632Seric ** Parameters: 206980Seric ** e -- the envelope to queue up. 216999Seric ** queueall -- if TRUE, queue all addresses, rather than 226999Seric ** just those with the QQUEUEUP flag set. 234632Seric ** 244632Seric ** Returns: 254632Seric ** none. 264632Seric ** 274632Seric ** Side Effects: 284632Seric ** The current request (only unsatisfied addresses) 294632Seric ** are saved in a control file. 304632Seric */ 314632Seric 326999Seric queueup(e, queueall) 336980Seric register ENVELOPE *e; 346999Seric bool queueall; 354632Seric { 364632Seric char cf[MAXNAME]; 376980Seric char buf[MAXNAME]; 386980Seric register FILE *cfp; 394632Seric register HDR *h; 405007Seric register ADDRESS *q; 415199Seric extern char *mktemp(); 425902Seric register int i; 434632Seric 445037Seric /* 455037Seric ** Create control file. 465037Seric */ 474632Seric 487009Seric (void) strcpy(cf, QueueDir); 497009Seric (void) strcat(cf, "/tfXXXXXX"); 505037Seric (void) mktemp(cf); 516980Seric cfp = fopen(cf, "w"); 526980Seric if (cfp == NULL) 534632Seric { 544632Seric syserr("queueup: cannot create control file %s", cf); 554632Seric return; 564632Seric } 577010Seric (void) chmod(cf, 0600); 584632Seric 594632Seric # ifdef DEBUG 604632Seric if (Debug) 616980Seric printf("queueing in %s\n", cf); 624632Seric # endif DEBUG 634632Seric 644632Seric /* 656980Seric ** If there is no data file yet, create one. 666980Seric */ 676980Seric 686980Seric if (e->e_df == NULL) 696980Seric { 706980Seric register FILE *dfp; 716980Seric 727009Seric (void) strcpy(buf, QueueDir); 737009Seric (void) strcat(buf, "/dfXXXXXX"); 746980Seric e->e_df = newstr(mktemp(buf)); 756980Seric dfp = fopen(e->e_df, "w"); 766980Seric if (dfp == NULL) 776980Seric { 786980Seric syserr("queueup: cannot create %s", e->e_df); 797009Seric (void) fclose(cfp); 806980Seric return; 816980Seric } 827010Seric (void) chmod(e->e_df, 0600); 836980Seric (*e->e_putbody)(dfp, Mailer[1], FALSE); 847009Seric (void) fclose(dfp); 856980Seric } 866980Seric 876980Seric /* 884632Seric ** Output future work requests. 894632Seric */ 904632Seric 914632Seric /* output name of data file */ 926980Seric fprintf(cfp, "D%s\n", e->e_df); 934632Seric 944632Seric /* output name of sender */ 956980Seric fprintf(cfp, "S%s\n", e->e_from.q_paddr); 964632Seric 974632Seric /* output timeout */ 986980Seric fprintf(cfp, "T%ld\n", TimeOut); 994632Seric 1004634Seric /* output message priority */ 1016980Seric fprintf(cfp, "P%ld\n", e->e_msgpriority); 1024634Seric 1036980Seric /* output message class */ 1046980Seric fprintf(cfp, "C%d\n", e->e_class); 1056980Seric 1065902Seric /* output macro definitions */ 1075902Seric for (i = 0; i < 128; i++) 1085902Seric { 1096980Seric register char *p = e->e_macro[i]; 1105902Seric 1115902Seric if (p != NULL && i != (int) 'b') 1126980Seric fprintf(cfp, "M%c%s\n", i, p); 1135902Seric } 1145902Seric 1154632Seric /* output list of recipient addresses */ 1166980Seric for (q = e->e_sendqueue; q != NULL; q = q->q_next) 1174632Seric { 1185037Seric # ifdef DEBUG 1195037Seric if (Debug > 0) 1205037Seric { 1215037Seric printf("queueing "); 1225037Seric printaddr(q, FALSE); 1235037Seric } 1245037Seric # endif DEBUG 1256999Seric if (queueall || bitset(QQUEUEUP, q->q_flags)) 1266980Seric fprintf(cfp, "R%s\n", q->q_paddr); 1274632Seric } 1284632Seric 1294632Seric /* output headers for this message */ 1306980Seric for (h = e->e_header; h != NULL; h = h->h_link) 1314632Seric { 1324632Seric if (h->h_value == NULL || h->h_value[0] == '\0') 1334632Seric continue; 1346980Seric fprintf(cfp, "H"); 1354632Seric if (h->h_mflags != 0 && bitset(H_CHECK|H_ACHECK, h->h_flags)) 1366980Seric mfdecode(h->h_mflags, cfp); 1376980Seric fprintf(cfp, "%s: %s\n", h->h_field, h->h_value); 1384632Seric } 1394632Seric 1404632Seric /* 1414632Seric ** Clean up. 1424632Seric */ 1434632Seric 1446980Seric (void) fclose(cfp); 1456980Seric (void) strcpy(buf, QueueDir); 1466980Seric (void) strcat(buf, "/cfXXXXXX"); 1476980Seric (void) mktemp(buf); 1486980Seric if (link(cf, buf) < 0) 1496980Seric syserr("cannot link(%s, %s), df=%s", cf, buf, e->e_df); 1506980Seric else 1517009Seric (void) unlink(cf); 152*7391Seric 153*7391Seric /* disconnect this temp file from the job */ 154*7391Seric e->e_df = NULL; 1554632Seric } 1564632Seric /* 1574632Seric ** RUNQUEUE -- run the jobs in the queue. 1584632Seric ** 1594632Seric ** Gets the stuff out of the queue in some presumably logical 1604632Seric ** order and processes them. 1614632Seric ** 1624632Seric ** Parameters: 1634632Seric ** none. 1644632Seric ** 1654632Seric ** Returns: 1664632Seric ** none. 1674632Seric ** 1684632Seric ** Side Effects: 1694632Seric ** runs things in the mail queue. 1704632Seric */ 1714632Seric 1724639Seric bool ReorderQueue; /* if set, reorder the send queue */ 1734639Seric int QueuePid; /* pid of child running queue */ 1744634Seric 1754639Seric runqueue(forkflag) 1764639Seric bool forkflag; 1774632Seric { 1784634Seric extern reordersig(); 1794632Seric 1804639Seric if (QueueIntvl != 0) 1814639Seric { 1824836Seric (void) signal(SIGALRM, reordersig); 1837009Seric (void) alarm(QueueIntvl); 1844639Seric } 1854639Seric 1864639Seric if (forkflag) 1874639Seric { 1884639Seric QueuePid = dofork(); 1894639Seric if (QueuePid > 0) 1904639Seric { 1914639Seric /* parent */ 1924639Seric return; 1934639Seric } 1944639Seric else 1957009Seric (void) alarm(0); 1964639Seric } 1974639Seric 1984634Seric for (;;) 1994634Seric { 2004634Seric /* 2014634Seric ** Order the existing work requests. 2024634Seric */ 2034632Seric 2044634Seric orderq(); 2054632Seric 2064634Seric if (WorkQ == NULL) 2074634Seric { 2084634Seric /* no work? well, maybe later */ 2094634Seric if (QueueIntvl == 0) 2104634Seric break; 2114639Seric pause(); 2124634Seric continue; 2134634Seric } 2144632Seric 2154634Seric ReorderQueue = FALSE; 2164634Seric 2174634Seric /* 2184634Seric ** Process them once at a time. 2194634Seric ** The queue could be reordered while we do this to take 2204634Seric ** new requests into account. If so, the existing job 2214634Seric ** will be finished but the next thing taken off WorkQ 2224634Seric ** may be something else. 2234634Seric */ 2244634Seric 2254634Seric while (WorkQ != NULL) 2264634Seric { 2274634Seric WORK *w = WorkQ; 2284634Seric 2294634Seric WorkQ = WorkQ->w_next; 2304634Seric dowork(w); 2314634Seric free(w->w_name); 2324634Seric free((char *) w); 2334634Seric if (ReorderQueue) 2344634Seric break; 2354634Seric } 2364634Seric 2374634Seric if (QueueIntvl == 0) 2384634Seric break; 2394632Seric } 2405978Seric 2415978Seric /* no work to do -- just exit */ 2425978Seric finis(); 2434632Seric } 2444632Seric /* 2454634Seric ** REORDERSIG -- catch the alarm signal and tell sendmail to reorder queue. 2464634Seric ** 2474634Seric ** Parameters: 2484634Seric ** none. 2494634Seric ** 2504634Seric ** Returns: 2514634Seric ** none. 2524634Seric ** 2534634Seric ** Side Effects: 2544634Seric ** sets the "reorder work queue" flag. 2554634Seric */ 2564634Seric 2574634Seric reordersig() 2584634Seric { 2594639Seric if (QueuePid == 0) 2604639Seric { 2614639Seric /* we are in a child doing queueing */ 2624639Seric ReorderQueue = TRUE; 2634639Seric } 2644639Seric else 2654639Seric { 2664639Seric /* we are in a parent -- poke child or start new one */ 2674639Seric if (kill(QueuePid, SIGALRM) < 0) 2684639Seric { 2694639Seric /* no child -- get zombie & start new one */ 2704639Seric static int st; 2714639Seric 2724836Seric (void) wait(&st); 2734639Seric QueuePid = dofork(); 2744639Seric if (QueuePid == 0) 2754639Seric { 2764639Seric /* new child; run queue */ 2774836Seric runqueue(FALSE); 2784639Seric finis(); 2794639Seric } 2804639Seric } 2814639Seric } 2824639Seric 2834639Seric /* 2844639Seric ** Arrange to get this signal again. 2854639Seric */ 2864639Seric 2876065Seric (void) signal(SIGALRM, reordersig); 2887009Seric (void) alarm(QueueIntvl); 2894634Seric } 2904634Seric /* 2914632Seric ** ORDERQ -- order the work queue. 2924632Seric ** 2934632Seric ** Parameters: 2944632Seric ** none. 2954632Seric ** 2964632Seric ** Returns: 2974632Seric ** none. 2984632Seric ** 2994632Seric ** Side Effects: 3004632Seric ** Sets WorkQ to the queue of available work, in order. 3014632Seric */ 3024632Seric 3034632Seric # define WLSIZE 120 /* max size of worklist per sort */ 3044632Seric 3054632Seric orderq() 3064632Seric { 3076625Sglickman register struct direct *d; 3084632Seric register WORK *w; 3094632Seric register WORK **wp; /* parent of w */ 3106625Sglickman DIR *f; 3114632Seric register int i; 3124632Seric WORK wlist[WLSIZE]; 3134632Seric int wn = 0; 3144632Seric extern workcmpf(); 3154632Seric extern char *QueueDir; 3164632Seric 3174632Seric /* clear out old WorkQ */ 3184632Seric for (w = WorkQ; w != NULL; ) 3194632Seric { 3204632Seric register WORK *nw = w->w_next; 3214632Seric 3224632Seric WorkQ = nw; 3234632Seric free(w->w_name); 3244632Seric free((char *) w); 3254632Seric w = nw; 3264632Seric } 3274632Seric 3284632Seric /* open the queue directory */ 3296625Sglickman f = opendir(QueueDir); 3304632Seric if (f == NULL) 3314632Seric { 3324632Seric syserr("orderq: cannot open %s", QueueDir); 3334632Seric return; 3344632Seric } 3354632Seric 3364632Seric /* 3374632Seric ** Read the work directory. 3384632Seric */ 3394632Seric 3406625Sglickman while (wn < WLSIZE && (d = readdir(f)) != NULL) 3414632Seric { 3424632Seric char cbuf[MAXNAME]; 3434632Seric char lbuf[MAXNAME]; 3444632Seric FILE *cf; 3454632Seric register char *p; 3464632Seric 3474632Seric /* is this an interesting entry? */ 3486625Sglickman if (d->d_name[0] != 'c') 3494632Seric continue; 3504632Seric 3514632Seric /* yes -- find the control file location */ 3527009Seric (void) strcpy(cbuf, QueueDir); 3537009Seric (void) strcat(cbuf, "/"); 3544632Seric p = &cbuf[strlen(cbuf)]; 3557009Seric (void) strcpy(p, d->d_name); 3564632Seric 3574632Seric /* open control file */ 3584632Seric cf = fopen(cbuf, "r"); 3594632Seric if (cf == NULL) 3604632Seric { 3617055Seric /* this may be some random person sending hir msgs */ 3627055Seric /* syserr("orderq: cannot open %s", cbuf); */ 3637055Seric errno = 0; 3644632Seric continue; 3654632Seric } 3665037Seric wlist[wn].w_name = newstr(cbuf); 3674632Seric 3684632Seric /* extract useful information */ 3694632Seric while (fgets(lbuf, sizeof lbuf, cf) != NULL) 3704632Seric { 3714632Seric fixcrlf(lbuf, TRUE); 3724632Seric 3734632Seric switch (lbuf[0]) 3744632Seric { 3754632Seric case 'P': /* message priority */ 3765037Seric (void) sscanf(&lbuf[1], "%ld", &wlist[wn].w_pri); 3774632Seric break; 3784632Seric } 3794632Seric } 3804632Seric wn++; 3814632Seric (void) fclose(cf); 3824632Seric } 3836625Sglickman (void) closedir(f); 3844632Seric 3854632Seric /* 3864632Seric ** Sort the work directory. 3874632Seric */ 3884632Seric 3894632Seric qsort(wlist, wn, sizeof *wlist, workcmpf); 3904632Seric 3914632Seric /* 3924632Seric ** Convert the work list into canonical form. 3934632Seric */ 3944632Seric 3954632Seric wp = &WorkQ; 3964632Seric for (i = 0; i < wn; i++) 3974632Seric { 3984632Seric w = (WORK *) xalloc(sizeof *w); 3994632Seric w->w_name = wlist[i].w_name; 4004632Seric w->w_pri = wlist[i].w_pri; 4014632Seric w->w_next = NULL; 4024632Seric *wp = w; 4034632Seric wp = &w->w_next; 4044632Seric } 4054632Seric 4064632Seric # ifdef DEBUG 4074632Seric if (Debug) 4084632Seric { 4094632Seric for (w = WorkQ; w != NULL; w = w->w_next) 4105037Seric printf("%32s: pri=%ld\n", w->w_name, w->w_pri); 4114632Seric } 4124632Seric # endif DEBUG 4134632Seric } 4144632Seric /* 4154632Seric ** WORKCMPF -- compare function for ordering work. 4164632Seric ** 4174632Seric ** Parameters: 4184632Seric ** a -- the first argument. 4194632Seric ** b -- the second argument. 4204632Seric ** 4214632Seric ** Returns: 4224632Seric ** -1 if a < b 4234632Seric ** 0 if a == b 4244632Seric ** 1 if a > b 4254632Seric ** 4264632Seric ** Side Effects: 4274632Seric ** none. 4284632Seric */ 4294632Seric 4304632Seric # define PRIFACT 1800 /* bytes each priority point is worth */ 4314632Seric 4324632Seric workcmpf(a, b) 4335037Seric register WORK *a; 4345037Seric register WORK *b; 4354632Seric { 4365037Seric if (a->w_pri == b->w_pri) 4374632Seric return (0); 4385037Seric else if (a->w_pri > b->w_pri) 4394632Seric return (1); 4404632Seric else 4414632Seric return (-1); 4424632Seric } 4434632Seric /* 4444632Seric ** DOWORK -- do a work request. 4454632Seric ** 4464632Seric ** Parameters: 4474632Seric ** w -- the work request to be satisfied. 4484632Seric ** 4494632Seric ** Returns: 4504632Seric ** none. 4514632Seric ** 4524632Seric ** Side Effects: 4534632Seric ** The work request is satisfied if possible. 4544632Seric */ 4554632Seric 4564632Seric dowork(w) 4574632Seric register WORK *w; 4584632Seric { 4594632Seric register int i; 4604632Seric auto int xstat; 4614632Seric 4624632Seric # ifdef DEBUG 4634632Seric if (Debug) 4645037Seric printf("dowork: %s pri %ld\n", w->w_name, w->w_pri); 4654632Seric # endif DEBUG 4664632Seric 4674632Seric /* 4684632Seric ** Fork for work. 4694632Seric */ 4704632Seric 4714632Seric i = fork(); 4724632Seric if (i < 0) 4734632Seric { 4744632Seric syserr("dowork: cannot fork"); 4754632Seric return; 4764632Seric } 4774632Seric 4784632Seric if (i == 0) 4794632Seric { 4806980Seric char buf[MAXNAME]; 4816980Seric 4824632Seric /* 4834632Seric ** CHILD 4846980Seric ** Change the name of the control file to avoid 4857350Seric ** duplicate deliveries. Then run the file 4867350Seric ** as though we had just read it. 4877350Seric ** We save an idea of the temporary name so we 4887350Seric ** can recover on interrupt. 4894632Seric */ 4904632Seric 4917356Seric (void) alarm(0); 4927347Seric FatalErrors = FALSE; 4934632Seric QueueRun = TRUE; 4946991Seric MailBack = TRUE; 4956980Seric (void) strcpy(buf, QueueDir); 4966980Seric (void) strcat(buf, "/tfXXXXXX"); 4976980Seric (void) mktemp(buf); 4986980Seric if (link(w->w_name, buf) < 0) 4996980Seric { 5006980Seric syserr("dowork: link(%s, %s)", w->w_name, buf); 5016980Seric 5026980Seric /* it's ok to lie -- it will be run later */ 5036980Seric exit(EX_OK); 5046980Seric } 5057350Seric ControlFile = newstr(buf); 5066980Seric (void) unlink(w->w_name); 5076980Seric 5086980Seric /* create ourselves a transcript file */ 5094634Seric openxscrpt(); 5106980Seric 5116980Seric /* do basic system initialization */ 5124632Seric initsys(); 5136980Seric 5146980Seric /* read the queue control file */ 5156980Seric readqf(buf); 5166980Seric 5176980Seric /* do the delivery */ 5187046Seric sendall(CurEnv, FALSE); 5196980Seric 5206980Seric /* if still not sent, perhaps we should time out.... */ 5214634Seric # ifdef DEBUG 5224634Seric if (Debug > 2) 5234634Seric printf("CurTime=%ld, TimeOut=%ld\n", CurTime, TimeOut); 5244634Seric # endif DEBUG 5256908Seric if (CurEnv->e_queueup && CurTime > TimeOut) 5264634Seric timeout(w); 5276980Seric 5286980Seric /* get rid of the temporary file -- a new cf will be made */ 5297350Seric ControlFile = NULL; 5306980Seric (void) unlink(buf); 5316980Seric 5326980Seric /* finish up and exit */ 5334632Seric finis(); 5344632Seric } 5354632Seric 5364632Seric /* 5374632Seric ** Parent -- pick up results. 5384632Seric */ 5394632Seric 5404632Seric errno = 0; 5414632Seric while ((i = wait(&xstat)) > 0 && errno != EINTR) 5424632Seric { 5434632Seric if (errno == EINTR) 5444632Seric { 5454632Seric errno = 0; 5464632Seric } 5474632Seric } 5484632Seric } 5494632Seric /* 5504632Seric ** READQF -- read queue file and set up environment. 5514632Seric ** 5524632Seric ** Parameters: 5534632Seric ** cf -- name of queue control file. 5544632Seric ** 5554632Seric ** Returns: 5564632Seric ** none. 5574632Seric ** 5584632Seric ** Side Effects: 5594632Seric ** cf is read and created as the current job, as though 5604632Seric ** we had been invoked by argument. 5614632Seric */ 5624632Seric 5634632Seric readqf(cf) 5644632Seric char *cf; 5654632Seric { 5664632Seric register FILE *f; 5674632Seric char buf[MAXLINE]; 5684632Seric 5694632Seric /* 5704632Seric ** Open the file created by queueup. 5714632Seric */ 5724632Seric 5734632Seric f = fopen(cf, "r"); 5744632Seric if (f == NULL) 5754632Seric { 5764632Seric syserr("readqf: no cf file %s", cf); 5774632Seric return; 5784632Seric } 5794632Seric 5804632Seric /* 5814632Seric ** Read and process the file. 5824632Seric */ 5834632Seric 5847356Seric if (Verbose) 5857356Seric printf("\nRunning %s\n", cf); 5864632Seric while (fgets(buf, sizeof buf, f) != NULL) 5874632Seric { 5884632Seric fixcrlf(buf, TRUE); 5894632Seric 5904632Seric switch (buf[0]) 5914632Seric { 5924632Seric case 'R': /* specify recipient */ 5936908Seric sendto(&buf[1], 1, (ADDRESS *) NULL, &CurEnv->e_sendqueue); 5944632Seric break; 5954632Seric 5964632Seric case 'H': /* header */ 5974632Seric (void) chompheader(&buf[1], FALSE); 5984632Seric break; 5994632Seric 6004632Seric case 'S': /* sender */ 6014634Seric setsender(newstr(&buf[1])); 6024632Seric break; 6034632Seric 6044632Seric case 'D': /* data file name */ 6056991Seric CurEnv->e_df = newstr(&buf[1]); 6066991Seric TempFile = fopen(CurEnv->e_df, "r"); 6074632Seric if (TempFile == NULL) 6086991Seric syserr("readqf: cannot open %s", CurEnv->e_df); 6094632Seric break; 6104632Seric 6114632Seric case 'T': /* timeout */ 6124632Seric (void) sscanf(&buf[1], "%ld", &TimeOut); 6134632Seric break; 6144632Seric 6154634Seric case 'P': /* message priority */ 6166908Seric (void) sscanf(&buf[1], "%ld", &CurEnv->e_msgpriority); 6175037Seric 6185037Seric /* make sure that big things get sent eventually */ 6196908Seric CurEnv->e_msgpriority -= WKTIMEFACT; 6204634Seric break; 6214634Seric 6226980Seric case 'C': /* message class */ 6236980Seric (void) sscanf(&buf[1], "%hd", &CurEnv->e_class); 6246980Seric break; 6256980Seric 6265902Seric case 'M': /* define macro */ 6275902Seric define(buf[1], newstr(&buf[2])); 6285902Seric break; 6295902Seric 6304632Seric default: 6314632Seric syserr("readqf(%s): bad line \"%s\"", cf, buf); 6324632Seric break; 6334632Seric } 6344632Seric } 6354632Seric } 6364632Seric /* 6374632Seric ** TIMEOUT -- process timeout on queue file. 6384632Seric ** 6394632Seric ** Parameters: 6404632Seric ** w -- pointer to work request that timed out. 6414632Seric ** 6424632Seric ** Returns: 6434632Seric ** none. 6444632Seric ** 6454632Seric ** Side Effects: 6464632Seric ** Returns a message to the sender saying that this 6474632Seric ** message has timed out. 6484632Seric */ 6494632Seric 6504632Seric timeout(w) 6514632Seric register WORK *w; 6524632Seric { 6537369Seric char buf[MAXLINE]; 6547369Seric extern char *TextTimeOut; 6557369Seric 6564634Seric # ifdef DEBUG 6574634Seric if (Debug > 0) 6584634Seric printf("timeout(%s)\n", w->w_name); 6594634Seric # endif DEBUG 6606991Seric message(Arpa_Info, "Message has timed out"); 6614634Seric 6624634Seric /* return message to sender */ 6637369Seric (void) sprintf(buf, "Cannot send mail for %s", TextTimeOut); 6647369Seric (void) returntosender(buf, &CurEnv->e_from, TRUE); 6654634Seric 6664634Seric /* arrange to remove files from queue */ 6676908Seric CurEnv->e_queueup = FALSE; 6684632Seric } 6695182Seric 6705182Seric # endif QUEUE 671