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