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