libnisdb/yptol/shim.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2015 Gary Mills
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * DESCRIPTION: Contains the top level shim hook functions. These must have
 *      identical interfaces to the equivalent standard dbm calls.
 *
 *      Unfortunately many of these will do a copy of a datum structure
 *      on return. This is a side effect of the original DBM function
 *      being written to pass structures rather than pointers.
 *
 * NOTE :   There is a major bug/feature in dbm. A key obtained by
 *      dbm_nextkey() of dbm_firstkey() cannot be passed to dbm_store().
 *      When the store occurs dbm's internal memory get's reorganized
 *      and the static strings pointed to by the key are destroyed. The
 *      data is then stored in the wrong place. We attempt to get round
 *      this by dbm_firstkey() and dbm_nextkey() making a copy of the
 *      key data in malloced memory. This is freed when map_ctrl is
 *      freed.
 */

#include <unistd.h>
#include <syslog.h>
#include <ndbm.h>
#include <strings.h>
#include "ypsym.h"
#include "ypdefs.h"
#include "shim.h"
#include "yptol.h"
#include "stubs.h"
#include "../ldap_parse.h"
#include "../ldap_util.h"

/*
 * Globals
 */
bool_t yptol_mode = FALSE;  /* Set if in N2L mode */
bool_t yptol_newlock = FALSE;
                /*
                 * Set if in N2L mode and we want to use the new
                 * lock mapping mechanism
                 */
bool_t ypxfrd_flag = FALSE; /* Set if called from ypxfrd */
pid_t parent_pid;           /* ID of calling parent process */


/*
 * Decs
 */
void check_old_map_date(map_ctrl *);

/*
 * Constants
 */
/* Number of times to try to update a map before giving up */
/* #define MAX_UPDATE_ATTEMPTS 3 */
#define MAX_UPDATE_ATTEMPTS 1

/*
 * FUNCTION:    shim_dbm_close();
 *
 * INPUTS:      Identical to equivalent dbm call.
 *
 * OUTPUTS:     Identical to equivalent dbm call.
 *
 */
void
shim_dbm_close(DBM *db)
{
    map_ctrl *map;

    /* Lock the map */
    map = get_map_ctrl(db);
    if (map == NULL)
        return;

    free_map_ctrl(map);
}

/*
 * FUNCTION:    shim_dbm_delete();
 *
 * DESCRIPTION: This function is currently unused but is present so that the
 *      set of shim_dbm_xxx() interfaces is complete if required in
 *      future.
 *
 * INPUTS:      Identical to equivalent dbm call.
 *
 * OUTPUTS:     Identical to equivalent dbm call.
 *
 */
int
shim_dbm_delete(DBM *db, datum key)
{
    int ret;
    map_ctrl *map;

    /* Lock the map */
    map = get_map_ctrl(db);
    if (map == NULL)
        return (FAILURE);
    if (1 != lock_map_ctrl(map))
        return (FAILURE);

    if (yptol_mode) {
        /* Delete from and ttl map. Not a huge disaster if it fails. */
        dbm_delete(map->ttl, key);
    }

    ret = dbm_delete(map->entries, key);

    unlock_map_ctrl(map);

    return (ret);
}


/*
 * FUNCTION:    shim_dbm_fetch()
 *
 * DESCRIPTION: N2L function used to handle 'normal' dbm_fetch() operations.
 *
 * INPUTS:      First two identical to equivalent dbm call.
 *
 * OUTPUTS:     Identical to equivalent dbm call.
 *
 */
datum
shim_dbm_fetch(DBM *db, datum key)
{
    datum ret = {0, NULL};
    map_ctrl *map;

    /* Lock the map */
    map = get_map_ctrl(db);
    if (map == NULL)
        return (ret);
    if (1 != lock_map_ctrl(map))
        return (ret);

    if (yptol_mode) {
        if (SUCCESS == update_entry_if_required(map, &key)) {
            /* Update thinks we should return something */
            ret = dbm_fetch(map->entries, key);
        }
    } else {
        /* Non yptol mode do a normal fetch */
        ret = dbm_fetch(map->entries, key);
    }

    unlock_map_ctrl(map);

    return (ret);
}

/*
 * FUNCTION:    shim_dbm_fetch_noupdate()
 *
 * DESCRIPTION: A special version of shim_dbm_fetch() that never checks TTLs
 *      or updates entries.
 *
 * INPUTS:      Identical to equivalent dbm call.
 *
 * OUTPUTS:     Identical to equivalent dbm call.
 *
 */
datum
shim_dbm_fetch_noupdate(DBM *db, datum key)
{
    datum ret = {0, NULL};
    map_ctrl *map;

    /* Get the map control block */
    map = get_map_ctrl(db);
    if (map == NULL)
        return (ret);

    /* Not updating so no need to lock */
    ret = dbm_fetch(map->entries, key);

    return (ret);
}

/*
 * FUNCTION:    shim_dbm_firstkey()
 *
 * DESCRIPTION: Get firstkey in an enumeration. If the map is out of date then
 *        this is the time to scan it and see if any new entries have been
 *        created.
 *
 * INPUTS:      Identical to equivalent dbm call.
 *
 * OUTPUTS:     Identical to equivalent dbm call.
 *
 */
datum
shim_dbm_firstkey(DBM *db)
{
    int count;
    bool_t wait_flag;

    datum ret = {0, NULL};
    map_ctrl *map;

    /* Lock the map */
    map = get_map_ctrl(db);
    if (map == NULL)
        return (ret);
    if (1 != lock_map_ctrl(map))
        return (ret);

    if (yptol_mode) {
        /*
         * Due to the limitations in the hashing algorithm ypxfrd
         * may end up waiting on the wrong update. It must thus loop
         * until the right map has been updated.
         */
        for (count = 0; has_map_expired(map) &&
                (MAX_UPDATE_ATTEMPTS > count); count++) {
            /*
             * Ideally ypxfr should wait for the map update
             * to complete i.e. pass ypxfrd_flag into
             * update_map_if_required(). This cannot be done
             * because if there is a large map update the client
             * side, ypxfr, can time out while waiting.
             */
            wait_flag = FALSE;
            update_map_if_required(map, wait_flag);

            if (wait_flag) {
                /*
                 * Because ypxfrd does weird things with DBMs
                 * internal structures it's a good idea to
                 * reopen here. (Code that uses the real DBM
                 * API appears not to need this.)
                 *
                 * This should not be necessary all we have
                 * done is 'mv' the new file over the old one.
                 * Open handles should get the old data but if
                 * these lines are removed the first ypxfrd
                 * read access fail with bad file handle.
                 *
                 * NOTE : If we don't wait, because of the
                 * ypxfr timeout problem, there is no point
                 * doing this.
                 */
                dbm_close(map->entries);
                dbm_close(map->ttl);
                if (FAILURE == open_yptol_files(map)) {
                    logmsg(MSG_NOTIMECHECK, LOG_ERR,
                        "Could not reopen DBM files");
                }
            } else {
                /* For daemons that don't wait just try once */
                break;
            }
        }

        if (MAX_UPDATE_ATTEMPTS < count)
            logmsg(MSG_NOTIMECHECK, LOG_ERR,
                    "Cannot update map %s", map->map_name);
    }

    ret = dbm_firstkey(map->entries);

    /* Move key data out of static memory. See NOTE in file header above */
    if (yptol_mode) {
        set_key_data(map, &ret);
    }
    unlock_map_ctrl(map);

    return (ret);
}

/*
 * FUNCTION:    shim_dbm_nextkey()
 *
 * DESCRIPTION: Get next key in an enumeration. Since updating an entry would
 *        invalidate the enumeration we never do it.
 *
 * INPUTS:      Identical to equivalent dbm call.
 *
 * OUTPUTS:     Identical to equivalent dbm call.
 *
 */
datum
shim_dbm_nextkey(DBM *db)
{
    datum ret;
    map_ctrl *map;

    /* Lock the map */
    map = get_map_ctrl(db);
    if (map == NULL)
        return (ret);
    if (1 != lock_map_ctrl(map))
        return (ret);

    ret = dbm_nextkey(map->entries);

    /* Move key data out of static memory. See NOTE in file header above */
    if (yptol_mode) {
        set_key_data(map, &ret);
    }

    unlock_map_ctrl(map);

    return (ret);
}

/*
 * FUNCTION:    shim_dbm_do_nextkey()
 *
 * DESCRIPTION: Get next key in an enumeration. Since updating an entry would
 *        invalidate the enumeration we never do it.
 *
 * NOTE :   dbm_do_nextkey is not a documented or legal DBM API.
 *      Despite this the existing NIS code calls it. One gross hack
 *      deserves another so we have this extra shim function to handle
 *      the illegal call.
 *
 * INPUTS:      Identical to equivalent dbm call.
 *
 * OUTPUTS:     Identical to equivalent dbm call.
 *
 */
datum
shim_dbm_do_nextkey(DBM *db, datum inkey)
{
    datum ret;
    map_ctrl *map;

    /* Lock the map */
    map = get_map_ctrl(db);
    if (map == NULL)
        return (ret);
    if (1 != lock_map_ctrl(map))
        return (ret);

    ret = dbm_do_nextkey(map->entries, inkey);

    /* Move key data out of static memory. See NOTE in file header above */
    if (yptol_mode) {
        set_key_data(map, &ret);
    }

    unlock_map_ctrl(map);

    return (ret);
}
/*
 * FUNCTION:    shim_dbm_open()
 *
 * INPUTS:      Identical to equivalent dbm call.
 *
 * OUTPUTS:     Identical to equivalent dbm call.
 *
 */
DBM *
shim_dbm_open(const char *file, int open_flags, mode_t file_mode)
{
    map_ctrl *map;
    suc_code ret = FAILURE;

    /* Find or create map_ctrl for this map */
    map = create_map_ctrl((char *)file);

    if (map == NULL)
        return (NULL);

    /* Lock map */
    if (1 != lock_map_ctrl(map))
        return (NULL);

    /* Remember flags and mode in case we have to reopen */
    map->open_flags = open_flags;
    map->open_mode = file_mode;

    if (yptol_mode) {
        ret = open_yptol_files(map);

        /*
         * This is a good place to check that the
         * equivalent old style map file has not been
         * updated.
         */
        if (SUCCESS == ret)
            check_old_map_date(map);

    } else {
        /* Open entries map */
        map->entries = dbm_open(map->map_path, map->open_flags,
                                map->open_mode);

        if (NULL != map->entries)
            ret = SUCCESS;
    }

    /* If we were not successful unravel what we have done so far */
    if (ret != SUCCESS) {
        unlock_map_ctrl(map);
        free_map_ctrl(map);
        return (NULL);
    }

    unlock_map_ctrl(map);

    /* Return map_ctrl pointer as a DBM *. To the outside world it is */
    /* opaque. */
    return ((DBM *)map);
}

/*
 * FUNCTION:    shim_dbm_store()
 *
 * DESCRIPTION: Shim for dbm_store.
 *
 *      In N2L mode if we are asked to store in DBM_INSERT mode
 *      then first an attempt is made to write to the DIT (in the same
 *      mode). If this is successful then the value is forced into DBM
 *      using DBM_REPLACE. This is because the DIT is authoritative.
 *      The success of failure of an 'insert' is determined by the
 *      presence or otherwise of an entry in the DIT not DBM.
 *
 * INPUTS:  Identical to equivalent dbm call.
 *
 * OUTPUTS: Identical to equivalent dbm call.
 *
 */
int
shim_dbm_store(DBM  *db,  datum  key,  datum  content, int store_mode)
{
    int ret;
    map_ctrl *map;

    /* Get map name */
    map = get_map_ctrl(db);
    if (map == NULL)
        return (FAILURE);

    if (yptol_mode) {
        /* Write to the DIT before doing anything else */
        if (!write_to_dit(map->map_name, map->domain, key, content,
                    DBM_REPLACE == store_mode, FALSE))
            return (FAILURE);
    }

    /* Lock the map */
    if (1 != lock_map_ctrl(map))
        return (FAILURE);

    if (yptol_mode) {
        if (!is_map_updating(map)) {
            ret = dbm_store(map->entries, key, content,
                                DBM_REPLACE);

            if (SUCCESS == ret)
                /* Update TTL */
                update_entry_ttl(map, &key, TTL_RAND);
        }
    } else {
        ret = dbm_store(map->entries, key, content, store_mode);
    }

    unlock_map_ctrl(map);

    return (ret);
}

/*
 * FUNCTION :   shim_exit()
 *
 * DESCRIPTION: Intercepts exit() calls made by N2L compatible NIS components.
 *      This is required because any call to the shim_dbm... series
 *      of functions may have started an update thread. If the process
 *      exits normally then this thread may be killed before it can
 *      complete its work. We thus wait here for the thread to complete.
 *
 * GIVEN :  Same arg as exit()
 *
 * RETURNS :    Never
 */
void
shim_exit(int code)
{
    thr_join(NULL, NULL, NULL);
    exit(code);
}

/*
 * FUNCTION :   init_yptol_flag()
 *
 * DESCRIPTION: Initializes two flags these are similar but their function is
 *      subtly different.
 *
 *      yp2ldap tells the mapping system if it is to work in NIS or
 *      NIS+ mode. For N2L this is always set to NIS mode.
 *
 *      yptol tells the shim if it is to work in N2L or traditional
 *      NIS mode. For N2L this is turned on if the N2L mapping file
 *      is found to be present. In NIS+ mode it is meaningless.
 */
void
init_yptol_flag()
{
    /*
     * yp2ldap is used to switch appropriate code in the
     * common libnisdb library used by rpc.nisd and ypserv.
     */
    yp2ldap = 1;
    yptol_mode = is_yptol_mode();
    /*
     * Use the new lock mapping mechanism
     * if in N2L mode.
     */
    yptol_newlock = yptol_mode;
}

/*
 * FUNCTION :   set_yxfrd_flag()
 */
void
set_ypxfrd_flag()
{
    ypxfrd_flag = TRUE;
}

/*
 * FUNCTION :   check_old_map_date()
 *
 * DESCRIPTION: Checks that an old style map has not been updated. If it has
 *      then ypmake has probably erroneously been run and an error is
 *      logged.
 *
 * GIVEN :  A map_ctrl containing details of the NEW STYLE map.
 *
 * RETURNS :    Nothing
 */
void
check_old_map_date(map_ctrl *map)
{
    datum key;
    datum value;
    struct stat stats;
    time_t old_time;

    /* Get date of last update */
    if (0 != stat(map->trad_map_path, &stats)) {
        /*
         * No problem. We have a new style map but no old style map
         * this will occur if the original data came from native LDAP
         * instead of NIS.
         */
        return;
    }

    /* Set up datum with key for recorded old map update time */
    key.dsize = strlen(MAP_OLD_MAP_DATE_KEY);
    key.dptr = MAP_OLD_MAP_DATE_KEY;
    value = dbm_fetch(map->ttl, key);

    if (NULL != value.dptr) {
        /*
         * Because dptr may not be int aligned need to build an int
         * out of what it points to or will get a bus error.
         */
        bcopy(value.dptr, &old_time, sizeof (time_t));


        /* Do the comparison */
        if (stats.st_mtime <= old_time) {
            /* All is well, has not been updated */
            return;
        }

        /* If we get here the file has been updated */
        logmsg(MSG_NOTIMECHECK, LOG_ERR,
            "Caution. ypmake may have been run in N2L "
            "mode. This will NOT initiate a NIS map push. In "
            "this mode pushes should be initiated with yppush");
    }

    /*
     * If we get here then either the file was updated or there was not
     * a valid old map date (no problem, maybe this is the first time we
     * checked). In either case the old map date entry must be update.
     */
    value.dptr = (char *)&(stats.st_mtime);
    value.dsize = sizeof (time_t);
    dbm_store(map->ttl, key, value, DBM_REPLACE);
}

/*
 * FUNCTION :   init_lock_system()
 *
 * DESCRIPTION: Initializes all the systems related to map locking. This must
 *      be called before any access to the shim functions.
 *
 * GIVEN :  A flag indicating if we are being called from ypserv, which does
 *      not wait for map updates to complete, or other NIS components
 *      which do.
 *
 * RETURNS :    TRUE = Everything worked
 *      FALSE = There were problems
 */
bool_t
init_lock_system(bool_t ypxfrd)
{
    /* Remember what called us */
    if (ypxfrd)
        set_ypxfrd_flag();

    /*
     * Remember PID of process which called us. This enables update threads
     * created by YP children to be handled differently to those created
     * by YP parents.
     */
    parent_pid = getpid();

    /* Init map locks */
    if (!init_lock_map()) {
        logmsg(MSG_NOTIMECHECK, LOG_ERR,
                "Failed to init process synchronization");
        return (FALSE);
    }

    /* If we are in yptol mode set flag indicating the fact */
    init_yptol_flag();

    /*
     * If boot random number system. For now go for reproducible
     * random numbers.
     */
    srand48(0x12345678);

    /*
     * If not N2L mode then no error but do not bother initializing update
     * flags.
     */
    if (yptol_mode) {
        if (!init_update_lock_map()) {
            logmsg(MSG_NOTIMECHECK, LOG_ERR,
                "Failed to init update synchronization");
            return (FALSE);
        }
    }

    return (TRUE);
}