1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) The Exim Maintainers 2020 - 2022 */
6 /* Copyright (c) University of Cambridge 1995 - 2018 */
7 /* See the file NOTICE for conditions of use and distribution. */
8 /* SPDX-License-Identifier: GPL-2.0-or-later */
10 /* Functions that operate on the input queue. */
21 #ifndef COMPILE_UTILITY
23 /* The number of nodes to use for the bottom-up merge sort when a list of queue
24 items is to be ordered. The code for this sort was contributed as a patch by
27 #define LOG2_MAXNODES 32
31 static BOOL queue_tls_init = FALSE;
34 /*************************************************
35 * Helper sort function for queue_get_spool_list *
36 *************************************************/
38 /* This function is used when sorting the queue list in the function
39 queue_get_spool_list() below.
42 a points to an ordered list of queue_filename items
43 b points to another ordered list
45 Returns: a pointer to a merged ordered list
48 static queue_filename *
49 merge_queue_lists(queue_filename *a, queue_filename *b)
51 queue_filename *first = NULL;
52 queue_filename **append = &first;
57 if ((d = Ustrncmp(a->text, b->text, 6)) == 0)
58 d = Ustrcmp(a->text + 14, b->text + 14);
81 /*************************************************
82 * Get list of spool files *
83 *************************************************/
85 /* Scan the spool directory and return a list of the relevant file names
86 therein. Single-character sub-directories are handled as follows:
88 If the first argument is > 0, a sub-directory is scanned; the letter is
89 taken from the nth entry in subdirs.
91 If the first argument is 0, sub-directories are not scanned. However, a
92 list of them is returned.
94 If the first argument is < 0, sub-directories are scanned for messages,
95 and a single, unified list is created. The returned data blocks contain the
96 identifying character of the subdirectory, if any. The subdirs vector is
97 still required as an argument.
99 If the randomize argument is TRUE, messages are returned in "randomized" order.
100 Actually, the order is anything but random, but the algorithm is cheap, and the
101 point is simply to ensure that the same order doesn't occur every time, in case
102 a particular message is causing a remote MTA to barf - we would like to try
103 other messages to that MTA first.
105 If the randomize argument is FALSE, sort the list according to the file name.
106 This should give the order in which the messages arrived. It is normally used
107 only for presentation to humans, in which case the (possibly expensive) sort
108 that it does is not part of the normal operational code. However, if
109 queue_run_in_order is set, sorting has to take place for queue runs as well.
110 When randomize is FALSE, the first argument is normally -1, so all messages are
114 subdiroffset sub-directory character offset, or 0 or -1 (see above)
115 subdirs vector to store list of subdirchars
116 subcount pointer to int in which to store count of subdirs
117 randomize TRUE if the order of the list is to be unpredictable
118 pcount If not NULL, fill in with count of files and do not return list
120 Returns: pointer to a chain of queue name items
123 static queue_filename *
124 queue_get_spool_list(int subdiroffset, uschar *subdirs, int *subcount,
125 BOOL randomize, unsigned * pcount)
131 queue_filename *yield = NULL;
132 queue_filename *last = NULL;
134 queue_filename *root[LOG2_MAXNODES];
136 /* When randomizing, the file names are added to the start or end of the list
137 according to the bits of the flags variable. Get a collection of bits from the
138 current time. Use the bottom 16 and just keep re-using them if necessary. When
139 not randomizing, initialize the sublists for the bottom-up merge sort. */
144 resetflags = time(NULL) & 0xFFFF;
146 for (i = 0; i < LOG2_MAXNODES; i++)
149 /* If processing the full queue, or just the top-level, start at the base
150 directory, and initialize the first subdirectory name (as none). Otherwise,
151 start at the sub-directory offset. */
153 if (subdiroffset <= 0)
162 /* Set up prototype for the directory name. */
164 spool_pname_buf(buffer, sizeof(buffer));
165 buffer[sizeof(buffer) - 3] = 0;
166 subptr = Ustrlen(buffer);
167 buffer[subptr+2] = 0; /* terminator for lengthened name */
169 /* This loop runs at least once, for the main or given directory, and then as
170 many times as necessary to scan any subdirectories encountered in the main
171 directory, if they are to be scanned at this time. */
173 for (; i <= *subcount; i++)
176 int subdirchar = subdirs[i]; /* 0 for main directory */
181 buffer[subptr] = '/';
182 buffer[subptr+1] = subdirchar;
185 DEBUG(D_queue_run) debug_printf("looking in %s\n", buffer);
186 if (!(dd = exim_opendir(buffer)))
189 /* Now scan the directory. */
191 for (struct dirent *ent; ent = readdir(dd); )
193 uschar *name = US ent->d_name;
194 int len = Ustrlen(name);
200 /* If we find a single alphameric sub-directory in the base directory,
201 add it to the list for subsequent scans. */
203 if (i == 0 && len == 1 && isalnum(*name))
205 *subcount = *subcount + 1;
206 subdirs[*subcount] = *name;
210 /* Otherwise, if it is a header spool file, add it to the list */
212 if (len == SPOOL_NAME_LENGTH &&
213 Ustrcmp(name + SPOOL_NAME_LENGTH - 2, "-H") == 0)
218 queue_filename * next =
219 store_get(sizeof(queue_filename) + Ustrlen(name), name);
220 Ustrcpy(next->text, name);
221 next->dir_uschar = subdirchar;
223 /* Handle the creation of a randomized list. The first item becomes both
224 the top and bottom of the list. Subsequent items are inserted either at
225 the top or the bottom, randomly. This is, I argue, faster than doing a
226 sort by allocating a random number to each item, and it also saves having
227 to store the number with each item. */
239 if ((flags & 1) == 0)
253 /* Otherwise do a bottom-up merge sort based on the name. */
258 for (int j = 0; j < LOG2_MAXNODES; j++)
261 next = merge_queue_lists(next, root[j]);
262 root[j] = j == LOG2_MAXNODES - 1 ? next : NULL;
273 /* Finished with this directory */
277 /* If we have just scanned a sub-directory, and it was empty (count == 2
278 implies just "." and ".." entries), and Exim is no longer configured to
279 use sub-directories, attempt to get rid of it. At the same time, try to
280 get rid of any corresponding msglog subdirectory. These are just cosmetic
281 tidying actions, so just ignore failures. If we are scanning just a single
282 sub-directory, break the loop. */
286 if (!split_spool_directory && count <= 2)
291 subdir[0] = subdirchar; subdir[1] = 0;
292 rmdir(CS spool_dname(US"msglog", subdir));
294 if (subdiroffset > 0) break; /* Single sub-directory */
297 /* If we have just scanned the base directory, and subdiroffset is 0,
298 we do not want to continue scanning the sub-directories. */
300 else if (subdiroffset == 0)
302 } /* Loop for multiple subdirectories */
304 /* When using a bottom-up merge sort, do the final merging of the sublists.
305 Then pass back the final list of file items. */
307 if (!pcount && !randomize)
308 for (i = 0; i < LOG2_MAXNODES; ++i)
309 yield = merge_queue_lists(yield, root[i]);
317 /*************************************************
318 * Perform a queue run *
319 *************************************************/
321 /* The arguments give the messages to start and stop at; NULL means start at
322 the beginning or stop at the end. If the given start message doesn't exist, we
323 start at the next lexically greater one, and likewise we stop at the after the
324 previous lexically lesser one if the given stop message doesn't exist. Because
325 a queue run can take some time, stat each file before forking, in case it has
326 been delivered in the meantime by some other means.
328 The qrun descriptor variables queue_run_force and queue_run_local may be set to
329 cause forced deliveries or local-only deliveries, respectively.
331 If deliver_selectstring[_sender] is not NULL, skip messages whose recipients do
332 not contain the string. As this option is typically used when a machine comes
333 back online, we want to ensure that at least one delivery attempt takes place,
334 so force the first one. The selecting string can optionally be a regex, or
335 refer to the sender instead of recipients.
337 If queue_2stage is set, the queue is scanned twice. The first time, queue_smtp
338 is set so that routing is done for all messages. Thus in the second run those
339 that are routed to the same host should go down the same SMTP connection.
342 q queue-runner descriptor
343 start_id message id to start at, or NULL for all
344 stop_id message id to end at, or NULL for all
345 recurse TRUE if recursing for 2-stage run
351 queue_run(qrunner * q, uschar * start_id, uschar * stop_id, BOOL recurse)
353 BOOL force_delivery = q->queue_run_force
354 || deliver_selectstring || deliver_selectstring_sender;
355 const pcre2_code *selectstring_regex = NULL;
356 const pcre2_code *selectstring_regex_sender = NULL;
357 uschar *log_detail = NULL;
360 pid_t qpid[4] = {0}; /* Parallelism factor for q2stage 1st phase */
361 BOOL single_id = FALSE;
363 #ifdef MEASURE_TIMING
364 report_time_since(×tamp_startup, US"queue_run start");
367 /* Copy the legacy globals from the newer per-qrunner-desc */
369 queue_name = q->name ? q->name : US"";
370 f.queue_2stage = q->queue_2stage;
371 f.deliver_force_thaw = q->deliver_force_thaw;
372 f.queue_run_local = q->queue_run_local;
374 /* Cancel any specific queue domains. Turn off the flag that causes SMTP
375 deliveries not to happen, unless doing a 2-stage queue run, when the SMTP flag
376 gets set. Save the queue_runner's pid and the flag that indicates any
377 deliveries run directly from this process. Deliveries that are run by handing
378 on TCP/IP channels have queue_run_pid set, but not queue_running. */
380 queue_domains = NULL;
381 queue_smtp_domains = NULL;
382 f.queue_smtp = q->queue_2stage;
384 queue_run_pid = getpid();
385 f.queue_running = TRUE;
387 /* Log the true start of a queue run, and fancy options */
394 if (q->queue_2stage) *p++ = 'q';
395 if (q->queue_run_first_delivery) *p++ = 'i';
396 if (q->queue_run_force) *p++ = 'f';
397 if (q->deliver_force_thaw) *p++ = 'f';
398 if (q->queue_run_local) *p++ = 'l';
402 p += sprintf(CS p, "pid=%d", (int)queue_run_pid);
405 p += sprintf(CS p, " -q%s", extras);
407 if (deliver_selectstring)
409 snprintf(CS p, big_buffer_size - (p - big_buffer), " -R%s %s",
410 f.deliver_selectstring_regex ? "r" : "", deliver_selectstring);
414 if (deliver_selectstring_sender)
416 snprintf(CS p, big_buffer_size - (p - big_buffer), " -S%s %s",
417 f.deliver_selectstring_sender_regex ? "r" : "", deliver_selectstring_sender);
421 log_detail = string_copy(big_buffer);
423 log_write(L_queue_run, LOG_MAIN, "Start '%s' queue run: %s",
424 q->name, log_detail);
426 log_write(L_queue_run, LOG_MAIN, "Start queue run: %s", log_detail);
428 single_id = start_id && stop_id && !q->queue_2stage
429 && Ustrcmp(start_id, stop_id) == 0;
432 /* If deliver_selectstring is a regex, compile it. */
434 if (deliver_selectstring && f.deliver_selectstring_regex)
435 selectstring_regex = regex_must_compile(deliver_selectstring, MCS_CASELESS, FALSE);
437 if (deliver_selectstring_sender && f.deliver_selectstring_sender_regex)
438 selectstring_regex_sender =
439 regex_must_compile(deliver_selectstring_sender, MCS_CASELESS, FALSE);
441 /* If the spool is split into subdirectories, we want to process it one
442 directory at a time, so as to spread out the directory scanning and the
443 delivering when there are lots of messages involved, except when
444 queue_run_in_order is set.
446 In the random order case, this loop runs once for the main directory (handling
447 any messages therein), and then repeats for any subdirectories that were found.
448 When the first argument of queue_get_spool_list() is 0, it scans the top
449 directory, fills in subdirs, and sets subcount. The order of the directories is
450 then randomized after the first time through, before they are scanned in
451 subsequent iterations.
453 When the first argument of queue_get_spool_list() is -1 (for queue_run_in_
454 order), it scans all directories and makes a single message list. */
456 for (int i = queue_run_in_order ? -1 : 0;
457 i <= (queue_run_in_order ? -1 : subcount);
460 rmark reset_point1 = store_mark();
465 debug_printf("queue running main directory\n");
467 debug_printf("queue running combined directories\n");
469 debug_printf("queue running subdirectory '%c'\n", subdirs[i]);
472 for (queue_filename * fq = queue_get_spool_list(i, subdirs, &subcount,
473 !queue_run_in_order, NULL);
482 /* Unless deliveries are forced, if deliver_queue_load_max is non-negative,
483 check that the load average is low enough to permit deliveries. */
485 if (!q->queue_run_force && deliver_queue_load_max >= 0)
486 if ((load_average = os_getloadavg()) > deliver_queue_load_max)
488 log_write(L_queue_run, LOG_MAIN, "Abandon queue run: %s (load %.2f, max %.2f)",
490 (double)load_average/1000.0,
491 (double)deliver_queue_load_max/1000.0);
492 i = subcount; /* Don't process other directories */
496 DEBUG(D_load) debug_printf("load average = %.2f max = %.2f\n",
497 (double)load_average/1000.0,
498 (double)deliver_queue_load_max/1000.0);
500 /* If initial of a 2-phase run, maintain a set of child procs
501 to get disk parallelism */
503 if (q->queue_2stage && !queue_run_in_order)
506 if (qpid[f.running_in_test_harness ? 0 : nelem(qpid) - 1])
508 DEBUG(D_queue_run) debug_printf("q2stage waiting for child %d\n", (int)qpid[0]);
509 waitpid(qpid[0], NULL, 0);
510 DEBUG(D_queue_run) debug_printf("q2stage reaped child %d\n", (int)qpid[0]);
511 if (f.running_in_test_harness) i = 0;
512 else for (i = 0; i < nelem(qpid) - 1; i++) qpid[i] = qpid[i+1];
516 for (i = 0; qpid[i]; ) i++;
517 if ((qpid[i] = exim_fork(US"qrun-phase-one")))
518 continue; /* parent loops around */
521 /* Skip this message unless it's within the ID limits */
523 if (stop_id && Ustrncmp(fq->text, stop_id, MESSAGE_ID_LENGTH) > 0)
525 if (start_id && Ustrncmp(fq->text, start_id, MESSAGE_ID_LENGTH) < 0)
528 /* Check that the message still exists */
530 message_subdir[0] = fq->dir_uschar;
531 if (Ustat(spool_fname(US"input", message_subdir, fq->text, US""), &statbuf) < 0)
534 /* There are some tests that require the reading of the header file. Ensure
535 the store used is scavenged afterwards so that this process doesn't keep
536 growing its store. We have to read the header file again when actually
537 delivering, but it's cheaper than forking a delivery process for each
538 message when many are not going to be delivered. */
540 if (deliver_selectstring || deliver_selectstring_sender ||
541 q->queue_run_first_delivery)
544 BOOL orig_dont_deliver = f.dont_deliver;
545 rmark reset_point2 = store_mark();
547 /* Restore the original setting of dont_deliver after reading the header,
548 so that a setting for a particular message doesn't force it for any that
549 follow. If the message is chosen for delivery, the header is read again
550 in the deliver_message() function, in a subprocess. */
552 if (spool_read_header(fq->text, FALSE, TRUE) != spool_read_OK) goto go_around;
553 f.dont_deliver = orig_dont_deliver;
555 /* Now decide if we want to deliver this message. As we have read the
556 header file, we might as well do the freeze test now, and save forking
559 if (f.deliver_freeze && !q->deliver_force_thaw)
561 log_write(L_skip_delivery, LOG_MAIN, "Message is frozen");
565 /* Check first_delivery in the case when there are no message logs. */
567 else if (q->queue_run_first_delivery && !f.deliver_firsttime)
569 DEBUG(D_queue_run) debug_printf("%s: not first delivery\n", fq->text);
573 /* Check for a matching address if deliver_selectstring[_sender] is set.
574 If so, we do a fully delivery - don't want to omit other addresses since
575 their routing might trigger re-writing etc. */
577 /* Sender matching */
579 else if ( deliver_selectstring_sender
580 && !(f.deliver_selectstring_sender_regex
581 ? regex_match(selectstring_regex_sender, sender_address, -1, NULL)
582 : (strstric(sender_address, deliver_selectstring_sender, FALSE)
586 DEBUG(D_queue_run) debug_printf("%s: sender address did not match %s\n",
587 fq->text, deliver_selectstring_sender);
591 /* Recipient matching */
593 else if (deliver_selectstring)
596 for (i = 0; i < recipients_count; i++)
598 uschar *address = recipients_list[i].address;
599 if ( (f.deliver_selectstring_regex
600 ? regex_match(selectstring_regex, address, -1, NULL)
601 : (strstric(address, deliver_selectstring, FALSE) != NULL)
603 && tree_search(tree_nonrecipients, address) == NULL
608 if (i >= recipients_count)
611 debug_printf("%s: no recipient address matched %s\n",
612 fq->text, deliver_selectstring);
617 /* Recover store used when reading the header */
619 spool_clear_header_globals();
620 store_reset(reset_point2);
621 if (!wanted) goto go_around; /* With next message */
624 /* OK, got a message we want to deliver. Create a pipe which will
625 serve as a means of detecting when all the processes created by the
626 delivery process are finished. This is relevant when the delivery
627 process passes one or more SMTP channels on to its own children. The
628 pipe gets passed down; by reading on it here we detect when the last
629 descendent dies by the unblocking of the read. It's a pity that for
630 most of the time the pipe isn't used, but creating a pipe should be
634 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to create pipe in queue "
635 "runner process %d: %s", queue_run_pid, strerror(errno));
636 queue_run_pipe = pfd[pipe_write]; /* To ensure it gets passed on. */
638 /* Make sure it isn't stdin. This seems unlikely, but just to be on the
641 if (queue_run_pipe == 0)
643 queue_run_pipe = dup(queue_run_pipe);
647 /* Before forking to deliver the message, ensure any open and cached
648 lookup files or databases are closed. Otherwise, closing in the subprocess
649 can make the next subprocess have problems. There won't often be anything
650 open here, but it is possible (e.g. if spool_directory is an expanded
651 string). A single call before this loop would probably suffice, but just in
652 case expansions get inserted at some point, I've taken the heavy-handed
653 approach. When nothing is open, the call should be cheap. */
657 /* Now deliver the message; get the id by cutting the -H off the file
658 name. The return of the process is zero if a delivery was attempted. */
660 set_process_info("running queue: %s", fq->text);
661 fq->text[SPOOL_NAME_LENGTH-2] = 0;
662 #ifdef MEASURE_TIMING
663 report_time_since(×tamp_startup, US"queue msg selected");
669 queue_tls_init = TRUE;
670 /* Preload TLS library info for smtp transports. Once, and only if we
671 have a delivery to do. */
672 tls_client_creds_reload(FALSE);
677 if ((pid = exim_fork(US"qrun-delivery")) == 0)
680 (void)close(pfd[pipe_read]);
681 rc = deliver_message(fq->text, force_delivery, FALSE);
682 exim_underbar_exit(rc == DELIVER_NOT_ATTEMPTED
683 ? EXIT_FAILURE : EXIT_SUCCESS);
686 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork of delivery process from "
687 "queue runner %d failed\n", queue_run_pid);
689 /* Close the writing end of the synchronizing pipe in this process,
690 then wait for the first level process to terminate. */
692 (void)close(pfd[pipe_write]);
693 set_process_info("running queue: waiting for %s (%d)", fq->text, pid);
694 while (wait(&status) != pid);
696 /* A zero return means a delivery was attempted; turn off the force flag
697 for any subsequent calls unless queue_force is set. */
699 if (!(status & 0xffff)) force_delivery = q->queue_run_force;
701 /* If the process crashed, tell somebody */
703 else if (status & 0x00ff)
704 log_write(0, LOG_MAIN|LOG_PANIC,
705 "queue run: process %d crashed with signal %d while delivering %s",
706 (int)pid, status & 0x00ff, fq->text);
708 /* If single-item delivery was untried (likely due to locking)
709 retry once after a delay */
711 if (status & 0xff00 && single_id)
714 DEBUG(D_queue_run) debug_printf("qrun single-item pause before retry\n");
716 DEBUG(D_queue_run) debug_printf("qrun single-item retry after pause\n");
717 goto single_item_retry;
720 /* Before continuing, wait till the pipe gets closed at the far end. This
721 tells us that any children created by the delivery to re-use any SMTP
722 channels have all finished. Since no process actually writes to the pipe,
723 the mere fact that read() unblocks is enough. */
725 set_process_info("running queue: waiting for children of %d", pid);
726 if ((status = read(pfd[pipe_read], buffer, sizeof(buffer))) != 0)
727 log_write(0, LOG_MAIN|LOG_PANIC, status > 0 ?
728 "queue run: unexpected data on pipe" : "queue run: error on pipe: %s",
730 (void)close(pfd[pipe_read]);
731 set_process_info("running queue");
733 /* If initial of a 2-phase run, we are a child - so just exit */
734 if (q->queue_2stage && !queue_run_in_order)
735 exim_exit(EXIT_SUCCESS);
737 /* If we are in the test harness, and this is not the first of a 2-stage
738 queue run, update fudged queue times. */
740 if (f.running_in_test_harness && !q->queue_2stage)
742 uschar * fqtnext = Ustrchr(fudged_queue_times, '/');
743 if (fqtnext) fudged_queue_times = fqtnext + 1;
750 /* If initial of a 2-phase run, we are a child - so just exit */
751 if (q->queue_2stage && !queue_run_in_order)
752 exim_exit(EXIT_SUCCESS);
753 } /* End loop for list of messages */
755 tree_nonrecipients = NULL;
756 store_reset(reset_point1); /* Scavenge list of messages */
758 /* If this was the first time through for random order processing, and
759 sub-directories have been found, randomize their order if necessary. */
761 if (i == 0 && subcount > 1 && !queue_run_in_order)
762 for (int j = 1; j <= subcount; j++)
765 if ((r = random_number(100)) >= 50)
767 int k = (r % subcount) + 1;
769 subdirs[j] = subdirs[k];
773 } /* End loop for multiple directories */
775 /* If queue_2stage is true, we do it all again, with the 2stage flag
781 /* wait for last children */
782 for (int i = 0; i < nelem(qpid); i++)
785 DEBUG(D_queue_run) debug_printf("q2stage reaped child %d\n", (int)qpid[i]);
786 waitpid(qpid[i], NULL, 0);
790 #ifdef MEASURE_TIMING
791 report_time_since(×tamp_startup, US"queue_run 1st phase done");
793 q->queue_2stage = f.queue_2stage = FALSE;
794 queue_run(q, start_id, stop_id, TRUE);
797 /* At top level, log the end of the run. */
801 log_write(L_queue_run, LOG_MAIN, "End '%s' queue run: %s",
802 q->name, log_detail);
804 log_write(L_queue_run, LOG_MAIN, "End queue run: %s", log_detail);
810 single_queue_run(qrunner * q, uschar * start_id, uschar * stop_id)
812 DEBUG(D_queue_run) debug_printf("Single queue run%s%s%s%s\n",
813 start_id ? US" starting at " : US"",
814 start_id ? start_id: US"",
815 stop_id ? US" stopping at " : US"",
816 stop_id ? stop_id : US"");
819 set_process_info("running the '%s' queue (single queue run)", queue_name);
821 set_process_info("running the queue (single queue run)");
822 queue_run(q, start_id, stop_id, FALSE);
828 /************************************************
829 * Count messages on the queue *
830 ************************************************/
832 /* Called as a result of -bpc
845 (void) queue_get_spool_list(-1, /* entire queue */
846 subdirs, /* for holding sub list */
847 &subcount, /* for subcount */
848 FALSE, /* not random */
849 &count); /* just get the count */
854 #define QUEUE_SIZE_AGE 60 /* update rate for queue_size */
857 queue_count_cached(void)
860 if ((now = time(NULL)) >= queue_size_next)
862 queue_size = queue_count();
863 queue_size_next = now + (f.running_in_test_harness ? 3 : QUEUE_SIZE_AGE);
868 /************************************************
869 * List extra deliveries *
870 ************************************************/
872 /* This is called from queue_list below to print out all addresses that
873 have received a message but which were not primary addresses. That is, all
874 the addresses in the tree of non-recipients that are not primary addresses.
875 The tree has been scanned and the data field filled in for those that are
878 Argument: points to the tree node
883 queue_list_extras(tree_node *p)
885 if (p->left) queue_list_extras(p->left);
886 if (!p->data.val) printf(" +D %s\n", p->name);
887 if (p->right) queue_list_extras(p->right);
892 /************************************************
893 * List messages on the queue *
894 ************************************************/
896 /* Or a given list of messages. In the "all" case, we get a list of file names
897 as quickly as possible, then scan each one for information to output. If any
898 disappear while we are processing, just leave them out, but give an error if an
899 explicit list was given. This function is a top-level function that is obeyed
900 as a result of the -bp argument. As there may be a lot of messages on the
901 queue, we must tidy up the store after reading the headers for each one.
904 option 0 => list top-level recipients, with "D" for those delivered
905 1 => list only undelivered top-level recipients
906 2 => as 0, plus any generated delivered recipients
907 If 8 is added to any of these values, the queue is listed in
909 list => first of any message ids to list
910 count count of message ids; 0 => all
916 queue_list(int option, uschar **list, int count)
919 int now = (int)time(NULL);
921 queue_filename * qf = NULL;
924 /* If given a list of messages, build a chain containing their ids. */
928 queue_filename *last = NULL;
929 for (int i = 0; i < count; i++)
931 queue_filename * next =
932 store_get(sizeof(queue_filename) + Ustrlen(list[i]) + 2, list[i]);
933 sprintf(CS next->text, "%s-H", list[i]);
934 next->dir_uschar = '*';
936 if (i == 0) qf = next; else last->next = next;
941 /* Otherwise get a list of the entire queue, in order if necessary. */
944 qf = queue_get_spool_list(
945 -1, /* entire queue */
946 subdirs, /* for holding sub list */
947 &subcount, /* for subcount */
948 option >= 8, /* randomize if required */
949 NULL); /* don't just count */
951 if (option >= 8) option -= 8;
953 /* Now scan the chain and print information, resetting store used
957 qf && (reset_point = store_mark());
958 spool_clear_header_globals(), store_reset(reset_point), qf = qf->next
966 message_subdir[0] = qf->dir_uschar;
967 rc = spool_read_header(qf->text, FALSE, count <= 0);
968 if (rc == spool_read_notopen && errno == ENOENT && count <= 0)
972 env_read = (rc == spool_read_OK || rc == spool_read_hdrerror);
979 uschar * fname = spool_fname(US"input", message_subdir, qf->text, US"");
981 ptr = Ustrlen(fname)-1;
984 /* Add the data size to the header size; don't count the file name
985 at the start of the data file, but add one for the notional blank line
986 that precedes the data. */
988 if (Ustat(fname, &statbuf) == 0)
989 size = message_size + statbuf.st_size - SPOOL_DATA_START_OFFSET + 1;
990 i = (now - received_time.tv_sec)/60; /* minutes on queue */
994 if (i > 72) printf("%2dd ", (i + 12)/24); else printf("%2dh ", i);
996 else printf("%2dm ", i);
998 /* Collect delivered addresses from any J file */
1001 if ((jread = Ufopen(fname, "rb")))
1003 while (Ufgets(big_buffer, big_buffer_size, jread) != NULL)
1005 int n = Ustrlen(big_buffer);
1006 big_buffer[n-1] = 0;
1007 tree_add_nonrecipient(big_buffer);
1009 (void)fclose(jread);
1013 fprintf(stdout, "%s ", string_format_size(size, big_buffer));
1014 for (int i = 0; i < 16; i++) fputc(qf->text[i], stdout);
1016 if (env_read && sender_address)
1018 printf(" <%s>", sender_address);
1019 if (f.sender_set_untrusted) printf(" (%s)", originator_login);
1022 if (rc != spool_read_OK)
1025 if (save_errno == ERRNO_SPOOLFORMAT)
1027 struct stat statbuf;
1028 uschar * fname = spool_fname(US"input", message_subdir, qf->text, US"");
1030 if (Ustat(fname, &statbuf) == 0)
1031 printf("*** spool format error: size=" OFF_T_FMT " ***",
1033 else printf("*** spool format error ***");
1035 else printf("*** spool read error: %s ***", strerror(save_errno));
1036 if (rc != spool_read_hdrerror)
1043 if (f.deliver_freeze) printf(" *** frozen ***");
1047 if (recipients_list)
1049 for (int i = 0; i < recipients_count; i++)
1051 tree_node *delivered =
1052 tree_search(tree_nonrecipients, recipients_list[i].address);
1053 if (!delivered || option != 1)
1055 delivered ? "D" : " ", recipients_list[i].address);
1056 if (delivered) delivered->data.val = TRUE;
1058 if (option == 2 && tree_nonrecipients)
1059 queue_list_extras(tree_nonrecipients);
1067 /*************************************************
1068 * Act on a specific message *
1069 *************************************************/
1071 /* Actions that require a list of addresses make use of argv/argc/
1072 recipients_arg. Other actions do not. This function does its own
1076 id id of the message to work on
1077 action which action is required (MSG_xxx)
1078 argv the original argv for Exim
1079 argc the original argc for Exim
1080 recipients_arg offset to the list of recipients in argv
1082 Returns: FALSE if there was any problem
1086 queue_action(uschar *id, int action, uschar **argv, int argc, int recipients_arg)
1089 BOOL removed = FALSE;
1091 uschar *doing = NULL;
1094 uschar spoolname[32];
1096 /* Set the global message_id variable, used when re-writing spool files. This
1097 also causes message ids to be added to log messages. */
1099 Ustrcpy(message_id, id);
1101 /* The "actions" that just list the files do not require any locking to be
1102 done. Only admin users may read the spool files. */
1104 if (action >= MSG_SHOW_BODY)
1107 uschar *subdirectory, *suffix;
1111 printf("Permission denied\n");
1115 if (recipients_arg < argc)
1117 printf("*** Only one message can be listed at once\n");
1121 if (action == MSG_SHOW_BODY)
1123 subdirectory = US"input";
1126 else if (action == MSG_SHOW_HEADER)
1128 subdirectory = US"input";
1133 subdirectory = US"msglog";
1137 for (int i = 0; i < 2; i++)
1139 set_subdir_str(message_subdir, id, i);
1140 if ((fd = Uopen(spool_fname(subdirectory, message_subdir, id, suffix),
1146 printf("Failed to open %s file for %s%s: %s\n", subdirectory, id, suffix,
1148 if (action == MSG_SHOW_LOG && !message_logs)
1149 printf("(No message logs are being created because the message_logs "
1150 "option is false.)\n");
1154 while((rc = read(fd, big_buffer, big_buffer_size)) > 0)
1155 rc = write(fileno(stdout), big_buffer, rc);
1161 /* For actions that actually act, open and lock the data file to ensure that no
1162 other process is working on this message. If the file does not exist, continue
1163 only if the action is remove and the user is an admin user, to allow for
1164 tidying up broken states. */
1166 if ((deliver_datafile = spool_open_datafile(id)) < 0)
1167 if (errno == ENOENT)
1170 printf("Spool data file for %s does not exist\n", id);
1171 if (action != MSG_REMOVE || !f.admin_user) return FALSE;
1172 printf("Continuing, to ensure all files removed\n");
1176 if (errno == 0) printf("Message %s is locked\n", id);
1177 else printf("Couldn't open spool file for %s: %s\n", id,
1182 /* Read the spool header file for the message. Again, continue after an
1183 error only in the case of deleting by an administrator. Setting the third
1184 argument false causes it to look both in the main spool directory and in
1185 the appropriate subdirectory, and set message_subdir according to where it
1186 found the message. */
1188 sprintf(CS spoolname, "%s-H", id);
1189 if (spool_read_header(spoolname, TRUE, FALSE) != spool_read_OK)
1192 if (errno != ERRNO_SPOOLFORMAT)
1193 printf("Spool read error for %s: %s\n", spoolname, strerror(errno));
1195 printf("Spool format error for %s\n", spoolname);
1196 if (action != MSG_REMOVE || !f.admin_user)
1198 (void)close(deliver_datafile);
1199 deliver_datafile = -1;
1202 printf("Continuing to ensure all files removed\n");
1205 /* Check that the user running this process is entitled to operate on this
1206 message. Only admin users may freeze/thaw, add/cancel recipients, or otherwise
1207 mess about, but the original sender is permitted to remove a message. That's
1208 why we leave this check until after the headers are read. */
1210 if (!f.admin_user && (action != MSG_REMOVE || real_uid != originator_uid))
1212 printf("Permission denied\n");
1213 (void)close(deliver_datafile);
1214 deliver_datafile = -1;
1218 /* Set up the user name for logging. */
1220 pw = getpwuid(real_uid);
1221 username = (pw != NULL)?
1222 US pw->pw_name : string_sprintf("uid %ld", (long int)real_uid);
1224 /* Take the necessary action. */
1226 if (action != MSG_SHOW_COPY) printf("Message %s ", id);
1232 transport_ctx tctx = {{0}};
1233 deliver_in_buffer = store_malloc(DELIVER_IN_BUFFER_SIZE);
1234 deliver_out_buffer = store_malloc(DELIVER_OUT_BUFFER_SIZE);
1236 (void) transport_write_message(&tctx, 0);
1242 if (f.deliver_freeze)
1245 printf("is already frozen\n");
1249 f.deliver_freeze = TRUE;
1250 f.deliver_manual_thaw = FALSE;
1251 deliver_frozen_at = time(NULL);
1252 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1254 printf("is now frozen\n");
1255 log_write(0, LOG_MAIN, "frozen by %s", username);
1260 printf("could not be frozen: %s\n", errmsg);
1267 if (!f.deliver_freeze)
1270 printf("is not frozen\n");
1274 f.deliver_freeze = FALSE;
1275 f.deliver_manual_thaw = TRUE;
1276 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1278 printf("is no longer frozen\n");
1279 log_write(0, LOG_MAIN, "unfrozen by %s", username);
1284 printf("could not be unfrozen: %s\n", errmsg);
1290 /* We must ensure all files are removed from both the input directory
1291 and the appropriate subdirectory, to clean up cases when there are odd
1292 files left lying around in odd places. In the normal case message_subdir
1293 will have been set correctly by spool_read_header, but as this is a rare
1294 operation, just run everything twice. */
1302 message_subdir[0] = id[5];
1304 for (int j = 0; j < 2; message_subdir[0] = 0, j++)
1306 uschar * fname = spool_fname(US"msglog", message_subdir, id, US"");
1308 DEBUG(D_any) debug_printf(" removing %s", fname);
1309 if (Uunlink(fname) < 0)
1311 if (errno != ENOENT)
1314 printf("Error while removing %s: %s\n", fname, strerror(errno));
1316 else DEBUG(D_any) debug_printf(" (no file)\n");
1321 DEBUG(D_any) debug_printf(" (ok)\n");
1324 for (int i = 0; i < 3; i++)
1328 suffix[1] = (US"DHJ")[i];
1329 fname = spool_fname(US"input", message_subdir, id, suffix);
1331 DEBUG(D_any) debug_printf(" removing %s", fname);
1332 if (Uunlink(fname) < 0)
1334 if (errno != ENOENT)
1337 printf("Error while removing %s: %s\n", fname, strerror(errno));
1339 else DEBUG(D_any) debug_printf(" (no file)\n");
1344 DEBUG(D_any) debug_printf(" (done)\n");
1349 /* In the common case, the datafile is open (and locked), so give the
1350 obvious message. Otherwise be more specific. */
1352 if (deliver_datafile >= 0) printf("has been removed\n");
1353 else printf("has been removed or did not exist\n");
1356 #ifndef DISABLE_EVENT
1357 if (event_action) for (int i = 0; i < recipients_count; i++)
1359 tree_node *delivered =
1360 tree_search(tree_nonrecipients, recipients_list[i].address);
1363 uschar * save_local = deliver_localpart;
1364 const uschar * save_domain = deliver_domain;
1365 uschar * addr = recipients_list[i].address, * errmsg = NULL;
1366 int start, end, dom;
1368 if (!parse_extract_address(addr, &errmsg, &start, &end, &dom, TRUE))
1369 log_write(0, LOG_MAIN|LOG_PANIC,
1370 "failed to parse address '%.100s'\n: %s", addr, errmsg);
1374 string_copyn(addr+start, dom ? (dom-1) - start : end - start);
1375 deliver_domain = dom
1376 ? CUS string_copyn(addr+dom, end - dom) : CUS"";
1378 (void) event_raise(event_action, US"msg:fail:internal",
1379 string_sprintf("message removed by %s", username), NULL);
1381 deliver_localpart = save_local;
1382 deliver_domain = save_domain;
1386 (void) event_raise(event_action, US"msg:complete", NULL, NULL);
1388 log_write(0, LOG_MAIN, "removed by %s", username);
1389 log_write(0, LOG_MAIN, "Completed");
1396 /* The global "queue_name_dest" is used as destination, "queue_name"
1399 spool_move_message(id, message_subdir, US"", US"");
1403 case MSG_MARK_ALL_DELIVERED:
1404 for (int i = 0; i < recipients_count; i++)
1405 tree_add_nonrecipient(recipients_list[i].address);
1407 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1409 printf("has been modified\n");
1410 for (int i = 0; i < recipients_count; i++)
1411 log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1412 recipients_list[i].address, username);
1417 printf("- could not mark all delivered: %s\n", errmsg);
1422 case MSG_EDIT_SENDER:
1423 if (recipients_arg < argc - 1)
1426 printf("- only one sender address can be specified\n");
1429 doing = US"editing sender";
1432 case MSG_ADD_RECIPIENT:
1433 if (doing == NULL) doing = US"adding recipient";
1436 case MSG_MARK_DELIVERED:
1437 if (doing == NULL) doing = US"marking as delivered";
1439 /* Common code for EDIT_SENDER, ADD_RECIPIENT, & MARK_DELIVERED */
1441 if (recipients_arg >= argc)
1444 printf("- error while %s: no address given\n", doing);
1448 for (; recipients_arg < argc; recipients_arg++)
1450 int start, end, domain;
1453 parse_extract_address(argv[recipients_arg], &errmess, &start, &end,
1454 &domain, (action == MSG_EDIT_SENDER));
1459 printf("- error while %s:\n bad address %s: %s\n",
1460 doing, argv[recipients_arg], errmess);
1462 else if (*recipient && domain == 0)
1465 printf("- error while %s:\n bad address %s: "
1466 "domain missing\n", doing, argv[recipients_arg]);
1470 if (action == MSG_ADD_RECIPIENT)
1473 if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1475 receive_add_recipient(recipient, -1);
1476 log_write(0, LOG_MAIN, "recipient <%s> added by %s",
1477 recipient, username);
1479 else if (action == MSG_MARK_DELIVERED)
1482 for (i = 0; i < recipients_count; i++)
1483 if (Ustrcmp(recipients_list[i].address, recipient) == 0) break;
1484 if (i >= recipients_count)
1486 printf("- error while %s:\n %s is not a recipient:"
1487 " message not updated\n", doing, recipient);
1492 tree_add_nonrecipient(recipients_list[i].address);
1493 log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1494 recipient, username);
1497 else /* MSG_EDIT_SENDER */
1500 if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1502 sender_address = recipient;
1503 log_write(0, LOG_MAIN, "sender address changed to <%s> by %s",
1504 recipient, username);
1510 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1511 printf("has been modified\n");
1515 printf("- while %s: %s\n", doing, errmsg);
1521 /* Closing the datafile releases the lock and permits other processes
1522 to operate on the message (if it still exists). */
1524 if (deliver_datafile >= 0)
1526 (void)close(deliver_datafile);
1527 deliver_datafile = -1;
1534 /*************************************************
1535 * Check the queue_only_file condition *
1536 *************************************************/
1538 /* The queue_only_file option forces certain kinds of queueing if a given file
1546 queue_check_only(void)
1549 struct stat statbuf;
1550 const uschar * s = queue_only_file;
1554 while ((ss = string_nextinlist(&s, &sep, NULL, 0)))
1555 if (Ustrncmp(ss, "smtp", 4) == 0)
1558 if (Ustat(ss, &statbuf) == 0)
1560 f.queue_smtp = TRUE;
1561 DEBUG(D_receive) debug_printf("queue_smtp set because %s exists\n", ss);
1565 if (Ustat(ss, &statbuf) == 0)
1568 DEBUG(D_receive) debug_printf("queue_only set because %s exists\n", ss);
1574 /******************************************************************************/
1575 /******************************************************************************/
1577 #ifndef DISABLE_QUEUE_RAMP
1579 queue_notify_daemon(const uschar * msgid)
1581 int bsize = 1 + MESSAGE_ID_LENGTH + 1 + Ustrlen(queue_name) + 1;
1582 uschar * buf = store_get(bsize, GET_UNTAINTED);
1585 DEBUG(D_queue_run) debug_printf("%s: %s\n", __FUNCTION__, msgid);
1587 buf[0] = NOTIFY_MSG_QRUN;
1588 memcpy(buf+1, msgid, MESSAGE_ID_LENGTH+1);
1589 Ustrcpy(buf+1+MESSAGE_ID_LENGTH+1, queue_name);
1591 if ((fd = socket(AF_UNIX, SOCK_DGRAM, 0)) >= 0)
1593 struct sockaddr_un sa_un = {.sun_family = AF_UNIX};
1594 ssize_t len = daemon_notifier_sockname(&sa_un);
1596 if (sendto(fd, buf, bsize, 0, (struct sockaddr *)&sa_un, (socklen_t)len) < 0)
1598 debug_printf("%s: sendto %s\n", __FUNCTION__, strerror(errno));
1601 else DEBUG(D_queue_run) debug_printf(" socket: %s\n", strerror(errno));
1605 #endif /*!COMPILE_UTILITY*/
1607 /* End of queue.c */