usr/src/cmd/rpcbind/rpcb_svc_4.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 /*
  26  * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
  27  */
  28
  29 /*
  30  * rpcb_svc_4.c
  31  * The server procedure for the version 4 rpcbind.
  32  *
  33  */
  34
  35 #include <stdio.h>
  36 #include <sys/types.h>
  37 #include <sys/stat.h>
  38 #include <unistd.h>
  39 #include <rpc/rpc.h>
  40 #include <netconfig.h>
  41 #include <syslog.h>
  42 #include <netdir.h>
  43 #include <string.h>
  44 #include <stdlib.h>
  45 #include "rpcbind.h"
  46
  47 static void free_rpcb_entry_list(rpcb_entry_list_ptr);
  48 static bool_t xdr_rpcb_entry_list_ptr_wrap(XDR *, rpcb_entry_list_ptr *);
  49 static bool_t rpcbproc_getaddrlist(rpcb *, rpcb_entry_list_ptr *,
  50     struct svc_req *);
  51
  52 /*
  53  * Called by svc_getreqset. There is a separate server handle for
  54  * every transport that it waits on.
  55  */
  56 void
  57 rpcb_service_4(struct svc_req *rqstp, SVCXPRT *transp)
  58 {
  59         union {
  60                 rpcb rpcbproc_set_4_arg;
  61                 rpcb rpcbproc_unset_4_arg;
  62                 rpcb rpcbproc_getaddr_4_arg;
  63                 char *rpcbproc_uaddr2taddr_4_arg;
  64                 struct netbuf rpcbproc_taddr2uaddr_4_arg;
  65                 rpcb rpcbproc_getversaddr_4_arg;
  66                 rpcb rpcbproc_getaddrlist_4_arg;
  67         } argument;
  68         union {
  69                 bool_t rpcbproc_set_4_res;
  70                 bool_t rpcbproc_unset_4_res;
  71                 char *rpcbproc_getaddr_4_res;
  72                 rpcblist_ptr *rpcbproc_dump_4_res;
  73                 ulong_t rpcbproc_gettime_4_res;
  74                 struct netbuf rpcbproc_uaddr2taddr_4_res;
  75                 char *rpcbproc_taddr2uaddr_4_res;
  76                 char *rpcbproc_getversaddr_4_res;
  77                 rpcb_entry_list_ptr rpcbproc_getaddrlist_4_res;
  78                 rpcb_stat_byvers *rpcbproc_getstat_4_res;
  79         } result;
  80         bool_t retval;
  81         xdrproc_t xdr_argument, xdr_result;
  82         bool_t (*local)();
  83
  84         rpcbs_procinfo(RPCBVERS_4_STAT, rqstp->rq_proc);
  85
  86         RPCB_CHECK(transp, rqstp->rq_proc);
  87
  88         switch (rqstp->rq_proc) {
  89         case NULLPROC:
  90                 /*
  91                  * Null proc call
  92                  */
  93                 (void) svc_sendreply(transp, (xdrproc_t)xdr_void, NULL);
  94                 return;
  95
  96         case RPCBPROC_SET:
  97                 /*
  98                  * Check to see whether the message came from
  99                  * loopback transports (for security reasons)
 100                  */
 101                 if (strcasecmp(transp->xp_netid, loopback_dg) &&
 102                     strcasecmp(transp->xp_netid, loopback_vc) &&
 103                     strcasecmp(transp->xp_netid, loopback_vc_ord)) {
 104                         syslog(LOG_ERR, "non-local attempt to set");
 105                         svcerr_weakauth(transp);
 106                         return;
 107                 }
 108                 xdr_argument = xdr_rpcb;
 109                 xdr_result = xdr_bool;
 110                 local = (bool_t (*)()) rpcbproc_set_com;
 111                 break;
 112
 113         case RPCBPROC_UNSET:
 114                 /*
 115                  * Check to see whether the message came from
 116                  * loopback transports (for security reasons)
 117                  */
 118                 if (strcasecmp(transp->xp_netid, loopback_dg) &&
 119                     strcasecmp(transp->xp_netid, loopback_vc) &&
 120                     strcasecmp(transp->xp_netid, loopback_vc_ord)) {
 121                         syslog(LOG_ERR, "non-local attempt to unset");
 122                         svcerr_weakauth(transp);
 123                         return;
 124                 }
 125                 xdr_argument = xdr_rpcb;
 126                 xdr_result = xdr_bool;
 127                 local = (bool_t (*)()) rpcbproc_unset_com;
 128                 break;
 129
 130         case RPCBPROC_GETADDR:
 131                 xdr_argument = xdr_rpcb;
 132                 xdr_result = xdr_wrapstring;
 133                 local = (bool_t (*)()) rpcbproc_getaddr_com;
 134                 break;
 135
 136         case RPCBPROC_DUMP:
 137                 xdr_argument = xdr_void;
 138                 xdr_result = xdr_rpcblist_ptr_ptr;
 139                 local = (bool_t (*)()) rpcbproc_dump_com;
 140                 break;
 141
 142         case RPCBPROC_BCAST:
 143                 rpcbproc_callit_com(rqstp, transp, rqstp->rq_proc, RPCBVERS4);
 144                 return;
 145
 146         case RPCBPROC_GETTIME:
 147                 xdr_argument = xdr_void;
 148                 xdr_result = xdr_u_long;
 149                 local = (bool_t (*)()) rpcbproc_gettime_com;
 150                 break;
 151
 152         case RPCBPROC_UADDR2TADDR:
 153                 xdr_argument = xdr_wrapstring;
 154                 xdr_result = xdr_netbuf;
 155                 local = (bool_t (*)()) rpcbproc_uaddr2taddr_com;
 156                 break;
 157
 158         case RPCBPROC_TADDR2UADDR:
 159                 xdr_argument = xdr_netbuf;
 160                 xdr_result = xdr_wrapstring;
 161                 local = (bool_t (*)()) rpcbproc_taddr2uaddr_com;
 162                 break;
 163
 164         case RPCBPROC_GETVERSADDR:
 165                 xdr_argument = xdr_rpcb;
 166                 xdr_result = xdr_wrapstring;
 167                 local = (bool_t (*)()) rpcbproc_getaddr_com;
 168                 break;
 169
 170         case RPCBPROC_INDIRECT:
 171                 rpcbproc_callit_com(rqstp, transp, rqstp->rq_proc, RPCBVERS4);
 172                 return;
 173
 174         case RPCBPROC_GETADDRLIST:
 175                 xdr_argument = xdr_rpcb;
 176                 xdr_result = xdr_rpcb_entry_list_ptr_wrap;
 177                 local = (bool_t (*)()) rpcbproc_getaddrlist;
 178                 break;
 179
 180         case RPCBPROC_GETSTAT:
 181                 xdr_argument = xdr_void;
 182                 xdr_result = xdr_rpcb_stat_byvers_ptr;
 183                 local = (bool_t (*)()) rpcbproc_getstat;
 184                 break;
 185
 186         default:
 187                 svcerr_noproc(transp);
 188                 return;
 189         }
 190         (void) memset((char *)&argument, 0, sizeof (argument));
 191         if (!svc_getargs(transp, xdr_argument, (char *)&argument)) {
 192                 svcerr_decode(transp);
 193                 if (debugging)
 194                         (void) fprintf(stderr, "rpcbind: could not decode\n");
 195                 return;
 196         }
 197         retval = (*local)(&argument, &result, rqstp, RPCBVERS4);
 198         if (retval > 0 && !svc_sendreply(transp, xdr_result, (char *)&result)) {
 199                 svcerr_systemerr(transp);
 200                 if (debugging) {
 201                         (void) fprintf(stderr, "rpcbind: svc_sendreply\n");
 202                         if (doabort) {
 203                                 rpcbind_abort();
 204                         }
 205                 }
 206         }
 207         if (!svc_freeargs(transp, xdr_argument, (char *)&argument)) {
 208                 if (debugging) {
 209                         (void) fprintf(stderr, "unable to free arguments\n");
 210                         if (doabort) {
 211                                 rpcbind_abort();
 212                         }
 213                 }
 214         }
 215
 216         xdr_free(xdr_result, (char *)&result);
 217 }
 218
 219 /*
 220  * Lookup the mapping for a program, version and return the
 221  * addresses for all transports in the current transport family.
 222  * We return a merged address.
 223  */
 224 static bool_t
 225 rpcbproc_getaddrlist(rpcb *regp, rpcb_entry_list_ptr *result,
 226     struct svc_req *rqstp)
 227 {
 228         rpcb_entry_list_ptr rlist = *result = NULL;
 229         rpcblist_ptr rbl, next, prev;
 230         rpcb_entry_list_ptr rp, tail = NULL;
 231         ulong_t prog, vers;
 232         rpcb_entry *a;
 233         struct netconfig *nconf;
 234         struct netconfig *reg_nconf;
 235         char *saddr, *maddr = NULL;
 236         struct netconfig *trans_conf;   /* transport netconfig */
 237         SVCXPRT *transp = rqstp->rq_xprt;
 238
 239         /*
 240          * Deal with a possible window during which we could return an IPv6
 241          * address when the caller wanted IPv4.  See the comments in
 242          * rpcbproc_getaddr_com() for more details.
 243          */
 244         trans_conf = rpcbind_get_conf(transp->xp_netid);
 245         if (strcmp(trans_conf->nc_protofmly, NC_INET6) == 0) {
 246                 struct sockaddr_in6 *rmtaddr;
 247
 248                 rmtaddr = (struct sockaddr_in6 *)transp->xp_rtaddr.buf;
 249                 if (IN6_IS_ADDR_V4MAPPED(&rmtaddr->sin6_addr)) {
 250                         syslog(LOG_DEBUG,
 251                             "IPv4 GETADDRLIST request mapped "
 252                             "to IPv6: ignoring");
 253                         return (FALSE);
 254                 }
 255         }
 256
 257         prog = regp->r_prog;
 258         vers = regp->r_vers;
 259         reg_nconf = rpcbind_get_conf(transp->xp_netid);
 260         if (reg_nconf == NULL)
 261                 return (FALSE);
 262         if (*(regp->r_addr) != '\0') {
 263                 saddr = regp->r_addr;
 264         } else {
 265                 saddr = NULL;
 266         }
 267
 268         prev = NULL;
 269         (void) rw_wrlock(&list_rbl_lock);
 270         for (rbl = list_rbl; rbl != NULL; rbl = next) {
 271                 next = rbl->rpcb_next;
 272                 if ((rbl->rpcb_map.r_prog == prog) &&
 273                     (rbl->rpcb_map.r_vers == vers)) {
 274                         nconf = rpcbind_get_conf(rbl->rpcb_map.r_netid);
 275                         if (nconf == NULL) {
 276                                 (void) rw_unlock(&list_rbl_lock);
 277                                 goto fail;
 278                         }
 279                         if (strcmp(nconf->nc_protofmly, reg_nconf->nc_protofmly)
 280                             != 0) {
 281                                 prev = rbl;
 282                                 continue;       /* not same proto family */
 283                         }
 284                         if ((maddr = mergeaddr(transp, rbl->rpcb_map.r_netid,
 285                             rbl->rpcb_map.r_addr, saddr)) == NULL) {
 286                                 prev = rbl;
 287                                 continue;
 288                         } else if (!maddr[0]) {
 289                                 /*
 290                                  * The server died, remove this rpcb_map element
 291                                  * from the list and free it.
 292                                  */
 293 #ifdef PORTMAP
 294                                 (void) rw_wrlock(&list_pml_lock);
 295                                 (void) del_pmaplist(&rbl->rpcb_map);
 296                                 (void) rw_unlock(&list_pml_lock);
 297 #endif
 298                                 (void) delete_rbl(rbl);
 299
 300                                 if (prev == NULL)
 301                                         list_rbl = next;
 302                                 else
 303                                         prev->rpcb_next = next;
 304                                 continue;
 305                         }
 306                         /*
 307                          * Add it to rlist.
 308                          */
 309                         rp = (rpcb_entry_list_ptr)
 310                             malloc((uint_t)sizeof (rpcb_entry_list));
 311                         if (rp == NULL) {
 312                                 (void) rw_unlock(&list_rbl_lock);
 313                                 goto fail;
 314                         }
 315                         a = &rp->rpcb_entry_map;
 316                         a->r_maddr = maddr;
 317                         a->r_nc_netid = nconf->nc_netid;
 318                         a->r_nc_semantics = nconf->nc_semantics;
 319                         a->r_nc_protofmly = nconf->nc_protofmly;
 320                         a->r_nc_proto = nconf->nc_proto;
 321                         rp->rpcb_entry_next = NULL;
 322                         if (rlist == NULL) {
 323                                 rlist = rp;
 324                                 tail = rp;
 325                         } else {
 326                                 tail->rpcb_entry_next = rp;
 327                                 tail = rp;
 328                         }
 329                         rp = NULL;
 330                 }
 331                 prev = rbl;
 332         }
 333         (void) rw_unlock(&list_rbl_lock);
 334
 335         /*
 336          * XXX: getaddrlist info is also being stuffed into getaddr.
 337          * Perhaps wrong, but better than it not getting counted at all.
 338          */
 339         rpcbs_getaddr(RPCBVERS_4_STAT, prog, vers, transp->xp_netid, maddr);
 340
 341         *result = rlist;
 342         return (TRUE);
 343
 344 fail:
 345         free_rpcb_entry_list(rlist);
 346         return (FALSE);
 347 }
 348
 349 /*
 350  * Free only the allocated structure, rest is all a pointer to some
 351  * other data somewhere else.
 352  */
 353 static void
 354 free_rpcb_entry_list(rpcb_entry_list_ptr rlist)
 355 {
 356         while (rlist != NULL) {
 357                 rpcb_entry_list_ptr tmp = rlist;
 358                 rlist = rlist->rpcb_entry_next;
 359                 free(tmp->rpcb_entry_map.r_maddr);
 360                 free(tmp);
 361         }
 362 }
 363
 364 static bool_t
 365 xdr_rpcb_entry_list_ptr_wrap(XDR *xdrs, rpcb_entry_list_ptr *rp)
 366 {
 367         if (xdrs->x_op == XDR_FREE) {
 368                 free_rpcb_entry_list(*rp);
 369                 return (TRUE);
 370         }
 371
 372         return (xdr_rpcb_entry_list_ptr(xdrs, rp));
 373 }