dict_ni.c

[詳解]

/*++
/* NAME
/*  dict_ni 3
/* SUMMARY
/*  dictionary manager interface to NetInfo
/* SYNOPSIS
/*  #include <dict_ni.h>
/*
/*  DICT    *dict_ni_open(path, dummy, dict_flags)
/*  char    *path;
/*  int dummy;
/*  int dict_flags;
/* DESCRIPTION
/*  dict_ni_open() `opens' the named NetInfo database. The result is
/*  a pointer to a structure that can be used to access the dictionary
/*  using the generic methods documented in dict_open(3).
/* DIAGNOSTICS
/*  dict_ni_register() returns 0 in case of success, -1 in case
/*  of problems.
/*  Fatal errors: NetInfo errors, out of memory.
/* SEE ALSO
/*  dict(3) generic dictionary manager
/*  netinfo(3N) data base subroutines
/* AUTHOR(S)
/*  Pieter Schoenmakers
/*  Eindhoven University of Technology
/*  P.O. Box 513
/*  5600 MB Eindhoven
/*  The Netherlands
/*--*/

#include "sys_defs.h"

#ifdef HAS_NETINFO

/* System library. */

#include <stdio.h>
#include <netinfo/ni.h>

/* Utility library. */

#include "dict.h"
#include "dict_ni.h"
#include "msg.h"
#include "mymalloc.h"
#include "stringops.h"

typedef struct {
    DICT    dict;           /* my super */
    char   *path;           /* directory path */
} DICT_NI;

 /*
  * We'd like other possibilities, but that is not possible in the current
  * dictionary setup...  An example of a different setup: use `members' for
  * multi-valued lookups (to be compatible with /aliases), and `value' for
  * single-valued tables.
  */
#define NETINFO_PROP_KEY    "name"
#define NETINFO_PROP_VALUE  "members"
#define NETINFO_VALUE_SEP    ","

#define NETINFO_MAX_DOMAIN_DEPTH    100

/* Hard worker doing lookups.   Returned value is statically allocated and
   reused each call.  */
static const char *dict_ni_do_lookup(char *path, char *key_prop,
                          const char *key_value, char *val_prop)
{
    unsigned int result_cap = 0;
    static char *result = 0;

    char   *return_val = 0;
    ni_namelist values;
    int     depth = 0;
    void   *domain;
    void   *next_domain;
    char   *query;
    ni_status r;
    ni_id   dir;

    if (msg_verbose)
    msg_info("ni_lookup %s %s=%s", path, key_prop, key_value);

    r = ni_open(NULL, ".", &domain);
    if (r != NI_OK) {
    msg_warn("ni_open `.': %d", r);
    return NULL;
    }
    query = mymalloc(strlen(path) + strlen(key_prop) + 3 + strlen(key_value));
    sprintf(query, "%s/%s=%s", path, key_prop, key_value);

    for (;;) {

    /*
     * What does it _mean_ if we find the directory but not the value?
     */
    if (ni_pathsearch(domain, &dir, query) == NI_OK
        && ni_lookupprop(domain, &dir, val_prop, &values) == NI_OK)
        if (values.ni_namelist_len <= 0)
        ni_namelist_free(&values);
        else {
        unsigned int i, l, n;

        for (i = l = 0; i < values.ni_namelist_len; i++)
            l += 1 + strlen(values.ni_namelist_val[i]);
        if (result_cap < l) {
            if (result)
            myfree(result);
            result_cap = l + 100;
            result = mymalloc(result_cap);
        }
        for (i = l = 0; i < values.ni_namelist_len; i++) {
            n = strlen(values.ni_namelist_val[i]);
            memcpy(result + l, values.ni_namelist_val[i], n);
            l += n;
            if (i < values.ni_namelist_len - 1)
            result[l++] = ',';
        }
        result[l] = '\0';
        return_val = result;
        break;
        }

    if (++depth >= NETINFO_MAX_DOMAIN_DEPTH) {
        msg_warn("ni_open: domain depth limit");
        break;
    }
    r = ni_open(domain, "..", &next_domain);
    if (r != NI_OK) {
        if (r != NI_FAILED)
        msg_warn("ni_open `..': %d", r);
        break;
    }
    ni_free(domain);
    domain = next_domain;
    }

    ni_free(domain);
    myfree(query);

    return return_val;
}

/* dict_ni_lookup - find table entry */

static const char *dict_ni_lookup(DICT *dict, const char *key)
{
    DICT_NI *d = (DICT_NI *) dict;

    dict->error = 0;

    /*
     * Optionally fold the key.
     */
    if (dict->flags & DICT_FLAG_FOLD_FIX) {
    if (dict->fold_buf == 0)
        dict->fold_buf = vstring_alloc(10);
    vstring_strcpy(dict->fold_buf, key);
    key = lowercase(vstring_str(dict->fold_buf));
    }
    return dict_ni_do_lookup(d->dict.name, NETINFO_PROP_KEY,
                 key, NETINFO_PROP_VALUE);
}

/* dict_ni_close - disassociate from NetInfo map */

static void dict_ni_close(DICT *dict)
{
    DICT_NI *d = (DICT_NI *) dict;

    if (dict->fold_buf)
    vstring_free(dict->fold_buf);
    dict_free(dict);
}

/* dict_ni_open - create association with NetInfo map */

DICT   *dict_ni_open(const char *path, int unused_flags, int dict_flags)
{
    DICT_NI *d = (void *) dict_alloc(DICT_TYPE_NETINFO, path, sizeof(*d));

    d->dict.lookup = dict_ni_lookup;
    d->dict.close = dict_ni_close;
    d->dict.flags = dict_flags | DICT_FLAG_FIXED;
    if (dict_flags & DICT_FLAG_FOLD_FIX)
    d->dict.fold_buf = vstring_alloc(10);
    d->dict.owner.status = DICT_OWNER_TRUSTED;

    return (DICT_DEBUG (&d->dict));
}

#endif