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 /* The number of nodes to use for the bottom-up merge sort when a list of queue
16 items is to be ordered. The code for this sort was contributed as a patch by
19 #define LOG2_MAXNODES 32
23 /* Routines with knowlege of spool layout */
26 spool_pname_buf(uschar * buf, int len)
28 snprintf(CS buf, len, "%s/input/%s", spool_directory, queue_name);
32 spool_dname(const uschar * purpose, uschar * subdir)
34 return string_sprintf("%s/%s/%s/%s",
35 spool_directory, purpose, queue_name, subdir);
39 spool_sname(const uschar * purpose, uschar * subdir)
41 return string_sprintf("%s%s%s%s%s",
43 *queue_name ? "/" : "", queue_name,
44 *message_subdir ? "/" : "", message_subdir);
48 spool_fname(const uschar * purpose, uschar * subdir, uschar * fname, uschar * suffix)
50 return string_sprintf("%s/%s/%s/%s/%s%s",
51 spool_directory, purpose, queue_name, subdir, fname, suffix);
57 #ifndef COMPILE_UTILITY
58 /*************************************************
59 * Helper sort function for queue_get_spool_list *
60 *************************************************/
62 /* This function is used when sorting the queue list in the function
63 queue_get_spool_list() below.
66 a points to an ordered list of queue_filename items
67 b points to another ordered list
69 Returns: a pointer to a merged ordered list
72 static queue_filename *
73 merge_queue_lists(queue_filename *a, queue_filename *b)
75 queue_filename *first = NULL;
76 queue_filename **append = &first;
78 while (a != NULL && b != NULL)
80 if (Ustrcmp(a->text, b->text) < 0)
94 *append=((a != NULL)? a : b);
102 /*************************************************
103 * Get list of spool files *
104 *************************************************/
106 /* Scan the spool directory and return a list of the relevant file names
107 therein. Single-character sub-directories are handled as follows:
109 If the first argument is > 0, a sub-directory is scanned; the letter is
110 taken from the nth entry in subdirs.
112 If the first argument is 0, sub-directories are not scanned. However, a
113 list of them is returned.
115 If the first argument is < 0, sub-directories are scanned for messages,
116 and a single, unified list is created. The returned data blocks contain the
117 identifying character of the subdirectory, if any. The subdirs vector is
118 still required as an argument.
120 If the randomize argument is TRUE, messages are returned in "randomized" order.
121 Actually, the order is anything but random, but the algorithm is cheap, and the
122 point is simply to ensure that the same order doesn't occur every time, in case
123 a particular message is causing a remote MTA to barf - we would like to try
124 other messages to that MTA first.
126 If the randomize argument is FALSE, sort the list according to the file name.
127 This should give the order in which the messages arrived. It is normally used
128 only for presentation to humans, in which case the (possibly expensive) sort
129 that it does is not part of the normal operational code. However, if
130 queue_run_in_order is set, sorting has to take place for queue runs as well.
131 When randomize is FALSE, the first argument is normally -1, so all messages are
135 subdiroffset sub-directory character offset, or 0 or -1 (see above)
136 subdirs vector to store list of subdirchars
137 subcount pointer to int in which to store count of subdirs
138 randomize TRUE if the order of the list is to be unpredictable
140 Returns: pointer to a chain of queue name items
143 static queue_filename *
144 queue_get_spool_list(int subdiroffset, uschar *subdirs, int *subcount,
151 queue_filename *yield = NULL;
152 queue_filename *last = NULL;
156 queue_filename *root[LOG2_MAXNODES];
158 /* When randomizing, the file names are added to the start or end of the list
159 according to the bits of the flags variable. Get a collection of bits from the
160 current time. Use the bottom 16 and just keep re-using them if necessary. When
161 not randomizing, initialize the sublists for the bottom-up merge sort. */
163 if (randomize) resetflags = time(NULL) & 0xFFFF;
164 else for (i = 0; i < LOG2_MAXNODES; i++) root[i] = NULL;
166 /* If processing the full queue, or just the top-level, start at the base
167 directory, and initialize the first subdirectory name (as none). Otherwise,
168 start at the sub-directory offset. */
170 if (subdiroffset <= 0)
176 else i = subdiroffset;
178 /* Set up prototype for the directory name. */
180 spool_pname_buf(buffer, sizeof(buffer));
181 buffer[sizeof(buffer) - 3] = 0;
182 subptr = Ustrlen(buffer);
183 buffer[subptr+2] = 0; /* terminator for lengthened name */
185 /* This loop runs at least once, for the main or given directory, and then as
186 many times as necessary to scan any subdirectories encountered in the main
187 directory, if they are to be scanned at this time. */
189 for (; i <= *subcount; i++)
192 int subdirchar = subdirs[i]; /* 0 for main directory */
196 buffer[subptr] = '/';
197 buffer[subptr+1] = subdirchar;
200 DEBUG(D_queue_run) debug_printf("looking in %s\n", buffer);
201 if (!(dd = opendir(CS buffer)))
204 /* Now scan the directory. */
206 while ((ent = readdir(dd)) != NULL)
208 uschar *name = US ent->d_name;
209 int len = Ustrlen(name);
215 /* If we find a single alphameric sub-directory in the base directory,
216 add it to the list for subsequent scans. */
218 if (i == 0 && len == 1 && isalnum(*name))
220 *subcount = *subcount + 1;
221 subdirs[*subcount] = *name;
225 /* Otherwise, if it is a header spool file, add it to the list */
227 if (len == SPOOL_NAME_LENGTH &&
228 Ustrcmp(name + SPOOL_NAME_LENGTH - 2, "-H") == 0)
230 queue_filename *next =
231 store_get(sizeof(queue_filename) + Ustrlen(name));
232 Ustrcpy(next->text, name);
233 next->dir_uschar = subdirchar;
235 /* Handle the creation of a randomized list. The first item becomes both
236 the top and bottom of the list. Subsequent items are inserted either at
237 the top or the bottom, randomly. This is, I argue, faster than doing a
238 sort by allocating a random number to each item, and it also saves having
239 to store the number with each item. */
250 if (flags == 0) flags = resetflags;
251 if ((flags & 1) == 0)
266 /* Otherwise do a bottom-up merge sort based on the name. */
272 for (j = 0; j < LOG2_MAXNODES; j++)
276 next = merge_queue_lists(next, root[j]);
277 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. */
318 if (subdiroffset == 0) break;
320 } /* Loop for multiple subdirectories */
322 /* When using a bottom-up merge sort, do the final merging of the sublists.
323 Then pass back the final list of file items. */
326 for (i = 0; i < LOG2_MAXNODES; ++i)
327 yield = merge_queue_lists(yield, root[i]);
335 /*************************************************
336 * Perform a queue run *
337 *************************************************/
339 /* The arguments give the messages to start and stop at; NULL means start at
340 the beginning or stop at the end. If the given start message doesn't exist, we
341 start at the next lexically greater one, and likewise we stop at the after the
342 previous lexically lesser one if the given stop message doesn't exist. Because
343 a queue run can take some time, stat each file before forking, in case it has
344 been delivered in the meantime by some other means.
346 The global variables queue_run_force and queue_run_local may be set to cause
347 forced deliveries or local-only deliveries, respectively.
349 If deliver_selectstring[_sender] is not NULL, skip messages whose recipients do
350 not contain the string. As this option is typically used when a machine comes
351 back online, we want to ensure that at least one delivery attempt takes place,
352 so force the first one. The selecting string can optionally be a regex, or
353 refer to the sender instead of recipients.
355 If queue_2stage is set, the queue is scanned twice. The first time, queue_smtp
356 is set so that routing is done for all messages. Thus in the second run those
357 that are routed to the same host should go down the same SMTP connection.
360 start_id message id to start at, or NULL for all
361 stop_id message id to end at, or NULL for all
362 recurse TRUE if recursing for 2-stage run
368 queue_run(uschar *start_id, uschar *stop_id, BOOL recurse)
370 BOOL force_delivery = queue_run_force || deliver_selectstring != NULL ||
371 deliver_selectstring_sender != NULL;
372 const pcre *selectstring_regex = NULL;
373 const pcre *selectstring_regex_sender = NULL;
374 uschar *log_detail = NULL;
379 /* Cancel any specific queue domains. Turn off the flag that causes SMTP
380 deliveries not to happen, unless doing a 2-stage queue run, when the SMTP flag
381 gets set. Save the queue_runner's pid and the flag that indicates any
382 deliveries run directly from this process. Deliveries that are run by handing
383 on TCP/IP channels have queue_run_pid set, but not queue_running. */
385 queue_domains = NULL;
386 queue_smtp_domains = NULL;
387 queue_smtp = queue_2stage;
389 queue_run_pid = getpid();
390 queue_running = TRUE;
392 /* Log the true start of a queue run, and fancy options */
399 if (queue_2stage) *p++ = 'q';
400 if (queue_run_first_delivery) *p++ = 'i';
401 if (queue_run_force) *p++ = 'f';
402 if (deliver_force_thaw) *p++ = 'f';
403 if (queue_run_local) *p++ = 'l';
407 sprintf(CS p, "pid=%d", (int)queue_run_pid);
412 sprintf(CS p, " -q%s", extras);
416 if (deliver_selectstring != NULL)
418 sprintf(CS p, " -R%s %s", deliver_selectstring_regex? "r" : "",
419 deliver_selectstring);
423 if (deliver_selectstring_sender != NULL)
425 sprintf(CS p, " -S%s %s", deliver_selectstring_sender_regex? "r" : "",
426 deliver_selectstring_sender);
430 log_detail = string_copy(big_buffer);
432 log_write(L_queue_run, LOG_MAIN, "Start '%s' queue run: %s",
433 queue_name, log_detail);
435 log_write(L_queue_run, LOG_MAIN, "Start queue run: %s", log_detail);
438 /* If deliver_selectstring is a regex, compile it. */
440 if (deliver_selectstring != NULL && deliver_selectstring_regex)
441 selectstring_regex = regex_must_compile(deliver_selectstring, TRUE, FALSE);
443 if (deliver_selectstring_sender != NULL && deliver_selectstring_sender_regex)
444 selectstring_regex_sender =
445 regex_must_compile(deliver_selectstring_sender, TRUE, FALSE);
447 /* If the spool is split into subdirectories, we want to process it one
448 directory at a time, so as to spread out the directory scanning and the
449 delivering when there are lots of messages involved, except when
450 queue_run_in_order is set.
452 In the random order case, this loop runs once for the main directory (handling
453 any messages therein), and then repeats for any subdirectories that were found.
454 When the first argument of queue_get_spool_list() is 0, it scans the top
455 directory, fills in subdirs, and sets subcount. The order of the directories is
456 then randomized after the first time through, before they are scanned in
457 subsqeuent iterations.
459 When the first argument of queue_get_spool_list() is -1 (for queue_run_in_
460 order), it scans all directories and makes a single message list. */
462 for (i = (queue_run_in_order? -1 : 0);
463 i <= (queue_run_in_order? -1 : subcount);
467 void *reset_point1 = store_get(0);
472 debug_printf("queue running main directory\n");
474 debug_printf("queue running combined directories\n");
476 debug_printf("queue running subdirectory '%c'\n", subdirs[i]);
479 for (f = queue_get_spool_list(i, subdirs, &subcount, !queue_run_in_order);
489 /* Unless deliveries are forced, if deliver_queue_load_max is non-negative,
490 check that the load average is low enough to permit deliveries. */
492 if (!queue_run_force && deliver_queue_load_max >= 0)
494 load_average = os_getloadavg();
495 if (load_average > deliver_queue_load_max)
497 log_write(L_queue_run, LOG_MAIN, "Abandon queue run: %s (load %.2f, max %.2f)",
499 (double)load_average/1000.0,
500 (double)deliver_queue_load_max/1000.0);
501 i = subcount; /* Don't process other directories */
506 DEBUG(D_load) debug_printf("load average = %.2f max = %.2f\n",
507 (double)load_average/1000.0,
508 (double)deliver_queue_load_max/1000.0);
512 /* Skip this message unless it's within the ID limits */
514 if (stop_id != NULL && Ustrncmp(f->text, stop_id, MESSAGE_ID_LENGTH) > 0)
516 if (start_id != NULL && Ustrncmp(f->text, start_id, MESSAGE_ID_LENGTH) < 0)
519 /* Check that the message still exists */
521 message_subdir[0] = f->dir_uschar;
522 if (Ustat(spool_fname(US"input", message_subdir, f->text, US""), &statbuf) < 0)
525 /* There are some tests that require the reading of the header file. Ensure
526 the store used is scavenged afterwards so that this process doesn't keep
527 growing its store. We have to read the header file again when actually
528 delivering, but it's cheaper than forking a delivery process for each
529 message when many are not going to be delivered. */
531 if (deliver_selectstring != NULL || deliver_selectstring_sender != NULL ||
532 queue_run_first_delivery)
535 BOOL orig_dont_deliver = dont_deliver;
536 void *reset_point2 = store_get(0);
538 /* Restore the original setting of dont_deliver after reading the header,
539 so that a setting for a particular message doesn't force it for any that
540 follow. If the message is chosen for delivery, the header is read again
541 in the deliver_message() function, in a subprocess. */
543 if (spool_read_header(f->text, FALSE, TRUE) != spool_read_OK) continue;
544 dont_deliver = orig_dont_deliver;
546 /* Now decide if we want to deliver this message. As we have read the
547 header file, we might as well do the freeze test now, and save forking
550 if (deliver_freeze && !deliver_force_thaw)
552 log_write(L_skip_delivery, LOG_MAIN, "Message is frozen");
556 /* Check first_delivery in the case when there are no message logs. */
558 else if (queue_run_first_delivery && !deliver_firsttime)
560 DEBUG(D_queue_run) debug_printf("%s: not first delivery\n", f->text);
564 /* Check for a matching address if deliver_selectstring[_sender} is set.
565 If so, we do a fully delivery - don't want to omit other addresses since
566 their routing might trigger re-writing etc. */
568 /* Sender matching */
570 else if (deliver_selectstring_sender != NULL &&
571 !(deliver_selectstring_sender_regex?
572 (pcre_exec(selectstring_regex_sender, NULL, CS sender_address,
573 Ustrlen(sender_address), 0, PCRE_EOPT, NULL, 0) >= 0)
575 (strstric(sender_address, deliver_selectstring_sender, FALSE)
578 DEBUG(D_queue_run) debug_printf("%s: sender address did not match %s\n",
579 f->text, deliver_selectstring_sender);
583 /* Recipient matching */
585 else if (deliver_selectstring != NULL)
588 for (i = 0; i < recipients_count; i++)
590 uschar *address = recipients_list[i].address;
591 if ((deliver_selectstring_regex?
592 (pcre_exec(selectstring_regex, NULL, CS address,
593 Ustrlen(address), 0, PCRE_EOPT, NULL, 0) >= 0)
595 (strstric(address, deliver_selectstring, FALSE) != NULL))
597 tree_search(tree_nonrecipients, address) == NULL)
601 if (i >= recipients_count)
604 debug_printf("%s: no recipient address matched %s\n",
605 f->text, deliver_selectstring);
610 /* Recover store used when reading the header */
612 store_reset(reset_point2);
613 if (!wanted) continue; /* With next message */
616 /* OK, got a message we want to deliver. Create a pipe which will
617 serve as a means of detecting when all the processes created by the
618 delivery process are finished. This is relevant when the delivery
619 process passes one or more SMTP channels on to its own children. The
620 pipe gets passed down; by reading on it here we detect when the last
621 descendent dies by the unblocking of the read. It's a pity that for
622 most of the time the pipe isn't used, but creating a pipe should be
627 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to create pipe in queue "
628 "runner process %d: %s", queue_run_pid, strerror(errno));
630 queue_run_pipe = pfd[pipe_write]; /* To ensure it gets passed on. */
632 /* Make sure it isn't stdin. This seems unlikely, but just to be on the
635 if (queue_run_pipe == 0)
637 queue_run_pipe = dup(queue_run_pipe);
641 /* Before forking to deliver the message, ensure any open and cached
642 lookup files or databases are closed. Otherwise, closing in the subprocess
643 can make the next subprocess have problems. There won't often be anything
644 open here, but it is possible (e.g. if spool_directory is an expanded
645 string). A single call before this loop would probably suffice, but just in
646 case expansions get inserted at some point, I've taken the heavy-handed
647 approach. When nothing is open, the call should be cheap. */
651 /* Now deliver the message; get the id by cutting the -H off the file
652 name. The return of the process is zero if a delivery was attempted. */
654 set_process_info("running queue: %s", f->text);
655 f->text[SPOOL_NAME_LENGTH-2] = 0;
656 if ((pid = fork()) == 0)
659 if (running_in_test_harness) millisleep(100);
660 (void)close(pfd[pipe_read]);
661 rc = deliver_message(f->text, force_delivery, FALSE);
662 _exit(rc == DELIVER_NOT_ATTEMPTED);
665 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork of delivery process from "
666 "queue runner %d failed\n", queue_run_pid);
668 /* Close the writing end of the synchronizing pipe in this process,
669 then wait for the first level process to terminate. */
671 (void)close(pfd[pipe_write]);
672 set_process_info("running queue: waiting for %s (%d)", f->text, pid);
673 while (wait(&status) != pid);
675 /* A zero return means a delivery was attempted; turn off the force flag
676 for any subsequent calls unless queue_force is set. */
678 if ((status & 0xffff) == 0) force_delivery = queue_run_force;
680 /* If the process crashed, tell somebody */
682 else if ((status & 0x00ff) != 0)
684 log_write(0, LOG_MAIN|LOG_PANIC,
685 "queue run: process %d crashed with signal %d while delivering %s",
686 (int)pid, status & 0x00ff, f->text);
689 /* Before continuing, wait till the pipe gets closed at the far end. This
690 tells us that any children created by the delivery to re-use any SMTP
691 channels have all finished. Since no process actually writes to the pipe,
692 the mere fact that read() unblocks is enough. */
694 set_process_info("running queue: waiting for children of %d", pid);
695 if (read(pfd[pipe_read], buffer, sizeof(buffer)) > 0)
696 log_write(0, LOG_MAIN|LOG_PANIC, "queue run: unexpected data on pipe");
697 (void)close(pfd[pipe_read]);
698 set_process_info("running queue");
700 /* If we are in the test harness, and this is not the first of a 2-stage
701 queue run, update fudged queue times. */
703 if (running_in_test_harness && !queue_2stage)
705 uschar *fqtnext = Ustrchr(fudged_queue_times, '/');
706 if (fqtnext != NULL) fudged_queue_times = fqtnext + 1;
708 } /* End loop for list of messages */
710 store_reset(reset_point1); /* Scavenge list of messages */
712 /* If this was the first time through for random order processing, and
713 sub-directories have been found, randomize their order if necessary. */
715 if (i == 0 && subcount > 1 && !queue_run_in_order)
718 for (j = 1; j <= subcount; j++)
720 int r = random_number(100);
723 int k = (r % subcount) + 1;
725 subdirs[j] = subdirs[k];
730 } /* End loop for multiple directories */
732 /* If queue_2stage is true, we do it all again, with the 2stage flag
737 queue_2stage = FALSE;
738 queue_run(start_id, stop_id, TRUE);
741 /* At top level, log the end of the run. */
745 log_write(L_queue_run, LOG_MAIN, "End '%s' queue run: %s",
746 queue_name, log_detail);
748 log_write(L_queue_run, LOG_MAIN, "End queue run: %s", log_detail);
754 /************************************************
755 * Count messages on the queue *
756 ************************************************/
758 /* Called as a result of -bpc
769 queue_filename *f = NULL;
771 f = queue_get_spool_list(
772 -1, /* entire queue */
773 subdirs, /* for holding sub list */
774 &subcount, /* for subcount */
775 FALSE); /* not random */
776 for (; f != NULL; f = f->next) count++;
777 fprintf(stdout, "%d\n", count);
782 /************************************************
783 * List extra deliveries *
784 ************************************************/
786 /* This is called from queue_list below to print out all addresses that
787 have received a message but which were not primary addresses. That is, all
788 the addresses in the tree of non-recipients that are not primary addresses.
789 The tree has been scanned and the data field filled in for those that are
792 Argument: points to the tree node
796 static void queue_list_extras(tree_node *p)
798 if (p->left != NULL) queue_list_extras(p->left);
799 if (!p->data.val) printf(" +D %s\n", p->name);
800 if (p->right != NULL) queue_list_extras(p->right);
805 /************************************************
806 * List messages on the queue *
807 ************************************************/
809 /* Or a given list of messages. In the "all" case, we get a list of file names
810 as quickly as possible, then scan each one for information to output. If any
811 disappear while we are processing, just leave them out, but give an error if an
812 explicit list was given. This function is a top-level function that is obeyed
813 as a result of the -bp argument. As there may be a lot of messages on the
814 queue, we must tidy up the store after reading the headers for each one.
817 option 0 => list top-level recipients, with "D" for those delivered
818 1 => list only undelivered top-level recipients
819 2 => as 0, plus any generated delivered recipients
820 If 8 is added to any of these values, the queue is listed in
822 list => first of any message ids to list
823 count count of message ids; 0 => all
829 queue_list(int option, uschar **list, int count)
833 int now = (int)time(NULL);
835 queue_filename *f = NULL;
838 /* If given a list of messages, build a chain containing their ids. */
842 queue_filename *last = NULL;
843 for (i = 0; i < count; i++)
845 queue_filename *next =
846 store_get(sizeof(queue_filename) + Ustrlen(list[i]) + 2);
847 sprintf(CS next->text, "%s-H", list[i]);
848 next->dir_uschar = '*';
850 if (i == 0) f = next; else last->next = next;
855 /* Otherwise get a list of the entire queue, in order if necessary. */
858 f = queue_get_spool_list(
859 -1, /* entire queue */
860 subdirs, /* for holding sub list */
861 &subcount, /* for subcount */
862 option >= 8); /* randomize if required */
864 if (option >= 8) option -= 8;
866 /* Now scan the chain and print information, resetting store used
869 reset_point = store_get(0);
871 for (; f != NULL; f = f->next)
877 store_reset(reset_point);
879 message_subdir[0] = f->dir_uschar;
880 rc = spool_read_header(f->text, FALSE, count <= 0);
881 if (rc == spool_read_notopen && errno == ENOENT && count <= 0) continue;
884 env_read = (rc == spool_read_OK || rc == spool_read_hdrerror);
891 uschar * fname = spool_fname(US"input", message_subdir, f->text, US"");
893 ptr = Ustrlen(fname)-1;
896 /* Add the data size to the header size; don't count the file name
897 at the start of the data file, but add one for the notional blank line
898 that precedes the data. */
900 if (Ustat(fname, &statbuf) == 0)
901 size = message_size + statbuf.st_size - SPOOL_DATA_START_OFFSET + 1;
902 i = (now - received_time)/60; /* minutes on queue */
906 if (i > 72) printf("%2dd ", (i + 12)/24); else printf("%2dh ", i);
908 else printf("%2dm ", i);
910 /* Collect delivered addresses from any J file */
913 jread = Ufopen(fname, "rb");
916 while (Ufgets(big_buffer, big_buffer_size, jread) != NULL)
918 int n = Ustrlen(big_buffer);
920 tree_add_nonrecipient(big_buffer);
926 fprintf(stdout, "%s ", string_format_size(size, big_buffer));
927 for (i = 0; i < 16; i++) fputc(f->text[i], stdout);
929 if (env_read && sender_address != NULL)
931 printf(" <%s>", sender_address);
932 if (sender_set_untrusted) printf(" (%s)", originator_login);
935 if (rc != spool_read_OK)
938 if (save_errno == ERRNO_SPOOLFORMAT)
941 uschar * fname = spool_fname(US"input", message_subdir, f->text, US"");
943 if (Ustat(fname, &statbuf) == 0)
944 printf("*** spool format error: size=" OFF_T_FMT " ***",
946 else printf("*** spool format error ***");
948 else printf("*** spool read error: %s ***", strerror(save_errno));
949 if (rc != spool_read_hdrerror)
956 if (deliver_freeze) printf(" *** frozen ***");
960 if (recipients_list != NULL)
962 for (i = 0; i < recipients_count; i++)
964 tree_node *delivered =
965 tree_search(tree_nonrecipients, recipients_list[i].address);
966 if (!delivered || option != 1)
967 printf(" %s %s\n", (delivered != NULL)? "D":" ",
968 recipients_list[i].address);
969 if (delivered != NULL) delivered->data.val = TRUE;
971 if (option == 2 && tree_nonrecipients != NULL)
972 queue_list_extras(tree_nonrecipients);
980 /*************************************************
981 * Act on a specific message *
982 *************************************************/
984 /* Actions that require a list of addresses make use of argv/argc/
985 recipients_arg. Other actions do not. This function does its own
989 id id of the message to work on
990 action which action is required (MSG_xxx)
991 argv the original argv for Exim
992 argc the original argc for Exim
993 recipients_arg offset to the list of recipients in argv
995 Returns: FALSE if there was any problem
999 queue_action(uschar *id, int action, uschar **argv, int argc, int recipients_arg)
1003 BOOL removed = FALSE;
1005 uschar *doing = NULL;
1008 uschar spoolname[32];
1010 /* Set the global message_id variable, used when re-writing spool files. This
1011 also causes message ids to be added to log messages. */
1013 Ustrcpy(message_id, id);
1015 /* The "actions" that just list the files do not require any locking to be
1016 done. Only admin users may read the spool files. */
1018 if (action >= MSG_SHOW_BODY)
1021 uschar *subdirectory, *suffix;
1025 printf("Permission denied\n");
1029 if (recipients_arg < argc)
1031 printf("*** Only one message can be listed at once\n");
1035 if (action == MSG_SHOW_BODY)
1037 subdirectory = US"input";
1040 else if (action == MSG_SHOW_HEADER)
1042 subdirectory = US"input";
1047 subdirectory = US"msglog";
1051 for (i = 0; i < 2; i++)
1053 message_subdir[0] = split_spool_directory == (i == 0) ? id[5] : 0;
1054 if ((fd = Uopen(spool_fname(subdirectory, message_subdir, id, suffix),
1060 printf("Failed to open %s file for %s%s: %s\n", subdirectory, id, suffix,
1062 if (action == MSG_SHOW_LOG && !message_logs)
1063 printf("(No message logs are being created because the message_logs "
1064 "option is false.)\n");
1068 while((rc = read(fd, big_buffer, big_buffer_size)) > 0)
1069 rc = write(fileno(stdout), big_buffer, rc);
1075 /* For actions that actually act, open and lock the data file to ensure that no
1076 other process is working on this message. If the file does not exist, continue
1077 only if the action is remove and the user is an admin user, to allow for
1078 tidying up broken states. */
1080 if ((deliver_datafile = spool_open_datafile(id)) < 0)
1081 if (errno == ENOENT)
1084 printf("Spool data file for %s does not exist\n", id);
1085 if (action != MSG_REMOVE || !admin_user) return FALSE;
1086 printf("Continuing, to ensure all files removed\n");
1090 if (errno == 0) printf("Message %s is locked\n", id);
1091 else printf("Couldn't open spool file for %s: %s\n", id,
1096 /* Read the spool header file for the message. Again, continue after an
1097 error only in the case of deleting by an administrator. Setting the third
1098 argument false causes it to look both in the main spool directory and in
1099 the appropriate subdirectory, and set message_subdir according to where it
1100 found the message. */
1102 sprintf(CS spoolname, "%s-H", id);
1103 if (spool_read_header(spoolname, TRUE, FALSE) != spool_read_OK)
1106 if (errno != ERRNO_SPOOLFORMAT)
1107 printf("Spool read error for %s: %s\n", spoolname, strerror(errno));
1109 printf("Spool format error for %s\n", spoolname);
1110 if (action != MSG_REMOVE || !admin_user)
1112 (void)close(deliver_datafile);
1113 deliver_datafile = -1;
1116 printf("Continuing to ensure all files removed\n");
1119 /* Check that the user running this process is entitled to operate on this
1120 message. Only admin users may freeze/thaw, add/cancel recipients, or otherwise
1121 mess about, but the original sender is permitted to remove a message. That's
1122 why we leave this check until after the headers are read. */
1124 if (!admin_user && (action != MSG_REMOVE || real_uid != originator_uid))
1126 printf("Permission denied\n");
1127 (void)close(deliver_datafile);
1128 deliver_datafile = -1;
1132 /* Set up the user name for logging. */
1134 pw = getpwuid(real_uid);
1135 username = (pw != NULL)?
1136 US pw->pw_name : string_sprintf("uid %ld", (long int)real_uid);
1138 /* Take the necessary action. */
1140 if (action != MSG_SHOW_COPY) printf("Message %s ", id);
1145 deliver_in_buffer = store_malloc(DELIVER_IN_BUFFER_SIZE);
1146 deliver_out_buffer = store_malloc(DELIVER_OUT_BUFFER_SIZE);
1147 transport_write_message(NULL, 1, 0, 0, NULL, NULL, NULL, NULL, NULL, 0);
1155 printf("is already frozen\n");
1159 deliver_freeze = TRUE;
1160 deliver_manual_thaw = FALSE;
1161 deliver_frozen_at = time(NULL);
1162 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1164 printf("is now frozen\n");
1165 log_write(0, LOG_MAIN, "frozen by %s", username);
1170 printf("could not be frozen: %s\n", errmsg);
1177 if (!deliver_freeze)
1180 printf("is not frozen\n");
1184 deliver_freeze = FALSE;
1185 deliver_manual_thaw = TRUE;
1186 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1188 printf("is no longer frozen\n");
1189 log_write(0, LOG_MAIN, "unfrozen by %s", username);
1194 printf("could not be unfrozen: %s\n", errmsg);
1200 /* We must ensure all files are removed from both the input directory
1201 and the appropriate subdirectory, to clean up cases when there are odd
1202 files left lying around in odd places. In the normal case message_subdir
1203 will have been set correctly by spool_read_header, but as this is a rare
1204 operation, just run everything twice. */
1212 message_subdir[0] = id[5];
1214 for (j = 0; j < 2; message_subdir[0] = 0, j++)
1216 uschar * fname = spool_fname(US"msglog", message_subdir, id, US"");
1218 DEBUG(D_any) debug_printf(" removing %s", fname);
1219 if (Uunlink(fname) < 0)
1221 if (errno != ENOENT)
1224 printf("Error while removing %s: %s\n", fname, strerror(errno));
1226 else DEBUG(D_any) debug_printf(" (no file)\n");
1231 DEBUG(D_any) debug_printf(" (ok)\n");
1234 for (i = 0; i < 3; i++)
1238 suffix[1] = (US"DHJ")[i];
1239 fname = spool_fname(US"input", message_subdir, id, suffix);
1241 DEBUG(D_any) debug_printf(" removing %s", fname);
1242 if (Uunlink(fname) < 0)
1244 if (errno != ENOENT)
1247 printf("Error while removing %s: %s\n", fname, strerror(errno));
1249 else DEBUG(D_any) debug_printf(" (no file)\n");
1254 DEBUG(D_any) debug_printf(" (done)\n");
1259 /* In the common case, the datafile is open (and locked), so give the
1260 obvious message. Otherwise be more specific. */
1262 if (deliver_datafile >= 0) printf("has been removed\n");
1263 else printf("has been removed or did not exist\n");
1266 log_write(0, LOG_MAIN, "removed by %s", username);
1267 log_write(0, LOG_MAIN, "Completed");
1273 case MSG_MARK_ALL_DELIVERED:
1274 for (i = 0; i < recipients_count; i++)
1276 tree_add_nonrecipient(recipients_list[i].address);
1278 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1280 printf("has been modified\n");
1281 for (i = 0; i < recipients_count; i++)
1282 log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1283 recipients_list[i].address, username);
1288 printf("- could not mark all delivered: %s\n", errmsg);
1293 case MSG_EDIT_SENDER:
1294 if (recipients_arg < argc - 1)
1297 printf("- only one sender address can be specified\n");
1300 doing = US"editing sender";
1303 case MSG_ADD_RECIPIENT:
1304 if (doing == NULL) doing = US"adding recipient";
1307 case MSG_MARK_DELIVERED:
1308 if (doing == NULL) doing = US"marking as delivered";
1310 /* Common code for EDIT_SENDER, ADD_RECIPIENT, & MARK_DELIVERED */
1312 if (recipients_arg >= argc)
1315 printf("- error while %s: no address given\n", doing);
1319 for (; recipients_arg < argc; recipients_arg++)
1321 int start, end, domain;
1324 parse_extract_address(argv[recipients_arg], &errmess, &start, &end,
1325 &domain, (action == MSG_EDIT_SENDER));
1327 if (recipient == NULL)
1330 printf("- error while %s:\n bad address %s: %s\n",
1331 doing, argv[recipients_arg], errmess);
1333 else if (recipient[0] != 0 && domain == 0)
1336 printf("- error while %s:\n bad address %s: "
1337 "domain missing\n", doing, argv[recipients_arg]);
1341 if (action == MSG_ADD_RECIPIENT)
1344 if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1346 receive_add_recipient(recipient, -1);
1347 log_write(0, LOG_MAIN, "recipient <%s> added by %s",
1348 recipient, username);
1350 else if (action == MSG_MARK_DELIVERED)
1352 for (i = 0; i < recipients_count; i++)
1353 if (Ustrcmp(recipients_list[i].address, recipient) == 0) break;
1354 if (i >= recipients_count)
1356 printf("- error while %s:\n %s is not a recipient:"
1357 " message not updated\n", doing, recipient);
1362 tree_add_nonrecipient(recipients_list[i].address);
1363 log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1364 recipient, username);
1367 else /* MSG_EDIT_SENDER */
1370 if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1372 sender_address = recipient;
1373 log_write(0, LOG_MAIN, "sender address changed to <%s> by %s",
1374 recipient, username);
1381 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1382 printf("has been modified\n");
1386 printf("- while %s: %s\n", doing, errmsg);
1393 /* Closing the datafile releases the lock and permits other processes
1394 to operate on the message (if it still exists). */
1396 (void)close(deliver_datafile);
1397 deliver_datafile = -1;
1403 /*************************************************
1404 * Check the queue_only_file condition *
1405 *************************************************/
1407 /* The queue_only_file option forces certain kinds of queueing if a given file
1415 queue_check_only(void)
1419 struct stat statbuf;
1422 uschar buffer[1024];
1424 if (queue_only_file == NULL) return;
1426 s = queue_only_file;
1427 while ((ss = string_nextinlist(&s, &sep, buffer, sizeof(buffer))) != NULL)
1429 if (Ustrncmp(ss, "smtp", 4) == 0)
1431 name = US"queue_smtp";
1437 name = US"queue_only";
1441 if (Ustat(ss, &statbuf) == 0)
1444 DEBUG(D_receive) debug_printf("%s set because %s exists\n", name, ss);
1449 #endif /*!COMPILE_UTILITY*/
1451 /* End of queue.c */