lib/libstand/bootparam.c

   1 /*      $NetBSD: bootparam.c,v 1.11 1997/06/26 19:11:32 drochner Exp $  */
   2
   3 /*
   4  * Copyright (c) 1995 Gordon W. Ross
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. The name of the author may not be used to endorse or promote products
  16  *    derived from this software without specific prior written permission.
  17  * 4. All advertising materials mentioning features or use of this software
  18  *    must display the following acknowledgement:
  19  *      This product includes software developed by Gordon W. Ross
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  * $DragonFly: src/lib/libstand/bootparam.c,v 1.2 2005/12/11 02:27:26 swildner Exp $
  33  */
  34
  35 /*
  36  * RPC/bootparams
  37  */
  38
  39 #include <sys/param.h>
  40 #include <sys/socket.h>
  41
  42 #include <net/if.h>
  43
  44 #include <netinet/in.h>
  45 #include <netinet/in_systm.h>
  46
  47 #include <string.h>
  48
  49 #include "rpcv2.h"
  50
  51 #include "stand.h"
  52 #include "net.h"
  53 #include "netif.h"
  54 #include "rpc.h"
  55 #include "bootparam.h"
  56
  57 #ifdef DEBUG_RPC
  58 #define RPC_PRINTF(a)   printf a
  59 #else
  60 #define RPC_PRINTF(a)
  61 #endif
  62
  63 struct in_addr  bp_server_addr; /* net order */
  64 n_short         bp_server_port; /* net order */
  65
  66 /*
  67  * RPC definitions for bootparamd
  68  */
  69 #define BOOTPARAM_PROG          100026
  70 #define BOOTPARAM_VERS          1
  71 #define BOOTPARAM_WHOAMI        1
  72 #define BOOTPARAM_GETFILE       2
  73
  74 /*
  75  * Inet address in RPC messages
  76  * (Note, really four ints, NOT chars.  Blech.)
  77  */
  78 struct xdr_inaddr {
  79         u_int32_t  atype;
  80         int32_t addr[4];
  81 };
  82
  83 int xdr_inaddr_encode(char **p, struct in_addr ia);
  84 int xdr_inaddr_decode(char **p, struct in_addr *ia);
  85
  86 int xdr_string_encode(char **p, char *str, int len);
  87 int xdr_string_decode(char **p, char *str, int *len_p);
  88
  89
  90 /*
  91  * RPC: bootparam/whoami
  92  * Given client IP address, get:
  93  *      client name     (hostname)
  94  *      domain name (domainname)
  95  *      gateway address
  96  *
  97  * The hostname and domainname are set here for convenience.
  98  *
  99  * Note - bpsin is initialized to the broadcast address,
 100  * and will be replaced with the bootparam server address
 101  * after this call is complete.  Have to use PMAP_PROC_CALL
 102  * to make sure we get responses only from a servers that
 103  * know about us (don't want to broadcast a getport call).
 104  */
 105 int
 106 bp_whoami(int sockfd)
 107 {
 108         /* RPC structures for PMAPPROC_CALLIT */
 109         struct args {
 110                 u_int32_t prog;
 111                 u_int32_t vers;
 112                 u_int32_t proc;
 113                 u_int32_t arglen;
 114                 struct xdr_inaddr xina;
 115         } *args;
 116         struct repl {
 117                 u_int16_t _pad;
 118                 u_int16_t port;
 119                 u_int32_t encap_len;
 120                 /* encapsulated data here */
 121                 n_long  capsule[64];
 122         } *repl;
 123         struct {
 124                 n_long  h[RPC_HEADER_WORDS];
 125                 struct args d;
 126         } sdata;
 127         struct {
 128                 n_long  h[RPC_HEADER_WORDS];
 129                 struct repl d;
 130         } rdata;
 131         char *send_tail, *recv_head;
 132         struct iodesc *d;
 133         int len, x;
 134
 135         RPC_PRINTF(("bp_whoami: myip=%s\n", inet_ntoa(myip)));
 136
 137         if (!(d = socktodesc(sockfd))) {
 138                 RPC_PRINTF(("bp_whoami: bad socket. %d\n", sockfd));
 139                 return (-1);
 140         }
 141         args = &sdata.d;
 142         repl = &rdata.d;
 143
 144         /*
 145          * Build request args for PMAPPROC_CALLIT.
 146          */
 147         args->prog = htonl(BOOTPARAM_PROG);
 148         args->vers = htonl(BOOTPARAM_VERS);
 149         args->proc = htonl(BOOTPARAM_WHOAMI);
 150         args->arglen = htonl(sizeof(struct xdr_inaddr));
 151         send_tail = (char*) &args->xina;
 152
 153         /*
 154          * append encapsulated data (client IP address)
 155          */
 156         if (xdr_inaddr_encode(&send_tail, myip))
 157                 return (-1);
 158
 159         /* RPC: portmap/callit */
 160         d->myport = htons(rpc_newport());
 161         d->destip.s_addr = INADDR_BROADCAST;    /* XXX: subnet bcast? */
 162         /* rpc_call will set d->destport */
 163
 164         len = rpc_call(d, PMAPPROG, PMAPVERS, PMAPPROC_CALLIT,
 165                                   args, send_tail - (char*)args,
 166                                   repl, sizeof(*repl));
 167         if (len < 8) {
 168                 printf("bootparamd: 'whoami' call failed\n");
 169                 return (-1);
 170         }
 171
 172         /* Save bootparam server address (from IP header). */
 173         rpc_fromaddr(repl, &bp_server_addr, &bp_server_port);
 174
 175         /*
 176          * Note that bp_server_port is now 111 due to the
 177          * indirect call (using PMAPPROC_CALLIT), so get the
 178          * actual port number from the reply data.
 179          */
 180         bp_server_port = repl->port;
 181
 182         RPC_PRINTF(("bp_whoami: server at %s:%d\n",
 183             inet_ntoa(bp_server_addr), ntohs(bp_server_port)));
 184
 185         /* We have just done a portmap call, so cache the portnum. */
 186         rpc_pmap_putcache(bp_server_addr,
 187                           BOOTPARAM_PROG,
 188                           BOOTPARAM_VERS,
 189                           (int)ntohs(bp_server_port));
 190
 191         /*
 192          * Parse the encapsulated results from bootparam/whoami
 193          */
 194         x = ntohl(repl->encap_len);
 195         if (len < x) {
 196                 printf("bp_whoami: short reply, %d < %d\n", len, x);
 197                 return (-1);
 198         }
 199         recv_head = (char*) repl->capsule;
 200
 201         /* client name */
 202         hostnamelen = MAXHOSTNAMELEN-1;
 203         if (xdr_string_decode(&recv_head, hostname, &hostnamelen)) {
 204                 RPC_PRINTF(("bp_whoami: bad hostname\n"));
 205                 return (-1);
 206         }
 207
 208         /* domain name */
 209         domainnamelen = MAXHOSTNAMELEN-1;
 210         if (xdr_string_decode(&recv_head, domainname, &domainnamelen)) {
 211                 RPC_PRINTF(("bp_whoami: bad domainname\n"));
 212                 return (-1);
 213         }
 214
 215         /* gateway address */
 216         if (xdr_inaddr_decode(&recv_head, &gateip)) {
 217                 RPC_PRINTF(("bp_whoami: bad gateway\n"));
 218                 return (-1);
 219         }
 220
 221         /* success */
 222         return(0);
 223 }
 224
 225
 226 /*
 227  * RPC: bootparam/getfile
 228  * Given client name and file "key", get:
 229  *      server name
 230  *      server IP address
 231  *      server pathname
 232  */
 233 int
 234 bp_getfile(int sockfd, char *key, struct in_addr *serv_addr, char *pathname)
 235 {
 236         struct {
 237                 n_long  h[RPC_HEADER_WORDS];
 238                 n_long  d[64];
 239         } sdata;
 240         struct {
 241                 n_long  h[RPC_HEADER_WORDS];
 242                 n_long  d[128];
 243         } rdata;
 244         char serv_name[FNAME_SIZE];
 245         char *send_tail, *recv_head;
 246         /* misc... */
 247         struct iodesc *d;
 248         int sn_len, path_len, rlen;
 249
 250         if (!(d = socktodesc(sockfd))) {
 251                 RPC_PRINTF(("bp_getfile: bad socket. %d\n", sockfd));
 252                 return (-1);
 253         }
 254
 255         send_tail = (char*) sdata.d;
 256         recv_head = (char*) rdata.d;
 257
 258         /*
 259          * Build request message.
 260          */
 261
 262         /* client name (hostname) */
 263         if (xdr_string_encode(&send_tail, hostname, hostnamelen)) {
 264                 RPC_PRINTF(("bp_getfile: bad client\n"));
 265                 return (-1);
 266         }
 267
 268         /* key name (root or swap) */
 269         if (xdr_string_encode(&send_tail, key, strlen(key))) {
 270                 RPC_PRINTF(("bp_getfile: bad key\n"));
 271                 return (-1);
 272         }
 273
 274         /* RPC: bootparam/getfile */
 275         d->myport = htons(rpc_newport());
 276         d->destip   = bp_server_addr;
 277         /* rpc_call will set d->destport */
 278
 279         rlen = rpc_call(d,
 280                 BOOTPARAM_PROG, BOOTPARAM_VERS, BOOTPARAM_GETFILE,
 281                 sdata.d, send_tail - (char*)sdata.d,
 282                 rdata.d, sizeof(rdata.d));
 283         if (rlen < 4) {
 284                 RPC_PRINTF(("bp_getfile: short reply\n"));
 285                 errno = EBADRPC;
 286                 return (-1);
 287         }
 288         recv_head = (char*) rdata.d;
 289
 290         /*
 291          * Parse result message.
 292          */
 293
 294         /* server name */
 295         sn_len = FNAME_SIZE-1;
 296         if (xdr_string_decode(&recv_head, serv_name, &sn_len)) {
 297                 RPC_PRINTF(("bp_getfile: bad server name\n"));
 298                 return (-1);
 299         }
 300
 301         /* server IP address (mountd/NFS) */
 302         if (xdr_inaddr_decode(&recv_head, serv_addr)) {
 303                 RPC_PRINTF(("bp_getfile: bad server addr\n"));
 304                 return (-1);
 305         }
 306
 307         /* server pathname */
 308         path_len = MAXPATHLEN-1;
 309         if (xdr_string_decode(&recv_head, pathname, &path_len)) {
 310                 RPC_PRINTF(("bp_getfile: bad server path\n"));
 311                 return (-1);
 312         }
 313
 314         /* success */
 315         return(0);
 316 }
 317
 318
 319 /*
 320  * eXternal Data Representation routines.
 321  * (but with non-standard args...)
 322  */
 323
 324
 325 int
 326 xdr_string_encode(char **pkt, char *str, int len)
 327 {
 328         u_int32_t *lenp;
 329         char *datap;
 330         int padlen = (len + 3) & ~3;    /* padded length */
 331
 332         /* The data will be int aligned. */
 333         lenp = (u_int32_t*) *pkt;
 334         *pkt += sizeof(*lenp);
 335         *lenp = htonl(len);
 336
 337         datap = *pkt;
 338         *pkt += padlen;
 339         bcopy(str, datap, len);
 340
 341         return (0);
 342 }
 343
 344 /*
 345  * Parameters:
 346  *      len_p:  bufsize - 1
 347  */
 348 int
 349 xdr_string_decode(char **pkt, char *str, int *len_p)
 350 {
 351         u_int32_t *lenp;
 352         char *datap;
 353         int slen;       /* string length */
 354         int plen;       /* padded length */
 355
 356         /* The data will be int aligned. */
 357         lenp = (u_int32_t*) *pkt;
 358         *pkt += sizeof(*lenp);
 359         slen = ntohl(*lenp);
 360         plen = (slen + 3) & ~3;
 361
 362         if (slen > *len_p)
 363                 slen = *len_p;
 364         datap = *pkt;
 365         *pkt += plen;
 366         bcopy(datap, str, slen);
 367
 368         str[slen] = '\0';
 369         *len_p = slen;
 370
 371         return (0);
 372 }
 373
 374 /*
 375  * Parameters:
 376  *      ia:     network order
 377  */
 378 int
 379 xdr_inaddr_encode(char **pkt, struct in_addr ia)
 380 {
 381         struct xdr_inaddr *xi;
 382         u_char *cp;
 383         int32_t *ip;
 384         union {
 385                 n_long l;       /* network order */
 386                 u_char c[4];
 387         } uia;
 388
 389         /* The data will be int aligned. */
 390         xi = (struct xdr_inaddr *) *pkt;
 391         *pkt += sizeof(*xi);
 392         xi->atype = htonl(1);
 393         uia.l = ia.s_addr;
 394         cp = uia.c;
 395         ip = xi->addr;
 396         /*
 397          * Note: the htonl() calls below DO NOT
 398          * imply that uia.l is in host order.
 399          * In fact this needs it in net order.
 400          */
 401         *ip++ = htonl((unsigned int)*cp++);
 402         *ip++ = htonl((unsigned int)*cp++);
 403         *ip++ = htonl((unsigned int)*cp++);
 404         *ip++ = htonl((unsigned int)*cp++);
 405
 406         return (0);
 407 }
 408
 409 /*
 410  * Parameters:
 411  *      ia:     network order
 412  */
 413 int
 414 xdr_inaddr_decode(char **pkt, struct in_addr *ia)
 415 {
 416         struct xdr_inaddr *xi;
 417         u_char *cp;
 418         int32_t *ip;
 419         union {
 420                 n_long l;       /* network order */
 421                 u_char c[4];
 422         } uia;
 423
 424         /* The data will be int aligned. */
 425         xi = (struct xdr_inaddr *) *pkt;
 426         *pkt += sizeof(*xi);
 427         if (xi->atype != htonl(1)) {
 428                 RPC_PRINTF(("xdr_inaddr_decode: bad addrtype=%d\n",
 429                     ntohl(xi->atype)));
 430                 return(-1);
 431         }
 432
 433         cp = uia.c;
 434         ip = xi->addr;
 435         /*
 436          * Note: the ntohl() calls below DO NOT
 437          * imply that uia.l is in host order.
 438          * In fact this needs it in net order.
 439          */
 440         *cp++ = ntohl(*ip++);
 441         *cp++ = ntohl(*ip++);
 442         *cp++ = ntohl(*ip++);
 443         *cp++ = ntohl(*ip++);
 444         ia->s_addr = uia.l;
 445
 446         return (0);
 447 }