testcase
[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 if (*queue_name)
395 log_write(L_queue_run, LOG_MAIN, "Start '%s' queue run: %s",
396 queue_name, log_detail);
397 else
398 log_write(L_queue_run, LOG_MAIN, "Start queue run: %s", log_detail);
399 }
400
401 /* If deliver_selectstring is a regex, compile it. */
402
403 if (deliver_selectstring != NULL && deliver_selectstring_regex)
404 selectstring_regex = regex_must_compile(deliver_selectstring, TRUE, FALSE);
405
406 if (deliver_selectstring_sender != NULL && deliver_selectstring_sender_regex)
407 selectstring_regex_sender =
408 regex_must_compile(deliver_selectstring_sender, TRUE, FALSE);
409
410 /* If the spool is split into subdirectories, we want to process it one
411 directory at a time, so as to spread out the directory scanning and the
412 delivering when there are lots of messages involved, except when
413 queue_run_in_order is set.
414
415 In the random order case, this loop runs once for the main directory (handling
416 any messages therein), and then repeats for any subdirectories that were found.
417 When the first argument of queue_get_spool_list() is 0, it scans the top
418 directory, fills in subdirs, and sets subcount. The order of the directories is
419 then randomized after the first time through, before they are scanned in
420 subsqeuent iterations.
421
422 When the first argument of queue_get_spool_list() is -1 (for queue_run_in_
423 order), it scans all directories and makes a single message list. */
424
425 for (i = (queue_run_in_order? -1 : 0);
426 i <= (queue_run_in_order? -1 : subcount);
427 i++)
428 {
429 queue_filename *f;
430 void *reset_point1 = store_get(0);
431
432 DEBUG(D_queue_run)
433 {
434 if (i == 0)
435 debug_printf("queue running main directory\n");
436 else if (i == -1)
437 debug_printf("queue running combined directories\n");
438 else
439 debug_printf("queue running subdirectory '%c'\n", subdirs[i]);
440 }
441
442 for (f = queue_get_spool_list(i, subdirs, &subcount, !queue_run_in_order);
443 f != NULL;
444 f = f->next)
445 {
446 pid_t pid;
447 int status;
448 int pfd[2];
449 struct stat statbuf;
450 uschar buffer[256];
451
452 /* Unless deliveries are forced, if deliver_queue_load_max is non-negative,
453 check that the load average is low enough to permit deliveries. */
454
455 if (!queue_run_force && deliver_queue_load_max >= 0)
456 {
457 load_average = os_getloadavg();
458 if (load_average > deliver_queue_load_max)
459 {
460 log_write(L_queue_run, LOG_MAIN, "Abandon queue run: %s (load %.2f, max %.2f)",
461 log_detail,
462 (double)load_average/1000.0,
463 (double)deliver_queue_load_max/1000.0);
464 i = subcount; /* Don't process other directories */
465 break;
466 }
467 else
468 {
469 DEBUG(D_load) debug_printf("load average = %.2f max = %.2f\n",
470 (double)load_average/1000.0,
471 (double)deliver_queue_load_max/1000.0);
472 }
473 }
474
475 /* Skip this message unless it's within the ID limits */
476
477 if (stop_id != NULL && Ustrncmp(f->text, stop_id, MESSAGE_ID_LENGTH) > 0)
478 continue;
479 if (start_id != NULL && Ustrncmp(f->text, start_id, MESSAGE_ID_LENGTH) < 0)
480 continue;
481
482 /* Check that the message still exists */
483
484 message_subdir[0] = f->dir_uschar;
485 snprintf(CS buffer, sizeof(buffer), "%s/input/%s/%s/%s",
486 spool_directory, queue_name, message_subdir, f->text);
487 if (Ustat(buffer, &statbuf) < 0) continue;
488
489 /* There are some tests that require the reading of the header file. Ensure
490 the store used is scavenged afterwards so that this process doesn't keep
491 growing its store. We have to read the header file again when actually
492 delivering, but it's cheaper than forking a delivery process for each
493 message when many are not going to be delivered. */
494
495 if (deliver_selectstring != NULL || deliver_selectstring_sender != NULL ||
496 queue_run_first_delivery)
497 {
498 BOOL wanted = TRUE;
499 BOOL orig_dont_deliver = dont_deliver;
500 void *reset_point2 = store_get(0);
501
502 /* Restore the original setting of dont_deliver after reading the header,
503 so that a setting for a particular message doesn't force it for any that
504 follow. If the message is chosen for delivery, the header is read again
505 in the deliver_message() function, in a subprocess. */
506
507 if (spool_read_header(f->text, FALSE, TRUE) != spool_read_OK) continue;
508 dont_deliver = orig_dont_deliver;
509
510 /* Now decide if we want to deliver this message. As we have read the
511 header file, we might as well do the freeze test now, and save forking
512 another process. */
513
514 if (deliver_freeze && !deliver_force_thaw)
515 {
516 log_write(L_skip_delivery, LOG_MAIN, "Message is frozen");
517 wanted = FALSE;
518 }
519
520 /* Check first_delivery in the case when there are no message logs. */
521
522 else if (queue_run_first_delivery && !deliver_firsttime)
523 {
524 DEBUG(D_queue_run) debug_printf("%s: not first delivery\n", f->text);
525 wanted = FALSE;
526 }
527
528 /* Check for a matching address if deliver_selectstring[_sender} is set.
529 If so, we do a fully delivery - don't want to omit other addresses since
530 their routing might trigger re-writing etc. */
531
532 /* Sender matching */
533
534 else if (deliver_selectstring_sender != NULL &&
535 !(deliver_selectstring_sender_regex?
536 (pcre_exec(selectstring_regex_sender, NULL, CS sender_address,
537 Ustrlen(sender_address), 0, PCRE_EOPT, NULL, 0) >= 0)
538 :
539 (strstric(sender_address, deliver_selectstring_sender, FALSE)
540 != NULL)))
541 {
542 DEBUG(D_queue_run) debug_printf("%s: sender address did not match %s\n",
543 f->text, deliver_selectstring_sender);
544 wanted = FALSE;
545 }
546
547 /* Recipient matching */
548
549 else if (deliver_selectstring != NULL)
550 {
551 int i;
552 for (i = 0; i < recipients_count; i++)
553 {
554 uschar *address = recipients_list[i].address;
555 if ((deliver_selectstring_regex?
556 (pcre_exec(selectstring_regex, NULL, CS address,
557 Ustrlen(address), 0, PCRE_EOPT, NULL, 0) >= 0)
558 :
559 (strstric(address, deliver_selectstring, FALSE) != NULL))
560 &&
561 tree_search(tree_nonrecipients, address) == NULL)
562 break;
563 }
564
565 if (i >= recipients_count)
566 {
567 DEBUG(D_queue_run)
568 debug_printf("%s: no recipient address matched %s\n",
569 f->text, deliver_selectstring);
570 wanted = FALSE;
571 }
572 }
573
574 /* Recover store used when reading the header */
575
576 store_reset(reset_point2);
577 if (!wanted) continue; /* With next message */
578 }
579
580 /* OK, got a message we want to deliver. Create a pipe which will
581 serve as a means of detecting when all the processes created by the
582 delivery process are finished. This is relevant when the delivery
583 process passes one or more SMTP channels on to its own children. The
584 pipe gets passed down; by reading on it here we detect when the last
585 descendent dies by the unblocking of the read. It's a pity that for
586 most of the time the pipe isn't used, but creating a pipe should be
587 pretty cheap. */
588
589 if (pipe(pfd) < 0)
590 {
591 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to create pipe in queue "
592 "runner process %d: %s", queue_run_pid, strerror(errno));
593 }
594 queue_run_pipe = pfd[pipe_write]; /* To ensure it gets passed on. */
595
596 /* Make sure it isn't stdin. This seems unlikely, but just to be on the
597 safe side... */
598
599 if (queue_run_pipe == 0)
600 {
601 queue_run_pipe = dup(queue_run_pipe);
602 (void)close(0);
603 }
604
605 /* Before forking to deliver the message, ensure any open and cached
606 lookup files or databases are closed. Otherwise, closing in the subprocess
607 can make the next subprocess have problems. There won't often be anything
608 open here, but it is possible (e.g. if spool_directory is an expanded
609 string). A single call before this loop would probably suffice, but just in
610 case expansions get inserted at some point, I've taken the heavy-handed
611 approach. When nothing is open, the call should be cheap. */
612
613 search_tidyup();
614
615 /* Now deliver the message; get the id by cutting the -H off the file
616 name. The return of the process is zero if a delivery was attempted. */
617
618 set_process_info("running queue: %s", f->text);
619 f->text[SPOOL_NAME_LENGTH-2] = 0;
620 if ((pid = fork()) == 0)
621 {
622 int rc;
623 if (running_in_test_harness) millisleep(100);
624 (void)close(pfd[pipe_read]);
625 rc = deliver_message(f->text, force_delivery, FALSE);
626 _exit(rc == DELIVER_NOT_ATTEMPTED);
627 }
628 if (pid < 0)
629 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork of delivery process from "
630 "queue runner %d failed\n", queue_run_pid);
631
632 /* Close the writing end of the synchronizing pipe in this process,
633 then wait for the first level process to terminate. */
634
635 (void)close(pfd[pipe_write]);
636 set_process_info("running queue: waiting for %s (%d)", f->text, pid);
637 while (wait(&status) != pid);
638
639 /* A zero return means a delivery was attempted; turn off the force flag
640 for any subsequent calls unless queue_force is set. */
641
642 if ((status & 0xffff) == 0) force_delivery = queue_run_force;
643
644 /* If the process crashed, tell somebody */
645
646 else if ((status & 0x00ff) != 0)
647 {
648 log_write(0, LOG_MAIN|LOG_PANIC,
649 "queue run: process %d crashed with signal %d while delivering %s",
650 (int)pid, status & 0x00ff, f->text);
651 }
652
653 /* Before continuing, wait till the pipe gets closed at the far end. This
654 tells us that any children created by the delivery to re-use any SMTP
655 channels have all finished. Since no process actually writes to the pipe,
656 the mere fact that read() unblocks is enough. */
657
658 set_process_info("running queue: waiting for children of %d", pid);
659 if (read(pfd[pipe_read], buffer, sizeof(buffer)) > 0)
660 log_write(0, LOG_MAIN|LOG_PANIC, "queue run: unexpected data on pipe");
661 (void)close(pfd[pipe_read]);
662 set_process_info("running queue");
663
664 /* If we are in the test harness, and this is not the first of a 2-stage
665 queue run, update fudged queue times. */
666
667 if (running_in_test_harness && !queue_2stage)
668 {
669 uschar *fqtnext = Ustrchr(fudged_queue_times, '/');
670 if (fqtnext != NULL) fudged_queue_times = fqtnext + 1;
671 }
672 } /* End loop for list of messages */
673
674 store_reset(reset_point1); /* Scavenge list of messages */
675
676 /* If this was the first time through for random order processing, and
677 sub-directories have been found, randomize their order if necessary. */
678
679 if (i == 0 && subcount > 1 && !queue_run_in_order)
680 {
681 int j;
682 for (j = 1; j <= subcount; j++)
683 {
684 int r = random_number(100);
685 if (r >= 50)
686 {
687 int k = (r % subcount) + 1;
688 int x = subdirs[j];
689 subdirs[j] = subdirs[k];
690 subdirs[k] = x;
691 }
692 }
693 }
694 } /* End loop for multiple directories */
695
696 /* If queue_2stage is true, we do it all again, with the 2stage flag
697 turned off. */
698
699 if (queue_2stage)
700 {
701 queue_2stage = FALSE;
702 queue_run(start_id, stop_id, TRUE);
703 }
704
705 /* At top level, log the end of the run. */
706
707 if (!recurse)
708 if (*queue_name)
709 log_write(L_queue_run, LOG_MAIN, "End '%s' queue run: %s",
710 queue_name, log_detail);
711 else
712 log_write(L_queue_run, LOG_MAIN, "End queue run: %s", log_detail);
713 }
714
715
716
717
718 /************************************************
719 * Count messages on the queue *
720 ************************************************/
721
722 /* Called as a result of -bpc
723
724 Arguments: none
725 Returns: nothing
726 */
727
728 void
729 queue_count(void)
730 {
731 int subcount;
732 int count = 0;
733 queue_filename *f = NULL;
734 uschar subdirs[64];
735 f = queue_get_spool_list(
736 -1, /* entire queue */
737 subdirs, /* for holding sub list */
738 &subcount, /* for subcount */
739 FALSE); /* not random */
740 for (; f != NULL; f = f->next) count++;
741 fprintf(stdout, "%d\n", count);
742 }
743
744
745
746 /************************************************
747 * List extra deliveries *
748 ************************************************/
749
750 /* This is called from queue_list below to print out all addresses that
751 have received a message but which were not primary addresses. That is, all
752 the addresses in the tree of non-recipients that are not primary addresses.
753 The tree has been scanned and the data field filled in for those that are
754 primary addresses.
755
756 Argument: points to the tree node
757 Returns: nothing
758 */
759
760 static void queue_list_extras(tree_node *p)
761 {
762 if (p->left != NULL) queue_list_extras(p->left);
763 if (!p->data.val) printf(" +D %s\n", p->name);
764 if (p->right != NULL) queue_list_extras(p->right);
765 }
766
767
768
769 /************************************************
770 * List messages on the queue *
771 ************************************************/
772
773 /* Or a given list of messages. In the "all" case, we get a list of file names
774 as quickly as possible, then scan each one for information to output. If any
775 disappear while we are processing, just leave them out, but give an error if an
776 explicit list was given. This function is a top-level function that is obeyed
777 as a result of the -bp argument. As there may be a lot of messages on the
778 queue, we must tidy up the store after reading the headers for each one.
779
780 Arguments:
781 option 0 => list top-level recipients, with "D" for those delivered
782 1 => list only undelivered top-level recipients
783 2 => as 0, plus any generated delivered recipients
784 If 8 is added to any of these values, the queue is listed in
785 random order.
786 list => first of any message ids to list
787 count count of message ids; 0 => all
788
789 Returns: nothing
790 */
791
792 void
793 queue_list(int option, uschar **list, int count)
794 {
795 int i;
796 int subcount;
797 int now = (int)time(NULL);
798 void *reset_point;
799 queue_filename *f = NULL;
800 uschar subdirs[64];
801
802 /* If given a list of messages, build a chain containing their ids. */
803
804 if (count > 0)
805 {
806 queue_filename *last = NULL;
807 for (i = 0; i < count; i++)
808 {
809 queue_filename *next =
810 store_get(sizeof(queue_filename) + Ustrlen(list[i]) + 2);
811 sprintf(CS next->text, "%s-H", list[i]);
812 next->dir_uschar = '*';
813 next->next = NULL;
814 if (i == 0) f = next; else last->next = next;
815 last = next;
816 }
817 }
818
819 /* Otherwise get a list of the entire queue, in order if necessary. */
820
821 else
822 f = queue_get_spool_list(
823 -1, /* entire queue */
824 subdirs, /* for holding sub list */
825 &subcount, /* for subcount */
826 option >= 8); /* randomize if required */
827
828 if (option >= 8) option -= 8;
829
830 /* Now scan the chain and print information, resetting store used
831 each time. */
832
833 reset_point = store_get(0);
834
835 for (; f != NULL; f = f->next)
836 {
837 int rc, save_errno;
838 int size = 0;
839 BOOL env_read;
840
841 store_reset(reset_point);
842 message_size = 0;
843 message_subdir[0] = f->dir_uschar;
844 rc = spool_read_header(f->text, FALSE, count <= 0);
845 if (rc == spool_read_notopen && errno == ENOENT && count <= 0) continue;
846 save_errno = errno;
847
848 env_read = (rc == spool_read_OK || rc == spool_read_hdrerror);
849
850 if (env_read)
851 {
852 int ptr;
853 FILE *jread;
854 struct stat statbuf;
855
856 sprintf(CS big_buffer, "%s/input/%s/%s/%s",
857 spool_directory, queue_name, message_subdir, f->text);
858 ptr = Ustrlen(big_buffer)-1;
859 big_buffer[ptr] = 'D';
860
861 /* Add the data size to the header size; don't count the file name
862 at the start of the data file, but add one for the notional blank line
863 that precedes the data. */
864
865 if (Ustat(big_buffer, &statbuf) == 0)
866 size = message_size + statbuf.st_size - SPOOL_DATA_START_OFFSET + 1;
867 i = (now - received_time)/60; /* minutes on queue */
868 if (i > 90)
869 {
870 i = (i + 30)/60;
871 if (i > 72) printf("%2dd ", (i + 12)/24); else printf("%2dh ", i);
872 }
873 else printf("%2dm ", i);
874
875 /* Collect delivered addresses from any J file */
876
877 big_buffer[ptr] = 'J';
878 jread = Ufopen(big_buffer, "rb");
879 if (jread != NULL)
880 {
881 while (Ufgets(big_buffer, big_buffer_size, jread) != NULL)
882 {
883 int n = Ustrlen(big_buffer);
884 big_buffer[n-1] = 0;
885 tree_add_nonrecipient(big_buffer);
886 }
887 (void)fclose(jread);
888 }
889 }
890
891 fprintf(stdout, "%s ", string_format_size(size, big_buffer));
892 for (i = 0; i < 16; i++) fputc(f->text[i], stdout);
893
894 if (env_read && sender_address != NULL)
895 {
896 printf(" <%s>", sender_address);
897 if (sender_set_untrusted) printf(" (%s)", originator_login);
898 }
899
900 if (rc != spool_read_OK)
901 {
902 printf("\n ");
903 if (save_errno == ERRNO_SPOOLFORMAT)
904 {
905 struct stat statbuf;
906 sprintf(CS big_buffer, "%s/input/%s/%s/%s",
907 spool_directory, queue_name, message_subdir, f->text);
908 if (Ustat(big_buffer, &statbuf) == 0)
909 printf("*** spool format error: size=" OFF_T_FMT " ***",
910 statbuf.st_size);
911 else printf("*** spool format error ***");
912 }
913 else printf("*** spool read error: %s ***", strerror(save_errno));
914 if (rc != spool_read_hdrerror)
915 {
916 printf("\n\n");
917 continue;
918 }
919 }
920
921 if (deliver_freeze) printf(" *** frozen ***");
922
923 printf("\n");
924
925 if (recipients_list != NULL)
926 {
927 for (i = 0; i < recipients_count; i++)
928 {
929 tree_node *delivered =
930 tree_search(tree_nonrecipients, recipients_list[i].address);
931 if (!delivered || option != 1)
932 printf(" %s %s\n", (delivered != NULL)? "D":" ",
933 recipients_list[i].address);
934 if (delivered != NULL) delivered->data.val = TRUE;
935 }
936 if (option == 2 && tree_nonrecipients != NULL)
937 queue_list_extras(tree_nonrecipients);
938 printf("\n");
939 }
940 }
941 }
942
943
944
945 /*************************************************
946 * Act on a specific message *
947 *************************************************/
948
949 /* Actions that require a list of addresses make use of argv/argc/
950 recipients_arg. Other actions do not. This function does its own
951 authority checking.
952
953 Arguments:
954 id id of the message to work on
955 action which action is required (MSG_xxx)
956 argv the original argv for Exim
957 argc the original argc for Exim
958 recipients_arg offset to the list of recipients in argv
959
960 Returns: FALSE if there was any problem
961 */
962
963 BOOL
964 queue_action(uschar *id, int action, uschar **argv, int argc, int recipients_arg)
965 {
966 int i, j;
967 BOOL yield = TRUE;
968 BOOL removed = FALSE;
969 struct passwd *pw;
970 uschar *doing = NULL;
971 uschar *username;
972 uschar *errmsg;
973 uschar spoolname[256];
974
975 /* Set the global message_id variable, used when re-writing spool files. This
976 also causes message ids to be added to log messages. */
977
978 Ustrcpy(message_id, id);
979
980 /* The "actions" that just list the files do not require any locking to be
981 done. Only admin users may read the spool files. */
982
983 if (action >= MSG_SHOW_BODY)
984 {
985 int fd, i, rc;
986 uschar *subdirectory, *suffix;
987
988 if (!admin_user)
989 {
990 printf("Permission denied\n");
991 return FALSE;
992 }
993
994 if (recipients_arg < argc)
995 {
996 printf("*** Only one message can be listed at once\n");
997 return FALSE;
998 }
999
1000 if (action == MSG_SHOW_BODY)
1001 {
1002 subdirectory = US"input";
1003 suffix = US"-D";
1004 }
1005 else if (action == MSG_SHOW_HEADER)
1006 {
1007 subdirectory = US"input";
1008 suffix = US"-H";
1009 }
1010 else
1011 {
1012 subdirectory = US"msglog";
1013 suffix = US"";
1014 }
1015
1016 for (i = 0; i < 2; i++)
1017 {
1018 message_subdir[0] = split_spool_directory == (i == 0) ? id[5] : 0;
1019 snprintf(CS spoolname, sizeof(spoolname), "%s/%s/%s/%s/%s%s",
1020 spool_directory, subdirectory, queue_name,
1021 message_subdir, id, suffix);
1022 if ((fd = Uopen(spoolname, O_RDONLY, 0)) >= 0)
1023 break;
1024 if (i == 0)
1025 continue;
1026
1027 printf("Failed to open %s file for %s%s: %s\n", subdirectory, id, suffix,
1028 strerror(errno));
1029 if (action == MSG_SHOW_LOG && !message_logs)
1030 printf("(No message logs are being created because the message_logs "
1031 "option is false.)\n");
1032 return FALSE;
1033 }
1034
1035 while((rc = read(fd, big_buffer, big_buffer_size)) > 0)
1036 rc = write(fileno(stdout), big_buffer, rc);
1037
1038 (void)close(fd);
1039 return TRUE;
1040 }
1041
1042 /* For actions that actually act, open and lock the data file to ensure that no
1043 other process is working on this message. If the file does not exist, continue
1044 only if the action is remove and the user is an admin user, to allow for
1045 tidying up broken states. */
1046
1047 if ((deliver_datafile = spool_open_datafile(id)) < 0)
1048 {
1049 if (errno == ENOENT)
1050 {
1051 yield = FALSE;
1052 printf("Spool data file for %s does not exist\n", id);
1053 if (action != MSG_REMOVE || !admin_user) return FALSE;
1054 printf("Continuing, to ensure all files removed\n");
1055 }
1056 else
1057 {
1058 if (errno == 0) printf("Message %s is locked\n", id);
1059 else printf("Couldn't open spool file for %s: %s\n", id,
1060 strerror(errno));
1061 return FALSE;
1062 }
1063 }
1064
1065 /* Read the spool header file for the message. Again, continue after an
1066 error only in the case of deleting by an administrator. Setting the third
1067 argument false causes it to look both in the main spool directory and in
1068 the appropriate subdirectory, and set message_subdir according to where it
1069 found the message. */
1070
1071 sprintf(CS spoolname, "%s-H", id);
1072 if (spool_read_header(spoolname, TRUE, FALSE) != spool_read_OK)
1073 {
1074 yield = FALSE;
1075 if (errno != ERRNO_SPOOLFORMAT)
1076 printf("Spool read error for %s: %s\n", spoolname, strerror(errno));
1077 else
1078 printf("Spool format error for %s\n", spoolname);
1079 if (action != MSG_REMOVE || !admin_user)
1080 {
1081 (void)close(deliver_datafile);
1082 deliver_datafile = -1;
1083 return FALSE;
1084 }
1085 printf("Continuing to ensure all files removed\n");
1086 }
1087
1088 /* Check that the user running this process is entitled to operate on this
1089 message. Only admin users may freeze/thaw, add/cancel recipients, or otherwise
1090 mess about, but the original sender is permitted to remove a message. That's
1091 why we leave this check until after the headers are read. */
1092
1093 if (!admin_user && (action != MSG_REMOVE || real_uid != originator_uid))
1094 {
1095 printf("Permission denied\n");
1096 (void)close(deliver_datafile);
1097 deliver_datafile = -1;
1098 return FALSE;
1099 }
1100
1101 /* Set up the user name for logging. */
1102
1103 pw = getpwuid(real_uid);
1104 username = (pw != NULL)?
1105 US pw->pw_name : string_sprintf("uid %ld", (long int)real_uid);
1106
1107 /* Take the necessary action. */
1108
1109 if (action != MSG_SHOW_COPY) printf("Message %s ", id);
1110
1111 switch(action)
1112 {
1113 case MSG_SHOW_COPY:
1114 deliver_in_buffer = store_malloc(DELIVER_IN_BUFFER_SIZE);
1115 deliver_out_buffer = store_malloc(DELIVER_OUT_BUFFER_SIZE);
1116 transport_write_message(NULL, 1, 0, 0, NULL, NULL, NULL, NULL, NULL, 0);
1117 break;
1118
1119
1120 case MSG_FREEZE:
1121 if (deliver_freeze)
1122 {
1123 yield = FALSE;
1124 printf("is already frozen\n");
1125 }
1126 else
1127 {
1128 deliver_freeze = TRUE;
1129 deliver_manual_thaw = FALSE;
1130 deliver_frozen_at = time(NULL);
1131 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1132 {
1133 printf("is now frozen\n");
1134 log_write(0, LOG_MAIN, "frozen by %s", username);
1135 }
1136 else
1137 {
1138 yield = FALSE;
1139 printf("could not be frozen: %s\n", errmsg);
1140 }
1141 }
1142 break;
1143
1144
1145 case MSG_THAW:
1146 if (!deliver_freeze)
1147 {
1148 yield = FALSE;
1149 printf("is not frozen\n");
1150 }
1151 else
1152 {
1153 deliver_freeze = FALSE;
1154 deliver_manual_thaw = TRUE;
1155 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1156 {
1157 printf("is no longer frozen\n");
1158 log_write(0, LOG_MAIN, "unfrozen by %s", username);
1159 }
1160 else
1161 {
1162 yield = FALSE;
1163 printf("could not be unfrozen: %s\n", errmsg);
1164 }
1165 }
1166 break;
1167
1168
1169 /* We must ensure all files are removed from both the input directory
1170 and the appropriate subdirectory, to clean up cases when there are odd
1171 files left lying around in odd places. In the normal case message_subdir
1172 will have been set correctly by spool_read_header, but as this is a rare
1173 operation, just run everything twice. */
1174
1175 case MSG_REMOVE:
1176 message_subdir[0] = id[5];
1177 for (j = 0; j < 2; message_subdir[0] = 0, j++)
1178 {
1179 snprintf(CS spoolname, sizeof(spoolname), "%s/msglog/%s/%s/%s",
1180 spool_directory, queue_name, message_subdir, id);
1181 if (Uunlink(spoolname) < 0)
1182 {
1183 if (errno != ENOENT)
1184 {
1185 yield = FALSE;
1186 printf("Error while removing %s: %s\n", spoolname,
1187 strerror(errno));
1188 }
1189 }
1190 else removed = TRUE;
1191
1192 for (i = 0; i < 3; i++)
1193 {
1194 snprintf(CS spoolname, sizeof(spoolname), "%s/input/%s/%s/%s-%c",
1195 spool_directory, queue_name, message_subdir, id, "DHJ"[i]);
1196 if (Uunlink(spoolname) < 0)
1197 {
1198 if (errno != ENOENT)
1199 {
1200 yield = FALSE;
1201 printf("Error while removing %s: %s\n", spoolname,
1202 strerror(errno));
1203 }
1204 }
1205 else removed = TRUE;
1206 }
1207 }
1208
1209 /* In the common case, the datafile is open (and locked), so give the
1210 obvious message. Otherwise be more specific. */
1211
1212 if (deliver_datafile >= 0) printf("has been removed\n");
1213 else printf("has been removed or did not exist\n");
1214 if (removed)
1215 {
1216 log_write(0, LOG_MAIN, "removed by %s", username);
1217 log_write(0, LOG_MAIN, "Completed");
1218 }
1219 break;
1220
1221
1222 case MSG_MARK_ALL_DELIVERED:
1223 for (i = 0; i < recipients_count; i++)
1224 {
1225 tree_add_nonrecipient(recipients_list[i].address);
1226 }
1227 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1228 {
1229 printf("has been modified\n");
1230 for (i = 0; i < recipients_count; i++)
1231 log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1232 recipients_list[i].address, username);
1233 }
1234 else
1235 {
1236 yield = FALSE;
1237 printf("- could not mark all delivered: %s\n", errmsg);
1238 }
1239 break;
1240
1241
1242 case MSG_EDIT_SENDER:
1243 if (recipients_arg < argc - 1)
1244 {
1245 yield = FALSE;
1246 printf("- only one sender address can be specified\n");
1247 break;
1248 }
1249 doing = US"editing sender";
1250 /* Fall through */
1251
1252 case MSG_ADD_RECIPIENT:
1253 if (doing == NULL) doing = US"adding recipient";
1254 /* Fall through */
1255
1256 case MSG_MARK_DELIVERED:
1257 if (doing == NULL) doing = US"marking as delivered";
1258
1259 /* Common code for EDIT_SENDER, ADD_RECIPIENT, & MARK_DELIVERED */
1260
1261 if (recipients_arg >= argc)
1262 {
1263 yield = FALSE;
1264 printf("- error while %s: no address given\n", doing);
1265 break;
1266 }
1267
1268 for (; recipients_arg < argc; recipients_arg++)
1269 {
1270 int start, end, domain;
1271 uschar *errmess;
1272 uschar *recipient =
1273 parse_extract_address(argv[recipients_arg], &errmess, &start, &end,
1274 &domain, (action == MSG_EDIT_SENDER));
1275
1276 if (recipient == NULL)
1277 {
1278 yield = FALSE;
1279 printf("- error while %s:\n bad address %s: %s\n",
1280 doing, argv[recipients_arg], errmess);
1281 }
1282 else if (recipient[0] != 0 && domain == 0)
1283 {
1284 yield = FALSE;
1285 printf("- error while %s:\n bad address %s: "
1286 "domain missing\n", doing, argv[recipients_arg]);
1287 }
1288 else
1289 {
1290 if (action == MSG_ADD_RECIPIENT)
1291 {
1292 #ifdef SUPPORT_I18N
1293 if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1294 #endif
1295 receive_add_recipient(recipient, -1);
1296 log_write(0, LOG_MAIN, "recipient <%s> added by %s",
1297 recipient, username);
1298 }
1299 else if (action == MSG_MARK_DELIVERED)
1300 {
1301 for (i = 0; i < recipients_count; i++)
1302 if (Ustrcmp(recipients_list[i].address, recipient) == 0) break;
1303 if (i >= recipients_count)
1304 {
1305 printf("- error while %s:\n %s is not a recipient:"
1306 " message not updated\n", doing, recipient);
1307 yield = FALSE;
1308 }
1309 else
1310 {
1311 tree_add_nonrecipient(recipients_list[i].address);
1312 log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1313 recipient, username);
1314 }
1315 }
1316 else /* MSG_EDIT_SENDER */
1317 {
1318 #ifdef SUPPORT_I18N
1319 if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1320 #endif
1321 sender_address = recipient;
1322 log_write(0, LOG_MAIN, "sender address changed to <%s> by %s",
1323 recipient, username);
1324 }
1325 }
1326 }
1327
1328 if (yield)
1329 {
1330 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1331 printf("has been modified\n");
1332 else
1333 {
1334 yield = FALSE;
1335 printf("- while %s: %s\n", doing, errmsg);
1336 }
1337 }
1338
1339 break;
1340 }
1341
1342 /* Closing the datafile releases the lock and permits other processes
1343 to operate on the message (if it still exists). */
1344
1345 (void)close(deliver_datafile);
1346 deliver_datafile = -1;
1347 return yield;
1348 }
1349
1350
1351
1352 /*************************************************
1353 * Check the queue_only_file condition *
1354 *************************************************/
1355
1356 /* The queue_only_file option forces certain kinds of queueing if a given file
1357 exists.
1358
1359 Arguments: none
1360 Returns: nothing
1361 */
1362
1363 void
1364 queue_check_only(void)
1365 {
1366 BOOL *set;
1367 int sep = 0;
1368 struct stat statbuf;
1369 const uschar *s;
1370 uschar *ss, *name;
1371 uschar buffer[1024];
1372
1373 if (queue_only_file == NULL) return;
1374
1375 s = queue_only_file;
1376 while ((ss = string_nextinlist(&s, &sep, buffer, sizeof(buffer))) != NULL)
1377 {
1378 if (Ustrncmp(ss, "smtp", 4) == 0)
1379 {
1380 name = US"queue_smtp";
1381 set = &queue_smtp;
1382 ss += 4;
1383 }
1384 else
1385 {
1386 name = US"queue_only";
1387 set = &queue_only;
1388 }
1389
1390 if (Ustat(ss, &statbuf) == 0)
1391 {
1392 *set = TRUE;
1393 DEBUG(D_receive) debug_printf("%s set because %s exists\n", name, ss);
1394 }
1395 }
1396 }
1397
1398 /* End of queue.c */