8322 nl: misleading-indentation

[unleashed/tickless.git] / usr / src / lib / 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);
}