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 } 439