![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to clnt_tcp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / sunrpc|
Return to clnt_tcp.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / sunrpc |
1.1 root 1: /*
2: * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
3: * unrestricted use provided that this legend is included on all tape
4: * media and as a part of the software program in whole or part. Users
5: * may copy or modify Sun RPC without charge, but are not authorized
6: * to license or distribute it to anyone else except as part of a product or
7: * program developed by the user.
8: *
9: * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
10: * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
11: * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
12: *
13: * Sun RPC is provided with no support and without any obligation on the
14: * part of Sun Microsystems, Inc. to assist in its use, correction,
15: * modification or enhancement.
16: *
17: * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
18: * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
19: * OR ANY PART THEREOF.
20: *
21: * In no event will Sun Microsystems, Inc. be liable for any lost revenue
22: * or profits or other special, indirect and consequential damages, even if
23: * Sun has been advised of the possibility of such damages.
24: *
25: * Sun Microsystems, Inc.
26: * 2550 Garcia Avenue
27: * Mountain View, California 94043
28: */
29: #ifndef lint
30: static char sccsid[] = "@(#)clnt_tcp.c 1.5 85/03/17 Copyr 1984 Sun Micro";
31: #endif
32:
33: /*
34: * clnt_tcp.c, Implements a TCP/IP based, client side RPC.
35: *
36: * Copyright (C) 1984, Sun Microsystems, Inc.
37: *
38: * TCP based RPC supports 'batched calls'.
39: * A sequence of calls may be batched-up in a send buffer. The rpc call
40: * return immediately to the client even though the call was not necessarily
41: * sent. The batching occurs iff the results' xdr routine is NULL (0) AND
42: * the rpc timeout value is zero (see clnt.h, rpc).
43: *
44: * Clients should NOT casually batch calls that in fact return results; that is,
45: * the server side should be aware that a call is batched and not produce any
46: * return message. Batched calls that produce many result messages can
47: * deadlock (netlock) the client and the server....
48: *
49: * Now go hang yourself.
50: */
51:
52: #include <stdio.h>
53: #include "types.h"
54: #include <sys/socket.h>
55: #include <sys/time.h>
56: #include <netinet/in.h>
57: #include <netdb.h>
58: #include <errno.h>
59: #include "xdr.h"
60: #include "auth.h"
61: #include "clnt.h"
62: #include "rpc_msg.h"
63: #include "pmap_clnt.h"
64:
65: #define MCALL_MSG_SIZE 24
66:
67: char *malloc();
68: extern int errno;
69: long random();
70:
71: static int readtcp();
72: static int writetcp();
73:
74: static enum clnt_stat clnttcp_call();
75: static void clnttcp_abort();
76: static void clnttcp_geterr();
77: static bool_t clnttcp_freeres();
78: static void clnttcp_destroy();
79:
80: static struct clnt_ops tcp_ops = {
81: clnttcp_call,
82: clnttcp_abort,
83: clnttcp_geterr,
84: clnttcp_freeres,
85: clnttcp_destroy
86: };
87:
88: struct ct_data {
89: int ct_sock;
90: struct timeval ct_wait;
91: struct rpc_err ct_error;
92: char ct_mcall[MCALL_MSG_SIZE]; /* marshalled callmsg */
93: u_int ct_mpos; /* pos after marshal */
94: XDR ct_xdrs;
95: };
96:
97: /*
98: * Create a client handle for a tcp/ip connection.
99: * If *sockp<0, *sockp is set to a newly created TCP socket and it is
100: * connected to raddr. If *sockp non-negative then
101: * raddr is ignored. The rpc/tcp package does buffering
102: * similar to stdio, so the client must pick send and receive buffer sizes,];
103: * 0 => use the default.
104: * If raddr->sin_port is 0, then a binder on the remote machine is
105: * consulted for the right port number.
106: * NB: *sockp is copied into a private area.
107: * NB: It is the clients responsibility to close *sockp.
108: * NB: The rpch->cl_auth is set null authentication. Caller may wish to set this
109: * something more useful.
110: */
111: CLIENT *
112: clnttcp_create(raddr, prog, vers, sockp, sendsz, recvsz)
113: struct sockaddr_in *raddr;
114: u_long prog;
115: u_long vers;
116: register int *sockp;
117: u_int sendsz;
118: u_int recvsz;
119: {
120: CLIENT *h;
121: register struct ct_data *ct;
122: struct timeval now;
123: struct rpc_msg call_msg;
124:
125: h = (CLIENT *)mem_alloc(sizeof(*h));
126: if (h == NULL) {
127: fprintf(stderr, "clnttcp_create: out of memory\n");
128: rpc_createerr.cf_stat = RPC_SYSTEMERROR;
129: rpc_createerr.cf_error.re_errno = errno;
130: goto fooy;
131: }
132: ct = (struct ct_data *)mem_alloc(sizeof(*ct));
133: if (ct == NULL) {
134: fprintf(stderr, "clnttcp_create: out of memory\n");
135: rpc_createerr.cf_stat = RPC_SYSTEMERROR;
136: rpc_createerr.cf_error.re_errno = errno;
137: goto fooy;
138: }
139:
140: /*
141: * If no port number given ask the pmap for one
142: */
143: if (raddr->sin_port == 0) {
144: u_short port;
145: if ((port = pmap_getport(raddr, prog, vers, IPPROTO_TCP)) == 0) {
146: mem_free((caddr_t)ct, sizeof(struct ct_data));
147: mem_free((caddr_t)h, sizeof(CLIENT));
148: return ((CLIENT *)NULL);
149: }
150: raddr->sin_port = htons(port);
151: }
152:
153: /*
154: * If no socket given, open one
155: */
156: if (*sockp < 0) {
157: if (((*sockp = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
158: || (connect(*sockp, (struct sockaddr *)raddr,
159: sizeof(*raddr)) < 0)) {
160: rpc_createerr.cf_stat = RPC_SYSTEMERROR;
161: rpc_createerr.cf_error.re_errno = errno;
162: goto fooy;
163: }
164: }
165:
166: /*
167: * Set up private data struct
168: */
169: ct->ct_sock = *sockp;
170: ct->ct_wait.tv_usec = 0;
171:
172: /*
173: * Initialize call message
174: */
175: (void)gettimeofday(&now, (struct timezone *)0);
176: call_msg.rm_xid = getpid() ^ (int)random() ^ now.tv_sec ^ now.tv_usec;
177: call_msg.rm_direction = CALL;
178: call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
179: call_msg.rm_call.cb_prog = prog;
180: call_msg.rm_call.cb_vers = vers;
181:
182: /*
183: * pre-serialize the staic part of the call msg and stash it away
184: */
185: xdrmem_create(&(ct->ct_xdrs), ct->ct_mcall, MCALL_MSG_SIZE,
186: XDR_ENCODE);
187: if (! xdr_callhdr(&(ct->ct_xdrs), &call_msg)) {
188: goto fooy;
189: }
190: ct->ct_mpos = XDR_GETPOS(&(ct->ct_xdrs));
191: XDR_DESTROY(&(ct->ct_xdrs));
192:
193: /*
194: * Create a client handle which uses xdrrec for serialization
195: * and authnone for authentication.
196: */
197: xdrrec_create(&(ct->ct_xdrs), sendsz, recvsz,
198: (caddr_t)ct, readtcp, writetcp);
199: h->cl_ops = &tcp_ops;
200: h->cl_private = (caddr_t) ct;
201: h->cl_auth = authnone_create();
202: return (h);
203:
204: fooy:
205: /*
206: * Something goofed, free stuff and barf
207: */
208: mem_free((caddr_t)ct, sizeof(struct ct_data));
209: mem_free((caddr_t)h, sizeof(CLIENT));
210: (void)close(*sockp);
211: return ((CLIENT *)NULL);
212: }
213:
214: static enum clnt_stat
215: clnttcp_call(h, proc, xdr_args, args_ptr, xdr_results, results_ptr, timeout)
216: register CLIENT *h;
217: u_long proc;
218: xdrproc_t xdr_args;
219: caddr_t args_ptr;
220: xdrproc_t xdr_results;
221: caddr_t results_ptr;
222: struct timeval timeout;
223: {
224: register struct ct_data *ct = (struct ct_data *) h->cl_private;
225: register XDR *xdrs = &(ct->ct_xdrs);
226: struct rpc_msg reply_msg;
227: u_long x_id;
228: u_long *msg_x_id = (u_long *)(ct->ct_mcall); /* yuk */
229: register bool_t shipnow;
230:
231: ct->ct_wait = timeout;
232: shipnow =
233: (xdr_results == (xdrproc_t)0 && timeout.tv_sec == 0
234: && timeout.tv_usec == 0) ? FALSE : TRUE;
235:
236: call_again:
237: xdrs->x_op = XDR_ENCODE;
238: ct->ct_error.re_status = RPC_SUCCESS;
239: x_id = ntohl(--(*msg_x_id));
240: if ((! XDR_PUTBYTES(xdrs, ct->ct_mcall, ct->ct_mpos)) ||
241: (! XDR_PUTLONG(xdrs, (long *)&proc)) ||
242: (! AUTH_MARSHALL(h->cl_auth, xdrs)) ||
243: (! (*xdr_args)(xdrs, args_ptr))) {
244: if (ct->ct_error.re_status == RPC_SUCCESS)
245: ct->ct_error.re_status = RPC_CANTENCODEARGS;
246: (void)xdrrec_endofrecord(xdrs, TRUE);
247: return (ct->ct_error.re_status);
248: }
249: if (! xdrrec_endofrecord(xdrs, shipnow))
250: return (ct->ct_error.re_status = RPC_CANTSEND);
251: if (! shipnow)
252: return (RPC_SUCCESS);
253: xdrs->x_op = XDR_DECODE;
254:
255: /*
256: * Keep receiving until we get a valid transaction id
257: */
258: while (TRUE) {
259: reply_msg.acpted_rply.ar_verf = _null_auth;
260: reply_msg.acpted_rply.ar_results.where = NULL;
261: reply_msg.acpted_rply.ar_results.proc = xdr_void;
262: if (! xdrrec_skiprecord(xdrs))
263: return (ct->ct_error.re_status);
264: /* now decode and validate the response header */
265: if (! xdr_replymsg(xdrs, &reply_msg)) {
266: if (ct->ct_error.re_status == RPC_SUCCESS)
267: continue;
268: return (ct->ct_error.re_status);
269: }
270: if (reply_msg.rm_xid == x_id)
271: break;
272: }
273:
274: /*
275: * process header
276: */
277: _seterr_reply(&reply_msg, &(ct->ct_error));
278: if (ct->ct_error.re_status == RPC_SUCCESS) {
279: if (! AUTH_VALIDATE(h->cl_auth, &reply_msg.acpted_rply.ar_verf)) {
280: ct->ct_error.re_status = RPC_AUTHERROR;
281: ct->ct_error.re_why = AUTH_INVALIDRESP;
282: } else if (! (*xdr_results)(xdrs, results_ptr)) {
283: if (ct->ct_error.re_status == RPC_SUCCESS)
284: ct->ct_error.re_status = RPC_CANTDECODERES;
285: }
286: /* free verifier ... */
287: if (reply_msg.acpted_rply.ar_verf.oa_base != NULL) {
288: xdrs->x_op = XDR_FREE;
289: (void)xdr_opaque_auth(xdrs, &(reply_msg.acpted_rply.ar_verf));
290: }
291: } /* end successful completion */
292: else {
293: /* maybe our credentials need to be refreshed ... */
294: if (AUTH_REFRESH(h->cl_auth))
295: goto call_again;
296: } /* end of unsuccessful completion */
297: return (ct->ct_error.re_status);
298: }
299:
300: static void
301: clnttcp_geterr(h, errp)
302: CLIENT *h;
303: struct rpc_err *errp;
304: {
305: register struct ct_data *ct =
306: (struct ct_data *) h->cl_private;
307:
308: *errp = ct->ct_error;
309: }
310:
311: static bool_t
312: clnttcp_freeres(cl, xdr_res, res_ptr)
313: CLIENT *cl;
314: xdrproc_t xdr_res;
315: caddr_t res_ptr;
316: {
317: register struct ct_data *ct = (struct ct_data *)cl->cl_private;
318: register XDR *xdrs = &(ct->ct_xdrs);
319:
320: xdrs->x_op = XDR_FREE;
321: return ((*xdr_res)(xdrs, res_ptr));
322: }
323:
324: static void
325: clnttcp_abort()
326: {
327: }
328:
329: static void
330: clnttcp_destroy(h)
331: CLIENT *h;
332: {
333: register struct ct_data *ct =
334: (struct ct_data *) h->cl_private;
335:
336: XDR_DESTROY(&(ct->ct_xdrs));
337: mem_free((caddr_t)ct, sizeof(struct ct_data));
338: mem_free((caddr_t)h, sizeof(CLIENT));
339: }
340:
341: /*
342: * Interface between xdr serializer and tcp connection.
343: * Behaves like the system calls, read & write, but keeps some error state
344: * around for the rpc level.
345: */
346: static int
347: readtcp(ct, buf, len)
348: register struct ct_data *ct;
349: caddr_t buf;
350: register int len;
351: {
352: register int mask = 1 << (ct->ct_sock);
353: int readfds;
354:
355: while (TRUE) {
356: readfds = mask;
357: switch (select(32, &readfds, (int*)NULL, (int*)NULL,
358: &(ct->ct_wait))) {
359:
360: case 0:
361: ct->ct_error.re_status = RPC_TIMEDOUT;
362: return (-1);
363:
364: case -1:
365: if (errno == EINTR)
366: continue;
367: ct->ct_error.re_status = RPC_CANTRECV;
368: ct->ct_error.re_errno = errno;
369: return (-1);
370: }
371: if (readfds == mask)
372: break;
373: }
374: if ((len = read(ct->ct_sock, buf, len)) == -1) {
375: ct->ct_error.re_errno = errno;
376: ct->ct_error.re_status = RPC_CANTRECV;
377: }
378: return (len);
379: }
380:
381: static int
382: writetcp(ct, buf, len)
383: struct ct_data *ct;
384: caddr_t buf;
385: int len;
386: {
387: register int i, cnt;
388:
389: for (cnt = len; cnt > 0; cnt -= i, buf += i) {
390: if ((i = write(ct->ct_sock, buf, cnt)) == -1) {
391: ct->ct_error.re_errno = errno;
392: ct->ct_error.re_status = RPC_CANTSEND;
393: return (-1);
394: }
395: }
396: return (len);
397: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.