usr/src/boot/lib/libstand/rpc.c

   1 /*      $NetBSD: rpc.c,v 1.18 1998/01/23 19:27:45 thorpej Exp $ */
   2
   3 /*
   4  * Copyright (c) 1992 Regents of the University of California.
   5  * All rights reserved.
   6  *
   7  * This software was developed by the Computer Systems Engineering group
   8  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
   9  * contributed to Berkeley.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 4. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  *
  35  * @(#) Header: rpc.c,v 1.12 93/09/28 08:31:56 leres Exp  (LBL)
  36  */
  37
  38 #include <sys/cdefs.h>
  39 __FBSDID("$FreeBSD$");
  40
  41 /*
  42  * RPC functions used by NFS and bootparams.
  43  * Note that bootparams requires the ability to find out the
  44  * address of the server from which its response has come.
  45  * This is supported by keeping the IP/UDP headers in the
  46  * buffer space provided by the caller.  (See rpc_fromaddr)
  47  */
  48
  49 #include <sys/param.h>
  50 #include <sys/socket.h>
  51
  52 #include <netinet/in.h>
  53 #include <netinet/in_systm.h>
  54
  55 #include <string.h>
  56
  57 #include "rpcv2.h"
  58
  59 #include "stand.h"
  60 #include "net.h"
  61 #include "netif.h"
  62 #include "rpc.h"
  63
  64 struct auth_info {
  65         int32_t         authtype;       /* auth type */
  66         u_int32_t       authlen;        /* auth length */
  67 };
  68
  69 struct auth_unix {
  70         int32_t   ua_time;
  71         int32_t   ua_hostname;  /* null */
  72         int32_t   ua_uid;
  73         int32_t   ua_gid;
  74         int32_t   ua_gidlist;   /* null */
  75 };
  76
  77 struct rpc_call {
  78         u_int32_t       rp_xid;         /* request transaction id */
  79         int32_t         rp_direction;   /* call direction (0) */
  80         u_int32_t       rp_rpcvers;     /* rpc version (2) */
  81         u_int32_t       rp_prog;        /* program */
  82         u_int32_t       rp_vers;        /* version */
  83         u_int32_t       rp_proc;        /* procedure */
  84 };
  85
  86 struct rpc_reply {
  87         u_int32_t       rp_xid;         /* request transaction id */
  88         int32_t         rp_direction;   /* call direction (1) */
  89         int32_t         rp_astatus;     /* accept status (0: accepted) */
  90         union {
  91                 u_int32_t       rpu_errno;
  92                 struct {
  93                         struct auth_info rok_auth;
  94                         u_int32_t       rok_status;
  95                 } rpu_rok;
  96         } rp_u;
  97 };
  98
  99 /* Local forwards */
 100 static  ssize_t recvrpc(struct iodesc *, void *, size_t, time_t);
 101 static  int rpc_getport(struct iodesc *, n_long, n_long);
 102
 103 int rpc_xid;
 104 int rpc_port = 0x400;   /* predecrement */
 105
 106 /*
 107  * Make a rpc call; return length of answer
 108  * Note: Caller must leave room for headers.
 109  */
 110 ssize_t
 111 rpc_call(struct iodesc *d, n_long prog, n_long vers, n_long proc,
 112         void *sdata, size_t slen, void *rdata, size_t rlen)
 113 {
 114         ssize_t cc;
 115         struct auth_info *auth;
 116         struct rpc_call *call;
 117         struct rpc_reply *reply;
 118         char *send_head, *send_tail;
 119         char *recv_head, *recv_tail;
 120         n_long x;
 121         int port;       /* host order */
 122
 123 #ifdef RPC_DEBUG
 124         if (debug)
 125                 printf("rpc_call: prog=0x%x vers=%d proc=%d\n",
 126                     prog, vers, proc);
 127 #endif
 128
 129         port = rpc_getport(d, prog, vers);
 130         if (port == -1)
 131                 return (-1);
 132
 133         d->destport = htons(port);
 134
 135         /*
 136          * Prepend authorization stuff and headers.
 137          * Note, must prepend things in reverse order.
 138          */
 139         send_head = sdata;
 140         send_tail = (char *)sdata + slen;
 141
 142         /* Auth verifier is always auth_null */
 143         send_head -= sizeof(*auth);
 144         auth = (struct auth_info *)send_head;
 145         auth->authtype = htonl(RPCAUTH_NULL);
 146         auth->authlen = 0;
 147
 148 #if 1
 149         /* Auth credentials: always auth unix (as root) */
 150         send_head -= sizeof(struct auth_unix);
 151         bzero(send_head, sizeof(struct auth_unix));
 152         send_head -= sizeof(*auth);
 153         auth = (struct auth_info *)send_head;
 154         auth->authtype = htonl(RPCAUTH_UNIX);
 155         auth->authlen = htonl(sizeof(struct auth_unix));
 156 #else
 157         /* Auth credentials: always auth_null (XXX OK?) */
 158         send_head -= sizeof(*auth);
 159         auth = send_head;
 160         auth->authtype = htonl(RPCAUTH_NULL);
 161         auth->authlen = 0;
 162 #endif
 163
 164         /* RPC call structure. */
 165         send_head -= sizeof(*call);
 166         call = (struct rpc_call *)send_head;
 167         rpc_xid++;
 168         call->rp_xid       = htonl(rpc_xid);
 169         call->rp_direction = htonl(RPC_CALL);
 170         call->rp_rpcvers   = htonl(RPC_VER2);
 171         call->rp_prog = htonl(prog);
 172         call->rp_vers = htonl(vers);
 173         call->rp_proc = htonl(proc);
 174
 175         /* Make room for the rpc_reply header. */
 176         recv_head = rdata;
 177         recv_tail = (char *)rdata + rlen;
 178         recv_head -= sizeof(*reply);
 179
 180         cc = sendrecv(d,
 181             sendudp, send_head, send_tail - send_head,
 182             recvrpc, recv_head, recv_tail - recv_head);
 183
 184 #ifdef RPC_DEBUG
 185         if (debug)
 186                 printf("callrpc: cc=%ld rlen=%lu\n", (long)cc, (u_long)rlen);
 187 #endif
 188         if (cc == -1)
 189                 return (-1);
 190
 191         if (cc <= sizeof(*reply)) {
 192                 errno = EBADRPC;
 193                 return (-1);
 194         }
 195
 196         recv_tail = recv_head + cc;
 197
 198         /*
 199          * Check the RPC reply status.
 200          * The xid, dir, astatus were already checked.
 201          */
 202         reply = (struct rpc_reply *)recv_head;
 203         auth = &reply->rp_u.rpu_rok.rok_auth;
 204         x = ntohl(auth->authlen);
 205         if (x != 0) {
 206 #ifdef RPC_DEBUG
 207                 if (debug)
 208                         printf("callrpc: reply auth != NULL\n");
 209 #endif
 210                 errno = EBADRPC;
 211                 return(-1);
 212         }
 213         x = ntohl(reply->rp_u.rpu_rok.rok_status);
 214         if (x != 0) {
 215                 printf("callrpc: error = %ld\n", (long)x);
 216                 errno = EBADRPC;
 217                 return(-1);
 218         }
 219         recv_head += sizeof(*reply);
 220
 221         return (ssize_t)(recv_tail - recv_head);
 222 }
 223
 224 /*
 225  * Returns true if packet is the one we're waiting for.
 226  * This just checks the XID, direction, acceptance.
 227  * Remaining checks are done by callrpc
 228  */
 229 static ssize_t
 230 recvrpc(struct iodesc *d, void *pkt, size_t len, time_t tleft)
 231 {
 232         struct rpc_reply *reply;
 233         ssize_t n;
 234         int     x;
 235
 236         errno = 0;
 237 #ifdef RPC_DEBUG
 238         if (debug)
 239                 printf("recvrpc: called len=%lu\n", (u_long)len);
 240 #endif
 241
 242         n = readudp(d, pkt, len, tleft);
 243         if (n <= (4 * 4))
 244                 return -1;
 245
 246         reply = (struct rpc_reply *)pkt;
 247
 248         x = ntohl(reply->rp_xid);
 249         if (x != rpc_xid) {
 250 #ifdef RPC_DEBUG
 251                 if (debug)
 252                         printf("recvrpc: rp_xid %d != xid %d\n", x, rpc_xid);
 253 #endif
 254                 return -1;
 255         }
 256
 257         x = ntohl(reply->rp_direction);
 258         if (x != RPC_REPLY) {
 259 #ifdef RPC_DEBUG
 260                 if (debug)
 261                         printf("recvrpc: rp_direction %d != REPLY\n", x);
 262 #endif
 263                 return -1;
 264         }
 265
 266         x = ntohl(reply->rp_astatus);
 267         if (x != RPC_MSGACCEPTED) {
 268                 errno = ntohl(reply->rp_u.rpu_errno);
 269                 printf("recvrpc: reject, astat=%d, errno=%d\n", x, errno);
 270                 return -1;
 271         }
 272
 273         /* Return data count (thus indicating success) */
 274         return (n);
 275 }
 276
 277 /*
 278  * Given a pointer to a reply just received,
 279  * dig out the IP address/port from the headers.
 280  */
 281 void
 282 rpc_fromaddr(void *pkt, struct in_addr *addr, u_short *port)
 283 {
 284         struct hackhdr {
 285                 /* Tail of IP header: just IP addresses */
 286                 n_long ip_src;
 287                 n_long ip_dst;
 288                 /* UDP header: */
 289                 u_int16_t uh_sport;             /* source port */
 290                 u_int16_t uh_dport;             /* destination port */
 291                 int16_t   uh_ulen;              /* udp length */
 292                 u_int16_t uh_sum;               /* udp checksum */
 293                 /* RPC reply header: */
 294                 struct rpc_reply rpc;
 295         } *hhdr;
 296
 297         hhdr = ((struct hackhdr *)pkt) - 1;
 298         addr->s_addr = hhdr->ip_src;
 299         *port = hhdr->uh_sport;
 300 }
 301
 302 /*
 303  * RPC Portmapper cache
 304  */
 305 #define PMAP_NUM 8                      /* need at most 5 pmap entries */
 306
 307 int rpc_pmap_num;
 308 struct pmap_list {
 309         struct in_addr  addr;   /* server, net order */
 310         u_int   prog;           /* host order */
 311         u_int   vers;           /* host order */
 312         int     port;           /* host order */
 313 } rpc_pmap_list[PMAP_NUM];
 314
 315 /*
 316  * return port number in host order, or -1.
 317  * arguments are:
 318  *  addr .. server, net order.
 319  *  prog .. host order.
 320  *  vers .. host order.
 321  */
 322 int
 323 rpc_pmap_getcache(struct in_addr addr, u_int prog, u_int vers)
 324 {
 325         struct pmap_list *pl;
 326
 327         for (pl = rpc_pmap_list; pl < &rpc_pmap_list[rpc_pmap_num]; pl++) {
 328                 if (pl->addr.s_addr == addr.s_addr &&
 329                         pl->prog == prog && pl->vers == vers )
 330                 {
 331                         return (pl->port);
 332                 }
 333         }
 334         return (-1);
 335 }
 336
 337 /*
 338  * arguments are:
 339  *  addr .. server, net order.
 340  *  prog .. host order.
 341  *  vers .. host order.
 342  *  port .. host order.
 343  */
 344 void
 345 rpc_pmap_putcache(struct in_addr addr, u_int prog, u_int vers, int port)
 346 {
 347         struct pmap_list *pl;
 348
 349         /* Don't overflow cache... */
 350         if (rpc_pmap_num >= PMAP_NUM) {
 351                 /* ... just re-use the last entry. */
 352                 rpc_pmap_num = PMAP_NUM - 1;
 353 #ifdef  RPC_DEBUG
 354                 printf("rpc_pmap_putcache: cache overflow\n");
 355 #endif
 356         }
 357
 358         pl = &rpc_pmap_list[rpc_pmap_num];
 359         rpc_pmap_num++;
 360
 361         /* Cache answer */
 362         pl->addr = addr;
 363         pl->prog = prog;
 364         pl->vers = vers;
 365         pl->port = port;
 366 }
 367
 368
 369 /*
 370  * Request a port number from the port mapper.
 371  * Returns the port in host order.
 372  * prog and vers are host order.
 373  */
 374 int
 375 rpc_getport(struct iodesc *d, n_long prog, n_long vers)
 376 {
 377         struct args {
 378                 n_long  prog;           /* call program */
 379                 n_long  vers;           /* call version */
 380                 n_long  proto;          /* call protocol */
 381                 n_long  port;           /* call port (unused) */
 382         } *args;
 383         struct res {
 384                 n_long port;
 385         } *res;
 386         struct {
 387                 n_long  h[RPC_HEADER_WORDS];
 388                 struct args d;
 389         } sdata;
 390         struct {
 391                 n_long  h[RPC_HEADER_WORDS];
 392                 struct res d;
 393                 n_long  pad;
 394         } rdata;
 395         ssize_t cc;
 396         int port;
 397
 398 #ifdef RPC_DEBUG
 399         if (debug)
 400                 printf("%s: prog=0x%x vers=%d\n", __func__, prog, vers);
 401 #endif
 402
 403         /* This one is fixed forever. */
 404         if (prog == PMAPPROG) {
 405                 port = PMAPPORT;
 406                 goto out;
 407         }
 408
 409         /* Try for cached answer first */
 410         port = rpc_pmap_getcache(d->destip, prog, vers);
 411         if (port != -1)
 412                 goto out;
 413
 414         args = &sdata.d;
 415         args->prog = htonl(prog);
 416         args->vers = htonl(vers);
 417         args->proto = htonl(IPPROTO_UDP);
 418         args->port = 0;
 419         res = &rdata.d;
 420
 421         cc = rpc_call(d, PMAPPROG, PMAPVERS, PMAPPROC_GETPORT,
 422                 args, sizeof(*args), res, sizeof(*res));
 423         if (cc < sizeof(*res)) {
 424                 printf("getport: %s", strerror(errno));
 425                 errno = EBADRPC;
 426                 return (-1);
 427         }
 428         port = (int)ntohl(res->port);
 429
 430         rpc_pmap_putcache(d->destip, prog, vers, port);
 431
 432 out:
 433 #ifdef RPC_DEBUG
 434         if (debug)
 435                 printf("%s: port=%u\n", __func__, port);
 436 #endif
 437         return (port);
 438 }