static void qmgr_trigger_event(char *buf, int len,
char *unused_service, char **argv)
{
int incoming_flag = 0;
int deferred_flag = 0;
int i;
/*
* Sanity check. This service takes no command-line arguments.
*/
if (argv[0])
msg_fatal("unexpected command-line argument: %s", argv[0]);
/*
* Collapse identical requests that have arrived since we looked last
* time. There is no client feedback so there is no need to process each
* request in order. And as long as we don't have conflicting requests we
* are free to sort them into the most suitable order.
*/
#define QMGR_FLUSH_BEFORE (QMGR_FLUSH_ONCE | QMGR_FLUSH_DFXP)
for (i = 0; i < len; i++) {
if (msg_verbose)
msg_info("request: %d (%c)",
buf[i], ISALNUM(buf[i]) ? buf[i] : '?');
switch (buf[i]) {
case TRIGGER_REQ_WAKEUP:
case QMGR_REQ_SCAN_INCOMING:
incoming_flag |= QMGR_SCAN_START;
break;
case QMGR_REQ_SCAN_DEFERRED:
deferred_flag |= QMGR_SCAN_START;
break;
case QMGR_REQ_FLUSH_DEAD:
deferred_flag |= QMGR_FLUSH_BEFORE;
incoming_flag |= QMGR_FLUSH_BEFORE;
break;
case QMGR_REQ_SCAN_ALL:
deferred_flag |= QMGR_SCAN_ALL;
incoming_flag |= QMGR_SCAN_ALL;
break;
default:
if (msg_verbose)
msg_info("request ignored");
break;
}
}
/*
* Process each request type at most once. Modifiers take effect upon the
* next queue run. If no queue run is in progress, and a queue scan is
* requested, the request takes effect immediately.
*/
if (incoming_flag != 0)
qmgr_scan_request(qmgr_scans[QMGR_SCAN_IDX_INCOMING], incoming_flag);
if (deferred_flag != 0)
qmgr_scan_request(qmgr_scans[QMGR_SCAN_IDX_DEFERRED], deferred_flag);
}
static void qmgr_deferred_run_event(int unused_event, char *dummy)
{
/*
* This routine runs when it is time for another deferred queue scan.
* Make sure this routine gets called again in the future.
*/
qmgr_scan_request(qmgr_scans[QMGR_SCAN_IDX_DEFERRED], QMGR_SCAN_START);
event_request_timer(qmgr_deferred_run_event, dummy, var_queue_run_delay);
}
static void qmgr_post_init(char *name, char **unused_argv)
{
/*
* Backwards compatibility.
*/
if (strcmp(var_procname, "nqmgr") == 0) {
msg_warn("please update the %s/%s file; the new queue manager",
var_config_dir, MASTER_CONF_FILE);
msg_warn("(old name: nqmgr) has become the standard queue manager (new name: qmgr)");
msg_warn("support for the name old name (nqmgr) will be removed from Postfix");
}
/*
* Sanity check.
*/
if (var_qmgr_rcpt_limit < var_qmgr_active_limit) {
msg_warn("%s is smaller than %s - adjusting %s",
VAR_QMGR_RCPT_LIMIT, VAR_QMGR_ACT_LIMIT, VAR_QMGR_RCPT_LIMIT);
var_qmgr_rcpt_limit = var_qmgr_active_limit;
}
if (var_dsn_queue_time > var_max_queue_time) {
msg_warn("%s is larger than %s - adjusting %s",
VAR_DSN_QUEUE_TIME, VAR_MAX_QUEUE_TIME, VAR_DSN_QUEUE_TIME);
var_dsn_queue_time = var_max_queue_time;
}
/*
* This routine runs after the skeleton code has entered the chroot jail.
* Prevent automatic process suicide after a limited number of client
* requests or after a limited amount of idle time. Move any left-over
* entries from the active queue to the incoming queue, and give them a
* time stamp into the future, in order to allow ongoing deliveries to
* finish first. Start scanning the incoming and deferred queues.
* Left-over active queue entries are moved to the incoming queue because
* the incoming queue has priority; moving left-overs to the deferred
* queue could cause anomalous delays when "postfix reload/start" are
* issued often. Override the IPC timeout (default 3600s) so that the
* queue manager can reset a broken IPC channel before the watchdog timer
* goes off.
*/
var_ipc_timeout = var_qmgr_ipc_timeout;
var_use_limit = 0;
var_idle_limit = 0;
qmgr_move(MAIL_QUEUE_ACTIVE, MAIL_QUEUE_INCOMING, event_time());
qmgr_scans[QMGR_SCAN_IDX_INCOMING] = qmgr_scan_create(MAIL_QUEUE_INCOMING);
qmgr_scans[QMGR_SCAN_IDX_DEFERRED] = qmgr_scan_create(MAIL_QUEUE_DEFERRED);
qmgr_scan_request(qmgr_scans[QMGR_SCAN_IDX_INCOMING], QMGR_SCAN_START);
qmgr_deferred_run_event(0, (void *) 0);
}