2007-03-29 20:48:04 +00:00
|
|
|
/*
|
|
|
|
* In-kernel rpcbind client supporting versions 2, 3, and 4 of the rpcbind
|
|
|
|
* protocol
|
|
|
|
*
|
|
|
|
* Based on RFC 1833: "Binding Protocols for ONC RPC Version 2" and
|
|
|
|
* RFC 3530: "Network File System (NFS) version 4 Protocol"
|
|
|
|
*
|
|
|
|
* Original: Gilles Quillard, Bull Open Source, 2005 <gilles.quillard@bull.net>
|
|
|
|
* Updated: Chuck Lever, Oracle Corporation, 2007 <chuck.lever@oracle.com>
|
|
|
|
*
|
|
|
|
* Descended from net/sunrpc/pmap_clnt.c,
|
|
|
|
* Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
|
|
|
|
*/
|
|
|
|
|
2007-07-01 16:13:12 +00:00
|
|
|
#include <linux/module.h>
|
|
|
|
|
2007-03-29 20:48:04 +00:00
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/socket.h>
|
2011-05-09 19:22:55 +00:00
|
|
|
#include <linux/un.h>
|
2007-08-06 15:57:18 +00:00
|
|
|
#include <linux/in.h>
|
|
|
|
#include <linux/in6.h>
|
2007-03-29 20:48:04 +00:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/errno.h>
|
2009-12-03 20:58:56 +00:00
|
|
|
#include <linux/mutex.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2008-09-15 21:27:30 +00:00
|
|
|
#include <net/ipv6.h>
|
2007-03-29 20:48:04 +00:00
|
|
|
|
|
|
|
#include <linux/sunrpc/clnt.h>
|
2013-02-04 17:50:00 +00:00
|
|
|
#include <linux/sunrpc/addr.h>
|
2007-03-29 20:48:04 +00:00
|
|
|
#include <linux/sunrpc/sched.h>
|
2007-09-10 17:48:23 +00:00
|
|
|
#include <linux/sunrpc/xprtsock.h>
|
2007-03-29 20:48:04 +00:00
|
|
|
|
2012-01-13 08:52:10 +00:00
|
|
|
#include "netns.h"
|
|
|
|
|
2014-11-17 21:58:04 +00:00
|
|
|
#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
|
2007-03-29 20:48:04 +00:00
|
|
|
# define RPCDBG_FACILITY RPCDBG_BIND
|
|
|
|
#endif
|
|
|
|
|
2011-05-09 19:22:55 +00:00
|
|
|
#define RPCBIND_SOCK_PATHNAME "/var/run/rpcbind.sock"
|
|
|
|
|
2007-03-29 20:48:04 +00:00
|
|
|
#define RPCBIND_PROGRAM (100000u)
|
|
|
|
#define RPCBIND_PORT (111u)
|
|
|
|
|
2008-06-25 21:24:31 +00:00
|
|
|
#define RPCBVERS_2 (2u)
|
|
|
|
#define RPCBVERS_3 (3u)
|
|
|
|
#define RPCBVERS_4 (4u)
|
|
|
|
|
2007-03-29 20:48:04 +00:00
|
|
|
enum {
|
|
|
|
RPCBPROC_NULL,
|
|
|
|
RPCBPROC_SET,
|
|
|
|
RPCBPROC_UNSET,
|
|
|
|
RPCBPROC_GETPORT,
|
|
|
|
RPCBPROC_GETADDR = 3, /* alias for GETPORT */
|
|
|
|
RPCBPROC_DUMP,
|
|
|
|
RPCBPROC_CALLIT,
|
|
|
|
RPCBPROC_BCAST = 5, /* alias for CALLIT */
|
|
|
|
RPCBPROC_GETTIME,
|
|
|
|
RPCBPROC_UADDR2TADDR,
|
|
|
|
RPCBPROC_TADDR2UADDR,
|
|
|
|
RPCBPROC_GETVERSADDR,
|
|
|
|
RPCBPROC_INDIRECT,
|
|
|
|
RPCBPROC_GETADDRLIST,
|
|
|
|
RPCBPROC_GETSTAT,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* r_owner
|
|
|
|
*
|
|
|
|
* The "owner" is allowed to unset a service in the rpcbind database.
|
2009-03-19 00:47:14 +00:00
|
|
|
*
|
|
|
|
* For AF_LOCAL SET/UNSET requests, rpcbind treats this string as a
|
|
|
|
* UID which it maps to a local user name via a password lookup.
|
|
|
|
* In all other cases it is ignored.
|
|
|
|
*
|
|
|
|
* For SET/UNSET requests, user space provides a value, even for
|
|
|
|
* network requests, and GETADDR uses an empty string. We follow
|
|
|
|
* those precedents here.
|
2007-03-29 20:48:04 +00:00
|
|
|
*/
|
2009-03-19 00:47:14 +00:00
|
|
|
#define RPCB_OWNER_STRING "0"
|
2007-03-29 20:48:04 +00:00
|
|
|
#define RPCB_MAXOWNERLEN sizeof(RPCB_OWNER_STRING)
|
|
|
|
|
2009-08-09 19:09:33 +00:00
|
|
|
/*
|
|
|
|
* XDR data type sizes
|
|
|
|
*/
|
|
|
|
#define RPCB_program_sz (1)
|
|
|
|
#define RPCB_version_sz (1)
|
|
|
|
#define RPCB_protocol_sz (1)
|
|
|
|
#define RPCB_port_sz (1)
|
|
|
|
#define RPCB_boolean_sz (1)
|
|
|
|
|
|
|
|
#define RPCB_netid_sz (1 + XDR_QUADLEN(RPCBIND_MAXNETIDLEN))
|
|
|
|
#define RPCB_addr_sz (1 + XDR_QUADLEN(RPCBIND_MAXUADDRLEN))
|
|
|
|
#define RPCB_ownerstring_sz (1 + XDR_QUADLEN(RPCB_MAXOWNERLEN))
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XDR argument and result sizes
|
|
|
|
*/
|
|
|
|
#define RPCB_mappingargs_sz (RPCB_program_sz + RPCB_version_sz + \
|
|
|
|
RPCB_protocol_sz + RPCB_port_sz)
|
|
|
|
#define RPCB_getaddrargs_sz (RPCB_program_sz + RPCB_version_sz + \
|
|
|
|
RPCB_netid_sz + RPCB_addr_sz + \
|
|
|
|
RPCB_ownerstring_sz)
|
|
|
|
|
|
|
|
#define RPCB_getportres_sz RPCB_port_sz
|
|
|
|
#define RPCB_setres_sz RPCB_boolean_sz
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note that RFC 1833 does not put any size restrictions on the
|
|
|
|
* address string returned by the remote rpcbind database.
|
|
|
|
*/
|
|
|
|
#define RPCB_getaddrres_sz RPCB_addr_sz
|
|
|
|
|
2007-03-29 20:48:04 +00:00
|
|
|
static void rpcb_getport_done(struct rpc_task *, void *);
|
2008-07-07 16:18:53 +00:00
|
|
|
static void rpcb_map_release(void *data);
|
2012-01-20 18:53:56 +00:00
|
|
|
static const struct rpc_program rpcb_program;
|
2007-03-29 20:48:04 +00:00
|
|
|
|
|
|
|
struct rpcbind_args {
|
|
|
|
struct rpc_xprt * r_xprt;
|
|
|
|
|
|
|
|
u32 r_prog;
|
|
|
|
u32 r_vers;
|
|
|
|
u32 r_prot;
|
|
|
|
unsigned short r_port;
|
2008-01-08 02:16:56 +00:00
|
|
|
const char * r_netid;
|
|
|
|
const char * r_addr;
|
|
|
|
const char * r_owner;
|
2008-07-07 16:18:53 +00:00
|
|
|
|
|
|
|
int r_status;
|
2007-03-29 20:48:04 +00:00
|
|
|
};
|
|
|
|
|
2017-05-12 13:36:49 +00:00
|
|
|
static const struct rpc_procinfo rpcb_procedures2[];
|
|
|
|
static const struct rpc_procinfo rpcb_procedures3[];
|
|
|
|
static const struct rpc_procinfo rpcb_procedures4[];
|
2007-03-29 20:48:04 +00:00
|
|
|
|
2007-08-06 15:57:18 +00:00
|
|
|
struct rpcb_info {
|
2008-06-25 21:24:31 +00:00
|
|
|
u32 rpc_vers;
|
2017-05-12 13:36:49 +00:00
|
|
|
const struct rpc_procinfo *rpc_proc;
|
2007-08-06 15:57:18 +00:00
|
|
|
};
|
|
|
|
|
2012-01-20 18:53:56 +00:00
|
|
|
static const struct rpcb_info rpcb_next_version[];
|
|
|
|
static const struct rpcb_info rpcb_next_version6[];
|
2007-03-29 20:48:04 +00:00
|
|
|
|
|
|
|
static const struct rpc_call_ops rpcb_getport_ops = {
|
|
|
|
.rpc_call_done = rpcb_getport_done,
|
|
|
|
.rpc_release = rpcb_map_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void rpcb_wake_rpcbind_waiters(struct rpc_xprt *xprt, int status)
|
|
|
|
{
|
|
|
|
xprt_clear_binding(xprt);
|
|
|
|
rpc_wake_up_status(&xprt->binding, status);
|
|
|
|
}
|
|
|
|
|
2008-07-07 16:18:53 +00:00
|
|
|
static void rpcb_map_release(void *data)
|
|
|
|
{
|
|
|
|
struct rpcbind_args *map = data;
|
|
|
|
|
|
|
|
rpcb_wake_rpcbind_waiters(map->r_xprt, map->r_status);
|
|
|
|
xprt_put(map->r_xprt);
|
2009-08-09 19:09:35 +00:00
|
|
|
kfree(map->r_addr);
|
2008-07-07 16:18:53 +00:00
|
|
|
kfree(map);
|
|
|
|
}
|
|
|
|
|
2012-01-13 08:52:18 +00:00
|
|
|
static int rpcb_get_local(struct net *net)
|
2011-10-25 11:16:36 +00:00
|
|
|
{
|
|
|
|
int cnt;
|
2012-01-13 08:52:18 +00:00
|
|
|
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
|
2011-10-25 11:16:36 +00:00
|
|
|
|
2012-01-13 08:52:10 +00:00
|
|
|
spin_lock(&sn->rpcb_clnt_lock);
|
|
|
|
if (sn->rpcb_users)
|
|
|
|
sn->rpcb_users++;
|
|
|
|
cnt = sn->rpcb_users;
|
|
|
|
spin_unlock(&sn->rpcb_clnt_lock);
|
2011-10-25 11:16:36 +00:00
|
|
|
|
|
|
|
return cnt;
|
|
|
|
}
|
|
|
|
|
2012-01-13 08:52:51 +00:00
|
|
|
void rpcb_put_local(struct net *net)
|
2011-10-25 11:16:36 +00:00
|
|
|
{
|
2012-01-13 08:52:51 +00:00
|
|
|
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
|
2012-01-13 08:52:10 +00:00
|
|
|
struct rpc_clnt *clnt = sn->rpcb_local_clnt;
|
|
|
|
struct rpc_clnt *clnt4 = sn->rpcb_local_clnt4;
|
2012-05-02 12:08:38 +00:00
|
|
|
int shutdown = 0;
|
2011-10-25 11:16:36 +00:00
|
|
|
|
2012-01-13 08:52:10 +00:00
|
|
|
spin_lock(&sn->rpcb_clnt_lock);
|
2012-05-02 12:08:38 +00:00
|
|
|
if (sn->rpcb_users) {
|
|
|
|
if (--sn->rpcb_users == 0) {
|
|
|
|
sn->rpcb_local_clnt = NULL;
|
|
|
|
sn->rpcb_local_clnt4 = NULL;
|
|
|
|
}
|
|
|
|
shutdown = !sn->rpcb_users;
|
2011-10-25 11:16:36 +00:00
|
|
|
}
|
2012-01-13 08:52:10 +00:00
|
|
|
spin_unlock(&sn->rpcb_clnt_lock);
|
2011-10-25 11:16:36 +00:00
|
|
|
|
|
|
|
if (shutdown) {
|
|
|
|
/*
|
|
|
|
* cleanup_rpcb_clnt - remove xprtsock's sysctls, unregister
|
|
|
|
*/
|
|
|
|
if (clnt4)
|
|
|
|
rpc_shutdown_client(clnt4);
|
|
|
|
if (clnt)
|
|
|
|
rpc_shutdown_client(clnt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-13 08:52:18 +00:00
|
|
|
static void rpcb_set_local(struct net *net, struct rpc_clnt *clnt,
|
2013-08-05 20:04:47 +00:00
|
|
|
struct rpc_clnt *clnt4,
|
|
|
|
bool is_af_local)
|
2011-10-25 11:16:36 +00:00
|
|
|
{
|
2012-01-13 08:52:18 +00:00
|
|
|
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
|
2012-01-13 08:52:10 +00:00
|
|
|
|
2011-10-25 11:16:36 +00:00
|
|
|
/* Protected by rpcb_create_local_mutex */
|
2012-01-13 08:52:10 +00:00
|
|
|
sn->rpcb_local_clnt = clnt;
|
|
|
|
sn->rpcb_local_clnt4 = clnt4;
|
2013-08-05 20:04:47 +00:00
|
|
|
sn->rpcb_is_af_local = is_af_local ? 1 : 0;
|
2018-07-24 19:29:15 +00:00
|
|
|
smp_wmb();
|
2012-01-13 08:52:10 +00:00
|
|
|
sn->rpcb_users = 1;
|
2011-10-25 11:16:36 +00:00
|
|
|
dprintk("RPC: created new rpcb local clients (rpcb_local_clnt: "
|
2017-11-08 05:57:32 +00:00
|
|
|
"%p, rpcb_local_clnt4: %p) for net %x%s\n",
|
|
|
|
sn->rpcb_local_clnt, sn->rpcb_local_clnt4,
|
|
|
|
net->ns.inum, (net == &init_net) ? " (init_net)" : "");
|
2011-10-25 11:16:36 +00:00
|
|
|
}
|
|
|
|
|
2011-05-09 19:22:55 +00:00
|
|
|
/*
|
|
|
|
* Returns zero on success, otherwise a negative errno value
|
|
|
|
* is returned.
|
|
|
|
*/
|
2012-01-13 08:52:18 +00:00
|
|
|
static int rpcb_create_local_unix(struct net *net)
|
2011-05-09 19:22:55 +00:00
|
|
|
{
|
|
|
|
static const struct sockaddr_un rpcb_localaddr_rpcbind = {
|
|
|
|
.sun_family = AF_LOCAL,
|
|
|
|
.sun_path = RPCBIND_SOCK_PATHNAME,
|
|
|
|
};
|
|
|
|
struct rpc_create_args args = {
|
2012-01-13 08:52:18 +00:00
|
|
|
.net = net,
|
2011-05-09 19:22:55 +00:00
|
|
|
.protocol = XPRT_TRANSPORT_LOCAL,
|
|
|
|
.address = (struct sockaddr *)&rpcb_localaddr_rpcbind,
|
|
|
|
.addrsize = sizeof(rpcb_localaddr_rpcbind),
|
|
|
|
.servername = "localhost",
|
|
|
|
.program = &rpcb_program,
|
|
|
|
.version = RPCBVERS_2,
|
|
|
|
.authflavor = RPC_AUTH_NULL,
|
2013-08-05 18:10:43 +00:00
|
|
|
/*
|
|
|
|
* We turn off the idle timeout to prevent the kernel
|
|
|
|
* from automatically disconnecting the socket.
|
|
|
|
* Otherwise, we'd have to cache the mount namespace
|
|
|
|
* of the caller and somehow pass that to the socket
|
|
|
|
* reconnect code.
|
|
|
|
*/
|
|
|
|
.flags = RPC_CLNT_CREATE_NO_IDLE_TIMEOUT,
|
2011-05-09 19:22:55 +00:00
|
|
|
};
|
|
|
|
struct rpc_clnt *clnt, *clnt4;
|
|
|
|
int result = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Because we requested an RPC PING at transport creation time,
|
|
|
|
* this works only if the user space portmapper is rpcbind, and
|
|
|
|
* it's listening on AF_LOCAL on the named socket.
|
|
|
|
*/
|
|
|
|
clnt = rpc_create(&args);
|
|
|
|
if (IS_ERR(clnt)) {
|
|
|
|
dprintk("RPC: failed to create AF_LOCAL rpcbind "
|
|
|
|
"client (errno %ld).\n", PTR_ERR(clnt));
|
2012-07-20 11:57:48 +00:00
|
|
|
result = PTR_ERR(clnt);
|
2011-05-09 19:22:55 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
clnt4 = rpc_bind_new_program(clnt, &rpcb_program, RPCBVERS_4);
|
|
|
|
if (IS_ERR(clnt4)) {
|
|
|
|
dprintk("RPC: failed to bind second program to "
|
|
|
|
"rpcbind v4 client (errno %ld).\n",
|
|
|
|
PTR_ERR(clnt4));
|
|
|
|
clnt4 = NULL;
|
|
|
|
}
|
|
|
|
|
2013-08-05 20:04:47 +00:00
|
|
|
rpcb_set_local(net, clnt, clnt4, true);
|
2008-07-14 20:03:27 +00:00
|
|
|
|
2011-05-09 19:22:55 +00:00
|
|
|
out:
|
|
|
|
return result;
|
|
|
|
}
|
2009-12-03 20:58:56 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns zero on success, otherwise a negative errno value
|
|
|
|
* is returned.
|
|
|
|
*/
|
2012-01-13 08:52:18 +00:00
|
|
|
static int rpcb_create_local_net(struct net *net)
|
2008-07-14 20:03:27 +00:00
|
|
|
{
|
2011-05-09 19:22:55 +00:00
|
|
|
static const struct sockaddr_in rpcb_inaddr_loopback = {
|
|
|
|
.sin_family = AF_INET,
|
|
|
|
.sin_addr.s_addr = htonl(INADDR_LOOPBACK),
|
|
|
|
.sin_port = htons(RPCBIND_PORT),
|
|
|
|
};
|
2008-07-14 20:03:27 +00:00
|
|
|
struct rpc_create_args args = {
|
2012-01-13 08:52:18 +00:00
|
|
|
.net = net,
|
2009-12-03 20:58:56 +00:00
|
|
|
.protocol = XPRT_TRANSPORT_TCP,
|
2009-12-03 20:58:56 +00:00
|
|
|
.address = (struct sockaddr *)&rpcb_inaddr_loopback,
|
|
|
|
.addrsize = sizeof(rpcb_inaddr_loopback),
|
2008-07-14 20:03:27 +00:00
|
|
|
.servername = "localhost",
|
|
|
|
.program = &rpcb_program,
|
2009-12-03 20:58:56 +00:00
|
|
|
.version = RPCBVERS_2,
|
2008-07-14 20:03:27 +00:00
|
|
|
.authflavor = RPC_AUTH_UNIX,
|
|
|
|
.flags = RPC_CLNT_CREATE_NOPING,
|
|
|
|
};
|
2009-12-03 20:58:56 +00:00
|
|
|
struct rpc_clnt *clnt, *clnt4;
|
|
|
|
int result = 0;
|
|
|
|
|
|
|
|
clnt = rpc_create(&args);
|
|
|
|
if (IS_ERR(clnt)) {
|
|
|
|
dprintk("RPC: failed to create local rpcbind "
|
|
|
|
"client (errno %ld).\n", PTR_ERR(clnt));
|
2012-07-20 11:57:48 +00:00
|
|
|
result = PTR_ERR(clnt);
|
2009-12-03 20:58:56 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2008-07-14 20:03:27 +00:00
|
|
|
|
2009-12-03 20:58:56 +00:00
|
|
|
/*
|
|
|
|
* This results in an RPC ping. On systems running portmapper,
|
|
|
|
* the v4 ping will fail. Proceed anyway, but disallow rpcb
|
|
|
|
* v4 upcalls.
|
|
|
|
*/
|
|
|
|
clnt4 = rpc_bind_new_program(clnt, &rpcb_program, RPCBVERS_4);
|
|
|
|
if (IS_ERR(clnt4)) {
|
2010-09-21 20:55:48 +00:00
|
|
|
dprintk("RPC: failed to bind second program to "
|
|
|
|
"rpcbind v4 client (errno %ld).\n",
|
|
|
|
PTR_ERR(clnt4));
|
2009-12-03 20:58:56 +00:00
|
|
|
clnt4 = NULL;
|
|
|
|
}
|
|
|
|
|
2013-08-05 20:04:47 +00:00
|
|
|
rpcb_set_local(net, clnt, clnt4, false);
|
2009-12-03 20:58:56 +00:00
|
|
|
|
2011-05-09 19:22:55 +00:00
|
|
|
out:
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns zero on success, otherwise a negative errno value
|
|
|
|
* is returned.
|
|
|
|
*/
|
2012-01-13 08:52:51 +00:00
|
|
|
int rpcb_create_local(struct net *net)
|
2011-05-09 19:22:55 +00:00
|
|
|
{
|
|
|
|
static DEFINE_MUTEX(rpcb_create_local_mutex);
|
|
|
|
int result = 0;
|
|
|
|
|
2012-01-13 08:52:18 +00:00
|
|
|
if (rpcb_get_local(net))
|
2011-05-09 19:22:55 +00:00
|
|
|
return result;
|
|
|
|
|
|
|
|
mutex_lock(&rpcb_create_local_mutex);
|
2012-01-13 08:52:18 +00:00
|
|
|
if (rpcb_get_local(net))
|
2011-05-09 19:22:55 +00:00
|
|
|
goto out;
|
|
|
|
|
2012-01-13 08:52:18 +00:00
|
|
|
if (rpcb_create_local_unix(net) != 0)
|
|
|
|
result = rpcb_create_local_net(net);
|
2011-05-09 19:22:55 +00:00
|
|
|
|
2009-12-03 20:58:56 +00:00
|
|
|
out:
|
|
|
|
mutex_unlock(&rpcb_create_local_mutex);
|
|
|
|
return result;
|
2008-07-14 20:03:27 +00:00
|
|
|
}
|
|
|
|
|
2015-01-30 23:12:28 +00:00
|
|
|
static struct rpc_clnt *rpcb_create(struct net *net, const char *nodename,
|
|
|
|
const char *hostname,
|
2012-01-13 08:52:35 +00:00
|
|
|
struct sockaddr *srvaddr, size_t salen,
|
|
|
|
int proto, u32 version)
|
2007-03-29 20:48:04 +00:00
|
|
|
{
|
|
|
|
struct rpc_create_args args = {
|
2012-01-13 08:52:35 +00:00
|
|
|
.net = net,
|
2007-03-29 20:48:04 +00:00
|
|
|
.protocol = proto,
|
|
|
|
.address = srvaddr,
|
2007-12-10 19:56:31 +00:00
|
|
|
.addrsize = salen,
|
2007-03-29 20:48:04 +00:00
|
|
|
.servername = hostname,
|
2015-01-30 23:12:28 +00:00
|
|
|
.nodename = nodename,
|
2007-03-29 20:48:04 +00:00
|
|
|
.program = &rpcb_program,
|
|
|
|
.version = version,
|
|
|
|
.authflavor = RPC_AUTH_UNIX,
|
2008-07-14 20:03:28 +00:00
|
|
|
.flags = (RPC_CLNT_CREATE_NOPING |
|
|
|
|
RPC_CLNT_CREATE_NONPRIVPORT),
|
2007-03-29 20:48:04 +00:00
|
|
|
};
|
|
|
|
|
2007-08-06 15:57:18 +00:00
|
|
|
switch (srvaddr->sa_family) {
|
|
|
|
case AF_INET:
|
|
|
|
((struct sockaddr_in *)srvaddr)->sin_port = htons(RPCBIND_PORT);
|
|
|
|
break;
|
|
|
|
case AF_INET6:
|
|
|
|
((struct sockaddr_in6 *)srvaddr)->sin6_port = htons(RPCBIND_PORT);
|
|
|
|
break;
|
|
|
|
default:
|
2010-10-06 09:45:56 +00:00
|
|
|
return ERR_PTR(-EAFNOSUPPORT);
|
2007-08-06 15:57:18 +00:00
|
|
|
}
|
|
|
|
|
2007-03-29 20:48:04 +00:00
|
|
|
return rpc_create(&args);
|
|
|
|
}
|
|
|
|
|
2013-08-05 20:04:47 +00:00
|
|
|
static int rpcb_register_call(struct sunrpc_net *sn, struct rpc_clnt *clnt, struct rpc_message *msg, bool is_set)
|
2008-07-14 20:03:29 +00:00
|
|
|
{
|
2013-08-05 20:04:47 +00:00
|
|
|
int flags = RPC_TASK_NOCONNECT;
|
|
|
|
int error, result = 0;
|
2008-07-14 20:03:29 +00:00
|
|
|
|
2013-08-05 20:04:47 +00:00
|
|
|
if (is_set || !sn->rpcb_is_af_local)
|
|
|
|
flags = RPC_TASK_SOFTCONN;
|
2008-08-18 23:34:00 +00:00
|
|
|
msg->rpc_resp = &result;
|
2008-07-14 20:03:29 +00:00
|
|
|
|
2013-08-05 20:04:47 +00:00
|
|
|
error = rpc_call_sync(clnt, msg, flags);
|
2008-08-18 23:34:00 +00:00
|
|
|
if (error < 0) {
|
2009-03-19 00:47:44 +00:00
|
|
|
dprintk("RPC: failed to contact local rpcbind "
|
2008-07-14 20:03:29 +00:00
|
|
|
"server (errno %d).\n", -error);
|
2008-08-18 23:34:00 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2008-09-25 15:57:05 +00:00
|
|
|
if (!result)
|
2008-08-18 23:34:00 +00:00
|
|
|
return -EACCES;
|
|
|
|
return 0;
|
2008-07-14 20:03:29 +00:00
|
|
|
}
|
|
|
|
|
2007-03-29 20:48:04 +00:00
|
|
|
/**
|
|
|
|
* rpcb_register - set or unset a port registration with the local rpcbind svc
|
2012-05-13 17:35:40 +00:00
|
|
|
* @net: target network namespace
|
2007-03-29 20:48:04 +00:00
|
|
|
* @prog: RPC program number to bind
|
|
|
|
* @vers: RPC version number to bind
|
2008-07-14 20:03:30 +00:00
|
|
|
* @prot: transport protocol to register
|
2007-03-29 20:48:04 +00:00
|
|
|
* @port: port value to register
|
2008-08-18 23:34:00 +00:00
|
|
|
*
|
|
|
|
* Returns zero if the registration request was dispatched successfully
|
|
|
|
* and the rpcbind daemon returned success. Otherwise, returns an errno
|
|
|
|
* value that reflects the nature of the error (request could not be
|
|
|
|
* dispatched, timed out, or rpcbind returned an error).
|
2008-07-14 20:03:30 +00:00
|
|
|
*
|
|
|
|
* RPC services invoke this function to advertise their contact
|
|
|
|
* information via the system's rpcbind daemon. RPC services
|
|
|
|
* invoke this function once for each [program, version, transport]
|
|
|
|
* tuple they wish to advertise.
|
|
|
|
*
|
|
|
|
* Callers may also unregister RPC services that are no longer
|
|
|
|
* available by setting the passed-in port to zero. This removes
|
|
|
|
* all registered transports for [program, version] from the local
|
|
|
|
* rpcbind database.
|
|
|
|
*
|
|
|
|
* This function uses rpcbind protocol version 2 to contact the
|
|
|
|
* local rpcbind daemon.
|
|
|
|
*
|
|
|
|
* Registration works over both AF_INET and AF_INET6, and services
|
|
|
|
* registered via this function are advertised as available for any
|
|
|
|
* address. If the local rpcbind daemon is listening on AF_INET6,
|
|
|
|
* services registered via this function will be advertised on
|
|
|
|
* IN6ADDR_ANY (ie available for all AF_INET and AF_INET6
|
|
|
|
* addresses).
|
2007-03-29 20:48:04 +00:00
|
|
|
*/
|
2012-01-13 08:52:43 +00:00
|
|
|
int rpcb_register(struct net *net, u32 prog, u32 vers, int prot, unsigned short port)
|
2007-03-29 20:48:04 +00:00
|
|
|
{
|
|
|
|
struct rpcbind_args map = {
|
|
|
|
.r_prog = prog,
|
|
|
|
.r_vers = vers,
|
|
|
|
.r_prot = prot,
|
|
|
|
.r_port = port,
|
|
|
|
};
|
|
|
|
struct rpc_message msg = {
|
|
|
|
.rpc_argp = &map,
|
|
|
|
};
|
2012-01-13 08:52:43 +00:00
|
|
|
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
|
2013-08-05 20:04:47 +00:00
|
|
|
bool is_set = false;
|
2007-03-29 20:48:04 +00:00
|
|
|
|
|
|
|
dprintk("RPC: %sregistering (%u, %u, %d, %u) with local "
|
|
|
|
"rpcbind\n", (port ? "" : "un"),
|
|
|
|
prog, vers, prot, port);
|
|
|
|
|
2008-07-14 20:03:29 +00:00
|
|
|
msg.rpc_proc = &rpcb_procedures2[RPCBPROC_UNSET];
|
2013-08-05 20:04:47 +00:00
|
|
|
if (port != 0) {
|
2008-07-14 20:03:29 +00:00
|
|
|
msg.rpc_proc = &rpcb_procedures2[RPCBPROC_SET];
|
2013-08-05 20:04:47 +00:00
|
|
|
is_set = true;
|
|
|
|
}
|
2007-03-29 20:48:04 +00:00
|
|
|
|
2013-08-05 20:04:47 +00:00
|
|
|
return rpcb_register_call(sn, sn->rpcb_local_clnt, &msg, is_set);
|
2007-03-29 20:48:04 +00:00
|
|
|
}
|
|
|
|
|
2008-07-14 20:03:30 +00:00
|
|
|
/*
|
|
|
|
* Fill in AF_INET family-specific arguments to register
|
|
|
|
*/
|
2012-01-13 08:52:26 +00:00
|
|
|
static int rpcb_register_inet4(struct sunrpc_net *sn,
|
|
|
|
const struct sockaddr *sap,
|
2009-03-19 00:47:21 +00:00
|
|
|
struct rpc_message *msg)
|
2008-07-14 20:03:30 +00:00
|
|
|
{
|
2009-03-19 00:47:06 +00:00
|
|
|
const struct sockaddr_in *sin = (const struct sockaddr_in *)sap;
|
2008-07-14 20:03:30 +00:00
|
|
|
struct rpcbind_args *map = msg->rpc_argp;
|
2009-03-19 00:47:06 +00:00
|
|
|
unsigned short port = ntohs(sin->sin_port);
|
2013-08-05 20:04:47 +00:00
|
|
|
bool is_set = false;
|
2009-08-09 19:09:35 +00:00
|
|
|
int result;
|
2008-07-14 20:03:30 +00:00
|
|
|
|
2011-10-17 23:08:10 +00:00
|
|
|
map->r_addr = rpc_sockaddr2uaddr(sap, GFP_KERNEL);
|
2008-07-14 20:03:30 +00:00
|
|
|
|
|
|
|
dprintk("RPC: %sregistering [%u, %u, %s, '%s'] with "
|
|
|
|
"local rpcbind\n", (port ? "" : "un"),
|
|
|
|
map->r_prog, map->r_vers,
|
|
|
|
map->r_addr, map->r_netid);
|
|
|
|
|
|
|
|
msg->rpc_proc = &rpcb_procedures4[RPCBPROC_UNSET];
|
2013-08-05 20:04:47 +00:00
|
|
|
if (port != 0) {
|
2008-07-14 20:03:30 +00:00
|
|
|
msg->rpc_proc = &rpcb_procedures4[RPCBPROC_SET];
|
2013-08-05 20:04:47 +00:00
|
|
|
is_set = true;
|
|
|
|
}
|
2008-07-14 20:03:30 +00:00
|
|
|
|
2013-08-05 20:04:47 +00:00
|
|
|
result = rpcb_register_call(sn, sn->rpcb_local_clnt4, msg, is_set);
|
2009-08-09 19:09:35 +00:00
|
|
|
kfree(map->r_addr);
|
|
|
|
return result;
|
2008-07-14 20:03:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fill in AF_INET6 family-specific arguments to register
|
|
|
|
*/
|
2012-01-13 08:52:26 +00:00
|
|
|
static int rpcb_register_inet6(struct sunrpc_net *sn,
|
|
|
|
const struct sockaddr *sap,
|
2009-03-19 00:47:21 +00:00
|
|
|
struct rpc_message *msg)
|
2008-07-14 20:03:30 +00:00
|
|
|
{
|
2009-03-19 00:47:06 +00:00
|
|
|
const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)sap;
|
2008-07-14 20:03:30 +00:00
|
|
|
struct rpcbind_args *map = msg->rpc_argp;
|
2009-03-19 00:47:06 +00:00
|
|
|
unsigned short port = ntohs(sin6->sin6_port);
|
2013-08-05 20:04:47 +00:00
|
|
|
bool is_set = false;
|
2009-08-09 19:09:35 +00:00
|
|
|
int result;
|
2008-07-14 20:03:30 +00:00
|
|
|
|
2011-10-17 23:08:10 +00:00
|
|
|
map->r_addr = rpc_sockaddr2uaddr(sap, GFP_KERNEL);
|
2008-07-14 20:03:30 +00:00
|
|
|
|
|
|
|
dprintk("RPC: %sregistering [%u, %u, %s, '%s'] with "
|
|
|
|
"local rpcbind\n", (port ? "" : "un"),
|
|
|
|
map->r_prog, map->r_vers,
|
|
|
|
map->r_addr, map->r_netid);
|
|
|
|
|
|
|
|
msg->rpc_proc = &rpcb_procedures4[RPCBPROC_UNSET];
|
2013-08-05 20:04:47 +00:00
|
|
|
if (port != 0) {
|
2008-07-14 20:03:30 +00:00
|
|
|
msg->rpc_proc = &rpcb_procedures4[RPCBPROC_SET];
|
2013-08-05 20:04:47 +00:00
|
|
|
is_set = true;
|
|
|
|
}
|
2008-07-14 20:03:30 +00:00
|
|
|
|
2013-08-05 20:04:47 +00:00
|
|
|
result = rpcb_register_call(sn, sn->rpcb_local_clnt4, msg, is_set);
|
2009-08-09 19:09:35 +00:00
|
|
|
kfree(map->r_addr);
|
|
|
|
return result;
|
2008-07-14 20:03:30 +00:00
|
|
|
}
|
|
|
|
|
2012-01-13 08:52:26 +00:00
|
|
|
static int rpcb_unregister_all_protofamilies(struct sunrpc_net *sn,
|
|
|
|
struct rpc_message *msg)
|
2009-03-19 00:47:21 +00:00
|
|
|
{
|
|
|
|
struct rpcbind_args *map = msg->rpc_argp;
|
|
|
|
|
|
|
|
dprintk("RPC: unregistering [%u, %u, '%s'] with "
|
|
|
|
"local rpcbind\n",
|
|
|
|
map->r_prog, map->r_vers, map->r_netid);
|
|
|
|
|
|
|
|
map->r_addr = "";
|
|
|
|
msg->rpc_proc = &rpcb_procedures4[RPCBPROC_UNSET];
|
|
|
|
|
2013-08-05 20:04:47 +00:00
|
|
|
return rpcb_register_call(sn, sn->rpcb_local_clnt4, msg, false);
|
2009-03-19 00:47:21 +00:00
|
|
|
}
|
|
|
|
|
2008-07-14 20:03:30 +00:00
|
|
|
/**
|
|
|
|
* rpcb_v4_register - set or unset a port registration with the local rpcbind
|
2012-05-13 17:35:40 +00:00
|
|
|
* @net: target network namespace
|
2008-07-14 20:03:30 +00:00
|
|
|
* @program: RPC program number of service to (un)register
|
|
|
|
* @version: RPC version number of service to (un)register
|
|
|
|
* @address: address family, IP address, and port to (un)register
|
|
|
|
* @netid: netid of transport protocol to (un)register
|
2008-08-18 23:34:00 +00:00
|
|
|
*
|
|
|
|
* Returns zero if the registration request was dispatched successfully
|
|
|
|
* and the rpcbind daemon returned success. Otherwise, returns an errno
|
|
|
|
* value that reflects the nature of the error (request could not be
|
|
|
|
* dispatched, timed out, or rpcbind returned an error).
|
2008-07-14 20:03:30 +00:00
|
|
|
*
|
|
|
|
* RPC services invoke this function to advertise their contact
|
|
|
|
* information via the system's rpcbind daemon. RPC services
|
|
|
|
* invoke this function once for each [program, version, address,
|
|
|
|
* netid] tuple they wish to advertise.
|
|
|
|
*
|
2009-03-19 00:47:21 +00:00
|
|
|
* Callers may also unregister RPC services that are registered at a
|
|
|
|
* specific address by setting the port number in @address to zero.
|
|
|
|
* They may unregister all registered protocol families at once for
|
|
|
|
* a service by passing a NULL @address argument. If @netid is ""
|
|
|
|
* then all netids for [program, version, address] are unregistered.
|
2008-07-14 20:03:30 +00:00
|
|
|
*
|
|
|
|
* This function uses rpcbind protocol version 4 to contact the
|
|
|
|
* local rpcbind daemon. The local rpcbind daemon must support
|
|
|
|
* version 4 of the rpcbind protocol in order for these functions
|
|
|
|
* to register a service successfully.
|
|
|
|
*
|
|
|
|
* Supported netids include "udp" and "tcp" for UDP and TCP over
|
|
|
|
* IPv4, and "udp6" and "tcp6" for UDP and TCP over IPv6,
|
|
|
|
* respectively.
|
|
|
|
*
|
|
|
|
* The contents of @address determine the address family and the
|
|
|
|
* port to be registered. The usual practice is to pass INADDR_ANY
|
|
|
|
* as the raw address, but specifying a non-zero address is also
|
|
|
|
* supported by this API if the caller wishes to advertise an RPC
|
|
|
|
* service on a specific network interface.
|
|
|
|
*
|
|
|
|
* Note that passing in INADDR_ANY does not create the same service
|
|
|
|
* registration as IN6ADDR_ANY. The former advertises an RPC
|
|
|
|
* service on any IPv4 address, but not on IPv6. The latter
|
|
|
|
* advertises the service on all IPv4 and IPv6 addresses.
|
|
|
|
*/
|
2012-01-13 08:52:43 +00:00
|
|
|
int rpcb_v4_register(struct net *net, const u32 program, const u32 version,
|
2008-08-18 23:34:00 +00:00
|
|
|
const struct sockaddr *address, const char *netid)
|
2008-07-14 20:03:30 +00:00
|
|
|
{
|
|
|
|
struct rpcbind_args map = {
|
|
|
|
.r_prog = program,
|
|
|
|
.r_vers = version,
|
|
|
|
.r_netid = netid,
|
|
|
|
.r_owner = RPCB_OWNER_STRING,
|
|
|
|
};
|
|
|
|
struct rpc_message msg = {
|
|
|
|
.rpc_argp = &map,
|
|
|
|
};
|
2012-01-13 08:52:43 +00:00
|
|
|
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
|
2009-12-03 20:58:56 +00:00
|
|
|
|
2012-01-13 08:52:10 +00:00
|
|
|
if (sn->rpcb_local_clnt4 == NULL)
|
2009-12-03 20:58:56 +00:00
|
|
|
return -EPROTONOSUPPORT;
|
2008-07-14 20:03:30 +00:00
|
|
|
|
2009-03-19 00:47:21 +00:00
|
|
|
if (address == NULL)
|
2012-01-13 08:52:26 +00:00
|
|
|
return rpcb_unregister_all_protofamilies(sn, &msg);
|
2009-03-19 00:47:21 +00:00
|
|
|
|
2008-07-14 20:03:30 +00:00
|
|
|
switch (address->sa_family) {
|
|
|
|
case AF_INET:
|
2012-01-13 08:52:26 +00:00
|
|
|
return rpcb_register_inet4(sn, address, &msg);
|
2008-07-14 20:03:30 +00:00
|
|
|
case AF_INET6:
|
2012-01-13 08:52:26 +00:00
|
|
|
return rpcb_register_inet6(sn, address, &msg);
|
2008-07-14 20:03:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return -EAFNOSUPPORT;
|
|
|
|
}
|
|
|
|
|
2017-05-12 13:36:49 +00:00
|
|
|
static struct rpc_task *rpcb_call_async(struct rpc_clnt *rpcb_clnt,
|
|
|
|
struct rpcbind_args *map, const struct rpc_procinfo *proc)
|
2007-07-14 19:40:01 +00:00
|
|
|
{
|
|
|
|
struct rpc_message msg = {
|
2008-07-01 19:20:55 +00:00
|
|
|
.rpc_proc = proc,
|
2007-07-14 19:40:01 +00:00
|
|
|
.rpc_argp = map,
|
2009-08-09 19:09:43 +00:00
|
|
|
.rpc_resp = map,
|
2007-07-14 19:40:01 +00:00
|
|
|
};
|
|
|
|
struct rpc_task_setup task_setup_data = {
|
|
|
|
.rpc_client = rpcb_clnt,
|
|
|
|
.rpc_message = &msg,
|
|
|
|
.callback_ops = &rpcb_getport_ops,
|
|
|
|
.callback_data = map,
|
2009-12-03 20:58:56 +00:00
|
|
|
.flags = RPC_TASK_ASYNC | RPC_TASK_SOFTCONN,
|
2007-07-14 19:40:01 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
return rpc_run_task(&task_setup_data);
|
|
|
|
}
|
|
|
|
|
2008-10-03 20:48:34 +00:00
|
|
|
/*
|
|
|
|
* In the case where rpc clients have been cloned, we want to make
|
|
|
|
* sure that we use the program number/version etc of the actual
|
|
|
|
* owner of the xprt. To do so, we walk back up the tree of parents
|
|
|
|
* to find whoever created the transport and/or whoever has the
|
|
|
|
* autobind flag set.
|
|
|
|
*/
|
|
|
|
static struct rpc_clnt *rpcb_find_transport_owner(struct rpc_clnt *clnt)
|
|
|
|
{
|
|
|
|
struct rpc_clnt *parent = clnt->cl_parent;
|
2016-01-30 19:17:26 +00:00
|
|
|
struct rpc_xprt_switch *xps = rcu_access_pointer(clnt->cl_xpi.xpi_xpswitch);
|
2008-10-03 20:48:34 +00:00
|
|
|
|
|
|
|
while (parent != clnt) {
|
2016-01-30 19:17:26 +00:00
|
|
|
if (rcu_access_pointer(parent->cl_xpi.xpi_xpswitch) != xps)
|
2008-10-03 20:48:34 +00:00
|
|
|
break;
|
|
|
|
if (clnt->cl_autobind)
|
|
|
|
break;
|
|
|
|
clnt = parent;
|
|
|
|
parent = parent->cl_parent;
|
|
|
|
}
|
|
|
|
return clnt;
|
|
|
|
}
|
|
|
|
|
2007-03-29 20:48:04 +00:00
|
|
|
/**
|
2007-07-01 16:13:17 +00:00
|
|
|
* rpcb_getport_async - obtain the port for a given RPC service on a given host
|
2007-03-29 20:48:04 +00:00
|
|
|
* @task: task that is waiting for portmapper request
|
|
|
|
*
|
|
|
|
* This one can be called for an ongoing RPC request, and can be used in
|
|
|
|
* an async (rpciod) context.
|
|
|
|
*/
|
2007-07-01 16:13:17 +00:00
|
|
|
void rpcb_getport_async(struct rpc_task *task)
|
2007-03-29 20:48:04 +00:00
|
|
|
{
|
2008-10-03 20:48:34 +00:00
|
|
|
struct rpc_clnt *clnt;
|
2017-05-12 13:36:49 +00:00
|
|
|
const struct rpc_procinfo *proc;
|
2007-12-10 19:56:38 +00:00
|
|
|
u32 bind_version;
|
2008-10-03 20:48:34 +00:00
|
|
|
struct rpc_xprt *xprt;
|
2007-03-29 20:48:04 +00:00
|
|
|
struct rpc_clnt *rpcb_clnt;
|
2011-07-12 17:27:55 +00:00
|
|
|
struct rpcbind_args *map;
|
2007-03-29 20:48:04 +00:00
|
|
|
struct rpc_task *child;
|
2007-12-10 19:56:31 +00:00
|
|
|
struct sockaddr_storage addr;
|
|
|
|
struct sockaddr *sap = (struct sockaddr *)&addr;
|
|
|
|
size_t salen;
|
2007-03-29 20:48:04 +00:00
|
|
|
int status;
|
|
|
|
|
2012-03-01 22:00:56 +00:00
|
|
|
rcu_read_lock();
|
2016-01-30 21:39:26 +00:00
|
|
|
clnt = rpcb_find_transport_owner(task->tk_client);
|
2012-03-01 22:00:56 +00:00
|
|
|
rcu_read_unlock();
|
2016-01-30 21:39:26 +00:00
|
|
|
xprt = xprt_get(task->tk_xprt);
|
2008-10-03 20:48:34 +00:00
|
|
|
|
2007-07-01 16:13:17 +00:00
|
|
|
dprintk("RPC: %5u %s(%s, %u, %u, %d)\n",
|
2008-03-06 04:47:47 +00:00
|
|
|
task->tk_pid, __func__,
|
2012-03-01 22:01:05 +00:00
|
|
|
xprt->servername, clnt->cl_prog, clnt->cl_vers, xprt->prot);
|
2007-03-29 20:48:04 +00:00
|
|
|
|
2008-07-07 16:18:53 +00:00
|
|
|
/* Put self on the wait queue to ensure we get notified if
|
|
|
|
* some other task is already attempting to bind the port */
|
|
|
|
rpc_sleep_on(&xprt->binding, task, NULL);
|
|
|
|
|
2007-03-29 20:48:04 +00:00
|
|
|
if (xprt_test_and_set_binding(xprt)) {
|
2007-07-01 16:13:17 +00:00
|
|
|
dprintk("RPC: %5u %s: waiting for another binder\n",
|
2008-03-06 04:47:47 +00:00
|
|
|
task->tk_pid, __func__);
|
2012-03-01 22:00:56 +00:00
|
|
|
xprt_put(xprt);
|
2008-07-07 16:18:53 +00:00
|
|
|
return;
|
2007-03-29 20:48:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Someone else may have bound if we slept */
|
|
|
|
if (xprt_bound(xprt)) {
|
|
|
|
status = 0;
|
2007-07-01 16:13:17 +00:00
|
|
|
dprintk("RPC: %5u %s: already bound\n",
|
2008-03-06 04:47:47 +00:00
|
|
|
task->tk_pid, __func__);
|
2007-03-29 20:48:04 +00:00
|
|
|
goto bailout_nofree;
|
|
|
|
}
|
|
|
|
|
2009-08-09 19:09:35 +00:00
|
|
|
/* Parent transport's destination address */
|
2007-12-10 19:56:31 +00:00
|
|
|
salen = rpc_peeraddr(clnt, sap, sizeof(addr));
|
2007-08-06 15:57:18 +00:00
|
|
|
|
|
|
|
/* Don't ever use rpcbind v2 for AF_INET6 requests */
|
2007-12-10 19:56:31 +00:00
|
|
|
switch (sap->sa_family) {
|
2007-08-06 15:57:18 +00:00
|
|
|
case AF_INET:
|
2008-07-01 19:20:55 +00:00
|
|
|
proc = rpcb_next_version[xprt->bind_index].rpc_proc;
|
|
|
|
bind_version = rpcb_next_version[xprt->bind_index].rpc_vers;
|
2007-08-06 15:57:18 +00:00
|
|
|
break;
|
|
|
|
case AF_INET6:
|
2008-07-01 19:20:55 +00:00
|
|
|
proc = rpcb_next_version6[xprt->bind_index].rpc_proc;
|
|
|
|
bind_version = rpcb_next_version6[xprt->bind_index].rpc_vers;
|
2007-08-06 15:57:18 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
status = -EAFNOSUPPORT;
|
|
|
|
dprintk("RPC: %5u %s: bad address family\n",
|
2008-03-06 04:47:47 +00:00
|
|
|
task->tk_pid, __func__);
|
2007-08-06 15:57:18 +00:00
|
|
|
goto bailout_nofree;
|
|
|
|
}
|
2008-07-01 19:20:55 +00:00
|
|
|
if (proc == NULL) {
|
2007-03-29 20:48:04 +00:00
|
|
|
xprt->bind_index = 0;
|
2007-09-11 22:00:47 +00:00
|
|
|
status = -EPFNOSUPPORT;
|
2007-07-01 16:13:17 +00:00
|
|
|
dprintk("RPC: %5u %s: no more getport versions available\n",
|
2008-03-06 04:47:47 +00:00
|
|
|
task->tk_pid, __func__);
|
2007-03-29 20:48:04 +00:00
|
|
|
goto bailout_nofree;
|
|
|
|
}
|
|
|
|
|
2007-07-01 16:13:17 +00:00
|
|
|
dprintk("RPC: %5u %s: trying rpcbind version %u\n",
|
2008-03-06 04:47:47 +00:00
|
|
|
task->tk_pid, __func__, bind_version);
|
2007-03-29 20:48:04 +00:00
|
|
|
|
2015-01-30 23:12:28 +00:00
|
|
|
rpcb_clnt = rpcb_create(xprt->xprt_net,
|
|
|
|
clnt->cl_nodename,
|
|
|
|
xprt->servername, sap, salen,
|
2012-01-13 08:52:35 +00:00
|
|
|
xprt->prot, bind_version);
|
2007-08-16 20:03:31 +00:00
|
|
|
if (IS_ERR(rpcb_clnt)) {
|
|
|
|
status = PTR_ERR(rpcb_clnt);
|
|
|
|
dprintk("RPC: %5u %s: rpcb_create failed, error %ld\n",
|
2008-03-06 04:47:47 +00:00
|
|
|
task->tk_pid, __func__, PTR_ERR(rpcb_clnt));
|
2007-08-16 20:03:31 +00:00
|
|
|
goto bailout_nofree;
|
|
|
|
}
|
|
|
|
|
2018-12-20 15:42:36 +00:00
|
|
|
map = kzalloc(sizeof(struct rpcbind_args), GFP_NOFS);
|
2007-03-29 20:48:04 +00:00
|
|
|
if (!map) {
|
|
|
|
status = -ENOMEM;
|
2007-07-01 16:13:17 +00:00
|
|
|
dprintk("RPC: %5u %s: no memory available\n",
|
2008-03-06 04:47:47 +00:00
|
|
|
task->tk_pid, __func__);
|
2008-10-03 20:48:40 +00:00
|
|
|
goto bailout_release_client;
|
2007-03-29 20:48:04 +00:00
|
|
|
}
|
|
|
|
map->r_prog = clnt->cl_prog;
|
|
|
|
map->r_vers = clnt->cl_vers;
|
|
|
|
map->r_prot = xprt->prot;
|
|
|
|
map->r_port = 0;
|
2012-03-27 17:46:32 +00:00
|
|
|
map->r_xprt = xprt;
|
2008-07-07 16:18:53 +00:00
|
|
|
map->r_status = -EIO;
|
2007-03-29 20:48:04 +00:00
|
|
|
|
2009-08-09 19:09:35 +00:00
|
|
|
switch (bind_version) {
|
|
|
|
case RPCBVERS_4:
|
|
|
|
case RPCBVERS_3:
|
2012-03-01 22:00:56 +00:00
|
|
|
map->r_netid = xprt->address_strings[RPC_DISPLAY_NETID];
|
2018-12-20 15:42:36 +00:00
|
|
|
map->r_addr = rpc_sockaddr2uaddr(sap, GFP_NOFS);
|
2018-12-20 15:35:11 +00:00
|
|
|
if (!map->r_addr) {
|
|
|
|
status = -ENOMEM;
|
|
|
|
dprintk("RPC: %5u %s: no memory available\n",
|
|
|
|
task->tk_pid, __func__);
|
|
|
|
goto bailout_free_args;
|
|
|
|
}
|
2009-08-09 19:09:35 +00:00
|
|
|
map->r_owner = "";
|
|
|
|
break;
|
|
|
|
case RPCBVERS_2:
|
|
|
|
map->r_addr = NULL;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
2008-07-01 19:20:55 +00:00
|
|
|
child = rpcb_call_async(rpcb_clnt, map, proc);
|
2007-06-14 20:40:32 +00:00
|
|
|
rpc_release_client(rpcb_clnt);
|
2007-03-29 20:48:04 +00:00
|
|
|
if (IS_ERR(child)) {
|
2008-07-07 16:18:52 +00:00
|
|
|
/* rpcb_map_release() has freed the arguments */
|
2007-07-01 16:13:17 +00:00
|
|
|
dprintk("RPC: %5u %s: rpc_run_task failed\n",
|
2008-03-06 04:47:47 +00:00
|
|
|
task->tk_pid, __func__);
|
2008-07-07 16:18:53 +00:00
|
|
|
return;
|
2007-03-29 20:48:04 +00:00
|
|
|
}
|
|
|
|
|
2008-10-03 20:48:34 +00:00
|
|
|
xprt->stat.bind_count++;
|
|
|
|
rpc_put_task(child);
|
2007-03-29 20:48:04 +00:00
|
|
|
return;
|
|
|
|
|
2018-12-20 15:35:11 +00:00
|
|
|
bailout_free_args:
|
|
|
|
kfree(map);
|
2008-10-03 20:48:40 +00:00
|
|
|
bailout_release_client:
|
|
|
|
rpc_release_client(rpcb_clnt);
|
2007-03-29 20:48:04 +00:00
|
|
|
bailout_nofree:
|
|
|
|
rpcb_wake_rpcbind_waiters(xprt, status);
|
|
|
|
task->tk_status = status;
|
2012-03-01 22:00:56 +00:00
|
|
|
xprt_put(xprt);
|
2007-03-29 20:48:04 +00:00
|
|
|
}
|
2007-09-10 17:45:36 +00:00
|
|
|
EXPORT_SYMBOL_GPL(rpcb_getport_async);
|
2007-03-29 20:48:04 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Rpcbind child task calls this callback via tk_exit.
|
|
|
|
*/
|
|
|
|
static void rpcb_getport_done(struct rpc_task *child, void *data)
|
|
|
|
{
|
|
|
|
struct rpcbind_args *map = data;
|
|
|
|
struct rpc_xprt *xprt = map->r_xprt;
|
|
|
|
int status = child->tk_status;
|
|
|
|
|
2007-09-11 22:00:36 +00:00
|
|
|
/* Garbage reply: retry with a lesser rpcbind version */
|
|
|
|
if (status == -EIO)
|
|
|
|
status = -EPROTONOSUPPORT;
|
|
|
|
|
2007-03-29 20:48:04 +00:00
|
|
|
/* rpcbind server doesn't support this rpcbind protocol version */
|
|
|
|
if (status == -EPROTONOSUPPORT)
|
|
|
|
xprt->bind_index++;
|
|
|
|
|
|
|
|
if (status < 0) {
|
|
|
|
/* rpcbind server not available on remote host? */
|
|
|
|
xprt->ops->set_port(xprt, 0);
|
|
|
|
} else if (map->r_port == 0) {
|
|
|
|
/* Requested RPC service wasn't registered on remote host */
|
|
|
|
xprt->ops->set_port(xprt, 0);
|
|
|
|
status = -EACCES;
|
|
|
|
} else {
|
|
|
|
/* Succeeded */
|
|
|
|
xprt->ops->set_port(xprt, map->r_port);
|
|
|
|
xprt_set_bound(xprt);
|
|
|
|
status = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
dprintk("RPC: %5u rpcb_getport_done(status %d, port %u)\n",
|
|
|
|
child->tk_pid, status, map->r_port);
|
|
|
|
|
2008-07-07 16:18:53 +00:00
|
|
|
map->r_status = status;
|
2007-03-29 20:48:04 +00:00
|
|
|
}
|
|
|
|
|
2008-07-14 20:03:26 +00:00
|
|
|
/*
|
|
|
|
* XDR functions for rpcbind
|
|
|
|
*/
|
|
|
|
|
2010-12-14 14:59:18 +00:00
|
|
|
static void rpcb_enc_mapping(struct rpc_rqst *req, struct xdr_stream *xdr,
|
2017-05-08 07:59:45 +00:00
|
|
|
const void *data)
|
2009-08-09 19:09:40 +00:00
|
|
|
{
|
2017-05-08 07:59:45 +00:00
|
|
|
const struct rpcbind_args *rpcb = data;
|
2010-12-14 14:59:18 +00:00
|
|
|
__be32 *p;
|
2009-08-09 19:09:40 +00:00
|
|
|
|
|
|
|
dprintk("RPC: %5u encoding PMAP_%s call (%u, %u, %d, %u)\n",
|
2012-03-20 13:22:00 +00:00
|
|
|
req->rq_task->tk_pid,
|
|
|
|
req->rq_task->tk_msg.rpc_proc->p_name,
|
2009-08-09 19:09:40 +00:00
|
|
|
rpcb->r_prog, rpcb->r_vers, rpcb->r_prot, rpcb->r_port);
|
|
|
|
|
2010-12-14 14:59:18 +00:00
|
|
|
p = xdr_reserve_space(xdr, RPCB_mappingargs_sz << 2);
|
2010-12-14 14:58:59 +00:00
|
|
|
*p++ = cpu_to_be32(rpcb->r_prog);
|
|
|
|
*p++ = cpu_to_be32(rpcb->r_vers);
|
|
|
|
*p++ = cpu_to_be32(rpcb->r_prot);
|
|
|
|
*p = cpu_to_be32(rpcb->r_port);
|
2009-08-09 19:09:40 +00:00
|
|
|
}
|
|
|
|
|
2010-12-14 14:59:29 +00:00
|
|
|
static int rpcb_dec_getport(struct rpc_rqst *req, struct xdr_stream *xdr,
|
2017-05-08 13:00:29 +00:00
|
|
|
void *data)
|
2009-08-09 19:09:43 +00:00
|
|
|
{
|
2017-05-08 13:00:29 +00:00
|
|
|
struct rpcbind_args *rpcb = data;
|
2009-08-09 19:09:43 +00:00
|
|
|
unsigned long port;
|
2010-12-14 14:59:29 +00:00
|
|
|
__be32 *p;
|
2009-08-09 19:09:43 +00:00
|
|
|
|
|
|
|
rpcb->r_port = 0;
|
|
|
|
|
2010-12-14 14:59:29 +00:00
|
|
|
p = xdr_inline_decode(xdr, 4);
|
2009-08-09 19:09:43 +00:00
|
|
|
if (unlikely(p == NULL))
|
|
|
|
return -EIO;
|
|
|
|
|
2010-12-14 14:58:59 +00:00
|
|
|
port = be32_to_cpup(p);
|
2012-03-20 13:22:00 +00:00
|
|
|
dprintk("RPC: %5u PMAP_%s result: %lu\n", req->rq_task->tk_pid,
|
|
|
|
req->rq_task->tk_msg.rpc_proc->p_name, port);
|
2010-05-24 21:33:03 +00:00
|
|
|
if (unlikely(port > USHRT_MAX))
|
2009-08-09 19:09:43 +00:00
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
rpcb->r_port = port;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-12-14 14:59:29 +00:00
|
|
|
static int rpcb_dec_set(struct rpc_rqst *req, struct xdr_stream *xdr,
|
2017-05-08 13:00:29 +00:00
|
|
|
void *data)
|
2009-08-09 19:09:42 +00:00
|
|
|
{
|
2017-05-08 13:00:29 +00:00
|
|
|
unsigned int *boolp = data;
|
2010-12-14 14:59:29 +00:00
|
|
|
__be32 *p;
|
2009-08-09 19:09:42 +00:00
|
|
|
|
2010-12-14 14:59:29 +00:00
|
|
|
p = xdr_inline_decode(xdr, 4);
|
2009-08-09 19:09:42 +00:00
|
|
|
if (unlikely(p == NULL))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
*boolp = 0;
|
2010-12-14 14:59:29 +00:00
|
|
|
if (*p != xdr_zero)
|
2009-08-09 19:09:42 +00:00
|
|
|
*boolp = 1;
|
|
|
|
|
|
|
|
dprintk("RPC: %5u RPCB_%s call %s\n",
|
2012-03-20 13:22:00 +00:00
|
|
|
req->rq_task->tk_pid,
|
|
|
|
req->rq_task->tk_msg.rpc_proc->p_name,
|
2009-08-09 19:09:42 +00:00
|
|
|
(*boolp ? "succeeded" : "failed"));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-12-14 14:58:59 +00:00
|
|
|
static void encode_rpcb_string(struct xdr_stream *xdr, const char *string,
|
|
|
|
const u32 maxstrlen)
|
2009-08-09 19:09:40 +00:00
|
|
|
{
|
|
|
|
__be32 *p;
|
2010-12-14 14:58:59 +00:00
|
|
|
u32 len;
|
2009-08-09 19:09:40 +00:00
|
|
|
|
|
|
|
len = strlen(string);
|
2012-10-23 14:43:44 +00:00
|
|
|
WARN_ON_ONCE(len > maxstrlen);
|
|
|
|
if (len > maxstrlen)
|
|
|
|
/* truncate and hope for the best */
|
|
|
|
len = maxstrlen;
|
2010-12-14 14:58:59 +00:00
|
|
|
p = xdr_reserve_space(xdr, 4 + len);
|
2009-08-09 19:09:40 +00:00
|
|
|
xdr_encode_opaque(p, string, len);
|
|
|
|
}
|
|
|
|
|
2010-12-14 14:59:18 +00:00
|
|
|
static void rpcb_enc_getaddr(struct rpc_rqst *req, struct xdr_stream *xdr,
|
2017-05-08 07:59:45 +00:00
|
|
|
const void *data)
|
2009-08-09 19:09:40 +00:00
|
|
|
{
|
2017-05-08 07:59:45 +00:00
|
|
|
const struct rpcbind_args *rpcb = data;
|
2010-12-14 14:59:18 +00:00
|
|
|
__be32 *p;
|
2009-08-09 19:09:40 +00:00
|
|
|
|
|
|
|
dprintk("RPC: %5u encoding RPCB_%s call (%u, %u, '%s', '%s')\n",
|
2012-03-20 13:22:00 +00:00
|
|
|
req->rq_task->tk_pid,
|
|
|
|
req->rq_task->tk_msg.rpc_proc->p_name,
|
2009-08-09 19:09:40 +00:00
|
|
|
rpcb->r_prog, rpcb->r_vers,
|
|
|
|
rpcb->r_netid, rpcb->r_addr);
|
|
|
|
|
2010-12-14 14:59:18 +00:00
|
|
|
p = xdr_reserve_space(xdr, (RPCB_program_sz + RPCB_version_sz) << 2);
|
2010-12-14 14:58:59 +00:00
|
|
|
*p++ = cpu_to_be32(rpcb->r_prog);
|
|
|
|
*p = cpu_to_be32(rpcb->r_vers);
|
2009-08-09 19:09:40 +00:00
|
|
|
|
2010-12-14 14:59:18 +00:00
|
|
|
encode_rpcb_string(xdr, rpcb->r_netid, RPCBIND_MAXNETIDLEN);
|
|
|
|
encode_rpcb_string(xdr, rpcb->r_addr, RPCBIND_MAXUADDRLEN);
|
|
|
|
encode_rpcb_string(xdr, rpcb->r_owner, RPCB_MAXOWNERLEN);
|
2009-08-09 19:09:40 +00:00
|
|
|
}
|
|
|
|
|
2010-12-14 14:59:29 +00:00
|
|
|
static int rpcb_dec_getaddr(struct rpc_rqst *req, struct xdr_stream *xdr,
|
2017-05-08 13:00:29 +00:00
|
|
|
void *data)
|
2009-08-09 19:09:43 +00:00
|
|
|
{
|
2017-05-08 13:00:29 +00:00
|
|
|
struct rpcbind_args *rpcb = data;
|
2009-08-09 19:09:43 +00:00
|
|
|
struct sockaddr_storage address;
|
|
|
|
struct sockaddr *sap = (struct sockaddr *)&address;
|
2010-12-14 14:59:29 +00:00
|
|
|
__be32 *p;
|
2009-08-09 19:09:43 +00:00
|
|
|
u32 len;
|
|
|
|
|
|
|
|
rpcb->r_port = 0;
|
|
|
|
|
2010-12-14 14:59:29 +00:00
|
|
|
p = xdr_inline_decode(xdr, 4);
|
2009-08-09 19:09:43 +00:00
|
|
|
if (unlikely(p == NULL))
|
|
|
|
goto out_fail;
|
2010-12-14 14:58:59 +00:00
|
|
|
len = be32_to_cpup(p);
|
2009-08-09 19:09:43 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the returned universal address is a null string,
|
|
|
|
* the requested RPC service was not registered.
|
|
|
|
*/
|
|
|
|
if (len == 0) {
|
|
|
|
dprintk("RPC: %5u RPCB reply: program not registered\n",
|
2012-03-20 13:22:00 +00:00
|
|
|
req->rq_task->tk_pid);
|
2009-08-09 19:09:43 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (unlikely(len > RPCBIND_MAXUADDRLEN))
|
|
|
|
goto out_fail;
|
|
|
|
|
2010-12-14 14:59:29 +00:00
|
|
|
p = xdr_inline_decode(xdr, len);
|
2009-08-09 19:09:43 +00:00
|
|
|
if (unlikely(p == NULL))
|
|
|
|
goto out_fail;
|
2012-03-20 13:22:00 +00:00
|
|
|
dprintk("RPC: %5u RPCB_%s reply: %s\n", req->rq_task->tk_pid,
|
|
|
|
req->rq_task->tk_msg.rpc_proc->p_name, (char *)p);
|
2009-08-09 19:09:43 +00:00
|
|
|
|
2012-01-13 10:02:40 +00:00
|
|
|
if (rpc_uaddr2sockaddr(req->rq_xprt->xprt_net, (char *)p, len,
|
|
|
|
sap, sizeof(address)) == 0)
|
2009-08-09 19:09:43 +00:00
|
|
|
goto out_fail;
|
|
|
|
rpcb->r_port = rpc_get_port(sap);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_fail:
|
|
|
|
dprintk("RPC: %5u malformed RPCB_%s reply\n",
|
2012-03-20 13:22:00 +00:00
|
|
|
req->rq_task->tk_pid,
|
|
|
|
req->rq_task->tk_msg.rpc_proc->p_name);
|
2009-08-09 19:09:43 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2007-03-29 20:48:04 +00:00
|
|
|
/*
|
|
|
|
* Not all rpcbind procedures described in RFC 1833 are implemented
|
|
|
|
* since the Linux kernel RPC code requires only these.
|
|
|
|
*/
|
2009-08-09 19:09:44 +00:00
|
|
|
|
2017-05-12 13:36:49 +00:00
|
|
|
static const struct rpc_procinfo rpcb_procedures2[] = {
|
2009-08-09 19:09:44 +00:00
|
|
|
[RPCBPROC_SET] = {
|
|
|
|
.p_proc = RPCBPROC_SET,
|
2017-05-08 07:59:45 +00:00
|
|
|
.p_encode = rpcb_enc_mapping,
|
2017-05-08 13:00:29 +00:00
|
|
|
.p_decode = rpcb_dec_set,
|
2009-08-09 19:09:44 +00:00
|
|
|
.p_arglen = RPCB_mappingargs_sz,
|
|
|
|
.p_replen = RPCB_setres_sz,
|
|
|
|
.p_statidx = RPCBPROC_SET,
|
|
|
|
.p_timer = 0,
|
|
|
|
.p_name = "SET",
|
|
|
|
},
|
|
|
|
[RPCBPROC_UNSET] = {
|
|
|
|
.p_proc = RPCBPROC_UNSET,
|
2017-05-08 07:59:45 +00:00
|
|
|
.p_encode = rpcb_enc_mapping,
|
2017-05-08 13:00:29 +00:00
|
|
|
.p_decode = rpcb_dec_set,
|
2009-08-09 19:09:44 +00:00
|
|
|
.p_arglen = RPCB_mappingargs_sz,
|
|
|
|
.p_replen = RPCB_setres_sz,
|
|
|
|
.p_statidx = RPCBPROC_UNSET,
|
|
|
|
.p_timer = 0,
|
|
|
|
.p_name = "UNSET",
|
|
|
|
},
|
|
|
|
[RPCBPROC_GETPORT] = {
|
|
|
|
.p_proc = RPCBPROC_GETPORT,
|
2017-05-08 07:59:45 +00:00
|
|
|
.p_encode = rpcb_enc_mapping,
|
2017-05-08 13:00:29 +00:00
|
|
|
.p_decode = rpcb_dec_getport,
|
2009-08-09 19:09:44 +00:00
|
|
|
.p_arglen = RPCB_mappingargs_sz,
|
|
|
|
.p_replen = RPCB_getportres_sz,
|
|
|
|
.p_statidx = RPCBPROC_GETPORT,
|
|
|
|
.p_timer = 0,
|
|
|
|
.p_name = "GETPORT",
|
|
|
|
},
|
2007-03-29 20:48:04 +00:00
|
|
|
};
|
|
|
|
|
2017-05-12 13:36:49 +00:00
|
|
|
static const struct rpc_procinfo rpcb_procedures3[] = {
|
2009-08-09 19:09:44 +00:00
|
|
|
[RPCBPROC_SET] = {
|
|
|
|
.p_proc = RPCBPROC_SET,
|
2017-05-08 07:59:45 +00:00
|
|
|
.p_encode = rpcb_enc_getaddr,
|
2017-05-08 13:00:29 +00:00
|
|
|
.p_decode = rpcb_dec_set,
|
2009-08-09 19:09:44 +00:00
|
|
|
.p_arglen = RPCB_getaddrargs_sz,
|
|
|
|
.p_replen = RPCB_setres_sz,
|
|
|
|
.p_statidx = RPCBPROC_SET,
|
|
|
|
.p_timer = 0,
|
|
|
|
.p_name = "SET",
|
|
|
|
},
|
|
|
|
[RPCBPROC_UNSET] = {
|
|
|
|
.p_proc = RPCBPROC_UNSET,
|
2017-05-08 07:59:45 +00:00
|
|
|
.p_encode = rpcb_enc_getaddr,
|
2017-05-08 13:00:29 +00:00
|
|
|
.p_decode = rpcb_dec_set,
|
2009-08-09 19:09:44 +00:00
|
|
|
.p_arglen = RPCB_getaddrargs_sz,
|
|
|
|
.p_replen = RPCB_setres_sz,
|
|
|
|
.p_statidx = RPCBPROC_UNSET,
|
|
|
|
.p_timer = 0,
|
|
|
|
.p_name = "UNSET",
|
|
|
|
},
|
|
|
|
[RPCBPROC_GETADDR] = {
|
|
|
|
.p_proc = RPCBPROC_GETADDR,
|
2017-05-08 07:59:45 +00:00
|
|
|
.p_encode = rpcb_enc_getaddr,
|
2017-05-08 13:00:29 +00:00
|
|
|
.p_decode = rpcb_dec_getaddr,
|
2009-08-09 19:09:44 +00:00
|
|
|
.p_arglen = RPCB_getaddrargs_sz,
|
|
|
|
.p_replen = RPCB_getaddrres_sz,
|
|
|
|
.p_statidx = RPCBPROC_GETADDR,
|
|
|
|
.p_timer = 0,
|
|
|
|
.p_name = "GETADDR",
|
|
|
|
},
|
2007-03-29 20:48:04 +00:00
|
|
|
};
|
|
|
|
|
2017-05-12 13:36:49 +00:00
|
|
|
static const struct rpc_procinfo rpcb_procedures4[] = {
|
2009-08-09 19:09:44 +00:00
|
|
|
[RPCBPROC_SET] = {
|
|
|
|
.p_proc = RPCBPROC_SET,
|
2017-05-08 07:59:45 +00:00
|
|
|
.p_encode = rpcb_enc_getaddr,
|
2017-05-08 13:00:29 +00:00
|
|
|
.p_decode = rpcb_dec_set,
|
2009-08-09 19:09:44 +00:00
|
|
|
.p_arglen = RPCB_getaddrargs_sz,
|
|
|
|
.p_replen = RPCB_setres_sz,
|
|
|
|
.p_statidx = RPCBPROC_SET,
|
|
|
|
.p_timer = 0,
|
|
|
|
.p_name = "SET",
|
|
|
|
},
|
|
|
|
[RPCBPROC_UNSET] = {
|
|
|
|
.p_proc = RPCBPROC_UNSET,
|
2017-05-08 07:59:45 +00:00
|
|
|
.p_encode = rpcb_enc_getaddr,
|
2017-05-08 13:00:29 +00:00
|
|
|
.p_decode = rpcb_dec_set,
|
2009-08-09 19:09:44 +00:00
|
|
|
.p_arglen = RPCB_getaddrargs_sz,
|
|
|
|
.p_replen = RPCB_setres_sz,
|
|
|
|
.p_statidx = RPCBPROC_UNSET,
|
|
|
|
.p_timer = 0,
|
|
|
|
.p_name = "UNSET",
|
|
|
|
},
|
|
|
|
[RPCBPROC_GETADDR] = {
|
|
|
|
.p_proc = RPCBPROC_GETADDR,
|
2017-05-08 07:59:45 +00:00
|
|
|
.p_encode = rpcb_enc_getaddr,
|
2017-05-08 13:00:29 +00:00
|
|
|
.p_decode = rpcb_dec_getaddr,
|
2009-08-09 19:09:44 +00:00
|
|
|
.p_arglen = RPCB_getaddrargs_sz,
|
|
|
|
.p_replen = RPCB_getaddrres_sz,
|
|
|
|
.p_statidx = RPCBPROC_GETADDR,
|
|
|
|
.p_timer = 0,
|
|
|
|
.p_name = "GETADDR",
|
|
|
|
},
|
2007-03-29 20:48:04 +00:00
|
|
|
};
|
|
|
|
|
2012-01-20 18:53:56 +00:00
|
|
|
static const struct rpcb_info rpcb_next_version[] = {
|
2008-06-25 21:24:31 +00:00
|
|
|
{
|
|
|
|
.rpc_vers = RPCBVERS_2,
|
|
|
|
.rpc_proc = &rpcb_procedures2[RPCBPROC_GETPORT],
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.rpc_proc = NULL,
|
|
|
|
},
|
2007-03-29 20:48:04 +00:00
|
|
|
};
|
|
|
|
|
2012-01-20 18:53:56 +00:00
|
|
|
static const struct rpcb_info rpcb_next_version6[] = {
|
2008-06-25 21:24:31 +00:00
|
|
|
{
|
|
|
|
.rpc_vers = RPCBVERS_4,
|
2008-06-25 21:24:47 +00:00
|
|
|
.rpc_proc = &rpcb_procedures4[RPCBPROC_GETADDR],
|
2008-06-25 21:24:31 +00:00
|
|
|
},
|
|
|
|
{
|
|
|
|
.rpc_vers = RPCBVERS_3,
|
|
|
|
.rpc_proc = &rpcb_procedures3[RPCBPROC_GETADDR],
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.rpc_proc = NULL,
|
|
|
|
},
|
2007-08-06 15:57:18 +00:00
|
|
|
};
|
|
|
|
|
2017-05-08 21:27:10 +00:00
|
|
|
static unsigned int rpcb_version2_counts[ARRAY_SIZE(rpcb_procedures2)];
|
2012-01-20 18:53:56 +00:00
|
|
|
static const struct rpc_version rpcb_version2 = {
|
2008-06-25 21:24:31 +00:00
|
|
|
.number = RPCBVERS_2,
|
2010-12-14 14:59:09 +00:00
|
|
|
.nrprocs = ARRAY_SIZE(rpcb_procedures2),
|
2017-05-08 21:27:10 +00:00
|
|
|
.procs = rpcb_procedures2,
|
|
|
|
.counts = rpcb_version2_counts,
|
2007-03-29 20:48:04 +00:00
|
|
|
};
|
|
|
|
|
2017-05-08 21:27:10 +00:00
|
|
|
static unsigned int rpcb_version3_counts[ARRAY_SIZE(rpcb_procedures3)];
|
2012-01-20 18:53:56 +00:00
|
|
|
static const struct rpc_version rpcb_version3 = {
|
2008-06-25 21:24:31 +00:00
|
|
|
.number = RPCBVERS_3,
|
2010-12-14 14:59:09 +00:00
|
|
|
.nrprocs = ARRAY_SIZE(rpcb_procedures3),
|
2017-05-08 21:27:10 +00:00
|
|
|
.procs = rpcb_procedures3,
|
|
|
|
.counts = rpcb_version3_counts,
|
2007-03-29 20:48:04 +00:00
|
|
|
};
|
|
|
|
|
2017-05-08 21:27:10 +00:00
|
|
|
static unsigned int rpcb_version4_counts[ARRAY_SIZE(rpcb_procedures4)];
|
2012-01-20 18:53:56 +00:00
|
|
|
static const struct rpc_version rpcb_version4 = {
|
2008-06-25 21:24:31 +00:00
|
|
|
.number = RPCBVERS_4,
|
2010-12-14 14:59:09 +00:00
|
|
|
.nrprocs = ARRAY_SIZE(rpcb_procedures4),
|
2017-05-08 21:27:10 +00:00
|
|
|
.procs = rpcb_procedures4,
|
|
|
|
.counts = rpcb_version4_counts,
|
2007-03-29 20:48:04 +00:00
|
|
|
};
|
|
|
|
|
2012-01-20 18:53:56 +00:00
|
|
|
static const struct rpc_version *rpcb_version[] = {
|
2007-03-29 20:48:04 +00:00
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&rpcb_version2,
|
|
|
|
&rpcb_version3,
|
|
|
|
&rpcb_version4
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct rpc_stat rpcb_stats;
|
|
|
|
|
2012-01-20 18:53:56 +00:00
|
|
|
static const struct rpc_program rpcb_program = {
|
2007-03-29 20:48:04 +00:00
|
|
|
.name = "rpcbind",
|
|
|
|
.number = RPCBIND_PROGRAM,
|
|
|
|
.nrvers = ARRAY_SIZE(rpcb_version),
|
|
|
|
.version = rpcb_version,
|
|
|
|
.stats = &rpcb_stats,
|
|
|
|
};
|