src/src/queue.c

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