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