rpcb_svc_4.c revision 8f6d9dae92449b59bdafcb7777bc32f1b2726e48
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Copyright 2013 Nexenta Systems, Inc. All rights reserved.
*/
/*
* rpcb_svc_4.c
* The server procedure for the version 4 rpcbind.
*
*/
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <rpc/rpc.h>
#include <netconfig.h>
#include <syslog.h>
#include <netdir.h>
#include <string.h>
#include <stdlib.h>
#include "rpcbind.h"
static void free_rpcb_entry_list(rpcb_entry_list_ptr);
static bool_t xdr_rpcb_entry_list_ptr_wrap(XDR *, rpcb_entry_list_ptr *);
static bool_t rpcbproc_getaddrlist(rpcb *, rpcb_entry_list_ptr *,
struct svc_req *);
/*
* Called by svc_getreqset. There is a separate server handle for
* every transport that it waits on.
*/
void
rpcb_service_4(struct svc_req *rqstp, SVCXPRT *transp)
{
union {
rpcb rpcbproc_set_4_arg;
rpcb rpcbproc_unset_4_arg;
rpcb rpcbproc_getaddr_4_arg;
char *rpcbproc_uaddr2taddr_4_arg;
struct netbuf rpcbproc_taddr2uaddr_4_arg;
rpcb rpcbproc_getversaddr_4_arg;
rpcb rpcbproc_getaddrlist_4_arg;
} argument;
union {
bool_t rpcbproc_set_4_res;
bool_t rpcbproc_unset_4_res;
char *rpcbproc_getaddr_4_res;
rpcblist_ptr *rpcbproc_dump_4_res;
ulong_t rpcbproc_gettime_4_res;
struct netbuf rpcbproc_uaddr2taddr_4_res;
char *rpcbproc_taddr2uaddr_4_res;
char *rpcbproc_getversaddr_4_res;
rpcb_entry_list_ptr rpcbproc_getaddrlist_4_res;
rpcb_stat_byvers *rpcbproc_getstat_4_res;
} result;
bool_t retval;
xdrproc_t xdr_argument, xdr_result;
bool_t (*local)();
rpcbs_procinfo(RPCBVERS_4_STAT, rqstp->rq_proc);
RPCB_CHECK(transp, rqstp->rq_proc);
switch (rqstp->rq_proc) {
case NULLPROC:
/*
* Null proc call
*/
(void) svc_sendreply(transp, (xdrproc_t)xdr_void, (char *)NULL);
return;
case RPCBPROC_SET:
/*
* Check to see whether the message came from
* loopback transports (for security reasons)
*/
if (strcasecmp(transp->xp_netid, loopback_dg) &&
strcasecmp(transp->xp_netid, loopback_vc) &&
strcasecmp(transp->xp_netid, loopback_vc_ord)) {
syslog(LOG_ERR, "non-local attempt to set");
svcerr_weakauth(transp);
return;
}
xdr_argument = xdr_rpcb;
xdr_result = xdr_bool;
local = (bool_t (*)()) rpcbproc_set_com;
break;
case RPCBPROC_UNSET:
/*
* Check to see whether the message came from
* loopback transports (for security reasons)
*/
if (strcasecmp(transp->xp_netid, loopback_dg) &&
strcasecmp(transp->xp_netid, loopback_vc) &&
strcasecmp(transp->xp_netid, loopback_vc_ord)) {
syslog(LOG_ERR, "non-local attempt to unset");
svcerr_weakauth(transp);
return;
}
xdr_argument = xdr_rpcb;
xdr_result = xdr_bool;
local = (bool_t (*)()) rpcbproc_unset_com;
break;
case RPCBPROC_GETADDR:
xdr_argument = xdr_rpcb;
xdr_result = xdr_wrapstring;
local = (bool_t (*)()) rpcbproc_getaddr_com;
break;
case RPCBPROC_DUMP:
xdr_argument = xdr_void;
xdr_result = xdr_rpcblist_ptr_ptr;
local = (bool_t (*)()) rpcbproc_dump_com;
break;
case RPCBPROC_BCAST:
rpcbproc_callit_com(rqstp, transp, rqstp->rq_proc, RPCBVERS4);
return;
case RPCBPROC_GETTIME:
xdr_argument = xdr_void;
xdr_result = xdr_u_long;
local = (bool_t (*)()) rpcbproc_gettime_com;
break;
case RPCBPROC_UADDR2TADDR:
xdr_argument = xdr_wrapstring;
xdr_result = xdr_netbuf;
local = (bool_t (*)()) rpcbproc_uaddr2taddr_com;
break;
case RPCBPROC_TADDR2UADDR:
xdr_argument = xdr_netbuf;
xdr_result = xdr_wrapstring;
local = (bool_t (*)()) rpcbproc_taddr2uaddr_com;
break;
case RPCBPROC_GETVERSADDR:
xdr_argument = xdr_rpcb;
xdr_result = xdr_wrapstring;
local = (bool_t (*)()) rpcbproc_getaddr_com;
break;
case RPCBPROC_INDIRECT:
rpcbproc_callit_com(rqstp, transp, rqstp->rq_proc, RPCBVERS4);
return;
case RPCBPROC_GETADDRLIST:
xdr_argument = xdr_rpcb;
xdr_result = xdr_rpcb_entry_list_ptr_wrap;
local = (bool_t (*)()) rpcbproc_getaddrlist;
break;
case RPCBPROC_GETSTAT:
xdr_argument = xdr_void;
xdr_result = xdr_rpcb_stat_byvers_ptr;
local = (bool_t (*)()) rpcbproc_getstat;
break;
default:
svcerr_noproc(transp);
return;
}
(void) memset((char *)&argument, 0, sizeof (argument));
if (!svc_getargs(transp, xdr_argument, (char *)&argument)) {
svcerr_decode(transp);
if (debugging)
(void) fprintf(stderr, "rpcbind: could not decode\n");
return;
}
retval = (*local)(&argument, &result, rqstp, RPCBVERS4);
if (retval > 0 && !svc_sendreply(transp, xdr_result, (char *)&result)) {
svcerr_systemerr(transp);
if (debugging) {
(void) fprintf(stderr, "rpcbind: svc_sendreply\n");
if (doabort) {
rpcbind_abort();
}
}
}
if (!svc_freeargs(transp, xdr_argument, (char *)&argument)) {
if (debugging) {
(void) fprintf(stderr, "unable to free arguments\n");
if (doabort) {
rpcbind_abort();
}
}
}
xdr_free(xdr_result, (char *)&result);
}
/*
* Lookup the mapping for a program, version and return the
* addresses for all transports in the current transport family.
* We return a merged address.
*/
static bool_t
rpcbproc_getaddrlist(rpcb *regp, rpcb_entry_list_ptr *result,
struct svc_req *rqstp)
{
rpcb_entry_list_ptr rlist = *result = NULL;
rpcblist_ptr rbl, next, prev;
rpcb_entry_list_ptr rp, tail = NULL;
ulong_t prog, vers;
rpcb_entry *a;
struct netconfig *nconf;
struct netconfig *reg_nconf;
char *saddr, *maddr = NULL;
struct netconfig *trans_conf; /* transport netconfig */
SVCXPRT *transp = rqstp->rq_xprt;
/*
* Deal with a possible window during which we could return an IPv6
* address when the caller wanted IPv4. See the comments in
* rpcbproc_getaddr_com() for more details.
*/
trans_conf = rpcbind_get_conf(transp->xp_netid);
if (strcmp(trans_conf->nc_protofmly, NC_INET6) == 0) {
struct sockaddr_in6 *rmtaddr;
rmtaddr = (struct sockaddr_in6 *)transp->xp_rtaddr.buf;
if (IN6_IS_ADDR_V4MAPPED(&rmtaddr->sin6_addr)) {
syslog(LOG_DEBUG,
"IPv4 GETADDRLIST request mapped "
"to IPv6: ignoring");
return (FALSE);
}
}
prog = regp->r_prog;
vers = regp->r_vers;
reg_nconf = rpcbind_get_conf(transp->xp_netid);
if (reg_nconf == NULL)
return (FALSE);
if (*(regp->r_addr) != '\0') {
saddr = regp->r_addr;
} else {
saddr = NULL;
}
prev = NULL;
(void) rw_wrlock(&list_rbl_lock);
for (rbl = list_rbl; rbl != NULL; rbl = next) {
next = rbl->rpcb_next;
if ((rbl->rpcb_map.r_prog == prog) &&
(rbl->rpcb_map.r_vers == vers)) {
nconf = rpcbind_get_conf(rbl->rpcb_map.r_netid);
if (nconf == NULL) {
(void) rw_unlock(&list_rbl_lock);
goto fail;
}
if (strcmp(nconf->nc_protofmly, reg_nconf->nc_protofmly)
!= 0) {
prev = rbl;
continue; /* not same proto family */
}
if ((maddr = mergeaddr(transp, rbl->rpcb_map.r_netid,
rbl->rpcb_map.r_addr, saddr)) == NULL) {
prev = rbl;
continue;
} else if (!maddr[0]) {
/*
* The server died, remove this rpcb_map element
* from the list and free it.
*/
#ifdef PORTMAP
(void) rw_wrlock(&list_pml_lock);
(void) del_pmaplist(&rbl->rpcb_map);
(void) rw_unlock(&list_pml_lock);
#endif
(void) delete_rbl(rbl);
if (prev == NULL)
list_rbl = next;
else
prev->rpcb_next = next;
continue;
}
/*
* Add it to rlist.
*/
rp = (rpcb_entry_list_ptr)
malloc((uint_t)sizeof (rpcb_entry_list));
if (rp == NULL) {
(void) rw_unlock(&list_rbl_lock);
goto fail;
}
a = &rp->rpcb_entry_map;
a->r_maddr = maddr;
a->r_nc_netid = nconf->nc_netid;
a->r_nc_semantics = nconf->nc_semantics;
a->r_nc_protofmly = nconf->nc_protofmly;
a->r_nc_proto = nconf->nc_proto;
rp->rpcb_entry_next = NULL;
if (rlist == NULL) {
rlist = rp;
tail = rp;
} else {
tail->rpcb_entry_next = rp;
tail = rp;
}
rp = NULL;
}
prev = rbl;
}
(void) rw_unlock(&list_rbl_lock);
/*
* XXX: getaddrlist info is also being stuffed into getaddr.
* Perhaps wrong, but better than it not getting counted at all.
*/
rpcbs_getaddr(RPCBVERS_4_STAT, prog, vers, transp->xp_netid, maddr);
*result = rlist;
return (TRUE);
fail:
free_rpcb_entry_list(rlist);
return (FALSE);
}
/*
* Free only the allocated structure, rest is all a pointer to some
* other data somewhere else.
*/
static void
free_rpcb_entry_list(rpcb_entry_list_ptr rlist)
{
while (rlist != NULL) {
rpcb_entry_list_ptr tmp = rlist;
rlist = rlist->rpcb_entry_next;
free(tmp->rpcb_entry_map.r_maddr);
free(tmp);
}
}
static bool_t
xdr_rpcb_entry_list_ptr_wrap(XDR *xdrs, rpcb_entry_list_ptr *rp)
{
if (xdrs->x_op == XDR_FREE) {
free_rpcb_entry_list(*rp);
return (TRUE);
}
return (xdr_rpcb_entry_list_ptr(xdrs, rp));
}