/* 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>