Unleashed v1.4

[unleashed.git] / usr / src / 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 != 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, 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)) !=
            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))
                        == 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))
            != 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 NULL.
 */
static struct domain *
ypbind_point_to_domain(pname)
register char   *pname;
{
        register struct domain *pdom;
        char buf[300];

        for (pdom = known_domains; pdom != 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 == 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 != 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);
}