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