1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2015 */
6 /* See the file NOTICE for conditions of use and distribution. */
8 /* Functions that operate on the input queue. */
15 /* Routines with knowlege of spool layout */
18 spool_pname_buf(uschar * buf, int len)
20 snprintf(CS buf, len, "%s/%s/input", spool_directory, queue_name);
24 spool_dname(const uschar * purpose, uschar * subdir)
26 return string_sprintf("%s/%s/%s/%s",
27 spool_directory, queue_name, purpose, subdir);
31 spool_sname(const uschar * purpose, uschar * subdir)
33 return string_sprintf("%s%s%s%s%s",
34 queue_name, *queue_name ? "/" : "",
36 *subdir ? "/" : "", subdir);
40 spool_fname(const uschar * purpose, uschar * subdir, uschar * fname, uschar * suffix)
42 return string_sprintf("%s/%s/%s/%s/%s%s",
43 spool_directory, queue_name, purpose, subdir, fname, suffix);
49 #ifndef COMPILE_UTILITY
51 /* The number of nodes to use for the bottom-up merge sort when a list of queue
52 items is to be ordered. The code for this sort was contributed as a patch by
55 #define LOG2_MAXNODES 32
59 /*************************************************
60 * Helper sort function for queue_get_spool_list *
61 *************************************************/
63 /* This function is used when sorting the queue list in the function
64 queue_get_spool_list() below.
67 a points to an ordered list of queue_filename items
68 b points to another ordered list
70 Returns: a pointer to a merged ordered list
73 static queue_filename *
74 merge_queue_lists(queue_filename *a, queue_filename *b)
76 queue_filename *first = NULL;
77 queue_filename **append = &first;
80 if (Ustrcmp(a->text, b->text) < 0)
101 /*************************************************
102 * Get list of spool files *
103 *************************************************/
105 /* Scan the spool directory and return a list of the relevant file names
106 therein. Single-character sub-directories are handled as follows:
108 If the first argument is > 0, a sub-directory is scanned; the letter is
109 taken from the nth entry in subdirs.
111 If the first argument is 0, sub-directories are not scanned. However, a
112 list of them is returned.
114 If the first argument is < 0, sub-directories are scanned for messages,
115 and a single, unified list is created. The returned data blocks contain the
116 identifying character of the subdirectory, if any. The subdirs vector is
117 still required as an argument.
119 If the randomize argument is TRUE, messages are returned in "randomized" order.
120 Actually, the order is anything but random, but the algorithm is cheap, and the
121 point is simply to ensure that the same order doesn't occur every time, in case
122 a particular message is causing a remote MTA to barf - we would like to try
123 other messages to that MTA first.
125 If the randomize argument is FALSE, sort the list according to the file name.
126 This should give the order in which the messages arrived. It is normally used
127 only for presentation to humans, in which case the (possibly expensive) sort
128 that it does is not part of the normal operational code. However, if
129 queue_run_in_order is set, sorting has to take place for queue runs as well.
130 When randomize is FALSE, the first argument is normally -1, so all messages are
134 subdiroffset sub-directory character offset, or 0 or -1 (see above)
135 subdirs vector to store list of subdirchars
136 subcount pointer to int in which to store count of subdirs
137 randomize TRUE if the order of the list is to be unpredictable
139 Returns: pointer to a chain of queue name items
142 static queue_filename *
143 queue_get_spool_list(int subdiroffset, uschar *subdirs, int *subcount,
150 queue_filename *yield = NULL;
151 queue_filename *last = NULL;
155 queue_filename *root[LOG2_MAXNODES];
157 /* When randomizing, the file names are added to the start or end of the list
158 according to the bits of the flags variable. Get a collection of bits from the
159 current time. Use the bottom 16 and just keep re-using them if necessary. When
160 not randomizing, initialize the sublists for the bottom-up merge sort. */
163 resetflags = time(NULL) & 0xFFFF;
165 for (i = 0; i < LOG2_MAXNODES; i++)
168 /* If processing the full queue, or just the top-level, start at the base
169 directory, and initialize the first subdirectory name (as none). Otherwise,
170 start at the sub-directory offset. */
172 if (subdiroffset <= 0)
181 /* Set up prototype for the directory name. */
183 spool_pname_buf(buffer, sizeof(buffer));
184 buffer[sizeof(buffer) - 3] = 0;
185 subptr = Ustrlen(buffer);
186 buffer[subptr+2] = 0; /* terminator for lengthened name */
188 /* This loop runs at least once, for the main or given directory, and then as
189 many times as necessary to scan any subdirectories encountered in the main
190 directory, if they are to be scanned at this time. */
192 for (; i <= *subcount; i++)
195 int subdirchar = subdirs[i]; /* 0 for main directory */
199 buffer[subptr] = '/';
200 buffer[subptr+1] = subdirchar;
203 DEBUG(D_queue_run) debug_printf("looking in %s\n", buffer);
204 if (!(dd = opendir(CS buffer)))
207 /* Now scan the directory. */
209 while ((ent = readdir(dd)))
211 uschar *name = US ent->d_name;
212 int len = Ustrlen(name);
218 /* If we find a single alphameric sub-directory in the base directory,
219 add it to the list for subsequent scans. */
221 if (i == 0 && len == 1 && isalnum(*name))
223 *subcount = *subcount + 1;
224 subdirs[*subcount] = *name;
228 /* Otherwise, if it is a header spool file, add it to the list */
230 if (len == SPOOL_NAME_LENGTH &&
231 Ustrcmp(name + SPOOL_NAME_LENGTH - 2, "-H") == 0)
233 queue_filename *next =
234 store_get(sizeof(queue_filename) + Ustrlen(name));
235 Ustrcpy(next->text, name);
236 next->dir_uschar = subdirchar;
238 /* Handle the creation of a randomized list. The first item becomes both
239 the top and bottom of the list. Subsequent items are inserted either at
240 the top or the bottom, randomly. This is, I argue, faster than doing a
241 sort by allocating a random number to each item, and it also saves having
242 to store the number with each item. */
254 if ((flags & 1) == 0)
268 /* Otherwise do a bottom-up merge sort based on the name. */
274 for (j = 0; j < LOG2_MAXNODES; j++)
277 next = merge_queue_lists(next, root[j]);
278 root[j] = (j == LOG2_MAXNODES - 1)? next : NULL;
289 /* Finished with this directory */
293 /* If we have just scanned a sub-directory, and it was empty (count == 2
294 implies just "." and ".." entries), and Exim is no longer configured to
295 use sub-directories, attempt to get rid of it. At the same time, try to
296 get rid of any corresponding msglog subdirectory. These are just cosmetic
297 tidying actions, so just ignore failures. If we are scanning just a single
298 sub-directory, break the loop. */
302 if (!split_spool_directory && count <= 2)
307 subdir[0] = subdirchar; subdir[1] = 0;
308 rmdir(CS spool_dname(US"msglog", subdir));
310 if (subdiroffset > 0) break; /* Single sub-directory */
313 /* If we have just scanned the base directory, and subdiroffset is 0,
314 we do not want to continue scanning the sub-directories. */
316 else if (subdiroffset == 0)
318 } /* Loop for multiple subdirectories */
320 /* When using a bottom-up merge sort, do the final merging of the sublists.
321 Then pass back the final list of file items. */
324 for (i = 0; i < LOG2_MAXNODES; ++i)
325 yield = merge_queue_lists(yield, root[i]);
333 /*************************************************
334 * Perform a queue run *
335 *************************************************/
337 /* The arguments give the messages to start and stop at; NULL means start at
338 the beginning or stop at the end. If the given start message doesn't exist, we
339 start at the next lexically greater one, and likewise we stop at the after the
340 previous lexically lesser one if the given stop message doesn't exist. Because
341 a queue run can take some time, stat each file before forking, in case it has
342 been delivered in the meantime by some other means.
344 The global variables queue_run_force and queue_run_local may be set to cause
345 forced deliveries or local-only deliveries, respectively.
347 If deliver_selectstring[_sender] is not NULL, skip messages whose recipients do
348 not contain the string. As this option is typically used when a machine comes
349 back online, we want to ensure that at least one delivery attempt takes place,
350 so force the first one. The selecting string can optionally be a regex, or
351 refer to the sender instead of recipients.
353 If queue_2stage is set, the queue is scanned twice. The first time, queue_smtp
354 is set so that routing is done for all messages. Thus in the second run those
355 that are routed to the same host should go down the same SMTP connection.
358 start_id message id to start at, or NULL for all
359 stop_id message id to end at, or NULL for all
360 recurse TRUE if recursing for 2-stage run
366 queue_run(uschar *start_id, uschar *stop_id, BOOL recurse)
368 BOOL force_delivery = queue_run_force || deliver_selectstring != NULL ||
369 deliver_selectstring_sender != NULL;
370 const pcre *selectstring_regex = NULL;
371 const pcre *selectstring_regex_sender = NULL;
372 uschar *log_detail = NULL;
377 /* Cancel any specific queue domains. Turn off the flag that causes SMTP
378 deliveries not to happen, unless doing a 2-stage queue run, when the SMTP flag
379 gets set. Save the queue_runner's pid and the flag that indicates any
380 deliveries run directly from this process. Deliveries that are run by handing
381 on TCP/IP channels have queue_run_pid set, but not queue_running. */
383 queue_domains = NULL;
384 queue_smtp_domains = NULL;
385 queue_smtp = queue_2stage;
387 queue_run_pid = getpid();
388 queue_running = TRUE;
390 /* Log the true start of a queue run, and fancy options */
397 if (queue_2stage) *p++ = 'q';
398 if (queue_run_first_delivery) *p++ = 'i';
399 if (queue_run_force) *p++ = 'f';
400 if (deliver_force_thaw) *p++ = 'f';
401 if (queue_run_local) *p++ = 'l';
405 sprintf(CS p, "pid=%d", (int)queue_run_pid);
410 sprintf(CS p, " -q%s", extras);
414 if (deliver_selectstring != NULL)
416 sprintf(CS p, " -R%s %s", deliver_selectstring_regex? "r" : "",
417 deliver_selectstring);
421 if (deliver_selectstring_sender != NULL)
423 sprintf(CS p, " -S%s %s", deliver_selectstring_sender_regex? "r" : "",
424 deliver_selectstring_sender);
428 log_detail = string_copy(big_buffer);
430 log_write(L_queue_run, LOG_MAIN, "Start '%s' queue run: %s",
431 queue_name, log_detail);
433 log_write(L_queue_run, LOG_MAIN, "Start queue run: %s", log_detail);
436 /* If deliver_selectstring is a regex, compile it. */
438 if (deliver_selectstring != NULL && deliver_selectstring_regex)
439 selectstring_regex = regex_must_compile(deliver_selectstring, TRUE, FALSE);
441 if (deliver_selectstring_sender != NULL && deliver_selectstring_sender_regex)
442 selectstring_regex_sender =
443 regex_must_compile(deliver_selectstring_sender, TRUE, FALSE);
445 /* If the spool is split into subdirectories, we want to process it one
446 directory at a time, so as to spread out the directory scanning and the
447 delivering when there are lots of messages involved, except when
448 queue_run_in_order is set.
450 In the random order case, this loop runs once for the main directory (handling
451 any messages therein), and then repeats for any subdirectories that were found.
452 When the first argument of queue_get_spool_list() is 0, it scans the top
453 directory, fills in subdirs, and sets subcount. The order of the directories is
454 then randomized after the first time through, before they are scanned in
455 subsqeuent iterations.
457 When the first argument of queue_get_spool_list() is -1 (for queue_run_in_
458 order), it scans all directories and makes a single message list. */
460 for (i = (queue_run_in_order? -1 : 0);
461 i <= (queue_run_in_order? -1 : subcount);
465 void *reset_point1 = store_get(0);
470 debug_printf("queue running main directory\n");
472 debug_printf("queue running combined directories\n");
474 debug_printf("queue running subdirectory '%c'\n", subdirs[i]);
477 for (f = queue_get_spool_list(i, subdirs, &subcount, !queue_run_in_order);
487 /* Unless deliveries are forced, if deliver_queue_load_max is non-negative,
488 check that the load average is low enough to permit deliveries. */
490 if (!queue_run_force && deliver_queue_load_max >= 0)
491 if ((load_average = os_getloadavg()) > deliver_queue_load_max)
493 log_write(L_queue_run, LOG_MAIN, "Abandon queue run: %s (load %.2f, max %.2f)",
495 (double)load_average/1000.0,
496 (double)deliver_queue_load_max/1000.0);
497 i = subcount; /* Don't process other directories */
501 DEBUG(D_load) debug_printf("load average = %.2f max = %.2f\n",
502 (double)load_average/1000.0,
503 (double)deliver_queue_load_max/1000.0);
505 /* Skip this message unless it's within the ID limits */
507 if (stop_id && Ustrncmp(f->text, stop_id, MESSAGE_ID_LENGTH) > 0)
509 if (start_id && Ustrncmp(f->text, start_id, MESSAGE_ID_LENGTH) < 0)
512 /* Check that the message still exists */
514 message_subdir[0] = f->dir_uschar;
515 if (Ustat(spool_fname(US"input", message_subdir, f->text, US""), &statbuf) < 0)
518 /* There are some tests that require the reading of the header file. Ensure
519 the store used is scavenged afterwards so that this process doesn't keep
520 growing its store. We have to read the header file again when actually
521 delivering, but it's cheaper than forking a delivery process for each
522 message when many are not going to be delivered. */
524 if (deliver_selectstring || deliver_selectstring_sender ||
525 queue_run_first_delivery)
528 BOOL orig_dont_deliver = dont_deliver;
529 void *reset_point2 = store_get(0);
531 /* Restore the original setting of dont_deliver after reading the header,
532 so that a setting for a particular message doesn't force it for any that
533 follow. If the message is chosen for delivery, the header is read again
534 in the deliver_message() function, in a subprocess. */
536 if (spool_read_header(f->text, FALSE, TRUE) != spool_read_OK) continue;
537 dont_deliver = orig_dont_deliver;
539 /* Now decide if we want to deliver this message. As we have read the
540 header file, we might as well do the freeze test now, and save forking
543 if (deliver_freeze && !deliver_force_thaw)
545 log_write(L_skip_delivery, LOG_MAIN, "Message is frozen");
549 /* Check first_delivery in the case when there are no message logs. */
551 else if (queue_run_first_delivery && !deliver_firsttime)
553 DEBUG(D_queue_run) debug_printf("%s: not first delivery\n", f->text);
557 /* Check for a matching address if deliver_selectstring[_sender] is set.
558 If so, we do a fully delivery - don't want to omit other addresses since
559 their routing might trigger re-writing etc. */
561 /* Sender matching */
563 else if ( deliver_selectstring_sender
564 && !(deliver_selectstring_sender_regex
565 ? (pcre_exec(selectstring_regex_sender, NULL,
566 CS sender_address, Ustrlen(sender_address), 0, PCRE_EOPT,
568 : (strstric(sender_address, deliver_selectstring_sender, FALSE)
572 DEBUG(D_queue_run) debug_printf("%s: sender address did not match %s\n",
573 f->text, deliver_selectstring_sender);
577 /* Recipient matching */
579 else if (deliver_selectstring)
582 for (i = 0; i < recipients_count; i++)
584 uschar *address = recipients_list[i].address;
585 if ( (deliver_selectstring_regex
586 ? (pcre_exec(selectstring_regex, NULL, CS address,
587 Ustrlen(address), 0, PCRE_EOPT, NULL, 0) >= 0)
588 : (strstric(address, deliver_selectstring, FALSE) != NULL)
590 && tree_search(tree_nonrecipients, address) == NULL
595 if (i >= recipients_count)
598 debug_printf("%s: no recipient address matched %s\n",
599 f->text, deliver_selectstring);
604 /* Recover store used when reading the header */
606 store_reset(reset_point2);
607 if (!wanted) continue; /* With next message */
610 /* OK, got a message we want to deliver. Create a pipe which will
611 serve as a means of detecting when all the processes created by the
612 delivery process are finished. This is relevant when the delivery
613 process passes one or more SMTP channels on to its own children. The
614 pipe gets passed down; by reading on it here we detect when the last
615 descendent dies by the unblocking of the read. It's a pity that for
616 most of the time the pipe isn't used, but creating a pipe should be
620 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to create pipe in queue "
621 "runner process %d: %s", queue_run_pid, strerror(errno));
622 queue_run_pipe = pfd[pipe_write]; /* To ensure it gets passed on. */
624 /* Make sure it isn't stdin. This seems unlikely, but just to be on the
627 if (queue_run_pipe == 0)
629 queue_run_pipe = dup(queue_run_pipe);
633 /* Before forking to deliver the message, ensure any open and cached
634 lookup files or databases are closed. Otherwise, closing in the subprocess
635 can make the next subprocess have problems. There won't often be anything
636 open here, but it is possible (e.g. if spool_directory is an expanded
637 string). A single call before this loop would probably suffice, but just in
638 case expansions get inserted at some point, I've taken the heavy-handed
639 approach. When nothing is open, the call should be cheap. */
643 /* Now deliver the message; get the id by cutting the -H off the file
644 name. The return of the process is zero if a delivery was attempted. */
646 set_process_info("running queue: %s", f->text);
647 f->text[SPOOL_NAME_LENGTH-2] = 0;
648 if ((pid = fork()) == 0)
651 if (running_in_test_harness) millisleep(100);
652 (void)close(pfd[pipe_read]);
653 rc = deliver_message(f->text, force_delivery, FALSE);
654 _exit(rc == DELIVER_NOT_ATTEMPTED);
657 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork of delivery process from "
658 "queue runner %d failed\n", queue_run_pid);
660 /* Close the writing end of the synchronizing pipe in this process,
661 then wait for the first level process to terminate. */
663 (void)close(pfd[pipe_write]);
664 set_process_info("running queue: waiting for %s (%d)", f->text, pid);
665 while (wait(&status) != pid);
667 /* A zero return means a delivery was attempted; turn off the force flag
668 for any subsequent calls unless queue_force is set. */
670 if ((status & 0xffff) == 0) force_delivery = queue_run_force;
672 /* If the process crashed, tell somebody */
674 else if ((status & 0x00ff) != 0)
675 log_write(0, LOG_MAIN|LOG_PANIC,
676 "queue run: process %d crashed with signal %d while delivering %s",
677 (int)pid, status & 0x00ff, f->text);
679 /* Before continuing, wait till the pipe gets closed at the far end. This
680 tells us that any children created by the delivery to re-use any SMTP
681 channels have all finished. Since no process actually writes to the pipe,
682 the mere fact that read() unblocks is enough. */
684 set_process_info("running queue: waiting for children of %d", pid);
685 if (read(pfd[pipe_read], buffer, sizeof(buffer)) > 0)
686 log_write(0, LOG_MAIN|LOG_PANIC, "queue run: unexpected data on pipe");
687 (void)close(pfd[pipe_read]);
688 set_process_info("running queue");
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. */
693 if (running_in_test_harness && !queue_2stage)
695 uschar *fqtnext = Ustrchr(fudged_queue_times, '/');
696 if (fqtnext != NULL) fudged_queue_times = fqtnext + 1;
698 } /* End loop for list of messages */
700 store_reset(reset_point1); /* Scavenge list of messages */
702 /* If this was the first time through for random order processing, and
703 sub-directories have been found, randomize their order if necessary. */
705 if (i == 0 && subcount > 1 && !queue_run_in_order)
708 for (j = 1; j <= subcount; j++)
710 int r = random_number(100);
713 int k = (r % subcount) + 1;
715 subdirs[j] = subdirs[k];
720 } /* End loop for multiple directories */
722 /* If queue_2stage is true, we do it all again, with the 2stage flag
727 queue_2stage = FALSE;
728 queue_run(start_id, stop_id, TRUE);
731 /* At top level, log the end of the run. */
735 log_write(L_queue_run, LOG_MAIN, "End '%s' queue run: %s",
736 queue_name, log_detail);
738 log_write(L_queue_run, LOG_MAIN, "End queue run: %s", log_detail);
744 /************************************************
745 * Count messages on the queue *
746 ************************************************/
748 /* Called as a result of -bpc
759 queue_filename *f = NULL;
761 f = queue_get_spool_list(
762 -1, /* entire queue */
763 subdirs, /* for holding sub list */
764 &subcount, /* for subcount */
765 FALSE); /* not random */
766 for (; f != NULL; f = f->next) count++;
767 fprintf(stdout, "%d\n", count);
772 /************************************************
773 * List extra deliveries *
774 ************************************************/
776 /* This is called from queue_list below to print out all addresses that
777 have received a message but which were not primary addresses. That is, all
778 the addresses in the tree of non-recipients that are not primary addresses.
779 The tree has been scanned and the data field filled in for those that are
782 Argument: points to the tree node
786 static void queue_list_extras(tree_node *p)
788 if (p->left != NULL) queue_list_extras(p->left);
789 if (!p->data.val) printf(" +D %s\n", p->name);
790 if (p->right != NULL) queue_list_extras(p->right);
795 /************************************************
796 * List messages on the queue *
797 ************************************************/
799 /* Or a given list of messages. In the "all" case, we get a list of file names
800 as quickly as possible, then scan each one for information to output. If any
801 disappear while we are processing, just leave them out, but give an error if an
802 explicit list was given. This function is a top-level function that is obeyed
803 as a result of the -bp argument. As there may be a lot of messages on the
804 queue, we must tidy up the store after reading the headers for each one.
807 option 0 => list top-level recipients, with "D" for those delivered
808 1 => list only undelivered top-level recipients
809 2 => as 0, plus any generated delivered recipients
810 If 8 is added to any of these values, the queue is listed in
812 list => first of any message ids to list
813 count count of message ids; 0 => all
819 queue_list(int option, uschar **list, int count)
823 int now = (int)time(NULL);
825 queue_filename *f = NULL;
828 /* If given a list of messages, build a chain containing their ids. */
832 queue_filename *last = NULL;
833 for (i = 0; i < count; i++)
835 queue_filename *next =
836 store_get(sizeof(queue_filename) + Ustrlen(list[i]) + 2);
837 sprintf(CS next->text, "%s-H", list[i]);
838 next->dir_uschar = '*';
840 if (i == 0) f = next; else last->next = next;
845 /* Otherwise get a list of the entire queue, in order if necessary. */
848 f = queue_get_spool_list(
849 -1, /* entire queue */
850 subdirs, /* for holding sub list */
851 &subcount, /* for subcount */
852 option >= 8); /* randomize if required */
854 if (option >= 8) option -= 8;
856 /* Now scan the chain and print information, resetting store used
859 reset_point = store_get(0);
861 for (; f != NULL; f = f->next)
867 store_reset(reset_point);
869 message_subdir[0] = f->dir_uschar;
870 rc = spool_read_header(f->text, FALSE, count <= 0);
871 if (rc == spool_read_notopen && errno == ENOENT && count <= 0) continue;
874 env_read = (rc == spool_read_OK || rc == spool_read_hdrerror);
881 uschar * fname = spool_fname(US"input", message_subdir, f->text, US"");
883 ptr = Ustrlen(fname)-1;
886 /* Add the data size to the header size; don't count the file name
887 at the start of the data file, but add one for the notional blank line
888 that precedes the data. */
890 if (Ustat(fname, &statbuf) == 0)
891 size = message_size + statbuf.st_size - SPOOL_DATA_START_OFFSET + 1;
892 i = (now - received_time)/60; /* minutes on queue */
896 if (i > 72) printf("%2dd ", (i + 12)/24); else printf("%2dh ", i);
898 else printf("%2dm ", i);
900 /* Collect delivered addresses from any J file */
903 jread = Ufopen(fname, "rb");
906 while (Ufgets(big_buffer, big_buffer_size, jread) != NULL)
908 int n = Ustrlen(big_buffer);
910 tree_add_nonrecipient(big_buffer);
916 fprintf(stdout, "%s ", string_format_size(size, big_buffer));
917 for (i = 0; i < 16; i++) fputc(f->text[i], stdout);
919 if (env_read && sender_address != NULL)
921 printf(" <%s>", sender_address);
922 if (sender_set_untrusted) printf(" (%s)", originator_login);
925 if (rc != spool_read_OK)
928 if (save_errno == ERRNO_SPOOLFORMAT)
931 uschar * fname = spool_fname(US"input", message_subdir, f->text, US"");
933 if (Ustat(fname, &statbuf) == 0)
934 printf("*** spool format error: size=" OFF_T_FMT " ***",
936 else printf("*** spool format error ***");
938 else printf("*** spool read error: %s ***", strerror(save_errno));
939 if (rc != spool_read_hdrerror)
946 if (deliver_freeze) printf(" *** frozen ***");
950 if (recipients_list != NULL)
952 for (i = 0; i < recipients_count; i++)
954 tree_node *delivered =
955 tree_search(tree_nonrecipients, recipients_list[i].address);
956 if (!delivered || option != 1)
957 printf(" %s %s\n", (delivered != NULL)? "D":" ",
958 recipients_list[i].address);
959 if (delivered != NULL) delivered->data.val = TRUE;
961 if (option == 2 && tree_nonrecipients != NULL)
962 queue_list_extras(tree_nonrecipients);
970 /*************************************************
971 * Act on a specific message *
972 *************************************************/
974 /* Actions that require a list of addresses make use of argv/argc/
975 recipients_arg. Other actions do not. This function does its own
979 id id of the message to work on
980 action which action is required (MSG_xxx)
981 argv the original argv for Exim
982 argc the original argc for Exim
983 recipients_arg offset to the list of recipients in argv
985 Returns: FALSE if there was any problem
989 queue_action(uschar *id, int action, uschar **argv, int argc, int recipients_arg)
993 BOOL removed = FALSE;
995 uschar *doing = NULL;
998 uschar spoolname[32];
1000 /* Set the global message_id variable, used when re-writing spool files. This
1001 also causes message ids to be added to log messages. */
1003 Ustrcpy(message_id, id);
1005 /* The "actions" that just list the files do not require any locking to be
1006 done. Only admin users may read the spool files. */
1008 if (action >= MSG_SHOW_BODY)
1011 uschar *subdirectory, *suffix;
1015 printf("Permission denied\n");
1019 if (recipients_arg < argc)
1021 printf("*** Only one message can be listed at once\n");
1025 if (action == MSG_SHOW_BODY)
1027 subdirectory = US"input";
1030 else if (action == MSG_SHOW_HEADER)
1032 subdirectory = US"input";
1037 subdirectory = US"msglog";
1041 for (i = 0; i < 2; i++)
1043 message_subdir[0] = split_spool_directory == (i == 0) ? id[5] : 0;
1044 if ((fd = Uopen(spool_fname(subdirectory, message_subdir, id, suffix),
1050 printf("Failed to open %s file for %s%s: %s\n", subdirectory, id, suffix,
1052 if (action == MSG_SHOW_LOG && !message_logs)
1053 printf("(No message logs are being created because the message_logs "
1054 "option is false.)\n");
1058 while((rc = read(fd, big_buffer, big_buffer_size)) > 0)
1059 rc = write(fileno(stdout), big_buffer, rc);
1065 /* For actions that actually act, open and lock the data file to ensure that no
1066 other process is working on this message. If the file does not exist, continue
1067 only if the action is remove and the user is an admin user, to allow for
1068 tidying up broken states. */
1070 if ((deliver_datafile = spool_open_datafile(id)) < 0)
1071 if (errno == ENOENT)
1074 printf("Spool data file for %s does not exist\n", id);
1075 if (action != MSG_REMOVE || !admin_user) return FALSE;
1076 printf("Continuing, to ensure all files removed\n");
1080 if (errno == 0) printf("Message %s is locked\n", id);
1081 else printf("Couldn't open spool file for %s: %s\n", id,
1086 /* Read the spool header file for the message. Again, continue after an
1087 error only in the case of deleting by an administrator. Setting the third
1088 argument false causes it to look both in the main spool directory and in
1089 the appropriate subdirectory, and set message_subdir according to where it
1090 found the message. */
1092 sprintf(CS spoolname, "%s-H", id);
1093 if (spool_read_header(spoolname, TRUE, FALSE) != spool_read_OK)
1096 if (errno != ERRNO_SPOOLFORMAT)
1097 printf("Spool read error for %s: %s\n", spoolname, strerror(errno));
1099 printf("Spool format error for %s\n", spoolname);
1100 if (action != MSG_REMOVE || !admin_user)
1102 (void)close(deliver_datafile);
1103 deliver_datafile = -1;
1106 printf("Continuing to ensure all files removed\n");
1109 /* Check that the user running this process is entitled to operate on this
1110 message. Only admin users may freeze/thaw, add/cancel recipients, or otherwise
1111 mess about, but the original sender is permitted to remove a message. That's
1112 why we leave this check until after the headers are read. */
1114 if (!admin_user && (action != MSG_REMOVE || real_uid != originator_uid))
1116 printf("Permission denied\n");
1117 (void)close(deliver_datafile);
1118 deliver_datafile = -1;
1122 /* Set up the user name for logging. */
1124 pw = getpwuid(real_uid);
1125 username = (pw != NULL)?
1126 US pw->pw_name : string_sprintf("uid %ld", (long int)real_uid);
1128 /* Take the necessary action. */
1130 if (action != MSG_SHOW_COPY) printf("Message %s ", id);
1135 deliver_in_buffer = store_malloc(DELIVER_IN_BUFFER_SIZE);
1136 deliver_out_buffer = store_malloc(DELIVER_OUT_BUFFER_SIZE);
1137 transport_write_message(1, NULL, 0);
1145 printf("is already frozen\n");
1149 deliver_freeze = TRUE;
1150 deliver_manual_thaw = FALSE;
1151 deliver_frozen_at = time(NULL);
1152 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1154 printf("is now frozen\n");
1155 log_write(0, LOG_MAIN, "frozen by %s", username);
1160 printf("could not be frozen: %s\n", errmsg);
1167 if (!deliver_freeze)
1170 printf("is not frozen\n");
1174 deliver_freeze = FALSE;
1175 deliver_manual_thaw = TRUE;
1176 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1178 printf("is no longer frozen\n");
1179 log_write(0, LOG_MAIN, "unfrozen by %s", username);
1184 printf("could not be unfrozen: %s\n", errmsg);
1190 /* We must ensure all files are removed from both the input directory
1191 and the appropriate subdirectory, to clean up cases when there are odd
1192 files left lying around in odd places. In the normal case message_subdir
1193 will have been set correctly by spool_read_header, but as this is a rare
1194 operation, just run everything twice. */
1202 message_subdir[0] = id[5];
1204 for (j = 0; j < 2; message_subdir[0] = 0, j++)
1206 uschar * fname = spool_fname(US"msglog", message_subdir, id, US"");
1208 DEBUG(D_any) debug_printf(" removing %s", fname);
1209 if (Uunlink(fname) < 0)
1211 if (errno != ENOENT)
1214 printf("Error while removing %s: %s\n", fname, strerror(errno));
1216 else DEBUG(D_any) debug_printf(" (no file)\n");
1221 DEBUG(D_any) debug_printf(" (ok)\n");
1224 for (i = 0; i < 3; i++)
1228 suffix[1] = (US"DHJ")[i];
1229 fname = spool_fname(US"input", message_subdir, id, suffix);
1231 DEBUG(D_any) debug_printf(" removing %s", fname);
1232 if (Uunlink(fname) < 0)
1234 if (errno != ENOENT)
1237 printf("Error while removing %s: %s\n", fname, strerror(errno));
1239 else DEBUG(D_any) debug_printf(" (no file)\n");
1244 DEBUG(D_any) debug_printf(" (done)\n");
1249 /* In the common case, the datafile is open (and locked), so give the
1250 obvious message. Otherwise be more specific. */
1252 if (deliver_datafile >= 0) printf("has been removed\n");
1253 else printf("has been removed or did not exist\n");
1256 log_write(0, LOG_MAIN, "removed by %s", username);
1257 log_write(0, LOG_MAIN, "Completed");
1263 case MSG_MARK_ALL_DELIVERED:
1264 for (i = 0; i < recipients_count; i++)
1266 tree_add_nonrecipient(recipients_list[i].address);
1268 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1270 printf("has been modified\n");
1271 for (i = 0; i < recipients_count; i++)
1272 log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1273 recipients_list[i].address, username);
1278 printf("- could not mark all delivered: %s\n", errmsg);
1283 case MSG_EDIT_SENDER:
1284 if (recipients_arg < argc - 1)
1287 printf("- only one sender address can be specified\n");
1290 doing = US"editing sender";
1293 case MSG_ADD_RECIPIENT:
1294 if (doing == NULL) doing = US"adding recipient";
1297 case MSG_MARK_DELIVERED:
1298 if (doing == NULL) doing = US"marking as delivered";
1300 /* Common code for EDIT_SENDER, ADD_RECIPIENT, & MARK_DELIVERED */
1302 if (recipients_arg >= argc)
1305 printf("- error while %s: no address given\n", doing);
1309 for (; recipients_arg < argc; recipients_arg++)
1311 int start, end, domain;
1314 parse_extract_address(argv[recipients_arg], &errmess, &start, &end,
1315 &domain, (action == MSG_EDIT_SENDER));
1317 if (recipient == NULL)
1320 printf("- error while %s:\n bad address %s: %s\n",
1321 doing, argv[recipients_arg], errmess);
1323 else if (recipient[0] != 0 && domain == 0)
1326 printf("- error while %s:\n bad address %s: "
1327 "domain missing\n", doing, argv[recipients_arg]);
1331 if (action == MSG_ADD_RECIPIENT)
1334 if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1336 receive_add_recipient(recipient, -1);
1337 log_write(0, LOG_MAIN, "recipient <%s> added by %s",
1338 recipient, username);
1340 else if (action == MSG_MARK_DELIVERED)
1342 for (i = 0; i < recipients_count; i++)
1343 if (Ustrcmp(recipients_list[i].address, recipient) == 0) break;
1344 if (i >= recipients_count)
1346 printf("- error while %s:\n %s is not a recipient:"
1347 " message not updated\n", doing, recipient);
1352 tree_add_nonrecipient(recipients_list[i].address);
1353 log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1354 recipient, username);
1357 else /* MSG_EDIT_SENDER */
1360 if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1362 sender_address = recipient;
1363 log_write(0, LOG_MAIN, "sender address changed to <%s> by %s",
1364 recipient, username);
1370 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1371 printf("has been modified\n");
1375 printf("- while %s: %s\n", doing, errmsg);
1381 /* Closing the datafile releases the lock and permits other processes
1382 to operate on the message (if it still exists). */
1384 if (deliver_datafile >= 0)
1386 (void)close(deliver_datafile);
1387 deliver_datafile = -1;
1394 /*************************************************
1395 * Check the queue_only_file condition *
1396 *************************************************/
1398 /* The queue_only_file option forces certain kinds of queueing if a given file
1406 queue_check_only(void)
1410 struct stat statbuf;
1413 uschar buffer[1024];
1415 if (queue_only_file == NULL) return;
1417 s = queue_only_file;
1418 while ((ss = string_nextinlist(&s, &sep, buffer, sizeof(buffer))) != NULL)
1420 if (Ustrncmp(ss, "smtp", 4) == 0)
1422 name = US"queue_smtp";
1428 name = US"queue_only";
1432 if (Ustat(ss, &statbuf) == 0)
1435 DEBUG(D_receive) debug_printf("%s set because %s exists\n", name, ss);
1440 #endif /*!COMPILE_UTILITY*/
1442 /* End of queue.c */