/*      $NetBSD: bootparam.c,v 1.21 2019/04/02 22:25:10 christos Exp $  */

/*
* Copyright (c) 1995 Gordon W. Ross
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/*
* RPC/bootparams
*/

#include <sys/param.h>
#include <sys/socket.h>

#include <net/if.h>

#include <netinet/in.h>
#include <netinet/in_systm.h>

#ifdef _STANDALONE
#include <lib/libkern/libkern.h>
#else
#include <string.h>
#endif

#include "rpcv2.h"

#include "stand.h"
#include "net.h"
#include "rpc.h"
#include "bootparam.h"

#ifdef DEBUG_RPC
#define RPC_PRINTF(a)   printf a
#else
#define RPC_PRINTF(a)
#endif

struct in_addr  bp_server_addr; /* net order */
n_short         bp_server_port; /* net order */

uint32_t        hostnamelen;
char            domainname[FNAME_SIZE]; /* our DNS domain */
uint32_t        domainnamelen;

/*
* RPC definitions for bootparamd
*/
#define BOOTPARAM_PROG          100026
#define BOOTPARAM_VERS          1
#define BOOTPARAM_WHOAMI        1
#define BOOTPARAM_GETFILE       2

/*
* Inet address in RPC messages
* (Note, really four ints, NOT chars.  Blech.)
*/
struct xdr_inaddr {
       uint32_t  atype;
       int32_t addr[4];
};

int xdr_inaddr_encode(char **, struct in_addr);
int xdr_inaddr_decode(char **, struct in_addr *);

int xdr_string_encode(char **, char *, uint32_t);
int xdr_string_decode(char **, char *, uint32_t *);


/*
* RPC: bootparam/whoami
* Given client IP address, get:
*      client name     (hostname)
*      domain name (domainname)
*      gateway address
*
* The hostname and domainname are set here for convenience.
*
* Note - bpsin is initialized to the broadcast address,
* and will be replaced with the bootparam server address
* after this call is complete.  Have to use PMAP_PROC_CALL
* to make sure we get responses only from a servers that
* know about us (don't want to broadcast a getport call).
*/
int
bp_whoami(int sockfd)
{
       /* RPC structures for PMAPPROC_CALLIT */
       struct args {
               uint32_t prog;
               uint32_t vers;
               uint32_t proc;
               uint32_t arglen;
               struct xdr_inaddr xina;
       } *args;
       struct repl {
               uint16_t _pad;
               uint16_t port;
               uint32_t encap_len;
               /* encapsulated data here */
               n_long  capsule[64];
       } *repl;
       struct {
               n_long  h[RPC_HEADER_WORDS];
               struct args d;
       } sdata;
       struct {
               n_long  h[RPC_HEADER_WORDS];
               struct repl d;
       } rdata;
       char *send_tail, *recv_head;
       struct iodesc *d;
       uint32_t x;
       ssize_t len;

       RPC_PRINTF(("%s: myip=%s\n", __func__, inet_ntoa(myip)));

       if (!(d = socktodesc(sockfd))) {
               RPC_PRINTF(("%s: bad socket. %d\n", __func__, sockfd));
               return -1;
       }
       args = &sdata.d;
       repl = &rdata.d;

       /*
        * Build request args for PMAPPROC_CALLIT.
        */
       args->prog = htonl((uint32_t)BOOTPARAM_PROG);
       args->vers = htonl((uint32_t)BOOTPARAM_VERS);
       args->proc = htonl((uint32_t)BOOTPARAM_WHOAMI);
       args->arglen = htonl((uint32_t)sizeof(struct xdr_inaddr));
       send_tail = (char *)&args->xina;

       /*
        * append encapsulated data (client IP address)
        */
       if (xdr_inaddr_encode(&send_tail, myip))
               return -1;

       /* RPC: portmap/callit */
       --rpc_port;
       d->myport = (uint16_t)htons((uint16_t)rpc_port);
       d->destip.s_addr = INADDR_BROADCAST;    /* XXX: subnet bcast? */
       /* rpc_call will set d->destport */

       len = rpc_call(d, PMAPPROG, PMAPVERS, PMAPPROC_CALLIT,
                                 args, (size_t)(send_tail - (char *)args),
                                 repl, sizeof(*repl));
       if (len < 8) {
               printf("%s: 'whoami' call failed\n", __func__);
               return -1;
       }

       /* Save bootparam server address (from IP header). */
       rpc_fromaddr(repl, &bp_server_addr, &bp_server_port);

       /*
        * Note that bp_server_port is now 111 due to the
        * indirect call (using PMAPPROC_CALLIT), so get the
        * actual port number from the reply data.
        */
       bp_server_port = repl->port;

       RPC_PRINTF(("%s: server at %s:%d\n", __func__,
           inet_ntoa(bp_server_addr), ntohs((uint16_t)bp_server_port)));

       /* We have just done a portmap call, so cache the portnum. */
       rpc_pmap_putcache(bp_server_addr,
                         BOOTPARAM_PROG,
                         BOOTPARAM_VERS,
                         (int)ntohs((uint16_t)bp_server_port));

       /*
        * Parse the encapsulated results from bootparam/whoami
        */
       x = ntohl((uint32_t)repl->encap_len);
       if (len < x) {
               printf("%s: short reply, %zd < %d\n", __func__, len, x);
               return -1;
       }
       recv_head = (char *)repl->capsule;

       /* client name */
       hostnamelen = MAXHOSTNAMELEN-1;
       if (xdr_string_decode(&recv_head, hostname, &hostnamelen)) {
               RPC_PRINTF(("%s: bad hostname\n", __func__));
               return -1;
       }

       /* domain name */
       domainnamelen = MAXHOSTNAMELEN-1;
       if (xdr_string_decode(&recv_head, domainname, &domainnamelen)) {
               RPC_PRINTF(("%s: bad domainname\n", __func__));
               return -1;
       }

       /* gateway address */
       if (xdr_inaddr_decode(&recv_head, &gateip)) {
               RPC_PRINTF(("%s: bad gateway\n", __func__));
               return -1;
       }

       /* success */
       return 0;
}


/*
* RPC: bootparam/getfile
* Given client name and file "key", get:
*      server name
*      server IP address
*      server pathname
*/
int
bp_getfile(int sockfd, char *key, struct in_addr *serv_addr, char *pathname)
{
       struct {
               n_long  h[RPC_HEADER_WORDS];
               n_long  d[64];
       } sdata;
       struct {
               n_long  h[RPC_HEADER_WORDS];
               n_long  d[128];
       } rdata;
       char serv_name[FNAME_SIZE];
       char *send_tail, *recv_head;
       /* misc... */
       struct iodesc *d;
       uint32_t sn_len, path_len;
       ssize_t rlen;

       if (!(d = socktodesc(sockfd))) {
               RPC_PRINTF(("%s: bad socket. %d\n", __func__, sockfd));
               return -1;
       }

       send_tail = (char *)sdata.d;
       recv_head = (char *)rdata.d;

       /*
        * Build request message.
        */

       /* client name (hostname) */
       if (xdr_string_encode(&send_tail, hostname, hostnamelen)) {
               RPC_PRINTF(("%s: bad client\n", __func__));
               return -1;
       }

       /* key name (root or swap) */
       if (xdr_string_encode(&send_tail, key, (uint32_t)strlen(key))) {
               RPC_PRINTF(("%s: bad key\n", __func__));
               return -1;
       }

       /* RPC: bootparam/getfile */
       --rpc_port;
       d->myport = htons((uint16_t)rpc_port);
       d->destip = bp_server_addr;
       /* rpc_call will set d->destport */

       rlen = rpc_call(d,
               BOOTPARAM_PROG, BOOTPARAM_VERS, BOOTPARAM_GETFILE,
               sdata.d, (size_t)(send_tail - (char *)sdata.d),
               rdata.d, sizeof(rdata.d));
       if (rlen < 4) {
               RPC_PRINTF(("%s: short reply\n", __func__));
               errno = EBADRPC;
               return -1;
       }
       recv_head = (char *)rdata.d;

       /*
        * Parse result message.
        */

       /* server name */
       sn_len = FNAME_SIZE - 1;
       if (xdr_string_decode(&recv_head, serv_name, &sn_len)) {
               RPC_PRINTF(("%s: bad server name\n", __func__));
               return -1;
       }

       /* server IP address (mountd/NFS) */
       if (xdr_inaddr_decode(&recv_head, serv_addr)) {
               RPC_PRINTF(("%s: bad server addr\n", __func__));
               return -1;
       }

       /* server pathname */
       path_len = MAXPATHLEN - 1;
       if (xdr_string_decode(&recv_head, pathname, &path_len)) {
               RPC_PRINTF(("%s: bad server path\n", __func__));
               return -1;
       }

       /* success */
       return 0;
}


/*
* eXternal Data Representation routines.
* (but with non-standard args...)
*/


int
xdr_string_encode(char **pkt, char *str, uint32_t len)
{
       uint32_t *lenp;
       char *datap;
       uint32_t padlen = (len + 3) & ~3U;      /* padded length */

       /* The data will be int aligned. */
       lenp = (uint32_t *)*pkt;
       *pkt += sizeof(*lenp);
       *lenp = htonl(len);

       datap = *pkt;
       *pkt += padlen;
       (void)memcpy(datap, str, len);

       return 0;
}

/* len_p: bufsize - 1 */
int
xdr_string_decode(char **pkt, char *str, uint32_t *len_p)
{
       uint32_t *lenp;
       char *datap;
       uint32_t slen;  /* string length */
       uint32_t plen;  /* padded length */

       /* The data will be int aligned. */
       lenp = (uint32_t *)*pkt;
       *pkt += sizeof(*lenp);
       slen = ntohl(*lenp);
       plen = (slen + 3) & ~3U;

       if (slen > *len_p)
               slen = *len_p;
       datap = *pkt;
       *pkt += plen;
       (void)memcpy(str, datap, slen);

       str[slen] = '\0';
       *len_p = slen;

       return 0;
}


/* ia: network order */
int
xdr_inaddr_encode(char **pkt, struct in_addr ia)
{
       struct xdr_inaddr *xi;
       u_char *cp;
       uint32_t *ip;
       union {
               n_long l;       /* network order */
               u_char c[4];
       } uia;

       /* The data will be int aligned. */
       xi = (struct xdr_inaddr *)*pkt;
       *pkt += sizeof(*xi);
       xi->atype = htonl(1);
       uia.l = ia.s_addr;
       cp = uia.c;
       ip = (uint32_t *)xi->addr;
       /*
        * Note: the htonl() calls below DO NOT
        * imply that uia.l is in host order.
        * In fact this needs it in net order.
        */
       *ip++ = htonl((uint32_t)*cp++);
       *ip++ = htonl((uint32_t)*cp++);
       *ip++ = htonl((uint32_t)*cp++);
       *ip++ = htonl((uint32_t)*cp++);

       return 0;
}

/* ia: network order */
int
xdr_inaddr_decode(char **pkt, struct in_addr *ia)
{
       struct xdr_inaddr *xi;
       u_char *cp;
       uint32_t *ip;
       union {
               n_long l;       /* network order */
               u_char c[4];
       } uia;

       /* The data will be int aligned. */
       xi = (struct xdr_inaddr *)*pkt;
       *pkt += sizeof(*xi);
       if (xi->atype != htonl((uint32_t)1)) {
               RPC_PRINTF(("%s: bad addrtype=%d\n", __func__,
                   ntohl((uint32_t)nxi->atype)));
               return -1;
       }

       cp = uia.c;
       ip = (uint32_t *)xi->addr;
       /*
        * Note: the ntohl() calls below DO NOT
        * imply that uia.l is in host order.
        * In fact this needs it in net order.
        */
       *cp++ = (u_char)ntohl(*ip++);
       *cp++ = (u_char)ntohl(*ip++);
       *cp++ = (u_char)ntohl(*ip++);
       *cp++ = (u_char)ntohl(*ip++);
       ia->s_addr = uia.l;

       return 0;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.