/*++ /* NAME /* qmgr_scan 3 /* SUMMARY /* queue scanning /* SYNOPSIS /* #include "qmgr.h" /* /* QMGR_SCAN *qmgr_scan_create(queue_name) /* const char *queue_name; /* /* char *qmgr_scan_next(scan_info) /* QMGR_SCAN *scan_info; /* /* void qmgr_scan_request(scan_info, flags) /* QMGR_SCAN *scan_info; /* int flags; /* DESCRIPTION /* This module implements queue scans. A queue scan always runs /* to completion, so that all files get a fair chance. The caller /* can request that a queue scan be restarted once it completes. /* /* qmgr_scan_create() creates a context for scanning the named queue, /* but does not start a queue scan. /* /* qmgr_scan_next() returns the base name of the next queue file. /* A null pointer means that no file was found. qmgr_scan_next() /* automagically restarts a queue scan when a scan request had /* arrived while the scan was in progress. /* /* qmgr_scan_request() records a request for the next queue scan. The /* flags argument is the bit-wise OR of zero or more of the following, /* unrecognized flags being ignored: /* .IP QMGR_FLUSH_ONCE /* Forget state information about dead hosts or transports. /* This request takes effect immediately. /* .IP QMGR_FLUSH_DFXP /* Override the defer_transports setting. This takes effect /* immediately when a queue scan is in progress, and affects /* the next queue scan. /* .IP QMGR_SCAN_ALL /* Ignore queue file time stamps. This takes effect immediately /* when a queue scan is in progress, and affects the next queue /* scan. /* .IP QMGR_SCAN_START /* Start a queue scan when none is in progress, or restart the /* current scan upon completion. /* DIAGNOSTICS /* Fatal: out of memory. /* Panic: interface violations, internal consistency errors. /* LICENSE /* .ad /* .fi /* The Secure Mailer license must be distributed with this software. /* AUTHOR(S) /* Wietse Venema /* IBM T.J. Watson Research /* P.O. Box 704 /* Yorktown Heights, NY 10598, USA /*--*/ /* System library. */ #include <sys_defs.h> /* Utility library. */ #include <msg.h> #include <mymalloc.h> #include <scan_dir.h> /* Global library. */ #include <mail_scan_dir.h> /* Application-specific. */ #include "qmgr.h" /* qmgr_scan_start - start queue scan */ static void qmgr_scan_start(QMGR_SCAN *scan_info) { const char *myname = "qmgr_scan_start"; /* * Sanity check. */ if (scan_info->handle) msg_panic("%s: %s queue scan in progress", myname, scan_info->queue); /* * Give the poor tester a clue. */ if (msg_verbose) msg_info("%s: %sstart %s queue scan", myname, scan_info->nflags & QMGR_SCAN_START ? "re" : "", scan_info->queue); /* * Start or restart the scan. */ scan_info->flags = scan_info->nflags; scan_info->nflags = 0; scan_info->handle = scan_dir_open(scan_info->queue); } /* qmgr_scan_request - request for future scan */ void qmgr_scan_request(QMGR_SCAN *scan_info, int flags) { /* * Apply "forget all dead destinations" requests immediately. Throttle * dead transports and queues at the earliest opportunity: preferably * during an already ongoing queue scan, otherwise the throttling will * have to wait until a "start scan" trigger arrives. * * The QMGR_FLUSH_ONCE request always comes with QMGR_FLUSH_DFXP, and * sometimes it also comes with QMGR_SCAN_ALL. It becomes a completely * different story when a flush request is encoded in file permissions. */ if (flags & QMGR_FLUSH_ONCE) qmgr_enable_all(); /* * Apply "ignore time stamp" requests also towards the scan that is * already in progress. */ if (scan_info->handle != 0 && (flags & QMGR_SCAN_ALL)) scan_info->flags |= QMGR_SCAN_ALL; /* * Apply "override defer_transports" requests also towards the scan that * is already in progress. */ if (scan_info->handle != 0 && (flags & QMGR_FLUSH_DFXP)) scan_info->flags |= QMGR_FLUSH_DFXP; /* * If a scan is in progress, just record the request. */ scan_info->nflags |= flags; if (scan_info->handle == 0 && (flags & QMGR_SCAN_START) != 0) { scan_info->nflags &= ~QMGR_SCAN_START; qmgr_scan_start(scan_info); } } /* qmgr_scan_next - look for next queue file */ char *qmgr_scan_next(QMGR_SCAN *scan_info) { char *path = 0; /* * Restart the scan if we reach the end and a queue scan request has * arrived in the mean time. */ if (scan_info->handle && (path = mail_scan_dir_next(scan_info->handle)) == 0) { scan_info->handle = scan_dir_close(scan_info->handle); if (msg_verbose && (scan_info->nflags & QMGR_SCAN_START) == 0) msg_info("done %s queue scan", scan_info->queue); } if (!scan_info->handle && (scan_info->nflags & QMGR_SCAN_START)) { qmgr_scan_start(scan_info); path = mail_scan_dir_next(scan_info->handle); } return (path); } /* qmgr_scan_create - create queue scan context */ QMGR_SCAN *qmgr_scan_create(const char *queue) { QMGR_SCAN *scan_info; scan_info = (QMGR_SCAN *) mymalloc(sizeof(*scan_info)); scan_info->queue = mystrdup(queue); scan_info->flags = scan_info->nflags = 0; scan_info->handle = 0; return (scan_info); }