/* Test svc_register/svc_unregister rpcbind interaction (bug 5010).
Copyright (C) 2017-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
/* This test uses a stub rpcbind server (implemented in a child
process using rpcbind_dispatch/run_rpcbind) to check how RPC
services are registered and unregistered using the rpcbind
protocol. For each subtest, a separate rpcbind test server is
spawned and terminated. */
#include <errno.h>
#include <netinet/in.h>
#include <rpc/clnt.h>
#include <rpc/pmap_prot.h>
#include <rpc/svc.h>
#include <signal.h>
#include <support/check.h>
#include <support/namespace.h>
#include <support/test-driver.h>
#include <support/xsocket.h>
#include <support/xthread.h>
#include <support/xunistd.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>
#include <libc-symbols.h>
#include <shlib-compat.h>
/* These functions are only available as compat symbols. */
compat_symbol_reference (libc, xdr_pmap, xdr_pmap, GLIBC_2_0);
compat_symbol_reference (libc, svc_unregister, svc_unregister, GLIBC_2_0);
/* Server callback for the unused RPC service which is registered and
unregistered. */
static void
server_dispatch (struct svc_req *request, SVCXPRT *transport)
{
FAIL_EXIT1 ("server_dispatch called");
}
/* The port on which rpcbind listens for incoming requests. */
static inline const struct sockaddr_in
rpcbind_address (void)
{
return (struct sockaddr_in)
{
.sin_family = AF_INET,
.sin_addr.s_addr = htonl (INADDR_LOOPBACK),
.sin_port = htons (PMAPPORT)
};
}
/* Data provided by the test server after running the test, to see
that the expected calls (and only those) happened. */
struct test_state
{
bool_t set_called;
bool_t unset_called;
};
static bool_t
xdr_test_state (XDR *xdrs, void *data, ...)
{
struct test_state *p = data;
return xdr_bool (xdrs, &p->set_called)
&& xdr_bool (xdrs, &p->unset_called);
}
enum
{
/* Coordinates of our test service. These numbers are
arbitrary. */
PROGNUM = 123,
VERSNUM = 456,
/* Extension for this test. */
PROC_GET_STATE_AND_EXIT = 10760
};
/* Dummy implementation of the rpcbind service, with the
PROC_GET_STATE_AND_EXIT extension. */
static void
rpcbind_dispatch (struct svc_req *request, SVCXPRT *transport)
{
static struct test_state state = { 0, };
if (test_verbose)
printf ("info: rpcbind request %lu\n", request->rq_proc);
switch (request->rq_proc)
{
case PMAPPROC_SET:
case PMAPPROC_UNSET:
TEST_VERIFY (state.set_called == (request->rq_proc == PMAPPROC_UNSET));
TEST_VERIFY (!state.unset_called);
struct pmap query = { 0, };
TEST_VERIFY
(svc_getargs (transport, (xdrproc_t) xdr_pmap, (void *) &query));
if (test_verbose)
printf (" pm_prog=%lu pm_vers=%lu pm_prot=%lu pm_port=%lu\n",
query.pm_prog, query.pm_vers, query.pm_prot, query.pm_port);
TEST_VERIFY (query.pm_prog == PROGNUM);
TEST_VERIFY (query.pm_vers == VERSNUM);
if (request->rq_proc == PMAPPROC_SET)
state.set_called = TRUE;
else
state.unset_called = TRUE;
bool_t result = TRUE;
TEST_VERIFY (svc_sendreply (transport,
(xdrproc_t) xdr_bool, (void *) &result));
break;
case PROC_GET_STATE_AND_EXIT:
TEST_VERIFY (svc_sendreply (transport,
xdr_test_state, (void *) &state));
_exit (0);
break;
default:
FAIL_EXIT1 ("invalid rq_proc value: %lu", request->rq_proc);
}
}
/* Run the rpcbind test server. */
static void
run_rpcbind (int rpcbind_sock)
{
SVCXPRT *rpcbind_transport = svcudp_create (rpcbind_sock);
TEST_VERIFY (svc_register (rpcbind_transport, PMAPPROG, PMAPVERS,
rpcbind_dispatch,
/* Do not register with rpcbind. */
0));
svc_run ();
}
/* Call out to the rpcbind test server to retrieve the test status
information. */
static struct test_state
get_test_state (void)
{
int socket = RPC_ANYSOCK;
struct sockaddr_in address = rpcbind_address ();
CLIENT *client = clntudp_create
(&address, PMAPPROG, PMAPVERS, (struct timeval) { 1, 0}, &socket);
struct test_state result = { 0 };
TEST_VERIFY (clnt_call (client, PROC_GET_STATE_AND_EXIT,
(xdrproc_t) xdr_void, NULL,
xdr_test_state, (void *) &result,
((struct timeval) { 3, 0}))
== RPC_SUCCESS);
clnt_destroy (client);
return result;
}
/* Used by test_server_thread to receive test parameters. */
struct test_server_args
{
bool use_rpcbind;
bool use_unregister;
};
/* RPC test server. Used to verify the svc_unregister behavior during
thread cleanup. */
static void *
test_server_thread (void *closure)
{
struct test_server_args *args = closure;
SVCXPRT *transport = svcudp_create (RPC_ANYSOCK);
int protocol;
if (args->use_rpcbind)
protocol = IPPROTO_UDP;
else
/* Do not register with rpcbind. */
protocol = 0;
TEST_VERIFY (svc_register (transport, PROGNUM, VERSNUM,
server_dispatch, protocol));
if (args->use_unregister)
svc_unregister (PROGNUM, VERSNUM);
SVC_DESTROY (transport);
return NULL;
}
static int
do_test (void)
{
support_become_root ();
support_enter_network_namespace ();
/* Try to bind to the rpcbind port. */
int rpcbind_sock = xsocket (AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
{
struct sockaddr_in sin = rpcbind_address ();
if (bind (rpcbind_sock, (struct sockaddr *) &sin, sizeof (sin)) != 0)
{
/* If the port is not available, we cannot run this test. */
printf ("warning: could not bind to rpcbind port %d: %m\n",
(int) PMAPPORT);
return EXIT_UNSUPPORTED;
}
}
for (int use_thread = 0; use_thread < 2; ++use_thread)
for (int use_rpcbind = 0; use_rpcbind < 2; ++use_rpcbind)
for (int use_unregister = 0; use_unregister < 2; ++use_unregister)
{
if (test_verbose)
printf ("info: * use_thread=%d use_rpcbind=%d use_unregister=%d\n",
use_thread, use_rpcbind, use_unregister);
/* Create the subprocess which runs the actual test. The
kernel will queue the UDP packets to the rpcbind
process. */
pid_t svc_pid = xfork ();
if (svc_pid == 0)
{
struct test_server_args args =
{
.use_rpcbind = use_rpcbind,
.use_unregister = use_unregister,
};
if (use_thread)
xpthread_join (xpthread_create
(NULL, test_server_thread, &args));
else
test_server_thread (&args);
/* We cannnot use _exit here because we want to test the
process cleanup. */
exit (0);
}
/* Create the subprocess for the rpcbind test server. */
pid_t rpcbind_pid = xfork ();
if (rpcbind_pid == 0)
run_rpcbind (rpcbind_sock);
int status;
xwaitpid (svc_pid, &status, 0);
TEST_VERIFY (WIFEXITED (status) && WEXITSTATUS (status) == 0);
if (!use_rpcbind)
/* Wait a bit, to see if the packet arrives on the rpcbind
port. The choice is of the timeout is arbitrary, but
should be long enough even for slow/busy systems. For
the use_rpcbind case, waiting on svc_pid above makes
sure that the test server has responded because
svc_register/svc_unregister are supposed to wait for a
reply. */
usleep (300 * 1000);
struct test_state state = get_test_state ();
if (use_rpcbind)
{
TEST_VERIFY (state.set_called);
if (use_thread || use_unregister)
/* Thread cleanup or explicit svc_unregister will
result in a rpcbind unset RPC call. */
TEST_VERIFY (state.unset_called);
else
/* This is arguably a bug: Regular process termination
does not unregister the service with rpcbind. The
unset rpcbind call happens from a __libc_subfreeres
callback, and this only happens when running under
memory debuggers such as valgrind. */
TEST_VERIFY (!state.unset_called);
}
else
{
/* If rpcbind registration is not requested, we do not
expect any rpcbind calls. */
TEST_VERIFY (!state.set_called);
TEST_VERIFY (!state.unset_called);
}
xwaitpid (rpcbind_pid, &status, 0);
TEST_VERIFY (WIFEXITED (status) && WEXITSTATUS (status) == 0);
}
return 0;
}
#include <support/test-driver.c>