2113490474c791138debed7ddc220cf4d3584a8e
[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] = exim_fork(US"qrun phase one")))
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 = exim_fork(US"qrun delivery")) == 0)
655 {
656 int rc;
657 (void)close(pfd[pipe_read]);
658 rc = deliver_message(fq->text, force_delivery, FALSE);
659 exim_underbar_exit(rc == DELIVER_NOT_ATTEMPTED, US"qrun-delivery");
660 }
661 if (pid < 0)
662 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "fork of delivery process from "
663 "queue runner %d failed\n", queue_run_pid);
664
665 /* Close the writing end of the synchronizing pipe in this process,
666 then wait for the first level process to terminate. */
667
668 (void)close(pfd[pipe_write]);
669 set_process_info("running queue: waiting for %s (%d)", fq->text, pid);
670 while (wait(&status) != pid);
671
672 /* A zero return means a delivery was attempted; turn off the force flag
673 for any subsequent calls unless queue_force is set. */
674
675 if (!(status & 0xffff)) force_delivery = f.queue_run_force;
676
677 /* If the process crashed, tell somebody */
678
679 else if (status & 0x00ff)
680 log_write(0, LOG_MAIN|LOG_PANIC,
681 "queue run: process %d crashed with signal %d while delivering %s",
682 (int)pid, status & 0x00ff, fq->text);
683
684 /* If single-item delivery was untried (likely due to locking)
685 retry once after a delay */
686
687 if (status & 0xff00 && single_id)
688 {
689 single_id = FALSE;
690 DEBUG(D_queue_run) debug_printf("qrun single-item pause before retry\n");
691 millisleep(500);
692 DEBUG(D_queue_run) debug_printf("qrun single-item retry after pause\n");
693 goto single_item_retry;
694 }
695
696 /* Before continuing, wait till the pipe gets closed at the far end. This
697 tells us that any children created by the delivery to re-use any SMTP
698 channels have all finished. Since no process actually writes to the pipe,
699 the mere fact that read() unblocks is enough. */
700
701 set_process_info("running queue: waiting for children of %d", pid);
702 if ((status = read(pfd[pipe_read], buffer, sizeof(buffer))) != 0)
703 log_write(0, LOG_MAIN|LOG_PANIC, status > 0 ?
704 "queue run: unexpected data on pipe" : "queue run: error on pipe: %s",
705 strerror(errno));
706 (void)close(pfd[pipe_read]);
707 set_process_info("running queue");
708
709 /* If initial of a 2-phase run, we are a child - so just exit */
710 if (f.queue_2stage && !queue_run_in_order)
711 exim_exit(EXIT_SUCCESS, US"2-phase child");
712
713 /* If we are in the test harness, and this is not the first of a 2-stage
714 queue run, update fudged queue times. */
715
716 if (f.running_in_test_harness && !f.queue_2stage)
717 {
718 uschar * fqtnext = Ustrchr(fudged_queue_times, '/');
719 if (fqtnext) fudged_queue_times = fqtnext + 1;
720 }
721
722
723 continue;
724
725 go_around:
726 /* If initial of a 2-phase run, we are a child - so just exit */
727 if (f.queue_2stage && !queue_run_in_order)
728 exim_exit(EXIT_SUCCESS, US"2-phase child");
729 } /* End loop for list of messages */
730
731 tree_nonrecipients = NULL;
732 store_reset(reset_point1); /* Scavenge list of messages */
733
734 /* If this was the first time through for random order processing, and
735 sub-directories have been found, randomize their order if necessary. */
736
737 if (i == 0 && subcount > 1 && !queue_run_in_order)
738 for (int j = 1; j <= subcount; j++)
739 {
740 int r;
741 if ((r = random_number(100)) >= 50)
742 {
743 int k = (r % subcount) + 1;
744 int x = subdirs[j];
745 subdirs[j] = subdirs[k];
746 subdirs[k] = x;
747 }
748 }
749 } /* End loop for multiple directories */
750
751 /* If queue_2stage is true, we do it all again, with the 2stage flag
752 turned off. */
753
754 if (f.queue_2stage)
755 {
756
757 /* wait for last children */
758 for (int i = 0; i < nelem(qpid); i++)
759 if (qpid[i])
760 {
761 DEBUG(D_queue_run) debug_printf("q2stage reaped child %d\n", (int)qpid[i]);
762 waitpid(qpid[i], NULL, 0);
763 }
764 else break;
765
766 #ifdef MEASURE_TIMING
767 report_time_since(&timestamp_startup, US"queue_run 1st phase done");
768 #endif
769 f.queue_2stage = FALSE;
770 queue_run(start_id, stop_id, TRUE);
771 }
772
773 /* At top level, log the end of the run. */
774
775 if (!recurse)
776 if (*queue_name)
777 log_write(L_queue_run, LOG_MAIN, "End '%s' queue run: %s",
778 queue_name, log_detail);
779 else
780 log_write(L_queue_run, LOG_MAIN, "End queue run: %s", log_detail);
781 }
782
783
784
785
786 /************************************************
787 * Count messages on the queue *
788 ************************************************/
789
790 /* Called as a result of -bpc
791
792 Arguments: none
793 Returns: count
794 */
795
796 unsigned
797 queue_count(void)
798 {
799 int subcount;
800 unsigned count = 0;
801 uschar subdirs[64];
802
803 (void) queue_get_spool_list(-1, /* entire queue */
804 subdirs, /* for holding sub list */
805 &subcount, /* for subcount */
806 FALSE, /* not random */
807 &count); /* just get the count */
808 return count;
809 }
810
811
812 #define QUEUE_SIZE_AGE 60 /* update rate for queue_size */
813
814 unsigned
815 queue_count_cached(void)
816 {
817 time_t now;
818 if ((now = time(NULL)) >= queue_size_next)
819 {
820 queue_size = queue_count();
821 queue_size_next = now + (f.running_in_test_harness ? 3 : QUEUE_SIZE_AGE);
822 }
823 return queue_size;
824 }
825
826 /************************************************
827 * List extra deliveries *
828 ************************************************/
829
830 /* This is called from queue_list below to print out all addresses that
831 have received a message but which were not primary addresses. That is, all
832 the addresses in the tree of non-recipients that are not primary addresses.
833 The tree has been scanned and the data field filled in for those that are
834 primary addresses.
835
836 Argument: points to the tree node
837 Returns: nothing
838 */
839
840 static void
841 queue_list_extras(tree_node *p)
842 {
843 if (p->left) queue_list_extras(p->left);
844 if (!p->data.val) printf(" +D %s\n", p->name);
845 if (p->right) queue_list_extras(p->right);
846 }
847
848
849
850 /************************************************
851 * List messages on the queue *
852 ************************************************/
853
854 /* Or a given list of messages. In the "all" case, we get a list of file names
855 as quickly as possible, then scan each one for information to output. If any
856 disappear while we are processing, just leave them out, but give an error if an
857 explicit list was given. This function is a top-level function that is obeyed
858 as a result of the -bp argument. As there may be a lot of messages on the
859 queue, we must tidy up the store after reading the headers for each one.
860
861 Arguments:
862 option 0 => list top-level recipients, with "D" for those delivered
863 1 => list only undelivered top-level recipients
864 2 => as 0, plus any generated delivered recipients
865 If 8 is added to any of these values, the queue is listed in
866 random order.
867 list => first of any message ids to list
868 count count of message ids; 0 => all
869
870 Returns: nothing
871 */
872
873 void
874 queue_list(int option, uschar **list, int count)
875 {
876 int subcount;
877 int now = (int)time(NULL);
878 rmark reset_point;
879 queue_filename * qf = NULL;
880 uschar subdirs[64];
881
882 /* If given a list of messages, build a chain containing their ids. */
883
884 if (count > 0)
885 {
886 queue_filename *last = NULL;
887 for (int i = 0; i < count; i++)
888 {
889 queue_filename *next =
890 store_get(sizeof(queue_filename) + Ustrlen(list[i]) + 2, is_tainted(list[i]));
891 sprintf(CS next->text, "%s-H", list[i]);
892 next->dir_uschar = '*';
893 next->next = NULL;
894 if (i == 0) qf = next; else last->next = next;
895 last = next;
896 }
897 }
898
899 /* Otherwise get a list of the entire queue, in order if necessary. */
900
901 else
902 qf = queue_get_spool_list(
903 -1, /* entire queue */
904 subdirs, /* for holding sub list */
905 &subcount, /* for subcount */
906 option >= 8, /* randomize if required */
907 NULL); /* don't just count */
908
909 if (option >= 8) option -= 8;
910
911 /* Now scan the chain and print information, resetting store used
912 each time. */
913
914 for (;
915 qf && (reset_point = store_mark());
916 spool_clear_header_globals(), store_reset(reset_point), qf = qf->next
917 )
918 {
919 int rc, save_errno;
920 int size = 0;
921 BOOL env_read;
922
923 message_size = 0;
924 message_subdir[0] = qf->dir_uschar;
925 rc = spool_read_header(qf->text, FALSE, count <= 0);
926 if (rc == spool_read_notopen && errno == ENOENT && count <= 0)
927 continue;
928 save_errno = errno;
929
930 env_read = (rc == spool_read_OK || rc == spool_read_hdrerror);
931
932 if (env_read)
933 {
934 int i, ptr;
935 FILE *jread;
936 struct stat statbuf;
937 uschar * fname = spool_fname(US"input", message_subdir, qf->text, US"");
938
939 ptr = Ustrlen(fname)-1;
940 fname[ptr] = 'D';
941
942 /* Add the data size to the header size; don't count the file name
943 at the start of the data file, but add one for the notional blank line
944 that precedes the data. */
945
946 if (Ustat(fname, &statbuf) == 0)
947 size = message_size + statbuf.st_size - SPOOL_DATA_START_OFFSET + 1;
948 i = (now - received_time.tv_sec)/60; /* minutes on queue */
949 if (i > 90)
950 {
951 i = (i + 30)/60;
952 if (i > 72) printf("%2dd ", (i + 12)/24); else printf("%2dh ", i);
953 }
954 else printf("%2dm ", i);
955
956 /* Collect delivered addresses from any J file */
957
958 fname[ptr] = 'J';
959 if ((jread = Ufopen(fname, "rb")))
960 {
961 while (Ufgets(big_buffer, big_buffer_size, jread) != NULL)
962 {
963 int n = Ustrlen(big_buffer);
964 big_buffer[n-1] = 0;
965 tree_add_nonrecipient(big_buffer);
966 }
967 (void)fclose(jread);
968 }
969 }
970
971 fprintf(stdout, "%s ", string_format_size(size, big_buffer));
972 for (int i = 0; i < 16; i++) fputc(qf->text[i], stdout);
973
974 if (env_read && sender_address)
975 {
976 printf(" <%s>", sender_address);
977 if (f.sender_set_untrusted) printf(" (%s)", originator_login);
978 }
979
980 if (rc != spool_read_OK)
981 {
982 printf("\n ");
983 if (save_errno == ERRNO_SPOOLFORMAT)
984 {
985 struct stat statbuf;
986 uschar * fname = spool_fname(US"input", message_subdir, qf->text, US"");
987
988 if (Ustat(fname, &statbuf) == 0)
989 printf("*** spool format error: size=" OFF_T_FMT " ***",
990 statbuf.st_size);
991 else printf("*** spool format error ***");
992 }
993 else printf("*** spool read error: %s ***", strerror(save_errno));
994 if (rc != spool_read_hdrerror)
995 {
996 printf("\n\n");
997 continue;
998 }
999 }
1000
1001 if (f.deliver_freeze) printf(" *** frozen ***");
1002
1003 printf("\n");
1004
1005 if (recipients_list)
1006 {
1007 for (int i = 0; i < recipients_count; i++)
1008 {
1009 tree_node *delivered =
1010 tree_search(tree_nonrecipients, recipients_list[i].address);
1011 if (!delivered || option != 1)
1012 printf(" %s %s\n",
1013 delivered ? "D" : " ", recipients_list[i].address);
1014 if (delivered) delivered->data.val = TRUE;
1015 }
1016 if (option == 2 && tree_nonrecipients)
1017 queue_list_extras(tree_nonrecipients);
1018 printf("\n");
1019 }
1020 }
1021 }
1022
1023
1024
1025 /*************************************************
1026 * Act on a specific message *
1027 *************************************************/
1028
1029 /* Actions that require a list of addresses make use of argv/argc/
1030 recipients_arg. Other actions do not. This function does its own
1031 authority checking.
1032
1033 Arguments:
1034 id id of the message to work on
1035 action which action is required (MSG_xxx)
1036 argv the original argv for Exim
1037 argc the original argc for Exim
1038 recipients_arg offset to the list of recipients in argv
1039
1040 Returns: FALSE if there was any problem
1041 */
1042
1043 BOOL
1044 queue_action(uschar *id, int action, uschar **argv, int argc, int recipients_arg)
1045 {
1046 BOOL yield = TRUE;
1047 BOOL removed = FALSE;
1048 struct passwd *pw;
1049 uschar *doing = NULL;
1050 uschar *username;
1051 uschar *errmsg;
1052 uschar spoolname[32];
1053
1054 /* Set the global message_id variable, used when re-writing spool files. This
1055 also causes message ids to be added to log messages. */
1056
1057 Ustrcpy(message_id, id);
1058
1059 /* The "actions" that just list the files do not require any locking to be
1060 done. Only admin users may read the spool files. */
1061
1062 if (action >= MSG_SHOW_BODY)
1063 {
1064 int fd, rc;
1065 uschar *subdirectory, *suffix;
1066
1067 if (!f.admin_user)
1068 {
1069 printf("Permission denied\n");
1070 return FALSE;
1071 }
1072
1073 if (recipients_arg < argc)
1074 {
1075 printf("*** Only one message can be listed at once\n");
1076 return FALSE;
1077 }
1078
1079 if (action == MSG_SHOW_BODY)
1080 {
1081 subdirectory = US"input";
1082 suffix = US"-D";
1083 }
1084 else if (action == MSG_SHOW_HEADER)
1085 {
1086 subdirectory = US"input";
1087 suffix = US"-H";
1088 }
1089 else
1090 {
1091 subdirectory = US"msglog";
1092 suffix = US"";
1093 }
1094
1095 for (int i = 0; i < 2; i++)
1096 {
1097 set_subdir_str(message_subdir, id, i);
1098 if ((fd = Uopen(spool_fname(subdirectory, message_subdir, id, suffix),
1099 O_RDONLY, 0)) >= 0)
1100 break;
1101 if (i == 0)
1102 continue;
1103
1104 printf("Failed to open %s file for %s%s: %s\n", subdirectory, id, suffix,
1105 strerror(errno));
1106 if (action == MSG_SHOW_LOG && !message_logs)
1107 printf("(No message logs are being created because the message_logs "
1108 "option is false.)\n");
1109 return FALSE;
1110 }
1111
1112 while((rc = read(fd, big_buffer, big_buffer_size)) > 0)
1113 rc = write(fileno(stdout), big_buffer, rc);
1114
1115 (void)close(fd);
1116 return TRUE;
1117 }
1118
1119 /* For actions that actually act, open and lock the data file to ensure that no
1120 other process is working on this message. If the file does not exist, continue
1121 only if the action is remove and the user is an admin user, to allow for
1122 tidying up broken states. */
1123
1124 if ((deliver_datafile = spool_open_datafile(id)) < 0)
1125 if (errno == ENOENT)
1126 {
1127 yield = FALSE;
1128 printf("Spool data file for %s does not exist\n", id);
1129 if (action != MSG_REMOVE || !f.admin_user) return FALSE;
1130 printf("Continuing, to ensure all files removed\n");
1131 }
1132 else
1133 {
1134 if (errno == 0) printf("Message %s is locked\n", id);
1135 else printf("Couldn't open spool file for %s: %s\n", id,
1136 strerror(errno));
1137 return FALSE;
1138 }
1139
1140 /* Read the spool header file for the message. Again, continue after an
1141 error only in the case of deleting by an administrator. Setting the third
1142 argument false causes it to look both in the main spool directory and in
1143 the appropriate subdirectory, and set message_subdir according to where it
1144 found the message. */
1145
1146 sprintf(CS spoolname, "%s-H", id);
1147 if (spool_read_header(spoolname, TRUE, FALSE) != spool_read_OK)
1148 {
1149 yield = FALSE;
1150 if (errno != ERRNO_SPOOLFORMAT)
1151 printf("Spool read error for %s: %s\n", spoolname, strerror(errno));
1152 else
1153 printf("Spool format error for %s\n", spoolname);
1154 if (action != MSG_REMOVE || !f.admin_user)
1155 {
1156 (void)close(deliver_datafile);
1157 deliver_datafile = -1;
1158 return FALSE;
1159 }
1160 printf("Continuing to ensure all files removed\n");
1161 }
1162
1163 /* Check that the user running this process is entitled to operate on this
1164 message. Only admin users may freeze/thaw, add/cancel recipients, or otherwise
1165 mess about, but the original sender is permitted to remove a message. That's
1166 why we leave this check until after the headers are read. */
1167
1168 if (!f.admin_user && (action != MSG_REMOVE || real_uid != originator_uid))
1169 {
1170 printf("Permission denied\n");
1171 (void)close(deliver_datafile);
1172 deliver_datafile = -1;
1173 return FALSE;
1174 }
1175
1176 /* Set up the user name for logging. */
1177
1178 pw = getpwuid(real_uid);
1179 username = (pw != NULL)?
1180 US pw->pw_name : string_sprintf("uid %ld", (long int)real_uid);
1181
1182 /* Take the necessary action. */
1183
1184 if (action != MSG_SHOW_COPY) printf("Message %s ", id);
1185
1186 switch(action)
1187 {
1188 case MSG_SHOW_COPY:
1189 {
1190 transport_ctx tctx = {{0}};
1191 deliver_in_buffer = store_malloc(DELIVER_IN_BUFFER_SIZE);
1192 deliver_out_buffer = store_malloc(DELIVER_OUT_BUFFER_SIZE);
1193 tctx.u.fd = 1;
1194 (void) transport_write_message(&tctx, 0);
1195 break;
1196 }
1197
1198
1199 case MSG_FREEZE:
1200 if (f.deliver_freeze)
1201 {
1202 yield = FALSE;
1203 printf("is already frozen\n");
1204 }
1205 else
1206 {
1207 f.deliver_freeze = TRUE;
1208 f.deliver_manual_thaw = FALSE;
1209 deliver_frozen_at = time(NULL);
1210 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1211 {
1212 printf("is now frozen\n");
1213 log_write(0, LOG_MAIN, "frozen by %s", username);
1214 }
1215 else
1216 {
1217 yield = FALSE;
1218 printf("could not be frozen: %s\n", errmsg);
1219 }
1220 }
1221 break;
1222
1223
1224 case MSG_THAW:
1225 if (!f.deliver_freeze)
1226 {
1227 yield = FALSE;
1228 printf("is not frozen\n");
1229 }
1230 else
1231 {
1232 f.deliver_freeze = FALSE;
1233 f.deliver_manual_thaw = TRUE;
1234 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1235 {
1236 printf("is no longer frozen\n");
1237 log_write(0, LOG_MAIN, "unfrozen by %s", username);
1238 }
1239 else
1240 {
1241 yield = FALSE;
1242 printf("could not be unfrozen: %s\n", errmsg);
1243 }
1244 }
1245 break;
1246
1247
1248 /* We must ensure all files are removed from both the input directory
1249 and the appropriate subdirectory, to clean up cases when there are odd
1250 files left lying around in odd places. In the normal case message_subdir
1251 will have been set correctly by spool_read_header, but as this is a rare
1252 operation, just run everything twice. */
1253
1254 case MSG_REMOVE:
1255 {
1256 uschar suffix[3];
1257
1258 suffix[0] = '-';
1259 suffix[2] = 0;
1260 message_subdir[0] = id[5];
1261
1262 for (int j = 0; j < 2; message_subdir[0] = 0, j++)
1263 {
1264 uschar * fname = spool_fname(US"msglog", message_subdir, id, US"");
1265
1266 DEBUG(D_any) debug_printf(" removing %s", fname);
1267 if (Uunlink(fname) < 0)
1268 {
1269 if (errno != ENOENT)
1270 {
1271 yield = FALSE;
1272 printf("Error while removing %s: %s\n", fname, strerror(errno));
1273 }
1274 else DEBUG(D_any) debug_printf(" (no file)\n");
1275 }
1276 else
1277 {
1278 removed = TRUE;
1279 DEBUG(D_any) debug_printf(" (ok)\n");
1280 }
1281
1282 for (int i = 0; i < 3; i++)
1283 {
1284 uschar * fname;
1285
1286 suffix[1] = (US"DHJ")[i];
1287 fname = spool_fname(US"input", message_subdir, id, suffix);
1288
1289 DEBUG(D_any) debug_printf(" removing %s", fname);
1290 if (Uunlink(fname) < 0)
1291 {
1292 if (errno != ENOENT)
1293 {
1294 yield = FALSE;
1295 printf("Error while removing %s: %s\n", fname, strerror(errno));
1296 }
1297 else DEBUG(D_any) debug_printf(" (no file)\n");
1298 }
1299 else
1300 {
1301 removed = TRUE;
1302 DEBUG(D_any) debug_printf(" (done)\n");
1303 }
1304 }
1305 }
1306
1307 /* In the common case, the datafile is open (and locked), so give the
1308 obvious message. Otherwise be more specific. */
1309
1310 if (deliver_datafile >= 0) printf("has been removed\n");
1311 else printf("has been removed or did not exist\n");
1312 if (removed)
1313 {
1314 #ifndef DISABLE_EVENT
1315 if (event_action) for (int i = 0; i < recipients_count; i++)
1316 {
1317 tree_node *delivered =
1318 tree_search(tree_nonrecipients, recipients_list[i].address);
1319 if (!delivered)
1320 {
1321 uschar * save_local = deliver_localpart;
1322 const uschar * save_domain = deliver_domain;
1323 uschar * addr = recipients_list[i].address, * errmsg = NULL;
1324 int start, end, dom;
1325
1326 if (!parse_extract_address(addr, &errmsg, &start, &end, &dom, TRUE))
1327 log_write(0, LOG_MAIN|LOG_PANIC,
1328 "failed to parse address '%.100s'\n: %s", addr, errmsg);
1329 else
1330 {
1331 deliver_localpart =
1332 string_copyn(addr+start, dom ? (dom-1) - start : end - start);
1333 deliver_domain = dom
1334 ? CUS string_copyn(addr+dom, end - dom) : CUS"";
1335
1336 event_raise(event_action, US"msg:fail:internal",
1337 string_sprintf("message removed by %s", username));
1338
1339 deliver_localpart = save_local;
1340 deliver_domain = save_domain;
1341 }
1342 }
1343 }
1344 (void) event_raise(event_action, US"msg:complete", NULL);
1345 #endif
1346 log_write(0, LOG_MAIN, "removed by %s", username);
1347 log_write(0, LOG_MAIN, "Completed");
1348 }
1349 break;
1350 }
1351
1352
1353 case MSG_SETQUEUE:
1354 /* The global "queue_name_dest" is used as destination, "queue_name"
1355 as source */
1356
1357 spool_move_message(id, message_subdir, US"", US"");
1358 break;
1359
1360
1361 case MSG_MARK_ALL_DELIVERED:
1362 for (int i = 0; i < recipients_count; i++)
1363 tree_add_nonrecipient(recipients_list[i].address);
1364
1365 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1366 {
1367 printf("has been modified\n");
1368 for (int i = 0; i < recipients_count; i++)
1369 log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1370 recipients_list[i].address, username);
1371 }
1372 else
1373 {
1374 yield = FALSE;
1375 printf("- could not mark all delivered: %s\n", errmsg);
1376 }
1377 break;
1378
1379
1380 case MSG_EDIT_SENDER:
1381 if (recipients_arg < argc - 1)
1382 {
1383 yield = FALSE;
1384 printf("- only one sender address can be specified\n");
1385 break;
1386 }
1387 doing = US"editing sender";
1388 /* Fall through */
1389
1390 case MSG_ADD_RECIPIENT:
1391 if (doing == NULL) doing = US"adding recipient";
1392 /* Fall through */
1393
1394 case MSG_MARK_DELIVERED:
1395 if (doing == NULL) doing = US"marking as delivered";
1396
1397 /* Common code for EDIT_SENDER, ADD_RECIPIENT, & MARK_DELIVERED */
1398
1399 if (recipients_arg >= argc)
1400 {
1401 yield = FALSE;
1402 printf("- error while %s: no address given\n", doing);
1403 break;
1404 }
1405
1406 for (; recipients_arg < argc; recipients_arg++)
1407 {
1408 int start, end, domain;
1409 uschar *errmess;
1410 uschar *recipient =
1411 parse_extract_address(argv[recipients_arg], &errmess, &start, &end,
1412 &domain, (action == MSG_EDIT_SENDER));
1413
1414 if (recipient == NULL)
1415 {
1416 yield = FALSE;
1417 printf("- error while %s:\n bad address %s: %s\n",
1418 doing, argv[recipients_arg], errmess);
1419 }
1420 else if (recipient[0] != 0 && domain == 0)
1421 {
1422 yield = FALSE;
1423 printf("- error while %s:\n bad address %s: "
1424 "domain missing\n", doing, argv[recipients_arg]);
1425 }
1426 else
1427 {
1428 if (action == MSG_ADD_RECIPIENT)
1429 {
1430 #ifdef SUPPORT_I18N
1431 if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1432 #endif
1433 receive_add_recipient(recipient, -1);
1434 log_write(0, LOG_MAIN, "recipient <%s> added by %s",
1435 recipient, username);
1436 }
1437 else if (action == MSG_MARK_DELIVERED)
1438 {
1439 int i;
1440 for (i = 0; i < recipients_count; i++)
1441 if (Ustrcmp(recipients_list[i].address, recipient) == 0) break;
1442 if (i >= recipients_count)
1443 {
1444 printf("- error while %s:\n %s is not a recipient:"
1445 " message not updated\n", doing, recipient);
1446 yield = FALSE;
1447 }
1448 else
1449 {
1450 tree_add_nonrecipient(recipients_list[i].address);
1451 log_write(0, LOG_MAIN, "address <%s> marked delivered by %s",
1452 recipient, username);
1453 }
1454 }
1455 else /* MSG_EDIT_SENDER */
1456 {
1457 #ifdef SUPPORT_I18N
1458 if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1459 #endif
1460 sender_address = recipient;
1461 log_write(0, LOG_MAIN, "sender address changed to <%s> by %s",
1462 recipient, username);
1463 }
1464 }
1465 }
1466
1467 if (yield)
1468 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1469 printf("has been modified\n");
1470 else
1471 {
1472 yield = FALSE;
1473 printf("- while %s: %s\n", doing, errmsg);
1474 }
1475
1476 break;
1477 }
1478
1479 /* Closing the datafile releases the lock and permits other processes
1480 to operate on the message (if it still exists). */
1481
1482 if (deliver_datafile >= 0)
1483 {
1484 (void)close(deliver_datafile);
1485 deliver_datafile = -1;
1486 }
1487 return yield;
1488 }
1489
1490
1491
1492 /*************************************************
1493 * Check the queue_only_file condition *
1494 *************************************************/
1495
1496 /* The queue_only_file option forces certain kinds of queueing if a given file
1497 exists.
1498
1499 Arguments: none
1500 Returns: nothing
1501 */
1502
1503 void
1504 queue_check_only(void)
1505 {
1506 int sep = 0;
1507 struct stat statbuf;
1508 const uschar * s = queue_only_file;
1509 uschar * ss;
1510
1511 if (s)
1512 while ((ss = string_nextinlist(&s, &sep, NULL, 0)))
1513 if (Ustrncmp(ss, "smtp", 4) == 0)
1514 {
1515 ss += 4;
1516 if (Ustat(ss, &statbuf) == 0)
1517 {
1518 f.queue_smtp = TRUE;
1519 DEBUG(D_receive) debug_printf("queue_smtp set because %s exists\n", ss);
1520 }
1521 }
1522 else
1523 if (Ustat(ss, &statbuf) == 0)
1524 {
1525 queue_only = TRUE;
1526 DEBUG(D_receive) debug_printf("queue_only set because %s exists\n", ss);
1527 }
1528 }
1529
1530
1531
1532 /******************************************************************************/
1533 /******************************************************************************/
1534
1535 #ifdef EXPERIMENTAL_QUEUE_RAMP
1536 void
1537 queue_notify_daemon(const uschar * msgid)
1538 {
1539 uschar buf[MESSAGE_ID_LENGTH + 2];
1540 int fd;
1541
1542 DEBUG(D_queue_run) debug_printf("%s: %s\n", __FUNCTION__, msgid);
1543
1544 buf[0] = NOTIFY_MSG_QRUN;
1545 memcpy(buf+1, msgid, MESSAGE_ID_LENGTH+1);
1546
1547 if ((fd = socket(AF_UNIX, SOCK_DGRAM, 0)) >= 0)
1548 {
1549 struct sockaddr_un sa_un = {.sun_family = AF_UNIX};
1550 int slen;
1551
1552 #ifdef EXIM_HAVE_ABSTRACT_UNIX_SOCKETS
1553 int len = offsetof(struct sockaddr_un, sun_path) + 1
1554 + snprintf(sa_un.sun_path+1, sizeof(sa_un.sun_path)-1, "%s",
1555 expand_string(notifier_socket));
1556 sa_un.sun_path[0] = 0;
1557 #else
1558 int len = offsetof(struct sockaddr_un, sun_path)
1559 + snprintf(sa_un.sun_path, sizeof(sa_un.sun_path), "%s",
1560 expand_string(notifier_socket));
1561 #endif
1562
1563 if (sendto(fd, buf, sizeof(buf), 0, (struct sockaddr *)&sa_un, len) < 0)
1564 DEBUG(D_queue_run)
1565 debug_printf("%s: sendto %s\n", __FUNCTION__, strerror(errno));
1566 close(fd);
1567 }
1568 else DEBUG(D_queue_run) debug_printf(" socket: %s\n", strerror(errno));
1569 }
1570 #endif
1571
1572 #endif /*!COMPILE_UTILITY*/
1573
1574 /* End of queue.c */