support/nfs/svc_create.c

   1 /*
   2  * Copyright 2009 Oracle.  All rights reserved.
   3  *
   4  * This file is part of nfs-utils.
   5  *
   6  * nfs-utils is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * nfs-utils is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with nfs-utils.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <memory.h>
  28 #include <signal.h>
  29 #include <unistd.h>
  30 #include <errno.h>
  31 #include <netdb.h>
  32
  33 #include <netinet/in.h>
  34
  35 #include <sys/socket.h>
  36 #include <sys/resource.h>
  37
  38 #include <rpc/rpc.h>
  39 #include <rpc/svc.h>
  40
  41 #ifdef HAVE_TCP_WRAPPER
  42 #include "tcpwrapper.h"
  43 #endif
  44
  45 #include "sockaddr.h"
  46 #include "rpcmisc.h"
  47 #include "xlog.h"
  48
  49 #ifdef HAVE_LIBTIRPC
  50
  51 #define SVC_CREATE_XPRT_CACHE_SIZE      (8)
  52 static SVCXPRT *svc_create_xprt_cache[SVC_CREATE_XPRT_CACHE_SIZE] = { NULL, };
  53
  54 /*
  55  * Cache an SVC xprt, in case there are more programs or versions to
  56  * register against it.
  57  */
  58 static void
  59 svc_create_cache_xprt(SVCXPRT *xprt)
  60 {
  61         unsigned int i;
  62
  63         /* Check if we've already got this one... */
  64         for (i = 0; i < SVC_CREATE_XPRT_CACHE_SIZE; i++)
  65                 if (svc_create_xprt_cache[i] == xprt)
  66                         return;
  67
  68         /* No, we don't.  Cache it. */
  69         for (i = 0; i < SVC_CREATE_XPRT_CACHE_SIZE; i++)
  70                 if (svc_create_xprt_cache[i] == NULL) {
  71                         svc_create_xprt_cache[i] = xprt;
  72                         return;
  73                 }
  74
  75         xlog(L_ERROR, "%s: Failed to cache an xprt", __func__);
  76 }
  77
  78 /*
  79  * Find a previously cached SVC xprt structure with the given bind address
  80  * and transport semantics.
  81  *
  82  * Returns pointer to a cached SVC xprt.
  83  *
  84  * If no matching SVC XPRT can be found, NULL is returned.
  85  */
  86 static SVCXPRT *
  87 svc_create_find_xprt(const struct sockaddr *bindaddr, const struct netconfig *nconf)
  88 {
  89         unsigned int i;
  90
  91         for (i = 0; i < SVC_CREATE_XPRT_CACHE_SIZE; i++) {
  92                 SVCXPRT *xprt = svc_create_xprt_cache[i];
  93                 struct sockaddr *sap;
  94
  95                 if (xprt == NULL)
  96                         continue;
  97                 if (strcmp(nconf->nc_netid, xprt->xp_netid) != 0)
  98                         continue;
  99                 sap = (struct sockaddr *)xprt->xp_ltaddr.buf;
 100                 if (!nfs_compare_sockaddr(bindaddr, sap))
 101                         continue;
 102                 return xprt;
 103         }
 104         return NULL;
 105 }
 106
 107 /*
 108  * Set up an appropriate bind address, given @port and @nconf.
 109  *
 110  * Returns getaddrinfo(3) results if successful.  Caller must
 111  * invoke freeaddrinfo(3) on these results.
 112  *
 113  * Otherwise NULL is returned if an error occurs.
 114  */
 115 __attribute_malloc__
 116 static struct addrinfo *
 117 svc_create_bindaddr(struct netconfig *nconf, const uint16_t port)
 118 {
 119         struct addrinfo *ai = NULL;
 120         struct addrinfo hint = {
 121                 .ai_flags       = AI_PASSIVE | AI_NUMERICSERV,
 122         };
 123         char buf[8];
 124         int error;
 125
 126         if (strcmp(nconf->nc_protofmly, NC_INET) == 0)
 127                 hint.ai_family = AF_INET;
 128 #ifdef IPV6_SUPPORTED
 129         else if (strcmp(nconf->nc_protofmly, NC_INET6) == 0)
 130                 hint.ai_family = AF_INET6;
 131 #endif  /* IPV6_SUPPORTED */
 132         else {
 133                 xlog(D_GENERAL, "Unrecognized bind address family: %s",
 134                         nconf->nc_protofmly);
 135                 return NULL;
 136         }
 137
 138         if (strcmp(nconf->nc_proto, NC_UDP) == 0)
 139                 hint.ai_protocol = (int)IPPROTO_UDP;
 140         else if (strcmp(nconf->nc_proto, NC_TCP) == 0)
 141                 hint.ai_protocol = (int)IPPROTO_TCP;
 142         else {
 143                 xlog(D_GENERAL, "Unrecognized bind address protocol: %s",
 144                         nconf->nc_proto);
 145                 return NULL;
 146         }
 147
 148         (void)snprintf(buf, sizeof(buf), "%u", port);
 149         error = getaddrinfo(NULL, buf, &hint, &ai);
 150         if (error != 0) {
 151                 xlog(L_ERROR, "Failed to construct bind address: %s",
 152                         gai_strerror(error));
 153                 return NULL;
 154         }
 155
 156         return ai;
 157 }
 158
 159 /*
 160  * Create a listener socket on a specific bindaddr, and set
 161  * special socket options to allow it to share the same port
 162  * as other listeners.
 163  *
 164  * Returns an open, bound, and possibly listening network
 165  * socket on success.
 166  *
 167  * Otherwise returns -1 if some error occurs.
 168  */
 169 static int
 170 svc_create_sock(const struct sockaddr *sap, socklen_t salen,
 171                 struct netconfig *nconf)
 172 {
 173         int fd, type, protocol;
 174         int one = 1;
 175
 176         switch(nconf->nc_semantics) {
 177         case NC_TPI_CLTS:
 178                 type = SOCK_DGRAM;
 179                 break;
 180         case NC_TPI_COTS_ORD:
 181                 type = SOCK_STREAM;
 182                 break;
 183         default:
 184                 xlog(D_GENERAL, "%s: Unrecognized bind address semantics: %u",
 185                         __func__, nconf->nc_semantics);
 186                 return -1;
 187         }
 188
 189         if (strcmp(nconf->nc_proto, NC_UDP) == 0)
 190                 protocol = (int)IPPROTO_UDP;
 191         else if (strcmp(nconf->nc_proto, NC_TCP) == 0)
 192                 protocol = (int)IPPROTO_TCP;
 193         else {
 194                 xlog(D_GENERAL, "%s: Unrecognized bind address protocol: %s",
 195                         __func__, nconf->nc_proto);
 196                 return -1;
 197         }
 198
 199         fd = socket((int)sap->sa_family, type, protocol);
 200         if (fd == -1) {
 201                 xlog(L_ERROR, "Could not make a socket: (%d) %m",
 202                         errno);
 203                 return -1;
 204         }
 205
 206 #ifdef IPV6_SUPPORTED
 207         if (sap->sa_family == AF_INET6) {
 208                 if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY,
 209                                 &one, sizeof(one)) == -1) {
 210                         xlog(L_ERROR, "Failed to set IPV6_V6ONLY: (%d) %m",
 211                                 errno);
 212                         (void)close(fd);
 213                         return -1;
 214                 }
 215         }
 216 #endif  /* IPV6_SUPPORTED */
 217
 218         if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
 219                        &one, sizeof(one)) == -1) {
 220                 xlog(L_ERROR, "Failed to set SO_REUSEADDR: (%d) %m",
 221                         errno);
 222                 (void)close(fd);
 223                 return -1;
 224         }
 225
 226         if (bind(fd, sap, salen) == -1) {
 227                 xlog(L_ERROR, "Could not bind socket: (%d) %m",
 228                         errno);
 229                 (void)close(fd);
 230                 return -1;
 231         }
 232
 233         if (nconf->nc_semantics == NC_TPI_COTS_ORD)
 234                 if (listen(fd, SOMAXCONN) == -1) {
 235                         xlog(L_ERROR, "Could not listen on socket: (%d) %m",
 236                                 errno);
 237                         (void)close(fd);
 238                         return -1;
 239                 }
 240
 241         return fd;
 242 }
 243
 244 /*
 245  * The simple case is allowing the TI-RPC library to create a
 246  * transport itself, given just the bind address and transport
 247  * semantics.
 248  *
 249  * Our local xprt cache is ignored in this path, since the
 250  * caller is not interested in sharing listeners or ports, and
 251  * the library automatically avoids ports already in use.
 252  *
 253  * Returns the count of started listeners (one or zero).
 254  */
 255 static unsigned int
 256 svc_create_nconf_rand_port(const char *name, const rpcprog_t program,
 257                 const rpcvers_t version,
 258                 void (*dispatch)(struct svc_req *, SVCXPRT *),
 259                 struct netconfig *nconf)
 260 {
 261         struct t_bind bindaddr;
 262         struct addrinfo *ai;
 263         SVCXPRT *xprt;
 264
 265         ai = svc_create_bindaddr(nconf, 0);
 266         if (ai == NULL)
 267                 return 0;
 268
 269         bindaddr.addr.buf = ai->ai_addr;
 270         bindaddr.qlen = SOMAXCONN;
 271
 272         xprt = svc_tli_create(RPC_ANYFD, nconf, &bindaddr, 0, 0);
 273         freeaddrinfo(ai);
 274         if (xprt == NULL) {
 275                 xlog(D_GENERAL, "Failed to create listener xprt "
 276                         "(%s, %u, %s)", name, version, nconf->nc_netid);
 277                 return 0;
 278         }
 279
 280         if (!svc_reg(xprt, program, version, dispatch, nconf)) {
 281                 /* svc_reg(3) destroys @xprt in this case */
 282                 xlog(D_GENERAL, "Failed to register (%s, %u, %s)",
 283                                 name, version, nconf->nc_netid);
 284                 return 0;
 285         }
 286
 287         return 1;
 288 }
 289
 290 /*
 291  * If a port is specified on the command line, that port value will be
 292  * the same for all listeners created here.  Create each listener
 293  * socket in advance and set SO_REUSEADDR, rather than allowing the
 294  * RPC library to create the listeners for us on a randomly chosen
 295  * port via svc_tli_create(RPC_ANYFD).
 296  *
 297  * Some callers want to listen for more than one RPC version using the
 298  * same port number.  For example, mountd could want to listen for MNT
 299  * version 1, 2, and 3 requests.  This means mountd must use the same
 300  * set of listener sockets for multiple RPC versions, since, on one
 301  * system, you can't have two listener sockets with the exact same
 302  * bind address (and port) and transport protocol.
 303  *
 304  * To accomplish this, this function caches xprts as they are created.
 305  * This cache is checked to see if a previously created xprt can be
 306  * used, before creating a new xprt for this [program, version].  If
 307  * there is a cached xprt with the same bindaddr and transport
 308  * semantics, we simply register the new version with that xprt,
 309  * rather than creating a fresh xprt for it.
 310  *
 311  * The xprt cache implemented here is local to a process.  Two
 312  * separate RPC daemons can not share a set of listeners.
 313  *
 314  * Returns the count of started listeners (one or zero).
 315  */
 316 static unsigned int
 317 svc_create_nconf_fixed_port(const char *name, const rpcprog_t program,
 318                 const rpcvers_t version,
 319                 void (*dispatch)(struct svc_req *, SVCXPRT *),
 320                 const uint16_t port, struct netconfig *nconf)
 321 {
 322         struct addrinfo *ai;
 323         SVCXPRT *xprt;
 324
 325         ai = svc_create_bindaddr(nconf, port);
 326         if (ai == NULL)
 327                 return 0;
 328
 329         xprt = svc_create_find_xprt(ai->ai_addr, nconf);
 330         if (xprt == NULL) {
 331                 int fd;
 332
 333                 fd = svc_create_sock(ai->ai_addr, ai->ai_addrlen, nconf);
 334                 if (fd == -1)
 335                         goto out_free;
 336
 337                 xprt = svc_tli_create(fd, nconf, NULL, 0, 0);
 338                 if (xprt == NULL) {
 339                         xlog(D_GENERAL, "Failed to create listener xprt "
 340                                 "(%s, %u, %s)", name, version, nconf->nc_netid);
 341                         (void)close(fd);
 342                         goto out_free;
 343                 }
 344         }
 345
 346         if (!svc_reg(xprt, program, version, dispatch, nconf)) {
 347                 /* svc_reg(3) destroys @xprt in this case */
 348                 xlog(D_GENERAL, "Failed to register (%s, %u, %s)",
 349                                 name, version, nconf->nc_netid);
 350                 goto out_free;
 351         }
 352
 353         svc_create_cache_xprt(xprt);
 354
 355         freeaddrinfo(ai);
 356         return 1;
 357
 358 out_free:
 359         freeaddrinfo(ai);
 360         return 0;
 361 }
 362
 363 static unsigned int
 364 svc_create_nconf(const char *name, const rpcprog_t program,
 365                 const rpcvers_t version,
 366                 void (*dispatch)(struct svc_req *, SVCXPRT *),
 367                 const uint16_t port, struct netconfig *nconf)
 368 {
 369         if (port != 0)
 370                 return svc_create_nconf_fixed_port(name, program,
 371                         version, dispatch, port, nconf);
 372
 373         return svc_create_nconf_rand_port(name, program,
 374                         version, dispatch, nconf);
 375 }
 376
 377 /**
 378  * nfs_svc_create - start up RPC svc listeners
 379  * @name: C string containing name of new service
 380  * @program: RPC program number to register
 381  * @version: RPC version number to register
 382  * @dispatch: address of function that handles incoming RPC requests
 383  * @port: if not zero, transport listens on this port
 384  *
 385  * Sets up network transports for receiving RPC requests, and starts
 386  * the RPC dispatcher.  Returns the number of started network transports.
 387  */
 388 unsigned int
 389 nfs_svc_create(char *name, const rpcprog_t program, const rpcvers_t version,
 390                 void (*dispatch)(struct svc_req *, SVCXPRT *),
 391                 const uint16_t port)
 392 {
 393         const struct sigaction create_sigaction = {
 394                 .sa_handler     = SIG_IGN,
 395         };
 396         unsigned int visible, up, servport;
 397         struct netconfig *nconf;
 398         void *handlep;
 399
 400         /*
 401          * Ignore SIGPIPE to avoid exiting sideways when peers
 402          * close their TCP connection while we're trying to reply
 403          * to them.
 404          */
 405         (void)sigaction(SIGPIPE, &create_sigaction, NULL);
 406
 407         handlep = setnetconfig();
 408         if (handlep == NULL) {
 409                 xlog(L_ERROR, "Failed to access local netconfig database: %s",
 410                         nc_sperror());
 411                 return 0;
 412         }
 413
 414         visible = 0;
 415         up = 0;
 416         while ((nconf = getnetconfig(handlep)) != NULL) {
 417                 if (!(nconf->nc_flag & NC_VISIBLE))
 418                         continue;
 419                 visible++;
 420                 if (port == 0)
 421                         servport = getservport(program, nconf->nc_proto);
 422                 else
 423                         servport = port;
 424
 425                 up += svc_create_nconf(name, program, version, dispatch,
 426                                                 servport, nconf);
 427         }
 428
 429         if (visible == 0)
 430                 xlog(L_ERROR, "Failed to find any visible netconfig entries");
 431
 432         if (endnetconfig(handlep) == -1)
 433                 xlog(L_ERROR, "Failed to close local netconfig database: %s",
 434                         nc_sperror());
 435
 436         return up;
 437 }
 438
 439 /**
 440  * nfs_svc_unregister - remove service registrations from local rpcbind database
 441  * @program: RPC program number to unregister
 442  * @version: RPC version number to unregister
 443  *
 444  * Removes all registrations for [ @program, @version ] .
 445  */
 446 void
 447 nfs_svc_unregister(const rpcprog_t program, const rpcvers_t version)
 448 {
 449         if (rpcb_unset(program, version, NULL) == FALSE)
 450                 xlog(D_GENERAL, "Failed to unregister program %lu, version %lu",
 451                         (unsigned long)program, (unsigned long)version);
 452 }
 453
 454 #else   /* !HAVE_LIBTIRPC */
 455
 456 /**
 457  * nfs_svc_create - start up RPC svc listeners
 458  * @name: C string containing name of new service
 459  * @program: RPC program number to register
 460  * @version: RPC version number to register
 461  * @dispatch: address of function that handles incoming RPC requests
 462  * @port: if not zero, transport listens on this port
 463  *
 464  * Sets up network transports for receiving RPC requests, and starts
 465  * the RPC dispatcher.  Returns the number of started network transports.
 466  */
 467 unsigned int
 468 nfs_svc_create(char *name, const rpcprog_t program, const rpcvers_t version,
 469                 void (*dispatch)(struct svc_req *, SVCXPRT *),
 470                 const uint16_t port)
 471 {
 472         rpc_init(name, (int)program, (int)version, dispatch, (int)port);
 473         return 1;
 474 }
 475
 476 /**
 477  * nfs_svc_unregister - remove service registrations from local rpcbind database
 478  * @program: RPC program number to unregister
 479  * @version: RPC version number to unregister
 480  *
 481  * Removes all registrations for [ @program, @version ] .
 482  */
 483 void
 484 nfs_svc_unregister(const rpcprog_t program, const rpcvers_t version)
 485 {
 486         if (pmap_unset((unsigned long)program, (unsigned long)version) == FALSE)
 487                 xlog(D_GENERAL, "Failed to unregister program %lu, version %lu",
 488                         (unsigned long)program, (unsigned long)version);
 489 }
 490
 491 #endif  /* !HAVE_LIBTIRPC */