diff options
Diffstat (limited to 'sunrpc')
50 files changed, 7582 insertions, 6918 deletions
diff --git a/sunrpc/Makefile b/sunrpc/Makefile index 1981c75941..9feff64c53 100644 --- a/sunrpc/Makefile +++ b/sunrpc/Makefile @@ -80,9 +80,6 @@ extra-objs = $(rpcgen-objs) all: # Make this the default target; it will be defined in Rules. -# Sun's code is not too clean. -override +gccwarn := -w - include ../Makeconfig ifeq (no,$(cross-compiling)) @@ -96,6 +93,19 @@ librpcsvc-inhibit-o = .so # Build no shared rpcsvc library. omit-deps = $(librpcsvc-routines) endif +CFLAGS-xbootparam.c = -Wno-unused +CFLAGS-xnlm_prot.c = -Wno-unused +CFLAGS-xrstat.c = -Wno-unused +CFLAGS-xyppasswd.c = -Wno-unused +CFLAGS-xklm_prot.c = -Wno-unused +CFLAGS-xrex.c = -Wno-unused +CFLAGS-xsm_inter.c = -Wno-unused +CFLAGS-xmount.c = -Wno-unused +CFLAGS-xrusers.c = -Wno-unused +CFLAGS-xspray.c = -Wno-unused +CFLAGS-xnfs_prot.c = -Wno-unused +CFLAGS-xrquote.c = -Wno-unused + include ../Rules $(objpfx)rpcgen: $(addprefix $(objpfx),$(rpcgen-objs)) $(common-objpfx)libc.a diff --git a/sunrpc/auth_none.c b/sunrpc/auth_none.c index 630037fb47..a7c1524ef5 100644 --- a/sunrpc/auth_none.c +++ b/sunrpc/auth_none.c @@ -6,23 +6,23 @@ * may copy or modify Sun RPC without charge, but are not authorized * to license or distribute it to anyone else except as part of a product or * program developed by the user. - * + * * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. - * + * * Sun RPC is provided with no support and without any obligation on the * part of Sun Microsystems, Inc. to assist in its use, correction, * modification or enhancement. - * + * * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC * OR ANY PART THEREOF. - * + * * In no event will Sun Microsystems, Inc. be liable for any lost revenue * or profits or other special, indirect and consequential damages, even if * Sun has been advised of the possibility of such damages. - * + * * Sun Microsystems, Inc. * 2550 Garcia Avenue * Mountain View, California 94043 @@ -33,101 +33,104 @@ static char sccsid[] = "@(#)auth_none.c 1.19 87/08/11 Copyr 1984 Sun Micro"; /* * auth_none.c - * Creates a client authentication handle for passing "null" - * credentials and verifiers to remote systems. - * - * Copyright (C) 1984, Sun Microsystems, Inc. + * Creates a client authentication handle for passing "null" + * credentials and verifiers to remote systems. + * + * Copyright (C) 1984, Sun Microsystems, Inc. */ #include <rpc/types.h> -#include <rpc/xdr.h> #include <rpc/auth.h> + #define MAX_MARSHEL_SIZE 20 +extern bool_t xdr_opaque_auth (XDR *, struct opaque_auth *); + /* * 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 (AUTH *); +static void authnone_destroy (AUTH *); +static bool_t authnone_marshal (AUTH *, XDR *); +static bool_t authnone_validate (AUTH *, struct opaque_auth *); +static bool_t authnone_refresh (AUTH *); -static struct auth_ops ops = { - authnone_verf, - authnone_marshal, - authnone_validate, - authnone_refresh, - authnone_destroy +static struct auth_ops ops = +{ + authnone_verf, + authnone_marshal, + authnone_validate, + authnone_refresh, + authnone_destroy }; -static struct authnone_private { - AUTH no_client; - char marshalled_client[MAX_MARSHEL_SIZE]; - u_int mcnt; -} *authnone_private; +static struct authnone_private + { + AUTH no_client; + char marshalled_client[MAX_MARSHEL_SIZE]; + u_int mcnt; + } + *authnone_private; AUTH * -authnone_create() +authnone_create (void) { - register struct authnone_private *ap = authnone_private; - XDR xdr_stream; - register XDR *xdrs; + struct authnone_private *ap = authnone_private; + XDR xdr_stream; + XDR *xdrs; - if (ap == 0) { - ap = (struct authnone_private *)calloc(1, sizeof (*ap)); - if (ap == 0) - return (0); - authnone_private = ap; - } - if (!ap->mcnt) { - 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); - ap->mcnt = XDR_GETPOS(xdrs); - XDR_DESTROY(xdrs); - } - return (&ap->no_client); + if (ap == 0) + { + ap = (struct authnone_private *) calloc (1, sizeof (*ap)); + if (ap == 0) + return NULL; + authnone_private = ap; + } + if (!ap->mcnt) + { + 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); + ap->mcnt = XDR_GETPOS (xdrs); + XDR_DESTROY (xdrs); + } + return (&ap->no_client); } -/*ARGSUSED*/ +/*ARGSUSED */ static bool_t -authnone_marshal(client, xdrs) - AUTH *client; - XDR *xdrs; +authnone_marshal (AUTH *client, XDR *xdrs) { - register struct authnone_private *ap = authnone_private; + struct authnone_private *ap = authnone_private; - if (ap == 0) - return (0); - return ((*xdrs->x_ops->x_putbytes)(xdrs, - ap->marshalled_client, ap->mcnt)); + if (ap == 0) + return (0); + return ((*xdrs->x_ops->x_putbytes) (xdrs, + ap->marshalled_client, ap->mcnt)); } -static void -authnone_verf() +static void +authnone_verf (AUTH *auth) { } static bool_t -authnone_validate() +authnone_validate (AUTH *auth, struct opaque_auth *oa) { - - return (TRUE); + return TRUE; } static bool_t -authnone_refresh() +authnone_refresh (AUTH *auth) { - - return (FALSE); + return FALSE; } static void -authnone_destroy() +authnone_destroy (AUTH *auth) { } diff --git a/sunrpc/auth_unix.c b/sunrpc/auth_unix.c index 8890a926ba..5e5dc995ca 100644 --- a/sunrpc/auth_unix.c +++ b/sunrpc/auth_unix.c @@ -45,6 +45,7 @@ static char sccsid[] = "@(#)auth_unix.c 1.19 87/08/11 Copyr 1984 Sun Micro"; #include <limits.h> #include <stdio.h> +#include <string.h> #include <unistd.h> #include <sys/param.h> @@ -53,36 +54,40 @@ static char sccsid[] = "@(#)auth_unix.c 1.19 87/08/11 Copyr 1984 Sun Micro"; #include <rpc/auth.h> #include <rpc/auth_unix.h> +extern bool_t xdr_opaque_auth (XDR *, struct opaque_auth *); + /* * 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 struct auth_ops auth_unix_ops = { - authunix_nextverf, - authunix_marshal, - authunix_validate, - authunix_refresh, - authunix_destroy +static void authunix_nextverf (AUTH *); +static bool_t authunix_marshal (AUTH *, XDR *); +static bool_t authunix_validate (AUTH *, struct opaque_auth *); +static bool_t authunix_refresh (AUTH *); +static void authunix_destroy (AUTH *); + +static struct auth_ops auth_unix_ops = +{ + authunix_nextverf, + authunix_marshal, + authunix_validate, + authunix_refresh, + authunix_destroy }; /* * 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 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 */ + }; #define AUTH_PRIVATE(auth) ((struct audata *)auth->ah_private) -static bool_t marshal_new_auth(); +static bool_t marshal_new_auth (AUTH *); /* @@ -90,77 +95,72 @@ static bool_t marshal_new_auth(); * Returns an auth handle with the given stuff in it. */ AUTH * -authunix_create(machname, uid, gid, len, aup_gids) - char *machname; - uid_t uid; - gid_t gid; - register int len; - gid_t *aup_gids; +authunix_create (machname, uid, gid, len, aup_gids) + char *machname; + uid_t uid; + gid_t gid; + int len; + gid_t *aup_gids; { - struct authunix_parms aup; - char mymem[MAX_AUTH_BYTES]; - struct timeval now; - XDR xdrs; - register AUTH *auth; - register struct audata *au; - - /* - * Allocate and set up auth handle - */ - auth = (AUTH *)mem_alloc(sizeof(*auth)); -#ifndef KERNEL - if (auth == NULL) { - (void)fprintf(stderr, "authunix_create: out of memory\n"); - return (NULL); - } -#endif - au = (struct audata *)mem_alloc(sizeof(*au)); -#ifndef KERNEL - if (au == NULL) { - (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_verf = au->au_shcred = _null_auth; - au->au_shfaults = 0; - - /* - * fill in param struct from the given params - */ - (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_gids = aup_gids; - - /* - * Serialize the parameters into origcred - */ - xdrmem_create(&xdrs, mymem, MAX_AUTH_BYTES, XDR_ENCODE); - if (! xdr_authunix_parms(&xdrs, &aup)) - abort(); - au->au_origcred.oa_length = len = XDR_GETPOS(&xdrs); - au->au_origcred.oa_flavor = AUTH_UNIX; -#ifdef KERNEL - 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"); - return (NULL); - } -#endif - bcopy(mymem, au->au_origcred.oa_base, (u_int)len); - - /* - * set auth handle to reflect new cred. - */ - auth->ah_cred = au->au_origcred; - marshal_new_auth(auth); - return (auth); + struct authunix_parms aup; + char mymem[MAX_AUTH_BYTES]; + struct timeval now; + XDR xdrs; + AUTH *auth; + struct audata *au; + + /* + * Allocate and set up auth handle + */ + auth = (AUTH *) mem_alloc (sizeof (*auth)); + if (auth == NULL) + { + (void) fprintf (stderr, _("authunix_create: out of memory\n")); + return NULL; + } + au = (struct audata *) mem_alloc (sizeof (*au)); + if (au == NULL) + { + (void) fprintf (stderr, _("authunix_create: out of memory\n")); + return NULL; + } + auth->ah_ops = &auth_unix_ops; + 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); + 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_gids = aup_gids; + + /* + * Serialize the parameters into origcred + */ + xdrmem_create (&xdrs, mymem, MAX_AUTH_BYTES, XDR_ENCODE); + if (!xdr_authunix_parms (&xdrs, &aup)) + abort (); + au->au_origcred.oa_length = len = XDR_GETPOS (&xdrs); + au->au_origcred.oa_flavor = AUTH_UNIX; + if ((au->au_origcred.oa_base = mem_alloc ((u_int) len)) == NULL) + { + (void) fprintf (stderr, _("authunix_create: out of memory\n")); + return NULL; + } + bcopy (mymem, au->au_origcred.oa_base, (u_int) len); + + /* + * set auth handle to reflect new cred. + */ + auth->ah_cred = au->au_origcred; + marshal_new_auth (auth); + return auth; } /* @@ -168,27 +168,27 @@ authunix_create(machname, uid, gid, len, aup_gids) * syscalls. */ AUTH * -authunix_create_default() +authunix_create_default (void) { - register int len; - char machname[MAX_MACHINE_NAME + 1]; - register uid_t uid; - register gid_t gid; - int max_nr_groups = sysconf (_SC_NGROUPS_MAX); - gid_t gids[max_nr_groups]; - - if (gethostname(machname, MAX_MACHINE_NAME) == -1) - abort(); - machname[MAX_MACHINE_NAME] = 0; - uid = geteuid(); - gid = getegid(); - - if ((len = getgroups(max_nr_groups, gids)) < 0) - abort(); - /* This braindamaged Sun code forces us here to truncate the - list of groups to NGRPS members since the code in - authuxprot.c transforms a fixed array. Grrr. */ - return (authunix_create(machname, uid, gid, MIN (NGRPS, len), gids)); + int len; + char machname[MAX_MACHINE_NAME + 1]; + uid_t uid; + gid_t gid; + int max_nr_groups = sysconf (_SC_NGROUPS_MAX); + gid_t gids[max_nr_groups]; + + if (gethostname (machname, MAX_MACHINE_NAME) == -1) + abort (); + machname[MAX_MACHINE_NAME] = 0; + uid = geteuid (); + gid = getegid (); + + if ((len = getgroups (max_nr_groups, gids)) < 0) + abort (); + /* This braindamaged Sun code forces us here to truncate the + list of groups to NGRPS members since the code in + authuxprot.c transforms a fixed array. Grrr. */ + return authunix_create (machname, uid, gid, MIN (NGRPS, len), gids); } /* @@ -196,113 +196,112 @@ authunix_create_default() */ static void -authunix_nextverf(auth) - AUTH *auth; +authunix_nextverf (AUTH *auth) { - /* no action necessary */ + /* no action necessary */ } static bool_t -authunix_marshal(auth, xdrs) - AUTH *auth; - XDR *xdrs; +authunix_marshal (AUTH *auth, XDR *xdrs) { - register struct audata *au = AUTH_PRIVATE(auth); + struct audata *au = AUTH_PRIVATE (auth); - return (XDR_PUTBYTES(xdrs, au->au_marshed, au->au_mpos)); + return XDR_PUTBYTES (xdrs, au->au_marshed, au->au_mpos); } static bool_t -authunix_validate(auth, verf) - register AUTH *auth; - struct opaque_auth *verf; +authunix_validate (AUTH *auth, struct opaque_auth *verf) { - register struct audata *au; - XDR xdrs; - - if (verf->oa_flavor == AUTH_SHORT) { - au = AUTH_PRIVATE(auth); - 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); - 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); - au->au_shcred.oa_base = NULL; - auth->ah_cred = au->au_origcred; - } - marshal_new_auth(auth); + struct audata *au; + XDR xdrs; + + if (verf->oa_flavor == AUTH_SHORT) + { + au = AUTH_PRIVATE (auth); + 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); + au->au_shcred.oa_base = NULL; + } + if (xdr_opaque_auth (&xdrs, &au->au_shcred)) + { + auth->ah_cred = au->au_shcred; } - return (TRUE); + else + { + xdrs.x_op = XDR_FREE; + (void) xdr_opaque_auth (&xdrs, &au->au_shcred); + au->au_shcred.oa_base = NULL; + auth->ah_cred = au->au_origcred; + } + marshal_new_auth (auth); + } + return TRUE; } static bool_t -authunix_refresh(auth) - register AUTH *auth; +authunix_refresh (AUTH *auth) { - register struct audata *au = AUTH_PRIVATE(auth); - struct authunix_parms aup; - struct timeval now; - XDR xdrs; - register int stat; - - if (auth->ah_cred.oa_base == au->au_origcred.oa_base) { - /* there is no hope. Punt */ - return (FALSE); - } - au->au_shfaults ++; - - /* first deserialize the creds back into a struct authunix_parms */ - aup.aup_machname = NULL; - aup.aup_gids = (gid_t *)NULL; - xdrmem_create(&xdrs, au->au_origcred.oa_base, - au->au_origcred.oa_length, XDR_DECODE); - stat = xdr_authunix_parms(&xdrs, &aup); - if (! stat) - goto done; - - /* update the time and serialize in place */ - (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) - goto done; - auth->ah_cred = au->au_origcred; - marshal_new_auth(auth); + struct audata *au = AUTH_PRIVATE (auth); + struct authunix_parms aup; + struct timeval now; + XDR xdrs; + int stat; + + if (auth->ah_cred.oa_base == au->au_origcred.oa_base) + { + /* there is no hope. Punt */ + return FALSE; + } + au->au_shfaults++; + + /* first deserialize the creds back into a struct authunix_parms */ + aup.aup_machname = NULL; + aup.aup_gids = (gid_t *) NULL; + xdrmem_create (&xdrs, au->au_origcred.oa_base, + au->au_origcred.oa_length, XDR_DECODE); + stat = xdr_authunix_parms (&xdrs, &aup); + if (!stat) + goto done; + + /* update the time and serialize in place */ + (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) + goto done; + auth->ah_cred = au->au_origcred; + marshal_new_auth (auth); done: - /* free the struct authunix_parms created by deserializing */ - xdrs.x_op = XDR_FREE; - (void)xdr_authunix_parms(&xdrs, &aup); - XDR_DESTROY(&xdrs); - return (stat); + /* free the struct authunix_parms created by deserializing */ + xdrs.x_op = XDR_FREE; + (void) xdr_authunix_parms (&xdrs, &aup); + XDR_DESTROY (&xdrs); + return stat; } static void -authunix_destroy(auth) - register AUTH *auth; +authunix_destroy (AUTH *auth) { - register struct audata *au = AUTH_PRIVATE(auth); + struct audata *au = AUTH_PRIVATE (auth); - mem_free(au->au_origcred.oa_base, au->au_origcred.oa_length); + mem_free (au->au_origcred.oa_base, au->au_origcred.oa_length); - if (au->au_shcred.oa_base != NULL) - mem_free(au->au_shcred.oa_base, au->au_shcred.oa_length); + if (au->au_shcred.oa_base != NULL) + mem_free (au->au_shcred.oa_base, au->au_shcred.oa_length); - mem_free(auth->ah_private, sizeof(struct audata)); + mem_free (auth->ah_private, sizeof (struct audata)); - if (auth->ah_verf.oa_base != NULL) - mem_free(auth->ah_verf.oa_base, auth->ah_verf.oa_length); + 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)); } /* @@ -310,19 +309,23 @@ authunix_destroy(auth) * sets private data, au_marshed and au_mpos */ static bool_t -marshal_new_auth(auth) - register AUTH *auth; +marshal_new_auth (AUTH *auth) { - 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)))) { - perror(_("auth_none.c - Fatal marshalling problem")); - } else { - au->au_mpos = XDR_GETPOS(xdrs); - } - XDR_DESTROY(xdrs); + XDR xdr_stream; + XDR *xdrs = &xdr_stream; + 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)))) + { + perror (_("auth_none.c - Fatal marshalling problem")); + } + else + { + au->au_mpos = XDR_GETPOS (xdrs); + } + XDR_DESTROY (xdrs); + + return TRUE; } diff --git a/sunrpc/authuxprot.c b/sunrpc/authuxprot.c index 9b21ce195e..d172ebc655 100644 --- a/sunrpc/authuxprot.c +++ b/sunrpc/authuxprot.c @@ -48,24 +48,22 @@ 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; +xdr_authunix_parms (XDR * xdrs, struct authunix_parms *p) { - - if (xdr_u_long(xdrs, &(p->aup_time)) - && xdr_string(xdrs, &(p->aup_machname), MAX_MACHINE_NAME) - && (sizeof (uid_t) == sizeof (short int) - ? xdr_u_short(xdrs, (u_short *) &(p->aup_uid)) - : xdr_u_int(xdrs, (u_int *) &(p->aup_uid))) - && (sizeof (gid_t) == sizeof (short int) - ? xdr_u_short(xdrs, (u_short *) &(p->aup_gid)) - : xdr_u_int(xdrs, (u_int *) &(p->aup_gid))) - && xdr_array(xdrs, (caddr_t *)&(p->aup_gids), - &(p->aup_len), NGRPS, sizeof(gid_t), - (sizeof (gid_t) == sizeof (short int) - ? xdr_u_short : xdr_u_int)) ) { - return (TRUE); - } - return (FALSE); + if (xdr_u_long (xdrs, &(p->aup_time)) + && xdr_string (xdrs, &(p->aup_machname), MAX_MACHINE_NAME) + && (sizeof (uid_t) == sizeof (short int) + ? xdr_u_short (xdrs, (u_short *) & (p->aup_uid)) + : xdr_u_int (xdrs, (u_int *) & (p->aup_uid))) + && (sizeof (gid_t) == sizeof (short int) + ? xdr_u_short (xdrs, (u_short *) & (p->aup_gid)) + : xdr_u_int (xdrs, (u_int *) & (p->aup_gid))) + && xdr_array (xdrs, (caddr_t *) & (p->aup_gids), + & (p->aup_len), NGRPS, sizeof (gid_t), + (sizeof (gid_t) == sizeof (short int) + ? (xdrproc_t) xdr_u_short : (xdrproc_t) xdr_u_int))) + { + return TRUE; + } + return FALSE; } diff --git a/sunrpc/bindrsvprt.c b/sunrpc/bindrsvprt.c index 44660dede6..e1d53ce950 100644 --- a/sunrpc/bindrsvprt.c +++ b/sunrpc/bindrsvprt.c @@ -1,4 +1,3 @@ -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 @@ -27,11 +26,15 @@ static char sccsid[] = "@(#)bindresvport.c 2.2 88/07/29 4.0 RPCSRC 1.8 88/02/08 * 2550 Garcia Avenue * Mountain View, California 94043 */ - +#if !defined(lint) && defined(SCCSIDS) +static char sccsid[] = "@(#)bindresvport.c 2.2 88/07/29 4.0 RPCSRC 1.8 88/02/08 SMI"; +#endif /* * Copyright (c) 1987 by Sun Microsystems, Inc. */ +#include <unistd.h> +#include <string.h> #include <sys/types.h> #include <sys/errno.h> #include <sys/socket.h> @@ -40,41 +43,46 @@ 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 +bindresvport (int sd, struct sockaddr_in *sin) { - int res; - static short port; - struct sockaddr_in myaddr; + int res; + static short port; + struct sockaddr_in myaddr; #ifndef errno - extern int errno; + extern int errno; #endif - int i; + int i; #define STARTPORT 600 #define ENDPORT (IPPORT_RESERVED - 1) #define NPORTS (ENDPORT - STARTPORT + 1) - if (sin == (struct sockaddr_in *)0) { - sin = &myaddr; - bzero(sin, sizeof (*sin)); - sin->sin_family = AF_INET; - } else if (sin->sin_family != AF_INET) { - __set_errno (EPFNOSUPPORT); - return (-1); - } - if (port == 0) { - port = (getpid() % NPORTS) + STARTPORT; - } - res = -1; - __set_errno (EADDRINUSE); - for (i = 0; i < NPORTS && res < 0 && errno == EADDRINUSE; i++) { - sin->sin_port = htons(port++); - if (port > ENDPORT) { - port = STARTPORT; - } - res = bind(sd, sin, sizeof(struct sockaddr_in)); + if (sin == (struct sockaddr_in *) 0) + { + sin = &myaddr; + bzero (sin, sizeof (*sin)); + sin->sin_family = AF_INET; + } + else if (sin->sin_family != AF_INET) + { + __set_errno (EPFNOSUPPORT); + return -1; + } + if (port == 0) + { + port = (getpid () % NPORTS) + STARTPORT; + } + res = -1; + __set_errno (EADDRINUSE); + for (i = 0; i < NPORTS && res < 0 && errno == EADDRINUSE; i++) + { + sin->sin_port = htons (port++); + if (port > ENDPORT) + { + port = STARTPORT; } - return (res); + res = bind (sd, sin, sizeof (struct sockaddr_in)); + } + return res; } diff --git a/sunrpc/clnt_gen.c b/sunrpc/clnt_gen.c index d7b949caa6..c24442cb36 100644 --- a/sunrpc/clnt_gen.c +++ b/sunrpc/clnt_gen.c @@ -35,6 +35,7 @@ static char sccsid[] = "@(#)clnt_generic.c 1.4 87/08/11 (C) 1987 SMI"; */ #include <alloca.h> #include <errno.h> +#include <string.h> #include <rpc/rpc.h> #include <sys/socket.h> #include <sys/errno.h> @@ -46,95 +47,96 @@ static char sccsid[] = "@(#)clnt_generic.c 1.4 87/08/11 (C) 1987 SMI"; * change using the rpc equivalent of ioctl()'s. */ CLIENT * -clnt_create(hostname, prog, vers, proto) - char *hostname; - unsigned prog; - unsigned vers; - char *proto; +clnt_create (const char *hostname, u_long prog, u_long vers, + const char *proto) { - struct hostent hostbuf, *h; - size_t hstbuflen; - char *hsttmpbuf; - struct protoent protobuf, *p; - size_t prtbuflen; - char *prttmpbuf; - struct sockaddr_in sin; - int sock; - struct timeval tv; - CLIENT *client; - int herr; + struct hostent hostbuf, *h; + size_t hstbuflen; + char *hsttmpbuf; + struct protoent protobuf, *p; + size_t prtbuflen; + char *prttmpbuf; + struct sockaddr_in sin; + int sock; + struct timeval tv; + CLIENT *client; + int herr; - hstbuflen = 1024; + hstbuflen = 1024; + hsttmpbuf = __alloca (hstbuflen); + while (__gethostbyname_r (hostname, &hostbuf, hsttmpbuf, hstbuflen, + &h, &herr) < 0) + if (herr != NETDB_INTERNAL || errno != ERANGE) + { + rpc_createerr.cf_stat = RPC_UNKNOWNHOST; + return NULL; + } + else + { + /* Enlarge the buffer. */ + hstbuflen *= 2; hsttmpbuf = __alloca (hstbuflen); - while (__gethostbyname_r (hostname, &hostbuf, hsttmpbuf, hstbuflen, - &h, &herr) < 0) - if (herr != NETDB_INTERNAL || errno != ERANGE) - { - rpc_createerr.cf_stat = RPC_UNKNOWNHOST; - return NULL; - } - else - { - /* Enlarge the buffer. */ - hstbuflen *= 2; - hsttmpbuf = __alloca (hstbuflen); - } + } - if (h->h_addrtype != AF_INET) { - /* - * Only support INET for now - */ - rpc_createerr.cf_stat = RPC_SYSTEMERROR; - rpc_createerr.cf_error.re_errno = EAFNOSUPPORT; - return (NULL); - } - sin.sin_family = h->h_addrtype; - sin.sin_port = 0; - bzero(sin.sin_zero, sizeof(sin.sin_zero)); - bcopy(h->h_addr, (char*)&sin.sin_addr, h->h_length); + if (h->h_addrtype != AF_INET) + { + /* + * Only support INET for now + */ + rpc_createerr.cf_stat = RPC_SYSTEMERROR; + rpc_createerr.cf_error.re_errno = EAFNOSUPPORT; + return NULL; + } + sin.sin_family = h->h_addrtype; + sin.sin_port = 0; + bzero (sin.sin_zero, sizeof (sin.sin_zero)); + bcopy (h->h_addr, (char *) &sin.sin_addr, h->h_length); - prtbuflen = 1024; + prtbuflen = 1024; + prttmpbuf = __alloca (prtbuflen); + while (__getprotobyname_r (proto, &protobuf, prttmpbuf, prtbuflen, &p) + < 0) + if (errno != ERANGE) + { + rpc_createerr.cf_stat = RPC_UNKNOWNPROTO; + rpc_createerr.cf_error.re_errno = EPFNOSUPPORT; + return NULL; + } + else + { + /* Enlarge the buffer. */ + prtbuflen *= 2; prttmpbuf = __alloca (prtbuflen); - while (__getprotobyname_r (proto, &protobuf, prttmpbuf, prtbuflen, &p) - < 0) - if (errno != ERANGE) - { - rpc_createerr.cf_stat = RPC_UNKNOWNPROTO; - rpc_createerr.cf_error.re_errno = EPFNOSUPPORT; - return NULL; - } - else - { - /* Enlarge the buffer. */ - prtbuflen *= 2; - prttmpbuf = __alloca (prtbuflen); - } + } - sock = RPC_ANYSOCK; - switch (p->p_proto) { - case IPPROTO_UDP: - tv.tv_sec = 5; - tv.tv_usec = 0; - client = clntudp_create(&sin, prog, vers, tv, &sock); - if (client == NULL) { - return (NULL); - } - tv.tv_sec = 25; - clnt_control(client, CLSET_TIMEOUT, &tv); - break; - case IPPROTO_TCP: - client = clnttcp_create(&sin, prog, vers, &sock, 0, 0); - if (client == NULL) { - return (NULL); - } - tv.tv_sec = 25; - tv.tv_usec = 0; - clnt_control(client, CLSET_TIMEOUT, &tv); - break; - default: - rpc_createerr.cf_stat = RPC_SYSTEMERROR; - rpc_createerr.cf_error.re_errno = EPFNOSUPPORT; - return (NULL); + sock = RPC_ANYSOCK; + switch (p->p_proto) + { + case IPPROTO_UDP: + tv.tv_sec = 5; + tv.tv_usec = 0; + client = clntudp_create (&sin, prog, vers, tv, &sock); + if (client == NULL) + { + return NULL; + } + tv.tv_sec = 25; + clnt_control (client, CLSET_TIMEOUT, (char *)&tv); + break; + case IPPROTO_TCP: + client = clnttcp_create (&sin, prog, vers, &sock, 0, 0); + if (client == NULL) + { + return NULL; } - return (client); + tv.tv_sec = 25; + tv.tv_usec = 0; + clnt_control (client, CLSET_TIMEOUT, (char *)&tv); + break; + default: + rpc_createerr.cf_stat = RPC_SYSTEMERROR; + rpc_createerr.cf_error.re_errno = EPFNOSUPPORT; + return (NULL); + } + return client; } diff --git a/sunrpc/clnt_perr.c b/sunrpc/clnt_perr.c index 147a5ea23c..68f3640cd7 100644 --- a/sunrpc/clnt_perr.c +++ b/sunrpc/clnt_perr.c @@ -38,165 +38,156 @@ static char sccsid[] = "@(#)clnt_perror.c 1.15 87/10/07 Copyr 1984 Sun Micro"; * */ #include <stdio.h> - +#include <string.h> #include <rpc/types.h> #include <rpc/auth.h> #include <rpc/clnt.h> -/* extern char *sys_errlist[]; --drepper@gnu */ -/* extern char *sprintf(); --roland@gnu */ -static char *auth_errmsg(); - -extern char *strcpy(); +static char *auth_errmsg (enum auth_stat stat); static char *buf; static char * -_buf() +_buf (void) { - - if (buf == 0) - buf = (char *)malloc(256); - return (buf); + if (buf == NULL) + buf = (char *) malloc (256); + return buf; } /* * Print reply error info */ char * -clnt_sperror(rpch, s) - CLIENT *rpch; - char *s; +clnt_sperror (CLIENT * rpch, const char *msg) { - struct rpc_err e; - void clnt_perrno(); - char *err; - char *str = _buf(); - char *strstart = str; - - if (str == 0) - return (0); - CLNT_GETERR(rpch, &e); - - (void) sprintf(str, "%s: ", s); - str += strlen(str); - - (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_PROGUNAVAIL: - case RPC_PROCUNAVAIL: - case RPC_CANTDECODEARGS: - case RPC_SYSTEMERROR: - case RPC_UNKNOWNHOST: - case RPC_UNKNOWNPROTO: - case RPC_PMAPFAILURE: - case RPC_PROGNOTREGISTERED: - case RPC_FAILED: - break; - - case RPC_CANTSEND: - case RPC_CANTRECV: - (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); - str += strlen(str); - break; - - case RPC_AUTHERROR: - err = auth_errmsg(e.re_why); - (void) sprintf(str,_("; why = ")); - str += strlen(str); - if (err != NULL) { - (void) sprintf(str, "%s",err); - } else { - (void) sprintf(str, - _("(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); - str += strlen(str); - break; - - default: /* unknown */ - (void) sprintf(str, - "; s1 = %lu, s2 = %lu", - e.re_lb.s1, e.re_lb.s2); - str += strlen(str); - break; + char buf[1024]; + struct rpc_err e; + char *err; + char *str = _buf (); + char *strstart = str; + int len; + + if (str == NULL) + return NULL; + CLNT_GETERR (rpch, &e); + + len = sprintf (str, "%s: ", msg); + str += len; + + str = stpcpy (str, clnt_sperrno (e.re_status)); + + switch (e.re_status) + { + case RPC_SUCCESS: + case RPC_CANTENCODEARGS: + case RPC_CANTDECODERES: + case RPC_TIMEDOUT: + case RPC_PROGUNAVAIL: + case RPC_PROCUNAVAIL: + case RPC_CANTDECODEARGS: + case RPC_SYSTEMERROR: + case RPC_UNKNOWNHOST: + case RPC_UNKNOWNPROTO: + case RPC_PMAPFAILURE: + case RPC_PROGNOTREGISTERED: + case RPC_FAILED: + break; + + case RPC_CANTSEND: + case RPC_CANTRECV: + len = sprintf (str, "; errno = %s", strerror_r (e.re_errno, + buf, sizeof buf)); + str += len; + break; + + case RPC_VERSMISMATCH: + len= sprintf (str, _("; low version = %lu, high version = %lu"), + e.re_vers.low, e.re_vers.high); + str += len; + break; + + case RPC_AUTHERROR: + err = auth_errmsg (e.re_why); + str = stpcpy (str, _ ("; why = ")); + if (err != NULL) + { + str = stpcpy (str, err); + } + else + { + len = sprintf (str, _("(unknown authentication error - %d)"), + (int) e.re_why); + str += len; } - (void) sprintf(str, "\n"); - return(strstart) ; + break; + + case RPC_PROGVERSMISMATCH: + len = sprintf (str, _("; low version = %lu, high version = %lu"), + e.re_vers.low, e.re_vers.high); + str += len; + break; + + default: /* unknown */ + len = sprintf (str, "; s1 = %lu, s2 = %lu", e.re_lb.s1, e.re_lb.s2); + str += len; + break; + } + *str = '\n'; + return (strstart); } void -clnt_perror(rpch, s) - CLIENT *rpch; - char *s; +clnt_perror (CLIENT * rpch, const char *msg) { - (void) fprintf(stderr,"%s",clnt_sperror(rpch,s)); + (void) fputs (clnt_sperror (rpch, msg), stderr); } -struct rpc_errtab { - enum clnt_stat status; - char *message; +struct rpc_errtab +{ + enum clnt_stat status; + const char *message; }; -static struct rpc_errtab rpc_errlist[] = { - { RPC_SUCCESS, - N_("RPC: Success") }, - { RPC_CANTENCODEARGS, - N_("RPC: Can't encode arguments") }, - { RPC_CANTDECODERES, - N_("RPC: Can't decode result") }, - { RPC_CANTSEND, - N_("RPC: Unable to send") }, - { RPC_CANTRECV, - N_("RPC: Unable to receive") }, - { RPC_TIMEDOUT, - N_("RPC: Timed out") }, - { RPC_VERSMISMATCH, - N_("RPC: Incompatible versions of RPC") }, - { RPC_AUTHERROR, - N_("RPC: Authentication error") }, - { RPC_PROGUNAVAIL, - N_("RPC: Program unavailable") }, - { RPC_PROGVERSMISMATCH, - N_("RPC: Program/version mismatch") }, - { RPC_PROCUNAVAIL, - N_("RPC: Procedure unavailable") }, - { RPC_CANTDECODEARGS, - N_("RPC: Server can't decode arguments") }, - { RPC_SYSTEMERROR, - N_("RPC: Remote system error") }, - { RPC_UNKNOWNHOST, - N_("RPC: Unknown host") }, - { RPC_UNKNOWNPROTO, - N_("RPC: Unknown protocol") }, - { RPC_PMAPFAILURE, - N_("RPC: Port mapper failure") }, - { RPC_PROGNOTREGISTERED, - N_("RPC: Program not registered") }, - { RPC_FAILED, - N_("RPC: Failed (unspecified error)") } +static const struct rpc_errtab rpc_errlist[] = +{ + {RPC_SUCCESS, + N_("RPC: Success")}, + {RPC_CANTENCODEARGS, + N_("RPC: Can't encode arguments")}, + {RPC_CANTDECODERES, + N_("RPC: Can't decode result")}, + {RPC_CANTSEND, + N_("RPC: Unable to send")}, + {RPC_CANTRECV, + N_("RPC: Unable to receive")}, + {RPC_TIMEDOUT, + N_("RPC: Timed out")}, + {RPC_VERSMISMATCH, + N_("RPC: Incompatible versions of RPC")}, + {RPC_AUTHERROR, + N_("RPC: Authentication error")}, + {RPC_PROGUNAVAIL, + N_("RPC: Program unavailable")}, + {RPC_PROGVERSMISMATCH, + N_("RPC: Program/version mismatch")}, + {RPC_PROCUNAVAIL, + N_("RPC: Procedure unavailable")}, + {RPC_CANTDECODEARGS, + N_("RPC: Server can't decode arguments")}, + {RPC_SYSTEMERROR, + N_("RPC: Remote system error")}, + {RPC_UNKNOWNHOST, + N_("RPC: Unknown host")}, + {RPC_UNKNOWNPROTO, + N_("RPC: Unknown protocol")}, + {RPC_PMAPFAILURE, + N_("RPC: Port mapper failure")}, + {RPC_PROGNOTREGISTERED, + N_("RPC: Program not registered")}, + {RPC_FAILED, + N_("RPC: Failed (unspecified error)")} }; @@ -204,102 +195,109 @@ static struct rpc_errtab rpc_errlist[] = { * This interface for use by clntrpc */ char * -clnt_sperrno(stat) - enum clnt_stat stat; +clnt_sperrno (enum clnt_stat stat) { - int i; + int i; - for (i = 0; i < sizeof(rpc_errlist)/sizeof(struct rpc_errtab); i++) { - if (rpc_errlist[i].status == stat) { - return _(rpc_errlist[i].message); - } + for (i = 0; i < sizeof (rpc_errlist) / sizeof (struct rpc_errtab); i++) + { + if (rpc_errlist[i].status == stat) + { + return _(rpc_errlist[i].message); } - return _("RPC: (unknown error code)"); + } + return _("RPC: (unknown error code)"); } void -clnt_perrno(num) - enum clnt_stat num; +clnt_perrno (enum clnt_stat num) { - (void) fprintf(stderr,"%s",clnt_sperrno(num)); + (void) fputs (clnt_sperrno (num), stderr); } char * -clnt_spcreateerror(s) - char *s; +clnt_spcreateerror (const char *msg) { - extern int sys_nerr; - /* extern char *sys_errlist[]; --drepper@gnu */ - char *str = _buf(); - - if (str == 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)); - break; - - case RPC_SYSTEMERROR: - (void) strcat(str, " - "); - if (rpc_createerr.cf_error.re_errno > 0 - && rpc_createerr.cf_error.re_errno < sys_nerr) - (void) strcat(str, - sys_errlist[rpc_createerr.cf_error.re_errno]); - else - (void) sprintf(&str[strlen(str)], _("Error %d"), - rpc_createerr.cf_error.re_errno); - break; + char buf[1024]; + char *str = _buf (); + char *cp; + int len; + + if (str == NULL) + return NULL; + len = sprintf (str, "%s: ", msg); + cp = str + len; + cp = stpcpy (cp, clnt_sperrno (rpc_createerr.cf_stat)); + switch (rpc_createerr.cf_stat) + { + case RPC_PMAPFAILURE: + cp = stpcpy (cp, " - "); + cp = stpcpy (cp, clnt_sperrno (rpc_createerr.cf_error.re_status)); + break; + + case RPC_SYSTEMERROR: + cp = stpcpy (str, " - "); + if (rpc_createerr.cf_error.re_errno > 0 + && rpc_createerr.cf_error.re_errno < sys_nerr) + cp = stpcpy (str, strerror_r (rpc_createerr.cf_error.re_errno, + buf, sizeof buf)); + else + { + len = sprintf (cp, _("Error %d"), rpc_createerr.cf_error.re_errno); + cp += len; } - (void) strcat(str, "\n"); - return (str); + break; + default: + break; + } + *cp = '\n'; + return str; } void -clnt_pcreateerror(s) - char *s; +clnt_pcreateerror (const char *msg) { - (void) fprintf(stderr,"%s",clnt_spcreateerror(s)); + (void) fputs (clnt_spcreateerror (msg), stderr); } -struct auth_errtab { - enum auth_stat status; - char *message; +struct auth_errtab +{ + enum auth_stat status; + const char *message; }; -static struct auth_errtab auth_errlist[] = { - { AUTH_OK, - N_("Authentication OK") }, - { AUTH_BADCRED, - N_("Invalid client credential") }, - { AUTH_REJECTEDCRED, - N_("Server rejected credential") }, - { AUTH_BADVERF, - N_("Invalid client verifier") }, - { AUTH_REJECTEDVERF, - N_("Server rejected verifier") }, - { AUTH_TOOWEAK, - N_("Client credential too weak") }, - { AUTH_INVALIDRESP, - N_("Invalid server verifier") }, - { AUTH_FAILED, - N_("Failed (unspecified error)") }, +static const struct auth_errtab auth_errlist[] = +{ + {AUTH_OK, + N_("Authentication OK")}, + {AUTH_BADCRED, + N_("Invalid client credential")}, + {AUTH_REJECTEDCRED, + N_("Server rejected credential")}, + {AUTH_BADVERF, + N_("Invalid client verifier")}, + {AUTH_REJECTEDVERF, + N_("Server rejected verifier")}, + {AUTH_TOOWEAK, + N_("Client credential too weak")}, + {AUTH_INVALIDRESP, + N_("Invalid server verifier")}, + {AUTH_FAILED, + N_("Failed (unspecified error)")}, }; static char * -auth_errmsg(stat) - enum auth_stat stat; +auth_errmsg (enum auth_stat stat) { - int i; + size_t i; - for (i = 0; i < sizeof(auth_errlist)/sizeof(struct auth_errtab); i++) { - if (auth_errlist[i].status == stat) { - return _(auth_errlist[i].message); - } + for (i = 0; i < sizeof (auth_errlist) / sizeof (struct auth_errtab); i++) + { + if (auth_errlist[i].status == stat) + { + return _(auth_errlist[i].message); } - return(NULL); + } + return NULL; } diff --git a/sunrpc/clnt_raw.c b/sunrpc/clnt_raw.c index fe2aecfa5a..a9ff3ca00a 100644 --- a/sunrpc/clnt_raw.c +++ b/sunrpc/clnt_raw.c @@ -43,196 +43,209 @@ static char sccsid[] = "@(#)clnt_raw.c 1.22 87/08/11 Copyr 1984 Sun Micro"; */ #include <rpc/rpc.h> +#include <rpc/svc.h> +#include <rpc/xdr.h> + +extern bool_t xdr_opaque_auth (XDR *, struct opaque_auth *); #define MCALL_MSG_SIZE 24 /* * 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; -} *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 struct clnt_ops client_ops = { - clntraw_call, - clntraw_abort, - clntraw_geterr, - clntraw_freeres, - clntraw_destroy, - clntraw_control +static struct clntraw_private + { + 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 (CLIENT *, u_long, xdrproc_t, caddr_t, + xdrproc_t, caddr_t, struct timeval); +static void clntraw_abort (void); +static void clntraw_geterr (CLIENT *, struct rpc_err *); +static bool_t clntraw_freeres (CLIENT *, xdrproc_t, caddr_t); +static bool_t clntraw_control (CLIENT *, int, char *); +static void clntraw_destroy (CLIENT *); + +static struct clnt_ops client_ops = +{ + clntraw_call, + clntraw_abort, + clntraw_geterr, + clntraw_freeres, + clntraw_destroy, + clntraw_control }; -void svc_getreq(); - /* * Create a client handle for memory based rpc. */ CLIENT * -clntraw_create(prog, vers) - u_long prog; - u_long vers; +clntraw_create (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; - - if (clp == 0) { - clp = (struct clntraw_private *)calloc(1, sizeof (*clp)); - if (clp == 0) - return (0); - clntraw_private = clp; - } - /* - * pre-serialize the static part of the call msg and stash it away - */ - call_msg.rm_direction = CALL; - call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION; - call_msg.rm_call.cb_prog = prog; - call_msg.rm_call.cb_vers = vers; - 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); - XDR_DESTROY(xdrs); - - /* - * Set xdrmem for client/server shared buffer - */ - xdrmem_create(xdrs, clp->_raw_buf, UDPMSGSIZE, XDR_FREE); - - /* - * create client handle - */ - client->cl_ops = &client_ops; - client->cl_auth = authnone_create(); - return (client); + struct clntraw_private *clp = clntraw_private; + struct rpc_msg call_msg; + XDR *xdrs = &clp->xdr_stream; + CLIENT *client = &clp->client_object; + + if (clp == 0) + { + clp = (struct clntraw_private *) calloc (1, sizeof (*clp)); + if (clp == 0) + return (0); + clntraw_private = clp; + } + /* + * pre-serialize the static part of the call msg and stash it away + */ + call_msg.rm_direction = CALL; + call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION; + call_msg.rm_call.cb_prog = prog; + call_msg.rm_call.cb_vers = vers; + 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); + XDR_DESTROY (xdrs); + + /* + * Set xdrmem for client/server shared buffer + */ + xdrmem_create (xdrs, clp->_raw_buf, UDPMSGSIZE, XDR_FREE); + + /* + * create client handle + */ + client->cl_ops = &client_ops; + client->cl_auth = authnone_create (); + return client; } 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; +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; { - register struct clntraw_private *clp = clntraw_private; - register XDR *xdrs = &clp->xdr_stream; - struct rpc_msg msg; - enum clnt_stat status; - struct rpc_err error; - - if (clp == 0) - return (RPC_FAILED); + struct clntraw_private *clp = clntraw_private; + XDR *xdrs = &clp->xdr_stream; + struct rpc_msg msg; + enum clnt_stat status; + struct rpc_err error; + + if (clp == NULL) + return RPC_FAILED; 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))) { - return (RPC_CANTENCODEARGS); + /* + * 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))) + { + return (RPC_CANTENCODEARGS); + } + (void) XDR_GETPOS (xdrs); /* called just to cause overhead */ + + /* + * We have to call server input routine here because this is + * all going on in one process. Yuk. + */ + svc_getreq (1); + + /* + * get results + */ + xdrs->x_op = XDR_DECODE; + XDR_SETPOS (xdrs, 0); + 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)) + 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)) + { + status = RPC_AUTHERROR; } - (void)XDR_GETPOS(xdrs); /* called just to cause overhead */ - - /* - * We have to call server input routine here because this is - * all going on in one process. Yuk. - */ - svc_getreq(1); - - /* - * get results - */ - xdrs->x_op = XDR_DECODE; - XDR_SETPOS(xdrs, 0); - 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)) - 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)) { - status = RPC_AUTHERROR; - } - } /* end successful completion */ - else { - if (AUTH_REFRESH(h->cl_auth)) - goto call_again; - } /* end of unsuccessful completion */ - - if (status == RPC_SUCCESS) { - 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)); - } + } /* end successful completion */ + else + { + if (AUTH_REFRESH (h->cl_auth)) + goto call_again; + } /* end of unsuccessful completion */ + + if (status == RPC_SUCCESS) + { + 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)); } + } - return (status); + return status; } static void -clntraw_geterr() +clntraw_geterr (CLIENT *cl, struct rpc_err *err) { } static bool_t -clntraw_freeres(cl, xdr_res, res_ptr) - CLIENT *cl; - xdrproc_t xdr_res; - caddr_t res_ptr; +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) - { - rval = (bool_t) RPC_FAILED; - return (rval); - } - xdrs->x_op = XDR_FREE; - return ((*xdr_res)(xdrs, res_ptr)); + struct clntraw_private *clp = clntraw_private; + XDR *xdrs = &clp->xdr_stream; + bool_t rval; + + if (clp == NULL) + { + rval = (bool_t) RPC_FAILED; + return rval; + } + xdrs->x_op = XDR_FREE; + return (*xdr_res) (xdrs, res_ptr); } static void -clntraw_abort() +clntraw_abort (void) { } static bool_t -clntraw_control() +clntraw_control (CLIENT *cl, int i, char *c) { - return (FALSE); + return FALSE; } static void -clntraw_destroy() +clntraw_destroy (CLIENT *cl) { } diff --git a/sunrpc/clnt_simp.c b/sunrpc/clnt_simp.c index 42ab1a28f8..30a051724f 100644 --- a/sunrpc/clnt_simp.c +++ b/sunrpc/clnt_simp.c @@ -41,94 +41,102 @@ static char sccsid[] = "@(#)clnt_simple.c 1.35 87/08/11 Copyr 1984 Sun Micro"; #include <alloca.h> #include <errno.h> #include <stdio.h> +#include <unistd.h> #include <rpc/rpc.h> #include <sys/socket.h> #include <netdb.h> #include <strings.h> -static struct callrpc_private { - CLIENT *client; - int socket; - int oldprognum, oldversnum, valid; - char *oldhost; -} *callrpc_private; +static struct callrpc_private + { + CLIENT *client; + int socket; + u_long 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; +int +callrpc (const char *host, u_long prognum, u_long versnum, u_long procnum, + xdrproc_t inproc, const char *in, xdrproc_t outproc, char *out) { - register struct callrpc_private *crp = callrpc_private; - struct sockaddr_in server_addr; - enum clnt_stat clnt_stat; - struct hostent hostbuf, *hp; - struct timeval timeout, tottimeout; + struct callrpc_private *crp = callrpc_private; + struct sockaddr_in server_addr; + enum clnt_stat clnt_stat; + struct hostent hostbuf, *hp; + struct timeval timeout, tottimeout; - if (crp == 0) { - crp = (struct callrpc_private *)calloc(1, sizeof (*crp)); - if (crp == 0) - return (0); - callrpc_private = crp; + if (crp == 0) + { + crp = (struct callrpc_private *) calloc (1, sizeof (*crp)); + if (crp == 0) + return 0; + callrpc_private = crp; + } + if (crp->oldhost == NULL) + { + crp->oldhost = malloc (256); + 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 */ + } + else + { + size_t buflen; + char *buffer; + int herr; + + crp->valid = 0; + if (crp->socket != RPC_ANYSOCK) + { + (void) close (crp->socket); + crp->socket = RPC_ANYSOCK; } - if (crp->oldhost == NULL) { - crp->oldhost = malloc(256); - crp->oldhost[0] = 0; - crp->socket = RPC_ANYSOCK; + if (crp->client) + { + clnt_destroy (crp->client); + crp->client = NULL; } - if (crp->valid && crp->oldprognum == prognum && crp->oldversnum == versnum - && strcmp(crp->oldhost, host) == 0) { - /* reuse old client */ - } else { - size_t buflen; - char *buffer; - int herr; - - crp->valid = 0; - if (crp->socket != RPC_ANYSOCK) - { - (void)close(crp->socket); - crp->socket = RPC_ANYSOCK; - } - if (crp->client) { - clnt_destroy(crp->client); - crp->client = NULL; - } - buflen = 1024; - buffer = __alloca (buflen); - while (__gethostbyname_r (host, &hostbuf, buffer, buflen, - &hp, &herr) < 0) - if (herr != NETDB_INTERNAL || errno != ERANGE) - return (int) RPC_UNKNOWNHOST; - else - { - /* Enlarge the buffer. */ - buflen *= 2; - buffer = __alloca (buflen); - } + buflen = 1024; + buffer = __alloca (buflen); + while (__gethostbyname_r (host, &hostbuf, buffer, buflen, + &hp, &herr) < 0) + if (herr != NETDB_INTERNAL || errno != ERANGE) + return (int) RPC_UNKNOWNHOST; + else + { + /* Enlarge the buffer. */ + buflen *= 2; + buffer = __alloca (buflen); + } - timeout.tv_usec = 0; - timeout.tv_sec = 5; - 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) - return ((int) rpc_createerr.cf_stat); - crp->valid = 1; - crp->oldprognum = prognum; - crp->oldversnum = versnum; - (void) strncpy(crp->oldhost, host, 255); - crp->oldhost[256] = '\0'; - } - tottimeout.tv_sec = 25; - tottimeout.tv_usec = 0; - clnt_stat = clnt_call(crp->client, procnum, inproc, in, - outproc, out, tottimeout); - /* - * if call failed, empty cache - */ - if (clnt_stat != RPC_SUCCESS) - crp->valid = 0; - return ((int) clnt_stat); + timeout.tv_usec = 0; + timeout.tv_sec = 5; + 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) + return (int) rpc_createerr.cf_stat; + crp->valid = 1; + crp->oldprognum = prognum; + crp->oldversnum = versnum; + (void) strncpy (crp->oldhost, host, 255); + crp->oldhost[256] = '\0'; + } + tottimeout.tv_sec = 25; + tottimeout.tv_usec = 0; + clnt_stat = clnt_call (crp->client, procnum, inproc, (char *) in, + outproc, out, tottimeout); + /* + * if call failed, empty cache + */ + if (clnt_stat != RPC_SUCCESS) + crp->valid = 0; + return (int) clnt_stat; } diff --git a/sunrpc/clnt_tcp.c b/sunrpc/clnt_tcp.c index aeaf558ad2..02c43dd26f 100644 --- a/sunrpc/clnt_tcp.c +++ b/sunrpc/clnt_tcp.c @@ -50,48 +50,50 @@ static char sccsid[] = "@(#)clnt_tcp.c 1.37 87/10/05 Copyr 1984 Sun Micro"; * Now go hang yourself. */ +#include <netdb.h> +#include <errno.h> #include <stdio.h> +#include <unistd.h> #include <rpc/rpc.h> #include <sys/socket.h> -#include <netdb.h> -#include <errno.h> #include <rpc/pmap_clnt.h> -#define MCALL_MSG_SIZE 24 - -#ifndef errno -extern int errno; -#endif +extern bool_t xdr_opaque_auth (XDR *, struct opaque_auth *); -static int readtcp(); -static int writetcp(); - -static enum clnt_stat clnttcp_call(); -static void clnttcp_abort(); -static void clnttcp_geterr(); -static bool_t clnttcp_freeres(); -static bool_t clnttcp_control(); -static void clnttcp_destroy(); - -static struct clnt_ops tcp_ops = { - clnttcp_call, - clnttcp_abort, - clnttcp_geterr, - clnttcp_freeres, - clnttcp_destroy, - clnttcp_control -}; +#define MCALL_MSG_SIZE 24 -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; +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; + }; + +static int readtcp (char *, char *, int); +static int writetcp (char *, char *, int); + +static enum clnt_stat clnttcp_call (CLIENT *, u_long, xdrproc_t, caddr_t, + xdrproc_t, caddr_t, struct timeval); +static void clnttcp_abort (void); +static void clnttcp_geterr (CLIENT *, struct rpc_err *); +static bool_t clnttcp_freeres (CLIENT *, xdrproc_t, caddr_t); +static bool_t clnttcp_control (CLIENT *, int, char *); +static void clnttcp_destroy (CLIENT *); + +static struct clnt_ops tcp_ops = +{ + clnttcp_call, + clnttcp_abort, + clnttcp_geterr, + clnttcp_freeres, + clnttcp_destroy, + clnttcp_control }; /* @@ -109,284 +111,301 @@ struct ct_data { * 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; +clnttcp_create (struct sockaddr_in *raddr, u_long prog, u_long vers, + int *sockp, u_int sendsz, u_int recvsz) { - CLIENT *h; - register struct ct_data *ct; - struct timeval now; - struct rpc_msg call_msg; - - h = (CLIENT *)mem_alloc(sizeof(*h)); - if (h == NULL) { - (void)fprintf(stderr, "clnttcp_create: out of memory\n"); - rpc_createerr.cf_stat = RPC_SYSTEMERROR; - rpc_createerr.cf_error.re_errno = errno; - goto fooy; - } - ct = (struct ct_data *)mem_alloc(sizeof(*ct)); - if (ct == NULL) { - (void)fprintf(stderr, "clnttcp_create: out of memory\n"); - rpc_createerr.cf_stat = RPC_SYSTEMERROR; - rpc_createerr.cf_error.re_errno = errno; - goto fooy; + CLIENT *h; + struct ct_data *ct = (struct ct_data *) mem_alloc (sizeof (*ct)); + struct timeval now; + struct rpc_msg call_msg; + + h = (CLIENT *) mem_alloc (sizeof (*h)); + if (h == NULL) + { + (void) fprintf (stderr, _("clnttcp_create: out of memory\n")); + rpc_createerr.cf_stat = RPC_SYSTEMERROR; + rpc_createerr.cf_error.re_errno = errno; + goto fooy; + } + /* ct = (struct ct_data *) mem_alloc (sizeof (*ct)); */ + if (ct == NULL) + { + (void) fprintf (stderr, _("clnttcp_create: out of memory\n")); + rpc_createerr.cf_stat = RPC_SYSTEMERROR; + rpc_createerr.cf_error.re_errno = errno; + goto fooy; + } + + /* + * If no port number given ask the pmap for one + */ + if (raddr->sin_port == 0) + { + u_short port; + if ((port = pmap_getport (raddr, prog, vers, IPPROTO_TCP)) == 0) + { + mem_free ((caddr_t) ct, sizeof (struct ct_data)); + mem_free ((caddr_t) h, sizeof (CLIENT)); + return ((CLIENT *) NULL); } - - /* - * If no port number given ask the pmap for one - */ - if (raddr->sin_port == 0) { - u_short port; - if ((port = pmap_getport(raddr, prog, vers, IPPROTO_TCP)) == 0) { - mem_free((caddr_t)ct, sizeof(struct ct_data)); - mem_free((caddr_t)h, sizeof(CLIENT)); - return ((CLIENT *)NULL); - } - raddr->sin_port = htons(port); - } - - /* - * If no socket given, open one - */ - if (*sockp < 0) { - *sockp = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); - (void)bindresvport(*sockp, (struct sockaddr_in *)0); - if ((*sockp < 0) - || (connect(*sockp, (struct sockaddr *)raddr, - sizeof(*raddr)) < 0)) { - rpc_createerr.cf_stat = RPC_SYSTEMERROR; - rpc_createerr.cf_error.re_errno = errno; - if (*sockp >= 0) - (void)close(*sockp); - goto fooy; - } - ct->ct_closeit = TRUE; - } else { - ct->ct_closeit = FALSE; + raddr->sin_port = htons (port); + } + + /* + * If no socket given, open one + */ + if (*sockp < 0) + { + *sockp = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); + (void) bindresvport (*sockp, (struct sockaddr_in *) 0); + if ((*sockp < 0) + || (connect (*sockp, (struct sockaddr *) raddr, + sizeof (*raddr)) < 0)) + { + rpc_createerr.cf_stat = RPC_SYSTEMERROR; + rpc_createerr.cf_error.re_errno = errno; + if (*sockp >= 0) + (void) close (*sockp); + goto fooy; } - - /* - * Set up private data struct - */ - ct->ct_sock = *sockp; - ct->ct_wait.tv_usec = 0; - ct->ct_waitset = FALSE; - ct->ct_addr = *raddr; - - /* - * Initialize call message - */ - (void)gettimeofday(&now, (struct timezone *)0); - call_msg.rm_xid = getpid() ^ now.tv_sec ^ now.tv_usec; - call_msg.rm_direction = CALL; - call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION; - call_msg.rm_call.cb_prog = prog; - call_msg.rm_call.cb_vers = vers; - - /* - * pre-serialize the static part of the call msg and stash it away - */ - xdrmem_create(&(ct->ct_xdrs), ct->ct_mcall, MCALL_MSG_SIZE, - XDR_ENCODE); - if (! xdr_callhdr(&(ct->ct_xdrs), &call_msg)) { - if (ct->ct_closeit) { - (void)close(*sockp); - } - goto fooy; + ct->ct_closeit = TRUE; + } + else + { + ct->ct_closeit = FALSE; + } + + /* + * Set up private data struct + */ + ct->ct_sock = *sockp; + ct->ct_wait.tv_usec = 0; + ct->ct_waitset = FALSE; + ct->ct_addr = *raddr; + + /* + * Initialize call message + */ + (void) gettimeofday (&now, (struct timezone *) 0); + call_msg.rm_xid = getpid () ^ now.tv_sec ^ now.tv_usec; + call_msg.rm_direction = CALL; + call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION; + call_msg.rm_call.cb_prog = prog; + call_msg.rm_call.cb_vers = vers; + + /* + * pre-serialize the static part of the call msg and stash it away + */ + xdrmem_create (&(ct->ct_xdrs), ct->ct_mcall, MCALL_MSG_SIZE, + XDR_ENCODE); + if (!xdr_callhdr (&(ct->ct_xdrs), &call_msg)) + { + if (ct->ct_closeit) + { + (void) close (*sockp); } - ct->ct_mpos = XDR_GETPOS(&(ct->ct_xdrs)); - XDR_DESTROY(&(ct->ct_xdrs)); - - /* - * Create a client handle which uses xdrrec for serialization - * and authnone for authentication. - */ - xdrrec_create(&(ct->ct_xdrs), sendsz, recvsz, - (caddr_t)ct, readtcp, writetcp); - h->cl_ops = &tcp_ops; - h->cl_private = (caddr_t) ct; - h->cl_auth = authnone_create(); - return (h); + goto fooy; + } + ct->ct_mpos = XDR_GETPOS (&(ct->ct_xdrs)); + XDR_DESTROY (&(ct->ct_xdrs)); + + /* + * Create a client handle which uses xdrrec for serialization + * and authnone for authentication. + */ + xdrrec_create (&(ct->ct_xdrs), sendsz, recvsz, + (caddr_t) ct, readtcp, writetcp); + h->cl_ops = &tcp_ops; + h->cl_private = (caddr_t) ct; + h->cl_auth = authnone_create (); + return h; fooy: - /* - * Something goofed, free stuff and barf - */ - mem_free((caddr_t)ct, sizeof(struct ct_data)); - mem_free((caddr_t)h, sizeof(CLIENT)); - return ((CLIENT *)NULL); + /* + * Something goofed, free stuff and barf + */ + mem_free ((caddr_t) ct, sizeof (struct ct_data)); + mem_free ((caddr_t) h, sizeof (CLIENT)); + return ((CLIENT *) NULL); } static enum clnt_stat -clnttcp_call(h, proc, xdr_args, args_ptr, xdr_results, results_ptr, timeout) - register CLIENT *h; - u_long proc; - xdrproc_t xdr_args; - caddr_t args_ptr; - xdrproc_t xdr_results; - caddr_t results_ptr; - struct timeval timeout; +clnttcp_call (h, proc, xdr_args, args_ptr, xdr_results, results_ptr, timeout) + 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_int32_t *msg_x_id = (u_int32_t *)(ct->ct_mcall); /* yuk */ - register bool_t shipnow; - int refreshes = 2; - - if (!ct->ct_waitset) { - ct->ct_wait = timeout; - } - - shipnow = - (xdr_results == (xdrproc_t)0 && timeout.tv_sec == 0 - && timeout.tv_usec == 0) ? FALSE : TRUE; + struct ct_data *ct = (struct ct_data *) h->cl_private; + XDR *xdrs = &(ct->ct_xdrs); + struct rpc_msg reply_msg; + u_long x_id; + u_int32_t *msg_x_id = (u_int32_t *) (ct->ct_mcall); /* yuk */ + bool_t shipnow; + int refreshes = 2; + + if (!ct->ct_waitset) + { + ct->ct_wait = timeout; + } + + shipnow = + (xdr_results == (xdrproc_t) 0 && timeout.tv_sec == 0 + && timeout.tv_usec == 0) ? FALSE : TRUE; call_again: - xdrs->x_op = XDR_ENCODE; - ct->ct_error.re_status = RPC_SUCCESS; - x_id = ntohl(--(*msg_x_id)); - if ((! XDR_PUTBYTES(xdrs, ct->ct_mcall, ct->ct_mpos)) || - (! XDR_PUTLONG(xdrs, (long *)&proc)) || - (! AUTH_MARSHALL(h->cl_auth, xdrs)) || - (! (*xdr_args)(xdrs, args_ptr))) { - if (ct->ct_error.re_status == RPC_SUCCESS) - ct->ct_error.re_status = RPC_CANTENCODEARGS; - (void)xdrrec_endofrecord(xdrs, TRUE); - return (ct->ct_error.re_status); + xdrs->x_op = XDR_ENCODE; + ct->ct_error.re_status = RPC_SUCCESS; + x_id = ntohl (--(*msg_x_id)); + if ((!XDR_PUTBYTES (xdrs, ct->ct_mcall, ct->ct_mpos)) || + (!XDR_PUTLONG (xdrs, (long *) &proc)) || + (!AUTH_MARSHALL (h->cl_auth, xdrs)) || + (!(*xdr_args) (xdrs, args_ptr))) + { + if (ct->ct_error.re_status == RPC_SUCCESS) + ct->ct_error.re_status = RPC_CANTENCODEARGS; + (void) xdrrec_endofrecord (xdrs, TRUE); + return (ct->ct_error.re_status); + } + if (!xdrrec_endofrecord (xdrs, shipnow)) + return ct->ct_error.re_status = RPC_CANTSEND; + if (!shipnow) + return RPC_SUCCESS; + /* + * Hack to provide rpc-based message passing + */ + if (timeout.tv_sec == 0 && timeout.tv_usec == 0) + { + return ct->ct_error.re_status = RPC_TIMEDOUT; + } + + + /* + * Keep receiving until we get a valid transaction id + */ + xdrs->x_op = XDR_DECODE; + while (TRUE) + { + reply_msg.acpted_rply.ar_verf = _null_auth; + reply_msg.acpted_rply.ar_results.where = NULL; + reply_msg.acpted_rply.ar_results.proc = (xdrproc_t)xdr_void; + if (!xdrrec_skiprecord (xdrs)) + return (ct->ct_error.re_status); + /* now decode and validate the response header */ + if (!xdr_replymsg (xdrs, &reply_msg)) + { + if (ct->ct_error.re_status == RPC_SUCCESS) + continue; + return ct->ct_error.re_status; } - if (! xdrrec_endofrecord(xdrs, shipnow)) - return (ct->ct_error.re_status = RPC_CANTSEND); - if (! shipnow) - return (RPC_SUCCESS); - /* - * Hack to provide rpc-based message passing - */ - if (timeout.tv_sec == 0 && timeout.tv_usec == 0) { - return(ct->ct_error.re_status = RPC_TIMEDOUT); + if (reply_msg.rm_xid == x_id) + break; + } + + /* + * process header + */ + _seterr_reply (&reply_msg, &(ct->ct_error)); + if (ct->ct_error.re_status == RPC_SUCCESS) + { + if (!AUTH_VALIDATE (h->cl_auth, &reply_msg.acpted_rply.ar_verf)) + { + ct->ct_error.re_status = RPC_AUTHERROR; + ct->ct_error.re_why = AUTH_INVALIDRESP; } - - - /* - * Keep receiving until we get a valid transaction id - */ - xdrs->x_op = XDR_DECODE; - while (TRUE) { - reply_msg.acpted_rply.ar_verf = _null_auth; - reply_msg.acpted_rply.ar_results.where = NULL; - reply_msg.acpted_rply.ar_results.proc = xdr_void; - if (! xdrrec_skiprecord(xdrs)) - return (ct->ct_error.re_status); - /* now decode and validate the response header */ - if (! xdr_replymsg(xdrs, &reply_msg)) { - if (ct->ct_error.re_status == RPC_SUCCESS) - continue; - return (ct->ct_error.re_status); - } - if (reply_msg.rm_xid == x_id) - break; + else if (!(*xdr_results) (xdrs, results_ptr)) + { + if (ct->ct_error.re_status == RPC_SUCCESS) + ct->ct_error.re_status = RPC_CANTDECODERES; } - - /* - * process header - */ - _seterr_reply(&reply_msg, &(ct->ct_error)); - if (ct->ct_error.re_status == RPC_SUCCESS) { - if (! AUTH_VALIDATE(h->cl_auth, &reply_msg.acpted_rply.ar_verf)) { - ct->ct_error.re_status = RPC_AUTHERROR; - ct->ct_error.re_why = AUTH_INVALIDRESP; - } else if (! (*xdr_results)(xdrs, results_ptr)) { - if (ct->ct_error.re_status == RPC_SUCCESS) - ct->ct_error.re_status = RPC_CANTDECODERES; - } - /* free verifier ... */ - if (reply_msg.acpted_rply.ar_verf.oa_base != NULL) { - xdrs->x_op = XDR_FREE; - (void)xdr_opaque_auth(xdrs, &(reply_msg.acpted_rply.ar_verf)); - } - } /* end successful completion */ - else { - /* maybe our credentials need to be refreshed ... */ - if (refreshes-- && AUTH_REFRESH(h->cl_auth)) - goto call_again; - } /* end of unsuccessful completion */ - return (ct->ct_error.re_status); + /* free verifier ... */ + if (reply_msg.acpted_rply.ar_verf.oa_base != NULL) + { + xdrs->x_op = XDR_FREE; + (void) xdr_opaque_auth (xdrs, &(reply_msg.acpted_rply.ar_verf)); + } + } /* end successful completion */ + else + { + /* maybe our credentials need to be refreshed ... */ + if (refreshes-- && AUTH_REFRESH (h->cl_auth)) + goto call_again; + } /* end of unsuccessful completion */ + return ct->ct_error.re_status; } static void -clnttcp_geterr(h, errp) - CLIENT *h; - struct rpc_err *errp; +clnttcp_geterr (h, errp) + CLIENT *h; + struct rpc_err *errp; { - register struct ct_data *ct = - (struct ct_data *) h->cl_private; + struct ct_data *ct = + (struct ct_data *) h->cl_private; - *errp = ct->ct_error; + *errp = ct->ct_error; } static bool_t -clnttcp_freeres(cl, xdr_res, res_ptr) - CLIENT *cl; - xdrproc_t xdr_res; - caddr_t res_ptr; +clnttcp_freeres (cl, xdr_res, res_ptr) + CLIENT *cl; + xdrproc_t xdr_res; + caddr_t res_ptr; { - register struct ct_data *ct = (struct ct_data *)cl->cl_private; - register XDR *xdrs = &(ct->ct_xdrs); + struct ct_data *ct = (struct ct_data *) cl->cl_private; + XDR *xdrs = &(ct->ct_xdrs); - xdrs->x_op = XDR_FREE; - return ((*xdr_res)(xdrs, res_ptr)); + xdrs->x_op = XDR_FREE; + return (*xdr_res) (xdrs, res_ptr); } static void -clnttcp_abort() +clnttcp_abort () { } static bool_t -clnttcp_control(cl, request, info) - CLIENT *cl; - int request; - char *info; +clnttcp_control (cl, request, info) + CLIENT *cl; + int request; + char *info; { - register struct ct_data *ct = (struct ct_data *)cl->cl_private; - - switch (request) { - case CLSET_TIMEOUT: - ct->ct_wait = *(struct timeval *)info; - ct->ct_waitset = TRUE; - break; - case CLGET_TIMEOUT: - *(struct timeval *)info = ct->ct_wait; - break; - case CLGET_SERVER_ADDR: - *(struct sockaddr_in *)info = ct->ct_addr; - break; - default: - return (FALSE); - } - return (TRUE); + struct ct_data *ct = (struct ct_data *) cl->cl_private; + + switch (request) + { + case CLSET_TIMEOUT: + ct->ct_wait = *(struct timeval *) info; + ct->ct_waitset = TRUE; + break; + case CLGET_TIMEOUT: + *(struct timeval *) info = ct->ct_wait; + break; + case CLGET_SERVER_ADDR: + *(struct sockaddr_in *) info = ct->ct_addr; + break; + default: + return FALSE; + } + return TRUE; } static void -clnttcp_destroy(h) - CLIENT *h; +clnttcp_destroy (CLIENT *h) { - register struct ct_data *ct = - (struct ct_data *) h->cl_private; - - if (ct->ct_closeit) { - (void)close(ct->ct_sock); - } - XDR_DESTROY(&(ct->ct_xdrs)); - mem_free((caddr_t)ct, sizeof(struct ct_data)); - mem_free((caddr_t)h, sizeof(CLIENT)); + struct ct_data *ct = + (struct ct_data *) h->cl_private; + + if (ct->ct_closeit) + { + (void) close (ct->ct_sock); + } + XDR_DESTROY (&(ct->ct_xdrs)); + mem_free ((caddr_t) ct, sizeof (struct ct_data)); + mem_free ((caddr_t) h, sizeof (CLIENT)); } /* @@ -395,76 +414,77 @@ clnttcp_destroy(h) * around for the rpc level. */ static int -readtcp(ct, buf, len) - register struct ct_data *ct; - caddr_t buf; - register int len; +readtcp (char *ctptr, char *buf, int len) { + struct ct_data *ct = (struct ct_data *)ctptr; #ifdef FD_SETSIZE - fd_set mask; - fd_set readfds; + fd_set mask; + fd_set readfds; - if (len == 0) - return (0); - FD_ZERO(&mask); - FD_SET(ct->ct_sock, &mask); + if (len == 0) + return 0; + FD_ZERO (&mask); + FD_SET (ct->ct_sock, &mask); #else - register int mask = 1 << (ct->ct_sock); - int readfds; + int mask = 1 << (ct->ct_sock); + int readfds; - if (len == 0) - return (0); + if (len == 0) + return 0; #endif /* def FD_SETSIZE */ - while (TRUE) { - struct timeval timeout = ct->ct_wait; - readfds = mask; - switch (select(_rpc_dtablesize(), &readfds, (int*)NULL, (int*)NULL, - &timeout)) { - case 0: - ct->ct_error.re_status = RPC_TIMEDOUT; - return (-1); - - case -1: - if (errno == EINTR) - continue; - ct->ct_error.re_status = RPC_CANTRECV; - ct->ct_error.re_errno = errno; - return (-1); - } - break; - } - switch (len = read(ct->ct_sock, buf, len)) { - + while (TRUE) + { + struct timeval timeout = ct->ct_wait; + readfds = mask; + switch (select (_rpc_dtablesize (), &readfds, (fd_set*)NULL, + (fd_set*)NULL, &timeout)) + { case 0: - /* premature eof */ - ct->ct_error.re_errno = ECONNRESET; - ct->ct_error.re_status = RPC_CANTRECV; - len = -1; /* it's really an error */ - break; + ct->ct_error.re_status = RPC_TIMEDOUT; + return -1; case -1: - ct->ct_error.re_errno = errno; - ct->ct_error.re_status = RPC_CANTRECV; - break; + if (errno == EINTR) + continue; + ct->ct_error.re_status = RPC_CANTRECV; + ct->ct_error.re_errno = errno; + return -1; } - return (len); + break; + } + switch (len = read (ct->ct_sock, buf, len)) + { + + case 0: + /* premature eof */ + ct->ct_error.re_errno = ECONNRESET; + ct->ct_error.re_status = RPC_CANTRECV; + len = -1; /* it's really an error */ + break; + + case -1: + ct->ct_error.re_errno = errno; + ct->ct_error.re_status = RPC_CANTRECV; + break; + } + return len; } static int -writetcp(ct, buf, len) - struct ct_data *ct; - caddr_t buf; - int len; +writetcp (char *ctptr, char *buf, int len) { - register int i, cnt; - - for (cnt = len; cnt > 0; cnt -= i, buf += i) { - if ((i = write(ct->ct_sock, buf, cnt)) == -1) { - ct->ct_error.re_errno = errno; - ct->ct_error.re_status = RPC_CANTSEND; - return (-1); - } + int i, cnt; + struct ct_data *ct = (struct ct_data*)ctptr; + + for (cnt = len; cnt > 0; cnt -= i, buf += i) + { + if ((i = write (ct->ct_sock, buf, cnt)) == -1) + { + ct->ct_error.re_errno = errno; + ct->ct_error.re_status = RPC_CANTSEND; + return -1; } - return (len); + } + return len; } diff --git a/sunrpc/clnt_udp.c b/sunrpc/clnt_udp.c index e166dede81..efd6a9f9f5 100644 --- a/sunrpc/clnt_udp.c +++ b/sunrpc/clnt_udp.c @@ -38,54 +38,58 @@ static char sccsid[] = "@(#)clnt_udp.c 1.39 87/08/11 Copyr 1984 Sun Micro"; */ #include <stdio.h> +#include <unistd.h> #include <rpc/rpc.h> +#include <rpc/xdr.h> +#include <rpc/clnt.h> #include <sys/socket.h> #include <sys/ioctl.h> #include <netdb.h> #include <errno.h> #include <rpc/pmap_clnt.h> -#ifndef errno -extern int errno; -#endif +extern bool_t xdr_opaque_auth (XDR *, struct opaque_auth *); /* * 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 (CLIENT *, u_long, xdrproc_t, caddr_t, + xdrproc_t, caddr_t, struct timeval); +static void clntudp_abort (void); +static void clntudp_geterr (CLIENT *, struct rpc_err *); +static bool_t clntudp_freeres (CLIENT *, xdrproc_t, caddr_t); +static bool_t clntudp_control (CLIENT *, int, char *); +static void clntudp_destroy (CLIENT *); -static struct clnt_ops udp_ops = { - clntudp_call, - clntudp_abort, - clntudp_geterr, - clntudp_freeres, - clntudp_destroy, - clntudp_control +static struct clnt_ops udp_ops = +{ + clntudp_call, + clntudp_abort, + clntudp_geterr, + clntudp_freeres, + clntudp_destroy, + clntudp_control }; /* * Private data kept per client handle */ -struct cu_data { - 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]; -}; +struct cu_data + { + 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]; + }; /* * Create a UDP based client handle. @@ -104,342 +108,361 @@ struct cu_data { * 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; +clntudp_bufcreate (raddr, program, version, wait, sockp, sendsz, recvsz) + struct sockaddr_in *raddr; + u_long program; + u_long version; + struct timeval wait; + int *sockp; + u_int sendsz; + u_int recvsz; { - CLIENT *cl; - register struct cu_data *cu; - struct timeval now; - struct rpc_msg call_msg; + CLIENT *cl; + struct cu_data *cu = NULL; + struct timeval now; + struct rpc_msg call_msg; - cl = (CLIENT *)mem_alloc(sizeof(CLIENT)); - if (cl == NULL) { - (void) fprintf(stderr, "clntudp_create: out of memory\n"); - rpc_createerr.cf_stat = RPC_SYSTEMERROR; - rpc_createerr.cf_error.re_errno = errno; - goto fooy; - } - sendsz = ((sendsz + 3) / 4) * 4; - recvsz = ((recvsz + 3) / 4) * 4; - 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; - rpc_createerr.cf_error.re_errno = errno; - goto fooy; - } - cu->cu_outbuf = &cu->cu_inbuf[recvsz]; + cl = (CLIENT *) mem_alloc (sizeof (CLIENT)); + if (cl == NULL) + { + (void) fprintf (stderr, _("clntudp_create: out of memory\n")); + rpc_createerr.cf_stat = RPC_SYSTEMERROR; + rpc_createerr.cf_error.re_errno = errno; + goto fooy; + } + sendsz = ((sendsz + 3) / 4) * 4; + recvsz = ((recvsz + 3) / 4) * 4; + 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; + rpc_createerr.cf_error.re_errno = errno; + goto fooy; + } + cu->cu_outbuf = &cu->cu_inbuf[recvsz]; - (void)gettimeofday(&now, (struct timezone *)0); - if (raddr->sin_port == 0) { - u_short port; - if ((port = - 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; - cu->cu_raddr = *raddr; - cu->cu_rlen = sizeof (cu->cu_raddr); - cu->cu_wait = wait; - cu->cu_total.tv_sec = -1; - cu->cu_total.tv_usec = -1; - cu->cu_sendsz = sendsz; - cu->cu_recvsz = recvsz; - call_msg.rm_xid = getpid() ^ now.tv_sec ^ now.tv_usec; - call_msg.rm_direction = CALL; - call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION; - call_msg.rm_call.cb_prog = 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)) { - goto fooy; + (void) gettimeofday (&now, (struct timezone *) 0); + if (raddr->sin_port == 0) + { + u_short port; + if ((port = + pmap_getport (raddr, program, version, IPPROTO_UDP)) == 0) + { + goto fooy; } - cu->cu_xdrpos = XDR_GETPOS(&(cu->cu_outxdrs)); - if (*sockp < 0) { - int dontblock = 1; + raddr->sin_port = htons (port); + } + cl->cl_ops = &udp_ops; + cl->cl_private = (caddr_t) cu; + cu->cu_raddr = *raddr; + cu->cu_rlen = sizeof (cu->cu_raddr); + cu->cu_wait = wait; + cu->cu_total.tv_sec = -1; + cu->cu_total.tv_usec = -1; + cu->cu_sendsz = sendsz; + cu->cu_recvsz = recvsz; + call_msg.rm_xid = getpid () ^ now.tv_sec ^ now.tv_usec; + call_msg.rm_direction = CALL; + call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION; + call_msg.rm_call.cb_prog = 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)) + { + goto fooy; + } + cu->cu_xdrpos = XDR_GETPOS (&(cu->cu_outxdrs)); + if (*sockp < 0) + { + int dontblock = 1; - *sockp = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); - if (*sockp < 0) { - rpc_createerr.cf_stat = RPC_SYSTEMERROR; - rpc_createerr.cf_error.re_errno = errno; - goto fooy; - } - /* attempt to bind to prov port */ - (void)bindresvport(*sockp, (struct sockaddr_in *)0); - /* the sockets rpc controls are non-blocking */ - (void)ioctl(*sockp, FIONBIO, (char *) &dontblock); - cu->cu_closeit = TRUE; - } else { - cu->cu_closeit = FALSE; + *sockp = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP); + if (*sockp < 0) + { + rpc_createerr.cf_stat = RPC_SYSTEMERROR; + rpc_createerr.cf_error.re_errno = errno; + goto fooy; } - cu->cu_sock = *sockp; - cl->cl_auth = authnone_create(); - return (cl); + /* attempt to bind to prov port */ + (void) bindresvport (*sockp, (struct sockaddr_in *) 0); + /* the sockets rpc controls are non-blocking */ + (void) ioctl (*sockp, FIONBIO, (char *) &dontblock); + cu->cu_closeit = TRUE; + } + else + { + cu->cu_closeit = FALSE; + } + cu->cu_sock = *sockp; + cl->cl_auth = authnone_create (); + return cl; fooy: - if (cu) - mem_free((caddr_t)cu, sizeof(*cu) + sendsz + recvsz); - if (cl) - mem_free((caddr_t)cl, sizeof(CLIENT)); - return ((CLIENT *)NULL); + if (cu) + mem_free ((caddr_t) cu, sizeof (*cu) + sendsz + recvsz); + if (cl) + 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; +clntudp_create (raddr, program, version, wait, sockp) + struct sockaddr_in *raddr; + u_long program; + u_long version; + struct timeval wait; + 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 -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 */ +clntudp_call (cl, proc, xargs, argsp, xresults, resultsp, utimeout) + 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 XDR *xdrs; - register int outlen; - register int inlen; - int fromlen; + struct cu_data *cu = (struct cu_data *) cl->cl_private; + XDR *xdrs; + int outlen; + int inlen; + int fromlen; #ifdef FD_SETSIZE - fd_set readfds; - fd_set mask; + fd_set readfds; + fd_set mask; #else - int readfds; - register int mask; + int readfds; + int mask; #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 */ - struct timeval timeout; + 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 */ + struct timeval timeout; - if (cu->cu_total.tv_usec == -1) { - timeout = utimeout; /* use supplied timeout */ - } else { - timeout = cu->cu_total; /* use default timeout */ - } + if (cu->cu_total.tv_usec == -1) + { + timeout = utimeout; /* use supplied timeout */ + } + else + { + timeout = cu->cu_total; /* use default timeout */ + } - time_waited.tv_sec = 0; - time_waited.tv_usec = 0; + time_waited.tv_sec = 0; + time_waited.tv_usec = 0; 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))) - return (cu->cu_error.re_status = RPC_CANTENCODEARGS); - outlen = (int)XDR_GETPOS(xdrs); + 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))) + return (cu->cu_error.re_status = RPC_CANTENCODEARGS); + outlen = (int) XDR_GETPOS (xdrs); send_again: - if (sendto(cu->cu_sock, cu->cu_outbuf, outlen, 0, - (struct sockaddr *)&(cu->cu_raddr), cu->cu_rlen) - != outlen) { - cu->cu_error.re_errno = errno; - return (cu->cu_error.re_status = RPC_CANTSEND); - } + if (sendto (cu->cu_sock, cu->cu_outbuf, outlen, 0, + (struct sockaddr *) &(cu->cu_raddr), cu->cu_rlen) + != outlen) + { + cu->cu_error.re_errno = errno; + return (cu->cu_error.re_status = RPC_CANTSEND); + } - /* - * Hack to provide rpc-based message passing - */ - if (timeout.tv_sec == 0 && timeout.tv_usec == 0) { - return (cu->cu_error.re_status = RPC_TIMEDOUT); - } - /* - * sub-optimal code appears here because we have - * some clock time to spare while the packets are in flight. - * (We assume that this is actually only executed once.) - */ - reply_msg.acpted_rply.ar_verf = _null_auth; - reply_msg.acpted_rply.ar_results.where = resultsp; - reply_msg.acpted_rply.ar_results.proc = xresults; + /* + * Hack to provide rpc-based message passing + */ + if (timeout.tv_sec == 0 && timeout.tv_usec == 0) + { + return (cu->cu_error.re_status = RPC_TIMEDOUT); + } + /* + * sub-optimal code appears here because we have + * some clock time to spare while the packets are in flight. + * (We assume that this is actually only executed once.) + */ + reply_msg.acpted_rply.ar_verf = _null_auth; + reply_msg.acpted_rply.ar_results.where = resultsp; + reply_msg.acpted_rply.ar_results.proc = xresults; #ifdef FD_SETSIZE - FD_ZERO(&mask); - FD_SET(cu->cu_sock, &mask); + FD_ZERO (&mask); + FD_SET (cu->cu_sock, &mask); #else - mask = 1 << cu->cu_sock; + mask = 1 << cu->cu_sock; #endif /* def FD_SETSIZE */ - for (;;) { - struct timeval timeout = cu->cu_wait; - readfds = mask; - switch (select(_rpc_dtablesize(), &readfds, (int *)NULL, - (int *)NULL, &timeout)) { + for (;;) + { + struct timeval timeout = cu->cu_wait; + readfds = mask; + switch (select (_rpc_dtablesize (), &readfds, (fd_set*) NULL, + (fd_set*) NULL, &timeout)) + { - case 0: - time_waited.tv_sec += cu->cu_wait.tv_sec; - time_waited.tv_usec += cu->cu_wait.tv_usec; - while (time_waited.tv_usec >= 1000000) { - time_waited.tv_sec++; - time_waited.tv_usec -= 1000000; - } - 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; - return (cu->cu_error.re_status = RPC_TIMEDOUT); + case 0: + time_waited.tv_sec += cu->cu_wait.tv_sec; + time_waited.tv_usec += cu->cu_wait.tv_usec; + while (time_waited.tv_usec >= 1000000) + { + time_waited.tv_sec++; + time_waited.tv_usec -= 1000000; + } + 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; + return (cu->cu_error.re_status = RPC_TIMEDOUT); - /* - * buggy in other cases because time_waited is not being - * updated. - */ - case -1: - if (errno == EINTR) - 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); - } while (inlen < 0 && errno == EINTR); - if (inlen < 0) { - if (errno == EWOULDBLOCK) - continue; - cu->cu_error.re_errno = errno; - return (cu->cu_error.re_status = RPC_CANTRECV); - } - if (inlen < 4) - continue; - /* see if reply transaction id matches sent id */ - if (*((u_int32_t *)(cu->cu_inbuf)) != *((u_int32_t *)(cu->cu_outbuf))) - continue; - /* we now assume we have the proper reply */ - break; + /* + * buggy in other cases because time_waited is not being + * updated. + */ + case -1: + if (errno == EINTR) + continue; + cu->cu_error.re_errno = errno; + return (cu->cu_error.re_status = RPC_CANTRECV); } - - /* - * now decode and validate the response - */ - 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)) { - 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 */ - 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 */ - else { - cu->cu_error.re_status = RPC_CANTDECODERES; + do + { + fromlen = sizeof (struct sockaddr); + 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; + cu->cu_error.re_errno = errno; + return (cu->cu_error.re_status = RPC_CANTRECV); } - return (cu->cu_error.re_status); + if (inlen < 4) + continue; + /* see if reply transaction id matches sent id */ + if (*((u_int32_t *) (cu->cu_inbuf)) != *((u_int32_t *) (cu->cu_outbuf))) + continue; + /* we now assume we have the proper reply */ + break; + } + + /* + * now decode and validate the response + */ + 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)) + { + 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 */ + 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 */ + 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; +clntudp_geterr (CLIENT *cl, struct rpc_err *errp) { - register struct cu_data *cu = (struct cu_data *)cl->cl_private; + struct cu_data *cu = (struct cu_data *) cl->cl_private; - *errp = cu->cu_error; + *errp = cu->cu_error; } static bool_t -clntudp_freeres(cl, xdr_res, res_ptr) - CLIENT *cl; - xdrproc_t xdr_res; - caddr_t res_ptr; +clntudp_freeres (CLIENT *cl, xdrproc_t xdr_res, caddr_t res_ptr) { - register struct cu_data *cu = (struct cu_data *)cl->cl_private; - register XDR *xdrs = &(cu->cu_outxdrs); + struct cu_data *cu = (struct cu_data *) cl->cl_private; + XDR *xdrs = &(cu->cu_outxdrs); - xdrs->x_op = XDR_FREE; - return ((*xdr_res)(xdrs, res_ptr)); + xdrs->x_op = XDR_FREE; + return (*xdr_res) (xdrs, res_ptr); } static void -clntudp_abort(/*h*/) - /*CLIENT *h;*/ +clntudp_abort (void) { } static bool_t -clntudp_control(cl, request, info) - CLIENT *cl; - int request; - char *info; +clntudp_control (CLIENT *cl, int request, char *info) { - register struct cu_data *cu = (struct cu_data *)cl->cl_private; + struct cu_data *cu = (struct cu_data *) cl->cl_private; - switch (request) { - case CLSET_TIMEOUT: - cu->cu_total = *(struct timeval *)info; - break; - case CLGET_TIMEOUT: - *(struct timeval *)info = cu->cu_total; - break; - case CLSET_RETRY_TIMEOUT: - cu->cu_wait = *(struct timeval *)info; - break; - case CLGET_RETRY_TIMEOUT: - *(struct timeval *)info = cu->cu_wait; - break; - case CLGET_SERVER_ADDR: - *(struct sockaddr_in *)info = cu->cu_raddr; - break; - default: - return (FALSE); - } - return (TRUE); + switch (request) + { + case CLSET_TIMEOUT: + cu->cu_total = *(struct timeval *) info; + break; + case CLGET_TIMEOUT: + *(struct timeval *) info = cu->cu_total; + break; + case CLSET_RETRY_TIMEOUT: + cu->cu_wait = *(struct timeval *) info; + break; + case CLGET_RETRY_TIMEOUT: + *(struct timeval *) info = cu->cu_wait; + break; + case CLGET_SERVER_ADDR: + *(struct sockaddr_in *) info = cu->cu_raddr; + break; + default: + return FALSE; + } + return TRUE; } static void -clntudp_destroy(cl) - CLIENT *cl; +clntudp_destroy (CLIENT *cl) { - register struct cu_data *cu = (struct cu_data *)cl->cl_private; + struct cu_data *cu = (struct cu_data *) cl->cl_private; - if (cu->cu_closeit) { - (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)); + if (cu->cu_closeit) + { + (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)); } diff --git a/sunrpc/get_myaddr.c b/sunrpc/get_myaddr.c index c0ff44efcf..d45cb6d908 100644 --- a/sunrpc/get_myaddr.c +++ b/sunrpc/get_myaddr.c @@ -38,6 +38,7 @@ static char sccsid[] = "@(#)get_myaddress.c 1.4 87/08/11 Copyr 1984 Sun Micro"; * Copyright (C) 1984, Sun Microsystems, Inc. */ +#include <unistd.h> #include <rpc/types.h> #include <rpc/pmap_prot.h> #include <sys/socket.h> @@ -53,40 +54,44 @@ static char sccsid[] = "@(#)get_myaddress.c 1.4 87/08/11 Copyr 1984 Sun Micro"; /* * don't use gethostbyname, which would invoke yellow pages */ -get_myaddress(addr) - struct sockaddr_in *addr; +void +get_myaddress (struct sockaddr_in *addr) { - int s; - char buf[BUFSIZ]; - struct ifconf ifc; - struct ifreq ifreq, *ifr; - int len; + int s; + char buf[BUFSIZ]; + struct ifconf ifc; + struct ifreq ifreq, *ifr; + int len; - if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { - perror("get_myaddress: socket"); - exit(1); + if ((s = socket (AF_INET, SOCK_DGRAM, 0)) < 0) + { + perror ("get_myaddress: socket"); + exit (1); + } + ifc.ifc_len = sizeof (buf); + ifc.ifc_buf = buf; + 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) + { + perror ("get_myaddress: ioctl"); + exit (1); } - ifc.ifc_len = sizeof (buf); - ifc.ifc_buf = buf; - if (ioctl(s, SIOCGIFCONF, (char *)&ifc) < 0) { - perror( - _("get_myaddress: ioctl (get interface configuration)")); - exit(1); + if ((ifreq.ifr_flags & IFF_UP) && + ifr->ifr_addr.sa_family == AF_INET) + { + *addr = *((struct sockaddr_in *) &ifr->ifr_addr); + addr->sin_port = htons (PMAPPORT); + break; } - ifr = ifc.ifc_req; - for (len = ifc.ifc_len; len; len -= sizeof ifreq) { - ifreq = *ifr; - 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); - addr->sin_port = htons(PMAPPORT); - break; - } - ifr++; - } - (void) close(s); + ifr++; + } + (void) close (s); } diff --git a/sunrpc/getrpcport.c b/sunrpc/getrpcport.c index 3e94dbbf7b..df48dc66d8 100644 --- a/sunrpc/getrpcport.c +++ b/sunrpc/getrpcport.c @@ -38,35 +38,37 @@ static char sccsid[] = "@(#)getrpcport.c 1.3 87/08/11 SMI"; #include <alloca.h> #include <errno.h> #include <stdio.h> -#include <rpc/rpc.h> #include <netdb.h> +#include <string.h> +#include <rpc/rpc.h> +#include <rpc/clnt.h> +#include <rpc/pmap_clnt.h> #include <sys/socket.h> int -getrpcport(host, prognum, versnum, proto) - char *host; +getrpcport (const char *host, u_long prognum, u_long versnum, u_int proto) { - struct sockaddr_in addr; - struct hostent hostbuf, *hp; - size_t buflen; - char *buffer; - int herr; + struct sockaddr_in addr; + struct hostent hostbuf, *hp; + size_t buflen; + char *buffer; + int herr; - buflen = 1024; + buflen = 1024; + buffer = __alloca (buflen); + while (__gethostbyname_r (host, &hostbuf, buffer, buflen, &hp, &herr) + < 0) + if (herr != NETDB_INTERNAL || errno != ERANGE) + return 0; + else + { + /* Enlarge the buffer. */ + buflen *= 2; buffer = __alloca (buflen); - while (__gethostbyname_r (host, &hostbuf, buffer, buflen, &hp, &herr) - < 0) - if (herr != NETDB_INTERNAL || errno != ERANGE) - return 0; - else - { - /* Enlarge the buffer. */ - buflen *= 2; - buffer = __alloca (buflen); - } + } - bcopy(hp->h_addr, (char *) &addr.sin_addr, hp->h_length); - addr.sin_family = AF_INET; - addr.sin_port = 0; - return (pmap_getport(&addr, prognum, versnum, proto)); + bcopy (hp->h_addr, (char *) &addr.sin_addr, hp->h_length); + addr.sin_family = AF_INET; + addr.sin_port = 0; + return pmap_getport (&addr, prognum, versnum, proto); } diff --git a/sunrpc/pm_getmaps.c b/sunrpc/pm_getmaps.c index d84e0c5dc0..2812b3aead 100644 --- a/sunrpc/pm_getmaps.c +++ b/sunrpc/pm_getmaps.c @@ -47,43 +47,34 @@ static char sccsid[] = "@(#)pmap_getmaps.c 1.10 87/08/11 Copyr 1984 Sun Micro"; #include <stdio.h> #include <errno.h> -#if 0 /* these seem to be gratuitous --roland@gnu */ -#include <net/if.h> -#include <sys/ioctl.h> -#define NAMELEN 255 -#define MAX_BROADCAST_SIZE 1400 -#endif - -#ifndef errno -extern int errno; -#endif - /* * 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; +pmap_getmaps (struct sockaddr_in *address) { - struct pmaplist *head = (struct pmaplist *)NULL; - int socket = -1; - struct timeval minutetimeout; - register CLIENT *client; + struct pmaplist *head = (struct pmaplist *) NULL; + int socket = -1; + struct timeval minutetimeout; + CLIENT *client; - 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) { - if (CLNT_CALL(client, PMAPPROC_DUMP, xdr_void, NULL, xdr_pmaplist, - &head, minutetimeout) != RPC_SUCCESS) { - clnt_perror(client, "pmap_getmaps rpc problem"); - } - CLNT_DESTROY(client); + 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) + { + if (CLNT_CALL (client, PMAPPROC_DUMP, (xdrproc_t)xdr_void, NULL, + (xdrproc_t)xdr_pmaplist, (caddr_t)&head, + minutetimeout) != RPC_SUCCESS) + { + clnt_perror (client, _("pmap_getmaps rpc problem")); } - /* (void)close(socket); CLNT_DESTROY already closed it */ - address->sin_port = 0; - return (head); + CLNT_DESTROY (client); + } + /* (void)close(socket); CLNT_DESTROY already closed it */ + address->sin_port = 0; + return head; } diff --git a/sunrpc/pm_getport.c b/sunrpc/pm_getport.c index f156af41c2..be3cb495a6 100644 --- a/sunrpc/pm_getport.c +++ b/sunrpc/pm_getport.c @@ -43,12 +43,10 @@ static char sccsid[] = "@(#)pmap_getport.c 1.9 87/08/11 Copyr 1984 Sun Micro"; #include <rpc/pmap_clnt.h> #include <sys/socket.h> -#if 0 /* these seem to be gratuitous --roland@gnu */ -#include <net/if.h> -#endif - -static struct timeval timeout = { 5, 0 }; -static struct timeval tottimeout = { 60, 0 }; +static const struct timeval timeout = +{5, 0}; +static const struct timeval tottimeout = +{60, 0}; /* * Find the mapped port for program,version. @@ -56,35 +54,40 @@ static struct timeval tottimeout = { 60, 0 }; * 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; +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; - register CLIENT *client; - struct pmap parms; + u_short port = 0; + int socket = -1; + CLIENT *client; + struct pmap parms; - address->sin_port = htons(PMAPPORT); - client = clntudp_bufcreate(address, PMAPPROG, - 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 */ - if (CLNT_CALL(client, PMAPPROC_GETPORT, xdr_pmap, &parms, - xdr_u_short, &port, tottimeout) != RPC_SUCCESS){ - rpc_createerr.cf_stat = RPC_PMAPFAILURE; - clnt_geterr(client, &rpc_createerr.cf_error); - } else if (port == 0) { - rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED; - } - CLNT_DESTROY(client); + address->sin_port = htons (PMAPPORT); + client = clntudp_bufcreate (address, PMAPPROG, + 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 */ + if (CLNT_CALL (client, PMAPPROC_GETPORT, (xdrproc_t)xdr_pmap, + (caddr_t)&parms, (xdrproc_t)xdr_u_short, + (caddr_t)&port, tottimeout) != RPC_SUCCESS) + { + rpc_createerr.cf_stat = RPC_PMAPFAILURE; + clnt_geterr (client, &rpc_createerr.cf_error); + } + else if (port == 0) + { + rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED; } - /* (void)close(socket); CLNT_DESTROY already closed it */ - address->sin_port = 0; - return (port); + CLNT_DESTROY (client); + } + /* (void)close(socket); CLNT_DESTROY already closed it */ + address->sin_port = 0; + return port; } diff --git a/sunrpc/pmap_clnt.c b/sunrpc/pmap_clnt.c index 08285e2719..263cd130b9 100644 --- a/sunrpc/pmap_clnt.c +++ b/sunrpc/pmap_clnt.c @@ -42,46 +42,43 @@ static char sccsid[] = "@(#)pmap_clnt.c 1.37 87/08/11 Copyr 1984 Sun Micro"; #include <rpc/pmap_prot.h> #include <rpc/pmap_clnt.h> -static struct timeval timeout = { 5, 0 }; -static struct timeval tottimeout = { 60, 0 }; - -void clnt_perror(); +extern void get_myaddress (struct sockaddr_in *addr); +static const struct timeval timeout = {5, 0}; +static const struct timeval tottimeout = {60, 0}; /* * 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; +pmap_set (u_long program, u_long version, int protocol, u_short port) { - struct sockaddr_in myaddress; - int socket = -1; - register CLIENT *client; - struct pmap parms; - bool_t rslt; + struct sockaddr_in myaddress; + int socket = -1; + CLIENT *client; + struct pmap parms; + bool_t rslt; - get_myaddress(&myaddress); - client = clntudp_bufcreate(&myaddress, PMAPPROG, PMAPVERS, - 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) { - clnt_perror(client, _("Cannot register service")); - return (FALSE); - } - CLNT_DESTROY(client); - /* (void)close(socket); CLNT_DESTROY closes it */ - return (rslt); + get_myaddress (&myaddress); + client = clntudp_bufcreate (&myaddress, PMAPPROG, PMAPVERS, + 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, (xdrproc_t)xdr_pmap, (caddr_t)&parms, + (xdrproc_t)xdr_bool, (caddr_t)&rslt, + tottimeout) != RPC_SUCCESS) + { + clnt_perror (client, _("Cannot register service")); + return FALSE; + } + CLNT_DESTROY (client); + /* (void)close(socket); CLNT_DESTROY closes it */ + return rslt; } /* @@ -89,27 +86,25 @@ pmap_set(program, version, protocol, port) * Calls the pmap service remotely to do the un-mapping. */ bool_t -pmap_unset(program, version) - u_long program; - u_long version; +pmap_unset (u_long program, u_long version) { - struct sockaddr_in myaddress; - int socket = -1; - register CLIENT *client; - struct pmap parms; - bool_t rslt; + struct sockaddr_in myaddress; + int socket = -1; + CLIENT *client; + struct pmap parms; + bool_t rslt; - get_myaddress(&myaddress); - client = clntudp_bufcreate(&myaddress, PMAPPROG, PMAPVERS, - 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); - CLNT_DESTROY(client); - /* (void)close(socket); CLNT_DESTROY already closed it */ - return (rslt); + get_myaddress (&myaddress); + client = clntudp_bufcreate (&myaddress, PMAPPROG, PMAPVERS, + 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, (xdrproc_t)xdr_pmap, (caddr_t)&parms, + (xdrproc_t)xdr_bool, (caddr_t)&rslt, tottimeout); + CLNT_DESTROY (client); + /* (void)close(socket); CLNT_DESTROY already closed it */ + return rslt; } diff --git a/sunrpc/pmap_prot.c b/sunrpc/pmap_prot.c index 643c2ff6a2..982971885a 100644 --- a/sunrpc/pmap_prot.c +++ b/sunrpc/pmap_prot.c @@ -6,23 +6,23 @@ * may copy or modify Sun RPC without charge, but are not authorized * to license or distribute it to anyone else except as part of a product or * program developed by the user. - * + * * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. - * + * * Sun RPC is provided with no support and without any obligation on the * part of Sun Microsystems, Inc. to assist in its use, correction, * modification or enhancement. - * + * * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC * OR ANY PART THEREOF. - * + * * In no event will Sun Microsystems, Inc. be liable for any lost revenue * or profits or other special, indirect and consequential damages, even if * Sun has been advised of the possibility of such damages. - * + * * Sun Microsystems, Inc. * 2550 Garcia Avenue * Mountain View, California 94043 @@ -44,14 +44,14 @@ static char sccsid[] = "@(#)pmap_prot.c 1.17 87/08/11 Copyr 1984 Sun Micro"; bool_t -xdr_pmap(xdrs, regs) - XDR *xdrs; - struct pmap *regs; +xdr_pmap (xdrs, regs) + XDR *xdrs; + struct pmap *regs; { - 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 (FALSE); + 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 FALSE; } diff --git a/sunrpc/pmap_prot2.c b/sunrpc/pmap_prot2.c index e2a8214d48..6cb7c5e1b3 100644 --- a/sunrpc/pmap_prot2.c +++ b/sunrpc/pmap_prot2.c @@ -6,23 +6,23 @@ * may copy or modify Sun RPC without charge, but are not authorized * to license or distribute it to anyone else except as part of a product or * program developed by the user. - * + * * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. - * + * * Sun RPC is provided with no support and without any obligation on the * part of Sun Microsystems, Inc. to assist in its use, correction, * modification or enhancement. - * + * * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC * OR ANY PART THEREOF. - * + * * In no event will Sun Microsystems, Inc. be liable for any lost revenue * or profits or other special, indirect and consequential damages, even if * Sun has been advised of the possibility of such damages. - * + * * Sun Microsystems, Inc. * 2550 Garcia Avenue * Mountain View, California 94043 @@ -43,34 +43,34 @@ static char sccsid[] = "@(#)pmap_prot2.c 1.3 87/08/11 Copyr 1984 Sun Micro"; #include <rpc/pmap_prot.h> -/* +/* * What is going on with linked lists? (!) * First recall the link list declaration from pmap_prot.h: * * struct pmaplist { - * struct pmap pml_map; - * struct pmaplist *pml_map; + * struct pmap pml_map; + * struct pmaplist *pml_map; * }; * - * Compare that declaration with a corresponding xdr declaration that + * Compare that declaration with a corresponding xdr declaration that * is (a) pointer-less, and (b) recursive: * * typedef union switch (bool_t) { - * - * case TRUE: struct { - * struct pmap; - * pmaplist_t foo; - * }; * - * case FALSE: struct {}; + * case TRUE: struct { + * struct pmap; + * pmaplist_t foo; + * }; + * + * case FALSE: struct {}; * } pmaplist_t; * * Notice that the xdr declaration has no nxt pointer while * the C declaration has no bool_t variable. The bool_t can be * interpreted as ``more data follows me''; if FALSE then nothing * follows this bool_t; if TRUE then the bool_t is followed by - * an actual struct pmap, and then (recursively) by the - * xdr union, pamplist_t. + * an actual struct pmap, and then (recursively) by the + * xdr union, pamplist_t. * * This could be implemented via the xdr_union primitive, though this * would cause a one recursive call per element in the list. Rather than do @@ -82,35 +82,37 @@ static char sccsid[] = "@(#)pmap_prot2.c 1.3 87/08/11 Copyr 1984 Sun Micro"; * this sounds like a job for xdr_reference! */ bool_t -xdr_pmaplist(xdrs, rp) - register XDR *xdrs; - register struct pmaplist **rp; +xdr_pmaplist (xdrs, rp) + XDR *xdrs; + struct pmaplist **rp; { - /* - * more_elements is pre-computed in case the direction is - * XDR_ENCODE or XDR_FREE. more_elements is overwritten by - * xdr_bool when the direction is XDR_DECODE. - */ - bool_t more_elements; - register int freeing = (xdrs->x_op == XDR_FREE); - register struct pmaplist **next; + /* + * more_elements is pre-computed in case the direction is + * XDR_ENCODE or XDR_FREE. more_elements is overwritten by + * xdr_bool when the direction is XDR_DECODE. + */ + bool_t more_elements; + int freeing = (xdrs->x_op == XDR_FREE); + struct pmaplist **next = NULL; - while (TRUE) { - more_elements = (bool_t)(*rp != NULL); - if (! xdr_bool(xdrs, &more_elements)) - return (FALSE); - 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)) - return (FALSE); - rp = (freeing) ? next : &((*rp)->pml_next); - } + while (TRUE) + { + more_elements = (bool_t) (*rp != NULL); + if (!xdr_bool (xdrs, &more_elements)) + return FALSE; + 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), + (xdrproc_t) xdr_pmap)) + return FALSE; + rp = freeing ? next : &((*rp)->pml_next); + } } diff --git a/sunrpc/pmap_rmt.c b/sunrpc/pmap_rmt.c index 8907929973..c3667d4738 100644 --- a/sunrpc/pmap_rmt.c +++ b/sunrpc/pmap_rmt.c @@ -39,6 +39,8 @@ static char sccsid[] = "@(#)pmap_rmt.c 1.21 87/08/27 Copyr 1984 Sun Micro"; * Copyright (C) 1984, Sun Microsystems, Inc. */ +#include <unistd.h> +#include <string.h> #include <rpc/rpc.h> #include <rpc/pmap_prot.h> #include <rpc/pmap_clnt.h> @@ -53,11 +55,7 @@ static char sccsid[] = "@(#)pmap_rmt.c 1.21 87/08/27 Copyr 1984 Sun Micro"; #include <arpa/inet.h> #define MAX_BROADCAST_SIZE 1400 -#ifndef errno -extern int errno; -#endif -static struct timeval timeout = { 3, 0 }; - +static struct timeval timeout = {3, 0}; /* * pmapper remote-call-service interface. @@ -65,42 +63,46 @@ static struct timeval timeout = { 3, 0 }; * which will look up a service program in the port maps, and then * remotely call that routine with the given parameters. This allows * 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; - struct rmtcallargs a; - struct rmtcallres r; - enum clnt_stat stat; + int socket = -1; + CLIENT *client; + struct rmtcallargs a; + struct rmtcallres r; + enum clnt_stat stat; - addr->sin_port = htons(PMAPPORT); - client = clntudp_create(addr, PMAPPROG, PMAPVERS, timeout, &socket); - if (client != (CLIENT *)NULL) { - a.prog = prog; - a.vers = vers; - a.proc = proc; - a.args_ptr = argsp; - a.xdr_args = xdrargs; - r.port_ptr = port_ptr; - r.results_ptr = resp; - r.xdr_results = xdrres; - stat = CLNT_CALL(client, PMAPPROC_CALLIT, xdr_rmtcall_args, &a, - xdr_rmtcallres, &r, tout); - CLNT_DESTROY(client); - } else { - stat = RPC_FAILED; - } - /* (void)close(socket); CLNT_DESTROY already closed it */ - addr->sin_port = 0; - return (stat); + addr->sin_port = htons (PMAPPORT); + client = clntudp_create (addr, PMAPPROG, PMAPVERS, timeout, &socket); + if (client != (CLIENT *) NULL) + { + a.prog = prog; + a.vers = vers; + a.proc = proc; + a.args_ptr = argsp; + a.xdr_args = xdrargs; + r.port_ptr = port_ptr; + r.results_ptr = resp; + r.xdr_results = xdrres; + stat = CLNT_CALL (client, PMAPPROC_CALLIT, (xdrproc_t)xdr_rmtcall_args, + (caddr_t)&a, (xdrproc_t)xdr_rmtcallres, + (caddr_t)&r, tout); + CLNT_DESTROY (client); + } + else + { + stat = RPC_FAILED; + } + /* (void)close(socket); CLNT_DESTROY already closed it */ + addr->sin_port = 0; + return stat; } @@ -109,30 +111,31 @@ pmap_rmtcall(addr, prog, vers, proc, xdrargs, argsp, xdrres, resp, tout, port_pt * written for XDR_ENCODE direction only */ bool_t -xdr_rmtcall_args(xdrs, cap) - register XDR *xdrs; - register struct rmtcallargs *cap; +xdr_rmtcall_args (xdrs, cap) + XDR *xdrs; + struct rmtcallargs *cap; { - u_int lenposition, argposition, position; + u_int lenposition, argposition, position; - if (xdr_u_long(xdrs, &(cap->prog)) && - 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); - argposition = XDR_GETPOS(xdrs); - if (! (*(cap->xdr_args))(xdrs, cap->args_ptr)) - return (FALSE); - position = XDR_GETPOS(xdrs); - cap->arglen = (u_long)position - (u_long)argposition; - XDR_SETPOS(xdrs, lenposition); - if (! xdr_u_long(xdrs, &(cap->arglen))) - return (FALSE); - XDR_SETPOS(xdrs, position); - return (TRUE); - } - return (FALSE); + if (xdr_u_long (xdrs, &(cap->prog)) && + 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; + argposition = XDR_GETPOS (xdrs); + if (!(*(cap->xdr_args)) (xdrs, cap->args_ptr)) + return FALSE; + position = XDR_GETPOS (xdrs); + cap->arglen = (u_long) position - (u_long) argposition; + XDR_SETPOS (xdrs, lenposition); + if (!xdr_u_long (xdrs, &(cap->arglen))) + return FALSE; + XDR_SETPOS (xdrs, position); + return TRUE; + } + return FALSE; } /* @@ -140,19 +143,20 @@ xdr_rmtcall_args(xdrs, cap) * written for XDR_DECODE direction only */ bool_t -xdr_rmtcallres(xdrs, crp) - register XDR *xdrs; - register struct rmtcallres *crp; +xdr_rmtcallres (xdrs, crp) + XDR *xdrs; + struct rmtcallres *crp; { - caddr_t port_ptr; + 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)); - } - return (FALSE); + port_ptr = (caddr_t) crp->port_ptr; + if (xdr_reference (xdrs, &port_ptr, sizeof (u_long), (xdrproc_t) 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; } @@ -163,231 +167,253 @@ xdr_rmtcallres(xdrs, crp) */ static int -getbroadcastnets(addrs, sock, buf) - struct in_addr *addrs; - int sock; /* any valid socket will do */ - char *buf; /* why allocate more when we can use existing... */ +getbroadcastnets (struct in_addr *addrs, int sock, char *buf) + /* int sock: any valid socket will do */ + /* char *buf: why allocate more when we can use existing... */ { - struct ifconf ifc; - struct ifreq ifreq, *ifr; - struct sockaddr_in *sin; - int n, i; + struct ifconf ifc; + struct ifreq ifreq, *ifr; + struct sockaddr_in *sin; + 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) { - addrs[i++] = inet_makeaddr(inet_netof - /* Changed to pass struct instead of s_addr member - by roland@gnu. */ - (sin->sin_addr), INADDR_ANY); - } else { - addrs[i++] = ((struct sockaddr_in*) - &ifreq.ifr_addr)->sin_addr; - } + 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) + { + addrs[i++] = inet_makeaddr (inet_netof + /* Changed to pass struct instead of s_addr member + by roland@gnu. */ + (sin->sin_addr), INADDR_ANY); + } + else + { + addrs[i++] = ((struct sockaddr_in *) + &ifreq.ifr_addr)->sin_addr; + } #else /* 4.2 BSD */ - addrs[i++] = inet_makeaddr(inet_netof - (sin->sin_addr.s_addr), INADDR_ANY); + addrs[i++] = inet_makeaddr (inet_netof + (sin->sin_addr.s_addr), INADDR_ANY); #endif - } } - return (i); + } + return i; } 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 */ +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(); - XDR xdr_stream; - register XDR *xdrs = &xdr_stream; - int outlen, inlen, fromlen, nets; - register int sock; - int on = 1; + enum clnt_stat stat; + AUTH *unix_auth = authunix_create_default (); + XDR xdr_stream; + XDR *xdrs = &xdr_stream; + int outlen, inlen, fromlen, nets; + int sock; + int on = 1; #ifdef FD_SETSIZE - fd_set mask; - fd_set readfds; + fd_set mask; + fd_set readfds; #else - int readfds; - register int mask; + int readfds; + int mask; #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 rmtcallargs a; - struct rmtcallres r; - struct rpc_msg msg; - struct timeval t, t1; - char outbuf[MAX_BROADCAST_SIZE], inbuf[UDPMSGSIZE]; + int i; + bool_t done = FALSE; + u_long xid; + u_long port; + struct in_addr addrs[20]; + struct sockaddr_in baddr, raddr; /* broadcast and response addresses */ + struct rmtcallargs a; + struct rmtcallres r; + struct rpc_msg msg; + struct timeval t, t1; + char outbuf[MAX_BROADCAST_SIZE], inbuf[UDPMSGSIZE]; - /* - * initialization: create a socket, a broadcast address, and - * preserialize the arguments into a send buffer. - */ - if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { - perror(_("Cannot create socket for broadcast rpc")); - stat = RPC_CANTSEND; - goto done_broad; - } + /* + * initialization: create a socket, a broadcast address, and + * preserialize the arguments into a send buffer. + */ + if ((sock = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) + { + perror (_("Cannot create socket for broadcast rpc")); + stat = RPC_CANTSEND; + goto done_broad; + } #ifdef SO_BROADCAST - if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &on, sizeof (on)) < 0) { - perror(_("Cannot set socket option SO_BROADCAST")); - stat = RPC_CANTSEND; - goto done_broad; - } + 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 */ #ifdef FD_SETSIZE - FD_ZERO(&mask); - FD_SET(sock, &mask); + FD_ZERO (&mask); + FD_SET (sock, &mask); #else - mask = (1 << sock); + mask = (1 << sock); #endif /* def FD_SETSIZE */ - nets = getbroadcastnets(addrs, sock, inbuf); - 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); - msg.rm_xid = xid = getpid() ^ t.tv_sec ^ t.tv_usec; - t.tv_usec = 0; - msg.rm_direction = CALL; - msg.rm_call.cb_rpcvers = RPC_MSG_VERSION; - msg.rm_call.cb_prog = PMAPPROG; - msg.rm_call.cb_vers = PMAPVERS; - msg.rm_call.cb_proc = PMAPPROC_CALLIT; - msg.rm_call.cb_cred = unix_auth->ah_cred; - msg.rm_call.cb_verf = unix_auth->ah_verf; - a.prog = prog; - a.vers = vers; - a.proc = proc; - a.xdr_args = xargs; - a.args_ptr = argsp; - r.port_ptr = &port; - 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))) { - stat = RPC_CANTENCODEARGS; - goto done_broad; + nets = getbroadcastnets (addrs, sock, inbuf); + 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); + msg.rm_xid = xid = getpid () ^ t.tv_sec ^ t.tv_usec; + t.tv_usec = 0; + msg.rm_direction = CALL; + msg.rm_call.cb_rpcvers = RPC_MSG_VERSION; + msg.rm_call.cb_prog = PMAPPROG; + msg.rm_call.cb_vers = PMAPVERS; + msg.rm_call.cb_proc = PMAPPROC_CALLIT; + msg.rm_call.cb_cred = unix_auth->ah_cred; + msg.rm_call.cb_verf = unix_auth->ah_verf; + a.prog = prog; + a.vers = vers; + a.proc = proc; + a.xdr_args = xargs; + a.args_ptr = argsp; + r.port_ptr = &port; + 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))) + { + stat = RPC_CANTENCODEARGS; + goto done_broad; + } + outlen = (int) xdr_getpos (xdrs); + xdr_destroy (xdrs); + /* + * Basic loop: broadcast a packet and wait a while for response(s). + * The response timeout grows larger per iteration. + */ + for (t.tv_sec = 4; t.tv_sec <= 14; t.tv_sec += 2) + { + for (i = 0; i < nets; i++) + { + baddr.sin_addr = addrs[i]; + if (sendto (sock, outbuf, outlen, 0, + (struct sockaddr *) &baddr, + sizeof (struct sockaddr)) != outlen) + { + perror (_("Cannot send broadcast packet")); + stat = RPC_CANTSEND; + goto done_broad; + } } - outlen = (int)xdr_getpos(xdrs); - xdr_destroy(xdrs); - /* - * Basic loop: broadcast a packet and wait a while for response(s). - * The response timeout grows larger per iteration. - */ - for (t.tv_sec = 4; t.tv_sec <= 14; t.tv_sec += 2) { - for (i = 0; i < nets; i++) { - baddr.sin_addr = addrs[i]; - if (sendto(sock, outbuf, outlen, 0, - (struct sockaddr *)&baddr, - sizeof (struct sockaddr)) != outlen) { - perror(_("Cannot send broadcast packet")); - stat = RPC_CANTSEND; - goto done_broad; - } - } - if (eachresult == NULL) { - stat = RPC_SUCCESS; - goto done_broad; - } - 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; - readfds = mask; - t1 = t; - switch (select(_rpc_dtablesize(), &readfds, (int *)NULL, - (int *)NULL, &t1)) { + if (eachresult == NULL) + { + stat = RPC_SUCCESS; + goto done_broad; + } + recv_again: + msg.acpted_rply.ar_verf = _null_auth; + msg.acpted_rply.ar_results.where = (caddr_t) & r; + msg.acpted_rply.ar_results.proc = (xdrproc_t) xdr_rmtcallres; + readfds = mask; + t1 = t; + switch (select (_rpc_dtablesize (), &readfds, (fd_set *) NULL, + (fd_set *) NULL, &t1)) + { - case 0: /* timed out */ - stat = RPC_TIMEDOUT; - continue; + case 0: /* timed out */ + stat = RPC_TIMEDOUT; + continue; - case -1: /* some kind of error */ - if (errno == EINTR) - goto recv_again; - perror(_("Broadcast select problem")); - stat = RPC_CANTRECV; - goto done_broad; + 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: - fromlen = sizeof(struct sockaddr); - inlen = recvfrom(sock, inbuf, UDPMSGSIZE, 0, - (struct sockaddr *)&raddr, &fromlen); - if (inlen < 0) { - if (errno == EINTR) - goto try_again; - perror(_("Cannot receive reply to broadcast")); - stat = RPC_CANTRECV; - goto done_broad; - } - if (inlen < sizeof(u_long)) - goto recv_again; - /* - * see if reply transaction id matches sent id. - * If so, decode the results. - */ - 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); - } - /* otherwise, we just ignore the errors ... */ - } else { + } /* end of select results switch */ + try_again: + fromlen = sizeof (struct sockaddr); + inlen = recvfrom (sock, inbuf, UDPMSGSIZE, 0, + (struct sockaddr *) &raddr, &fromlen); + if (inlen < 0) + { + if (errno == EINTR) + goto try_again; + perror (_("Cannot receive reply to broadcast")); + stat = RPC_CANTRECV; + goto done_broad; + } + if (inlen < sizeof (u_long)) + goto recv_again; + /* + * see if reply transaction id matches sent id. + * If so, decode the results. + */ + 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); + } + /* otherwise, we just ignore the errors ... */ + } + else + { #ifdef notdef - /* some kind of deserialization problem ... */ - if (msg.rm_xid == xid) - fprintf(stderr, "Broadcast deserialization problem"); - /* otherwise, just random garbage */ + /* some kind of deserialization problem ... */ + if (msg.rm_xid == xid) + fprintf (stderr, "Broadcast deserialization problem"); + /* otherwise, just random garbage */ #endif - } - xdrs->x_op = XDR_FREE; - msg.acpted_rply.ar_results.proc = xdr_void; - (void)xdr_replymsg(xdrs, &msg); - (void)(*xresults)(xdrs, resultsp); - xdr_destroy(xdrs); - if (done) { - stat = RPC_SUCCESS; - goto done_broad; - } else { - goto recv_again; - } } + xdrs->x_op = XDR_FREE; + msg.acpted_rply.ar_results.proc = (xdrproc_t)xdr_void; + (void) xdr_replymsg (xdrs, &msg); + (void) (*xresults) (xdrs, resultsp); + xdr_destroy (xdrs); + if (done) + { + stat = RPC_SUCCESS; + goto done_broad; + } + else + { + goto recv_again; + } + } done_broad: - (void)close(sock); - AUTH_DESTROY(unix_auth); - return (stat); + (void) close (sock); + AUTH_DESTROY (unix_auth); + return stat; } diff --git a/sunrpc/rpc/auth.h b/sunrpc/rpc/auth.h index fff60baccd..61cd351485 100644 --- a/sunrpc/rpc/auth.h +++ b/sunrpc/rpc/auth.h @@ -42,6 +42,7 @@ #define _RPC_AUTH_H 1 #include <features.h> +#include <rpc/xdr.h> __BEGIN_DECLS @@ -76,7 +77,7 @@ union des_block { char c[8]; }; typedef union des_block des_block; -extern bool_t xdr_des_block(); +extern bool_t xdr_des_block __P ((XDR *__xdrs, des_block *__blkp)); /* * Authentication info. Opaque to client. @@ -90,19 +91,21 @@ struct opaque_auth { /* * Auth handle, interface to client side authenticators. */ -typedef struct { - struct opaque_auth ah_cred; - struct opaque_auth ah_verf; - union des_block ah_key; - struct auth_ops { - void (*ah_nextverf)(); - int (*ah_marshal)(); /* nextverf & serialize */ - int (*ah_validate)(); /* validate verifier */ - int (*ah_refresh)(); /* refresh credentials */ - void (*ah_destroy)(); /* destroy this structure */ - } *ah_ops; - caddr_t ah_private; -} AUTH; +typedef struct AUTH AUTH; +struct AUTH { + struct opaque_auth ah_cred; + struct opaque_auth ah_verf; + union des_block ah_key; + struct auth_ops { + void (*ah_nextverf) __P ((AUTH *)); + int (*ah_marshal) __P ((AUTH *, XDR *)); /* nextverf & serialize */ + int (*ah_validate) __P ((AUTH *, struct opaque_auth *)); + /* validate verifier */ + int (*ah_refresh) __P ((AUTH *)); /* refresh credentials */ + void (*ah_destroy) __P ((AUTH *)); /* destroy this structure */ + } *ah_ops; + caddr_t ah_private; +}; /* @@ -160,14 +163,17 @@ extern AUTH *authunix_create __P ((char *__machname, __uid_t __uid, __gid_t *__aup_gids)); extern AUTH *authunix_create_default __P ((void)); extern AUTH *authnone_create __P ((void)); -extern AUTH *authdes_create(); +extern AUTH *authdes_create __P ((char *__servername, u_int __window, + struct sockaddr *__syncaddr, + des_block *__ckey)); #define AUTH_NONE 0 /* no authentication */ #define AUTH_NULL 0 /* backward compatibility */ -#define AUTH_UNIX 1 /* unix style (uid, gids) */ #define AUTH_SYS 1 /* unix style (uid, gids) */ +#define AUTH_UNIX AUTH_SYS #define AUTH_SHORT 2 /* short hand unix style */ #define AUTH_DES 3 /* des style (encrypted timestamps) */ +#define AUTH_KERB 4 /* kerberos style */ __END_DECLS diff --git a/sunrpc/rpc/clnt.h b/sunrpc/rpc/clnt.h index 305e26d241..2cabc00d64 100644 --- a/sunrpc/rpc/clnt.h +++ b/sunrpc/rpc/clnt.h @@ -66,22 +66,33 @@ enum clnt_stat { RPC_PROCUNAVAIL=10, /* procedure unavailable */ RPC_CANTDECODEARGS=11, /* decode arguments error */ RPC_SYSTEMERROR=12, /* generic "other problem" */ - + RPC_NOBROADCAST = 21, /* Broadcasting not supported */ /* * callrpc & clnt_create errors */ RPC_UNKNOWNHOST=13, /* unknown host name */ RPC_UNKNOWNPROTO=17, /* unknown protocol */ + RPC_UNKNOWNADDR = 19, /* Remote address unknown */ /* - * _ create errors + * rpcbind errors */ - RPC_PMAPFAILURE=14, /* the pmapper failed in its call */ + RPC_RPCBFAILURE=14, /* portmapper failed in its call */ +#define RPC_PMAPFAILURE RPC_RPCBFAILURE RPC_PROGNOTREGISTERED=15, /* remote program is not registered */ + RPC_N2AXLATEFAILURE = 22, /* Name to addr translation failed */ /* * unspecified error */ - RPC_FAILED=16 + RPC_FAILED=16, + RPC_INTR=18, + RPC_TLIERROR=20, + RPC_UDERROR=23, + /* + * asynchronous errors + */ + RPC_INPROGRESS = 24, + RPC_STALERACHANDLE = 25 }; @@ -89,19 +100,19 @@ enum clnt_stat { * Error info. */ struct rpc_err { - enum clnt_stat re_status; - union { - int RE_errno; /* related system error */ - enum auth_stat RE_why; /* why the auth error occurred */ - struct { - u_long low; /* lowest verion supported */ - u_long high; /* highest verion supported */ - } RE_vers; - struct { /* maybe meaningful if RPC_FAILED */ - long s1; - long s2; - } RE_lb; /* life boot & debugging only */ - } ru; + enum clnt_stat re_status; + union { + int RE_errno; /* related system error */ + enum auth_stat RE_why; /* why the auth error occurred */ + struct { + u_long low; /* lowest verion supported */ + u_long high; /* highest verion supported */ + } RE_vers; + struct { /* maybe meaningful if RPC_FAILED */ + long s1; + long s2; + } RE_lb; /* life boot & debugging only */ + } ru; #define re_errno ru.RE_errno #define re_why ru.RE_why #define re_vers ru.RE_vers @@ -114,18 +125,25 @@ struct rpc_err { * Created by individual implementations, see e.g. rpc_udp.c. * Client is responsible for initializing auth, see e.g. auth_none.c. */ -typedef struct { - AUTH *cl_auth; /* authenticator */ - struct clnt_ops { - enum clnt_stat (*cl_call)(); /* call remote procedure */ - void (*cl_abort)(); /* abort a call */ - void (*cl_geterr)(); /* get specific error code */ - bool_t (*cl_freeres)(); /* frees results */ - void (*cl_destroy)();/* destroy this structure */ - bool_t (*cl_control)();/* the ioctl() of rpc */ - } *cl_ops; - caddr_t cl_private; /* private stuff */ -} CLIENT; +typedef struct CLIENT CLIENT; +struct CLIENT { + AUTH *cl_auth; /* authenticator */ + struct clnt_ops { + enum clnt_stat (*cl_call) __P ((CLIENT *, u_long, xdrproc_t, + caddr_t, xdrproc_t, + caddr_t, struct timeval)); + /* call remote procedure */ + void (*cl_abort) __P ((void)); /* abort a call */ + void (*cl_geterr) __P ((CLIENT *, struct rpc_err *)); + /* get specific error code */ + bool_t (*cl_freeres) __P ((CLIENT *, xdrproc_t, caddr_t)); + /* frees results */ + void (*cl_destroy) __P ((CLIENT *)); /* destroy this structure */ + bool_t (*cl_control) __P ((CLIENT *, int, char *)); + /* the ioctl() of rpc */ + } *cl_ops; + caddr_t cl_private; /* private stuff */ +}; /* @@ -189,16 +207,29 @@ typedef struct { #define clnt_control(cl,rq,in) ((*(cl)->cl_ops->cl_control)(cl,rq,in)) /* - * control operations that apply to both udp and tcp transports + * control operations that apply to all transports */ -#define CLSET_TIMEOUT 1 /* set timeout (timeval) */ -#define CLGET_TIMEOUT 2 /* get timeout (timeval) */ -#define CLGET_SERVER_ADDR 3 /* get server's address (sockaddr) */ +#define CLSET_TIMEOUT 1 /* set timeout (timeval) */ +#define CLGET_TIMEOUT 2 /* get timeout (timeval) */ +#define CLGET_SERVER_ADDR 3 /* get server's address (sockaddr) */ +#define CLGET_FD 6 /* get connections file descriptor */ +#define CLGET_SVC_ADDR 7 /* get server's address (netbuf) */ +#define CLSET_FD_CLOSE 8 /* close fd while clnt_destroy */ +#define CLSET_FD_NCLOSE 9 /* Do not close fd while clnt_destroy*/ +#define CLGET_XID 10 /* Get xid */ +#define CLSET_XID 11 /* Set xid */ +#define CLGET_VERS 12 /* Get version number */ +#define CLSET_VERS 13 /* Set version number */ +#define CLGET_PROG 14 /* Get program number */ +#define CLSET_PROG 15 /* Set program number */ +#define CLSET_SVC_ADDR 16 /* get server's address (netbuf) */ +#define CLSET_PUSH_TIMOD 17 /* push timod if not already present */ +#define CLSET_POP_TIMOD 18 /* pop timod */ /* - * udp only control operations + * Connectionless only control operations */ -#define CLSET_RETRY_TIMEOUT 4 /* set retry timeout (timeval) */ -#define CLGET_RETRY_TIMEOUT 5 /* get retry timeout (timeval) */ +#define CLSET_RETRY_TIMEOUT 4 /* set retry timeout (timeval) */ +#define CLGET_RETRY_TIMEOUT 5 /* get retry timeout (timeval) */ /* * void @@ -239,7 +270,8 @@ typedef struct { * u_long prog; * u_long vers; */ -extern CLIENT *clntraw_create __P ((u_long __prog, u_long __vers)); +extern CLIENT *clntraw_create __P ((__const u_long __prog, + __const u_long __vers)); /* @@ -247,12 +279,12 @@ extern CLIENT *clntraw_create __P ((u_long __prog, u_long __vers)); * CLIENT * * clnt_create(host, prog, vers, prot) * char *host; -- hostname - * u_int prog; -- program number - * u_int vers; -- version number + * u_long prog; -- program number + * u_ong vers; -- version number * char *prot; -- protocol */ -extern CLIENT *clnt_create __P ((char *__host, u_int __prog, u_int __vers, - char *__prot)); +extern CLIENT *clnt_create __P ((__const char *__host, __const u_long __prog, + __const u_long __vers, __const char *__prot)); /* @@ -302,11 +334,17 @@ extern CLIENT *clntudp_bufcreate __P ((struct sockaddr_in *__raddr, int *__sockp, u_int __sendsz, u_int __recvsz)); +extern int callrpc __P ((__const char *__host, __const u_long __prognum, + __const u_long __versnum, __const u_long __procnum, + __const xdrproc_t __inproc, __const char *__in, + __const xdrproc_t __outproc, char *__out)); +extern int _rpc_dtablesize __P ((void)); + /* * Print why creation failed */ -extern void clnt_pcreateerror __P ((char *__msg)); /* stderr */ -extern char *clnt_spcreateerror __P ((char *__msg)); /* string */ +extern void clnt_pcreateerror __P ((__const char *__msg)); /* stderr */ +extern char *clnt_spcreateerror __P ((__const char *__msg)); /* string */ /* * Like clnt_perror(), but is more verbose in its output @@ -316,8 +354,10 @@ extern void clnt_perrno __P ((enum clnt_stat __num)); /* stderr */ /* * Print an English error message, given the client error code */ -extern void clnt_perror __P ((CLIENT *__clnt, char *__msg)); /* stderr */ -extern char *clnt_sperror __P ((CLIENT *__clnt, char *__msg)); /* string */ +extern void clnt_perror __P ((CLIENT *__clnt, __const char *__msg)); + /* stderr */ +extern char *clnt_sperror __P ((CLIENT *__clnt, __const char *__msg)); + /* string */ /* * If a creation fails, the following allows the user to figure out why. @@ -336,7 +376,8 @@ extern struct rpc_createerr rpc_createerr; */ extern char *clnt_sperrno __P ((enum clnt_stat __num)); /* string */ - +extern int getrpcport __P ((__const char * __host, u_long __prognum, + u_long __versnum, u_int proto)); #define UDPMSGSIZE 8800 /* rpc imposed limit on udp msg size */ #define RPCSMALLMSGSIZE 400 /* a more reasonable packet size */ diff --git a/sunrpc/rpc/pmap_clnt.h b/sunrpc/rpc/pmap_clnt.h index f1a9d9be88..0b8d50f10f 100644 --- a/sunrpc/rpc/pmap_clnt.h +++ b/sunrpc/rpc/pmap_clnt.h @@ -41,7 +41,7 @@ __BEGIN_DECLS -typedef bool_t (*resultproc_t)(); +typedef bool_t (*resultproc_t) __P ((caddr_t resp, struct sockaddr_in *raddr)); /* * Usage: @@ -65,29 +65,29 @@ typedef bool_t (*resultproc_t)(); * address if the responder to the broadcast. */ -extern bool_t pmap_set __P ((u_long __program, u_long __version, +extern bool_t pmap_set __P ((__const u_long __program, __const u_long __vers, int __protocol, u_short __port)); - -extern bool_t pmap_unset __P ((u_long __program, u_long __version)); - +extern bool_t pmap_unset __P ((__const u_long __program, __const u_long __vers)); extern struct pmaplist *pmap_getmaps __P ((struct sockaddr_in *__address)); - extern enum clnt_stat pmap_rmtcall __P ((struct sockaddr_in *__addr, - u_long __prog, u_long __vers, - u_long __proc, xdrproc_t __xdrargs, + __const u_long __prog, + __const u_long __vers, + __const u_long __proc, + xdrproc_t __xdrargs, caddr_t __argsp, xdrproc_t __xdrres, caddr_t __resp, struct timeval __tout, u_long *__port_ptr)); - -extern enum clnt_stat clnt_broadcast __P ((u_long __prog, u_long __vers, - u_long __proc, xdrproc_t __xargs, +extern enum clnt_stat clnt_broadcast __P ((__const u_long __prog, + __const u_long __vers, + __const u_long __proc, + xdrproc_t __xargs, caddr_t __argsp, xdrproc_t __xresults, caddr_t __resultsp, resultproc_t __eachresult)); - extern u_short pmap_getport __P ((struct sockaddr_in *__address, - u_long __program, u_long __version, + __const u_long __program, + __const u_long __version, u_int __protocol)); __END_DECLS diff --git a/sunrpc/rpc/svc.h b/sunrpc/rpc/svc.h index ff7738752f..6a36900908 100644 --- a/sunrpc/rpc/svc.h +++ b/sunrpc/rpc/svc.h @@ -37,6 +37,9 @@ #ifndef __SVC_HEADER__ #define __SVC_HEADER__ +#include <features.h> +#include <rpc/rpc_msg.h> + __BEGIN_DECLS /* @@ -70,23 +73,31 @@ enum xprt_stat { /* * Server side transport handle */ -typedef struct { - int xp_sock; - u_short xp_port; /* associated port number */ - struct xp_ops { - bool_t (*xp_recv)(); /* receive incoming requests */ - enum xprt_stat (*xp_stat)(); /* get transport status */ - bool_t (*xp_getargs)(); /* get arguments */ - bool_t (*xp_reply)(); /* send reply */ - bool_t (*xp_freeargs)();/* free mem allocated for args */ - void (*xp_destroy)(); /* destroy this struct */ - } *xp_ops; - int xp_addrlen; /* length of remote address */ - struct sockaddr_in xp_raddr; /* remote address */ - struct opaque_auth xp_verf; /* raw response verifier */ - caddr_t xp_p1; /* private */ - caddr_t xp_p2; /* private */ -} SVCXPRT; +typedef struct SVCXPRT SVCXPRT; +struct SVCXPRT { + int xp_sock; + u_short xp_port; /* associated port number */ + const struct xp_ops { + bool_t (*xp_recv) __P ((SVCXPRT *__xprt, struct rpc_msg *__msg)); + /* receive incoming requests */ + enum xprt_stat (*xp_stat) __P ((SVCXPRT *__xprt)); + /* get transport status */ + bool_t (*xp_getargs) __P ((SVCXPRT *__xprt, xdrproc_t __xdr_args, + caddr_t args_ptr)); /* get arguments */ + bool_t (*xp_reply) __P ((SVCXPRT *__xprt, struct rpc_msg *__msg)); + /* send reply */ + bool_t (*xp_freeargs) __P ((SVCXPRT *__xprt, xdrproc_t __xdr_args, + caddr_t args_ptr)); + /* free mem allocated for args */ + void (*xp_destroy) __P ((SVCXPRT *__xprt)); + /* destroy this struct */ + } *xp_ops; + int xp_addrlen; /* length of remote address */ + struct sockaddr_in xp_raddr; /* remote address */ + struct opaque_auth xp_verf; /* raw response verifier */ + caddr_t xp_p1; /* private */ + caddr_t xp_p2; /* private */ +}; /* * Approved way of getting address of caller @@ -153,11 +164,12 @@ struct svc_req { * u_long prog; * u_long vers; * void (*dispatch)(); - * int protocol; like TCP or UDP, zero means do not register + * u_long protocol; like TCP or UDP, zero means do not register */ extern bool_t svc_register __P ((SVCXPRT *__xprt, u_long __prog, - u_long __vers, void (*__dispatch) (), - int __protocol)); + u_long __vers, void (*__dispatch) + __P ((struct svc_req *, SVCXPRT *)), + u_long __protocol)); /* * Service un-registration @@ -257,11 +269,9 @@ extern int svc_fds; * a small program implemented by the svc_rpc implementation itself; * also see clnt.h for protocol numbers. */ -extern void rpctest_service(); - extern void svc_getreq __P ((int __rdfds)); extern void svc_getreqset __P ((fd_set *readfds)); -extern void svc_run __P ((void)) __attribute__ ((noreturn)); +extern void svc_run __P ((void)); /* __attribute__ ((noreturn)) */ /* * Socket to use on svcxxx_create call to get default socket diff --git a/sunrpc/rpc/svc_auth.h b/sunrpc/rpc/svc_auth.h index 543ddb974d..320a03a3bd 100644 --- a/sunrpc/rpc/svc_auth.h +++ b/sunrpc/rpc/svc_auth.h @@ -39,6 +39,7 @@ #define _RPC_SVC_AUTH_H 1 #include <features.h> +#include <rpc/svc.h> __BEGIN_DECLS diff --git a/sunrpc/rpc/types.h b/sunrpc/rpc/types.h index fc3d7d5302..fbfda1a3db 100644 --- a/sunrpc/rpc/types.h +++ b/sunrpc/rpc/types.h @@ -35,13 +35,21 @@ #ifndef __TYPES_RPC_HEADER__ #define __TYPES_RPC_HEADER__ -#define bool_t int -#define enum_t int -#define FALSE (0) -#define TRUE (1) -#define __dontcare__ -1 +typedef int bool_t; +typedef int enum_t; + +#define __dontcare__ -1 + +#ifndef FALSE +# define FALSE (0) +#endif + +#ifndef TRUE +# define TRUE (1) +#endif + #ifndef NULL -# define NULL 0 +# define NULL 0 #endif #include <stdlib.h> /* For malloc decl. */ diff --git a/sunrpc/rpc/xdr.h b/sunrpc/rpc/xdr.h index e54df5a1fd..eecb1e14be 100644 --- a/sunrpc/rpc/xdr.h +++ b/sunrpc/rpc/xdr.h @@ -54,10 +54,10 @@ __BEGIN_DECLS * * Each data type provides a single procedure which takes two arguments: * - * bool_t - * xdrproc(xdrs, argresp) - * XDR *xdrs; - * <type> *argresp; + * bool_t + * xdrproc(xdrs, argresp) + * XDR *xdrs; + * <type> *argresp; * * xdrs is an instance of a XDR handle, to which or from which the data * type is to be converted. argresp is a pointer to the structure to be @@ -80,11 +80,12 @@ __BEGIN_DECLS * XDR_FREE can be used to release the space allocated by an XDR_DECODE * request. */ -enum xdr_op { - XDR_ENCODE=0, - XDR_DECODE=1, - XDR_FREE=2 -}; +enum xdr_op + { + XDR_ENCODE = 0, + XDR_DECODE = 1, + XDR_FREE = 2 + }; /* * This is the number of bytes per unit of external data. @@ -99,23 +100,36 @@ enum xdr_op { * an operations vector for the particular implementation (e.g. see xdr_mem.c), * and two private fields for the use of the particular implementation. */ -typedef struct { - enum xdr_op x_op; /* operation; fast additional param */ - struct xdr_ops { - bool_t (*x_getlong)(); /* get a long from underlying stream */ - bool_t (*x_putlong)(); /* put a long to " */ - bool_t (*x_getbytes)();/* get some bytes from " */ - bool_t (*x_putbytes)();/* put some bytes to " */ - u_int (*x_getpostn)();/* returns bytes off from beginning */ - bool_t (*x_setpostn)();/* lets you reposition the stream */ - long * (*x_inline)(); /* buf quick ptr to buffered data */ - void (*x_destroy)(); /* free privates of this xdr_stream */ - } *x_ops; - caddr_t x_public; /* users' data */ - caddr_t x_private; /* pointer to private data */ - caddr_t x_base; /* private used for position info */ - int x_handy; /* extra private word */ -} XDR; +typedef struct XDR XDR; +struct XDR + { + enum xdr_op x_op; /* operation; fast additional param */ + const struct xdr_ops + { + bool_t (*x_getlong) __P ((XDR * __xdrs, long *__lp)); + /* get a long from underlying stream */ + bool_t (*x_putlong) __P ((XDR * __xdrs, long *__lp)); + /* put a long to " */ + bool_t (*x_getbytes) __P ((XDR * __xdrs, caddr_t __addr, u_int __len)); + /* get some bytes from " */ + bool_t (*x_putbytes) __P ((XDR * __xdrs, __const caddr_t __addr, + u_int __len)); + /* put some bytes to " */ + u_int (*x_getpostn) __P ((XDR * __xdrs)); + /* returns bytes off from beginning */ + bool_t (*x_setpostn) __P ((XDR * __xdrs, u_int pos)); + /* lets you reposition the stream */ + long *(*x_inline) __P ((XDR * __xdrs, int len)); + /* buf quick ptr to buffered data */ + void (*x_destroy) __P ((XDR * __xdrs)); + /* free privates of this xdr_stream */ + } + *x_ops; + caddr_t x_public; /* users' data */ + caddr_t x_private; /* pointer to private data */ + caddr_t x_base; /* private used for position info */ + int x_handy; /* extra private word */ + }; /* * A xdrproc_t exists for each data type which is to be encoded or decoded. @@ -124,18 +138,19 @@ typedef struct { * The opaque pointer generally points to a structure of the data type * to be decoded. If this pointer is 0, then the type routines should * allocate dynamic storage of the appropriate size and return it. - * bool_t (*xdrproc_t)(XDR *, caddr_t *); + * bool_t (*xdrproc_t)(XDR *, caddr_t *); */ -typedef bool_t (*xdrproc_t) __P ((XDR *, void *, ...)); +typedef +bool_t (*xdrproc_t) __P ((XDR *, void *,...)); /* * Operations defined on a XDR handle * - * XDR *xdrs; - * long *longp; - * caddr_t addr; - * u_int len; - * u_int pos; + * XDR *xdrs; + * long *longp; + * caddr_t addr; + * u_int len; + * u_int pos; */ #define XDR_GETLONG(xdrs, longp) \ (*(xdrs)->x_ops->x_getlong)(xdrs, longp) @@ -190,9 +205,10 @@ typedef bool_t (*xdrproc_t) __P ((XDR *, void *, ...)); * If there is no match and no default routine it is an error. */ #define NULL_xdrproc_t ((xdrproc_t)0) -struct xdr_discrim { - int value; - xdrproc_t proc; +struct xdr_discrim +{ + int value; + xdrproc_t proc; }; /* @@ -201,9 +217,9 @@ struct xdr_discrim { * data from the underlying buffer, and will fail to operate * properly if the data is not aligned. The standard way to use these * is to say: - * if ((buf = XDR_INLINE(xdrs, count)) == NULL) - * return (FALSE); - * <<< macro calls >>> + * if ((buf = XDR_INLINE(xdrs, count)) == NULL) + * return (FALSE); + * <<< macro calls >>> * where ``count'' is the number of bytes of data occupied * by the primitive data types. * @@ -228,48 +244,49 @@ struct xdr_discrim { /* * These are the "generic" xdr routines. */ -extern bool_t xdr_void (); -extern bool_t xdr_int __P ((XDR *__xdrs, int *__ip)); -extern bool_t xdr_u_int __P ((XDR *__xdrs, u_int *__up)); -extern bool_t xdr_long __P ((XDR *__xdrs, long *__lp)); -extern bool_t xdr_u_long __P ((XDR *__xdrs, u_long *__ulp)); -extern bool_t xdr_short __P ((XDR *__xdrs, short *__sp)); -extern bool_t xdr_u_short __P ((XDR *__xdrs, u_short *__usp)); -extern bool_t xdr_bool __P ((XDR *__xdrs, bool_t *__bp)); -extern bool_t xdr_enum __P ((XDR *__xdrs, enum_t *__ep)); -extern bool_t xdr_array __P ((XDR *_xdrs, caddr_t *__addrp, u_int *__sizep, - u_int __maxsize, u_int __elsize, - xdrproc_t __elproc)); -extern bool_t xdr_bytes __P ((XDR *__xdrs, char **__cpp, u_int *__sizep, - u_int __maxsize)); -extern bool_t xdr_opaque __P ((XDR *__xdrs, caddr_t __cp, u_int __cnt)); -extern bool_t xdr_string __P ((XDR *__xdrs, char **__cpp, u_int __maxsize)); -extern bool_t xdr_union __P ((XDR *__xdrs, enum_t *__dscmp, char *__unp, - struct xdr_discrim *__choices, - xdrproc_t dfault)); -extern bool_t xdr_char __P ((XDR *__xdrs, char *__cp)); -extern bool_t xdr_u_char __P ((XDR *__xdrs, u_char *__cp)); -extern bool_t xdr_vector __P ((XDR *__xdrs, char *__basep, u_int __nelem, - u_int __elemsize, xdrproc_t __xdr_elem)); -extern bool_t xdr_float __P ((XDR *__xdrs, float *__fp)); -extern bool_t xdr_double __P ((XDR *__xdrs, double *__dp)); -extern bool_t xdr_reference __P ((XDR *__xdrs, caddr_t *__pp, u_int __size, - xdrproc_t __proc)); -extern bool_t xdr_pointer __P ((XDR *__xdrs, char **__objpp, - u_int __obj_size, xdrproc_t __xdr_obj)); -extern bool_t xdr_wrapstring __P ((XDR *__xdrs, char **__cpp)); +extern bool_t xdr_void __P ((void)); +extern bool_t xdr_int __P ((XDR * __xdrs, int *__ip)); +extern bool_t xdr_u_int __P ((XDR * __xdrs, u_int * __up)); +extern bool_t xdr_long __P ((XDR * __xdrs, long *__lp)); +extern bool_t xdr_u_long __P ((XDR * __xdrs, u_long * __ulp)); +extern bool_t xdr_short __P ((XDR * __xdrs, short *__sp)); +extern bool_t xdr_u_short __P ((XDR * __xdrs, u_short * __usp)); +extern bool_t xdr_bool __P ((XDR * __xdrs, bool_t * __bp)); +extern bool_t xdr_enum __P ((XDR * __xdrs, enum_t * __ep)); +extern bool_t xdr_array __P ((XDR * _xdrs, caddr_t * __addrp, u_int * __sizep, + u_int __maxsize, u_int __elsize, + xdrproc_t __elproc)); +extern bool_t xdr_bytes __P ((XDR * __xdrs, char **__cpp, u_int * __sizep, + u_int __maxsize)); +extern bool_t xdr_opaque __P ((XDR * __xdrs, caddr_t __cp, u_int __cnt)); +extern bool_t xdr_string __P ((XDR * __xdrs, char **__cpp, u_int __maxsize)); +extern bool_t xdr_union __P ((XDR * __xdrs, enum_t * __dscmp, char *__unp, + __const struct xdr_discrim * __choices, + xdrproc_t dfault)); +extern bool_t xdr_char __P ((XDR * __xdrs, char *__cp)); +extern bool_t xdr_u_char __P ((XDR * __xdrs, u_char * __cp)); +extern bool_t xdr_vector __P ((XDR * __xdrs, char *__basep, u_int __nelem, + u_int __elemsize, xdrproc_t __xdr_elem)); +extern bool_t xdr_float __P ((XDR * __xdrs, float *__fp)); +extern bool_t xdr_double __P ((XDR * __xdrs, double *__dp)); +extern bool_t xdr_reference __P ((XDR * __xdrs, caddr_t * __pp, u_int __size, + xdrproc_t __proc)); +extern bool_t xdr_pointer __P ((XDR * __xdrs, char **__objpp, + u_int __obj_size, xdrproc_t __xdr_obj)); +extern bool_t xdr_wrapstring __P ((XDR * __xdrs, char **__cpp)); /* * Common opaque bytes objects used by many rpc protocols; * declared here due to commonality. */ #define MAX_NETOBJ_SZ 1024 -struct netobj { - u_int n_len; - char *n_bytes; +struct netobj +{ + u_int n_len; + char *n_bytes; }; typedef struct netobj netobj; -extern bool_t xdr_netobj __P ((XDR *__xdrs, struct netobj *__np)); +extern bool_t xdr_netobj __P ((XDR * __xdrs, struct netobj * __np)); /* * These are the public routines for the various implementations of @@ -277,26 +294,27 @@ extern bool_t xdr_netobj __P ((XDR *__xdrs, struct netobj *__np)); */ /* XDR using memory buffers */ -extern void xdrmem_create __P ((XDR *__xdrs, caddr_t __addr, u_int __size, - enum xdr_op __op)); +extern void xdrmem_create __P ((XDR * __xdrs, caddr_t __addr, u_int __size, + enum xdr_op __op)); /* XDR using stdio library */ -extern void xdrstdio_create __P ((XDR *__xdrs, FILE *__file, - enum xdr_op __op)); +extern void xdrstdio_create __P ((XDR * __xdrs, FILE * __file, + enum xdr_op __op)); /* XDR pseudo records for tcp */ -extern void xdrrec_create __P ((XDR *__xdrs, u_int __sendsize, - u_int __recvsize, caddr_t __tcp_handle, - int (*__readit) (), int (*__writeit) ())); +extern void xdrrec_create __P ((XDR * __xdrs, u_int __sendsize, + u_int __recvsize, caddr_t __tcp_handle, + int (*__readit) (char *, char *, int), + int (*__writeit) (char *, char *, int))); /* make end of xdr record */ -extern bool_t xdrrec_endofrecord __P ((XDR *__xdrs, bool_t __sendnow)); +extern bool_t xdrrec_endofrecord __P ((XDR * __xdrs, bool_t __sendnow)); /* move to beginning of next record */ -extern bool_t xdrrec_skiprecord __P ((XDR *__xdrs)); +extern bool_t xdrrec_skiprecord __P ((XDR * __xdrs)); /* true if no more input */ -extern bool_t xdrrec_eof __P ((XDR *__xdrs)); +extern bool_t xdrrec_eof __P ((XDR * __xdrs)); /* free memory buffers for xdr */ extern void xdr_free __P ((xdrproc_t __proc, char *__objp)); diff --git a/sunrpc/rpc_clntout.c b/sunrpc/rpc_clntout.c index fbb8761100..fb086047ba 100644 --- a/sunrpc/rpc_clntout.c +++ b/sunrpc/rpc_clntout.c @@ -31,7 +31,7 @@ /* * From: @(#)rpc_clntout.c 1.11 89/02/22 (C) 1987 SMI */ -char clntout_rcsid[] = +char clntout_rcsid[] = "$Id$"; /* @@ -46,121 +46,141 @@ char clntout_rcsid[] = #include "proto.h" #define DEFAULT_TIMEOUT 25 /* in seconds */ -static char RESULT[] = "clnt_res"; +static const char RESULT[] = "clnt_res"; -static void write_program(definition *def); -static void printbody(proc_list *proc); -static const char *ampr(const char *type); -static void printbody(proc_list *proc); +static void write_program (definition * def); +static void printbody (proc_list * proc); +static const char *ampr (const char *type); +static void printbody (proc_list * proc); void -write_stubs(void) +write_stubs (void) { - list *l; - definition *def; - - f_print(fout, - "\n/* Default timeout can be changed using clnt_control() */\n"); - f_print(fout, "static struct timeval TIMEOUT = { %d, 0 };\n", - DEFAULT_TIMEOUT); - for (l = defined; l != NULL; l = l->next) { - def = (definition *) l->val; - if (def->def_kind == DEF_PROGRAM) { - write_program(def); - } + list *l; + definition *def; + + f_print (fout, + "\n/* Default timeout can be changed using clnt_control() */\n"); + f_print (fout, "static struct timeval TIMEOUT = { %d, 0 };\n", + DEFAULT_TIMEOUT); + for (l = defined; l != NULL; l = l->next) + { + def = (definition *) l->val; + if (def->def_kind == DEF_PROGRAM) + { + write_program (def); } + } } static void -write_program(definition *def) +write_program (definition * def) { - version_list *vp; - proc_list *proc; - - for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { - for (proc = vp->procs; proc != NULL; proc = proc->next) { - f_print(fout, "\n"); - ptype(proc->res_prefix, proc->res_type, 1); - f_print(fout, "*\n"); - pvname(proc->proc_name, vp->vers_num); - printarglist( proc, "clnt", "CLIENT *" ); - f_print(fout, "{\n"); - printbody(proc); - f_print(fout, "}\n"); - } + version_list *vp; + proc_list *proc; + + for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) + { + for (proc = vp->procs; proc != NULL; proc = proc->next) + { + f_print (fout, "\n"); + ptype (proc->res_prefix, proc->res_type, 1); + f_print (fout, "*\n"); + pvname (proc->proc_name, vp->vers_num); + printarglist (proc, "clnt", "CLIENT *"); + f_print (fout, "{\n"); + printbody (proc); + f_print (fout, "}\n"); } + } } /* Writes out declarations of procedure's argument list. In either ANSI C style, in one of old rpcgen style (pass by reference), or new rpcgen style (multiple arguments, pass by value); - */ + */ /* sample addargname = "clnt"; sample addargtype = "CLIENT * " */ -void printarglist(proc_list *proc, - const char *addargname, const char *addargtype) +void +printarglist (proc_list * proc, + const char *addargname, const char *addargtype) { decl_list *l; - if (!newstyle) { /* old style: always pass argument by reference */ - if (Cflag) { /* C++ style heading */ - f_print(fout, "("); - ptype(proc->args.decls->decl.prefix, proc->args.decls->decl.type, 1); - f_print(fout, "*argp, %s%s)\n", addargtype, addargname ); + if (!newstyle) + { /* old style: always pass argument by reference */ + if (Cflag) + { /* C++ style heading */ + f_print (fout, "("); + ptype (proc->args.decls->decl.prefix, proc->args.decls->decl.type, 1); + f_print (fout, "*argp, %s%s)\n", addargtype, addargname); + } + else + { + f_print (fout, "(argp, %s)\n", addargname); + f_print (fout, "\t"); + ptype (proc->args.decls->decl.prefix, proc->args.decls->decl.type, 1); + f_print (fout, "*argp;\n"); + } } - else { - f_print(fout, "(argp, %s)\n", addargname); - f_print(fout, "\t"); - ptype(proc->args.decls->decl.prefix, proc->args.decls->decl.type, 1); - f_print(fout, "*argp;\n"); + else if (streq (proc->args.decls->decl.type, "void")) + { + /* newstyle, 0 argument */ + if (Cflag) + f_print (fout, "(%s%s)\n", addargtype, addargname); + else + f_print (fout, "(%s)\n", addargname); } - } else if (streq( proc->args.decls->decl.type, "void")) { - /* newstyle, 0 argument */ - if( Cflag ) - f_print(fout, "(%s%s)\n", addargtype, addargname ); - else - f_print(fout, "(%s)\n", addargname); - } else { - /* new style, 1 or multiple arguments */ - if( !Cflag ) { - f_print(fout, "("); - for (l = proc->args.decls; l != NULL; l = l->next) - f_print(fout, "%s, ", l->decl.name); - f_print(fout, "%s)\n", addargname ); - for (l = proc->args.decls; l != NULL; l = l->next) { - pdeclaration(proc->args.argname, &l->decl, 1, ";\n" ); - } - } else { /* C++ style header */ - f_print(fout, "("); - for(l = proc->args.decls; l != NULL; l = l->next) { - pdeclaration(proc->args.argname, &l->decl, 0, ", " ); - } - f_print(fout, " %s%s)\n", addargtype, addargname ); + else + { + /* new style, 1 or multiple arguments */ + if (!Cflag) + { + f_print (fout, "("); + for (l = proc->args.decls; l != NULL; l = l->next) + f_print (fout, "%s, ", l->decl.name); + f_print (fout, "%s)\n", addargname); + for (l = proc->args.decls; l != NULL; l = l->next) + { + pdeclaration (proc->args.argname, &l->decl, 1, ";\n"); + } + } + else + { /* C++ style header */ + f_print (fout, "("); + for (l = proc->args.decls; l != NULL; l = l->next) + { + pdeclaration (proc->args.argname, &l->decl, 0, ", "); + } + f_print (fout, " %s%s)\n", addargtype, addargname); + } } - } - if( !Cflag ) - f_print(fout, "\t%s%s;\n", addargtype, addargname ); + if (!Cflag) + f_print (fout, "\t%s%s;\n", addargtype, addargname); } static const char * -ampr(const char *type) +ampr (const char *type) { - if (isvectordef(type, REL_ALIAS)) { - return (""); - } else { - return ("&"); - } + if (isvectordef (type, REL_ALIAS)) + { + return ""; + } + else + { + return "&"; + } } static void -printbody(proc_list *proc) +printbody (proc_list * proc) { decl_list *l; bool_t args2 = (proc->arg_num > 1); @@ -168,55 +188,68 @@ printbody(proc_list *proc) /* For new style with multiple arguments, need a structure in which to stuff the arguments. */ - if ( newstyle && args2) { - f_print(fout, "\t%s", proc->args.argname); - f_print(fout, " arg;\n"); - } - f_print(fout, "\tstatic "); - if (streq(proc->res_type, "void")) { - f_print(fout, "char "); - } else { - ptype(proc->res_prefix, proc->res_type, 0); - } - f_print(fout, "%s;\n",RESULT); - f_print(fout, "\n"); - f_print(fout, "\tmemset((char *)%s%s, 0, sizeof(%s));\n", - ampr(proc->res_type ), RESULT, RESULT); - if (newstyle && !args2 && (streq( proc->args.decls->decl.type, "void"))) { - /* newstyle, 0 arguments */ - f_print(fout, - "\tif (clnt_call(clnt, %s, xdr_void", proc->proc_name); - f_print(fout, - ", NULL, xdr_%s, %s,%s, TIMEOUT) != RPC_SUCCESS) {\n", - stringfix(proc->res_type), ampr(proc->res_type), RESULT); - - } else if ( newstyle && args2) { - /* newstyle, multiple arguments: stuff arguments into structure */ - for (l = proc->args.decls; l != NULL; l = l->next) { - f_print(fout, "\targ.%s = %s;\n", - l->decl.name, l->decl.name); - } - f_print(fout, - "\tif (clnt_call(clnt, %s, xdr_%s", proc->proc_name, - proc->args.argname); - f_print(fout, - ", &arg, xdr_%s, %s%s, TIMEOUT) != RPC_SUCCESS) {\n", - stringfix(proc->res_type), ampr(proc->res_type), RESULT); - } else { /* single argument, new or old style */ - f_print(fout, - "\tif (clnt_call(clnt, %s, xdr_%s, %s%s, xdr_%s, %s%s, TIMEOUT) != RPC_SUCCESS) {\n", - proc->proc_name, - stringfix(proc->args.decls->decl.type), - (newstyle ? "&" : ""), - (newstyle ? proc->args.decls->decl.name : "argp"), - stringfix(proc->res_type), ampr(proc->res_type),RESULT); - } - f_print(fout, "\t\treturn (NULL);\n"); - f_print(fout, "\t}\n"); - if (streq(proc->res_type, "void")) { - f_print(fout, "\treturn ((void *)%s%s);\n", - ampr(proc->res_type),RESULT); - } else { - f_print(fout, "\treturn (%s%s);\n", ampr(proc->res_type),RESULT); + if (newstyle && args2) + { + f_print (fout, "\t%s", proc->args.argname); + f_print (fout, " arg;\n"); + } + f_print (fout, "\tstatic "); + if (streq (proc->res_type, "void")) + { + f_print (fout, "char "); + } + else + { + ptype (proc->res_prefix, proc->res_type, 0); + } + f_print (fout, "%s;\n", RESULT); + f_print (fout, "\n"); + f_print (fout, "\tmemset((char *)%s%s, 0, sizeof(%s));\n", + ampr (proc->res_type), RESULT, RESULT); + if (newstyle && !args2 && (streq (proc->args.decls->decl.type, "void"))) + { + /* newstyle, 0 arguments */ + f_print (fout, + "\tif (clnt_call(clnt, %s, xdr_void", proc->proc_name); + f_print (fout, + ", NULL, xdr_%s, %s,%s, TIMEOUT) != RPC_SUCCESS) {\n", + stringfix (proc->res_type), ampr (proc->res_type), RESULT); + + } + else if (newstyle && args2) + { + /* newstyle, multiple arguments: stuff arguments into structure */ + for (l = proc->args.decls; l != NULL; l = l->next) + { + f_print (fout, "\targ.%s = %s;\n", + l->decl.name, l->decl.name); } + f_print (fout, + "\tif (clnt_call(clnt, %s, xdr_%s", proc->proc_name, + proc->args.argname); + f_print (fout, + ", &arg, xdr_%s, %s%s, TIMEOUT) != RPC_SUCCESS) {\n", + stringfix (proc->res_type), ampr (proc->res_type), RESULT); + } + else + { /* single argument, new or old style */ + f_print (fout, + "\tif (clnt_call(clnt, %s, xdr_%s, %s%s, xdr_%s, %s%s, TIMEOUT) != RPC_SUCCESS) {\n", + proc->proc_name, + stringfix (proc->args.decls->decl.type), + (newstyle ? "&" : ""), + (newstyle ? proc->args.decls->decl.name : "argp"), + stringfix (proc->res_type), ampr (proc->res_type), RESULT); + } + f_print (fout, "\t\treturn (NULL);\n"); + f_print (fout, "\t}\n"); + if (streq (proc->res_type, "void")) + { + f_print (fout, "\treturn ((void *)%s%s);\n", + ampr (proc->res_type), RESULT); + } + else + { + f_print (fout, "\treturn (%s%s);\n", ampr (proc->res_type), RESULT); + } } diff --git a/sunrpc/rpc_cmsg.c b/sunrpc/rpc_cmsg.c index a4d5ef3e49..5759360b21 100644 --- a/sunrpc/rpc_cmsg.c +++ b/sunrpc/rpc_cmsg.c @@ -6,23 +6,23 @@ * may copy or modify Sun RPC without charge, but are not authorized * to license or distribute it to anyone else except as part of a product or * program developed by the user. - * + * * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. - * + * * Sun RPC is provided with no support and without any obligation on the * part of Sun Microsystems, Inc. to assist in its use, correction, * modification or enhancement. - * + * * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC * OR ANY PART THEREOF. - * + * * In no event will Sun Microsystems, Inc. be liable for any lost revenue * or profits or other special, indirect and consequential damages, even if * Sun has been advised of the possibility of such damages. - * + * * Sun Microsystems, Inc. * 2550 Garcia Avenue * Mountain View, California 94043 @@ -38,153 +38,182 @@ static char sccsid[] = "@(#)rpc_callmsg.c 1.4 87/08/11 Copyr 1984 Sun Micro"; * */ +#include <string.h> #include <sys/param.h> - #include <rpc/rpc.h> +extern bool_t xdr_opaque_auth (XDR *, struct opaque_auth *); + /* * XDR a call message */ bool_t -xdr_callmsg(xdrs, cmsg) - register XDR *xdrs; - register struct rpc_msg *cmsg; +xdr_callmsg (XDR *xdrs, struct rpc_msg *cmsg) { - register long *buf; - register struct opaque_auth *oa; + long *buf; + struct opaque_auth *oa; - if (xdrs->x_op == XDR_ENCODE) { - if (cmsg->rm_call.cb_cred.oa_length > MAX_AUTH_BYTES) { - return (FALSE); + if (xdrs->x_op == XDR_ENCODE) + { + if (cmsg->rm_call.cb_cred.oa_length > MAX_AUTH_BYTES) + { + return (FALSE); + } + if (cmsg->rm_call.cb_verf.oa_length > MAX_AUTH_BYTES) + { + 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)); + if (buf != NULL) + { + IXDR_PUT_LONG (buf, cmsg->rm_xid); + IXDR_PUT_ENUM (buf, cmsg->rm_direction); + if (cmsg->rm_direction != CALL) + { + return FALSE; + } + IXDR_PUT_LONG (buf, cmsg->rm_call.cb_rpcvers); + if (cmsg->rm_call.cb_rpcvers != RPC_MSG_VERSION) + { + return FALSE; + } + IXDR_PUT_LONG (buf, cmsg->rm_call.cb_prog); + IXDR_PUT_LONG (buf, cmsg->rm_call.cb_vers); + IXDR_PUT_LONG (buf, cmsg->rm_call.cb_proc); + oa = &cmsg->rm_call.cb_cred; + 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 = (long *) ((char *) buf + RNDUP (oa->oa_length)); + } + 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); + /* no real need.... + buf = (long *) ((char *) buf + RNDUP(oa->oa_length)); + */ + } + return TRUE; + } + } + if (xdrs->x_op == XDR_DECODE) + { + buf = XDR_INLINE (xdrs, 8 * BYTES_PER_XDR_UNIT); + 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; + } + cmsg->rm_call.cb_rpcvers = IXDR_GET_LONG (buf); + if (cmsg->rm_call.cb_rpcvers != RPC_MSG_VERSION) + { + return FALSE; + } + cmsg->rm_call.cb_prog = IXDR_GET_LONG (buf); + cmsg->rm_call.cb_vers = IXDR_GET_LONG (buf); + cmsg->rm_call.cb_proc = IXDR_GET_LONG (buf); + oa = &cmsg->rm_call.cb_cred; + oa->oa_flavor = IXDR_GET_ENUM (buf, enum_t); + oa->oa_length = IXDR_GET_LONG (buf); + if (oa->oa_length) + { + if (oa->oa_length > MAX_AUTH_BYTES) + { + return FALSE; } - if (cmsg->rm_call.cb_verf.oa_length > MAX_AUTH_BYTES) { - return (FALSE); + if (oa->oa_base == NULL) + { + oa->oa_base = (caddr_t) + mem_alloc (oa->oa_length); } - 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)); - if (buf != NULL) { - IXDR_PUT_LONG(buf, cmsg->rm_xid); - IXDR_PUT_ENUM(buf, cmsg->rm_direction); - if (cmsg->rm_direction != CALL) { - return (FALSE); - } - IXDR_PUT_LONG(buf, cmsg->rm_call.cb_rpcvers); - if (cmsg->rm_call.cb_rpcvers != RPC_MSG_VERSION) { - return (FALSE); - } - IXDR_PUT_LONG(buf, cmsg->rm_call.cb_prog); - IXDR_PUT_LONG(buf, cmsg->rm_call.cb_vers); - IXDR_PUT_LONG(buf, cmsg->rm_call.cb_proc); - oa = &cmsg->rm_call.cb_cred; - 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 = (long *) ((char *) buf + RNDUP(oa->oa_length)); - } - 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); - /* no real need.... - buf = (long *) ((char *) buf + RNDUP(oa->oa_length)); - */ - } - return (TRUE); + buf = XDR_INLINE (xdrs, RNDUP (oa->oa_length)); + if (buf == NULL) + { + if (xdr_opaque (xdrs, oa->oa_base, + oa->oa_length) == FALSE) + { + return FALSE; + } } - } - if (xdrs->x_op == XDR_DECODE) { - buf = XDR_INLINE(xdrs, 8 * BYTES_PER_XDR_UNIT); - 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); - } - cmsg->rm_call.cb_rpcvers = IXDR_GET_LONG(buf); - if (cmsg->rm_call.cb_rpcvers != RPC_MSG_VERSION) { - return (FALSE); - } - cmsg->rm_call.cb_prog = IXDR_GET_LONG(buf); - cmsg->rm_call.cb_vers = IXDR_GET_LONG(buf); - cmsg->rm_call.cb_proc = IXDR_GET_LONG(buf); - oa = &cmsg->rm_call.cb_cred; - oa->oa_flavor = IXDR_GET_ENUM(buf, enum_t); - oa->oa_length = IXDR_GET_LONG(buf); - if (oa->oa_length) { - if (oa->oa_length > MAX_AUTH_BYTES) { - return (FALSE); - } - if (oa->oa_base == NULL) { - oa->oa_base = (caddr_t) - mem_alloc(oa->oa_length); - } - buf = XDR_INLINE(xdrs, RNDUP(oa->oa_length)); - if (buf == NULL) { - if (xdr_opaque(xdrs, oa->oa_base, - oa->oa_length) == FALSE) { - return (FALSE); - } - } else { - bcopy((caddr_t)buf, oa->oa_base, - oa->oa_length); - /* no real need.... - buf = (long *) ((char *) buf - + RNDUP(oa->oa_length)); - */ - } - } - 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) { - return (FALSE); - } - } else { - oa->oa_flavor = IXDR_GET_ENUM(buf, enum_t); - oa->oa_length = IXDR_GET_LONG(buf); - } - if (oa->oa_length) { - if (oa->oa_length > MAX_AUTH_BYTES) { - return (FALSE); - } - if (oa->oa_base == NULL) { - oa->oa_base = (caddr_t) - mem_alloc(oa->oa_length); - } - buf = XDR_INLINE(xdrs, RNDUP(oa->oa_length)); - if (buf == NULL) { - if (xdr_opaque(xdrs, oa->oa_base, - oa->oa_length) == FALSE) { - return (FALSE); - } - } else { - bcopy((caddr_t)buf, oa->oa_base, - oa->oa_length); - /* no real need... - buf = (long *) ((char *) buf - + RNDUP(oa->oa_length)); - */ - } - } - return (TRUE); + else + { + bcopy ((caddr_t) buf, oa->oa_base, + oa->oa_length); + /* no real need.... + buf = (long *) ((char *) buf + + RNDUP(oa->oa_length)); + */ + } + } + 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) + { + return FALSE; + } + } + else + { + oa->oa_flavor = IXDR_GET_ENUM (buf, enum_t); + oa->oa_length = IXDR_GET_LONG (buf); + } + if (oa->oa_length) + { + if (oa->oa_length > MAX_AUTH_BYTES) + { + return FALSE; } + if (oa->oa_base == NULL) + { + oa->oa_base = (caddr_t) + mem_alloc (oa->oa_length); + } + buf = XDR_INLINE (xdrs, RNDUP (oa->oa_length)); + if (buf == NULL) + { + if (xdr_opaque (xdrs, oa->oa_base, + oa->oa_length) == FALSE) + { + return FALSE; + } + } + else + { + bcopy ((caddr_t) buf, oa->oa_base, + oa->oa_length); + /* no real need... + buf = (long *) ((char *) buf + + RNDUP(oa->oa_length)); + */ + } + } + 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))); - return (FALSE); + } + 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/sunrpc/rpc_dtable.c b/sunrpc/rpc_dtable.c index a8488172e4..26bf1a204a 100644 --- a/sunrpc/rpc_dtable.c +++ b/sunrpc/rpc_dtable.c @@ -31,16 +31,19 @@ static char sccsid[] = "@(#)rpc_dtablesize.c 1.2 87/08/11 Copyr 1987 Sun Micro"; #endif +#include <unistd.h> + /* * Cache the result of getdtablesize(), so we don't have to do an * expensive system call every time. */ -_rpc_dtablesize() +int +_rpc_dtablesize (void) { - static int size; - - if (size == 0) { - size = getdtablesize(); - } - return (size); + static int size; + + if (size == 0) + size = getdtablesize (); + + return size; } diff --git a/sunrpc/rpc_prot.c b/sunrpc/rpc_prot.c index 8da20c61c8..79a58c2732 100644 --- a/sunrpc/rpc_prot.c +++ b/sunrpc/rpc_prot.c @@ -55,26 +55,22 @@ static char sccsid[] = "@(#)rpc_prot.c 1.36 87/08/11 Copyr 1984 Sun Micro"; * (see auth.h) */ bool_t -xdr_opaque_auth(xdrs, ap) - register XDR *xdrs; - register struct opaque_auth *ap; +xdr_opaque_auth (XDR *xdrs, struct opaque_auth *ap) { - if (xdr_enum(xdrs, &(ap->oa_flavor))) - return (xdr_bytes(xdrs, &ap->oa_base, - &ap->oa_length, MAX_AUTH_BYTES)); - return (FALSE); + if (xdr_enum (xdrs, &(ap->oa_flavor))) + return xdr_bytes (xdrs, &ap->oa_base, + &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; +xdr_des_block (XDR *xdrs, 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 * * * * * * * * * * * * * * * */ @@ -83,74 +79,70 @@ 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; +xdr_accepted_reply (XDR *xdrs, struct accepted_reply *ar) { - - /* personalized union, rather than calling xdr_union */ - if (! xdr_opaque_auth(xdrs, &(ar->ar_verf))) - return (FALSE); - 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)); - - case PROG_MISMATCH: - 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 */ + /* personalized union, rather than calling xdr_union */ + if (!xdr_opaque_auth (xdrs, &(ar->ar_verf))) + return FALSE; + 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)); + case PROG_MISMATCH: + if (!xdr_u_long (xdrs, &(ar->ar_vers.low))) + return FALSE; + return (xdr_u_long (xdrs, &(ar->ar_vers.high))); + default: + return TRUE; + } + 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; +xdr_rejected_reply (XDR *xdrs, struct rejected_reply *rr) { - - /* personalized union, rather than calling xdr_union */ - 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))) - return (FALSE); - return (xdr_u_long(xdrs, &(rr->rj_vers.high))); - - case AUTH_ERROR: - return (xdr_enum(xdrs, (enum_t *)&(rr->rj_why))); - } - return (FALSE); + /* personalized union, rather than calling xdr_union */ + 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))) + return FALSE; + return xdr_u_long (xdrs, &(rr->rj_vers.high)); + + case AUTH_ERROR: + 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 } }; +static const struct xdr_discrim reply_dscrm[3] = +{ + {(int) MSG_ACCEPTED, (xdrproc_t) xdr_accepted_reply}, + {(int) MSG_DENIED, (xdrproc_t) 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; +xdr_replymsg (xdrs, rmsg) + XDR *xdrs; + 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)); - return (FALSE); + 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; } @@ -160,128 +152,128 @@ xdr_replymsg(xdrs, rmsg) * 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; +xdr_callhdr (xdrs, cmsg) + XDR *xdrs; + 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))); - return (FALSE); + 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)); + return FALSE; } /* ************************** Client utility routine ************* */ static void -accepted(acpt_stat, error) - register enum accept_stat acpt_stat; - register struct rpc_err *error; +accepted (enum accept_stat acpt_stat, + struct rpc_err *error) { - - switch (acpt_stat) { - - case PROG_UNAVAIL: - error->re_status = RPC_PROGUNAVAIL; - return; - - case PROG_MISMATCH: - error->re_status = RPC_PROGVERSMISMATCH; - return; - - case PROC_UNAVAIL: - error->re_status = RPC_PROCUNAVAIL; - return; - - case GARBAGE_ARGS: - error->re_status = RPC_CANTDECODEARGS; - return; - - case SYSTEM_ERR: - error->re_status = RPC_SYSTEMERROR; - return; - - case SUCCESS: - error->re_status = RPC_SUCCESS; - return; - } - /* 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; + switch (acpt_stat) + { + + case PROG_UNAVAIL: + error->re_status = RPC_PROGUNAVAIL; + return; + + case PROG_MISMATCH: + error->re_status = RPC_PROGVERSMISMATCH; + return; + + case PROC_UNAVAIL: + error->re_status = RPC_PROCUNAVAIL; + return; + + case GARBAGE_ARGS: + error->re_status = RPC_CANTDECODEARGS; + return; + + case SYSTEM_ERR: + error->re_status = RPC_SYSTEMERROR; + return; + + case SUCCESS: + error->re_status = RPC_SUCCESS; + return; + } + /* 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; } static void -rejected(rjct_stat, error) - register enum reject_stat rjct_stat; - register struct rpc_err *error; +rejected (enum reject_stat rjct_stat, + struct rpc_err *error) { - - switch (rjct_stat) { - - case RPC_VERSMISMATCH: - error->re_status = RPC_VERSMISMATCH; - return; - - case AUTH_ERROR: - error->re_status = RPC_AUTHERROR; - return; - } - /* 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; + switch (rjct_stat) + { + case RPC_VERSMISMATCH: + error->re_status = RPC_VERSMISMATCH; + return; + case AUTH_ERROR: + error->re_status = RPC_AUTHERROR; + return; + default: + /* 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; + return; + } } /* * given a reply message, fills in the error */ void -_seterr_reply(msg, error) - register struct rpc_msg *msg; - register struct rpc_err *error; +_seterr_reply (struct rpc_msg *msg, + struct rpc_err *error) { - - /* optimized for normal, SUCCESSful case */ - switch (msg->rm_reply.rp_stat) { - - case MSG_ACCEPTED: - if (msg->acpted_rply.ar_stat == SUCCESS) { - error->re_status = RPC_SUCCESS; - return; - }; - accepted(msg->acpted_rply.ar_stat, error); - break; - - case MSG_DENIED: - rejected(msg->rjcted_rply.rj_stat, error); - break; - - default: - error->re_status = RPC_FAILED; - error->re_lb.s1 = (long)(msg->rm_reply.rp_stat); - break; - } - switch (error->re_status) { - - case RPC_VERSMISMATCH: - error->re_vers.low = msg->rjcted_rply.rj_vers.low; - error->re_vers.high = msg->rjcted_rply.rj_vers.high; - break; - - case RPC_AUTHERROR: - error->re_why = msg->rjcted_rply.rj_why; - break; - - case RPC_PROGVERSMISMATCH: - error->re_vers.low = msg->acpted_rply.ar_vers.low; - error->re_vers.high = msg->acpted_rply.ar_vers.high; - break; - } + /* optimized for normal, SUCCESSful case */ + switch (msg->rm_reply.rp_stat) + { + case MSG_ACCEPTED: + if (msg->acpted_rply.ar_stat == SUCCESS) + { + error->re_status = RPC_SUCCESS; + return; + }; + accepted (msg->acpted_rply.ar_stat, error); + break; + + case MSG_DENIED: + rejected (msg->rjcted_rply.rj_stat, error); + break; + + default: + error->re_status = RPC_FAILED; + error->re_lb.s1 = (long) (msg->rm_reply.rp_stat); + break; + } + switch (error->re_status) + { + + case RPC_VERSMISMATCH: + error->re_vers.low = msg->rjcted_rply.rj_vers.low; + error->re_vers.high = msg->rjcted_rply.rj_vers.high; + break; + + case RPC_AUTHERROR: + error->re_why = msg->rjcted_rply.rj_why; + break; + + case RPC_PROGVERSMISMATCH: + error->re_vers.low = msg->acpted_rply.ar_vers.low; + error->re_vers.high = msg->acpted_rply.ar_vers.high; + break; + default: + break; + } } diff --git a/sunrpc/rpc_sample.c b/sunrpc/rpc_sample.c index a5551d94c1..d1e1277c5b 100644 --- a/sunrpc/rpc_sample.c +++ b/sunrpc/rpc_sample.c @@ -28,10 +28,10 @@ * Mountain View, California 94043 */ -/* +/* * From: @(#)rpc_sample.c 1.1 90/08/30 (C) 1987 SMI */ -char sample_rcsid[] = +char sample_rcsid[] = "$Id$"; /* @@ -45,209 +45,226 @@ char sample_rcsid[] = #include "proto.h" -static char RQSTP[] = "rqstp"; +static const char RQSTP[] = "rqstp"; -static void write_sample_client(const char *program_name, version_list *vp); -static void write_sample_server(definition *def); -static void return_type(proc_list *plist); +static void write_sample_client (const char *program_name, version_list * vp); +static void write_sample_server (definition * def); +static void return_type (proc_list * plist); void -write_sample_svc(definition *def) +write_sample_svc (definition * def) { - if (def->def_kind != DEF_PROGRAM) - return; - write_sample_server(def); + if (def->def_kind != DEF_PROGRAM) + return; + write_sample_server (def); } int -write_sample_clnt(definition *def) +write_sample_clnt (definition * def) { - version_list *vp; - int count = 0; - - if (def->def_kind != DEF_PROGRAM) - return( 0 ); - /* generate sample code for each version */ - for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { - write_sample_client(def->def_name, vp ); - ++count; - } - return( count ); + version_list *vp; + int count = 0; + + if (def->def_kind != DEF_PROGRAM) + return (0); + /* generate sample code for each version */ + for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) + { + write_sample_client (def->def_name, vp); + ++count; + } + return (count); } static void -write_sample_client(const char *program_name, version_list *vp) +write_sample_client (const char *program_name, version_list * vp) { proc_list *proc; int i; decl_list *l; - f_print(fout, "\n\nvoid\n" ); - pvname( program_name, vp->vers_num ); - if( Cflag ) - f_print(fout,"( char* host )\n{\n" ); + f_print (fout, "\n\nvoid\n"); + pvname (program_name, vp->vers_num); + if (Cflag) + f_print (fout, "( char* host )\n{\n"); else - f_print(fout, "(host)\nchar *host;\n{\n" ); - f_print(fout, "\tCLIENT *clnt;\n"); + f_print (fout, "(host)\nchar *host;\n{\n"); + f_print (fout, "\tCLIENT *clnt;\n"); i = 0; - for (proc = vp->procs; proc != NULL; proc = proc->next) { - f_print(fout, "\t"); - ptype(proc->res_prefix, proc->res_type, 1); - f_print(fout, " *result_%d;\n",++i); + for (proc = vp->procs; proc != NULL; proc = proc->next) + { + f_print (fout, "\t"); + ptype (proc->res_prefix, proc->res_type, 1); + f_print (fout, " *result_%d;\n", ++i); /* print out declarations for arguments */ - if( proc->arg_num < 2 && !newstyle) { - f_print( fout, "\t" ); - if( !streq( proc->args.decls->decl.type, "void") ) - ptype(proc->args.decls->decl.prefix, proc->args.decls->decl.type, 1); - else - f_print(fout, "char* "); /* cannot have "void" type */ - f_print(fout, " "); - pvname( proc->proc_name, vp->vers_num ); - f_print(fout, "_arg;\n"); - } else if (!streq( proc->args.decls->decl.type, "void")) { - for (l = proc->args.decls; l != NULL; l = l->next) { - f_print( fout, "\t" ); - ptype(l->decl.prefix, l->decl.type, 1); - f_print( fout, " "); - pvname( proc->proc_name, vp->vers_num ); - f_print(fout, "_%s;\n", l->decl.name ); -/* pdeclaration(proc->args.argname, &l->decl, 1, ";\n" );*/ + if (proc->arg_num < 2 && !newstyle) + { + f_print (fout, "\t"); + if (!streq (proc->args.decls->decl.type, "void")) + ptype (proc->args.decls->decl.prefix, proc->args.decls->decl.type, 1); + else + f_print (fout, "char* "); /* cannot have "void" type */ + f_print (fout, " "); + pvname (proc->proc_name, vp->vers_num); + f_print (fout, "_arg;\n"); + } + else if (!streq (proc->args.decls->decl.type, "void")) + { + for (l = proc->args.decls; l != NULL; l = l->next) + { + f_print (fout, "\t"); + ptype (l->decl.prefix, l->decl.type, 1); + f_print (fout, " "); + pvname (proc->proc_name, vp->vers_num); + f_print (fout, "_%s;\n", l->decl.name); +/* pdeclaration(proc->args.argname, &l->decl, 1, ";\n" ); */ + } } - } } /* generate creation of client handle */ - f_print(fout, "\tclnt = clnt_create(host, %s, %s, \"%s\");\n", - program_name, vp->vers_name, tirpcflag? "netpath" : "udp"); - f_print(fout, "\tif (clnt == NULL) {\n"); - f_print(fout, "\t\tclnt_pcreateerror(host);\n"); - f_print(fout, "\t\texit(1);\n\t}\n"); + f_print (fout, "\tclnt = clnt_create(host, %s, %s, \"%s\");\n", + program_name, vp->vers_name, tirpcflag ? "netpath" : "udp"); + f_print (fout, "\tif (clnt == NULL) {\n"); + f_print (fout, "\t\tclnt_pcreateerror(host);\n"); + f_print (fout, "\t\texit(1);\n\t}\n"); /* generate calls to procedures */ i = 0; - for (proc = vp->procs; proc != NULL; proc = proc->next) { - f_print(fout, "\tresult_%d = ",++i); - pvname(proc->proc_name, vp->vers_num); - if (proc->arg_num < 2 && !newstyle) { - f_print(fout, "(" ); - if( streq( proc->args.decls->decl.type, "void") ) /* cast to void* */ - f_print(fout, "(void*)"); - f_print(fout, "&" ); - pvname(proc->proc_name, vp->vers_num ); - f_print(fout, "_arg, clnt);\n"); - } else if (streq( proc->args.decls->decl.type, "void")) { - f_print(fout, "(clnt);\n"); - } - else { - f_print(fout, "("); - for (l = proc->args.decls; l != NULL; l = l->next) { - pvname( proc->proc_name, vp->vers_num ); - f_print(fout, "_%s, ", l->decl.name); + for (proc = vp->procs; proc != NULL; proc = proc->next) + { + f_print (fout, "\tresult_%d = ", ++i); + pvname (proc->proc_name, vp->vers_num); + if (proc->arg_num < 2 && !newstyle) + { + f_print (fout, "("); + if (streq (proc->args.decls->decl.type, "void")) /* cast to void* */ + f_print (fout, "(void*)"); + f_print (fout, "&"); + pvname (proc->proc_name, vp->vers_num); + f_print (fout, "_arg, clnt);\n"); } - f_print(fout, "clnt);\n"); - } - f_print(fout, "\tif (result_%d == NULL) {\n", i); - f_print(fout, "\t\tclnt_perror(clnt, \"call failed:\");\n"); - f_print(fout, "\t}\n"); + else if (streq (proc->args.decls->decl.type, "void")) + { + f_print (fout, "(clnt);\n"); + } + else + { + f_print (fout, "("); + for (l = proc->args.decls; l != NULL; l = l->next) + { + pvname (proc->proc_name, vp->vers_num); + f_print (fout, "_%s, ", l->decl.name); + } + f_print (fout, "clnt);\n"); + } + f_print (fout, "\tif (result_%d == NULL) {\n", i); + f_print (fout, "\t\tclnt_perror(clnt, \"call failed:\");\n"); + f_print (fout, "\t}\n"); } - f_print(fout, "\tclnt_destroy( clnt );\n" ); - f_print(fout, "}\n"); + f_print (fout, "\tclnt_destroy( clnt );\n"); + f_print (fout, "}\n"); } static void -write_sample_server(definition *def) +write_sample_server (definition * def) { - version_list *vp; - proc_list *proc; - - for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { - for (proc = vp->procs; proc != NULL; proc = proc->next) { - f_print(fout, "\n"); -/* if( Cflag ) - f_print( fout, "extern \"C\"{\n"); -*/ - return_type(proc); - f_print(fout, "* \n"); - if( Cflag ) - pvname_svc(proc->proc_name, vp->vers_num); - else - pvname(proc->proc_name, vp->vers_num); - printarglist( proc, RQSTP, "struct svc_req *" ); - - f_print(fout, "{\n"); - f_print(fout, "\n\tstatic "); - if( !streq( proc->res_type, "void") ) - return_type(proc); - else - f_print(fout, "char*" ); /* cannot have void type */ - f_print(fout, " result;\n" /*, proc->res_type*/ /*?*/); - f_print(fout, - "\n\t/*\n\t * insert server code here\n\t */\n\n"); - if( !streq( proc->res_type, "void") ) - f_print(fout, "\treturn(&result);\n}\n"); - else /* cast back to void * */ - f_print(fout, "\treturn((void*) &result);\n}\n"); -/* if( Cflag) - f_print( fout, "};\n"); -*/ - - } + version_list *vp; + proc_list *proc; + + for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) + { + for (proc = vp->procs; proc != NULL; proc = proc->next) + { + f_print (fout, "\n"); +/* if( Cflag ) + f_print( fout, "extern \"C\"{\n"); + */ + return_type (proc); + f_print (fout, "* \n"); + if (Cflag) + pvname_svc (proc->proc_name, vp->vers_num); + else + pvname (proc->proc_name, vp->vers_num); + printarglist (proc, RQSTP, "struct svc_req *"); + + f_print (fout, "{\n"); + f_print (fout, "\n\tstatic "); + if (!streq (proc->res_type, "void")) + return_type (proc); + else + f_print (fout, "char*"); /* cannot have void type */ + f_print (fout, " result;\n" /*, proc->res_type *//*? */ ); + f_print (fout, + "\n\t/*\n\t * insert server code here\n\t */\n\n"); + if (!streq (proc->res_type, "void")) + f_print (fout, "\treturn(&result);\n}\n"); + else /* cast back to void * */ + f_print (fout, "\treturn((void*) &result);\n}\n"); +/* if( Cflag) + f_print( fout, "};\n"); + */ + } + } } static void -return_type(proc_list *plist) +return_type (proc_list * plist) { - ptype( plist->res_prefix, plist->res_type, 1 ); + ptype (plist->res_prefix, plist->res_type, 1); } void -add_sample_msg(void) +add_sample_msg (void) { - f_print(fout, "/*\n"); - f_print(fout, " * This is sample code generated by rpcgen.\n"); - f_print(fout, " * These are only templates and you can use them\n"); - f_print(fout, " * as a guideline for developing your own functions.\n"); - f_print(fout, " */\n\n"); + f_print (fout, "/*\n"); + f_print (fout, " * This is sample code generated by rpcgen.\n"); + f_print (fout, " * These are only templates and you can use them\n"); + f_print (fout, " * as a guideline for developing your own functions.\n"); + f_print (fout, " */\n\n"); } void -write_sample_clnt_main(void) +write_sample_clnt_main (void) { list *l; definition *def; version_list *vp; - f_print(fout, "\n\n" ); - if( Cflag ) - f_print(fout,"main( int argc, char* argv[] )\n{\n" ); + f_print (fout, "\n\n"); + if (Cflag) + f_print (fout, "main( int argc, char* argv[] )\n{\n"); else - f_print(fout, "main(argc, argv)\nint argc;\nchar *argv[];\n{\n" ); - - f_print(fout, "\tchar *host;"); - f_print(fout, "\n\n\tif(argc < 2) {"); - f_print(fout, "\n\t\tprintf(\"usage: %%s server_host\\n\", argv[0]);\n" ); - f_print(fout, "\t\texit(1);\n\t}"); - f_print(fout, "\n\thost = argv[1];\n"); - - for (l = defined; l != NULL; l = l->next) { - def = l->val; - if (def->def_kind != DEF_PROGRAM) { - continue; - } - for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { - f_print( fout, "\t" ); - pvname(def->def_name, vp->vers_num); - f_print( fout, "( host );\n" ); - } - } - f_print(fout, "}\n"); + f_print (fout, "main(argc, argv)\nint argc;\nchar *argv[];\n{\n"); + + f_print (fout, "\tchar *host;"); + f_print (fout, "\n\n\tif(argc < 2) {"); + f_print (fout, "\n\t\tprintf(\"usage: %%s server_host\\n\", argv[0]);\n"); + f_print (fout, "\t\texit(1);\n\t}"); + f_print (fout, "\n\thost = argv[1];\n"); + + for (l = defined; l != NULL; l = l->next) + { + def = l->val; + if (def->def_kind != DEF_PROGRAM) + { + continue; + } + for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) + { + f_print (fout, "\t"); + pvname (def->def_name, vp->vers_num); + f_print (fout, "( host );\n"); + } + } + f_print (fout, "}\n"); } diff --git a/sunrpc/rpc_scan.c b/sunrpc/rpc_scan.c index c0293a3316..acffab2a89 100644 --- a/sunrpc/rpc_scan.c +++ b/sunrpc/rpc_scan.c @@ -31,12 +31,12 @@ /* * From: @(#)rpc_scan.c 1.11 89/02/22 (C) 1987 SMI */ -char scan_rcsid[] = +char scan_rcsid[] = "$Id$"; /* - * rpc_scan.c, Scanner for the RPC protocol compiler - * Copyright (C) 1987, Sun Microsystems, Inc. + * rpc_scan.c, Scanner for the RPC protocol compiler + * Copyright (C) 1987, Sun Microsystems, Inc. */ #include <stdio.h> #include <ctype.h> @@ -49,439 +49,499 @@ char scan_rcsid[] = #define startcomment(where) (where[0] == '/' && where[1] == '*') #define endcomment(where) (where[-1] == '*' && where[0] == '/') -static int pushed = 0; /* is a token pushed */ -static token lasttok; /* last token, if pushed */ +static int pushed = 0; /* is a token pushed */ +static token lasttok; /* last token, if pushed */ -static void unget_token(token *tokp); -static void findstrconst(const char **str, const char **val); -static void findchrconst(const char **str, const char **val); -static void findconst(const char **str, const char **val); -static void findkind(const char **mark, token *tokp); -static int cppline(const char *line); -static int directive(const char *line); -static void printdirective(const char *line); -static void docppline(const char *line, int *lineno, const char **fname); +static void unget_token (token * tokp); +static void findstrconst (const char **str, const char **val); +static void findchrconst (const char **str, const char **val); +static void findconst (const char **str, const char **val); +static void findkind (const char **mark, token * tokp); +static int cppline (const char *line); +static int directive (const char *line); +static void printdirective (const char *line); +static void docppline (const char *line, int *lineno, const char **fname); /* - * scan expecting 1 given token + * scan expecting 1 given token */ void -scan(tok_kind expect, token *tokp) +scan (tok_kind expect, token * tokp) { - get_token(tokp); - if (tokp->kind != expect) { - expected1(expect); - } + get_token (tokp); + if (tokp->kind != expect) + { + expected1 (expect); + } } /* - * scan expecting any of the 2 given tokens + * scan expecting any of the 2 given tokens */ void -scan2(tok_kind expect1, tok_kind expect2, token *tokp) +scan2 (tok_kind expect1, tok_kind expect2, token * tokp) { - get_token(tokp); - if (tokp->kind != expect1 && tokp->kind != expect2) { - expected2(expect1, expect2); - } + get_token (tokp); + if (tokp->kind != expect1 && tokp->kind != expect2) + { + expected2 (expect1, expect2); + } } /* - * scan expecting any of the 3 given token + * scan expecting any of the 3 given token */ void -scan3(tok_kind expect1, tok_kind expect2, tok_kind expect3, token *tokp) +scan3 (tok_kind expect1, tok_kind expect2, tok_kind expect3, token * tokp) { - get_token(tokp); - if (tokp->kind != expect1 && tokp->kind != expect2 - && tokp->kind != expect3) { - expected3(expect1, expect2, expect3); - } + get_token (tokp); + if (tokp->kind != expect1 && tokp->kind != expect2 + && tokp->kind != expect3) + { + expected3 (expect1, expect2, expect3); + } } /* - * scan expecting a constant, possibly symbolic + * scan expecting a constant, possibly symbolic */ void -scan_num(token *tokp) +scan_num (token * tokp) { - get_token(tokp); - switch (tokp->kind) { - case TOK_IDENT: - break; - default: - error("constant or identifier expected"); - } + get_token (tokp); + switch (tokp->kind) + { + case TOK_IDENT: + break; + default: + error ("constant or identifier expected"); + } } /* - * Peek at the next token + * Peek at the next token */ void -peek(token *tokp) +peek (token * tokp) { - get_token(tokp); - unget_token(tokp); + get_token (tokp); + unget_token (tokp); } /* - * Peek at the next token and scan it if it matches what you expect + * Peek at the next token and scan it if it matches what you expect */ int -peekscan(tok_kind expect, token *tokp) +peekscan (tok_kind expect, token * tokp) { - peek(tokp); - if (tokp->kind == expect) { - get_token(tokp); - return (1); - } - return (0); + peek (tokp); + if (tokp->kind == expect) + { + get_token (tokp); + return (1); + } + return (0); } /* - * Get the next token, printing out any directive that are encountered. + * Get the next token, printing out any directive that are encountered. */ void -get_token(token *tokp) +get_token (token * tokp) { - int commenting; - - if (pushed) { - pushed = 0; - *tokp = lasttok; - return; - } - commenting = 0; - for (;;) { - if (*where == 0) { - for (;;) { - if (!fgets(curline, MAXLINESIZE, fin)) { - tokp->kind = TOK_EOF; - *curline = 0; - where = curline; - return; - } - linenum++; - if (commenting) { - break; - } else if (cppline(curline)) { - docppline(curline, &linenum, - &infilename); - } else if (directive(curline)) { - printdirective(curline); - } else { - break; - } - } - where = curline; - } else if (isspace(*where)) { - while (isspace(*where)) { - where++; /* eat */ - } - } else if (commenting) { - for (where++; *where; where++) { - if (endcomment(where)) { - where++; - commenting--; - break; - } - } - } else if (startcomment(where)) { - where += 2; - commenting++; - } else { - break; + int commenting; + + if (pushed) + { + pushed = 0; + *tokp = lasttok; + return; + } + commenting = 0; + for (;;) + { + if (*where == 0) + { + for (;;) + { + if (!fgets (curline, MAXLINESIZE, fin)) + { + tokp->kind = TOK_EOF; + *curline = 0; + where = curline; + return; + } + linenum++; + if (commenting) + { + break; } + else if (cppline (curline)) + { + docppline (curline, &linenum, + &infilename); + } + else if (directive (curline)) + { + printdirective (curline); + } + else + { + break; + } + } + where = curline; } - - /* - * 'where' is not whitespace, comment or directive Must be a token! - */ - switch (*where) { - case ':': - tokp->kind = TOK_COLON; - where++; - break; - case ';': - tokp->kind = TOK_SEMICOLON; - where++; - break; - case ',': - tokp->kind = TOK_COMMA; - where++; - break; - case '=': - tokp->kind = TOK_EQUAL; - where++; - break; - case '*': - tokp->kind = TOK_STAR; - where++; - break; - case '[': - tokp->kind = TOK_LBRACKET; - where++; - break; - case ']': - tokp->kind = TOK_RBRACKET; - where++; - break; - case '{': - tokp->kind = TOK_LBRACE; - where++; - break; - case '}': - tokp->kind = TOK_RBRACE; - where++; - break; - case '(': - tokp->kind = TOK_LPAREN; - where++; - break; - case ')': - tokp->kind = TOK_RPAREN; - where++; - break; - case '<': - tokp->kind = TOK_LANGLE; - where++; - break; - case '>': - tokp->kind = TOK_RANGLE; - where++; - break; - - case '"': - tokp->kind = TOK_STRCONST; - findstrconst(&where, &tokp->str); - break; - case '\'': - tokp->kind = TOK_CHARCONST; - findchrconst(&where, &tokp->str); - break; - - case '-': - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - tokp->kind = TOK_IDENT; - findconst(&where, &tokp->str); - break; - - default: - if (!(isalpha(*where) || *where == '_')) { - char buf[100]; - char *p; - - s_print(buf, "illegal character in file: "); - p = buf + strlen(buf); - if (isprint(*where)) { - s_print(p, "%c", *where); - } else { - s_print(p, "%d", *where); - } - error(buf); + else if (isspace (*where)) + { + while (isspace (*where)) + { + where++; /* eat */ + } + } + else if (commenting) + { + for (where++; *where; where++) + { + if (endcomment (where)) + { + where++; + commenting--; + break; } - findkind(&where, tokp); - break; + } + } + else if (startcomment (where)) + { + where += 2; + commenting++; + } + else + { + break; } + } + + /* + * 'where' is not whitespace, comment or directive Must be a token! + */ + switch (*where) + { + case ':': + tokp->kind = TOK_COLON; + where++; + break; + case ';': + tokp->kind = TOK_SEMICOLON; + where++; + break; + case ',': + tokp->kind = TOK_COMMA; + where++; + break; + case '=': + tokp->kind = TOK_EQUAL; + where++; + break; + case '*': + tokp->kind = TOK_STAR; + where++; + break; + case '[': + tokp->kind = TOK_LBRACKET; + where++; + break; + case ']': + tokp->kind = TOK_RBRACKET; + where++; + break; + case '{': + tokp->kind = TOK_LBRACE; + where++; + break; + case '}': + tokp->kind = TOK_RBRACE; + where++; + break; + case '(': + tokp->kind = TOK_LPAREN; + where++; + break; + case ')': + tokp->kind = TOK_RPAREN; + where++; + break; + case '<': + tokp->kind = TOK_LANGLE; + where++; + break; + case '>': + tokp->kind = TOK_RANGLE; + where++; + break; + + case '"': + tokp->kind = TOK_STRCONST; + findstrconst (&where, &tokp->str); + break; + case '\'': + tokp->kind = TOK_CHARCONST; + findchrconst (&where, &tokp->str); + break; + + case '-': + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + tokp->kind = TOK_IDENT; + findconst (&where, &tokp->str); + break; + + default: + if (!(isalpha (*where) || *where == '_')) + { + char buf[100]; + char *p; + + s_print (buf, _("illegal character in file: ")); + p = buf + strlen (buf); + if (isprint (*where)) + { + s_print (p, "%c", *where); + } + else + { + s_print (p, "%d", *where); + } + error (buf); + } + findkind (&where, tokp); + break; + } } static void -unget_token(token *tokp) +unget_token (token * tokp) { - lasttok = *tokp; - pushed = 1; + lasttok = *tokp; + pushed = 1; } static void -findstrconst(const char **str, const char **val) +findstrconst (const char **str, const char **val) { - const char *p; - char *tmp; - int size; - - p = *str; - do { - p++; - } while (*p && *p != '"'); - if (*p == 0) { - error("unterminated string constant"); - } - p++; - size = p - *str; - tmp = alloc(size + 1); - strncpy(tmp, *str, size); - tmp[size] = 0; - *val = tmp; - *str = p; + const char *p; + char *tmp; + int size; + + p = *str; + do + { + p++; + } + while (*p && *p != '"'); + if (*p == 0) + { + error (_("unterminated string constant")); + } + p++; + size = p - *str; + tmp = alloc (size + 1); + strncpy (tmp, *str, size); + tmp[size] = 0; + *val = tmp; + *str = p; } static void -findchrconst(const char **str, const char **val) +findchrconst (const char **str, const char **val) { - const char *p; - char *tmp; - int size; - - p = *str; - do { - p++; - } while (*p && *p != '\''); - if (*p == 0) { - error("unterminated string constant"); - } - p++; - size = p - *str; - if (size != 3) { - error("empty char string"); - } - tmp = alloc(size + 1); - strncpy(tmp, *str, size); - tmp[size] = 0; - *val = tmp; - *str = p; + const char *p; + char *tmp; + int size; + + p = *str; + do + { + p++; + } + while (*p && *p != '\''); + if (*p == 0) + { + error (_("unterminated string constant")); + } + p++; + size = p - *str; + if (size != 3) + { + error (_("empty char string")); + } + tmp = alloc (size + 1); + strncpy (tmp, *str, size); + tmp[size] = 0; + *val = tmp; + *str = p; } static void -findconst(const char **str, const char **val) +findconst (const char **str, const char **val) { - const char *p; - char *tmp; - int size; - - p = *str; - if (*p == '0' && *(p + 1) == 'x') { - p++; - do { - p++; - } while (isxdigit(*p)); - } else { - do { - p++; - } while (isdigit(*p)); + const char *p; + char *tmp; + int size; + + p = *str; + if (*p == '0' && *(p + 1) == 'x') + { + p++; + do + { + p++; } - size = p - *str; - tmp = alloc(size + 1); - strncpy(tmp, *str, size); - tmp[size] = 0; - *val = tmp; - *str = p; + while (isxdigit (*p)); + } + else + { + do + { + p++; + } + while (isdigit (*p)); + } + size = p - *str; + tmp = alloc (size + 1); + strncpy (tmp, *str, size); + tmp[size] = 0; + *val = tmp; + *str = p; } -static token symbols[] = { - {TOK_CONST, "const"}, - {TOK_UNION, "union"}, - {TOK_SWITCH, "switch"}, - {TOK_CASE, "case"}, - {TOK_DEFAULT, "default"}, - {TOK_STRUCT, "struct"}, - {TOK_TYPEDEF, "typedef"}, - {TOK_ENUM, "enum"}, - {TOK_OPAQUE, "opaque"}, - {TOK_BOOL, "bool"}, - {TOK_VOID, "void"}, - {TOK_CHAR, "char"}, - {TOK_INT, "int"}, - {TOK_UNSIGNED, "unsigned"}, - {TOK_SHORT, "short"}, - {TOK_LONG, "long"}, - {TOK_FLOAT, "float"}, - {TOK_DOUBLE, "double"}, - {TOK_STRING, "string"}, - {TOK_PROGRAM, "program"}, - {TOK_VERSION, "version"}, - {TOK_EOF, "??????"}, +static const token symbols[] = +{ + {TOK_CONST, "const"}, + {TOK_UNION, "union"}, + {TOK_SWITCH, "switch"}, + {TOK_CASE, "case"}, + {TOK_DEFAULT, "default"}, + {TOK_STRUCT, "struct"}, + {TOK_TYPEDEF, "typedef"}, + {TOK_ENUM, "enum"}, + {TOK_OPAQUE, "opaque"}, + {TOK_BOOL, "bool"}, + {TOK_VOID, "void"}, + {TOK_CHAR, "char"}, + {TOK_INT, "int"}, + {TOK_UNSIGNED, "unsigned"}, + {TOK_SHORT, "short"}, + {TOK_LONG, "long"}, + {TOK_FLOAT, "float"}, + {TOK_DOUBLE, "double"}, + {TOK_STRING, "string"}, + {TOK_PROGRAM, "program"}, + {TOK_VERSION, "version"}, + {TOK_EOF, "??????"}, }; static void -findkind(const char **mark, token *tokp) +findkind (const char **mark, token * tokp) { - int len; - token *s; - const char *str; - char *tmp; - - str = *mark; - for (s = symbols; s->kind != TOK_EOF; s++) { - len = strlen(s->str); - if (strncmp(str, s->str, len) == 0) { - if (!isalnum(str[len]) && str[len] != '_') { - tokp->kind = s->kind; - tokp->str = s->str; - *mark = str + len; - return; - } - } + int len; + token *s; + const char *str; + char *tmp; + + str = *mark; + for (s = symbols; s->kind != TOK_EOF; s++) + { + len = strlen (s->str); + if (strncmp (str, s->str, len) == 0) + { + if (!isalnum (str[len]) && str[len] != '_') + { + tokp->kind = s->kind; + tokp->str = s->str; + *mark = str + len; + return; + } } - tokp->kind = TOK_IDENT; - for (len = 0; isalnum(str[len]) || str[len] == '_'; len++); - tmp = alloc(len + 1); - strncpy(tmp, str, len); - tmp[len] = 0; - tokp->str = tmp; - *mark = str + len; + } + tokp->kind = TOK_IDENT; + for (len = 0; isalnum (str[len]) || str[len] == '_'; len++); + tmp = alloc (len + 1); + strncpy (tmp, str, len); + tmp[len] = 0; + tokp->str = tmp; + *mark = str + len; } static int -cppline(const char *line) +cppline (const char *line) { - return (line == curline && *line == '#'); + return line == curline && *line == '#'; } static int -directive(const char *line) +directive (const char *line) { - return (line == curline && *line == '%'); + return line == curline && *line == '%'; } static void -printdirective(const char *line) +printdirective (const char *line) { - f_print(fout, "%s", line + 1); + f_print (fout, "%s", line + 1); } static void -docppline(const char *line, int *lineno, const char **fname) +docppline (const char *line, int *lineno, const char **fname) { - char *file; - int num; - char *p; - - line++; - while (isspace(*line)) { - line++; - } - num = atoi(line); - while (isdigit(*line)) { - line++; - } - while (isspace(*line)) { - line++; - } - if (*line != '"') { - error("preprocessor error"); - } - line++; - p = file = alloc(strlen(line) + 1); - while (*line && *line != '"') { - *p++ = *line++; - } - if (*line == 0) { - error("preprocessor error"); - } - *p = 0; - if (*file == 0) { - *fname = NULL; - } else { - *fname = file; - } - *lineno = num - 1; + char *file; + int num; + char *p; + + line++; + while (isspace (*line)) + { + line++; + } + num = atoi (line); + while (isdigit (*line)) + { + line++; + } + while (isspace (*line)) + { + line++; + } + if (*line != '"') + { + error (_("preprocessor error")); + } + line++; + p = file = alloc (strlen (line) + 1); + while (*line && *line != '"') + { + *p++ = *line++; + } + if (*line == 0) + { + error (_("preprocessor error")); + } + *p = 0; + if (*file == 0) + { + *fname = NULL; + } + else + { + *fname = file; + } + *lineno = num - 1; } diff --git a/sunrpc/rpc_svcout.c b/sunrpc/rpc_svcout.c index f959a32b0b..d19b9b45eb 100644 --- a/sunrpc/rpc_svcout.c +++ b/sunrpc/rpc_svcout.c @@ -43,46 +43,46 @@ char svcout_rcsid[] = #include "rpc_util.h" #include "proto.h" -static char RQSTP[] = "rqstp"; -static char TRANSP[] = "transp"; -static char ARG[] = "argument"; -static char RESULT[] = "result"; -static char ROUTINE[] = "local"; - -char _errbuf[256]; /* For all messages */ - -static void internal_proctype(proc_list *plist); -static void p_xdrfunc(const char *rname, const char *typename); -static void write_real_program(definition *def); -static void write_program(definition *def, const char *storage); -static void printerr(const char *err, const char *transp); -static void printif(const char *proc, const char *transp, - const char *prefix, const char *arg); -static void write_inetmost(const char *infile); -static void print_return(const char *space); -static void print_pmapunset(const char *space); -static void print_err_message(const char *space); -static void write_timeout_func(void); -static void write_pm_most(const char *infile, int netflag); -static void write_rpc_svc_fg(const char *infile, const char *sp); -static void open_log_file(const char *infile, const char *sp); +static const char RQSTP[] = "rqstp"; +static const char TRANSP[] = "transp"; +static const char ARG[] = "argument"; +static const char RESULT[] = "result"; +static const char ROUTINE[] = "local"; + +char _errbuf[256]; /* For all messages */ + +static void internal_proctype (proc_list * plist); +static void p_xdrfunc (const char *rname, const char *typename); +static void write_real_program (definition * def); +static void write_program (definition * def, const char *storage); +static void printerr (const char *err, const char *transp); +static void printif (const char *proc, const char *transp, + const char *prefix, const char *arg); +static void write_inetmost (const char *infile); +static void print_return (const char *space); +static void print_pmapunset (const char *space); +static void print_err_message (const char *space); +static void write_timeout_func (void); +static void write_pm_most (const char *infile, int netflag); +static void write_rpc_svc_fg (const char *infile, const char *sp); +static void open_log_file (const char *infile, const char *sp); static void -p_xdrfunc(const char *rname, const char *typename) +p_xdrfunc (const char *rname, const char *typename) { - if( Cflag ) - f_print(fout, "\t\txdr_%s = (xdrproc_t) xdr_%s;\n", rname, - stringfix(typename) ); + if (Cflag) + f_print (fout, "\t\txdr_%s = (xdrproc_t) xdr_%s;\n", rname, + stringfix (typename)); else - f_print(fout, "\t\txdr_%s = xdr_%s;\n", rname, stringfix(typename) ); + f_print (fout, "\t\txdr_%s = xdr_%s;\n", rname, stringfix (typename)); } void -internal_proctype(proc_list *plist) +internal_proctype (proc_list * plist) { - f_print(fout, "static "); - ptype( plist->res_prefix, plist->res_type, 1 ); - f_print( fout, "*" ); + f_print (fout, "static "); + ptype (plist->res_prefix, plist->res_type, 1); + f_print (fout, "*"); } @@ -90,205 +90,228 @@ internal_proctype(proc_list *plist) * write most of the service, that is, everything but the registrations. */ void -write_most(const char *infile /* our name */, int netflag, int nomain) +write_most (const char *infile /* our name */ , int netflag, int nomain) { - if (inetdflag || pmflag) { - const char *var_type; + if (inetdflag || pmflag) + { + const char *var_type; #ifdef __GNU_LIBRARY__ - /* WHY? */ - var_type = (nomain? "extern" : ""); + /* WHY? */ + var_type = (nomain ? "extern" : ""); #else - var_type = (nomain? "extern" : "static"); + var_type = (nomain ? "extern" : "static"); #endif - f_print(fout, "%s int _rpcpmstart;", var_type ); - f_print(fout, "\t\t/* Started by a port monitor ? */\n"); - f_print(fout, "%s int _rpcfdtype;", var_type ); - f_print(fout, "\t\t/* Whether Stream or Datagram ? */\n"); - if (timerflag) { - f_print(fout, "%s int _rpcsvcdirty;", var_type ); - f_print(fout, "\t/* Still serving ? */\n"); - } - write_svc_aux( nomain ); + f_print (fout, "%s int _rpcpmstart;", var_type); + f_print (fout, "\t\t/* Started by a port monitor ? */\n"); + f_print (fout, "%s int _rpcfdtype;", var_type); + f_print (fout, "\t\t/* Whether Stream or Datagram ? */\n"); + if (timerflag) + { + f_print (fout, "%s int _rpcsvcdirty;", var_type); + f_print (fout, "\t/* Still serving ? */\n"); } - /* write out dispatcher and stubs */ - write_programs(nomain ? NULL : "static"); + write_svc_aux (nomain); + } + /* write out dispatcher and stubs */ + write_programs (nomain ? NULL : "static"); - if( nomain ) - return; + if (nomain) + return; #ifdef __GNU_LIBRARY__ - if (Cflag) - f_print(fout, "\nint\nmain(int argc, char **argv)\n"); - else { - f_print(fout, "\nint\nmain(argc, argv)\n"); - f_print(fout, "\tint argc;\n"); - f_print(fout, "\tchar **argv;\n"); - } + if (Cflag) + f_print (fout, "\nint\nmain(int argc, char **argv)\n"); + else + { + f_print (fout, "\nint\nmain(argc, argv)\n"); + f_print (fout, "\tint argc;\n"); + f_print (fout, "\tchar **argv;\n"); + } #else - f_print(fout, "\nmain()\n"); + f_print (fout, "\nmain()\n"); #endif - f_print(fout, "{\n"); - if (inetdflag) { - write_inetmost(infile); /* Includes call to write_rpc_svc_fg() */ - } else { - if( tirpcflag ) { - if (netflag) { - f_print(fout, "\tregister SVCXPRT *%s;\n", TRANSP); - f_print(fout, "\tstruct netconfig *nconf = NULL;\n"); - } - f_print(fout, "\tpid_t pid;\n"); - f_print(fout, "\tint i;\n"); - f_print(fout, "\tchar mname[FMNAMESZ + 1];\n\n"); - write_pm_most(infile, netflag); - f_print(fout, "\telse {\n"); - write_rpc_svc_fg(infile, "\t\t"); - f_print(fout, "\t}\n"); - } else { - f_print(fout, "\tregister SVCXPRT *%s;\n", TRANSP); - f_print(fout, "\n"); - print_pmapunset("\t"); - } + f_print (fout, "{\n"); + if (inetdflag) + { + write_inetmost (infile); /* Includes call to write_rpc_svc_fg() */ + } + else + { + if (tirpcflag) + { + if (netflag) + { + f_print (fout, "\tregister SVCXPRT *%s;\n", TRANSP); + f_print (fout, "\tstruct netconfig *nconf = NULL;\n"); + } + f_print (fout, "\tpid_t pid;\n"); + f_print (fout, "\tint i;\n"); + f_print (fout, "\tchar mname[FMNAMESZ + 1];\n\n"); + write_pm_most (infile, netflag); + f_print (fout, "\telse {\n"); + write_rpc_svc_fg (infile, "\t\t"); + f_print (fout, "\t}\n"); } - - if (logflag && !inetdflag) { - open_log_file(infile, "\t"); + else + { + f_print (fout, "\tregister SVCXPRT *%s;\n", TRANSP); + f_print (fout, "\n"); + print_pmapunset ("\t"); } + } + + if (logflag && !inetdflag) + { + open_log_file (infile, "\t"); + } } /* * write a registration for the given transport */ void -write_netid_register(const char *transp) +write_netid_register (const char *transp) { - list *l; - definition *def; - version_list *vp; - const char *sp; - char tmpbuf[32]; - - sp = ""; - f_print(fout, "\n"); - f_print(fout, "%s\tnconf = getnetconfigent(\"%s\");\n", sp, transp); - f_print(fout, "%s\tif (nconf == NULL) {\n", sp); - (void) sprintf(_errbuf, "cannot find %s netid.", transp); - sprintf(tmpbuf, "%s\t\t", sp); - print_err_message(tmpbuf); - f_print(fout, "%s\t\texit(1);\n", sp); - f_print(fout, "%s\t}\n", sp); - f_print(fout, "%s\t%s = svc_tli_create(RPC_ANYFD, nconf, 0, 0, 0);\n", - sp, TRANSP /*, transp*/ /* ?!?... */ ); - f_print(fout, "%s\tif (%s == NULL) {\n", sp, TRANSP); - (void) sprintf(_errbuf, "cannot create %s service.", transp); - print_err_message(tmpbuf); - f_print(fout, "%s\t\texit(1);\n", sp); - f_print(fout, "%s\t}\n", sp); - - for (l = defined; l != NULL; l = l->next) { - def = (definition *) l->val; - if (def->def_kind != DEF_PROGRAM) { - continue; - } - for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { - f_print(fout, - "%s\t(void) rpcb_unset(%s, %s, nconf);\n", - sp, def->def_name, vp->vers_name); - f_print(fout, - "%s\tif (!svc_reg(%s, %s, %s, ", - sp, TRANSP, def->def_name, vp->vers_name); - pvname(def->def_name, vp->vers_num); - f_print(fout, ", nconf)) {\n"); - (void) sprintf(_errbuf, "unable to register (%s, %s, %s).", - def->def_name, vp->vers_name, transp); - print_err_message(tmpbuf); - f_print(fout, "%s\t\texit(1);\n", sp); - f_print(fout, "%s\t}\n", sp); - } + list *l; + definition *def; + version_list *vp; + const char *sp; + char tmpbuf[32]; + + sp = ""; + f_print (fout, "\n"); + f_print (fout, "%s\tnconf = getnetconfigent(\"%s\");\n", sp, transp); + f_print (fout, "%s\tif (nconf == NULL) {\n", sp); + (void) sprintf (_errbuf, "cannot find %s netid.", transp); + sprintf (tmpbuf, "%s\t\t", sp); + print_err_message (tmpbuf); + f_print (fout, "%s\t\texit(1);\n", sp); + f_print (fout, "%s\t}\n", sp); + f_print (fout, "%s\t%s = svc_tli_create(RPC_ANYFD, nconf, 0, 0, 0);\n", + sp, TRANSP /*, transp *//* ?!?... */ ); + f_print (fout, "%s\tif (%s == NULL) {\n", sp, TRANSP); + (void) sprintf (_errbuf, "cannot create %s service.", transp); + print_err_message (tmpbuf); + f_print (fout, "%s\t\texit(1);\n", sp); + f_print (fout, "%s\t}\n", sp); + + for (l = defined; l != NULL; l = l->next) + { + def = (definition *) l->val; + if (def->def_kind != DEF_PROGRAM) + { + continue; + } + for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) + { + f_print (fout, + "%s\t(void) rpcb_unset(%s, %s, nconf);\n", + sp, def->def_name, vp->vers_name); + f_print (fout, + "%s\tif (!svc_reg(%s, %s, %s, ", + sp, TRANSP, def->def_name, vp->vers_name); + pvname (def->def_name, vp->vers_num); + f_print (fout, ", nconf)) {\n"); + (void) sprintf (_errbuf, "unable to register (%s, %s, %s).", + def->def_name, vp->vers_name, transp); + print_err_message (tmpbuf); + f_print (fout, "%s\t\texit(1);\n", sp); + f_print (fout, "%s\t}\n", sp); } - f_print(fout, "%s\tfreenetconfigent(nconf);\n", sp); + } + f_print (fout, "%s\tfreenetconfigent(nconf);\n", sp); } /* * write a registration for the given transport for TLI */ void -write_nettype_register(const char *transp) +write_nettype_register (const char *transp) { - list *l; - definition *def; - version_list *vp; - - for (l = defined; l != NULL; l = l->next) { - def = (definition *) l->val; - if (def->def_kind != DEF_PROGRAM) { - continue; - } - for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { - f_print(fout, "\tif (!svc_create("); - pvname(def->def_name, vp->vers_num); - f_print(fout, ", %s, %s, \"%s\")) {\n ", - def->def_name, vp->vers_name, transp); - (void) sprintf(_errbuf, - "unable to create (%s, %s) for %s.", - def->def_name, vp->vers_name, transp); - print_err_message("\t\t"); - f_print(fout, "\t\texit(1);\n"); - f_print(fout, "\t}\n"); - } + list *l; + definition *def; + version_list *vp; + + for (l = defined; l != NULL; l = l->next) + { + def = (definition *) l->val; + if (def->def_kind != DEF_PROGRAM) + { + continue; } + for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) + { + f_print (fout, "\tif (!svc_create("); + pvname (def->def_name, vp->vers_num); + f_print (fout, ", %s, %s, \"%s\")) {\n ", + def->def_name, vp->vers_name, transp); + (void) sprintf (_errbuf, + "unable to create (%s, %s) for %s.", + def->def_name, vp->vers_name, transp); + print_err_message ("\t\t"); + f_print (fout, "\t\texit(1);\n"); + f_print (fout, "\t}\n"); + } + } } /* * write the rest of the service */ void -write_rest(void) +write_rest (void) { - f_print(fout, "\n"); - if (inetdflag) { - f_print(fout, "\tif (%s == (SVCXPRT *)NULL) {\n", TRANSP); - (void) sprintf(_errbuf, "could not create a handle"); - print_err_message("\t\t"); - f_print(fout, "\t\texit(1);\n"); - f_print(fout, "\t}\n"); - if (timerflag) { - f_print(fout, "\tif (_rpcpmstart) {\n"); - f_print(fout, - "\t\t(void) signal(SIGALRM, %s closedown);\n", - Cflag? "(SIG_PF)" : "(void(*)())" ); - f_print(fout, "\t\t(void) alarm(_RPCSVC_CLOSEDOWN);\n"); - f_print(fout, "\t}\n"); - } + f_print (fout, "\n"); + if (inetdflag) + { + f_print (fout, "\tif (%s == (SVCXPRT *)NULL) {\n", TRANSP); + (void) sprintf (_errbuf, "could not create a handle"); + print_err_message ("\t\t"); + f_print (fout, "\t\texit(1);\n"); + f_print (fout, "\t}\n"); + if (timerflag) + { + f_print (fout, "\tif (_rpcpmstart) {\n"); + f_print (fout, + "\t\t(void) signal(SIGALRM, %s closedown);\n", + Cflag ? "(SIG_PF)" : "(void(*)())"); + f_print (fout, "\t\t(void) alarm(_RPCSVC_CLOSEDOWN);\n"); + f_print (fout, "\t}\n"); } - f_print(fout, "\tsvc_run();\n"); - (void) sprintf(_errbuf, "svc_run returned"); - print_err_message("\t"); - f_print(fout, "\texit(1);\n"); - f_print(fout, "\t/* NOTREACHED */\n"); - f_print(fout, "}\n"); + } + f_print (fout, "\tsvc_run();\n"); + (void) sprintf (_errbuf, "svc_run returned"); + print_err_message ("\t"); + f_print (fout, "\texit(1);\n"); + f_print (fout, "\t/* NOTREACHED */\n"); + f_print (fout, "}\n"); } void -write_programs(const char *storage) +write_programs (const char *storage) { - list *l; - definition *def; - - /* write out stubs for procedure definitions */ - for (l = defined; l != NULL; l = l->next) { - def = (definition *) l->val; - if (def->def_kind == DEF_PROGRAM) { - write_real_program(def); - } + list *l; + definition *def; + + /* write out stubs for procedure definitions */ + for (l = defined; l != NULL; l = l->next) + { + def = (definition *) l->val; + if (def->def_kind == DEF_PROGRAM) + { + write_real_program (def); } - - /* write out dispatcher for each program */ - for (l = defined; l != NULL; l = l->next) { - def = (definition *) l->val; - if (def->def_kind == DEF_PROGRAM) { - write_program(def, storage); - } + } + + /* write out dispatcher for each program */ + for (l = defined; l != NULL; l = l->next) + { + def = (definition *) l->val; + if (def->def_kind == DEF_PROGRAM) + { + write_program (def, storage); } + } } @@ -298,312 +321,347 @@ write_programs(const char *storage) Unpacks single user argument of printmsg_1 to call-by-value format expected by printmsg_1. */ static void -write_real_program(definition *def) +write_real_program (definition * def) { - version_list *vp; - proc_list *proc; - decl_list *l; - - if( !newstyle ) return; /* not needed for old style */ - for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { - for (proc = vp->procs; proc != NULL; proc = proc->next) { - f_print(fout, "\n"); - internal_proctype(proc); - f_print(fout, "\n_"); - pvname(proc->proc_name, vp->vers_num); - if( Cflag ) { - f_print(fout, "(" ); - /* arg name */ - if (proc->arg_num > 1) - f_print(fout, proc->args.argname); - else - ptype(proc->args.decls->decl.prefix, - proc->args.decls->decl.type, 0); - f_print(fout, " *argp, struct svc_req *%s)\n", - RQSTP); - } else { - f_print(fout, "(argp, %s)\n", RQSTP ); - /* arg name */ - if (proc->arg_num > 1) - f_print(fout, "\t%s *argp;\n", proc->args.argname); - else { - f_print(fout, "\t"); - ptype(proc->args.decls->decl.prefix, - proc->args.decls->decl.type, 0); - f_print(fout, " *argp;\n"); - } - f_print(fout, " struct svc_req *%s;\n", RQSTP); - } - - f_print(fout, "{\n"); - f_print(fout, "\treturn("); - if( Cflag ) - pvname_svc(proc->proc_name, vp->vers_num); - else - pvname(proc->proc_name, vp->vers_num); - f_print(fout, "("); - if (proc->arg_num < 2) { /* single argument */ - if (!streq( proc->args.decls->decl.type, "void")) - f_print(fout, "*argp, "); /* non-void */ - } else { - for (l = proc->args.decls; l != NULL; l = l->next) - f_print(fout, "argp->%s, ", l->decl.name); - } - f_print(fout, "%s));\n}\n", RQSTP); + version_list *vp; + proc_list *proc; + decl_list *l; + + if (!newstyle) + return; /* not needed for old style */ + for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) + { + for (proc = vp->procs; proc != NULL; proc = proc->next) + { + f_print (fout, "\n"); + internal_proctype (proc); + f_print (fout, "\n_"); + pvname (proc->proc_name, vp->vers_num); + if (Cflag) + { + f_print (fout, "("); + /* arg name */ + if (proc->arg_num > 1) + f_print (fout, proc->args.argname); + else + ptype (proc->args.decls->decl.prefix, + proc->args.decls->decl.type, 0); + f_print (fout, " *argp, struct svc_req *%s)\n", + RQSTP); + } + else + { + f_print (fout, "(argp, %s)\n", RQSTP); + /* arg name */ + if (proc->arg_num > 1) + f_print (fout, "\t%s *argp;\n", proc->args.argname); + else + { + f_print (fout, "\t"); + ptype (proc->args.decls->decl.prefix, + proc->args.decls->decl.type, 0); + f_print (fout, " *argp;\n"); } + f_print (fout, " struct svc_req *%s;\n", RQSTP); + } + + f_print (fout, "{\n"); + f_print (fout, "\treturn("); + if (Cflag) + pvname_svc (proc->proc_name, vp->vers_num); + else + pvname (proc->proc_name, vp->vers_num); + f_print (fout, "("); + if (proc->arg_num < 2) + { /* single argument */ + if (!streq (proc->args.decls->decl.type, "void")) + f_print (fout, "*argp, "); /* non-void */ + } + else + { + for (l = proc->args.decls; l != NULL; l = l->next) + f_print (fout, "argp->%s, ", l->decl.name); + } + f_print (fout, "%s));\n}\n", RQSTP); } + } } static void -write_program(definition *def, const char *storage) +write_program (definition * def, const char *storage) { - version_list *vp; - proc_list *proc; - int filled; - - for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { - f_print(fout, "\n"); - if (storage != NULL) { - f_print(fout, "%s ", storage); - } - f_print(fout, "void\n"); - pvname(def->def_name, vp->vers_num); - - if (Cflag) { - f_print(fout, "(struct svc_req *%s, ", RQSTP); - f_print(fout, "register SVCXPRT *%s)\n", TRANSP); - } else { - f_print(fout, "(%s, %s)\n", RQSTP, TRANSP); - f_print(fout, " struct svc_req *%s;\n", RQSTP); - f_print(fout, " register SVCXPRT *%s;\n", TRANSP); - } + version_list *vp; + proc_list *proc; + int filled; + + for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) + { + f_print (fout, "\n"); + if (storage != NULL) + { + f_print (fout, "%s ", storage); + } + f_print (fout, "void\n"); + pvname (def->def_name, vp->vers_num); - f_print(fout, "{\n"); - - filled = 0; - f_print(fout, "\tunion {\n"); - for (proc = vp->procs; proc != NULL; proc = proc->next) { - if (proc->arg_num < 2) { /* single argument */ - if (streq(proc->args.decls->decl.type, - "void")) { - continue; - } - filled = 1; - f_print(fout, "\t\t"); - ptype(proc->args.decls->decl.prefix, - proc->args.decls->decl.type, 0); - pvname(proc->proc_name, vp->vers_num); - f_print(fout, "_arg;\n"); - - } - else { - filled = 1; - f_print(fout, "\t\t%s", proc->args.argname); - f_print(fout, " "); - pvname(proc->proc_name, vp->vers_num); - f_print(fout, "_arg;\n"); - } - } - if (!filled) { - f_print(fout, "\t\tint fill;\n"); - } - f_print(fout, "\t} %s;\n", ARG); - f_print(fout, "\tchar *%s;\n", RESULT); - - if (Cflag) { - f_print(fout, "\txdrproc_t xdr_%s, xdr_%s;\n", ARG, RESULT); - f_print(fout, - "\tchar *(*%s)(char *, struct svc_req *);\n", - ROUTINE); - } else { - f_print(fout, "\tbool_t (*xdr_%s)(), (*xdr_%s)();\n", ARG, RESULT); - f_print(fout, "\tchar *(*%s)();\n", ROUTINE); - } + if (Cflag) + { + f_print (fout, "(struct svc_req *%s, ", RQSTP); + f_print (fout, "register SVCXPRT *%s)\n", TRANSP); + } + else + { + f_print (fout, "(%s, %s)\n", RQSTP, TRANSP); + f_print (fout, " struct svc_req *%s;\n", RQSTP); + f_print (fout, " register SVCXPRT *%s;\n", TRANSP); + } - f_print(fout, "\n"); - - if (timerflag) - f_print(fout, "\t_rpcsvcdirty = 1;\n"); - f_print(fout, "\tswitch (%s->rq_proc) {\n", RQSTP); - if (!nullproc(vp->procs)) { - f_print(fout, "\tcase NULLPROC:\n"); - f_print(fout, - Cflag - ? "\t\t(void) svc_sendreply(%s, (xdrproc_t) xdr_void, (char *)NULL);\n" - : "\t\t(void) svc_sendreply(%s, xdr_void, (char *)NULL);\n", - TRANSP); - print_return("\t\t"); - f_print(fout, "\n"); - } - for (proc = vp->procs; proc != NULL; proc = proc->next) { - f_print(fout, "\tcase %s:\n", proc->proc_name); - if (proc->arg_num < 2) { /* single argument */ - p_xdrfunc( ARG, proc->args.decls->decl.type); - } else { - p_xdrfunc( ARG, proc->args.argname); - } - p_xdrfunc( RESULT, proc->res_type); - if( Cflag ) - f_print(fout, - "\t\t%s = (char *(*)(char *, struct svc_req *)) ", - ROUTINE); - else - f_print(fout, "\t\t%s = (char *(*)()) ", ROUTINE); - - if (newstyle) { /* new style: calls internal routine */ - f_print(fout,"_"); - } - if( Cflag && !newstyle ) - pvname_svc(proc->proc_name, vp->vers_num); - else - pvname(proc->proc_name, vp->vers_num); - f_print(fout, ";\n"); - f_print(fout, "\t\tbreak;\n\n"); + f_print (fout, "{\n"); + + filled = 0; + f_print (fout, "\tunion {\n"); + for (proc = vp->procs; proc != NULL; proc = proc->next) + { + if (proc->arg_num < 2) + { /* single argument */ + if (streq (proc->args.decls->decl.type, + "void")) + { + continue; } - f_print(fout, "\tdefault:\n"); - printerr("noproc", TRANSP); - print_return("\t\t"); - f_print(fout, "\t}\n"); - - f_print(fout, "\t(void) memset((char *)&%s, 0, sizeof (%s));\n", ARG, ARG); - if (Cflag) - printif("getargs", TRANSP, "(caddr_t) &", ARG); - else - printif("getargs", TRANSP, "&", ARG); - printerr("decode", TRANSP); - print_return("\t\t"); - f_print(fout, "\t}\n"); - - if (Cflag) - f_print(fout, "\t%s = (*%s)((char *)&%s, %s);\n", - RESULT, ROUTINE, ARG, RQSTP); - else - f_print(fout, "\t%s = (*%s)(&%s, %s);\n", - RESULT, ROUTINE, ARG, RQSTP); - f_print(fout, - "\tif (%s != NULL && !svc_sendreply(%s, xdr_%s, %s)) {\n", - RESULT, TRANSP, RESULT, RESULT); - printerr("systemerr", TRANSP); - f_print(fout, "\t}\n"); - - if (Cflag) - printif("freeargs", TRANSP, "(caddr_t) &", ARG); - else - printif("freeargs", TRANSP, "&", ARG); - (void) sprintf(_errbuf, "unable to free arguments"); - print_err_message("\t\t"); - f_print(fout, "\t\texit(1);\n"); - f_print(fout, "\t}\n"); - print_return("\t"); - f_print(fout, "}\n"); + filled = 1; + f_print (fout, "\t\t"); + ptype (proc->args.decls->decl.prefix, + proc->args.decls->decl.type, 0); + pvname (proc->proc_name, vp->vers_num); + f_print (fout, "_arg;\n"); + + } + else + { + filled = 1; + f_print (fout, "\t\t%s", proc->args.argname); + f_print (fout, " "); + pvname (proc->proc_name, vp->vers_num); + f_print (fout, "_arg;\n"); + } + } + if (!filled) + { + f_print (fout, "\t\tint fill;\n"); + } + f_print (fout, "\t} %s;\n", ARG); + f_print (fout, "\tchar *%s;\n", RESULT); + + if (Cflag) + { + f_print (fout, "\txdrproc_t xdr_%s, xdr_%s;\n", ARG, RESULT); + f_print (fout, + "\tchar *(*%s)(char *, struct svc_req *);\n", + ROUTINE); + } + else + { + f_print (fout, "\tbool_t (*xdr_%s)(), (*xdr_%s)();\n", ARG, RESULT); + f_print (fout, "\tchar *(*%s)();\n", ROUTINE); } + + f_print (fout, "\n"); + + if (timerflag) + f_print (fout, "\t_rpcsvcdirty = 1;\n"); + f_print (fout, "\tswitch (%s->rq_proc) {\n", RQSTP); + if (!nullproc (vp->procs)) + { + f_print (fout, "\tcase NULLPROC:\n"); + f_print (fout, + Cflag + ? "\t\t(void) svc_sendreply(%s, (xdrproc_t) xdr_void, (char *)NULL);\n" + : "\t\t(void) svc_sendreply(%s, xdr_void, (char *)NULL);\n", + TRANSP); + print_return ("\t\t"); + f_print (fout, "\n"); + } + for (proc = vp->procs; proc != NULL; proc = proc->next) + { + f_print (fout, "\tcase %s:\n", proc->proc_name); + if (proc->arg_num < 2) + { /* single argument */ + p_xdrfunc (ARG, proc->args.decls->decl.type); + } + else + { + p_xdrfunc (ARG, proc->args.argname); + } + p_xdrfunc (RESULT, proc->res_type); + if (Cflag) + f_print (fout, + "\t\t%s = (char *(*)(char *, struct svc_req *)) ", + ROUTINE); + else + f_print (fout, "\t\t%s = (char *(*)()) ", ROUTINE); + + if (newstyle) + { /* new style: calls internal routine */ + f_print (fout, "_"); + } + if (Cflag && !newstyle) + pvname_svc (proc->proc_name, vp->vers_num); + else + pvname (proc->proc_name, vp->vers_num); + f_print (fout, ";\n"); + f_print (fout, "\t\tbreak;\n\n"); + } + f_print (fout, "\tdefault:\n"); + printerr ("noproc", TRANSP); + print_return ("\t\t"); + f_print (fout, "\t}\n"); + + f_print (fout, "\t(void) memset((char *)&%s, 0, sizeof (%s));\n", ARG, ARG); + if (Cflag) + printif ("getargs", TRANSP, "(caddr_t) &", ARG); + else + printif ("getargs", TRANSP, "&", ARG); + printerr ("decode", TRANSP); + print_return ("\t\t"); + f_print (fout, "\t}\n"); + + if (Cflag) + f_print (fout, "\t%s = (*%s)((char *)&%s, %s);\n", + RESULT, ROUTINE, ARG, RQSTP); + else + f_print (fout, "\t%s = (*%s)(&%s, %s);\n", + RESULT, ROUTINE, ARG, RQSTP); + f_print (fout, + "\tif (%s != NULL && !svc_sendreply(%s, xdr_%s, %s)) {\n", + RESULT, TRANSP, RESULT, RESULT); + printerr ("systemerr", TRANSP); + f_print (fout, "\t}\n"); + + if (Cflag) + printif ("freeargs", TRANSP, "(caddr_t) &", ARG); + else + printif ("freeargs", TRANSP, "&", ARG); + (void) sprintf (_errbuf, "unable to free arguments"); + print_err_message ("\t\t"); + f_print (fout, "\t\texit(1);\n"); + f_print (fout, "\t}\n"); + print_return ("\t"); + f_print (fout, "}\n"); + } } static void -printerr(const char *err, const char *transp) +printerr (const char *err, const char *transp) { - f_print(fout, "\t\tsvcerr_%s(%s);\n", err, transp); + f_print (fout, "\t\tsvcerr_%s(%s);\n", err, transp); } static void -printif(const char *proc, const char *transp, const char *prefix, - const char *arg) +printif (const char *proc, const char *transp, const char *prefix, + const char *arg) { - f_print(fout, "\tif (!svc_%s(%s, xdr_%s, %s%s)) {\n", - proc, transp, arg, prefix, arg); + f_print (fout, "\tif (!svc_%s(%s, xdr_%s, %s%s)) {\n", + proc, transp, arg, prefix, arg); } int -nullproc(proc_list *proc) +nullproc (proc_list * proc) { - for (; proc != NULL; proc = proc->next) { - if (streq(proc->proc_num, "0")) { - return (1); - } + for (; proc != NULL; proc = proc->next) + { + if (streq (proc->proc_num, "0")) + { + return (1); } - return (0); + } + return (0); } static void -write_inetmost(const char *infile) +write_inetmost (const char *infile) { - f_print(fout, "\tregister SVCXPRT *%s;\n", TRANSP); - f_print(fout, "\tint sock;\n"); - f_print(fout, "\tint proto;\n"); - f_print(fout, "\tstruct sockaddr_in saddr;\n"); - f_print(fout, "\tint asize = sizeof (saddr);\n"); - f_print(fout, "\n"); - f_print(fout, - "\tif (getsockname(0, (struct sockaddr *)&saddr, &asize) == 0) {\n"); - f_print(fout, "\t\tint ssize = sizeof (int);\n\n"); - f_print(fout, "\t\tif (saddr.sin_family != AF_INET)\n"); - f_print(fout, "\t\t\texit(1);\n"); - f_print(fout, "\t\tif (getsockopt(0, SOL_SOCKET, SO_TYPE,\n"); - f_print(fout, "\t\t\t\t(char *)&_rpcfdtype, &ssize) == -1)\n"); - f_print(fout, "\t\t\texit(1);\n"); - f_print(fout, "\t\tsock = 0;\n"); - f_print(fout, "\t\t_rpcpmstart = 1;\n"); - f_print(fout, "\t\tproto = 0;\n"); - open_log_file(infile, "\t\t"); - f_print(fout, "\t} else {\n"); - write_rpc_svc_fg(infile, "\t\t"); - f_print(fout, "\t\tsock = RPC_ANYSOCK;\n"); - print_pmapunset("\t\t"); - f_print(fout, "\t}\n"); + f_print (fout, "\tregister SVCXPRT *%s;\n", TRANSP); + f_print (fout, "\tint sock;\n"); + f_print (fout, "\tint proto;\n"); + f_print (fout, "\tstruct sockaddr_in saddr;\n"); + f_print (fout, "\tint asize = sizeof (saddr);\n"); + f_print (fout, "\n"); + f_print (fout, + "\tif (getsockname(0, (struct sockaddr *)&saddr, &asize) == 0) {\n"); + f_print (fout, "\t\tint ssize = sizeof (int);\n\n"); + f_print (fout, "\t\tif (saddr.sin_family != AF_INET)\n"); + f_print (fout, "\t\t\texit(1);\n"); + f_print (fout, "\t\tif (getsockopt(0, SOL_SOCKET, SO_TYPE,\n"); + f_print (fout, "\t\t\t\t(char *)&_rpcfdtype, &ssize) == -1)\n"); + f_print (fout, "\t\t\texit(1);\n"); + f_print (fout, "\t\tsock = 0;\n"); + f_print (fout, "\t\t_rpcpmstart = 1;\n"); + f_print (fout, "\t\tproto = 0;\n"); + open_log_file (infile, "\t\t"); + f_print (fout, "\t} else {\n"); + write_rpc_svc_fg (infile, "\t\t"); + f_print (fout, "\t\tsock = RPC_ANYSOCK;\n"); + print_pmapunset ("\t\t"); + f_print (fout, "\t}\n"); } static void -print_return(const char *space) +print_return (const char *space) { - if (exitnow) - f_print(fout, "%sexit(0);\n", space); - else { - if (timerflag) - f_print(fout, "%s_rpcsvcdirty = 0;\n", space); - f_print(fout, "%sreturn;\n", space); - } + if (exitnow) + f_print (fout, "%sexit(0);\n", space); + else + { + if (timerflag) + f_print (fout, "%s_rpcsvcdirty = 0;\n", space); + f_print (fout, "%sreturn;\n", space); + } } static void -print_pmapunset(const char *space) +print_pmapunset (const char *space) { - list *l; - definition *def; - version_list *vp; - - for (l = defined; l != NULL; l = l->next) { - def = (definition *) l->val; - if (def->def_kind == DEF_PROGRAM) { - for (vp = def->def.pr.versions; vp != NULL; - vp = vp->next) { - f_print(fout, "%s(void) pmap_unset(%s, %s);\n", - space, def->def_name, vp->vers_name); - } - } + list *l; + definition *def; + version_list *vp; + + for (l = defined; l != NULL; l = l->next) + { + def = (definition *) l->val; + if (def->def_kind == DEF_PROGRAM) + { + for (vp = def->def.pr.versions; vp != NULL; + vp = vp->next) + { + f_print (fout, "%s(void) pmap_unset(%s, %s);\n", + space, def->def_name, vp->vers_name); + } } + } } static void -print_err_message(const char *space) +print_err_message (const char *space) { - if (logflag) - f_print(fout, "%ssyslog(LOG_ERR, \"%s\");\n", space, _errbuf); - else if (inetdflag || pmflag) - f_print(fout, "%s_msgout(\"%s\");\n", space, _errbuf); - else - f_print(fout, "%sfprintf(stderr, \"%s\");\n", space, _errbuf); + if (logflag) + f_print (fout, "%ssyslog(LOG_ERR, \"%s\");\n", space, _errbuf); + else if (inetdflag || pmflag) + f_print (fout, "%s_msgout(\"%s\");\n", space, _errbuf); + else + f_print (fout, "%sfprintf(stderr, \"%s\");\n", space, _errbuf); } /* * Write the server auxiliary function ( _msgout, timeout) */ void -write_svc_aux(int nomain) +write_svc_aux (int nomain) { - if (!logflag) - write_msg_out(); - if( !nomain ) - write_timeout_func(); + if (!logflag) + write_msg_out (); + if (!nomain) + write_timeout_func (); } /* @@ -611,232 +669,250 @@ write_svc_aux(int nomain) */ void -write_msg_out(void) +write_msg_out (void) { - f_print(fout, "\n"); - f_print(fout, "static\n"); - if( !Cflag ) { - f_print(fout, "void _msgout(msg)\n"); - f_print(fout, "\tchar *msg;\n"); - } else { - f_print(fout, "void _msgout(char* msg)\n"); - } - f_print(fout, "{\n"); - f_print(fout, "#ifdef RPC_SVC_FG\n"); - if (inetdflag || pmflag) - f_print(fout, "\tif (_rpcpmstart)\n"); - f_print(fout, "\t\tsyslog(LOG_ERR, msg);\n"); - f_print(fout, "\telse\n"); - f_print(fout, "\t\t(void) fprintf(stderr, \"%%s\\n\", msg);\n"); - f_print(fout, "#else\n"); - f_print(fout, "\tsyslog(LOG_ERR, msg);\n"); - f_print(fout, "#endif\n"); - f_print(fout, "}\n"); + f_print (fout, "\n"); + f_print (fout, "static\n"); + if (!Cflag) + { + f_print (fout, "void _msgout(msg)\n"); + f_print (fout, "\tchar *msg;\n"); + } + else + { + f_print (fout, "void _msgout(char* msg)\n"); + } + f_print (fout, "{\n"); + f_print (fout, "#ifdef RPC_SVC_FG\n"); + if (inetdflag || pmflag) + f_print (fout, "\tif (_rpcpmstart)\n"); + f_print (fout, "\t\tsyslog(LOG_ERR, msg);\n"); + f_print (fout, "\telse\n"); + f_print (fout, "\t\t(void) fprintf(stderr, \"%%s\\n\", msg);\n"); + f_print (fout, "#else\n"); + f_print (fout, "\tsyslog(LOG_ERR, msg);\n"); + f_print (fout, "#endif\n"); + f_print (fout, "}\n"); } /* * Write the timeout function */ static void -write_timeout_func(void) +write_timeout_func (void) { - if (!timerflag) - return; - f_print(fout, "\n"); - f_print(fout, "static void\n"); + if (!timerflag) + return; + f_print (fout, "\n"); + f_print (fout, "static void\n"); #ifdef __GNU_LIBRARY__ - if (Cflag) - f_print(fout, "closedown(int sig)\n"); - else - f_print(fout, "closedown(sig)\n\tint sig;\n"); + if (Cflag) + f_print (fout, "closedown(int sig)\n"); + else + f_print (fout, "closedown(sig)\n\tint sig;\n"); #else - f_print(fout, "closedown()\n"); + f_print (fout, "closedown()\n"); #endif - f_print(fout, "{\n"); + f_print (fout, "{\n"); #ifdef __GNU_LIBRARY__ - f_print(fout, "\t(void) signal(sig, %s closedown);\n", - Cflag? "(SIG_PF)" : "(void(*)())" ); + f_print (fout, "\t(void) signal(sig, %s closedown);\n", + Cflag ? "(SIG_PF)" : "(void(*)())"); #endif - f_print(fout, "\tif (_rpcsvcdirty == 0) {\n"); - f_print(fout, "\t\textern fd_set svc_fdset;\n"); - f_print(fout, "\t\tstatic int size;\n"); - f_print(fout, "\t\tint i, openfd;\n"); - if (tirpcflag && pmflag) { - f_print(fout, "\t\tstruct t_info tinfo;\n\n"); - f_print(fout, "\t\tif (!t_getinfo(0, &tinfo) && (tinfo.servtype == T_CLTS))\n"); - } else { - f_print(fout, "\n\t\tif (_rpcfdtype == SOCK_DGRAM)\n"); - } - f_print(fout, "\t\t\texit(0);\n"); - f_print(fout, "\t\tif (size == 0) {\n"); - if( tirpcflag ) { - f_print(fout, "\t\t\tstruct rlimit rl;\n\n"); - f_print(fout, "\t\t\trl.rlim_max = 0;\n"); - f_print(fout, "\t\t\tgetrlimit(RLIMIT_NOFILE, &rl);\n"); - f_print(fout, "\t\t\tif ((size = rl.rlim_max) == 0)\n"); - f_print(fout, "\t\t\t\treturn;\n"); - } else { - f_print(fout, "\t\t\tsize = getdtablesize();\n"); - } - f_print(fout, "\t\t}\n"); - f_print(fout, "\t\tfor (i = 0, openfd = 0; i < size && openfd < 2; i++)\n"); - f_print(fout, "\t\t\tif (FD_ISSET(i, &svc_fdset))\n"); - f_print(fout, "\t\t\t\topenfd++;\n"); - f_print(fout, "\t\tif (openfd <= 1)\n"); - f_print(fout, "\t\t\texit(0);\n"); - f_print(fout, "\t}\n"); - f_print(fout, "\t(void) alarm(_RPCSVC_CLOSEDOWN);\n"); - f_print(fout, "}\n"); + f_print (fout, "\tif (_rpcsvcdirty == 0) {\n"); + f_print (fout, "\t\textern fd_set svc_fdset;\n"); + f_print (fout, "\t\tstatic int size;\n"); + f_print (fout, "\t\tint i, openfd;\n"); + if (tirpcflag && pmflag) + { + f_print (fout, "\t\tstruct t_info tinfo;\n\n"); + f_print (fout, "\t\tif (!t_getinfo(0, &tinfo) && (tinfo.servtype == T_CLTS))\n"); + } + else + { + f_print (fout, "\n\t\tif (_rpcfdtype == SOCK_DGRAM)\n"); + } + f_print (fout, "\t\t\texit(0);\n"); + f_print (fout, "\t\tif (size == 0) {\n"); + if (tirpcflag) + { + f_print (fout, "\t\t\tstruct rlimit rl;\n\n"); + f_print (fout, "\t\t\trl.rlim_max = 0;\n"); + f_print (fout, "\t\t\tgetrlimit(RLIMIT_NOFILE, &rl);\n"); + f_print (fout, "\t\t\tif ((size = rl.rlim_max) == 0)\n"); + f_print (fout, "\t\t\t\treturn;\n"); + } + else + { + f_print (fout, "\t\t\tsize = getdtablesize();\n"); + } + f_print (fout, "\t\t}\n"); + f_print (fout, "\t\tfor (i = 0, openfd = 0; i < size && openfd < 2; i++)\n"); + f_print (fout, "\t\t\tif (FD_ISSET(i, &svc_fdset))\n"); + f_print (fout, "\t\t\t\topenfd++;\n"); + f_print (fout, "\t\tif (openfd <= 1)\n"); + f_print (fout, "\t\t\texit(0);\n"); + f_print (fout, "\t}\n"); + f_print (fout, "\t(void) alarm(_RPCSVC_CLOSEDOWN);\n"); + f_print (fout, "}\n"); } /* * Write the most of port monitor support */ static void -write_pm_most(const char *infile, int netflag) +write_pm_most (const char *infile, int netflag) { - list *l; - definition *def; - version_list *vp; - - f_print(fout, "\tif (!ioctl(0, I_LOOK, mname) &&\n"); - f_print(fout, "\t\t(!strcmp(mname, \"sockmod\") ||"); - f_print(fout, " !strcmp(mname, \"timod\"))) {\n"); - f_print(fout, "\t\tchar *netid;\n"); - if (!netflag) { /* Not included by -n option */ - f_print(fout, "\t\tstruct netconfig *nconf = NULL;\n"); - f_print(fout, "\t\tSVCXPRT *%s;\n", TRANSP); - } - if( timerflag ) - f_print(fout, "\t\tint pmclose;\n"); + list *l; + definition *def; + version_list *vp; + + f_print (fout, "\tif (!ioctl(0, I_LOOK, mname) &&\n"); + f_print (fout, "\t\t(!strcmp(mname, \"sockmod\") ||"); + f_print (fout, " !strcmp(mname, \"timod\"))) {\n"); + f_print (fout, "\t\tchar *netid;\n"); + if (!netflag) + { /* Not included by -n option */ + f_print (fout, "\t\tstruct netconfig *nconf = NULL;\n"); + f_print (fout, "\t\tSVCXPRT *%s;\n", TRANSP); + } + if (timerflag) + f_print (fout, "\t\tint pmclose;\n"); /* not necessary, defined in /usr/include/stdlib */ -/* f_print(fout, "\t\textern char *getenv();\n");*/ - f_print(fout, "\n"); - f_print(fout, "\t\t_rpcpmstart = 1;\n"); - if (logflag) - open_log_file(infile, "\t\t"); - f_print(fout, "\t\tif ((netid = getenv(\"NLSPROVIDER\")) == NULL) {\n"); - sprintf(_errbuf, "cannot get transport name"); - print_err_message("\t\t\t"); - f_print(fout, "\t\t} else if ((nconf = getnetconfigent(netid)) == NULL) {\n"); - sprintf(_errbuf, "cannot get transport info"); - print_err_message("\t\t\t"); - f_print(fout, "\t\t}\n"); - /* - * A kludgy support for inetd services. Inetd only works with - * sockmod, and RPC works only with timod, hence all this jugglery - */ - f_print(fout, "\t\tif (strcmp(mname, \"sockmod\") == 0) {\n"); - f_print(fout, "\t\t\tif (ioctl(0, I_POP, 0) || ioctl(0, I_PUSH, \"timod\")) {\n"); - sprintf(_errbuf, "could not get the right module"); - print_err_message("\t\t\t\t"); - f_print(fout, "\t\t\t\texit(1);\n"); - f_print(fout, "\t\t\t}\n"); - f_print(fout, "\t\t}\n"); - if( timerflag ) - f_print(fout, "\t\tpmclose = (t_getstate(0) != T_DATAXFER);\n"); - f_print(fout, "\t\tif ((%s = svc_tli_create(0, nconf, NULL, 0, 0)) == NULL) {\n", - TRANSP); - sprintf(_errbuf, "cannot create server handle"); - print_err_message("\t\t\t"); - f_print(fout, "\t\t\texit(1);\n"); - f_print(fout, "\t\t}\n"); - f_print(fout, "\t\tif (nconf)\n"); - f_print(fout, "\t\t\tfreenetconfigent(nconf);\n"); - for (l = defined; l != NULL; l = l->next) { - def = (definition *) l->val; - if (def->def_kind != DEF_PROGRAM) { - continue; - } - for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { - f_print(fout, - "\t\tif (!svc_reg(%s, %s, %s, ", - TRANSP, def->def_name, vp->vers_name); - pvname(def->def_name, vp->vers_num); - f_print(fout, ", 0)) {\n"); - (void) sprintf(_errbuf, "unable to register (%s, %s).", - def->def_name, vp->vers_name); - print_err_message("\t\t\t"); - f_print(fout, "\t\t\texit(1);\n"); - f_print(fout, "\t\t}\n"); - } +/* f_print(fout, "\t\textern char *getenv();\n"); */ + f_print (fout, "\n"); + f_print (fout, "\t\t_rpcpmstart = 1;\n"); + if (logflag) + open_log_file (infile, "\t\t"); + f_print (fout, "\t\tif ((netid = getenv(\"NLSPROVIDER\")) == NULL) {\n"); + sprintf (_errbuf, "cannot get transport name"); + print_err_message ("\t\t\t"); + f_print (fout, "\t\t} else if ((nconf = getnetconfigent(netid)) == NULL) {\n"); + sprintf (_errbuf, "cannot get transport info"); + print_err_message ("\t\t\t"); + f_print (fout, "\t\t}\n"); + /* + * A kludgy support for inetd services. Inetd only works with + * sockmod, and RPC works only with timod, hence all this jugglery + */ + f_print (fout, "\t\tif (strcmp(mname, \"sockmod\") == 0) {\n"); + f_print (fout, "\t\t\tif (ioctl(0, I_POP, 0) || ioctl(0, I_PUSH, \"timod\")) {\n"); + sprintf (_errbuf, "could not get the right module"); + print_err_message ("\t\t\t\t"); + f_print (fout, "\t\t\t\texit(1);\n"); + f_print (fout, "\t\t\t}\n"); + f_print (fout, "\t\t}\n"); + if (timerflag) + f_print (fout, "\t\tpmclose = (t_getstate(0) != T_DATAXFER);\n"); + f_print (fout, "\t\tif ((%s = svc_tli_create(0, nconf, NULL, 0, 0)) == NULL) {\n", + TRANSP); + sprintf (_errbuf, "cannot create server handle"); + print_err_message ("\t\t\t"); + f_print (fout, "\t\t\texit(1);\n"); + f_print (fout, "\t\t}\n"); + f_print (fout, "\t\tif (nconf)\n"); + f_print (fout, "\t\t\tfreenetconfigent(nconf);\n"); + for (l = defined; l != NULL; l = l->next) + { + def = (definition *) l->val; + if (def->def_kind != DEF_PROGRAM) + { + continue; } - if (timerflag) { - f_print(fout, "\t\tif (pmclose) {\n"); - f_print(fout, "\t\t\t(void) signal(SIGALRM, %s closedown);\n", - Cflag? "(SIG_PF)" : "(void(*)())" ); - f_print(fout, "\t\t\t(void) alarm(_RPCSVC_CLOSEDOWN);\n"); - f_print(fout, "\t\t}\n"); + for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) + { + f_print (fout, + "\t\tif (!svc_reg(%s, %s, %s, ", + TRANSP, def->def_name, vp->vers_name); + pvname (def->def_name, vp->vers_num); + f_print (fout, ", 0)) {\n"); + (void) sprintf (_errbuf, "unable to register (%s, %s).", + def->def_name, vp->vers_name); + print_err_message ("\t\t\t"); + f_print (fout, "\t\t\texit(1);\n"); + f_print (fout, "\t\t}\n"); } - f_print(fout, "\t\tsvc_run();\n"); - f_print(fout, "\t\texit(1);\n"); - f_print(fout, "\t\t/* NOTREACHED */\n"); - f_print(fout, "\t}\n"); + } + if (timerflag) + { + f_print (fout, "\t\tif (pmclose) {\n"); + f_print (fout, "\t\t\t(void) signal(SIGALRM, %s closedown);\n", + Cflag ? "(SIG_PF)" : "(void(*)())"); + f_print (fout, "\t\t\t(void) alarm(_RPCSVC_CLOSEDOWN);\n"); + f_print (fout, "\t\t}\n"); + } + f_print (fout, "\t\tsvc_run();\n"); + f_print (fout, "\t\texit(1);\n"); + f_print (fout, "\t\t/* NOTREACHED */\n"); + f_print (fout, "\t}\n"); } /* * Support for backgrounding the server if self started. */ static void -write_rpc_svc_fg(const char *infile, const char *sp) +write_rpc_svc_fg (const char *infile, const char *sp) { - f_print(fout, "#ifndef RPC_SVC_FG\n"); - f_print(fout, "%sint size;\n", sp); - if( tirpcflag ) - f_print(fout, "%sstruct rlimit rl;\n", sp); - if (inetdflag) - f_print(fout, "%sint pid, i;\n\n", sp); - f_print(fout, "%spid = fork();\n", sp); - f_print(fout, "%sif (pid < 0) {\n", sp); - f_print(fout, "%s\tperror(\"cannot fork\");\n", sp); - f_print(fout, "%s\texit(1);\n", sp); - f_print(fout, "%s}\n", sp); - f_print(fout, "%sif (pid)\n", sp); - f_print(fout, "%s\texit(0);\n", sp); - /* get number of file descriptors */ - if( tirpcflag ) { - f_print(fout, "%srl.rlim_max = 0;\n", sp); - f_print(fout, "%sgetrlimit(RLIMIT_NOFILE, &rl);\n", sp); - f_print(fout, "%sif ((size = rl.rlim_max) == 0)\n", sp); - f_print(fout, "%s\texit(1);\n", sp); - } else { - f_print(fout, "%ssize = getdtablesize();\n", sp); - } - - f_print(fout, "%sfor (i = 0; i < size; i++)\n", sp); - f_print(fout, "%s\t(void) close(i);\n", sp); - /* Redirect stderr and stdout to console */ - f_print(fout, "%si = open(\"/dev/console\", 2);\n", sp); - f_print(fout, "%s(void) dup2(i, 1);\n", sp); - f_print(fout, "%s(void) dup2(i, 2);\n", sp); - /* This removes control of the controlling terminal */ - if( tirpcflag ) - f_print(fout, "%ssetsid();\n", sp); - else { - f_print(fout, "%si = open(\"/dev/tty\", 2);\n", sp); - f_print(fout, "%sif (i >= 0) {\n", sp); - f_print(fout, "%s\t(void) ioctl(i, TIOCNOTTY, (char *)NULL);\n", sp);; - f_print(fout, "%s\t(void) close(i);\n", sp); - f_print(fout, "%s}\n", sp); - } - if (!logflag) - open_log_file(infile, sp); - f_print(fout, "#endif\n"); - if (logflag) - open_log_file(infile, sp); + f_print (fout, "#ifndef RPC_SVC_FG\n"); + f_print (fout, "%sint size;\n", sp); + if (tirpcflag) + f_print (fout, "%sstruct rlimit rl;\n", sp); + if (inetdflag) + f_print (fout, "%sint pid, i;\n\n", sp); + f_print (fout, "%spid = fork();\n", sp); + f_print (fout, "%sif (pid < 0) {\n", sp); + f_print (fout, "%s\tperror(\"cannot fork\");\n", sp); + f_print (fout, "%s\texit(1);\n", sp); + f_print (fout, "%s}\n", sp); + f_print (fout, "%sif (pid)\n", sp); + f_print (fout, "%s\texit(0);\n", sp); + /* get number of file descriptors */ + if (tirpcflag) + { + f_print (fout, "%srl.rlim_max = 0;\n", sp); + f_print (fout, "%sgetrlimit(RLIMIT_NOFILE, &rl);\n", sp); + f_print (fout, "%sif ((size = rl.rlim_max) == 0)\n", sp); + f_print (fout, "%s\texit(1);\n", sp); + } + else + { + f_print (fout, "%ssize = getdtablesize();\n", sp); + } + + f_print (fout, "%sfor (i = 0; i < size; i++)\n", sp); + f_print (fout, "%s\t(void) close(i);\n", sp); + /* Redirect stderr and stdout to console */ + f_print (fout, "%si = open(\"/dev/console\", 2);\n", sp); + f_print (fout, "%s(void) dup2(i, 1);\n", sp); + f_print (fout, "%s(void) dup2(i, 2);\n", sp); + /* This removes control of the controlling terminal */ + if (tirpcflag) + f_print (fout, "%ssetsid();\n", sp); + else + { + f_print (fout, "%si = open(\"/dev/tty\", 2);\n", sp); + f_print (fout, "%sif (i >= 0) {\n", sp); + f_print (fout, "%s\t(void) ioctl(i, TIOCNOTTY, (char *)NULL);\n", sp);; + f_print (fout, "%s\t(void) close(i);\n", sp); + f_print (fout, "%s}\n", sp); + } + if (!logflag) + open_log_file (infile, sp); + f_print (fout, "#endif\n"); + if (logflag) + open_log_file (infile, sp); } static void -open_log_file(const char *infile, const char *sp) +open_log_file (const char *infile, const char *sp) { - char *s; - - s = strrchr(infile, '.'); - if (s) - *s = '\0'; - f_print(fout,"%sopenlog(\"%s\", LOG_PID, LOG_DAEMON);\n", sp, infile); - if (s) - *s = '.'; + char *s; + + s = strrchr (infile, '.'); + if (s) + *s = '\0'; + f_print (fout, "%sopenlog(\"%s\", LOG_PID, LOG_DAEMON);\n", sp, infile); + if (s) + *s = '.'; } @@ -846,66 +922,71 @@ open_log_file(const char *infile, const char *sp) * write a registration for the given transport for Inetd */ void -write_inetd_register(const char *transp) +write_inetd_register (const char *transp) { - list *l; - definition *def; - version_list *vp; - const char *sp; - int isudp; - char tmpbuf[32]; - - if (inetdflag) - sp = "\t"; - else - sp = ""; - if (streq(transp, "udp")) - isudp = 1; - else - isudp = 0; - f_print(fout, "\n"); - if (inetdflag) { - f_print(fout, "\tif ((_rpcfdtype == 0) || (_rpcfdtype == %s)) {\n", - isudp ? "SOCK_DGRAM" : "SOCK_STREAM"); - } - f_print(fout, "%s\t%s = svc%s_create(%s", - sp, TRANSP, transp, inetdflag? "sock": "RPC_ANYSOCK"); - if (!isudp) - f_print(fout, ", 0, 0"); - f_print(fout, ");\n"); - f_print(fout, "%s\tif (%s == NULL) {\n", sp, TRANSP); - (void) sprintf(_errbuf, "cannot create %s service.", transp); - (void) sprintf(tmpbuf, "%s\t\t", sp); - print_err_message(tmpbuf); - f_print(fout, "%s\t\texit(1);\n", sp); - f_print(fout, "%s\t}\n", sp); - - if (inetdflag) { - f_print(fout, "%s\tif (!_rpcpmstart)\n\t", sp); - f_print(fout, "%s\tproto = IPPROTO_%s;\n", - sp, isudp ? "UDP": "TCP"); + list *l; + definition *def; + version_list *vp; + const char *sp; + int isudp; + char tmpbuf[32]; + + if (inetdflag) + sp = "\t"; + else + sp = ""; + if (streq (transp, "udp")) + isudp = 1; + else + isudp = 0; + f_print (fout, "\n"); + if (inetdflag) + { + f_print (fout, "\tif ((_rpcfdtype == 0) || (_rpcfdtype == %s)) {\n", + isudp ? "SOCK_DGRAM" : "SOCK_STREAM"); + } + f_print (fout, "%s\t%s = svc%s_create(%s", + sp, TRANSP, transp, inetdflag ? "sock" : "RPC_ANYSOCK"); + if (!isudp) + f_print (fout, ", 0, 0"); + f_print (fout, ");\n"); + f_print (fout, "%s\tif (%s == NULL) {\n", sp, TRANSP); + (void) sprintf (_errbuf, "cannot create %s service.", transp); + (void) sprintf (tmpbuf, "%s\t\t", sp); + print_err_message (tmpbuf); + f_print (fout, "%s\t\texit(1);\n", sp); + f_print (fout, "%s\t}\n", sp); + + if (inetdflag) + { + f_print (fout, "%s\tif (!_rpcpmstart)\n\t", sp); + f_print (fout, "%s\tproto = IPPROTO_%s;\n", + sp, isudp ? "UDP" : "TCP"); + } + for (l = defined; l != NULL; l = l->next) + { + def = (definition *) l->val; + if (def->def_kind != DEF_PROGRAM) + { + continue; } - for (l = defined; l != NULL; l = l->next) { - def = (definition *) l->val; - if (def->def_kind != DEF_PROGRAM) { - continue; - } - for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { - f_print(fout, "%s\tif (!svc_register(%s, %s, %s, ", - sp, TRANSP, def->def_name, vp->vers_name); - pvname(def->def_name, vp->vers_num); - if (inetdflag) - f_print(fout, ", proto)) {\n"); - else - f_print(fout, ", IPPROTO_%s)) {\n", - isudp ? "UDP": "TCP"); - (void) sprintf(_errbuf, "unable to register (%s, %s, %s).", - def->def_name, vp->vers_name, transp); - print_err_message(tmpbuf); - f_print(fout, "%s\t\texit(1);\n", sp); - f_print(fout, "%s\t}\n", sp); - } + for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) + { + f_print (fout, "%s\tif (!svc_register(%s, %s, %s, ", + sp, TRANSP, def->def_name, vp->vers_name); + pvname (def->def_name, vp->vers_num); + if (inetdflag) + f_print (fout, ", proto)) {\n"); + else + f_print (fout, ", IPPROTO_%s)) {\n", + isudp ? "UDP" : "TCP"); + (void) sprintf (_errbuf, "unable to register (%s, %s, %s).", + def->def_name, vp->vers_name, transp); + print_err_message (tmpbuf); + f_print (fout, "%s\t\texit(1);\n", sp); + f_print (fout, "%s\t}\n", sp); } - if (inetdflag) - f_print(fout, "\t}\n"); + } + if (inetdflag) + f_print (fout, "\t}\n"); } diff --git a/sunrpc/rpc_tblout.c b/sunrpc/rpc_tblout.c index 7a362471db..4f62e2e7fd 100644 --- a/sunrpc/rpc_tblout.c +++ b/sunrpc/rpc_tblout.c @@ -28,10 +28,10 @@ * Mountain View, California 94043 */ -/* +/* * From: @(#)rpc_tblout.c 1.4 89/02/22 (C) 1988 SMI */ -char tblout_rcsid[] = +char tblout_rcsid[] = "$Id$"; /* @@ -47,124 +47,136 @@ char tblout_rcsid[] = #define TABCOUNT 5 #define TABSTOP (TABSIZE*TABCOUNT) -static char tabstr[TABCOUNT+1] = "\t\t\t\t\t"; +static const char tabstr[TABCOUNT + 1] = "\t\t\t\t\t"; -static char tbl_hdr[] = "struct rpcgen_table %s_table[] = {\n"; -static char tbl_end[] = "};\n"; +static const char tbl_hdr[] = "struct rpcgen_table %s_table[] = {\n"; +static const char tbl_end[] = "};\n"; -static char null_entry[] = "\n\t(char *(*)())0,\n\ +static const char null_entry[] = "\n\t(char *(*)())0,\n\ \t(xdrproc_t) xdr_void,\t\t\t0,\n\ \t(xdrproc_t) xdr_void,\t\t\t0,\n"; -static char tbl_nproc[] = "int %s_nproc =\n\tsizeof(%s_table)/sizeof(%s_table[0]);\n\n"; +static const char tbl_nproc[] = "int %s_nproc =\n\tsizeof(%s_table)/sizeof(%s_table[0]);\n\n"; -static void write_table(const definition *def); -static void printit(const char *prefix, const char *type); +static void write_table (const definition * def); +static void printit (const char *prefix, const char *type); void -write_tables(void) +write_tables (void) { - list *l; - definition *def; - - f_print(fout, "\n"); - for (l = defined; l != NULL; l = l->next) { - def = (definition *) l->val; - if (def->def_kind == DEF_PROGRAM) { - write_table(def); - } + list *l; + definition *def; + + f_print (fout, "\n"); + for (l = defined; l != NULL; l = l->next) + { + def = (definition *) l->val; + if (def->def_kind == DEF_PROGRAM) + { + write_table (def); } + } } static void -write_table(const definition *def) +write_table (const definition * def) { - version_list *vp; - proc_list *proc; - int current; - int expected; - char progvers[100]; - int warning; - - for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) { - warning = 0; - s_print(progvers, "%s_%s", - locase(def->def_name), vp->vers_num); - /* print the table header */ - f_print(fout, tbl_hdr, progvers); - - if (nullproc(vp->procs)) { - expected = 0; - } - else { - expected = 1; - f_print(fout, null_entry); - } - for (proc = vp->procs; proc != NULL; proc = proc->next) { - current = atoi(proc->proc_num); - if (current != expected++) { - f_print(fout, - "\n/*\n * WARNING: table out of order\n */\n"); - if (warning == 0) { - f_print(stderr, - "WARNING %s table is out of order\n", - progvers); - warning = 1; - nonfatalerrors = 1; - } - expected = current + 1; - } - f_print(fout, "\n\t(char *(*)())RPCGEN_ACTION("); - - /* routine to invoke */ - if( Cflag && !newstyle ) - pvname_svc(proc->proc_name, vp->vers_num); - else { - if( newstyle ) - f_print( fout, "_"); /* calls internal func */ - pvname(proc->proc_name, vp->vers_num); - } - f_print(fout, "),\n"); - - /* argument info */ - if( proc->arg_num > 1 ) - printit((char*) NULL, proc->args.argname ); - else - /* do we have to do something special for newstyle */ - printit( proc->args.decls->decl.prefix, - proc->args.decls->decl.type ); - /* result info */ - printit(proc->res_prefix, proc->res_type); + version_list *vp; + proc_list *proc; + int current; + int expected; + char progvers[100]; + int warning; + + for (vp = def->def.pr.versions; vp != NULL; vp = vp->next) + { + warning = 0; + s_print (progvers, "%s_%s", + locase (def->def_name), vp->vers_num); + /* print the table header */ + f_print (fout, tbl_hdr, progvers); + + if (nullproc (vp->procs)) + { + expected = 0; + } + else + { + expected = 1; + f_print (fout, null_entry); + } + for (proc = vp->procs; proc != NULL; proc = proc->next) + { + current = atoi (proc->proc_num); + if (current != expected++) + { + f_print (fout, + "\n/*\n * WARNING: table out of order\n */\n"); + if (warning == 0) + { + f_print (stderr, + "WARNING %s table is out of order\n", + progvers); + warning = 1; + nonfatalerrors = 1; } - - /* print the table trailer */ - f_print(fout, tbl_end); - f_print(fout, tbl_nproc, progvers, progvers, progvers); + expected = current + 1; + } + f_print (fout, "\n\t(char *(*)())RPCGEN_ACTION("); + + /* routine to invoke */ + if (Cflag && !newstyle) + pvname_svc (proc->proc_name, vp->vers_num); + else + { + if (newstyle) + f_print (fout, "_"); /* calls internal func */ + pvname (proc->proc_name, vp->vers_num); + } + f_print (fout, "),\n"); + + /* argument info */ + if (proc->arg_num > 1) + printit ((char *) NULL, proc->args.argname); + else + /* do we have to do something special for newstyle */ + printit (proc->args.decls->decl.prefix, + proc->args.decls->decl.type); + /* result info */ + printit (proc->res_prefix, proc->res_type); } + + /* print the table trailer */ + f_print (fout, tbl_end); + f_print (fout, tbl_nproc, progvers, progvers, progvers); + } } static void -printit(const char *prefix, const char *type) +printit (const char *prefix, const char *type) { - int len; - int tabs; - - - len = fprintf(fout, "\txdr_%s,", stringfix(type)); - /* account for leading tab expansion */ - len += TABSIZE - 1; - /* round up to tabs required */ - tabs = (TABSTOP - len + TABSIZE - 1)/TABSIZE; - f_print(fout, "%s", &tabstr[TABCOUNT-tabs]); - - if (streq(type, "void")) { - f_print(fout, "0"); - } else { - f_print(fout, "sizeof ( "); - /* XXX: should "follow" be 1 ??? */ - ptype(prefix, type, 0); - f_print(fout, ")"); - } - f_print(fout, ",\n"); + int len; + int tabs; + + + len = fprintf (fout, "\txdr_%s,", stringfix (type)); + /* account for leading tab expansion */ + len += TABSIZE - 1; + /* round up to tabs required */ + tabs = (TABSTOP - len + TABSIZE - 1) / TABSIZE; + f_print (fout, "%s", &tabstr[TABCOUNT - tabs]); + + if (streq (type, "void")) + { + f_print (fout, "0"); + } + else + { + f_print (fout, "sizeof ( "); + /* XXX: should "follow" be 1 ??? */ + ptype (prefix, type, 0); + f_print (fout, ")"); + } + f_print (fout, ",\n"); } diff --git a/sunrpc/rpc_util.c b/sunrpc/rpc_util.c index cb4561ef39..a5fa727afe 100644 --- a/sunrpc/rpc_util.c +++ b/sunrpc/rpc_util.c @@ -28,14 +28,14 @@ * Mountain View, California 94043 */ -/* +/* * From: @(#)rpc_util.c 1.11 89/02/22 (C) 1987 SMI */ char util_rcsid[] = "$Id$"; /* - * rpc_util.c, Utility routines for the RPC protocol compiler + * rpc_util.c, Utility routines for the RPC protocol compiler */ #include <stdio.h> #include <ctype.h> @@ -63,425 +63,464 @@ FILE *fin; /* file pointer of current input */ list *defined; /* list of defined things */ -static int findit(const definition *def, const char *type); -static const char *fixit(const char *type, const char *orig); -static int typedefed(const definition *def, const char *type); -static const char *toktostr(tok_kind kind); -static void printbuf(void); -static void printwhere(void); +static int findit (const definition * def, const char *type); +static const char *fixit (const char *type, const char *orig); +static int typedefed (const definition * def, const char *type); +static const char *toktostr (tok_kind kind); +static void printbuf (void); +static void printwhere (void); /* - * Reinitialize the world + * Reinitialize the world */ void -reinitialize(void) +reinitialize (void) { - memset(curline, 0, MAXLINESIZE); - where = curline; - linenum = 0; - defined = NULL; + memset (curline, 0, MAXLINESIZE); + where = curline; + linenum = 0; + defined = NULL; } /* - * string equality + * string equality */ int -streq(const char *a, const char *b) +streq (const char *a, const char *b) { - return (strcmp(a, b) == 0); + return strcmp (a, b) == 0; } /* - * find a value in a list + * find a value in a list */ definition * -findval(list *lst, const char *val, - int (*cmp)(const definition *, const char *)) +findval (list * lst, const char *val, + int (*cmp) (const definition *, const char *)) { - - for (; lst != NULL; lst = lst->next) { - if (cmp(lst->val, val)) { - return (lst->val); - } + + for (; lst != NULL; lst = lst->next) + { + if (cmp (lst->val, val)) + { + return lst->val; } - return NULL; + } + return NULL; } /* - * store a value in a list + * store a value in a list */ void -storeval(list **lstp, definition *val) +storeval (list ** lstp, definition * val) { - list **l; - list *lst; - - - for (l = lstp; *l != NULL; l = (list **) & (*l)->next); - lst = ALLOC(list); - lst->val = val; - lst->next = NULL; - *l = lst; + list **l; + list *lst; + + + for (l = lstp; *l != NULL; l = (list **) & (*l)->next); + lst = ALLOC (list); + lst->val = val; + lst->next = NULL; + *l = lst; } static int -findit(const definition *def, const char *type) +findit (const definition * def, const char *type) { - return (streq(def->def_name, type)); + return streq (def->def_name, type); } static const char * -fixit(const char *type, const char *orig) +fixit (const char *type, const char *orig) { - definition *def; + definition *def; - def = findval(defined, type, findit); - if (def == NULL || def->def_kind != DEF_TYPEDEF) { - return (orig); - } - switch (def->def.ty.rel) { - case REL_VECTOR: - return (def->def.ty.old_type); - case REL_ALIAS: - return (fixit(def->def.ty.old_type, orig)); - default: - return (orig); - } + def = findval (defined, type, findit); + if (def == NULL || def->def_kind != DEF_TYPEDEF) + { + return orig; + } + switch (def->def.ty.rel) + { + case REL_VECTOR: + return (def->def.ty.old_type); + case REL_ALIAS: + return (fixit (def->def.ty.old_type, orig)); + default: + return orig; + } } const char * -fixtype(const char *type) +fixtype (const char *type) { - return (fixit(type, type)); + return fixit (type, type); } const char * -stringfix(const char *type) +stringfix (const char *type) { - if (streq(type, "string")) { - return "wrapstring"; - } - else { - return type; - } + if (streq (type, "string")) + { + return "wrapstring"; + } + else + { + return type; + } } void -ptype(const char *prefix, const char *type, int follow) +ptype (const char *prefix, const char *type, int follow) { - if (prefix != NULL) { - if (streq(prefix, "enum")) { - f_print(fout, "enum "); - } else { - f_print(fout, "struct "); - } + if (prefix != NULL) + { + if (streq (prefix, "enum")) + { + f_print (fout, "enum "); } - if (streq(type, "bool")) { - f_print(fout, "bool_t "); - } else if (streq(type, "string")) { - f_print(fout, "char *"); - } else { - f_print(fout, "%s ", follow ? fixtype(type) : type); + else + { + f_print (fout, "struct "); } + } + if (streq (type, "bool")) + { + f_print (fout, "bool_t "); + } + else if (streq (type, "string")) + { + f_print (fout, "char *"); + } + else + { + f_print (fout, "%s ", follow ? fixtype (type) : type); + } } static int -typedefed(const definition *def, const char *type) +typedefed (const definition * def, const char *type) { - if (def->def_kind != DEF_TYPEDEF || def->def.ty.old_prefix != NULL) { - return (0); - } else { - return (streq(def->def_name, type)); - } + if (def->def_kind != DEF_TYPEDEF || def->def.ty.old_prefix != NULL) + { + return 0; + } + else + { + return streq (def->def_name, type); + } } int -isvectordef(const char *type, relation rel) +isvectordef (const char *type, relation rel) { - definition *def; - - for (;;) { - switch (rel) { - case REL_VECTOR: - return (!streq(type, "string")); - case REL_ARRAY: - return (0); - case REL_POINTER: - return (0); - case REL_ALIAS: - def = findval(defined, type, typedefed); - if (def == NULL) { - return (0); - } - type = def->def.ty.old_type; - rel = def->def.ty.rel; - } + definition *def; + + for (;;) + { + switch (rel) + { + case REL_VECTOR: + return !streq (type, "string"); + case REL_ARRAY: + return 0; + case REL_POINTER: + return (0); + case REL_ALIAS: + def = findval (defined, type, typedefed); + if (def == NULL) + { + return 0; + } + type = def->def.ty.old_type; + rel = def->def.ty.rel; } + } } char * -locase(const char *str) +locase (const char *str) { - char c; - static char buf[100]; - char *p = buf; + char c; + static char buf[100]; + char *p = buf; - while ((c = *str++)!=0) { - *p++ = (c >= 'A' && c <= 'Z') ? (c - 'A' + 'a') : c; - } - *p = 0; - return (buf); + while ((c = *str++) != 0) + { + *p++ = (c >= 'A' && c <= 'Z') ? (c - 'A' + 'a') : c; + } + *p = 0; + return buf; } void -pvname_svc(const char *pname, const char *vnum) +pvname_svc (const char *pname, const char *vnum) { - f_print(fout, "%s_%s_svc", locase(pname), vnum); + f_print (fout, "%s_%s_svc", locase (pname), vnum); } void -pvname(const char *pname, const char *vnum) +pvname (const char *pname, const char *vnum) { - f_print(fout, "%s_%s", locase(pname), vnum); + f_print (fout, "%s_%s", locase (pname), vnum); } /* - * print a useful (?) error message, and then die + * print a useful (?) error message, and then die */ void -error(const char *msg) +error (const char *msg) { - printwhere(); - f_print(stderr, "%s, line %d: ", infilename, linenum); - f_print(stderr, "%s\n", msg); - crash(); + printwhere (); + f_print (stderr, "%s, line %d: ", infilename, linenum); + f_print (stderr, "%s\n", msg); + crash (); } /* * Something went wrong, unlink any files that we may have created and then - * die. + * die. */ void -crash(void) +crash (void) { - int i; + int i; - for (i = 0; i < nfiles; i++) { - (void) unlink(outfiles[i]); - } - exit(1); + for (i = 0; i < nfiles; i++) + { + (void) unlink (outfiles[i]); + } + exit (1); } void -record_open(const char *file) +record_open (const char *file) { - if (nfiles < NFILES) { - outfiles[nfiles++] = file; - } - else { - f_print(stderr, "too many files!\n"); - crash(); - } + if (nfiles < NFILES) + { + outfiles[nfiles++] = file; + } + else + { + f_print (stderr, "too many files!\n"); + crash (); + } } static char expectbuf[100]; /* - * error, token encountered was not the expected one + * error, token encountered was not the expected one */ void -expected1(tok_kind exp1) +expected1 (tok_kind exp1) { - s_print(expectbuf, "expected '%s'", - toktostr(exp1)); - error(expectbuf); + s_print (expectbuf, "expected '%s'", + toktostr (exp1)); + error (expectbuf); } /* - * error, token encountered was not one of two expected ones + * error, token encountered was not one of two expected ones */ void -expected2(tok_kind exp1, tok_kind exp2) +expected2 (tok_kind exp1, tok_kind exp2) { - s_print(expectbuf, "expected '%s' or '%s'", - toktostr(exp1), - toktostr(exp2)); - error(expectbuf); + s_print (expectbuf, "expected '%s' or '%s'", + toktostr (exp1), + toktostr (exp2)); + error (expectbuf); } /* - * error, token encountered was not one of 3 expected ones + * error, token encountered was not one of 3 expected ones */ void -expected3(tok_kind exp1, tok_kind exp2, tok_kind exp3) +expected3 (tok_kind exp1, tok_kind exp2, tok_kind exp3) { - s_print(expectbuf, "expected '%s', '%s' or '%s'", - toktostr(exp1), - toktostr(exp2), - toktostr(exp3)); - error(expectbuf); + s_print (expectbuf, "expected '%s', '%s' or '%s'", + toktostr (exp1), + toktostr (exp2), + toktostr (exp3)); + error (expectbuf); } void -tabify(FILE *f, int tab) +tabify (FILE * f, int tab) { - while (tab--) { - (void) fputc('\t', f); - } + while (tab--) + { + (void) fputc ('\t', f); + } } -static token tokstrings[] = { - {TOK_IDENT, "identifier"}, - {TOK_CONST, "const"}, - {TOK_RPAREN, ")"}, - {TOK_LPAREN, "("}, - {TOK_RBRACE, "}"}, - {TOK_LBRACE, "{"}, - {TOK_LBRACKET, "["}, - {TOK_RBRACKET, "]"}, - {TOK_STAR, "*"}, - {TOK_COMMA, ","}, - {TOK_EQUAL, "="}, - {TOK_COLON, ":"}, - {TOK_SEMICOLON, ";"}, - {TOK_UNION, "union"}, - {TOK_STRUCT, "struct"}, - {TOK_SWITCH, "switch"}, - {TOK_CASE, "case"}, - {TOK_DEFAULT, "default"}, - {TOK_ENUM, "enum"}, - {TOK_TYPEDEF, "typedef"}, - {TOK_INT, "int"}, - {TOK_SHORT, "short"}, - {TOK_LONG, "long"}, - {TOK_UNSIGNED, "unsigned"}, - {TOK_DOUBLE, "double"}, - {TOK_FLOAT, "float"}, - {TOK_CHAR, "char"}, - {TOK_STRING, "string"}, - {TOK_OPAQUE, "opaque"}, - {TOK_BOOL, "bool"}, - {TOK_VOID, "void"}, - {TOK_PROGRAM, "program"}, - {TOK_VERSION, "version"}, - {TOK_EOF, "??????"} +static const token tokstrings[] = +{ + {TOK_IDENT, "identifier"}, + {TOK_CONST, "const"}, + {TOK_RPAREN, ")"}, + {TOK_LPAREN, "("}, + {TOK_RBRACE, "}"}, + {TOK_LBRACE, "{"}, + {TOK_LBRACKET, "["}, + {TOK_RBRACKET, "]"}, + {TOK_STAR, "*"}, + {TOK_COMMA, ","}, + {TOK_EQUAL, "="}, + {TOK_COLON, ":"}, + {TOK_SEMICOLON, ";"}, + {TOK_UNION, "union"}, + {TOK_STRUCT, "struct"}, + {TOK_SWITCH, "switch"}, + {TOK_CASE, "case"}, + {TOK_DEFAULT, "default"}, + {TOK_ENUM, "enum"}, + {TOK_TYPEDEF, "typedef"}, + {TOK_INT, "int"}, + {TOK_SHORT, "short"}, + {TOK_LONG, "long"}, + {TOK_UNSIGNED, "unsigned"}, + {TOK_DOUBLE, "double"}, + {TOK_FLOAT, "float"}, + {TOK_CHAR, "char"}, + {TOK_STRING, "string"}, + {TOK_OPAQUE, "opaque"}, + {TOK_BOOL, "bool"}, + {TOK_VOID, "void"}, + {TOK_PROGRAM, "program"}, + {TOK_VERSION, "version"}, + {TOK_EOF, "??????"} }; static const char * -toktostr(tok_kind kind) +toktostr (tok_kind kind) { - token *sp; + token *sp; - for (sp = tokstrings; sp->kind != TOK_EOF && sp->kind != kind; sp++); - return (sp->str); + for (sp = tokstrings; sp->kind != TOK_EOF && sp->kind != kind; sp++); + return (sp->str); } static void -printbuf(void) +printbuf (void) { - char c; - int i; - int cnt; - -# define TABSIZE 4 - - for (i = 0; (c = curline[i])!=0; i++) { - if (c == '\t') { - cnt = 8 - (i % TABSIZE); - c = ' '; - } else { - cnt = 1; - } - while (cnt--) { - (void) fputc(c, stderr); - } + char c; + int i; + int cnt; + +#define TABSIZE 4 + + for (i = 0; (c = curline[i]) != 0; i++) + { + if (c == '\t') + { + cnt = 8 - (i % TABSIZE); + c = ' '; + } + else + { + cnt = 1; } + while (cnt--) + { + (void) fputc (c, stderr); + } + } } static void -printwhere(void) +printwhere (void) { - int i; - char c; - int cnt; - - printbuf(); - for (i = 0; i < where - curline; i++) { - c = curline[i]; - if (c == '\t') { - cnt = 8 - (i % TABSIZE); - } else { - cnt = 1; - } - while (cnt--) { - (void) fputc('^', stderr); - } + int i; + char c; + int cnt; + + printbuf (); + for (i = 0; i < where - curline; i++) + { + c = curline[i]; + if (c == '\t') + { + cnt = 8 - (i % TABSIZE); + } + else + { + cnt = 1; + } + while (cnt--) + { + (void) fputc ('^', stderr); } - (void) fputc('\n', stderr); + } + (void) fputc ('\n', stderr); } -char * -make_argname(const char *pname, const char *vname) +char * +make_argname (const char *pname, const char *vname) { - char *name; - - name = malloc(strlen(pname) + strlen(vname) + strlen(ARGEXT) + 3); - if (!name) { - fprintf(stderr, "failed in malloc"); - exit(1); - } - sprintf(name, "%s_%s_%s", locase(pname), vname, ARGEXT); - return name; + char *name; + + name = malloc (strlen (pname) + strlen (vname) + strlen (ARGEXT) + 3); + if (!name) + { + fprintf (stderr, "failed in malloc"); + exit (1); + } + sprintf (name, "%s_%s_%s", locase (pname), vname, ARGEXT); + return name; } bas_type *typ_list_h; bas_type *typ_list_t; void -add_type(int len, const char *type) +add_type (int len, const char *type) { bas_type *ptr; - if ((ptr = malloc(sizeof(bas_type))) == NULL) { - fprintf(stderr, "failed in malloc"); - exit(1); - } + if ((ptr = malloc (sizeof (bas_type))) == NULL) + { + fprintf (stderr, "failed in malloc"); + exit (1); + } - ptr->name=type; - ptr->length=len; - ptr->next=NULL; - if(typ_list_t == NULL) + ptr->name = type; + ptr->length = len; + ptr->next = NULL; + if (typ_list_t == NULL) { - typ_list_t=ptr; - typ_list_h=ptr; + typ_list_t = ptr; + typ_list_h = ptr; } else { - typ_list_t->next=ptr; - typ_list_t=ptr; + typ_list_t->next = ptr; + typ_list_t = ptr; } } -bas_type *find_type(const char *type) +bas_type * +find_type (const char *type) { bas_type *ptr; - ptr=typ_list_h; + ptr = typ_list_h; - while(ptr != NULL) + while (ptr != NULL) { - if(strcmp(ptr->name,type) == 0) - return(ptr); - else - ptr=ptr->next; + if (strcmp (ptr->name, type) == 0) + return ptr; + else + ptr = ptr->next; }; -return(NULL); + return NULL; } - diff --git a/sunrpc/rpcinfo.c b/sunrpc/rpcinfo.c index 30932c83a6..23fb3c0d8e 100644 --- a/sunrpc/rpcinfo.c +++ b/sunrpc/rpcinfo.c @@ -1,6 +1,7 @@ -/* @(#)rpcinfo.c 2.2 88/08/11 4.0 RPCSRC */ -#ifndef lint -static char sccsid[] = "@(#)rpcinfo.c 1.22 87/08/12 SMI"; + +/* @(#)rpcinfo.c 2.2 88/08/11 4.0 RPCSRC */ +#if !defined(lint) && defined (SCCSID) +static char sccsid[] = "@(#)rpcinfo.c 1.22 87/08/12 SMI"; #endif /* @@ -41,33 +42,38 @@ static char sccsid[] = "@(#)rpcinfo.c 1.22 87/08/12 SMI"; * Mountain View, California 94043 */ +#include <getopt.h> +#include <string.h> +#include <unistd.h> #include <rpc/rpc.h> #include <stdio.h> #include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> #include <netdb.h> #include <rpc/pmap_prot.h> #include <rpc/pmap_clnt.h> #include <signal.h> #include <ctype.h> +#include <locale.h> +#include <libintl.h> #define MAXHOSTLEN 256 #define MIN_VERS ((u_long) 0) -#define MAX_VERS ((u_long) 4294967295L) - -static void udpping(/*u_short portflag, int argc, char **argv*/); -static void tcpping(/*u_short portflag, int argc, char **argv*/); -static int pstatus(/*CLIENT *client, u_long prognum, u_long vers*/); -static void pmapdump(/*int argc, char **argv*/); -static bool_t reply_proc(/*void *res, struct sockaddr_in *who*/); -static void brdcst(/*int argc, char **argv*/); -static void deletereg(/* int argc, char **argv */) ; -static void usage(/*void*/); -static u_long getprognum(/*char *arg*/); -static u_long getvers(/*char *arg*/); -static void get_inet_address(/*struct sockaddr_in *addr, char *host*/); -extern u_long inet_addr(); /* in 4.2BSD, arpa/inet.h called that a in_addr */ -extern char *inet_ntoa(); +#define MAX_VERS ((u_long) 4294967295UL) + +static void udpping (u_short portflag, int argc, char **argv); +static void tcpping (u_short portflag, int argc, char **argv); +static int pstatus (CLIENT *client, u_long prognum, u_long vers); +static void pmapdump (int argc, char **argv); +static bool_t reply_proc (void *res, struct sockaddr_in *who); +static void brdcst (int argc, char **argv); +static void deletereg (int argc, char **argv); +static void usage (void); +static u_long getprognum (char *arg); +static u_long getvers (char *arg); +static void get_inet_address (struct sockaddr_in *addr, char *host); /* * Functions to be performed. @@ -80,365 +86,408 @@ extern char *inet_ntoa(); #define DELETES 5 /* delete registration for the service */ int -main(argc, argv) - int argc; - char **argv; +main (int argc, char **argv) { - register int c; - extern char *optarg; - extern int optind; - int errflg; - int function; - u_short portnum; - - function = NONE; - portnum = 0; - errflg = 0; - while ((c = getopt(argc, argv, "ptubdn:")) != -1) { - switch (c) { - - case 'p': - if (function != NONE) - errflg = 1; - else - function = PMAPDUMP; - break; - - case 't': - if (function != NONE) - errflg = 1; - else - function = TCPPING; - break; - - case 'u': - if (function != NONE) - errflg = 1; - else - function = UDPPING; - break; - - case 'b': - if (function != NONE) - errflg = 1; - else - function = BRDCST; - break; - - case 'n': - portnum = (u_short) atoi(optarg); /* hope we don't get bogus # */ - break; - - case 'd': - if (function != NONE) - errflg = 1; - else - function = DELETES; - break; - - case '?': - errflg = 1; - } + register int c; + int errflg; + int function; + u_short portnum; + + setlocale (LC_ALL, ""); + textdomain (_libc_intl_domainname); + + function = NONE; + portnum = 0; + errflg = 0; + while ((c = getopt (argc, argv, "ptubdn:")) != -1) + { + switch (c) + { + + case 'p': + if (function != NONE) + errflg = 1; + else + function = PMAPDUMP; + break; + + case 't': + if (function != NONE) + errflg = 1; + else + function = TCPPING; + break; + + case 'u': + if (function != NONE) + errflg = 1; + else + function = UDPPING; + break; + + case 'b': + if (function != NONE) + errflg = 1; + else + function = BRDCST; + break; + + case 'n': + portnum = (u_short) atoi (optarg); /* hope we don't get bogus # */ + break; + + case 'd': + if (function != NONE) + errflg = 1; + else + function = DELETES; + break; + + case '?': + errflg = 1; } - - if (errflg || function == NONE) { - usage(); - return (1); + } + + if (errflg || function == NONE) + { + usage (); + return (1); + } + + switch (function) + { + + case PMAPDUMP: + if (portnum != 0) + { + usage (); + return (1); } - - switch (function) { - - case PMAPDUMP: - if (portnum != 0) { - usage(); - return (1); - } - pmapdump(argc - optind, argv + optind); - break; - - case UDPPING: - udpping(portnum, argc - optind, argv + optind); - break; - - case TCPPING: - tcpping(portnum, argc - optind, argv + optind); - break; - - case BRDCST: - if (portnum != 0) { - usage(); - return (1); - } - brdcst(argc - optind, argv + optind); - break; - - case DELETES: - deletereg(argc - optind, argv + optind); - break; + pmapdump (argc - optind, argv + optind); + break; + + case UDPPING: + udpping (portnum, argc - optind, argv + optind); + break; + + case TCPPING: + tcpping (portnum, argc - optind, argv + optind); + break; + + case BRDCST: + if (portnum != 0) + { + usage (); + return (1); } + brdcst (argc - optind, argv + optind); + break; - return (0); + case DELETES: + deletereg (argc - optind, argv + optind); + break; + } + + return (0); } static void -udpping(portnum, argc, argv) - u_short portnum; - int argc; - char **argv; +udpping (portnum, argc, argv) + u_short portnum; + int argc; + char **argv; { - struct timeval to; - struct sockaddr_in addr; - enum clnt_stat rpc_stat; - CLIENT *client; - u_long prognum, vers, minvers, maxvers; - int sock = RPC_ANYSOCK; - struct rpc_err rpcerr; - int failure; - - if (argc < 2 || argc > 3) { - usage(); - exit(1); + struct timeval to; + struct sockaddr_in addr; + enum clnt_stat rpc_stat; + CLIENT *client; + u_long prognum, vers, minvers, maxvers; + int sock = RPC_ANYSOCK; + struct rpc_err rpcerr; + int failure; + + if (argc < 2 || argc > 3) + { + usage (); + exit (1); + } + prognum = getprognum (argv[1]); + get_inet_address (&addr, argv[0]); + /* Open the socket here so it will survive calls to clnt_destroy */ + sock = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP); + if (sock < 0) + { + perror ("rpcinfo: socket"); + exit (1); + } + failure = 0; + if (argc == 2) + { + /* + * A call to version 0 should fail with a program/version + * mismatch, and give us the range of versions supported. + */ + addr.sin_port = htons (portnum); + to.tv_sec = 5; + to.tv_usec = 0; + if ((client = clntudp_create (&addr, prognum, (u_long) 0, + to, &sock)) == NULL) + { + clnt_pcreateerror ("rpcinfo"); + printf (_ ("program %lu is not available\n"), + prognum); + exit (1); + } + to.tv_sec = 10; + to.tv_usec = 0; + rpc_stat = clnt_call (client, NULLPROC, (xdrproc_t) xdr_void, + (char *) NULL, (xdrproc_t) xdr_void, + (char *) NULL, to); + if (rpc_stat == RPC_PROGVERSMISMATCH) + { + clnt_geterr (client, &rpcerr); + minvers = rpcerr.re_vers.low; + maxvers = rpcerr.re_vers.high; + } + else if (rpc_stat == RPC_SUCCESS) + { + /* + * Oh dear, it DOES support version 0. + * Let's try version MAX_VERS. + */ + addr.sin_port = htons (portnum); + to.tv_sec = 5; + to.tv_usec = 0; + if ((client = clntudp_create (&addr, prognum, MAX_VERS, + to, &sock)) == NULL) + { + clnt_pcreateerror ("rpcinfo"); + printf (_ ("program %lu version %lu is not available\n"), + prognum, MAX_VERS); + exit (1); + } + to.tv_sec = 10; + to.tv_usec = 0; + rpc_stat = clnt_call (client, NULLPROC, (xdrproc_t) xdr_void, + NULL, (xdrproc_t) xdr_void, NULL, to); + if (rpc_stat == RPC_PROGVERSMISMATCH) + { + clnt_geterr (client, &rpcerr); + minvers = rpcerr.re_vers.low; + maxvers = rpcerr.re_vers.high; + } + else if (rpc_stat == RPC_SUCCESS) + { + /* + * It also supports version MAX_VERS. + * Looks like we have a wise guy. + * OK, we give them information on all + * 4 billion versions they support... + */ + minvers = 0; + maxvers = MAX_VERS; + } + else + { + (void) pstatus (client, prognum, MAX_VERS); + exit (1); + } } - prognum = getprognum(argv[1]); - get_inet_address(&addr, argv[0]); - /* Open the socket here so it will survive calls to clnt_destroy */ - sock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP); - if (sock < 0) { - perror("rpcinfo: socket"); - exit(1); + else + { + (void) pstatus (client, prognum, (u_long) 0); + exit (1); } - failure = 0; - if (argc == 2) { - /* - * A call to version 0 should fail with a program/version - * mismatch, and give us the range of versions supported. - */ - addr.sin_port = htons(portnum); - to.tv_sec = 5; - to.tv_usec = 0; - if ((client = clntudp_create(&addr, prognum, (u_long)0, - to, &sock)) == NULL) { - clnt_pcreateerror("rpcinfo"); - printf(_("program %lu is not available\n"), - prognum); - exit(1); - } - to.tv_sec = 10; - to.tv_usec = 0; - rpc_stat = clnt_call(client, NULLPROC, xdr_void, (char *)NULL, - xdr_void, (char *)NULL, to); - if (rpc_stat == RPC_PROGVERSMISMATCH) { - clnt_geterr(client, &rpcerr); - minvers = rpcerr.re_vers.low; - maxvers = rpcerr.re_vers.high; - } else if (rpc_stat == RPC_SUCCESS) { - /* - * Oh dear, it DOES support version 0. - * Let's try version MAX_VERS. - */ - addr.sin_port = htons(portnum); - to.tv_sec = 5; - to.tv_usec = 0; - if ((client = clntudp_create(&addr, prognum, MAX_VERS, - to, &sock)) == NULL) { - clnt_pcreateerror("rpcinfo"); - printf(_("program %lu version %lu is not available\n"), - prognum, MAX_VERS); - exit(1); - } - to.tv_sec = 10; - to.tv_usec = 0; - rpc_stat = clnt_call(client, NULLPROC, xdr_void, - (char *)NULL, xdr_void, (char *)NULL, to); - if (rpc_stat == RPC_PROGVERSMISMATCH) { - clnt_geterr(client, &rpcerr); - minvers = rpcerr.re_vers.low; - maxvers = rpcerr.re_vers.high; - } else if (rpc_stat == RPC_SUCCESS) { - /* - * It also supports version MAX_VERS. - * Looks like we have a wise guy. - * OK, we give them information on all - * 4 billion versions they support... - */ - minvers = 0; - maxvers = MAX_VERS; - } else { - (void) pstatus(client, prognum, MAX_VERS); - exit(1); - } - } else { - (void) pstatus(client, prognum, (u_long)0); - exit(1); - } - clnt_destroy(client); - for (vers = minvers; vers <= maxvers; vers++) { - addr.sin_port = htons(portnum); - to.tv_sec = 5; - to.tv_usec = 0; - if ((client = clntudp_create(&addr, prognum, vers, - to, &sock)) == NULL) { - clnt_pcreateerror("rpcinfo"); - printf(_("program %lu version %lu is not available\n"), - prognum, vers); - exit(1); - } - to.tv_sec = 10; - to.tv_usec = 0; - rpc_stat = clnt_call(client, NULLPROC, xdr_void, - (char *)NULL, xdr_void, (char *)NULL, to); - if (pstatus(client, prognum, vers) < 0) - failure = 1; - clnt_destroy(client); - } + clnt_destroy (client); + for (vers = minvers; vers <= maxvers; vers++) + { + addr.sin_port = htons (portnum); + to.tv_sec = 5; + to.tv_usec = 0; + if ((client = clntudp_create (&addr, prognum, vers, + to, &sock)) == NULL) + { + clnt_pcreateerror ("rpcinfo"); + printf (_ ("program %lu version %lu is not available\n"), + prognum, vers); + exit (1); + } + to.tv_sec = 10; + to.tv_usec = 0; + rpc_stat = clnt_call (client, NULLPROC, (xdrproc_t) xdr_void, + NULL, (xdrproc_t) xdr_void, NULL, to); + if (pstatus (client, prognum, vers) < 0) + failure = 1; + clnt_destroy (client); } - else { - vers = getvers(argv[2]); - addr.sin_port = htons(portnum); - to.tv_sec = 5; - to.tv_usec = 0; - if ((client = clntudp_create(&addr, prognum, vers, - to, &sock)) == NULL) { - clnt_pcreateerror("rpcinfo"); - printf("program %lu version %lu is not available\n", - prognum, vers); - exit(1); - } - to.tv_sec = 10; - to.tv_usec = 0; - rpc_stat = clnt_call(client, 0, xdr_void, (char *)NULL, - xdr_void, (char *)NULL, to); - if (pstatus(client, prognum, vers) < 0) - failure = 1; + } + else + { + vers = getvers (argv[2]); + addr.sin_port = htons (portnum); + to.tv_sec = 5; + to.tv_usec = 0; + if ((client = clntudp_create (&addr, prognum, vers, + to, &sock)) == NULL) + { + clnt_pcreateerror ("rpcinfo"); + printf ("program %lu version %lu is not available\n", + prognum, vers); + exit (1); } - (void) close(sock); /* Close it up again */ - if (failure) - exit(1); + to.tv_sec = 10; + to.tv_usec = 0; + rpc_stat = clnt_call (client, 0, (xdrproc_t) xdr_void, NULL, + (xdrproc_t) xdr_void, NULL, to); + if (pstatus (client, prognum, vers) < 0) + failure = 1; + } + (void) close (sock); /* Close it up again */ + if (failure) + exit (1); } static void -tcpping(portnum, argc, argv) - u_short portnum; - int argc; - char **argv; +tcpping (portnum, argc, argv) + u_short portnum; + int argc; + char **argv; { - struct timeval to; - struct sockaddr_in addr; - enum clnt_stat rpc_stat; - CLIENT *client; - u_long prognum, vers, minvers, maxvers; - int sock = RPC_ANYSOCK; - struct rpc_err rpcerr; - int failure; - - if (argc < 2 || argc > 3) { - usage(); - exit(1); + struct timeval to; + struct sockaddr_in addr; + enum clnt_stat rpc_stat; + CLIENT *client; + u_long prognum, vers, minvers, maxvers; + int sock = RPC_ANYSOCK; + struct rpc_err rpcerr; + int failure; + + if (argc < 2 || argc > 3) + { + usage (); + exit (1); + } + prognum = getprognum (argv[1]); + get_inet_address (&addr, argv[0]); + failure = 0; + if (argc == 2) + { + /* + * A call to version 0 should fail with a program/version + * mismatch, and give us the range of versions supported. + */ + addr.sin_port = htons (portnum); + if ((client = clnttcp_create (&addr, prognum, MIN_VERS, + &sock, 0, 0)) == NULL) + { + clnt_pcreateerror ("rpcinfo"); + printf (_ ("program %lu is not available\n"), + prognum); + exit (1); } - prognum = getprognum(argv[1]); - get_inet_address(&addr, argv[0]); - failure = 0; - if (argc == 2) { - /* - * A call to version 0 should fail with a program/version - * mismatch, and give us the range of versions supported. - */ - addr.sin_port = htons(portnum); - if ((client = clnttcp_create(&addr, prognum, MIN_VERS, - &sock, 0, 0)) == NULL) { - clnt_pcreateerror("rpcinfo"); - printf(_("program %lu is not available\n"), - prognum); - exit(1); - } - to.tv_sec = 10; - to.tv_usec = 0; - rpc_stat = clnt_call(client, NULLPROC, xdr_void, (char *)NULL, - xdr_void, (char *)NULL, to); - if (rpc_stat == RPC_PROGVERSMISMATCH) { - clnt_geterr(client, &rpcerr); - minvers = rpcerr.re_vers.low; - maxvers = rpcerr.re_vers.high; - } else if (rpc_stat == RPC_SUCCESS) { - /* - * Oh dear, it DOES support version 0. - * Let's try version MAX_VERS. - */ - addr.sin_port = htons(portnum); - if ((client = clnttcp_create(&addr, prognum, MAX_VERS, - &sock, 0, 0)) == NULL) { - clnt_pcreateerror("rpcinfo"); - printf(_("program %lu version %lu is not available\n"), - prognum, MAX_VERS); - exit(1); - } - to.tv_sec = 10; - to.tv_usec = 0; - rpc_stat = clnt_call(client, NULLPROC, xdr_void, - (char *)NULL, xdr_void, (char *)NULL, to); - if (rpc_stat == RPC_PROGVERSMISMATCH) { - clnt_geterr(client, &rpcerr); - minvers = rpcerr.re_vers.low; - maxvers = rpcerr.re_vers.high; - } else if (rpc_stat == RPC_SUCCESS) { - /* - * It also supports version MAX_VERS. - * Looks like we have a wise guy. - * OK, we give them information on all - * 4 billion versions they support... - */ - minvers = 0; - maxvers = MAX_VERS; - } else { - (void) pstatus(client, prognum, MAX_VERS); - exit(1); - } - } else { - (void) pstatus(client, prognum, MIN_VERS); - exit(1); - } - clnt_destroy(client); - (void) close(sock); - sock = RPC_ANYSOCK; /* Re-initialize it for later */ - for (vers = minvers; vers <= maxvers; vers++) { - addr.sin_port = htons(portnum); - if ((client = clnttcp_create(&addr, prognum, vers, - &sock, 0, 0)) == NULL) { - clnt_pcreateerror("rpcinfo"); - printf(_("program %lu version %lu is not available\n"), - prognum, vers); - exit(1); - } - to.tv_usec = 0; - to.tv_sec = 10; - rpc_stat = clnt_call(client, 0, xdr_void, (char *)NULL, - xdr_void, (char *)NULL, to); - if (pstatus(client, prognum, vers) < 0) - failure = 1; - clnt_destroy(client); - (void) close(sock); - sock = RPC_ANYSOCK; - } + to.tv_sec = 10; + to.tv_usec = 0; + rpc_stat = clnt_call (client, NULLPROC, (xdrproc_t) xdr_void, NULL, + (xdrproc_t) xdr_void, NULL, to); + if (rpc_stat == RPC_PROGVERSMISMATCH) + { + clnt_geterr (client, &rpcerr); + minvers = rpcerr.re_vers.low; + maxvers = rpcerr.re_vers.high; } - else { - vers = getvers(argv[2]); - addr.sin_port = htons(portnum); - if ((client = clnttcp_create(&addr, prognum, vers, &sock, - 0, 0)) == NULL) { - clnt_pcreateerror("rpcinfo"); - printf(_("program %lu version %lu is not available\n"), - prognum, vers); - exit(1); - } - to.tv_usec = 0; - to.tv_sec = 10; - rpc_stat = clnt_call(client, 0, xdr_void, (char *)NULL, - xdr_void, (char *)NULL, to); - if (pstatus(client, prognum, vers) < 0) - failure = 1; + else if (rpc_stat == RPC_SUCCESS) + { + /* + * Oh dear, it DOES support version 0. + * Let's try version MAX_VERS. + */ + addr.sin_port = htons (portnum); + if ((client = clnttcp_create (&addr, prognum, MAX_VERS, + &sock, 0, 0)) == NULL) + { + clnt_pcreateerror ("rpcinfo"); + printf (_ ("program %lu version %lu is not available\n"), + prognum, MAX_VERS); + exit (1); + } + to.tv_sec = 10; + to.tv_usec = 0; + rpc_stat = clnt_call (client, NULLPROC, (xdrproc_t) xdr_void, + NULL, (xdrproc_t) xdr_void, NULL, to); + if (rpc_stat == RPC_PROGVERSMISMATCH) + { + clnt_geterr (client, &rpcerr); + minvers = rpcerr.re_vers.low; + maxvers = rpcerr.re_vers.high; + } + else if (rpc_stat == RPC_SUCCESS) + { + /* + * It also supports version MAX_VERS. + * Looks like we have a wise guy. + * OK, we give them information on all + * 4 billion versions they support... + */ + minvers = 0; + maxvers = MAX_VERS; + } + else + { + (void) pstatus (client, prognum, MAX_VERS); + exit (1); + } } - if (failure) - exit(1); + else + { + (void) pstatus (client, prognum, MIN_VERS); + exit (1); + } + clnt_destroy (client); + (void) close (sock); + sock = RPC_ANYSOCK; /* Re-initialize it for later */ + for (vers = minvers; vers <= maxvers; vers++) + { + addr.sin_port = htons (portnum); + if ((client = clnttcp_create (&addr, prognum, vers, + &sock, 0, 0)) == NULL) + { + clnt_pcreateerror ("rpcinfo"); + printf (_ ("program %lu version %lu is not available\n"), + prognum, vers); + exit (1); + } + to.tv_usec = 0; + to.tv_sec = 10; + rpc_stat = clnt_call (client, 0, (xdrproc_t) xdr_void, NULL, + (xdrproc_t) xdr_void, NULL, to); + if (pstatus (client, prognum, vers) < 0) + failure = 1; + clnt_destroy (client); + (void) close (sock); + sock = RPC_ANYSOCK; + } + } + else + { + vers = getvers (argv[2]); + addr.sin_port = htons (portnum); + if ((client = clnttcp_create (&addr, prognum, vers, &sock, + 0, 0)) == NULL) + { + clnt_pcreateerror ("rpcinfo"); + printf (_ ("program %lu version %lu is not available\n"), + prognum, vers); + exit (1); + } + to.tv_usec = 0; + to.tv_sec = 10; + rpc_stat = clnt_call (client, 0, (xdrproc_t) xdr_void, NULL, + (xdrproc_t) xdr_void, NULL, to); + if (pstatus (client, prognum, vers) < 0) + failure = 1; + } + if (failure) + exit (1); } /* @@ -449,90 +498,102 @@ tcpping(portnum, argc, argv) * a good error message. */ static int -pstatus(client, prognum, vers) - register CLIENT *client; - u_long prognum; - u_long vers; +pstatus (client, prognum, vers) + register CLIENT *client; + u_long prognum; + u_long vers; { - struct rpc_err rpcerr; - - clnt_geterr(client, &rpcerr); - if (rpcerr.re_status != RPC_SUCCESS) { - clnt_perror(client, "rpcinfo"); - printf(_("program %lu version %lu is not available\n"), - prognum, vers); - return (-1); - } else { - printf(_("program %lu version %lu ready and waiting\n"), - prognum, vers); - return (0); - } + struct rpc_err rpcerr; + + clnt_geterr (client, &rpcerr); + if (rpcerr.re_status != RPC_SUCCESS) + { + clnt_perror (client, "rpcinfo"); + printf (_ ("program %lu version %lu is not available\n"), + prognum, vers); + return (-1); + } + else + { + printf (_ ("program %lu version %lu ready and waiting\n"), + prognum, vers); + return (0); + } } static void -pmapdump(argc, argv) - int argc; - char **argv; +pmapdump (argc, argv) + int argc; + char **argv; { - struct sockaddr_in server_addr; - register struct hostent *hp; - struct pmaplist *head = NULL; - int socket = RPC_ANYSOCK; - struct timeval minutetimeout; - register CLIENT *client; - struct rpcent *rpc; - - if (argc > 1) { - usage(); - exit(1); - } - if (argc == 1) - get_inet_address(&server_addr, argv[0]); - else { - bzero((char *)&server_addr, sizeof server_addr); - server_addr.sin_family = AF_INET; - if ((hp = gethostbyname("localhost")) != NULL) - bcopy(hp->h_addr, (caddr_t)&server_addr.sin_addr, - hp->h_length); - else - server_addr.sin_addr.s_addr = inet_addr("0.0.0.0"); - } - minutetimeout.tv_sec = 60; - minutetimeout.tv_usec = 0; - server_addr.sin_port = htons(PMAPPORT); - if ((client = clnttcp_create(&server_addr, PMAPPROG, - PMAPVERS, &socket, 50, 500)) == NULL) { - clnt_pcreateerror(_("rpcinfo: can't contact portmapper")); - exit(1); - } - if (clnt_call(client, PMAPPROC_DUMP, xdr_void, NULL, - xdr_pmaplist, &head, minutetimeout) != RPC_SUCCESS) { - fprintf(stderr, _("rpcinfo: can't contact portmapper: ")); - clnt_perror(client, "rpcinfo"); - exit(1); - } - if (head == NULL) { - printf(_("No remote programs registered.\n")); - } else { - printf(_(" program vers proto port\n")); - for (; head != NULL; head = head->pml_next) { - printf("%10ld%5ld", - head->pml_map.pm_prog, - head->pml_map.pm_vers); - if (head->pml_map.pm_prot == IPPROTO_UDP) - printf("%6s", "udp"); - else if (head->pml_map.pm_prot == IPPROTO_TCP) - printf("%6s", "tcp"); - else - printf("%6ld", head->pml_map.pm_prot); - printf("%7ld", head->pml_map.pm_port); - rpc = getrpcbynumber(head->pml_map.pm_prog); - if (rpc) - printf(" %s\n", rpc->r_name); - else - printf("\n"); - } + struct sockaddr_in server_addr; + register struct hostent *hp; + struct pmaplist *head = NULL; + int socket = RPC_ANYSOCK; + struct timeval minutetimeout; + register CLIENT *client; + struct rpcent *rpc; + + if (argc > 1) + { + usage (); + exit (1); + } + if (argc == 1) + get_inet_address (&server_addr, argv[0]); + else + { + bzero ((char *) &server_addr, sizeof server_addr); + server_addr.sin_family = AF_INET; + if ((hp = gethostbyname ("localhost")) != NULL) + bcopy (hp->h_addr, (caddr_t) & server_addr.sin_addr, + hp->h_length); + else + server_addr.sin_addr.s_addr = inet_addr ("0.0.0.0"); + } + minutetimeout.tv_sec = 60; + minutetimeout.tv_usec = 0; + server_addr.sin_port = htons (PMAPPORT); + if ((client = clnttcp_create (&server_addr, PMAPPROG, + PMAPVERS, &socket, 50, 500)) == NULL) + { + clnt_pcreateerror (_ ("rpcinfo: can't contact portmapper")); + exit (1); + } + if (clnt_call (client, PMAPPROC_DUMP, (xdrproc_t) xdr_void, NULL, + (xdrproc_t) xdr_pmaplist, (caddr_t) &head, + minutetimeout) != RPC_SUCCESS) + { + fprintf (stderr, _ ("rpcinfo: can't contact portmapper: ")); + clnt_perror (client, "rpcinfo"); + exit (1); + } + if (head == NULL) + { + printf (_ ("No remote programs registered.\n")); + } + else + { + printf (_ (" program vers proto port\n")); + for (; head != NULL; head = head->pml_next) + { + printf ("%10ld%5ld", + head->pml_map.pm_prog, + head->pml_map.pm_vers); + if (head->pml_map.pm_prot == IPPROTO_UDP) + printf ("%6s", "udp"); + else if (head->pml_map.pm_prot == IPPROTO_TCP) + printf ("%6s", "tcp"); + else + printf ("%6ld", head->pml_map.pm_prot); + printf ("%7ld", head->pml_map.pm_port); + rpc = getrpcbynumber (head->pml_map.pm_prog); + if (rpc) + printf (" %s\n", rpc->r_name); + else + printf ("\n"); } + } } /* @@ -541,126 +602,139 @@ pmapdump(argc, argv) * be piped through sort(1) and then uniq(1). */ -/*ARGSUSED*/ +/*ARGSUSED */ static bool_t -reply_proc(res, who) - void *res; /* Nothing comes back */ - struct sockaddr_in *who; /* Who sent us the reply */ +reply_proc (res, who) + void *res; /* Nothing comes back */ + struct sockaddr_in *who; /* Who sent us the reply */ { - register struct hostent *hp; + register struct hostent *hp; - hp = gethostbyaddr((char *) &who->sin_addr, sizeof who->sin_addr, - AF_INET); - printf("%s %s\n", inet_ntoa(who->sin_addr), - (hp == NULL) ? _("(unknown)") : hp->h_name); - return(FALSE); + hp = gethostbyaddr ((char *) &who->sin_addr, sizeof who->sin_addr, + AF_INET); + printf ("%s %s\n", inet_ntoa (who->sin_addr), + (hp == NULL) ? _ ("(unknown)") : hp->h_name); + return (FALSE); } static void -brdcst(argc, argv) - int argc; - char **argv; +brdcst (argc, argv) + int argc; + char **argv; { - enum clnt_stat rpc_stat; - u_long prognum, vers; - - if (argc != 2) { - usage(); - exit(1); - } - prognum = getprognum(argv[0]); - vers = getvers(argv[1]); - rpc_stat = clnt_broadcast(prognum, vers, NULLPROC, xdr_void, - (char *)NULL, xdr_void, (char *)NULL, reply_proc); - if ((rpc_stat != RPC_SUCCESS) && (rpc_stat != RPC_TIMEDOUT)) { - fprintf(stderr, _("rpcinfo: broadcast failed: %s\n"), - clnt_sperrno(rpc_stat)); - exit(1); - } - exit(0); + enum clnt_stat rpc_stat; + u_long prognum, vers; + + if (argc != 2) + { + usage (); + exit (1); + } + prognum = getprognum (argv[0]); + vers = getvers (argv[1]); + rpc_stat = clnt_broadcast (prognum, vers, NULLPROC, (xdrproc_t) xdr_void, + NULL, (xdrproc_t) xdr_void, NULL, + (resultproc_t) reply_proc); + if ((rpc_stat != RPC_SUCCESS) && (rpc_stat != RPC_TIMEDOUT)) + { + fprintf (stderr, _ ("rpcinfo: broadcast failed: %s\n"), + clnt_sperrno (rpc_stat)); + exit (1); + } + exit (0); } static void -deletereg(argc, argv) - int argc; - char **argv; -{ u_long prog_num, version_num ; - - if (argc != 2) { - usage() ; - exit(1) ; - } - if (getuid()) { /* This command allowed only to root */ - fprintf(stderr, "Sorry. You are not root\n") ; - exit(1) ; - } - prog_num = getprognum(argv[0]); - version_num = getvers(argv[1]); - if ((pmap_unset(prog_num, version_num)) == 0) { - fprintf(stderr, _("rpcinfo: Could not delete registration for prog %s version %s\n"), - argv[0], argv[1]) ; - exit(1) ; - } +deletereg (argc, argv) + int argc; + char **argv; +{ + u_long prog_num, version_num; + + if (argc != 2) + { + usage (); + exit (1); + } + if (getuid ()) + { /* This command allowed only to root */ + fprintf (stderr, "Sorry. You are not root\n"); + exit (1); + } + prog_num = getprognum (argv[0]); + version_num = getvers (argv[1]); + if ((pmap_unset (prog_num, version_num)) == 0) + { + fprintf (stderr, _ ("rpcinfo: Could not delete registration for prog %s version %s\n"), + argv[0], argv[1]); + exit (1); + } } static void -usage() +usage () { - fprintf(stderr, _("Usage: rpcinfo [ -n portnum ] -u host prognum [ versnum ]\n")); - fprintf(stderr, _(" rpcinfo [ -n portnum ] -t host prognum [ versnum ]\n")); - fprintf(stderr, _(" rpcinfo -p [ host ]\n")); - fprintf(stderr, _(" rpcinfo -b prognum versnum\n")); - fprintf(stderr, _(" rpcinfo -d prognum versnum\n")) ; + fprintf (stderr, _ ("Usage: rpcinfo [ -n portnum ] -u host prognum [ versnum ]\n")); + fprintf (stderr, _ (" rpcinfo [ -n portnum ] -t host prognum [ versnum ]\n")); + fprintf (stderr, _ (" rpcinfo -p [ host ]\n")); + fprintf (stderr, _ (" rpcinfo -b prognum versnum\n")); + fprintf (stderr, _ (" rpcinfo -d prognum versnum\n")); } static u_long -getprognum(arg) - char *arg; +getprognum (arg) + char *arg; { - register struct rpcent *rpc; - register u_long prognum; - - if (isalpha(*arg)) { - rpc = getrpcbyname(arg); - if (rpc == NULL) { - fprintf(stderr, _("rpcinfo: %s is unknown service\n"), - arg); - exit(1); - } - prognum = rpc->r_number; - } else { - prognum = (u_long) atoi(arg); + register struct rpcent *rpc; + register u_long prognum; + + if (isalpha (*arg)) + { + rpc = getrpcbyname (arg); + if (rpc == NULL) + { + fprintf (stderr, _ ("rpcinfo: %s is unknown service\n"), + arg); + exit (1); } - - return (prognum); + prognum = rpc->r_number; + } + else + { + prognum = (u_long) atoi (arg); + } + + return (prognum); } static u_long -getvers(arg) - char *arg; +getvers (arg) + char *arg; { - register u_long vers; + register u_long vers; - vers = (int) atoi(arg); - return (vers); + vers = (int) atoi (arg); + return (vers); } static void -get_inet_address(addr, host) - struct sockaddr_in *addr; - char *host; +get_inet_address (addr, host) + struct sockaddr_in *addr; + char *host; { - register struct hostent *hp; - - bzero((char *)addr, sizeof *addr); - addr->sin_addr.s_addr = (u_long) inet_addr(host); - if (addr->sin_addr.s_addr == -1 || addr->sin_addr.s_addr == 0) { - if ((hp = gethostbyname(host)) == NULL) { - fprintf(stderr, _("rpcinfo: %s is unknown host\n"), - host); - exit(1); - } - bcopy(hp->h_addr, (char *)&addr->sin_addr, hp->h_length); + register struct hostent *hp; + + bzero ((char *) addr, sizeof *addr); + addr->sin_addr.s_addr = (u_long) inet_addr (host); + if (addr->sin_addr.s_addr == -1 || addr->sin_addr.s_addr == 0) + { + if ((hp = gethostbyname (host)) == NULL) + { + fprintf (stderr, _ ("rpcinfo: %s is unknown host\n"), + host); + exit (1); } - addr->sin_family = AF_INET; + bcopy (hp->h_addr, (char *) &addr->sin_addr, hp->h_length); + } + addr->sin_family = AF_INET; } diff --git a/sunrpc/svc.c b/sunrpc/svc.c index fcd7b36db4..93d8bbd993 100644 --- a/sunrpc/svc.c +++ b/sunrpc/svc.c @@ -41,8 +41,9 @@ static char sccsid[] = "@(#)svc.c 1.41 87/10/13 Copyr 1984 Sun Micro"; * Copyright (C) 1984, Sun Microsystems, Inc. */ -#include <sys/errno.h> +#include <errno.h> #include <rpc/rpc.h> +#include <rpc/svc.h> #include <rpc/pmap_clnt.h> #ifndef errno @@ -58,7 +59,7 @@ static SVCXPRT *xports[NOFILE]; #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 @@ -66,14 +67,16 @@ static SVCXPRT *xports[NOFILE]; * The dispatch routine takes request structs and runs the * appropriate procedure. */ -static struct svc_callout { - struct svc_callout *sc_next; - u_long sc_prog; - u_long sc_vers; - void (*sc_dispatch)(); -} *svc_head; +static struct svc_callout + { + struct svc_callout *sc_next; + u_long sc_prog; + u_long sc_vers; + void (*sc_dispatch) (struct svc_req *, SVCXPRT *); + } + *svc_head; -static struct svc_callout *svc_find(); +static struct svc_callout *svc_find (u_long, u_long, struct svc_callout **); /* *************** SVCXPRT related stuff **************** */ @@ -81,25 +84,27 @@ static struct svc_callout *svc_find(); * Activate a transport handle. */ void -xprt_register(xprt) - SVCXPRT *xprt; +xprt_register (SVCXPRT *xprt) { - register int sock = xprt->xp_sock; + register int sock = xprt->xp_sock; #ifdef FD_SETSIZE - if (xports == NULL) { - xports = (SVCXPRT **) - mem_alloc(FD_SETSIZE * sizeof(SVCXPRT *)); - } - if (sock < _rpc_dtablesize()) { - xports[sock] = xprt; - FD_SET(sock, &svc_fdset); - } + if (xports == NULL) + { + xports = (SVCXPRT **) + mem_alloc (FD_SETSIZE * sizeof (SVCXPRT *)); + } + if (sock < _rpc_dtablesize ()) + { + xports[sock] = xprt; + FD_SET (sock, &svc_fdset); + } #else - if (sock < NOFILE) { - xports[sock] = xprt; - svc_fds |= (1 << sock); - } + if (sock < NOFILE) + { + xports[sock] = xprt; + svc_fds |= (1 << sock); + } #endif /* def FD_SETSIZE */ } @@ -108,21 +113,23 @@ xprt_register(xprt) * De-activate a transport handle. */ void -xprt_unregister(xprt) - SVCXPRT *xprt; +xprt_unregister (xprt) + SVCXPRT *xprt; { - register int sock = xprt->xp_sock; + register int sock = xprt->xp_sock; #ifdef FD_SETSIZE - if ((sock < _rpc_dtablesize()) && (xports[sock] == xprt)) { - xports[sock] = (SVCXPRT *)0; - FD_CLR(sock, &svc_fdset); - } + if ((sock < _rpc_dtablesize ()) && (xports[sock] == xprt)) + { + xports[sock] = (SVCXPRT *) 0; + FD_CLR (sock, &svc_fdset); + } #else - if ((sock < NOFILE) && (xports[sock] == xprt)) { - xports[sock] = (SVCXPRT *)0; - svc_fds &= ~(1 << sock); - } + if ((sock < NOFILE) && (xports[sock] == xprt)) + { + xports[sock] = (SVCXPRT *) 0; + svc_fds &= ~(1 << sock); + } #endif /* def FD_SETSIZE */ } @@ -135,60 +142,62 @@ xprt_unregister(xprt) * 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; +svc_register (SVCXPRT *xprt, u_long prog, u_long vers, + void (*dispatch) (struct svc_req *, SVCXPRT *), u_long 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 */ - return (FALSE); - } - s = (struct svc_callout *)mem_alloc(sizeof(struct svc_callout)); - if (s == (struct svc_callout *)0) { - return (FALSE); - } - s->sc_prog = prog; - s->sc_vers = vers; - s->sc_dispatch = dispatch; - s->sc_next = svc_head; - svc_head = s; + 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 */ + return FALSE; + } + s = (struct svc_callout *) mem_alloc (sizeof (struct svc_callout)); + if (s == (struct svc_callout *) 0) + { + return FALSE; + } + s->sc_prog = prog; + s->sc_vers = vers; + s->sc_dispatch = dispatch; + s->sc_next = svc_head; + svc_head = s; pmap_it: - /* now register the information with the local binder service */ - if (protocol) { - return (pmap_set(prog, vers, protocol, xprt->xp_port)); - } - return (TRUE); + /* now register the information with the local binder service */ + if (protocol) + { + return pmap_set (prog, vers, protocol, xprt->xp_port); + } + return TRUE; } /* * Remove a service program from the callout list. */ void -svc_unregister(prog, vers) - u_long prog; - u_long vers; +svc_unregister (prog, vers) + u_long prog; + u_long vers; { - struct svc_callout *prev; - register struct svc_callout *s; - - if ((s = svc_find(prog, vers, &prev)) == NULL_SVC) - return; - if (prev == NULL_SVC) { - svc_head = s->sc_next; - } else { - prev->sc_next = s->sc_next; - } - 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); + struct svc_callout *prev; + register struct svc_callout *s; + + if ((s = svc_find (prog, vers, &prev)) == NULL_SVC) + return; + if (prev == NULL_SVC) + { + svc_head = s->sc_next; + } + else + { + prev->sc_next = s->sc_next; + } + 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); } /* @@ -196,22 +205,20 @@ svc_unregister(prog, vers) * struct. */ static struct svc_callout * -svc_find(prog, vers, prev) - u_long prog; - u_long vers; - struct svc_callout **prev; +svc_find (u_long prog, u_long vers, struct svc_callout **prev) { - register struct svc_callout *s, *p; - - p = NULL_SVC; - for (s = svc_head; s != NULL_SVC; s = s->sc_next) { - if ((s->sc_prog == prog) && (s->sc_vers == vers)) - goto done; - p = s; - } + register struct svc_callout *s, *p; + + p = NULL_SVC; + for (s = svc_head; s != NULL_SVC; s = s->sc_next) + { + if ((s->sc_prog == prog) && (s->sc_vers == vers)) + goto done; + p = s; + } done: - *prev = p; - return (s); + *prev = p; + return s; } /* ******************* REPLY GENERATION ROUTINES ************ */ @@ -220,132 +227,132 @@ 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; +svc_sendreply (xprt, xdr_results, xdr_location) + register SVCXPRT *xprt; + xdrproc_t xdr_results; + caddr_t xdr_location; { - struct rpc_msg rply; - - 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)); + struct rpc_msg rply; + + 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); } /* * No procedure error reply */ void -svcerr_noproc(xprt) - register SVCXPRT *xprt; +svcerr_noproc (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.acpted_rply.ar_stat = PROC_UNAVAIL; - SVC_REPLY(xprt, &rply); + rply.rm_direction = REPLY; + rply.rm_reply.rp_stat = MSG_ACCEPTED; + rply.acpted_rply.ar_verf = xprt->xp_verf; + rply.acpted_rply.ar_stat = PROC_UNAVAIL; + SVC_REPLY (xprt, &rply); } /* * Can't decode args error reply */ void -svcerr_decode(xprt) - register SVCXPRT *xprt; +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.acpted_rply.ar_verf = xprt->xp_verf; - rply.acpted_rply.ar_stat = GARBAGE_ARGS; - SVC_REPLY(xprt, &rply); + 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); } /* * Some system error */ void -svcerr_systemerr(xprt) - register SVCXPRT *xprt; +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.acpted_rply.ar_verf = xprt->xp_verf; - rply.acpted_rply.ar_stat = SYSTEM_ERR; - SVC_REPLY(xprt, &rply); + 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); } /* * Authentication error reply */ void -svcerr_auth(xprt, why) - SVCXPRT *xprt; - enum auth_stat why; +svcerr_auth (xprt, why) + SVCXPRT *xprt; + enum auth_stat why; { - struct rpc_msg rply; + struct rpc_msg rply; - rply.rm_direction = REPLY; - rply.rm_reply.rp_stat = MSG_DENIED; - rply.rjcted_rply.rj_stat = AUTH_ERROR; - rply.rjcted_rply.rj_why = why; - SVC_REPLY(xprt, &rply); + rply.rm_direction = REPLY; + rply.rm_reply.rp_stat = MSG_DENIED; + rply.rjcted_rply.rj_stat = AUTH_ERROR; + rply.rjcted_rply.rj_why = why; + SVC_REPLY (xprt, &rply); } /* * Auth too weak error reply */ void -svcerr_weakauth(xprt) - SVCXPRT *xprt; +svcerr_weakauth (xprt) + SVCXPRT *xprt; { - svcerr_auth(xprt, AUTH_TOOWEAK); + svcerr_auth (xprt, AUTH_TOOWEAK); } /* * Program unavailable error reply */ void -svcerr_noprog(xprt) - register SVCXPRT *xprt; +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.acpted_rply.ar_stat = PROG_UNAVAIL; - SVC_REPLY(xprt, &rply); + 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); } /* * Program version mismatch error reply */ void -svcerr_progvers(xprt, low_vers, high_vers) - register SVCXPRT *xprt; - u_long low_vers; - u_long high_vers; +svcerr_progvers (xprt, low_vers, high_vers) + register SVCXPRT *xprt; + u_long low_vers; + u_long high_vers; { - struct rpc_msg rply; - - 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_MISMATCH; - rply.acpted_rply.ar_vers.low = low_vers; - rply.acpted_rply.ar_vers.high = high_vers; - SVC_REPLY(xprt, &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.acpted_rply.ar_stat = PROG_MISMATCH; + rply.acpted_rply.ar_vers.low = low_vers; + rply.acpted_rply.ar_vers.high = high_vers; + SVC_REPLY (xprt, &rply); } /* ******************* SERVER INPUT STUFF ******************* */ @@ -367,115 +374,127 @@ svcerr_progvers(xprt, low_vers, high_vers) */ void -svc_getreq(rdfds) - int rdfds; +svc_getreq (rdfds) + int rdfds; { #ifdef FD_SETSIZE - fd_set readfds; + fd_set readfds; - FD_ZERO(&readfds); - readfds.fds_bits[0] = rdfds; - svc_getreqset(&readfds); + FD_ZERO (&readfds); + readfds.fds_bits[0] = rdfds; + svc_getreqset (&readfds); #else - int readfds = rdfds & svc_fds; + int readfds = rdfds & svc_fds; - svc_getreqset(&readfds); + svc_getreqset (&readfds); #endif /* def FD_SETSIZE */ } void -svc_getreqset(readfds) +svc_getreqset (readfds) #ifdef FD_SETSIZE - fd_set *readfds; + fd_set *readfds; { #else - int *readfds; + int *readfds; { - int readfds_local = *readfds; + int readfds_local = *readfds; #endif /* def FD_SETSIZE */ - enum xprt_stat stat; - struct rpc_msg msg; - int prog_found; - u_long low_vers; - u_long high_vers; - struct svc_req r; - register SVCXPRT *xprt; - register u_long mask; - register int bit; - register u_int32_t *maskp; - register int setsize; - register int sock; - 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]); + enum xprt_stat stat; + struct rpc_msg msg; + int prog_found; + u_long low_vers; + u_long high_vers; + struct svc_req r; + register SVCXPRT *xprt; + register u_long mask; + register int bit; + register u_int32_t *maskp; + register int setsize; + register int sock; + 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]); #ifdef FD_SETSIZE - setsize = _rpc_dtablesize(); - maskp = (u_int32_t *)readfds->fds_bits; - for (sock = 0; sock < setsize; sock += 32) { - for (mask = *maskp++; bit = ffs(mask); mask ^= (1 << (bit - 1))) { - /* sock has input waiting */ - xprt = xports[sock + bit - 1]; + setsize = _rpc_dtablesize (); + maskp = (u_int32_t *) readfds->fds_bits; + for (sock = 0; sock < setsize; sock += 32) + { + 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]; + 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; - } - /* 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 ... */ - } - call_done: - if ((stat = SVC_STAT(xprt)) == XPRT_DIED){ - SVC_DESTROY(xprt); - break; - } - } while (stat == XPRT_MOREREQS); + /* 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 ... */ + } + call_done: + if ((stat = SVC_STAT (xprt)) == XPRT_DIED) + { + SVC_DESTROY (xprt); + break; + } } + while (stat == XPRT_MOREREQS); } + } } diff --git a/sunrpc/svc_auth.c b/sunrpc/svc_auth.c index b650de9bea..9f7ed5eca6 100644 --- a/sunrpc/svc_auth.c +++ b/sunrpc/svc_auth.c @@ -1,6 +1,4 @@ -#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"; -#endif +/* @(#)svc_auth.c 2.4 88/08/15 4.0 RPCSRC */ /* * Sun RPC is a product of Sun Microsystems, Inc. and is provided for * unrestricted use provided that this legend is included on all tape @@ -29,15 +27,20 @@ static char sccsid[] = "@(#)svc_auth.c 2.1 88/08/07 4.0 RPCSRC; from 1.19 87/08/ * 2550 Garcia Avenue * Mountain View, California 94043 */ +#if !defined(lint) && defined(SCCSIDS) +static char sccsid[] = "@(#)svc_auth.c 1.19 87/08/11 Copyr 1984 Sun Micro"; +#endif /* - * svc_auth_nodes.c, Server-side rpc authenticator interface, + * svc_auth.c, Server-side rpc authenticator interface. * *WITHOUT* DES authentication. * * Copyright (C) 1984, Sun Microsystems, Inc. */ #include <rpc/rpc.h> +#include <rpc/svc.h> +#include <rpc/svc_auth.h> /* * svcauthsw is the bdevsw of server side authentication. @@ -47,25 +50,31 @@ static char sccsid[] = "@(#)svc_auth.c 2.1 88/08/07 4.0 RPCSRC; from 1.19 87/08/ * The server auth flavors must implement a routine that looks * like: * - * enum auth_stat - * flavorx_auth(rqst, msg) - * register struct svc_req *rqst; - * register struct rpc_msg *msg; + * enum auth_stat + * flavorx_auth(rqst, msg) + * register struct svc_req *rqst; + * register struct rpc_msg *msg; * */ -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 enum auth_stat _svcauth_null (struct svc_req *, struct rpc_msg *); + /* no authentication */ +extern enum auth_stat _svcauth_unix (struct svc_req *, struct rpc_msg *); + /* unix style (uid, gids) */ +extern enum auth_stat _svcauth_short (struct svc_req *, struct rpc_msg *); + /* short hand unix style */ -static struct { - enum auth_stat (*authenticator)(); -} svcauthsw[] = { - _svcauth_null, /* AUTH_NULL */ - _svcauth_unix, /* AUTH_UNIX */ - _svcauth_short, /* AUTH_SHORT */ +static const struct + { + enum auth_stat (*authenticator) (struct svc_req *, struct rpc_msg *); + } +svcauthsw[] = +{ + { _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 */ /* @@ -87,28 +96,22 @@ static struct { * invalid. */ enum auth_stat -_authenticate(rqst, msg) - register struct svc_req *rqst; - struct rpc_msg *msg; +_authenticate (register struct svc_req *rqst, struct rpc_msg *msg) { - register int cred_flavor; + register int cred_flavor; - rqst->rq_cred = msg->rm_call.cb_cred; - rqst->rq_xprt->xp_verf.oa_flavor = _null_auth.oa_flavor; - 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)); - } + rqst->rq_cred = msg->rm_call.cb_cred; + rqst->rq_xprt->xp_verf.oa_flavor = _null_auth.oa_flavor; + 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 (AUTH_REJECTEDCRED); + return AUTH_REJECTEDCRED; } -enum auth_stat -_svcauth_null(/*rqst, msg*/) - /*struct svc_req *rqst; - struct rpc_msg *msg;*/ +static enum auth_stat +_svcauth_null (struct svc_req *rqst, struct rpc_msg *msg) { - - return (AUTH_OK); + return AUTH_OK; } diff --git a/sunrpc/svc_authux.c b/sunrpc/svc_authux.c index 59fdde6ad8..04cff9c53a 100644 --- a/sunrpc/svc_authux.c +++ b/sunrpc/svc_authux.c @@ -43,80 +43,89 @@ static char sccsid[] = "@(#)svc_auth_unix.c 1.28 88/02/08 Copyr 1984 Sun Micro"; */ #include <stdio.h> +#include <string.h> #include <rpc/rpc.h> +#include <rpc/svc.h> /* * Unix longhand authenticator */ enum auth_stat -_svcauth_unix(rqst, msg) - register struct svc_req *rqst; - register struct rpc_msg *msg; +_svcauth_unix (struct svc_req *rqst, struct rpc_msg *msg) { - register enum auth_stat stat; - XDR xdrs; - register struct authunix_parms *aup; - register long *buf; - struct area { - struct authunix_parms area_aup; - char area_machname[MAX_MACHINE_NAME+1]; - gid_t area_gids[NGRPS]; - } *area; - u_int auth_len; - int str_len, gid_len; - register int i; + enum auth_stat stat; + XDR xdrs; + struct authunix_parms *aup; + long *buf; + struct area + { + struct authunix_parms area_aup; + char area_machname[MAX_MACHINE_NAME + 1]; + gid_t area_gids[NGRPS]; + } + *area; + u_int auth_len; + u_int str_len, gid_len; + u_int i; - area = (struct area *) rqst->rq_clntcred; - 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); - buf = XDR_INLINE(&xdrs, auth_len); - if (buf != NULL) { - aup->aup_time = IXDR_GET_LONG(buf); - str_len = IXDR_GET_U_LONG(buf); - if (str_len > MAX_MACHINE_NAME) { - stat = AUTH_BADCRED; - goto done; - } - bcopy((caddr_t)buf, aup->aup_machname, (u_int)str_len); - aup->aup_machname[str_len] = 0; - str_len = RNDUP(str_len); - buf = (u_long *) ((char *) buf + str_len); - aup->aup_uid = IXDR_GET_LONG(buf); - aup->aup_gid = IXDR_GET_LONG(buf); - gid_len = IXDR_GET_U_LONG(buf); - if (gid_len > NGRPS) { - stat = AUTH_BADCRED; - goto done; - } - aup->aup_len = gid_len; - for (i = 0; i < gid_len; i++) { - aup->aup_gids[i] = IXDR_GET_LONG(buf); - } - /* - * five is the smallest unix credentials structure - - * timestamp, hostname len (0), uid, gid, and gids len (0). - */ - 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); - stat = AUTH_BADCRED; - goto done; - } - } else if (! xdr_authunix_parms(&xdrs, aup)) { - xdrs.x_op = XDR_FREE; - (void)xdr_authunix_parms(&xdrs, aup); - stat = AUTH_BADCRED; - goto done; + area = (struct area *) rqst->rq_clntcred; + 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); + buf = XDR_INLINE (&xdrs, auth_len); + if (buf != NULL) + { + aup->aup_time = IXDR_GET_LONG (buf); + str_len = IXDR_GET_U_LONG (buf); + if (str_len > MAX_MACHINE_NAME) + { + 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; + bcopy ((caddr_t) buf, aup->aup_machname, (u_int) str_len); + aup->aup_machname[str_len] = 0; + str_len = RNDUP (str_len); + buf = (u_long *) ((char *) buf + str_len); + aup->aup_uid = IXDR_GET_LONG (buf); + aup->aup_gid = IXDR_GET_LONG (buf); + gid_len = IXDR_GET_U_LONG (buf); + if (gid_len > NGRPS) + { + stat = AUTH_BADCRED; + goto done; + } + aup->aup_len = gid_len; + for (i = 0; i < gid_len; i++) + { + aup->aup_gids[i] = IXDR_GET_LONG (buf); + } + /* + * five is the smallest unix credentials structure - + * timestamp, hostname len (0), uid, gid, and gids len (0). + */ + 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); + stat = AUTH_BADCRED; + goto done; + } + } + else if (!xdr_authunix_parms (&xdrs, aup)) + { + xdrs.x_op = XDR_FREE; + (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: - XDR_DESTROY(&xdrs); - return (stat); + XDR_DESTROY (&xdrs); + return stat; } @@ -124,11 +133,9 @@ done: * Shorthand unix authenticator * Looks up longhand in a cache. */ -/*ARGSUSED*/ +/*ARGSUSED */ enum auth_stat -_svcauth_short(rqst, msg) - struct svc_req *rqst; - struct rpc_msg *msg; +_svcauth_short (struct svc_req *rqst, struct rpc_msg *msg) { - return (AUTH_REJECTEDCRED); + return AUTH_REJECTEDCRED; } diff --git a/sunrpc/svc_raw.c b/sunrpc/svc_raw.c index 1b6cb3bf8a..1a7fcaa4e4 100644 --- a/sunrpc/svc_raw.c +++ b/sunrpc/svc_raw.c @@ -41,126 +41,121 @@ static char sccsid[] = "@(#)svc_raw.c 1.15 87/08/11 Copyr 1984 Sun Micro"; */ #include <rpc/rpc.h> - +#include <rpc/svc.h> /* * 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]; -} *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 struct xp_ops server_ops = { - svcraw_recv, - svcraw_stat, - svcraw_getargs, - svcraw_reply, - svcraw_freeargs, - svcraw_destroy +static struct svcraw_private + { + char _raw_buf[UDPMSGSIZE]; + SVCXPRT server; + XDR xdr_stream; + char verf_body[MAX_AUTH_BYTES]; + } + *svcraw_private; + +static bool_t svcraw_recv (SVCXPRT *, struct rpc_msg *); +static enum xprt_stat svcraw_stat (SVCXPRT *); +static bool_t svcraw_getargs (SVCXPRT *, xdrproc_t, caddr_t); +static bool_t svcraw_reply (SVCXPRT *, struct rpc_msg *); +static bool_t svcraw_freeargs (SVCXPRT *, xdrproc_t, caddr_t); +static void svcraw_destroy (SVCXPRT *); + +static struct xp_ops server_ops = +{ + svcraw_recv, + svcraw_stat, + svcraw_getargs, + svcraw_reply, + svcraw_freeargs, + svcraw_destroy }; SVCXPRT * -svcraw_create() +svcraw_create (void) { - register struct svcraw_private *srp = svcraw_private; - - if (srp == 0) { - srp = (struct svcraw_private *)calloc(1, sizeof (*srp)); - if (srp == 0) - return (0); - } - srp->server.xp_sock = 0; - srp->server.xp_port = 0; - srp->server.xp_ops = &server_ops; - srp->server.xp_verf.oa_base = srp->verf_body; - xdrmem_create(&srp->xdr_stream, srp->_raw_buf, UDPMSGSIZE, XDR_FREE); - return (&srp->server); + struct svcraw_private *srp = svcraw_private; + + if (srp == 0) + { + srp = (struct svcraw_private *) calloc (1, sizeof (*srp)); + if (srp == 0) + return NULL; + } + srp->server.xp_sock = 0; + srp->server.xp_port = 0; + srp->server.xp_ops = &server_ops; + srp->server.xp_verf.oa_base = srp->verf_body; + xdrmem_create (&srp->xdr_stream, srp->_raw_buf, UDPMSGSIZE, XDR_FREE); + return &srp->server; } static enum xprt_stat -svcraw_stat() +svcraw_stat (SVCXPRT *xprt) { - - return (XPRT_IDLE); + return XPRT_IDLE; } static bool_t -svcraw_recv(xprt, msg) - SVCXPRT *xprt; - struct rpc_msg *msg; +svcraw_recv (xprt, msg) + SVCXPRT *xprt; + struct rpc_msg *msg; { - register struct svcraw_private *srp = svcraw_private; - register XDR *xdrs; - - if (srp == 0) - return (0); - xdrs = &srp->xdr_stream; - xdrs->x_op = XDR_DECODE; - XDR_SETPOS(xdrs, 0); - if (! xdr_callmsg(xdrs, msg)) - return (FALSE); - return (TRUE); + struct svcraw_private *srp = svcraw_private; + XDR *xdrs; + + if (srp == 0) + return FALSE; + xdrs = &srp->xdr_stream; + xdrs->x_op = XDR_DECODE; + XDR_SETPOS (xdrs, 0); + if (!xdr_callmsg (xdrs, msg)) + return FALSE; + return TRUE; } static bool_t -svcraw_reply(xprt, msg) - SVCXPRT *xprt; - struct rpc_msg *msg; +svcraw_reply (SVCXPRT *xprt, struct rpc_msg *msg) { - register struct svcraw_private *srp = svcraw_private; - register XDR *xdrs; - - if (srp == 0) - return (FALSE); - 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 */ - return (TRUE); + struct svcraw_private *srp = svcraw_private; + XDR *xdrs; + + if (srp == 0) + return FALSE; + 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 */ + return TRUE; } static bool_t -svcraw_getargs(xprt, xdr_args, args_ptr) - SVCXPRT *xprt; - xdrproc_t xdr_args; - caddr_t args_ptr; +svcraw_getargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr) { - register struct svcraw_private *srp = svcraw_private; + struct svcraw_private *srp = svcraw_private; - if (srp == 0) - return (FALSE); - return ((*xdr_args)(&srp->xdr_stream, args_ptr)); + if (srp == 0) + return FALSE; + 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; +svcraw_freeargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr) { - register struct svcraw_private *srp = svcraw_private; - register XDR *xdrs; - - if (srp == 0) - return (FALSE); - xdrs = &srp->xdr_stream; - xdrs->x_op = XDR_FREE; - return ((*xdr_args)(xdrs, args_ptr)); + struct svcraw_private *srp = svcraw_private; + XDR *xdrs; + + if (srp == 0) + return FALSE; + xdrs = &srp->xdr_stream; + xdrs->x_op = XDR_FREE; + return (*xdr_args) (xdrs, args_ptr); } static void -svcraw_destroy() +svcraw_destroy (SVCXPRT *xprt) { } diff --git a/sunrpc/svc_run.c b/sunrpc/svc_run.c index 45ea4008bc..0f59637fd1 100644 --- a/sunrpc/svc_run.c +++ b/sunrpc/svc_run.c @@ -36,39 +36,39 @@ static char sccsid[] = "@(#)svc_run.c 1.1 87/10/13 Copyr 1984 Sun Micro"; * This is the rpc server side idle loop * Wait for input, call server program. */ +#include <errno.h> #include <rpc/rpc.h> -#include <sys/errno.h> void -svc_run() +svc_run (void) { #ifdef FD_SETSIZE - fd_set readfds; + fd_set readfds; #else - int readfds; + int readfds; #endif /* def FD_SETSIZE */ -#ifndef errno - extern int errno; -#endif - for (;;) { + for (;;) + { #ifdef FD_SETSIZE - readfds = svc_fdset; + readfds = svc_fdset; #else - readfds = svc_fds; + readfds = svc_fds; #endif /* def FD_SETSIZE */ - switch (select(_rpc_dtablesize(), &readfds, (int *)0, (int *)0, - (struct timeval *)0)) { - case -1: - if (errno == EINTR) { - continue; - } - perror("svc_run: - select failed"); - return; - case 0: - continue; - default: - svc_getreqset(&readfds); - } + switch (select (_rpc_dtablesize (), &readfds, (fd_set *)NULL, + (fd_set *)NULL, (struct timeval *) 0)) + { + case -1: + if (errno == EINTR) + { + continue; + } + perror (_("svc_run: - select failed")); + return; + case 0: + continue; + default: + svc_getreqset (&readfds); } + } } diff --git a/sunrpc/svc_simple.c b/sunrpc/svc_simple.c index 0a30c45b42..cc28f6a7e3 100644 --- a/sunrpc/svc_simple.c +++ b/sunrpc/svc_simple.c @@ -39,105 +39,117 @@ static char sccsid[] = "@(#)svc_simple.c 1.18 87/08/11 Copyr 1984 Sun Micro"; */ #include <stdio.h> +#include <string.h> #include <rpc/rpc.h> +#include <rpc/pmap_clnt.h> #include <sys/socket.h> #include <netdb.h> -static struct proglst { - char *(*p_progname)(); - int p_prognum; - int p_procnum; - xdrproc_t p_inproc, p_outproc; - struct proglst *p_nxt; -} *proglst; -static void universal(); +static struct proglst + { + char *(*p_progname) (char *); + int p_prognum; + int p_procnum; + xdrproc_t p_inproc, p_outproc; + struct proglst *p_nxt; + } + *proglst; + +static void universal (struct svc_req *rqstp, SVCXPRT *transp); static SVCXPRT *transp; -registerrpc(prognum, versnum, procnum, progname, inproc, outproc) - char *(*progname)(); - xdrproc_t inproc, outproc; +int +registerrpc (u_long prognum, u_long versnum, u_long procnum, + char *(*progname) (char *), xdrproc_t inproc, xdrproc_t outproc) { - struct proglst *pl; + struct proglst *pl; - if (procnum == NULLPROC) { - (void) fprintf(stderr, - _("can't reassign procedure number %d\n"), NULLPROC); - return (-1); - } - if (transp == 0) { - transp = svcudp_create(RPC_ANYSOCK); - if (transp == NULL) { - (void) fprintf(stderr, _("couldn't create an rpc server\n")); - 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); - return (-1); + if (procnum == NULLPROC) + { + (void) fprintf (stderr, + _("can't reassign procedure number %d\n"), NULLPROC); + return -1; + } + if (transp == 0) + { + transp = svcudp_create (RPC_ANYSOCK); + if (transp == NULL) + { + (void) fputs (_("couldn't create an rpc server\n"), stderr); + return -1; } - pl = (struct proglst *)malloc(sizeof(struct proglst)); - if (pl == NULL) { - (void) fprintf(stderr, _("registerrpc: out of memory\n")); - return (-1); - } - pl->p_progname = progname; - pl->p_prognum = prognum; - pl->p_procnum = procnum; - pl->p_inproc = inproc; - pl->p_outproc = outproc; - pl->p_nxt = proglst; - proglst = pl; - return (0); + } + (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)); + if (pl == NULL) + { + (void) fprintf (stderr, _("registerrpc: out of memory\n")); + return -1; + } + pl->p_progname = progname; + pl->p_prognum = prognum; + pl->p_procnum = procnum; + pl->p_inproc = inproc; + pl->p_outproc = outproc; + pl->p_nxt = proglst; + proglst = pl; + return 0; } static void -universal(rqstp, transp) - struct svc_req *rqstp; - SVCXPRT *transp; +universal (struct svc_req *rqstp, SVCXPRT *transp) { - int prog, proc; - char *outdata; - char xdrbuf[UDPMSGSIZE]; - struct proglst *pl; + int prog, proc; + char *outdata; + char xdrbuf[UDPMSGSIZE]; + struct proglst *pl; - /* - * enforce "procnum 0 is echo" convention - */ - if (rqstp->rq_proc == NULLPROC) { - if (svc_sendreply(transp, xdr_void, (char *)NULL) == FALSE) { - (void) fprintf(stderr, "xxx\n"); - exit(1); - } - return; + /* + * enforce "procnum 0 is echo" convention + */ + if (rqstp->rq_proc == NULLPROC) + { + if (svc_sendreply (transp, (xdrproc_t)xdr_void, (char *) NULL) == FALSE) + { + (void) fprintf (stderr, "xxx\n"); + exit (1); } - prog = rqstp->rq_prog; - proc = rqstp->rq_proc; - 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 ! */ - if (!svc_getargs(transp, pl->p_inproc, xdrbuf)) { - svcerr_decode(transp); - return; - } - 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); - exit(1); - } - /* free the decoded arguments */ - (void)svc_freeargs(transp, pl->p_inproc, xdrbuf); - return; - } - (void) fprintf(stderr, _("never registered prog %d\n"), prog); - exit(1); + return; + } + prog = rqstp->rq_prog; + proc = rqstp->rq_proc; + 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 ! */ + if (!svc_getargs (transp, pl->p_inproc, xdrbuf)) + { + svcerr_decode (transp); + return; + } + outdata = (*(pl->p_progname)) (xdrbuf); + if (outdata == NULL && pl->p_outproc != (xdrproc_t)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); + exit (1); + } + /* free the decoded arguments */ + (void) svc_freeargs (transp, pl->p_inproc, xdrbuf); + return; + } + (void) fprintf (stderr, _ ("never registered prog %d\n"), prog); + exit (1); } - diff --git a/sunrpc/svc_tcp.c b/sunrpc/svc_tcp.c index 278e16fc33..758b6ba6e4 100644 --- a/sunrpc/svc_tcp.c +++ b/sunrpc/svc_tcp.c @@ -42,66 +42,70 @@ static char sccsid[] = "@(#)svc_tcp.c 1.21 87/08/11 Copyr 1984 Sun Micro"; */ #include <stdio.h> +#include <unistd.h> +#include <string.h> #include <rpc/rpc.h> #include <sys/socket.h> #include <errno.h> -#define abort ((bool_t (*) ()) abort) -#ifndef errno -extern errno; -#endif +#include <stdlib.h> /* * 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 struct xp_ops svctcp_op = { - svctcp_recv, - svctcp_stat, - svctcp_getargs, - svctcp_reply, - svctcp_freeargs, - svctcp_destroy +static bool_t svctcp_recv (SVCXPRT *, struct rpc_msg *); +static enum xprt_stat svctcp_stat (SVCXPRT *); +static bool_t svctcp_getargs (SVCXPRT *, xdrproc_t, caddr_t); +static bool_t svctcp_reply (SVCXPRT *, struct rpc_msg *); +static bool_t svctcp_freeargs (SVCXPRT *, xdrproc_t, caddr_t); +static void svctcp_destroy (SVCXPRT *); + +static const struct xp_ops svctcp_op = +{ + svctcp_recv, + svctcp_stat, + svctcp_getargs, + svctcp_reply, + svctcp_freeargs, + svctcp_destroy }; /* * Ops vector for TCP/IP rendezvous handler */ -static bool_t rendezvous_request(); -static enum xprt_stat rendezvous_stat(); - -static struct xp_ops svctcp_rendezvous_op = { - rendezvous_request, - rendezvous_stat, - abort, - abort, - abort, - svctcp_destroy +static bool_t rendezvous_request (SVCXPRT *, struct rpc_msg *); +static enum xprt_stat rendezvous_stat (SVCXPRT *); + +static const struct xp_ops svctcp_rendezvous_op = +{ + rendezvous_request, + rendezvous_stat, + (bool_t (*) (SVCXPRT *, xdrproc_t, caddr_t)) abort, + (bool_t (*) (SVCXPRT *, struct rpc_msg *)) abort, + (bool_t (*) (SVCXPRT *, xdrproc_t, caddr_t)) abort, + svctcp_destroy }; -static int readtcp(), writetcp(); -static SVCXPRT *makefd_xprt(); +static int readtcp (char*, char *, int); +static int writetcp (char *, char *, int); +static SVCXPRT *makefd_xprt (int, u_int, u_int); -struct tcp_rendezvous { /* kept in xprt->xp_p1 */ - u_int sendsize; - u_int recvsize; -}; +struct tcp_rendezvous + { /* kept in xprt->xp_p1 */ + u_int sendsize; + u_int recvsize; + }; -struct tcp_conn { /* kept in xprt->xp_p1 */ - enum xprt_stat strm_stat; - u_long x_id; - XDR xdrs; - char verf_body[MAX_AUTH_BYTES]; -}; +struct tcp_conn + { /* kept in xprt->xp_p1 */ + enum xprt_stat strm_stat; + u_long x_id; + XDR xdrs; + char verf_body[MAX_AUTH_BYTES]; + }; /* * Usage: - * xprt = svctcp_create(sock, send_buf_size, recv_buf_size); + * xprt = svctcp_create(sock, send_buf_size, recv_buf_size); * * Creates, registers, and returns a (rpc) tcp based transporter. * Once *xprt is initialized, it is registered as a transporter @@ -120,57 +124,60 @@ struct tcp_conn { /* kept in xprt->xp_p1 */ * 0 => use the system default. */ SVCXPRT * -svctcp_create(sock, sendsize, recvsize) - register int sock; - u_int sendsize; - u_int recvsize; +svctcp_create (int sock, u_int sendsize, u_int recvsize) { - bool_t madesock = FALSE; - register SVCXPRT *xprt; - register struct tcp_rendezvous *r; - struct sockaddr_in addr; - int len = sizeof(struct sockaddr_in); - - if (sock == RPC_ANYSOCK) { - if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { - perror(_("svctcp_.c - udp socket creation problem")); - return ((SVCXPRT *)NULL); - } - madesock = TRUE; - } - 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); - } - 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); - } - 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)); - if (xprt == NULL) { - (void) fprintf(stderr, _("svctcp_create: out of memory\n")); - return (NULL); + bool_t madesock = FALSE; + SVCXPRT *xprt; + struct tcp_rendezvous *r; + struct sockaddr_in addr; + int len = sizeof (struct sockaddr_in); + + if (sock == RPC_ANYSOCK) + { + if ((sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) + { + perror (_("svctcp_.c - udp socket creation problem")); + return (SVCXPRT *) NULL; } - xprt->xp_p2 = NULL; - xprt->xp_p1 = (caddr_t)r; - xprt->xp_verf = _null_auth; - xprt->xp_ops = &svctcp_rendezvous_op; - xprt->xp_port = ntohs(addr.sin_port); - xprt->xp_sock = sock; - xprt_register(xprt); - return (xprt); + madesock = TRUE; + } + 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); + } + 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; + } + r = (struct tcp_rendezvous *) mem_alloc (sizeof (*r)); + if (r == NULL) + { + (void) fputs (_("svctcp_create: out of memory\n"), stderr); + return NULL; + } + r->sendsize = sendsize; + r->recvsize = recvsize; + xprt = (SVCXPRT *) mem_alloc (sizeof (SVCXPRT)); + if (xprt == NULL) + { + (void) fputs (_("svctcp_create: out of memory\n"), stderr); + return NULL; + } + xprt->xp_p2 = NULL; + xprt->xp_p1 = (caddr_t) r; + xprt->xp_verf = _null_auth; + xprt->xp_ops = &svctcp_rendezvous_op; + xprt->xp_port = ntohs (addr.sin_port); + xprt->xp_sock = sock; + xprt_register (xprt); + return xprt; } /* @@ -178,109 +185,106 @@ svctcp_create(sock, sendsize, recvsize) * descriptor as its first input. */ SVCXPRT * -svcfd_create(fd, sendsize, recvsize) - int fd; - u_int sendsize; - u_int recvsize; +svcfd_create (int fd, u_int sendsize, u_int recvsize) { - - return (makefd_xprt(fd, sendsize, recvsize)); + return makefd_xprt (fd, sendsize, recvsize); } static SVCXPRT * -makefd_xprt(fd, sendsize, recvsize) - int fd; - u_int sendsize; - u_int recvsize; +makefd_xprt (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) { - (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) { - (void) fprintf(stderr, _("svc_tcp: makefd_xprt: out of memory\n")); - mem_free((char *) xprt, sizeof(SVCXPRT)); - xprt = (SVCXPRT *)NULL; - goto done; - } - cd->strm_stat = XPRT_IDLE; - xdrrec_create(&(cd->xdrs), sendsize, recvsize, - (caddr_t)xprt, readtcp, writetcp); - xprt->xp_p2 = NULL; - xprt->xp_p1 = (caddr_t)cd; - xprt->xp_verf.oa_base = cd->verf_body; - xprt->xp_addrlen = 0; - xprt->xp_ops = &svctcp_op; /* truly deals with calls */ - xprt->xp_port = 0; /* this is a connection, not a rendezvouser */ - xprt->xp_sock = fd; - xprt_register(xprt); - done: - return (xprt); + SVCXPRT *xprt; + struct tcp_conn *cd; + + xprt = (SVCXPRT *) mem_alloc (sizeof (SVCXPRT)); + if (xprt == (SVCXPRT *) NULL) + { + (void) fputs (_("svc_tcp: makefd_xprt: out of memory\n"), stderr); + goto done; + } + cd = (struct tcp_conn *) mem_alloc (sizeof (struct tcp_conn)); + if (cd == (struct tcp_conn *) NULL) + { + (void) fputs (_("svc_tcp: makefd_xprt: out of memory\n"), stderr); + mem_free ((char *) xprt, sizeof (SVCXPRT)); + xprt = (SVCXPRT *) NULL; + goto done; + } + cd->strm_stat = XPRT_IDLE; + xdrrec_create (&(cd->xdrs), sendsize, recvsize, + (caddr_t) xprt, readtcp, writetcp); + xprt->xp_p2 = NULL; + xprt->xp_p1 = (caddr_t) cd; + xprt->xp_verf.oa_base = cd->verf_body; + xprt->xp_addrlen = 0; + xprt->xp_ops = &svctcp_op; /* truly deals with calls */ + xprt->xp_port = 0; /* this is a connection, not a rendezvouser */ + xprt->xp_sock = fd; + xprt_register (xprt); +done: + return xprt; } static bool_t -rendezvous_request(xprt) - register SVCXPRT *xprt; +rendezvous_request (SVCXPRT *xprt, struct rpc_msg *errmsg) { - int sock; - struct tcp_rendezvous *r; - struct sockaddr_in addr; - int len; - - 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 (errno == EINTR) - goto again; - return (FALSE); - } - /* - * make a new transporter (re-uses 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 */ + int sock; + struct tcp_rendezvous *r; + struct sockaddr_in addr; + int len; + + 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 (errno == EINTR) + goto again; + return FALSE; + } + /* + * make a new transporter (re-uses 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 */ } static enum xprt_stat -rendezvous_stat() +rendezvous_stat (SVCXPRT *xprt) { - - return (XPRT_IDLE); + return XPRT_IDLE; } static void -svctcp_destroy(xprt) - register SVCXPRT *xprt; +svctcp_destroy (SVCXPRT *xprt) { - register struct tcp_conn *cd = (struct tcp_conn *)xprt->xp_p1; - - xprt_unregister(xprt); - (void)close(xprt->xp_sock); - if (xprt->xp_port != 0) { - /* a rendezvouser socket */ - xprt->xp_port = 0; - } else { - /* an actual connection socket */ - XDR_DESTROY(&(cd->xdrs)); - } - mem_free((caddr_t)cd, sizeof(struct tcp_conn)); - mem_free((caddr_t)xprt, sizeof(SVCXPRT)); + struct tcp_conn *cd = (struct tcp_conn *) xprt->xp_p1; + + xprt_unregister (xprt); + (void) close (xprt->xp_sock); + if (xprt->xp_port != 0) + { + /* a rendezvouser socket */ + xprt->xp_port = 0; + } + else + { + /* an actual connection socket */ + XDR_DESTROY (&(cd->xdrs)); + } + mem_free ((caddr_t) cd, sizeof (struct tcp_conn)); + mem_free ((caddr_t) xprt, sizeof (SVCXPRT)); } /* * All read operations timeout after 35 seconds. * A timeout is fatal for the connection. */ -static struct timeval wait_per_try = { 35, 0 }; +static struct timeval wait_per_try = +{35, 0}; /* * reads data from the tcp connection. @@ -288,43 +292,47 @@ static struct timeval wait_per_try = { 35, 0 }; * (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; +readtcp (char *xprtptr, char *buf, int len) { - register int sock = xprt->xp_sock; + SVCXPRT *xprt = (SVCXPRT *)xprtptr; + int sock = xprt->xp_sock; #ifdef FD_SETSIZE - fd_set mask; - fd_set readfds; + fd_set mask; + fd_set readfds; - FD_ZERO(&mask); - FD_SET(sock, &mask); + FD_ZERO (&mask); + FD_SET (sock, &mask); #else - register int mask = 1 << sock; - int readfds; + int mask = 1 << sock; + int readfds; #endif /* def FD_SETSIZE */ - do { - struct timeval timeout = wait_per_try; - readfds = mask; - if (select(_rpc_dtablesize(), &readfds, (int*)NULL, (int*)NULL, - &timeout) <= 0) { - if (errno == EINTR) { - continue; - } - goto fatal_err; - } + do + { + struct timeval timeout = wait_per_try; + readfds = mask; + if (select (_rpc_dtablesize (), &readfds, (fd_set *) NULL, + (fd_set *) NULL, &timeout) <= 0) + { + if (errno == EINTR) + { + continue; + } + goto fatal_err; + } #ifdef FD_SETSIZE - } while (!FD_ISSET(sock, &readfds)); + } + while (!FD_ISSET (sock, &readfds)); #else - } while (readfds != mask); + } + while (readfds != mask); #endif /* def FD_SETSIZE */ - if ((len = read(sock, buf, len)) > 0) { - return (len); - } + if ((len = read (sock, buf, len)) > 0) + { + return len; + } fatal_err: - ((struct tcp_conn *)(xprt->xp_p1))->strm_stat = XPRT_DIED; - return (-1); + ((struct tcp_conn *) (xprt->xp_p1))->strm_stat = XPRT_DIED; + return -1; } /* @@ -332,91 +340,91 @@ fatal_err: * Any error is fatal and the connection is closed. */ static int -writetcp(xprt, buf, len) - register SVCXPRT *xprt; - caddr_t buf; - int len; +writetcp (char *xprtptr, char * 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; - return (-1); - } + SVCXPRT *xprt = (SVCXPRT *)xprtptr; + 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; + return (-1); } - return (len); + } + return (len); } static enum xprt_stat -svctcp_stat(xprt) - SVCXPRT *xprt; +svctcp_stat (SVCXPRT *xprt) { - 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))) - return (XPRT_MOREREQS); - return (XPRT_IDLE); + struct tcp_conn *cd = + (struct tcp_conn *) (xprt->xp_p1); + + if (cd->strm_stat == XPRT_DIED) + return (XPRT_DIED); + 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; +svctcp_recv (xprt, msg) + SVCXPRT *xprt; + struct rpc_msg *msg; { - 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); - if (xdr_callmsg(xdrs, msg)) { - cd->x_id = msg->rm_xid; - return (TRUE); - } - return (FALSE); + struct tcp_conn *cd = + (struct tcp_conn *) (xprt->xp_p1); + XDR *xdrs = &(cd->xdrs); + + xdrs->x_op = XDR_DECODE; + (void) xdrrec_skiprecord (xdrs); + if (xdr_callmsg (xdrs, msg)) + { + cd->x_id = msg->rm_xid; + return (TRUE); + } + return (FALSE); } static bool_t -svctcp_getargs(xprt, xdr_args, args_ptr) - SVCXPRT *xprt; - xdrproc_t xdr_args; - caddr_t args_ptr; +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; +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); + XDR *xdrs = + &(((struct tcp_conn *) (xprt->xp_p1))->xdrs); - xdrs->x_op = XDR_FREE; - return ((*xdr_args)(xdrs, args_ptr)); + xdrs->x_op = XDR_FREE; + return ((*xdr_args) (xdrs, args_ptr)); } static bool_t -svctcp_reply(xprt, msg) - SVCXPRT *xprt; - register struct rpc_msg *msg; +svctcp_reply (xprt, msg) + SVCXPRT *xprt; + struct rpc_msg *msg; { - 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); - return (stat); + struct tcp_conn *cd = + (struct tcp_conn *) (xprt->xp_p1); + XDR *xdrs = &(cd->xdrs); + bool_t stat; + + xdrs->x_op = XDR_ENCODE; + msg->rm_xid = cd->x_id; + stat = xdr_replymsg (xdrs, msg); + (void) xdrrec_endofrecord (xdrs, TRUE); + return (stat); } diff --git a/sunrpc/svc_udp.c b/sunrpc/svc_udp.c index c9efc97024..8ae18a9147 100644 --- a/sunrpc/svc_udp.c +++ b/sunrpc/svc_udp.c @@ -40,6 +40,8 @@ static char sccsid[] = "@(#)svc_udp.c 1.24 87/08/11 Copyr 1984 Sun Micro"; */ #include <stdio.h> +#include <unistd.h> +#include <string.h> #include <rpc/rpc.h> #include <sys/socket.h> #include <errno.h> @@ -47,44 +49,46 @@ static char sccsid[] = "@(#)svc_udp.c 1.24 87/08/11 Copyr 1984 Sun Micro"; #define rpc_buffer(xprt) ((xprt)->xp_p1) #ifndef MAX -# define MAX(a, b) ((a > b) ? a : b) +#define MAX(a, b) ((a > b) ? a : b) #endif -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, - svcudp_stat, - svcudp_getargs, - svcudp_reply, - svcudp_freeargs, - svcudp_destroy +static bool_t svcudp_recv (SVCXPRT *, struct rpc_msg *); +static bool_t svcudp_reply (SVCXPRT *, struct rpc_msg *); +static enum xprt_stat svcudp_stat (SVCXPRT *); +static bool_t svcudp_getargs (SVCXPRT *, xdrproc_t, caddr_t); +static bool_t svcudp_freeargs (SVCXPRT *, xdrproc_t, caddr_t); +static void svcudp_destroy (SVCXPRT *); + +static const struct xp_ops svcudp_op = +{ + svcudp_recv, + svcudp_stat, + svcudp_getargs, + svcudp_reply, + svcudp_freeargs, + svcudp_destroy }; -#ifndef errno -extern int errno; -#endif +static int cache_get (SVCXPRT *, struct rpc_msg *, char **replyp, + u_long *replylenp); +static void cache_set (SVCXPRT *xprt, u_long replylen); /* * 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 */ -}; +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 */ + }; #define su_data(xprt) ((struct svcudp_data *)(xprt->xp_p2)) /* * Usage: - * xprt = svcudp_create(sock); + * xprt = svcudp_create(sock); * * If sock<0 then a socket is created, else sock is used. * If the socket, sock is not bound to a port then svcudp_create @@ -96,173 +100,184 @@ struct svcudp_data { * The routines returns NULL if a problem occurred. */ SVCXPRT * -svcudp_bufcreate(sock, sendsz, recvsz) - register int sock; - u_int sendsz, recvsz; +svcudp_bufcreate (sock, sendsz, recvsz) + int sock; + u_int sendsz, recvsz; { - bool_t madesock = FALSE; - register SVCXPRT *xprt; - register struct svcudp_data *su; - struct sockaddr_in addr; - int len = sizeof(struct sockaddr_in); - - if (sock == RPC_ANYSOCK) { - if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { - perror(_("svcudp_create: socket creation problem")); - return ((SVCXPRT *)NULL); - } - madesock = TRUE; - } - 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); + bool_t madesock = FALSE; + SVCXPRT *xprt; + struct svcudp_data *su; + struct sockaddr_in addr; + int len = sizeof (struct sockaddr_in); + + if (sock == RPC_ANYSOCK) + { + if ((sock = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) + { + perror (_("svcudp_create: socket creation problem")); + return (SVCXPRT *) NULL; } - if (getsockname(sock, (struct sockaddr *)&addr, &len) != 0) { - perror(_("svcudp_create - cannot getsockname")); - if (madesock) - (void)close(sock); - return ((SVCXPRT *)NULL); - } - xprt = (SVCXPRT *)mem_alloc(sizeof(SVCXPRT)); - if (xprt == NULL) { - (void)fprintf(stderr, "svcudp_create: out of memory\n"); - return (NULL); - } - su = (struct svcudp_data *)mem_alloc(sizeof(*su)); - if (su == NULL) { - (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"); - return (NULL); - } - 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_verf.oa_base = su->su_verfbody; - xprt->xp_ops = &svcudp_op; - xprt->xp_port = ntohs(addr.sin_port); - xprt->xp_sock = sock; - xprt_register(xprt); - return (xprt); + madesock = TRUE; + } + 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); + } + if (getsockname (sock, (struct sockaddr *) &addr, &len) != 0) + { + perror (_("svcudp_create - cannot getsockname")); + if (madesock) + (void) close (sock); + return (SVCXPRT *) NULL; + } + xprt = (SVCXPRT *) mem_alloc (sizeof (SVCXPRT)); + if (xprt == NULL) + { + (void) fputs (_("svcudp_create: out of memory\n"), stderr); + return NULL; + } + su = (struct svcudp_data *) mem_alloc (sizeof (*su)); + if (su == NULL) + { + (void) fputs (_("svcudp_create: out of memory\n"), stderr); + return NULL; + } + su->su_iosz = ((MAX (sendsz, recvsz) + 3) / 4) * 4; + if ((rpc_buffer (xprt) = mem_alloc (su->su_iosz)) == NULL) + { + (void) fputs (_("svcudp_create: out of memory\n"), stderr); + return NULL; + } + 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_verf.oa_base = su->su_verfbody; + xprt->xp_ops = &svcudp_op; + xprt->xp_port = ntohs (addr.sin_port); + xprt->xp_sock = sock; + xprt_register (xprt); + return xprt; } SVCXPRT * -svcudp_create(sock) - int sock; +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; +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; +svcudp_recv (xprt, msg) + SVCXPRT *xprt; + struct rpc_msg *msg; { - register struct svcudp_data *su = su_data(xprt); - register XDR *xdrs = &(su->su_xdrs); - register int rlen; - char *reply; - u_long replylen; - - 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)); - if (rlen == -1 && errno == EINTR) - goto again; - if (rlen < 16) /* < 4 32-bit ints? */ - return (FALSE); - xdrs->x_op = XDR_DECODE; - XDR_SETPOS(xdrs, 0); - 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); - return (TRUE); - } + struct svcudp_data *su = su_data (xprt); + XDR *xdrs = &(su->su_xdrs); + int rlen; + char *reply; + u_long replylen; + +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)); + if (rlen == -1 && errno == EINTR) + goto again; + if (rlen < 16) /* < 4 32-bit ints? */ + return FALSE; + xdrs->x_op = XDR_DECODE; + XDR_SETPOS (xdrs, 0); + 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); + return TRUE; } - return (TRUE); + } + return TRUE; } static bool_t -svcudp_reply(xprt, msg) - register SVCXPRT *xprt; - struct rpc_msg *msg; +svcudp_reply (xprt, msg) + SVCXPRT *xprt; + struct rpc_msg *msg; { - register struct svcudp_data *su = su_data(xprt); - register XDR *xdrs = &(su->su_xdrs); - register int slen; - register bool_t stat = FALSE; - - xdrs->x_op = XDR_ENCODE; - XDR_SETPOS(xdrs, 0); - msg->rm_xid = su->su_xid; - if (xdr_replymsg(xdrs, msg)) { - slen = (int)XDR_GETPOS(xdrs); - if (sendto(xprt->xp_sock, rpc_buffer(xprt), slen, 0, - (struct sockaddr *)&(xprt->xp_raddr), xprt->xp_addrlen) - == slen) { - stat = TRUE; - if (su->su_cache && slen >= 0) { - cache_set(xprt, (u_long) slen); - } - } + struct svcudp_data *su = su_data (xprt); + XDR *xdrs = &(su->su_xdrs); + int slen; + bool_t stat = FALSE; + + xdrs->x_op = XDR_ENCODE; + XDR_SETPOS (xdrs, 0); + msg->rm_xid = su->su_xid; + if (xdr_replymsg (xdrs, msg)) + { + slen = (int) XDR_GETPOS (xdrs); + if (sendto (xprt->xp_sock, rpc_buffer (xprt), slen, 0, + (struct sockaddr *) &(xprt->xp_raddr), xprt->xp_addrlen) + == slen) + { + stat = TRUE; + if (su->su_cache && slen >= 0) + { + cache_set (xprt, (u_long) slen); + } } - return (stat); + } + return stat; } static bool_t -svcudp_getargs(xprt, xdr_args, args_ptr) - SVCXPRT *xprt; - xdrproc_t xdr_args; - caddr_t args_ptr; +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; +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); + XDR *xdrs = &(su_data (xprt)->su_xdrs); - xdrs->x_op = XDR_FREE; - return ((*xdr_args)(xdrs, args_ptr)); + xdrs->x_op = XDR_FREE; + return (*xdr_args) (xdrs, args_ptr); } static void -svcudp_destroy(xprt) - register SVCXPRT *xprt; +svcudp_destroy (xprt) + SVCXPRT *xprt; { - register struct svcudp_data *su = su_data(xprt); - - xprt_unregister(xprt); - (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)); + struct svcudp_data *su = su_data (xprt); + + xprt_unregister (xprt); + (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)); } @@ -274,7 +289,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) @@ -289,41 +304,43 @@ svcudp_destroy(xprt) * An entry in the cache */ typedef struct cache_node *cache_ptr; -struct cache_node { - /* - * Index into cache is xid, proc, vers, prog and address - */ - u_long cache_xid; - u_long cache_proc; - u_long cache_vers; - u_long cache_prog; - struct sockaddr_in cache_addr; - /* - * The cached reply and length - */ - char * cache_reply; - u_long cache_replylen; - /* - * Next node on the list, if there is a collision - */ - cache_ptr cache_next; -}; +struct cache_node + { + /* + * Index into cache is xid, proc, vers, prog and address + */ + u_long cache_xid; + u_long cache_proc; + u_long cache_vers; + u_long cache_prog; + struct sockaddr_in cache_addr; + /* + * The cached reply and length + */ + char *cache_reply; + u_long cache_replylen; + /* + * Next node on the list, if there is a collision + */ + cache_ptr cache_next; + }; /* * 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 */ -}; +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 */ + }; /* @@ -337,142 +354,151 @@ struct udp_cache { * Enable use of the cache. * Note: there is no disable. */ -svcudp_enablecache(transp, size) - SVCXPRT *transp; - u_long size; +int +svcudp_enablecache (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); - } - uc = ALLOC(struct udp_cache, 1); - if (uc == NULL) { - CACHE_PERROR(_("enablecache: could not allocate cache")); - 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); - } - 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); - } - BZERO(uc->uc_fifo, cache_ptr, size); - su->su_cache = (char *) uc; - return(1); + struct svcudp_data *su = su_data (transp); + struct udp_cache *uc; + + if (su->su_cache != NULL) + { + CACHE_PERROR (_("enablecache: cache already enabled")); + return 0; + } + uc = ALLOC (struct udp_cache, 1); + if (uc == NULL) + { + CACHE_PERROR (_("enablecache: could not allocate cache")); + 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; + } + 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; + } + BZERO (uc->uc_fifo, cache_ptr, size); + su->su_cache = (char *) uc; + return 1; } /* * Set an entry in the cache */ -static -cache_set(xprt, replylen) - SVCXPRT *xprt; - u_long replylen; +static void +cache_set (SVCXPRT *xprt, u_long replylen) { - 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; - u_int loc; - char *newbuf; - - /* - * 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) - ; - if (*vicp == NULL) { - CACHE_PERROR(_("cache_set: victim not found")); - return; - } - *vicp = victim->cache_next; /* remote from cache */ - newbuf = victim->cache_reply; - } else { - victim = ALLOC(struct cache_node, 1); - if (victim == NULL) { - CACHE_PERROR("cache_set: victim alloc failed"); - return; - } - newbuf = mem_alloc(su->su_iosz); - if (newbuf == NULL) { - CACHE_PERROR("cache_set: could not allocate new rpc_buffer"); - return; - } + cache_ptr victim; + cache_ptr *vicp; + struct svcudp_data *su = su_data (xprt); + struct udp_cache *uc = (struct udp_cache *) su->su_cache; + u_int loc; + char *newbuf; + + /* + * 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) + ; + if (*vicp == NULL) + { + CACHE_PERROR (_("cache_set: victim not found")); + return; } - - /* - * Store it away - */ - 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); - 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]; - uc->uc_entries[loc] = victim; - uc->uc_fifo[uc->uc_nextvictim++] = victim; - uc->uc_nextvictim %= uc->uc_size; + *vicp = victim->cache_next; /* remote from cache */ + newbuf = victim->cache_reply; + } + else + { + victim = ALLOC (struct cache_node, 1); + if (victim == NULL) + { + CACHE_PERROR (_("cache_set: victim alloc failed")); + return; + } + newbuf = mem_alloc (su->su_iosz); + if (newbuf == NULL) + { + CACHE_PERROR (_("cache_set: could not allocate new rpc_buffer")); + return; + } + } + + /* + * Store it away + */ + 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); + 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]; + uc->uc_entries[loc] = victim; + uc->uc_fifo[uc->uc_nextvictim++] = victim; + uc->uc_nextvictim %= uc->uc_size; } /* * 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 int +cache_get (xprt, msg, replyp, replylenp) + SVCXPRT *xprt; + struct rpc_msg *msg; + char **replyp; + u_long *replylenp; { - u_int loc; - register cache_ptr ent; - register struct svcudp_data *su = su_data(xprt); - register struct udp_cache *uc = (struct udp_cache *) su->su_cache; - -# define EQADDR(a1, a2) (bcmp((char*)&a1, (char*)&a2, sizeof(a1)) == 0) - - 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)) { - *replyp = ent->cache_reply; - *replylenp = ent->cache_replylen; - return(1); - } + u_int loc; + cache_ptr ent; + struct svcudp_data *su = su_data (xprt); + struct udp_cache *uc = (struct udp_cache *) su->su_cache; + +#define EQADDR(a1, a2) (bcmp((char*)&a1, (char*)&a2, sizeof(a1)) == 0) + + 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)) + { + *replyp = ent->cache_reply; + *replylenp = ent->cache_replylen; + return 1; } - /* - * Failed to find entry - * Remember a few things so we can do a set later - */ - uc->uc_proc = msg->rm_call.cb_proc; - uc->uc_vers = msg->rm_call.cb_vers; - uc->uc_prog = msg->rm_call.cb_prog; - uc->uc_addr = xprt->xp_raddr; - return(0); + } + /* + * Failed to find entry + * Remember a few things so we can do a set later + */ + uc->uc_proc = msg->rm_call.cb_proc; + uc->uc_vers = msg->rm_call.cb_vers; + uc->uc_prog = msg->rm_call.cb_prog; + uc->uc_addr = xprt->xp_raddr; + return 0; } diff --git a/sunrpc/xdr.c b/sunrpc/xdr.c index 969fa6ba04..d666119376 100644 --- a/sunrpc/xdr.c +++ b/sunrpc/xdr.c @@ -57,72 +57,72 @@ static char sccsid[] = "@(#)xdr.c 1.35 87/08/12"; /* * for unit alignment */ -static char xdr_zero[BYTES_PER_XDR_UNIT] = { 0, 0, 0, 0 }; +static const 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; +xdr_free (proc, objp) + xdrproc_t proc; + char *objp; { - XDR x; + XDR x; - x.x_op = XDR_FREE; - (*proc)(&x, objp); + x.x_op = XDR_FREE; + (*proc) (&x, objp); } /* * XDR nothing */ bool_t -xdr_void(/* xdrs, addr */) - /* XDR *xdrs; */ - /* caddr_t addr; */ +xdr_void (void) { - - return (TRUE); + return TRUE; } /* * XDR integers */ bool_t -xdr_int(xdrs, ip) - XDR *xdrs; - int *ip; +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 INT_MAX < LONG_MAX - long l; - - switch (xdrs->x_op) { - case XDR_ENCODE: - l = (long) *ip; - return XDR_PUTLONG(xdrs, &l); - - case XDR_DECODE: - if (!XDR_GETLONG(xdrs, &l)) { - return FALSE; - } - *ip = (int) l; - case XDR_FREE: - return TRUE; +#if INT_MAX < LONG_MAX + long l; + + switch (xdrs->x_op) + { + case XDR_ENCODE: + l = (long) *ip; + return XDR_PUTLONG (xdrs, &l); + + case XDR_DECODE: + if (!XDR_GETLONG (xdrs, &l)) + { + return FALSE; } - return FALSE; -# elif INT_MAX == LONG_MAX - return xdr_long(xdrs, (long *)ip); -# elif INT_MAX == SHRT_MAX - return xdr_short(xdrs, (short *)ip); -# else -# error unexpected integer sizes in_xdr_int() -# endif + *ip = (int) l; + case XDR_FREE: + return TRUE; + } + return FALSE; +#elif INT_MAX == LONG_MAX + return xdr_long (xdrs, (long *) ip); +#elif INT_MAX == SHRT_MAX + return xdr_short (xdrs, (short *) ip); +#else +#error unexpected integer sizes in_xdr_int() +#endif #endif } @@ -130,38 +130,40 @@ xdr_int(xdrs, ip) * XDR unsigned integers */ bool_t -xdr_u_int(xdrs, up) - XDR *xdrs; - u_int *up; +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 UINT_MAX < ULONG_MAX - u_long l; - - switch (xdrs->x_op) { - case XDR_ENCODE: - l = (u_long) *up; - return XDR_PUTLONG(xdrs, &l); - - case XDR_DECODE: - if (!XDR_GETLONG(xdrs, &l)) { - return FALSE; - } - *up = (u_int) l; - case XDR_FREE: - return TRUE; +#if UINT_MAX < ULONG_MAX + u_long l; + + switch (xdrs->x_op) + { + case XDR_ENCODE: + l = (u_long) * up; + return XDR_PUTLONG (xdrs, &l); + + case XDR_DECODE: + if (!XDR_GETLONG (xdrs, &l)) + { + return FALSE; } - return FALSE; -# elif UINT_MAX == ULONG_MAX - return xdr_u_long(xdrs, (u_long *)up); -# elif UINT_MAX == USHRT_MAX - return xdr_short(xdrs, (short *)up); -# else -# error unexpected integer sizes in_xdr_u_int() -# endif + *up = (u_int) l; + case XDR_FREE: + return TRUE; + } + return FALSE; +#elif UINT_MAX == ULONG_MAX + return xdr_u_long (xdrs, (u_long *) up); +#elif UINT_MAX == USHRT_MAX + return xdr_short (xdrs, (short *) up); +#else +#error unexpected integer sizes in_xdr_u_int() +#endif #endif } @@ -170,21 +172,21 @@ xdr_u_int(xdrs, up) * same as xdr_u_long - open coded to save a proc call! */ bool_t -xdr_long(xdrs, lp) - register XDR *xdrs; - long *lp; +xdr_long (xdrs, lp) + XDR *xdrs; + long *lp; { - if (xdrs->x_op == XDR_ENCODE) - return (XDR_PUTLONG(xdrs, lp)); + if (xdrs->x_op == XDR_ENCODE) + return XDR_PUTLONG (xdrs, lp); - if (xdrs->x_op == XDR_DECODE) - return (XDR_GETLONG(xdrs, lp)); + if (xdrs->x_op == XDR_DECODE) + return XDR_GETLONG (xdrs, lp); - if (xdrs->x_op == XDR_FREE) - return (TRUE); + if (xdrs->x_op == XDR_FREE) + return TRUE; - return (FALSE); + return FALSE; } /* @@ -192,77 +194,82 @@ xdr_long(xdrs, lp) * same as xdr_long - open coded to save a proc call! */ bool_t -xdr_u_long(xdrs, ulp) - register XDR *xdrs; - u_long *ulp; +xdr_u_long (xdrs, ulp) + XDR *xdrs; + u_long *ulp; { - switch (xdrs->x_op) { - case XDR_DECODE: - return XDR_GETLONG(xdrs, (long *)ulp); - - case XDR_ENCODE: - return XDR_PUTLONG(xdrs, (long *)ulp); - - case XDR_FREE: - return TRUE; - } - return FALSE; + switch (xdrs->x_op) + { + case XDR_DECODE: + return XDR_GETLONG (xdrs, (long *) ulp); + + case XDR_ENCODE: + return XDR_PUTLONG (xdrs, (long *) ulp); + + case XDR_FREE: + return TRUE; + } + return FALSE; } /* * XDR short integers */ bool_t -xdr_short(xdrs, sp) - register XDR *xdrs; - short *sp; +xdr_short (xdrs, sp) + XDR *xdrs; + short *sp; { - long l; - - switch (xdrs->x_op) { - case XDR_ENCODE: - l = (long) *sp; - return XDR_PUTLONG(xdrs, &l); - - case XDR_DECODE: - if (!XDR_GETLONG(xdrs, &l)) { - return FALSE; - } - *sp = (short) l; - return TRUE; - - case XDR_FREE: - return TRUE; + long l; + + switch (xdrs->x_op) + { + case XDR_ENCODE: + l = (long) *sp; + return XDR_PUTLONG (xdrs, &l); + + case XDR_DECODE: + if (!XDR_GETLONG (xdrs, &l)) + { + return FALSE; } - return FALSE; + *sp = (short) l; + return TRUE; + + case XDR_FREE: + return TRUE; + } + return FALSE; } /* * XDR unsigned short integers */ bool_t -xdr_u_short(xdrs, usp) - register XDR *xdrs; - u_short *usp; +xdr_u_short (xdrs, usp) + XDR *xdrs; + u_short *usp; { - u_long l; - - switch (xdrs->x_op) { - case XDR_ENCODE: - l = (u_long) *usp; - return XDR_PUTLONG(xdrs, &l); - - case XDR_DECODE: - if (!XDR_GETLONG(xdrs, &l)) { - return FALSE; - } - *usp = (u_short) l; - return TRUE; - - case XDR_FREE: - return TRUE; + u_long l; + + switch (xdrs->x_op) + { + case XDR_ENCODE: + l = (u_long) * usp; + return XDR_PUTLONG (xdrs, &l); + + case XDR_DECODE: + if (!XDR_GETLONG (xdrs, &l)) + { + return FALSE; } - return FALSE; + *usp = (u_short) l; + return TRUE; + + case XDR_FREE: + return TRUE; + } + return FALSE; } @@ -270,110 +277,124 @@ xdr_u_short(xdrs, usp) * XDR a char */ bool_t -xdr_char(xdrs, cp) - XDR *xdrs; - char *cp; +xdr_char (xdrs, cp) + XDR *xdrs; + char *cp; { - int i; - - i = (*cp); - if (!xdr_int(xdrs, &i)) { - return FALSE; - } - *cp = i; - return TRUE; + int i; + + i = (*cp); + if (!xdr_int (xdrs, &i)) + { + return FALSE; + } + *cp = i; + return TRUE; } /* * XDR an unsigned char */ bool_t -xdr_u_char(xdrs, cp) - XDR *xdrs; - u_char *cp; +xdr_u_char (xdrs, cp) + XDR *xdrs; + u_char *cp; { - u_int u; - - u = (*cp); - if (!xdr_u_int(xdrs, &u)) { - return FALSE; - } - *cp = u; - return TRUE; + u_int u; + + u = (*cp); + if (!xdr_u_int (xdrs, &u)) + { + return FALSE; + } + *cp = u; + return TRUE; } /* * XDR booleans */ bool_t -xdr_bool(xdrs, bp) - register XDR *xdrs; - bool_t *bp; +xdr_bool (xdrs, bp) + XDR *xdrs; + bool_t *bp; { - long lb; - - switch (xdrs->x_op) { - case XDR_ENCODE: - lb = *bp ? XDR_TRUE : XDR_FALSE; - return XDR_PUTLONG(xdrs, &lb); - - case XDR_DECODE: - if (!XDR_GETLONG(xdrs, &lb)) { - return FALSE; - } - *bp = (lb == XDR_FALSE) ? FALSE : TRUE; - return TRUE; - - case XDR_FREE: - return TRUE; + long lb; + + switch (xdrs->x_op) + { + case XDR_ENCODE: + lb = *bp ? XDR_TRUE : XDR_FALSE; + return XDR_PUTLONG (xdrs, &lb); + + case XDR_DECODE: + if (!XDR_GETLONG (xdrs, &lb)) + { + return FALSE; } - return FALSE; + *bp = (lb == XDR_FALSE) ? FALSE : TRUE; + return TRUE; + + case XDR_FREE: + return TRUE; + } + return FALSE; } /* * XDR enumerations */ bool_t -xdr_enum(xdrs, ep) - XDR *xdrs; - enum_t *ep; +xdr_enum (xdrs, ep) + XDR *xdrs; + enum_t *ep; { #ifndef lint - enum sizecheck { SIZEVAL }; /* used to find the size of an enum */ - - /* - * enums are treated as ints - */ - if (sizeof (enum sizecheck) == 4) { -# if INT_MAX < LONG_MAX - long l; - - switch (xdrs->x_op) { - case XDR_ENCODE: - l = *ep; - return XDR_PUTLONG(xdrs, &l); - - case XDR_DECODE: - if (!XDR_GETLONG(xdrs, &l)) { - return FALSE; - } - *ep = l; - case XDR_FREE: - return TRUE; - - } - return FALSE; -# else - return (xdr_long(xdrs, (long *)ep)); -# endif - } else if (sizeof (enum sizecheck) == sizeof (short)) { - return xdr_short(xdrs, (short *)ep); - } else { - return FALSE; + enum sizecheck + { + SIZEVAL + }; /* used to find the size of an enum */ + + /* + * enums are treated as ints + */ + if (sizeof (enum sizecheck) == 4) + { +#if INT_MAX < LONG_MAX + long l; + + switch (xdrs->x_op) + { + case XDR_ENCODE: + l = *ep; + return XDR_PUTLONG (xdrs, &l); + + case XDR_DECODE: + if (!XDR_GETLONG (xdrs, &l)) + { + return FALSE; + } + *ep = l; + case XDR_FREE: + return TRUE; + } + return FALSE; +#else + return xdr_long (xdrs, (long *) ep); +#endif + } + else if (sizeof (enum sizecheck) == sizeof (short)) + { + return xdr_short (xdrs, (short *) ep); + } + else + { + return FALSE; + } #else /* lint */ - (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 /* lint */ } @@ -383,48 +404,51 @@ xdr_enum(xdrs, ep) * 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; +xdr_opaque (xdrs, cp, cnt) + XDR *xdrs; + caddr_t cp; + u_int cnt; { - register u_int rndup; - static crud[BYTES_PER_XDR_UNIT]; - - /* - * if no data we are done - */ - if (cnt == 0) - return TRUE; - - /* - * round byte count to full xdr units - */ - rndup = cnt % BYTES_PER_XDR_UNIT; - if (rndup > 0) - rndup = BYTES_PER_XDR_UNIT - rndup; - - switch (xdrs->x_op) { - case XDR_DECODE: - if (!XDR_GETBYTES(xdrs, cp, cnt)) { - return FALSE; - } - if (rndup == 0) - return TRUE; - return XDR_GETBYTES(xdrs, crud, rndup); - - case XDR_ENCODE: - if (!XDR_PUTBYTES(xdrs, cp, cnt)) { - return FALSE; - } - if (rndup == 0) - return TRUE; - return XDR_PUTBYTES(xdrs, xdr_zero, rndup); - - case XDR_FREE: - return TRUE; + u_int rndup; + static char crud[BYTES_PER_XDR_UNIT]; + + /* + * if no data we are done + */ + if (cnt == 0) + return TRUE; + + /* + * round byte count to full xdr units + */ + rndup = cnt % BYTES_PER_XDR_UNIT; + if (rndup > 0) + rndup = BYTES_PER_XDR_UNIT - rndup; + + switch (xdrs->x_op) + { + case XDR_DECODE: + if (!XDR_GETBYTES (xdrs, cp, cnt)) + { + return FALSE; } - return FALSE; + if (rndup == 0) + return TRUE; + return XDR_GETBYTES (xdrs, (caddr_t)crud, rndup); + + case XDR_ENCODE: + if (!XDR_PUTBYTES (xdrs, cp, cnt)) + { + return FALSE; + } + if (rndup == 0) + return TRUE; + return XDR_PUTBYTES (xdrs, xdr_zero, rndup); + + case XDR_FREE: + return TRUE; + } + return FALSE; } /* @@ -433,66 +457,73 @@ xdr_opaque(xdrs, cp, cnt) * 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; +xdr_bytes (xdrs, cpp, sizep, maxsize) + XDR *xdrs; + char **cpp; + u_int *sizep; + u_int maxsize; { - 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)) { - return FALSE; + char *sp = *cpp; /* sp is the actual string pointer */ + u_int nodesize; + + /* + * first deal with the length since xdr bytes are counted + */ + if (!xdr_u_int (xdrs, sizep)) + { + return FALSE; + } + nodesize = *sizep; + if ((nodesize > maxsize) && (xdrs->x_op != XDR_FREE)) + { + return FALSE; + } + + /* + * now deal with the actual bytes + */ + switch (xdrs->x_op) + { + case XDR_DECODE: + if (nodesize == 0) + { + return TRUE; + } + if (sp == NULL) + { + *cpp = sp = (char *) mem_alloc (nodesize); } - nodesize = *sizep; - if ((nodesize > maxsize) && (xdrs->x_op != XDR_FREE)) { - return FALSE; + if (sp == NULL) + { + (void) fprintf (stderr, "xdr_bytes: out of memory\n"); + return FALSE; } + /* fall into ... */ - /* - * now deal with the actual bytes - */ - switch (xdrs->x_op) { - case XDR_DECODE: - if (nodesize == 0) { - return TRUE; - } - if (sp == NULL) { - *cpp = sp = (char *)mem_alloc(nodesize); - } - if (sp == NULL) { - (void) fprintf(stderr, "xdr_bytes: out of memory\n"); - return FALSE; - } - /* fall into ... */ - - case XDR_ENCODE: - return xdr_opaque(xdrs, sp, nodesize); - - case XDR_FREE: - if (sp != NULL) { - mem_free(sp, nodesize); - *cpp = NULL; - } - return TRUE; + case XDR_ENCODE: + return xdr_opaque (xdrs, sp, nodesize); + + case XDR_FREE: + if (sp != NULL) + { + mem_free (sp, nodesize); + *cpp = NULL; } - return FALSE; + return TRUE; + } + return FALSE; } /* * Implemented here due to commonality of the object. */ bool_t -xdr_netobj(xdrs, np) - XDR *xdrs; - struct netobj *np; +xdr_netobj (xdrs, np) + XDR *xdrs; + struct netobj *np; { - return xdr_bytes(xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ); + return xdr_bytes (xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ); } /* @@ -507,37 +538,39 @@ xdr_netobj(xdrs, np) * 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 */ +xdr_union (xdrs, dscmp, unp, choices, dfault) + XDR *xdrs; + enum_t *dscmp; /* enum to decide which arm to work on */ + char *unp; /* the union itself */ + const 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)) { - return FALSE; - } - dscm = *dscmp; - - /* - * search choices for a value that matches the discriminator. - * if we find one, execute the xdr routine for that value. - */ - for (; choices->proc != NULL_xdrproc_t; choices++) { - if (choices->value == dscm) - 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)); + enum_t dscm; + + /* + * we deal with the discriminator; it's an enum + */ + if (!xdr_enum (xdrs, dscmp)) + { + return FALSE; + } + dscm = *dscmp; + + /* + * search choices for a value that matches the discriminator. + * if we find one, execute the xdr routine for that value. + */ + for (; choices->proc != NULL_xdrproc_t; choices++) + { + if (choices->value == dscm) + 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)); } @@ -556,64 +589,73 @@ xdr_union(xdrs, dscmp, unp, choices, dfault) * of the string as specified by a protocol. */ bool_t -xdr_string(xdrs, cpp, maxsize) - register XDR *xdrs; - char **cpp; - u_int maxsize; +xdr_string (xdrs, cpp, maxsize) + XDR *xdrs; + char **cpp; + u_int maxsize; { - register char *sp = *cpp; /* sp is the actual string pointer */ - u_int size; - u_int nodesize; - - /* - * first deal with the length since xdr strings are counted-strings - */ - switch (xdrs->x_op) { - case XDR_FREE: - if (sp == NULL) { - return TRUE; /* already free */ - } - /* fall through... */ - case XDR_ENCODE: - if (sp == NULL) - return FALSE; - size = strlen(sp); - break; + char *sp = *cpp; /* sp is the actual string pointer */ + u_int size; + u_int nodesize; + + /* + * first deal with the length since xdr strings are counted-strings + */ + switch (xdrs->x_op) + { + case XDR_FREE: + if (sp == NULL) + { + return TRUE; /* already free */ } - if (! xdr_u_int(xdrs, &size)) { - return FALSE; - } - if (size > maxsize) { - return FALSE; + /* fall through... */ + case XDR_ENCODE: + if (sp == NULL) + return FALSE; + size = strlen (sp); + break; + case XDR_DECODE: + break; + } + if (!xdr_u_int (xdrs, &size)) + { + return FALSE; + } + if (size > maxsize) + { + return FALSE; + } + nodesize = size + 1; + + /* + * now deal with the actual bytes + */ + switch (xdrs->x_op) + { + case XDR_DECODE: + if (nodesize == 0) + { + return TRUE; } - nodesize = size + 1; - - /* - * now deal with the actual bytes - */ - switch (xdrs->x_op) { - case XDR_DECODE: - if (nodesize == 0) { - return TRUE; - } - if (sp == NULL) - *cpp = sp = (char *)mem_alloc(nodesize); - if (sp == NULL) { - (void) fprintf(stderr, "xdr_string: out of memory\n"); - return FALSE; - } - sp[size] = 0; - /* fall into ... */ - - case XDR_ENCODE: - return xdr_opaque(xdrs, sp, size); - - case XDR_FREE: - mem_free(sp, nodesize); - *cpp = NULL; - return TRUE; + if (sp == NULL) + *cpp = sp = (char *) mem_alloc (nodesize); + if (sp == NULL) + { + (void) fprintf (stderr, "xdr_string: out of memory\n"); + return FALSE; } - return FALSE; + sp[size] = 0; + /* fall into ... */ + + case XDR_ENCODE: + return xdr_opaque (xdrs, sp, size); + + case XDR_FREE: + mem_free (sp, nodesize); + *cpp = NULL; + return TRUE; + } + return FALSE; } /* @@ -621,12 +663,13 @@ xdr_string(xdrs, cpp, maxsize) * routines like clnt_call */ bool_t -xdr_wrapstring(xdrs, cpp) - XDR *xdrs; - char **cpp; +xdr_wrapstring (xdrs, cpp) + XDR *xdrs; + char **cpp; { - if (xdr_string(xdrs, cpp, LASTUNSIGNED)) { - return TRUE; - } - return FALSE; + if (xdr_string (xdrs, cpp, LASTUNSIGNED)) + { + return TRUE; + } + return FALSE; } diff --git a/sunrpc/xdr_array.c b/sunrpc/xdr_array.c index 6b2adb2331..a58fade734 100644 --- a/sunrpc/xdr_array.c +++ b/sunrpc/xdr_array.c @@ -41,7 +41,7 @@ static char sccsid[] = "@(#)xdr_array.c 1.10 87/08/11 Copyr 1984 Sun Micro"; */ #include <stdio.h> - +#include <string.h> #include <rpc/types.h> #include <rpc/xdr.h> @@ -56,68 +56,76 @@ static char sccsid[] = "@(#)xdr_array.c 1.10 87/08/11 Copyr 1984 Sun Micro"; * 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 */ +xdr_array (xdrs, addrp, sizep, maxsize, elsize, elproc) + 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 bool_t stat = TRUE; - register u_int nodesize; + u_int i; + caddr_t target = *addrp; + u_int c; /* the actual element count */ + bool_t stat = TRUE; + u_int nodesize; - /* like strings, arrays are really counted arrays */ - if (! xdr_u_int(xdrs, sizep)) { - return (FALSE); - } - c = *sizep; - if ((c > maxsize) && (xdrs->x_op != XDR_FREE)) { - return (FALSE); - } - nodesize = c * elsize; + /* like strings, arrays are really counted arrays */ + if (!xdr_u_int (xdrs, sizep)) + { + return FALSE; + } + c = *sizep; + if ((c > maxsize) && (xdrs->x_op != XDR_FREE)) + { + return FALSE; + } + nodesize = c * elsize; - /* - * if we are deserializing, we may need to allocate an array. - * We also save time by checking for a null array if we are freeing. - */ + /* + * if we are deserializing, we may need to allocate an array. + * We also save time by checking for a null array if we are freeing. + */ + if (target == NULL) + switch (xdrs->x_op) + { + case XDR_DECODE: + if (c == 0) + return TRUE; + *addrp = target = mem_alloc (nodesize); if (target == NULL) - switch (xdrs->x_op) { - case XDR_DECODE: - if (c == 0) - return (TRUE); - *addrp = target = mem_alloc(nodesize); - if (target == NULL) { - (void) fprintf(stderr, - "xdr_array: out of memory\n"); - return (FALSE); - } - bzero(target, nodesize); - break; + { + (void) fprintf (stderr, + "xdr_array: out of memory\n"); + return FALSE; + } + bzero (target, nodesize); + break; - case XDR_FREE: - return (TRUE); - } + case XDR_FREE: + return TRUE; + default: + break; + } - /* - * now we xdr each element of array - */ - for (i = 0; (i < c) && stat; i++) { - stat = (*elproc)(xdrs, target, LASTUNSIGNED); - target += elsize; - } + /* + * now we xdr each element of array + */ + for (i = 0; (i < c) && stat; i++) + { + stat = (*elproc) (xdrs, target, LASTUNSIGNED); + target += elsize; + } - /* - * the array may need freeing - */ - if (xdrs->x_op == XDR_FREE) { - mem_free(*addrp, nodesize); - *addrp = NULL; - } - return (stat); + /* + * the array may need freeing + */ + if (xdrs->x_op == XDR_FREE) + { + mem_free (*addrp, nodesize); + *addrp = NULL; + } + return stat; } /* @@ -131,22 +139,24 @@ xdr_array(xdrs, addrp, sizep, maxsize, elsize, elproc) * > 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; +xdr_vector (xdrs, basep, nelem, elemsize, xdr_elem) + XDR *xdrs; + char *basep; + u_int nelem; + u_int elemsize; + xdrproc_t xdr_elem; { - register u_int i; - register char *elptr; + u_int i; + char *elptr; - elptr = basep; - for (i = 0; i < nelem; i++) { - if (! (*xdr_elem)(xdrs, elptr, LASTUNSIGNED)) { - return(FALSE); - } - elptr += elemsize; + elptr = basep; + for (i = 0; i < nelem; i++) + { + if (!(*xdr_elem) (xdrs, elptr, LASTUNSIGNED)) + { + return FALSE; } - return(TRUE); + elptr += elemsize; + } + return TRUE; } diff --git a/sunrpc/xdr_mem.c b/sunrpc/xdr_mem.c index d6241e7f7d..481a8664b5 100644 --- a/sunrpc/xdr_mem.c +++ b/sunrpc/xdr_mem.c @@ -6,23 +6,23 @@ * may copy or modify Sun RPC without charge, but are not authorized * to license or distribute it to anyone else except as part of a product or * program developed by the user. - * + * * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. - * + * * Sun RPC is provided with no support and without any obligation on the * part of Sun Microsystems, Inc. to assist in its use, correction, * modification or enhancement. - * + * * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC * OR ANY PART THEREOF. - * + * * In no event will Sun Microsystems, Inc. be liable for any lost revenue * or profits or other special, indirect and consequential damages, even if * Sun has been advised of the possibility of such damages. - * + * * Sun Microsystems, Inc. * 2550 Garcia Avenue * Mountain View, California 94043 @@ -43,142 +43,142 @@ static char sccsid[] = "@(#)xdr_mem.c 1.19 87/08/11 Copyr 1984 Sun Micro"; */ -#include <rpc/types.h> -#include <rpc/xdr.h> -#include <netinet/in.h> - -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, - xdrmem_putbytes, - xdrmem_getpos, - xdrmem_setpos, - xdrmem_inline, - xdrmem_destroy +#include <string.h> +#include <rpc/rpc.h> + +static bool_t xdrmem_getlong (XDR *, long *); +static bool_t xdrmem_putlong (XDR *, long *); +static bool_t xdrmem_getbytes (XDR *, caddr_t, u_int); +static bool_t xdrmem_putbytes (XDR *, caddr_t, u_int); +static u_int xdrmem_getpos (XDR *); +static bool_t xdrmem_setpos (XDR *, u_int); +static long *xdrmem_inline (XDR *, int); +static void xdrmem_destroy (XDR *); + +static const struct xdr_ops xdrmem_ops = +{ + xdrmem_getlong, + xdrmem_putlong, + xdrmem_getbytes, + xdrmem_putbytes, + xdrmem_getpos, + xdrmem_setpos, + xdrmem_inline, + xdrmem_destroy }; /* * The procedure xdrmem_create initializes a stream descriptor for a - * memory buffer. + * memory buffer. */ void -xdrmem_create(xdrs, addr, size, op) - register XDR *xdrs; - caddr_t addr; - u_int size; - enum xdr_op op; +xdrmem_create (xdrs, addr, size, op) + XDR *xdrs; + caddr_t addr; + u_int size; + enum xdr_op op; { - xdrs->x_op = op; - xdrs->x_ops = &xdrmem_ops; - xdrs->x_private = xdrs->x_base = addr; - xdrs->x_handy = size; + xdrs->x_op = op; + xdrs->x_ops = &xdrmem_ops; + xdrs->x_private = xdrs->x_base = addr; + xdrs->x_handy = size; } static void -xdrmem_destroy(/*xdrs*/) - /*XDR *xdrs;*/ +xdrmem_destroy (XDR *xdrs) { } static bool_t -xdrmem_getlong(xdrs, lp) - register XDR *xdrs; - long *lp; +xdrmem_getlong (xdrs, lp) + XDR *xdrs; + long *lp; { - if ((xdrs->x_handy -= 4) < 0) - return (FALSE); - *lp = (int32_t) ntohl((*((int32_t *)(xdrs->x_private)))); - xdrs->x_private += 4; - return (TRUE); + if ((xdrs->x_handy -= 4) < 0) + return FALSE; + *lp = (int32_t) ntohl ((*((int32_t *) (xdrs->x_private)))); + xdrs->x_private += 4; + return TRUE; } static bool_t -xdrmem_putlong(xdrs, lp) - register XDR *xdrs; - long *lp; +xdrmem_putlong (xdrs, lp) + XDR *xdrs; + long *lp; { - if ((xdrs->x_handy -= 4) < 0) - return (FALSE); - *(int32_t *)xdrs->x_private = htonl(*lp); - xdrs->x_private += 4; - return (TRUE); + if ((xdrs->x_handy -= 4) < 0) + return FALSE; + *(int32_t *) xdrs->x_private = htonl (*lp); + xdrs->x_private += 4; + return TRUE; } static bool_t -xdrmem_getbytes(xdrs, addr, len) - register XDR *xdrs; - caddr_t addr; - register u_int len; +xdrmem_getbytes (xdrs, addr, len) + XDR *xdrs; + caddr_t addr; + u_int len; { - if ((xdrs->x_handy -= len) < 0) - return (FALSE); - bcopy(xdrs->x_private, addr, len); - xdrs->x_private += len; - return (TRUE); + if ((xdrs->x_handy -= len) < 0) + return FALSE; + bcopy (xdrs->x_private, addr, len); + xdrs->x_private += len; + return TRUE; } static bool_t -xdrmem_putbytes(xdrs, addr, len) - register XDR *xdrs; - caddr_t addr; - register u_int len; +xdrmem_putbytes (xdrs, addr, len) + XDR *xdrs; + caddr_t addr; + u_int len; { - if ((xdrs->x_handy -= len) < 0) - return (FALSE); - bcopy(addr, xdrs->x_private, len); - xdrs->x_private += len; - return (TRUE); + if ((xdrs->x_handy -= len) < 0) + return FALSE; + bcopy (addr, xdrs->x_private, len); + xdrs->x_private += len; + return TRUE; } static u_int -xdrmem_getpos(xdrs) - register XDR *xdrs; +xdrmem_getpos (xdrs) + XDR *xdrs; { - return ((u_long)xdrs->x_private - (u_long)xdrs->x_base); + return (u_long) xdrs->x_private - (u_long) xdrs->x_base; } static bool_t -xdrmem_setpos(xdrs, pos) - register XDR *xdrs; - u_int pos; +xdrmem_setpos (xdrs, pos) + 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) - return (FALSE); - xdrs->x_private = newaddr; - xdrs->x_handy = (long)lastaddr - (long)newaddr; - return (TRUE); + caddr_t newaddr = xdrs->x_base + pos; + caddr_t lastaddr = xdrs->x_private + xdrs->x_handy; + + if ((long) newaddr > (long) lastaddr) + return FALSE; + xdrs->x_private = newaddr; + xdrs->x_handy = (long) lastaddr - (long) newaddr; + return TRUE; } static long * -xdrmem_inline(xdrs, len) - register XDR *xdrs; - int len; +xdrmem_inline (xdrs, len) + XDR *xdrs; + int len; { - long *buf = 0; - - if (xdrs->x_handy >= len) { - xdrs->x_handy -= len; - buf = (long *) xdrs->x_private; - xdrs->x_private += len; - } - return (buf); + long *buf = 0; + + if (xdrs->x_handy >= len) + { + xdrs->x_handy -= len; + buf = (long *) xdrs->x_private; + xdrs->x_private += len; + } + return buf; } diff --git a/sunrpc/xdr_rec.c b/sunrpc/xdr_rec.c index 6b33208d76..af2f9f5ed7 100644 --- a/sunrpc/xdr_rec.c +++ b/sunrpc/xdr_rec.c @@ -49,32 +49,29 @@ static char sccsid[] = "@(#)xdr_rec.c 1.21 87/08/11 Copyr 1984 Sun Micro"; */ #include <stdio.h> -#include <rpc/types.h> -#include <rpc/xdr.h> -#include <netinet/in.h> - -extern long lseek(); - -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 struct xdr_ops xdrrec_ops = { - xdrrec_getlong, - xdrrec_putlong, - xdrrec_getbytes, - xdrrec_putbytes, - xdrrec_getpos, - xdrrec_setpos, - xdrrec_inline, - xdrrec_destroy +#include <string.h> +#include <unistd.h> +#include <rpc/rpc.h> + +static bool_t xdrrec_getlong (XDR *, long *); +static bool_t xdrrec_putlong (XDR *, long *); +static bool_t xdrrec_getbytes (XDR *, caddr_t, u_int); +static bool_t xdrrec_putbytes (XDR *, caddr_t, u_int); +static u_int xdrrec_getpos (XDR *); +static bool_t xdrrec_setpos (XDR *, u_int); +static long *xdrrec_inline (XDR *, int); +static void xdrrec_destroy (XDR *); + +static const struct xdr_ops xdrrec_ops = +{ + xdrrec_getlong, + xdrrec_putlong, + xdrrec_getbytes, + xdrrec_putbytes, + xdrrec_getpos, + xdrrec_setpos, + xdrrec_inline, + xdrrec_destroy }; /* @@ -92,32 +89,39 @@ static struct xdr_ops xdrrec_ops = { #define LAST_FRAG (1UL << 31) -typedef struct rec_strm { - caddr_t tcp_handle; - caddr_t the_buffer; - /* - * out-going 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_int32_t *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 */ - 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 */ - bool_t last_frag; - u_int sendsize; - u_int recvsize; -} RECSTREAM; - +typedef struct rec_strm + { + caddr_t tcp_handle; + caddr_t the_buffer; + /* + * out-going bits + */ + int (*writeit) (char *, char *, int); + 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_int32_t *frag_header; /* beginning of curren fragment */ + bool_t frag_sent; /* true if buffer sent in middle of record */ + /* + * in-coming bits + */ + int (*readit) (char *, char *, int); + 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 */ + bool_t last_frag; + u_int sendsize; + u_int recvsize; + } +RECSTREAM; + +static u_int fix_buf_size (u_int); +static bool_t skip_input_bytes (RECSTREAM *, long); +static bool_t flush_out (RECSTREAM *, bool_t); +static bool_t set_input_fragment (RECSTREAM *); +static bool_t get_input_bytes (RECSTREAM *, caddr_t, int); /* * Create an xdr handle for xdrrec @@ -129,57 +133,56 @@ typedef struct rec_strm { * 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 */ +xdrrec_create (XDR *xdrs, u_int sendsize, + u_int recvsize, caddr_t tcp_handle, + int (*readit) (char *, char *, int), + int (*writeit) (char *, char *, int)) { - register RECSTREAM *rstrm = - (RECSTREAM *)mem_alloc(sizeof(RECSTREAM)); - - if (rstrm == NULL) { - (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 - */ - return; - } - /* - * adjust sizes and allocate buffer quad byte aligned - */ - 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); - if (rstrm->the_buffer == NULL) { - (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++); - rstrm->in_base = rstrm->out_base + sendsize; - /* - * now the rest ... - */ - xdrs->x_ops = &xdrrec_ops; - 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_int32_t *)rstrm->out_base; - rstrm->out_finger += 4; - rstrm->out_boundry += sendsize; - rstrm->frag_sent = FALSE; - rstrm->in_size = recvsize; - rstrm->in_boundry = rstrm->in_base; - rstrm->in_finger = (rstrm->in_boundry += recvsize); - rstrm->fbtbc = 0; - rstrm->last_frag = TRUE; + RECSTREAM *rstrm = + (RECSTREAM *) mem_alloc (sizeof (RECSTREAM)); + + if (rstrm == NULL) + { + (void) fputs (_("xdrrec_create: out of memory\n"), stderr); + /* + * This is bad. Should rework xdrrec_create to + * return a handle, and in this case return NULL + */ + return; + } + /* + * adjust sizes and allocate buffer quad byte aligned + */ + 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); + if (rstrm->the_buffer == NULL) + { + (void) fputs (_("xdrrec_create: out of memory\n"), stderr); + return; + } + for (rstrm->out_base = rstrm->the_buffer; + (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; + rstrm->tcp_handle = tcp_handle; + rstrm->readit = readit; + rstrm->writeit = writeit; + rstrm->out_finger = rstrm->out_boundry = rstrm->out_base; + rstrm->frag_header = (u_int32_t *) rstrm->out_base; + rstrm->out_finger += 4; + rstrm->out_boundry += sendsize; + rstrm->frag_sent = FALSE; + rstrm->in_size = recvsize; + rstrm->in_boundry = rstrm->in_base; + rstrm->in_finger = (rstrm->in_boundry += recvsize); + rstrm->fbtbc = 0; + rstrm->last_frag = TRUE; } @@ -189,208 +192,224 @@ xdrrec_create(xdrs, sendsize, recvsize, tcp_handle, readit, writeit) */ static bool_t -xdrrec_getlong(xdrs, lp) - XDR *xdrs; - long *lp; +xdrrec_getlong (xdrs, lp) + XDR *xdrs; + long *lp; { - register RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; - register int32_t *buflp = (int32_t *) rstrm->in_finger; - int32_t mylong; - - /* first try the inline, fast case */ - if (rstrm->fbtbc >= BYTES_PER_XDR_UNIT && - rstrm->in_boundry - (char *) buflp >= BYTES_PER_XDR_UNIT) - { - *lp = (int32_t) ntohl(*buflp); - rstrm->fbtbc -= BYTES_PER_XDR_UNIT; - rstrm->in_finger += BYTES_PER_XDR_UNIT; - } else { - if (! xdrrec_getbytes(xdrs, (caddr_t) &mylong, - BYTES_PER_XDR_UNIT)) - return FALSE; - *lp = (int32_t) ntohl(mylong); - } - return TRUE; + RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; + int32_t *buflp = (int32_t *) rstrm->in_finger; + int32_t mylong; + + /* first try the inline, fast case */ + if (rstrm->fbtbc >= BYTES_PER_XDR_UNIT && + rstrm->in_boundry - (char *) buflp >= BYTES_PER_XDR_UNIT) + { + *lp = (int32_t) ntohl (*buflp); + rstrm->fbtbc -= BYTES_PER_XDR_UNIT; + rstrm->in_finger += BYTES_PER_XDR_UNIT; + } + else + { + if (!xdrrec_getbytes (xdrs, (caddr_t) & mylong, + BYTES_PER_XDR_UNIT)) + return FALSE; + *lp = (int32_t) ntohl (mylong); + } + return TRUE; } static bool_t -xdrrec_putlong(xdrs, lp) - XDR *xdrs; - long *lp; +xdrrec_putlong (xdrs, lp) + XDR *xdrs; + long *lp; { - register RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; - register int32_t *dest_lp = (int32_t *) rstrm->out_finger; - - if ((rstrm->out_finger += BYTES_PER_XDR_UNIT) > rstrm->out_boundry) { - /* - * this case should almost never happen so the code is - * inefficient - */ - rstrm->out_finger -= BYTES_PER_XDR_UNIT; - rstrm->frag_sent = TRUE; - if (! flush_out(rstrm, FALSE)) - return FALSE; - dest_lp = (int32_t *) rstrm->out_finger; - rstrm->out_finger += BYTES_PER_XDR_UNIT; - } - *dest_lp = htonl(*lp); - return TRUE; + RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; + int32_t *dest_lp = (int32_t *) rstrm->out_finger; + + if ((rstrm->out_finger += BYTES_PER_XDR_UNIT) > rstrm->out_boundry) + { + /* + * this case should almost never happen so the code is + * inefficient + */ + rstrm->out_finger -= BYTES_PER_XDR_UNIT; + rstrm->frag_sent = TRUE; + if (!flush_out (rstrm, FALSE)) + return FALSE; + dest_lp = (int32_t *) rstrm->out_finger; + rstrm->out_finger += BYTES_PER_XDR_UNIT; + } + *dest_lp = htonl (*lp); + return TRUE; } -static bool_t /* must manage buffers, fragments, and records */ -xdrrec_getbytes(xdrs, addr, len) - XDR *xdrs; - register caddr_t addr; - register u_int len; +static bool_t /* must manage buffers, fragments, and records */ +xdrrec_getbytes (xdrs, addr, len) + XDR *xdrs; + caddr_t addr; + u_int len; { - register RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; - register int current; - - while (len > 0) { - current = rstrm->fbtbc; - if (current == 0) { - if (rstrm->last_frag) - return FALSE; - if (! set_input_fragment(rstrm)) - return FALSE; - continue; - } - current = (len < current) ? len : current; - if (! get_input_bytes(rstrm, addr, current)) - return FALSE; - addr += current; - rstrm->fbtbc -= current; - len -= current; + RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; + u_int current; + + while (len > 0) + { + current = rstrm->fbtbc; + if (current == 0) + { + if (rstrm->last_frag) + return FALSE; + if (!set_input_fragment (rstrm)) + return FALSE; + continue; } - return TRUE; + current = (len < current) ? len : current; + if (!get_input_bytes (rstrm, addr, current)) + return FALSE; + 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; +xdrrec_putbytes (xdrs, addr, len) + XDR *xdrs; + caddr_t addr; + u_int len; { - register RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; - register int current; - - while (len > 0) { - current = rstrm->out_boundry - rstrm->out_finger; - current = (len < current) ? len : current; - bcopy(addr, rstrm->out_finger, current); - rstrm->out_finger += current; - addr += current; - len -= current; - if (rstrm->out_finger == rstrm->out_boundry) { - rstrm->frag_sent = TRUE; - if (! flush_out(rstrm, FALSE)) - return FALSE; - } + RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; + u_int current; + + while (len > 0) + { + current = rstrm->out_boundry - rstrm->out_finger; + current = (len < current) ? len : current; + bcopy (addr, rstrm->out_finger, current); + rstrm->out_finger += current; + addr += current; + len -= current; + if (rstrm->out_finger == rstrm->out_boundry) + { + rstrm->frag_sent = TRUE; + if (!flush_out (rstrm, FALSE)) + return FALSE; } - return TRUE; + } + return TRUE; } static u_int -xdrrec_getpos(xdrs) - register XDR *xdrs; +xdrrec_getpos (XDR *xdrs) { - register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private; - register long pos; - - pos = lseek((int)rstrm->tcp_handle, (long) 0, 1); - if (pos != -1) - switch (xdrs->x_op) { - - case XDR_ENCODE: - pos += rstrm->out_finger - rstrm->out_base; - break; - - case XDR_DECODE: - pos -= rstrm->in_boundry - rstrm->in_finger; - break; - - default: - pos = (u_int) -1; - break; - } - return ((u_int) pos); + RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; + long pos; + + pos = lseek ((int) rstrm->tcp_handle, (long) 0, 1); + if (pos != -1) + switch (xdrs->x_op) + { + + case XDR_ENCODE: + pos += rstrm->out_finger - rstrm->out_base; + break; + + case XDR_DECODE: + pos -= rstrm->in_boundry - rstrm->in_finger; + break; + + default: + pos = (u_int) - 1; + break; + } + return (u_int) pos; } static bool_t -xdrrec_setpos(xdrs, pos) - register XDR *xdrs; - u_int pos; +xdrrec_setpos (xdrs, pos) + XDR *xdrs; + u_int pos; { - register RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; - u_int currpos = xdrrec_getpos(xdrs); - int delta = currpos - pos; - caddr_t newpos; - - if ((int)currpos != -1) - switch (xdrs->x_op) { - - case XDR_ENCODE: - newpos = rstrm->out_finger - delta; - if (newpos > (caddr_t) rstrm->frag_header && - newpos < rstrm->out_boundry) - { - rstrm->out_finger = newpos; - return TRUE; - } - break; - - case XDR_DECODE: - newpos = rstrm->in_finger - delta; - if ((delta < (int)(rstrm->fbtbc)) && - (newpos <= rstrm->in_boundry) && - (newpos >= rstrm->in_base)) { - rstrm->in_finger = newpos; - rstrm->fbtbc -= delta; - return TRUE; - } - break; - } - return FALSE; + RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; + u_int currpos = xdrrec_getpos (xdrs); + int delta = currpos - pos; + caddr_t newpos; + + if ((int) currpos != -1) + switch (xdrs->x_op) + { + + case XDR_ENCODE: + newpos = rstrm->out_finger - delta; + if (newpos > (caddr_t) rstrm->frag_header && + newpos < rstrm->out_boundry) + { + rstrm->out_finger = newpos; + return TRUE; + } + break; + + case XDR_DECODE: + newpos = rstrm->in_finger - delta; + if ((delta < (int) (rstrm->fbtbc)) && + (newpos <= rstrm->in_boundry) && + (newpos >= rstrm->in_base)) + { + rstrm->in_finger = newpos; + rstrm->fbtbc -= delta; + return TRUE; + } + break; + + default: + break; + } + return FALSE; } static long * -xdrrec_inline(xdrs, len) - register XDR *xdrs; - int len; +xdrrec_inline (XDR *xdrs, int len) { - register RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; - long * buf = NULL; - - switch (xdrs->x_op) { - - case XDR_ENCODE: - if ((rstrm->out_finger + len) <= rstrm->out_boundry) { - buf = (long *) rstrm->out_finger; - rstrm->out_finger += len; - } - break; - - case XDR_DECODE: - if ((len <= rstrm->fbtbc) && - ((rstrm->in_finger + len) <= rstrm->in_boundry)) { - buf = (long *) rstrm->in_finger; - rstrm->fbtbc -= len; - rstrm->in_finger += len; - } - break; + RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; + long *buf = NULL; + + switch (xdrs->x_op) + { + + case XDR_ENCODE: + if ((rstrm->out_finger + len) <= rstrm->out_boundry) + { + buf = (long *) rstrm->out_finger; + rstrm->out_finger += len; + } + break; + + case XDR_DECODE: + if ((len <= rstrm->fbtbc) && + ((rstrm->in_finger + len) <= rstrm->in_boundry)) + { + buf = (long *) rstrm->in_finger; + rstrm->fbtbc -= len; + rstrm->in_finger += len; } - return buf; + break; + + default: + break; + } + return buf; } static void -xdrrec_destroy(xdrs) - register XDR *xdrs; +xdrrec_destroy (xdrs) + XDR *xdrs; { - register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private; + 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)); + mem_free (rstrm->the_buffer, + rstrm->sendsize + rstrm->recvsize + BYTES_PER_XDR_UNIT); + mem_free ((caddr_t) rstrm, sizeof (RECSTREAM)); } @@ -403,20 +422,21 @@ xdrrec_destroy(xdrs) * this procedure to guarantee proper record alignment. */ bool_t -xdrrec_skiprecord(xdrs) - XDR *xdrs; +xdrrec_skiprecord (xdrs) + XDR *xdrs; { - register RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; - - 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))) - return FALSE; - } - rstrm->last_frag = FALSE; - return TRUE; + RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; + + 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))) + return FALSE; + } + rstrm->last_frag = FALSE; + return TRUE; } /* @@ -425,21 +445,22 @@ xdrrec_skiprecord(xdrs) * after consuming the rest of the current record. */ bool_t -xdrrec_eof(xdrs) - XDR *xdrs; +xdrrec_eof (xdrs) + XDR *xdrs; { - register RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; - - 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))) - return TRUE; - } - if (rstrm->in_finger == rstrm->in_boundry) - return TRUE; - return FALSE; + RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; + + 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))) + return TRUE; + } + if (rstrm->in_finger == rstrm->in_boundry) + return TRUE; + return FALSE; } /* @@ -449,25 +470,25 @@ xdrrec_eof(xdrs) * pipelined procedure calls.) TRUE => immediate flush to tcp connection. */ bool_t -xdrrec_endofrecord(xdrs, sendnow) - XDR *xdrs; - bool_t sendnow; +xdrrec_endofrecord (xdrs, sendnow) + XDR *xdrs; + bool_t sendnow; { - register RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; - register u_long len; /* fragment length */ - - if (sendnow || rstrm->frag_sent - || rstrm->out_finger + BYTES_PER_XDR_UNIT >= rstrm->out_boundry) - { - rstrm->frag_sent = FALSE; - return flush_out(rstrm, TRUE); - } - len = (rstrm->out_finger - (char *) rstrm->frag_header - - BYTES_PER_XDR_UNIT); - *rstrm->frag_header = htonl((u_long)len | LAST_FRAG); - rstrm->frag_header = (u_int32_t *) rstrm->out_finger; - rstrm->out_finger += BYTES_PER_XDR_UNIT; - return TRUE; + RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private; + u_long len; /* fragment length */ + + if (sendnow || rstrm->frag_sent + || rstrm->out_finger + BYTES_PER_XDR_UNIT >= rstrm->out_boundry) + { + rstrm->frag_sent = FALSE; + return flush_out (rstrm, TRUE); + } + len = (rstrm->out_finger - (char *) rstrm->frag_header + - BYTES_PER_XDR_UNIT); + *rstrm->frag_header = htonl ((u_long) len | LAST_FRAG); + rstrm->frag_header = (u_int32_t *) rstrm->out_finger; + rstrm->out_finger += BYTES_PER_XDR_UNIT; + return TRUE; } @@ -475,110 +496,102 @@ xdrrec_endofrecord(xdrs, sendnow) * Internal useful routines */ static bool_t -flush_out(rstrm, eor) - register RECSTREAM *rstrm; - bool_t eor; +flush_out (RECSTREAM *rstrm, bool_t eor) { - register u_long eormask = (eor == TRUE) ? LAST_FRAG : 0; - register u_long len = (rstrm->out_finger - - (char *) rstrm->frag_header - - BYTES_PER_XDR_UNIT); - - *rstrm->frag_header = htonl(len | eormask); - len = rstrm->out_finger - rstrm->out_base; - if ((*(rstrm->writeit))(rstrm->tcp_handle, rstrm->out_base, (int)len) - != (int)len) - return FALSE; - rstrm->frag_header = (u_int32_t *) rstrm->out_base; - rstrm->out_finger = (caddr_t) rstrm->out_base + BYTES_PER_XDR_UNIT; - return TRUE; + u_long eormask = (eor == TRUE) ? LAST_FRAG : 0; + u_long len = (rstrm->out_finger - (char *) rstrm->frag_header + - BYTES_PER_XDR_UNIT); + + *rstrm->frag_header = htonl (len | eormask); + len = rstrm->out_finger - rstrm->out_base; + if ((*(rstrm->writeit)) (rstrm->tcp_handle, rstrm->out_base, (int) len) + != (int) len) + return FALSE; + rstrm->frag_header = (u_int32_t *) rstrm->out_base; + rstrm->out_finger = (caddr_t) rstrm->out_base + BYTES_PER_XDR_UNIT; + return TRUE; } -static bool_t /* knows nothing about records! Only about input buffers */ -fill_input_buf(rstrm) - register RECSTREAM *rstrm; +static bool_t /* knows nothing about records! Only about input buffers */ +fill_input_buf (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; - where += i; - len = rstrm->in_size - i; - if ((len = (*(rstrm->readit))(rstrm->tcp_handle, where, len)) == -1) - return FALSE; - rstrm->in_finger = where; - where += len; - rstrm->in_boundry = where; - return TRUE; + caddr_t where; + u_int i; + int len; + + where = rstrm->in_base; + 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) + return FALSE; + rstrm->in_finger = where; + where += len; + rstrm->in_boundry = where; + return TRUE; } -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; +static bool_t /* knows nothing about records! Only about input buffers */ +get_input_bytes (RECSTREAM *rstrm, caddr_t addr, int len) { - register int current; - - while (len > 0) { - current = rstrm->in_boundry - rstrm->in_finger; - if (current == 0) { - if (! fill_input_buf(rstrm)) - return FALSE; - continue; - } - current = (len < current) ? len : current; - bcopy(rstrm->in_finger, addr, current); - rstrm->in_finger += current; - addr += current; - len -= current; + int current; + + while (len > 0) + { + current = rstrm->in_boundry - rstrm->in_finger; + if (current == 0) + { + if (!fill_input_buf (rstrm)) + return FALSE; + continue; } - return TRUE; + current = (len < current) ? len : current; + bcopy (rstrm->in_finger, addr, current); + rstrm->in_finger += current; + addr += current; + len -= current; + } + return TRUE; } -static bool_t /* next two bytes of the input stream are treated as a header */ -set_input_fragment(rstrm) - register RECSTREAM *rstrm; +static bool_t /* next two bytes of the input stream are treated as a header */ +set_input_fragment (RECSTREAM *rstrm) { - u_long header; - - if (! get_input_bytes(rstrm, (caddr_t)&header, BYTES_PER_XDR_UNIT)) - return FALSE; - header = ntohl(header); - rstrm->last_frag = ((header & LAST_FRAG) == 0) ? FALSE : TRUE; - rstrm->fbtbc = header & ~LAST_FRAG; - return TRUE; + u_long header; + + if (!get_input_bytes (rstrm, (caddr_t) & header, BYTES_PER_XDR_UNIT)) + return FALSE; + header = 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! */ -skip_input_bytes(rstrm, cnt) - register RECSTREAM *rstrm; - long cnt; +static bool_t /* consumes input bytes; knows nothing about records! */ +skip_input_bytes (RECSTREAM *rstrm, long cnt) { - register int current; - - while (cnt > 0) { - current = rstrm->in_boundry - rstrm->in_finger; - if (current == 0) { - if (! fill_input_buf(rstrm)) - return FALSE; - continue; - } - current = (cnt < current) ? cnt : current; - rstrm->in_finger += current; - cnt -= current; + int current; + + while (cnt > 0) + { + current = rstrm->in_boundry - rstrm->in_finger; + if (current == 0) + { + if (!fill_input_buf (rstrm)) + return FALSE; + continue; } - return TRUE; + current = (cnt < current) ? cnt : current; + rstrm->in_finger += current; + cnt -= current; + } + return TRUE; } static u_int -fix_buf_size(s) - register u_int s; +fix_buf_size (u_int s) { - - if (s < 100) - s = 4000; - return RNDUP(s); + if (s < 100) + s = 4000; + return RNDUP (s); } diff --git a/sunrpc/xdr_ref.c b/sunrpc/xdr_ref.c index f4ad74df3e..911892ef2d 100644 --- a/sunrpc/xdr_ref.c +++ b/sunrpc/xdr_ref.c @@ -41,6 +41,7 @@ static char sccsid[] = "@(#)xdr_reference.c 1.11 87/08/11 SMI"; */ #include <stdio.h> +#include <string.h> #include <rpc/types.h> #include <rpc/xdr.h> @@ -56,38 +57,42 @@ static char sccsid[] = "@(#)xdr_reference.c 1.11 87/08/11 SMI"; * 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 */ +xdr_reference (xdrs, pp, size, proc) + 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; + caddr_t loc = *pp; + bool_t stat; - if (loc == NULL) - switch (xdrs->x_op) { - case XDR_FREE: - return (TRUE); + if (loc == NULL) + switch (xdrs->x_op) + { + case XDR_FREE: + return TRUE; - case XDR_DECODE: - *pp = loc = (caddr_t) mem_alloc(size); - if (loc == NULL) { - (void) fprintf(stderr, - "xdr_reference: out of memory\n"); - return (FALSE); - } - bzero(loc, (int)size); - break; - } + case XDR_DECODE: + *pp = loc = (caddr_t) mem_alloc (size); + if (loc == NULL) + { + (void) fputs (_("xdr_reference: out of memory\n"), stderr); + return FALSE; + } + bzero (loc, (int) size); + break; + default: + break; + } - stat = (*proc)(xdrs, loc, LASTUNSIGNED); + stat = (*proc) (xdrs, loc, LASTUNSIGNED); - if (xdrs->x_op == XDR_FREE) { - mem_free(loc, size); - *pp = NULL; - } - return (stat); + if (xdrs->x_op == XDR_FREE) + { + mem_free (loc, size); + *pp = NULL; + } + return stat; } @@ -111,22 +116,24 @@ xdr_reference(xdrs, pp, size, proc) * */ bool_t -xdr_pointer(xdrs,objpp,obj_size,xdr_obj) - register XDR *xdrs; - char **objpp; - u_int obj_size; - xdrproc_t xdr_obj; +xdr_pointer (xdrs, objpp, obj_size, xdr_obj) + XDR *xdrs; + char **objpp; + u_int obj_size; + xdrproc_t xdr_obj; { - bool_t more_data; + bool_t more_data; - more_data = (*objpp != NULL); - if (! xdr_bool(xdrs,&more_data)) { - return (FALSE); - } - if (! more_data) { - *objpp = NULL; - return (TRUE); - } - return (xdr_reference(xdrs,objpp,obj_size,xdr_obj)); + more_data = (*objpp != NULL); + if (!xdr_bool (xdrs, &more_data)) + { + return FALSE; + } + if (!more_data) + { + *objpp = NULL; + return TRUE; + } + return xdr_reference (xdrs, objpp, obj_size, xdr_obj); } diff --git a/sunrpc/xdr_stdio.c b/sunrpc/xdr_stdio.c index 351b8f94b4..f95bc70be1 100644 --- a/sunrpc/xdr_stdio.c +++ b/sunrpc/xdr_stdio.c @@ -45,27 +45,28 @@ static char sccsid[] = "@(#)xdr_stdio.c 1.16 87/08/11 Copyr 1984 Sun Micro"; #include <stdio.h> #include <rpc/xdr.h> -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 (XDR *, long *); +static bool_t xdrstdio_putlong (XDR *, long *); +static bool_t xdrstdio_getbytes (XDR *, caddr_t, u_int); +static bool_t xdrstdio_putbytes (XDR *, caddr_t, u_int); +static u_int xdrstdio_getpos (XDR *); +static bool_t xdrstdio_setpos (XDR *, u_int); +static long *xdrstdio_inline (XDR *, int); +static void xdrstdio_destroy (XDR *); /* * Ops vector for stdio type XDR */ -static struct xdr_ops xdrstdio_ops = { - xdrstdio_getlong, /* deserialize a long int */ - xdrstdio_putlong, /* serialize 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 const struct xdr_ops xdrstdio_ops = +{ + xdrstdio_getlong, /* deserialize a long int */ + xdrstdio_putlong, /* serialize 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 */ }; /* @@ -74,17 +75,17 @@ static struct xdr_ops xdrstdio_ops = { * Operation flag is set to op. */ void -xdrstdio_create(xdrs, file, op) - register XDR *xdrs; - FILE *file; - enum xdr_op op; +xdrstdio_create (xdrs, file, op) + 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_handy = 0; - xdrs->x_base = 0; + xdrs->x_op = op; + xdrs->x_ops = &xdrstdio_ops; + xdrs->x_private = (caddr_t) file; + xdrs->x_handy = 0; + xdrs->x_base = 0; } /* @@ -92,95 +93,81 @@ xdrstdio_create(xdrs, file, op) * Cleans up the xdr stream handle xdrs previously set up by xdrstdio_create. */ static void -xdrstdio_destroy(xdrs) - register XDR *xdrs; +xdrstdio_destroy (xdrs) + XDR *xdrs; { - (void)fflush((FILE *)xdrs->x_private); - /* xx should we close the file ?? */ + (void) fflush ((FILE *) xdrs->x_private); + /* xx should we close the file ?? */ }; static bool_t -xdrstdio_getlong(xdrs, lp) - XDR *xdrs; - register long *lp; +xdrstdio_getlong (xdrs, lp) + XDR *xdrs; + long *lp; { - int32_t mycopy; + int32_t mycopy; - if (fread((caddr_t)&mycopy, 4, 1, (FILE *)xdrs->x_private) != 1) - return (FALSE); - *lp = (int32_t) ntohl(mycopy); - return (TRUE); + if (fread ((caddr_t) & mycopy, 4, 1, (FILE *) xdrs->x_private) != 1) + return FALSE; + *lp = (int32_t) ntohl (mycopy); + return TRUE; } static bool_t -xdrstdio_putlong(xdrs, lp) - XDR *xdrs; - long *lp; +xdrstdio_putlong (XDR *xdrs, long *lp) { - int32_t mycopy = htonl(*lp); - lp = &mycopy; - if (fwrite((caddr_t)lp, 4, 1, (FILE *)xdrs->x_private) != 1) - return (FALSE); - return (TRUE); + long mycopy = htonl (*lp); + lp = &mycopy; + if (fwrite ((caddr_t) lp, 4, 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; +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)) - return (FALSE); - return (TRUE); + 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; +xdrstdio_putbytes (XDR *xdrs, caddr_t addr, u_int len) { - - if ((len != 0) && (fwrite(addr, (int)len, 1, (FILE *)xdrs->x_private) != 1)) - return (FALSE); - return (TRUE); + 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; +xdrstdio_getpos (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; +xdrstdio_setpos (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; +xdrstdio_inline (XDR *xdrs, int len) { - /* - * Must do some work to implement this: must insure - * enough data in the underlying stdio buffer, - * that the buffer is aligned so that we can indirect through a - * long *, and stuff this pointer in xdrs->x_buf. Doing - * a fread or fwrite to a scratch buffer would defeat - * most of the gains to be had here and require storage - * management on this buffer, so we don't do this. - */ - return (NULL); + /* + * Must do some work to implement this: must insure + * enough data in the underlying stdio buffer, + * that the buffer is aligned so that we can indirect through a + * long *, and stuff this pointer in xdrs->x_buf. Doing + * a fread or fwrite to a scratch buffer would defeat + * most of the gains to be had here and require storage + * management on this buffer, so we don't do this. + */ + return NULL; } |