src/src/queue.c

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