nis/common/nis_common.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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * nis_common.c
 *
 * Common code and structures used by name-service-switch "nis" backends.
 */

#include "nis_common.h"
#include <string.h>
#include <synch.h>
#include <rpcsvc/ypclnt.h>
#include <rpcsvc/yp_prot.h>
#include <thread.h>
#include <ctype.h>
#include <stdlib.h>
#include <signal.h>

#ifndef MT_UNSAFE_YP        /* Is the libnsl YP client code MT-unsafe? */
#define MT_UNSAFE_YP    0   /* No, not any longer */
#endif

#if MT_UNSAFE_YP
static mutex_t  one_lane = DEFAULTMUTEX;
#endif

/* <rpcsvc/ypclnt.h> uses (char *) where it should use (const char *) */
typedef char *grrr;

/*
 * The YP client code thinks it's being helpful by appending '\n' and '\0'
 *   to the values returned by yp_match() et al.  In order to do this it
 *   ends up doing more malloc()ing and data copying than would otherwise
 *   be necessary.  If we're interested in performance we should provide
 *   alternative library interfaces that skip the helpfulness and instead
 *   let the XDR routines dump the value directly into the buffer where
 *   we really want it.  For now, though, we just use the vanilla interface.
 */

static nss_status_t
switch_err(ypstatus, ismatch)
    int         ypstatus;
    int         ismatch;
{
    switch (ypstatus) {
    case 0:
        errno = 0;
        return (NSS_SUCCESS);

    case YPERR_BADARGS:
    case YPERR_KEY:
        errno = 0;
        return (NSS_NOTFOUND);

        /*
         *  When the YP server is running in DNS forwarding mode,
         *  the forwarder will return YPERR_NOMORE to us if it
         *  is unable to contact a server (i.e., it has timed out).
         *  The NSS_NISSERVDNS_TRYAGAIN is returned for timeout errors.
         */
    case YPERR_NOMORE:
        if (ismatch)
            return (NSS_NISSERVDNS_TRYAGAIN);
        else
            return (NSS_NOTFOUND);

    case YPERR_DOMAIN:
    case YPERR_YPSERV:
    case YPERR_BUSY:
        return (NSS_TRYAGAIN);

    default:
        return (NSS_UNAVAIL);
    }
}

/*ARGSUSED*/
nss_status_t
_nss_nis_setent(be, dummy)
    nis_backend_ptr_t   be;
    void            *dummy;
{
    if (be->enum_key != 0) {
        free(be->enum_key);
        be->enum_key = 0;
    }
    be->enum_keylen = 0;
    return (NSS_SUCCESS);
}

nss_status_t
_nss_nis_endent(be, dummy)
    nis_backend_ptr_t   be;
    void            *dummy;
{
    return (_nss_nis_setent(be, dummy));
    /* Nothing else we can clean up, is there? */
}

void
massage_netdb(const char **valp, int *vallenp)
{
    const char      *first;
    const char      *last;
    const char      *val    = *valp;
    int         vallen  = *vallenp;

    if ((last = memchr(val, '#', vallen)) == 0) {
        last = val + vallen;
    }
    for (first = val;  first < last && isspace(*first);  first++) {
        ;
    }
    for (/* cstyle */;  first < last && isspace(last[-1]);  last--) {
        ;
    }
    /*
     * Don't check for an empty line because it shouldn't ever
     *   have made it into the YP map.
     */
    *valp = first;
    *vallenp = (int)(last - first);
}

nss_status_t
_nss_nis_ypmatch(domain, map, key, valp, vallenp, ypstatusp)
    const char      *domain;
    const char      *map;
    const char      *key;
    char            **valp;
    int         *vallenp;
    int         *ypstatusp;
{
    int         ypstatus;

#if MT_UNSAFE_YP
    sigset_t        oldmask, newmask;

    (void) sigfillset(&newmask);
    (void) thr_sigsetmask(SIG_SETMASK, &newmask, &oldmask);
    (void) mutex_lock(&one_lane);
#endif
    ypstatus = __yp_match_cflookup((grrr)domain, (grrr)map,
                (grrr)key, (int)strlen(key), valp, vallenp, 0);
#if MT_UNSAFE_YP
    (void) mutex_unlock(&one_lane);
    (void) thr_sigsetmask(SIG_SETMASK, &oldmask, NULL);
#endif

    if (ypstatusp != 0) {
        *ypstatusp = ypstatus;
    }
    return (switch_err(ypstatus, 1));
}

/*
 * XXX special version of _nss_nis_ypmatch() for handling C2 (passwd.adjunct)
 * lookups when we need a reserved port.
 */

static nss_status_t
_nss_nis_ypmatch_rsvdport(domain, map, key, valp, vallenp, ypstatusp)
    const char      *domain;
    const char      *map;
    const char      *key;
    char            **valp;
    int         *vallenp;
    int         *ypstatusp;
{
    int         ypstatus;

#if MT_UNSAFE_YP
    sigset_t        oldmask, newmask;

    (void) sigfillset(&newmask);
    (void) thr_sigsetmask(SIG_SETMASK, &newmask, &oldmask);
    (void) mutex_lock(&one_lane);
#endif
    ypstatus = __yp_match_rsvdport_cflookup((grrr)domain, (grrr)map,
                (grrr)key, strlen(key), valp, vallenp, 0);
#if MT_UNSAFE_YP
    (void) mutex_unlock(&one_lane);
    (void) thr_sigsetmask(SIG_SETMASK, &oldmask, NULL);
#endif

    if (ypstatusp != 0) {
        *ypstatusp = ypstatus;
    }
    return (switch_err(ypstatus, 1));
}

nss_status_t
_nss_nis_lookup(be, args, netdb, map, key, ypstatusp)
    nis_backend_ptr_t   be;
    nss_XbyY_args_t     *args;
    int         netdb;
    const char      *map;
    const char      *key;
    int         *ypstatusp;
{
    nss_status_t        res;
    int         vallen;
    char            *val;
    char            *free_ptr;
    int         parsestat;

    if ((res = _nss_nis_ypmatch(be->domain, map, key, &val, &vallen,
                    ypstatusp)) != NSS_SUCCESS) {
        return (res);
    }

    parsestat = NSS_STR_PARSE_SUCCESS;
    if (strcmp(map, "passwd.byname") == 0 ||
        strcmp(map, "passwd.byuid") == 0) {
        parsestat = validate_passwd_ids(&val, &vallen, 1);
    } else if (strcmp(map, "group.byname") == 0)
        parsestat = validate_group_ids(&val, &vallen, 1);
    if (parsestat != NSS_STR_PARSE_SUCCESS) {
        free(val);
        return (NSS_NOTFOUND);
    }

    free_ptr = val;

    if (netdb) {
        massage_netdb((const char **)&val, &vallen);
    }

    args->returnval = NULL;
    args->returnlen = 0;
    parsestat = (*args->str2ent)(val, vallen,
            args->buf.result, args->buf.buffer, args->buf.buflen);
    if (parsestat == NSS_STR_PARSE_SUCCESS) {
        args->returnval = args->buf.result;
        args->returnlen = vallen;
        res = NSS_SUCCESS;
    } else if (parsestat == NSS_STR_PARSE_ERANGE) {
        args->erange = 1;
        /* We won't find this otherwise, anyway */
        res = NSS_NOTFOUND;
    } /* else if (parsestat == NSS_STR_PARSE_PARSE) won't happen ! */

    free(free_ptr);

    return (res);
}

nss_status_t
_nss_nis_lookup_rsvdport(be, args, netdb, map, key, ypstatusp)
    nis_backend_ptr_t   be;
    nss_XbyY_args_t     *args;
    int         netdb;
    const char      *map;
    const char      *key;
    int         *ypstatusp;
{
    nss_status_t        res;
    int         vallen;
    char            *val;
    char            *free_ptr;
    int         parsestat;

    if ((res = _nss_nis_ypmatch_rsvdport(be->domain, map, key, &val,
                    &vallen, ypstatusp)) != NSS_SUCCESS) {
        return (res);
    }

    free_ptr = val;

    if (netdb) {
        massage_netdb((const char **)&val, &vallen);
    }

    args->returnval = NULL;
    args->returnlen = 0;
    parsestat = (*args->str2ent)(val, vallen,
            args->buf.result, args->buf.buffer, args->buf.buflen);
    if (parsestat == NSS_STR_PARSE_SUCCESS) {
        args->returnval = args->buf.result;
        args->returnlen = vallen;
        res = NSS_SUCCESS;
    } else if (parsestat == NSS_STR_PARSE_ERANGE) {
        args->erange = 1;
        /* We won't find this otherwise, anyway */
        res = NSS_NOTFOUND;
    } /* else if (parsestat == NSS_STR_PARSE_PARSE) won't happen ! */

    free(free_ptr);

    return (res);
}

static nss_status_t
do_getent(be, args, netdb)
    nis_backend_ptr_t   be;
    nss_XbyY_args_t     *args;
    int         netdb;
{
    nss_status_t        res;
    int         ypstatus;
    int         outkeylen, outvallen;
    char            *outkey, *outval;
    char            *free_ptr;
    int         parsestat;

#if MT_UNSAFE_YP
    sigset_t        oldmask, newmask;

    (void) sigfillset(&newmask);
    (void) thr_sigsetmask(SIG_SETMASK, &newmask, &oldmask);
    (void) mutex_lock(&one_lane);
#endif
    if (be->enum_key == 0) {
        ypstatus = __yp_first_cflookup((grrr)be->domain,
                        (grrr)be->enum_map, &outkey,
                        &outkeylen, &outval,
                        &outvallen, 0);
    } else {
        ypstatus = __yp_next_cflookup((grrr)be->domain,
                        (grrr)be->enum_map, be->enum_key,
                        be->enum_keylen, &outkey,
                        &outkeylen, &outval,
                        &outvallen, 0);
    }
#if MT_UNSAFE_YP
    (void) mutex_unlock(&one_lane);
    (void) thr_sigsetmask(SIG_SETMASK, &oldmask, NULL);
#endif

    if ((res = switch_err(ypstatus, 0)) != NSS_SUCCESS) {
        return (res);
    }

    free_ptr = outval;

    if (netdb) {
        massage_netdb((const char **)&outval, &outvallen);
    }

    args->returnval = NULL;
    args->returnlen = 0;
    parsestat = (*args->str2ent)(outval, outvallen,
            args->buf.result, args->buf.buffer, args->buf.buflen);
    if (parsestat == NSS_STR_PARSE_SUCCESS) {
        args->returnval = args->buf.result;
        args->returnlen = outvallen;
        res = NSS_SUCCESS;
    } else if (parsestat == NSS_STR_PARSE_ERANGE) {
        args->erange = 1;
        /* We won't find this otherwise, anyway */
        res = NSS_NOTFOUND;
    } /* else if (parsestat == NSS_STR_PARSE_PARSE) won't happen ! */

    free(free_ptr);

    if (be->enum_key != 0) {
        free(be->enum_key);
    }
    be->enum_key = outkey;
    be->enum_keylen = outkeylen;

    return (res);
}

nss_status_t
_nss_nis_getent_rigid(be, args)
    nis_backend_ptr_t   be;
    void            *args;
{
    return (do_getent(be, (nss_XbyY_args_t *)args, 0));
}

nss_status_t
_nss_nis_getent_netdb(be, args)
    nis_backend_ptr_t   be;
    void            *args;
{
    return (do_getent(be, (nss_XbyY_args_t *)args, 1));
}


struct cb_data {
    void            *args;
    const char      *filter;
    nis_do_all_func_t   func;
    nss_status_t        result;
};

enum { ITER_NEXT = 0, ITER_STOP = 1 };  /* Should be in <rpcsvc/ypclnt.h> */

/*ARGSUSED*/
static int
do_cback(instatus, inkey, inkeylen, inval, invallen, indata)
    int         instatus;
    const char      *inkey;
    int         inkeylen;
    const char      *inval;
    int         invallen;
    struct cb_data      *indata;
{
    nss_status_t        res;

    if (instatus != YP_TRUE) {
        return (ITER_NEXT); /* yp_all may decide otherwise... */
    }

    if (indata->filter != 0 && strstr(inval, indata->filter) == 0) {
        /*
         * Optimization:  if the entry doesn't contain the filter
         *   string then it can't be the entry we want, so don't
         *   bother looking more closely at it.
         */
        return (ITER_NEXT);
    }

    res = (*indata->func)(inval, invallen, indata->args);

    if (res == NSS_NOTFOUND) {
        return (ITER_NEXT);
    } else {
        indata->result = res;
        return (ITER_STOP);
    }
}

nss_status_t
_nss_nis_do_all(be, args, filter, func)
    nis_backend_ptr_t   be;
    void            *args;
    const char      *filter;
    nis_do_all_func_t   func;
{
    int         ypall_status;
    struct cb_data      data;
    struct ypall_callback   cback;

    data.args   = args;
    data.filter = filter;
    data.func   = func;
    data.result = NSS_NOTFOUND;

    cback.foreach   = do_cback;
    cback.data  = (char *)&data;

#if MT_UNSAFE_YP
    sigset_t        oldmask, newmask;

    (void) sigfillset(&newmask);
    (void) thr_sigsetmask(SIG_SETMASK, &newmask, &oldmask);
    (void) mutex_lock(&one_lane);
#endif
    ypall_status = __yp_all_cflookup((grrr)be->domain,
            (grrr) be->enum_map, &cback, 0);
#if MT_UNSAFE_YP
    (void) mutex_unlock(&one_lane);
    (void) thr_sigsetmask(SIG_SETMASK, &oldmask, NULL);
#endif

    switch (ypall_status) {
        case 0:
        return (data.result);
        case YPERR_DOMAIN:
        case YPERR_YPSERV:
        case YPERR_BUSY:        /* Probably never get this, but... */
        return (NSS_TRYAGAIN);
        default:
        return (NSS_UNAVAIL);
    }
}

struct XbyY_data {
    nss_XbyY_args_t     *args;
    nis_XY_check_func   func;
    int         netdb;
};

static nss_status_t
XbyY_iterator(instr, instr_len, a)
    const char      *instr;
    int         instr_len;
    void            *a;
{
    struct XbyY_data    *xydata = (struct XbyY_data *)a;
    nss_XbyY_args_t     *args   = xydata->args;
    nss_status_t        res;
    int         parsestat;

    if (xydata->netdb) {
        massage_netdb(&instr, &instr_len);
    }

    args->returnval = NULL;
    args->returnlen = 0;
    parsestat = (*args->str2ent)(instr, instr_len,
            args->buf.result, args->buf.buffer, args->buf.buflen);
    if (parsestat == NSS_STR_PARSE_SUCCESS) {
        args->returnval = args->buf.result;
        if ((*xydata->func)(args)) {
            res = NSS_SUCCESS;
            args->returnlen = instr_len;
        } else {
            res = NSS_NOTFOUND;
            args->returnval = 0;
        }
    } else if (parsestat == NSS_STR_PARSE_ERANGE) {
        /*
         * If we got here because (*str2ent)() found that the buffer
         * wasn't big enough, maybe we should quit and return erange.
         * Instead we'll keep looking and eventually return "not
         * found" -- it's a bug, but not an earth-shattering one.
         */
        args->erange = 1;   /* <== Is this a good idea? */
        res = NSS_NOTFOUND;
    } /* else if (parsestat == NSS_STR_PARSE_PARSE) won't happen ! */

    return (res);
}

nss_status_t
_nss_nis_XY_all(be, args, netdb, filter, func)
    nis_backend_ptr_t   be;
    nss_XbyY_args_t     *args;
    int         netdb;
    const char      *filter;
    nis_XY_check_func   func;
{
    struct XbyY_data    data;

    data.args = args;
    data.func = func;
    data.netdb = netdb;

    return (_nss_nis_do_all(be, &data, filter, XbyY_iterator));
    /* Now how many levels of callbacks was that? */
}


/*ARGSUSED*/
nss_status_t
_nss_nis_destr(be, dummy)
    nis_backend_ptr_t   be;
    void            *dummy;
{
    if (be != 0) {
        /* === Should change to invoke ops[ENDENT] ? */
        (void) _nss_nis_endent(be, 0);
        free(be);
    }
    return (NSS_SUCCESS);   /* In case anyone is dumb enough to check */
}

/* We want to lock this even if the YP routines are MT-safe */
static mutex_t  yp_domain_lock = DEFAULTMUTEX;
static char *yp_domain;

const char *
_nss_nis_domain()
{
    char            *domain;

    /*
     * This much locking is probably more "by the book" than necessary...
     */
    sigset_t        oldmask, newmask;

    (void) sigfillset(&newmask);
    (void) thr_sigsetmask(SIG_SETMASK, &newmask, &oldmask);
    (void) mutex_lock(&yp_domain_lock);

    if ((domain = yp_domain) == 0) {
#if MT_UNSAFE_YP
        (void) mutex_lock(&one_lane);
#endif
        if (yp_get_default_domain(&yp_domain) == 0) {
            domain = yp_domain;
        }
#if MT_UNSAFE_YP
        (void) mutex_unlock(&one_lane);
#endif
    }

    (void) mutex_unlock(&yp_domain_lock);
    (void) thr_sigsetmask(SIG_SETMASK, &oldmask, NULL);

    return (domain);
}

nss_backend_t *
_nss_nis_constr(ops, n_ops, enum_map)
    nis_backend_op_t    ops[];
    int         n_ops;
    const char      *enum_map;
{
    const char      *domain;
    nis_backend_ptr_t   be;

    if ((domain = _nss_nis_domain()) == 0 ||
        (be = (nis_backend_ptr_t)malloc(sizeof (*be))) == 0) {
        return (0);
    }
    be->ops     = ops;
    be->n_ops   = n_ops;
    be->domain  = domain;
    be->enum_map    = enum_map;   /* Don't strdup, assume valid forever */
    be->enum_key    = 0;
    be->enum_keylen = 0;

    return ((nss_backend_t *)be);
}

/*
 * This routine is used to parse lines of the form:
 *  name number aliases
 * It returns 1 if the key in argp matches any one of the
 * names in the line, otherwise 0
 * Used by rpc
 */
int
_nss_nis_check_name_aliases(nss_XbyY_args_t *argp, const char *line,
    int linelen)
{
    const char  *limit, *linep, *keyp;

    linep = line;
    limit = line + linelen;
    keyp = argp->key.name;

    /* compare name */
    while (*keyp && linep < limit && !isspace(*linep) && *keyp == *linep) {
        keyp++;
        linep++;
    }
    if (*keyp == '\0' && linep < limit && isspace(*linep))
        return (1);
    /* skip remainder of the name, if any */
    while (linep < limit && !isspace(*linep))
        linep++;
    /* skip the delimiting spaces */
    while (linep < limit && isspace(*linep))
        linep++;
    /* compare with the aliases */
    while (linep < limit) {
        /*
         * 1st pass: skip number
         * Other passes: skip remainder of the alias name, if any
         */
        while (linep < limit && !isspace(*linep))
            linep++;
        /* skip the delimiting spaces */
        while (linep < limit && isspace(*linep))
            linep++;
        /* compare with the alias name */
        keyp = argp->key.name;
        while (*keyp && linep < limit && !isspace(*linep) &&
            *keyp == *linep) {
            keyp++;
            linep++;
        }
        if (*keyp == '\0' && (linep == limit || isspace(*linep)))
            return (1);
    }
    return (0);
}