sys/lib/libsa/bootparam.c

   1 /*      $NetBSD: bootparam.c,v 1.19 2009/10/21 23:12:10 snj 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  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 /*
  29  * RPC/bootparams
  30  */
  31
  32 #include <sys/param.h>
  33 #include <sys/socket.h>
  34
  35 #include <net/if.h>
  36
  37 #include <netinet/in.h>
  38 #include <netinet/in_systm.h>
  39
  40 #ifdef _STANDALONE
  41 #include <lib/libkern/libkern.h>
  42 #else
  43 #include <string.h>
  44 #endif
  45
  46 #include "rpcv2.h"
  47
  48 #include "stand.h"
  49 #include "net.h"
  50 #include "rpc.h"
  51 #include "bootparam.h"
  52
  53 #ifdef DEBUG_RPC
  54 #define RPC_PRINTF(a)   printf a
  55 #else
  56 #define RPC_PRINTF(a)
  57 #endif
  58
  59 struct in_addr  bp_server_addr; /* net order */
  60 n_short         bp_server_port; /* net order */
  61
  62 int             hostnamelen;
  63 char            domainname[FNAME_SIZE]; /* our DNS domain */
  64 int             domainnamelen;
  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 **, struct in_addr);
  84 int xdr_inaddr_decode(char **, struct in_addr *);
  85
  86 int xdr_string_encode(char **, char *, int);
  87 int xdr_string_decode(char **, char *, int *);
  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_port);
 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_port);
 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         (void)memcpy(datap, str, len);
 340
 341         return 0;
 342 }
 343
 344 /* len_p: bufsize - 1 */
 345 int
 346 xdr_string_decode(char **pkt, char *str, int *len_p)
 347 {
 348         u_int32_t *lenp;
 349         char *datap;
 350         int slen;       /* string length */
 351         int plen;       /* padded length */
 352
 353         /* The data will be int aligned. */
 354         lenp = (u_int32_t *)*pkt;
 355         *pkt += sizeof(*lenp);
 356         slen = ntohl(*lenp);
 357         plen = (slen + 3) & ~3;
 358
 359         if (slen > *len_p)
 360                 slen = *len_p;
 361         datap = *pkt;
 362         *pkt += plen;
 363         (void)memcpy(str, datap, slen);
 364
 365         str[slen] = '\0';
 366         *len_p = slen;
 367
 368         return 0;
 369 }
 370
 371
 372 /* ia: network order */
 373 int
 374 xdr_inaddr_encode(char **pkt, struct in_addr ia)
 375 {
 376         struct xdr_inaddr *xi;
 377         u_char *cp;
 378         int32_t *ip;
 379         union {
 380                 n_long l;       /* network order */
 381                 u_char c[4];
 382         } uia;
 383
 384         /* The data will be int aligned. */
 385         xi = (struct xdr_inaddr *)*pkt;
 386         *pkt += sizeof(*xi);
 387         xi->atype = htonl(1);
 388         uia.l = ia.s_addr;
 389         cp = uia.c;
 390         ip = xi->addr;
 391         /*
 392          * Note: the htonl() calls below DO NOT
 393          * imply that uia.l is in host order.
 394          * In fact this needs it in net order.
 395          */
 396         *ip++ = htonl((unsigned int)*cp++);
 397         *ip++ = htonl((unsigned int)*cp++);
 398         *ip++ = htonl((unsigned int)*cp++);
 399         *ip++ = htonl((unsigned int)*cp++);
 400
 401         return 0;
 402 }
 403
 404 /* ia: network order */
 405 int
 406 xdr_inaddr_decode(char **pkt, struct in_addr *ia)
 407 {
 408         struct xdr_inaddr *xi;
 409         u_char *cp;
 410         int32_t *ip;
 411         union {
 412                 n_long l;       /* network order */
 413                 u_char c[4];
 414         } uia;
 415
 416         /* The data will be int aligned. */
 417         xi = (struct xdr_inaddr *)*pkt;
 418         *pkt += sizeof(*xi);
 419         if (xi->atype != htonl(1)) {
 420                 RPC_PRINTF(("xdr_inaddr_decode: bad addrtype=%d\n",
 421                     ntohl(xi->atype)));
 422                 return -1;
 423         }
 424
 425         cp = uia.c;
 426         ip = xi->addr;
 427         /*
 428          * Note: the ntohl() calls below DO NOT
 429          * imply that uia.l is in host order.
 430          * In fact this needs it in net order.
 431          */
 432         *cp++ = ntohl(*ip++);
 433         *cp++ = ntohl(*ip++);
 434         *cp++ = ntohl(*ip++);
 435         *cp++ = ntohl(*ip++);
 436         ia->s_addr = uia.l;
 437
 438         return 0;
 439 }