qmgr_scan.c

[詳解]

/*++
/* 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);
}