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