src/src/queue.c

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