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