1 /* 2 * $NetBSD: rpcb_svc_4.c,v 1.1 2000/06/02 23:15:41 fvdl Exp $ 3 * $FreeBSD$ 4 */ 5 6 /* 7 * Sun RPC is a product of Sun Microsystems, Inc. and is provided for 8 * unrestricted use provided that this legend is included on all tape 9 * media and as a part of the software program in whole or part. Users 10 * may copy or modify Sun RPC without charge, but are not authorized 11 * to license or distribute it to anyone else except as part of a product or 12 * program developed by the user. 13 * 14 * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE 15 * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR 16 * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. 17 * 18 * Sun RPC is provided with no support and without any obligation on the 19 * part of Sun Microsystems, Inc. to assist in its use, correction, 20 * modification or enhancement. 21 * 22 * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE 23 * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC 24 * OR ANY PART THEREOF. 25 * 26 * In no event will Sun Microsystems, Inc. be liable for any lost revenue 27 * or profits or other special, indirect and consequential damages, even if 28 * Sun has been advised of the possibility of such damages. 29 * 30 * Sun Microsystems, Inc. 31 * 2550 Garcia Avenue 32 * Mountain View, California 94043 33 */ 34 /* 35 * Copyright (c) 1986 - 1991 by Sun Microsystems, Inc. 36 */ 37 38 /* #ident "@(#)rpcb_svc_4.c 1.8 93/07/05 SMI" */ 39 40 /* 41 * rpcb_svc_4.c 42 * The server procedure for the version 4 rpcbind. 43 * 44 */ 45 46 #include <sys/types.h> 47 #include <sys/stat.h> 48 #include <rpc/rpc.h> 49 #include <stdio.h> 50 #include <unistd.h> 51 #include <netconfig.h> 52 #include <syslog.h> 53 #include <string.h> 54 #include <stdlib.h> 55 #include "rpcbind.h" 56 57 static void *rpcbproc_getaddr_4_local __P((void *, struct svc_req *, SVCXPRT *, 58 rpcvers_t)); 59 static void *rpcbproc_getversaddr_4_local __P((void *, struct svc_req *, SVCXPRT *, rpcvers_t)); 60 static void *rpcbproc_getaddrlist_4_local 61 __P((void *, struct svc_req *, SVCXPRT *, rpcvers_t)); 62 static void free_rpcb_entry_list __P((rpcb_entry_list_ptr *)); 63 static void *rpcbproc_dump_4_local __P((void *, struct svc_req *, SVCXPRT *, rpcvers_t)); 64 65 /* 66 * Called by svc_getreqset. There is a separate server handle for 67 * every transport that it waits on. 68 */ 69 void 70 rpcb_service_4(struct svc_req *rqstp, SVCXPRT *transp) 71 { 72 union { 73 rpcb rpcbproc_set_4_arg; 74 rpcb rpcbproc_unset_4_arg; 75 rpcb rpcbproc_getaddr_4_local_arg; 76 char *rpcbproc_uaddr2taddr_4_arg; 77 struct netbuf rpcbproc_taddr2uaddr_4_arg; 78 } argument; 79 char *result; 80 xdrproc_t xdr_argument, xdr_result; 81 void *(*local) __P((void *, struct svc_req *, SVCXPRT *, rpcvers_t)); 82 83 rpcbs_procinfo(RPCBVERS_4_STAT, rqstp->rq_proc); 84 85 switch (rqstp->rq_proc) { 86 case NULLPROC: 87 /* 88 * Null proc call 89 */ 90 #ifdef RPCBIND_DEBUG 91 if (debugging) 92 fprintf(stderr, "RPCBPROC_NULL\n"); 93 #endif 94 check_access(transp, rqstp->rq_proc, NULL, RPCBVERS4); 95 (void) svc_sendreply(transp, (xdrproc_t) xdr_void, 96 (char *)NULL); 97 return; 98 99 case RPCBPROC_SET: 100 /* 101 * Check to see whether the message came from 102 * loopback transports (for security reasons) 103 */ 104 xdr_argument = (xdrproc_t)xdr_rpcb; 105 xdr_result = (xdrproc_t)xdr_bool; 106 local = rpcbproc_set_com; 107 break; 108 109 case RPCBPROC_UNSET: 110 /* 111 * Check to see whether the message came from 112 * loopback transports (for security reasons) 113 */ 114 xdr_argument = (xdrproc_t)xdr_rpcb; 115 xdr_result = (xdrproc_t)xdr_bool; 116 local = rpcbproc_unset_com; 117 break; 118 119 case RPCBPROC_GETADDR: 120 xdr_argument = (xdrproc_t)xdr_rpcb; 121 xdr_result = (xdrproc_t)xdr_wrapstring; 122 local = rpcbproc_getaddr_4_local; 123 break; 124 125 case RPCBPROC_GETVERSADDR: 126 #ifdef RPCBIND_DEBUG 127 if (debugging) 128 fprintf(stderr, "RPCBPROC_GETVERSADDR\n"); 129 #endif 130 xdr_argument = (xdrproc_t)xdr_rpcb; 131 xdr_result = (xdrproc_t)xdr_wrapstring; 132 local = rpcbproc_getversaddr_4_local; 133 break; 134 135 case RPCBPROC_DUMP: 136 #ifdef RPCBIND_DEBUG 137 if (debugging) 138 fprintf(stderr, "RPCBPROC_DUMP\n"); 139 #endif 140 xdr_argument = (xdrproc_t)xdr_void; 141 xdr_result = (xdrproc_t)xdr_rpcblist_ptr; 142 local = rpcbproc_dump_4_local; 143 break; 144 145 case RPCBPROC_INDIRECT: 146 #ifdef RPCBIND_DEBUG 147 if (debugging) 148 fprintf(stderr, "RPCBPROC_INDIRECT\n"); 149 #endif 150 rpcbproc_callit_com(rqstp, transp, rqstp->rq_proc, RPCBVERS4); 151 return; 152 153 /* case RPCBPROC_CALLIT: */ 154 case RPCBPROC_BCAST: 155 #ifdef RPCBIND_DEBUG 156 if (debugging) 157 fprintf(stderr, "RPCBPROC_BCAST\n"); 158 #endif 159 rpcbproc_callit_com(rqstp, transp, rqstp->rq_proc, RPCBVERS4); 160 return; 161 162 case RPCBPROC_GETTIME: 163 #ifdef RPCBIND_DEBUG 164 if (debugging) 165 fprintf(stderr, "RPCBPROC_GETTIME\n"); 166 #endif 167 xdr_argument = (xdrproc_t)xdr_void; 168 xdr_result = (xdrproc_t)xdr_u_long; 169 local = rpcbproc_gettime_com; 170 break; 171 172 case RPCBPROC_UADDR2TADDR: 173 #ifdef RPCBIND_DEBUG 174 if (debugging) 175 fprintf(stderr, "RPCBPROC_UADDR2TADDR\n"); 176 #endif 177 xdr_argument = (xdrproc_t)xdr_wrapstring; 178 xdr_result = (xdrproc_t)xdr_netbuf; 179 local = rpcbproc_uaddr2taddr_com; 180 break; 181 182 case RPCBPROC_TADDR2UADDR: 183 #ifdef RPCBIND_DEBUG 184 if (debugging) 185 fprintf(stderr, "RPCBPROC_TADDR2UADDR\n"); 186 #endif 187 xdr_argument = (xdrproc_t)xdr_netbuf; 188 xdr_result = (xdrproc_t)xdr_wrapstring; 189 local = rpcbproc_taddr2uaddr_com; 190 break; 191 192 case RPCBPROC_GETADDRLIST: 193 #ifdef RPCBIND_DEBUG 194 if (debugging) 195 fprintf(stderr, "RPCBPROC_GETADDRLIST\n"); 196 #endif 197 xdr_argument = (xdrproc_t)xdr_rpcb; 198 xdr_result = (xdrproc_t)xdr_rpcb_entry_list_ptr; 199 local = rpcbproc_getaddrlist_4_local; 200 break; 201 202 case RPCBPROC_GETSTAT: 203 #ifdef RPCBIND_DEBUG 204 if (debugging) 205 fprintf(stderr, "RPCBPROC_GETSTAT\n"); 206 #endif 207 xdr_argument = (xdrproc_t)xdr_void; 208 xdr_result = (xdrproc_t)xdr_rpcb_stat_byvers; 209 local = rpcbproc_getstat; 210 break; 211 212 default: 213 svcerr_noproc(transp); 214 return; 215 } 216 memset((char *)&argument, 0, sizeof (argument)); 217 if (!svc_getargs(transp, (xdrproc_t) xdr_argument, 218 (char *)&argument)) { 219 svcerr_decode(transp); 220 if (debugging) 221 (void) fprintf(stderr, "rpcbind: could not decode\n"); 222 return; 223 } 224 if (!check_access(transp, rqstp->rq_proc, &argument, RPCBVERS4)) { 225 svcerr_weakauth(transp); 226 goto done; 227 } 228 result = (*local)(&argument, rqstp, transp, RPCBVERS4); 229 if (result != NULL && !svc_sendreply(transp, (xdrproc_t) xdr_result, 230 result)) { 231 svcerr_systemerr(transp); 232 if (debugging) { 233 (void) fprintf(stderr, "rpcbind: svc_sendreply\n"); 234 if (doabort) { 235 rpcbind_abort(); 236 } 237 } 238 } 239 done: 240 if (!svc_freeargs(transp, (xdrproc_t) xdr_argument, 241 (char *)&argument)) { 242 if (debugging) { 243 (void) fprintf(stderr, "unable to free arguments\n"); 244 if (doabort) { 245 rpcbind_abort(); 246 } 247 } 248 } 249 return; 250 } 251 252 /* 253 * Lookup the mapping for a program, version and return its 254 * address. Assuming that the caller wants the address of the 255 * server running on the transport on which the request came. 256 * Even if a service with a different version number is available, 257 * it will return that address. The client should check with an 258 * clnt_call to verify whether the service is the one that is desired. 259 * We also try to resolve the universal address in terms of 260 * address of the caller. 261 */ 262 /* ARGSUSED */ 263 static void * 264 rpcbproc_getaddr_4_local(void *arg, struct svc_req *rqstp, SVCXPRT *transp, 265 rpcvers_t rpcbversnum __unused) 266 { 267 RPCB *regp = (RPCB *)arg; 268 #ifdef RPCBIND_DEBUG 269 if (debugging) { 270 char *uaddr; 271 272 uaddr = taddr2uaddr(rpcbind_get_conf(transp->xp_netid), 273 svc_getrpccaller(transp)); 274 fprintf(stderr, "RPCB_GETADDR req for (%lu, %lu, %s) from %s: ", 275 (unsigned long)regp->r_prog, (unsigned long)regp->r_vers, 276 regp->r_netid, uaddr); 277 free(uaddr); 278 } 279 #endif 280 return (rpcbproc_getaddr_com(regp, rqstp, transp, RPCBVERS4, 281 RPCB_ALLVERS)); 282 } 283 284 /* 285 * Lookup the mapping for a program, version and return its 286 * address. Assuming that the caller wants the address of the 287 * server running on the transport on which the request came. 288 * 289 * We also try to resolve the universal address in terms of 290 * address of the caller. 291 */ 292 /* ARGSUSED */ 293 static void * 294 rpcbproc_getversaddr_4_local(void *arg, struct svc_req *rqstp, SVCXPRT *transp, 295 rpcvers_t versnum __unused) 296 { 297 RPCB *regp = (RPCB *)arg; 298 #ifdef RPCBIND_DEBUG 299 if (debugging) { 300 char *uaddr; 301 302 uaddr = taddr2uaddr(rpcbind_get_conf(transp->xp_netid), 303 svc_getrpccaller(transp)); 304 fprintf(stderr, "RPCB_GETVERSADDR rqst for (%lu, %lu, %s)" 305 " from %s : ", 306 (unsigned long)regp->r_prog, (unsigned long)regp->r_vers, 307 regp->r_netid, uaddr); 308 free(uaddr); 309 } 310 #endif 311 return (rpcbproc_getaddr_com(regp, rqstp, transp, RPCBVERS4, 312 RPCB_ONEVERS)); 313 } 314 315 /* 316 * Lookup the mapping for a program, version and return the 317 * addresses for all transports in the current transport family. 318 * We return a merged address. 319 */ 320 /* ARGSUSED */ 321 static void * 322 rpcbproc_getaddrlist_4_local(void *arg, struct svc_req *rqstp __unused, 323 SVCXPRT *transp, rpcvers_t versnum __unused) 324 { 325 RPCB *regp = (RPCB *)arg; 326 static rpcb_entry_list_ptr rlist; 327 register rpcblist_ptr rbl; 328 rpcb_entry_list_ptr rp, tail; 329 rpcprog_t prog; 330 rpcvers_t vers; 331 rpcb_entry *a; 332 struct netconfig *nconf; 333 struct netconfig *reg_nconf; 334 char *saddr, *maddr = NULL; 335 336 free_rpcb_entry_list(&rlist); 337 tail = NULL; 338 prog = regp->r_prog; 339 vers = regp->r_vers; 340 reg_nconf = rpcbind_get_conf(transp->xp_netid); 341 if (reg_nconf == NULL) 342 return (NULL); 343 if (*(regp->r_addr) != '\0') { 344 saddr = regp->r_addr; 345 } else { 346 saddr = NULL; 347 } 348 #ifdef RPCBIND_DEBUG 349 if (debugging) { 350 fprintf(stderr, "r_addr: %s r_netid: %s nc_protofmly: %s\n", 351 regp->r_addr, regp->r_netid, reg_nconf->nc_protofmly); 352 } 353 #endif 354 for (rbl = list_rbl; rbl != NULL; rbl = rbl->rpcb_next) { 355 if ((rbl->rpcb_map.r_prog == prog) && 356 (rbl->rpcb_map.r_vers == vers)) { 357 nconf = rpcbind_get_conf(rbl->rpcb_map.r_netid); 358 if (nconf == NULL) 359 goto fail; 360 if (strcmp(nconf->nc_protofmly, reg_nconf->nc_protofmly) 361 != 0) { 362 continue; /* not same proto family */ 363 } 364 #ifdef RPCBIND_DEBUG 365 if (debugging) 366 fprintf(stderr, "\tmerge with: %s\n", 367 rbl->rpcb_map.r_addr); 368 #endif 369 if ((maddr = mergeaddr(transp, rbl->rpcb_map.r_netid, 370 rbl->rpcb_map.r_addr, saddr)) == NULL) { 371 #ifdef RPCBIND_DEBUG 372 if (debugging) 373 fprintf(stderr, " FAILED\n"); 374 #endif 375 continue; 376 } else if (!maddr[0]) { 377 #ifdef RPCBIND_DEBUG 378 if (debugging) 379 fprintf(stderr, " SUCCEEDED, but port died - maddr: nullstring\n"); 380 #endif 381 /* The server died. Unset this combination */ 382 delete_prog(regp->r_prog); 383 continue; 384 } 385 #ifdef RPCBIND_DEBUG 386 if (debugging) 387 fprintf(stderr, " SUCCEEDED maddr: %s\n", maddr); 388 #endif 389 /* 390 * Add it to rlist. 391 */ 392 rp = malloc(sizeof (rpcb_entry_list)); 393 if (rp == NULL) 394 goto fail; 395 a = &rp->rpcb_entry_map; 396 a->r_maddr = maddr; 397 a->r_nc_netid = nconf->nc_netid; 398 a->r_nc_semantics = nconf->nc_semantics; 399 a->r_nc_protofmly = nconf->nc_protofmly; 400 a->r_nc_proto = nconf->nc_proto; 401 rp->rpcb_entry_next = NULL; 402 if (rlist == NULL) { 403 rlist = rp; 404 tail = rp; 405 } else { 406 tail->rpcb_entry_next = rp; 407 tail = rp; 408 } 409 rp = NULL; 410 } 411 } 412 #ifdef RPCBIND_DEBUG 413 if (debugging) { 414 for (rp = rlist; rp; rp = rp->rpcb_entry_next) { 415 fprintf(stderr, "\t%s %s\n", rp->rpcb_entry_map.r_maddr, 416 rp->rpcb_entry_map.r_nc_proto); 417 } 418 } 419 #endif 420 /* 421 * XXX: getaddrlist info is also being stuffed into getaddr. 422 * Perhaps wrong, but better than it not getting counted at all. 423 */ 424 rpcbs_getaddr(RPCBVERS4 - 2, prog, vers, transp->xp_netid, maddr); 425 return (void *)&rlist; 426 427 fail: free_rpcb_entry_list(&rlist); 428 return (NULL); 429 } 430 431 /* 432 * Free only the allocated structure, rest is all a pointer to some 433 * other data somewhere else. 434 */ 435 static void 436 free_rpcb_entry_list(rpcb_entry_list_ptr *rlistp) 437 { 438 register rpcb_entry_list_ptr rbl, tmp; 439 440 for (rbl = *rlistp; rbl != NULL; ) { 441 tmp = rbl; 442 rbl = rbl->rpcb_entry_next; 443 free((char *)tmp->rpcb_entry_map.r_maddr); 444 free((char *)tmp); 445 } 446 *rlistp = NULL; 447 } 448 449 /* ARGSUSED */ 450 static void * 451 rpcbproc_dump_4_local(void *arg __unused, struct svc_req *req __unused, 452 SVCXPRT *xprt __unused, rpcvers_t versnum __unused) 453 { 454 return ((void *)&list_rbl); 455 } 456