Copyright updates:
[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 */
1e1ddfac 6/* Copyright (c) The Exim Maintainers 2020 */
059ec3d9
PH
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
41313d92
JH
16
17
18
19
20#ifndef COMPILE_UTILITY
0971ec06
JH
21
22/* The number of nodes to use for the bottom-up merge sort when a list of queue
23items is to be ordered. The code for this sort was contributed as a patch by
24Michael Haardt. */
25
26#define LOG2_MAXNODES 32
27
28
29
059ec3d9
PH
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
35queue_get_spool_list() below.
36
37Arguments:
38 a points to an ordered list of queue_filename items
39 b points to another ordered list
40
41Returns: a pointer to a merged ordered list
42*/
43
44static queue_filename *
45merge_queue_lists(queue_filename *a, queue_filename *b)
46{
47queue_filename *first = NULL;
48queue_filename **append = &first;
49
40c90bca 50while (a && b)
2540f2f8
JH
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)
059ec3d9
PH
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 }
2540f2f8 67 }
059ec3d9 68
40c90bca 69*append = a ? a : b;
059ec3d9
PH
70return 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
82therein. 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
95If the randomize argument is TRUE, messages are returned in "randomized" order.
96Actually, the order is anything but random, but the algorithm is cheap, and the
97point is simply to ensure that the same order doesn't occur every time, in case
98a particular message is causing a remote MTA to barf - we would like to try
99other messages to that MTA first.
100
101If the randomize argument is FALSE, sort the list according to the file name.
102This should give the order in which the messages arrived. It is normally used
103only for presentation to humans, in which case the (possibly expensive) sort
104that it does is not part of the normal operational code. However, if
105queue_run_in_order is set, sorting has to take place for queue runs as well.
106When randomize is FALSE, the first argument is normally -1, so all messages are
107included.
108
109Arguments:
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
45907b9d 114 pcount If not NULL, fill in with count of files and do not return list
059ec3d9
PH
115
116Returns: pointer to a chain of queue name items
117*/
118
119static queue_filename *
120queue_get_spool_list(int subdiroffset, uschar *subdirs, int *subcount,
45907b9d 121 BOOL randomize, unsigned * pcount)
059ec3d9
PH
122{
123int i;
124int flags = 0;
125int resetflags = -1;
126int subptr;
127queue_filename *yield = NULL;
128queue_filename *last = NULL;
059ec3d9
PH
129uschar buffer[256];
130queue_filename *root[LOG2_MAXNODES];
131
132/* When randomizing, the file names are added to the start or end of the list
133according to the bits of the flags variable. Get a collection of bits from the
134current time. Use the bottom 16 and just keep re-using them if necessary. When
135not randomizing, initialize the sublists for the bottom-up merge sort. */
136
45907b9d
JH
137if (pcount)
138 *pcount = 0;
139else if (randomize)
40c90bca
JH
140 resetflags = time(NULL) & 0xFFFF;
141else
142 for (i = 0; i < LOG2_MAXNODES; i++)
143 root[i] = NULL;
059ec3d9
PH
144
145/* If processing the full queue, or just the top-level, start at the base
146directory, and initialize the first subdirectory name (as none). Otherwise,
147start at the sub-directory offset. */
148
149if (subdiroffset <= 0)
150 {
151 i = 0;
152 subdirs[0] = 0;
153 *subcount = 0;
154 }
40c90bca
JH
155else
156 i = subdiroffset;
059ec3d9
PH
157
158/* Set up prototype for the directory name. */
159
41313d92 160spool_pname_buf(buffer, sizeof(buffer));
a2da3176 161buffer[sizeof(buffer) - 3] = 0;
059ec3d9
PH
162subptr = Ustrlen(buffer);
163buffer[subptr+2] = 0; /* terminator for lengthened name */
164
165/* This loop runs at least once, for the main or given directory, and then as
166many times as necessary to scan any subdirectories encountered in the main
167directory, if they are to be scanned at this time. */
168
169for (; i <= *subcount; i++)
170 {
171 int count = 0;
172 int subdirchar = subdirs[i]; /* 0 for main directory */
54a2a2a9 173 DIR *dd;
059ec3d9
PH
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);
54a2a2a9 182 if (!(dd = exim_opendir(buffer)))
a2da3176 183 continue;
059ec3d9
PH
184
185 /* Now scan the directory. */
186
54a2a2a9 187 for (struct dirent *ent; 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++;
4b01271f 499 if ((qpid[i] = exim_fork(US"qrun-phase-one")))
92562f63 500 continue; /* parent loops around */
92562f63
JH
501 }
502
059ec3d9
PH
503 /* Skip this message unless it's within the ID limits */
504
8768d548 505 if (stop_id && Ustrncmp(fq->text, stop_id, MESSAGE_ID_LENGTH) > 0)
92562f63 506 goto go_around;
8768d548 507 if (start_id && Ustrncmp(fq->text, start_id, MESSAGE_ID_LENGTH) < 0)
92562f63 508 goto go_around;
059ec3d9
PH
509
510 /* Check that the message still exists */
511
8768d548
JH
512 message_subdir[0] = fq->dir_uschar;
513 if (Ustat(spool_fname(US"input", message_subdir, fq->text, US""), &statbuf) < 0)
92562f63 514 goto go_around;
059ec3d9
PH
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
40c90bca 522 if (deliver_selectstring || deliver_selectstring_sender ||
8768d548 523 f.queue_run_first_delivery)
059ec3d9
PH
524 {
525 BOOL wanted = TRUE;
8768d548 526 BOOL orig_dont_deliver = f.dont_deliver;
f3ebb786 527 rmark reset_point2 = store_mark();
059ec3d9
PH
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
92562f63 534 if (spool_read_header(fq->text, FALSE, TRUE) != spool_read_OK) goto go_around;
8768d548 535 f.dont_deliver = orig_dont_deliver;
059ec3d9
PH
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
8768d548 541 if (f.deliver_freeze && !f.deliver_force_thaw)
059ec3d9
PH
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
8768d548 549 else if (f.queue_run_first_delivery && !f.deliver_firsttime)
059ec3d9 550 {
8768d548 551 DEBUG(D_queue_run) debug_printf("%s: not first delivery\n", fq->text);
059ec3d9
PH
552 wanted = FALSE;
553 }
554
40c90bca 555 /* Check for a matching address if deliver_selectstring[_sender] is set.
059ec3d9
PH
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
40c90bca 561 else if ( deliver_selectstring_sender
8768d548 562 && !(f.deliver_selectstring_sender_regex
40c90bca
JH
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 ) )
059ec3d9
PH
569 {
570 DEBUG(D_queue_run) debug_printf("%s: sender address did not match %s\n",
8768d548 571 fq->text, deliver_selectstring_sender);
059ec3d9
PH
572 wanted = FALSE;
573 }
574
575 /* Recipient matching */
576
40c90bca 577 else if (deliver_selectstring)
059ec3d9
PH
578 {
579 int i;
580 for (i = 0; i < recipients_count; i++)
581 {
582 uschar *address = recipients_list[i].address;
8768d548 583 if ( (f.deliver_selectstring_regex
40c90bca
JH
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 )
059ec3d9
PH
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",
8768d548 597 fq->text, deliver_selectstring);
059ec3d9
PH
598 wanted = FALSE;
599 }
600 }
601
602 /* Recover store used when reading the header */
603
4b4856ff 604 spool_clear_header_globals();
059ec3d9 605 store_reset(reset_point2);
92562f63 606 if (!wanted) goto go_around; /* With next message */
059ec3d9
PH
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)
059ec3d9
PH
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));
059ec3d9
PH
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);
f1e894f3 629 (void)close(0);
059ec3d9
PH
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
8768d548
JH
645 set_process_info("running queue: %s", fq->text);
646 fq->text[SPOOL_NAME_LENGTH-2] = 0;
9f01e50d
JH
647#ifdef MEASURE_TIMING
648 report_time_since(&timestamp_startup, US"queue msg selected");
649#endif
650
b5695709 651single_item_retry:
81022793 652 if ((pid = exim_fork(US"qrun-delivery")) == 0)
059ec3d9
PH
653 {
654 int rc;
655 (void)close(pfd[pipe_read]);
8768d548 656 rc = deliver_message(fq->text, force_delivery, FALSE);
81022793
JH
657 exim_underbar_exit(rc == DELIVER_NOT_ATTEMPTED
658 ? EXIT_FAILURE : EXIT_SUCCESS);
059ec3d9
PH
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
f1e894f3 667 (void)close(pfd[pipe_write]);
8768d548 668 set_process_info("running queue: waiting for %s (%d)", fq->text, pid);
059ec3d9
PH
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
aa81ee14 674 if (!(status & 0xffff)) force_delivery = f.queue_run_force;
059ec3d9
PH
675
676 /* If the process crashed, tell somebody */
677
aa81ee14 678 else if (status & 0x00ff)
059ec3d9
PH
679 log_write(0, LOG_MAIN|LOG_PANIC,
680 "queue run: process %d crashed with signal %d while delivering %s",
8768d548 681 (int)pid, status & 0x00ff, fq->text);
059ec3d9 682
b5695709
JH
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
059ec3d9
PH
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);
847a015a
JH
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",
aa81ee14 704 strerror(errno));
059ec3d9
PH
705 (void)close(pfd[pipe_read]);
706 set_process_info("running queue");
707
92562f63
JH
708 /* If initial of a 2-phase run, we are a child - so just exit */
709 if (f.queue_2stage && !queue_run_in_order)
81022793 710 exim_exit(EXIT_SUCCESS);
92562f63 711
059ec3d9
PH
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
8768d548 715 if (f.running_in_test_harness && !f.queue_2stage)
059ec3d9 716 {
44416341
JH
717 uschar * fqtnext = Ustrchr(fudged_queue_times, '/');
718 if (fqtnext) fudged_queue_times = fqtnext + 1;
059ec3d9 719 }
92562f63
JH
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)
81022793 727 exim_exit(EXIT_SUCCESS);
059ec3d9
PH
728 } /* End loop for list of messages */
729
ce93c6d8 730 tree_nonrecipients = NULL;
059ec3d9
PH
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)
d7978c0f
JH
737 for (int j = 1; j <= subcount; j++)
738 {
739 int r;
f267271d 740 if ((r = random_number(100)) >= 50)
059ec3d9
PH
741 {
742 int k = (r % subcount) + 1;
743 int x = subdirs[j];
744 subdirs[j] = subdirs[k];
745 subdirs[k] = x;
746 }
d7978c0f 747 }
059ec3d9
PH
748 } /* End loop for multiple directories */
749
750/* If queue_2stage is true, we do it all again, with the 2stage flag
751turned off. */
752
8768d548 753if (f.queue_2stage)
059ec3d9 754 {
92562f63
JH
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
8768d548 768 f.queue_2stage = FALSE;
059ec3d9
PH
769 queue_run(start_id, stop_id, TRUE);
770 }
771
772/* At top level, log the end of the run. */
773
6073ad45
JH
774if (!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);
059ec3d9
PH
780}
781
782
783
784
785/************************************************
786* Count messages on the queue *
787************************************************/
788
789/* Called as a result of -bpc
790
791Arguments: none
04403ab0 792Returns: count
059ec3d9
PH
793*/
794
04403ab0 795unsigned
059ec3d9
PH
796queue_count(void)
797{
798int subcount;
04403ab0 799unsigned count = 0;
059ec3d9 800uschar subdirs[64];
d7978c0f 801
45907b9d
JH
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 */
04403ab0 807return count;
059ec3d9
PH
808}
809
810
04403ab0
JH
811#define QUEUE_SIZE_AGE 60 /* update rate for queue_size */
812
813unsigned
814queue_count_cached(void)
815{
816time_t now;
817if ((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 }
822return queue_size;
823}
059ec3d9
PH
824
825/************************************************
826* List extra deliveries *
827************************************************/
828
829/* This is called from queue_list below to print out all addresses that
830have received a message but which were not primary addresses. That is, all
831the addresses in the tree of non-recipients that are not primary addresses.
832The tree has been scanned and the data field filled in for those that are
833primary addresses.
834
835Argument: points to the tree node
836Returns: nothing
837*/
838
e5903596
JH
839static void
840queue_list_extras(tree_node *p)
059ec3d9 841{
e5903596 842if (p->left) queue_list_extras(p->left);
059ec3d9 843if (!p->data.val) printf(" +D %s\n", p->name);
e5903596 844if (p->right) queue_list_extras(p->right);
059ec3d9
PH
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
854as quickly as possible, then scan each one for information to output. If any
855disappear while we are processing, just leave them out, but give an error if an
856explicit list was given. This function is a top-level function that is obeyed
857as a result of the -bp argument. As there may be a lot of messages on the
858queue, we must tidy up the store after reading the headers for each one.
859
860Arguments:
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
869Returns: nothing
870*/
871
872void
873queue_list(int option, uschar **list, int count)
874{
059ec3d9
PH
875int subcount;
876int now = (int)time(NULL);
f3ebb786 877rmark reset_point;
8768d548 878queue_filename * qf = NULL;
059ec3d9
PH
879uschar subdirs[64];
880
881/* If given a list of messages, build a chain containing their ids. */
882
883if (count > 0)
884 {
885 queue_filename *last = NULL;
d7978c0f 886 for (int i = 0; i < count; i++)
059ec3d9
PH
887 {
888 queue_filename *next =
f3ebb786 889 store_get(sizeof(queue_filename) + Ustrlen(list[i]) + 2, is_tainted(list[i]));
059ec3d9
PH
890 sprintf(CS next->text, "%s-H", list[i]);
891 next->dir_uschar = '*';
892 next->next = NULL;
8768d548 893 if (i == 0) qf = next; else last->next = next;
059ec3d9
PH
894 last = next;
895 }
896 }
897
898/* Otherwise get a list of the entire queue, in order if necessary. */
899
900else
8768d548 901 qf = queue_get_spool_list(
059ec3d9
PH
902 -1, /* entire queue */
903 subdirs, /* for holding sub list */
904 &subcount, /* for subcount */
45907b9d
JH
905 option >= 8, /* randomize if required */
906 NULL); /* don't just count */
059ec3d9
PH
907
908if (option >= 8) option -= 8;
909
910/* Now scan the chain and print information, resetting store used
911each time. */
912
f3ebb786
JH
913for (;
914 qf && (reset_point = store_mark());
8768d548 915 spool_clear_header_globals(), store_reset(reset_point), qf = qf->next
c232fc99 916 )
059ec3d9
PH
917 {
918 int rc, save_errno;
919 int size = 0;
920 BOOL env_read;
921
059ec3d9 922 message_size = 0;
8768d548
JH
923 message_subdir[0] = qf->dir_uschar;
924 rc = spool_read_header(qf->text, FALSE, count <= 0);
c232fc99
JH
925 if (rc == spool_read_notopen && errno == ENOENT && count <= 0)
926 continue;
059ec3d9
PH
927 save_errno = errno;
928
929 env_read = (rc == spool_read_OK || rc == spool_read_hdrerror);
930
931 if (env_read)
932 {
d7978c0f 933 int i, ptr;
059ec3d9
PH
934 FILE *jread;
935 struct stat statbuf;
8768d548 936 uschar * fname = spool_fname(US"input", message_subdir, qf->text, US"");
059ec3d9 937
41313d92
JH
938 ptr = Ustrlen(fname)-1;
939 fname[ptr] = 'D';
059ec3d9
PH
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
41313d92 945 if (Ustat(fname, &statbuf) == 0)
059ec3d9 946 size = message_size + statbuf.st_size - SPOOL_DATA_START_OFFSET + 1;
32dfdf8b 947 i = (now - received_time.tv_sec)/60; /* minutes on queue */
059ec3d9
PH
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
41313d92 957 fname[ptr] = 'J';
90341c71 958 if ((jread = Ufopen(fname, "rb")))
059ec3d9
PH
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 }
f1e894f3 966 (void)fclose(jread);
059ec3d9
PH
967 }
968 }
969
970 fprintf(stdout, "%s ", string_format_size(size, big_buffer));
d7978c0f 971 for (int i = 0; i < 16; i++) fputc(qf->text[i], stdout);
059ec3d9 972
90341c71 973 if (env_read && sender_address)
059ec3d9
PH
974 {
975 printf(" <%s>", sender_address);
8768d548 976 if (f.sender_set_untrusted) printf(" (%s)", originator_login);
059ec3d9
PH
977 }
978
979 if (rc != spool_read_OK)
980 {
981 printf("\n ");
982 if (save_errno == ERRNO_SPOOLFORMAT)
983 {
984 struct stat statbuf;
8768d548 985 uschar * fname = spool_fname(US"input", message_subdir, qf->text, US"");
41313d92
JH
986
987 if (Ustat(fname, &statbuf) == 0)
b1c749bb
PH
988 printf("*** spool format error: size=" OFF_T_FMT " ***",
989 statbuf.st_size);
059ec3d9
PH
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");
c232fc99 996 continue;
059ec3d9
PH
997 }
998 }
999
8768d548 1000 if (f.deliver_freeze) printf(" *** frozen ***");
059ec3d9
PH
1001
1002 printf("\n");
1003
90341c71 1004 if (recipients_list)
059ec3d9 1005 {
d7978c0f 1006 for (int i = 0; i < recipients_count; i++)
059ec3d9
PH
1007 {
1008 tree_node *delivered =
1009 tree_search(tree_nonrecipients, recipients_list[i].address);
1010 if (!delivered || option != 1)
c232fc99
JH
1011 printf(" %s %s\n",
1012 delivered ? "D" : " ", recipients_list[i].address);
90341c71 1013 if (delivered) delivered->data.val = TRUE;
059ec3d9 1014 }
90341c71 1015 if (option == 2 && tree_nonrecipients)
059ec3d9
PH
1016 queue_list_extras(tree_nonrecipients);
1017 printf("\n");
1018 }
1019 }
1020}
1021
1022
1023
1024/*************************************************
1025* Act on a specific message *
1026*************************************************/
1027
a96603a0
PH
1028/* Actions that require a list of addresses make use of argv/argc/
1029recipients_arg. Other actions do not. This function does its own
1030authority checking.
059ec3d9
PH
1031
1032Arguments:
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
1039Returns: FALSE if there was any problem
1040*/
1041
1042BOOL
1043queue_action(uschar *id, int action, uschar **argv, int argc, int recipients_arg)
1044{
059ec3d9
PH
1045BOOL yield = TRUE;
1046BOOL removed = FALSE;
1047struct passwd *pw;
1048uschar *doing = NULL;
1049uschar *username;
1050uschar *errmsg;
41313d92 1051uschar spoolname[32];
059ec3d9
PH
1052
1053/* Set the global message_id variable, used when re-writing spool files. This
1054also causes message ids to be added to log messages. */
1055
1056Ustrcpy(message_id, id);
1057
1058/* The "actions" that just list the files do not require any locking to be
1059done. Only admin users may read the spool files. */
1060
1061if (action >= MSG_SHOW_BODY)
1062 {
d7978c0f 1063 int fd, rc;
059ec3d9
PH
1064 uschar *subdirectory, *suffix;
1065
8768d548 1066 if (!f.admin_user)
059ec3d9
PH
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
d7978c0f 1094 for (int i = 0; i < 2; i++)
059ec3d9 1095 {
59a93276 1096 set_subdir_str(message_subdir, id, i);
41313d92
JH
1097 if ((fd = Uopen(spool_fname(subdirectory, message_subdir, id, suffix),
1098 O_RDONLY, 0)) >= 0)
a2da3176
JH
1099 break;
1100 if (i == 0)
1101 continue;
1102
059ec3d9
PH
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)
1ac6b2e7 1112 rc = write(fileno(stdout), big_buffer, rc);
059ec3d9 1113
f1e894f3 1114 (void)close(fd);
059ec3d9
PH
1115 return TRUE;
1116 }
1117
1118/* For actions that actually act, open and lock the data file to ensure that no
1119other process is working on this message. If the file does not exist, continue
1120only if the action is remove and the user is an admin user, to allow for
1121tidying up broken states. */
1122
789f8a4f 1123if ((deliver_datafile = spool_open_datafile(id)) < 0)
059ec3d9
PH
1124 if (errno == ENOENT)
1125 {
1126 yield = FALSE;
1127 printf("Spool data file for %s does not exist\n", id);
8768d548 1128 if (action != MSG_REMOVE || !f.admin_user) return FALSE;
059ec3d9
PH
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 }
059ec3d9
PH
1138
1139/* Read the spool header file for the message. Again, continue after an
1140error only in the case of deleting by an administrator. Setting the third
1141argument false causes it to look both in the main spool directory and in
1142the appropriate subdirectory, and set message_subdir according to where it
1143found the message. */
1144
1145sprintf(CS spoolname, "%s-H", id);
1146if (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);
8768d548 1153 if (action != MSG_REMOVE || !f.admin_user)
059ec3d9 1154 {
f1e894f3 1155 (void)close(deliver_datafile);
059ec3d9
PH
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
1163message. Only admin users may freeze/thaw, add/cancel recipients, or otherwise
1164mess about, but the original sender is permitted to remove a message. That's
1165why we leave this check until after the headers are read. */
1166
8768d548 1167if (!f.admin_user && (action != MSG_REMOVE || real_uid != originator_uid))
059ec3d9
PH
1168 {
1169 printf("Permission denied\n");
f1e894f3 1170 (void)close(deliver_datafile);
059ec3d9
PH
1171 deliver_datafile = -1;
1172 return FALSE;
1173 }
1174
1175/* Set up the user name for logging. */
1176
1177pw = getpwuid(real_uid);
1178username = (pw != NULL)?
1179 US pw->pw_name : string_sprintf("uid %ld", (long int)real_uid);
1180
1181/* Take the necessary action. */
1182
a96603a0 1183if (action != MSG_SHOW_COPY) printf("Message %s ", id);
059ec3d9
PH
1184
1185switch(action)
1186 {
a96603a0 1187 case MSG_SHOW_COPY:
42055a33 1188 {
cab0c277 1189 transport_ctx tctx = {{0}};
42055a33
JH
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;
ee8b8090 1193 (void) transport_write_message(&tctx, 0);
42055a33
JH
1194 break;
1195 }
a96603a0
PH
1196
1197
059ec3d9 1198 case MSG_FREEZE:
8768d548 1199 if (f.deliver_freeze)
059ec3d9
PH
1200 {
1201 yield = FALSE;
1202 printf("is already frozen\n");
1203 }
1204 else
1205 {
8768d548
JH
1206 f.deliver_freeze = TRUE;
1207 f.deliver_manual_thaw = FALSE;
059ec3d9
PH
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:
8768d548 1224 if (!f.deliver_freeze)
059ec3d9
PH
1225 {
1226 yield = FALSE;
1227 printf("is not frozen\n");
1228 }
1229 else
1230 {
8768d548
JH
1231 f.deliver_freeze = FALSE;
1232 f.deliver_manual_thaw = TRUE;
059ec3d9
PH
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:
059ec3d9 1254 {
41313d92 1255 uschar suffix[3];
059ec3d9 1256
41313d92
JH
1257 suffix[0] = '-';
1258 suffix[2] = 0;
1259 message_subdir[0] = id[5];
1260
d7978c0f 1261 for (int j = 0; j < 2; message_subdir[0] = 0, j++)
059ec3d9 1262 {
41313d92
JH
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
d7978c0f 1281 for (int i = 0; i < 3; i++)
41313d92
JH
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 }
059ec3d9 1304 }
059ec3d9 1305
41313d92
JH
1306 /* In the common case, the datafile is open (and locked), so give the
1307 obvious message. Otherwise be more specific. */
059ec3d9 1308
41313d92
JH
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 {
7ea1237c 1313#ifndef DISABLE_EVENT
7a9e0ae1 1314 if (event_action) for (int i = 0; i < recipients_count; i++)
7ea1237c
MK
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
41313d92
JH
1345 log_write(0, LOG_MAIN, "removed by %s", username);
1346 log_write(0, LOG_MAIN, "Completed");
1347 }
1348 break;
8e669ac1 1349 }
059ec3d9
PH
1350
1351
fc7bae7f
JH
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
059ec3d9 1360 case MSG_MARK_ALL_DELIVERED:
d7978c0f 1361 for (int i = 0; i < recipients_count; i++)
059ec3d9 1362 tree_add_nonrecipient(recipients_list[i].address);
7ea1237c 1363
059ec3d9
PH
1364 if (spool_write_header(id, SW_MODIFYING, &errmsg) >= 0)
1365 {
1366 printf("has been modified\n");
d7978c0f 1367 for (int i = 0; i < recipients_count; i++)
059ec3d9
PH
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
5fcc791a 1413 if (!recipient)
059ec3d9
PH
1414 {
1415 yield = FALSE;
1416 printf("- error while %s:\n bad address %s: %s\n",
1417 doing, argv[recipients_arg], errmess);
1418 }
5fcc791a 1419 else if (*recipient && domain == 0)
059ec3d9
PH
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 {
8c5d388a 1429#ifdef SUPPORT_I18N
d752cc0e
JH
1430 if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1431#endif
059ec3d9
PH
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 {
d7978c0f 1438 int i;
059ec3d9
PH
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 {
8c5d388a 1456#ifdef SUPPORT_I18N
d752cc0e
JH
1457 if (string_is_utf8(recipient)) allow_utf8_domains = message_smtputf8 = TRUE;
1458#endif
059ec3d9
PH
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)
059ec3d9
PH
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 }
059ec3d9
PH
1474
1475 break;
1476 }
1477
1478/* Closing the datafile releases the lock and permits other processes
1479to operate on the message (if it still exists). */
1480
12cf7615
JH
1481if (deliver_datafile >= 0)
1482 {
1483 (void)close(deliver_datafile);
1484 deliver_datafile = -1;
1485 }
059ec3d9
PH
1486return 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
1496exists.
1497
1498Arguments: none
1499Returns: nothing
1500*/
1501
1502void
1503queue_check_only(void)
1504{
059ec3d9
PH
1505int sep = 0;
1506struct stat statbuf;
e851856f
JH
1507const uschar * s = queue_only_file;
1508uschar * ss;
059ec3d9 1509
e851856f
JH
1510if (s)
1511 while ((ss = string_nextinlist(&s, &sep, NULL, 0)))
1512 if (Ustrncmp(ss, "smtp", 4) == 0)
8768d548 1513 {
e851856f
JH
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 }
8768d548 1520 }
e851856f
JH
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 }
059ec3d9
PH
1527}
1528
ff966302
JH
1529
1530
1531/******************************************************************************/
1532/******************************************************************************/
1533
1534#ifdef EXPERIMENTAL_QUEUE_RAMP
1535void
1536queue_notify_daemon(const uschar * msgid)
1537{
1538uschar buf[MESSAGE_ID_LENGTH + 2];
1539int fd;
1540
1541DEBUG(D_queue_run) debug_printf("%s: %s\n", __FUNCTION__, msgid);
1542
1543buf[0] = NOTIFY_MSG_QRUN;
1544memcpy(buf+1, msgid, MESSAGE_ID_LENGTH+1);
1545
1546if ((fd = socket(AF_UNIX, SOCK_DGRAM, 0)) >= 0)
1547 {
3978c243 1548 struct sockaddr_un sa_un = {.sun_family = AF_UNIX};
2f2dd3a5
JH
1549
1550#ifdef EXIM_HAVE_ABSTRACT_UNIX_SOCKETS
04403ab0 1551 int len = offsetof(struct sockaddr_un, sun_path) + 1
3978c243 1552 + snprintf(sa_un.sun_path+1, sizeof(sa_un.sun_path)-1, "%s",
691ca88c 1553 expand_string(notifier_socket));
3978c243 1554 sa_un.sun_path[0] = 0;
2f2dd3a5
JH
1555#else
1556 int len = offsetof(struct sockaddr_un, sun_path)
691ca88c
JH
1557 + snprintf(sa_un.sun_path, sizeof(sa_un.sun_path), "%s",
1558 expand_string(notifier_socket));
2f2dd3a5 1559#endif
ff966302 1560
3978c243 1561 if (sendto(fd, buf, sizeof(buf), 0, (struct sockaddr *)&sa_un, len) < 0)
ff966302
JH
1562 DEBUG(D_queue_run)
1563 debug_printf("%s: sendto %s\n", __FUNCTION__, strerror(errno));
1564 close(fd);
1565 }
1566else DEBUG(D_queue_run) debug_printf(" socket: %s\n", strerror(errno));
1567}
1568#endif
1569
41313d92
JH
1570#endif /*!COMPILE_UTILITY*/
1571
059ec3d9 1572/* End of queue.c */