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