cmd/ypcmd/yp_b_subr.c

/*
 * 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 2004 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 "ypsym.h"
#include <stdlib.h>
#include "yp_b.h"
#include <string.h>
#include <limits.h>
#include <netconfig.h>
#include <netdir.h>
#include <rpc/clnt.h>
#include <syslog.h>
#include <sys/time.h>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/statvfs.h>
#include <rpcsvc/nis.h>
#include <sys/systeminfo.h>

#ifndef NULL
#define NULL    0
#endif

#define YPSERVERS   "ypservers"

void ypbind_init_default();
static int ypbind_pipe_setdom();

static bool firsttime = TRUE;
static struct domain *known_domains;

extern struct netconfig *__rpc_getconf();
extern void *__rpc_setconf(), *__rpc_endconf();
extern CLIENT *__clnt_tp_create_bootstrap();
extern char *inet_ntoa();
extern int __rpc_get_local_uid();

extern listofnames *names();
extern void free_listofnames();

#define PINGTIME    10  /* Timeout for the ypservers list */
#define PINGTOTTIM 5    /* Total seconds for ping timeout */

static void broadcast_setup();
static void sigcld_handler();
static struct ypbind_binding *dup_ypbind_binding();
static struct netbuf *dup_netbuf();
static void free_ypbind_binding();
static void enable_exit();
static void ypbind_ping();
static struct domain *ypbind_point_to_domain();
static bool ypbind_broadcast_ack();
static int pong_servers();
void cache_binding();
void uncache_binding();

extern int setok;
extern int broadcast;
extern int cache_okay;

/*
 * Need to differentiate between RPC_UNKNOWNHOST returned by the RPC
 * library, and the same error caused by a local lookup failure in
 * /etc/hosts and/or /etc/inet/ipnodes.
 */
int hostNotKnownLocally;

/*ARGSUSED*/
void    *
ypbindproc_null_3(argp, clnt)
void    *argp;
CLIENT *clnt;
{
    static char res;

    return ((void *) & res);
}

static void
enable_exit()
{
    static bool done = FALSE;

    if (!done) {
        done = TRUE;
        sigset(SIGCHLD, (void (*)())sigcld_handler);
    }
}

int sigcld_event = 0;

static void
sigcld_handler()
{
    sigcld_event++;
#ifdef DEBUG
    fprintf(stderr, "ypbind sighandler: got SIGCLD signal (event=%d)\n",
        sigcld_event);
#endif
}


/*
 * This is a Unix SIGCHILD handler that notices when a broadcaster child
 * process has exited, and retrieves the exit status.  The broadcaster pid
 * is set to 0.  If the broadcaster succeeded, dom_report_success will be
 * be set to -1.
 */

void
broadcast_proc_exit()
{
    int pid, ret;
    siginfo_t infop;
    register struct domain *pdom;
    bool    succeeded = FALSE;

    sigcld_event = 0;
                    /* ==== Why WEXITED? */
    while ((ret = waitid(P_ALL, 0, &infop, WNOHANG | WEXITED)) != -1) {
        switch (infop.si_code) {
        case CLD_EXITED:
            succeeded = infop.si_status == 0;
            break;
        case CLD_KILLED:
        case CLD_DUMPED:
            succeeded = FALSE;
            break;
        case CLD_TRAPPED:
        case CLD_STOPPED:
        case CLD_CONTINUED:
            enable_exit();
            return;
        }
        pid = infop.si_pid;

#ifdef DEBUG
        fprintf(stderr,
            "ypbind event_handler: got wait from %d status = %d\n",
            pid, infop.si_status);
#endif

    /* to aid the progeny print the infamous "not responding" message */
        firsttime = FALSE;

        for (pdom = known_domains; pdom != (struct domain *)NULL;
                pdom = pdom->dom_pnext) {

            if (pdom->dom_broadcaster_pid == pid) {
#ifdef DEBUG
            fprintf(stderr,
            "ypbind event_handler: got match %s\n", pdom->dom_name);
#endif
                if (succeeded) {
                    broadcast_setup(pdom);
                }
                if (pdom->broadcaster_pipe != 0) {
                    xdr_destroy(&(pdom->broadcaster_xdr));
                    fclose(pdom->broadcaster_pipe);
                    pdom->broadcaster_pipe = 0;
                    pdom->broadcaster_fd = -1;
                }
                pdom->dom_broadcaster_pid = 0;

                break;
            }
        }
    }   /* while loop */
    enable_exit();
}

static void
broadcast_setup(pdom)
struct domain *pdom;
{
    ypbind_setdom req;

    memset(&req, 0, sizeof (req));
    if (pdom->broadcaster_pipe) {
        pdom->dom_report_success = -1;
        if (xdr_ypbind_setdom(&(pdom->broadcaster_xdr), &req)) {
#ifdef DEBUG
    fprintf(stderr, "parent: broadcast_setup: got xdr ok \n");
#endif
            ypbindproc_setdom_3(&req, (struct svc_req *)NULL,
                (SVCXPRT *)NULL);
            xdr_free(xdr_ypbind_setdom, (char *)&req);
            gettimeofday(&(pdom->lastping), NULL);
        }
#ifdef DEBUG
            else {
    fprintf(stderr, "ypbind parent: xdr_ypbind_setdom failed\n");
        }
#endif
    }
#ifdef DEBUG
        else {
    fprintf(stderr, "ypbind: internal error -- no broadcaster pipe\n");
    }
#endif
}

#define YPBIND_PINGHOLD_DOWN 5
/* Same as the ypbind_get_binding() routine in SunOS */
/*ARGSUSED*/
ypbind_resp *
ypbindproc_domain_3(argp, clnt)
ypbind_domain *argp;
CLIENT *clnt;
{
    static ypbind_resp resp;
    struct domain *cur_domain;
    int bpid;
    int fildes[2];

    memset((char *)&resp, 0, sizeof (resp));

#ifdef DEBUG
    fprintf(stderr, "\nypbindproc_domain_3: domain: %s\n",
        argp->ypbind_domainname);
#endif

    if ((int)strlen(argp->ypbind_domainname) > YPMAXDOMAIN) {

        resp.ypbind_status = YPBIND_FAIL_VAL;
        resp.ypbind_resp_u.ypbind_error = YPBIND_ERR_NOSERV;
        return (&resp);
    }

    if ((cur_domain = ypbind_point_to_domain(argp->ypbind_domainname)) !=
        (struct domain *)NULL) {
        if (cur_domain->dom_boundp) {

            struct timeval tp;

            (void) gettimeofday(&tp, NULL);
            if ((tp.tv_sec - cur_domain->lastping.tv_sec) >
                    YPBIND_PINGHOLD_DOWN) {
#ifdef DEBUG
    fprintf(stderr, "domain is bound pinging: %s\n",
        argp->ypbind_domainname);
#endif
                (void) ypbind_ping(cur_domain);
            }
        }

        /*
         * Bound or not, return the current state of the binding.
         */

        if (cur_domain->dom_boundp) {
#ifdef DEBUG
    fprintf(stderr, "server is up for domain: %s\n",
        argp->ypbind_domainname);
#endif
            resp.ypbind_status = YPBIND_SUCC_VAL;
            resp.ypbind_resp_u.ypbind_bindinfo =
                cur_domain->dom_binding;
        } else {
#ifdef DEBUG
    fprintf(stderr, "domain is NOT bound returning: %s %d\n",
        argp->ypbind_domainname, cur_domain->dom_error);
#endif
            resp.ypbind_status = YPBIND_FAIL_VAL;
            resp.ypbind_resp_u.ypbind_error =
                cur_domain->dom_error;
        }

    } else {
        resp.ypbind_status = YPBIND_FAIL_VAL;
        resp.ypbind_resp_u.ypbind_error = YPBIND_ERR_RESC;
    }
    /*
     * RETURN NOW: if successful, otherwise
     * RETURN LATER: after spawning off a child to do the "broadcast" work.
     */
    if (resp.ypbind_status == YPBIND_SUCC_VAL) {
#ifdef DEBUG
    fprintf(stderr, "yp_b_subr: returning success to yp_b_svc %d\n",
        resp.ypbind_status);
#endif
        return (&resp);
    }

    /* Go about the broadcast (really, pinging here) business */

    if ((cur_domain) && (!cur_domain->dom_boundp) &&
        (!cur_domain->dom_broadcaster_pid)) {
#ifdef DEBUG
    fprintf(stderr, "yp_b_subr: fork: boundp=%d broadcast_pid=%d\n",
        cur_domain->dom_boundp, cur_domain->dom_broadcaster_pid);
#endif
        /*
         * The current domain is unbound, and there is no child
         * process active now.  Fork off a child who will beg to the
         * ypservers list one by one or broadcast and accept whoever
         * commands the right domain.
         */
        if (pipe(fildes) < 0) {
#ifdef DEBUG
    fprintf(stderr, "yp_b_subr: returning pipe failure to yp_b_svc %d\n",
        resp.ypbind_status);
#endif
            return (&resp);
        }

        enable_exit();
        sighold(SIGCLD); /* add it to ypbind's signal mask */
        cur_domain->dom_report_success++;
        bpid = fork();
        if (bpid != 0) { /* parent */
            if (bpid > 0) { /* parent started */
                close(fildes[1]);
                cur_domain->dom_broadcaster_pid = bpid;
                cur_domain->broadcaster_fd = fildes[0];
                cur_domain->broadcaster_pipe =
                        fdopen(fildes[0], "r");
                if (cur_domain->broadcaster_pipe)
            xdrstdio_create(&(cur_domain->broadcaster_xdr),
            (cur_domain->broadcaster_pipe), XDR_DECODE);

#ifdef DEBUG
    fprintf(stderr, "ypbindproc_domain_3: %s starting pid = %d try = %d\n",
        cur_domain->dom_name, bpid,
        cur_domain->dom_report_success);
    fprintf(stderr, "yp_b_subr: returning after spawning, to yp_b_svc %d\n",
        resp.ypbind_status);
#endif
                sigrelse(SIGCLD);
                /* remove it from ypbind's signal mask */
                return (&resp);
            } else { /* fork failed */
                perror("fork");
                close(fildes[0]);
                close(fildes[1]);
#ifdef DEBUG
    fprintf(stderr, "yp_b_subr: returning fork failure to yp_b_svc %d\n",
        resp.ypbind_status);
#endif
                sigrelse(SIGCLD);
                return (&resp);
            }
        } /* end parent */
        /* child only code */
        sigrelse(SIGCLD);
        close(fildes[0]);
        cur_domain->broadcaster_fd = fildes[1];
        cur_domain->broadcaster_pipe = fdopen(fildes[1], "w");
        if (cur_domain->broadcaster_pipe)
            xdrstdio_create(&(cur_domain->broadcaster_xdr),
                (cur_domain->broadcaster_pipe), XDR_ENCODE);
        else {
            perror("fdopen-pipe");
            exit(-1);
        }
        exit(pong_servers(cur_domain));
    }
#ifdef DEBUG
    fprintf(stderr, "yp_b_subr: lazy returns failure status yp_b_svc %d\n",
            resp.ypbind_status);
#endif
    return (&resp);
}


/*
 * call ypbindproc_domain_3 and convert results
 *
 * This adds support for YP clients that send requests on
 * ypbind version 1 & 2 (i.e. clients before we started
 * using universal addresses and netbufs). This is supported
 * for binary compatibility for static 4.x programs. The
 * assumption used to be that clients coming in with ypbind vers 1
 * should be given the address of a server serving ypserv version 1.
 * However, since yp_bind routines in 4.x YP library try
 * to connect with ypserv version 2, even if they requested
 * binding using ypbind version 1, the ypbind process will
 * "always" look for only ypserv version 2 servers for all
 * (ypbind vers 1, 2, & 3) clients.
 */
ypbind_resp_2 *
ypbindproc_domain_2(argp, clnt)
domainname_2 *argp;
CLIENT *clnt;
{
    ypbind_domain arg_3;
    ypbind_resp *resp_3;
    static ypbind_resp_2 resp;

    arg_3.ypbind_domainname = *argp;
    resp_3 = ypbindproc_domain_3(&arg_3, clnt);
    if (resp_3 == NULL)
        return (NULL);
    resp.ypbind_status = resp_3->ypbind_status;
    if (resp_3->ypbind_status == YPBIND_SUCC_VAL) {
        struct sockaddr_in *sin;
        struct ypbind_binding_2 *bi;

        sin = (struct sockaddr_in *)
            resp_3->ypbind_resp_u.ypbind_bindinfo->ypbind_svcaddr->buf;
        if (sin->sin_family == AF_INET) {
            bi = &resp.ypbind_respbody_2.ypbind_bindinfo;
            memcpy(&(bi->ypbind_binding_port), &sin->sin_port, 2);
            memcpy(&(bi->ypbind_binding_addr), &sin->sin_addr, 4);
        } else {
            resp.ypbind_respbody_2.ypbind_error = YPBIND_ERR_NOSERV;
        }
    } else {
        resp.ypbind_respbody_2.ypbind_error =
            resp_3->ypbind_resp_u.ypbind_error;
    }
    return (&resp);
}

/* used to exchange information between pong_servers and ypbind_broadcast_ack */
struct domain *process_current_domain;

int
pong_servers(domain_struct)
struct domain *domain_struct; /* to pass back */
{
    char *domain = domain_struct->dom_name;
    CLIENT *clnt2;
    char *servername;
    listofnames *list, *lin;
    char serverfile[MAXNAMLEN];
    struct timeval timeout;
    int isok = 0, res = -1;
    struct netconfig *nconf;
    void *handle;
    int nconf_count;
    char rpcdomain[YPMAXDOMAIN+1];
    long inforet;

    /*
     * If the ``domain'' name passed in is not the same as the RPC
     * domain set from /etc/defaultdomain.  Then we set ``firsttime''
     * to TRUE so no error messages are ever syslog()-ed this
     * prevents a possible Denial of Service attack.
     */
    inforet = sysinfo(SI_SRPC_DOMAIN, &(rpcdomain[0]), YPMAXDOMAIN);
    if ((inforet > 0) && (strcmp(domain, rpcdomain) != 0))
        firsttime = TRUE;

    if (broadcast) {
        enum clnt_stat stat = RPC_SUCCESS;
#ifdef DEBUG
    fprintf(stderr, "pong_servers: doing an rpc_broadcast\n");
#endif
        /*
         * Here we do the real SunOS thing that users love. Do a
         * broadcast on the network and find out the ypserv. No need
         * to do "ypinit -c", no setting up /etc/hosts file, and no
         * recursion looking up the server's IP address.
         */
        process_current_domain = domain_struct;
        stat = rpc_broadcast(YPPROG, YPVERS, YPPROC_DOMAIN_NONACK,
            (xdrproc_t)xdr_ypdomain_wrap_string, (caddr_t)&domain,
            xdr_int,  (caddr_t)&isok,
            (resultproc_t)ypbind_broadcast_ack, "udp");
        if (stat == RPC_SYSTEMERROR || stat == RPC_UNKNOWNPROTO ||
            stat == RPC_CANTRECV || stat == RPC_CANTSEND ||
            stat == RPC_NOBROADCAST ||
            stat == RPC_N2AXLATEFAILURE) {
            syslog(LOG_ERR, "RPC/Transport subsystem failure %s\n",
                clnt_sperrno(stat));
            exit(-1);
        }
        if (domain_struct->broadcaster_pipe == 0)
            /* init binding case */
            return (domain_struct->dom_boundp - 1);
        if (domain_struct->dom_boundp) {
            res = ypbind_pipe_setdom(NULL, domain,
                    NULL, domain_struct);
            if (domain_struct->dom_report_success > 0)
                syslog(LOG_ERR,
            "NIS server for domain \"%s\" OK", domain);
        } else if (firsttime == FALSE)
            syslog(LOG_ERR,
    "NIS server not responding for domain \"%s\"; still trying", domain);
        return (res);
    }
#ifdef DEBUG
    fprintf(stderr, "pong_servers: ponging servers one by one\n");
#endif
    /*
     * Do the politically correct thing.. transport independent and
     * secure (trusts only listed servers).
     */

    /*
     * get list of possible servers for this domain
     */

    /*
     * get alias for domain: Things of the past..
     * sysvconfig();
     * (void) yp_getalias(domain, domain_alias, NAME_MAX);
     */
    sprintf(serverfile, "%s/%s/%s", BINDING, domain, YPSERVERS);
#ifdef DEBUG
    fprintf(stderr, "pong_servers: serverfile %s\n", serverfile);
#endif
    list = names(serverfile);
    if (list == NULL) {
        if (firsttime == FALSE)
            syslog(LOG_ERR,
            "service not installed, use /usr/sbin/ypinit -c");
        return (-1);
    }
    lin = list;
    for (list = lin; list; list = list->nextname) {
        servername = strtok(list->name, " \t\n");
        if (servername == NULL) continue;

        /* Check all datagram_v transports for this server */
        if ((handle = __rpc_setconf("datagram_v")) == NULL) {
            syslog(LOG_ERR,
            "ypbind: RPC operation on /etc/netconfig failed");
            free_listofnames(lin);
            return (-1);
        }

        nconf_count = 0;
        clnt2 = 0;
        while (clnt2 == 0 && (nconf = __rpc_getconf(handle)) != 0) {
            nconf_count++;
            /*
             * We use only datagram here. It is expected to be udp.
             * VERY IMPORTANT: __clnt_tp_create_bootstrap is a
             * hacked up version that does not do netdir_getbyname.
             */
            hostNotKnownLocally = 0;
            clnt2 =
    __clnt_tp_create_bootstrap(servername, YPPROG, YPVERS, nconf);
        }
        if (nconf_count == 0) {
            syslog(LOG_ERR,
            "ypbind: RPC operation on /etc/netconfig failed");
            free_listofnames(lin);
            return (-1);
        }

        if (clnt2 == 0) {
            if (rpc_createerr.cf_stat == RPC_UNKNOWNHOST &&
                hostNotKnownLocally) {
                syslog(LOG_ERR,
        "NIS server %s is not in local host files !", servername);
            }
            perror(servername);
            clnt_pcreateerror("ypbind");
            continue;
        }

        timeout.tv_sec = PINGTIME;
        timeout.tv_usec = 0;
        if ((enum clnt_stat) clnt_call(clnt2,
            YPPROC_DOMAIN, (xdrproc_t)xdr_ypdomain_wrap_string,
            (char *)&domain, xdr_int,
            (char *)&isok, timeout) == RPC_SUCCESS) {
            if (isok) {
                if (domain_struct->dom_report_success > 0) {
                    syslog(LOG_ERR,
                "NIS server for domain \"%s\" OK", domain);
                }
                if (domain_struct->broadcaster_pipe == 0) {
                    /* init binding case --parent */
                    struct netconfig *setnc;
                    struct netbuf setua;
                    struct ypbind_binding *b =
                        domain_struct->dom_binding;

                    setnc =
                getnetconfigent(clnt2->cl_netid);
                    if (b == NULL) {
                    /* ASSERT: This shouldn't happen ! */
                        b =
                (struct ypbind_binding *)calloc(1, sizeof (*b));
                        domain_struct->dom_binding = b;
                        if (b == NULL) {
                            __rpc_endconf(handle);
                            clnt_destroy(clnt2);
                            free_listofnames(lin);
                            return (-2);
                        }
                    }


                    b->ypbind_nconf = setnc;
                    clnt_control(clnt2, CLGET_SVC_ADDR,
                        (char *)&setua);
                    if (b->ypbind_svcaddr) {
                        if (b->ypbind_svcaddr->buf)
                free(b->ypbind_svcaddr->buf);
                        free(b->ypbind_svcaddr);
                    }
                    b->ypbind_svcaddr = dup_netbuf(&setua);
                    if (b->ypbind_servername)
                        free(b->ypbind_servername);
                    b->ypbind_servername =
                        strdup(servername);
                    b->ypbind_hi_vers = YPVERS;
                    b->ypbind_lo_vers = YPVERS;
                    __rpc_endconf(handle);
                    domain_struct->dom_boundp = TRUE;
                    clnt_destroy(clnt2);
                    free_listofnames(lin);
                    return (0);
                }
                res = ypbind_pipe_setdom(clnt2, domain,
                    servername, domain_struct);
                __rpc_endconf(handle);
                clnt_destroy(clnt2);
                free_listofnames(lin);
                return (res);
            } else {
                syslog(LOG_ERR,
                    "server %s doesn't serve domain %s\n",
                    servername, domain);
            }
        } else {
            clnt_perror(clnt2, servername);
        }
        clnt_destroy(clnt2);
    }
    /*
     * We tried all servers, none obliged !
     * After ypbind is started up it will not be bound
     * immediately.  This is normal, no error message
     * is needed. Although, with the ypbind_init_default
     * it will be bound immediately.
     */
    if (firsttime == FALSE) {
        syslog(LOG_ERR,
"NIS server not responding for domain \"%s\"; still trying", domain);
    }
    free_listofnames(lin);
    __rpc_endconf(handle);
    return (-2);
}

struct netbuf *
dup_netbuf(inbuf)
    struct netbuf *inbuf;
{
    struct netbuf *outbuf;

    if (inbuf == NULL)
        return (NULL);
    if ((outbuf =
        (struct netbuf *)calloc(1, sizeof (struct netbuf))) == NULL)
        return (NULL);
    if ((outbuf->buf = malloc(inbuf->len)) == NULL) {
        free(outbuf);
        return (NULL);
    }
    outbuf->len = inbuf->len;
    outbuf->maxlen = inbuf->len;
    (void) memcpy(outbuf->buf, inbuf->buf, inbuf->len);
    return (outbuf);
}

/*
 * This is called by the broadcast rpc routines to process the responses
 * coming back from the broadcast request. Since the form of the request
 * which is used in ypbind_broadcast_bind is "respond only in the positive
 * case", we know that we have a server.
 * The internet address of the responding server will be picked up from
 * the saddr parameter, and stuffed into the domain.  The domain's boundp
 * field will be set TRUE.  The first responding server (or the first one
 * which is on a reserved port) will be the bound server for the domain.
 */
bool
ypbind_broadcast_ack(ptrue, nbuf, nconf)
    bool *ptrue;
    struct netbuf *nbuf;
    struct netconfig *nconf;
{
    struct ypbind_binding b;

    process_current_domain->dom_boundp = TRUE;
    b.ypbind_nconf = nconf;
    b.ypbind_svcaddr = nbuf;
    b.ypbind_servername = "\000";
    b.ypbind_hi_vers = YPVERS;
    b.ypbind_lo_vers = YPVERS;
    free_ypbind_binding(process_current_domain->dom_binding);
    process_current_domain->dom_binding = dup_ypbind_binding(&b);
    return (TRUE);
}

/*
 * WARNING: This routine is entered only by the child process.
 * Called if it pongs/broadcasts okay.
 */
static int
ypbind_pipe_setdom(client, domain, servername, opaque_domain)
CLIENT *client;
char *servername;
char *domain;
struct domain *opaque_domain;
{
    struct netconfig *setnc;
    struct netbuf setua;
    ypbind_binding setb;
    ypbind_setdom setd;
    int retval;

    setd.ypsetdom_domain = domain;
    if (client == NULL && opaque_domain->dom_binding) {
#ifdef DEBUG
    fprintf(stderr, "ypbind_pipe_setdom: child broadcast case ");
#endif
        /* ypbind_broadcast_ack already setup dom_binding for us */
        setd.ypsetdom_bindinfo = opaque_domain->dom_binding;
    } else if (client) {
#ifdef DEBUG
    fprintf(stderr, "ypbind_pipe_setdom: child unicast case ");
#endif
        setnc = getnetconfigent(client->cl_netid);
        if (setnc == NULL) {
#ifdef DEBUG
    fprintf(stderr, "PANIC: shouldn't happen\n");
#endif
            fclose(opaque_domain->broadcaster_pipe);
            close(opaque_domain->broadcaster_fd);
            return (-2);
        }
        clnt_control(client, CLGET_SVC_ADDR, (char *)&setua);
        setb.ypbind_nconf = setnc;
        setb.ypbind_svcaddr = &setua;
        setb.ypbind_servername = servername;
        setb.ypbind_hi_vers = YPVERS;
        setb.ypbind_lo_vers = YPVERS;
        setd.ypsetdom_bindinfo = &setb;
    /*
     * Let's hardcode versions, that is the only ypserv we support anyway.
     * Avoid the song and dance of recursively calling ypbind_ping
     * for no reason. Consistent with the 4.1 policy, that if ypbind gets
     * a request on new binder protocol, the requestor is looking for the
     * new ypserv. And, we have even higher binder protocol version i.e. 3.
     */
    } else
        return (-1);
#ifdef DEBUG
    fprintf(stderr,
        " saving server settings, \nsupports versions %d thru %d\n",
        setd.ypsetdom_bindinfo->ypbind_lo_vers,
        setd.ypsetdom_bindinfo->ypbind_hi_vers);
#endif

    if (opaque_domain->broadcaster_pipe == 0) {
#ifdef DEBUG
    fprintf(stderr, "PANIC: shouldn't be in this function\n");
#endif
        return (-2);
    }
#ifdef DEBUG
    fprintf(stderr, "child: doing xdr_ypbind_setdom\n");
#endif
    retval = xdr_ypbind_setdom(&(opaque_domain->broadcaster_xdr), &setd);
    xdr_destroy(&(opaque_domain->broadcaster_xdr));
    fclose(opaque_domain->broadcaster_pipe);
    close(opaque_domain->broadcaster_fd);
    /*
     * This child process is about to exit. Don't bother freeing memory.
     */
    if (!retval) {
#ifdef DEBUG
    fprintf(stderr,
        "YPBIND pipe_setdom failed \n(xdr failure) to server %s\n",
        servername ? servername : "");
#endif
        return (-3);
    }
#ifdef DEBUG
    fprintf(stderr, "ypbind_pipe_setdom: YPBIND OK-set to server %s\n",
        servername ? servername : "");
#endif
    return (0);
}

/* Same as ypbind_set_binding in SunOS */
/*
 *  We use a trick from SunOS to return an error to the ypset command
 *  when we are not allowing the domain to be set.  We do a svcerr_noprog()
 *  to send RPC_PROGUNAVAIL to ypset.  We also return NULL so that
 *  our caller (ypbindprog_3) won't try to return a result.  This
 *  hack is necessary because the YPBINDPROC_SETDOM procedure is defined
 *  in the protocol to return xdr_void, so we don't have a direct way to
 *  return an error to the client.
 */
/*ARGSUSED*/
void    *
ypbindproc_setdom_3(argp, rqstp, transp)
ypbind_setdom *argp;
struct svc_req *rqstp;
SVCXPRT *transp;
{
    struct domain *a_domain;
    struct netbuf *who;
    static char res; /* dummy for void * return */
    uid_t caller_uid;

    if ((int)strlen(argp->ypsetdom_domain) > YPMAXDOMAIN) {

        if (transp) {
            svcerr_systemerr(transp);
            return (0);
        }
        return (&res);
    }

    if (transp != NULL) {
        /* find out who originated the request */
        char *uaddr;
        struct netconfig *nconf;

        who = svc_getrpccaller(transp);
        if ((nconf = getnetconfigent(transp->xp_netid))
            == (struct netconfig *)NULL) {
            svcerr_systemerr(transp);
            return (0);
        }
        if (strcmp(nconf->nc_protofmly, NC_LOOPBACK) == 0) {
            uaddr = strdup("local host");
        } else {
            uaddr = taddr2uaddr(nconf, who);
        }
        if (setok != YPSETALL) {
        /* for -ypset, it falls through and let anybody do a setdom ! */
            if (strcmp(nconf->nc_protofmly, NC_LOOPBACK) != 0) {
                syslog(LOG_ERR,
"ypset request from %s not on loopback, \
cannot set ypbind to %s", uaddr ? uaddr : "unknown source",
argp->ypsetdom_bindinfo->ypbind_servername);
                if (uaddr)
                    free(uaddr);
                freenetconfigent(nconf);
                svcerr_noprog(transp);
                return (0);
            }
            switch (setok) {
            case YPSETNONE:
                if (strcmp(nconf->nc_protofmly,
                    NC_LOOPBACK) == 0)
                    syslog(LOG_ERR,
"ypset request to %s from %s failed - ypset not allowed",
argp->ypsetdom_bindinfo->ypbind_servername, uaddr);
                if (uaddr)
                    free(uaddr);
                freenetconfigent(nconf);
                svcerr_noprog(transp);
                return (0);
            case YPSETLOCAL:
                if (__rpc_get_local_uid(transp,
                    &caller_uid) < 0) {
                    syslog(LOG_ERR, "ypset request from \
unidentified local user on %s - ypset not allowed",
transp->xp_netid);
                    if (uaddr)
                        free(uaddr);
                    freenetconfigent(nconf);
                    svcerr_noprog(transp);
                    return (0);
                }
                if (caller_uid != 0) {
                    syslog(LOG_ERR,
"Set domain request to host %s \
from local non-root user %ld failed - ypset not allowed",
argp->ypsetdom_bindinfo->ypbind_servername, caller_uid);
                    if (uaddr)
                        free(uaddr);
                    freenetconfigent(nconf);
                    svcerr_noprog(transp);
                    return (0);
                }
            }
        }
        syslog(LOG_ERR, "Set domain request from %s : \
setting server for domain %s to %s", uaddr ? uaddr : "UNKNOWN SOURCE",
argp->ypsetdom_domain, argp->ypsetdom_bindinfo->ypbind_servername);
        if (uaddr)
            free(uaddr);
        freenetconfigent(nconf);
    }

    if ((a_domain = ypbind_point_to_domain(argp->ypsetdom_domain))
        != (struct domain *)NULL) {
        /* setting binding; old may be invalid */
        uncache_binding(a_domain);

        /* this does the set -- should copy the structure */
        free_ypbind_binding(a_domain->dom_binding);
        if ((a_domain->dom_binding =
            dup_ypbind_binding(argp->ypsetdom_bindinfo)) == NULL) {
            syslog(LOG_ERR, "ypbindproc_setdom_3: out of memory, ",
                "dup_ypbind_binding failed\n");
            if (transp) {
                svcerr_noprog(transp);
                return (0);
            }
            return (&res);
        }
        gettimeofday(&(a_domain->lastping), NULL);
        a_domain->dom_boundp = TRUE;
        cache_binding(a_domain);
#ifdef DEBUG
    fprintf(stderr, "ypbindproc_setdom_3: setting domain %s to server %s\n",
        argp->ypsetdom_domain,
        argp->ypsetdom_bindinfo->ypbind_servername);
#endif
    }

    return (&res);
}

/*
 * This returns a pointer to a domain entry.  If no such domain existed on
 * the list previously, an entry will be allocated, initialized, and linked
 * to the list.  Note:  If no memory can be malloc-ed for the domain structure,
 * the functional value will be (struct domain *) NULL.
 */
static struct domain *
ypbind_point_to_domain(pname)
register char   *pname;
{
    register struct domain *pdom;
    char buf[300];

    for (pdom = known_domains; pdom != (struct domain *)NULL;
        pdom = pdom->dom_pnext) {
        if (strcmp(pname, pdom->dom_name) == 0)
            return (pdom);
    }

    /* Not found.  Add it to the list */

    if (pdom = (struct domain *)calloc(1, sizeof (struct domain))) {
        pdom->dom_name = strdup(pname);
        if (pdom->dom_name == NULL) {
            free((char *)pdom);
            syslog(LOG_ERR,
                "ypbind_point_to_domain: strdup failed\n");
            return (NULL);
        }
        pdom->dom_pnext = known_domains;
        known_domains = pdom;
        pdom->dom_boundp = FALSE;
        pdom->dom_vers = YPVERS; /* This doesn't talk to old ypserv */
        pdom->dom_binding = NULL;
        pdom->dom_error = YPBIND_ERR_NOSERV;
        pdom->ping_clnt = (CLIENT *)NULL;
        pdom->dom_report_success = -1;
        pdom->dom_broadcaster_pid = 0;
        pdom->broadcaster_pipe = 0;
        pdom->bindfile = -1;
        pdom->lastping.tv_sec = 0;
        pdom->lastping.tv_usec = 0; /* require ping */
        pdom->cache_fp = 0;
        sprintf(buf, "%s/%s/cache_binding", BINDING, pdom->dom_name);
        pdom->cache_file = strdup(buf);
        /*
         *  We don't give an error if pdom->cache_file is not set.
         *  If we got null (out of memory), then we just won't use
         *  the cache file in cache_binding() (assuming the
         *  application gets that far.
         */
    }
    else
        syslog(LOG_ERR, "ypbind_point_to_domain: malloc failed\n");

    return (pdom);
}

static void
ypbind_ping(pdom)
struct domain *pdom;
{
    struct timeval timeout;
    int vers;
    int isok;

    if (pdom->dom_boundp == FALSE)
        return;
    vers = pdom->dom_vers;

    if (pdom->ping_clnt == (CLIENT *) NULL) {
        pdom->ping_clnt = __nis_clnt_create(RPC_ANYFD,
                    pdom->dom_binding->ypbind_nconf, 0,
                    pdom->dom_binding->ypbind_svcaddr, 0,
                    YPPROG, vers, 0, 0);
    }

    if (pdom->ping_clnt == (CLIENT *) NULL) {
        perror("clnt_tli_create");
        clnt_pcreateerror("ypbind_ping()");
        pdom->dom_boundp = FALSE;
        pdom->dom_error = YPBIND_ERR_NOSERV;
        return;
    }


#ifdef DEBUG
    fprintf(stderr, "ypbind: ypbind_ping()\n");
#endif
    timeout.tv_sec = PINGTOTTIM;
    timeout.tv_usec =  0;
    if (clnt_call(pdom->ping_clnt,
        YPPROC_DOMAIN, (xdrproc_t)xdr_ypdomain_wrap_string,
        (char *)&pdom->dom_name, xdr_int, (char *)&isok,
        timeout) == RPC_SUCCESS) {
            pdom->dom_boundp = isok;
            pdom->dom_binding->ypbind_lo_vers = vers;
            pdom->dom_binding->ypbind_hi_vers = vers;
#ifdef DEBUG
    fprintf(stderr,
        "Server pinged successfully, supports versions %d thru %d\n",
        pdom->dom_binding->ypbind_lo_vers,
        pdom->dom_binding->ypbind_hi_vers);
#endif
    } else {
        clnt_perror(pdom->ping_clnt, "ping");
        pdom->dom_boundp = FALSE;
        pdom->dom_error = YPBIND_ERR_NOSERV;
    }
    (void) gettimeofday(&(pdom->lastping), NULL);
    if (pdom->ping_clnt)
        clnt_destroy(pdom->ping_clnt);
    pdom->ping_clnt = (CLIENT *)NULL;
    if (pdom->dom_boundp)
        cache_binding(pdom);
}

static struct ypbind_binding *
dup_ypbind_binding(a)
struct ypbind_binding *a;
{
    struct ypbind_binding *b;
    struct netconfig *nca, *ncb;
    struct netbuf *nxa, *nxb;
    int i;

    b = (struct ypbind_binding *)calloc(1, sizeof (*b));
    if (b == NULL)
        return (b);
    b->ypbind_hi_vers = a->ypbind_hi_vers;
    b->ypbind_lo_vers = a->ypbind_lo_vers;
    b->ypbind_servername =
        a->ypbind_servername ? strdup(a->ypbind_servername) : NULL;
    ncb = (b->ypbind_nconf =
        (struct netconfig *)calloc(1, sizeof (struct netconfig)));
    nxb = (b->ypbind_svcaddr =
        (struct netbuf *)calloc(1, sizeof (struct netbuf)));
    nca = a->ypbind_nconf;
    nxa = a->ypbind_svcaddr;
    ncb->nc_flag = nca->nc_flag;
    ncb->nc_protofmly =
        nca->nc_protofmly ? strdup(nca->nc_protofmly) : NULL;
    ncb->nc_proto =
        nca->nc_proto ? strdup(nca->nc_proto) : NULL;
    ncb->nc_semantics = nca->nc_semantics;
    ncb->nc_netid =
        nca->nc_netid ? strdup(nca->nc_netid) : NULL;
    ncb->nc_device =
        nca->nc_device ? strdup(nca->nc_device) : NULL;
    ncb->nc_nlookups = nca->nc_nlookups;
    ncb->nc_lookups = (char **)calloc(nca->nc_nlookups, sizeof (char *));
    if (ncb->nc_lookups == NULL) {
        if (ncb->nc_device)
            free(ncb->nc_device);
        if (ncb->nc_netid)
            free(ncb->nc_netid);
        if (ncb->nc_proto)
            free(ncb->nc_proto);
        if (ncb->nc_protofmly)
            free(ncb->nc_protofmly);
        if (nxb)
            free(nxb);
        if (ncb)
            free(ncb);
        if (b->ypbind_servername)
            free(b->ypbind_servername);
        if (b)
            free(b);
        return (NULL);
    }
    for (i = 0; i < nca->nc_nlookups; i++)
        ncb->nc_lookups[i] =
            nca->nc_lookups[i] ? strdup(nca->nc_lookups[i]) : NULL;
    for (i = 0; i < 8; i++)
        ncb->nc_unused[i] = nca->nc_unused[i];
    nxb->maxlen = nxa->maxlen;
    nxb->len = nxa->len;
    nxb->buf = malloc(nxa->maxlen);
    if (nxb->buf == NULL) {
        for (i = 0; i < nca->nc_nlookups; i++)
            if (ncb->nc_lookups[i])
                free(ncb->nc_lookups[i]);
        free(ncb->nc_lookups);
        if (ncb->nc_device)
            free(ncb->nc_device);
        if (ncb->nc_netid)
            free(ncb->nc_netid);
        if (ncb->nc_proto)
            free(ncb->nc_proto);
        if (ncb->nc_protofmly)
            free(ncb->nc_protofmly);
        if (nxb)
            free(nxb);
        if (ncb)
            free(ncb);
        if (b->ypbind_servername)
            free(b->ypbind_servername);
        if (b)
            free(b);
        return (NULL);
    }
    memcpy(nxb->buf, nxa->buf, nxb->len);
    return (b);
}

static void
free_ypbind_binding(b)
struct ypbind_binding *b;
{
    if (b == NULL)
        return;
    netdir_free((char *)b->ypbind_svcaddr, ND_ADDR);
    free(b->ypbind_servername);
    freenetconfigent(b->ypbind_nconf);
    free(b);
}

/*
 * Preloads teh default domain's domain binding. Domain binding for the
 * local node's default domain for ypserv version 2 (YPVERS) will be
 * set up. This may make it a little slower to start ypbind during
 * boot time, but would make it easy on other domains that rely on
 * this binding.
 */
void
ypbind_init_default()
{
    char domain[256];
    struct domain *cur_domain;

    if (getdomainname(domain, 256) == 0) {
        cur_domain = ypbind_point_to_domain(domain);

        if (cur_domain == (struct domain *)NULL) {
            abort();
        }
        (void) pong_servers(cur_domain);
    }
}

bool_t
xdr_ypbind_binding_2(xdrs, objp)
    register XDR *xdrs;
    ypbind_binding_2 *objp;
{
    if (!xdr_opaque(xdrs, (char *)&(objp->ypbind_binding_addr), 4))
        return (FALSE);
    if (!xdr_opaque(xdrs, (char *)&(objp->ypbind_binding_port), 2))
        return (FALSE);
    return (TRUE);
}

bool_t
xdr_ypbind_resp_2(xdrs, objp)
    register XDR *xdrs;
    ypbind_resp_2 *objp;
{
    if (!xdr_ypbind_resptype(xdrs, &objp->ypbind_status))
        return (FALSE);
    switch (objp->ypbind_status) {
    case YPBIND_FAIL_VAL:
        if (!xdr_u_long(xdrs, &objp->ypbind_respbody_2.ypbind_error))
            return (FALSE);
        break;
    case YPBIND_SUCC_VAL:
        if (!xdr_ypbind_binding_2(xdrs,
            &objp->ypbind_respbody_2.ypbind_bindinfo))
            return (FALSE);
        break;
    default:
        return (FALSE);
    }
    return (TRUE);
}

/*
 *  The following is some caching code to improve the performance of
 *  yp clients.  In the days of yore, a client would talk to rpcbind
 *  to get the address for ypbind, then talk to ypbind to get the
 *  address of the server.  If a lot of clients are doing this at
 *  the same time, then rpcbind and ypbind get bogged down and clients
 *  start to time out.
 *
 *  We cache two things:  the current address for ypserv, and the
 *  transport addresses for talking to ypbind.  These are saved in
 *  files in /var/yp.  To get the address of ypserv, the client opens
 *  a file and reads the address.  It does not have to talk to rpcbind
 *  or ypbind.  If this file is not available, then it can read the
 *  the transport address for talking to ypbind without bothering
 *  rpcbind.  If this also fails, then it uses the old method of
 *  talking to rpcbind and then ypbind.
 *
 *  We lock the first byte of the cache files after writing to them.
 *  This indicates to the client that they contents are valid.  The
 *  client should test the lock.  If the lock is held, then it can
 *  use the contents.  If the lock test fails, then the contents should
 *  be ignored.
 */

/*
 *  Cache new binding information for a domain in a file.  If the
 *  new binding is the same as the old, then we skip it.  We xdr
 *  a 'ypbind_resp', which is what would be returned by a call to
 *  the YBINDPROCP_DOMAIN service.  We xdr the data because it is
 *  easier than writing the data out field by field.  It would be
 *  nice if there were an xdrfd_create() that was similar to
 *  xdrstdio_create().  Instead, we do an fdopen and use xdrstdio_create().
 */
void
cache_binding(pdom)
    struct domain *pdom;
{
    int st;
    int fd;
    XDR xdrs;
    struct ypbind_resp resp;

    if (!cache_okay)
        return;

    /* if the domain doesn't have a cache file, then skip it */
    if (pdom->cache_file == 0)
        return;

    /*
     *  If we already had a cache file for this domain, remove it.  If
     *  a client just started accessing it, then it will either find
     *  it unlocked (and not use it), or continue to use it with
     *  old information.  This is not a problem, the client will
     *  either fail to talk to ypserv and try to bind again, or
     *  will continue to use the old server.
     */
    if (pdom->cache_fp) {
        fclose(pdom->cache_fp);    /* automatically unlocks */
        unlink(pdom->cache_file);
        pdom->cache_fp = 0;
    }

    fd = open(pdom->cache_file, O_CREAT|O_WRONLY, 0444);
    if (fd == -1)
        return;

    pdom->cache_fp = fdopen(fd, "w");
    if (pdom->cache_fp == 0) {
        close(fd);
        return;
    }

    xdrstdio_create(&xdrs, pdom->cache_fp, XDR_ENCODE);
    resp.ypbind_status = YPBIND_SUCC_VAL;
    resp.ypbind_resp_u.ypbind_bindinfo = pdom->dom_binding;

    if (!xdr_ypbind_resp(&xdrs, &resp)) {
        xdr_destroy(&xdrs);
        unlink(pdom->cache_file);
        fclose(pdom->cache_fp);
        pdom->cache_fp = 0;
        return;
    }
    xdr_destroy(&xdrs);    /* flushes xdr but leaves fp open */

    /* we lock the first byte to indicate that the file is valid */
    lseek(fd, 0L, SEEK_SET);
    st = lockf(fd, F_LOCK, 1);
    if (st == -1) {
        unlink(pdom->cache_file);
        fclose(pdom->cache_fp);
        pdom->cache_fp = 0;
    }
}

void
uncache_binding(pdom)
    struct domain *pdom;
{
    if (!cache_okay)
        return;

    if (pdom->cache_fp != 0) {
        unlink(pdom->cache_file);
        fclose(pdom->cache_fp);
        pdom->cache_fp = 0;
    }
}

/*
 *  Cache a transport address for talking to ypbind.  We convert the
 *  transport address to a universal address and save that in a file.
 *  The file lives in the binding directory because it does not depend
 *  on the domain.
 */
void
cache_transport(nconf, xprt, vers)
    struct netconfig *nconf;
    SVCXPRT *xprt;
    int vers;
{
    char filename[300];
    char *uaddr;
    int fd;
    int st;
    int len;

    if (!cache_okay)
        return;

    sprintf(filename, "%s/xprt.%s.%d",
        BINDING, nconf->nc_netid, vers);

    unlink(filename);    /* remove any old version */

    uaddr = taddr2uaddr(nconf, &xprt->xp_ltaddr);
    if (uaddr == 0)
        return;

    fd = open(filename, O_CREAT|O_WRONLY, 0444);    /* readable by all */
    if (fd == -1) {
        free(uaddr);
        return;
    }

    len = strlen(uaddr) + 1;    /* include terminating null */
    st = write(fd, uaddr, len);
    if (st != len) {
        close(fd);
        unlink(filename);
        free(uaddr);
        return;
    }

    free(uaddr);

    /* we lock the first byte to indicate that the file is valid */
    lseek(fd, 0L, SEEK_SET);
    st = lockf(fd, F_LOCK, 1);
    if (st == -1) {
        close(fd);
        unlink(filename);
    }
}

/*
 *  Create a file that clients can check to see if we are running.
 */
void
cache_pid()
{
    char filename[300];
    char spid[15];
    int fd;
    int st;
    int len;

    if (!cache_okay)
        return;

    sprintf(filename, "%s/ypbind.pid", BINDING);

    unlink(filename);    /* remove any old version */

    fd = open(filename, O_CREAT|O_WRONLY, 0444);    /* readable by all */
    if (fd == -1) {
        return;
    }

    sprintf(spid, "%d\n", getpid());

    len = strlen(spid);
    st = write(fd, spid, len);
    if (st != len) {
        close(fd);
        unlink(filename);
        return;
    }

    /* we lock the first byte to indicate that the file is valid */
    lseek(fd, 0L, SEEK_SET);
    st = lockf(fd, F_LOCK, 1);
    if (st == -1) {
        close(fd);
        unlink(filename);
    }

    /* we keep 'fd' open so that the lock will continue to be held */
}

/*
 *  We are called once at startup (when the known_domains list is empty)
 *  to clean up left-over files.  We are also called right before
 *  exiting.  In the latter case case we don't bother closing descriptors
 *  in the entries in the domain list because they will be closed
 *  automatically (and unlocked) when we exit.
 *
 *  We ignore the cache_okay flag because it is important that we remove
 *  all cache files (left-over files can temporarily confuse clients).
 */
void
clean_cache()
{
    struct domain *pdom;
    DIR *dir;
    struct dirent *dirent;
    char filename[300];

    /* close and unlink cache files for each domain */
    for (pdom = known_domains; pdom != (struct domain *)NULL;
        pdom = pdom->dom_pnext) {
        if (pdom->cache_file)
            unlink(pdom->cache_file);
    }

    sprintf(filename, "%s/ypbind.pid", BINDING);
    unlink(filename);

    dir = opendir(BINDING);

    if (dir == NULL) {
        /* Directory could not be opened. */
        syslog(LOG_ERR, "opendir failed with [%s]", strerror(errno));
        return;
    }

    while ((dirent = readdir(dir)) != 0) {
        if (strncmp(dirent->d_name, "xprt.", 5) == 0) {
            sprintf(filename, "%s/%s", BINDING, dirent->d_name);
            unlink(filename);
            rewinddir(dir);  /* removing file may harm iteration */
        }
    }
    closedir(dir);
}

/*
 *  We only want to use the cache stuff on local file systems.
 *  For remote file systems (e.g., NFS, the locking overhead is
 *  worse than the overhead of loopback RPC, so the caching
 *  wouldn't buy us anything.  In addition, if the remote locking
 *  software isn't configured before we start, then we would
 *  block when we try to lock.
 *
 *  We don't have a direct way to tell if a file system is local
 *  or remote, so we assume it is local unless it is NFS.
 */
int
cache_check()
{
    int st;
    struct statvfs stbuf;

    st = statvfs(BINDING, &stbuf);
    if (st == -1) {
        syslog(LOG_ERR, "statvfs failed with [%s]", strerror(errno));
        return (0);
    }

    /* we use strncasecmp to get NFS, NFS3, nfs, nfs3, etc. */
    if (strncasecmp(stbuf.f_basetype, "NFS", 3) == 0)
        return (0);
    return (1);
}