sys/lib/libsa/rpc.c

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