lib/libc/rpc/clnt_simple.c

   1 /*      $NetBSD: clnt_simple.c,v 1.32 2013/03/11 20:19:29 tron Exp $    */
   2
   3 /*
   4  * Copyright (c) 2010, Oracle America, Inc.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are
   8  * met:
   9  *
  10  *     * Redistributions of source code must retain the above copyright
  11  *       notice, this list of conditions and the following disclaimer.
  12  *     * Redistributions in binary form must reproduce the above
  13  *       copyright notice, this list of conditions and the following
  14  *       disclaimer in the documentation and/or other materials
  15  *       provided with the distribution.
  16  *     * Neither the name of the "Oracle America, Inc." nor the names of its
  17  *       contributors may be used to endorse or promote products derived
  18  *       from this software without specific prior written permission.
  19  *
  20  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  23  *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  24  *   COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  25  *   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  *   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  27  *   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28  *   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  29  *   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  30  *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33 /*
  34  * Copyright (c) 1986-1991 by Sun Microsystems Inc.
  35  */
  36
  37 /* #ident       "@(#)clnt_simple.c      1.17    94/04/24 SMI" */
  38
  39 #include <sys/cdefs.h>
  40 #if defined(LIBC_SCCS) && !defined(lint)
  41 #if 0
  42 static char sccsid[] = "@(#)clnt_simple.c 1.49 89/01/31 Copyr 1984 Sun Micro";
  43 #else
  44 __RCSID("$NetBSD: clnt_simple.c,v 1.32 2013/03/11 20:19:29 tron Exp $");
  45 #endif
  46 #endif
  47
  48 /*
  49  * clnt_simple.c
  50  * Simplified front end to client rpc.
  51  *
  52  */
  53
  54 #include "namespace.h"
  55 #include "reentrant.h"
  56 #include <sys/param.h>
  57 #include <stdio.h>
  58 #include <assert.h>
  59 #include <errno.h>
  60 #include <rpc/rpc.h>
  61 #include <string.h>
  62 #include <stdlib.h>
  63 #include <fcntl.h>
  64 #include <unistd.h>
  65
  66 #ifdef __weak_alias
  67 __weak_alias(rpc_call,_rpc_call)
  68 #endif
  69
  70 #ifndef MAXHOSTNAMELEN
  71 #define MAXHOSTNAMELEN 64
  72 #endif
  73
  74 #ifndef NETIDLEN
  75 #define NETIDLEN 32
  76 #endif
  77
  78 struct rpc_call_private {
  79         int     valid;                  /* Is this entry valid ? */
  80         CLIENT  *client;                /* Client handle */
  81         pid_t   pid;                    /* process-id at moment of creation */
  82         rpcprog_t prognum;              /* Program */
  83         rpcvers_t versnum;              /* Version */
  84         char    host[MAXHOSTNAMELEN];   /* Servers host */
  85         char    nettype[NETIDLEN];      /* Network type */
  86 };
  87 static struct rpc_call_private *rpc_call_private_main;
  88
  89 #ifdef _REENTRANT
  90 static void rpc_call_destroy(void *);
  91
  92 static void
  93 rpc_call_destroy(void *vp)
  94 {
  95         struct rpc_call_private *rcp = (struct rpc_call_private *)vp;
  96
  97         if (rcp) {
  98                 if (rcp->client)
  99                         CLNT_DESTROY(rcp->client);
 100                 free(rcp);
 101         }
 102 }
 103 static thread_key_t rpc_call_key;
 104 static once_t rpc_call_once = ONCE_INITIALIZER;
 105
 106 static void
 107 rpc_call_setup(void)
 108 {
 109
 110         thr_keycreate(&rpc_call_key, rpc_call_destroy);
 111 }
 112 #endif
 113
 114
 115 /*
 116  * This is the simplified interface to the client rpc layer.
 117  * The client handle is not destroyed here and is reused for
 118  * the future calls to same prog, vers, host and nettype combination.
 119  *
 120  * The total time available is 25 seconds.
 121  */
 122 enum clnt_stat
 123 rpc_call(
 124         const char *    host,           /* host name */
 125         rpcprog_t       prognum,        /* program number */
 126         rpcvers_t       versnum,        /* version number */
 127         rpcproc_t       procnum,        /* procedure number */
 128         xdrproc_t       inproc,         /* in XDR procedures */
 129         const char *    in,             /* recv data */
 130         xdrproc_t       outproc,        /* out XDR procedures */
 131         char *          out,            /* send data */
 132         const char *    nettype)        /* nettype */
 133 {
 134         struct rpc_call_private *rcp = (struct rpc_call_private *) 0;
 135         enum clnt_stat clnt_stat;
 136         struct timeval timeout, tottimeout;
 137
 138         _DIAGASSERT(host != NULL);
 139         /* XXX: in may be NULL ??? */
 140         /* XXX: out may be NULL ??? */
 141         /* XXX: nettype may be NULL ??? */
 142
 143 #ifdef _REENTRANT
 144         if (__isthreaded == 0) {
 145                 rcp = rpc_call_private_main;
 146         } else {
 147                 thr_once(&rpc_call_once, rpc_call_setup);
 148                 rcp = thr_getspecific(rpc_call_key);
 149         }
 150 #else
 151         rcp = rpc_call_private_main;
 152 #endif
 153         if (rcp == NULL) {
 154                 rcp = malloc(sizeof (*rcp));
 155                 if (rcp == NULL) {
 156                         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
 157                         rpc_createerr.cf_error.re_errno = errno;
 158                         return (rpc_createerr.cf_stat);
 159                 }
 160                 if (__isthreaded == 0)
 161                         rpc_call_private_main = rcp;
 162                 else
 163                         thr_setspecific(rpc_call_key, (void *) rcp);
 164                 rcp->valid = 0;
 165                 rcp->client = NULL;
 166         }
 167         if ((nettype == NULL) || (nettype[0] == 0))
 168                 nettype = "netpath";
 169         if (!(rcp->valid && rcp->pid == getpid() &&
 170                 (rcp->prognum == prognum) &&
 171                 (rcp->versnum == versnum) &&
 172                 (!strcmp(rcp->host, host)) &&
 173                 (!strcmp(rcp->nettype, nettype)))) {
 174                 int fd;
 175
 176                 rcp->valid = 0;
 177                 if (rcp->client)
 178                         CLNT_DESTROY(rcp->client);
 179                 /*
 180                  * Using the first successful transport for that type
 181                  */
 182                 rcp->client = clnt_create(host, prognum, versnum, nettype);
 183                 rcp->pid = getpid();
 184                 if (rcp->client == NULL) {
 185                         return (rpc_createerr.cf_stat);
 186                 }
 187                 /*
 188                  * Set time outs for connectionless case.  Do it
 189                  * unconditionally.  Faster than doing a t_getinfo()
 190                  * and then doing the right thing.
 191                  */
 192                 timeout.tv_usec = 0;
 193                 timeout.tv_sec = 5;
 194                 (void) CLNT_CONTROL(rcp->client,
 195                                 CLSET_RETRY_TIMEOUT, (char *)(void *)&timeout);
 196                 if (CLNT_CONTROL(rcp->client, CLGET_FD, (char *)(void *)&fd))
 197                         (void)fcntl(fd, F_SETFD, FD_CLOEXEC);
 198                 rcp->prognum = prognum;
 199                 rcp->versnum = versnum;
 200                 if ((strlen(host) < (size_t)MAXHOSTNAMELEN) &&
 201                     (strlen(nettype) < (size_t)NETIDLEN)) {
 202                         (void) strcpy(rcp->host, host);
 203                         (void) strcpy(rcp->nettype, nettype);
 204                         rcp->valid = 1;
 205                 } else {
 206                         rcp->valid = 0;
 207                 }
 208         } /* else reuse old client */
 209         tottimeout.tv_sec = 25;
 210         tottimeout.tv_usec = 0;
 211         clnt_stat = CLNT_CALL(rcp->client, procnum, inproc, in,
 212             outproc, out, tottimeout);
 213         /*
 214          * if call failed, empty cache
 215          */
 216         if (clnt_stat != RPC_SUCCESS)
 217                 rcp->valid = 0;
 218         return (clnt_stat);
 219 }