libnsl/yp/yp_match.c

	yp_match.c revision e8031f0a8ed0e45c6d8847c5e09424e66fd34a4b
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*  Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
/*    All Rights Reserved   */

/*
 * Portions of this source code were derived from Berkeley
 * under license from the Regents of the University of
 * California.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

#include "mt.h"
#include <stdlib.h>
#include <unistd.h>
#include "../rpc/rpc_mt.h"
#include <rpc/rpc.h>
#include <sys/types.h>
#include "yp_b.h"
#include <rpcsvc/yp_prot.h>
#include <rpcsvc/ypclnt.h>
#include <malloc.h>
#include <string.h>
#include <sys/time.h>

extern int __yp_dobind_cflookup(char *, struct dom_binding **, int);
extern int __yp_dobind_rsvdport_cflookup(char *, struct dom_binding **, int);

static int domatch(char *, char *, char *, int, struct dom_binding *,
    struct timeval *, char **, int *);
int yp_match_rsvdport();
int yp_match_rsvdport_cflookup();

struct cache {
    struct cache *next;
    unsigned int birth;
    char *domain;
    char *map;
    char *key;
    int  keylen;
    char *val;
    int  vallen;
};

static mutex_t      cache_lock = DEFAULTMUTEX;
static int      generation; /* Incremented when we add to cache */
static struct cache *head;

#define CACHESZ 16
#define CACHETO 600

static void
freenode(struct cache *n)
{
    if (n->val != 0)
        free(n->val);
    if (n->key != 0)
        free(n->key);
    if (n->map != 0)
        free(n->map);
    if (n->domain != 0)
        free(n->domain);
    free(n);
}

/*
 * Attempt to Add item to cache
 */
static struct cache *
makenode(char *domain, char *map, int keylen, int vallen)
{
    struct cache *n;

    /* Do not cache 'passwd' values i.e. passwd.byname or passwd.byuid. */
    if (strncmp(map, "passwd", 6) == 0)
        return (0);

    if ((n = calloc(1, sizeof (*n))) == 0)
        return (0);
    if (((n->domain = strdup(domain)) == 0) ||
        ((n->map = strdup(map)) == 0) ||
        ((n->key = malloc(keylen)) == 0) ||
        ((n->val = malloc(vallen)) == 0)) {
        freenode(n);
        return (0);
    }
    return (n);
}

/*
 * Look for a matching result in the per-process cache.
 * Upon finding a match set the passed in 'val' and 'vallen'
 * parameters and return 1.  Otherwise return 0.
 */
static int
in_cache(char *domain, char *map, char *key, int keylen, char **val,
                                int *vallen)
{
    struct cache *c, **pp;
    int cnt;
    struct timeval now;
    struct timezone tz;

    /* The 'passwd' data is not cached. */
    if (strncmp(map, "passwd", 6) == 0)
        return (0);

    /*
     * Assumes that caller (yp_match) has locked the cache
     */
    for (pp = &head, cnt = 0;  (c = *pp) != 0;  pp = &c->next, cnt++) {
        if ((c->keylen == keylen) &&
            (memcmp(key, c->key, (size_t)keylen) == 0) &&
            (strcmp(map, c->map) == 0) &&
            (strcmp(domain, c->domain) == 0)) {
            /* cache hit */
            (void) gettimeofday(&now, &tz);
            if ((now.tv_sec - c->birth) > CACHETO) {
                /* rats.  it is too old to use */
                *pp = c->next;
                freenode(c);
                break;
            } else {
                *val = c->val;
                *vallen = c->vallen;

                /* Ersatz LRU:  Move this entry to the front */
                *pp = c->next;
                c->next = head;
                head = c;
                return (1);
            }
        }
        if (cnt >= CACHESZ) {
            *pp = c->next;
            freenode(c);
            break;
        }
    }
    return (0);
}

/*
 * Requests the yp server associated with a given domain to attempt to match
 * the passed key datum in the named map, and to return the associated value
 * datum. This part does parameter checking, and implements the "infinite"
 * (until success) sleep loop if 'hardlookup' parameter is set.
 */
int
__yp_match_cflookup(char *domain, char *map, char *key, int keylen, char **val,
                        int *vallen, int hardlookup)
{
    size_t domlen;
    size_t maplen;
    int reason;
    struct dom_binding *pdomb;
    int savesize;
    struct timeval now;
    struct timezone tz;
    char *my_val;
    int  my_vallen;
    int  found_it;
    int  cachegen;

    if ((map == NULL) || (domain == NULL))
        return (YPERR_BADARGS);

    domlen = strlen(domain);
    maplen = strlen(map);

    if ((domlen == 0) || (domlen > YPMAXDOMAIN) ||
        (maplen == 0) || (maplen > YPMAXMAP) ||
        (key == NULL) || (keylen == 0))
        return (YPERR_BADARGS);

    (void) mutex_lock(&cache_lock);
    found_it = in_cache(domain, map, key, keylen, &my_val, &my_vallen);
    cachegen = generation;

    if (found_it) {
        /* NB: Copy two extra bytes; see below */
        savesize = my_vallen + 2;
        if ((*val = malloc((size_t)savesize)) == 0) {
            (void) mutex_unlock(&cache_lock);
            return (YPERR_RESRC);
        }
        (void) memcpy(*val, my_val, (size_t)savesize);
        *vallen = my_vallen;
        (void) mutex_unlock(&cache_lock);
        return (0); /* Success */
    }
    (void) mutex_unlock(&cache_lock);

    for (;;) {

        if (reason = __yp_dobind_cflookup(domain, &pdomb, hardlookup))
            return (reason);

        if (pdomb->dom_binding->ypbind_hi_vers >= YPVERS) {

            reason = domatch(domain, map, key, keylen, pdomb,
                &_ypserv_timeout, val, vallen);

            __yp_rel_binding(pdomb);
            if (reason == YPERR_RPC || reason == YPERR_YPSERV ||
                reason == YPERR_BUSY /* as if */) {
                yp_unbind(domain);
                if (hardlookup)
                    (void) sleep(_ypsleeptime); /* retry */
                else
                    return (reason);
            } else
                break;
        } else {
            __yp_rel_binding(pdomb);
            return (YPERR_VERS);
        }
    }

    /* add to our cache */
    if (reason == 0) {
        (void) mutex_lock(&cache_lock);
        /*
         * Check whether some other annoying thread did the same
         * thing in parallel with us.  I hate it when that happens...
         */
        if (generation != cachegen &&
            in_cache(domain, map, key, keylen, &my_val, &my_vallen)) {
            /*
             * Could get cute and update the birth time, but it's
             *   not worth the bother.
             * It looks strange that we return one val[] array
             *   to the caller and have a different copy of the
             *   val[] array in the cache (presumably with the
             *   same contents), but it should work just fine.
             * So, do absolutely nothing...
             */
            /* EMPTY */
        } else {
            struct cache    *c;
            /*
             * NB: allocate and copy extract two bytes of the
             * value;  these are mandatory CR and NULL bytes.
             */
            savesize = *vallen + 2;
            c = makenode(domain, map, keylen, savesize);
            if (c != 0) {
                (void) gettimeofday(&now, &tz);
                c->birth = now.tv_sec;
                c->keylen = keylen;
                c->vallen = *vallen;
                (void) memcpy(c->key, key, (size_t)keylen);
                (void) memcpy(c->val, *val, (size_t)savesize);

                c->next = head;
                head = c;
                ++generation;
            }
        }
        (void) mutex_unlock(&cache_lock);
    } else if (reason == YPERR_MAP && geteuid() == 0) {
        /*
         * Lookup could be for a secure map; fail over to retry
         * from a reserved port. Only useful to try this if we're
         * the super user.
         */
        int rsvdreason;
        rsvdreason = yp_match_rsvdport(domain, map, key, keylen, val,
                        vallen);
        if (rsvdreason == 0)
            reason = rsvdreason;
    }
    return (reason);
}

int
yp_match(
    char *domain,
    char *map,
    char *key,
    int  keylen,
    char **val,     /* returns value array */
    int  *vallen)       /* returns bytes in val */

{
    /* the traditional yp_match loops forever thus hardlookup is set */
    return (__yp_match_cflookup(domain, map, key, keylen, val, vallen, 1));
}

extern void
__empty_yp_cache(void)
{
    struct cache *p, *n;

    /* Copy the cache pointer and make it ZERO */
    (void) mutex_lock(&cache_lock);
    p = head;
    head = 0;
    (void) mutex_unlock(&cache_lock);

    if (p == 0)
        return;

    /* Empty the cache */
    n = p->next;
    while (p) {
        freenode(p);
        p = n;
        if (p)
            n = p->next;
    }
}

/*
 * Requests the yp server associated with a given domain to attempt to match
 * the passed key datum in the named map, and to return the associated value
 * datum. This part does parameter checking, and implements the "infinite"
 * (until success) sleep loop.
 *
 * XXX special version for handling C2 (passwd.adjunct) lookups when we need
 * a reserved port.
 * Only difference against yp_match is that this function uses
 * __yp_dobind_rsvdport().
 *
 * Only called from NIS switch backend.
 */
int
__yp_match_rsvdport_cflookup(
    char *domain,
    char *map,
    char *key,
    int  keylen,
    char **val,     /* returns value array */
    int  *vallen,       /* returns bytes in val */
    int  hardlookup)    /* retry until we can an answer */
{
    size_t domlen;
    size_t maplen;
    int reason;
    struct dom_binding *pdomb;
    int savesize;
    struct timeval now;
    struct timezone tz;
    char *my_val;
    int  my_vallen;
    int  found_it;
    int  cachegen;

    if ((map == NULL) || (domain == NULL))
        return (YPERR_BADARGS);

    domlen = strlen(domain);
    maplen = strlen(map);

    if ((domlen == 0) || (domlen > YPMAXDOMAIN) ||
        (maplen == 0) || (maplen > YPMAXMAP) ||
        (key == NULL) || (keylen == 0))
        return (YPERR_BADARGS);

    (void) mutex_lock(&cache_lock);
    found_it = in_cache(domain, map, key, keylen, &my_val, &my_vallen);
    cachegen = generation;
    if (found_it) {
        /* NB: Copy two extra bytes; see below */
        savesize = my_vallen + 2;
        if ((*val = malloc((size_t)savesize)) == 0) {
            (void) mutex_unlock(&cache_lock);
            return (YPERR_RESRC);
        }
        (void) memcpy(*val, my_val, (size_t)savesize);
        *vallen = my_vallen;
        (void) mutex_unlock(&cache_lock);
        return (0); /* Success */
    }
    (void) mutex_unlock(&cache_lock);

    for (;;) {

        if (reason = __yp_dobind_rsvdport_cflookup(domain, &pdomb,
                            hardlookup))
            return (reason);

        if (pdomb->dom_binding->ypbind_hi_vers >= YPVERS) {

            reason = domatch(domain, map, key, keylen,
                pdomb, &_ypserv_timeout, val, vallen);

            /*
             * Have to free the binding since the reserved
             * port bindings are not cached.
             */
            __yp_rel_binding(pdomb);
            free_dom_binding(pdomb);

            if (reason == YPERR_RPC || reason == YPERR_YPSERV ||
                reason == YPERR_BUSY /* as if */) {
                yp_unbind(domain);
                if (hardlookup)
                    (void) sleep(_ypsleeptime); /* retry */
                else
                    return (reason);
            } else
                break;
        } else {
            /*
             * Have to free the binding since the reserved
             * port bindings are not cached.
             */
            __yp_rel_binding(pdomb);
            free_dom_binding(pdomb);
            return (YPERR_VERS);
        }
    }

    /* add to our cache */
    if (reason == 0) {
        (void) mutex_lock(&cache_lock);
        /*
         * Check whether some other annoying thread did the same
         * thing in parallel with us.  I hate it when that happens...
         */
        if (generation != cachegen &&
            in_cache(domain, map, key, keylen, &my_val, &my_vallen)) {
            /*
             * Could get cute and update the birth time, but it's
             *   not worth the bother.
             * It looks strange that we return one val[] array
             *   to the caller and have a different copy of the
             *   val[] array in the cache (presumably with the
             *   same contents), but it should work just fine.
             * So, do absolutely nothing...
             */
            /* EMPTY */
        } else {
            struct cache    *c;
            /*
             * NB: allocate and copy extract two bytes of the
             * value;  these are mandatory CR and NULL bytes.
             */
            savesize = *vallen + 2;
            c = makenode(domain, map, keylen, savesize);
            if (c != 0) {
                (void) gettimeofday(&now, &tz);
                c->birth = now.tv_sec;
                c->keylen = keylen;
                c->vallen = *vallen;
                (void) memcpy(c->key, key, (size_t)keylen);
                (void) memcpy(c->val, *val, (size_t)savesize);

                c->next = head;
                head = c;
                ++generation;
            }
        }
        (void) mutex_unlock(&cache_lock);
    }
    return (reason);
}


int
yp_match_rsvdport(
    char *domain,
    char *map,
    char *key,
    int  keylen,
    char **val,     /* returns value array */
    int  *vallen)       /* returns bytes in val */
{
    /* traditional yp_match retries forever so set hardlookup */
    return (__yp_match_rsvdport_cflookup(domain, map, key, keylen, val,
                    vallen, 1));
}


/*
 * This talks v3 protocol to ypserv
 */
static int
domatch(char *domain, char *map, char *key, int  keylen,
    struct dom_binding *pdomb, struct timeval *timeoutp, char **val,
    int  *vallen)
{
    struct ypreq_key req;
    struct ypresp_val resp;
    unsigned int retval = 0;

    req.domain = domain;
    req.map = map;
    req.keydat.dptr = key;
    req.keydat.dsize = keylen;

    resp.valdat.dptr = NULL;
    resp.valdat.dsize = 0;
    (void) memset((char *)&resp, 0, sizeof (struct ypresp_val));

    /*
     * Do the match request.  If the rpc call failed, return with status
     * from this point.
     */

    switch (clnt_call(pdomb->dom_client, YPPROC_MATCH,
            (xdrproc_t)xdr_ypreq_key, (char *)&req,
            (xdrproc_t)xdr_ypresp_val, (char *)&resp,
            *timeoutp)) {
    case RPC_SUCCESS:
        break;
    case RPC_TIMEDOUT:
        return (YPERR_YPSERV);
    default:
        return (YPERR_RPC);
    }

    /* See if the request succeeded */

    if (resp.status != YP_TRUE) {
        retval = ypprot_err(resp.status);
    }

    /* Get some memory which the user can get rid of as he likes */

    if (!retval && ((*val = malloc((size_t)
        resp.valdat.dsize + 2)) == NULL)) {
        retval = YPERR_RESRC;
    }

    /* Copy the returned value byte string into the new memory */

    if (!retval) {
        *vallen = (int)resp.valdat.dsize;
        (void) memcpy(*val, resp.valdat.dptr,
            (size_t)resp.valdat.dsize);
        (*val)[resp.valdat.dsize] = '\n';
        (*val)[resp.valdat.dsize + 1] = '\0';
    }

    CLNT_FREERES(pdomb->dom_client,
        (xdrproc_t)xdr_ypresp_val, (char *)&resp);
    return (retval);
}