From c1fe19d4c1db610692365472a90f4661e48449c1 Mon Sep 17 00:00:00 2001 From: Eric Andersen Date: Mon, 9 Oct 2000 20:06:30 +0000 Subject: Bug ugly formatting update --- libc/inet/rpc/auth_none.c | 57 ++++---- libc/inet/rpc/auth_unix.c | 126 ++++++++--------- libc/inet/rpc/authunix_prot.c | 22 +-- libc/inet/rpc/bindresvport.c | 12 +- libc/inet/rpc/clnt_generic.c | 19 ++- libc/inet/rpc/clnt_perror.c | 218 ++++++++++++++-------------- libc/inet/rpc/clnt_raw.c | 106 +++++++------- libc/inet/rpc/clnt_simple.c | 39 +++--- libc/inet/rpc/clnt_tcp.c | 234 +++++++++++++++---------------- libc/inet/rpc/clnt_udp.c | 261 +++++++++++++++++----------------- libc/inet/rpc/get_myaddress.c | 22 +-- libc/inet/rpc/getrpcent.c | 74 +++++----- libc/inet/rpc/getrpcport.c | 6 +- libc/inet/rpc/pmap_clnt.c | 40 +++--- libc/inet/rpc/pmap_getmaps.c | 20 +-- libc/inet/rpc/pmap_getport.c | 26 ++-- libc/inet/rpc/pmap_prot.c | 17 +-- libc/inet/rpc/pmap_prot2.c | 26 ++-- libc/inet/rpc/pmap_rmt.c | 212 ++++++++++++++-------------- libc/inet/rpc/rpc_callmsg.c | 74 +++++----- libc/inet/rpc/rpc_commondata.c | 3 +- libc/inet/rpc/rpc_dtablesize.c | 6 +- libc/inet/rpc/rpc_prot.c | 124 ++++++++-------- libc/inet/rpc/svc.c | 301 +++++++++++++++++++-------------------- libc/inet/rpc/svc_auth.c | 33 ++--- libc/inet/rpc/svc_auth_unix.c | 39 +++--- libc/inet/rpc/svc_raw.c | 81 +++++------ libc/inet/rpc/svc_run.c | 13 +- libc/inet/rpc/svc_simple.c | 51 +++---- libc/inet/rpc/svc_tcp.c | 219 ++++++++++++++--------------- libc/inet/rpc/svc_udp.c | 229 +++++++++++++++--------------- libc/inet/rpc/xdr.c | 198 ++++++++++++-------------- libc/inet/rpc/xdr_array.c | 52 ++++--- libc/inet/rpc/xdr_float.c | 154 ++++++++++---------- libc/inet/rpc/xdr_mem.c | 101 +++++++------ libc/inet/rpc/xdr_rec.c | 312 ++++++++++++++++++++--------------------- libc/inet/rpc/xdr_reference.c | 37 +++-- libc/inet/rpc/xdr_stdio.c | 132 +++++++++-------- 38 files changed, 1800 insertions(+), 1896 deletions(-) (limited to 'libc/inet/rpc') diff --git a/libc/inet/rpc/auth_none.c b/libc/inet/rpc/auth_none.c index 630037fb4..7a4dffe87 100644 --- a/libc/inet/rpc/auth_none.c +++ b/libc/inet/rpc/auth_none.c @@ -28,7 +28,9 @@ * Mountain View, California 94043 */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)auth_none.c 1.19 87/08/11 Copyr 1984 Sun Micro"; +static char sccsid[] = + + "@(#)auth_none.c 1.19 87/08/11 Copyr 1984 Sun Micro"; #endif /* @@ -47,11 +49,11 @@ static char sccsid[] = "@(#)auth_none.c 1.19 87/08/11 Copyr 1984 Sun Micro"; /* * Authenticator operations routines */ -static void authnone_verf(); -static void authnone_destroy(); -static bool_t authnone_marshal(); -static bool_t authnone_validate(); -static bool_t authnone_refresh(); +static void authnone_verf(); +static void authnone_destroy(); +static bool_t authnone_marshal(); +static bool_t authnone_validate(); +static bool_t authnone_refresh(); static struct auth_ops ops = { authnone_verf, @@ -62,20 +64,19 @@ static struct auth_ops ops = { }; static struct authnone_private { - AUTH no_client; - char marshalled_client[MAX_MARSHEL_SIZE]; - u_int mcnt; + AUTH no_client; + char marshalled_client[MAX_MARSHEL_SIZE]; + u_int mcnt; } *authnone_private; -AUTH * -authnone_create() +AUTH *authnone_create() { register struct authnone_private *ap = authnone_private; XDR xdr_stream; register XDR *xdrs; if (ap == 0) { - ap = (struct authnone_private *)calloc(1, sizeof (*ap)); + ap = (struct authnone_private *) calloc(1, sizeof(*ap)); if (ap == 0) return (0); authnone_private = ap; @@ -84,50 +85,44 @@ authnone_create() ap->no_client.ah_cred = ap->no_client.ah_verf = _null_auth; ap->no_client.ah_ops = &ops; xdrs = &xdr_stream; - xdrmem_create(xdrs, ap->marshalled_client, (u_int)MAX_MARSHEL_SIZE, - XDR_ENCODE); - (void)xdr_opaque_auth(xdrs, &ap->no_client.ah_cred); - (void)xdr_opaque_auth(xdrs, &ap->no_client.ah_verf); + xdrmem_create(xdrs, ap->marshalled_client, + (u_int) MAX_MARSHEL_SIZE, XDR_ENCODE); + (void) xdr_opaque_auth(xdrs, &ap->no_client.ah_cred); + (void) xdr_opaque_auth(xdrs, &ap->no_client.ah_verf); ap->mcnt = XDR_GETPOS(xdrs); XDR_DESTROY(xdrs); } return (&ap->no_client); } -/*ARGSUSED*/ -static bool_t -authnone_marshal(client, xdrs) - AUTH *client; - XDR *xdrs; + /*ARGSUSED*/ static bool_t authnone_marshal(client, xdrs) +AUTH *client; +XDR *xdrs; { register struct authnone_private *ap = authnone_private; if (ap == 0) return (0); - return ((*xdrs->x_ops->x_putbytes)(xdrs, - ap->marshalled_client, ap->mcnt)); + return ((*xdrs->x_ops->x_putbytes) (xdrs, + ap->marshalled_client, ap->mcnt)); } -static void -authnone_verf() +static void authnone_verf() { } -static bool_t -authnone_validate() +static bool_t authnone_validate() { return (TRUE); } -static bool_t -authnone_refresh() +static bool_t authnone_refresh() { return (FALSE); } -static void -authnone_destroy() +static void authnone_destroy() { } diff --git a/libc/inet/rpc/auth_unix.c b/libc/inet/rpc/auth_unix.c index ffdfa11a0..dcd7df98f 100644 --- a/libc/inet/rpc/auth_unix.c +++ b/libc/inet/rpc/auth_unix.c @@ -28,7 +28,9 @@ * Mountain View, California 94043 */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)auth_unix.c 1.19 87/08/11 Copyr 1984 Sun Micro"; +static char sccsid[] = + + "@(#)auth_unix.c 1.19 87/08/11 Copyr 1984 Sun Micro"; #endif /* @@ -56,11 +58,11 @@ static char sccsid[] = "@(#)auth_unix.c 1.19 87/08/11 Copyr 1984 Sun Micro"; /* * Unix authenticator operations vector */ -static void authunix_nextverf(); -static bool_t authunix_marshal(); -static bool_t authunix_validate(); -static bool_t authunix_refresh(); -static void authunix_destroy(); +static void authunix_nextverf(); +static bool_t authunix_marshal(); +static bool_t authunix_validate(); +static bool_t authunix_refresh(); +static void authunix_destroy(); static struct auth_ops auth_unix_ops = { authunix_nextverf, @@ -74,12 +76,13 @@ static struct auth_ops auth_unix_ops = { * This struct is pointed to by the ah_private field of an auth_handle. */ struct audata { - struct opaque_auth au_origcred; /* original credentials */ - struct opaque_auth au_shcred; /* short hand cred */ - u_long au_shfaults; /* short hand cache faults */ - char au_marshed[MAX_AUTH_BYTES]; - u_int au_mpos; /* xdr pos at end of marshed */ + struct opaque_auth au_origcred; /* original credentials */ + struct opaque_auth au_shcred; /* short hand cred */ + u_long au_shfaults; /* short hand cache faults */ + char au_marshed[MAX_AUTH_BYTES]; + u_int au_mpos; /* xdr pos at end of marshed */ }; + #define AUTH_PRIVATE(auth) ((struct audata *)auth->ah_private) static bool_t marshal_new_auth(); @@ -89,13 +92,12 @@ static bool_t marshal_new_auth(); * Create a unix style authenticator. * Returns an auth handle with the given stuff in it. */ -AUTH * -authunix_create(machname, uid, gid, len, aup_gids) - char *machname; - int uid; - int gid; - register int len; - int *aup_gids; +AUTH *authunix_create(machname, uid, gid, len, aup_gids) +char *machname; +int uid; +int gid; +register int len; +int *aup_gids; { struct authunix_parms aup; char mymem[MAX_AUTH_BYTES]; @@ -107,41 +109,41 @@ authunix_create(machname, uid, gid, len, aup_gids) /* * Allocate and set up auth handle */ - auth = (AUTH *)mem_alloc(sizeof(*auth)); + auth = (AUTH *) mem_alloc(sizeof(*auth)); #ifndef KERNEL if (auth == NULL) { - (void)fprintf(stderr, "authunix_create: out of memory\n"); + (void) fprintf(stderr, "authunix_create: out of memory\n"); return (NULL); } #endif - au = (struct audata *)mem_alloc(sizeof(*au)); + au = (struct audata *) mem_alloc(sizeof(*au)); #ifndef KERNEL if (au == NULL) { - (void)fprintf(stderr, "authunix_create: out of memory\n"); + (void) fprintf(stderr, "authunix_create: out of memory\n"); return (NULL); } #endif auth->ah_ops = &auth_unix_ops; - auth->ah_private = (caddr_t)au; + auth->ah_private = (caddr_t) au; auth->ah_verf = au->au_shcred = _null_auth; au->au_shfaults = 0; /* * fill in param struct from the given params */ - (void)gettimeofday(&now, (struct timezone *)0); + (void) gettimeofday(&now, (struct timezone *) 0); aup.aup_time = now.tv_sec; aup.aup_machname = machname; aup.aup_uid = uid; aup.aup_gid = gid; - aup.aup_len = (u_int)len; + aup.aup_len = (u_int) len; aup.aup_gids = aup_gids; /* * Serialize the parameters into origcred */ xdrmem_create(&xdrs, mymem, MAX_AUTH_BYTES, XDR_ENCODE); - if (! xdr_authunix_parms(&xdrs, &aup)) + if (!xdr_authunix_parms(&xdrs, &aup)) abort(); au->au_origcred.oa_length = len = XDR_GETPOS(&xdrs); au->au_origcred.oa_flavor = AUTH_UNIX; @@ -149,11 +151,11 @@ authunix_create(machname, uid, gid, len, aup_gids) au->au_origcred.oa_base = mem_alloc((u_int) len); #else if ((au->au_origcred.oa_base = mem_alloc((u_int) len)) == NULL) { - (void)fprintf(stderr, "authunix_create: out of memory\n"); + (void) fprintf(stderr, "authunix_create: out of memory\n"); return (NULL); } #endif - bcopy(mymem, au->au_origcred.oa_base, (u_int)len); + bcopy(mymem, au->au_origcred.oa_base, (u_int) len); /* * set auth handle to reflect new cred. @@ -167,8 +169,7 @@ authunix_create(machname, uid, gid, len, aup_gids) * Returns an auth handle with parameters determined by doing lots of * syscalls. */ -AUTH * -authunix_create_default() +AUTH *authunix_create_default() { register int len; char machname[MAX_MACHINE_NAME + 1]; @@ -190,27 +191,24 @@ authunix_create_default() * authunix operations */ -static void -authunix_nextverf(auth) - AUTH *auth; +static void authunix_nextverf(auth) +AUTH *auth; { /* no action necessary */ } -static bool_t -authunix_marshal(auth, xdrs) - AUTH *auth; - XDR *xdrs; +static bool_t authunix_marshal(auth, xdrs) +AUTH *auth; +XDR *xdrs; { register struct audata *au = AUTH_PRIVATE(auth); return (XDR_PUTBYTES(xdrs, au->au_marshed, au->au_mpos)); } -static bool_t -authunix_validate(auth, verf) - register AUTH *auth; - struct opaque_auth verf; +static bool_t authunix_validate(auth, verf) +register AUTH *auth; +struct opaque_auth verf; { register struct audata *au; XDR xdrs; @@ -220,15 +218,14 @@ authunix_validate(auth, verf) xdrmem_create(&xdrs, verf.oa_base, verf.oa_length, XDR_DECODE); if (au->au_shcred.oa_base != NULL) { - mem_free(au->au_shcred.oa_base, - au->au_shcred.oa_length); + mem_free(au->au_shcred.oa_base, au->au_shcred.oa_length); au->au_shcred.oa_base = NULL; } if (xdr_opaque_auth(&xdrs, &au->au_shcred)) { auth->ah_cred = au->au_shcred; } else { xdrs.x_op = XDR_FREE; - (void)xdr_opaque_auth(&xdrs, &au->au_shcred); + (void) xdr_opaque_auth(&xdrs, &au->au_shcred); au->au_shcred.oa_base = NULL; auth->ah_cred = au->au_origcred; } @@ -237,9 +234,8 @@ authunix_validate(auth, verf) return (TRUE); } -static bool_t -authunix_refresh(auth) - register AUTH *auth; +static bool_t authunix_refresh(auth) +register AUTH *auth; { register struct audata *au = AUTH_PRIVATE(auth); struct authunix_parms aup; @@ -251,38 +247,37 @@ authunix_refresh(auth) /* there is no hope. Punt */ return (FALSE); } - au->au_shfaults ++; + au->au_shfaults++; /* first deserialize the creds back into a struct authunix_parms */ aup.aup_machname = NULL; - aup.aup_gids = (int *)NULL; + aup.aup_gids = (int *) NULL; xdrmem_create(&xdrs, au->au_origcred.oa_base, - au->au_origcred.oa_length, XDR_DECODE); + au->au_origcred.oa_length, XDR_DECODE); stat = xdr_authunix_parms(&xdrs, &aup); - if (! stat) + if (!stat) goto done; /* update the time and serialize in place */ - (void)gettimeofday(&now, (struct timezone *)0); + (void) gettimeofday(&now, (struct timezone *) 0); aup.aup_time = now.tv_sec; xdrs.x_op = XDR_ENCODE; XDR_SETPOS(&xdrs, 0); stat = xdr_authunix_parms(&xdrs, &aup); - if (! stat) + if (!stat) goto done; auth->ah_cred = au->au_origcred; marshal_new_auth(auth); -done: + done: /* free the struct authunix_parms created by deserializing */ xdrs.x_op = XDR_FREE; - (void)xdr_authunix_parms(&xdrs, &aup); + (void) xdr_authunix_parms(&xdrs, &aup); XDR_DESTROY(&xdrs); return (stat); } -static void -authunix_destroy(auth) - register AUTH *auth; +static void authunix_destroy(auth) +register AUTH *auth; { register struct audata *au = AUTH_PRIVATE(auth); @@ -296,24 +291,23 @@ authunix_destroy(auth) if (auth->ah_verf.oa_base != NULL) mem_free(auth->ah_verf.oa_base, auth->ah_verf.oa_length); - mem_free((caddr_t)auth, sizeof(*auth)); + mem_free((caddr_t) auth, sizeof(*auth)); } /* * Marshals (pre-serializes) an auth struct. * sets private data, au_marshed and au_mpos */ -static bool_t -marshal_new_auth(auth) - register AUTH *auth; +static bool_t marshal_new_auth(auth) +register AUTH *auth; { - XDR xdr_stream; - register XDR *xdrs = &xdr_stream; + XDR xdr_stream; + register XDR *xdrs = &xdr_stream; register struct audata *au = AUTH_PRIVATE(auth); xdrmem_create(xdrs, au->au_marshed, MAX_AUTH_BYTES, XDR_ENCODE); - if ((! xdr_opaque_auth(xdrs, &(auth->ah_cred))) || - (! xdr_opaque_auth(xdrs, &(auth->ah_verf)))) { + if ((!xdr_opaque_auth(xdrs, &(auth->ah_cred))) || + (!xdr_opaque_auth(xdrs, &(auth->ah_verf)))) { perror("auth_none.c - Fatal marshalling problem"); } else { au->au_mpos = XDR_GETPOS(xdrs); diff --git a/libc/inet/rpc/authunix_prot.c b/libc/inet/rpc/authunix_prot.c index a60d99a57..cae173571 100644 --- a/libc/inet/rpc/authunix_prot.c +++ b/libc/inet/rpc/authunix_prot.c @@ -28,7 +28,9 @@ * Mountain View, California 94043 */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)authunix_prot.c 1.15 87/08/11 Copyr 1984 Sun Micro"; +static char sccsid[] = + + "@(#)authunix_prot.c 1.15 87/08/11 Copyr 1984 Sun Micro"; #endif /* @@ -47,20 +49,18 @@ static char sccsid[] = "@(#)authunix_prot.c 1.15 87/08/11 Copyr 1984 Sun Micro"; /* * XDR for unix authentication parameters. */ -bool_t -xdr_authunix_parms(xdrs, p) - register XDR *xdrs; - register struct authunix_parms *p; +bool_t xdr_authunix_parms(xdrs, p) +register XDR *xdrs; +register struct authunix_parms *p; { if (xdr_u_long(xdrs, &(p->aup_time)) - && xdr_string(xdrs, &(p->aup_machname), MAX_MACHINE_NAME) - && xdr_int(xdrs, &(p->aup_uid)) - && xdr_int(xdrs, &(p->aup_gid)) - && xdr_array(xdrs, (caddr_t *)&(p->aup_gids), - &(p->aup_len), NGRPS, sizeof(int), xdr_int) ) { + && xdr_string(xdrs, &(p->aup_machname), MAX_MACHINE_NAME) + && xdr_int(xdrs, &(p->aup_uid)) + && xdr_int(xdrs, &(p->aup_gid)) + && xdr_array(xdrs, (caddr_t *) & (p->aup_gids), + &(p->aup_len), NGRPS, sizeof(int), xdr_int)) { return (TRUE); } return (FALSE); } - diff --git a/libc/inet/rpc/bindresvport.c b/libc/inet/rpc/bindresvport.c index 71803dd41..6a6f385cd 100644 --- a/libc/inet/rpc/bindresvport.c +++ b/libc/inet/rpc/bindresvport.c @@ -1,4 +1,6 @@ -static char sccsid[] = "@(#)bindresvport.c 2.2 88/07/29 4.0 RPCSRC 1.8 88/02/08 SMI"; +static char sccsid[] = + + "@(#)bindresvport.c 2.2 88/07/29 4.0 RPCSRC 1.8 88/02/08 SMI"; /* * Sun RPC is a product of Sun Microsystems, Inc. and is provided for * unrestricted use provided that this legend is included on all tape @@ -41,8 +43,8 @@ static char sccsid[] = "@(#)bindresvport.c 2.2 88/07/29 4.0 RPCSRC 1.8 88/02/08 * Bind a socket to a privileged IP port */ bindresvport(sd, sin) - int sd; - struct sockaddr_in *sin; +int sd; +struct sockaddr_in *sin; { int res; static short port; @@ -54,9 +56,9 @@ bindresvport(sd, sin) #define ENDPORT (IPPORT_RESERVED - 1) #define NPORTS (ENDPORT - STARTPORT + 1) - if (sin == (struct sockaddr_in *)0) { + if (sin == (struct sockaddr_in *) 0) { sin = &myaddr; - bzero(sin, sizeof (*sin)); + bzero(sin, sizeof(*sin)); sin->sin_family = AF_INET; } else if (sin->sin_family != AF_INET) { errno = EPFNOSUPPORT; diff --git a/libc/inet/rpc/clnt_generic.c b/libc/inet/rpc/clnt_generic.c index fabcc2b32..ba5309492 100644 --- a/libc/inet/rpc/clnt_generic.c +++ b/libc/inet/rpc/clnt_generic.c @@ -43,12 +43,11 @@ static char sccsid[] = "@(#)clnt_generic.c 1.4 87/08/11 (C) 1987 SMI"; * returns client handle. Default options are set, which the user can * change using the rpc equivalent of ioctl()'s. */ -CLIENT * -clnt_create(hostname, prog, vers, proto) - char *hostname; - unsigned prog; - unsigned vers; - char *proto; +CLIENT *clnt_create(hostname, prog, vers, proto) +char *hostname; +unsigned prog; +unsigned vers; +char *proto; { struct hostent *h; struct protoent *p; @@ -67,7 +66,7 @@ clnt_create(hostname, prog, vers, proto) * Only support INET for now */ rpc_createerr.cf_stat = RPC_SYSTEMERROR; - rpc_createerr.cf_error.re_errno = EAFNOSUPPORT; + rpc_createerr.cf_error.re_errno = EAFNOSUPPORT; return (NULL); } #ifdef __linux__ @@ -78,11 +77,11 @@ clnt_create(hostname, prog, vers, proto) #ifndef __linux__ bzero(sin.sin_zero, sizeof(sin.sin_zero)); #endif - bcopy(h->h_addr, (char*)&sin.sin_addr, h->h_length); + bcopy(h->h_addr, (char *) &sin.sin_addr, h->h_length); p = getprotobyname(proto); if (p == NULL) { rpc_createerr.cf_stat = RPC_UNKNOWNPROTO; - rpc_createerr.cf_error.re_errno = EPFNOSUPPORT; + rpc_createerr.cf_error.re_errno = EPFNOSUPPORT; return (NULL); } sock = RPC_ANYSOCK; @@ -108,7 +107,7 @@ clnt_create(hostname, prog, vers, proto) break; default: rpc_createerr.cf_stat = RPC_SYSTEMERROR; - rpc_createerr.cf_error.re_errno = EPFNOSUPPORT; + rpc_createerr.cf_error.re_errno = EPFNOSUPPORT; return (NULL); } return (client); diff --git a/libc/inet/rpc/clnt_perror.c b/libc/inet/rpc/clnt_perror.c index 80f51aa79..84d2658ee 100644 --- a/libc/inet/rpc/clnt_perror.c +++ b/libc/inet/rpc/clnt_perror.c @@ -28,7 +28,9 @@ * Mountain View, California 94043 */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)clnt_perror.c 1.15 87/10/07 Copyr 1984 Sun Micro"; +static char sccsid[] = + + "@(#)clnt_perror.c 1.15 87/10/07 Copyr 1984 Sun Micro"; #endif /* @@ -50,22 +52,20 @@ extern char *strcpy(); static char *buf; -static char * -_buf() +static char *_buf() { if (buf == 0) - buf = (char *)malloc(256); + buf = (char *) malloc(256); return (buf); } /* * Print reply error info */ -char * -clnt_sperror(rpch, s) - CLIENT *rpch; - char *s; +char *clnt_sperror(rpch, s) +CLIENT *rpch; +char *s; { #if 0 struct rpc_err e; @@ -78,17 +78,17 @@ clnt_sperror(rpch, s) return (0); CLNT_GETERR(rpch, &e); - (void) sprintf(str, "%s: ", s); + (void) sprintf(str, "%s: ", s); str += strlen(str); - (void) strcpy(str, clnt_sperrno(e.re_status)); + (void) strcpy(str, clnt_sperrno(e.re_status)); str += strlen(str); switch (e.re_status) { case RPC_SUCCESS: case RPC_CANTENCODEARGS: case RPC_CANTDECODERES: - case RPC_TIMEDOUT: + case RPC_TIMEDOUT: case RPC_PROGUNAVAIL: case RPC_PROCUNAVAIL: case RPC_CANTDECODEARGS: @@ -102,57 +102,54 @@ clnt_sperror(rpch, s) case RPC_CANTSEND: case RPC_CANTRECV: - (void) sprintf(str, "; errno = %s", - sys_errlist[e.re_errno]); + (void) sprintf(str, "; errno = %s", sys_errlist[e.re_errno]); str += strlen(str); break; case RPC_VERSMISMATCH: (void) sprintf(str, - "; low version = %lu, high version = %lu", - e.re_vers.low, e.re_vers.high); + "; low version = %lu, high version = %lu", + e.re_vers.low, e.re_vers.high); str += strlen(str); break; case RPC_AUTHERROR: err = auth_errmsg(e.re_why); - (void) sprintf(str,"; why = "); + (void) sprintf(str, "; why = "); str += strlen(str); if (err != NULL) { - (void) sprintf(str, "%s",err); + (void) sprintf(str, "%s", err); } else { (void) sprintf(str, - "(unknown authentication error - %d)", - (int) e.re_why); + "(unknown authentication error - %d)", + (int) e.re_why); } str += strlen(str); break; case RPC_PROGVERSMISMATCH: - (void) sprintf(str, - "; low version = %lu, high version = %lu", - e.re_vers.low, e.re_vers.high); + (void) sprintf(str, + "; low version = %lu, high version = %lu", + e.re_vers.low, e.re_vers.high); str += strlen(str); break; - default: /* unknown */ - (void) sprintf(str, - "; s1 = %lu, s2 = %lu", - e.re_lb.s1, e.re_lb.s2); + default: /* unknown */ + (void) sprintf(str, + "; s1 = %lu, s2 = %lu", e.re_lb.s1, e.re_lb.s2); str += strlen(str); break; } (void) sprintf(str, "\n"); - return(strstart) ; + return (strstart); #endif } -void -clnt_perror(rpch, s) - CLIENT *rpch; - char *s; +void clnt_perror(rpch, s) +CLIENT *rpch; +char *s; { - (void) fprintf(stderr,"%s",clnt_sperror(rpch,s)); + (void) fprintf(stderr, "%s", clnt_sperror(rpch, s)); } @@ -160,58 +157,58 @@ struct rpc_errtab { enum clnt_stat status; char *message; }; + #if 0 -static struct rpc_errtab rpc_errlist[] = { - { RPC_SUCCESS, - "RPC: Success" }, - { RPC_CANTENCODEARGS, - "RPC: Can't encode arguments" }, - { RPC_CANTDECODERES, - "RPC: Can't decode result" }, - { RPC_CANTSEND, - "RPC: Unable to send" }, - { RPC_CANTRECV, - "RPC: Unable to receive" }, - { RPC_TIMEDOUT, - "RPC: Timed out" }, - { RPC_VERSMISMATCH, - "RPC: Incompatible versions of RPC" }, - { RPC_AUTHERROR, - "RPC: Authentication error" }, - { RPC_PROGUNAVAIL, - "RPC: Program unavailable" }, - { RPC_PROGVERSMISMATCH, - "RPC: Program/version mismatch" }, - { RPC_PROCUNAVAIL, - "RPC: Procedure unavailable" }, - { RPC_CANTDECODEARGS, - "RPC: Server can't decode arguments" }, - { RPC_SYSTEMERROR, - "RPC: Remote system error" }, - { RPC_UNKNOWNHOST, - "RPC: Unknown host" }, - { RPC_UNKNOWNPROTO, - "RPC: Unknown protocol" }, - { RPC_PMAPFAILURE, - "RPC: Port mapper failure" }, - { RPC_PROGNOTREGISTERED, - "RPC: Program not registered"}, - { RPC_FAILED, - "RPC: Failed (unspecified error)"} +static struct rpc_errtab rpc_errlist[] = { + {RPC_SUCCESS, + "RPC: Success"}, + {RPC_CANTENCODEARGS, + "RPC: Can't encode arguments"}, + {RPC_CANTDECODERES, + "RPC: Can't decode result"}, + {RPC_CANTSEND, + "RPC: Unable to send"}, + {RPC_CANTRECV, + "RPC: Unable to receive"}, + {RPC_TIMEDOUT, + "RPC: Timed out"}, + {RPC_VERSMISMATCH, + "RPC: Incompatible versions of RPC"}, + {RPC_AUTHERROR, + "RPC: Authentication error"}, + {RPC_PROGUNAVAIL, + "RPC: Program unavailable"}, + {RPC_PROGVERSMISMATCH, + "RPC: Program/version mismatch"}, + {RPC_PROCUNAVAIL, + "RPC: Procedure unavailable"}, + {RPC_CANTDECODEARGS, + "RPC: Server can't decode arguments"}, + {RPC_SYSTEMERROR, + "RPC: Remote system error"}, + {RPC_UNKNOWNHOST, + "RPC: Unknown host"}, + {RPC_UNKNOWNPROTO, + "RPC: Unknown protocol"}, + {RPC_PMAPFAILURE, + "RPC: Port mapper failure"}, + {RPC_PROGNOTREGISTERED, + "RPC: Program not registered"}, + {RPC_FAILED, + "RPC: Failed (unspecified error)"} }; #endif /* * This interface for use by clntrpc */ -char * -clnt_sperrno(stat) - enum clnt_stat stat; +char *clnt_sperrno(stat) +enum clnt_stat stat; { #if 0 int i; - for (i = 0; i < sizeof(rpc_errlist)/sizeof(struct rpc_errtab); i++) { + for (i = 0; i < sizeof(rpc_errlist) / sizeof(struct rpc_errtab); i++) { if (rpc_errlist[i].status == stat) { return (rpc_errlist[i].message); } @@ -220,17 +217,15 @@ clnt_sperrno(stat) return ("RPC: (unknown error code)"); } -void -clnt_perrno(num) - enum clnt_stat num; +void clnt_perrno(num) +enum clnt_stat num; { - (void) fprintf(stderr,"%s",clnt_sperrno(num)); + (void) fprintf(stderr, "%s", clnt_sperrno(num)); } -char * -clnt_spcreateerror(s) - char *s; +char *clnt_spcreateerror(s) +char *s; { #if 0 extern int sys_nerr; @@ -238,25 +233,24 @@ clnt_spcreateerror(s) char *str = _buf(); if (str == 0) - return(0); + return (0); (void) sprintf(str, "%s: ", s); (void) strcat(str, clnt_sperrno(rpc_createerr.cf_stat)); switch (rpc_createerr.cf_stat) { case RPC_PMAPFAILURE: (void) strcat(str, " - "); - (void) strcat(str, - clnt_sperrno(rpc_createerr.cf_error.re_status)); + (void) strcat(str, clnt_sperrno(rpc_createerr.cf_error.re_status)); break; case RPC_SYSTEMERROR: (void) strcat(str, " - "); if (rpc_createerr.cf_error.re_errno > 0 - && rpc_createerr.cf_error.re_errno < sys_nerr) + && rpc_createerr.cf_error.re_errno < sys_nerr) (void) strcat(str, - sys_errlist[rpc_createerr.cf_error.re_errno]); + sys_errlist[rpc_createerr.cf_error.re_errno]); else (void) sprintf(&str[strlen(str)], "Error %d", - rpc_createerr.cf_error.re_errno); + rpc_createerr.cf_error.re_errno); break; } (void) strcat(str, "\n"); @@ -264,47 +258,45 @@ clnt_spcreateerror(s) #endif } -void -clnt_pcreateerror(s) - char *s; +void clnt_pcreateerror(s) +char *s; { - (void) fprintf(stderr,"%s",clnt_spcreateerror(s)); + (void) fprintf(stderr, "%s", clnt_spcreateerror(s)); } struct auth_errtab { - enum auth_stat status; + enum auth_stat status; char *message; }; static struct auth_errtab auth_errlist[] = { - { AUTH_OK, - "Authentication OK" }, - { AUTH_BADCRED, - "Invalid client credential" }, - { AUTH_REJECTEDCRED, - "Server rejected credential" }, - { AUTH_BADVERF, - "Invalid client verifier" }, - { AUTH_REJECTEDVERF, - "Server rejected verifier" }, - { AUTH_TOOWEAK, - "Client credential too weak" }, - { AUTH_INVALIDRESP, - "Invalid server verifier" }, - { AUTH_FAILED, - "Failed (unspecified error)" }, + {AUTH_OK, + "Authentication OK"}, + {AUTH_BADCRED, + "Invalid client credential"}, + {AUTH_REJECTEDCRED, + "Server rejected credential"}, + {AUTH_BADVERF, + "Invalid client verifier"}, + {AUTH_REJECTEDVERF, + "Server rejected verifier"}, + {AUTH_TOOWEAK, + "Client credential too weak"}, + {AUTH_INVALIDRESP, + "Invalid server verifier"}, + {AUTH_FAILED, + "Failed (unspecified error)"}, }; -static char * -auth_errmsg(stat) - enum auth_stat stat; +static char *auth_errmsg(stat) +enum auth_stat stat; { int i; - for (i = 0; i < sizeof(auth_errlist)/sizeof(struct auth_errtab); i++) { + for (i = 0; i < sizeof(auth_errlist) / sizeof(struct auth_errtab); i++) { if (auth_errlist[i].status == stat) { - return(auth_errlist[i].message); + return (auth_errlist[i].message); } } - return(NULL); + return (NULL); } diff --git a/libc/inet/rpc/clnt_raw.c b/libc/inet/rpc/clnt_raw.c index 89059ae2d..7479b55d6 100644 --- a/libc/inet/rpc/clnt_raw.c +++ b/libc/inet/rpc/clnt_raw.c @@ -50,19 +50,19 @@ static char sccsid[] = "@(#)clnt_raw.c 1.22 87/08/11 Copyr 1984 Sun Micro"; * This is the "network" we will be moving stuff over. */ static struct clntraw_private { - CLIENT client_object; - XDR xdr_stream; - char _raw_buf[UDPMSGSIZE]; - char mashl_callmsg[MCALL_MSG_SIZE]; - u_int mcnt; + CLIENT client_object; + XDR xdr_stream; + char _raw_buf[UDPMSGSIZE]; + char mashl_callmsg[MCALL_MSG_SIZE]; + u_int mcnt; } *clntraw_private; -static enum clnt_stat clntraw_call(); -static void clntraw_abort(); -static void clntraw_geterr(); -static bool_t clntraw_freeres(); -static bool_t clntraw_control(); -static void clntraw_destroy(); +static enum clnt_stat clntraw_call(); +static void clntraw_abort(); +static void clntraw_geterr(); +static bool_t clntraw_freeres(); +static bool_t clntraw_control(); +static void clntraw_destroy(); static struct clnt_ops client_ops = { clntraw_call, @@ -73,23 +73,22 @@ static struct clnt_ops client_ops = { clntraw_control }; -void svc_getreq(); +void svc_getreq(); /* * Create a client handle for memory based rpc. */ -CLIENT * -clntraw_create(prog, vers) - u_long prog; - u_long vers; +CLIENT *clntraw_create(prog, vers) +u_long prog; +u_long vers; { register struct clntraw_private *clp = clntraw_private; struct rpc_msg call_msg; XDR *xdrs = &clp->xdr_stream; - CLIENT *client = &clp->client_object; + CLIENT *client = &clp->client_object; if (clp == 0) { - clp = (struct clntraw_private *)calloc(1, sizeof (*clp)); + clp = (struct clntraw_private *) calloc(1, sizeof(*clp)); if (clp == 0) return (0); clntraw_private = clp; @@ -101,8 +100,8 @@ clntraw_create(prog, vers) call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION; call_msg.rm_call.cb_prog = prog; call_msg.rm_call.cb_vers = vers; - xdrmem_create(xdrs, clp->mashl_callmsg, MCALL_MSG_SIZE, XDR_ENCODE); - if (! xdr_callhdr(xdrs, &call_msg)) { + xdrmem_create(xdrs, clp->mashl_callmsg, MCALL_MSG_SIZE, XDR_ENCODE); + if (!xdr_callhdr(xdrs, &call_msg)) { perror("clnt_raw.c - Fatal header serialization error."); } clp->mcnt = XDR_GETPOS(xdrs); @@ -121,15 +120,15 @@ clntraw_create(prog, vers) return (client); } -static enum clnt_stat +static enum clnt_stat clntraw_call(h, proc, xargs, argsp, xresults, resultsp, timeout) - CLIENT *h; - u_long proc; - xdrproc_t xargs; - caddr_t argsp; - xdrproc_t xresults; - caddr_t resultsp; - struct timeval timeout; +CLIENT *h; +u_long proc; +xdrproc_t xargs; +caddr_t argsp; +xdrproc_t xresults; +caddr_t resultsp; +struct timeval timeout; { register struct clntraw_private *clp = clntraw_private; register XDR *xdrs = &clp->xdr_stream; @@ -139,20 +138,19 @@ clntraw_call(h, proc, xargs, argsp, xresults, resultsp, timeout) if (clp == 0) return (RPC_FAILED); -call_again: + call_again: /* * send request */ xdrs->x_op = XDR_ENCODE; XDR_SETPOS(xdrs, 0); - ((struct rpc_msg *)clp->mashl_callmsg)->rm_xid ++ ; - if ((! XDR_PUTBYTES(xdrs, clp->mashl_callmsg, clp->mcnt)) || - (! XDR_PUTLONG(xdrs, (long *)&proc)) || - (! AUTH_MARSHALL(h->cl_auth, xdrs)) || - (! (*xargs)(xdrs, argsp))) { + ((struct rpc_msg *) clp->mashl_callmsg)->rm_xid++; + if ((!XDR_PUTBYTES(xdrs, clp->mashl_callmsg, clp->mcnt)) || + (!XDR_PUTLONG(xdrs, (long *) &proc)) || + (!AUTH_MARSHALL(h->cl_auth, xdrs)) || (!(*xargs) (xdrs, argsp))) { return (RPC_CANTENCODEARGS); } - (void)XDR_GETPOS(xdrs); /* called just to cause overhead */ + (void) XDR_GETPOS(xdrs); /* called just to cause overhead */ /* * We have to call server input routine here because this is @@ -168,71 +166,65 @@ call_again: msg.acpted_rply.ar_verf = _null_auth; msg.acpted_rply.ar_results.where = resultsp; msg.acpted_rply.ar_results.proc = xresults; - if (! xdr_replymsg(xdrs, &msg)) + if (!xdr_replymsg(xdrs, &msg)) return (RPC_CANTDECODERES); _seterr_reply(&msg, &error); status = error.re_status; if (status == RPC_SUCCESS) { - if (! AUTH_VALIDATE(h->cl_auth, &msg.acpted_rply.ar_verf)) { + if (!AUTH_VALIDATE(h->cl_auth, &msg.acpted_rply.ar_verf)) { status = RPC_AUTHERROR; } - } /* end successful completion */ + } /* end successful completion */ else { if (AUTH_REFRESH(h->cl_auth)) goto call_again; - } /* end of unsuccessful completion */ + } /* end of unsuccessful completion */ if (status == RPC_SUCCESS) { - if (! AUTH_VALIDATE(h->cl_auth, &msg.acpted_rply.ar_verf)) { + if (!AUTH_VALIDATE(h->cl_auth, &msg.acpted_rply.ar_verf)) { status = RPC_AUTHERROR; } if (msg.acpted_rply.ar_verf.oa_base != NULL) { xdrs->x_op = XDR_FREE; - (void)xdr_opaque_auth(xdrs, &(msg.acpted_rply.ar_verf)); + (void) xdr_opaque_auth(xdrs, &(msg.acpted_rply.ar_verf)); } } return (status); } -static void -clntraw_geterr() +static void clntraw_geterr() { } -static bool_t -clntraw_freeres(cl, xdr_res, res_ptr) - CLIENT *cl; - xdrproc_t xdr_res; - caddr_t res_ptr; +static bool_t clntraw_freeres(cl, xdr_res, res_ptr) +CLIENT *cl; +xdrproc_t xdr_res; +caddr_t res_ptr; { register struct clntraw_private *clp = clntraw_private; register XDR *xdrs = &clp->xdr_stream; bool_t rval; - if (clp == 0) - { + if (clp == 0) { rval = (bool_t) RPC_FAILED; return (rval); } xdrs->x_op = XDR_FREE; - return ((*xdr_res)(xdrs, res_ptr)); + return ((*xdr_res) (xdrs, res_ptr)); } -static void -clntraw_abort() +static void clntraw_abort() { } -static bool_t -clntraw_control() +static bool_t clntraw_control() { return (FALSE); } -static void -clntraw_destroy() +static void clntraw_destroy() { } diff --git a/libc/inet/rpc/clnt_simple.c b/libc/inet/rpc/clnt_simple.c index 043ce0a3e..77657ecf3 100644 --- a/libc/inet/rpc/clnt_simple.c +++ b/libc/inet/rpc/clnt_simple.c @@ -28,7 +28,9 @@ * Mountain View, California 94043 */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)clnt_simple.c 1.35 87/08/11 Copyr 1984 Sun Micro"; +static char sccsid[] = + + "@(#)clnt_simple.c 1.35 87/08/11 Copyr 1984 Sun Micro"; #endif /* @@ -45,16 +47,16 @@ static char sccsid[] = "@(#)clnt_simple.c 1.35 87/08/11 Copyr 1984 Sun Micro"; #include static struct callrpc_private { - CLIENT *client; - int socket; - int oldprognum, oldversnum, valid; - char *oldhost; + CLIENT *client; + int socket; + int oldprognum, oldversnum, valid; + char *oldhost; } *callrpc_private; callrpc(host, prognum, versnum, procnum, inproc, in, outproc, out) - char *host; - xdrproc_t inproc, outproc; - char *in, *out; +char *host; +xdrproc_t inproc, outproc; +char *in, *out; { register struct callrpc_private *crp = callrpc_private; struct sockaddr_in server_addr; @@ -63,7 +65,7 @@ callrpc(host, prognum, versnum, procnum, inproc, in, outproc, out) struct timeval timeout, tottimeout; if (crp == 0) { - crp = (struct callrpc_private *)calloc(1, sizeof (*crp)); + crp = (struct callrpc_private *) calloc(1, sizeof(*crp)); if (crp == 0) return (0); callrpc_private = crp; @@ -73,12 +75,12 @@ callrpc(host, prognum, versnum, procnum, inproc, in, outproc, out) crp->oldhost[0] = 0; crp->socket = RPC_ANYSOCK; } - if (crp->valid && crp->oldprognum == prognum && crp->oldversnum == versnum - && strcmp(crp->oldhost, host) == 0) { - /* reuse old client */ + if (crp->valid && crp->oldprognum == prognum + && crp->oldversnum == versnum && strcmp(crp->oldhost, host) == 0) { + /* reuse old client */ } else { crp->valid = 0; - (void)close(crp->socket); + (void) close(crp->socket); crp->socket = RPC_ANYSOCK; if (crp->client) { clnt_destroy(crp->client); @@ -88,11 +90,12 @@ callrpc(host, prognum, versnum, procnum, inproc, in, outproc, out) return ((int) RPC_UNKNOWNHOST); timeout.tv_usec = 0; timeout.tv_sec = 5; - bcopy(hp->h_addr, (char *)&server_addr.sin_addr, hp->h_length); + bcopy(hp->h_addr, (char *) &server_addr.sin_addr, hp->h_length); server_addr.sin_family = AF_INET; - server_addr.sin_port = 0; - if ((crp->client = clntudp_create(&server_addr, (u_long)prognum, - (u_long)versnum, timeout, &crp->socket)) == NULL) + server_addr.sin_port = 0; + if ((crp->client = clntudp_create(&server_addr, (u_long) prognum, + (u_long) versnum, timeout, + &crp->socket)) == NULL) return ((int) rpc_createerr.cf_stat); crp->valid = 1; crp->oldprognum = prognum; @@ -102,7 +105,7 @@ callrpc(host, prognum, versnum, procnum, inproc, in, outproc, out) tottimeout.tv_sec = 25; tottimeout.tv_usec = 0; clnt_stat = clnt_call(crp->client, procnum, inproc, in, - outproc, out, tottimeout); + outproc, out, tottimeout); /* * if call failed, empty cache */ diff --git a/libc/inet/rpc/clnt_tcp.c b/libc/inet/rpc/clnt_tcp.c index 2222bc657..30422268a 100644 --- a/libc/inet/rpc/clnt_tcp.c +++ b/libc/inet/rpc/clnt_tcp.c @@ -30,7 +30,7 @@ #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. * @@ -61,15 +61,15 @@ static char sccsid[] = "@(#)clnt_tcp.c 1.37 87/10/05 Copyr 1984 Sun Micro"; extern int errno; -static int readtcp(); -static int writetcp(); +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 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, @@ -81,15 +81,15 @@ static struct clnt_ops tcp_ops = { }; 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; + 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; }; /* @@ -106,30 +106,29 @@ struct ct_data { * 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 *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)); + h = (CLIENT *) mem_alloc(sizeof(*h)); if (h == NULL) { - (void)fprintf(stderr, "clnttcp_create: out of memory\n"); + (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)); + ct = (struct ct_data *) mem_alloc(sizeof(*ct)); if (ct == NULL) { - (void)fprintf(stderr, "clnttcp_create: out of memory\n"); + (void) fprintf(stderr, "clnttcp_create: out of memory\n"); rpc_createerr.cf_stat = RPC_SYSTEMERROR; rpc_createerr.cf_error.re_errno = errno; goto fooy; @@ -140,10 +139,12 @@ clnttcp_create(raddr, prog, vers, sockp, sendsz, recvsz) */ 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); + mem_free((caddr_t) ct, sizeof(struct ct_data)); + + mem_free((caddr_t) h, sizeof(CLIENT)); + return ((CLIENT *) NULL); } raddr->sin_port = htons(port); } @@ -153,13 +154,13 @@ clnttcp_create(raddr, prog, vers, sockp, sendsz, recvsz) */ if (*sockp < 0) { *sockp = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); - (void)bindresvport(*sockp, (struct sockaddr_in *)0); + (void) bindresvport(*sockp, (struct sockaddr_in *) 0); if ((*sockp < 0) - || (connect(*sockp, (struct sockaddr *)raddr, - sizeof(*raddr)) < 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); + (void) close(*sockp); goto fooy; } ct->ct_closeit = TRUE; @@ -178,7 +179,7 @@ clnttcp_create(raddr, prog, vers, sockp, sendsz, recvsz) /* * Initialize call message */ - (void)gettimeofday(&now, (struct timezone *)0); + (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; @@ -189,10 +190,10 @@ clnttcp_create(raddr, prog, vers, sockp, sendsz, recvsz) * 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)) { + XDR_ENCODE); + if (!xdr_callhdr(&(ct->ct_xdrs), &call_msg)) { if (ct->ct_closeit) { - (void)close(*sockp); + (void) close(*sockp); } goto fooy; } @@ -204,36 +205,38 @@ clnttcp_create(raddr, prog, vers, sockp, sendsz, recvsz) * and authnone for authentication. */ xdrrec_create(&(ct->ct_xdrs), sendsz, recvsz, - (caddr_t)ct, readtcp, writetcp); + (caddr_t) ct, readtcp, writetcp); h->cl_ops = &tcp_ops; h->cl_private = (caddr_t) ct; h->cl_auth = authnone_create(); return (h); -fooy: + 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); + 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; +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 */ + u_long *msg_x_id = (u_long *) (ct->ct_mcall); /* yuk */ register bool_t shipnow; int refreshes = 2; @@ -242,31 +245,31 @@ clnttcp_call(h, proc, xdr_args, args_ptr, xdr_results, results_ptr, timeout) } shipnow = - (xdr_results == (xdrproc_t)0 && timeout.tv_sec == 0 - && timeout.tv_usec == 0) ? FALSE : TRUE; + (xdr_results == (xdrproc_t) 0 && timeout.tv_sec == 0 + && timeout.tv_usec == 0) ? FALSE : TRUE; -call_again: + 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 ((!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); + (void) xdrrec_endofrecord(xdrs, TRUE); return (ct->ct_error.re_status); } - if (! xdrrec_endofrecord(xdrs, shipnow)) + if (!xdrrec_endofrecord(xdrs, shipnow)) return (ct->ct_error.re_status = RPC_CANTSEND); - if (! shipnow) + 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); + return (ct->ct_error.re_status = RPC_TIMEDOUT); } @@ -278,10 +281,10 @@ call_again: 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)) + if (!xdrrec_skiprecord(xdrs)) return (ct->ct_error.re_status); /* now decode and validate the response header */ - if (! xdr_replymsg(xdrs, &reply_msg)) { + if (!xdr_replymsg(xdrs, &reply_msg)) { if (ct->ct_error.re_status == RPC_SUCCESS) continue; return (ct->ct_error.re_status); @@ -295,74 +298,69 @@ call_again: */ _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)) { + 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)) { + } 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)); + (void) xdr_opaque_auth(xdrs, &(reply_msg.acpted_rply.ar_verf)); } - } /* end successful completion */ + } /* 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 */ + } /* end of unsuccessful completion */ return (ct->ct_error.re_status); } -static void -clnttcp_geterr(h, errp) - CLIENT *h; - struct rpc_err *errp; +static void clnttcp_geterr(h, errp) +CLIENT *h; +struct rpc_err *errp; { - register struct ct_data *ct = - (struct ct_data *) h->cl_private; + 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; +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 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)); + return ((*xdr_res) (xdrs, res_ptr)); } -static void -clnttcp_abort() +static void clnttcp_abort() { } -static bool_t -clnttcp_control(cl, request, info) - CLIENT *cl; - int request; - char *info; +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; + register struct ct_data *ct = (struct ct_data *) cl->cl_private; switch (request) { case CLSET_TIMEOUT: - ct->ct_wait = *(struct timeval *)info; + ct->ct_wait = *(struct timeval *) info; ct->ct_waitset = TRUE; break; case CLGET_TIMEOUT: - *(struct timeval *)info = ct->ct_wait; + *(struct timeval *) info = ct->ct_wait; break; case CLGET_SERVER_ADDR: - *(struct sockaddr_in *)info = ct->ct_addr; + *(struct sockaddr_in *) info = ct->ct_addr; break; default: return (FALSE); @@ -371,19 +369,18 @@ clnttcp_control(cl, request, info) } -static void -clnttcp_destroy(h) - CLIENT *h; +static void clnttcp_destroy(h) +CLIENT *h; { - register struct ct_data *ct = - (struct ct_data *) h->cl_private; + register struct ct_data *ct = (struct ct_data *) h->cl_private; if (ct->ct_closeit) { - (void)close(ct->ct_sock); + (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)); + mem_free((caddr_t) ct, sizeof(struct ct_data)); + + mem_free((caddr_t) h, sizeof(CLIENT)); } /* @@ -391,11 +388,10 @@ clnttcp_destroy(h) * 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; +static int readtcp(ct, buf, len) +register struct ct_data *ct; +caddr_t buf; +register int len; { #ifdef FD_SETSIZE fd_set mask; @@ -412,11 +408,12 @@ readtcp(ct, buf, len) if (len == 0) return (0); -#endif /* def FD_SETSIZE */ +#endif /* def FD_SETSIZE */ while (TRUE) { readfds = mask; - switch (select(_rpc_dtablesize(), &readfds, (int*)NULL, (int*)NULL, - &(ct->ct_wait))) { + switch (select + (_rpc_dtablesize(), &readfds, (int *) NULL, (int *) NULL, + &(ct->ct_wait))) { case 0: ct->ct_error.re_status = RPC_TIMEDOUT; return (-1); @@ -436,7 +433,7 @@ readtcp(ct, buf, len) /* premature eof */ ct->ct_error.re_errno = ECONNRESET; ct->ct_error.re_status = RPC_CANTRECV; - len = -1; /* it's really an error */ + len = -1; /* it's really an error */ break; case -1: @@ -447,11 +444,10 @@ readtcp(ct, buf, len) return (len); } -static int -writetcp(ct, buf, len) - struct ct_data *ct; - caddr_t buf; - int len; +static int writetcp(ct, buf, len) +struct ct_data *ct; +caddr_t buf; +int len; { register int i, cnt; diff --git a/libc/inet/rpc/clnt_udp.c b/libc/inet/rpc/clnt_udp.c index 815cbb4ed..7857f86fd 100644 --- a/libc/inet/rpc/clnt_udp.c +++ b/libc/inet/rpc/clnt_udp.c @@ -50,12 +50,12 @@ extern int errno; /* * UDP bases client side rpc operations */ -static enum clnt_stat clntudp_call(); -static void clntudp_abort(); -static void clntudp_geterr(); -static bool_t clntudp_freeres(); -static bool_t clntudp_control(); -static void clntudp_destroy(); +static enum clnt_stat clntudp_call(); +static void clntudp_abort(); +static void clntudp_geterr(); +static bool_t clntudp_freeres(); +static bool_t clntudp_control(); +static void clntudp_destroy(); static struct clnt_ops udp_ops = { clntudp_call, @@ -70,19 +70,19 @@ static struct clnt_ops udp_ops = { * Private data kept per client handle */ struct cu_data { - int cu_sock; - bool_t cu_closeit; + int cu_sock; + bool_t cu_closeit; struct sockaddr_in cu_raddr; - int cu_rlen; - struct timeval cu_wait; - struct timeval cu_total; - struct rpc_err cu_error; - XDR cu_outxdrs; - u_int cu_xdrpos; - u_int cu_sendsz; - char *cu_outbuf; - u_int cu_recvsz; - char cu_inbuf[1]; + int cu_rlen; + struct timeval cu_wait; + struct timeval cu_total; + struct rpc_err cu_error; + XDR cu_outxdrs; + u_int cu_xdrpos; + u_int cu_sendsz; + char *cu_outbuf; + u_int cu_recvsz; + char cu_inbuf[1]; }; /* @@ -101,22 +101,22 @@ struct cu_data { * sendsz and recvsz are the maximum allowable packet sizes that can be * sent and received. */ -CLIENT * -clntudp_bufcreate(raddr, program, version, wait, sockp, sendsz, recvsz) - struct sockaddr_in *raddr; - u_long program; - u_long version; - struct timeval wait; - register int *sockp; - u_int sendsz; - u_int recvsz; +CLIENT *clntudp_bufcreate(raddr, program, version, wait, sockp, sendsz, + recvsz) +struct sockaddr_in *raddr; +u_long program; +u_long version; +struct timeval wait; +register int *sockp; +u_int sendsz; +u_int recvsz; { CLIENT *cl; register struct cu_data *cu; struct timeval now; struct rpc_msg call_msg; - cl = (CLIENT *)mem_alloc(sizeof(CLIENT)); + cl = (CLIENT *) mem_alloc(sizeof(CLIENT)); if (cl == NULL) { (void) fprintf(stderr, "clntudp_create: out of memory\n"); rpc_createerr.cf_stat = RPC_SYSTEMERROR; @@ -125,7 +125,7 @@ clntudp_bufcreate(raddr, program, version, wait, sockp, sendsz, recvsz) } sendsz = ((sendsz + 3) / 4) * 4; recvsz = ((recvsz + 3) / 4) * 4; - cu = (struct cu_data *)mem_alloc(sizeof(*cu) + sendsz + recvsz); + cu = (struct cu_data *) mem_alloc(sizeof(*cu) + sendsz + recvsz); if (cu == NULL) { (void) fprintf(stderr, "clntudp_create: out of memory\n"); rpc_createerr.cf_stat = RPC_SYSTEMERROR; @@ -134,19 +134,20 @@ clntudp_bufcreate(raddr, program, version, wait, sockp, sendsz, recvsz) } cu->cu_outbuf = &cu->cu_inbuf[recvsz]; - (void)gettimeofday(&now, (struct timezone *)0); + (void) gettimeofday(&now, (struct timezone *) 0); if (raddr->sin_port == 0) { u_short port; + if ((port = - pmap_getport(raddr, program, version, IPPROTO_UDP)) == 0) { + pmap_getport(raddr, program, version, IPPROTO_UDP)) == 0) { goto fooy; } raddr->sin_port = htons(port); } cl->cl_ops = &udp_ops; - cl->cl_private = (caddr_t)cu; + cl->cl_private = (caddr_t) cu; cu->cu_raddr = *raddr; - cu->cu_rlen = sizeof (cu->cu_raddr); + cu->cu_rlen = sizeof(cu->cu_raddr); cu->cu_wait = wait; cu->cu_total.tv_sec = -1; cu->cu_total.tv_usec = -1; @@ -157,9 +158,8 @@ clntudp_bufcreate(raddr, program, version, wait, sockp, sendsz, recvsz) call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION; call_msg.rm_call.cb_prog = program; call_msg.rm_call.cb_vers = version; - xdrmem_create(&(cu->cu_outxdrs), cu->cu_outbuf, - sendsz, XDR_ENCODE); - if (! xdr_callhdr(&(cu->cu_outxdrs), &call_msg)) { + xdrmem_create(&(cu->cu_outxdrs), cu->cu_outbuf, sendsz, XDR_ENCODE); + if (!xdr_callhdr(&(cu->cu_outxdrs), &call_msg)) { goto fooy; } cu->cu_xdrpos = XDR_GETPOS(&(cu->cu_outxdrs)); @@ -173,9 +173,9 @@ clntudp_bufcreate(raddr, program, version, wait, sockp, sendsz, recvsz) goto fooy; } /* attempt to bind to prov port */ - (void)bindresvport(*sockp, (struct sockaddr_in *)0); + (void) bindresvport(*sockp, (struct sockaddr_in *) 0); /* the sockets rpc controls are non-blocking */ - (void)ioctl(*sockp, FIONBIO, (char *) &dontblock); + (void) ioctl(*sockp, FIONBIO, (char *) &dontblock); cu->cu_closeit = TRUE; } else { cu->cu_closeit = FALSE; @@ -183,83 +183,82 @@ clntudp_bufcreate(raddr, program, version, wait, sockp, sendsz, recvsz) cu->cu_sock = *sockp; cl->cl_auth = authnone_create(); return (cl); -fooy: + fooy: if (cu) - mem_free((caddr_t)cu, sizeof(*cu) + sendsz + recvsz); + mem_free((caddr_t) cu, sizeof(*cu) + sendsz + recvsz); if (cl) - mem_free((caddr_t)cl, sizeof(CLIENT)); - return ((CLIENT *)NULL); + mem_free((caddr_t) cl, sizeof(CLIENT)); + return ((CLIENT *) NULL); } -CLIENT * -clntudp_create(raddr, program, version, wait, sockp) - struct sockaddr_in *raddr; - u_long program; - u_long version; - struct timeval wait; - register int *sockp; +CLIENT *clntudp_create(raddr, program, version, wait, sockp) +struct sockaddr_in *raddr; +u_long program; +u_long version; +struct timeval wait; +register int *sockp; { - return(clntudp_bufcreate(raddr, program, version, wait, sockp, - UDPMSGSIZE, UDPMSGSIZE)); + return (clntudp_bufcreate(raddr, program, version, wait, sockp, + UDPMSGSIZE, UDPMSGSIZE)); } -static enum clnt_stat +static enum clnt_stat clntudp_call(cl, proc, xargs, argsp, xresults, resultsp, utimeout) - register CLIENT *cl; /* client handle */ - u_long proc; /* procedure number */ - xdrproc_t xargs; /* xdr routine for args */ - caddr_t argsp; /* pointer to args */ - xdrproc_t xresults; /* xdr routine for results */ - caddr_t resultsp; /* pointer to results */ - struct timeval utimeout; /* seconds to wait before giving up */ +register CLIENT *cl; /* client handle */ +u_long proc; /* procedure number */ +xdrproc_t xargs; /* xdr routine for args */ +caddr_t argsp; /* pointer to args */ +xdrproc_t xresults; /* xdr routine for results */ +caddr_t resultsp; /* pointer to results */ +struct timeval utimeout; /* seconds to wait before giving up */ { - register struct cu_data *cu = (struct cu_data *)cl->cl_private; + register struct cu_data *cu = (struct cu_data *) cl->cl_private; register XDR *xdrs; register int outlen; register int inlen; int fromlen; + #ifdef FD_SETSIZE fd_set readfds; fd_set mask; #else int readfds; register int mask; -#endif /* def FD_SETSIZE */ +#endif /* def FD_SETSIZE */ struct sockaddr_in from; struct rpc_msg reply_msg; XDR reply_xdrs; struct timeval time_waited; bool_t ok; - int nrefreshes = 2; /* number of times to refresh cred */ + int nrefreshes = 2; /* number of times to refresh cred */ struct timeval timeout; if (cu->cu_total.tv_usec == -1) { - timeout = utimeout; /* use supplied timeout */ + timeout = utimeout; /* use supplied timeout */ } else { - timeout = cu->cu_total; /* use default timeout */ + timeout = cu->cu_total; /* use default timeout */ } time_waited.tv_sec = 0; time_waited.tv_usec = 0; -call_again: + call_again: xdrs = &(cu->cu_outxdrs); xdrs->x_op = XDR_ENCODE; XDR_SETPOS(xdrs, cu->cu_xdrpos); /* * the transaction is the first thing in the out buffer */ - (*(u_short *)(cu->cu_outbuf))++; - if ((! XDR_PUTLONG(xdrs, (long *)&proc)) || - (! AUTH_MARSHALL(cl->cl_auth, xdrs)) || - (! (*xargs)(xdrs, argsp))) + (*(u_short *) (cu->cu_outbuf))++; + if ((!XDR_PUTLONG(xdrs, (long *) &proc)) || + (!AUTH_MARSHALL(cl->cl_auth, xdrs)) || (!(*xargs) (xdrs, argsp))) return (cu->cu_error.re_status = RPC_CANTENCODEARGS); - outlen = (int)XDR_GETPOS(xdrs); + outlen = (int) XDR_GETPOS(xdrs); -send_again: + send_again: if (sendto(cu->cu_sock, cu->cu_outbuf, outlen, 0, - (struct sockaddr *)&(cu->cu_raddr), cu->cu_rlen) - != outlen) { + (struct sockaddr *) &(cu->cu_raddr), cu->cu_rlen) + != outlen) { cu->cu_error.re_errno = errno; return (cu->cu_error.re_status = RPC_CANTSEND); } @@ -283,11 +282,11 @@ send_again: FD_SET(cu->cu_sock, &mask); #else mask = 1 << cu->cu_sock; -#endif /* def FD_SETSIZE */ +#endif /* def FD_SETSIZE */ for (;;) { readfds = mask; - switch (select(_rpc_dtablesize(), &readfds, (int *)NULL, - (int *)NULL, &(cu->cu_wait))) { + switch (select(_rpc_dtablesize(), &readfds, (int *) NULL, + (int *) NULL, &(cu->cu_wait))) { case 0: time_waited.tv_sec += cu->cu_wait.tv_sec; @@ -298,37 +297,38 @@ send_again: } if ((time_waited.tv_sec < timeout.tv_sec) || ((time_waited.tv_sec == timeout.tv_sec) && - (time_waited.tv_usec < timeout.tv_usec))) - goto send_again; + (time_waited.tv_usec < timeout.tv_usec))) + goto send_again; return (cu->cu_error.re_status = RPC_TIMEDOUT); - /* - * buggy in other cases because time_waited is not being - * updated. - */ + /* + * buggy in other cases because time_waited is not being + * updated. + */ case -1: if (errno == EINTR) - continue; + continue; cu->cu_error.re_errno = errno; return (cu->cu_error.re_status = RPC_CANTRECV); } do { fromlen = sizeof(struct sockaddr); - inlen = recvfrom(cu->cu_sock, cu->cu_inbuf, - (int) cu->cu_recvsz, 0, - (struct sockaddr *)&from, &fromlen); + + inlen = recvfrom(cu->cu_sock, cu->cu_inbuf, + (int) cu->cu_recvsz, 0, + (struct sockaddr *) &from, &fromlen); } while (inlen < 0 && errno == EINTR); if (inlen < 0) { if (errno == EWOULDBLOCK) - continue; + continue; cu->cu_error.re_errno = errno; return (cu->cu_error.re_status = RPC_CANTRECV); } if (inlen < sizeof(u_long)) - continue; + continue; /* see if reply transaction id matches sent id */ - if (*((u_long *)(cu->cu_inbuf)) != *((u_long *)(cu->cu_outbuf))) - continue; + if (*((u_long *) (cu->cu_inbuf)) != *((u_long *) (cu->cu_outbuf))) + continue; /* we now assume we have the proper reply */ break; } @@ -336,107 +336,102 @@ send_again: /* * now decode and validate the response */ - xdrmem_create(&reply_xdrs, cu->cu_inbuf, (u_int)inlen, XDR_DECODE); + xdrmem_create(&reply_xdrs, cu->cu_inbuf, (u_int) inlen, XDR_DECODE); ok = xdr_replymsg(&reply_xdrs, &reply_msg); /* XDR_DESTROY(&reply_xdrs); save a few cycles on noop destroy */ if (ok) { _seterr_reply(&reply_msg, &(cu->cu_error)); if (cu->cu_error.re_status == RPC_SUCCESS) { - if (! AUTH_VALIDATE(cl->cl_auth, - &reply_msg.acpted_rply.ar_verf)) { + if (!AUTH_VALIDATE(cl->cl_auth, + &reply_msg.acpted_rply.ar_verf)) { cu->cu_error.re_status = RPC_AUTHERROR; cu->cu_error.re_why = AUTH_INVALIDRESP; } 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 */ + (void) xdr_opaque_auth(xdrs, + &(reply_msg.acpted_rply.ar_verf)); + } + } /* end successful completion */ else { /* maybe our credentials need to be refreshed ... */ if (nrefreshes > 0 && AUTH_REFRESH(cl->cl_auth)) { nrefreshes--; goto call_again; } - } /* end of unsuccessful completion */ - } /* end of valid reply message */ + } /* end of unsuccessful completion */ + } /* end of valid reply message */ else { cu->cu_error.re_status = RPC_CANTDECODERES; } return (cu->cu_error.re_status); } -static void -clntudp_geterr(cl, errp) - CLIENT *cl; - struct rpc_err *errp; +static void clntudp_geterr(cl, errp) +CLIENT *cl; +struct rpc_err *errp; { - register struct cu_data *cu = (struct cu_data *)cl->cl_private; + register struct cu_data *cu = (struct cu_data *) cl->cl_private; *errp = cu->cu_error; } -static bool_t -clntudp_freeres(cl, xdr_res, res_ptr) - CLIENT *cl; - xdrproc_t xdr_res; - caddr_t res_ptr; +static bool_t clntudp_freeres(cl, xdr_res, res_ptr) +CLIENT *cl; +xdrproc_t xdr_res; +caddr_t res_ptr; { - register struct cu_data *cu = (struct cu_data *)cl->cl_private; + register struct cu_data *cu = (struct cu_data *) cl->cl_private; register XDR *xdrs = &(cu->cu_outxdrs); xdrs->x_op = XDR_FREE; - return ((*xdr_res)(xdrs, res_ptr)); + return ((*xdr_res) (xdrs, res_ptr)); } -static void -clntudp_abort(/*h*/) - /*CLIENT *h;*/ +static void clntudp_abort( /*h */ ) + /*CLIENT *h; */ { } -static bool_t -clntudp_control(cl, request, info) - CLIENT *cl; - int request; - char *info; +static bool_t clntudp_control(cl, request, info) +CLIENT *cl; +int request; +char *info; { - register struct cu_data *cu = (struct cu_data *)cl->cl_private; + register struct cu_data *cu = (struct cu_data *) cl->cl_private; switch (request) { case CLSET_TIMEOUT: - cu->cu_total = *(struct timeval *)info; + cu->cu_total = *(struct timeval *) info; break; case CLGET_TIMEOUT: - *(struct timeval *)info = cu->cu_total; + *(struct timeval *) info = cu->cu_total; break; case CLSET_RETRY_TIMEOUT: - cu->cu_wait = *(struct timeval *)info; + cu->cu_wait = *(struct timeval *) info; break; case CLGET_RETRY_TIMEOUT: - *(struct timeval *)info = cu->cu_wait; + *(struct timeval *) info = cu->cu_wait; break; case CLGET_SERVER_ADDR: - *(struct sockaddr_in *)info = cu->cu_raddr; + *(struct sockaddr_in *) info = cu->cu_raddr; break; default: return (FALSE); } return (TRUE); } - -static void -clntudp_destroy(cl) - CLIENT *cl; + +static void clntudp_destroy(cl) +CLIENT *cl; { - register struct cu_data *cu = (struct cu_data *)cl->cl_private; + register struct cu_data *cu = (struct cu_data *) cl->cl_private; if (cu->cu_closeit) { - (void)close(cu->cu_sock); + (void) close(cu->cu_sock); } XDR_DESTROY(&(cu->cu_outxdrs)); - mem_free((caddr_t)cu, (sizeof(*cu) + cu->cu_sendsz + cu->cu_recvsz)); - mem_free((caddr_t)cl, sizeof(CLIENT)); + mem_free((caddr_t) cu, (sizeof(*cu) + cu->cu_sendsz + cu->cu_recvsz)); + mem_free((caddr_t) cl, sizeof(CLIENT)); } diff --git a/libc/inet/rpc/get_myaddress.c b/libc/inet/rpc/get_myaddress.c index cbfc05b8d..95ddc71b4 100644 --- a/libc/inet/rpc/get_myaddress.c +++ b/libc/inet/rpc/get_myaddress.c @@ -28,7 +28,9 @@ * Mountain View, California 94043 */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)get_myaddress.c 1.4 87/08/11 Copyr 1984 Sun Micro"; +static char sccsid[] = + + "@(#)get_myaddress.c 1.4 87/08/11 Copyr 1984 Sun Micro"; #endif /* @@ -51,7 +53,7 @@ static char sccsid[] = "@(#)get_myaddress.c 1.4 87/08/11 Copyr 1984 Sun Micro"; /* DO use gethostbyname because it's portable */ #include get_myaddress(addr) - struct sockaddr_in *addr; +struct sockaddr_in *addr; { char localhost[256 + 1]; struct hostent *hp; @@ -70,7 +72,7 @@ get_myaddress(addr) * don't use gethostbyname, which would invoke yellow pages */ get_myaddress(addr) - struct sockaddr_in *addr; +struct sockaddr_in *addr; { int s; char buf[BUFSIZ]; @@ -79,25 +81,25 @@ get_myaddress(addr) int len; if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { - perror("get_myaddress: socket"); - exit(1); + perror("get_myaddress: socket"); + exit(1); } - ifc.ifc_len = sizeof (buf); + ifc.ifc_len = sizeof(buf); ifc.ifc_buf = buf; - if (ioctl(s, SIOCGIFCONF, (char *)&ifc) < 0) { + if (ioctl(s, SIOCGIFCONF, (char *) &ifc) < 0) { perror("get_myaddress: ioctl (get interface configuration)"); exit(1); } ifr = ifc.ifc_req; for (len = ifc.ifc_len; len; len -= sizeof ifreq) { ifreq = *ifr; - if (ioctl(s, SIOCGIFFLAGS, (char *)&ifreq) < 0) { + if (ioctl(s, SIOCGIFFLAGS, (char *) &ifreq) < 0) { perror("get_myaddress: ioctl"); exit(1); } if ((ifreq.ifr_flags & IFF_UP) && - ifr->ifr_addr.sa_family == AF_INET) { - *addr = *((struct sockaddr_in *)&ifr->ifr_addr); + ifr->ifr_addr.sa_family == AF_INET) { + *addr = *((struct sockaddr_in *) &ifr->ifr_addr); addr->sin_port = htons(PMAPPORT); break; } diff --git a/libc/inet/rpc/getrpcent.c b/libc/inet/rpc/getrpcent.c index b3b3ece4c..06c272c89 100644 --- a/libc/inet/rpc/getrpcent.c +++ b/libc/inet/rpc/getrpcent.c @@ -1,6 +1,8 @@ /* @(#)getrpcent.c 2.2 88/07/29 4.0 RPCSRC */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)getrpcent.c 1.9 87/08/11 Copyr 1984 Sun Micro"; +static char sccsid[] = + + "@(#)getrpcent.c 1.9 87/08/11 Copyr 1984 Sun Micro"; #endif /* @@ -46,43 +48,43 @@ static char sccsid[] = "@(#)getrpcent.c 1.9 87/08/11 Copyr 1984 Sun Micro"; * Internet version. */ struct rpcdata { - FILE *rpcf; - char *current; - int currentlen; - int stayopen; + FILE *rpcf; + char *current; + int currentlen; + int stayopen; #define MAXALIASES 35 - char *rpc_aliases[MAXALIASES]; - struct rpcent rpc; - char line[BUFSIZ+1]; - char *domain; + char *rpc_aliases[MAXALIASES]; + struct rpcent rpc; + char line[BUFSIZ + 1]; + char *domain; } *rpcdata, *_rpcdata(); -static struct rpcent *interpret(); -struct hostent *gethostent(); -char *inet_ntoa(); +static struct rpcent *interpret(); +struct hostent *gethostent(); +char *inet_ntoa(); + #ifndef __linux__ -static char *index(); +static char *index(); #else char *index(); #endif static char RPCDB[] = "/etc/rpc"; -static struct rpcdata * -_rpcdata() +static struct rpcdata *_rpcdata() { register struct rpcdata *d = rpcdata; if (d == 0) { - d = (struct rpcdata *)calloc(1, sizeof (struct rpcdata)); + d = (struct rpcdata *) calloc(1, sizeof(struct rpcdata)); + rpcdata = d; } return (d); } -struct rpcent * -getrpcbynumber(number) - register int number; +struct rpcent *getrpcbynumber(number) +register int number; { register struct rpcdata *d = _rpcdata(); register struct rpcent *p; @@ -106,14 +108,14 @@ struct rpcent * getrpcbyname(const char *name) #else getrpcbyname(name) - char *name; +char *name; #endif { struct rpcent *rpc; char **rp; setrpcent(0); - while(rpc = getrpcent()) { + while (rpc = getrpcent()) { if (strcmp(rpc->r_name, name) == 0) return (rpc); for (rp = rpc->r_aliases; *rp != NULL; rp++) { @@ -129,7 +131,7 @@ getrpcbyname(name) void #endif setrpcent(f) - int f; +int f; { register struct rpcdata *d = _rpcdata(); @@ -164,8 +166,7 @@ endrpcent() } } -struct rpcent * -getrpcent() +struct rpcent *getrpcent() { struct rpcent *hp; int reason; @@ -174,17 +175,16 @@ getrpcent() register struct rpcdata *d = _rpcdata(); if (d == 0) - return(NULL); + return (NULL); if (d->rpcf == NULL && (d->rpcf = fopen(RPCDB, "r")) == NULL) return (NULL); - if (fgets(d->line, BUFSIZ, d->rpcf) == NULL) + if (fgets(d->line, BUFSIZ, d->rpcf) == NULL) return (NULL); return interpret(d->line, strlen(d->line)); } #ifdef __linux__ -static char * -firstwhite(s) +static char *firstwhite(s) char *s; { char *s1, *s2; @@ -196,14 +196,12 @@ char *s; return (s1 < s2) ? s1 : s2; else return s1; - } - else + } else return s2; } #endif -static struct rpcent * -interpret(val, len) +static struct rpcent *interpret(val, len) { register struct rpcdata *d = _rpcdata(); char *p; @@ -217,8 +215,7 @@ interpret(val, len) if (*p == '#') return (getrpcent()); cp = index(p, '#'); - if (cp == NULL) - { + if (cp == NULL) { cp = index(p, '\n'); if (cp == NULL) return (getrpcent()); @@ -231,8 +228,7 @@ interpret(val, len) return (getrpcent()); #else cp = index(p, ' '); - if (cp == NULL) - { + if (cp == NULL) { cp = index(p, '\t'); if (cp == NULL) return (getrpcent()); @@ -252,8 +248,7 @@ interpret(val, len) cp = index(p, ' '); if (cp != NULL) *cp++ = '\0'; - else - { + else { cp = index(p, '\t'); if (cp != NULL) *cp++ = '\0'; @@ -273,8 +268,7 @@ interpret(val, len) cp = index(p, ' '); if (cp != NULL) *cp++ = '\0'; - else - { + else { cp = index(p, '\t'); if (cp != NULL) *cp++ = '\0'; diff --git a/libc/inet/rpc/getrpcport.c b/libc/inet/rpc/getrpcport.c index 9b13bac6b..af4f7daf6 100644 --- a/libc/inet/rpc/getrpcport.c +++ b/libc/inet/rpc/getrpcport.c @@ -1,6 +1,6 @@ /* @(#)getrpcport.c 2.1 88/07/29 4.0 RPCSRC */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)getrpcport.c 1.3 87/08/11 SMI"; +static char sccsid[] = "@(#)getrpcport.c 1.3 87/08/11 SMI"; #endif /* * Sun RPC is a product of Sun Microsystems, Inc. and is provided for @@ -41,7 +41,7 @@ static char sccsid[] = "@(#)getrpcport.c 1.3 87/08/11 SMI"; #include getrpcport(host, prognum, versnum, proto) - char *host; +char *host; { struct sockaddr_in addr; struct hostent *hp; @@ -50,6 +50,6 @@ getrpcport(host, prognum, versnum, proto) return (0); bcopy(hp->h_addr, (char *) &addr.sin_addr, hp->h_length); addr.sin_family = AF_INET; - addr.sin_port = 0; + addr.sin_port = 0; return (pmap_getport(&addr, prognum, versnum, proto)); } diff --git a/libc/inet/rpc/pmap_clnt.c b/libc/inet/rpc/pmap_clnt.c index 09220e77b..921575e02 100644 --- a/libc/inet/rpc/pmap_clnt.c +++ b/libc/inet/rpc/pmap_clnt.c @@ -28,7 +28,9 @@ * Mountain View, California 94043 */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)pmap_clnt.c 1.37 87/08/11 Copyr 1984 Sun Micro"; +static char sccsid[] = + + "@(#)pmap_clnt.c 1.37 87/08/11 Copyr 1984 Sun Micro"; #endif /* @@ -52,12 +54,11 @@ void clnt_perror(); * Set a mapping between program,version and port. * Calls the pmap service remotely to do the mapping. */ -bool_t -pmap_set(program, version, protocol, port) - u_long program; - u_long version; - int protocol; - u_short port; +bool_t pmap_set(program, version, protocol, port) +u_long program; +u_long version; +int protocol; +u_short port; { struct sockaddr_in myaddress; int socket = -1; @@ -67,20 +68,21 @@ pmap_set(program, version, protocol, port) get_myaddress(&myaddress); client = clntudp_bufcreate(&myaddress, PMAPPROG, PMAPVERS, - timeout, &socket, RPCSMALLMSGSIZE, RPCSMALLMSGSIZE); - if (client == (CLIENT *)NULL) + timeout, &socket, RPCSMALLMSGSIZE, + RPCSMALLMSGSIZE); + if (client == (CLIENT *) NULL) return (FALSE); parms.pm_prog = program; parms.pm_vers = version; parms.pm_prot = protocol; parms.pm_port = port; if (CLNT_CALL(client, PMAPPROC_SET, xdr_pmap, &parms, xdr_bool, &rslt, - tottimeout) != RPC_SUCCESS) { + tottimeout) != RPC_SUCCESS) { clnt_perror(client, "Cannot register service"); return (FALSE); } CLNT_DESTROY(client); - (void)close(socket); + (void) close(socket); return (rslt); } @@ -88,10 +90,9 @@ pmap_set(program, version, protocol, port) * Remove the mapping between program,version and port. * Calls the pmap service remotely to do the un-mapping. */ -bool_t -pmap_unset(program, version) - u_long program; - u_long version; +bool_t pmap_unset(program, version) +u_long program; +u_long version; { struct sockaddr_in myaddress; int socket = -1; @@ -101,15 +102,16 @@ pmap_unset(program, version) get_myaddress(&myaddress); client = clntudp_bufcreate(&myaddress, PMAPPROG, PMAPVERS, - timeout, &socket, RPCSMALLMSGSIZE, RPCSMALLMSGSIZE); - if (client == (CLIENT *)NULL) + timeout, &socket, RPCSMALLMSGSIZE, + RPCSMALLMSGSIZE); + if (client == (CLIENT *) NULL) return (FALSE); parms.pm_prog = program; parms.pm_vers = version; parms.pm_port = parms.pm_prot = 0; CLNT_CALL(client, PMAPPROC_UNSET, xdr_pmap, &parms, xdr_bool, &rslt, - tottimeout); + tottimeout); CLNT_DESTROY(client); - (void)close(socket); + (void) close(socket); return (rslt); } diff --git a/libc/inet/rpc/pmap_getmaps.c b/libc/inet/rpc/pmap_getmaps.c index 98803d3c5..837875328 100644 --- a/libc/inet/rpc/pmap_getmaps.c +++ b/libc/inet/rpc/pmap_getmaps.c @@ -28,7 +28,9 @@ * Mountain View, California 94043 */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)pmap_getmaps.c 1.10 87/08/11 Copyr 1984 Sun Micro"; +static char sccsid[] = + + "@(#)pmap_getmaps.c 1.10 87/08/11 Copyr 1984 Sun Micro"; #endif /* @@ -57,11 +59,10 @@ extern int errno; * Get a copy of the current port maps. * Calls the pmap service remotely to do get the maps. */ -struct pmaplist * -pmap_getmaps(address) - struct sockaddr_in *address; +struct pmaplist *pmap_getmaps(address) +struct sockaddr_in *address; { - struct pmaplist *head = (struct pmaplist *)NULL; + struct pmaplist *head = (struct pmaplist *) NULL; int socket = -1; struct timeval minutetimeout; register CLIENT *client; @@ -69,16 +70,15 @@ pmap_getmaps(address) minutetimeout.tv_sec = 60; minutetimeout.tv_usec = 0; address->sin_port = htons(PMAPPORT); - client = clnttcp_create(address, PMAPPROG, - PMAPVERS, &socket, 50, 500); - if (client != (CLIENT *)NULL) { + client = clnttcp_create(address, PMAPPROG, PMAPVERS, &socket, 50, 500); + if (client != (CLIENT *) NULL) { if (CLNT_CALL(client, PMAPPROC_DUMP, xdr_void, NULL, xdr_pmaplist, - &head, minutetimeout) != RPC_SUCCESS) { + &head, minutetimeout) != RPC_SUCCESS) { clnt_perror(client, "pmap_getmaps rpc problem"); } CLNT_DESTROY(client); } - (void)close(socket); + (void) close(socket); address->sin_port = 0; return (head); } diff --git a/libc/inet/rpc/pmap_getport.c b/libc/inet/rpc/pmap_getport.c index 5eb2eee3b..122105d8c 100644 --- a/libc/inet/rpc/pmap_getport.c +++ b/libc/inet/rpc/pmap_getport.c @@ -28,7 +28,9 @@ * Mountain View, California 94043 */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)pmap_getport.c 1.9 87/08/11 Copyr 1984 Sun Micro"; +static char sccsid[] = + + "@(#)pmap_getport.c 1.9 87/08/11 Copyr 1984 Sun Micro"; #endif /* @@ -52,12 +54,11 @@ static struct timeval tottimeout = { 60, 0 }; * Calls the pmap service remotely to do the lookup. * Returns 0 if no map exists. */ -u_short -pmap_getport(address, program, version, protocol) - struct sockaddr_in *address; - u_long program; - u_long version; - u_int protocol; +u_short pmap_getport(address, program, version, protocol) +struct sockaddr_in *address; +u_long program; +u_long version; +u_int protocol; { u_short port = 0; int socket = -1; @@ -66,14 +67,15 @@ pmap_getport(address, program, version, protocol) address->sin_port = htons(PMAPPORT); client = clntudp_bufcreate(address, PMAPPROG, - PMAPVERS, timeout, &socket, RPCSMALLMSGSIZE, RPCSMALLMSGSIZE); - if (client != (CLIENT *)NULL) { + PMAPVERS, timeout, &socket, RPCSMALLMSGSIZE, + RPCSMALLMSGSIZE); + if (client != (CLIENT *) NULL) { parms.pm_prog = program; parms.pm_vers = version; parms.pm_prot = protocol; - parms.pm_port = 0; /* not needed or used */ + parms.pm_port = 0; /* not needed or used */ if (CLNT_CALL(client, PMAPPROC_GETPORT, xdr_pmap, &parms, - xdr_u_short, &port, tottimeout) != RPC_SUCCESS){ + xdr_u_short, &port, tottimeout) != RPC_SUCCESS) { rpc_createerr.cf_stat = RPC_PMAPFAILURE; clnt_geterr(client, &rpc_createerr.cf_error); } else if (port == 0) { @@ -81,7 +83,7 @@ pmap_getport(address, program, version, protocol) } CLNT_DESTROY(client); } - (void)close(socket); + (void) close(socket); address->sin_port = 0; return (port); } diff --git a/libc/inet/rpc/pmap_prot.c b/libc/inet/rpc/pmap_prot.c index 643c2ff6a..ec8b5af79 100644 --- a/libc/inet/rpc/pmap_prot.c +++ b/libc/inet/rpc/pmap_prot.c @@ -28,7 +28,9 @@ * Mountain View, California 94043 */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)pmap_prot.c 1.17 87/08/11 Copyr 1984 Sun Micro"; +static char sccsid[] = + + "@(#)pmap_prot.c 1.17 87/08/11 Copyr 1984 Sun Micro"; #endif /* @@ -43,15 +45,14 @@ static char sccsid[] = "@(#)pmap_prot.c 1.17 87/08/11 Copyr 1984 Sun Micro"; #include -bool_t -xdr_pmap(xdrs, regs) - XDR *xdrs; - struct pmap *regs; +bool_t xdr_pmap(xdrs, regs) +XDR *xdrs; +struct pmap *regs; { - if (xdr_u_long(xdrs, ®s->pm_prog) && - xdr_u_long(xdrs, ®s->pm_vers) && + if (xdr_u_long(xdrs, ®s->pm_prog) && + xdr_u_long(xdrs, ®s->pm_vers) && xdr_u_long(xdrs, ®s->pm_prot)) - return (xdr_u_long(xdrs, ®s->pm_port)); + return (xdr_u_long(xdrs, ®s->pm_port)); return (FALSE); } diff --git a/libc/inet/rpc/pmap_prot2.c b/libc/inet/rpc/pmap_prot2.c index e2a8214d4..1a6207728 100644 --- a/libc/inet/rpc/pmap_prot2.c +++ b/libc/inet/rpc/pmap_prot2.c @@ -28,7 +28,9 @@ * Mountain View, California 94043 */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)pmap_prot2.c 1.3 87/08/11 Copyr 1984 Sun Micro"; +static char sccsid[] = + + "@(#)pmap_prot2.c 1.3 87/08/11 Copyr 1984 Sun Micro"; #endif /* @@ -81,10 +83,9 @@ static char sccsid[] = "@(#)pmap_prot2.c 1.3 87/08/11 Copyr 1984 Sun Micro"; * the net, yet is the data that the pointer points to which is interesting; * this sounds like a job for xdr_reference! */ -bool_t -xdr_pmaplist(xdrs, rp) - register XDR *xdrs; - register struct pmaplist **rp; +bool_t xdr_pmaplist(xdrs, rp) +register XDR *xdrs; +register struct pmaplist **rp; { /* * more_elements is pre-computed in case the direction is @@ -96,21 +97,22 @@ xdr_pmaplist(xdrs, rp) register struct pmaplist **next; while (TRUE) { - more_elements = (bool_t)(*rp != NULL); - if (! xdr_bool(xdrs, &more_elements)) + more_elements = (bool_t) (*rp != NULL); + if (!xdr_bool(xdrs, &more_elements)) return (FALSE); - if (! more_elements) - return (TRUE); /* we are done */ + if (!more_elements) + return (TRUE); /* we are done */ /* * the unfortunate side effect of non-recursion is that in * the case of freeing we must remember the next object * before we free the current object ... */ if (freeing) - next = &((*rp)->pml_next); - if (! xdr_reference(xdrs, (caddr_t *)rp, - (u_int)sizeof(struct pmaplist), xdr_pmap)) + next = &((*rp)->pml_next); + if (!xdr_reference(xdrs, (caddr_t *) rp, + (u_int) sizeof(struct pmaplist), xdr_pmap)) return (FALSE); + rp = (freeing) ? next : &((*rp)->pml_next); } } diff --git a/libc/inet/rpc/pmap_rmt.c b/libc/inet/rpc/pmap_rmt.c index 1921b74c1..1f2b47cba 100644 --- a/libc/inet/rpc/pmap_rmt.c +++ b/libc/inet/rpc/pmap_rmt.c @@ -63,13 +63,14 @@ static struct timeval timeout = { 3, 0 }; * programs to do a lookup and call in one step. */ enum clnt_stat -pmap_rmtcall(addr, prog, vers, proc, xdrargs, argsp, xdrres, resp, tout, port_ptr) - struct sockaddr_in *addr; - u_long prog, vers, proc; - xdrproc_t xdrargs, xdrres; - caddr_t argsp, resp; - struct timeval tout; - u_long *port_ptr; +pmap_rmtcall(addr, prog, vers, proc, xdrargs, argsp, xdrres, resp, tout, + port_ptr) +struct sockaddr_in *addr; +u_long prog, vers, proc; +xdrproc_t xdrargs, xdrres; +caddr_t argsp, resp; +struct timeval tout; +u_long *port_ptr; { int socket = -1; register CLIENT *client; @@ -79,7 +80,7 @@ pmap_rmtcall(addr, prog, vers, proc, xdrargs, argsp, xdrres, resp, tout, port_pt addr->sin_port = htons(PMAPPORT); client = clntudp_create(addr, PMAPPROG, PMAPVERS, timeout, &socket); - if (client != (CLIENT *)NULL) { + if (client != (CLIENT *) NULL) { a.prog = prog; a.vers = vers; a.proc = proc; @@ -89,12 +90,12 @@ pmap_rmtcall(addr, prog, vers, proc, xdrargs, argsp, xdrres, resp, tout, port_pt r.results_ptr = resp; r.xdr_results = xdrres; stat = CLNT_CALL(client, PMAPPROC_CALLIT, xdr_rmtcall_args, &a, - xdr_rmtcallres, &r, tout); + xdr_rmtcallres, &r, tout); CLNT_DESTROY(client); } else { stat = RPC_FAILED; } - (void)close(socket); + (void) close(socket); addr->sin_port = 0; return (stat); } @@ -104,27 +105,25 @@ pmap_rmtcall(addr, prog, vers, proc, xdrargs, argsp, xdrres, resp, tout, port_pt * XDR remote call arguments * written for XDR_ENCODE direction only */ -bool_t -xdr_rmtcall_args(xdrs, cap) - register XDR *xdrs; - register struct rmtcallargs *cap; +bool_t xdr_rmtcall_args(xdrs, cap) +register XDR *xdrs; +register struct rmtcallargs *cap; { u_int lenposition, argposition, position; if (xdr_u_long(xdrs, &(cap->prog)) && - xdr_u_long(xdrs, &(cap->vers)) && - xdr_u_long(xdrs, &(cap->proc))) { + xdr_u_long(xdrs, &(cap->vers)) && xdr_u_long(xdrs, &(cap->proc))) { lenposition = XDR_GETPOS(xdrs); - if (! xdr_u_long(xdrs, &(cap->arglen))) - return (FALSE); + if (!xdr_u_long(xdrs, &(cap->arglen))) + return (FALSE); argposition = XDR_GETPOS(xdrs); - if (! (*(cap->xdr_args))(xdrs, cap->args_ptr)) - return (FALSE); + if (!(*(cap->xdr_args)) (xdrs, cap->args_ptr)) + return (FALSE); position = XDR_GETPOS(xdrs); - cap->arglen = (u_long)position - (u_long)argposition; + cap->arglen = (u_long) position - (u_long) argposition; XDR_SETPOS(xdrs, lenposition); - if (! xdr_u_long(xdrs, &(cap->arglen))) - return (FALSE); + if (!xdr_u_long(xdrs, &(cap->arglen))) + return (FALSE); XDR_SETPOS(xdrs, position); return (TRUE); } @@ -135,18 +134,17 @@ xdr_rmtcall_args(xdrs, cap) * XDR remote call results * written for XDR_DECODE direction only */ -bool_t -xdr_rmtcallres(xdrs, crp) - register XDR *xdrs; - register struct rmtcallres *crp; +bool_t xdr_rmtcallres(xdrs, crp) +register XDR *xdrs; +register struct rmtcallres *crp; { caddr_t port_ptr; - port_ptr = (caddr_t)crp->port_ptr; - if (xdr_reference(xdrs, &port_ptr, sizeof (u_long), - xdr_u_long) && xdr_u_long(xdrs, &crp->resultslen)) { - crp->port_ptr = (u_long *)port_ptr; - return ((*(crp->xdr_results))(xdrs, crp->results_ptr)); + port_ptr = (caddr_t) crp->port_ptr; + if (xdr_reference(xdrs, &port_ptr, sizeof(u_long), + xdr_u_long) && xdr_u_long(xdrs, &crp->resultslen)) { + crp->port_ptr = (u_long *) port_ptr; + return ((*(crp->xdr_results)) (xdrs, crp->results_ptr)); } return (FALSE); } @@ -158,11 +156,10 @@ xdr_rmtcallres(xdrs, crp) * routines which only support udp/ip . */ -static int -getbroadcastnets(addrs, sock, buf) - struct in_addr *addrs; - int sock; /* any valid socket will do */ - char *buf; /* why allocxate more when we can use existing... */ +static int getbroadcastnets(addrs, sock, buf) +struct in_addr *addrs; +int sock; /* any valid socket will do */ +char *buf; /* why allocxate more when we can use existing... */ { #ifdef __linux__ struct sockaddr_in addr; @@ -176,45 +173,46 @@ getbroadcastnets(addrs, sock, buf) return 1; #else struct ifconf ifc; - struct ifreq ifreq, *ifr; + struct ifreq ifreq, *ifr; struct sockaddr_in *sin; - int n, i; + int n, i; - ifc.ifc_len = UDPMSGSIZE; - ifc.ifc_buf = buf; - if (ioctl(sock, SIOCGIFCONF, (char *)&ifc) < 0) { - perror("broadcast: ioctl (get interface configuration)"); - return (0); - } - ifr = ifc.ifc_req; - for (i = 0, n = ifc.ifc_len/sizeof (struct ifreq); n > 0; n--, ifr++) { - ifreq = *ifr; - if (ioctl(sock, SIOCGIFFLAGS, (char *)&ifreq) < 0) { - perror("broadcast: ioctl (get interface flags)"); - continue; - } - if ((ifreq.ifr_flags & IFF_BROADCAST) && - (ifreq.ifr_flags & IFF_UP) && - ifr->ifr_addr.sa_family == AF_INET) { - sin = (struct sockaddr_in *)&ifr->ifr_addr; -#ifdef SIOCGIFBRDADDR /* 4.3BSD */ - if (ioctl(sock, SIOCGIFBRDADDR, (char *)&ifreq) < 0) { + ifc.ifc_len = UDPMSGSIZE; + ifc.ifc_buf = buf; + if (ioctl(sock, SIOCGIFCONF, (char *) &ifc) < 0) { + perror("broadcast: ioctl (get interface configuration)"); + return (0); + } + ifr = ifc.ifc_req; + for (i = 0, n = ifc.ifc_len / sizeof(struct ifreq); n > 0; n--, ifr++) { + ifreq = *ifr; + if (ioctl(sock, SIOCGIFFLAGS, (char *) &ifreq) < 0) { + perror("broadcast: ioctl (get interface flags)"); + continue; + } + if ((ifreq.ifr_flags & IFF_BROADCAST) && + (ifreq.ifr_flags & IFF_UP) && + ifr->ifr_addr.sa_family == AF_INET) { + sin = (struct sockaddr_in *) &ifr->ifr_addr; +#ifdef SIOCGIFBRDADDR /* 4.3BSD */ + if (ioctl(sock, SIOCGIFBRDADDR, (char *) &ifreq) < 0) { #if 1 -printf("%s(%d): no inet_makeaddr()\n", __FILE__, __LINE__); + printf("%s(%d): no inet_makeaddr()\n", __FILE__, __LINE__); #else addrs[i++] = inet_makeaddr(inet_netof - (sin->sin_addr.s_addr), INADDR_ANY); + (sin->sin_addr.s_addr), + INADDR_ANY); #endif } else { - addrs[i++] = ((struct sockaddr_in*) - &ifreq.ifr_addr)->sin_addr; + addrs[i++] = ((struct sockaddr_in *) + &ifreq.ifr_addr)->sin_addr; } -#else /* 4.2 BSD */ +#else /* 4.2 BSD */ #if 1 -printf("%s(%d): no inet_makeaddr()\n", __FILE__, __LINE__); + printf("%s(%d): no inet_makeaddr()\n", __FILE__, __LINE__); #else addrs[i++] = inet_makeaddr(inet_netof - (sin->sin_addr.s_addr), INADDR_ANY); + (sin->sin_addr.s_addr), INADDR_ANY); #endif #endif } @@ -223,18 +221,19 @@ printf("%s(%d): no inet_makeaddr()\n", __FILE__, __LINE__); #endif } -typedef bool_t (*resultproc_t)(); +typedef bool_t(*resultproc_t) (); -enum clnt_stat -clnt_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp, eachresult) - u_long prog; /* program number */ - u_long vers; /* version number */ - u_long proc; /* procedure number */ - xdrproc_t xargs; /* xdr routine for args */ - caddr_t argsp; /* pointer to args */ - xdrproc_t xresults; /* xdr routine for results */ - caddr_t resultsp; /* pointer to results */ - resultproc_t eachresult; /* call with each result obtained */ +enum clnt_stat +clnt_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp, + eachresult) +u_long prog; /* program number */ +u_long vers; /* version number */ +u_long proc; /* procedure number */ +xdrproc_t xargs; /* xdr routine for args */ +caddr_t argsp; /* pointer to args */ +xdrproc_t xresults; /* xdr routine for results */ +caddr_t resultsp; /* pointer to results */ +resultproc_t eachresult; /* call with each result obtained */ { enum clnt_stat stat; AUTH *unix_auth = authunix_create_default(); @@ -243,23 +242,24 @@ clnt_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp, eachresult) int outlen, inlen, fromlen, nets; register int sock; int on = 1; + #ifdef FD_SETSIZE fd_set mask; fd_set readfds; #else int readfds; register int mask; -#endif /* def FD_SETSIZE */ +#endif /* def FD_SETSIZE */ register int i; bool_t done = FALSE; register u_long xid; u_long port; struct in_addr addrs[20]; - struct sockaddr_in baddr, raddr; /* broadcast and response addresses */ + struct sockaddr_in baddr, raddr; /* broadcast and response addresses */ struct rmtcallargs a; struct rmtcallres r; struct rpc_msg msg; - struct timeval t; + struct timeval t; char outbuf[MAX_BROADCAST_SIZE], inbuf[UDPMSGSIZE]; /* @@ -272,25 +272,25 @@ clnt_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp, eachresult) goto done_broad; } #ifdef SO_BROADCAST - if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &on, sizeof (on)) < 0) { + if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on)) < 0) { perror("Cannot set socket option SO_BROADCAST"); stat = RPC_CANTSEND; goto done_broad; } -#endif /* def SO_BROADCAST */ +#endif /* def SO_BROADCAST */ #ifdef FD_SETSIZE FD_ZERO(&mask); FD_SET(sock, &mask); #else mask = (1 << sock); -#endif /* def FD_SETSIZE */ +#endif /* def FD_SETSIZE */ nets = getbroadcastnets(addrs, sock, inbuf); - bzero((char *)&baddr, sizeof (baddr)); + bzero((char *) &baddr, sizeof(baddr)); baddr.sin_family = AF_INET; baddr.sin_port = htons(PMAPPORT); baddr.sin_addr.s_addr = htonl(INADDR_ANY); /* baddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY); */ - (void)gettimeofday(&t, (struct timezone *)0); + (void) gettimeofday(&t, (struct timezone *) 0); msg.rm_xid = xid = getpid() ^ t.tv_sec ^ t.tv_usec; t.tv_usec = 0; msg.rm_direction = CALL; @@ -309,11 +309,11 @@ clnt_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp, eachresult) r.xdr_results = xresults; r.results_ptr = resultsp; xdrmem_create(xdrs, outbuf, MAX_BROADCAST_SIZE, XDR_ENCODE); - if ((! xdr_callmsg(xdrs, &msg)) || (! xdr_rmtcall_args(xdrs, &a))) { + if ((!xdr_callmsg(xdrs, &msg)) || (!xdr_rmtcall_args(xdrs, &a))) { stat = RPC_CANTENCODEARGS; goto done_broad; } - outlen = (int)xdr_getpos(xdrs); + outlen = (int) xdr_getpos(xdrs); xdr_destroy(xdrs); /* * Basic loop: broadcast a packet and wait a while for response(s). @@ -323,8 +323,8 @@ clnt_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp, eachresult) for (i = 0; i < nets; i++) { baddr.sin_addr = addrs[i]; if (sendto(sock, outbuf, outlen, 0, - (struct sockaddr *)&baddr, - sizeof (struct sockaddr)) != outlen) { + (struct sockaddr *) &baddr, + sizeof(struct sockaddr)) != outlen) { perror("Cannot send broadcast packet"); stat = RPC_CANTSEND; goto done_broad; @@ -334,30 +334,31 @@ clnt_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp, eachresult) stat = RPC_SUCCESS; goto done_broad; } - recv_again: + recv_again: msg.acpted_rply.ar_verf = _null_auth; - msg.acpted_rply.ar_results.where = (caddr_t)&r; - msg.acpted_rply.ar_results.proc = xdr_rmtcallres; + msg.acpted_rply.ar_results.where = (caddr_t) & r; + msg.acpted_rply.ar_results.proc = xdr_rmtcallres; readfds = mask; - switch (select(_rpc_dtablesize(), &readfds, (int *)NULL, - (int *)NULL, &t)) { + switch (select(_rpc_dtablesize(), &readfds, (int *) NULL, + (int *) NULL, &t)) { - case 0: /* timed out */ + case 0: /* timed out */ stat = RPC_TIMEDOUT; continue; - case -1: /* some kind of error */ + case -1: /* some kind of error */ if (errno == EINTR) goto recv_again; perror("Broadcast select problem"); stat = RPC_CANTRECV; goto done_broad; - } /* end of select results switch */ - try_again: + } /* end of select results switch */ + try_again: fromlen = sizeof(struct sockaddr); + inlen = recvfrom(sock, inbuf, UDPMSGSIZE, 0, - (struct sockaddr *)&raddr, &fromlen); + (struct sockaddr *) &raddr, &fromlen); if (inlen < 0) { if (errno == EINTR) goto try_again; @@ -371,13 +372,13 @@ clnt_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp, eachresult) * see if reply transaction id matches sent id. * If so, decode the results. */ - xdrmem_create(xdrs, inbuf, (u_int)inlen, XDR_DECODE); + xdrmem_create(xdrs, inbuf, (u_int) inlen, XDR_DECODE); if (xdr_replymsg(xdrs, &msg)) { if ((msg.rm_xid == xid) && (msg.rm_reply.rp_stat == MSG_ACCEPTED) && (msg.acpted_rply.ar_stat == SUCCESS)) { - raddr.sin_port = htons((u_short)port); - done = (*eachresult)(resultsp, &raddr); + raddr.sin_port = htons((u_short) port); + done = (*eachresult) (resultsp, &raddr); } /* otherwise, we just ignore the errors ... */ } else { @@ -390,8 +391,8 @@ clnt_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp, eachresult) } xdrs->x_op = XDR_FREE; msg.acpted_rply.ar_results.proc = xdr_void; - (void)xdr_replymsg(xdrs, &msg); - (void)(*xresults)(xdrs, resultsp); + (void) xdr_replymsg(xdrs, &msg); + (void) (*xresults) (xdrs, resultsp); xdr_destroy(xdrs); if (done) { stat = RPC_SUCCESS; @@ -400,9 +401,8 @@ clnt_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp, eachresult) goto recv_again; } } -done_broad: - (void)close(sock); + done_broad: + (void) close(sock); AUTH_DESTROY(unix_auth); return (stat); } - diff --git a/libc/inet/rpc/rpc_callmsg.c b/libc/inet/rpc/rpc_callmsg.c index d9d815a6f..1bd6bb6d6 100644 --- a/libc/inet/rpc/rpc_callmsg.c +++ b/libc/inet/rpc/rpc_callmsg.c @@ -28,7 +28,9 @@ * Mountain View, California 94043 */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)rpc_callmsg.c 1.4 87/08/11 Copyr 1984 Sun Micro"; +static char sccsid[] = + + "@(#)rpc_callmsg.c 1.4 87/08/11 Copyr 1984 Sun Micro"; #endif /* @@ -45,10 +47,9 @@ static char sccsid[] = "@(#)rpc_callmsg.c 1.4 87/08/11 Copyr 1984 Sun Micro"; /* * XDR a call message */ -bool_t -xdr_callmsg(xdrs, cmsg) - register XDR *xdrs; - register struct rpc_msg *cmsg; +bool_t xdr_callmsg(xdrs, cmsg) +register XDR *xdrs; +register struct rpc_msg *cmsg; { register long *buf; register struct opaque_auth *oa; @@ -61,9 +62,9 @@ xdr_callmsg(xdrs, cmsg) return (FALSE); } buf = XDR_INLINE(xdrs, 8 * BYTES_PER_XDR_UNIT - + RNDUP(cmsg->rm_call.cb_cred.oa_length) - + 2 * BYTES_PER_XDR_UNIT - + RNDUP(cmsg->rm_call.cb_verf.oa_length)); + + RNDUP(cmsg->rm_call.cb_cred.oa_length) + + 2 * BYTES_PER_XDR_UNIT + + RNDUP(cmsg->rm_call.cb_verf.oa_length)); if (buf != NULL) { IXDR_PUT_LONG(buf, cmsg->rm_xid); IXDR_PUT_ENUM(buf, cmsg->rm_direction); @@ -81,17 +82,17 @@ xdr_callmsg(xdrs, cmsg) IXDR_PUT_ENUM(buf, oa->oa_flavor); IXDR_PUT_LONG(buf, oa->oa_length); if (oa->oa_length) { - bcopy(oa->oa_base, (caddr_t)buf, oa->oa_length); - buf += RNDUP(oa->oa_length) / sizeof (long); + bcopy(oa->oa_base, (caddr_t) buf, oa->oa_length); + buf += RNDUP(oa->oa_length) / sizeof(long); } oa = &cmsg->rm_call.cb_verf; IXDR_PUT_ENUM(buf, oa->oa_flavor); IXDR_PUT_LONG(buf, oa->oa_length); if (oa->oa_length) { - bcopy(oa->oa_base, (caddr_t)buf, oa->oa_length); + bcopy(oa->oa_base, (caddr_t) buf, oa->oa_length); /* no real need.... - buf += RNDUP(oa->oa_length) / sizeof (long); - */ + buf += RNDUP(oa->oa_length) / sizeof (long); + */ } return (TRUE); } @@ -101,6 +102,7 @@ xdr_callmsg(xdrs, cmsg) if (buf != NULL) { cmsg->rm_xid = IXDR_GET_LONG(buf); cmsg->rm_direction = IXDR_GET_ENUM(buf, enum msg_type); + if (cmsg->rm_direction != CALL) { return (FALSE); } @@ -125,23 +127,22 @@ xdr_callmsg(xdrs, cmsg) buf = XDR_INLINE(xdrs, RNDUP(oa->oa_length)); if (buf == NULL) { if (xdr_opaque(xdrs, oa->oa_base, - oa->oa_length) == FALSE) { + oa->oa_length) == FALSE) { return (FALSE); } } else { - bcopy((caddr_t)buf, oa->oa_base, - oa->oa_length); + bcopy((caddr_t) buf, oa->oa_base, oa->oa_length); /* no real need.... - buf += RNDUP(oa->oa_length) / - sizeof (long); - */ + buf += RNDUP(oa->oa_length) / + sizeof (long); + */ } } oa = &cmsg->rm_call.cb_verf; buf = XDR_INLINE(xdrs, 2 * BYTES_PER_XDR_UNIT); if (buf == NULL) { if (xdr_enum(xdrs, &oa->oa_flavor) == FALSE || - xdr_u_int(xdrs, &oa->oa_length) == FALSE) { + xdr_u_int(xdrs, &oa->oa_length) == FALSE) { return (FALSE); } } else { @@ -159,32 +160,29 @@ xdr_callmsg(xdrs, cmsg) buf = XDR_INLINE(xdrs, RNDUP(oa->oa_length)); if (buf == NULL) { if (xdr_opaque(xdrs, oa->oa_base, - oa->oa_length) == FALSE) { + oa->oa_length) == FALSE) { return (FALSE); } } else { - bcopy((caddr_t)buf, oa->oa_base, - oa->oa_length); + bcopy((caddr_t) buf, oa->oa_base, oa->oa_length); /* no real need... - buf += RNDUP(oa->oa_length) / - sizeof (long); - */ + buf += RNDUP(oa->oa_length) / + sizeof (long); + */ } } return (TRUE); } } - if ( - xdr_u_long(xdrs, &(cmsg->rm_xid)) && - xdr_enum(xdrs, (enum_t *)&(cmsg->rm_direction)) && - (cmsg->rm_direction == CALL) && - xdr_u_long(xdrs, &(cmsg->rm_call.cb_rpcvers)) && - (cmsg->rm_call.cb_rpcvers == RPC_MSG_VERSION) && - xdr_u_long(xdrs, &(cmsg->rm_call.cb_prog)) && - xdr_u_long(xdrs, &(cmsg->rm_call.cb_vers)) && - xdr_u_long(xdrs, &(cmsg->rm_call.cb_proc)) && - xdr_opaque_auth(xdrs, &(cmsg->rm_call.cb_cred)) ) - return (xdr_opaque_auth(xdrs, &(cmsg->rm_call.cb_verf))); + if (xdr_u_long(xdrs, &(cmsg->rm_xid)) && + xdr_enum(xdrs, (enum_t *) & (cmsg->rm_direction)) && + (cmsg->rm_direction == CALL) && + xdr_u_long(xdrs, &(cmsg->rm_call.cb_rpcvers)) && + (cmsg->rm_call.cb_rpcvers == RPC_MSG_VERSION) && + xdr_u_long(xdrs, &(cmsg->rm_call.cb_prog)) && + xdr_u_long(xdrs, &(cmsg->rm_call.cb_vers)) && + xdr_u_long(xdrs, &(cmsg->rm_call.cb_proc)) && + xdr_opaque_auth(xdrs, &(cmsg->rm_call.cb_cred))) + return (xdr_opaque_auth(xdrs, &(cmsg->rm_call.cb_verf))); return (FALSE); } - diff --git a/libc/inet/rpc/rpc_commondata.c b/libc/inet/rpc/rpc_commondata.c index 75cead087..39648d284 100644 --- a/libc/inet/rpc/rpc_commondata.c +++ b/libc/inet/rpc/rpc_commondata.c @@ -33,9 +33,10 @@ * by public interfaces */ struct opaque_auth _null_auth; + #ifdef FD_SETSIZE fd_set svc_fdset; #else int svc_fds; -#endif /* def FD_SETSIZE */ +#endif /* def FD_SETSIZE */ struct rpc_createerr rpc_createerr; diff --git a/libc/inet/rpc/rpc_dtablesize.c b/libc/inet/rpc/rpc_dtablesize.c index a8488172e..960bb4699 100644 --- a/libc/inet/rpc/rpc_dtablesize.c +++ b/libc/inet/rpc/rpc_dtablesize.c @@ -28,7 +28,9 @@ * Mountain View, California 94043 */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)rpc_dtablesize.c 1.2 87/08/11 Copyr 1987 Sun Micro"; +static char sccsid[] = + + "@(#)rpc_dtablesize.c 1.2 87/08/11 Copyr 1987 Sun Micro"; #endif /* @@ -38,7 +40,7 @@ static char sccsid[] = "@(#)rpc_dtablesize.c 1.2 87/08/11 Copyr 1987 Sun Micro"; _rpc_dtablesize() { static int size; - + if (size == 0) { size = getdtablesize(); } diff --git a/libc/inet/rpc/rpc_prot.c b/libc/inet/rpc/rpc_prot.c index 4b1319ad5..e3c873b44 100644 --- a/libc/inet/rpc/rpc_prot.c +++ b/libc/inet/rpc/rpc_prot.c @@ -56,27 +56,25 @@ struct opaque_auth _null_auth; * XDR an opaque authentication struct * (see auth.h) */ -bool_t -xdr_opaque_auth(xdrs, ap) - register XDR *xdrs; - register struct opaque_auth *ap; +bool_t xdr_opaque_auth(xdrs, ap) +register XDR *xdrs; +register struct opaque_auth *ap; { if (xdr_enum(xdrs, &(ap->oa_flavor))) return (xdr_bytes(xdrs, &ap->oa_base, - &ap->oa_length, MAX_AUTH_BYTES)); + &ap->oa_length, MAX_AUTH_BYTES)); return (FALSE); } /* * XDR a DES block */ -bool_t -xdr_des_block(xdrs, blkp) - register XDR *xdrs; - register des_block *blkp; +bool_t xdr_des_block(xdrs, blkp) +register XDR *xdrs; +register des_block *blkp; { - return (xdr_opaque(xdrs, (caddr_t)blkp, sizeof(des_block))); + return (xdr_opaque(xdrs, (caddr_t) blkp, sizeof(des_block))); } /* * * * * * * * * * * * * * XDR RPC MESSAGE * * * * * * * * * * * * * * * */ @@ -84,74 +82,72 @@ xdr_des_block(xdrs, blkp) /* * XDR the MSG_ACCEPTED part of a reply message union */ -bool_t -xdr_accepted_reply(xdrs, ar) - register XDR *xdrs; - register struct accepted_reply *ar; +bool_t xdr_accepted_reply(xdrs, ar) +register XDR *xdrs; +register struct accepted_reply *ar; { /* personalized union, rather than calling xdr_union */ - if (! xdr_opaque_auth(xdrs, &(ar->ar_verf))) + if (!xdr_opaque_auth(xdrs, &(ar->ar_verf))) return (FALSE); - if (! xdr_enum(xdrs, (enum_t *)&(ar->ar_stat))) + if (!xdr_enum(xdrs, (enum_t *) & (ar->ar_stat))) return (FALSE); switch (ar->ar_stat) { case SUCCESS: - return ((*(ar->ar_results.proc))(xdrs, ar->ar_results.where)); + return ((*(ar->ar_results.proc)) (xdrs, ar->ar_results.where)); case PROG_MISMATCH: - if (! xdr_u_long(xdrs, &(ar->ar_vers.low))) + if (!xdr_u_long(xdrs, &(ar->ar_vers.low))) return (FALSE); return (xdr_u_long(xdrs, &(ar->ar_vers.high))); } - return (TRUE); /* TRUE => open ended set of problems */ + return (TRUE); /* TRUE => open ended set of problems */ } /* * XDR the MSG_DENIED part of a reply message union */ -bool_t -xdr_rejected_reply(xdrs, rr) - register XDR *xdrs; - register struct rejected_reply *rr; +bool_t xdr_rejected_reply(xdrs, rr) +register XDR *xdrs; +register struct rejected_reply *rr; { /* personalized union, rather than calling xdr_union */ - if (! xdr_enum(xdrs, (enum_t *)&(rr->rj_stat))) + if (!xdr_enum(xdrs, (enum_t *) & (rr->rj_stat))) return (FALSE); switch (rr->rj_stat) { case RPC_MISMATCH: - if (! xdr_u_long(xdrs, &(rr->rj_vers.low))) + if (!xdr_u_long(xdrs, &(rr->rj_vers.low))) return (FALSE); return (xdr_u_long(xdrs, &(rr->rj_vers.high))); case AUTH_ERROR: - return (xdr_enum(xdrs, (enum_t *)&(rr->rj_why))); + return (xdr_enum(xdrs, (enum_t *) & (rr->rj_why))); } return (FALSE); } static struct xdr_discrim reply_dscrm[3] = { - { (int)MSG_ACCEPTED, xdr_accepted_reply }, - { (int)MSG_DENIED, xdr_rejected_reply }, - { __dontcare__, NULL_xdrproc_t } }; + {(int) MSG_ACCEPTED, xdr_accepted_reply}, + {(int) MSG_DENIED, xdr_rejected_reply}, + {__dontcare__, NULL_xdrproc_t} +}; /* * XDR a reply message */ -bool_t -xdr_replymsg(xdrs, rmsg) - register XDR *xdrs; - register struct rpc_msg *rmsg; +bool_t xdr_replymsg(xdrs, rmsg) +register XDR *xdrs; +register struct rpc_msg *rmsg; { - if ( - xdr_u_long(xdrs, &(rmsg->rm_xid)) && - xdr_enum(xdrs, (enum_t *)&(rmsg->rm_direction)) && - (rmsg->rm_direction == REPLY) ) - return (xdr_union(xdrs, (enum_t *)&(rmsg->rm_reply.rp_stat), - (caddr_t)&(rmsg->rm_reply.ru), reply_dscrm, NULL_xdrproc_t)); + if (xdr_u_long(xdrs, &(rmsg->rm_xid)) && + xdr_enum(xdrs, (enum_t *) & (rmsg->rm_direction)) && + (rmsg->rm_direction == REPLY)) + return (xdr_union(xdrs, (enum_t *) & (rmsg->rm_reply.rp_stat), + (caddr_t) & (rmsg->rm_reply.ru), reply_dscrm, + NULL_xdrproc_t)); return (FALSE); } @@ -161,30 +157,28 @@ xdr_replymsg(xdrs, rmsg) * The fields include: rm_xid, rm_direction, rpcvers, prog, and vers. * The rm_xid is not really static, but the user can easily munge on the fly. */ -bool_t -xdr_callhdr(xdrs, cmsg) - register XDR *xdrs; - register struct rpc_msg *cmsg; +bool_t xdr_callhdr(xdrs, cmsg) +register XDR *xdrs; +register struct rpc_msg *cmsg; { cmsg->rm_direction = CALL; cmsg->rm_call.cb_rpcvers = RPC_MSG_VERSION; if ( - (xdrs->x_op == XDR_ENCODE) && - xdr_u_long(xdrs, &(cmsg->rm_xid)) && - xdr_enum(xdrs, (enum_t *)&(cmsg->rm_direction)) && - xdr_u_long(xdrs, &(cmsg->rm_call.cb_rpcvers)) && - xdr_u_long(xdrs, &(cmsg->rm_call.cb_prog)) ) - return (xdr_u_long(xdrs, &(cmsg->rm_call.cb_vers))); + (xdrs->x_op == XDR_ENCODE) && + xdr_u_long(xdrs, &(cmsg->rm_xid)) && + xdr_enum(xdrs, (enum_t *) & (cmsg->rm_direction)) && + xdr_u_long(xdrs, &(cmsg->rm_call.cb_rpcvers)) && + xdr_u_long(xdrs, &(cmsg->rm_call.cb_prog))) + return (xdr_u_long(xdrs, &(cmsg->rm_call.cb_vers))); return (FALSE); } /* ************************** Client utility routine ************* */ -static void -accepted(acpt_stat, error) - register enum accept_stat acpt_stat; - register struct rpc_err *error; +static void accepted(acpt_stat, error) +register enum accept_stat acpt_stat; +register struct rpc_err *error; { switch (acpt_stat) { @@ -215,14 +209,13 @@ accepted(acpt_stat, error) } /* something's wrong, but we don't know what ... */ error->re_status = RPC_FAILED; - error->re_lb.s1 = (long)MSG_ACCEPTED; - error->re_lb.s2 = (long)acpt_stat; + error->re_lb.s1 = (long) MSG_ACCEPTED; + error->re_lb.s2 = (long) acpt_stat; } -static void -rejected(rjct_stat, error) - register enum reject_stat rjct_stat; - register struct rpc_err *error; +static void rejected(rjct_stat, error) +register enum reject_stat rjct_stat; +register struct rpc_err *error; { switch (rjct_stat) { @@ -237,17 +230,16 @@ rejected(rjct_stat, error) } /* something's wrong, but we don't know what ... */ error->re_status = RPC_FAILED; - error->re_lb.s1 = (long)MSG_DENIED; - error->re_lb.s2 = (long)rjct_stat; + error->re_lb.s1 = (long) MSG_DENIED; + error->re_lb.s2 = (long) rjct_stat; } /* * given a reply message, fills in the error */ -void -_seterr_reply(msg, error) - register struct rpc_msg *msg; - register struct rpc_err *error; +void _seterr_reply(msg, error) +register struct rpc_msg *msg; +register struct rpc_err *error; { /* optimized for normal, SUCCESSful case */ @@ -267,7 +259,7 @@ _seterr_reply(msg, error) default: error->re_status = RPC_FAILED; - error->re_lb.s1 = (long)(msg->rm_reply.rp_stat); + error->re_lb.s1 = (long) (msg->rm_reply.rp_stat); break; } switch (error->re_status) { diff --git a/libc/inet/rpc/svc.c b/libc/inet/rpc/svc.c index 9d0092d8a..1ba12efd5 100644 --- a/libc/inet/rpc/svc.c +++ b/libc/inet/rpc/svc.c @@ -56,10 +56,10 @@ static SVCXPRT **xports; #define NOFILE 32 static SVCXPRT *xports[NOFILE]; -#endif /* def FD_SETSIZE */ +#endif /* def FD_SETSIZE */ #define NULL_SVC ((struct svc_callout *)0) -#define RQCRED_SIZE 400 /* this size is excessive */ +#define RQCRED_SIZE 400 /* this size is excessive */ /* * The services list @@ -69,9 +69,9 @@ static SVCXPRT *xports[NOFILE]; */ static struct svc_callout { struct svc_callout *sc_next; - u_long sc_prog; - u_long sc_vers; - void (*sc_dispatch)(); + u_long sc_prog; + u_long sc_vers; + void (*sc_dispatch) (); } *svc_head; static struct svc_callout *svc_find(); @@ -81,9 +81,8 @@ static struct svc_callout *svc_find(); /* * Activate a transport handle. */ -void -xprt_register(xprt) - SVCXPRT *xprt; +void xprt_register(xprt) +SVCXPRT *xprt; { register int sock = xprt->xp_sock; @@ -101,30 +100,29 @@ xprt_register(xprt) xports[sock] = xprt; svc_fds |= (1 << sock); } -#endif /* def FD_SETSIZE */ +#endif /* def FD_SETSIZE */ } /* * De-activate a transport handle. */ -void -xprt_unregister(xprt) - SVCXPRT *xprt; -{ +void xprt_unregister(xprt) +SVCXPRT *xprt; +{ register int sock = xprt->xp_sock; #ifdef FD_SETSIZE if ((sock < _rpc_dtablesize()) && (xports[sock] == xprt)) { - xports[sock] = (SVCXPRT *)0; + xports[sock] = (SVCXPRT *) 0; FD_CLR(sock, &svc_fdset); } #else if ((sock < NOFILE) && (xports[sock] == xprt)) { - xports[sock] = (SVCXPRT *)0; + xports[sock] = (SVCXPRT *) 0; svc_fds &= ~(1 << sock); } -#endif /* def FD_SETSIZE */ +#endif /* def FD_SETSIZE */ } @@ -135,24 +133,24 @@ xprt_unregister(xprt) * The dispatch routine will be called when a rpc request for this * program number comes in. */ -bool_t -svc_register(xprt, prog, vers, dispatch, protocol) - SVCXPRT *xprt; - u_long prog; - u_long vers; - void (*dispatch)(); - int protocol; +bool_t svc_register(xprt, prog, vers, dispatch, protocol) +SVCXPRT *xprt; +u_long prog; +u_long vers; +void (*dispatch) (); +int protocol; { struct svc_callout *prev; register struct svc_callout *s; if ((s = svc_find(prog, vers, &prev)) != NULL_SVC) { if (s->sc_dispatch == dispatch) - goto pmap_it; /* he is registering another xptr */ + goto pmap_it; /* he is registering another xptr */ return (FALSE); } - s = (struct svc_callout *)mem_alloc(sizeof(struct svc_callout)); - if (s == (struct svc_callout *)0) { + s = (struct svc_callout *) mem_alloc(sizeof(struct svc_callout)); + + if (s == (struct svc_callout *) 0) { return (FALSE); } s->sc_prog = prog; @@ -160,7 +158,7 @@ svc_register(xprt, prog, vers, dispatch, protocol) s->sc_dispatch = dispatch; s->sc_next = svc_head; svc_head = s; -pmap_it: + pmap_it: /* now register the information with the local binder service */ if (protocol) { return (pmap_set(prog, vers, protocol, xprt->xp_port)); @@ -171,10 +169,9 @@ pmap_it: /* * Remove a service program from the callout list. */ -void -svc_unregister(prog, vers) - u_long prog; - u_long vers; +void svc_unregister(prog, vers) +u_long prog; +u_long vers; { struct svc_callout *prev; register struct svc_callout *s; @@ -188,19 +185,19 @@ svc_unregister(prog, vers) } s->sc_next = NULL_SVC; mem_free((char *) s, (u_int) sizeof(struct svc_callout)); + /* now unregister the information with the local binder service */ - (void)pmap_unset(prog, vers); + (void) pmap_unset(prog, vers); } /* * Search the callout list for a program number, return the callout * struct. */ -static struct svc_callout * -svc_find(prog, vers, prev) - u_long prog; - u_long vers; - struct svc_callout **prev; +static struct svc_callout *svc_find(prog, vers, prev) +u_long prog; +u_long vers; +struct svc_callout **prev; { register struct svc_callout *s, *p; @@ -210,7 +207,7 @@ svc_find(prog, vers, prev) goto done; p = s; } -done: + done: *prev = p; return (s); } @@ -220,29 +217,27 @@ done: /* * Send a reply to an rpc request */ -bool_t -svc_sendreply(xprt, xdr_results, xdr_location) - register SVCXPRT *xprt; - xdrproc_t xdr_results; - caddr_t xdr_location; +bool_t svc_sendreply(xprt, xdr_results, xdr_location) +register SVCXPRT *xprt; +xdrproc_t xdr_results; +caddr_t xdr_location; { - struct rpc_msg rply; + struct rpc_msg rply; - rply.rm_direction = REPLY; - rply.rm_reply.rp_stat = MSG_ACCEPTED; - rply.acpted_rply.ar_verf = xprt->xp_verf; + rply.rm_direction = REPLY; + rply.rm_reply.rp_stat = MSG_ACCEPTED; + rply.acpted_rply.ar_verf = xprt->xp_verf; rply.acpted_rply.ar_stat = SUCCESS; rply.acpted_rply.ar_results.where = xdr_location; rply.acpted_rply.ar_results.proc = xdr_results; - return (SVC_REPLY(xprt, &rply)); + return (SVC_REPLY(xprt, &rply)); } /* * No procedure error reply */ -void -svcerr_noproc(xprt) - register SVCXPRT *xprt; +void svcerr_noproc(xprt) +register SVCXPRT *xprt; { struct rpc_msg rply; @@ -256,42 +251,39 @@ svcerr_noproc(xprt) /* * Can't decode args error reply */ -void -svcerr_decode(xprt) - register SVCXPRT *xprt; +void svcerr_decode(xprt) +register SVCXPRT *xprt; { - struct rpc_msg rply; + struct rpc_msg rply; - rply.rm_direction = REPLY; - rply.rm_reply.rp_stat = MSG_ACCEPTED; + rply.rm_direction = REPLY; + rply.rm_reply.rp_stat = MSG_ACCEPTED; rply.acpted_rply.ar_verf = xprt->xp_verf; rply.acpted_rply.ar_stat = GARBAGE_ARGS; - SVC_REPLY(xprt, &rply); + SVC_REPLY(xprt, &rply); } /* * Some system error */ -void -svcerr_systemerr(xprt) - register SVCXPRT *xprt; +void svcerr_systemerr(xprt) +register SVCXPRT *xprt; { - struct rpc_msg rply; + struct rpc_msg rply; - rply.rm_direction = REPLY; - rply.rm_reply.rp_stat = MSG_ACCEPTED; + rply.rm_direction = REPLY; + rply.rm_reply.rp_stat = MSG_ACCEPTED; rply.acpted_rply.ar_verf = xprt->xp_verf; rply.acpted_rply.ar_stat = SYSTEM_ERR; - SVC_REPLY(xprt, &rply); + SVC_REPLY(xprt, &rply); } /* * Authentication error reply */ -void -svcerr_auth(xprt, why) - SVCXPRT *xprt; - enum auth_stat why; +void svcerr_auth(xprt, why) +SVCXPRT *xprt; +enum auth_stat why; { struct rpc_msg rply; @@ -305,9 +297,8 @@ svcerr_auth(xprt, why) /* * Auth too weak error reply */ -void -svcerr_weakauth(xprt) - SVCXPRT *xprt; +void svcerr_weakauth(xprt) +SVCXPRT *xprt; { svcerr_auth(xprt, AUTH_TOOWEAK); @@ -316,15 +307,14 @@ svcerr_weakauth(xprt) /* * Program unavailable error reply */ -void -svcerr_noprog(xprt) - register SVCXPRT *xprt; +void svcerr_noprog(xprt) +register SVCXPRT *xprt; { - struct rpc_msg rply; + struct rpc_msg rply; - rply.rm_direction = REPLY; - rply.rm_reply.rp_stat = MSG_ACCEPTED; - rply.acpted_rply.ar_verf = xprt->xp_verf; + rply.rm_direction = REPLY; + rply.rm_reply.rp_stat = MSG_ACCEPTED; + rply.acpted_rply.ar_verf = xprt->xp_verf; rply.acpted_rply.ar_stat = PROG_UNAVAIL; SVC_REPLY(xprt, &rply); } @@ -332,11 +322,10 @@ svcerr_noprog(xprt) /* * Program version mismatch error reply */ -void -svcerr_progvers(xprt, low_vers, high_vers) - register SVCXPRT *xprt; - u_long low_vers; - u_long high_vers; +void svcerr_progvers(xprt, low_vers, high_vers) +register SVCXPRT *xprt; +u_long low_vers; +u_long high_vers; { struct rpc_msg rply; @@ -367,9 +356,8 @@ svcerr_progvers(xprt, low_vers, high_vers) * is mallocated in kernel land. */ -void -svc_getreq(rdfds) - int rdfds; +void svc_getreq(rdfds) +int rdfds; { #ifdef FD_SETSIZE fd_set readfds; @@ -386,19 +374,18 @@ svc_getreq(rdfds) int readfds = rdfds & svc_fds; svc_getreqset(&readfds); -#endif /* def FD_SETSIZE */ +#endif /* def FD_SETSIZE */ } -void -svc_getreqset(readfds) +void svc_getreqset(readfds) #ifdef FD_SETSIZE - fd_set *readfds; +fd_set *readfds; { #else - int *readfds; +int *readfds; { - int readfds_local = *readfds; -#endif /* def FD_SETSIZE */ + int readfds_local = *readfds; +#endif /* def FD_SETSIZE */ enum xprt_stat stat; struct rpc_msg msg; int prog_found; @@ -411,82 +398,82 @@ svc_getreqset(readfds) register u_long *maskp; register int setsize; register int sock; - char cred_area[2*MAX_AUTH_BYTES + RQCRED_SIZE]; + char cred_area[2 * MAX_AUTH_BYTES + RQCRED_SIZE]; + msg.rm_call.cb_cred.oa_base = cred_area; msg.rm_call.cb_verf.oa_base = &(cred_area[MAX_AUTH_BYTES]); - r.rq_clntcred = &(cred_area[2*MAX_AUTH_BYTES]); + r.rq_clntcred = &(cred_area[2 * MAX_AUTH_BYTES]); #ifdef FD_SETSIZE - setsize = _rpc_dtablesize(); + setsize = _rpc_dtablesize(); #ifdef __linux__ /*#define NFDBITS 32*/ - maskp = (u_long *)readfds; + maskp = (u_long *) readfds; #else - maskp = (u_long *)readfds->fds_bits; + maskp = (u_long *) readfds->fds_bits; #endif for (sock = 0; sock < setsize; sock += NFDBITS) { - for (mask = *maskp++; bit = ffs(mask); mask ^= (1 << (bit - 1))) { - /* sock has input waiting */ - xprt = xports[sock + bit - 1]; + for (mask = *maskp++; bit = ffs(mask); mask ^= (1 << (bit - 1))) { + /* sock has input waiting */ + xprt = xports[sock + bit - 1]; #else for (sock = 0; readfds_local != 0; sock++, readfds_local >>= 1) { - if ((readfds_local & 1) != 0) { - /* sock has input waiting */ - xprt = xports[sock]; -#endif /* def FD_SETSIZE */ - /* now receive msgs from xprtprt (support batch calls) */ - do { - if (SVC_RECV(xprt, &msg)) { - - /* now find the exported program and call it */ - register struct svc_callout *s; - enum auth_stat why; - - r.rq_xprt = xprt; - r.rq_prog = msg.rm_call.cb_prog; - r.rq_vers = msg.rm_call.cb_vers; - r.rq_proc = msg.rm_call.cb_proc; - r.rq_cred = msg.rm_call.cb_cred; - /* first authenticate the message */ - if ((why= _authenticate(&r, &msg)) != AUTH_OK) { - svcerr_auth(xprt, why); - goto call_done; + if ((readfds_local & 1) != 0) { + /* sock has input waiting */ + xprt = xports[sock]; +#endif /* def FD_SETSIZE */ + /* now receive msgs from xprtprt (support batch calls) */ + do { + if (SVC_RECV(xprt, &msg)) { + + /* now find the exported program and call it */ + register struct svc_callout *s; + enum auth_stat why; + + r.rq_xprt = xprt; + r.rq_prog = msg.rm_call.cb_prog; + r.rq_vers = msg.rm_call.cb_vers; + r.rq_proc = msg.rm_call.cb_proc; + r.rq_cred = msg.rm_call.cb_cred; + /* first authenticate the message */ + if ((why = _authenticate(&r, &msg)) != AUTH_OK) { + svcerr_auth(xprt, why); + goto call_done; + } + /* now match message with a registered service */ + prog_found = FALSE; + low_vers = 0 - 1; + high_vers = 0; + for (s = svc_head; s != NULL_SVC; s = s->sc_next) { + if (s->sc_prog == r.rq_prog) { + if (s->sc_vers == r.rq_vers) { + (*s->sc_dispatch) (&r, xprt); + goto call_done; + } /* found correct version */ + prog_found = TRUE; + if (s->sc_vers < low_vers) + low_vers = s->sc_vers; + if (s->sc_vers > high_vers) + high_vers = s->sc_vers; + } /* found correct program */ + } + /* + * if we got here, the program or version + * is not served ... + */ + if (prog_found) + svcerr_progvers(xprt, low_vers, high_vers); + else + svcerr_noprog(xprt); + /* Fall through to ... */ } - /* now match message with a registered service*/ - prog_found = FALSE; - low_vers = 0 - 1; - high_vers = 0; - for (s = svc_head; s != NULL_SVC; s = s->sc_next) { - if (s->sc_prog == r.rq_prog) { - if (s->sc_vers == r.rq_vers) { - (*s->sc_dispatch)(&r, xprt); - goto call_done; - } /* found correct version */ - prog_found = TRUE; - if (s->sc_vers < low_vers) - low_vers = s->sc_vers; - if (s->sc_vers > high_vers) - high_vers = s->sc_vers; - } /* found correct program */ + call_done: + if ((stat = SVC_STAT(xprt)) == XPRT_DIED) { + SVC_DESTROY(xprt); + break; } - /* - * if we got here, the program or version - * is not served ... - */ - if (prog_found) - svcerr_progvers(xprt, - low_vers, high_vers); - else - svcerr_noprog(xprt); - /* Fall through to ... */ - } - call_done: - if ((stat = SVC_STAT(xprt)) == XPRT_DIED){ - SVC_DESTROY(xprt); - break; - } - } while (stat == XPRT_MOREREQS); - } + } while (stat == XPRT_MOREREQS); + } } } diff --git a/libc/inet/rpc/svc_auth.c b/libc/inet/rpc/svc_auth.c index ab7ab6942..60e4fa74b 100644 --- a/libc/inet/rpc/svc_auth.c +++ b/libc/inet/rpc/svc_auth.c @@ -1,5 +1,7 @@ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)svc_auth.c 2.1 88/08/07 4.0 RPCSRC; from 1.19 87/08/11 Copyr 1984 Sun Micro"; +static char sccsid[] = + + "@(#)svc_auth.c 2.1 88/08/07 4.0 RPCSRC; from 1.19 87/08/11 Copyr 1984 Sun Micro"; #endif /* * Sun RPC is a product of Sun Microsystems, Inc. and is provided for @@ -54,18 +56,19 @@ static char sccsid[] = "@(#)svc_auth.c 2.1 88/08/07 4.0 RPCSRC; from 1.19 87/08/ * */ -enum auth_stat _svcauth_null(); /* no authentication */ -enum auth_stat _svcauth_unix(); /* unix style (uid, gids) */ +enum auth_stat _svcauth_null(); /* no authentication */ +enum auth_stat _svcauth_unix(); /* unix style (uid, gids) */ enum auth_stat _svcauth_short(); /* short hand unix style */ static struct { - enum auth_stat (*authenticator)(); + enum auth_stat (*authenticator) (); } svcauthsw[] = { - _svcauth_null, /* AUTH_NULL */ - _svcauth_unix, /* AUTH_UNIX */ - _svcauth_short, /* AUTH_SHORT */ + _svcauth_null, /* AUTH_NULL */ + _svcauth_unix, /* AUTH_UNIX */ + _svcauth_short, /* AUTH_SHORT */ }; -#define AUTH_MAX 2 /* HIGHEST AUTH NUMBER */ + +#define AUTH_MAX 2 /* HIGHEST AUTH NUMBER */ /* @@ -86,10 +89,9 @@ static struct { * There is an assumption that any flavour less than AUTH_NULL is * invalid. */ -enum auth_stat -_authenticate(rqst, msg) - register struct svc_req *rqst; - struct rpc_msg *msg; +enum auth_stat _authenticate(rqst, msg) +register struct svc_req *rqst; +struct rpc_msg *msg; { register int cred_flavor; @@ -98,16 +100,15 @@ _authenticate(rqst, msg) rqst->rq_xprt->xp_verf.oa_length = 0; cred_flavor = rqst->rq_cred.oa_flavor; if ((cred_flavor <= AUTH_MAX) && (cred_flavor >= AUTH_NULL)) { - return ((*(svcauthsw[cred_flavor].authenticator))(rqst, msg)); + return ((*(svcauthsw[cred_flavor].authenticator)) (rqst, msg)); } return (AUTH_REJECTEDCRED); } -enum auth_stat -_svcauth_null(/*rqst, msg*/) +enum auth_stat _svcauth_null( /*rqst, msg */ ) /*struct svc_req *rqst; - struct rpc_msg *msg;*/ + struct rpc_msg *msg; */ { return (AUTH_OK); diff --git a/libc/inet/rpc/svc_auth_unix.c b/libc/inet/rpc/svc_auth_unix.c index ea00b7895..212f9cb3a 100644 --- a/libc/inet/rpc/svc_auth_unix.c +++ b/libc/inet/rpc/svc_auth_unix.c @@ -28,7 +28,9 @@ * Mountain View, California 94043 */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)svc_auth_unix.c 1.28 88/02/08 Copyr 1984 Sun Micro"; +static char sccsid[] = + + "@(#)svc_auth_unix.c 1.28 88/02/08 Copyr 1984 Sun Micro"; #endif /* @@ -48,10 +50,9 @@ static char sccsid[] = "@(#)svc_auth_unix.c 1.28 88/02/08 Copyr 1984 Sun Micro"; /* * Unix longhand authenticator */ -enum auth_stat -_svcauth_unix(rqst, msg) - register struct svc_req *rqst; - register struct rpc_msg *msg; +enum auth_stat _svcauth_unix(rqst, msg) +register struct svc_req *rqst; +register struct rpc_msg *msg; { register enum auth_stat stat; XDR xdrs; @@ -59,7 +60,7 @@ _svcauth_unix(rqst, msg) register long *buf; struct area { struct authunix_parms area_aup; - char area_machname[MAX_MACHINE_NAME+1]; + char area_machname[MAX_MACHINE_NAME + 1]; int area_gids[NGRPS]; } *area; u_int auth_len; @@ -70,8 +71,9 @@ _svcauth_unix(rqst, msg) aup = &area->area_aup; aup->aup_machname = area->area_machname; aup->aup_gids = area->area_gids; - auth_len = (u_int)msg->rm_call.cb_cred.oa_length; - xdrmem_create(&xdrs, msg->rm_call.cb_cred.oa_base, auth_len,XDR_DECODE); + auth_len = (u_int) msg->rm_call.cb_cred.oa_length; + xdrmem_create(&xdrs, msg->rm_call.cb_cred.oa_base, auth_len, + XDR_DECODE); buf = XDR_INLINE(&xdrs, auth_len); if (buf != NULL) { aup->aup_time = IXDR_GET_LONG(buf); @@ -80,10 +82,11 @@ _svcauth_unix(rqst, msg) stat = AUTH_BADCRED; goto done; } - bcopy((caddr_t)buf, aup->aup_machname, (u_int)str_len); + bcopy((caddr_t) buf, aup->aup_machname, (u_int) str_len); aup->aup_machname[str_len] = 0; str_len = RNDUP(str_len); - buf += str_len / sizeof (long); + buf += str_len / sizeof(long); + aup->aup_uid = IXDR_GET_LONG(buf); aup->aup_gid = IXDR_GET_LONG(buf); gid_len = IXDR_GET_U_LONG(buf); @@ -101,20 +104,20 @@ _svcauth_unix(rqst, msg) */ if ((5 + gid_len) * BYTES_PER_XDR_UNIT + str_len > auth_len) { (void) printf("bad auth_len gid %d str %d auth %d\n", - gid_len, str_len, auth_len); + gid_len, str_len, auth_len); stat = AUTH_BADCRED; goto done; } - } else if (! xdr_authunix_parms(&xdrs, aup)) { + } else if (!xdr_authunix_parms(&xdrs, aup)) { xdrs.x_op = XDR_FREE; - (void)xdr_authunix_parms(&xdrs, aup); + (void) xdr_authunix_parms(&xdrs, aup); stat = AUTH_BADCRED; goto done; } rqst->rq_xprt->xp_verf.oa_flavor = AUTH_NULL; rqst->rq_xprt->xp_verf.oa_length = 0; stat = AUTH_OK; -done: + done: XDR_DESTROY(&xdrs); return (stat); } @@ -124,11 +127,9 @@ done: * Shorthand unix authenticator * Looks up longhand in a cache. */ -/*ARGSUSED*/ -enum auth_stat -_svcauth_short(rqst, msg) - struct svc_req *rqst; - struct rpc_msg *msg; + /*ARGSUSED*/ enum auth_stat _svcauth_short(rqst, msg) +struct svc_req *rqst; +struct rpc_msg *msg; { return (AUTH_REJECTEDCRED); } diff --git a/libc/inet/rpc/svc_raw.c b/libc/inet/rpc/svc_raw.c index 1170ecec8..c13ea5e06 100644 --- a/libc/inet/rpc/svc_raw.c +++ b/libc/inet/rpc/svc_raw.c @@ -47,18 +47,18 @@ static char sccsid[] = "@(#)svc_raw.c 1.15 87/08/11 Copyr 1984 Sun Micro"; * This is the "network" that we will be moving data over */ static struct svcraw_private { - char _raw_buf[UDPMSGSIZE]; - SVCXPRT server; - XDR xdr_stream; - char verf_body[MAX_AUTH_BYTES]; + char _raw_buf[UDPMSGSIZE]; + SVCXPRT server; + XDR xdr_stream; + char verf_body[MAX_AUTH_BYTES]; } *svcraw_private; -static bool_t svcraw_recv(); -static enum xprt_stat svcraw_stat(); -static bool_t svcraw_getargs(); -static bool_t svcraw_reply(); -static bool_t svcraw_freeargs(); -static void svcraw_destroy(); +static bool_t svcraw_recv(); +static enum xprt_stat svcraw_stat(); +static bool_t svcraw_getargs(); +static bool_t svcraw_reply(); +static bool_t svcraw_freeargs(); +static void svcraw_destroy(); static struct xp_ops server_ops = { svcraw_recv, @@ -69,13 +69,12 @@ static struct xp_ops server_ops = { svcraw_destroy }; -SVCXPRT * -svcraw_create() +SVCXPRT *svcraw_create() { register struct svcraw_private *srp = svcraw_private; if (srp == 0) { - srp = (struct svcraw_private *)calloc(1, sizeof (*srp)); + srp = (struct svcraw_private *) calloc(1, sizeof(*srp)); if (srp == 0) return (0); } @@ -87,17 +86,15 @@ svcraw_create() return (&srp->server); } -static enum xprt_stat -svcraw_stat() +static enum xprt_stat svcraw_stat() { return (XPRT_IDLE); } -static bool_t -svcraw_recv(xprt, msg) - SVCXPRT *xprt; - struct rpc_msg *msg; +static bool_t svcraw_recv(xprt, msg) +SVCXPRT *xprt; +struct rpc_msg *msg; { register struct svcraw_private *srp = svcraw_private; register XDR *xdrs; @@ -107,15 +104,14 @@ svcraw_recv(xprt, msg) xdrs = &srp->xdr_stream; xdrs->x_op = XDR_DECODE; XDR_SETPOS(xdrs, 0); - if (! xdr_callmsg(xdrs, msg)) - return (FALSE); + if (!xdr_callmsg(xdrs, msg)) + return (FALSE); return (TRUE); } -static bool_t -svcraw_reply(xprt, msg) - SVCXPRT *xprt; - struct rpc_msg *msg; +static bool_t svcraw_reply(xprt, msg) +SVCXPRT *xprt; +struct rpc_msg *msg; { register struct svcraw_private *srp = svcraw_private; register XDR *xdrs; @@ -125,31 +121,29 @@ svcraw_reply(xprt, msg) xdrs = &srp->xdr_stream; xdrs->x_op = XDR_ENCODE; XDR_SETPOS(xdrs, 0); - if (! xdr_replymsg(xdrs, msg)) - return (FALSE); - (void)XDR_GETPOS(xdrs); /* called just for overhead */ + if (!xdr_replymsg(xdrs, msg)) + return (FALSE); + (void) XDR_GETPOS(xdrs); /* called just for overhead */ return (TRUE); } -static bool_t -svcraw_getargs(xprt, xdr_args, args_ptr) - SVCXPRT *xprt; - xdrproc_t xdr_args; - caddr_t args_ptr; +static bool_t svcraw_getargs(xprt, xdr_args, args_ptr) +SVCXPRT *xprt; +xdrproc_t xdr_args; +caddr_t args_ptr; { register struct svcraw_private *srp = svcraw_private; if (srp == 0) return (FALSE); - return ((*xdr_args)(&srp->xdr_stream, args_ptr)); + return ((*xdr_args) (&srp->xdr_stream, args_ptr)); } -static bool_t -svcraw_freeargs(xprt, xdr_args, args_ptr) - SVCXPRT *xprt; - xdrproc_t xdr_args; - caddr_t args_ptr; -{ +static bool_t svcraw_freeargs(xprt, xdr_args, args_ptr) +SVCXPRT *xprt; +xdrproc_t xdr_args; +caddr_t args_ptr; +{ register struct svcraw_private *srp = svcraw_private; register XDR *xdrs; @@ -157,10 +151,9 @@ svcraw_freeargs(xprt, xdr_args, args_ptr) return (FALSE); xdrs = &srp->xdr_stream; xdrs->x_op = XDR_FREE; - return ((*xdr_args)(xdrs, args_ptr)); -} + return ((*xdr_args) (xdrs, args_ptr)); +} -static void -svcraw_destroy() +static void svcraw_destroy() { } diff --git a/libc/inet/rpc/svc_run.c b/libc/inet/rpc/svc_run.c index c1c3e0478..092fcb9a8 100644 --- a/libc/inet/rpc/svc_run.c +++ b/libc/inet/rpc/svc_run.c @@ -39,14 +39,13 @@ static char sccsid[] = "@(#)svc_run.c 1.1 87/10/13 Copyr 1984 Sun Micro"; #include #include -void -svc_run() +void svc_run() { #ifdef FD_SETSIZE fd_set readfds; #else - int readfds; -#endif /* def FD_SETSIZE */ + int readfds; +#endif /* def FD_SETSIZE */ extern int errno; for (;;) { @@ -54,9 +53,9 @@ svc_run() readfds = svc_fdset; #else readfds = svc_fds; -#endif /* def FD_SETSIZE */ - switch (select(_rpc_dtablesize(), &readfds, (int *)0, (int *)0, - (struct timeval *)0)) { +#endif /* def FD_SETSIZE */ + switch (select(_rpc_dtablesize(), &readfds, (int *) 0, (int *) 0, + (struct timeval *) 0)) { case -1: if (errno == EINTR) { continue; diff --git a/libc/inet/rpc/svc_simple.c b/libc/inet/rpc/svc_simple.c index d6bcbd3c0..3c75de3f0 100644 --- a/libc/inet/rpc/svc_simple.c +++ b/libc/inet/rpc/svc_simple.c @@ -28,7 +28,9 @@ * Mountain View, California 94043 */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)svc_simple.c 1.18 87/08/11 Copyr 1984 Sun Micro"; +static char sccsid[] = + + "@(#)svc_simple.c 1.18 87/08/11 Copyr 1984 Sun Micro"; #endif /* @@ -44,9 +46,9 @@ static char sccsid[] = "@(#)svc_simple.c 1.18 87/08/11 Copyr 1984 Sun Micro"; #include static struct proglst { - char *(*p_progname)(); - int p_prognum; - int p_procnum; + char *(*p_progname) (); + int p_prognum; + int p_procnum; xdrproc_t p_inproc, p_outproc; struct proglst *p_nxt; } *proglst; @@ -55,13 +57,13 @@ static SVCXPRT *transp; struct proglst *pl; registerrpc(prognum, versnum, procnum, progname, inproc, outproc) - char *(*progname)(); - xdrproc_t inproc, outproc; +char *(*progname) (); +xdrproc_t inproc, outproc; { - + if (procnum == NULLPROC) { (void) fprintf(stderr, - "can't reassign procedure number %d\n", NULLPROC); + "can't reassign procedure number %d\n", NULLPROC); return (-1); } if (transp == 0) { @@ -71,14 +73,15 @@ registerrpc(prognum, versnum, procnum, progname, inproc, outproc) return (-1); } } - (void) pmap_unset((u_long)prognum, (u_long)versnum); - if (!svc_register(transp, (u_long)prognum, (u_long)versnum, - universal, IPPROTO_UDP)) { - (void) fprintf(stderr, "couldn't register prog %d vers %d\n", - prognum, versnum); + (void) pmap_unset((u_long) prognum, (u_long) versnum); + if (!svc_register(transp, (u_long) prognum, (u_long) versnum, + universal, IPPROTO_UDP)) { + (void) fprintf(stderr, "couldn't register prog %d vers %d\n", + prognum, versnum); return (-1); } - pl = (struct proglst *)malloc(sizeof(struct proglst)); + pl = (struct proglst *) malloc(sizeof(struct proglst)); + if (pl == NULL) { (void) fprintf(stderr, "registerrpc: out of memory\n"); return (-1); @@ -93,10 +96,9 @@ registerrpc(prognum, versnum, procnum, progname, inproc, outproc) return (0); } -static void -universal(rqstp, transp) - struct svc_req *rqstp; - SVCXPRT *transp; +static void universal(rqstp, transp) +struct svc_req *rqstp; +SVCXPRT *transp; { int prog, proc; char *outdata; @@ -107,7 +109,7 @@ universal(rqstp, transp) * enforce "procnum 0 is echo" convention */ if (rqstp->rq_proc == NULLPROC) { - if (svc_sendreply(transp, xdr_void, (char *)NULL) == FALSE) { + if (svc_sendreply(transp, xdr_void, (char *) NULL) == FALSE) { (void) fprintf(stderr, "xxx\n"); exit(1); } @@ -118,26 +120,25 @@ universal(rqstp, transp) for (pl = proglst; pl != NULL; pl = pl->p_nxt) if (pl->p_prognum == prog && pl->p_procnum == proc) { /* decode arguments into a CLEAN buffer */ - bzero(xdrbuf, sizeof(xdrbuf)); /* required ! */ + bzero(xdrbuf, sizeof(xdrbuf)); /* required ! */ if (!svc_getargs(transp, pl->p_inproc, xdrbuf)) { svcerr_decode(transp); return; } - outdata = (*(pl->p_progname))(xdrbuf); + outdata = (*(pl->p_progname)) (xdrbuf); if (outdata == NULL && pl->p_outproc != xdr_void) /* there was an error */ return; if (!svc_sendreply(transp, pl->p_outproc, outdata)) { (void) fprintf(stderr, - "trouble replying to prog %d\n", - pl->p_prognum); + "trouble replying to prog %d\n", + pl->p_prognum); exit(1); } /* free the decoded arguments */ - (void)svc_freeargs(transp, pl->p_inproc, xdrbuf); + (void) svc_freeargs(transp, pl->p_inproc, xdrbuf); return; } (void) fprintf(stderr, "never registered prog %d\n", prog); exit(1); } - diff --git a/libc/inet/rpc/svc_tcp.c b/libc/inet/rpc/svc_tcp.c index 837e70c82..0008eaa0c 100644 --- a/libc/inet/rpc/svc_tcp.c +++ b/libc/inet/rpc/svc_tcp.c @@ -51,12 +51,12 @@ extern errno; /* * Ops vector for TCP/IP based rpc service handle */ -static bool_t svctcp_recv(); -static enum xprt_stat svctcp_stat(); -static bool_t svctcp_getargs(); -static bool_t svctcp_reply(); -static bool_t svctcp_freeargs(); -static void svctcp_destroy(); +static bool_t svctcp_recv(); +static enum xprt_stat svctcp_stat(); +static bool_t svctcp_getargs(); +static bool_t svctcp_reply(); +static bool_t svctcp_freeargs(); +static void svctcp_destroy(); static struct xp_ops svctcp_op = { svctcp_recv, @@ -70,8 +70,8 @@ static struct xp_ops svctcp_op = { /* * Ops vector for TCP/IP rendezvous handler */ -static bool_t rendezvous_request(); -static enum xprt_stat rendezvous_stat(); +static bool_t rendezvous_request(); +static enum xprt_stat rendezvous_stat(); static struct xp_ops svctcp_rendezvous_op = { rendezvous_request, @@ -85,12 +85,12 @@ static struct xp_ops svctcp_rendezvous_op = { static int readtcp(), writetcp(); static SVCXPRT *makefd_xprt(); -struct tcp_rendezvous { /* kept in xprt->xp_p1 */ +struct tcp_rendezvous { /* kept in xprt->xp_p1 */ u_int sendsize; u_int recvsize; }; -struct tcp_conn { /* kept in xprt->xp_p1 */ +struct tcp_conn { /* kept in xprt->xp_p1 */ enum xprt_stat strm_stat; u_long x_id; XDR xdrs; @@ -117,11 +117,10 @@ struct tcp_conn { /* kept in xprt->xp_p1 */ * how big the send and receive buffers are via the second and third parms; * 0 => use the system default. */ -SVCXPRT * -svctcp_create(sock, sendsize, recvsize) - register int sock; - u_int sendsize; - u_int recvsize; +SVCXPRT *svctcp_create(sock, sendsize, recvsize) +register int sock; +u_int sendsize; +u_int recvsize; { bool_t madesock = FALSE; register SVCXPRT *xprt; @@ -132,37 +131,37 @@ svctcp_create(sock, sendsize, recvsize) if (sock == RPC_ANYSOCK) { if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { perror("svc_tcp.c - tcp socket creation problem"); - return ((SVCXPRT *)NULL); + return ((SVCXPRT *) NULL); } madesock = TRUE; } - bzero((char *)&addr, sizeof (addr)); + bzero((char *) &addr, sizeof(addr)); addr.sin_family = AF_INET; if (bindresvport(sock, &addr)) { addr.sin_port = 0; - (void)bind(sock, (struct sockaddr *)&addr, len); + (void) bind(sock, (struct sockaddr *) &addr, len); } - if ((getsockname(sock, (struct sockaddr *)&addr, &len) != 0) || - (listen(sock, 2) != 0)) { + if ((getsockname(sock, (struct sockaddr *) &addr, &len) != 0) || + (listen(sock, 2) != 0)) { perror("svctcp_.c - cannot getsockname or listen"); if (madesock) - (void)close(sock); - return ((SVCXPRT *)NULL); + (void) close(sock); + return ((SVCXPRT *) NULL); } - r = (struct tcp_rendezvous *)mem_alloc(sizeof(*r)); + r = (struct tcp_rendezvous *) mem_alloc(sizeof(*r)); if (r == NULL) { (void) fprintf(stderr, "svctcp_create: out of memory\n"); return (NULL); } r->sendsize = sendsize; r->recvsize = recvsize; - xprt = (SVCXPRT *)mem_alloc(sizeof(SVCXPRT)); + xprt = (SVCXPRT *) mem_alloc(sizeof(SVCXPRT)); if (xprt == NULL) { (void) fprintf(stderr, "svctcp_create: out of memory\n"); return (NULL); } xprt->xp_p2 = NULL; - xprt->xp_p1 = (caddr_t)r; + xprt->xp_p1 = (caddr_t) r; xprt->xp_verf = _null_auth; xprt->xp_ops = &svctcp_rendezvous_op; xprt->xp_port = ntohs(addr.sin_port); @@ -175,69 +174,68 @@ svctcp_create(sock, sendsize, recvsize) * Like svtcp_create(), except the routine takes any *open* UNIX file * descriptor as its first input. */ -SVCXPRT * -svcfd_create(fd, sendsize, recvsize) - int fd; - u_int sendsize; - u_int recvsize; +SVCXPRT *svcfd_create(fd, sendsize, recvsize) +int fd; +u_int sendsize; +u_int recvsize; { return (makefd_xprt(fd, sendsize, recvsize)); } -static SVCXPRT * -makefd_xprt(fd, sendsize, recvsize) - int fd; - u_int sendsize; - u_int recvsize; +static SVCXPRT *makefd_xprt(fd, sendsize, recvsize) +int fd; +u_int sendsize; +u_int recvsize; { register SVCXPRT *xprt; register struct tcp_conn *cd; - - xprt = (SVCXPRT *)mem_alloc(sizeof(SVCXPRT)); - if (xprt == (SVCXPRT *)NULL) { + + xprt = (SVCXPRT *) mem_alloc(sizeof(SVCXPRT)); + if (xprt == (SVCXPRT *) NULL) { (void) fprintf(stderr, "svc_tcp: makefd_xprt: out of memory\n"); goto done; } - cd = (struct tcp_conn *)mem_alloc(sizeof(struct tcp_conn)); - if (cd == (struct tcp_conn *)NULL) { + cd = (struct tcp_conn *) mem_alloc(sizeof(struct tcp_conn)); + + if (cd == (struct tcp_conn *) NULL) { (void) fprintf(stderr, "svc_tcp: makefd_xprt: out of memory\n"); mem_free((char *) xprt, sizeof(SVCXPRT)); - xprt = (SVCXPRT *)NULL; + xprt = (SVCXPRT *) NULL; goto done; } cd->strm_stat = XPRT_IDLE; xdrrec_create(&(cd->xdrs), sendsize, recvsize, - (caddr_t)xprt, readtcp, writetcp); + (caddr_t) xprt, readtcp, writetcp); xprt->xp_p2 = NULL; - xprt->xp_p1 = (caddr_t)cd; + xprt->xp_p1 = (caddr_t) cd; xprt->xp_verf.oa_base = cd->verf_body; xprt->xp_addrlen = 0; - xprt->xp_ops = &svctcp_op; /* truely deals with calls */ - xprt->xp_port = 0; /* this is a connection, not a rendezvouser */ + xprt->xp_ops = &svctcp_op; /* truely deals with calls */ + xprt->xp_port = 0; /* this is a connection, not a rendezvouser */ xprt->xp_sock = fd; xprt_register(xprt); - done: + done: return (xprt); } -static bool_t -rendezvous_request(xprt) - register SVCXPRT *xprt; +static bool_t rendezvous_request(xprt) +register SVCXPRT *xprt; { int sock; struct tcp_rendezvous *r; struct sockaddr_in addr; int len; - r = (struct tcp_rendezvous *)xprt->xp_p1; - again: + r = (struct tcp_rendezvous *) xprt->xp_p1; + again: len = sizeof(struct sockaddr_in); - if ((sock = accept(xprt->xp_sock, (struct sockaddr *)&addr, - &len)) < 0) { + + if ((sock = accept(xprt->xp_sock, (struct sockaddr *) &addr, + &len)) < 0) { if (errno == EINTR) goto again; - return (FALSE); + return (FALSE); } /* * make a new transporter (re-uses xprt) @@ -245,24 +243,22 @@ rendezvous_request(xprt) xprt = makefd_xprt(sock, r->sendsize, r->recvsize); xprt->xp_raddr = addr; xprt->xp_addrlen = len; - return (FALSE); /* there is never an rpc msg to be processed */ + return (FALSE); /* there is never an rpc msg to be processed */ } -static enum xprt_stat -rendezvous_stat() +static enum xprt_stat rendezvous_stat() { return (XPRT_IDLE); } -static void -svctcp_destroy(xprt) - register SVCXPRT *xprt; +static void svctcp_destroy(xprt) +register SVCXPRT *xprt; { - register struct tcp_conn *cd = (struct tcp_conn *)xprt->xp_p1; + register struct tcp_conn *cd = (struct tcp_conn *) xprt->xp_p1; xprt_unregister(xprt); - (void)close(xprt->xp_sock); + (void) close(xprt->xp_sock); if (xprt->xp_port != 0) { /* a rendezvouser socket */ xprt->xp_port = 0; @@ -270,8 +266,9 @@ svctcp_destroy(xprt) /* an actual connection socket */ XDR_DESTROY(&(cd->xdrs)); } - mem_free((caddr_t)cd, sizeof(struct tcp_conn)); - mem_free((caddr_t)xprt, sizeof(SVCXPRT)); + mem_free((caddr_t) cd, sizeof(struct tcp_conn)); + + mem_free((caddr_t) xprt, sizeof(SVCXPRT)); } /* @@ -285,13 +282,13 @@ static struct timeval wait_per_try = { 35, 0 }; * any error is fatal and the connection is closed. * (And a read of zero bytes is a half closed stream => error.) */ -static int -readtcp(xprt, buf, len) - register SVCXPRT *xprt; - caddr_t buf; - register int len; +static int readtcp(xprt, buf, len) +register SVCXPRT *xprt; +caddr_t buf; +register int len; { register int sock = xprt->xp_sock; + #ifdef FD_SETSIZE fd_set mask; fd_set readfds; @@ -301,11 +298,11 @@ readtcp(xprt, buf, len) #else register int mask = 1 << sock; int readfds; -#endif /* def FD_SETSIZE */ +#endif /* def FD_SETSIZE */ do { readfds = mask; - if (select(_rpc_dtablesize(), &readfds, (int*)NULL, (int*)NULL, - &wait_per_try) <= 0) { + if (select(_rpc_dtablesize(), &readfds, (int *) NULL, (int *) NULL, + &wait_per_try) <= 0) { if (errno == EINTR) { continue; } @@ -315,12 +312,12 @@ readtcp(xprt, buf, len) } while (!FD_ISSET(sock, &readfds)); #else } while (readfds != mask); -#endif /* def FD_SETSIZE */ +#endif /* def FD_SETSIZE */ if ((len = read(sock, buf, len)) > 0) { return (len); } -fatal_err: - ((struct tcp_conn *)(xprt->xp_p1))->strm_stat = XPRT_DIED; + fatal_err: + ((struct tcp_conn *) (xprt->xp_p1))->strm_stat = XPRT_DIED; return (-1); } @@ -328,49 +325,43 @@ fatal_err: * writes data to the tcp connection. * Any error is fatal and the connection is closed. */ -static int -writetcp(xprt, buf, len) - register SVCXPRT *xprt; - caddr_t buf; - int len; +static int writetcp(xprt, buf, len) +register SVCXPRT *xprt; +caddr_t buf; +int len; { register int i, cnt; for (cnt = len; cnt > 0; cnt -= i, buf += i) { if ((i = write(xprt->xp_sock, buf, cnt)) < 0) { - ((struct tcp_conn *)(xprt->xp_p1))->strm_stat = - XPRT_DIED; + ((struct tcp_conn *) (xprt->xp_p1))->strm_stat = XPRT_DIED; return (-1); } } return (len); } -static enum xprt_stat -svctcp_stat(xprt) - SVCXPRT *xprt; +static enum xprt_stat svctcp_stat(xprt) +SVCXPRT *xprt; { - register struct tcp_conn *cd = - (struct tcp_conn *)(xprt->xp_p1); + register struct tcp_conn *cd = (struct tcp_conn *) (xprt->xp_p1); if (cd->strm_stat == XPRT_DIED) return (XPRT_DIED); - if (! xdrrec_eof(&(cd->xdrs))) + if (!xdrrec_eof(&(cd->xdrs))) return (XPRT_MOREREQS); return (XPRT_IDLE); } -static bool_t -svctcp_recv(xprt, msg) - SVCXPRT *xprt; - register struct rpc_msg *msg; +static bool_t svctcp_recv(xprt, msg) +SVCXPRT *xprt; +register struct rpc_msg *msg; { - register struct tcp_conn *cd = - (struct tcp_conn *)(xprt->xp_p1); + register struct tcp_conn *cd = (struct tcp_conn *) (xprt->xp_p1); register XDR *xdrs = &(cd->xdrs); xdrs->x_op = XDR_DECODE; - (void)xdrrec_skiprecord(xdrs); + (void) xdrrec_skiprecord(xdrs); if (xdr_callmsg(xdrs, msg)) { cd->x_id = msg->rm_xid; return (TRUE); @@ -378,42 +369,38 @@ svctcp_recv(xprt, msg) return (FALSE); } -static bool_t -svctcp_getargs(xprt, xdr_args, args_ptr) - SVCXPRT *xprt; - xdrproc_t xdr_args; - caddr_t args_ptr; +static bool_t svctcp_getargs(xprt, xdr_args, args_ptr) +SVCXPRT *xprt; +xdrproc_t xdr_args; +caddr_t args_ptr; { - return ((*xdr_args)(&(((struct tcp_conn *)(xprt->xp_p1))->xdrs), args_ptr)); + return ((*xdr_args) + (&(((struct tcp_conn *) (xprt->xp_p1))->xdrs), args_ptr)); } -static bool_t -svctcp_freeargs(xprt, xdr_args, args_ptr) - SVCXPRT *xprt; - xdrproc_t xdr_args; - caddr_t args_ptr; +static bool_t svctcp_freeargs(xprt, xdr_args, args_ptr) +SVCXPRT *xprt; +xdrproc_t xdr_args; +caddr_t args_ptr; { - register XDR *xdrs = - &(((struct tcp_conn *)(xprt->xp_p1))->xdrs); + register XDR *xdrs = &(((struct tcp_conn *) (xprt->xp_p1))->xdrs); xdrs->x_op = XDR_FREE; - return ((*xdr_args)(xdrs, args_ptr)); + return ((*xdr_args) (xdrs, args_ptr)); } -static bool_t -svctcp_reply(xprt, msg) - SVCXPRT *xprt; - register struct rpc_msg *msg; +static bool_t svctcp_reply(xprt, msg) +SVCXPRT *xprt; +register struct rpc_msg *msg; { - register struct tcp_conn *cd = - (struct tcp_conn *)(xprt->xp_p1); + register struct tcp_conn *cd = (struct tcp_conn *) (xprt->xp_p1); register XDR *xdrs = &(cd->xdrs); register bool_t stat; xdrs->x_op = XDR_ENCODE; msg->rm_xid = cd->x_id; stat = xdr_replymsg(xdrs, msg); - (void)xdrrec_endofrecord(xdrs, TRUE); + (void) xdrrec_endofrecord(xdrs, TRUE); return (stat); } diff --git a/libc/inet/rpc/svc_udp.c b/libc/inet/rpc/svc_udp.c index 69ef7a1ce..b8495a127 100644 --- a/libc/inet/rpc/svc_udp.c +++ b/libc/inet/rpc/svc_udp.c @@ -48,12 +48,12 @@ static char sccsid[] = "@(#)svc_udp.c 1.24 87/08/11 Copyr 1984 Sun Micro"; #define rpc_buffer(xprt) ((xprt)->xp_p1) #define MAX(a, b) ((a > b) ? a : b) -static bool_t svcudp_recv(); -static bool_t svcudp_reply(); -static enum xprt_stat svcudp_stat(); -static bool_t svcudp_getargs(); -static bool_t svcudp_freeargs(); -static void svcudp_destroy(); +static bool_t svcudp_recv(); +static bool_t svcudp_reply(); +static enum xprt_stat svcudp_stat(); +static bool_t svcudp_getargs(); +static bool_t svcudp_freeargs(); +static void svcudp_destroy(); static struct xp_ops svcudp_op = { svcudp_recv, @@ -70,12 +70,13 @@ extern int errno; * kept in xprt->xp_p2 */ struct svcudp_data { - u_int su_iosz; /* byte size of send.recv buffer */ - u_long su_xid; /* transaction id */ - XDR su_xdrs; /* XDR handle */ - char su_verfbody[MAX_AUTH_BYTES]; /* verifier body */ - char * su_cache; /* cached data, NULL if no cache */ + u_int su_iosz; /* byte size of send.recv buffer */ + u_long su_xid; /* transaction id */ + XDR su_xdrs; /* XDR handle */ + char su_verfbody[MAX_AUTH_BYTES]; /* verifier body */ + char *su_cache; /* cached data, NULL if no cache */ }; + #define su_data(xprt) ((struct svcudp_data *)(xprt->xp_p2)) /* @@ -91,10 +92,9 @@ struct svcudp_data { * see (svc.h, xprt_register). * The routines returns NULL if a problem occurred. */ -SVCXPRT * -svcudp_bufcreate(sock, sendsz, recvsz) - register int sock; - u_int sendsz, recvsz; +SVCXPRT *svcudp_bufcreate(sock, sendsz, recvsz) +register int sock; +u_int sendsz, recvsz; { bool_t madesock = FALSE; register SVCXPRT *xprt; @@ -105,41 +105,41 @@ svcudp_bufcreate(sock, sendsz, recvsz) if (sock == RPC_ANYSOCK) { if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { perror("svcudp_create: socket creation problem"); - return ((SVCXPRT *)NULL); + return ((SVCXPRT *) NULL); } madesock = TRUE; } - bzero((char *)&addr, sizeof (addr)); + bzero((char *) &addr, sizeof(addr)); addr.sin_family = AF_INET; if (bindresvport(sock, &addr)) { addr.sin_port = 0; - (void)bind(sock, (struct sockaddr *)&addr, len); + (void) bind(sock, (struct sockaddr *) &addr, len); } - if (getsockname(sock, (struct sockaddr *)&addr, &len) != 0) { + if (getsockname(sock, (struct sockaddr *) &addr, &len) != 0) { perror("svcudp_create - cannot getsockname"); if (madesock) - (void)close(sock); - return ((SVCXPRT *)NULL); + (void) close(sock); + return ((SVCXPRT *) NULL); } - xprt = (SVCXPRT *)mem_alloc(sizeof(SVCXPRT)); + xprt = (SVCXPRT *) mem_alloc(sizeof(SVCXPRT)); if (xprt == NULL) { - (void)fprintf(stderr, "svcudp_create: out of memory\n"); + (void) fprintf(stderr, "svcudp_create: out of memory\n"); return (NULL); } - su = (struct svcudp_data *)mem_alloc(sizeof(*su)); + su = (struct svcudp_data *) mem_alloc(sizeof(*su)); if (su == NULL) { - (void)fprintf(stderr, "svcudp_create: out of memory\n"); + (void) fprintf(stderr, "svcudp_create: out of memory\n"); return (NULL); } su->su_iosz = ((MAX(sendsz, recvsz) + 3) / 4) * 4; if ((rpc_buffer(xprt) = mem_alloc(su->su_iosz)) == NULL) { - (void)fprintf(stderr, "svcudp_create: out of memory\n"); + (void) fprintf(stderr, "svcudp_create: out of memory\n"); return (NULL); } - xdrmem_create( - &(su->su_xdrs), rpc_buffer(xprt), su->su_iosz, XDR_DECODE); + xdrmem_create(&(su->su_xdrs), rpc_buffer(xprt), su->su_iosz, + XDR_DECODE); su->su_cache = NULL; - xprt->xp_p2 = (caddr_t)su; + xprt->xp_p2 = (caddr_t) su; xprt->xp_verf.oa_base = su->su_verfbody; xprt->xp_ops = &svcudp_op; xprt->xp_port = ntohs(addr.sin_port); @@ -148,26 +148,23 @@ svcudp_bufcreate(sock, sendsz, recvsz) return (xprt); } -SVCXPRT * -svcudp_create(sock) - int sock; +SVCXPRT *svcudp_create(sock) +int sock; { - return(svcudp_bufcreate(sock, UDPMSGSIZE, UDPMSGSIZE)); + return (svcudp_bufcreate(sock, UDPMSGSIZE, UDPMSGSIZE)); } -static enum xprt_stat -svcudp_stat(xprt) - SVCXPRT *xprt; +static enum xprt_stat svcudp_stat(xprt) +SVCXPRT *xprt; { - return (XPRT_IDLE); + return (XPRT_IDLE); } -static bool_t -svcudp_recv(xprt, msg) - register SVCXPRT *xprt; - struct rpc_msg *msg; +static bool_t svcudp_recv(xprt, msg) +register SVCXPRT *xprt; +struct rpc_msg *msg; { register struct svcudp_data *su = su_data(xprt); register XDR *xdrs = &(su->su_xdrs); @@ -175,33 +172,35 @@ svcudp_recv(xprt, msg) char *reply; u_long replylen; - again: + again: xprt->xp_addrlen = sizeof(struct sockaddr_in); + rlen = recvfrom(xprt->xp_sock, rpc_buffer(xprt), (int) su->su_iosz, - 0, (struct sockaddr *)&(xprt->xp_raddr), &(xprt->xp_addrlen)); + 0, (struct sockaddr *) &(xprt->xp_raddr), + &(xprt->xp_addrlen)); if (rlen == -1 && errno == EINTR) goto again; - if (rlen < 4*sizeof(u_long)) + if (rlen < 4 * sizeof(u_long)) return (FALSE); xdrs->x_op = XDR_DECODE; XDR_SETPOS(xdrs, 0); - if (! xdr_callmsg(xdrs, msg)) + if (!xdr_callmsg(xdrs, msg)) return (FALSE); su->su_xid = msg->rm_xid; if (su->su_cache != NULL) { if (cache_get(xprt, msg, &reply, &replylen)) { (void) sendto(xprt->xp_sock, reply, (int) replylen, 0, - (struct sockaddr *) &xprt->xp_raddr, xprt->xp_addrlen); + (struct sockaddr *) &xprt->xp_raddr, + xprt->xp_addrlen); return (TRUE); } } return (TRUE); } -static bool_t -svcudp_reply(xprt, msg) - register SVCXPRT *xprt; - struct rpc_msg *msg; +static bool_t svcudp_reply(xprt, msg) +register SVCXPRT *xprt; +struct rpc_msg *msg; { register struct svcudp_data *su = su_data(xprt); register XDR *xdrs = &(su->su_xdrs); @@ -212,10 +211,10 @@ svcudp_reply(xprt, msg) XDR_SETPOS(xdrs, 0); msg->rm_xid = su->su_xid; if (xdr_replymsg(xdrs, msg)) { - slen = (int)XDR_GETPOS(xdrs); + slen = (int) XDR_GETPOS(xdrs); if (sendto(xprt->xp_sock, rpc_buffer(xprt), slen, 0, - (struct sockaddr *)&(xprt->xp_raddr), xprt->xp_addrlen) - == slen) { + (struct sockaddr *) &(xprt->xp_raddr), xprt->xp_addrlen) + == slen) { stat = TRUE; if (su->su_cache && slen >= 0) { cache_set(xprt, (u_long) slen); @@ -225,40 +224,38 @@ svcudp_reply(xprt, msg) return (stat); } -static bool_t -svcudp_getargs(xprt, xdr_args, args_ptr) - SVCXPRT *xprt; - xdrproc_t xdr_args; - caddr_t args_ptr; +static bool_t svcudp_getargs(xprt, xdr_args, args_ptr) +SVCXPRT *xprt; +xdrproc_t xdr_args; +caddr_t args_ptr; { - return ((*xdr_args)(&(su_data(xprt)->su_xdrs), args_ptr)); + return ((*xdr_args) (&(su_data(xprt)->su_xdrs), args_ptr)); } -static bool_t -svcudp_freeargs(xprt, xdr_args, args_ptr) - SVCXPRT *xprt; - xdrproc_t xdr_args; - caddr_t args_ptr; +static bool_t svcudp_freeargs(xprt, xdr_args, args_ptr) +SVCXPRT *xprt; +xdrproc_t xdr_args; +caddr_t args_ptr; { register XDR *xdrs = &(su_data(xprt)->su_xdrs); xdrs->x_op = XDR_FREE; - return ((*xdr_args)(xdrs, args_ptr)); + return ((*xdr_args) (xdrs, args_ptr)); } -static void -svcudp_destroy(xprt) - register SVCXPRT *xprt; +static void svcudp_destroy(xprt) +register SVCXPRT *xprt; { register struct svcudp_data *su = su_data(xprt); xprt_unregister(xprt); - (void)close(xprt->xp_sock); + (void) close(xprt->xp_sock); XDR_DESTROY(&(su->su_xdrs)); mem_free(rpc_buffer(xprt), su->su_iosz); - mem_free((caddr_t)su, sizeof(struct svcudp_data)); - mem_free((caddr_t)xprt, sizeof(SVCXPRT)); + mem_free((caddr_t) su, sizeof(struct svcudp_data)); + + mem_free((caddr_t) xprt, sizeof(SVCXPRT)); } @@ -270,7 +267,7 @@ svcudp_destroy(xprt) * Buffers are sent again if retransmissions are detected. */ -#define SPARSENESS 4 /* 75% sparse */ +#define SPARSENESS 4 /* 75% sparse */ #define CACHE_PERROR(msg) \ (void) fprintf(stderr,"%s\n", msg) @@ -279,7 +276,7 @@ svcudp_destroy(xprt) (type *) mem_alloc((unsigned) (sizeof(type) * (size))) #define BZERO(addr, type, size) \ - bzero((char *) addr, sizeof(type) * (int) (size)) + bzero((char *) addr, sizeof(type) * (int) (size)) /* * An entry in the cache @@ -297,12 +294,12 @@ struct cache_node { /* * The cached reply and length */ - char * cache_reply; + char *cache_reply; u_long cache_replylen; /* - * Next node on the list, if there is a collision + * Next node on the list, if there is a collision */ - cache_ptr cache_next; + cache_ptr cache_next; }; @@ -311,14 +308,14 @@ struct cache_node { * The entire cache */ struct udp_cache { - u_long uc_size; /* size of cache */ - cache_ptr *uc_entries; /* hash table of entries in cache */ - cache_ptr *uc_fifo; /* fifo list of entries in cache */ - u_long uc_nextvictim; /* points to next victim in fifo list */ - u_long uc_prog; /* saved program number */ - u_long uc_vers; /* saved version number */ - u_long uc_proc; /* saved procedure number */ - struct sockaddr_in uc_addr; /* saved caller's address */ + u_long uc_size; /* size of cache */ + cache_ptr *uc_entries; /* hash table of entries in cache */ + cache_ptr *uc_fifo; /* fifo list of entries in cache */ + u_long uc_nextvictim; /* points to next victim in fifo list */ + u_long uc_prog; /* saved program number */ + u_long uc_vers; /* saved version number */ + u_long uc_proc; /* saved procedure number */ + struct sockaddr_in uc_addr; /* saved caller's address */ }; @@ -326,7 +323,7 @@ struct udp_cache { * the hashing function */ #define CACHE_LOC(transp, xid) \ - (xid % (SPARSENESS*((struct udp_cache *) su_data(transp)->su_cache)->uc_size)) + (xid % (SPARSENESS*((struct udp_cache *) su_data(transp)->su_cache)->uc_size)) /* @@ -334,49 +331,48 @@ struct udp_cache { * Note: there is no disable. */ svcudp_enablecache(transp, size) - SVCXPRT *transp; - u_long size; +SVCXPRT *transp; +u_long size; { struct svcudp_data *su = su_data(transp); struct udp_cache *uc; if (su->su_cache != NULL) { CACHE_PERROR("enablecache: cache already enabled"); - return(0); + return (0); } uc = ALLOC(struct udp_cache, 1); if (uc == NULL) { CACHE_PERROR("enablecache: could not allocate cache"); - return(0); + return (0); } uc->uc_size = size; uc->uc_nextvictim = 0; uc->uc_entries = ALLOC(cache_ptr, size * SPARSENESS); if (uc->uc_entries == NULL) { CACHE_PERROR("enablecache: could not allocate cache data"); - return(0); + return (0); } BZERO(uc->uc_entries, cache_ptr, size * SPARSENESS); uc->uc_fifo = ALLOC(cache_ptr, size); if (uc->uc_fifo == NULL) { CACHE_PERROR("enablecache: could not allocate cache fifo"); - return(0); + return (0); } BZERO(uc->uc_fifo, cache_ptr, size); su->su_cache = (char *) uc; - return(1); + return (1); } /* * Set an entry in the cache */ -static -cache_set(xprt, replylen) - SVCXPRT *xprt; - u_long replylen; +static cache_set(xprt, replylen) +SVCXPRT *xprt; +u_long replylen; { - register cache_ptr victim; + register cache_ptr victim; register cache_ptr *vicp; register struct svcudp_data *su = su_data(xprt); struct udp_cache *uc = (struct udp_cache *) su->su_cache; @@ -384,16 +380,15 @@ cache_set(xprt, replylen) char *newbuf; /* - * Find space for the new entry, either by + * Find space for the new entry, either by * reusing an old entry, or by mallocing a new one */ victim = uc->uc_fifo[uc->uc_nextvictim]; if (victim != NULL) { loc = CACHE_LOC(xprt, victim->cache_xid); - for (vicp = &uc->uc_entries[loc]; - *vicp != NULL && *vicp != victim; - vicp = &(*vicp)->cache_next) - ; + for (vicp = &uc->uc_entries[loc]; + *vicp != NULL && *vicp != victim; + vicp = &(*vicp)->cache_next); if (*vicp == NULL) { CACHE_PERROR("cache_set: victim not found"); return; @@ -402,6 +397,7 @@ cache_set(xprt, replylen) newbuf = victim->cache_reply; } else { victim = ALLOC(struct cache_node, 1); + if (victim == NULL) { CACHE_PERROR("cache_set: victim alloc failed"); return; @@ -419,14 +415,15 @@ cache_set(xprt, replylen) victim->cache_replylen = replylen; victim->cache_reply = rpc_buffer(xprt); rpc_buffer(xprt) = newbuf; - xdrmem_create(&(su->su_xdrs), rpc_buffer(xprt), su->su_iosz, XDR_ENCODE); + xdrmem_create(&(su->su_xdrs), rpc_buffer(xprt), su->su_iosz, + XDR_ENCODE); victim->cache_xid = su->su_xid; victim->cache_proc = uc->uc_proc; victim->cache_vers = uc->uc_vers; victim->cache_prog = uc->uc_prog; victim->cache_addr = uc->uc_addr; loc = CACHE_LOC(xprt, victim->cache_xid); - victim->cache_next = uc->uc_entries[loc]; + victim->cache_next = uc->uc_entries[loc]; uc->uc_entries[loc] = victim; uc->uc_fifo[uc->uc_nextvictim++] = victim; uc->uc_nextvictim %= uc->uc_size; @@ -436,12 +433,11 @@ cache_set(xprt, replylen) * Try to get an entry from the cache * return 1 if found, 0 if not found */ -static -cache_get(xprt, msg, replyp, replylenp) - SVCXPRT *xprt; - struct rpc_msg *msg; - char **replyp; - u_long *replylenp; +static cache_get(xprt, msg, replyp, replylenp) +SVCXPRT *xprt; +struct rpc_msg *msg; +char **replyp; +u_long *replylenp; { u_int loc; register cache_ptr ent; @@ -453,13 +449,13 @@ cache_get(xprt, msg, replyp, replylenp) loc = CACHE_LOC(xprt, su->su_xid); for (ent = uc->uc_entries[loc]; ent != NULL; ent = ent->cache_next) { if (ent->cache_xid == su->su_xid && - ent->cache_proc == uc->uc_proc && - ent->cache_vers == uc->uc_vers && - ent->cache_prog == uc->uc_prog && - EQADDR(ent->cache_addr, uc->uc_addr)) { + ent->cache_proc == uc->uc_proc && + ent->cache_vers == uc->uc_vers && + ent->cache_prog == uc->uc_prog && + EQADDR(ent->cache_addr, uc->uc_addr)) { *replyp = ent->cache_reply; *replylenp = ent->cache_replylen; - return(1); + return (1); } } /* @@ -470,6 +466,5 @@ cache_get(xprt, msg, replyp, replylenp) uc->uc_vers = msg->rm_call.cb_vers; uc->uc_prog = msg->rm_call.cb_prog; uc->uc_addr = xprt->xp_raddr; - return(0); + return (0); } - diff --git a/libc/inet/rpc/xdr.c b/libc/inet/rpc/xdr.c index cc2783813..88600732a 100644 --- a/libc/inet/rpc/xdr.c +++ b/libc/inet/rpc/xdr.c @@ -62,22 +62,20 @@ static char xdr_zero[BYTES_PER_XDR_UNIT] = { 0, 0, 0, 0 }; * Free a data structure using XDR * Not a filter, but a convenient utility nonetheless */ -void -xdr_free(proc, objp) - xdrproc_t proc; - char *objp; +void xdr_free(proc, objp) +xdrproc_t proc; +char *objp; { XDR x; - + x.x_op = XDR_FREE; - (*proc)(&x, objp); + (*proc) (&x, objp); } /* * XDR nothing */ -bool_t -xdr_void(/* xdrs, addr */) +bool_t xdr_void( /* xdrs, addr */ ) /* XDR *xdrs; */ /* caddr_t addr; */ { @@ -88,20 +86,19 @@ xdr_void(/* xdrs, addr */) /* * XDR integers */ -bool_t -xdr_int(xdrs, ip) - XDR *xdrs; - int *ip; +bool_t xdr_int(xdrs, ip) +XDR *xdrs; +int *ip; { #ifdef lint - (void) (xdr_short(xdrs, (short *)ip)); - return (xdr_long(xdrs, (long *)ip)); + (void) (xdr_short(xdrs, (short *) ip)); + return (xdr_long(xdrs, (long *) ip)); #else - if (sizeof (int) == sizeof (long)) { - return (xdr_long(xdrs, (long *)ip)); + if (sizeof(int) == sizeof(long)) { + return (xdr_long(xdrs, (long *) ip)); } else { - return (xdr_short(xdrs, (short *)ip)); + return (xdr_short(xdrs, (short *) ip)); } #endif } @@ -109,20 +106,19 @@ xdr_int(xdrs, ip) /* * XDR unsigned integers */ -bool_t -xdr_u_int(xdrs, up) - XDR *xdrs; - u_int *up; +bool_t xdr_u_int(xdrs, up) +XDR *xdrs; +u_int *up; { #ifdef lint - (void) (xdr_short(xdrs, (short *)up)); - return (xdr_u_long(xdrs, (u_long *)up)); + (void) (xdr_short(xdrs, (short *) up)); + return (xdr_u_long(xdrs, (u_long *) up)); #else - if (sizeof (u_int) == sizeof (u_long)) { - return (xdr_u_long(xdrs, (u_long *)up)); + if (sizeof(u_int) == sizeof(u_long)) { + return (xdr_u_long(xdrs, (u_long *) up)); } else { - return (xdr_short(xdrs, (short *)up)); + return (xdr_short(xdrs, (short *) up)); } #endif } @@ -131,10 +127,9 @@ xdr_u_int(xdrs, up) * XDR long integers * same as xdr_u_long - open coded to save a proc call! */ -bool_t -xdr_long(xdrs, lp) - register XDR *xdrs; - long *lp; +bool_t xdr_long(xdrs, lp) +register XDR *xdrs; +long *lp; { if (xdrs->x_op == XDR_ENCODE) @@ -153,16 +148,15 @@ xdr_long(xdrs, lp) * XDR unsigned long integers * same as xdr_long - open coded to save a proc call! */ -bool_t -xdr_u_long(xdrs, ulp) - register XDR *xdrs; - u_long *ulp; +bool_t xdr_u_long(xdrs, ulp) +register XDR *xdrs; +u_long *ulp; { if (xdrs->x_op == XDR_DECODE) - return (XDR_GETLONG(xdrs, (long *)ulp)); + return (XDR_GETLONG(xdrs, (long *) ulp)); if (xdrs->x_op == XDR_ENCODE) - return (XDR_PUTLONG(xdrs, (long *)ulp)); + return (XDR_PUTLONG(xdrs, (long *) ulp)); if (xdrs->x_op == XDR_FREE) return (TRUE); return (FALSE); @@ -171,10 +165,9 @@ xdr_u_long(xdrs, ulp) /* * XDR short integers */ -bool_t -xdr_short(xdrs, sp) - register XDR *xdrs; - short *sp; +bool_t xdr_short(xdrs, sp) +register XDR *xdrs; +short *sp; { long l; @@ -200,17 +193,16 @@ xdr_short(xdrs, sp) /* * XDR unsigned short integers */ -bool_t -xdr_u_short(xdrs, usp) - register XDR *xdrs; - u_short *usp; +bool_t xdr_u_short(xdrs, usp) +register XDR *xdrs; +u_short *usp; { u_long l; switch (xdrs->x_op) { case XDR_ENCODE: - l = (u_long) *usp; + l = (u_long) * usp; return (XDR_PUTLONG(xdrs, &l)); case XDR_DECODE: @@ -230,10 +222,9 @@ xdr_u_short(xdrs, usp) /* * XDR a char */ -bool_t -xdr_char(xdrs, cp) - XDR *xdrs; - char *cp; +bool_t xdr_char(xdrs, cp) +XDR *xdrs; +char *cp; { int i; @@ -248,10 +239,9 @@ xdr_char(xdrs, cp) /* * XDR an unsigned char */ -bool_t -xdr_u_char(xdrs, cp) - XDR *xdrs; - char *cp; +bool_t xdr_u_char(xdrs, cp) +XDR *xdrs; +char *cp; { u_int u; @@ -266,10 +256,9 @@ xdr_u_char(xdrs, cp) /* * XDR booleans */ -bool_t -xdr_bool(xdrs, bp) - register XDR *xdrs; - bool_t *bp; +bool_t xdr_bool(xdrs, bp) +register XDR *xdrs; +bool_t *bp; { long lb; @@ -295,10 +284,9 @@ xdr_bool(xdrs, bp) /* * XDR enumerations */ -bool_t -xdr_enum(xdrs, ep) - XDR *xdrs; - enum_t *ep; +bool_t xdr_enum(xdrs, ep) +XDR *xdrs; +enum_t *ep; { #ifndef lint enum sizecheck { SIZEVAL }; /* used to find the size of an enum */ @@ -306,16 +294,16 @@ xdr_enum(xdrs, ep) /* * enums are treated as ints */ - if (sizeof (enum sizecheck) == sizeof (long)) { - return (xdr_long(xdrs, (long *)ep)); - } else if (sizeof (enum sizecheck) == sizeof (short)) { - return (xdr_short(xdrs, (short *)ep)); + if (sizeof(enum sizecheck) == sizeof(long)) { + return (xdr_long(xdrs, (long *) ep)); + } else if (sizeof(enum sizecheck) == sizeof(short)) { + return (xdr_short(xdrs, (short *) ep)); } else { return (FALSE); } #else - (void) (xdr_short(xdrs, (short *)ep)); - return (xdr_long(xdrs, (long *)ep)); + (void) (xdr_short(xdrs, (short *) ep)); + return (xdr_long(xdrs, (long *) ep)); #endif } @@ -324,11 +312,10 @@ xdr_enum(xdrs, ep) * Allows the specification of a fixed size sequence of opaque bytes. * cp points to the opaque object and cnt gives the byte length. */ -bool_t -xdr_opaque(xdrs, cp, cnt) - register XDR *xdrs; - caddr_t cp; - register u_int cnt; +bool_t xdr_opaque(xdrs, cp, cnt) +register XDR *xdrs; +caddr_t cp; +register u_int cnt; { register u_int rndup; static crud[BYTES_PER_XDR_UNIT]; @@ -376,20 +363,19 @@ xdr_opaque(xdrs, cp, cnt) * *cpp is a pointer to the bytes, *sizep is the count. * If *cpp is NULL maxsize bytes are allocated */ -bool_t -xdr_bytes(xdrs, cpp, sizep, maxsize) - register XDR *xdrs; - char **cpp; - register u_int *sizep; - u_int maxsize; +bool_t xdr_bytes(xdrs, cpp, sizep, maxsize) +register XDR *xdrs; +char **cpp; +register u_int *sizep; +u_int maxsize; { - register char *sp = *cpp; /* sp is the actual string pointer */ + register char *sp = *cpp; /* sp is the actual string pointer */ register u_int nodesize; /* * first deal with the length since xdr bytes are counted */ - if (! xdr_u_int(xdrs, sizep)) { + if (!xdr_u_int(xdrs, sizep)) { return (FALSE); } nodesize = *sizep; @@ -407,7 +393,7 @@ xdr_bytes(xdrs, cpp, sizep, maxsize) return (TRUE); } if (sp == NULL) { - *cpp = sp = (char *)mem_alloc(nodesize); + *cpp = sp = (char *) mem_alloc(nodesize); } if (sp == NULL) { (void) fprintf(stderr, "xdr_bytes: out of memory\n"); @@ -431,10 +417,9 @@ xdr_bytes(xdrs, cpp, sizep, maxsize) /* * Implemented here due to commonality of the object. */ -bool_t -xdr_netobj(xdrs, np) - XDR *xdrs; - struct netobj *np; +bool_t xdr_netobj(xdrs, np) +XDR *xdrs; +struct netobj *np; { return (xdr_bytes(xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ)); @@ -451,20 +436,19 @@ xdr_netobj(xdrs, np) * routine may be called. * If there is no specific or default routine an error is returned. */ -bool_t -xdr_union(xdrs, dscmp, unp, choices, dfault) - register XDR *xdrs; - enum_t *dscmp; /* enum to decide which arm to work on */ - char *unp; /* the union itself */ - struct xdr_discrim *choices; /* [value, xdr proc] for each arm */ - xdrproc_t dfault; /* default xdr routine */ +bool_t xdr_union(xdrs, dscmp, unp, choices, dfault) +register XDR *xdrs; +enum_t *dscmp; /* enum to decide which arm to work on */ +char *unp; /* the union itself */ +struct xdr_discrim *choices; /* [value, xdr proc] for each arm */ +xdrproc_t dfault; /* default xdr routine */ { register enum_t dscm; /* * we deal with the discriminator; it's an enum */ - if (! xdr_enum(xdrs, dscmp)) { + if (!xdr_enum(xdrs, dscmp)) { return (FALSE); } dscm = *dscmp; @@ -475,14 +459,14 @@ xdr_union(xdrs, dscmp, unp, choices, dfault) */ for (; choices->proc != NULL_xdrproc_t; choices++) { if (choices->value == dscm) - return ((*(choices->proc))(xdrs, unp, LASTUNSIGNED)); + return ((*(choices->proc)) (xdrs, unp, LASTUNSIGNED)); } /* * no match - execute the default xdr routine if there is one */ return ((dfault == NULL_xdrproc_t) ? FALSE : - (*dfault)(xdrs, unp, LASTUNSIGNED)); + (*dfault) (xdrs, unp, LASTUNSIGNED)); } @@ -500,13 +484,12 @@ xdr_union(xdrs, dscmp, unp, choices, dfault) * storage is allocated. The last parameter is the max allowed length * of the string as specified by a protocol. */ -bool_t -xdr_string(xdrs, cpp, maxsize) - register XDR *xdrs; - char **cpp; - u_int maxsize; +bool_t xdr_string(xdrs, cpp, maxsize) +register XDR *xdrs; +char **cpp; +u_int maxsize; { - register char *sp = *cpp; /* sp is the actual string pointer */ + register char *sp = *cpp; /* sp is the actual string pointer */ u_int size; u_int nodesize; @@ -516,14 +499,14 @@ xdr_string(xdrs, cpp, maxsize) switch (xdrs->x_op) { case XDR_FREE: if (sp == NULL) { - return(TRUE); /* already free */ + return (TRUE); /* already free */ } /* fall through... */ case XDR_ENCODE: size = strlen(sp); break; } - if (! xdr_u_int(xdrs, &size)) { + if (!xdr_u_int(xdrs, &size)) { return (FALSE); } if (size > maxsize) { @@ -541,7 +524,7 @@ xdr_string(xdrs, cpp, maxsize) return (TRUE); } if (sp == NULL) - *cpp = sp = (char *)mem_alloc(nodesize); + *cpp = sp = (char *) mem_alloc(nodesize); if (sp == NULL) { (void) fprintf(stderr, "xdr_string: out of memory\n"); return (FALSE); @@ -564,10 +547,9 @@ xdr_string(xdrs, cpp, maxsize) * Wrapper for xdr_string that can be called directly from * routines like clnt_call */ -bool_t -xdr_wrapstring(xdrs, cpp) - XDR *xdrs; - char **cpp; +bool_t xdr_wrapstring(xdrs, cpp) +XDR *xdrs; +char **cpp; { if (xdr_string(xdrs, cpp, LASTUNSIGNED)) { return (TRUE); diff --git a/libc/inet/rpc/xdr_array.c b/libc/inet/rpc/xdr_array.c index 7c2831ccd..1e6101719 100644 --- a/libc/inet/rpc/xdr_array.c +++ b/libc/inet/rpc/xdr_array.c @@ -28,7 +28,9 @@ * Mountain View, California 94043 */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)xdr_array.c 1.10 87/08/11 Copyr 1984 Sun Micro"; +static char sccsid[] = + + "@(#)xdr_array.c 1.10 87/08/11 Copyr 1984 Sun Micro"; #endif /* @@ -55,23 +57,22 @@ static char sccsid[] = "@(#)xdr_array.c 1.10 87/08/11 Copyr 1984 Sun Micro"; * elsize is the size (in bytes) of each element, and elproc is the * xdr procedure to call to handle each element of the array. */ -bool_t -xdr_array(xdrs, addrp, sizep, maxsize, elsize, elproc) - register XDR *xdrs; - caddr_t *addrp; /* array pointer */ - u_int *sizep; /* number of elements */ - u_int maxsize; /* max numberof elements */ - u_int elsize; /* size in bytes of each element */ - xdrproc_t elproc; /* xdr routine to handle each element */ +bool_t xdr_array(xdrs, addrp, sizep, maxsize, elsize, elproc) +register XDR *xdrs; +caddr_t *addrp; /* array pointer */ +u_int *sizep; /* number of elements */ +u_int maxsize; /* max numberof elements */ +u_int elsize; /* size in bytes of each element */ +xdrproc_t elproc; /* xdr routine to handle each element */ { register u_int i; register caddr_t target = *addrp; - register u_int c; /* the actual element count */ + register u_int c; /* the actual element count */ register bool_t stat = TRUE; register u_int nodesize; /* like strings, arrays are really counted arrays */ - if (! xdr_u_int(xdrs, sizep)) { + if (!xdr_u_int(xdrs, sizep)) { return (FALSE); } c = *sizep; @@ -91,8 +92,7 @@ xdr_array(xdrs, addrp, sizep, maxsize, elsize, elproc) return (TRUE); *addrp = target = mem_alloc(nodesize); if (target == NULL) { - (void) fprintf(stderr, - "xdr_array: out of memory\n"); + (void) fprintf(stderr, "xdr_array: out of memory\n"); return (FALSE); } bzero(target, nodesize); @@ -100,13 +100,13 @@ xdr_array(xdrs, addrp, sizep, maxsize, elsize, elproc) case XDR_FREE: return (TRUE); - } - + } + /* * now we xdr each element of array */ for (i = 0; (i < c) && stat; i++) { - stat = (*elproc)(xdrs, target, LASTUNSIGNED); + stat = (*elproc) (xdrs, target, LASTUNSIGNED); target += elsize; } @@ -130,24 +130,22 @@ xdr_array(xdrs, addrp, sizep, maxsize, elsize, elproc) * > elemsize: size of each element * > xdr_elem: routine to XDR each element */ -bool_t -xdr_vector(xdrs, basep, nelem, elemsize, xdr_elem) - register XDR *xdrs; - register char *basep; - register u_int nelem; - register u_int elemsize; - register xdrproc_t xdr_elem; +bool_t xdr_vector(xdrs, basep, nelem, elemsize, xdr_elem) +register XDR *xdrs; +register char *basep; +register u_int nelem; +register u_int elemsize; +register xdrproc_t xdr_elem; { register u_int i; register char *elptr; elptr = basep; for (i = 0; i < nelem; i++) { - if (! (*xdr_elem)(xdrs, elptr, LASTUNSIGNED)) { - return(FALSE); + if (!(*xdr_elem) (xdrs, elptr, LASTUNSIGNED)) { + return (FALSE); } elptr += elemsize; } - return(TRUE); + return (TRUE); } - diff --git a/libc/inet/rpc/xdr_float.c b/libc/inet/rpc/xdr_float.c index ce7b6e07f..f8eb5e99c 100644 --- a/libc/inet/rpc/xdr_float.c +++ b/libc/inet/rpc/xdr_float.c @@ -28,7 +28,9 @@ * Mountain View, California 94043 */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)xdr_float.c 1.12 87/08/11 Copyr 1984 Sun Micro"; +static char sccsid[] = + + "@(#)xdr_float.c 1.12 87/08/11 Copyr 1984 Sun Micro"; #endif /* @@ -59,18 +61,18 @@ static char sccsid[] = "@(#)xdr_float.c 1.12 87/08/11 Copyr 1984 Sun Micro"; #ifdef vax /* What IEEE single precision floating point looks like on a Vax */ -struct ieee_single { - unsigned int mantissa: 23; - unsigned int exp : 8; - unsigned int sign : 1; +struct ieee_single { + unsigned int mantissa:23; + unsigned int exp:8; + unsigned int sign:1; }; /* Vax single precision floating point */ -struct vax_single { - unsigned int mantissa1 : 7; - unsigned int exp : 8; - unsigned int sign : 1; - unsigned int mantissa2 : 16; +struct vax_single { + unsigned int mantissa1:7; + unsigned int exp:8; + unsigned int sign:1; + unsigned int mantissa2:16; }; #define VAX_SNG_BIAS 0x81 @@ -80,17 +82,20 @@ static struct sgl_limits { struct vax_single s; struct ieee_single ieee; } sgl_limits[2] = { - {{ 0x7f, 0xff, 0x0, 0xffff }, /* Max Vax */ - { 0x0, 0xff, 0x0 }}, /* Max IEEE */ - {{ 0x0, 0x0, 0x0, 0x0 }, /* Min Vax */ - { 0x0, 0x0, 0x0 }} /* Min IEEE */ + { { + 0x7f, 0xff, 0x0, 0xffff}, /* Max Vax */ + { + 0x0, 0xff, 0x0}}, /* Max IEEE */ + { { + 0x0, 0x0, 0x0, 0x0}, /* Min Vax */ + { + 0x0, 0x0, 0x0}} /* Min IEEE */ }; -#endif /* vax */ +#endif /* vax */ -bool_t -xdr_float(xdrs, fp) - register XDR *xdrs; - register float *fp; +bool_t xdr_float(xdrs, fp) +register XDR *xdrs; +register float *fp; { #if !defined(mc68000) && !defined(sparc) struct ieee_single is; @@ -102,12 +107,13 @@ xdr_float(xdrs, fp) case XDR_ENCODE: #if defined(mc68000) || defined(sparc) - return (XDR_PUTLONG(xdrs, (long *)fp)); + return (XDR_PUTLONG(xdrs, (long *) fp)); #else - vs = *((struct vax_single *)fp); + vs = *((struct vax_single *) fp); for (i = 0, lim = sgl_limits; - i < sizeof(sgl_limits)/sizeof(struct sgl_limits); - i++, lim++) { + + i < sizeof(sgl_limits) / sizeof(struct sgl_limits); + i++, lim++) { if ((vs.mantissa2 == lim->s.mantissa2) && (vs.exp == lim->s.exp) && (vs.mantissa1 == lim->s.mantissa1)) { @@ -117,21 +123,22 @@ xdr_float(xdrs, fp) } is.exp = vs.exp - VAX_SNG_BIAS + IEEE_SNG_BIAS; is.mantissa = (vs.mantissa1 << 16) | vs.mantissa2; - shipit: + shipit: is.sign = vs.sign; - return (XDR_PUTLONG(xdrs, (long *)&is)); + return (XDR_PUTLONG(xdrs, (long *) &is)); #endif case XDR_DECODE: #if defined(mc68000) || defined(sparc) - return (XDR_GETLONG(xdrs, (long *)fp)); + return (XDR_GETLONG(xdrs, (long *) fp)); #else - vsp = (struct vax_single *)fp; - if (!XDR_GETLONG(xdrs, (long *)&is)) + vsp = (struct vax_single *) fp; + if (!XDR_GETLONG(xdrs, (long *) &is)) return (FALSE); for (i = 0, lim = sgl_limits; - i < sizeof(sgl_limits)/sizeof(struct sgl_limits); - i++, lim++) { + + i < sizeof(sgl_limits) / sizeof(struct sgl_limits); + i++, lim++) { if ((is.exp == lim->ieee.exp) && (is.mantissa == lim->ieee.mantissa)) { *vsp = lim->s; @@ -141,7 +148,7 @@ xdr_float(xdrs, fp) vsp->exp = is.exp - IEEE_SNG_BIAS + VAX_SNG_BIAS; vsp->mantissa2 = is.mantissa; vsp->mantissa1 = (is.mantissa >> 16); - doneit: + doneit: vsp->sign = is.sign; return (TRUE); #endif @@ -158,21 +165,21 @@ xdr_float(xdrs, fp) #ifdef vax /* What IEEE double precision floating point looks like on a Vax */ -struct ieee_double { - unsigned int mantissa1 : 20; - unsigned int exp : 11; - unsigned int sign : 1; - unsigned int mantissa2 : 32; +struct ieee_double { + unsigned int mantissa1:20; + unsigned int exp:11; + unsigned int sign:1; + unsigned int mantissa2:32; }; /* Vax double precision floating point */ -struct vax_double { - unsigned int mantissa1 : 7; - unsigned int exp : 8; - unsigned int sign : 1; - unsigned int mantissa2 : 16; - unsigned int mantissa3 : 16; - unsigned int mantissa4 : 16; +struct vax_double { + unsigned int mantissa1:7; + unsigned int exp:8; + unsigned int sign:1; + unsigned int mantissa2:16; + unsigned int mantissa3:16; + unsigned int mantissa4:16; }; #define VAX_DBL_BIAS 0x81 @@ -180,27 +187,31 @@ struct vax_double { #define MASK(nbits) ((1 << nbits) - 1) static struct dbl_limits { - struct vax_double d; - struct ieee_double ieee; + struct vax_double d; + struct ieee_double ieee; } dbl_limits[2] = { - {{ 0x7f, 0xff, 0x0, 0xffff, 0xffff, 0xffff }, /* Max Vax */ - { 0x0, 0x7ff, 0x0, 0x0 }}, /* Max IEEE */ - {{ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, /* Min Vax */ - { 0x0, 0x0, 0x0, 0x0 }} /* Min IEEE */ + { { + 0x7f, 0xff, 0x0, 0xffff, 0xffff, 0xffff}, /* Max Vax */ + { + 0x0, 0x7ff, 0x0, 0x0}}, /* Max IEEE */ + { { + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, /* Min Vax */ + { + 0x0, 0x0, 0x0, 0x0}} /* Min IEEE */ }; -#endif /* vax */ +#endif /* vax */ -bool_t -xdr_double(xdrs, dp) - register XDR *xdrs; - double *dp; +bool_t xdr_double(xdrs, dp) +register XDR *xdrs; +double *dp; { register long *lp; + #if !defined(mc68000) && !defined(sparc) - struct ieee_double id; - struct vax_double vd; + struct ieee_double id; + struct vax_double vd; register struct dbl_limits *lim; int i; #endif @@ -209,12 +220,13 @@ xdr_double(xdrs, dp) case XDR_ENCODE: #if defined(mc68000) || defined(sparc) - lp = (long *)dp; + lp = (long *) dp; #else - vd = *((struct vax_double *)dp); + vd = *((struct vax_double *) dp); for (i = 0, lim = dbl_limits; - i < sizeof(dbl_limits)/sizeof(struct dbl_limits); - i++, lim++) { + + i < sizeof(dbl_limits) / sizeof(struct dbl_limits); + i++, lim++) { if ((vd.mantissa4 == lim->d.mantissa4) && (vd.mantissa3 == lim->d.mantissa3) && (vd.mantissa2 == lim->d.mantissa2) && @@ -227,25 +239,25 @@ xdr_double(xdrs, dp) id.exp = vd.exp - VAX_DBL_BIAS + IEEE_DBL_BIAS; id.mantissa1 = (vd.mantissa1 << 13) | (vd.mantissa2 >> 3); id.mantissa2 = ((vd.mantissa2 & MASK(3)) << 29) | - (vd.mantissa3 << 13) | - ((vd.mantissa4 >> 3) & MASK(13)); - shipit: + (vd.mantissa3 << 13) | ((vd.mantissa4 >> 3) & MASK(13)); + shipit: id.sign = vd.sign; - lp = (long *)&id; + lp = (long *) &id; #endif return (XDR_PUTLONG(xdrs, lp++) && XDR_PUTLONG(xdrs, lp)); case XDR_DECODE: #if defined(mc68000) || defined(sparc) - lp = (long *)dp; + lp = (long *) dp; return (XDR_GETLONG(xdrs, lp++) && XDR_GETLONG(xdrs, lp)); #else - lp = (long *)&id; + lp = (long *) &id; if (!XDR_GETLONG(xdrs, lp++) || !XDR_GETLONG(xdrs, lp)) return (FALSE); for (i = 0, lim = dbl_limits; - i < sizeof(dbl_limits)/sizeof(struct dbl_limits); - i++, lim++) { + + i < sizeof(dbl_limits) / sizeof(struct dbl_limits); + i++, lim++) { if ((id.mantissa2 == lim->ieee.mantissa2) && (id.mantissa1 == lim->ieee.mantissa1) && (id.exp == lim->ieee.exp)) { @@ -256,12 +268,12 @@ xdr_double(xdrs, dp) vd.exp = id.exp - IEEE_DBL_BIAS + VAX_DBL_BIAS; vd.mantissa1 = (id.mantissa1 >> 13); vd.mantissa2 = ((id.mantissa1 & MASK(13)) << 3) | - (id.mantissa2 >> 29); + (id.mantissa2 >> 29); vd.mantissa3 = (id.mantissa2 >> 13); vd.mantissa4 = (id.mantissa2 << 3); - doneit: + doneit: vd.sign = id.sign; - *dp = *((double *)&vd); + *dp = *((double *) &vd); return (TRUE); #endif diff --git a/libc/inet/rpc/xdr_mem.c b/libc/inet/rpc/xdr_mem.c index 558d36922..b05f2b6f3 100644 --- a/libc/inet/rpc/xdr_mem.c +++ b/libc/inet/rpc/xdr_mem.c @@ -47,16 +47,16 @@ static char sccsid[] = "@(#)xdr_mem.c 1.19 87/08/11 Copyr 1984 Sun Micro"; #include #include -static bool_t xdrmem_getlong(); -static bool_t xdrmem_putlong(); -static bool_t xdrmem_getbytes(); -static bool_t xdrmem_putbytes(); -static u_int xdrmem_getpos(); -static bool_t xdrmem_setpos(); -static long * xdrmem_inline(); -static void xdrmem_destroy(); - -static struct xdr_ops xdrmem_ops = { +static bool_t xdrmem_getlong(); +static bool_t xdrmem_putlong(); +static bool_t xdrmem_getbytes(); +static bool_t xdrmem_putbytes(); +static u_int xdrmem_getpos(); +static bool_t xdrmem_setpos(); +static long *xdrmem_inline(); +static void xdrmem_destroy(); + +static struct xdr_ops xdrmem_ops = { xdrmem_getlong, xdrmem_putlong, xdrmem_getbytes, @@ -71,12 +71,11 @@ static struct xdr_ops xdrmem_ops = { * The procedure xdrmem_create initializes a stream descriptor for a * memory buffer. */ -void -xdrmem_create(xdrs, addr, size, op) - register XDR *xdrs; - caddr_t addr; - u_int size; - enum xdr_op op; +void xdrmem_create(xdrs, addr, size, op) +register XDR *xdrs; +caddr_t addr; +u_int size; +enum xdr_op op; { xdrs->x_op = op; @@ -85,43 +84,43 @@ xdrmem_create(xdrs, addr, size, op) xdrs->x_handy = size; } -static void -xdrmem_destroy(/*xdrs*/) - /*XDR *xdrs;*/ +static void xdrmem_destroy( /*xdrs */ ) + /*XDR *xdrs; */ { } -static bool_t -xdrmem_getlong(xdrs, lp) - register XDR *xdrs; - long *lp; +static bool_t xdrmem_getlong(xdrs, lp) +register XDR *xdrs; +long *lp; { if ((xdrs->x_handy -= sizeof(long)) < 0) return (FALSE); - *lp = (long)ntohl((u_long)(*((long *)(xdrs->x_private)))); + + *lp = (long) ntohl((u_long) (*((long *) (xdrs->x_private)))); xdrs->x_private += sizeof(long); + return (TRUE); } -static bool_t -xdrmem_putlong(xdrs, lp) - register XDR *xdrs; - long *lp; +static bool_t xdrmem_putlong(xdrs, lp) +register XDR *xdrs; +long *lp; { if ((xdrs->x_handy -= sizeof(long)) < 0) return (FALSE); - *(long *)xdrs->x_private = (long)htonl((u_long)(*lp)); + + *(long *) xdrs->x_private = (long) htonl((u_long) (*lp)); xdrs->x_private += sizeof(long); + return (TRUE); } -static bool_t -xdrmem_getbytes(xdrs, addr, len) - register XDR *xdrs; - caddr_t addr; - register u_int len; +static bool_t xdrmem_getbytes(xdrs, addr, len) +register XDR *xdrs; +caddr_t addr; +register u_int len; { if ((xdrs->x_handy -= len) < 0) @@ -131,11 +130,10 @@ xdrmem_getbytes(xdrs, addr, len) return (TRUE); } -static bool_t -xdrmem_putbytes(xdrs, addr, len) - register XDR *xdrs; - caddr_t addr; - register u_int len; +static bool_t xdrmem_putbytes(xdrs, addr, len) +register XDR *xdrs; +caddr_t addr; +register u_int len; { if ((xdrs->x_handy -= len) < 0) @@ -145,33 +143,30 @@ xdrmem_putbytes(xdrs, addr, len) return (TRUE); } -static u_int -xdrmem_getpos(xdrs) - register XDR *xdrs; +static u_int xdrmem_getpos(xdrs) +register XDR *xdrs; { - return ((u_int)xdrs->x_private - (u_int)xdrs->x_base); + return ((u_int) xdrs->x_private - (u_int) xdrs->x_base); } -static bool_t -xdrmem_setpos(xdrs, pos) - register XDR *xdrs; - u_int pos; +static bool_t xdrmem_setpos(xdrs, pos) +register XDR *xdrs; +u_int pos; { register caddr_t newaddr = xdrs->x_base + pos; register caddr_t lastaddr = xdrs->x_private + xdrs->x_handy; - if ((long)newaddr > (long)lastaddr) + if ((long) newaddr > (long) lastaddr) return (FALSE); xdrs->x_private = newaddr; - xdrs->x_handy = (int)lastaddr - (int)newaddr; + xdrs->x_handy = (int) lastaddr - (int) newaddr; return (TRUE); } -static long * -xdrmem_inline(xdrs, len) - register XDR *xdrs; - int len; +static long *xdrmem_inline(xdrs, len) +register XDR *xdrs; +int len; { long *buf = 0; diff --git a/libc/inet/rpc/xdr_rec.c b/libc/inet/rpc/xdr_rec.c index 4d0d4ecfb..94fcc3809 100644 --- a/libc/inet/rpc/xdr_rec.c +++ b/libc/inet/rpc/xdr_rec.c @@ -53,20 +53,20 @@ static char sccsid[] = "@(#)xdr_rec.c 1.21 87/08/11 Copyr 1984 Sun Micro"; #include #include -extern long lseek(); +extern long lseek(); -static u_int fix_buf_size(); +static u_int fix_buf_size(); -static bool_t xdrrec_getlong(); -static bool_t xdrrec_putlong(); -static bool_t xdrrec_getbytes(); -static bool_t xdrrec_putbytes(); -static u_int xdrrec_getpos(); -static bool_t xdrrec_setpos(); -static long * xdrrec_inline(); -static void xdrrec_destroy(); +static bool_t xdrrec_getlong(); +static bool_t xdrrec_putlong(); +static bool_t xdrrec_getbytes(); +static bool_t xdrrec_putbytes(); +static u_int xdrrec_getpos(); +static bool_t xdrrec_setpos(); +static long *xdrrec_inline(); +static void xdrrec_destroy(); -static struct xdr_ops xdrrec_ops = { +static struct xdr_ops xdrrec_ops = { xdrrec_getlong, xdrrec_putlong, xdrrec_getbytes, @@ -98,21 +98,21 @@ typedef struct rec_strm { /* * out-goung bits */ - int (*writeit)(); - caddr_t out_base; /* output buffer (points to frag header) */ - caddr_t out_finger; /* next output position */ - caddr_t out_boundry; /* data cannot up to this address */ - u_long *frag_header; /* beginning of curren fragment */ - bool_t frag_sent; /* true if buffer sent in middle of record */ + int (*writeit) (); + caddr_t out_base; /* output buffer (points to frag header) */ + caddr_t out_finger; /* next output position */ + caddr_t out_boundry; /* data cannot up to this address */ + u_long *frag_header; /* beginning of curren fragment */ + bool_t frag_sent; /* true if buffer sent in middle of record */ /* * in-coming bits */ - int (*readit)(); - u_long in_size; /* fixed size of the input buffer */ + int (*readit) (); + u_long in_size; /* fixed size of the input buffer */ caddr_t in_base; - caddr_t in_finger; /* location of next byte to be had */ - caddr_t in_boundry; /* can read up to this location */ - long fbtbc; /* fragment bytes to be consumed */ + caddr_t in_finger; /* location of next byte to be had */ + caddr_t in_boundry; /* can read up to this location */ + long fbtbc; /* fragment bytes to be consumed */ bool_t last_frag; u_int sendsize; u_int recvsize; @@ -128,20 +128,18 @@ typedef struct rec_strm { * write respectively. They are like the system * calls expect that they take an opaque handle rather than an fd. */ -void -xdrrec_create(xdrs, sendsize, recvsize, tcp_handle, readit, writeit) - register XDR *xdrs; - register u_int sendsize; - register u_int recvsize; - caddr_t tcp_handle; - int (*readit)(); /* like read, but pass it a tcp_handle, not sock */ - int (*writeit)(); /* like write, but pass it a tcp_handle, not sock */ +void xdrrec_create(xdrs, sendsize, recvsize, tcp_handle, readit, writeit) +register XDR *xdrs; +register u_int sendsize; +register u_int recvsize; +caddr_t tcp_handle; +int (*readit) (); /* like read, but pass it a tcp_handle, not sock */ +int (*writeit) (); /* like write, but pass it a tcp_handle, not sock */ { - register RECSTREAM *rstrm = - (RECSTREAM *)mem_alloc(sizeof(RECSTREAM)); + register RECSTREAM *rstrm = (RECSTREAM *) mem_alloc(sizeof(RECSTREAM)); if (rstrm == NULL) { - (void)fprintf(stderr, "xdrrec_create: out of memory\n"); + (void) fprintf(stderr, "xdrrec_create: out of memory\n"); /* * This is bad. Should rework xdrrec_create to * return a handle, and in this case return NULL @@ -153,25 +151,26 @@ xdrrec_create(xdrs, sendsize, recvsize, tcp_handle, readit, writeit) */ rstrm->sendsize = sendsize = fix_buf_size(sendsize); rstrm->recvsize = recvsize = fix_buf_size(recvsize); - rstrm->the_buffer = mem_alloc(sendsize + recvsize + BYTES_PER_XDR_UNIT); + rstrm->the_buffer = + mem_alloc(sendsize + recvsize + BYTES_PER_XDR_UNIT); if (rstrm->the_buffer == NULL) { - (void)fprintf(stderr, "xdrrec_create: out of memory\n"); + (void) fprintf(stderr, "xdrrec_create: out of memory\n"); return; } for (rstrm->out_base = rstrm->the_buffer; - (u_int)rstrm->out_base % BYTES_PER_XDR_UNIT != 0; - rstrm->out_base++); + (u_int) rstrm->out_base % BYTES_PER_XDR_UNIT != 0; + rstrm->out_base++); rstrm->in_base = rstrm->out_base + sendsize; /* * now the rest ... */ xdrs->x_ops = &xdrrec_ops; - xdrs->x_private = (caddr_t)rstrm; + xdrs->x_private = (caddr_t) rstrm; rstrm->tcp_handle = tcp_handle; rstrm->readit = readit; rstrm->writeit = writeit; rstrm->out_finger = rstrm->out_boundry = rstrm->out_base; - rstrm->frag_header = (u_long *)rstrm->out_base; + rstrm->frag_header = (u_long *) rstrm->out_base; rstrm->out_finger += sizeof(u_long); rstrm->out_boundry += sendsize; rstrm->frag_sent = FALSE; @@ -188,36 +187,35 @@ xdrrec_create(xdrs, sendsize, recvsize, tcp_handle, readit, writeit) * xdr handle filled in by xdrrec_create. */ -static bool_t -xdrrec_getlong(xdrs, lp) - XDR *xdrs; - long *lp; +static bool_t xdrrec_getlong(xdrs, lp) +XDR *xdrs; +long *lp; { - register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private); - register long *buflp = (long *)(rstrm->in_finger); + register RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private); + register long *buflp = (long *) (rstrm->in_finger); long mylong; /* first try the inline, fast case */ if ((rstrm->fbtbc >= sizeof(long)) && - (((int)rstrm->in_boundry - (int)buflp) >= sizeof(long))) { - *lp = (long)ntohl((u_long)(*buflp)); + (((int) rstrm->in_boundry - (int) buflp) >= sizeof(long))) { + *lp = (long) ntohl((u_long) (*buflp)); rstrm->fbtbc -= sizeof(long); rstrm->in_finger += sizeof(long); } else { - if (! xdrrec_getbytes(xdrs, (caddr_t)&mylong, sizeof(long))) + if (!xdrrec_getbytes(xdrs, (caddr_t) & mylong, sizeof(long))) return (FALSE); - *lp = (long)ntohl((u_long)mylong); + + *lp = (long) ntohl((u_long) mylong); } return (TRUE); } -static bool_t -xdrrec_putlong(xdrs, lp) - XDR *xdrs; - long *lp; +static bool_t xdrrec_putlong(xdrs, lp) +XDR *xdrs; +long *lp; { - register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private); - register long *dest_lp = ((long *)(rstrm->out_finger)); + register RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private); + register long *dest_lp = ((long *) (rstrm->out_finger)); if ((rstrm->out_finger += sizeof(long)) > rstrm->out_boundry) { /* @@ -225,23 +223,25 @@ xdrrec_putlong(xdrs, lp) * inefficient */ rstrm->out_finger -= sizeof(long); + rstrm->frag_sent = TRUE; - if (! flush_out(rstrm, FALSE)) + if (!flush_out(rstrm, FALSE)) return (FALSE); - dest_lp = ((long *)(rstrm->out_finger)); + dest_lp = ((long *) (rstrm->out_finger)); rstrm->out_finger += sizeof(long); } - *dest_lp = (long)htonl((u_long)(*lp)); + *dest_lp = (long) htonl((u_long) (*lp)); return (TRUE); } -static bool_t /* must manage buffers, fragments, and records */ +static bool_t +/* must manage buffers, fragments, and records */ xdrrec_getbytes(xdrs, addr, len) - XDR *xdrs; - register caddr_t addr; - register u_int len; +XDR *xdrs; +register caddr_t addr; +register u_int len; { - register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private); + register RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private); register int current; while (len > 0) { @@ -249,31 +249,30 @@ xdrrec_getbytes(xdrs, addr, len) if (current == 0) { if (rstrm->last_frag) return (FALSE); - if (! set_input_fragment(rstrm)) + if (!set_input_fragment(rstrm)) return (FALSE); continue; } current = (len < current) ? len : current; - if (! get_input_bytes(rstrm, addr, current)) + if (!get_input_bytes(rstrm, addr, current)) return (FALSE); - addr += current; + addr += current; rstrm->fbtbc -= current; len -= current; } return (TRUE); } -static bool_t -xdrrec_putbytes(xdrs, addr, len) - XDR *xdrs; - register caddr_t addr; - register u_int len; +static bool_t xdrrec_putbytes(xdrs, addr, len) +XDR *xdrs; +register caddr_t addr; +register u_int len; { - register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private); + register RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private); register int current; while (len > 0) { - current = (u_int)rstrm->out_boundry - (u_int)rstrm->out_finger; + current = (u_int) rstrm->out_boundry - (u_int) rstrm->out_finger; current = (len < current) ? len : current; bcopy(addr, rstrm->out_finger, current); rstrm->out_finger += current; @@ -281,21 +280,20 @@ xdrrec_putbytes(xdrs, addr, len) len -= current; if (rstrm->out_finger == rstrm->out_boundry) { rstrm->frag_sent = TRUE; - if (! flush_out(rstrm, FALSE)) + if (!flush_out(rstrm, FALSE)) return (FALSE); } } return (TRUE); } -static u_int -xdrrec_getpos(xdrs) - register XDR *xdrs; +static u_int xdrrec_getpos(xdrs) +register XDR *xdrs; { - register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private; + register RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; register long pos; - pos = lseek((int)rstrm->tcp_handle, (long) 0, 1); + pos = lseek((int) rstrm->tcp_handle, (long) 0, 1); if (pos != -1) switch (xdrs->x_op) { @@ -308,28 +306,27 @@ xdrrec_getpos(xdrs) break; default: - pos = (u_int) -1; + pos = (u_int) - 1; break; } return ((u_int) pos); } -static bool_t -xdrrec_setpos(xdrs, pos) - register XDR *xdrs; - u_int pos; +static bool_t xdrrec_setpos(xdrs, pos) +register XDR *xdrs; +u_int pos; { - register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private; + register RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; u_int currpos = xdrrec_getpos(xdrs); int delta = currpos - pos; caddr_t newpos; - if ((int)currpos != -1) + if ((int) currpos != -1) switch (xdrs->x_op) { case XDR_ENCODE: newpos = rstrm->out_finger - delta; - if ((newpos > (caddr_t)(rstrm->frag_header)) && + if ((newpos > (caddr_t) (rstrm->frag_header)) && (newpos < rstrm->out_boundry)) { rstrm->out_finger = newpos; return (TRUE); @@ -338,7 +335,7 @@ xdrrec_setpos(xdrs, pos) case XDR_DECODE: newpos = rstrm->in_finger - delta; - if ((delta < (int)(rstrm->fbtbc)) && + if ((delta < (int) (rstrm->fbtbc)) && (newpos <= rstrm->in_boundry) && (newpos >= rstrm->in_base)) { rstrm->in_finger = newpos; @@ -350,13 +347,12 @@ xdrrec_setpos(xdrs, pos) return (FALSE); } -static long * -xdrrec_inline(xdrs, len) - register XDR *xdrs; - int len; +static long *xdrrec_inline(xdrs, len) +register XDR *xdrs; +int len; { - register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private; - long * buf = NULL; + register RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; + long *buf = NULL; switch (xdrs->x_op) { @@ -379,15 +375,14 @@ xdrrec_inline(xdrs, len) return (buf); } -static void -xdrrec_destroy(xdrs) - register XDR *xdrs; +static void xdrrec_destroy(xdrs) +register XDR *xdrs; { - register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private; + register RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; mem_free(rstrm->the_buffer, - rstrm->sendsize + rstrm->recvsize + BYTES_PER_XDR_UNIT); - mem_free((caddr_t)rstrm, sizeof(RECSTREAM)); + rstrm->sendsize + rstrm->recvsize + BYTES_PER_XDR_UNIT); + mem_free((caddr_t) rstrm, sizeof(RECSTREAM)); } @@ -399,17 +394,16 @@ xdrrec_destroy(xdrs) * Before reading (deserializing from the stream, one should always call * this procedure to guarantee proper record alignment. */ -bool_t -xdrrec_skiprecord(xdrs) - XDR *xdrs; +bool_t xdrrec_skiprecord(xdrs) +XDR *xdrs; { - register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private); + register RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private); - while (rstrm->fbtbc > 0 || (! rstrm->last_frag)) { - if (! skip_input_bytes(rstrm, rstrm->fbtbc)) + while (rstrm->fbtbc > 0 || (!rstrm->last_frag)) { + if (!skip_input_bytes(rstrm, rstrm->fbtbc)) return (FALSE); rstrm->fbtbc = 0; - if ((! rstrm->last_frag) && (! set_input_fragment(rstrm))) + if ((!rstrm->last_frag) && (!set_input_fragment(rstrm))) return (FALSE); } rstrm->last_frag = FALSE; @@ -421,17 +415,16 @@ xdrrec_skiprecord(xdrs) * Returns TRUE iff there is no more input in the buffer * after consuming the rest of the current record. */ -bool_t -xdrrec_eof(xdrs) - XDR *xdrs; +bool_t xdrrec_eof(xdrs) +XDR *xdrs; { - register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private); + register RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private); - while (rstrm->fbtbc > 0 || (! rstrm->last_frag)) { - if (! skip_input_bytes(rstrm, rstrm->fbtbc)) + while (rstrm->fbtbc > 0 || (!rstrm->last_frag)) { + if (!skip_input_bytes(rstrm, rstrm->fbtbc)) return (TRUE); rstrm->fbtbc = 0; - if ((! rstrm->last_frag) && (! set_input_fragment(rstrm))) + if ((!rstrm->last_frag) && (!set_input_fragment(rstrm))) return (TRUE); } if (rstrm->in_finger == rstrm->in_boundry) @@ -445,24 +438,23 @@ xdrrec_eof(xdrs) * (output) tcp stream. (This let's the package support batched or * pipelined procedure calls.) TRUE => immmediate flush to tcp connection. */ -bool_t -xdrrec_endofrecord(xdrs, sendnow) - XDR *xdrs; - bool_t sendnow; +bool_t xdrrec_endofrecord(xdrs, sendnow) +XDR *xdrs; +bool_t sendnow; { - register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private); - register u_long len; /* fragment length */ + register RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private); + register u_long len; /* fragment length */ if (sendnow || rstrm->frag_sent || - ((u_long)rstrm->out_finger + sizeof(u_long) >= - (u_long)rstrm->out_boundry)) { + ((u_long) rstrm->out_finger + sizeof(u_long) >= + (u_long) rstrm->out_boundry)) { rstrm->frag_sent = FALSE; return (flush_out(rstrm, TRUE)); } - len = (u_long)(rstrm->out_finger) - (u_long)(rstrm->frag_header) - - sizeof(u_long); - *(rstrm->frag_header) = htonl((u_long)len | LAST_FRAG); - rstrm->frag_header = (u_long *)rstrm->out_finger; + len = (u_long) (rstrm->out_finger) - (u_long) (rstrm->frag_header) - + sizeof(u_long); + *(rstrm->frag_header) = htonl((u_long) len | LAST_FRAG); + rstrm->frag_header = (u_long *) rstrm->out_finger; rstrm->out_finger += sizeof(u_long); return (TRUE); } @@ -471,38 +463,38 @@ xdrrec_endofrecord(xdrs, sendnow) /* * Internal useful routines */ -static bool_t -flush_out(rstrm, eor) - register RECSTREAM *rstrm; - bool_t eor; +static bool_t flush_out(rstrm, eor) +register RECSTREAM *rstrm; +bool_t eor; { register u_long eormask = (eor == TRUE) ? LAST_FRAG : 0; - register u_long len = (u_long)(rstrm->out_finger) - - (u_long)(rstrm->frag_header) - sizeof(u_long); + register u_long len = (u_long) (rstrm->out_finger) - + (u_long) (rstrm->frag_header) - sizeof(u_long); *(rstrm->frag_header) = htonl(len | eormask); - len = (u_long)(rstrm->out_finger) - (u_long)(rstrm->out_base); - if ((*(rstrm->writeit))(rstrm->tcp_handle, rstrm->out_base, (int)len) - != (int)len) + len = (u_long) (rstrm->out_finger) - (u_long) (rstrm->out_base); + if ((*(rstrm->writeit)) (rstrm->tcp_handle, rstrm->out_base, (int) len) + != (int) len) return (FALSE); - rstrm->frag_header = (u_long *)rstrm->out_base; - rstrm->out_finger = (caddr_t)rstrm->out_base + sizeof(u_long); + rstrm->frag_header = (u_long *) rstrm->out_base; + rstrm->out_finger = (caddr_t) rstrm->out_base + sizeof(u_long); return (TRUE); } -static bool_t /* knows nothing about records! Only about input buffers */ +static bool_t +/* knows nothing about records! Only about input buffers */ fill_input_buf(rstrm) - register RECSTREAM *rstrm; +register RECSTREAM *rstrm; { register caddr_t where; u_int i; register int len; where = rstrm->in_base; - i = (u_int)rstrm->in_boundry % BYTES_PER_XDR_UNIT; + i = (u_int) rstrm->in_boundry % BYTES_PER_XDR_UNIT; where += i; len = rstrm->in_size - i; - if ((len = (*(rstrm->readit))(rstrm->tcp_handle, where, len)) == -1) + if ((len = (*(rstrm->readit)) (rstrm->tcp_handle, where, len)) == -1) return (FALSE); rstrm->in_finger = where; where += len; @@ -510,18 +502,19 @@ fill_input_buf(rstrm) return (TRUE); } -static bool_t /* knows nothing about records! Only about input buffers */ +static bool_t +/* knows nothing about records! Only about input buffers */ get_input_bytes(rstrm, addr, len) - register RECSTREAM *rstrm; - register caddr_t addr; - register int len; +register RECSTREAM *rstrm; +register caddr_t addr; +register int len; { register int current; while (len > 0) { - current = (int)rstrm->in_boundry - (int)rstrm->in_finger; + current = (int) rstrm->in_boundry - (int) rstrm->in_finger; if (current == 0) { - if (! fill_input_buf(rstrm)) + if (!fill_input_buf(rstrm)) return (FALSE); continue; } @@ -534,31 +527,33 @@ get_input_bytes(rstrm, addr, len) return (TRUE); } -static bool_t /* next two bytes of the input stream are treated as a header */ +static bool_t +/* next two bytes of the input stream are treated as a header */ set_input_fragment(rstrm) - register RECSTREAM *rstrm; +register RECSTREAM *rstrm; { u_long header; - if (! get_input_bytes(rstrm, (caddr_t)&header, sizeof(header))) + if (!get_input_bytes(rstrm, (caddr_t) & header, sizeof(header))) return (FALSE); - header = (long)ntohl(header); + header = (long) ntohl(header); rstrm->last_frag = ((header & LAST_FRAG) == 0) ? FALSE : TRUE; rstrm->fbtbc = header & (~LAST_FRAG); return (TRUE); } -static bool_t /* consumes input bytes; knows nothing about records! */ +static bool_t +/* consumes input bytes; knows nothing about records! */ skip_input_bytes(rstrm, cnt) - register RECSTREAM *rstrm; - long cnt; +register RECSTREAM *rstrm; +long cnt; { register int current; while (cnt > 0) { - current = (int)rstrm->in_boundry - (int)rstrm->in_finger; + current = (int) rstrm->in_boundry - (int) rstrm->in_finger; if (current == 0) { - if (! fill_input_buf(rstrm)) + if (!fill_input_buf(rstrm)) return (FALSE); continue; } @@ -569,9 +564,8 @@ skip_input_bytes(rstrm, cnt) return (TRUE); } -static u_int -fix_buf_size(s) - register u_int s; +static u_int fix_buf_size(s) +register u_int s; { if (s < 100) diff --git a/libc/inet/rpc/xdr_reference.c b/libc/inet/rpc/xdr_reference.c index 32d91d999..61050b6e7 100644 --- a/libc/inet/rpc/xdr_reference.c +++ b/libc/inet/rpc/xdr_reference.c @@ -55,12 +55,11 @@ static char sccsid[] = "@(#)xdr_reference.c 1.11 87/08/11 SMI"; * size is the sizeof the referneced structure. * proc is the routine to handle the referenced structure. */ -bool_t -xdr_reference(xdrs, pp, size, proc) - register XDR *xdrs; - caddr_t *pp; /* the pointer to work on */ - u_int size; /* size of the object pointed to */ - xdrproc_t proc; /* xdr routine to handle the object */ +bool_t xdr_reference(xdrs, pp, size, proc) +register XDR *xdrs; +caddr_t *pp; /* the pointer to work on */ +u_int size; /* size of the object pointed to */ +xdrproc_t proc; /* xdr routine to handle the object */ { register caddr_t loc = *pp; register bool_t stat; @@ -73,15 +72,14 @@ xdr_reference(xdrs, pp, size, proc) case XDR_DECODE: *pp = loc = (caddr_t) mem_alloc(size); if (loc == NULL) { - (void) fprintf(stderr, - "xdr_reference: out of memory\n"); + (void) fprintf(stderr, "xdr_reference: out of memory\n"); return (FALSE); } - bzero(loc, (int)size); + bzero(loc, (int) size); break; - } + } - stat = (*proc)(xdrs, loc, LASTUNSIGNED); + stat = (*proc) (xdrs, loc, LASTUNSIGNED); if (xdrs->x_op == XDR_FREE) { mem_free(loc, size); @@ -110,23 +108,22 @@ xdr_reference(xdrs, pp, size, proc) * > xdr_obj: routine to XDR an object. * */ -bool_t -xdr_pointer(xdrs,objpp,obj_size,xdr_obj) - register XDR *xdrs; - char **objpp; - u_int obj_size; - xdrproc_t xdr_obj; +bool_t xdr_pointer(xdrs, objpp, obj_size, xdr_obj) +register XDR *xdrs; +char **objpp; +u_int obj_size; +xdrproc_t xdr_obj; { bool_t more_data; more_data = (*objpp != NULL); - if (! xdr_bool(xdrs,&more_data)) { + if (!xdr_bool(xdrs, &more_data)) { return (FALSE); } - if (! more_data) { + if (!more_data) { *objpp = NULL; return (TRUE); } - return (xdr_reference(xdrs,objpp,obj_size,xdr_obj)); + return (xdr_reference(xdrs, objpp, obj_size, xdr_obj)); } diff --git a/libc/inet/rpc/xdr_stdio.c b/libc/inet/rpc/xdr_stdio.c index 694774f6f..7ae5fbdab 100644 --- a/libc/inet/rpc/xdr_stdio.c +++ b/libc/inet/rpc/xdr_stdio.c @@ -28,7 +28,9 @@ * Mountain View, California 94043 */ #if !defined(lint) && defined(SCCSIDS) -static char sccsid[] = "@(#)xdr_stdio.c 1.16 87/08/11 Copyr 1984 Sun Micro"; +static char sccsid[] = + + "@(#)xdr_stdio.c 1.16 87/08/11 Copyr 1984 Sun Micro"; #endif /* @@ -45,27 +47,27 @@ static char sccsid[] = "@(#)xdr_stdio.c 1.16 87/08/11 Copyr 1984 Sun Micro"; #include #include -static bool_t xdrstdio_getlong(); -static bool_t xdrstdio_putlong(); -static bool_t xdrstdio_getbytes(); -static bool_t xdrstdio_putbytes(); -static u_int xdrstdio_getpos(); -static bool_t xdrstdio_setpos(); -static long * xdrstdio_inline(); -static void xdrstdio_destroy(); +static bool_t xdrstdio_getlong(); +static bool_t xdrstdio_putlong(); +static bool_t xdrstdio_getbytes(); +static bool_t xdrstdio_putbytes(); +static u_int xdrstdio_getpos(); +static bool_t xdrstdio_setpos(); +static long *xdrstdio_inline(); +static void xdrstdio_destroy(); /* * Ops vector for stdio type XDR */ -static struct xdr_ops xdrstdio_ops = { - xdrstdio_getlong, /* deseraialize a long int */ - xdrstdio_putlong, /* seraialize a long int */ - xdrstdio_getbytes, /* deserialize counted bytes */ - xdrstdio_putbytes, /* serialize counted bytes */ - xdrstdio_getpos, /* get offset in the stream */ - xdrstdio_setpos, /* set offset in the stream */ - xdrstdio_inline, /* prime stream for inline macros */ - xdrstdio_destroy /* destroy stream */ +static struct xdr_ops xdrstdio_ops = { + xdrstdio_getlong, /* deseraialize a long int */ + xdrstdio_putlong, /* seraialize a long int */ + xdrstdio_getbytes, /* deserialize counted bytes */ + xdrstdio_putbytes, /* serialize counted bytes */ + xdrstdio_getpos, /* get offset in the stream */ + xdrstdio_setpos, /* set offset in the stream */ + xdrstdio_inline, /* prime stream for inline macros */ + xdrstdio_destroy /* destroy stream */ }; /* @@ -73,16 +75,15 @@ static struct xdr_ops xdrstdio_ops = { * Sets the xdr stream handle xdrs for use on the stream file. * Operation flag is set to op. */ -void -xdrstdio_create(xdrs, file, op) - register XDR *xdrs; - FILE *file; - enum xdr_op op; +void xdrstdio_create(xdrs, file, op) +register XDR *xdrs; +FILE *file; +enum xdr_op op; { xdrs->x_op = op; xdrs->x_ops = &xdrstdio_ops; - xdrs->x_private = (caddr_t)file; + xdrs->x_private = (caddr_t) file; xdrs->x_handy = 0; xdrs->x_base = 0; } @@ -91,89 +92,86 @@ xdrstdio_create(xdrs, file, op) * Destroy a stdio xdr stream. * Cleans up the xdr stream handle xdrs previously set up by xdrstdio_create. */ -static void -xdrstdio_destroy(xdrs) - register XDR *xdrs; +static void xdrstdio_destroy(xdrs) +register XDR *xdrs; { - (void)fflush((FILE *)xdrs->x_private); + (void) fflush((FILE *) xdrs->x_private); /* xx should we close the file ?? */ }; -static bool_t -xdrstdio_getlong(xdrs, lp) - XDR *xdrs; - register long *lp; +static bool_t xdrstdio_getlong(xdrs, lp) +XDR *xdrs; +register long *lp; { - if (fread((caddr_t)lp, sizeof(long), 1, (FILE *)xdrs->x_private) != 1) - return (FALSE); + if (fread((caddr_t) lp, sizeof(long), 1, (FILE *) xdrs->x_private) != + 1) return (FALSE); + #ifndef mc68000 *lp = ntohl(*lp); #endif return (TRUE); } -static bool_t -xdrstdio_putlong(xdrs, lp) - XDR *xdrs; - long *lp; +static bool_t xdrstdio_putlong(xdrs, lp) +XDR *xdrs; +long *lp; { #ifndef mc68000 long mycopy = htonl(*lp); + lp = &mycopy; #endif - if (fwrite((caddr_t)lp, sizeof(long), 1, (FILE *)xdrs->x_private) != 1) - return (FALSE); + if (fwrite((caddr_t) lp, sizeof(long), 1, (FILE *) xdrs->x_private) != + 1) return (FALSE); + return (TRUE); } -static bool_t -xdrstdio_getbytes(xdrs, addr, len) - XDR *xdrs; - caddr_t addr; - u_int len; +static bool_t xdrstdio_getbytes(xdrs, addr, len) +XDR *xdrs; +caddr_t addr; +u_int len; { - if ((len != 0) && (fread(addr, (int)len, 1, (FILE *)xdrs->x_private) != 1)) + if ((len != 0) + && (fread(addr, (int) len, 1, (FILE *) xdrs->x_private) != 1)) return (FALSE); return (TRUE); } -static bool_t -xdrstdio_putbytes(xdrs, addr, len) - XDR *xdrs; - caddr_t addr; - u_int len; +static bool_t xdrstdio_putbytes(xdrs, addr, len) +XDR *xdrs; +caddr_t addr; +u_int len; { - if ((len != 0) && (fwrite(addr, (int)len, 1, (FILE *)xdrs->x_private) != 1)) + if ((len != 0) + && (fwrite(addr, (int) len, 1, (FILE *) xdrs->x_private) != 1)) return (FALSE); return (TRUE); } -static u_int -xdrstdio_getpos(xdrs) - XDR *xdrs; +static u_int xdrstdio_getpos(xdrs) +XDR *xdrs; { - return ((u_int) ftell((FILE *)xdrs->x_private)); + return ((u_int) ftell((FILE *) xdrs->x_private)); } -static bool_t -xdrstdio_setpos(xdrs, pos) - XDR *xdrs; - u_int pos; -{ +static bool_t xdrstdio_setpos(xdrs, pos) +XDR *xdrs; +u_int pos; +{ - return ((fseek((FILE *)xdrs->x_private, (long)pos, 0) < 0) ? - FALSE : TRUE); + return ((fseek((FILE *) xdrs->x_private, (long) pos, 0) < 0) ? + FALSE : TRUE); } -static long * -xdrstdio_inline(xdrs, len) - XDR *xdrs; - u_int len; +static long *xdrstdio_inline(xdrs, len) +XDR *xdrs; +u_int len; { /* -- cgit v1.2.3