mkmap_open.c

[詳解]

/*++
/* NAME
/*  mkmap_open 3
/* SUMMARY
/*  create or rewrite database, generic interface
/* SYNOPSIS
/*  #include <mkmap.h>
/*
/*  typedef struct MKMAP {
/*      DICT_OPEN_FN open;              /* dict_xx_open() */
/*      DICT *dict;                 /* dict_xx_open() result */
/*      void    (*after_open) (struct MKMAP *); /* may be null */
/*      void    (*after_close) (struct MKMAP *);    /* may be null */
/*      int     multi_writer;           /* multi-writer safe */
/*  } MKMAP;
/*
/*  MKMAP   *mkmap_open(type, path, open_flags, dict_flags)
/*  char    *type;
/*  char    *path;
/*  int open_flags;
/*  int dict_flags;
/*
/*  void    mkmap_append(mkmap, key, value, lineno)
/*  MKMAP   *mkmap;
/*  char    *key;
/*  char    *value;
/*  int lineno;
/*
/*  void    mkmap_close(mkmap)
/*  MKMAP   *mkmap;
/*
/*  typedef MKMAP *(*MKMAP_OPEN_FN) (const char *);
/*  typedef MKMAP_OPEN_FN *(*MKMAP_OPEN_EXTEND_FN) (const char *);
/*
/*  void    mkmap_open_register(type, open_fn)
/*  const char *type;
/*  MKMAP_OPEN_FN open_fn;
/*
/*  MKMAP_OPEN_EXTEND_FN mkmap_open_extend(call_back)
/*  MKMAP_OPEN_EXTEND_FN call_back;
/* DESCRIPTION
/*  This module implements support for creating Postfix databases.
/*  It is a dict(3) wrapper that adds global locking to dict-level
/*  routines where appropriate.
/*
/*  mkmap_open() creates or truncates the named database, after
/*  appending the appropriate suffixes to the specified filename.
/*  Before the database is updated, it is locked for exclusive
/*  access, and signal delivery is suspended.
/*  See dict(3) for a description of \fBopen_flags\fR and
/*  \fBdict_flags\fR.  All errors are fatal.
/*
/*  mkmap_append() appends the named (key, value) pair to the
/*  database. Update errors are fatal; duplicate keys are ignored
/*  (but a warning is issued).
/*  \fBlineno\fR is used for diagnostics.
/*
/*  mkmap_close() closes the database, releases any locks,
/*  and resumes signal delivery. All errors are fatal.
/*
/*  mkmap_open_register() adds support for a new database type.
/*
/*  mkmap_open_extend() registers a call-back function that looks
/*  up the mkmap open() function for a database type that is not
/*  registered, or null in case of error. The result value is the
/*  last previously-registered call-back or null. A mkmap open()
/*  function is cached after it is looked up through this extension
/*  mechanism.
/* SEE ALSO
/*  sigdelay(3) suspend/resume signal delivery
/* 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>
#include <unistd.h>
#include <string.h>

/* Utility library. */

#include <msg.h>
#include <htable.h>
#include <dict.h>
#include <dict_db.h>
#include <dict_cdb.h>
#include <dict_dbm.h>
#include <dict_lmdb.h>
#include <dict_sdbm.h>
#include <dict_proxy.h>
#include <dict_fail.h>
#include <sigdelay.h>
#include <mymalloc.h>
#include <stringops.h>

/* Global library. */

#include "mkmap.h"

 /*
  * Information about available database types. Here, we list only those map
  * types that support "bulk create" operations.
  * 
  * We use a different table (in dict_open.c and mail_dict.c) when querying maps
  * or when making incremental updates.
  */
typedef struct {
    const char *type;
    MKMAP_OPEN_FN before_open;
} MKMAP_OPEN_INFO;

static const MKMAP_OPEN_INFO mkmap_open_info[] = {
#ifndef USE_DYNAMIC_MAPS
#ifdef HAS_CDB
    DICT_TYPE_CDB, mkmap_cdb_open,
#endif
#ifdef HAS_SDBM
    DICT_TYPE_SDBM, mkmap_sdbm_open,
#endif
#ifdef HAS_LMDB
    DICT_TYPE_LMDB, mkmap_lmdb_open,
#endif
#endif                  /* !USE_DYNAMIC_MAPS */
#ifdef HAS_DBM
    DICT_TYPE_DBM, mkmap_dbm_open,
#endif
#ifdef HAS_DB
    DICT_TYPE_HASH, mkmap_hash_open,
    DICT_TYPE_BTREE, mkmap_btree_open,
#endif
    DICT_TYPE_FAIL, mkmap_fail_open,
    0,
};

static HTABLE *mkmap_open_hash;

static MKMAP_OPEN_EXTEND_FN mkmap_open_extend_hook = 0;

/* mkmap_open_init - one-off initialization */

static void mkmap_open_init(void)
{
    static const char myname[] = "mkmap_open_init";
    const MKMAP_OPEN_INFO *mp;

    if (mkmap_open_hash != 0)
    msg_panic("%s: multiple initialization", myname);
    mkmap_open_hash = htable_create(10);

    for (mp = mkmap_open_info; mp->type; mp++)
    htable_enter(mkmap_open_hash, mp->type, (void *) mp);
}

/* mkmap_open_register - register dictionary type */

void    mkmap_open_register(const char *type, MKMAP_OPEN_FN open_fn)
{
    static const char myname[] = "mkmap_open_register";
    MKMAP_OPEN_INFO *mp;
    HTABLE_INFO *ht;

    if (mkmap_open_hash == 0)
    mkmap_open_init();
    if (htable_find(mkmap_open_hash, type))
    msg_panic("%s: database type exists: %s", myname, type);
    mp = (MKMAP_OPEN_INFO *) mymalloc(sizeof(*mp));
    mp->before_open = open_fn;
    ht = htable_enter(mkmap_open_hash, type, (void *) mp);
    mp->type = ht->key;
}

/* mkmap_open_extend - register alternate lookup function */

MKMAP_OPEN_EXTEND_FN mkmap_open_extend(MKMAP_OPEN_EXTEND_FN new_cb)
{
    MKMAP_OPEN_EXTEND_FN old_cb;

    old_cb = mkmap_open_extend_hook;
    mkmap_open_extend_hook = new_cb;
    return (old_cb);
}

/* mkmap_append - append entry to map */

#undef mkmap_append

void    mkmap_append(MKMAP *mkmap, const char *key, const char *value)
{
    DICT   *dict = mkmap->dict;

    if (dict_put(dict, key, value) != 0 && dict->error != 0)
    msg_fatal("%s:%s: update failed", dict->type, dict->name);
}

/* mkmap_close - close database */

void    mkmap_close(MKMAP *mkmap)
{

    /*
     * Close the database.
     */
    dict_close(mkmap->dict);

    /*
     * Do whatever special processing is needed after closing the database,
     * such as releasing a global exclusive lock on the database file.
     * Individual Postfix dict modules implement locking only for individual
     * record operations, because most Postfix applications don't need global
     * exclusive locks.
     */
    if (mkmap->after_close)
    mkmap->after_close(mkmap);

    /*
     * Resume signal delivery.
     */
    if (mkmap->multi_writer == 0)
    sigresume();

    /*
     * Cleanup.
     */
    myfree((void *) mkmap);
}

/* mkmap_open - create or truncate database */

MKMAP  *mkmap_open(const char *type, const char *path,
                   int open_flags, int dict_flags)
{
    MKMAP  *mkmap;
    const MKMAP_OPEN_INFO *mp;
    MKMAP_OPEN_FN open_fn;

    /*
     * Find out what map type to use.
     */
    if (mkmap_open_hash == 0)
    mkmap_open_init();
    if ((mp = (MKMAP_OPEN_INFO *) htable_find(mkmap_open_hash, type)) == 0) {
    if (mkmap_open_extend_hook != 0 &&
        (open_fn = mkmap_open_extend_hook(type)) != 0) {
        mkmap_open_register(type, open_fn);
        mp = (MKMAP_OPEN_INFO *) htable_find(mkmap_open_hash, type);
    }
    if (mp == 0)
        msg_fatal("unsupported map type for this operation: %s", type);
    }
    if (msg_verbose)
    msg_info("open %s %s", type, path);

    /*
     * Do whatever before-open initialization is needed, such as acquiring a
     * global exclusive lock on an existing database file. Individual Postfix
     * dict modules implement locking only for individual record operations,
     * because most Postfix applications don't need global exclusive locks.
     */
    mkmap = mp->before_open(path);

    /*
     * Delay signal delivery, so that we won't leave the database in an
     * inconsistent state if we can avoid it.
     */
    sigdelay();

    /*
     * Truncate the database upon open, and update it. Read-write mode is
     * needed because the underlying routines read as well as write. We
     * explicitly clobber lock_fd to trigger a fatal error when a map wants
     * to unlock the database after individual transactions: that would
     * result in race condition problems. We clobbber stat_fd as well,
     * because that, too, is used only for individual-transaction clients.
     */
    mkmap->dict = mkmap->open(path, open_flags, dict_flags);
    mkmap->dict->lock_fd = -1;          /* XXX just in case */
    mkmap->dict->stat_fd = -1;          /* XXX just in case */
    mkmap->dict->flags |= DICT_FLAG_DUP_WARN;
    mkmap->multi_writer = (mkmap->dict->flags & DICT_FLAG_MULTI_WRITER);

    /*
     * Do whatever post-open initialization is needed, such as acquiring a
     * global exclusive lock on a database file that did not exist.
     * Individual Postfix dict modules implement locking only for individual
     * record operations, because most Postfix applications don't need global
     * exclusive locks.
     */
    if (mkmap->after_open)
    mkmap->after_open(mkmap);

    /*
     * Wrap the dictionary for UTF-8 syntax checks and casefolding.
     */
    if ((mkmap->dict->flags & DICT_FLAG_UTF8_ACTIVE) == 0
    && DICT_NEED_UTF8_ACTIVATION(util_utf8_enable, dict_flags))
    mkmap->dict = dict_utf8_activate(mkmap->dict);

    /*
     * Resume signal delivery if multi-writer safe.
     */
    if (mkmap->multi_writer)
    sigresume();

    return (mkmap);
}