c971790927475b39f17e2e647c5fbd33a8fed721
[exim.git] / src / src / queue.c
1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2015 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 /* Functions that operate on the input queue. */
9
10
11 #include "exim.h"
12
13
14
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
17 Michael Haardt. */
18
19 #define LOG2_MAXNODES 32
20
21
22
23 /*************************************************
24 * Helper sort function for queue_get_spool_list *
25 *************************************************/
26
27 /* This function is used when sorting the queue list in the function
28 queue_get_spool_list() below.
29
30 Arguments:
31 a points to an ordered list of queue_filename items
32 b points to another ordered list
33
34 Returns: a pointer to a merged ordered list
35 */
36
37 static queue_filename *
38 merge_queue_lists(queue_filename *a, queue_filename *b)
39 {
40 queue_filename *first = NULL;
41 queue_filename **append = &first;
42
43 while (a != NULL && b != NULL)
44 {
45 if (Ustrcmp(a->text, b->text) < 0)
46 {
47 *append = a;
48 append= &a->next;
49 a = a->next;
50 }
51 else
52 {
53 *append = b;
54 append= &b->next;
55 b = b->next;
56 }
57 }
58
59 *append=((a != NULL)? a : b);
60 return first;
61 }
62
63
64
65
66
67 /*************************************************
68 * Get list of spool files *
69 *************************************************/
70
71 /* Scan the spool directory and return a list of the relevant file names
72 therein. Single-character sub-directories are handled as follows:
73
74 If the first argument is > 0, a sub-directory is scanned; the letter is
75 taken from the nth entry in subdirs.
76
77 If the first argument is 0, sub-directories are not scanned. However, a
78 list of them is returned.
79
80 If the first argument is < 0, sub-directories are scanned for messages,
81 and a single, unified list is created. The returned data blocks contain the
82 identifying character of the subdirectory, if any. The subdirs vector is
83 still required as an argument.
84
85 If the randomize argument is TRUE, messages are returned in "randomized" order.
86 Actually, the order is anything but random, but the algorithm is cheap, and the
87 point is simply to ensure that the same order doesn't occur every time, in case
88 a particular message is causing a remote MTA to barf - we would like to try
89 other messages to that MTA first.
90
91 If the randomize argument is FALSE, sort the list according to the file name.
92 This should give the order in which the messages arrived. It is normally used
93 only for presentation to humans, in which case the (possibly expensive) sort
94 that it does is not part of the normal operational code. However, if
95 queue_run_in_order is set, sorting has to take place for queue runs as well.
96 When randomize is FALSE, the first argument is normally -1, so all messages are
97 included.
98
99 Arguments:
100 subdiroffset sub-directory character offset, or 0 or -1 (see above)
101 subdirs vector to store list of subdirchars
102 subcount pointer to int in which to store count of subdirs
103 randomize TRUE if the order of the list is to be unpredictable
104
105 Returns: pointer to a chain of queue name items
106 */
107
108 static queue_filename *
109 queue_get_spool_list(int subdiroffset, uschar *subdirs, int *subcount,
110 BOOL randomize)
111 {
112 int i;
113 int flags = 0;
114 int resetflags = -1;
115 int subptr;
116 queue_filename *yield = NULL;
117 queue_filename *last = NULL;
118 struct dirent *ent;
119 DIR *dd;
120 uschar buffer[256];
121 queue_filename *root[LOG2_MAXNODES];
122
123 /* When randomizing, the file names are added to the start or end of the list
124 according to the bits of the flags variable. Get a collection of bits from the
125 current time. Use the bottom 16 and just keep re-using them if necessary. When
126 not randomizing, initialize the sublists for the bottom-up merge sort. */
127
128 if (randomize) resetflags = time(NULL) & 0xFFFF;
129 else for (i = 0; i < LOG2_MAXNODES; i++) root[i] = NULL;
130
131 /* If processing the full queue, or just the top-level, start at the base
132 directory, and initialize the first subdirectory name (as none). Otherwise,
133 start at the sub-directory offset. */
134
135 if (subdiroffset <= 0)
136 {
137 i = 0;
138 subdirs[0] = 0;
139 *subcount = 0;
140 }
141 else i = subdiroffset;
142
143 /* Set up prototype for the directory name. */
144
145 snprintf(CS buffer, sizeof(buffer), "%s/input/%s", spool_directory, queue_name);
146 buffer[sizeof(buffer) - 3] = 0;
147 subptr = Ustrlen(buffer);
148 buffer[subptr+2] = 0; /* terminator for lengthened name */
149
150 /* This loop runs at least once, for the main or given directory, and then as
151 many times as necessary to scan any subdirectories encountered in the main
152 directory, if they are to be scanned at this time. */
153
154 for (; i <= *subcount; i++)
155 {
156 int count = 0;
157 int subdirchar = subdirs[i]; /* 0 for main directory */
158
159 if (subdirchar != 0)
160 {
161 buffer[subptr] = '/';
162 buffer[subptr+1] = subdirchar;
163 }
164
165 if (!(dd = opendir(CS buffer)))
166 continue;
167
168 /* Now scan the directory. */
169
170 while ((ent = readdir(dd)) != NULL)
171 {
172 uschar *name = US ent->d_name;
173 int len = Ustrlen(name);
174
175 /* Count entries */
176
177 count++;
178
179 /* If we find a single alphameric sub-directory in the base directory,
180 add it to the list for subsequent scans. */
181
182 if (i == 0 && len == 1 && isalnum(*name))
183 {
184 *subcount = *subcount + 1;
185 subdirs[*subcount] = *name;
186 continue;
187 }
188
189 /* Otherwise, if it is a header spool file, add it to the list */
190
191 if (len == SPOOL_NAME_LENGTH &&
192 Ustrcmp(name + SPOOL_NAME_LENGTH - 2, "-H") == 0)
193 {
194 queue_filename *next =
195 store_get(sizeof(queue_filename) + Ustrlen(name));
196 Ustrcpy(next->text, name);
197 next->dir_uschar = subdirchar;
198
199 /* Handle the creation of a randomized list. The first item becomes both
200 the top and bottom of the list. Subsequent items are inserted either at
201 the top or the bottom, randomly. This is, I argue, faster than doing a
202 sort by allocating a random number to each item, and it also saves having
203 to store the number with each item. */
204
205 if (randomize)
206 {
207 if (yield == NULL)
208 {
209 next->next = NULL;
210 yield = last = next;
211 }
212 else
213 {
214 if (flags == 0) flags = resetflags;
215 if ((flags & 1) == 0)
216 {
217 next->next = yield;
218 yield = next;
219 }
220 else
221 {
222 next->next = NULL;
223 last->next = next;
224 last = next;
225 }
226 flags = flags >> 1;
227 }
228 }
229
230 /* Otherwise do a bottom-up merge sort based on the name. */
231
232 else
233 {
234 int j;
235 next->next = NULL;
236 for (j = 0; j < LOG2_MAXNODES; j++)
237 {
238 if (root[j] != NULL)
239 {
240 next = merge_queue_lists(next, root[j]);
241 root[j] = (j == LOG2_MAXNODES - 1)? next : NULL;
242 }
243 else
244 {
245 root[j] = next;
246 break;
247 }
248 }
249 }
250 }
251 }
252
253 /* Finished with this directory */
254
255 closedir(dd);
256
257 /* If we have just scanned a sub-directory, and it was empty (count == 2
258 implies just "." and ".." entries), and Exim is no longer configured to
259 use sub-directories, attempt to get rid of it. At the same time, try to
260 get rid of any corresponding msglog subdirectory. These are just cosmetic
261 tidying actions, so just ignore failures. If we are scanning just a single
262 sub-directory, break the loop. */
263
264 if (i != 0)
265 {
266 if (!split_spool_directory && count <= 2)
267 {
268 rmdir(CS buffer);
269 sprintf(CS big_buffer, "%s/msglog/%s/%c",
270 spool_directory, queue_name, subdirchar);
271 rmdir(CS big_buffer);
272 }
273 if (subdiroffset > 0) break; /* Single sub-directory */
274 }
275
276 /* If we have just scanned the base directory, and subdiroffset is 0,
277 we do not want to continue scanning the sub-directories. */
278
279 else
280 {
281 if (subdiroffset == 0) break;
282 }
283 } /* Loop for multiple subdirectories */
284
285 /* When using a bottom-up merge sort, do the final merging of the sublists.
286 Then pass back the final list of file items. */
287
288 if (!randomize)
289 for (i = 0; i < LOG2_MAXNODES; ++i)
290 yield = merge_queue_lists(yield, root[i]);
291
292 return yield;
293 }
294
295
296
297
298 /*************************************************
299 * Perform a queue run *
300 *************************************************/
301
302 /* The arguments give the messages to start and stop at; NULL means start at
303 the beginning or stop at the end. If the given start message doesn't exist, we
304 start at the next lexically greater one, and likewise we stop at the after the
305 previous lexically lesser one if the given stop message doesn't exist. Because
306 a queue run can take some time, stat each file before forking, in case it has
307 been delivered in the meantime by some other means.
308
309 The global variables queue_run_force and queue_run_local may be set to cause
310 forced deliveries or local-only deliveries, respectively.
311
312 If deliver_selectstring[_sender] is not NULL, skip messages whose recipients do
313 not contain the string. As this option is typically used when a machine comes
314 back online, we want to ensure that at least one delivery attempt takes place,
315 so force the first one. The selecting string can optionally be a regex, or
316 refer to the sender instead of recipients.
317
318 If queue_2stage is set, the queue is scanned twice. The first time, queue_smtp
319 is set so that routing is done for all messages. Thus in the second run those
320 that are routed to the same host should go down the same SMTP connection.
321
322 Arguments:
323 start_id message id to start at, or NULL for all
324 stop_id message id to end at, or NULL for all
325 recurse TRUE if recursing for 2-stage run
326
327 Returns: nothing
328 */
329
330 void
331 queue_run(uschar *start_id, uschar *stop_id, BOOL recurse)
332 {
333 BOOL force_delivery = queue_run_force || deliver_selectstring != NULL ||
334 deliver_selectstring_sender != NULL;
335 const pcre *selectstring_regex = NULL;
336 const pcre *selectstring_regex_sender = NULL;
337 uschar *log_detail = NULL;
338 int subcount = 0;
339 int i;
340 uschar subdirs[64];
341
342 /* Cancel any specific queue domains. Turn off the flag that causes SMTP
343 deliveries not to happen, unless doing a 2-stage queue run, when the SMTP flag
344 gets set. Save the queue_runner's pid and the flag that indicates any
345 deliveries run directly from this process. Deliveries that are run by handing
346 on TCP/IP channels have queue_run_pid set, but not queue_running. */
347
348 queue_domains = NULL;
349 queue_smtp_domains = NULL;
350 queue_smtp = queue_2stage;
351
352 queue_run_pid = getpid();
353 queue_running = TRUE;
354
355 /* Log the true start of a queue run, and fancy options */
356
357 if (!recurse)
358 {
359 uschar extras[8];
360 uschar *p = extras;
361
362 if (queue_2stage) *p++ = 'q';
363 if (queue_run_first_delivery) *p++ = 'i';
364 if (queue_run_force) *p++ = 'f';
365 if (deliver_force_thaw) *p++ = 'f';
366 if (queue_run_local) *p++ = 'l';
367 *p = 0;
368
369 p = big_buffer;
370 sprintf(CS p, "pid=%d", (int)queue_run_pid);
371 while (*p != 0) p++;
372
373 if (extras[0] != 0)
374 {
375 sprintf(CS p, " -q%s", extras);
376 while (*p != 0) p++;
377 }
378
379 if (deliver_selectstring != NULL)
380 {
381 sprintf(CS p, " -R%s %s", deliver_selectstring_regex? "r" : "",
382 deliver_selectstring);
383 while (*p != 0) p++;
384 }
385
386 if (deliver_selectstring_sender != NULL)
387 {
388 sprintf(CS p, " -S%s %s", deliver_selectstring_sender_regex? "r" : "",
389 deliver_selectstring_sender);
390 while (*p != 0) p++;
391 }
392
393 log_detail = string_copy(big_buffer);
394 log_write(L_queue_run, LOG_MAIN, "Start queue run: %s", log_detail);
395 }
396
397 /* If deliver_selectstring is a regex, compile it. */
398
399 if (deliver_selectstring != NULL && deliver_selectstring_regex)
400 selectstring_regex = regex_must_compile(deliver_selectstring, TRUE, FALSE);
401
402 if (deliver_selectstring_sender != NULL && deliver_selectstring_sender_regex)
403 selectstring_regex_sender =
404 regex_must_compile(deliver_selectstring_sender, TRUE, FALSE);
405
406 /* If the spool is split into subdirectories, we want to process it one
407 directory at a time, so as to spread out the directory scanning and the
408 delivering when there are lots of messages involved, except when
409 queue_run_in_order is set.
410
411 In the random order case, this loop runs once for the main directory (handling
412 any messages therein), and then repeats for any subdirectories that were found.
413 When the first argument of queue_get_spool_list() is 0, it scans the top
414 directory, fills in subdirs, and sets subcount. The order of the directories is
415 then randomized after the first time through, before they are scanned in
416 subsqeuent iterations.
417
418 When the first argument of queue_get_spool_list() is -1 (for queue_run_in_
419 order), it scans all directories and makes a single message list. */
420
421 for (i = (queue_run_in_order? -1 : 0);
422 i <= (queue_run_in_order? -1 : subcount);
423 i++)
424 {
425 queue_filename *f;
426 void *reset_point1 = store_get(0);
427
428 DEBUG(D_queue_run)
429 {
430 if (i == 0)
431 debug_printf("queue running main directory\n");
432 else if (i == -1)
433 debug_printf("queue running combined directories\n");
434 else
435 debug_printf("queue running subdirectory '%c'\n", subdirs[i]);
436 }
437
438 for (f = queue_get_spool_list(i, subdirs, &subcount, !queue_run_in_order);
439 f != NULL;
440 f = f->next)
441 {
442 pid_t pid;
443 int status;
444 int pfd[2];
445 struct stat statbuf;
446 uschar buffer[256];
447
448 /* Unless deliveries are forced, if deliver_queue_load_max is non-negative,
449 check that the load average is low enough to permit deliveries. */
450
451 if (!queue_run_force && deliver_queue_load_max >= 0)
452 {
453 load_average = os_getloadavg();
454 if (load_average > deliver_queue_load_max)
455 {
456 log_write(L_queue_run, LOG_MAIN, "Abandon queue run: %s (load %.2f, max %.2f)",
457 log_detail,
458 (double)load_average/1000.0,
459 (double)deliver_queue_load_max/1000.0);
460 i = subcount; /* Don't process other directories */
461 break;
462 }
463 else
464 {
465 DEBUG(D_load) debug_printf("load average = %.2f max = %.2f\n",
466 (double)load_average/1000.0,
467 (double)deliver_queue_load_max/1000.0);
468 }
469 }
470
471 /* Skip this message unless it's within the ID limits */
472
473 if (stop_id != NULL && Ustrncmp(f->text, stop_id, MESSAGE_ID_LENGTH) > 0)
474 continue;
475 if (start_id != NULL && Ustrncmp(f->text, start_id, MESSAGE_ID_LENGTH) < 0)
476 continue;
477
478 /* Check that the message still exists */
479
480 message_subdir[0] = f->dir_uschar;
481 snprintf(CS buffer, sizeof(buffer), "%s/input/%s/%s/%s",
482 spool_directory, queue_name, message_subdir, f->text);
483 if (Ustat(buffer, &statbuf) < 0) continue;
484
485 /* There are some tests that require the reading of the header file. Ensure
486 the store used is scavenged afterwards so that this process doesn't keep
487 growing its store. We have to read the header file again when actually
488 delivering, but it's cheaper than forking a delivery process for each
489 message when many are not going to be delivered. */
490
491 if (deliver_selectstring != NULL || deliver_selectstring_sender != NULL ||
492 queue_run_first_delivery)
493 {
494 BOOL wanted = TRUE;
495 BOOL orig_dont_deliver = dont_deliver;
496 void *reset_point2 = store_get(0);
497
498 /* Restore the original setting of dont_deliver after reading the header,
499 so that a setting for a particular message doesn't force it for any that
500 follow. If the message is chosen for delivery, the header is read again
501 in the deliver_message() function, in a subprocess. */
502
503 if (spool_read_header(f->text, FALSE, TRUE) != spool_read_OK) continue;
504 dont_deliver = orig_dont_deliver;
505
506 /* Now decide if we want to deliver this message. As we have read the
507 header file, we might as well do the freeze test now, and save forking
508 another process. */
509
510 if (deliver_freeze && !deliver_force_thaw)
511 {
512 log_write(L_skip_delivery, LOG_MAIN, "Message is frozen");
513 wanted = FALSE;
514 }
515
516 /* Check first_delivery in the case when there are no message logs. */
517
518 else if (queue_run_first_delivery && !deliver_firsttime)
519 {
520 DEBUG(D_queue_run) debug_printf("%s: not first delivery\n", f->text);
521 wanted = FALSE;
522 }
523
524 /* Check for a matching address if deliver_selectstring[_sender} is set.
525 If so, we do a fully delivery - don't want to omit other addresses since
526 their routing might trigger re-writing etc. */
527
528 /* Sender matching */
529
530 else if (deliver_selectstring_sender != NULL &&
531 !(deliver_selectstring_sender_regex?
532 (pcre_exec(selectstring_regex_sender, NULL, CS sender_address,
533 Ustrlen(sender_address), 0, PCRE_EOPT, NULL, 0) >= 0)
534 :
535 (strstric(sender_address, deliver_selectstring_sender, FALSE)
536 != NULL)))
537 {
538 DEBUG(D_queue_run) debug_printf("%s: sender address did not match %s\n",
539 f->text, deliver_selectstring_sender);
540 wanted = FALSE;
541 }
542
543 /* Recipient matching */
544
545 else if (deliver_selectstring != NULL)
546 {
547 int i;
548 for (i = 0; i < recipients_count; i++)
549 {
550 uschar *address = recipients_list[i].address;
551 if ((deliver_selectstring_regex?
552 (pcre_exec(selectstring_regex, NULL, CS address,
553 Ustrlen(address), 0, PCRE_EOPT, NULL, 0) >= 0)
554 :
555 (strstric(address, deliver_selectstring, FALSE) != NULL))
556 &&
557 tree_search(tree_nonrecipients, address) == NULL)
558 break;
559 }
560
561 if (i >= recipients_count)
562 {
563 DEBUG(D_queue_run)
564 debug_printf("%s: no recipient address matched %s\n",
565 f->text, deliver_selectstring);
566 wanted = FALSE;
567 }
568 }
569
570 /* Recover store used when reading the header */
571
572 store_reset(reset_point2);
573 if (!wanted) continue; /* With next message */
574 }
575
576 /* OK, got a message we want to deliver. Create a pipe which will
577 serve as a means of detecting when all the processes created by the
578 delivery process are finished. This is relevant when the delivery
579 process passes one or more SMTP channels on to its own children. The
580 pipe gets passed down; by reading on it here we detect when the last
581 descendent dies by the unblocking of the read. It's a pity that for
582 most of the time the pipe isn't used, but creating a pipe should be
583 pretty cheap. */
584
585 if (pipe(pfd) < 0)
586 {
587 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to create pipe in queue "
588 "runner process %d: %s", queue_run_pid, strerror(errno));
589 }
590 queue_run_pipe = pfd[pipe_write]; /* To ensure it gets passed on. */
591
592 /* Make sure it isn't stdin. This seems unlikely, but just to be on the
593 safe side... */
594
595 if (queue_run_pipe == 0)
596 {
597 queue_run_pipe = dup(queue_run_pipe);
598 (void)close(0);
599 }
600
601 /* Before forking to deliver the message, ensure any open and cached
602 lookup files or databases are closed. Otherwise, closing in the subprocess
603 can make the next subprocess have problems. There won't often be anything
604 open here, but it is possible (e.g. if spool_directory is an expanded
605 string). A single call before this loop would probably suffice, but just in
606 case expansions get inserted at some point, I've taken the heavy-handed
607 approach. When nothing is open, the call should be cheap. */
608
609 search_tidyup();
610
611 /* Now deliver the message; get the id by cutting the -H off the file
612 name. The return of the process is zero if a delivery was attempted. */
613
614 set_process_info("running queue: %s", f->text);
615 f->text[SPOOL_NAME_LENGTH-2] = 0;
616 if ((pid = fork()) == 0)
617 {
618 int rc;
619 if (running_in_test_harness) millisleep(100);
620 (void)close(pfd[pipe_read]);
621 rc = deliver_message(f->text, force_delivery, FALSE);
622 _exit(rc == DELIVER_NOT_ATTEMPTED);
623 }
624 if (pid < 0)
625 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork of delivery process from "
626 "queue runner %d failed\n", queue_run_pid);
627
628 /* Close the writing end of the synchronizing pipe in this process,
629 then wait for the first level process to terminate. */
630
631 (void)close(pfd[pipe_write]);
632 set_process_info("running queue: waiting for %s (%d)", f->text, pid);
633 while (wait(&status) != pid);
634
635 /* A zero return means a delivery was attempted; turn off the force flag
636 for any subsequent calls unless queue_force is set. */
637
638 if ((status & 0xffff) == 0) force_delivery = queue_run_force;
639
640 /* If the process crashed, tell somebody */
641
642 else if ((status & 0x00ff) != 0)
643 {
644 log_write(0, LOG_MAIN|LOG_PANIC,
645 "queue run: process %d crashed with signal %d while delivering %s",
646 (int)pid, status & 0x00ff, f->text);
647 }
648
649 /* Before continuing, wait till the pipe gets closed at the far end. This
650 tells us that any children created by the delivery to re-use any SMTP
651 channels have all finished. Since no process actually writes to the pipe,
652 the mere fact that read() unblocks is enough. */
653
654 set_process_info("running queue: waiting for children of %d", pid);
655 if (read(pfd[pipe_read], buffer, sizeof(buffer)) > 0)
656 log_write(0, LOG_MAIN|LOG_PANIC, "queue run: unexpected data on pipe");
657 (void)close(pfd[pipe_read]);
658 set_process_info("running queue");
659
660 /* If we are in the test harness, and this is not the first of a 2-stage
661 queue run, update fudged queue times. */
662
663 if (running_in_test_harness && !queue_2stage)
664 {
665 uschar *fqtnext = Ustrchr(fudged_queue_times, '/');
666 if (fqtnext != NULL) fudged_queue_times = fqtnext + 1;
667 }
668 } /* End loop for list of messages */
669
670 store_reset(reset_point1); /* Scavenge list of messages */
671
672 /* If this was the first time through for random order processing, and
673 sub-directories have been found, randomize their order if necessary. */
674
675 if (i == 0 && subcount > 1 && !queue_run_in_order)
676 {
677 int j;
678 for (j = 1; j <= subcount; j++)
679 {
680 int r = random_number(100);
681 if (r >= 50)
682 {
683 int k = (r % subcount) + 1;
684 int x = subdirs[j];
685 subdirs[j] = subdirs[k];
686 subdirs[k] = x;
687 }
688 }
689 }
690 } /* End loop for multiple directories */
691
692 /* If queue_2stage is true, we do it all again, with the 2stage flag
693 turned off. */
694
695 if (queue_2stage)
696 {
697 queue_2stage = FALSE;
698 queue_run(start_id, stop_id, TRUE);
699 }
700
701 /* At top level, log the end of the run. */
702
703 if (!recurse) log_write(L_queue_run, LOG_MAIN, "End queue run: %s", log_detail);
704 }
705
706
707
708
709 /************************************************
710 * Count messages on the queue *
711 ************************************************/
712
713 /* Called as a result of -bpc
714
715 Arguments: none
716 Returns: nothing
717 */
718
719 void
720 queue_count(void)
721 {
722 int subcount;
723 int count = 0;
724 queue_filename *f = NULL;
725 uschar subdirs[64];
726 f = queue_get_spool_list(
727 -1, /* entire queue */
728 subdirs, /* for holding sub list */
729 &subcount, /* for subcount */
730 FALSE); /* not random */
731 for (; f != NULL; f = f->next) count++;
732 fprintf(stdout, "%d\n", count);
733 }
734
735
736
737 /************************************************
738 * List extra deliveries *
739 ************************************************/
740
741 /* This is called from queue_list below to print out all addresses that
742 have received a message but which were not primary addresses. That is, all
743 the addresses in the tree of non-recipients that are not primary addresses.
744 The tree has been scanned and the data field filled in for those that are
745 primary addresses.
746
747 Argument: points to the tree node
748 Returns: nothing
749 */
750
751 static void queue_list_extras(tree_node *p)
752 {
753 if (p->left != NULL) queue_list_extras(p->left);
754 if (!p->data.val) printf(" +D %s\n", p->name);
755 if (p->right != NULL) queue_list_extras(p->right);
756 }
757
758
759
760 /************************************************
761 * List messages on the queue *
762 ************************************************/
763
764 /* Or a given list of messages. In the "all" case, we get a list of file names
765 as quickly as possible, then scan each one for information to output. If any
766 disappear while we are processing, just leave them out, but give an error if an
767 explicit list was given. This function is a top-level function that is obeyed
768 as a result of the -bp argument. As there may be a lot of messages on the
769 queue, we must tidy up the store after reading the headers for each one.
770
771 Arguments:
772 option 0 => list top-level recipients, with "D" for those delivered
773 1 => list only undelivered top-level recipients
774 2 => as 0, plus any generated delivered recipients
775 If 8 is added to any of these values, the queue is listed in
776 random order.
777 list => first of any message ids to list
778 count count of message ids; 0 => all
779
780 Returns: nothing
781 */
782
783 void
784 queue_list(int option, uschar **list, int count)
785 {
786 int i;
787 int subcount;
788 int now = (int)time(NULL);
789 void *reset_point;
790 queue_filename *f = NULL;
791 uschar subdirs[64];
792
793 /* If given a list of messages, build a chain containing their ids. */
794
795 if (count > 0)
796 {
797 queue_filename *last = NULL;
798 for (i = 0; i < count; i++)
799 {
800 queue_filename *next =
801 store_get(sizeof(queue_filename) + Ustrlen(list[i]) + 2);
802 sprintf(CS next->text, "%s-H", list[i]);
803 next->dir_uschar = '*';
804 next->next = NULL;
805 if (i == 0) f = next; else last->next = next;
806 last = next;
807 }
808 }
809
810 /* Otherwise get a list of the entire queue, in order if necessary. */
811
812 else
813 f = queue_get_spool_list(
814 -1, /* entire queue */
815 subdirs, /* for holding sub list */
816 &subcount, /* for subcount */
817 option >= 8); /* randomize if required */
818
819 if (option >= 8) option -= 8;
820
821 /* Now scan the chain and print information, resetting store used
822 each time. */
823
824 reset_point = store_get(0);
825
826 for (; f != NULL; f = f->next)
827 {
828 int rc, save_errno;
829 int size = 0;
830 BOOL env_read;
831
832 store_reset(reset_point);
833 message_size = 0;
834 message_subdir[0] = f->dir_uschar;
835 rc = spool_read_header(f->text, FALSE, count <= 0);
836 if (rc == spool_read_notopen && errno == ENOENT && count <= 0) continue;
837 save_errno = errno;
838
839 env_read = (rc == spool_read_OK || rc == spool_read_hdrerror);
840
841 if (env_read)
842 {
843 int ptr;
844 FILE *jread;
845 struct stat statbuf;
846
847 sprintf(CS big_buffer, "%s/input/%s/%s/%s",
848 spool_directory, queue_name, message_subdir, f->text);
849 ptr = Ustrlen(big_buffer)-1;
850 big_buffer[ptr] = 'D';
851
852 /* Add the data size to the header size; don't count the file name
853 at the start of the data file, but add one for the notional blank line
854 that precedes the data. */
855
856 if (Ustat(big_buffer, &statbuf) == 0)
857 size = message_size + statbuf.st_size - SPOOL_DATA_START_OFFSET + 1;
858 i = (now - received_time)/60; /* minutes on queue */
859 if (i > 90)
860 {
861 i = (i + 30)/60;
862 if (i > 72) printf("%2dd ", (i + 12)/24); else printf("%2dh ", i);
863 }
864 else printf("%2dm ", i);
865
866 /* Collect delivered addresses from any J file */
867
868 big_buffer[ptr] = 'J';
869 jread = Ufopen(big_buffer, "rb");
870 if (jread != NULL)
871 {
872 while (Ufgets(big_buffer, big_buffer_size, jread) != NULL)
873 {
874 int n = Ustrlen(big_buffer);
875 big_buffer[n-1] = 0;
876 tree_add_nonrecipient(big_buffer);
877 }
878 (void)fclose(jread);
879 }
880 }
881
882 fprintf(stdout, "%s ", string_format_size(size, big_buffer));
883 for (i = 0; i < 16; i++) fputc(f->text[i], stdout);
884
885 if (env_read && sender_address != NULL)
886 {
887 printf(" <%s>", sender_address);
888 if (sender_set_untrusted) printf(" (%s)", originator_login);
889 }
890
891 if (rc != spool_read_OK)
892 {
893 printf("\n ");
894 if (save_errno == ERRNO_SPOOLFORMAT)
895 {
896 struct stat statbuf;
897 sprintf(CS big_buffer, "%s/input/%s/%s/%s",
898 spool_directory, queue_name, message_subdir, f->text);
899 if (Ustat(big_buffer, &statbuf) == 0)
900 printf("*** spool format error: size=" OFF_T_FMT " ***",
901 statbuf.st_size);
902 else printf("*** spool format error ***");
903 }
904 else printf("*** spool read error: %s ***", strerror(save_errno));
905 if (rc != spool_read_hdrerror)
906 {
907 printf("\n\n");
908 continue;
909 }
910 }
911
912 if (deliver_freeze) printf(" *** frozen ***");
913
914 printf("\n");
915
916 if (recipients_list != NULL)
917 {
918 for (i = 0; i < recipients_count; i++)
919 {
920 tree_node *delivered =
921 tree_search(tree_nonrecipients, recipients_list[i].address);
922 if (!delivered || option != 1)
923 printf(" %s %s\n", (delivered != NULL)? "D":" ",
924 recipients_list[i].address);
925 if (delivered != NULL) delivered->data.val = TRUE;
926 }
927 if (option == 2 && tree_nonrecipients != NULL)
928 queue_list_extras(tree_nonrecipients);
929 printf("\n");
930 }
931 }
932 }
933
934
935
936 /*************************************************
937 * Act on a specific message *
938 *************************************************/
939
940 /* Actions that require a list of addresses make use of argv/argc/
941 recipients_arg. Other actions do not. This function does its own
942 authority checking.
943
944 Arguments:
945 id id of the message to work on
946 action which action is required (MSG_xxx)
947 argv the original argv for Exim
948 argc the original argc for Exim
949 recipients_arg offset to the list of recipients in argv
950
951 Returns: FALSE if there was any problem
952 */
953
954 BOOL
955 queue_action(uschar *id, int action, uschar **argv, int argc, int recipients_arg)
956 {
957 int i, j;
958 BOOL yield = TRUE;
959 BOOL removed = FALSE;
960 struct passwd *pw;
961 uschar *doing = NULL;
962 uschar *username;
963 uschar *errmsg;
964 uschar spoolname[256];
965
966 /* Set the global message_id variable, used when re-writing spool files. This
967 also causes message ids to be added to log messages. */
968
969 Ustrcpy(message_id, id);
970
971 /* The "actions" that just list the files do not require any locking to be
972 done. Only admin users may read the spool files. */
973
974 if (action >= MSG_SHOW_BODY)
975 {
976 int fd, i, rc;
977 uschar *subdirectory, *suffix;
978
979 if (!admin_user)
980 {
981 printf("Permission denied\n");
982 return FALSE;
983 }
984
985 if (recipients_arg < argc)
986 {
987 printf("*** Only one message can be listed at once\n");
988 return FALSE;
989 }
990
991 if (action == MSG_SHOW_BODY)
992 {
993 subdirectory = US"input";
994 suffix = US"-D";
995 }
996 else if (action == MSG_SHOW_HEADER)
997 {
998 subdirectory = US"input";
999 suffix = US"-H";
1000 }
1001 else
1002 {
1003 subdirectory = US"msglog";
1004 suffix = US"";
1005 }
1006
1007 for (i = 0; i < 2; i++)
1008 {
1009 message_subdir[0] = split_spool_directory == (i == 0) ? id[5] : 0;
1010 snprintf(CS spoolname, sizeof(spoolname), "%s/%s/%s/%s/%s%s",
1011 spool_directory, subdirectory, queue_name,
1012 message_subdir, id, suffix);
1013 if ((fd = Uopen(spoolname, O_RDONLY, 0)) >= 0)
1014 break;
1015 if (i == 0)
1016 continue;
1017
1018 printf("Failed to open %s file for %s%s: %s\n", subdirectory, id, suffix,
1019 strerror(errno));
1020 if (action == MSG_SHOW_LOG && !message_logs)
1021 printf("(No message logs are being created because the message_logs "
1022 "option is false.)\n");
1023 return FALSE;
1024 }
1025
1026 while((rc = read(fd, big_buffer, big_buffer_size)) > 0)
1027 rc = write(fileno(stdout), big_buffer, rc);
1028
1029 (void)close(fd);
1030 return TRUE;
1031 }
1032
1033 /* For actions that actually act, open and lock the data file to ensure that no
1034 other process is working on this message. If the file does not exist, continue
1035 only if the action is remove and the user is an admin user, to allow for
1036 tidying up broken states. */
1037
1038 if ((deliver_datafile = spool_open_datafile(id)) < 0)
1039 {
1040 if (errno == ENOENT)
1041 {
1042 yield = FALSE;
1043 printf("Spool data file for %s does not exist\n", id);
1044 if (action != MSG_REMOVE || !admin_user) return FALSE;
1045 printf("Continuing, to ensure all files removed\n");
1046 }
1047 else
1048 {
1049 if (errno == 0) printf("Message %s is locked\n", id);
1050 else printf("Couldn't open spool file for %s: %s\n", id,
1051 strerror(errno));
1052 return FALSE;
1053 }
1054 }
1055
1056 /* Read the spool header file for the message. Again, continue after an
1057 error only in the case of deleting by an administrator. Setting the third
1058 argument false causes it to look both in the main spool directory and in
1059 the appropriate subdirectory, and set message_subdir according to where it
1060 found the message. */
1061
1062 sprintf(CS spoolname, "%s-H", id);
1063 if (spool_read_header(spoolname, TRUE, FALSE) != spool_read_OK)
1064 {
1065 yield = FALSE;
1066 if (errno != ERRNO_SPOOLFORMAT)
1067 printf("Spool read error for %s: %s\n", spoolname, strerror(errno));
1068 else
1069 printf("Spool format error for %s\n", spoolname);
1070 if (action != MSG_REMOVE || !admin_user)
1071 {
1072 (void)close(deliver_datafile);
1073 deliver_datafile = -1;
1074 return FALSE;
1075 }
1076 printf("Continuing to ensure all files removed\n");
1077 }
1078
1079 /* Check that the user running this process is entitled to operate on this
1080 message. Only admin users may freeze/thaw, add/cancel recipients, or otherwise
1081 mess about, but the original sender is permitted to remove a message. That's
1082 why we leave this check until after the headers are read. */
1083
1084 if (!admin_user && (action != MSG_REMOVE || real_uid != originator_uid))
1085 {
1086 printf("Permission denied\n");
1087 (void)close(deliver_datafile);
1088 deliver_datafile = -1;
1089 return FALSE;
1090 }
1091
1092 /* Set up the user name for logging. */
1093
1094 pw = getpwuid(real_uid);
1095 username = (pw != NULL)?
1096 US pw->pw_name : string_sprintf("uid %ld", (long int)real_uid);
1097
1098 /* Take the necessary action. */
1099
1100 if (action != MSG_SHOW_COPY) printf("Message %s ", id);
1101
1102 switch(action)
1103 {
1104 case MSG_SHOW_COPY:
1105 deliver_in_buffer = store_malloc(DELIVER_IN_BUFFER_SIZE);
1106 deliver_out_buffer = store_malloc(DELIVER_OUT_BUFFER_SIZE);
1107 transport_write_message(NULL, 1, 0, 0, NULL, NULL, NULL, NULL, NULL, 0);
1108 break;
1109
1110
1111 case MSG_FREEZE:
1112 if (deliver_freeze)
1113 {
1114 yield = FALSE;
1115 printf("is already frozen\n");
1116 }
1117 else
1118 {
1119 deliver_freeze = TRUE;
1120 deliver_manual_thaw = FALSE;
1121 deliver_frozen_at = time(NULL);
1122 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1123 {
1124 printf("is now frozen\n");
1125 log_write(0, LOG_MAIN, "frozen by %s", username);
1126 }
1127 else
1128 {
1129 yield = FALSE;
1130 printf("could not be frozen: %s\n", errmsg);
1131 }
1132 }
1133 break;
1134
1135
1136 case MSG_THAW:
1137 if (!deliver_freeze)
1138 {
1139 yield = FALSE;
1140 printf("is not frozen\n");
1141 }
1142 else
1143 {
1144 deliver_freeze = FALSE;
1145 deliver_manual_thaw = TRUE;
1146 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1147 {
1148 printf("is no longer frozen\n");
1149 log_write(0, LOG_MAIN, "unfrozen by %s", username);
1150 }
1151 else
1152 {
1153 yield = FALSE;
1154 printf("could not be unfrozen: %s\n", errmsg);
1155 }
1156 }
1157 break;
1158
1159
1160 /* We must ensure all files are removed from both the input directory
1161 and the appropriate subdirectory, to clean up cases when there are odd
1162 files left lying around in odd places. In the normal case message_subdir
1163 will have been set correctly by spool_read_header, but as this is a rare
1164 operation, just run everything twice. */
1165
1166 case MSG_REMOVE:
1167 message_subdir[0] = id[5];
1168 for (j = 0; j < 2; message_subdir[0] = 0, j++)
1169 {
1170 snprintf(CS spoolname, sizeof(spoolname), "%s/msglog/%s/%s/%s",
1171 spool_directory, queue_name, message_subdir, id);
1172 if (Uunlink(spoolname) < 0)
1173 {
1174 if (errno != ENOENT)
1175 {
1176 yield = FALSE;
1177 printf("Error while removing %s: %s\n", spoolname,
1178 strerror(errno));
1179 }
1180 }
1181 else removed = TRUE;
1182
1183 for (i = 0; i < 3; i++)
1184 {
1185 snprintf(CS spoolname, sizeof(spoolname), "%s/input/%s/%s/%s-%c",
1186 spool_directory, queue_name, message_subdir, id, "DHJ"[i]);
1187 if (Uunlink(spoolname) < 0)
1188 {
1189 if (errno != ENOENT)
1190 {
1191 yield = FALSE;
1192 printf("Error while removing %s: %s\n", spoolname,
1193 strerror(errno));
1194 }
1195 }
1196 else removed = TRUE;
1197 }
1198 }
1199
1200 /* In the common case, the datafile is open (and locked), so give the
1201 obvious message. Otherwise be more specific. */
1202
1203 if (deliver_datafile >= 0) printf("has been removed\n");
1204 else printf("has been removed or did not exist\n");
1205 if (removed)
1206 {
1207 log_write(0, LOG_MAIN, "removed by %s", username);
1208 log_write(0, LOG_MAIN, "Completed");
1209 }
1210 break;
1211
1212
1213 case MSG_MARK_ALL_DELIVERED:
1214 for (i = 0; i < recipients_count; i++)
1215 {
1216 tree_add_nonrecipient(recipients_list[i].address);
1217 }
1218 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1219 {
1220 printf("has been modified\n");
1221 for (i = 0; i < recipients_count; i++)
1222 log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1223 recipients_list[i].address, username);
1224 }
1225 else
1226 {
1227 yield = FALSE;
1228 printf("- could not mark all delivered: %s\n", errmsg);
1229 }
1230 break;
1231
1232
1233 case MSG_EDIT_SENDER:
1234 if (recipients_arg < argc - 1)
1235 {
1236 yield = FALSE;
1237 printf("- only one sender address can be specified\n");
1238 break;
1239 }
1240 doing = US"editing sender";
1241 /* Fall through */
1242
1243 case MSG_ADD_RECIPIENT:
1244 if (doing == NULL) doing = US"adding recipient";
1245 /* Fall through */
1246
1247 case MSG_MARK_DELIVERED:
1248 if (doing == NULL) doing = US"marking as delivered";
1249
1250 /* Common code for EDIT_SENDER, ADD_RECIPIENT, & MARK_DELIVERED */
1251
1252 if (recipients_arg >= argc)
1253 {
1254 yield = FALSE;
1255 printf("- error while %s: no address given\n", doing);
1256 break;
1257 }
1258
1259 for (; recipients_arg < argc; recipients_arg++)
1260 {
1261 int start, end, domain;
1262 uschar *errmess;
1263 uschar *recipient =
1264 parse_extract_address(argv[recipients_arg], &errmess, &start, &end,
1265 &domain, (action == MSG_EDIT_SENDER));
1266
1267 if (recipient == NULL)
1268 {
1269 yield = FALSE;
1270 printf("- error while %s:\n bad address %s: %s\n",
1271 doing, argv[recipients_arg], errmess);
1272 }
1273 else if (recipient[0] != 0 && domain == 0)
1274 {
1275 yield = FALSE;
1276 printf("- error while %s:\n bad address %s: "
1277 "domain missing\n", doing, argv[recipients_arg]);
1278 }
1279 else
1280 {
1281 if (action == MSG_ADD_RECIPIENT)
1282 {
1283 #ifdef SUPPORT_I18N
1284 if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1285 #endif
1286 receive_add_recipient(recipient, -1);
1287 log_write(0, LOG_MAIN, "recipient <%s> added by %s",
1288 recipient, username);
1289 }
1290 else if (action == MSG_MARK_DELIVERED)
1291 {
1292 for (i = 0; i < recipients_count; i++)
1293 if (Ustrcmp(recipients_list[i].address, recipient) == 0) break;
1294 if (i >= recipients_count)
1295 {
1296 printf("- error while %s:\n %s is not a recipient:"
1297 " message not updated\n", doing, recipient);
1298 yield = FALSE;
1299 }
1300 else
1301 {
1302 tree_add_nonrecipient(recipients_list[i].address);
1303 log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1304 recipient, username);
1305 }
1306 }
1307 else /* MSG_EDIT_SENDER */
1308 {
1309 #ifdef SUPPORT_I18N
1310 if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1311 #endif
1312 sender_address = recipient;
1313 log_write(0, LOG_MAIN, "sender address changed to <%s> by %s",
1314 recipient, username);
1315 }
1316 }
1317 }
1318
1319 if (yield)
1320 {
1321 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1322 printf("has been modified\n");
1323 else
1324 {
1325 yield = FALSE;
1326 printf("- while %s: %s\n", doing, errmsg);
1327 }
1328 }
1329
1330 break;
1331 }
1332
1333 /* Closing the datafile releases the lock and permits other processes
1334 to operate on the message (if it still exists). */
1335
1336 (void)close(deliver_datafile);
1337 deliver_datafile = -1;
1338 return yield;
1339 }
1340
1341
1342
1343 /*************************************************
1344 * Check the queue_only_file condition *
1345 *************************************************/
1346
1347 /* The queue_only_file option forces certain kinds of queueing if a given file
1348 exists.
1349
1350 Arguments: none
1351 Returns: nothing
1352 */
1353
1354 void
1355 queue_check_only(void)
1356 {
1357 BOOL *set;
1358 int sep = 0;
1359 struct stat statbuf;
1360 const uschar *s;
1361 uschar *ss, *name;
1362 uschar buffer[1024];
1363
1364 if (queue_only_file == NULL) return;
1365
1366 s = queue_only_file;
1367 while ((ss = string_nextinlist(&s, &sep, buffer, sizeof(buffer))) != NULL)
1368 {
1369 if (Ustrncmp(ss, "smtp", 4) == 0)
1370 {
1371 name = US"queue_smtp";
1372 set = &queue_smtp;
1373 ss += 4;
1374 }
1375 else
1376 {
1377 name = US"queue_only";
1378 set = &queue_only;
1379 }
1380
1381 if (Ustat(ss, &statbuf) == 0)
1382 {
1383 *set = TRUE;
1384 DEBUG(D_receive) debug_printf("%s set because %s exists\n", name, ss);
1385 }
1386 }
1387 }
1388
1389 /* End of queue.c */