1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
8 /* Functions that operate on the input queue. */
15 /* Routines with knowledge of spool layout */
17 #ifndef COMPILE_UTILITY
19 spool_pname_buf(uschar * buf, int len)
21 snprintf(CS buf, len, "%s/%s/input", spool_directory, queue_name);
25 spool_dname(const uschar * purpose, uschar * subdir)
27 return string_sprintf("%s/%s/%s/%s",
28 spool_directory, queue_name, purpose, subdir);
33 spool_sname(const uschar * purpose, uschar * subdir)
35 return string_sprintf("%s%s%s%s%s",
36 queue_name, *queue_name ? "/" : "",
38 *subdir ? "/" : "", subdir);
42 spool_fname(const uschar * purpose, const uschar * subdir, const uschar * fname,
43 const uschar * suffix)
45 return string_sprintf("%s/%s/%s/%s/%s%s",
46 spool_directory, queue_name, purpose, subdir, fname, suffix);
52 #ifndef COMPILE_UTILITY
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
58 #define LOG2_MAXNODES 32
62 /*************************************************
63 * Helper sort function for queue_get_spool_list *
64 *************************************************/
66 /* This function is used when sorting the queue list in the function
67 queue_get_spool_list() below.
70 a points to an ordered list of queue_filename items
71 b points to another ordered list
73 Returns: a pointer to a merged ordered list
76 static queue_filename *
77 merge_queue_lists(queue_filename *a, queue_filename *b)
79 queue_filename *first = NULL;
80 queue_filename **append = &first;
85 if ((d = Ustrncmp(a->text, b->text, 6)) == 0)
86 d = Ustrcmp(a->text + 14, b->text + 14);
109 /*************************************************
110 * Get list of spool files *
111 *************************************************/
113 /* Scan the spool directory and return a list of the relevant file names
114 therein. Single-character sub-directories are handled as follows:
116 If the first argument is > 0, a sub-directory is scanned; the letter is
117 taken from the nth entry in subdirs.
119 If the first argument is 0, sub-directories are not scanned. However, a
120 list of them is returned.
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.
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.
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
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
147 Returns: pointer to a chain of queue name items
150 static queue_filename *
151 queue_get_spool_list(int subdiroffset, uschar *subdirs, int *subcount,
158 queue_filename *yield = NULL;
159 queue_filename *last = NULL;
163 queue_filename *root[LOG2_MAXNODES];
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. */
171 resetflags = time(NULL) & 0xFFFF;
173 for (i = 0; i < LOG2_MAXNODES; i++)
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. */
180 if (subdiroffset <= 0)
189 /* Set up prototype for the directory name. */
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 */
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. */
200 for (; i <= *subcount; i++)
203 int subdirchar = subdirs[i]; /* 0 for main directory */
207 buffer[subptr] = '/';
208 buffer[subptr+1] = subdirchar;
211 DEBUG(D_queue_run) debug_printf("looking in %s\n", buffer);
212 if (!(dd = opendir(CS buffer)))
215 /* Now scan the directory. */
217 while ((ent = readdir(dd)))
219 uschar *name = US ent->d_name;
220 int len = Ustrlen(name);
226 /* If we find a single alphameric sub-directory in the base directory,
227 add it to the list for subsequent scans. */
229 if (i == 0 && len == 1 && isalnum(*name))
231 *subcount = *subcount + 1;
232 subdirs[*subcount] = *name;
236 /* Otherwise, if it is a header spool file, add it to the list */
238 if (len == SPOOL_NAME_LENGTH &&
239 Ustrcmp(name + SPOOL_NAME_LENGTH - 2, "-H") == 0)
241 queue_filename *next =
242 store_get(sizeof(queue_filename) + Ustrlen(name));
243 Ustrcpy(next->text, name);
244 next->dir_uschar = subdirchar;
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. */
262 if ((flags & 1) == 0)
276 /* Otherwise do a bottom-up merge sort based on the name. */
281 for (int j = 0; j < LOG2_MAXNODES; j++)
284 next = merge_queue_lists(next, root[j]);
285 root[j] = j == LOG2_MAXNODES - 1 ? next : NULL;
296 /* Finished with this directory */
300 /* If we have just scanned a sub-directory, and it was empty (count == 2
301 implies just "." and ".." entries), and Exim is no longer configured to
302 use sub-directories, attempt to get rid of it. At the same time, try to
303 get rid of any corresponding msglog subdirectory. These are just cosmetic
304 tidying actions, so just ignore failures. If we are scanning just a single
305 sub-directory, break the loop. */
309 if (!split_spool_directory && count <= 2)
314 subdir[0] = subdirchar; subdir[1] = 0;
315 rmdir(CS spool_dname(US"msglog", subdir));
317 if (subdiroffset > 0) break; /* Single sub-directory */
320 /* If we have just scanned the base directory, and subdiroffset is 0,
321 we do not want to continue scanning the sub-directories. */
323 else if (subdiroffset == 0)
325 } /* Loop for multiple subdirectories */
327 /* When using a bottom-up merge sort, do the final merging of the sublists.
328 Then pass back the final list of file items. */
331 for (i = 0; i < LOG2_MAXNODES; ++i)
332 yield = merge_queue_lists(yield, root[i]);
340 /*************************************************
341 * Perform a queue run *
342 *************************************************/
344 /* The arguments give the messages to start and stop at; NULL means start at
345 the beginning or stop at the end. If the given start message doesn't exist, we
346 start at the next lexically greater one, and likewise we stop at the after the
347 previous lexically lesser one if the given stop message doesn't exist. Because
348 a queue run can take some time, stat each file before forking, in case it has
349 been delivered in the meantime by some other means.
351 The global variables queue_run_force and queue_run_local may be set to cause
352 forced deliveries or local-only deliveries, respectively.
354 If deliver_selectstring[_sender] is not NULL, skip messages whose recipients do
355 not contain the string. As this option is typically used when a machine comes
356 back online, we want to ensure that at least one delivery attempt takes place,
357 so force the first one. The selecting string can optionally be a regex, or
358 refer to the sender instead of recipients.
360 If queue_2stage is set, the queue is scanned twice. The first time, queue_smtp
361 is set so that routing is done for all messages. Thus in the second run those
362 that are routed to the same host should go down the same SMTP connection.
365 start_id message id to start at, or NULL for all
366 stop_id message id to end at, or NULL for all
367 recurse TRUE if recursing for 2-stage run
373 queue_run(uschar *start_id, uschar *stop_id, BOOL recurse)
375 BOOL force_delivery = f.queue_run_force || deliver_selectstring != NULL ||
376 deliver_selectstring_sender != NULL;
377 const pcre *selectstring_regex = NULL;
378 const pcre *selectstring_regex_sender = NULL;
379 uschar *log_detail = NULL;
383 /* Cancel any specific queue domains. Turn off the flag that causes SMTP
384 deliveries not to happen, unless doing a 2-stage queue run, when the SMTP flag
385 gets set. Save the queue_runner's pid and the flag that indicates any
386 deliveries run directly from this process. Deliveries that are run by handing
387 on TCP/IP channels have queue_run_pid set, but not queue_running. */
389 queue_domains = NULL;
390 queue_smtp_domains = NULL;
391 f.queue_smtp = f.queue_2stage;
393 queue_run_pid = getpid();
394 f.queue_running = TRUE;
396 /* Log the true start of a queue run, and fancy options */
403 if (f.queue_2stage) *p++ = 'q';
404 if (f.queue_run_first_delivery) *p++ = 'i';
405 if (f.queue_run_force) *p++ = 'f';
406 if (f.deliver_force_thaw) *p++ = 'f';
407 if (f.queue_run_local) *p++ = 'l';
411 p += sprintf(CS p, "pid=%d", (int)queue_run_pid);
414 p += sprintf(CS p, " -q%s", extras);
416 if (deliver_selectstring)
417 p += sprintf(CS p, " -R%s %s", f.deliver_selectstring_regex? "r" : "",
418 deliver_selectstring);
420 if (deliver_selectstring_sender)
421 p += sprintf(CS p, " -S%s %s", f.deliver_selectstring_sender_regex? "r" : "",
422 deliver_selectstring_sender);
424 log_detail = string_copy(big_buffer);
426 log_write(L_queue_run, LOG_MAIN, "Start '%s' queue run: %s",
427 queue_name, log_detail);
429 log_write(L_queue_run, LOG_MAIN, "Start queue run: %s", log_detail);
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, TRUE, FALSE);
437 if (deliver_selectstring_sender && f.deliver_selectstring_sender_regex)
438 selectstring_regex_sender =
439 regex_must_compile(deliver_selectstring_sender, TRUE, 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 void *reset_point1 = store_get(0);
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);
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 (!f.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 /* Skip this message unless it's within the ID limits */
502 if (stop_id && Ustrncmp(fq->text, stop_id, MESSAGE_ID_LENGTH) > 0)
504 if (start_id && Ustrncmp(fq->text, start_id, MESSAGE_ID_LENGTH) < 0)
507 /* Check that the message still exists */
509 message_subdir[0] = fq->dir_uschar;
510 if (Ustat(spool_fname(US"input", message_subdir, fq->text, US""), &statbuf) < 0)
513 /* There are some tests that require the reading of the header file. Ensure
514 the store used is scavenged afterwards so that this process doesn't keep
515 growing its store. We have to read the header file again when actually
516 delivering, but it's cheaper than forking a delivery process for each
517 message when many are not going to be delivered. */
519 if (deliver_selectstring || deliver_selectstring_sender ||
520 f.queue_run_first_delivery)
523 BOOL orig_dont_deliver = f.dont_deliver;
524 void *reset_point2 = store_get(0);
526 /* Restore the original setting of dont_deliver after reading the header,
527 so that a setting for a particular message doesn't force it for any that
528 follow. If the message is chosen for delivery, the header is read again
529 in the deliver_message() function, in a subprocess. */
531 if (spool_read_header(fq->text, FALSE, TRUE) != spool_read_OK) continue;
532 f.dont_deliver = orig_dont_deliver;
534 /* Now decide if we want to deliver this message. As we have read the
535 header file, we might as well do the freeze test now, and save forking
538 if (f.deliver_freeze && !f.deliver_force_thaw)
540 log_write(L_skip_delivery, LOG_MAIN, "Message is frozen");
544 /* Check first_delivery in the case when there are no message logs. */
546 else if (f.queue_run_first_delivery && !f.deliver_firsttime)
548 DEBUG(D_queue_run) debug_printf("%s: not first delivery\n", fq->text);
552 /* Check for a matching address if deliver_selectstring[_sender] is set.
553 If so, we do a fully delivery - don't want to omit other addresses since
554 their routing might trigger re-writing etc. */
556 /* Sender matching */
558 else if ( deliver_selectstring_sender
559 && !(f.deliver_selectstring_sender_regex
560 ? (pcre_exec(selectstring_regex_sender, NULL,
561 CS sender_address, Ustrlen(sender_address), 0, PCRE_EOPT,
563 : (strstric(sender_address, deliver_selectstring_sender, FALSE)
567 DEBUG(D_queue_run) debug_printf("%s: sender address did not match %s\n",
568 fq->text, deliver_selectstring_sender);
572 /* Recipient matching */
574 else if (deliver_selectstring)
577 for (i = 0; i < recipients_count; i++)
579 uschar *address = recipients_list[i].address;
580 if ( (f.deliver_selectstring_regex
581 ? (pcre_exec(selectstring_regex, NULL, CS address,
582 Ustrlen(address), 0, PCRE_EOPT, NULL, 0) >= 0)
583 : (strstric(address, deliver_selectstring, FALSE) != NULL)
585 && tree_search(tree_nonrecipients, address) == NULL
590 if (i >= recipients_count)
593 debug_printf("%s: no recipient address matched %s\n",
594 fq->text, deliver_selectstring);
599 /* Recover store used when reading the header */
601 spool_clear_header_globals();
602 store_reset(reset_point2);
603 if (!wanted) continue; /* With next message */
606 /* OK, got a message we want to deliver. Create a pipe which will
607 serve as a means of detecting when all the processes created by the
608 delivery process are finished. This is relevant when the delivery
609 process passes one or more SMTP channels on to its own children. The
610 pipe gets passed down; by reading on it here we detect when the last
611 descendent dies by the unblocking of the read. It's a pity that for
612 most of the time the pipe isn't used, but creating a pipe should be
616 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to create pipe in queue "
617 "runner process %d: %s", queue_run_pid, strerror(errno));
618 queue_run_pipe = pfd[pipe_write]; /* To ensure it gets passed on. */
620 /* Make sure it isn't stdin. This seems unlikely, but just to be on the
623 if (queue_run_pipe == 0)
625 queue_run_pipe = dup(queue_run_pipe);
629 /* Before forking to deliver the message, ensure any open and cached
630 lookup files or databases are closed. Otherwise, closing in the subprocess
631 can make the next subprocess have problems. There won't often be anything
632 open here, but it is possible (e.g. if spool_directory is an expanded
633 string). A single call before this loop would probably suffice, but just in
634 case expansions get inserted at some point, I've taken the heavy-handed
635 approach. When nothing is open, the call should be cheap. */
639 /* Now deliver the message; get the id by cutting the -H off the file
640 name. The return of the process is zero if a delivery was attempted. */
642 set_process_info("running queue: %s", fq->text);
643 fq->text[SPOOL_NAME_LENGTH-2] = 0;
644 if ((pid = fork()) == 0)
647 if (f.running_in_test_harness) millisleep(100);
648 (void)close(pfd[pipe_read]);
649 rc = deliver_message(fq->text, force_delivery, FALSE);
650 _exit(rc == DELIVER_NOT_ATTEMPTED);
653 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork of delivery process from "
654 "queue runner %d failed\n", queue_run_pid);
656 /* Close the writing end of the synchronizing pipe in this process,
657 then wait for the first level process to terminate. */
659 (void)close(pfd[pipe_write]);
660 set_process_info("running queue: waiting for %s (%d)", fq->text, pid);
661 while (wait(&status) != pid);
663 /* A zero return means a delivery was attempted; turn off the force flag
664 for any subsequent calls unless queue_force is set. */
666 if ((status & 0xffff) == 0) force_delivery = f.queue_run_force;
668 /* If the process crashed, tell somebody */
670 else if ((status & 0x00ff) != 0)
671 log_write(0, LOG_MAIN|LOG_PANIC,
672 "queue run: process %d crashed with signal %d while delivering %s",
673 (int)pid, status & 0x00ff, fq->text);
675 /* Before continuing, wait till the pipe gets closed at the far end. This
676 tells us that any children created by the delivery to re-use any SMTP
677 channels have all finished. Since no process actually writes to the pipe,
678 the mere fact that read() unblocks is enough. */
680 set_process_info("running queue: waiting for children of %d", pid);
681 if ((status = read(pfd[pipe_read], buffer, sizeof(buffer))) != 0)
682 log_write(0, LOG_MAIN|LOG_PANIC, "queue run: %s on pipe",
683 status > 0 ? "unexpected data" : "error");
684 (void)close(pfd[pipe_read]);
685 set_process_info("running queue");
687 /* If we are in the test harness, and this is not the first of a 2-stage
688 queue run, update fudged queue times. */
690 if (f.running_in_test_harness && !f.queue_2stage)
692 uschar *fqtnext = Ustrchr(fudged_queue_times, '/');
693 if (fqtnext != NULL) fudged_queue_times = fqtnext + 1;
695 } /* End loop for list of messages */
697 tree_nonrecipients = NULL;
698 store_reset(reset_point1); /* Scavenge list of messages */
700 /* If this was the first time through for random order processing, and
701 sub-directories have been found, randomize their order if necessary. */
703 if (i == 0 && subcount > 1 && !queue_run_in_order)
704 for (int j = 1; j <= subcount; j++)
707 if ((r = random_number(100)) >= 50)
709 int k = (r % subcount) + 1;
711 subdirs[j] = subdirs[k];
715 } /* End loop for multiple directories */
717 /* If queue_2stage is true, we do it all again, with the 2stage flag
722 f.queue_2stage = FALSE;
723 queue_run(start_id, stop_id, TRUE);
726 /* At top level, log the end of the run. */
730 log_write(L_queue_run, LOG_MAIN, "End '%s' queue run: %s",
731 queue_name, log_detail);
733 log_write(L_queue_run, LOG_MAIN, "End queue run: %s", log_detail);
739 /************************************************
740 * Count messages on the queue *
741 ************************************************/
743 /* Called as a result of -bpc
756 for (queue_filename *f = queue_get_spool_list(
757 -1, /* entire queue */
758 subdirs, /* for holding sub list */
759 &subcount, /* for subcount */
760 FALSE); /* not random */
761 f; f = f->next) count++;
762 fprintf(stdout, "%d\n", count);
767 /************************************************
768 * List extra deliveries *
769 ************************************************/
771 /* This is called from queue_list below to print out all addresses that
772 have received a message but which were not primary addresses. That is, all
773 the addresses in the tree of non-recipients that are not primary addresses.
774 The tree has been scanned and the data field filled in for those that are
777 Argument: points to the tree node
781 static void queue_list_extras(tree_node *p)
783 if (p->left != NULL) queue_list_extras(p->left);
784 if (!p->data.val) printf(" +D %s\n", p->name);
785 if (p->right != NULL) queue_list_extras(p->right);
790 /************************************************
791 * List messages on the queue *
792 ************************************************/
794 /* Or a given list of messages. In the "all" case, we get a list of file names
795 as quickly as possible, then scan each one for information to output. If any
796 disappear while we are processing, just leave them out, but give an error if an
797 explicit list was given. This function is a top-level function that is obeyed
798 as a result of the -bp argument. As there may be a lot of messages on the
799 queue, we must tidy up the store after reading the headers for each one.
802 option 0 => list top-level recipients, with "D" for those delivered
803 1 => list only undelivered top-level recipients
804 2 => as 0, plus any generated delivered recipients
805 If 8 is added to any of these values, the queue is listed in
807 list => first of any message ids to list
808 count count of message ids; 0 => all
814 queue_list(int option, uschar **list, int count)
817 int now = (int)time(NULL);
819 queue_filename * qf = NULL;
822 /* If given a list of messages, build a chain containing their ids. */
826 queue_filename *last = NULL;
827 for (int i = 0; i < count; i++)
829 queue_filename *next =
830 store_get(sizeof(queue_filename) + Ustrlen(list[i]) + 2);
831 sprintf(CS next->text, "%s-H", list[i]);
832 next->dir_uschar = '*';
834 if (i == 0) qf = next; else last->next = next;
839 /* Otherwise get a list of the entire queue, in order if necessary. */
842 qf = queue_get_spool_list(
843 -1, /* entire queue */
844 subdirs, /* for holding sub list */
845 &subcount, /* for subcount */
846 option >= 8); /* randomize if required */
848 if (option >= 8) option -= 8;
850 /* Now scan the chain and print information, resetting store used
853 for (reset_point = store_get(0);
855 spool_clear_header_globals(), store_reset(reset_point), qf = qf->next
863 message_subdir[0] = qf->dir_uschar;
864 rc = spool_read_header(qf->text, FALSE, count <= 0);
865 if (rc == spool_read_notopen && errno == ENOENT && count <= 0)
869 env_read = (rc == spool_read_OK || rc == spool_read_hdrerror);
876 uschar * fname = spool_fname(US"input", message_subdir, qf->text, US"");
878 ptr = Ustrlen(fname)-1;
881 /* Add the data size to the header size; don't count the file name
882 at the start of the data file, but add one for the notional blank line
883 that precedes the data. */
885 if (Ustat(fname, &statbuf) == 0)
886 size = message_size + statbuf.st_size - SPOOL_DATA_START_OFFSET + 1;
887 i = (now - received_time.tv_sec)/60; /* minutes on queue */
891 if (i > 72) printf("%2dd ", (i + 12)/24); else printf("%2dh ", i);
893 else printf("%2dm ", i);
895 /* Collect delivered addresses from any J file */
898 if ((jread = Ufopen(fname, "rb")))
900 while (Ufgets(big_buffer, big_buffer_size, jread) != NULL)
902 int n = Ustrlen(big_buffer);
904 tree_add_nonrecipient(big_buffer);
910 fprintf(stdout, "%s ", string_format_size(size, big_buffer));
911 for (int i = 0; i < 16; i++) fputc(qf->text[i], stdout);
913 if (env_read && sender_address)
915 printf(" <%s>", sender_address);
916 if (f.sender_set_untrusted) printf(" (%s)", originator_login);
919 if (rc != spool_read_OK)
922 if (save_errno == ERRNO_SPOOLFORMAT)
925 uschar * fname = spool_fname(US"input", message_subdir, qf->text, US"");
927 if (Ustat(fname, &statbuf) == 0)
928 printf("*** spool format error: size=" OFF_T_FMT " ***",
930 else printf("*** spool format error ***");
932 else printf("*** spool read error: %s ***", strerror(save_errno));
933 if (rc != spool_read_hdrerror)
940 if (f.deliver_freeze) printf(" *** frozen ***");
946 for (int i = 0; i < recipients_count; i++)
948 tree_node *delivered =
949 tree_search(tree_nonrecipients, recipients_list[i].address);
950 if (!delivered || option != 1)
952 delivered ? "D" : " ", recipients_list[i].address);
953 if (delivered) delivered->data.val = TRUE;
955 if (option == 2 && tree_nonrecipients)
956 queue_list_extras(tree_nonrecipients);
964 /*************************************************
965 * Act on a specific message *
966 *************************************************/
968 /* Actions that require a list of addresses make use of argv/argc/
969 recipients_arg. Other actions do not. This function does its own
973 id id of the message to work on
974 action which action is required (MSG_xxx)
975 argv the original argv for Exim
976 argc the original argc for Exim
977 recipients_arg offset to the list of recipients in argv
979 Returns: FALSE if there was any problem
983 queue_action(uschar *id, int action, uschar **argv, int argc, int recipients_arg)
986 BOOL removed = FALSE;
988 uschar *doing = NULL;
991 uschar spoolname[32];
993 /* Set the global message_id variable, used when re-writing spool files. This
994 also causes message ids to be added to log messages. */
996 Ustrcpy(message_id, id);
998 /* The "actions" that just list the files do not require any locking to be
999 done. Only admin users may read the spool files. */
1001 if (action >= MSG_SHOW_BODY)
1004 uschar *subdirectory, *suffix;
1008 printf("Permission denied\n");
1012 if (recipients_arg < argc)
1014 printf("*** Only one message can be listed at once\n");
1018 if (action == MSG_SHOW_BODY)
1020 subdirectory = US"input";
1023 else if (action == MSG_SHOW_HEADER)
1025 subdirectory = US"input";
1030 subdirectory = US"msglog";
1034 for (int i = 0; i < 2; i++)
1036 message_subdir[0] = split_spool_directory == (i == 0) ? id[5] : 0;
1037 if ((fd = Uopen(spool_fname(subdirectory, message_subdir, id, suffix),
1043 printf("Failed to open %s file for %s%s: %s\n", subdirectory, id, suffix,
1045 if (action == MSG_SHOW_LOG && !message_logs)
1046 printf("(No message logs are being created because the message_logs "
1047 "option is false.)\n");
1051 while((rc = read(fd, big_buffer, big_buffer_size)) > 0)
1052 rc = write(fileno(stdout), big_buffer, rc);
1058 /* For actions that actually act, open and lock the data file to ensure that no
1059 other process is working on this message. If the file does not exist, continue
1060 only if the action is remove and the user is an admin user, to allow for
1061 tidying up broken states. */
1063 if ((deliver_datafile = spool_open_datafile(id)) < 0)
1064 if (errno == ENOENT)
1067 printf("Spool data file for %s does not exist\n", id);
1068 if (action != MSG_REMOVE || !f.admin_user) return FALSE;
1069 printf("Continuing, to ensure all files removed\n");
1073 if (errno == 0) printf("Message %s is locked\n", id);
1074 else printf("Couldn't open spool file for %s: %s\n", id,
1079 /* Read the spool header file for the message. Again, continue after an
1080 error only in the case of deleting by an administrator. Setting the third
1081 argument false causes it to look both in the main spool directory and in
1082 the appropriate subdirectory, and set message_subdir according to where it
1083 found the message. */
1085 sprintf(CS spoolname, "%s-H", id);
1086 if (spool_read_header(spoolname, TRUE, FALSE) != spool_read_OK)
1089 if (errno != ERRNO_SPOOLFORMAT)
1090 printf("Spool read error for %s: %s\n", spoolname, strerror(errno));
1092 printf("Spool format error for %s\n", spoolname);
1093 if (action != MSG_REMOVE || !f.admin_user)
1095 (void)close(deliver_datafile);
1096 deliver_datafile = -1;
1099 printf("Continuing to ensure all files removed\n");
1102 /* Check that the user running this process is entitled to operate on this
1103 message. Only admin users may freeze/thaw, add/cancel recipients, or otherwise
1104 mess about, but the original sender is permitted to remove a message. That's
1105 why we leave this check until after the headers are read. */
1107 if (!f.admin_user && (action != MSG_REMOVE || real_uid != originator_uid))
1109 printf("Permission denied\n");
1110 (void)close(deliver_datafile);
1111 deliver_datafile = -1;
1115 /* Set up the user name for logging. */
1117 pw = getpwuid(real_uid);
1118 username = (pw != NULL)?
1119 US pw->pw_name : string_sprintf("uid %ld", (long int)real_uid);
1121 /* Take the necessary action. */
1123 if (action != MSG_SHOW_COPY) printf("Message %s ", id);
1129 transport_ctx tctx = {{0}};
1130 deliver_in_buffer = store_malloc(DELIVER_IN_BUFFER_SIZE);
1131 deliver_out_buffer = store_malloc(DELIVER_OUT_BUFFER_SIZE);
1133 (void) transport_write_message(&tctx, 0);
1139 if (f.deliver_freeze)
1142 printf("is already frozen\n");
1146 f.deliver_freeze = TRUE;
1147 f.deliver_manual_thaw = FALSE;
1148 deliver_frozen_at = time(NULL);
1149 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1151 printf("is now frozen\n");
1152 log_write(0, LOG_MAIN, "frozen by %s", username);
1157 printf("could not be frozen: %s\n", errmsg);
1164 if (!f.deliver_freeze)
1167 printf("is not frozen\n");
1171 f.deliver_freeze = FALSE;
1172 f.deliver_manual_thaw = TRUE;
1173 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1175 printf("is no longer frozen\n");
1176 log_write(0, LOG_MAIN, "unfrozen by %s", username);
1181 printf("could not be unfrozen: %s\n", errmsg);
1187 /* We must ensure all files are removed from both the input directory
1188 and the appropriate subdirectory, to clean up cases when there are odd
1189 files left lying around in odd places. In the normal case message_subdir
1190 will have been set correctly by spool_read_header, but as this is a rare
1191 operation, just run everything twice. */
1199 message_subdir[0] = id[5];
1201 for (int j = 0; j < 2; message_subdir[0] = 0, j++)
1203 uschar * fname = spool_fname(US"msglog", message_subdir, id, US"");
1205 DEBUG(D_any) debug_printf(" removing %s", fname);
1206 if (Uunlink(fname) < 0)
1208 if (errno != ENOENT)
1211 printf("Error while removing %s: %s\n", fname, strerror(errno));
1213 else DEBUG(D_any) debug_printf(" (no file)\n");
1218 DEBUG(D_any) debug_printf(" (ok)\n");
1221 for (int i = 0; i < 3; i++)
1225 suffix[1] = (US"DHJ")[i];
1226 fname = spool_fname(US"input", message_subdir, id, suffix);
1228 DEBUG(D_any) debug_printf(" removing %s", fname);
1229 if (Uunlink(fname) < 0)
1231 if (errno != ENOENT)
1234 printf("Error while removing %s: %s\n", fname, strerror(errno));
1236 else DEBUG(D_any) debug_printf(" (no file)\n");
1241 DEBUG(D_any) debug_printf(" (done)\n");
1246 /* In the common case, the datafile is open (and locked), so give the
1247 obvious message. Otherwise be more specific. */
1249 if (deliver_datafile >= 0) printf("has been removed\n");
1250 else printf("has been removed or did not exist\n");
1253 #ifndef DISABLE_EVENT
1254 for (int i = 0; i < recipients_count; i++)
1256 tree_node *delivered =
1257 tree_search(tree_nonrecipients, recipients_list[i].address);
1260 uschar * save_local = deliver_localpart;
1261 const uschar * save_domain = deliver_domain;
1262 uschar * addr = recipients_list[i].address, * errmsg = NULL;
1263 int start, end, dom;
1265 if (!parse_extract_address(addr, &errmsg, &start, &end, &dom, TRUE))
1266 log_write(0, LOG_MAIN|LOG_PANIC,
1267 "failed to parse address '%.100s'\n: %s", addr, errmsg);
1271 string_copyn(addr+start, dom ? (dom-1) - start : end - start);
1272 deliver_domain = dom
1273 ? CUS string_copyn(addr+dom, end - dom) : CUS"";
1275 event_raise(event_action, US"msg:fail:internal",
1276 string_sprintf("message removed by %s", username));
1278 deliver_localpart = save_local;
1279 deliver_domain = save_domain;
1283 (void) event_raise(event_action, US"msg:complete", NULL);
1285 log_write(0, LOG_MAIN, "removed by %s", username);
1286 log_write(0, LOG_MAIN, "Completed");
1292 case MSG_MARK_ALL_DELIVERED:
1293 for (int i = 0; i < recipients_count; i++)
1294 tree_add_nonrecipient(recipients_list[i].address);
1296 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1298 printf("has been modified\n");
1299 for (int i = 0; i < recipients_count; i++)
1300 log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1301 recipients_list[i].address, username);
1306 printf("- could not mark all delivered: %s\n", errmsg);
1311 case MSG_EDIT_SENDER:
1312 if (recipients_arg < argc - 1)
1315 printf("- only one sender address can be specified\n");
1318 doing = US"editing sender";
1321 case MSG_ADD_RECIPIENT:
1322 if (doing == NULL) doing = US"adding recipient";
1325 case MSG_MARK_DELIVERED:
1326 if (doing == NULL) doing = US"marking as delivered";
1328 /* Common code for EDIT_SENDER, ADD_RECIPIENT, & MARK_DELIVERED */
1330 if (recipients_arg >= argc)
1333 printf("- error while %s: no address given\n", doing);
1337 for (; recipients_arg < argc; recipients_arg++)
1339 int start, end, domain;
1342 parse_extract_address(argv[recipients_arg], &errmess, &start, &end,
1343 &domain, (action == MSG_EDIT_SENDER));
1345 if (recipient == NULL)
1348 printf("- error while %s:\n bad address %s: %s\n",
1349 doing, argv[recipients_arg], errmess);
1351 else if (recipient[0] != 0 && domain == 0)
1354 printf("- error while %s:\n bad address %s: "
1355 "domain missing\n", doing, argv[recipients_arg]);
1359 if (action == MSG_ADD_RECIPIENT)
1362 if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1364 receive_add_recipient(recipient, -1);
1365 log_write(0, LOG_MAIN, "recipient <%s> added by %s",
1366 recipient, username);
1368 else if (action == MSG_MARK_DELIVERED)
1371 for (i = 0; i < recipients_count; i++)
1372 if (Ustrcmp(recipients_list[i].address, recipient) == 0) break;
1373 if (i >= recipients_count)
1375 printf("- error while %s:\n %s is not a recipient:"
1376 " message not updated\n", doing, recipient);
1381 tree_add_nonrecipient(recipients_list[i].address);
1382 log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1383 recipient, username);
1386 else /* MSG_EDIT_SENDER */
1389 if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1391 sender_address = recipient;
1392 log_write(0, LOG_MAIN, "sender address changed to <%s> by %s",
1393 recipient, username);
1399 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1400 printf("has been modified\n");
1404 printf("- while %s: %s\n", doing, errmsg);
1410 /* Closing the datafile releases the lock and permits other processes
1411 to operate on the message (if it still exists). */
1413 if (deliver_datafile >= 0)
1415 (void)close(deliver_datafile);
1416 deliver_datafile = -1;
1423 /*************************************************
1424 * Check the queue_only_file condition *
1425 *************************************************/
1427 /* The queue_only_file option forces certain kinds of queueing if a given file
1435 queue_check_only(void)
1438 struct stat statbuf;
1441 uschar buffer[1024];
1443 if (queue_only_file == NULL) return;
1445 s = queue_only_file;
1446 while ((ss = string_nextinlist(&s, &sep, buffer, sizeof(buffer))) != NULL)
1448 if (Ustrncmp(ss, "smtp", 4) == 0)
1451 if (Ustat(ss, &statbuf) == 0)
1453 f.queue_smtp = TRUE;
1454 DEBUG(D_receive) debug_printf("queue_smtp set because %s exists\n", ss);
1459 if (Ustat(ss, &statbuf) == 0)
1462 DEBUG(D_receive) debug_printf("queue_only set because %s exists\n", ss);
1468 #endif /*!COMPILE_UTILITY*/
1470 /* End of queue.c */