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