ac1bb760411eed4b93477223fb41ef99fa5eeaaf
[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 = f.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 f.queue_smtp = f.queue_2stage;
394
395 queue_run_pid = getpid();
396 f.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 (f.queue_2stage) *p++ = 'q';
406   if (f.queue_run_first_delivery) *p++ = 'i';
407   if (f.queue_run_force) *p++ = 'f';
408   if (f.deliver_force_thaw) *p++ = 'f';
409   if (f.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", f.deliver_selectstring_regex? "r" : "",
420       deliver_selectstring);
421
422   if (deliver_selectstring_sender)
423     p += sprintf(CS p, " -S%s %s", f.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 && f.deliver_selectstring_regex)
437   selectstring_regex = regex_must_compile(deliver_selectstring, TRUE, FALSE);
438
439 if (deliver_selectstring_sender && f.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 * fq;
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 (fq = queue_get_spool_list(i, subdirs, &subcount, !queue_run_in_order);
476        fq;
477        fq = fq->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 (!f.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(fq->text, stop_id, MESSAGE_ID_LENGTH) > 0)
506       continue;
507     if (start_id && Ustrncmp(fq->text, start_id, MESSAGE_ID_LENGTH) < 0)
508       continue;
509
510     /* Check that the message still exists */
511
512     message_subdir[0] = fq->dir_uschar;
513     if (Ustat(spool_fname(US"input", message_subdir, fq->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         f.queue_run_first_delivery)
524       {
525       BOOL wanted = TRUE;
526       BOOL orig_dont_deliver = f.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(fq->text, FALSE, TRUE) != spool_read_OK) continue;
535       f.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 (f.deliver_freeze && !f.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 (f.queue_run_first_delivery && !f.deliver_firsttime)
550         {
551         DEBUG(D_queue_run) debug_printf("%s: not first delivery\n", fq->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               && !(f.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           fq->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 (  (f.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               fq->text, deliver_selectstring);
598           wanted = FALSE;
599           }
600         }
601
602       /* Recover store used when reading the header */
603
604       spool_clear_header_globals();
605       store_reset(reset_point2);
606       if (!wanted) continue;      /* With next message */
607       }
608
609     /* OK, got a message we want to deliver. Create a pipe which will
610     serve as a means of detecting when all the processes created by the
611     delivery process are finished. This is relevant when the delivery
612     process passes one or more SMTP channels on to its own children. The
613     pipe gets passed down; by reading on it here we detect when the last
614     descendent dies by the unblocking of the read. It's a pity that for
615     most of the time the pipe isn't used, but creating a pipe should be
616     pretty cheap. */
617
618     if (pipe(pfd) < 0)
619       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to create pipe in queue "
620         "runner process %d: %s", queue_run_pid, strerror(errno));
621     queue_run_pipe = pfd[pipe_write];  /* To ensure it gets passed on. */
622
623     /* Make sure it isn't stdin. This seems unlikely, but just to be on the
624     safe side... */
625
626     if (queue_run_pipe == 0)
627       {
628       queue_run_pipe = dup(queue_run_pipe);
629       (void)close(0);
630       }
631
632     /* Before forking to deliver the message, ensure any open and cached
633     lookup files or databases are closed. Otherwise, closing in the subprocess
634     can make the next subprocess have problems. There won't often be anything
635     open here, but it is possible (e.g. if spool_directory is an expanded
636     string). A single call before this loop would probably suffice, but just in
637     case expansions get inserted at some point, I've taken the heavy-handed
638     approach. When nothing is open, the call should be cheap. */
639
640     search_tidyup();
641
642     /* Now deliver the message; get the id by cutting the -H off the file
643     name. The return of the process is zero if a delivery was attempted. */
644
645     set_process_info("running queue: %s", fq->text);
646     fq->text[SPOOL_NAME_LENGTH-2] = 0;
647     if ((pid = fork()) == 0)
648       {
649       int rc;
650       if (f.running_in_test_harness) millisleep(100);
651       (void)close(pfd[pipe_read]);
652       rc = deliver_message(fq->text, force_delivery, FALSE);
653       _exit(rc == DELIVER_NOT_ATTEMPTED);
654       }
655     if (pid < 0)
656       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork of delivery process from "
657         "queue runner %d failed\n", queue_run_pid);
658
659     /* Close the writing end of the synchronizing pipe in this process,
660     then wait for the first level process to terminate. */
661
662     (void)close(pfd[pipe_write]);
663     set_process_info("running queue: waiting for %s (%d)", fq->text, pid);
664     while (wait(&status) != pid);
665
666     /* A zero return means a delivery was attempted; turn off the force flag
667     for any subsequent calls unless queue_force is set. */
668
669     if ((status & 0xffff) == 0) force_delivery = f.queue_run_force;
670
671     /* If the process crashed, tell somebody */
672
673     else if ((status & 0x00ff) != 0)
674       log_write(0, LOG_MAIN|LOG_PANIC,
675         "queue run: process %d crashed with signal %d while delivering %s",
676         (int)pid, status & 0x00ff, fq->text);
677
678     /* Before continuing, wait till the pipe gets closed at the far end. This
679     tells us that any children created by the delivery to re-use any SMTP
680     channels have all finished. Since no process actually writes to the pipe,
681     the mere fact that read() unblocks is enough. */
682
683     set_process_info("running queue: waiting for children of %d", pid);
684     if ((status = read(pfd[pipe_read], buffer, sizeof(buffer))) != 0)
685       log_write(0, LOG_MAIN|LOG_PANIC, "queue run: %s on pipe",
686                 status > 0 ? "unexpected data" : "error");
687     (void)close(pfd[pipe_read]);
688     set_process_info("running queue");
689
690     /* If we are in the test harness, and this is not the first of a 2-stage
691     queue run, update fudged queue times. */
692
693     if (f.running_in_test_harness && !f.queue_2stage)
694       {
695       uschar *fqtnext = Ustrchr(fudged_queue_times, '/');
696       if (fqtnext != NULL) fudged_queue_times = fqtnext + 1;
697       }
698     }                                  /* End loop for list of messages */
699
700   tree_nonrecipients = NULL;
701   store_reset(reset_point1);           /* Scavenge list of messages */
702
703   /* If this was the first time through for random order processing, and
704   sub-directories have been found, randomize their order if necessary. */
705
706   if (i == 0 && subcount > 1 && !queue_run_in_order)
707     {
708     int j, r;
709     for (j = 1; j <= subcount; j++)
710       if ((r = random_number(100)) >= 50)
711         {
712         int k = (r % subcount) + 1;
713         int x = subdirs[j];
714         subdirs[j] = subdirs[k];
715         subdirs[k] = x;
716         }
717     }
718   }                                    /* End loop for multiple directories */
719
720 /* If queue_2stage is true, we do it all again, with the 2stage flag
721 turned off. */
722
723 if (f.queue_2stage)
724   {
725   f.queue_2stage = FALSE;
726   queue_run(start_id, stop_id, TRUE);
727   }
728
729 /* At top level, log the end of the run. */
730
731 if (!recurse)
732   if (*queue_name)
733     log_write(L_queue_run, LOG_MAIN, "End '%s' queue run: %s",
734       queue_name, log_detail);
735   else
736     log_write(L_queue_run, LOG_MAIN, "End queue run: %s", log_detail);
737 }
738
739
740
741
742 /************************************************
743 *         Count messages on the queue           *
744 ************************************************/
745
746 /* Called as a result of -bpc
747
748 Arguments:  none
749 Returns:    nothing
750 */
751
752 void
753 queue_count(void)
754 {
755 int subcount;
756 int count = 0;
757 queue_filename *f = NULL;
758 uschar subdirs[64];
759 f = queue_get_spool_list(
760         -1,             /* entire queue */
761         subdirs,        /* for holding sub list */
762         &subcount,      /* for subcount */
763         FALSE);         /* not random */
764 for (; f != NULL; f = f->next) count++;
765 fprintf(stdout, "%d\n", count);
766 }
767
768
769
770 /************************************************
771 *          List extra deliveries                *
772 ************************************************/
773
774 /* This is called from queue_list below to print out all addresses that
775 have received a message but which were not primary addresses. That is, all
776 the addresses in the tree of non-recipients that are not primary addresses.
777 The tree has been scanned and the data field filled in for those that are
778 primary addresses.
779
780 Argument:    points to the tree node
781 Returns:     nothing
782 */
783
784 static void queue_list_extras(tree_node *p)
785 {
786 if (p->left != NULL) queue_list_extras(p->left);
787 if (!p->data.val) printf("       +D %s\n", p->name);
788 if (p->right != NULL) queue_list_extras(p->right);
789 }
790
791
792
793 /************************************************
794 *          List messages on the queue           *
795 ************************************************/
796
797 /* Or a given list of messages. In the "all" case, we get a list of file names
798 as quickly as possible, then scan each one for information to output. If any
799 disappear while we are processing, just leave them out, but give an error if an
800 explicit list was given. This function is a top-level function that is obeyed
801 as a result of the -bp argument. As there may be a lot of messages on the
802 queue, we must tidy up the store after reading the headers for each one.
803
804 Arguments:
805    option     0 => list top-level recipients, with "D" for those delivered
806               1 => list only undelivered top-level recipients
807               2 => as 0, plus any generated delivered recipients
808               If 8 is added to any of these values, the queue is listed in
809                 random order.
810    list       => first of any message ids to list
811    count      count of message ids; 0 => all
812
813 Returns:      nothing
814 */
815
816 void
817 queue_list(int option, uschar **list, int count)
818 {
819 int i;
820 int subcount;
821 int now = (int)time(NULL);
822 void *reset_point;
823 queue_filename * qf = NULL;
824 uschar subdirs[64];
825
826 /* If given a list of messages, build a chain containing their ids. */
827
828 if (count > 0)
829   {
830   queue_filename *last = NULL;
831   for (i = 0; i < count; i++)
832     {
833     queue_filename *next =
834       store_get(sizeof(queue_filename) + Ustrlen(list[i]) + 2);
835     sprintf(CS next->text, "%s-H", list[i]);
836     next->dir_uschar = '*';
837     next->next = NULL;
838     if (i == 0) qf = next; else last->next = next;
839     last = next;
840     }
841   }
842
843 /* Otherwise get a list of the entire queue, in order if necessary. */
844
845 else
846   qf = queue_get_spool_list(
847           -1,             /* entire queue */
848           subdirs,        /* for holding sub list */
849           &subcount,      /* for subcount */
850           option >= 8);   /* randomize if required */
851
852 if (option >= 8) option -= 8;
853
854 /* Now scan the chain and print information, resetting store used
855 each time. */
856
857 for (reset_point = store_get(0);
858     qf;
859     spool_clear_header_globals(), store_reset(reset_point), qf = qf->next
860     )
861   {
862   int rc, save_errno;
863   int size = 0;
864   BOOL env_read;
865
866   message_size = 0;
867   message_subdir[0] = qf->dir_uschar;
868   rc = spool_read_header(qf->text, FALSE, count <= 0);
869   if (rc == spool_read_notopen && errno == ENOENT && count <= 0)
870     continue;
871   save_errno = errno;
872
873   env_read = (rc == spool_read_OK || rc == spool_read_hdrerror);
874
875   if (env_read)
876     {
877     int ptr;
878     FILE *jread;
879     struct stat statbuf;
880     uschar * fname = spool_fname(US"input", message_subdir, qf->text, US"");
881
882     ptr = Ustrlen(fname)-1;
883     fname[ptr] = 'D';
884
885     /* Add the data size to the header size; don't count the file name
886     at the start of the data file, but add one for the notional blank line
887     that precedes the data. */
888
889     if (Ustat(fname, &statbuf) == 0)
890       size = message_size + statbuf.st_size - SPOOL_DATA_START_OFFSET + 1;
891     i = (now - received_time.tv_sec)/60;  /* minutes on queue */
892     if (i > 90)
893       {
894       i = (i + 30)/60;
895       if (i > 72) printf("%2dd ", (i + 12)/24); else printf("%2dh ", i);
896       }
897     else printf("%2dm ", i);
898
899     /* Collect delivered addresses from any J file */
900
901     fname[ptr] = 'J';
902     if ((jread = Ufopen(fname, "rb")))
903       {
904       while (Ufgets(big_buffer, big_buffer_size, jread) != NULL)
905         {
906         int n = Ustrlen(big_buffer);
907         big_buffer[n-1] = 0;
908         tree_add_nonrecipient(big_buffer);
909         }
910       (void)fclose(jread);
911       }
912     }
913
914   fprintf(stdout, "%s ", string_format_size(size, big_buffer));
915   for (i = 0; i < 16; i++) fputc(qf->text[i], stdout);
916
917   if (env_read && sender_address)
918     {
919     printf(" <%s>", sender_address);
920     if (f.sender_set_untrusted) printf(" (%s)", originator_login);
921     }
922
923   if (rc != spool_read_OK)
924     {
925     printf("\n    ");
926     if (save_errno == ERRNO_SPOOLFORMAT)
927       {
928       struct stat statbuf;
929       uschar * fname = spool_fname(US"input", message_subdir, qf->text, US"");
930
931       if (Ustat(fname, &statbuf) == 0)
932         printf("*** spool format error: size=" OFF_T_FMT " ***",
933           statbuf.st_size);
934       else printf("*** spool format error ***");
935       }
936     else printf("*** spool read error: %s ***", strerror(save_errno));
937     if (rc != spool_read_hdrerror)
938       {
939       printf("\n\n");
940       continue;
941       }
942     }
943
944   if (f.deliver_freeze) printf(" *** frozen ***");
945
946   printf("\n");
947
948   if (recipients_list)
949     {
950     for (i = 0; i < recipients_count; i++)
951       {
952       tree_node *delivered =
953         tree_search(tree_nonrecipients, recipients_list[i].address);
954       if (!delivered || option != 1)
955         printf("        %s %s\n",
956           delivered ? "D" : " ", recipients_list[i].address);
957       if (delivered) delivered->data.val = TRUE;
958       }
959     if (option == 2 && tree_nonrecipients)
960       queue_list_extras(tree_nonrecipients);
961     printf("\n");
962     }
963   }
964 }
965
966
967
968 /*************************************************
969 *             Act on a specific message          *
970 *************************************************/
971
972 /* Actions that require a list of addresses make use of argv/argc/
973 recipients_arg. Other actions do not. This function does its own
974 authority checking.
975
976 Arguments:
977   id              id of the message to work on
978   action          which action is required (MSG_xxx)
979   argv            the original argv for Exim
980   argc            the original argc for Exim
981   recipients_arg  offset to the list of recipients in argv
982
983 Returns:          FALSE if there was any problem
984 */
985
986 BOOL
987 queue_action(uschar *id, int action, uschar **argv, int argc, int recipients_arg)
988 {
989 int i, j;
990 BOOL yield = TRUE;
991 BOOL removed = FALSE;
992 struct passwd *pw;
993 uschar *doing = NULL;
994 uschar *username;
995 uschar *errmsg;
996 uschar spoolname[32];
997
998 /* Set the global message_id variable, used when re-writing spool files. This
999 also causes message ids to be added to log messages. */
1000
1001 Ustrcpy(message_id, id);
1002
1003 /* The "actions" that just list the files do not require any locking to be
1004 done. Only admin users may read the spool files. */
1005
1006 if (action >= MSG_SHOW_BODY)
1007   {
1008   int fd, i, rc;
1009   uschar *subdirectory, *suffix;
1010
1011   if (!f.admin_user)
1012     {
1013     printf("Permission denied\n");
1014     return FALSE;
1015     }
1016
1017   if (recipients_arg < argc)
1018     {
1019     printf("*** Only one message can be listed at once\n");
1020     return FALSE;
1021     }
1022
1023   if (action == MSG_SHOW_BODY)
1024     {
1025     subdirectory = US"input";
1026     suffix = US"-D";
1027     }
1028   else if (action == MSG_SHOW_HEADER)
1029     {
1030     subdirectory = US"input";
1031     suffix = US"-H";
1032     }
1033   else
1034     {
1035     subdirectory = US"msglog";
1036     suffix = US"";
1037     }
1038
1039   for (i = 0; i < 2; i++)
1040     {
1041     message_subdir[0] = split_spool_directory == (i == 0) ? id[5] : 0;
1042     if ((fd = Uopen(spool_fname(subdirectory, message_subdir, id, suffix),
1043                     O_RDONLY, 0)) >= 0)
1044       break;
1045     if (i == 0)
1046       continue;
1047
1048     printf("Failed to open %s file for %s%s: %s\n", subdirectory, id, suffix,
1049       strerror(errno));
1050     if (action == MSG_SHOW_LOG && !message_logs)
1051       printf("(No message logs are being created because the message_logs "
1052         "option is false.)\n");
1053     return FALSE;
1054     }
1055
1056   while((rc = read(fd, big_buffer, big_buffer_size)) > 0)
1057     rc = write(fileno(stdout), big_buffer, rc);
1058
1059   (void)close(fd);
1060   return TRUE;
1061   }
1062
1063 /* For actions that actually act, open and lock the data file to ensure that no
1064 other process is working on this message. If the file does not exist, continue
1065 only if the action is remove and the user is an admin user, to allow for
1066 tidying up broken states. */
1067
1068 if ((deliver_datafile = spool_open_datafile(id)) < 0)
1069   if (errno == ENOENT)
1070     {
1071     yield = FALSE;
1072     printf("Spool data file for %s does not exist\n", id);
1073     if (action != MSG_REMOVE || !f.admin_user) return FALSE;
1074     printf("Continuing, to ensure all files removed\n");
1075     }
1076   else
1077     {
1078     if (errno == 0) printf("Message %s is locked\n", id);
1079       else printf("Couldn't open spool file for %s: %s\n", id,
1080         strerror(errno));
1081     return FALSE;
1082     }
1083
1084 /* Read the spool header file for the message. Again, continue after an
1085 error only in the case of deleting by an administrator. Setting the third
1086 argument false causes it to look both in the main spool directory and in
1087 the appropriate subdirectory, and set message_subdir according to where it
1088 found the message. */
1089
1090 sprintf(CS spoolname, "%s-H", id);
1091 if (spool_read_header(spoolname, TRUE, FALSE) != spool_read_OK)
1092   {
1093   yield = FALSE;
1094   if (errno != ERRNO_SPOOLFORMAT)
1095     printf("Spool read error for %s: %s\n", spoolname, strerror(errno));
1096   else
1097     printf("Spool format error for %s\n", spoolname);
1098   if (action != MSG_REMOVE || !f.admin_user)
1099     {
1100     (void)close(deliver_datafile);
1101     deliver_datafile = -1;
1102     return FALSE;
1103     }
1104   printf("Continuing to ensure all files removed\n");
1105   }
1106
1107 /* Check that the user running this process is entitled to operate on this
1108 message. Only admin users may freeze/thaw, add/cancel recipients, or otherwise
1109 mess about, but the original sender is permitted to remove a message. That's
1110 why we leave this check until after the headers are read. */
1111
1112 if (!f.admin_user && (action != MSG_REMOVE || real_uid != originator_uid))
1113   {
1114   printf("Permission denied\n");
1115   (void)close(deliver_datafile);
1116   deliver_datafile = -1;
1117   return FALSE;
1118   }
1119
1120 /* Set up the user name for logging. */
1121
1122 pw = getpwuid(real_uid);
1123 username = (pw != NULL)?
1124   US pw->pw_name : string_sprintf("uid %ld", (long int)real_uid);
1125
1126 /* Take the necessary action. */
1127
1128 if (action != MSG_SHOW_COPY) printf("Message %s ", id);
1129
1130 switch(action)
1131   {
1132   case MSG_SHOW_COPY:
1133     {
1134     transport_ctx tctx = {{0}};
1135     deliver_in_buffer = store_malloc(DELIVER_IN_BUFFER_SIZE);
1136     deliver_out_buffer = store_malloc(DELIVER_OUT_BUFFER_SIZE);
1137     tctx.u.fd = 1;
1138     transport_write_message(&tctx, 0);
1139     break;
1140     }
1141
1142
1143   case MSG_FREEZE:
1144   if (f.deliver_freeze)
1145     {
1146     yield = FALSE;
1147     printf("is already frozen\n");
1148     }
1149   else
1150     {
1151     f.deliver_freeze = TRUE;
1152     f.deliver_manual_thaw = FALSE;
1153     deliver_frozen_at = time(NULL);
1154     if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1155       {
1156       printf("is now frozen\n");
1157       log_write(0, LOG_MAIN, "frozen by %s", username);
1158       }
1159     else
1160       {
1161       yield = FALSE;
1162       printf("could not be frozen: %s\n", errmsg);
1163       }
1164     }
1165   break;
1166
1167
1168   case MSG_THAW:
1169   if (!f.deliver_freeze)
1170     {
1171     yield = FALSE;
1172     printf("is not frozen\n");
1173     }
1174   else
1175     {
1176     f.deliver_freeze = FALSE;
1177     f.deliver_manual_thaw = TRUE;
1178     if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1179       {
1180       printf("is no longer frozen\n");
1181       log_write(0, LOG_MAIN, "unfrozen by %s", username);
1182       }
1183     else
1184       {
1185       yield = FALSE;
1186       printf("could not be unfrozen: %s\n", errmsg);
1187       }
1188     }
1189   break;
1190
1191
1192   /* We must ensure all files are removed from both the input directory
1193   and the appropriate subdirectory, to clean up cases when there are odd
1194   files left lying around in odd places. In the normal case message_subdir
1195   will have been set correctly by spool_read_header, but as this is a rare
1196   operation, just run everything twice. */
1197
1198   case MSG_REMOVE:
1199     {
1200     uschar suffix[3];
1201
1202     suffix[0] = '-';
1203     suffix[2] = 0;
1204     message_subdir[0] = id[5];
1205
1206     for (j = 0; j < 2; message_subdir[0] = 0, j++)
1207       {
1208       uschar * fname = spool_fname(US"msglog", message_subdir, id, US"");
1209
1210       DEBUG(D_any) debug_printf(" removing %s", fname);
1211       if (Uunlink(fname) < 0)
1212         {
1213         if (errno != ENOENT)
1214           {
1215           yield = FALSE;
1216           printf("Error while removing %s: %s\n", fname, strerror(errno));
1217           }
1218         else DEBUG(D_any) debug_printf(" (no file)\n");
1219         }
1220       else
1221         {
1222         removed = TRUE;
1223         DEBUG(D_any) debug_printf(" (ok)\n");
1224         }
1225
1226       for (i = 0; i < 3; i++)
1227         {
1228         uschar * fname;
1229
1230         suffix[1] = (US"DHJ")[i];
1231         fname = spool_fname(US"input", message_subdir, id, suffix);
1232
1233         DEBUG(D_any) debug_printf(" removing %s", fname);
1234         if (Uunlink(fname) < 0)
1235           {
1236           if (errno != ENOENT)
1237             {
1238             yield = FALSE;
1239             printf("Error while removing %s: %s\n", fname, strerror(errno));
1240             }
1241           else DEBUG(D_any) debug_printf(" (no file)\n");
1242           }
1243         else
1244           {
1245           removed = TRUE;
1246           DEBUG(D_any) debug_printf(" (done)\n");
1247           }
1248         }
1249       }
1250
1251     /* In the common case, the datafile is open (and locked), so give the
1252     obvious message. Otherwise be more specific. */
1253
1254     if (deliver_datafile >= 0) printf("has been removed\n");
1255       else printf("has been removed or did not exist\n");
1256     if (removed)
1257       {
1258 #ifndef DISABLE_EVENT
1259       for (i = 0; i < recipients_count; i++)
1260         {
1261         tree_node *delivered =
1262           tree_search(tree_nonrecipients, recipients_list[i].address);
1263         if (!delivered)
1264           {
1265           uschar * save_local = deliver_localpart;
1266           const uschar * save_domain = deliver_domain;
1267           uschar * addr = recipients_list[i].address, * errmsg = NULL;
1268           int start, end, dom;
1269
1270           if (!parse_extract_address(addr, &errmsg, &start, &end, &dom, TRUE))
1271             log_write(0, LOG_MAIN|LOG_PANIC,
1272               "failed to parse address '%.100s'\n: %s", addr, errmsg);
1273           else
1274             {
1275             deliver_localpart =
1276               string_copyn(addr+start, dom ? (dom-1) - start : end - start);
1277             deliver_domain = dom
1278               ? CUS string_copyn(addr+dom, end - dom) : CUS"";
1279
1280             event_raise(event_action, US"msg:fail:internal",
1281               string_sprintf("message removed by %s", username));
1282
1283             deliver_localpart = save_local;
1284             deliver_domain = save_domain;
1285             }
1286           }
1287         }
1288       (void) event_raise(event_action, US"msg:complete", NULL);
1289 #endif
1290       log_write(0, LOG_MAIN, "removed by %s", username);
1291       log_write(0, LOG_MAIN, "Completed");
1292       }
1293     break;
1294     }
1295
1296
1297   case MSG_MARK_ALL_DELIVERED:
1298   for (i = 0; i < recipients_count; i++)
1299     tree_add_nonrecipient(recipients_list[i].address);
1300
1301   if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1302     {
1303     printf("has been modified\n");
1304     for (i = 0; i < recipients_count; i++)
1305       log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1306         recipients_list[i].address, username);
1307     }
1308   else
1309     {
1310     yield = FALSE;
1311     printf("- could not mark all delivered: %s\n", errmsg);
1312     }
1313   break;
1314
1315
1316   case MSG_EDIT_SENDER:
1317   if (recipients_arg < argc - 1)
1318     {
1319     yield = FALSE;
1320     printf("- only one sender address can be specified\n");
1321     break;
1322     }
1323   doing = US"editing sender";
1324   /* Fall through */
1325
1326   case MSG_ADD_RECIPIENT:
1327   if (doing == NULL) doing = US"adding recipient";
1328   /* Fall through */
1329
1330   case MSG_MARK_DELIVERED:
1331   if (doing == NULL) doing = US"marking as delivered";
1332
1333   /* Common code for EDIT_SENDER, ADD_RECIPIENT, & MARK_DELIVERED */
1334
1335   if (recipients_arg >= argc)
1336     {
1337     yield = FALSE;
1338     printf("- error while %s: no address given\n", doing);
1339     break;
1340     }
1341
1342   for (; recipients_arg < argc; recipients_arg++)
1343     {
1344     int start, end, domain;
1345     uschar *errmess;
1346     uschar *recipient =
1347       parse_extract_address(argv[recipients_arg], &errmess, &start, &end,
1348         &domain, (action == MSG_EDIT_SENDER));
1349
1350     if (recipient == NULL)
1351       {
1352       yield = FALSE;
1353       printf("- error while %s:\n  bad address %s: %s\n",
1354         doing, argv[recipients_arg], errmess);
1355       }
1356     else if (recipient[0] != 0 && domain == 0)
1357       {
1358       yield = FALSE;
1359       printf("- error while %s:\n  bad address %s: "
1360         "domain missing\n", doing, argv[recipients_arg]);
1361       }
1362     else
1363       {
1364       if (action == MSG_ADD_RECIPIENT)
1365         {
1366 #ifdef SUPPORT_I18N
1367         if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1368 #endif
1369         receive_add_recipient(recipient, -1);
1370         log_write(0, LOG_MAIN, "recipient <%s> added by %s",
1371           recipient, username);
1372         }
1373       else if (action == MSG_MARK_DELIVERED)
1374         {
1375         for (i = 0; i < recipients_count; i++)
1376           if (Ustrcmp(recipients_list[i].address, recipient) == 0) break;
1377         if (i >= recipients_count)
1378           {
1379           printf("- error while %s:\n  %s is not a recipient:"
1380             " message not updated\n", doing, recipient);
1381           yield = FALSE;
1382           }
1383         else
1384           {
1385           tree_add_nonrecipient(recipients_list[i].address);
1386           log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1387             recipient, username);
1388           }
1389         }
1390       else  /* MSG_EDIT_SENDER */
1391         {
1392 #ifdef SUPPORT_I18N
1393         if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1394 #endif
1395         sender_address = recipient;
1396         log_write(0, LOG_MAIN, "sender address changed to <%s> by %s",
1397           recipient, username);
1398         }
1399       }
1400     }
1401
1402   if (yield)
1403     if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1404       printf("has been modified\n");
1405     else
1406       {
1407       yield = FALSE;
1408       printf("- while %s: %s\n", doing, errmsg);
1409       }
1410
1411   break;
1412   }
1413
1414 /* Closing the datafile releases the lock and permits other processes
1415 to operate on the message (if it still exists). */
1416
1417 if (deliver_datafile >= 0)
1418   {
1419   (void)close(deliver_datafile);
1420   deliver_datafile = -1;
1421   }
1422 return yield;
1423 }
1424
1425
1426
1427 /*************************************************
1428 *       Check the queue_only_file condition      *
1429 *************************************************/
1430
1431 /* The queue_only_file option forces certain kinds of queueing if a given file
1432 exists.
1433
1434 Arguments:  none
1435 Returns:    nothing
1436 */
1437
1438 void
1439 queue_check_only(void)
1440 {
1441 int sep = 0;
1442 struct stat statbuf;
1443 const uschar *s;
1444 uschar *ss;
1445 uschar buffer[1024];
1446
1447 if (queue_only_file == NULL) return;
1448
1449 s = queue_only_file;
1450 while ((ss = string_nextinlist(&s, &sep, buffer, sizeof(buffer))) != NULL)
1451   {
1452   if (Ustrncmp(ss, "smtp", 4) == 0)
1453     {
1454     ss += 4;
1455     if (Ustat(ss, &statbuf) == 0)
1456       {
1457       f.queue_smtp = TRUE;
1458       DEBUG(D_receive) debug_printf("queue_smtp set because %s exists\n", ss);
1459       }
1460     }
1461   else
1462     {
1463     if (Ustat(ss, &statbuf) == 0)
1464       {
1465       queue_only = TRUE;
1466       DEBUG(D_receive) debug_printf("queue_only set because %s exists\n", ss);
1467       }
1468     }
1469   }
1470 }
1471
1472 #endif /*!COMPILE_UTILITY*/
1473
1474 /* End of queue.c */