cmd/ypcmd/rpc_bootstrap.c

	rpc_bootstrap.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * 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 2002 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 <sys/types.h>
#include <sys/file.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <tiuser.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netdir.h>
#include <netdb.h>
#include <rpc/rpc.h>
#include <rpc/pmap_clnt.h>
#include <rpcsvc/nis.h>

CLIENT *__clnt_tp_create_bootstrap();
int __rpcb_getaddr_bootstrap();
struct hostent *__files_gethostbyname();

extern int hostNotKnownLocally;

static char *__map_addr();

/*
 * __clnt_tp_create_bootstrap()
 *
 * This routine is NOT TRANSPORT INDEPENDENT.
 *
 * It relies on the local /etc/hosts file for hostname to address
 * translation and does it itself instead of calling netdir_getbyname
 * thereby avoids recursion.
 */
CLIENT *
__clnt_tp_create_bootstrap(hostname, prog, vers, nconf)
    char *hostname;
    u_long prog, vers;
    struct netconfig    *nconf;
{
    CLIENT *cl;
    struct netbuf   *svc_taddr;
    struct sockaddr_in6 *sa;
    int fd;

    if (nconf == (struct netconfig *)NULL) {
        rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
        return (NULL);
    }
    if ((fd = t_open(nconf->nc_device, O_RDWR, NULL)) == -1) {
        rpc_createerr.cf_stat = RPC_TLIERROR;
        return (NULL);
    }
    svc_taddr = (struct netbuf *) malloc(sizeof (struct netbuf));
    if (! svc_taddr) {
        rpc_createerr.cf_stat = RPC_SYSTEMERROR;
        t_close(fd);
        return (NULL);
    }
    sa = (struct sockaddr_in6 *)calloc(1, sizeof (*sa));
    if (! sa) {
        rpc_createerr.cf_stat = RPC_SYSTEMERROR;
        t_close(fd);
        free(svc_taddr);
        return (NULL);
    }
    svc_taddr->maxlen = svc_taddr->len = sizeof (*sa);
    svc_taddr->buf = (char *)sa;
    if (__rpcb_getaddr_bootstrap(prog,
        vers, nconf, svc_taddr, hostname) == FALSE) {
        t_close(fd);
        free(svc_taddr);
        free(sa);
        return (NULL);
    }
    rpc_createerr.cf_stat = RPC_SUCCESS;
    cl = __nis_clnt_create(fd, nconf, 0, svc_taddr, 0, prog, vers, 0, 0);
    if (cl == 0) {
        if (rpc_createerr.cf_stat == RPC_SUCCESS)
            rpc_createerr.cf_stat = RPC_TLIERROR;
        t_close(fd);
    }
    free(svc_taddr);
    free(sa);
    return (cl);
}

/*
 * __rpcb_getaddr_bootstrap()
 *
 * This is our internal function that replaces rpcb_getaddr(). We
 * build our own to prevent calling netdir_getbyname() which could
 * recurse to the nameservice.
 */
int
__rpcb_getaddr_bootstrap(program, version, nconf, address, hostname)
    u_long program;
    u_long version;
    struct netconfig *nconf;
    struct netbuf *address; /* populate with the taddr of the service */
    char *hostname;
{
    char *svc_uaddr;
    struct hostent *hent;
    struct sockaddr_in *sa;
    struct sockaddr_in6 *sa6;
    struct netbuf rpcb_taddr;
    struct sockaddr_in local_sa;
    struct sockaddr_in6 local_sa6;
    in_port_t inport;
    int p1, p2;
    char *ipaddr, *port;
    int i, ipaddrlen;

    if (strcmp(nconf->nc_protofmly, NC_INET) != 0 &&
        strcmp(nconf->nc_protofmly, NC_INET6) != 0) {
        rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
        return (FALSE);
    }

    /* Get the address of the RPCBIND at hostname */
    hent = __files_gethostbyname(hostname, nconf->nc_protofmly);
    if (hent == (struct hostent *)NULL) {
        rpc_createerr.cf_stat = RPC_UNKNOWNHOST;
        hostNotKnownLocally = 1;
        return (FALSE);
    }

    switch (hent->h_addrtype) {
    case AF_INET:
        local_sa.sin_family = AF_INET;
        local_sa.sin_port = htons(111); /* RPCBIND port */
        memcpy((char *)&(local_sa.sin_addr.s_addr),
            hent->h_addr_list[0], hent->h_length);
        rpcb_taddr.buf = (char *)&local_sa;
        rpcb_taddr.maxlen = sizeof (local_sa);
        rpcb_taddr.len = rpcb_taddr.maxlen;
        break;
    case AF_INET6:
        local_sa6.sin6_family = AF_INET6;
        local_sa6.sin6_port = htons(111); /* RPCBIND port */
        memcpy((char *)&(local_sa6.sin6_addr.s6_addr),
            hent->h_addr_list[0], hent->h_length);
        rpcb_taddr.buf = (char *)&local_sa6;
        rpcb_taddr.maxlen = sizeof (local_sa6);
        rpcb_taddr.len = rpcb_taddr.maxlen;
        break;
    default:
        rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
        return (FALSE);
    }

    svc_uaddr = __map_addr(nconf, &rpcb_taddr, program, version);
    if (! svc_uaddr)
        return (FALSE);

/* do a local uaddr2taddr and stuff in the memory supplied by the caller */
    ipaddr = svc_uaddr;
    ipaddrlen = strlen(ipaddr);
    /* Look for the first '.' starting from the end */
    for (i = ipaddrlen-1; i >= 0; i--)
        if (ipaddr[i] == '.') break;
    /* Find the second dot (still counting from the end) */
    for (i--; i >= 0; i--)
        if (ipaddr[i] == '.') break;
    /* If we didn't find it, the uaddr has a syntax error */
    if (i < 0) {
        rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
        return (FALSE);
    }
    port = &ipaddr[i+1];
    ipaddr[i] = '\0';
    sscanf(port, "%d.%d", &p1, &p2);
    inport = (p1 << 8) + p2;
    if (hent->h_addrtype == AF_INET) {
        sa = (struct sockaddr_in *)address->buf;
        address->len = sizeof (*sa);
        if (inet_pton(AF_INET, ipaddr, &sa->sin_addr) != 1) {
            rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
            return (FALSE);
        }
        sa->sin_port = htons(inport);
        sa->sin_family = AF_INET;
    } else {
        sa6 = (struct sockaddr_in6 *)address->buf;
        address->len = sizeof (*sa6);
        if (inet_pton(AF_INET6, ipaddr, &sa6->sin6_addr) != 1) {
            rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
            return (FALSE);
        }
        sa6->sin6_port = htons(inport);
        sa6->sin6_family = AF_INET6;
    }
    return (TRUE);
}

/*
 * __map_addr()
 *
 */
static char *
__map_addr(nc, rpcb_taddr, prog, ver)
    struct netconfig    *nc;        /* Our transport    */
    struct netbuf   *rpcb_taddr; /* RPCBIND address */
    u_long          prog, ver;  /* Name service Prog/vers */
{
    register CLIENT *client;
    RPCB        parms;      /* Parameters for RPC binder      */
    enum clnt_stat  clnt_st;    /* Result from the rpc call   */
    int     fd;     /* Stream file descriptor     */
    char        *ua = NULL; /* Universal address of service   */
    struct timeval  tv;     /* Timeout for our rpcb call      */

    /*
     * First we open a connection to the remote rpcbind process.
     */
    if ((fd = t_open(nc->nc_device, O_RDWR, NULL)) == -1) {
        rpc_createerr.cf_stat = RPC_TLIERROR;
        return (NULL);
    }

    client = __nis_clnt_create(fd, nc, 0, rpcb_taddr, 0,
                    RPCBPROG, RPCBVERS, 0, 0);
    if (! client) {
        t_close(fd);
        rpc_createerr.cf_stat = RPC_TLIERROR;
        return (NULL);
    }

    /*
     * Now make the call to get the NIS service address.
     */
    tv.tv_sec = 10;
    tv.tv_usec = 0;
    parms.r_prog = prog;
    parms.r_vers = ver;
    parms.r_netid = nc->nc_netid;   /* not needed */
    parms.r_addr = "";  /* not needed; just for xdring */
    parms.r_owner = ""; /* not needed; just for xdring */
    clnt_st = clnt_call(client, RPCBPROC_GETADDR, xdr_rpcb, (char *)&parms,
                        xdr_wrapstring, (char *)&ua, tv);

    rpc_createerr.cf_stat = clnt_st;
    if (clnt_st == RPC_SUCCESS) {

        clnt_destroy(client);
        t_close(fd);
        if (*ua == '\0') {
            xdr_free(xdr_wrapstring, (char *)&ua);
            return (NULL);
        }
        return (ua);
    } else if (((clnt_st == RPC_PROGVERSMISMATCH) ||
            (clnt_st == RPC_PROGUNAVAIL) ||
            (clnt_st == RPC_TIMEDOUT)) &&
            (strcmp(nc->nc_protofmly, NC_INET) == 0)) {
        /*
         * version 3 not available. Try version 2
         * The assumption here is that the netbuf
         * is arranged in the sockaddr_in
         * style for IP cases.
         */
        u_short port;
        struct sockaddr_in  *sa;
        struct netbuf       remote;
        int     protocol;
        char    buf[32];
        char    *res;

        clnt_control(client, CLGET_SVC_ADDR, (char *) &remote);
        sa = (struct sockaddr_in *)(remote.buf);
        protocol = strcmp(nc->nc_proto, NC_TCP) ?
                IPPROTO_UDP : IPPROTO_TCP;
        port = (u_short) pmap_getport(sa, prog, ver, protocol);

        if (port != 0) {
            /* print s_addr (and port) in host byte order */
            sa->sin_addr.s_addr = ntohl(sa->sin_addr.s_addr);
            sprintf(buf, "%d.%d.%d.%d.%d.%d",
                (sa->sin_addr.s_addr >> 24) & 0xff,
                (sa->sin_addr.s_addr >> 16) & 0xff,
                (sa->sin_addr.s_addr >>  8) & 0xff,
                (sa->sin_addr.s_addr) & 0xff,
                (port >> 8) & 0xff,
                port & 0xff);
            res = strdup(buf);
            if (res != 0) {
                rpc_createerr.cf_stat = RPC_SUCCESS;
            } else {
                rpc_createerr.cf_stat = RPC_SYSTEMERROR;
            }
        } else {
            rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
            res = NULL;
        }
        clnt_destroy(client);
        t_close(fd);
        return (res);
    }
    clnt_destroy(client);
    t_close(fd);
    return (NULL);
}

#define bcmp(s1, s2, len)   memcmp(s1, s2, len)
#define bcopy(s1, s2, len)  memcpy(s2, s1, len)

#define MAXALIASES  35

static char line[BUFSIZ+1];
static char hostaddr[sizeof (struct in6_addr)];
static struct hostent host;
static char *host_aliases[MAXALIASES];
static char *host_addrs[] = {
    hostaddr,
    NULL
};

static char *_hosts6[] = { "/etc/inet/ipnodes", 0 };
static char *_hosts4[] = { "/etc/inet/ipnodes", "/etc/hosts", 0 };

static char *any();

static struct hostent *__files_gethostent();

struct hostent *
__files_gethostbyname(char *nam, char *fmly)
{
    register struct hostent *hp;
    register char **cp;
    char **file;
    FILE *hostf;
    sa_family_t af;

    if (strcmp(fmly, NC_INET) == 0) {
        af = AF_INET;
        file = _hosts4;
    } else if (strcmp(fmly, NC_INET6) == 0) {
        af = AF_INET6;
        file = _hosts6;
    } else {
        return (0);
    }

    for (; *file != 0; file++) {

        if ((hostf = fopen(*file, "r")) == 0)
            continue;

        while (hp = __files_gethostent(hostf)) {
            if (hp->h_addrtype != af)
                continue;
            if (strcasecmp(hp->h_name, nam) == 0) {
                (void) fclose(hostf);
                return (hp);
            }
            for (cp = hp->h_aliases; cp != 0 && *cp != 0; cp++)
                if (strcasecmp(*cp, nam) == 0) {
                    (void) fclose(hostf);
                    return (hp);
                }
        }

        (void) fclose(hostf);
    }

    return (0);
}

#define isV6Addr(s) (strchr(s, (int)':') != 0)

static struct hostent *
__files_gethostent(FILE *hostf)
{
    char *p;
    register char *cp, **q;
    struct in6_addr in6;
    struct in_addr in4;
    void *addr;
    sa_family_t af;
    int len;

    if (hostf == NULL)
        return (NULL);
again:
    if ((p = fgets(line, BUFSIZ, hostf)) == NULL)
        return (NULL);
    if (*p == '#')
        goto again;
    cp = any(p, "#\n");
    if (cp == NULL)
        goto again;
    *cp = '\0';
    cp = any(p, " \t");
    if (cp == NULL)
        goto again;
    *cp++ = '\0';
    /* THIS STUFF IS INTERNET SPECIFIC */
    host.h_addr_list = host_addrs;
    if (isV6Addr(p)) {
        af = AF_INET6;
        addr = (void *)&in6;
        len = sizeof (in6);
    } else {
        af = AF_INET;
        addr = (void *)&in4;
        len = sizeof (in4);
    }
    if (inet_pton(af, p, addr) != 1)
        goto again;
    bcopy(addr, host.h_addr_list[0], len);
    host.h_length = len;
    host.h_addrtype = af;
    while (*cp == ' ' || *cp == '\t')
        cp++;
    host.h_name = cp;
    q = host.h_aliases = host_aliases;
    cp = any(cp, " \t");
    if (cp != NULL)
        *cp++ = '\0';
    while (cp && *cp) {
        if (*cp == ' ' || *cp == '\t') {
            cp++;
            continue;
        }
        if (q < &host_aliases[MAXALIASES - 1])
            *q++ = cp;
        cp = any(cp, " \t");
        if (cp != NULL)
            *cp++ = '\0';
    }
    *q = NULL;
    return (&host);
}

static char *
any(cp, match)
    register char *cp;
    char *match;
{
    register char *mp, c;

    while (c = *cp) {
        for (mp = match; *mp; mp++)
            if (*mp == c)
                return (cp);
        cp++;
    }
    return ((char *)0);
}