1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2015 */
6 /* See the file NOTICE for conditions of use and distribution. */
8 /* Functions that operate on the input queue. */
15 /* Routines with knowlege of spool layout */
17 #ifndef COMPILE_UTILITY
19 spool_pname_buf(uschar
* buf
, int len
)
21 snprintf(CS buf
, len
, "%s/%s/input", spool_directory
, queue_name
);
25 spool_dname(const uschar
* purpose
, uschar
* subdir
)
27 return string_sprintf("%s/%s/%s/%s",
28 spool_directory
, queue_name
, purpose
, subdir
);
33 spool_sname(const uschar
* purpose
, uschar
* subdir
)
35 return string_sprintf("%s%s%s%s%s",
36 queue_name
, *queue_name
? "/" : "",
38 *subdir
? "/" : "", subdir
);
42 spool_fname(const uschar
* purpose
, const uschar
* subdir
, const uschar
* fname
,
43 const uschar
* suffix
)
45 return string_sprintf("%s/%s/%s/%s/%s%s",
46 spool_directory
, queue_name
, purpose
, subdir
, fname
, suffix
);
52 #ifndef COMPILE_UTILITY
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
58 #define LOG2_MAXNODES 32
62 /*************************************************
63 * Helper sort function for queue_get_spool_list *
64 *************************************************/
66 /* This function is used when sorting the queue list in the function
67 queue_get_spool_list() below.
70 a points to an ordered list of queue_filename items
71 b points to another ordered list
73 Returns: a pointer to a merged ordered list
76 static queue_filename
*
77 merge_queue_lists(queue_filename
*a
, queue_filename
*b
)
79 queue_filename
*first
= NULL
;
80 queue_filename
**append
= &first
;
83 if (Ustrcmp(a
->text
, b
->text
) < 0)
104 /*************************************************
105 * Get list of spool files *
106 *************************************************/
108 /* Scan the spool directory and return a list of the relevant file names
109 therein. Single-character sub-directories are handled as follows:
111 If the first argument is > 0, a sub-directory is scanned; the letter is
112 taken from the nth entry in subdirs.
114 If the first argument is 0, sub-directories are not scanned. However, a
115 list of them is returned.
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.
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.
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
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
142 Returns: pointer to a chain of queue name items
145 static queue_filename
*
146 queue_get_spool_list(int subdiroffset
, uschar
*subdirs
, int *subcount
,
153 queue_filename
*yield
= NULL
;
154 queue_filename
*last
= NULL
;
158 queue_filename
*root
[LOG2_MAXNODES
];
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. */
166 resetflags
= time(NULL
) & 0xFFFF;
168 for (i
= 0; i
< LOG2_MAXNODES
; i
++)
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. */
175 if (subdiroffset
<= 0)
184 /* Set up prototype for the directory name. */
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 */
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. */
195 for (; i
<= *subcount
; i
++)
198 int subdirchar
= subdirs
[i
]; /* 0 for main directory */
202 buffer
[subptr
] = '/';
203 buffer
[subptr
+1] = subdirchar
;
206 DEBUG(D_queue_run
) debug_printf("looking in %s\n", buffer
);
207 if (!(dd
= opendir(CS buffer
)))
210 /* Now scan the directory. */
212 while ((ent
= readdir(dd
)))
214 uschar
*name
= US ent
->d_name
;
215 int len
= Ustrlen(name
);
221 /* If we find a single alphameric sub-directory in the base directory,
222 add it to the list for subsequent scans. */
224 if (i
== 0 && len
== 1 && isalnum(*name
))
226 *subcount
= *subcount
+ 1;
227 subdirs
[*subcount
] = *name
;
231 /* Otherwise, if it is a header spool file, add it to the list */
233 if (len
== SPOOL_NAME_LENGTH
&&
234 Ustrcmp(name
+ SPOOL_NAME_LENGTH
- 2, "-H") == 0)
236 queue_filename
*next
=
237 store_get(sizeof(queue_filename
) + Ustrlen(name
));
238 Ustrcpy(next
->text
, name
);
239 next
->dir_uschar
= subdirchar
;
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. */
257 if ((flags
& 1) == 0)
271 /* Otherwise do a bottom-up merge sort based on the name. */
277 for (j
= 0; j
< LOG2_MAXNODES
; j
++)
280 next
= merge_queue_lists(next
, root
[j
]);
281 root
[j
] = (j
== LOG2_MAXNODES
- 1)? next
: NULL
;
292 /* Finished with this directory */
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. */
305 if (!split_spool_directory
&& count
<= 2)
310 subdir
[0] = subdirchar
; subdir
[1] = 0;
311 rmdir(CS
spool_dname(US
"msglog", subdir
));
313 if (subdiroffset
> 0) break; /* Single sub-directory */
316 /* If we have just scanned the base directory, and subdiroffset is 0,
317 we do not want to continue scanning the sub-directories. */
319 else if (subdiroffset
== 0)
321 } /* Loop for multiple subdirectories */
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. */
327 for (i
= 0; i
< LOG2_MAXNODES
; ++i
)
328 yield
= merge_queue_lists(yield
, root
[i
]);
336 /*************************************************
337 * Perform a queue run *
338 *************************************************/
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.
347 The global variables queue_run_force and queue_run_local may be set to cause
348 forced deliveries or local-only deliveries, respectively.
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.
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.
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
369 queue_run(uschar
*start_id
, uschar
*stop_id
, BOOL recurse
)
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
;
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. */
386 queue_domains
= NULL
;
387 queue_smtp_domains
= NULL
;
388 queue_smtp
= queue_2stage
;
390 queue_run_pid
= getpid();
391 queue_running
= TRUE
;
393 /* Log the true start of a queue run, and fancy options */
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';
408 sprintf(CS p
, "pid=%d", (int)queue_run_pid
);
413 sprintf(CS p
, " -q%s", extras
);
417 if (deliver_selectstring
!= NULL
)
419 sprintf(CS p
, " -R%s %s", deliver_selectstring_regex
? "r" : "",
420 deliver_selectstring
);
424 if (deliver_selectstring_sender
!= NULL
)
426 sprintf(CS p
, " -S%s %s", deliver_selectstring_sender_regex
? "r" : "",
427 deliver_selectstring_sender
);
431 log_detail
= string_copy(big_buffer
);
433 log_write(L_queue_run
, LOG_MAIN
, "Start '%s' queue run: %s",
434 queue_name
, log_detail
);
436 log_write(L_queue_run
, LOG_MAIN
, "Start queue run: %s", log_detail
);
439 /* If deliver_selectstring is a regex, compile it. */
441 if (deliver_selectstring
!= NULL
&& deliver_selectstring_regex
)
442 selectstring_regex
= regex_must_compile(deliver_selectstring
, TRUE
, FALSE
);
444 if (deliver_selectstring_sender
!= NULL
&& deliver_selectstring_sender_regex
)
445 selectstring_regex_sender
=
446 regex_must_compile(deliver_selectstring_sender
, TRUE
, FALSE
);
448 /* If the spool is split into subdirectories, we want to process it one
449 directory at a time, so as to spread out the directory scanning and the
450 delivering when there are lots of messages involved, except when
451 queue_run_in_order is set.
453 In the random order case, this loop runs once for the main directory (handling
454 any messages therein), and then repeats for any subdirectories that were found.
455 When the first argument of queue_get_spool_list() is 0, it scans the top
456 directory, fills in subdirs, and sets subcount. The order of the directories is
457 then randomized after the first time through, before they are scanned in
458 subsqeuent iterations.
460 When the first argument of queue_get_spool_list() is -1 (for queue_run_in_
461 order), it scans all directories and makes a single message list. */
463 for (i
= (queue_run_in_order
? -1 : 0);
464 i
<= (queue_run_in_order
? -1 : subcount
);
468 void *reset_point1
= store_get(0);
473 debug_printf("queue running main directory\n");
475 debug_printf("queue running combined directories\n");
477 debug_printf("queue running subdirectory '%c'\n", subdirs
[i
]);
480 for (f
= queue_get_spool_list(i
, subdirs
, &subcount
, !queue_run_in_order
);
490 /* Unless deliveries are forced, if deliver_queue_load_max is non-negative,
491 check that the load average is low enough to permit deliveries. */
493 if (!queue_run_force
&& deliver_queue_load_max
>= 0)
494 if ((load_average
= os_getloadavg()) > deliver_queue_load_max
)
496 log_write(L_queue_run
, LOG_MAIN
, "Abandon queue run: %s (load %.2f, max %.2f)",
498 (double)load_average
/1000.0,
499 (double)deliver_queue_load_max
/1000.0);
500 i
= subcount
; /* Don't process other directories */
504 DEBUG(D_load
) debug_printf("load average = %.2f max = %.2f\n",
505 (double)load_average
/1000.0,
506 (double)deliver_queue_load_max
/1000.0);
508 /* Skip this message unless it's within the ID limits */
510 if (stop_id
&& Ustrncmp(f
->text
, stop_id
, MESSAGE_ID_LENGTH
) > 0)
512 if (start_id
&& Ustrncmp(f
->text
, start_id
, MESSAGE_ID_LENGTH
) < 0)
515 /* Check that the message still exists */
517 message_subdir
[0] = f
->dir_uschar
;
518 if (Ustat(spool_fname(US
"input", message_subdir
, f
->text
, US
""), &statbuf
) < 0)
521 /* There are some tests that require the reading of the header file. Ensure
522 the store used is scavenged afterwards so that this process doesn't keep
523 growing its store. We have to read the header file again when actually
524 delivering, but it's cheaper than forking a delivery process for each
525 message when many are not going to be delivered. */
527 if (deliver_selectstring
|| deliver_selectstring_sender
||
528 queue_run_first_delivery
)
531 BOOL orig_dont_deliver
= dont_deliver
;
532 void *reset_point2
= store_get(0);
534 /* Restore the original setting of dont_deliver after reading the header,
535 so that a setting for a particular message doesn't force it for any that
536 follow. If the message is chosen for delivery, the header is read again
537 in the deliver_message() function, in a subprocess. */
539 if (spool_read_header(f
->text
, FALSE
, TRUE
) != spool_read_OK
) continue;
540 dont_deliver
= orig_dont_deliver
;
542 /* Now decide if we want to deliver this message. As we have read the
543 header file, we might as well do the freeze test now, and save forking
546 if (deliver_freeze
&& !deliver_force_thaw
)
548 log_write(L_skip_delivery
, LOG_MAIN
, "Message is frozen");
552 /* Check first_delivery in the case when there are no message logs. */
554 else if (queue_run_first_delivery
&& !deliver_firsttime
)
556 DEBUG(D_queue_run
) debug_printf("%s: not first delivery\n", f
->text
);
560 /* Check for a matching address if deliver_selectstring[_sender] is set.
561 If so, we do a fully delivery - don't want to omit other addresses since
562 their routing might trigger re-writing etc. */
564 /* Sender matching */
566 else if ( deliver_selectstring_sender
567 && !(deliver_selectstring_sender_regex
568 ? (pcre_exec(selectstring_regex_sender
, NULL
,
569 CS sender_address
, Ustrlen(sender_address
), 0, PCRE_EOPT
,
571 : (strstric(sender_address
, deliver_selectstring_sender
, FALSE
)
575 DEBUG(D_queue_run
) debug_printf("%s: sender address did not match %s\n",
576 f
->text
, deliver_selectstring_sender
);
580 /* Recipient matching */
582 else if (deliver_selectstring
)
585 for (i
= 0; i
< recipients_count
; i
++)
587 uschar
*address
= recipients_list
[i
].address
;
588 if ( (deliver_selectstring_regex
589 ? (pcre_exec(selectstring_regex
, NULL
, CS address
,
590 Ustrlen(address
), 0, PCRE_EOPT
, NULL
, 0) >= 0)
591 : (strstric(address
, deliver_selectstring
, FALSE
) != NULL
)
593 && tree_search(tree_nonrecipients
, address
) == NULL
598 if (i
>= recipients_count
)
601 debug_printf("%s: no recipient address matched %s\n",
602 f
->text
, deliver_selectstring
);
607 /* Recover store used when reading the header */
609 store_reset(reset_point2
);
610 if (!wanted
) continue; /* With next message */
613 /* OK, got a message we want to deliver. Create a pipe which will
614 serve as a means of detecting when all the processes created by the
615 delivery process are finished. This is relevant when the delivery
616 process passes one or more SMTP channels on to its own children. The
617 pipe gets passed down; by reading on it here we detect when the last
618 descendent dies by the unblocking of the read. It's a pity that for
619 most of the time the pipe isn't used, but creating a pipe should be
623 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "failed to create pipe in queue "
624 "runner process %d: %s", queue_run_pid
, strerror(errno
));
625 queue_run_pipe
= pfd
[pipe_write
]; /* To ensure it gets passed on. */
627 /* Make sure it isn't stdin. This seems unlikely, but just to be on the
630 if (queue_run_pipe
== 0)
632 queue_run_pipe
= dup(queue_run_pipe
);
636 /* Before forking to deliver the message, ensure any open and cached
637 lookup files or databases are closed. Otherwise, closing in the subprocess
638 can make the next subprocess have problems. There won't often be anything
639 open here, but it is possible (e.g. if spool_directory is an expanded
640 string). A single call before this loop would probably suffice, but just in
641 case expansions get inserted at some point, I've taken the heavy-handed
642 approach. When nothing is open, the call should be cheap. */
646 /* Now deliver the message; get the id by cutting the -H off the file
647 name. The return of the process is zero if a delivery was attempted. */
649 set_process_info("running queue: %s", f
->text
);
650 f
->text
[SPOOL_NAME_LENGTH
-2] = 0;
651 if ((pid
= fork()) == 0)
654 if (running_in_test_harness
) millisleep(100);
655 (void)close(pfd
[pipe_read
]);
656 rc
= deliver_message(f
->text
, force_delivery
, FALSE
);
657 _exit(rc
== DELIVER_NOT_ATTEMPTED
);
660 log_write(0, LOG_MAIN
|LOG_PANIC_DIE
, "fork of delivery process from "
661 "queue runner %d failed\n", queue_run_pid
);
663 /* Close the writing end of the synchronizing pipe in this process,
664 then wait for the first level process to terminate. */
666 (void)close(pfd
[pipe_write
]);
667 set_process_info("running queue: waiting for %s (%d)", f
->text
, pid
);
668 while (wait(&status
) != pid
);
670 /* A zero return means a delivery was attempted; turn off the force flag
671 for any subsequent calls unless queue_force is set. */
673 if ((status
& 0xffff) == 0) force_delivery
= queue_run_force
;
675 /* If the process crashed, tell somebody */
677 else if ((status
& 0x00ff) != 0)
678 log_write(0, LOG_MAIN
|LOG_PANIC
,
679 "queue run: process %d crashed with signal %d while delivering %s",
680 (int)pid
, status
& 0x00ff, f
->text
);
682 /* Before continuing, wait till the pipe gets closed at the far end. This
683 tells us that any children created by the delivery to re-use any SMTP
684 channels have all finished. Since no process actually writes to the pipe,
685 the mere fact that read() unblocks is enough. */
687 set_process_info("running queue: waiting for children of %d", pid
);
688 if (read(pfd
[pipe_read
], buffer
, sizeof(buffer
)) > 0)
689 log_write(0, LOG_MAIN
|LOG_PANIC
, "queue run: unexpected data on pipe");
690 (void)close(pfd
[pipe_read
]);
691 set_process_info("running queue");
693 /* If we are in the test harness, and this is not the first of a 2-stage
694 queue run, update fudged queue times. */
696 if (running_in_test_harness
&& !queue_2stage
)
698 uschar
*fqtnext
= Ustrchr(fudged_queue_times
, '/');
699 if (fqtnext
!= NULL
) fudged_queue_times
= fqtnext
+ 1;
701 } /* End loop for list of messages */
703 store_reset(reset_point1
); /* Scavenge list of messages */
705 /* If this was the first time through for random order processing, and
706 sub-directories have been found, randomize their order if necessary. */
708 if (i
== 0 && subcount
> 1 && !queue_run_in_order
)
711 for (j
= 1; j
<= subcount
; j
++)
713 int r
= random_number(100);
716 int k
= (r
% subcount
) + 1;
718 subdirs
[j
] = subdirs
[k
];
723 } /* End loop for multiple directories */
725 /* If queue_2stage is true, we do it all again, with the 2stage flag
730 queue_2stage
= FALSE
;
731 queue_run(start_id
, stop_id
, TRUE
);
734 /* At top level, log the end of the run. */
738 log_write(L_queue_run
, LOG_MAIN
, "End '%s' queue run: %s",
739 queue_name
, log_detail
);
741 log_write(L_queue_run
, LOG_MAIN
, "End queue run: %s", log_detail
);
747 /************************************************
748 * Count messages on the queue *
749 ************************************************/
751 /* Called as a result of -bpc
762 queue_filename
*f
= NULL
;
764 f
= queue_get_spool_list(
765 -1, /* entire queue */
766 subdirs
, /* for holding sub list */
767 &subcount
, /* for subcount */
768 FALSE
); /* not random */
769 for (; f
!= NULL
; f
= f
->next
) count
++;
770 fprintf(stdout
, "%d\n", count
);
775 /************************************************
776 * List extra deliveries *
777 ************************************************/
779 /* This is called from queue_list below to print out all addresses that
780 have received a message but which were not primary addresses. That is, all
781 the addresses in the tree of non-recipients that are not primary addresses.
782 The tree has been scanned and the data field filled in for those that are
785 Argument: points to the tree node
789 static void queue_list_extras(tree_node
*p
)
791 if (p
->left
!= NULL
) queue_list_extras(p
->left
);
792 if (!p
->data
.val
) printf(" +D %s\n", p
->name
);
793 if (p
->right
!= NULL
) queue_list_extras(p
->right
);
798 /************************************************
799 * List messages on the queue *
800 ************************************************/
802 /* Or a given list of messages. In the "all" case, we get a list of file names
803 as quickly as possible, then scan each one for information to output. If any
804 disappear while we are processing, just leave them out, but give an error if an
805 explicit list was given. This function is a top-level function that is obeyed
806 as a result of the -bp argument. As there may be a lot of messages on the
807 queue, we must tidy up the store after reading the headers for each one.
810 option 0 => list top-level recipients, with "D" for those delivered
811 1 => list only undelivered top-level recipients
812 2 => as 0, plus any generated delivered recipients
813 If 8 is added to any of these values, the queue is listed in
815 list => first of any message ids to list
816 count count of message ids; 0 => all
822 queue_list(int option
, uschar
**list
, int count
)
826 int now
= (int)time(NULL
);
828 queue_filename
*f
= NULL
;
831 /* If given a list of messages, build a chain containing their ids. */
835 queue_filename
*last
= NULL
;
836 for (i
= 0; i
< count
; i
++)
838 queue_filename
*next
=
839 store_get(sizeof(queue_filename
) + Ustrlen(list
[i
]) + 2);
840 sprintf(CS next
->text
, "%s-H", list
[i
]);
841 next
->dir_uschar
= '*';
843 if (i
== 0) f
= next
; else last
->next
= next
;
848 /* Otherwise get a list of the entire queue, in order if necessary. */
851 f
= queue_get_spool_list(
852 -1, /* entire queue */
853 subdirs
, /* for holding sub list */
854 &subcount
, /* for subcount */
855 option
>= 8); /* randomize if required */
857 if (option
>= 8) option
-= 8;
859 /* Now scan the chain and print information, resetting store used
862 reset_point
= store_get(0);
864 for (; f
!= NULL
; f
= f
->next
)
870 store_reset(reset_point
);
872 message_subdir
[0] = f
->dir_uschar
;
873 rc
= spool_read_header(f
->text
, FALSE
, count
<= 0);
874 if (rc
== spool_read_notopen
&& errno
== ENOENT
&& count
<= 0) continue;
877 env_read
= (rc
== spool_read_OK
|| rc
== spool_read_hdrerror
);
884 uschar
* fname
= spool_fname(US
"input", message_subdir
, f
->text
, US
"");
886 ptr
= Ustrlen(fname
)-1;
889 /* Add the data size to the header size; don't count the file name
890 at the start of the data file, but add one for the notional blank line
891 that precedes the data. */
893 if (Ustat(fname
, &statbuf
) == 0)
894 size
= message_size
+ statbuf
.st_size
- SPOOL_DATA_START_OFFSET
+ 1;
895 i
= (now
- received_time
)/60; /* minutes on queue */
899 if (i
> 72) printf("%2dd ", (i
+ 12)/24); else printf("%2dh ", i
);
901 else printf("%2dm ", i
);
903 /* Collect delivered addresses from any J file */
906 jread
= Ufopen(fname
, "rb");
909 while (Ufgets(big_buffer
, big_buffer_size
, jread
) != NULL
)
911 int n
= Ustrlen(big_buffer
);
913 tree_add_nonrecipient(big_buffer
);
919 fprintf(stdout
, "%s ", string_format_size(size
, big_buffer
));
920 for (i
= 0; i
< 16; i
++) fputc(f
->text
[i
], stdout
);
922 if (env_read
&& sender_address
!= NULL
)
924 printf(" <%s>", sender_address
);
925 if (sender_set_untrusted
) printf(" (%s)", originator_login
);
928 if (rc
!= spool_read_OK
)
931 if (save_errno
== ERRNO_SPOOLFORMAT
)
934 uschar
* fname
= spool_fname(US
"input", message_subdir
, f
->text
, US
"");
936 if (Ustat(fname
, &statbuf
) == 0)
937 printf("*** spool format error: size=" OFF_T_FMT
" ***",
939 else printf("*** spool format error ***");
941 else printf("*** spool read error: %s ***", strerror(save_errno
));
942 if (rc
!= spool_read_hdrerror
)
949 if (deliver_freeze
) printf(" *** frozen ***");
953 if (recipients_list
!= NULL
)
955 for (i
= 0; i
< recipients_count
; i
++)
957 tree_node
*delivered
=
958 tree_search(tree_nonrecipients
, recipients_list
[i
].address
);
959 if (!delivered
|| option
!= 1)
960 printf(" %s %s\n", (delivered
!= NULL
)? "D":" ",
961 recipients_list
[i
].address
);
962 if (delivered
!= NULL
) delivered
->data
.val
= TRUE
;
964 if (option
== 2 && tree_nonrecipients
!= NULL
)
965 queue_list_extras(tree_nonrecipients
);
973 /*************************************************
974 * Act on a specific message *
975 *************************************************/
977 /* Actions that require a list of addresses make use of argv/argc/
978 recipients_arg. Other actions do not. This function does its own
982 id id of the message to work on
983 action which action is required (MSG_xxx)
984 argv the original argv for Exim
985 argc the original argc for Exim
986 recipients_arg offset to the list of recipients in argv
988 Returns: FALSE if there was any problem
992 queue_action(uschar
*id
, int action
, uschar
**argv
, int argc
, int recipients_arg
)
996 BOOL removed
= FALSE
;
998 uschar
*doing
= NULL
;
1001 uschar spoolname
[32];
1003 /* Set the global message_id variable, used when re-writing spool files. This
1004 also causes message ids to be added to log messages. */
1006 Ustrcpy(message_id
, id
);
1008 /* The "actions" that just list the files do not require any locking to be
1009 done. Only admin users may read the spool files. */
1011 if (action
>= MSG_SHOW_BODY
)
1014 uschar
*subdirectory
, *suffix
;
1018 printf("Permission denied\n");
1022 if (recipients_arg
< argc
)
1024 printf("*** Only one message can be listed at once\n");
1028 if (action
== MSG_SHOW_BODY
)
1030 subdirectory
= US
"input";
1033 else if (action
== MSG_SHOW_HEADER
)
1035 subdirectory
= US
"input";
1040 subdirectory
= US
"msglog";
1044 for (i
= 0; i
< 2; i
++)
1046 message_subdir
[0] = split_spool_directory
== (i
== 0) ? id
[5] : 0;
1047 if ((fd
= Uopen(spool_fname(subdirectory
, message_subdir
, id
, suffix
),
1053 printf("Failed to open %s file for %s%s: %s\n", subdirectory
, id
, suffix
,
1055 if (action
== MSG_SHOW_LOG
&& !message_logs
)
1056 printf("(No message logs are being created because the message_logs "
1057 "option is false.)\n");
1061 while((rc
= read(fd
, big_buffer
, big_buffer_size
)) > 0)
1062 rc
= write(fileno(stdout
), big_buffer
, rc
);
1068 /* For actions that actually act, open and lock the data file to ensure that no
1069 other process is working on this message. If the file does not exist, continue
1070 only if the action is remove and the user is an admin user, to allow for
1071 tidying up broken states. */
1073 if ((deliver_datafile
= spool_open_datafile(id
)) < 0)
1074 if (errno
== ENOENT
)
1077 printf("Spool data file for %s does not exist\n", id
);
1078 if (action
!= MSG_REMOVE
|| !admin_user
) return FALSE
;
1079 printf("Continuing, to ensure all files removed\n");
1083 if (errno
== 0) printf("Message %s is locked\n", id
);
1084 else printf("Couldn't open spool file for %s: %s\n", id
,
1089 /* Read the spool header file for the message. Again, continue after an
1090 error only in the case of deleting by an administrator. Setting the third
1091 argument false causes it to look both in the main spool directory and in
1092 the appropriate subdirectory, and set message_subdir according to where it
1093 found the message. */
1095 sprintf(CS spoolname
, "%s-H", id
);
1096 if (spool_read_header(spoolname
, TRUE
, FALSE
) != spool_read_OK
)
1099 if (errno
!= ERRNO_SPOOLFORMAT
)
1100 printf("Spool read error for %s: %s\n", spoolname
, strerror(errno
));
1102 printf("Spool format error for %s\n", spoolname
);
1103 if (action
!= MSG_REMOVE
|| !admin_user
)
1105 (void)close(deliver_datafile
);
1106 deliver_datafile
= -1;
1109 printf("Continuing to ensure all files removed\n");
1112 /* Check that the user running this process is entitled to operate on this
1113 message. Only admin users may freeze/thaw, add/cancel recipients, or otherwise
1114 mess about, but the original sender is permitted to remove a message. That's
1115 why we leave this check until after the headers are read. */
1117 if (!admin_user
&& (action
!= MSG_REMOVE
|| real_uid
!= originator_uid
))
1119 printf("Permission denied\n");
1120 (void)close(deliver_datafile
);
1121 deliver_datafile
= -1;
1125 /* Set up the user name for logging. */
1127 pw
= getpwuid(real_uid
);
1128 username
= (pw
!= NULL
)?
1129 US pw
->pw_name
: string_sprintf("uid %ld", (long int)real_uid
);
1131 /* Take the necessary action. */
1133 if (action
!= MSG_SHOW_COPY
) printf("Message %s ", id
);
1138 deliver_in_buffer
= store_malloc(DELIVER_IN_BUFFER_SIZE
);
1139 deliver_out_buffer
= store_malloc(DELIVER_OUT_BUFFER_SIZE
);
1140 transport_write_message(1, NULL
, 0);
1148 printf("is already frozen\n");
1152 deliver_freeze
= TRUE
;
1153 deliver_manual_thaw
= FALSE
;
1154 deliver_frozen_at
= time(NULL
);
1155 if (spool_write_header(id
, SW_MODIFYING
, &errmsg
) >= 0)
1157 printf("is now frozen\n");
1158 log_write(0, LOG_MAIN
, "frozen by %s", username
);
1163 printf("could not be frozen: %s\n", errmsg
);
1170 if (!deliver_freeze
)
1173 printf("is not frozen\n");
1177 deliver_freeze
= FALSE
;
1178 deliver_manual_thaw
= TRUE
;
1179 if (spool_write_header(id
, SW_MODIFYING
, &errmsg
) >= 0)
1181 printf("is no longer frozen\n");
1182 log_write(0, LOG_MAIN
, "unfrozen by %s", username
);
1187 printf("could not be unfrozen: %s\n", errmsg
);
1193 /* We must ensure all files are removed from both the input directory
1194 and the appropriate subdirectory, to clean up cases when there are odd
1195 files left lying around in odd places. In the normal case message_subdir
1196 will have been set correctly by spool_read_header, but as this is a rare
1197 operation, just run everything twice. */
1205 message_subdir
[0] = id
[5];
1207 for (j
= 0; j
< 2; message_subdir
[0] = 0, j
++)
1209 uschar
* fname
= spool_fname(US
"msglog", message_subdir
, id
, US
"");
1211 DEBUG(D_any
) debug_printf(" removing %s", fname
);
1212 if (Uunlink(fname
) < 0)
1214 if (errno
!= ENOENT
)
1217 printf("Error while removing %s: %s\n", fname
, strerror(errno
));
1219 else DEBUG(D_any
) debug_printf(" (no file)\n");
1224 DEBUG(D_any
) debug_printf(" (ok)\n");
1227 for (i
= 0; i
< 3; i
++)
1231 suffix
[1] = (US
"DHJ")[i
];
1232 fname
= spool_fname(US
"input", message_subdir
, id
, suffix
);
1234 DEBUG(D_any
) debug_printf(" removing %s", fname
);
1235 if (Uunlink(fname
) < 0)
1237 if (errno
!= ENOENT
)
1240 printf("Error while removing %s: %s\n", fname
, strerror(errno
));
1242 else DEBUG(D_any
) debug_printf(" (no file)\n");
1247 DEBUG(D_any
) debug_printf(" (done)\n");
1252 /* In the common case, the datafile is open (and locked), so give the
1253 obvious message. Otherwise be more specific. */
1255 if (deliver_datafile
>= 0) printf("has been removed\n");
1256 else printf("has been removed or did not exist\n");
1259 log_write(0, LOG_MAIN
, "removed by %s", username
);
1260 log_write(0, LOG_MAIN
, "Completed");
1266 case MSG_MARK_ALL_DELIVERED
:
1267 for (i
= 0; i
< recipients_count
; i
++)
1269 tree_add_nonrecipient(recipients_list
[i
].address
);
1271 if (spool_write_header(id
, SW_MODIFYING
, &errmsg
) >= 0)
1273 printf("has been modified\n");
1274 for (i
= 0; i
< recipients_count
; i
++)
1275 log_write(0, LOG_MAIN
, "address <%s> marked delivered by %s",
1276 recipients_list
[i
].address
, username
);
1281 printf("- could not mark all delivered: %s\n", errmsg
);
1286 case MSG_EDIT_SENDER
:
1287 if (recipients_arg
< argc
- 1)
1290 printf("- only one sender address can be specified\n");
1293 doing
= US
"editing sender";
1296 case MSG_ADD_RECIPIENT
:
1297 if (doing
== NULL
) doing
= US
"adding recipient";
1300 case MSG_MARK_DELIVERED
:
1301 if (doing
== NULL
) doing
= US
"marking as delivered";
1303 /* Common code for EDIT_SENDER, ADD_RECIPIENT, & MARK_DELIVERED */
1305 if (recipients_arg
>= argc
)
1308 printf("- error while %s: no address given\n", doing
);
1312 for (; recipients_arg
< argc
; recipients_arg
++)
1314 int start
, end
, domain
;
1317 parse_extract_address(argv
[recipients_arg
], &errmess
, &start
, &end
,
1318 &domain
, (action
== MSG_EDIT_SENDER
));
1320 if (recipient
== NULL
)
1323 printf("- error while %s:\n bad address %s: %s\n",
1324 doing
, argv
[recipients_arg
], errmess
);
1326 else if (recipient
[0] != 0 && domain
== 0)
1329 printf("- error while %s:\n bad address %s: "
1330 "domain missing\n", doing
, argv
[recipients_arg
]);
1334 if (action
== MSG_ADD_RECIPIENT
)
1337 if (string_is_utf8(recipient
)) allow_utf8_domains
= message_smtputf8
= TRUE
;
1339 receive_add_recipient(recipient
, -1);
1340 log_write(0, LOG_MAIN
, "recipient <%s> added by %s",
1341 recipient
, username
);
1343 else if (action
== MSG_MARK_DELIVERED
)
1345 for (i
= 0; i
< recipients_count
; i
++)
1346 if (Ustrcmp(recipients_list
[i
].address
, recipient
) == 0) break;
1347 if (i
>= recipients_count
)
1349 printf("- error while %s:\n %s is not a recipient:"
1350 " message not updated\n", doing
, recipient
);
1355 tree_add_nonrecipient(recipients_list
[i
].address
);
1356 log_write(0, LOG_MAIN
, "address <%s> marked delivered by %s",
1357 recipient
, username
);
1360 else /* MSG_EDIT_SENDER */
1363 if (string_is_utf8(recipient
)) allow_utf8_domains
= message_smtputf8
= TRUE
;
1365 sender_address
= recipient
;
1366 log_write(0, LOG_MAIN
, "sender address changed to <%s> by %s",
1367 recipient
, username
);
1373 if (spool_write_header(id
, SW_MODIFYING
, &errmsg
) >= 0)
1374 printf("has been modified\n");
1378 printf("- while %s: %s\n", doing
, errmsg
);
1384 /* Closing the datafile releases the lock and permits other processes
1385 to operate on the message (if it still exists). */
1387 if (deliver_datafile
>= 0)
1389 (void)close(deliver_datafile
);
1390 deliver_datafile
= -1;
1397 /*************************************************
1398 * Check the queue_only_file condition *
1399 *************************************************/
1401 /* The queue_only_file option forces certain kinds of queueing if a given file
1409 queue_check_only(void)
1413 struct stat statbuf
;
1416 uschar buffer
[1024];
1418 if (queue_only_file
== NULL
) return;
1420 s
= queue_only_file
;
1421 while ((ss
= string_nextinlist(&s
, &sep
, buffer
, sizeof(buffer
))) != NULL
)
1423 if (Ustrncmp(ss
, "smtp", 4) == 0)
1425 name
= US
"queue_smtp";
1431 name
= US
"queue_only";
1435 if (Ustat(ss
, &statbuf
) == 0)
1438 DEBUG(D_receive
) debug_printf("%s set because %s exists\n", name
, ss
);
1443 #endif /*!COMPILE_UTILITY*/
1445 /* End of queue.c */