Update copyright year to 2018
[users/heiko/exim.git] / src / src / queue.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 /* Functions that operate on the input queue. */
9
10
11 #include "exim.h"
12
13
14
15 /* Routines with knowledge of spool layout */
16
17 #ifndef COMPILE_UTILITY
18 static void
19 spool_pname_buf(uschar * buf, int len)
20 {
21 snprintf(CS buf, len, "%s/%s/input", spool_directory, queue_name);
22 }
23
24 uschar *
25 spool_dname(const uschar * purpose, uschar * subdir)
26 {
27 return string_sprintf("%s/%s/%s/%s",
28         spool_directory, queue_name, purpose, subdir);
29 }
30 #endif
31
32 uschar *
33 spool_sname(const uschar * purpose, uschar * subdir)
34 {
35 return string_sprintf("%s%s%s%s%s",
36                     queue_name, *queue_name ? "/" : "",
37                     purpose,
38                     *subdir ? "/" : "", subdir);
39 }
40
41 uschar *
42 spool_fname(const uschar * purpose, const uschar * subdir, const uschar * fname,
43         const uschar * suffix)
44 {
45 return string_sprintf("%s/%s/%s/%s/%s%s",
46         spool_directory, queue_name, purpose, subdir, fname, suffix);
47 }
48
49
50
51
52 #ifndef COMPILE_UTILITY
53
54 /* The number of nodes to use for the bottom-up merge sort when a list of queue
55 items is to be ordered. The code for this sort was contributed as a patch by
56 Michael Haardt. */
57
58 #define LOG2_MAXNODES 32
59
60
61
62 /*************************************************
63 *  Helper sort function for queue_get_spool_list *
64 *************************************************/
65
66 /* This function is used when sorting the queue list in the function
67 queue_get_spool_list() below.
68
69 Arguments:
70   a            points to an ordered list of queue_filename items
71   b            points to another ordered list
72
73 Returns:       a pointer to a merged ordered list
74 */
75
76 static queue_filename *
77 merge_queue_lists(queue_filename *a, queue_filename *b)
78 {
79 queue_filename *first = NULL;
80 queue_filename **append = &first;
81
82 while (a && b)
83   {
84   int d;
85   if ((d = Ustrncmp(a->text, b->text, 6)) == 0)
86     d = Ustrcmp(a->text + 14, b->text + 14);
87   if (d < 0)
88     {
89     *append = a;
90     append= &a->next;
91     a = a->next;
92     }
93   else
94     {
95     *append = b;
96     append= &b->next;
97     b = b->next;
98     }
99   }
100
101 *append = a ? a : b;
102 return first;
103 }
104
105
106
107
108
109 /*************************************************
110 *             Get list of spool files            *
111 *************************************************/
112
113 /* Scan the spool directory and return a list of the relevant file names
114 therein. Single-character sub-directories are handled as follows:
115
116   If the first argument is > 0, a sub-directory is scanned; the letter is
117   taken from the nth entry in subdirs.
118
119   If the first argument is 0, sub-directories are not scanned. However, a
120   list of them is returned.
121
122   If the first argument is < 0, sub-directories are scanned for messages,
123   and a single, unified list is created. The returned data blocks contain the
124   identifying character of the subdirectory, if any. The subdirs vector is
125   still required as an argument.
126
127 If the randomize argument is TRUE, messages are returned in "randomized" order.
128 Actually, the order is anything but random, but the algorithm is cheap, and the
129 point is simply to ensure that the same order doesn't occur every time, in case
130 a particular message is causing a remote MTA to barf - we would like to try
131 other messages to that MTA first.
132
133 If the randomize argument is FALSE, sort the list according to the file name.
134 This should give the order in which the messages arrived. It is normally used
135 only for presentation to humans, in which case the (possibly expensive) sort
136 that it does is not part of the normal operational code. However, if
137 queue_run_in_order is set, sorting has to take place for queue runs as well.
138 When randomize is FALSE, the first argument is normally -1, so all messages are
139 included.
140
141 Arguments:
142   subdiroffset   sub-directory character offset, or 0 or -1 (see above)
143   subdirs        vector to store list of subdirchars
144   subcount       pointer to int in which to store count of subdirs
145   randomize      TRUE if the order of the list is to be unpredictable
146
147 Returns:         pointer to a chain of queue name items
148 */
149
150 static queue_filename *
151 queue_get_spool_list(int subdiroffset, uschar *subdirs, int *subcount,
152   BOOL randomize)
153 {
154 int i;
155 int flags = 0;
156 int resetflags = -1;
157 int subptr;
158 queue_filename *yield = NULL;
159 queue_filename *last = NULL;
160 struct dirent *ent;
161 DIR *dd;
162 uschar buffer[256];
163 queue_filename *root[LOG2_MAXNODES];
164
165 /* When randomizing, the file names are added to the start or end of the list
166 according to the bits of the flags variable. Get a collection of bits from the
167 current time. Use the bottom 16 and just keep re-using them if necessary. When
168 not randomizing, initialize the sublists for the bottom-up merge sort. */
169
170 if (randomize)
171   resetflags = time(NULL) & 0xFFFF;
172 else
173    for (i = 0; i < LOG2_MAXNODES; i++)
174      root[i] = NULL;
175
176 /* If processing the full queue, or just the top-level, start at the base
177 directory, and initialize the first subdirectory name (as none). Otherwise,
178 start at the sub-directory offset. */
179
180 if (subdiroffset <= 0)
181   {
182   i = 0;
183   subdirs[0] = 0;
184   *subcount = 0;
185   }
186 else
187   i = subdiroffset;
188
189 /* Set up prototype for the directory name. */
190
191 spool_pname_buf(buffer, sizeof(buffer));
192 buffer[sizeof(buffer) - 3] = 0;
193 subptr = Ustrlen(buffer);
194 buffer[subptr+2] = 0;               /* terminator for lengthened name */
195
196 /* This loop runs at least once, for the main or given directory, and then as
197 many times as necessary to scan any subdirectories encountered in the main
198 directory, if they are to be scanned at this time. */
199
200 for (; i <= *subcount; i++)
201   {
202   int count = 0;
203   int subdirchar = subdirs[i];      /* 0 for main directory */
204
205   if (subdirchar != 0)
206     {
207     buffer[subptr] = '/';
208     buffer[subptr+1] = subdirchar;
209     }
210
211   DEBUG(D_queue_run) debug_printf("looking in %s\n", buffer);
212   if (!(dd = opendir(CS buffer)))
213     continue;
214
215   /* Now scan the directory. */
216
217   while ((ent = readdir(dd)))
218     {
219     uschar *name = US ent->d_name;
220     int len = Ustrlen(name);
221
222     /* Count entries */
223
224     count++;
225
226     /* If we find a single alphameric sub-directory in the base directory,
227     add it to the list for subsequent scans. */
228
229     if (i == 0 && len == 1 && isalnum(*name))
230       {
231       *subcount = *subcount + 1;
232       subdirs[*subcount] = *name;
233       continue;
234       }
235
236     /* Otherwise, if it is a header spool file, add it to the list */
237
238     if (len == SPOOL_NAME_LENGTH &&
239         Ustrcmp(name + SPOOL_NAME_LENGTH - 2, "-H") == 0)
240       {
241       queue_filename *next =
242         store_get(sizeof(queue_filename) + Ustrlen(name));
243       Ustrcpy(next->text, name);
244       next->dir_uschar = subdirchar;
245
246       /* Handle the creation of a randomized list. The first item becomes both
247       the top and bottom of the list. Subsequent items are inserted either at
248       the top or the bottom, randomly. This is, I argue, faster than doing a
249       sort by allocating a random number to each item, and it also saves having
250       to store the number with each item. */
251
252       if (randomize)
253         if (!yield)
254           {
255           next->next = NULL;
256           yield = last = next;
257           }
258         else
259           {
260           if (flags == 0)
261             flags = resetflags;
262           if ((flags & 1) == 0)
263             {
264             next->next = yield;
265             yield = next;
266             }
267           else
268             {
269             next->next = NULL;
270             last->next = next;
271             last = next;
272             }
273           flags = flags >> 1;
274           }
275
276       /* Otherwise do a bottom-up merge sort based on the name. */
277
278       else
279         {
280         int j;
281         next->next = NULL;
282         for (j = 0; j < LOG2_MAXNODES; j++)
283           if (root[j])
284             {
285             next = merge_queue_lists(next, root[j]);
286             root[j] = j == LOG2_MAXNODES - 1 ? next : NULL;
287             }
288           else
289             {
290             root[j] = next;
291             break;
292             }
293         }
294       }
295     }
296
297   /* Finished with this directory */
298
299   closedir(dd);
300
301   /* If we have just scanned a sub-directory, and it was empty (count == 2
302   implies just "." and ".." entries), and Exim is no longer configured to
303   use sub-directories, attempt to get rid of it. At the same time, try to
304   get rid of any corresponding msglog subdirectory. These are just cosmetic
305   tidying actions, so just ignore failures. If we are scanning just a single
306   sub-directory, break the loop. */
307
308   if (i != 0)
309     {
310     if (!split_spool_directory && count <= 2)
311       {
312       uschar subdir[2];
313
314       rmdir(CS buffer);
315       subdir[0] = subdirchar; subdir[1] = 0;
316       rmdir(CS spool_dname(US"msglog", subdir));
317       }
318     if (subdiroffset > 0) break;    /* Single sub-directory */
319     }
320
321   /* If we have just scanned the base directory, and subdiroffset is 0,
322   we do not want to continue scanning the sub-directories. */
323
324   else if (subdiroffset == 0)
325     break;
326   }    /* Loop for multiple subdirectories */
327
328 /* When using a bottom-up merge sort, do the final merging of the sublists.
329 Then pass back the final list of file items. */
330
331 if (!randomize)
332   for (i = 0; i < LOG2_MAXNODES; ++i)
333     yield = merge_queue_lists(yield, root[i]);
334
335 return yield;
336 }
337
338
339
340
341 /*************************************************
342 *              Perform a queue run               *
343 *************************************************/
344
345 /* The arguments give the messages to start and stop at; NULL means start at
346 the beginning or stop at the end. If the given start message doesn't exist, we
347 start at the next lexically greater one, and likewise we stop at the after the
348 previous lexically lesser one if the given stop message doesn't exist. Because
349 a queue run can take some time, stat each file before forking, in case it has
350 been delivered in the meantime by some other means.
351
352 The global variables queue_run_force and queue_run_local may be set to cause
353 forced deliveries or local-only deliveries, respectively.
354
355 If deliver_selectstring[_sender] is not NULL, skip messages whose recipients do
356 not contain the string. As this option is typically used when a machine comes
357 back online, we want to ensure that at least one delivery attempt takes place,
358 so force the first one. The selecting string can optionally be a regex, or
359 refer to the sender instead of recipients.
360
361 If queue_2stage is set, the queue is scanned twice. The first time, queue_smtp
362 is set so that routing is done for all messages. Thus in the second run those
363 that are routed to the same host should go down the same SMTP connection.
364
365 Arguments:
366   start_id   message id to start at, or NULL for all
367   stop_id    message id to end at, or NULL for all
368   recurse    TRUE if recursing for 2-stage run
369
370 Returns:     nothing
371 */
372
373 void
374 queue_run(uschar *start_id, uschar *stop_id, BOOL recurse)
375 {
376 BOOL force_delivery = queue_run_force || deliver_selectstring != NULL ||
377   deliver_selectstring_sender != NULL;
378 const pcre *selectstring_regex = NULL;
379 const pcre *selectstring_regex_sender = NULL;
380 uschar *log_detail = NULL;
381 int subcount = 0;
382 int i;
383 uschar subdirs[64];
384
385 /* Cancel any specific queue domains. Turn off the flag that causes SMTP
386 deliveries not to happen, unless doing a 2-stage queue run, when the SMTP flag
387 gets set. Save the queue_runner's pid and the flag that indicates any
388 deliveries run directly from this process. Deliveries that are run by handing
389 on TCP/IP channels have queue_run_pid set, but not queue_running. */
390
391 queue_domains = NULL;
392 queue_smtp_domains = NULL;
393 queue_smtp = queue_2stage;
394
395 queue_run_pid = getpid();
396 queue_running = TRUE;
397
398 /* Log the true start of a queue run, and fancy options */
399
400 if (!recurse)
401   {
402   uschar extras[8];
403   uschar *p = extras;
404
405   if (queue_2stage) *p++ = 'q';
406   if (queue_run_first_delivery) *p++ = 'i';
407   if (queue_run_force) *p++ = 'f';
408   if (deliver_force_thaw) *p++ = 'f';
409   if (queue_run_local) *p++ = 'l';
410   *p = 0;
411
412   p = big_buffer;
413   p += sprintf(CS p, "pid=%d", (int)queue_run_pid);
414
415   if (extras[0] != 0)
416     p += sprintf(CS p, " -q%s", extras);
417
418   if (deliver_selectstring)
419     p += sprintf(CS p, " -R%s %s", deliver_selectstring_regex? "r" : "",
420       deliver_selectstring);
421
422   if (deliver_selectstring_sender)
423     p += sprintf(CS p, " -S%s %s", deliver_selectstring_sender_regex? "r" : "",
424       deliver_selectstring_sender);
425
426   log_detail = string_copy(big_buffer);
427   if (*queue_name)
428     log_write(L_queue_run, LOG_MAIN, "Start '%s' queue run: %s",
429       queue_name, log_detail);
430   else
431     log_write(L_queue_run, LOG_MAIN, "Start queue run: %s", log_detail);
432   }
433
434 /* If deliver_selectstring is a regex, compile it. */
435
436 if (deliver_selectstring && deliver_selectstring_regex)
437   selectstring_regex = regex_must_compile(deliver_selectstring, TRUE, FALSE);
438
439 if (deliver_selectstring_sender && deliver_selectstring_sender_regex)
440   selectstring_regex_sender =
441     regex_must_compile(deliver_selectstring_sender, TRUE, FALSE);
442
443 /* If the spool is split into subdirectories, we want to process it one
444 directory at a time, so as to spread out the directory scanning and the
445 delivering when there are lots of messages involved, except when
446 queue_run_in_order is set.
447
448 In the random order case, this loop runs once for the main directory (handling
449 any messages therein), and then repeats for any subdirectories that were found.
450 When the first argument of queue_get_spool_list() is 0, it scans the top
451 directory, fills in subdirs, and sets subcount. The order of the directories is
452 then randomized after the first time through, before they are scanned in
453 subsequent iterations.
454
455 When the first argument of queue_get_spool_list() is -1 (for queue_run_in_
456 order), it scans all directories and makes a single message list. */
457
458 for (i = queue_run_in_order ? -1 : 0;
459      i <= (queue_run_in_order ? -1 : subcount);
460      i++)
461   {
462   queue_filename *f;
463   void *reset_point1 = store_get(0);
464
465   DEBUG(D_queue_run)
466     {
467     if (i == 0)
468       debug_printf("queue running main directory\n");
469     else if (i == -1)
470       debug_printf("queue running combined directories\n");
471     else
472       debug_printf("queue running subdirectory '%c'\n", subdirs[i]);
473     }
474
475   for (f = queue_get_spool_list(i, subdirs, &subcount, !queue_run_in_order);
476        f;
477        f = f->next)
478     {
479     pid_t pid;
480     int status;
481     int pfd[2];
482     struct stat statbuf;
483     uschar buffer[256];
484
485     /* Unless deliveries are forced, if deliver_queue_load_max is non-negative,
486     check that the load average is low enough to permit deliveries. */
487
488     if (!queue_run_force && deliver_queue_load_max >= 0)
489       if ((load_average = os_getloadavg()) > deliver_queue_load_max)
490         {
491         log_write(L_queue_run, LOG_MAIN, "Abandon queue run: %s (load %.2f, max %.2f)",
492           log_detail,
493           (double)load_average/1000.0,
494           (double)deliver_queue_load_max/1000.0);
495         i = subcount;                 /* Don't process other directories */
496         break;
497         }
498       else
499         DEBUG(D_load) debug_printf("load average = %.2f max = %.2f\n",
500           (double)load_average/1000.0,
501           (double)deliver_queue_load_max/1000.0);
502
503     /* Skip this message unless it's within the ID limits */
504
505     if (stop_id && Ustrncmp(f->text, stop_id, MESSAGE_ID_LENGTH) > 0)
506       continue;
507     if (start_id && Ustrncmp(f->text, start_id, MESSAGE_ID_LENGTH) < 0)
508       continue;
509
510     /* Check that the message still exists */
511
512     message_subdir[0] = f->dir_uschar;
513     if (Ustat(spool_fname(US"input", message_subdir, f->text, US""), &statbuf) < 0)
514       continue;
515
516     /* There are some tests that require the reading of the header file. Ensure
517     the store used is scavenged afterwards so that this process doesn't keep
518     growing its store. We have to read the header file again when actually
519     delivering, but it's cheaper than forking a delivery process for each
520     message when many are not going to be delivered. */
521
522     if (deliver_selectstring || deliver_selectstring_sender ||
523         queue_run_first_delivery)
524       {
525       BOOL wanted = TRUE;
526       BOOL orig_dont_deliver = dont_deliver;
527       void *reset_point2 = store_get(0);
528
529       /* Restore the original setting of dont_deliver after reading the header,
530       so that a setting for a particular message doesn't force it for any that
531       follow. If the message is chosen for delivery, the header is read again
532       in the deliver_message() function, in a subprocess. */
533
534       if (spool_read_header(f->text, FALSE, TRUE) != spool_read_OK) continue;
535       dont_deliver = orig_dont_deliver;
536
537       /* Now decide if we want to deliver this message. As we have read the
538       header file, we might as well do the freeze test now, and save forking
539       another process. */
540
541       if (deliver_freeze && !deliver_force_thaw)
542         {
543         log_write(L_skip_delivery, LOG_MAIN, "Message is frozen");
544         wanted = FALSE;
545         }
546
547       /* Check first_delivery in the case when there are no message logs. */
548
549       else if (queue_run_first_delivery && !deliver_firsttime)
550         {
551         DEBUG(D_queue_run) debug_printf("%s: not first delivery\n", f->text);
552         wanted = FALSE;
553         }
554
555       /* Check for a matching address if deliver_selectstring[_sender] is set.
556       If so, we do a fully delivery - don't want to omit other addresses since
557       their routing might trigger re-writing etc. */
558
559       /* Sender matching */
560
561       else if (  deliver_selectstring_sender
562               && !(deliver_selectstring_sender_regex
563                   ? (pcre_exec(selectstring_regex_sender, NULL,
564                       CS sender_address, Ustrlen(sender_address), 0, PCRE_EOPT,
565                       NULL, 0) >= 0)
566                   : (strstric(sender_address, deliver_selectstring_sender, FALSE)
567                       != NULL)
568               )   )
569         {
570         DEBUG(D_queue_run) debug_printf("%s: sender address did not match %s\n",
571           f->text, deliver_selectstring_sender);
572         wanted = FALSE;
573         }
574
575       /* Recipient matching */
576
577       else if (deliver_selectstring)
578         {
579         int i;
580         for (i = 0; i < recipients_count; i++)
581           {
582           uschar *address = recipients_list[i].address;
583           if (  (deliver_selectstring_regex
584                 ? (pcre_exec(selectstring_regex, NULL, CS address,
585                      Ustrlen(address), 0, PCRE_EOPT, NULL, 0) >= 0)
586                 : (strstric(address, deliver_selectstring, FALSE) != NULL)
587                 )
588              && tree_search(tree_nonrecipients, address) == NULL
589              )
590             break;
591           }
592
593         if (i >= recipients_count)
594           {
595           DEBUG(D_queue_run)
596             debug_printf("%s: no recipient address matched %s\n",
597               f->text, deliver_selectstring);
598           wanted = FALSE;
599           }
600         }
601
602       /* Recover store used when reading the header */
603
604       received_protocol = NULL;
605       sender_address = sender_ident = NULL;
606       authenticated_id = authenticated_sender = NULL;
607       store_reset(reset_point2);
608       if (!wanted) continue;      /* With next message */
609       }
610
611     /* OK, got a message we want to deliver. Create a pipe which will
612     serve as a means of detecting when all the processes created by the
613     delivery process are finished. This is relevant when the delivery
614     process passes one or more SMTP channels on to its own children. The
615     pipe gets passed down; by reading on it here we detect when the last
616     descendent dies by the unblocking of the read. It's a pity that for
617     most of the time the pipe isn't used, but creating a pipe should be
618     pretty cheap. */
619
620     if (pipe(pfd) < 0)
621       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to create pipe in queue "
622         "runner process %d: %s", queue_run_pid, strerror(errno));
623     queue_run_pipe = pfd[pipe_write];  /* To ensure it gets passed on. */
624
625     /* Make sure it isn't stdin. This seems unlikely, but just to be on the
626     safe side... */
627
628     if (queue_run_pipe == 0)
629       {
630       queue_run_pipe = dup(queue_run_pipe);
631       (void)close(0);
632       }
633
634     /* Before forking to deliver the message, ensure any open and cached
635     lookup files or databases are closed. Otherwise, closing in the subprocess
636     can make the next subprocess have problems. There won't often be anything
637     open here, but it is possible (e.g. if spool_directory is an expanded
638     string). A single call before this loop would probably suffice, but just in
639     case expansions get inserted at some point, I've taken the heavy-handed
640     approach. When nothing is open, the call should be cheap. */
641
642     search_tidyup();
643
644     /* Now deliver the message; get the id by cutting the -H off the file
645     name. The return of the process is zero if a delivery was attempted. */
646
647     set_process_info("running queue: %s", f->text);
648     f->text[SPOOL_NAME_LENGTH-2] = 0;
649     if ((pid = fork()) == 0)
650       {
651       int rc;
652       if (running_in_test_harness) millisleep(100);
653       (void)close(pfd[pipe_read]);
654       rc = deliver_message(f->text, force_delivery, FALSE);
655       _exit(rc == DELIVER_NOT_ATTEMPTED);
656       }
657     if (pid < 0)
658       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork of delivery process from "
659         "queue runner %d failed\n", queue_run_pid);
660
661     /* Close the writing end of the synchronizing pipe in this process,
662     then wait for the first level process to terminate. */
663
664     (void)close(pfd[pipe_write]);
665     set_process_info("running queue: waiting for %s (%d)", f->text, pid);
666     while (wait(&status) != pid);
667
668     /* A zero return means a delivery was attempted; turn off the force flag
669     for any subsequent calls unless queue_force is set. */
670
671     if ((status & 0xffff) == 0) force_delivery = queue_run_force;
672
673     /* If the process crashed, tell somebody */
674
675     else if ((status & 0x00ff) != 0)
676       log_write(0, LOG_MAIN|LOG_PANIC,
677         "queue run: process %d crashed with signal %d while delivering %s",
678         (int)pid, status & 0x00ff, f->text);
679
680     /* Before continuing, wait till the pipe gets closed at the far end. This
681     tells us that any children created by the delivery to re-use any SMTP
682     channels have all finished. Since no process actually writes to the pipe,
683     the mere fact that read() unblocks is enough. */
684
685     set_process_info("running queue: waiting for children of %d", pid);
686     if ((status = read(pfd[pipe_read], buffer, sizeof(buffer))) != 0)
687       log_write(0, LOG_MAIN|LOG_PANIC, "queue run: %s on pipe",
688                 status > 0 ? "unexpected data" : "error");
689     (void)close(pfd[pipe_read]);
690     set_process_info("running queue");
691
692     /* If we are in the test harness, and this is not the first of a 2-stage
693     queue run, update fudged queue times. */
694
695     if (running_in_test_harness && !queue_2stage)
696       {
697       uschar *fqtnext = Ustrchr(fudged_queue_times, '/');
698       if (fqtnext != NULL) fudged_queue_times = fqtnext + 1;
699       }
700     }                                  /* End loop for list of messages */
701
702   tree_nonrecipients = NULL;
703   store_reset(reset_point1);           /* Scavenge list of messages */
704
705   /* If this was the first time through for random order processing, and
706   sub-directories have been found, randomize their order if necessary. */
707
708   if (i == 0 && subcount > 1 && !queue_run_in_order)
709     {
710     int j, r;
711     for (j = 1; j <= subcount; j++)
712       if ((r = random_number(100)) >= 50)
713         {
714         int k = (r % subcount) + 1;
715         int x = subdirs[j];
716         subdirs[j] = subdirs[k];
717         subdirs[k] = x;
718         }
719     }
720   }                                    /* End loop for multiple directories */
721
722 /* If queue_2stage is true, we do it all again, with the 2stage flag
723 turned off. */
724
725 if (queue_2stage)
726   {
727   queue_2stage = FALSE;
728   queue_run(start_id, stop_id, TRUE);
729   }
730
731 /* At top level, log the end of the run. */
732
733 if (!recurse)
734   if (*queue_name)
735     log_write(L_queue_run, LOG_MAIN, "End '%s' queue run: %s",
736       queue_name, log_detail);
737   else
738     log_write(L_queue_run, LOG_MAIN, "End queue run: %s", log_detail);
739 }
740
741
742
743
744 /************************************************
745 *         Count messages on the queue           *
746 ************************************************/
747
748 /* Called as a result of -bpc
749
750 Arguments:  none
751 Returns:    nothing
752 */
753
754 void
755 queue_count(void)
756 {
757 int subcount;
758 int count = 0;
759 queue_filename *f = NULL;
760 uschar subdirs[64];
761 f = queue_get_spool_list(
762         -1,             /* entire queue */
763         subdirs,        /* for holding sub list */
764         &subcount,      /* for subcount */
765         FALSE);         /* not random */
766 for (; f != NULL; f = f->next) count++;
767 fprintf(stdout, "%d\n", count);
768 }
769
770
771
772 /************************************************
773 *          List extra deliveries                *
774 ************************************************/
775
776 /* This is called from queue_list below to print out all addresses that
777 have received a message but which were not primary addresses. That is, all
778 the addresses in the tree of non-recipients that are not primary addresses.
779 The tree has been scanned and the data field filled in for those that are
780 primary addresses.
781
782 Argument:    points to the tree node
783 Returns:     nothing
784 */
785
786 static void queue_list_extras(tree_node *p)
787 {
788 if (p->left != NULL) queue_list_extras(p->left);
789 if (!p->data.val) printf("       +D %s\n", p->name);
790 if (p->right != NULL) queue_list_extras(p->right);
791 }
792
793
794
795 /************************************************
796 *          List messages on the queue           *
797 ************************************************/
798
799 /* Or a given list of messages. In the "all" case, we get a list of file names
800 as quickly as possible, then scan each one for information to output. If any
801 disappear while we are processing, just leave them out, but give an error if an
802 explicit list was given. This function is a top-level function that is obeyed
803 as a result of the -bp argument. As there may be a lot of messages on the
804 queue, we must tidy up the store after reading the headers for each one.
805
806 Arguments:
807    option     0 => list top-level recipients, with "D" for those delivered
808               1 => list only undelivered top-level recipients
809               2 => as 0, plus any generated delivered recipients
810               If 8 is added to any of these values, the queue is listed in
811                 random order.
812    list       => first of any message ids to list
813    count      count of message ids; 0 => all
814
815 Returns:      nothing
816 */
817
818 void
819 queue_list(int option, uschar **list, int count)
820 {
821 int i;
822 int subcount;
823 int now = (int)time(NULL);
824 void *reset_point;
825 queue_filename *f = NULL;
826 uschar subdirs[64];
827
828 /* If given a list of messages, build a chain containing their ids. */
829
830 if (count > 0)
831   {
832   queue_filename *last = NULL;
833   for (i = 0; i < count; i++)
834     {
835     queue_filename *next =
836       store_get(sizeof(queue_filename) + Ustrlen(list[i]) + 2);
837     sprintf(CS next->text, "%s-H", list[i]);
838     next->dir_uschar = '*';
839     next->next = NULL;
840     if (i == 0) f = next; else last->next = next;
841     last = next;
842     }
843   }
844
845 /* Otherwise get a list of the entire queue, in order if necessary. */
846
847 else
848   f = queue_get_spool_list(
849           -1,             /* entire queue */
850           subdirs,        /* for holding sub list */
851           &subcount,      /* for subcount */
852           option >= 8);   /* randomize if required */
853
854 if (option >= 8) option -= 8;
855
856 /* Now scan the chain and print information, resetting store used
857 each time. */
858
859 for (reset_point = store_get(0); f; f = f->next)
860   {
861   int rc, save_errno;
862   int size = 0;
863   BOOL env_read;
864
865   message_size = 0;
866   message_subdir[0] = f->dir_uschar;
867   rc = spool_read_header(f->text, FALSE, count <= 0);
868   if (rc == spool_read_notopen && errno == ENOENT && count <= 0) goto next;
869   save_errno = errno;
870
871   env_read = (rc == spool_read_OK || rc == spool_read_hdrerror);
872
873   if (env_read)
874     {
875     int ptr;
876     FILE *jread;
877     struct stat statbuf;
878     uschar * fname = spool_fname(US"input", message_subdir, f->text, US"");
879
880     ptr = Ustrlen(fname)-1;
881     fname[ptr] = 'D';
882
883     /* Add the data size to the header size; don't count the file name
884     at the start of the data file, but add one for the notional blank line
885     that precedes the data. */
886
887     if (Ustat(fname, &statbuf) == 0)
888       size = message_size + statbuf.st_size - SPOOL_DATA_START_OFFSET + 1;
889     i = (now - received_time.tv_sec)/60;  /* minutes on queue */
890     if (i > 90)
891       {
892       i = (i + 30)/60;
893       if (i > 72) printf("%2dd ", (i + 12)/24); else printf("%2dh ", i);
894       }
895     else printf("%2dm ", i);
896
897     /* Collect delivered addresses from any J file */
898
899     fname[ptr] = 'J';
900     if ((jread = Ufopen(fname, "rb")))
901       {
902       while (Ufgets(big_buffer, big_buffer_size, jread) != NULL)
903         {
904         int n = Ustrlen(big_buffer);
905         big_buffer[n-1] = 0;
906         tree_add_nonrecipient(big_buffer);
907         }
908       (void)fclose(jread);
909       }
910     }
911
912   fprintf(stdout, "%s ", string_format_size(size, big_buffer));
913   for (i = 0; i < 16; i++) fputc(f->text[i], stdout);
914
915   if (env_read && sender_address)
916     {
917     printf(" <%s>", sender_address);
918     if (sender_set_untrusted) printf(" (%s)", originator_login);
919     }
920
921   if (rc != spool_read_OK)
922     {
923     printf("\n    ");
924     if (save_errno == ERRNO_SPOOLFORMAT)
925       {
926       struct stat statbuf;
927       uschar * fname = spool_fname(US"input", message_subdir, f->text, US"");
928
929       if (Ustat(fname, &statbuf) == 0)
930         printf("*** spool format error: size=" OFF_T_FMT " ***",
931           statbuf.st_size);
932       else printf("*** spool format error ***");
933       }
934     else printf("*** spool read error: %s ***", strerror(save_errno));
935     if (rc != spool_read_hdrerror)
936       {
937       printf("\n\n");
938       goto next;
939       }
940     }
941
942   if (deliver_freeze) printf(" *** frozen ***");
943
944   printf("\n");
945
946   if (recipients_list)
947     {
948     for (i = 0; i < recipients_count; i++)
949       {
950       tree_node *delivered =
951         tree_search(tree_nonrecipients, recipients_list[i].address);
952       if (!delivered || option != 1)
953         printf("        %s %s\n", (delivered != NULL)? "D":" ",
954           recipients_list[i].address);
955       if (delivered) delivered->data.val = TRUE;
956       }
957     if (option == 2 && tree_nonrecipients)
958       queue_list_extras(tree_nonrecipients);
959     printf("\n");
960     }
961
962 next:
963   received_protocol = NULL;
964   sender_fullhost = sender_helo_name =
965   sender_rcvhost = sender_host_address = sender_address = sender_ident = NULL;
966   sender_host_authenticated = authenticated_sender = authenticated_id = NULL;
967   interface_address = NULL;
968   acl_var_m = NULL;
969
970   store_reset(reset_point);
971   }
972 }
973
974
975
976 /*************************************************
977 *             Act on a specific message          *
978 *************************************************/
979
980 /* Actions that require a list of addresses make use of argv/argc/
981 recipients_arg. Other actions do not. This function does its own
982 authority checking.
983
984 Arguments:
985   id              id of the message to work on
986   action          which action is required (MSG_xxx)
987   argv            the original argv for Exim
988   argc            the original argc for Exim
989   recipients_arg  offset to the list of recipients in argv
990
991 Returns:          FALSE if there was any problem
992 */
993
994 BOOL
995 queue_action(uschar *id, int action, uschar **argv, int argc, int recipients_arg)
996 {
997 int i, j;
998 BOOL yield = TRUE;
999 BOOL removed = FALSE;
1000 struct passwd *pw;
1001 uschar *doing = NULL;
1002 uschar *username;
1003 uschar *errmsg;
1004 uschar spoolname[32];
1005
1006 /* Set the global message_id variable, used when re-writing spool files. This
1007 also causes message ids to be added to log messages. */
1008
1009 Ustrcpy(message_id, id);
1010
1011 /* The "actions" that just list the files do not require any locking to be
1012 done. Only admin users may read the spool files. */
1013
1014 if (action >= MSG_SHOW_BODY)
1015   {
1016   int fd, i, rc;
1017   uschar *subdirectory, *suffix;
1018
1019   if (!admin_user)
1020     {
1021     printf("Permission denied\n");
1022     return FALSE;
1023     }
1024
1025   if (recipients_arg < argc)
1026     {
1027     printf("*** Only one message can be listed at once\n");
1028     return FALSE;
1029     }
1030
1031   if (action == MSG_SHOW_BODY)
1032     {
1033     subdirectory = US"input";
1034     suffix = US"-D";
1035     }
1036   else if (action == MSG_SHOW_HEADER)
1037     {
1038     subdirectory = US"input";
1039     suffix = US"-H";
1040     }
1041   else
1042     {
1043     subdirectory = US"msglog";
1044     suffix = US"";
1045     }
1046
1047   for (i = 0; i < 2; i++)
1048     {
1049     message_subdir[0] = split_spool_directory == (i == 0) ? id[5] : 0;
1050     if ((fd = Uopen(spool_fname(subdirectory, message_subdir, id, suffix),
1051                     O_RDONLY, 0)) >= 0)
1052       break;
1053     if (i == 0)
1054       continue;
1055
1056     printf("Failed to open %s file for %s%s: %s\n", subdirectory, id, suffix,
1057       strerror(errno));
1058     if (action == MSG_SHOW_LOG && !message_logs)
1059       printf("(No message logs are being created because the message_logs "
1060         "option is false.)\n");
1061     return FALSE;
1062     }
1063
1064   while((rc = read(fd, big_buffer, big_buffer_size)) > 0)
1065     rc = write(fileno(stdout), big_buffer, rc);
1066
1067   (void)close(fd);
1068   return TRUE;
1069   }
1070
1071 /* For actions that actually act, open and lock the data file to ensure that no
1072 other process is working on this message. If the file does not exist, continue
1073 only if the action is remove and the user is an admin user, to allow for
1074 tidying up broken states. */
1075
1076 if ((deliver_datafile = spool_open_datafile(id)) < 0)
1077   if (errno == ENOENT)
1078     {
1079     yield = FALSE;
1080     printf("Spool data file for %s does not exist\n", id);
1081     if (action != MSG_REMOVE || !admin_user) return FALSE;
1082     printf("Continuing, to ensure all files removed\n");
1083     }
1084   else
1085     {
1086     if (errno == 0) printf("Message %s is locked\n", id);
1087       else printf("Couldn't open spool file for %s: %s\n", id,
1088         strerror(errno));
1089     return FALSE;
1090     }
1091
1092 /* Read the spool header file for the message. Again, continue after an
1093 error only in the case of deleting by an administrator. Setting the third
1094 argument false causes it to look both in the main spool directory and in
1095 the appropriate subdirectory, and set message_subdir according to where it
1096 found the message. */
1097
1098 sprintf(CS spoolname, "%s-H", id);
1099 if (spool_read_header(spoolname, TRUE, FALSE) != spool_read_OK)
1100   {
1101   yield = FALSE;
1102   if (errno != ERRNO_SPOOLFORMAT)
1103     printf("Spool read error for %s: %s\n", spoolname, strerror(errno));
1104   else
1105     printf("Spool format error for %s\n", spoolname);
1106   if (action != MSG_REMOVE || !admin_user)
1107     {
1108     (void)close(deliver_datafile);
1109     deliver_datafile = -1;
1110     return FALSE;
1111     }
1112   printf("Continuing to ensure all files removed\n");
1113   }
1114
1115 /* Check that the user running this process is entitled to operate on this
1116 message. Only admin users may freeze/thaw, add/cancel recipients, or otherwise
1117 mess about, but the original sender is permitted to remove a message. That's
1118 why we leave this check until after the headers are read. */
1119
1120 if (!admin_user && (action != MSG_REMOVE || real_uid != originator_uid))
1121   {
1122   printf("Permission denied\n");
1123   (void)close(deliver_datafile);
1124   deliver_datafile = -1;
1125   return FALSE;
1126   }
1127
1128 /* Set up the user name for logging. */
1129
1130 pw = getpwuid(real_uid);
1131 username = (pw != NULL)?
1132   US pw->pw_name : string_sprintf("uid %ld", (long int)real_uid);
1133
1134 /* Take the necessary action. */
1135
1136 if (action != MSG_SHOW_COPY) printf("Message %s ", id);
1137
1138 switch(action)
1139   {
1140   case MSG_SHOW_COPY:
1141     {
1142     transport_ctx tctx = {{0}};
1143     deliver_in_buffer = store_malloc(DELIVER_IN_BUFFER_SIZE);
1144     deliver_out_buffer = store_malloc(DELIVER_OUT_BUFFER_SIZE);
1145     tctx.u.fd = 1;
1146     transport_write_message(&tctx, 0);
1147     break;
1148     }
1149
1150
1151   case MSG_FREEZE:
1152   if (deliver_freeze)
1153     {
1154     yield = FALSE;
1155     printf("is already frozen\n");
1156     }
1157   else
1158     {
1159     deliver_freeze = TRUE;
1160     deliver_manual_thaw = FALSE;
1161     deliver_frozen_at = time(NULL);
1162     if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1163       {
1164       printf("is now frozen\n");
1165       log_write(0, LOG_MAIN, "frozen by %s", username);
1166       }
1167     else
1168       {
1169       yield = FALSE;
1170       printf("could not be frozen: %s\n", errmsg);
1171       }
1172     }
1173   break;
1174
1175
1176   case MSG_THAW:
1177   if (!deliver_freeze)
1178     {
1179     yield = FALSE;
1180     printf("is not frozen\n");
1181     }
1182   else
1183     {
1184     deliver_freeze = FALSE;
1185     deliver_manual_thaw = TRUE;
1186     if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1187       {
1188       printf("is no longer frozen\n");
1189       log_write(0, LOG_MAIN, "unfrozen by %s", username);
1190       }
1191     else
1192       {
1193       yield = FALSE;
1194       printf("could not be unfrozen: %s\n", errmsg);
1195       }
1196     }
1197   break;
1198
1199
1200   /* We must ensure all files are removed from both the input directory
1201   and the appropriate subdirectory, to clean up cases when there are odd
1202   files left lying around in odd places. In the normal case message_subdir
1203   will have been set correctly by spool_read_header, but as this is a rare
1204   operation, just run everything twice. */
1205
1206   case MSG_REMOVE:
1207     {
1208     uschar suffix[3];
1209
1210     suffix[0] = '-';
1211     suffix[2] = 0;
1212     message_subdir[0] = id[5];
1213
1214     for (j = 0; j < 2; message_subdir[0] = 0, j++)
1215       {
1216       uschar * fname = spool_fname(US"msglog", message_subdir, id, US"");
1217
1218       DEBUG(D_any) debug_printf(" removing %s", fname);
1219       if (Uunlink(fname) < 0)
1220         {
1221         if (errno != ENOENT)
1222           {
1223           yield = FALSE;
1224           printf("Error while removing %s: %s\n", fname, strerror(errno));
1225           }
1226         else DEBUG(D_any) debug_printf(" (no file)\n");
1227         }
1228       else
1229         {
1230         removed = TRUE;
1231         DEBUG(D_any) debug_printf(" (ok)\n");
1232         }
1233
1234       for (i = 0; i < 3; i++)
1235         {
1236         uschar * fname;
1237
1238         suffix[1] = (US"DHJ")[i];
1239         fname = spool_fname(US"input", message_subdir, id, suffix);
1240
1241         DEBUG(D_any) debug_printf(" removing %s", fname);
1242         if (Uunlink(fname) < 0)
1243           {
1244           if (errno != ENOENT)
1245             {
1246             yield = FALSE;
1247             printf("Error while removing %s: %s\n", fname, strerror(errno));
1248             }
1249           else DEBUG(D_any) debug_printf(" (no file)\n");
1250           }
1251         else
1252           {
1253           removed = TRUE;
1254           DEBUG(D_any) debug_printf(" (done)\n");
1255           }
1256         }
1257       }
1258
1259     /* In the common case, the datafile is open (and locked), so give the
1260     obvious message. Otherwise be more specific. */
1261
1262     if (deliver_datafile >= 0) printf("has been removed\n");
1263       else printf("has been removed or did not exist\n");
1264     if (removed)
1265       {
1266       log_write(0, LOG_MAIN, "removed by %s", username);
1267       log_write(0, LOG_MAIN, "Completed");
1268       }
1269     break;
1270     }
1271
1272
1273   case MSG_MARK_ALL_DELIVERED:
1274   for (i = 0; i < recipients_count; i++)
1275     {
1276     tree_add_nonrecipient(recipients_list[i].address);
1277     }
1278   if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1279     {
1280     printf("has been modified\n");
1281     for (i = 0; i < recipients_count; i++)
1282       log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1283         recipients_list[i].address, username);
1284     }
1285   else
1286     {
1287     yield = FALSE;
1288     printf("- could not mark all delivered: %s\n", errmsg);
1289     }
1290   break;
1291
1292
1293   case MSG_EDIT_SENDER:
1294   if (recipients_arg < argc - 1)
1295     {
1296     yield = FALSE;
1297     printf("- only one sender address can be specified\n");
1298     break;
1299     }
1300   doing = US"editing sender";
1301   /* Fall through */
1302
1303   case MSG_ADD_RECIPIENT:
1304   if (doing == NULL) doing = US"adding recipient";
1305   /* Fall through */
1306
1307   case MSG_MARK_DELIVERED:
1308   if (doing == NULL) doing = US"marking as delivered";
1309
1310   /* Common code for EDIT_SENDER, ADD_RECIPIENT, & MARK_DELIVERED */
1311
1312   if (recipients_arg >= argc)
1313     {
1314     yield = FALSE;
1315     printf("- error while %s: no address given\n", doing);
1316     break;
1317     }
1318
1319   for (; recipients_arg < argc; recipients_arg++)
1320     {
1321     int start, end, domain;
1322     uschar *errmess;
1323     uschar *recipient =
1324       parse_extract_address(argv[recipients_arg], &errmess, &start, &end,
1325         &domain, (action == MSG_EDIT_SENDER));
1326
1327     if (recipient == NULL)
1328       {
1329       yield = FALSE;
1330       printf("- error while %s:\n  bad address %s: %s\n",
1331         doing, argv[recipients_arg], errmess);
1332       }
1333     else if (recipient[0] != 0 && domain == 0)
1334       {
1335       yield = FALSE;
1336       printf("- error while %s:\n  bad address %s: "
1337         "domain missing\n", doing, argv[recipients_arg]);
1338       }
1339     else
1340       {
1341       if (action == MSG_ADD_RECIPIENT)
1342         {
1343 #ifdef SUPPORT_I18N
1344         if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1345 #endif
1346         receive_add_recipient(recipient, -1);
1347         log_write(0, LOG_MAIN, "recipient <%s> added by %s",
1348           recipient, username);
1349         }
1350       else if (action == MSG_MARK_DELIVERED)
1351         {
1352         for (i = 0; i < recipients_count; i++)
1353           if (Ustrcmp(recipients_list[i].address, recipient) == 0) break;
1354         if (i >= recipients_count)
1355           {
1356           printf("- error while %s:\n  %s is not a recipient:"
1357             " message not updated\n", doing, recipient);
1358           yield = FALSE;
1359           }
1360         else
1361           {
1362           tree_add_nonrecipient(recipients_list[i].address);
1363           log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1364             recipient, username);
1365           }
1366         }
1367       else  /* MSG_EDIT_SENDER */
1368         {
1369 #ifdef SUPPORT_I18N
1370         if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1371 #endif
1372         sender_address = recipient;
1373         log_write(0, LOG_MAIN, "sender address changed to <%s> by %s",
1374           recipient, username);
1375         }
1376       }
1377     }
1378
1379   if (yield)
1380     if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1381       printf("has been modified\n");
1382     else
1383       {
1384       yield = FALSE;
1385       printf("- while %s: %s\n", doing, errmsg);
1386       }
1387
1388   break;
1389   }
1390
1391 /* Closing the datafile releases the lock and permits other processes
1392 to operate on the message (if it still exists). */
1393
1394 if (deliver_datafile >= 0)
1395   {
1396   (void)close(deliver_datafile);
1397   deliver_datafile = -1;
1398   }
1399 return yield;
1400 }
1401
1402
1403
1404 /*************************************************
1405 *       Check the queue_only_file condition      *
1406 *************************************************/
1407
1408 /* The queue_only_file option forces certain kinds of queueing if a given file
1409 exists.
1410
1411 Arguments:  none
1412 Returns:    nothing
1413 */
1414
1415 void
1416 queue_check_only(void)
1417 {
1418 BOOL *set;
1419 int sep = 0;
1420 struct stat statbuf;
1421 const uschar *s;
1422 uschar *ss, *name;
1423 uschar buffer[1024];
1424
1425 if (queue_only_file == NULL) return;
1426
1427 s = queue_only_file;
1428 while ((ss = string_nextinlist(&s, &sep, buffer, sizeof(buffer))) != NULL)
1429   {
1430   if (Ustrncmp(ss, "smtp", 4) == 0)
1431     {
1432     name = US"queue_smtp";
1433     set = &queue_smtp;
1434     ss += 4;
1435     }
1436   else
1437     {
1438     name = US"queue_only";
1439     set = &queue_only;
1440     }
1441
1442   if (Ustat(ss, &statbuf) == 0)
1443     {
1444     *set = TRUE;
1445     DEBUG(D_receive) debug_printf("%s set because %s exists\n", name, ss);
1446     }
1447   }
1448 }
1449
1450 #endif /*!COMPILE_UTILITY*/
1451
1452 /* End of queue.c */