usr.sbin/rpcbind/rpcb_svc_4.c

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