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 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. */
282 for (j = 0; j < LOG2_MAXNODES; j++)
285 next = merge_queue_lists(next, root[j]);
286 root[j] = j == LOG2_MAXNODES - 1 ? next : NULL;
297 /* Finished with this directory */
301 /* If we have just scanned a sub-directory, and it was empty (count == 2
302 implies just "." and ".." entries), and Exim is no longer configured to
303 use sub-directories, attempt to get rid of it. At the same time, try to
304 get rid of any corresponding msglog subdirectory. These are just cosmetic
305 tidying actions, so just ignore failures. If we are scanning just a single
306 sub-directory, break the loop. */
310 if (!split_spool_directory && count <= 2)
315 subdir[0] = subdirchar; subdir[1] = 0;
316 rmdir(CS spool_dname(US"msglog", subdir));
318 if (subdiroffset > 0) break; /* Single sub-directory */
321 /* If we have just scanned the base directory, and subdiroffset is 0,
322 we do not want to continue scanning the sub-directories. */
324 else if (subdiroffset == 0)
326 } /* Loop for multiple subdirectories */
328 /* When using a bottom-up merge sort, do the final merging of the sublists.
329 Then pass back the final list of file items. */
332 for (i = 0; i < LOG2_MAXNODES; ++i)
333 yield = merge_queue_lists(yield, root[i]);
341 /*************************************************
342 * Perform a queue run *
343 *************************************************/
345 /* The arguments give the messages to start and stop at; NULL means start at
346 the beginning or stop at the end. If the given start message doesn't exist, we
347 start at the next lexically greater one, and likewise we stop at the after the
348 previous lexically lesser one if the given stop message doesn't exist. Because
349 a queue run can take some time, stat each file before forking, in case it has
350 been delivered in the meantime by some other means.
352 The global variables queue_run_force and queue_run_local may be set to cause
353 forced deliveries or local-only deliveries, respectively.
355 If deliver_selectstring[_sender] is not NULL, skip messages whose recipients do
356 not contain the string. As this option is typically used when a machine comes
357 back online, we want to ensure that at least one delivery attempt takes place,
358 so force the first one. The selecting string can optionally be a regex, or
359 refer to the sender instead of recipients.
361 If queue_2stage is set, the queue is scanned twice. The first time, queue_smtp
362 is set so that routing is done for all messages. Thus in the second run those
363 that are routed to the same host should go down the same SMTP connection.
366 start_id message id to start at, or NULL for all
367 stop_id message id to end at, or NULL for all
368 recurse TRUE if recursing for 2-stage run
374 queue_run(uschar *start_id, uschar *stop_id, BOOL recurse)
376 BOOL force_delivery = queue_run_force || deliver_selectstring != NULL ||
377 deliver_selectstring_sender != NULL;
378 const pcre *selectstring_regex = NULL;
379 const pcre *selectstring_regex_sender = NULL;
380 uschar *log_detail = NULL;
385 /* Cancel any specific queue domains. Turn off the flag that causes SMTP
386 deliveries not to happen, unless doing a 2-stage queue run, when the SMTP flag
387 gets set. Save the queue_runner's pid and the flag that indicates any
388 deliveries run directly from this process. Deliveries that are run by handing
389 on TCP/IP channels have queue_run_pid set, but not queue_running. */
391 queue_domains = NULL;
392 queue_smtp_domains = NULL;
393 queue_smtp = queue_2stage;
395 queue_run_pid = getpid();
396 queue_running = TRUE;
398 /* Log the true start of a queue run, and fancy options */
405 if (queue_2stage) *p++ = 'q';
406 if (queue_run_first_delivery) *p++ = 'i';
407 if (queue_run_force) *p++ = 'f';
408 if (deliver_force_thaw) *p++ = 'f';
409 if (queue_run_local) *p++ = 'l';
413 sprintf(CS p, "pid=%d", (int)queue_run_pid);
418 sprintf(CS p, " -q%s", extras);
422 if (deliver_selectstring != NULL)
424 sprintf(CS p, " -R%s %s", deliver_selectstring_regex? "r" : "",
425 deliver_selectstring);
429 if (deliver_selectstring_sender != NULL)
431 sprintf(CS p, " -S%s %s", deliver_selectstring_sender_regex? "r" : "",
432 deliver_selectstring_sender);
436 log_detail = string_copy(big_buffer);
438 log_write(L_queue_run, LOG_MAIN, "Start '%s' queue run: %s",
439 queue_name, log_detail);
441 log_write(L_queue_run, LOG_MAIN, "Start queue run: %s", log_detail);
444 /* If deliver_selectstring is a regex, compile it. */
446 if (deliver_selectstring != NULL && deliver_selectstring_regex)
447 selectstring_regex = regex_must_compile(deliver_selectstring, TRUE, FALSE);
449 if (deliver_selectstring_sender != NULL && deliver_selectstring_sender_regex)
450 selectstring_regex_sender =
451 regex_must_compile(deliver_selectstring_sender, TRUE, FALSE);
453 /* If the spool is split into subdirectories, we want to process it one
454 directory at a time, so as to spread out the directory scanning and the
455 delivering when there are lots of messages involved, except when
456 queue_run_in_order is set.
458 In the random order case, this loop runs once for the main directory (handling
459 any messages therein), and then repeats for any subdirectories that were found.
460 When the first argument of queue_get_spool_list() is 0, it scans the top
461 directory, fills in subdirs, and sets subcount. The order of the directories is
462 then randomized after the first time through, before they are scanned in
463 subsequent iterations.
465 When the first argument of queue_get_spool_list() is -1 (for queue_run_in_
466 order), it scans all directories and makes a single message list. */
468 for (i = queue_run_in_order ? -1 : 0;
469 i <= (queue_run_in_order ? -1 : subcount);
473 void *reset_point1 = store_get(0);
478 debug_printf("queue running main directory\n");
480 debug_printf("queue running combined directories\n");
482 debug_printf("queue running subdirectory '%c'\n", subdirs[i]);
485 for (f = queue_get_spool_list(i, subdirs, &subcount, !queue_run_in_order);
495 /* Unless deliveries are forced, if deliver_queue_load_max is non-negative,
496 check that the load average is low enough to permit deliveries. */
498 if (!queue_run_force && deliver_queue_load_max >= 0)
499 if ((load_average = os_getloadavg()) > deliver_queue_load_max)
501 log_write(L_queue_run, LOG_MAIN, "Abandon queue run: %s (load %.2f, max %.2f)",
503 (double)load_average/1000.0,
504 (double)deliver_queue_load_max/1000.0);
505 i = subcount; /* Don't process other directories */
509 DEBUG(D_load) debug_printf("load average = %.2f max = %.2f\n",
510 (double)load_average/1000.0,
511 (double)deliver_queue_load_max/1000.0);
513 /* Skip this message unless it's within the ID limits */
515 if (stop_id && Ustrncmp(f->text, stop_id, MESSAGE_ID_LENGTH) > 0)
517 if (start_id && Ustrncmp(f->text, start_id, MESSAGE_ID_LENGTH) < 0)
520 /* Check that the message still exists */
522 message_subdir[0] = f->dir_uschar;
523 if (Ustat(spool_fname(US"input", message_subdir, f->text, US""), &statbuf) < 0)
526 /* There are some tests that require the reading of the header file. Ensure
527 the store used is scavenged afterwards so that this process doesn't keep
528 growing its store. We have to read the header file again when actually
529 delivering, but it's cheaper than forking a delivery process for each
530 message when many are not going to be delivered. */
532 if (deliver_selectstring || deliver_selectstring_sender ||
533 queue_run_first_delivery)
536 BOOL orig_dont_deliver = dont_deliver;
537 void *reset_point2 = store_get(0);
539 /* Restore the original setting of dont_deliver after reading the header,
540 so that a setting for a particular message doesn't force it for any that
541 follow. If the message is chosen for delivery, the header is read again
542 in the deliver_message() function, in a subprocess. */
544 if (spool_read_header(f->text, FALSE, TRUE) != spool_read_OK) continue;
545 dont_deliver = orig_dont_deliver;
547 /* Now decide if we want to deliver this message. As we have read the
548 header file, we might as well do the freeze test now, and save forking
551 if (deliver_freeze && !deliver_force_thaw)
553 log_write(L_skip_delivery, LOG_MAIN, "Message is frozen");
557 /* Check first_delivery in the case when there are no message logs. */
559 else if (queue_run_first_delivery && !deliver_firsttime)
561 DEBUG(D_queue_run) debug_printf("%s: not first delivery\n", f->text);
565 /* Check for a matching address if deliver_selectstring[_sender] is set.
566 If so, we do a fully delivery - don't want to omit other addresses since
567 their routing might trigger re-writing etc. */
569 /* Sender matching */
571 else if ( deliver_selectstring_sender
572 && !(deliver_selectstring_sender_regex
573 ? (pcre_exec(selectstring_regex_sender, NULL,
574 CS sender_address, Ustrlen(sender_address), 0, PCRE_EOPT,
576 : (strstric(sender_address, deliver_selectstring_sender, FALSE)
580 DEBUG(D_queue_run) debug_printf("%s: sender address did not match %s\n",
581 f->text, deliver_selectstring_sender);
585 /* Recipient matching */
587 else if (deliver_selectstring)
590 for (i = 0; i < recipients_count; i++)
592 uschar *address = recipients_list[i].address;
593 if ( (deliver_selectstring_regex
594 ? (pcre_exec(selectstring_regex, NULL, CS address,
595 Ustrlen(address), 0, PCRE_EOPT, NULL, 0) >= 0)
596 : (strstric(address, deliver_selectstring, FALSE) != NULL)
598 && tree_search(tree_nonrecipients, address) == NULL
603 if (i >= recipients_count)
606 debug_printf("%s: no recipient address matched %s\n",
607 f->text, deliver_selectstring);
612 /* Recover store used when reading the header */
614 received_protocol = NULL;
615 sender_address = sender_ident = NULL;
616 authenticated_id = authenticated_sender = NULL;
617 store_reset(reset_point2);
618 if (!wanted) continue; /* With next message */
621 /* OK, got a message we want to deliver. Create a pipe which will
622 serve as a means of detecting when all the processes created by the
623 delivery process are finished. This is relevant when the delivery
624 process passes one or more SMTP channels on to its own children. The
625 pipe gets passed down; by reading on it here we detect when the last
626 descendent dies by the unblocking of the read. It's a pity that for
627 most of the time the pipe isn't used, but creating a pipe should be
631 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to create pipe in queue "
632 "runner process %d: %s", queue_run_pid, strerror(errno));
633 queue_run_pipe = pfd[pipe_write]; /* To ensure it gets passed on. */
635 /* Make sure it isn't stdin. This seems unlikely, but just to be on the
638 if (queue_run_pipe == 0)
640 queue_run_pipe = dup(queue_run_pipe);
644 /* Before forking to deliver the message, ensure any open and cached
645 lookup files or databases are closed. Otherwise, closing in the subprocess
646 can make the next subprocess have problems. There won't often be anything
647 open here, but it is possible (e.g. if spool_directory is an expanded
648 string). A single call before this loop would probably suffice, but just in
649 case expansions get inserted at some point, I've taken the heavy-handed
650 approach. When nothing is open, the call should be cheap. */
654 /* Now deliver the message; get the id by cutting the -H off the file
655 name. The return of the process is zero if a delivery was attempted. */
657 set_process_info("running queue: %s", f->text);
658 f->text[SPOOL_NAME_LENGTH-2] = 0;
659 if ((pid = fork()) == 0)
662 if (running_in_test_harness) millisleep(100);
663 (void)close(pfd[pipe_read]);
664 rc = deliver_message(f->text, force_delivery, FALSE);
665 _exit(rc == DELIVER_NOT_ATTEMPTED);
668 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork of delivery process from "
669 "queue runner %d failed\n", queue_run_pid);
671 /* Close the writing end of the synchronizing pipe in this process,
672 then wait for the first level process to terminate. */
674 (void)close(pfd[pipe_write]);
675 set_process_info("running queue: waiting for %s (%d)", f->text, pid);
676 while (wait(&status) != pid);
678 /* A zero return means a delivery was attempted; turn off the force flag
679 for any subsequent calls unless queue_force is set. */
681 if ((status & 0xffff) == 0) force_delivery = queue_run_force;
683 /* If the process crashed, tell somebody */
685 else if ((status & 0x00ff) != 0)
686 log_write(0, LOG_MAIN|LOG_PANIC,
687 "queue run: process %d crashed with signal %d while delivering %s",
688 (int)pid, status & 0x00ff, f->text);
690 /* Before continuing, wait till the pipe gets closed at the far end. This
691 tells us that any children created by the delivery to re-use any SMTP
692 channels have all finished. Since no process actually writes to the pipe,
693 the mere fact that read() unblocks is enough. */
695 set_process_info("running queue: waiting for children of %d", pid);
696 if ((status = read(pfd[pipe_read], buffer, sizeof(buffer))) != 0)
697 log_write(0, LOG_MAIN|LOG_PANIC, "queue run: %s on pipe",
698 status > 0 ? "unexpected data" : "error");
699 (void)close(pfd[pipe_read]);
700 set_process_info("running queue");
702 /* If we are in the test harness, and this is not the first of a 2-stage
703 queue run, update fudged queue times. */
705 if (running_in_test_harness && !queue_2stage)
707 uschar *fqtnext = Ustrchr(fudged_queue_times, '/');
708 if (fqtnext != NULL) fudged_queue_times = fqtnext + 1;
710 } /* End loop for list of messages */
712 store_reset(reset_point1); /* Scavenge list of messages */
714 /* If this was the first time through for random order processing, and
715 sub-directories have been found, randomize their order if necessary. */
717 if (i == 0 && subcount > 1 && !queue_run_in_order)
720 for (j = 1; j <= subcount; j++)
721 if ((r = random_number(100)) >= 50)
723 int k = (r % subcount) + 1;
725 subdirs[j] = subdirs[k];
729 } /* End loop for multiple directories */
731 /* If queue_2stage is true, we do it all again, with the 2stage flag
736 queue_2stage = FALSE;
737 queue_run(start_id, stop_id, TRUE);
740 /* At top level, log the end of the run. */
744 log_write(L_queue_run, LOG_MAIN, "End '%s' queue run: %s",
745 queue_name, log_detail);
747 log_write(L_queue_run, LOG_MAIN, "End queue run: %s", log_detail);
753 /************************************************
754 * Count messages on the queue *
755 ************************************************/
757 /* Called as a result of -bpc
768 queue_filename *f = NULL;
770 f = queue_get_spool_list(
771 -1, /* entire queue */
772 subdirs, /* for holding sub list */
773 &subcount, /* for subcount */
774 FALSE); /* not random */
775 for (; f != NULL; f = f->next) count++;
776 fprintf(stdout, "%d\n", count);
781 /************************************************
782 * List extra deliveries *
783 ************************************************/
785 /* This is called from queue_list below to print out all addresses that
786 have received a message but which were not primary addresses. That is, all
787 the addresses in the tree of non-recipients that are not primary addresses.
788 The tree has been scanned and the data field filled in for those that are
791 Argument: points to the tree node
795 static void queue_list_extras(tree_node *p)
797 if (p->left != NULL) queue_list_extras(p->left);
798 if (!p->data.val) printf(" +D %s\n", p->name);
799 if (p->right != NULL) queue_list_extras(p->right);
804 /************************************************
805 * List messages on the queue *
806 ************************************************/
808 /* Or a given list of messages. In the "all" case, we get a list of file names
809 as quickly as possible, then scan each one for information to output. If any
810 disappear while we are processing, just leave them out, but give an error if an
811 explicit list was given. This function is a top-level function that is obeyed
812 as a result of the -bp argument. As there may be a lot of messages on the
813 queue, we must tidy up the store after reading the headers for each one.
816 option 0 => list top-level recipients, with "D" for those delivered
817 1 => list only undelivered top-level recipients
818 2 => as 0, plus any generated delivered recipients
819 If 8 is added to any of these values, the queue is listed in
821 list => first of any message ids to list
822 count count of message ids; 0 => all
828 queue_list(int option, uschar **list, int count)
832 int now = (int)time(NULL);
834 queue_filename *f = NULL;
837 /* If given a list of messages, build a chain containing their ids. */
841 queue_filename *last = NULL;
842 for (i = 0; i < count; i++)
844 queue_filename *next =
845 store_get(sizeof(queue_filename) + Ustrlen(list[i]) + 2);
846 sprintf(CS next->text, "%s-H", list[i]);
847 next->dir_uschar = '*';
849 if (i == 0) f = next; else last->next = next;
854 /* Otherwise get a list of the entire queue, in order if necessary. */
857 f = queue_get_spool_list(
858 -1, /* entire queue */
859 subdirs, /* for holding sub list */
860 &subcount, /* for subcount */
861 option >= 8); /* randomize if required */
863 if (option >= 8) option -= 8;
865 /* Now scan the chain and print information, resetting store used
868 for (reset_point = store_get(0); f; f = f->next)
875 message_subdir[0] = f->dir_uschar;
876 rc = spool_read_header(f->text, FALSE, count <= 0);
877 if (rc == spool_read_notopen && errno == ENOENT && count <= 0) goto next;
880 env_read = (rc == spool_read_OK || rc == spool_read_hdrerror);
887 uschar * fname = spool_fname(US"input", message_subdir, f->text, US"");
889 ptr = Ustrlen(fname)-1;
892 /* Add the data size to the header size; don't count the file name
893 at the start of the data file, but add one for the notional blank line
894 that precedes the data. */
896 if (Ustat(fname, &statbuf) == 0)
897 size = message_size + statbuf.st_size - SPOOL_DATA_START_OFFSET + 1;
898 i = (now - received_time)/60; /* minutes on queue */
902 if (i > 72) printf("%2dd ", (i + 12)/24); else printf("%2dh ", i);
904 else printf("%2dm ", i);
906 /* Collect delivered addresses from any J file */
909 if ((jread = Ufopen(fname, "rb")))
911 while (Ufgets(big_buffer, big_buffer_size, jread) != NULL)
913 int n = Ustrlen(big_buffer);
915 tree_add_nonrecipient(big_buffer);
921 fprintf(stdout, "%s ", string_format_size(size, big_buffer));
922 for (i = 0; i < 16; i++) fputc(f->text[i], stdout);
924 if (env_read && sender_address)
926 printf(" <%s>", sender_address);
927 if (sender_set_untrusted) printf(" (%s)", originator_login);
930 if (rc != spool_read_OK)
933 if (save_errno == ERRNO_SPOOLFORMAT)
936 uschar * fname = spool_fname(US"input", message_subdir, f->text, US"");
938 if (Ustat(fname, &statbuf) == 0)
939 printf("*** spool format error: size=" OFF_T_FMT " ***",
941 else printf("*** spool format error ***");
943 else printf("*** spool read error: %s ***", strerror(save_errno));
944 if (rc != spool_read_hdrerror)
951 if (deliver_freeze) printf(" *** frozen ***");
957 for (i = 0; i < recipients_count; i++)
959 tree_node *delivered =
960 tree_search(tree_nonrecipients, recipients_list[i].address);
961 if (!delivered || option != 1)
962 printf(" %s %s\n", (delivered != NULL)? "D":" ",
963 recipients_list[i].address);
964 if (delivered) delivered->data.val = TRUE;
966 if (option == 2 && tree_nonrecipients)
967 queue_list_extras(tree_nonrecipients);
972 received_protocol = NULL;
973 sender_fullhost = sender_helo_name =
974 sender_rcvhost = sender_host_address = sender_address = sender_ident = NULL;
975 sender_host_authenticated = authenticated_sender = authenticated_id = NULL;
976 interface_address = NULL;
979 store_reset(reset_point);
985 /*************************************************
986 * Act on a specific message *
987 *************************************************/
989 /* Actions that require a list of addresses make use of argv/argc/
990 recipients_arg. Other actions do not. This function does its own
994 id id of the message to work on
995 action which action is required (MSG_xxx)
996 argv the original argv for Exim
997 argc the original argc for Exim
998 recipients_arg offset to the list of recipients in argv
1000 Returns: FALSE if there was any problem
1004 queue_action(uschar *id, int action, uschar **argv, int argc, int recipients_arg)
1008 BOOL removed = FALSE;
1010 uschar *doing = NULL;
1013 uschar spoolname[32];
1015 /* Set the global message_id variable, used when re-writing spool files. This
1016 also causes message ids to be added to log messages. */
1018 Ustrcpy(message_id, id);
1020 /* The "actions" that just list the files do not require any locking to be
1021 done. Only admin users may read the spool files. */
1023 if (action >= MSG_SHOW_BODY)
1026 uschar *subdirectory, *suffix;
1030 printf("Permission denied\n");
1034 if (recipients_arg < argc)
1036 printf("*** Only one message can be listed at once\n");
1040 if (action == MSG_SHOW_BODY)
1042 subdirectory = US"input";
1045 else if (action == MSG_SHOW_HEADER)
1047 subdirectory = US"input";
1052 subdirectory = US"msglog";
1056 for (i = 0; i < 2; i++)
1058 message_subdir[0] = split_spool_directory == (i == 0) ? id[5] : 0;
1059 if ((fd = Uopen(spool_fname(subdirectory, message_subdir, id, suffix),
1065 printf("Failed to open %s file for %s%s: %s\n", subdirectory, id, suffix,
1067 if (action == MSG_SHOW_LOG && !message_logs)
1068 printf("(No message logs are being created because the message_logs "
1069 "option is false.)\n");
1073 while((rc = read(fd, big_buffer, big_buffer_size)) > 0)
1074 rc = write(fileno(stdout), big_buffer, rc);
1080 /* For actions that actually act, open and lock the data file to ensure that no
1081 other process is working on this message. If the file does not exist, continue
1082 only if the action is remove and the user is an admin user, to allow for
1083 tidying up broken states. */
1085 if ((deliver_datafile = spool_open_datafile(id)) < 0)
1086 if (errno == ENOENT)
1089 printf("Spool data file for %s does not exist\n", id);
1090 if (action != MSG_REMOVE || !admin_user) return FALSE;
1091 printf("Continuing, to ensure all files removed\n");
1095 if (errno == 0) printf("Message %s is locked\n", id);
1096 else printf("Couldn't open spool file for %s: %s\n", id,
1101 /* Read the spool header file for the message. Again, continue after an
1102 error only in the case of deleting by an administrator. Setting the third
1103 argument false causes it to look both in the main spool directory and in
1104 the appropriate subdirectory, and set message_subdir according to where it
1105 found the message. */
1107 sprintf(CS spoolname, "%s-H", id);
1108 if (spool_read_header(spoolname, TRUE, FALSE) != spool_read_OK)
1111 if (errno != ERRNO_SPOOLFORMAT)
1112 printf("Spool read error for %s: %s\n", spoolname, strerror(errno));
1114 printf("Spool format error for %s\n", spoolname);
1115 if (action != MSG_REMOVE || !admin_user)
1117 (void)close(deliver_datafile);
1118 deliver_datafile = -1;
1121 printf("Continuing to ensure all files removed\n");
1124 /* Check that the user running this process is entitled to operate on this
1125 message. Only admin users may freeze/thaw, add/cancel recipients, or otherwise
1126 mess about, but the original sender is permitted to remove a message. That's
1127 why we leave this check until after the headers are read. */
1129 if (!admin_user && (action != MSG_REMOVE || real_uid != originator_uid))
1131 printf("Permission denied\n");
1132 (void)close(deliver_datafile);
1133 deliver_datafile = -1;
1137 /* Set up the user name for logging. */
1139 pw = getpwuid(real_uid);
1140 username = (pw != NULL)?
1141 US pw->pw_name : string_sprintf("uid %ld", (long int)real_uid);
1143 /* Take the necessary action. */
1145 if (action != MSG_SHOW_COPY) printf("Message %s ", id);
1150 deliver_in_buffer = store_malloc(DELIVER_IN_BUFFER_SIZE);
1151 deliver_out_buffer = store_malloc(DELIVER_OUT_BUFFER_SIZE);
1152 transport_write_message(1, NULL, 0);
1160 printf("is already frozen\n");
1164 deliver_freeze = TRUE;
1165 deliver_manual_thaw = FALSE;
1166 deliver_frozen_at = time(NULL);
1167 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1169 printf("is now frozen\n");
1170 log_write(0, LOG_MAIN, "frozen by %s", username);
1175 printf("could not be frozen: %s\n", errmsg);
1182 if (!deliver_freeze)
1185 printf("is not frozen\n");
1189 deliver_freeze = FALSE;
1190 deliver_manual_thaw = TRUE;
1191 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1193 printf("is no longer frozen\n");
1194 log_write(0, LOG_MAIN, "unfrozen by %s", username);
1199 printf("could not be unfrozen: %s\n", errmsg);
1205 /* We must ensure all files are removed from both the input directory
1206 and the appropriate subdirectory, to clean up cases when there are odd
1207 files left lying around in odd places. In the normal case message_subdir
1208 will have been set correctly by spool_read_header, but as this is a rare
1209 operation, just run everything twice. */
1217 message_subdir[0] = id[5];
1219 for (j = 0; j < 2; message_subdir[0] = 0, j++)
1221 uschar * fname = spool_fname(US"msglog", message_subdir, id, US"");
1223 DEBUG(D_any) debug_printf(" removing %s", fname);
1224 if (Uunlink(fname) < 0)
1226 if (errno != ENOENT)
1229 printf("Error while removing %s: %s\n", fname, strerror(errno));
1231 else DEBUG(D_any) debug_printf(" (no file)\n");
1236 DEBUG(D_any) debug_printf(" (ok)\n");
1239 for (i = 0; i < 3; i++)
1243 suffix[1] = (US"DHJ")[i];
1244 fname = spool_fname(US"input", message_subdir, id, suffix);
1246 DEBUG(D_any) debug_printf(" removing %s", fname);
1247 if (Uunlink(fname) < 0)
1249 if (errno != ENOENT)
1252 printf("Error while removing %s: %s\n", fname, strerror(errno));
1254 else DEBUG(D_any) debug_printf(" (no file)\n");
1259 DEBUG(D_any) debug_printf(" (done)\n");
1264 /* In the common case, the datafile is open (and locked), so give the
1265 obvious message. Otherwise be more specific. */
1267 if (deliver_datafile >= 0) printf("has been removed\n");
1268 else printf("has been removed or did not exist\n");
1271 log_write(0, LOG_MAIN, "removed by %s", username);
1272 log_write(0, LOG_MAIN, "Completed");
1278 case MSG_MARK_ALL_DELIVERED:
1279 for (i = 0; i < recipients_count; i++)
1281 tree_add_nonrecipient(recipients_list[i].address);
1283 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1285 printf("has been modified\n");
1286 for (i = 0; i < recipients_count; i++)
1287 log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1288 recipients_list[i].address, username);
1293 printf("- could not mark all delivered: %s\n", errmsg);
1298 case MSG_EDIT_SENDER:
1299 if (recipients_arg < argc - 1)
1302 printf("- only one sender address can be specified\n");
1305 doing = US"editing sender";
1308 case MSG_ADD_RECIPIENT:
1309 if (doing == NULL) doing = US"adding recipient";
1312 case MSG_MARK_DELIVERED:
1313 if (doing == NULL) doing = US"marking as delivered";
1315 /* Common code for EDIT_SENDER, ADD_RECIPIENT, & MARK_DELIVERED */
1317 if (recipients_arg >= argc)
1320 printf("- error while %s: no address given\n", doing);
1324 for (; recipients_arg < argc; recipients_arg++)
1326 int start, end, domain;
1329 parse_extract_address(argv[recipients_arg], &errmess, &start, &end,
1330 &domain, (action == MSG_EDIT_SENDER));
1332 if (recipient == NULL)
1335 printf("- error while %s:\n bad address %s: %s\n",
1336 doing, argv[recipients_arg], errmess);
1338 else if (recipient[0] != 0 && domain == 0)
1341 printf("- error while %s:\n bad address %s: "
1342 "domain missing\n", doing, argv[recipients_arg]);
1346 if (action == MSG_ADD_RECIPIENT)
1349 if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1351 receive_add_recipient(recipient, -1);
1352 log_write(0, LOG_MAIN, "recipient <%s> added by %s",
1353 recipient, username);
1355 else if (action == MSG_MARK_DELIVERED)
1357 for (i = 0; i < recipients_count; i++)
1358 if (Ustrcmp(recipients_list[i].address, recipient) == 0) break;
1359 if (i >= recipients_count)
1361 printf("- error while %s:\n %s is not a recipient:"
1362 " message not updated\n", doing, recipient);
1367 tree_add_nonrecipient(recipients_list[i].address);
1368 log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1369 recipient, username);
1372 else /* MSG_EDIT_SENDER */
1375 if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1377 sender_address = recipient;
1378 log_write(0, LOG_MAIN, "sender address changed to <%s> by %s",
1379 recipient, username);
1385 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1386 printf("has been modified\n");
1390 printf("- while %s: %s\n", doing, errmsg);
1396 /* Closing the datafile releases the lock and permits other processes
1397 to operate on the message (if it still exists). */
1399 if (deliver_datafile >= 0)
1401 (void)close(deliver_datafile);
1402 deliver_datafile = -1;
1409 /*************************************************
1410 * Check the queue_only_file condition *
1411 *************************************************/
1413 /* The queue_only_file option forces certain kinds of queueing if a given file
1421 queue_check_only(void)
1425 struct stat statbuf;
1428 uschar buffer[1024];
1430 if (queue_only_file == NULL) return;
1432 s = queue_only_file;
1433 while ((ss = string_nextinlist(&s, &sep, buffer, sizeof(buffer))) != NULL)
1435 if (Ustrncmp(ss, "smtp", 4) == 0)
1437 name = US"queue_smtp";
1443 name = US"queue_only";
1447 if (Ustat(ss, &statbuf) == 0)
1450 DEBUG(D_receive) debug_printf("%s set because %s exists\n", name, ss);
1455 #endif /*!COMPILE_UTILITY*/
1457 /* End of queue.c */