mirror of
https://sourceware.org/git/glibc.git
synced 2025-08-01 10:06:57 +03:00
initial import
This commit is contained in:
Roland McGrath
466
sunrpc/clnt_tcp.c
Normal file
466
sunrpc/clnt_tcp.c
Normal file
@ -0,0 +1,466 @@
|
||||
/* @(#)clnt_tcp.c 2.2 88/08/01 4.0 RPCSRC */
|
||||
/*
|
||||
* Sun RPC is a product of Sun Microsystems, Inc. and is provided for
|
||||
* unrestricted use provided that this legend is included on all tape
|
||||
* media and as a part of the software program in whole or part. Users
|
||||
* may copy or modify Sun RPC without charge, but are not authorized
|
||||
* to license or distribute it to anyone else except as part of a product or
|
||||
* program developed by the user.
|
||||
*
|
||||
* SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
|
||||
* WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
|
||||
*
|
||||
* Sun RPC is provided with no support and without any obligation on the
|
||||
* part of Sun Microsystems, Inc. to assist in its use, correction,
|
||||
* modification or enhancement.
|
||||
*
|
||||
* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
|
||||
* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
|
||||
* OR ANY PART THEREOF.
|
||||
*
|
||||
* In no event will Sun Microsystems, Inc. be liable for any lost revenue
|
||||
* or profits or other special, indirect and consequential damages, even if
|
||||
* Sun has been advised of the possibility of such damages.
|
||||
*
|
||||
* Sun Microsystems, Inc.
|
||||
* 2550 Garcia Avenue
|
||||
* Mountain View, California 94043
|
||||
*/
|
||||
#if !defined(lint) && defined(SCCSIDS)
|
||||
static char sccsid[] = "@(#)clnt_tcp.c 1.37 87/10/05 Copyr 1984 Sun Micro";
|
||||
#endif
|
||||
|
||||
/*
|
||||
* clnt_tcp.c, Implements a TCP/IP based, client side RPC.
|
||||
*
|
||||
* Copyright (C) 1984, Sun Microsystems, Inc.
|
||||
*
|
||||
* TCP based RPC supports 'batched calls'.
|
||||
* A sequence of calls may be batched-up in a send buffer. The rpc call
|
||||
* return immediately to the client even though the call was not necessarily
|
||||
* sent. The batching occurs if the results' xdr routine is NULL (0) AND
|
||||
* the rpc timeout value is zero (see clnt.h, rpc).
|
||||
*
|
||||
* Clients should NOT casually batch calls that in fact return results; that is,
|
||||
* the server side should be aware that a call is batched and not produce any
|
||||
* return message. Batched calls that produce many result messages can
|
||||
* deadlock (netlock) the client and the server....
|
||||
*
|
||||
* Now go hang yourself.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <rpc/rpc.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netdb.h>
|
||||
#include <errno.h>
|
||||
#include <rpc/pmap_clnt.h>
|
||||
|
||||
#define MCALL_MSG_SIZE 24
|
||||
|
||||
extern int errno;
|
||||
|
||||
static int readtcp();
|
||||
static int writetcp();
|
||||
|
||||
static enum clnt_stat clnttcp_call();
|
||||
static void clnttcp_abort();
|
||||
static void clnttcp_geterr();
|
||||
static bool_t clnttcp_freeres();
|
||||
static bool_t clnttcp_control();
|
||||
static void clnttcp_destroy();
|
||||
|
||||
static struct clnt_ops tcp_ops = {
|
||||
clnttcp_call,
|
||||
clnttcp_abort,
|
||||
clnttcp_geterr,
|
||||
clnttcp_freeres,
|
||||
clnttcp_destroy,
|
||||
clnttcp_control
|
||||
};
|
||||
|
||||
struct ct_data {
|
||||
int ct_sock;
|
||||
bool_t ct_closeit;
|
||||
struct timeval ct_wait;
|
||||
bool_t ct_waitset; /* wait set by clnt_control? */
|
||||
struct sockaddr_in ct_addr;
|
||||
struct rpc_err ct_error;
|
||||
char ct_mcall[MCALL_MSG_SIZE]; /* marshalled callmsg */
|
||||
u_int ct_mpos; /* pos after marshal */
|
||||
XDR ct_xdrs;
|
||||
};
|
||||
|
||||
/*
|
||||
* Create a client handle for a tcp/ip connection.
|
||||
* If *sockp<0, *sockp is set to a newly created TCP socket and it is
|
||||
* connected to raddr. If *sockp non-negative then
|
||||
* raddr is ignored. The rpc/tcp package does buffering
|
||||
* similar to stdio, so the client must pick send and receive buffer sizes,];
|
||||
* 0 => use the default.
|
||||
* If raddr->sin_port is 0, then a binder on the remote machine is
|
||||
* consulted for the right port number.
|
||||
* NB: *sockp is copied into a private area.
|
||||
* NB: It is the clients responsibility to close *sockp.
|
||||
* NB: The rpch->cl_auth is set null authentication. Caller may wish to set this
|
||||
* something more useful.
|
||||
*/
|
||||
CLIENT *
|
||||
clnttcp_create(raddr, prog, vers, sockp, sendsz, recvsz)
|
||||
struct sockaddr_in *raddr;
|
||||
u_long prog;
|
||||
u_long vers;
|
||||
register int *sockp;
|
||||
u_int sendsz;
|
||||
u_int recvsz;
|
||||
{
|
||||
CLIENT *h;
|
||||
register struct ct_data *ct;
|
||||
struct timeval now;
|
||||
struct rpc_msg call_msg;
|
||||
|
||||
h = (CLIENT *)mem_alloc(sizeof(*h));
|
||||
if (h == NULL) {
|
||||
(void)fprintf(stderr, "clnttcp_create: out of memory\n");
|
||||
rpc_createerr.cf_stat = RPC_SYSTEMERROR;
|
||||
rpc_createerr.cf_error.re_errno = errno;
|
||||
goto fooy;
|
||||
}
|
||||
ct = (struct ct_data *)mem_alloc(sizeof(*ct));
|
||||
if (ct == NULL) {
|
||||
(void)fprintf(stderr, "clnttcp_create: out of memory\n");
|
||||
rpc_createerr.cf_stat = RPC_SYSTEMERROR;
|
||||
rpc_createerr.cf_error.re_errno = errno;
|
||||
goto fooy;
|
||||
}
|
||||
|
||||
/*
|
||||
* If no port number given ask the pmap for one
|
||||
*/
|
||||
if (raddr->sin_port == 0) {
|
||||
u_short port;
|
||||
if ((port = pmap_getport(raddr, prog, vers, IPPROTO_TCP)) == 0) {
|
||||
mem_free((caddr_t)ct, sizeof(struct ct_data));
|
||||
mem_free((caddr_t)h, sizeof(CLIENT));
|
||||
return ((CLIENT *)NULL);
|
||||
}
|
||||
raddr->sin_port = htons(port);
|
||||
}
|
||||
|
||||
/*
|
||||
* If no socket given, open one
|
||||
*/
|
||||
if (*sockp < 0) {
|
||||
*sockp = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
|
||||
(void)bindresvport(*sockp, (struct sockaddr_in *)0);
|
||||
if ((*sockp < 0)
|
||||
|| (connect(*sockp, (struct sockaddr *)raddr,
|
||||
sizeof(*raddr)) < 0)) {
|
||||
rpc_createerr.cf_stat = RPC_SYSTEMERROR;
|
||||
rpc_createerr.cf_error.re_errno = errno;
|
||||
(void)close(*sockp);
|
||||
goto fooy;
|
||||
}
|
||||
ct->ct_closeit = TRUE;
|
||||
} else {
|
||||
ct->ct_closeit = FALSE;
|
||||
}
|
||||
|
||||
/*
|
||||
* Set up private data struct
|
||||
*/
|
||||
ct->ct_sock = *sockp;
|
||||
ct->ct_wait.tv_usec = 0;
|
||||
ct->ct_waitset = FALSE;
|
||||
ct->ct_addr = *raddr;
|
||||
|
||||
/*
|
||||
* Initialize call message
|
||||
*/
|
||||
(void)gettimeofday(&now, (struct timezone *)0);
|
||||
call_msg.rm_xid = getpid() ^ now.tv_sec ^ now.tv_usec;
|
||||
call_msg.rm_direction = CALL;
|
||||
call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
|
||||
call_msg.rm_call.cb_prog = prog;
|
||||
call_msg.rm_call.cb_vers = vers;
|
||||
|
||||
/*
|
||||
* pre-serialize the staic part of the call msg and stash it away
|
||||
*/
|
||||
xdrmem_create(&(ct->ct_xdrs), ct->ct_mcall, MCALL_MSG_SIZE,
|
||||
XDR_ENCODE);
|
||||
if (! xdr_callhdr(&(ct->ct_xdrs), &call_msg)) {
|
||||
if (ct->ct_closeit) {
|
||||
(void)close(*sockp);
|
||||
}
|
||||
goto fooy;
|
||||
}
|
||||
ct->ct_mpos = XDR_GETPOS(&(ct->ct_xdrs));
|
||||
XDR_DESTROY(&(ct->ct_xdrs));
|
||||
|
||||
/*
|
||||
* Create a client handle which uses xdrrec for serialization
|
||||
* and authnone for authentication.
|
||||
*/
|
||||
xdrrec_create(&(ct->ct_xdrs), sendsz, recvsz,
|
||||
(caddr_t)ct, readtcp, writetcp);
|
||||
h->cl_ops = &tcp_ops;
|
||||
h->cl_private = (caddr_t) ct;
|
||||
h->cl_auth = authnone_create();
|
||||
return (h);
|
||||
|
||||
fooy:
|
||||
/*
|
||||
* Something goofed, free stuff and barf
|
||||
*/
|
||||
mem_free((caddr_t)ct, sizeof(struct ct_data));
|
||||
mem_free((caddr_t)h, sizeof(CLIENT));
|
||||
return ((CLIENT *)NULL);
|
||||
}
|
||||
|
||||
static enum clnt_stat
|
||||
clnttcp_call(h, proc, xdr_args, args_ptr, xdr_results, results_ptr, timeout)
|
||||
register CLIENT *h;
|
||||
u_long proc;
|
||||
xdrproc_t xdr_args;
|
||||
caddr_t args_ptr;
|
||||
xdrproc_t xdr_results;
|
||||
caddr_t results_ptr;
|
||||
struct timeval timeout;
|
||||
{
|
||||
register struct ct_data *ct = (struct ct_data *) h->cl_private;
|
||||
register XDR *xdrs = &(ct->ct_xdrs);
|
||||
struct rpc_msg reply_msg;
|
||||
u_long x_id;
|
||||
u_long *msg_x_id = (u_long *)(ct->ct_mcall); /* yuk */
|
||||
register bool_t shipnow;
|
||||
int refreshes = 2;
|
||||
|
||||
if (!ct->ct_waitset) {
|
||||
ct->ct_wait = timeout;
|
||||
}
|
||||
|
||||
shipnow =
|
||||
(xdr_results == (xdrproc_t)0 && timeout.tv_sec == 0
|
||||
&& timeout.tv_usec == 0) ? FALSE : TRUE;
|
||||
|
||||
call_again:
|
||||
xdrs->x_op = XDR_ENCODE;
|
||||
ct->ct_error.re_status = RPC_SUCCESS;
|
||||
x_id = ntohl(--(*msg_x_id));
|
||||
if ((! XDR_PUTBYTES(xdrs, ct->ct_mcall, ct->ct_mpos)) ||
|
||||
(! XDR_PUTLONG(xdrs, (long *)&proc)) ||
|
||||
(! AUTH_MARSHALL(h->cl_auth, xdrs)) ||
|
||||
(! (*xdr_args)(xdrs, args_ptr))) {
|
||||
if (ct->ct_error.re_status == RPC_SUCCESS)
|
||||
ct->ct_error.re_status = RPC_CANTENCODEARGS;
|
||||
(void)xdrrec_endofrecord(xdrs, TRUE);
|
||||
return (ct->ct_error.re_status);
|
||||
}
|
||||
if (! xdrrec_endofrecord(xdrs, shipnow))
|
||||
return (ct->ct_error.re_status = RPC_CANTSEND);
|
||||
if (! shipnow)
|
||||
return (RPC_SUCCESS);
|
||||
/*
|
||||
* Hack to provide rpc-based message passing
|
||||
*/
|
||||
if (timeout.tv_sec == 0 && timeout.tv_usec == 0) {
|
||||
return(ct->ct_error.re_status = RPC_TIMEDOUT);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Keep receiving until we get a valid transaction id
|
||||
*/
|
||||
xdrs->x_op = XDR_DECODE;
|
||||
while (TRUE) {
|
||||
reply_msg.acpted_rply.ar_verf = _null_auth;
|
||||
reply_msg.acpted_rply.ar_results.where = NULL;
|
||||
reply_msg.acpted_rply.ar_results.proc = xdr_void;
|
||||
if (! xdrrec_skiprecord(xdrs))
|
||||
return (ct->ct_error.re_status);
|
||||
/* now decode and validate the response header */
|
||||
if (! xdr_replymsg(xdrs, &reply_msg)) {
|
||||
if (ct->ct_error.re_status == RPC_SUCCESS)
|
||||
continue;
|
||||
return (ct->ct_error.re_status);
|
||||
}
|
||||
if (reply_msg.rm_xid == x_id)
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* process header
|
||||
*/
|
||||
_seterr_reply(&reply_msg, &(ct->ct_error));
|
||||
if (ct->ct_error.re_status == RPC_SUCCESS) {
|
||||
if (! AUTH_VALIDATE(h->cl_auth, &reply_msg.acpted_rply.ar_verf)) {
|
||||
ct->ct_error.re_status = RPC_AUTHERROR;
|
||||
ct->ct_error.re_why = AUTH_INVALIDRESP;
|
||||
} else if (! (*xdr_results)(xdrs, results_ptr)) {
|
||||
if (ct->ct_error.re_status == RPC_SUCCESS)
|
||||
ct->ct_error.re_status = RPC_CANTDECODERES;
|
||||
}
|
||||
/* free verifier ... */
|
||||
if (reply_msg.acpted_rply.ar_verf.oa_base != NULL) {
|
||||
xdrs->x_op = XDR_FREE;
|
||||
(void)xdr_opaque_auth(xdrs, &(reply_msg.acpted_rply.ar_verf));
|
||||
}
|
||||
} /* end successful completion */
|
||||
else {
|
||||
/* maybe our credentials need to be refreshed ... */
|
||||
if (refreshes-- && AUTH_REFRESH(h->cl_auth))
|
||||
goto call_again;
|
||||
} /* end of unsuccessful completion */
|
||||
return (ct->ct_error.re_status);
|
||||
}
|
||||
|
||||
static void
|
||||
clnttcp_geterr(h, errp)
|
||||
CLIENT *h;
|
||||
struct rpc_err *errp;
|
||||
{
|
||||
register struct ct_data *ct =
|
||||
(struct ct_data *) h->cl_private;
|
||||
|
||||
*errp = ct->ct_error;
|
||||
}
|
||||
|
||||
static bool_t
|
||||
clnttcp_freeres(cl, xdr_res, res_ptr)
|
||||
CLIENT *cl;
|
||||
xdrproc_t xdr_res;
|
||||
caddr_t res_ptr;
|
||||
{
|
||||
register struct ct_data *ct = (struct ct_data *)cl->cl_private;
|
||||
register XDR *xdrs = &(ct->ct_xdrs);
|
||||
|
||||
xdrs->x_op = XDR_FREE;
|
||||
return ((*xdr_res)(xdrs, res_ptr));
|
||||
}
|
||||
|
||||
static void
|
||||
clnttcp_abort()
|
||||
{
|
||||
}
|
||||
|
||||
static bool_t
|
||||
clnttcp_control(cl, request, info)
|
||||
CLIENT *cl;
|
||||
int request;
|
||||
char *info;
|
||||
{
|
||||
register struct ct_data *ct = (struct ct_data *)cl->cl_private;
|
||||
|
||||
switch (request) {
|
||||
case CLSET_TIMEOUT:
|
||||
ct->ct_wait = *(struct timeval *)info;
|
||||
ct->ct_waitset = TRUE;
|
||||
break;
|
||||
case CLGET_TIMEOUT:
|
||||
*(struct timeval *)info = ct->ct_wait;
|
||||
break;
|
||||
case CLGET_SERVER_ADDR:
|
||||
*(struct sockaddr_in *)info = ct->ct_addr;
|
||||
break;
|
||||
default:
|
||||
return (FALSE);
|
||||
}
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
clnttcp_destroy(h)
|
||||
CLIENT *h;
|
||||
{
|
||||
register struct ct_data *ct =
|
||||
(struct ct_data *) h->cl_private;
|
||||
|
||||
if (ct->ct_closeit) {
|
||||
(void)close(ct->ct_sock);
|
||||
}
|
||||
XDR_DESTROY(&(ct->ct_xdrs));
|
||||
mem_free((caddr_t)ct, sizeof(struct ct_data));
|
||||
mem_free((caddr_t)h, sizeof(CLIENT));
|
||||
}
|
||||
|
||||
/*
|
||||
* Interface between xdr serializer and tcp connection.
|
||||
* Behaves like the system calls, read & write, but keeps some error state
|
||||
* around for the rpc level.
|
||||
*/
|
||||
static int
|
||||
readtcp(ct, buf, len)
|
||||
register struct ct_data *ct;
|
||||
caddr_t buf;
|
||||
register int len;
|
||||
{
|
||||
#ifdef FD_SETSIZE
|
||||
fd_set mask;
|
||||
fd_set readfds;
|
||||
|
||||
if (len == 0)
|
||||
return (0);
|
||||
FD_ZERO(&mask);
|
||||
FD_SET(ct->ct_sock, &mask);
|
||||
#else
|
||||
register int mask = 1 << (ct->ct_sock);
|
||||
int readfds;
|
||||
|
||||
if (len == 0)
|
||||
return (0);
|
||||
|
||||
#endif /* def FD_SETSIZE */
|
||||
while (TRUE) {
|
||||
readfds = mask;
|
||||
switch (select(_rpc_dtablesize(), &readfds, (int*)NULL, (int*)NULL,
|
||||
&(ct->ct_wait))) {
|
||||
case 0:
|
||||
ct->ct_error.re_status = RPC_TIMEDOUT;
|
||||
return (-1);
|
||||
|
||||
case -1:
|
||||
if (errno == EINTR)
|
||||
continue;
|
||||
ct->ct_error.re_status = RPC_CANTRECV;
|
||||
ct->ct_error.re_errno = errno;
|
||||
return (-1);
|
||||
}
|
||||
break;
|
||||
}
|
||||
switch (len = read(ct->ct_sock, buf, len)) {
|
||||
|
||||
case 0:
|
||||
/* premature eof */
|
||||
ct->ct_error.re_errno = ECONNRESET;
|
||||
ct->ct_error.re_status = RPC_CANTRECV;
|
||||
len = -1; /* it's really an error */
|
||||
break;
|
||||
|
||||
case -1:
|
||||
ct->ct_error.re_errno = errno;
|
||||
ct->ct_error.re_status = RPC_CANTRECV;
|
||||
break;
|
||||
}
|
||||
return (len);
|
||||
}
|
||||
|
||||
static int
|
||||
writetcp(ct, buf, len)
|
||||
struct ct_data *ct;
|
||||
caddr_t buf;
|
||||
int len;
|
||||
{
|
||||
register int i, cnt;
|
||||
|
||||
for (cnt = len; cnt > 0; cnt -= i, buf += i) {
|
||||
if ((i = write(ct->ct_sock, buf, cnt)) == -1) {
|
||||
ct->ct_error.re_errno = errno;
|
||||
ct->ct_error.re_status = RPC_CANTSEND;
|
||||
return (-1);
|
||||
}
|
||||
}
|
||||
return (len);
|
||||
}
|
||||
Reference in New Issue
Block a user