OpenSolaris_b135/lib/libnsl/rpc/pmap_clnt.c
/*
* 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 (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* Portions of this source code were derived from Berkeley
* 4.3 BSD under license from the Regents of the University of
* California.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#ifdef PORTMAP
/*
* interface to pmap rpc service.
*/
#include "mt.h"
#include "rpc_mt.h"
#include <rpc/rpc.h>
#include <rpc/nettype.h>
#include <netdir.h>
#include <rpc/pmap_prot.h>
#include <rpc/pmap_clnt.h>
#include <rpc/pmap_rmt.h>
#include <string.h>
#include <syslog.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>
int use_portmapper = 0;
static const struct timeval timeout = { 5, 0 };
static const struct timeval tottimeout = { 60, 0 };
static const struct timeval rmttimeout = { 3, 0 };
/*
* Solaris hasn't trully supported local portmappers since Solaris 2.4.
*
* In Solaris 2.0 the portmapper was replaced with rpcbind. Essentially
* rpcbind implements version 3 of the portmapper protocol. (The last
* version of the portmapper protocol while it was still called
* portmap was version 2.) The rpcbind protocol provides a lot
* of improvements over the portmap protocol. (Like the ability
* to bind to non AF_INET transports like TLI and to unregister
* individual transport providers instead of entire serivices.)
*
* So in Solaris 2.0 the portmapper was replace with rpcbind, but it
* wasn't until Solaris 2.5 that all the local portmapper code was
* modified to assume that the local processes managing rpc services
* always supported the rpcbind protocol. When this happened all the
* local portmap registration code was enhanced to translated any
* portmapper requests into rpcbind requests. This is a fine assumption
* for Solaris where we always have control over the local
* portmapper/rpcbind service and we can make sure that it always
* understands the rpcbind protocol.
*
* But this is a problem for BrandZ. In BrandZ we don't have contol over
* what local portmapper is running. (Unless we want to replace it.)
* In the Linux case, current Linux distributions don't support the
* rpcbind protocol, instead they support the old portmapper protocol
* (verison 2.) So to allow Solaris services to register with the
* Linux portmapper (which we need to support to allow us to run the
* native NFS daemons) there are two things that need to be done.
*
* - The classic interfaces for registering services with the version 2
* portmapper is via pmap_set() and pmap_unset(). In Solaris 2.5 these
* functions were changed to translate portmap requests into rpcbind
* requests. These interfaces need to be enhanced so that if we're
* trying to register with a portmapper instead of rpcbind, we don't
* translate the requests to rpcbind requests.
*
* - Libnsl provides lots of interfaces to simplify the creation of rpc
* services (see rpc_svc_*). Internally, the interfaces all assume
* that the local process that manages rpc services support the rpcbind
* protocol. To avoid having to update all rpc services that use these
* functions to be portmapper aware, we need to enhance these functions
* to support the portmapper protocol in addition to rpcbind.
*
* To address both these requirements we've introduced three key functions.
*
* __pmap_set() - Registers services using the portmapper version 2
* protocol. (Behaves like the Pre-Solaris 2.5 pmap_set())
*
* __pmap_unset() - Unregisters services using the portmapper version 2
* protocol. (Behaves like the Pre-Solaris 2.5 pmap_unset())
*
* __use_portmapper() - Tells libnsl if the local system expects
* the portmapper protocol versus the rpcbind protocol.
*
* If an rpc program uses this interface to tell libnsl
* that it want's to use portmap based services instead of
* rpcbind based services, then libnsl will internally
* replace attempts to register services via rpcbind
* with portmap.
*/
static CLIENT *
pmap_common(const struct netconfig *nconf, int *socket)
{
struct sockaddr_in sa_local;
CLIENT *client;
/* we only support tcp and udp */
if ((nconf != NULL) &&
(strcmp(nconf->nc_netid, "udp") != 0) &&
(strcmp(nconf->nc_netid, "tcp") != 0))
return (NULL);
/* try connecting to the portmapper via udp */
get_myaddress(&sa_local);
client = clntudp_bufcreate(&sa_local, PMAPPROG, PMAPVERS,
timeout, socket, RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
if (client == NULL) {
/* try connecting to the portmapper via tcp */
client = clnttcp_create(&sa_local, PMAPPROG, PMAPVERS,
socket, RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
if (client == NULL)
return (NULL);
}
return (client);
}
void
__use_portmapper(int p)
{
use_portmapper = p;
}
/*
* Set a mapping between program, version and address.
* Calls the portmapper service to do the mapping.
*/
bool_t
__pmap_set(const rpcprog_t program, const rpcvers_t version,
const struct netconfig *nconf, const struct netbuf *address)
{
struct sockaddr_in *sa;
struct pmap parms;
CLIENT *client;
bool_t rslt;
int socket = RPC_ANYSOCK;
/* address better be a sockaddr_in struct */
if (address == NULL)
return (FALSE);
if (address->len != sizeof (struct sockaddr_in))
return (FALSE);
/* get a connection to the portmapper */
if (nconf == NULL)
return (FALSE);
if ((client = pmap_common(nconf, &socket)) == NULL)
return (FALSE);
/* LINTED pointer cast */
sa = (struct sockaddr_in *)(address->buf);
/* initialize the portmapper request */
parms.pm_prog = program;
parms.pm_vers = version;
parms.pm_port = ntohs(sa->sin_port);
parms.pm_prot =
(strcmp(nconf->nc_netid, "udp") == 0) ? IPPROTO_UDP : IPPROTO_TCP;
/* make the call */
if (CLNT_CALL(client, PMAPPROC_SET, xdr_pmap, (caddr_t)&parms,
xdr_bool, (char *)&rslt, tottimeout) != RPC_SUCCESS)
rslt = FALSE;
CLNT_DESTROY(client);
(void) close(socket);
return (rslt);
}
/*
* Remove the mapping between program, version and port.
* Calls the portmapper service remotely to do the un-mapping.
*/
bool_t
__pmap_unset(const rpcprog_t program, const rpcvers_t version)
{
struct pmap parms;
CLIENT *client;
bool_t rslt;
int socket = RPC_ANYSOCK;
/* get a connection to the portmapper */
if ((client = pmap_common(NULL, &socket)) == NULL)
return (FALSE);
/* initialize the portmapper request */
parms.pm_prog = program;
parms.pm_vers = version;
parms.pm_port = 0;
parms.pm_prot = 0;
/* make the call */
CLNT_CALL(client, PMAPPROC_UNSET, xdr_pmap, (caddr_t)&parms,
xdr_bool, (char *)&rslt, tottimeout);
CLNT_DESTROY(client);
(void) close(socket);
return (rslt);
}
/*
* Set a mapping between program, version and port.
* Calls the pmap service remotely to do the mapping.
*/
bool_t
pmap_set(rpcprog_t program, rpcvers_t version, rpcprot_t protocol,
ushort_t port)
{
bool_t rslt;
struct netbuf *na;
struct netconfig *nconf;
char buf[32];
if ((protocol != IPPROTO_UDP) && (protocol != IPPROTO_TCP))
return (FALSE);
nconf = __rpc_getconfip(protocol == IPPROTO_UDP ? "udp" : "tcp");
if (!nconf)
return (FALSE);
(void) sprintf(buf, "0.0.0.0.%d.%d", port >> 8 & 0xff, port & 0xff);
na = uaddr2taddr(nconf, buf);
if (!na) {
freenetconfigent(nconf);
return (FALSE);
}
if (!use_portmapper)
rslt = rpcb_set(program, version, nconf, na);
else
rslt = __pmap_set(program, version, nconf, na);
netdir_free((char *)na, ND_ADDR);
freenetconfigent(nconf);
return (rslt);
}
/*
* Remove the mapping between program, version and port.
* Calls the pmap service remotely to do the un-mapping.
*/
bool_t
pmap_unset(rpcprog_t program, rpcvers_t version)
{
struct netconfig *nconf;
bool_t udp_rslt = FALSE;
bool_t tcp_rslt = FALSE;
if (use_portmapper)
return (__pmap_unset(program, version));
nconf = __rpc_getconfip("udp");
if (nconf) {
udp_rslt = rpcb_unset(program, version, nconf);
freenetconfigent(nconf);
}
nconf = __rpc_getconfip("tcp");
if (nconf) {
tcp_rslt = rpcb_unset(program, version, nconf);
freenetconfigent(nconf);
}
/*
* XXX: The call may still succeed even if only one of the
* calls succeeded. This was the best that could be
* done for backward compatibility.
*/
return (tcp_rslt || udp_rslt);
}
/*
* Find the mapped port for program, version.
* Calls the pmap service remotely to do the lookup.
* Returns 0 if no map exists.
*
* XXX: It talks only to the portmapper and not to the rpcbind
* service. There may be implementations out there which do not
* run portmapper as a part of rpcbind.
*/
ushort_t
pmap_getport(struct sockaddr_in *address, rpcprog_t program,
rpcvers_t version, rpcprot_t protocol)
{
ushort_t port = 0;
int fd = RPC_ANYFD;
CLIENT *client;
struct pmap parms;
address->sin_port = htons(PMAPPORT);
client = clntudp_bufcreate(address, PMAPPROG, PMAPVERS, timeout,
&fd, RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
if (client != NULL) {
parms.pm_prog = program;
parms.pm_vers = version;
parms.pm_prot = protocol;
parms.pm_port = 0; /* not needed or used */
if (CLNT_CALL(client, PMAPPROC_GETPORT, (xdrproc_t)xdr_pmap,
(caddr_t)&parms, (xdrproc_t)xdr_u_short,
(caddr_t)&port, tottimeout) != RPC_SUCCESS) {
rpc_createerr.cf_stat = RPC_PMAPFAILURE;
clnt_geterr(client, &rpc_createerr.cf_error);
} else if (port == 0) {
rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
}
CLNT_DESTROY(client);
}
address->sin_port = 0;
return (port);
}
/*
* Get a copy of the current port maps.
* Calls the pmap service remotely to do get the maps.
*/
struct pmaplist *
pmap_getmaps(struct sockaddr_in *address)
{
pmaplist_ptr head = NULL;
int fd = RPC_ANYFD;
struct timeval minutetimeout;
CLIENT *client;
minutetimeout.tv_sec = 60;
minutetimeout.tv_usec = 0;
address->sin_port = htons(PMAPPORT);
client = clnttcp_create(address, PMAPPROG, PMAPVERS, &fd, 50, 500);
if (client != NULL) {
if (CLNT_CALL(client, PMAPPROC_DUMP, (xdrproc_t)xdr_void,
NULL, (xdrproc_t)xdr_pmaplist_ptr,
(caddr_t)&head, minutetimeout) != RPC_SUCCESS) {
(void) syslog(LOG_ERR, "%s",
clnt_sperror(client, "pmap_getmaps rpc problem"));
}
CLNT_DESTROY(client);
}
address->sin_port = 0;
return ((struct pmaplist *)head);
}
/*
* pmapper remote-call-service interface.
* This routine is used to call the pmapper remote call service
* which will look up a service program in the port maps, and then
* remotely call that routine with the given parameters. This allows
* programs to do a lookup and call in one step.
*/
enum clnt_stat
pmap_rmtcall(struct sockaddr_in *addr, rpcprog_t prog, rpcvers_t vers,
rpcproc_t proc, xdrproc_t xdrargs, caddr_t argsp, xdrproc_t xdrres,
caddr_t resp, struct timeval tout, rpcport_t *port_ptr)
{
int fd = RPC_ANYFD;
CLIENT *client;
struct p_rmtcallargs a;
struct p_rmtcallres r;
enum clnt_stat stat;
short tmp = addr->sin_port;
addr->sin_port = htons(PMAPPORT);
client = clntudp_create(addr, PMAPPROG, PMAPVERS, rmttimeout, &fd);
if (client != NULL) {
a.prog = prog;
a.vers = vers;
a.proc = proc;
a.args.args_val = argsp;
a.xdr_args = xdrargs;
r.res.res_val = resp;
r.xdr_res = xdrres;
stat = CLNT_CALL(client, PMAPPROC_CALLIT,
(xdrproc_t)xdr_rmtcallargs,
(caddr_t)&a, (xdrproc_t)xdr_rmtcallres,
(caddr_t)&r, tout);
CLNT_DESTROY(client);
} else {
stat = RPC_FAILED;
}
addr->sin_port = tmp;
*port_ptr = r.port;
return (stat);
}
#endif /* PORTMAP */