 @@ -1,193 +1,193 @@
-/*	$NetBSD: auth.h,v 1.18 2016/01/23 01:05:30 dholland Exp $	*/
+/*	$NetBSD: auth.h,v 1.19 2016/01/23 02:34:09 dholland Exp $	*/
 /*
  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  * unrestricted use provided that this legend is included on all tape
  * media and as a part of the software program in whole or part.  Users
  * may copy or modify Sun RPC without charge, but are not authorized
  * to license or distribute it to anyone else except as part of a product or
  * program developed by the user.
+ *
  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ *
  * Sun RPC is provided with no support and without any obligation on the
  * part of Sun Microsystems, Inc. to assist in its use, correction,
  * modification or enhancement.
+ *
  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  * OR ANY PART THEREOF.
+ *
  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  * or profits or other special, indirect and consequential damages, even if
  * Sun has been advised of the possibility of such damages.
+ *
  * Sun Microsystems, Inc.
  * 2550 Garcia Avenue
  * Mountain View, California  94043
+ *
  *	from: @(#)auth.h 1.17 88/02/08 SMI
  *	@(#)auth.h	2.3 88/08/07 4.0 RPCSRC
  */
 /*
  * auth.h, Authentication interface.
+ *
  * Copyright (C) 1984, Sun Microsystems, Inc.
+ *
  * The data structures are completely opaque to the client.  The client
  * is required to pass a AUTH * to routines that create rpc
  * "sessions".
  */
 #ifndef _RPC_AUTH_H_
 #define _RPC_AUTH_H_
 #include <sys/cdefs.h>
 #define MAX_AUTH_BYTES	400
 #define MAXNETNAMELEN	255	/* maximum length of network user's name */
 /*
  * Status returned from authentication check
  */
 enum auth_stat {
 	AUTH_OK=0,
 	/*
 	 * failed at remote end
 	 */
 	AUTH_BADCRED=1,			/* bogus credentials (seal broken) */
 	AUTH_REJECTEDCRED=2,		/* client should begin new session */
 	AUTH_BADVERF=3,			/* bogus verifier (seal broken) */
 	AUTH_REJECTEDVERF=4,		/* verifier expired or was replayed */
 	AUTH_TOOWEAK=5,			/* rejected due to security reasons */
 	/*
 	 * failed locally
 	*/
 	AUTH_INVALIDRESP=6,		/* bogus response verifier */
 	AUTH_FAILED=7			/* some unknown reason */
 };
 union des_block {
 	struct {
 		uint32_t high;
 		uint32_t low;
 	} key;
 	char c[8];
 };
 typedef union des_block des_block;
 __BEGIN_DECLS
 extern bool_t xdr_des_block(XDR *, des_block *);
 __END_DECLS
 /*
  * Authentication info.  Opaque to client.
  */
 struct opaque_auth {
 	enum_t	oa_flavor;		/* flavor of auth */
 	caddr_t	oa_base;		/* address of more auth stuff */
-	unsigned oa_length;		/* not to exceed MAX_AUTH_BYTES */
+	unsigned int oa_length;		/* not to exceed MAX_AUTH_BYTES */
 };
 /*
  * Auth handle, interface to client side authenticators.
  */
 typedef struct __rpc_auth {
 	struct	opaque_auth	ah_cred;
 	struct	opaque_auth	ah_verf;
 	union	des_block	ah_key;
 	const struct auth_ops {
 		void	(*ah_nextverf)(struct __rpc_auth *);
 		/* nextverf & serialize */
 		int	(*ah_marshal)(struct __rpc_auth *, XDR *);
 		/* validate varifier */
 		int	(*ah_validate)(struct __rpc_auth *,
 			    struct opaque_auth *);
 		/* refresh credentials */
 		int	(*ah_refresh)(struct __rpc_auth *);
 		/* destroy this structure */
 		void	(*ah_destroy)(struct __rpc_auth *);
 	} *ah_ops;
 	void *ah_private;
 } AUTH;
 /*
  * Authentication ops.
  * The ops and the auth handle provide the interface to the authenticators.
+ *
  * AUTH	*auth;
  * XDR	*xdrs;
  * struct opaque_auth verf;
  */
 #define AUTH_NEXTVERF(auth)		\
 		((*((auth)->ah_ops->ah_nextverf))(auth))
 #define auth_nextverf(auth)		\
 		((*((auth)->ah_ops->ah_nextverf))(auth))
 #define AUTH_MARSHALL(auth, xdrs)	\
 		((*((auth)->ah_ops->ah_marshal))(auth, xdrs))
 #define auth_marshall(auth, xdrs)	\
 		((*((auth)->ah_ops->ah_marshal))(auth, xdrs))
 #define AUTH_VALIDATE(auth, verfp)	\
 		((*((auth)->ah_ops->ah_validate))((auth), verfp))
 #define auth_validate(auth, verfp)	\
 		((*((auth)->ah_ops->ah_validate))((auth), verfp))
 #define AUTH_REFRESH(auth)		\
 		((*((auth)->ah_ops->ah_refresh))(auth))
 #define auth_refresh(auth)		\
 		((*((auth)->ah_ops->ah_refresh))(auth))
 #define AUTH_DESTROY(auth)		\
 		((*((auth)->ah_ops->ah_destroy))(auth))
 #define auth_destroy(auth)		\
 		((*((auth)->ah_ops->ah_destroy))(auth))
 extern struct opaque_auth _null_auth;
 /*
  * These are the various implementations of client side authenticators.
  */
 /*
  * Unix style authentication
  * AUTH *authunix_create(machname, uid, gid, len, aup_gids)
  *	char *machname;
  *	int uid;
  *	int gid;
  *	int len;
  *	int *aup_gids;
  */
 __BEGIN_DECLS
 struct sockaddr_in;
 extern AUTH *authunix_create		(char *, int, int, int, int *);
 extern AUTH *authunix_create_default	(void);
 extern AUTH *authnone_create		(void);
-extern AUTH *authdes_create		(char *, unsigned,
+extern AUTH *authdes_create		(char *, unsigned int,
 					    struct sockaddr_in *, des_block *);
 extern bool_t xdr_opaque_auth		(XDR *, struct opaque_auth *);
 #define authsys_create(c,i1,i2,i3,ip) authunix_create((c),(i1),(i2),(i3),(ip))
 #define authsys_create_default() authunix_create_default()
 struct svc_req;
 struct rpc_msg;
 enum auth_stat _svcauth_null(struct svc_req *, struct rpc_msg *);
 enum auth_stat _svcauth_short(struct svc_req *, struct rpc_msg *);
 enum auth_stat _svcauth_unix(struct svc_req *, struct rpc_msg *);
 __END_DECLS
 #define AUTH_NONE	0		/* no authentication */
 #define	AUTH_NULL	0		/* backward compatibility */
 #define	AUTH_SYS	1		/* unix style (uid, gids) */
 #define AUTH_UNIX	AUTH_SYS	/* backward compatibility */
 #define	AUTH_SHORT	2		/* short hand unix style */
 #define AUTH_DES	3		/* des style (encrypted timestamps) */
 #endif /* !_RPC_AUTH_H_ */

 @@ -1,538 +1,538 @@
-/*	$NetBSD: clnt.h,v 1.23 2016/01/23 01:05:30 dholland Exp $	*/
+/*	$NetBSD: clnt.h,v 1.24 2016/01/23 02:34:09 dholland Exp $	*/
 /*
  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  * unrestricted use provided that this legend is included on all tape
  * media and as a part of the software program in whole or part.  Users
  * may copy or modify Sun RPC without charge, but are not authorized
  * to license or distribute it to anyone else except as part of a product or
  * program developed by the user.
+ *
  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ *
  * Sun RPC is provided with no support and without any obligation on the
  * part of Sun Microsystems, Inc. to assist in its use, correction,
  * modification or enhancement.
+ *
  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  * OR ANY PART THEREOF.
+ *
  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  * or profits or other special, indirect and consequential damages, even if
  * Sun has been advised of the possibility of such damages.
+ *
  * Sun Microsystems, Inc.
  * 2550 Garcia Avenue
  * Mountain View, California  94043
+ *
  *	from: @(#)clnt.h 1.31 94/04/29 SMI
  *	@(#)clnt.h	2.1 88/07/29 4.0 RPCSRC
  */
 /*
  * clnt.h - Client side remote procedure call interface.
+ *
  * Copyright (C) 1984, Sun Microsystems, Inc.
  */
 #ifndef _RPC_CLNT_H_
 #define _RPC_CLNT_H_
 #include <sys/cdefs.h>
 #include <rpc/rpc_com.h>
 /*
  * Well-known IPV6 RPC broadcast address.
  */
 #define RPCB_MULTICAST_ADDR "ff02::202"
 /*
  * Rpc calls return an enum clnt_stat.  This should be looked at more,
  * since each implementation is required to live with this (implementation
  * independent) list of errors.
  */
 enum clnt_stat {
 	RPC_SUCCESS=0,			/* call succeeded */
 	/*
 	 * local errors
 	 */
 	RPC_CANTENCODEARGS=1,		/* can't encode arguments */
 	RPC_CANTDECODERES=2,		/* can't decode results */
 	RPC_CANTSEND=3,			/* failure in sending call */
 	RPC_CANTRECV=4,			/* failure in receiving result */
 	RPC_TIMEDOUT=5,			/* call timed out */
 	/*
 	 * remote errors
 	 */
 	RPC_VERSMISMATCH=6,		/* rpc versions not compatible */
 	RPC_AUTHERROR=7,		/* authentication error */
 	RPC_PROGUNAVAIL=8,		/* program not available */
 	RPC_PROGVERSMISMATCH=9,		/* program version mismatched */
 	RPC_PROCUNAVAIL=10,		/* procedure unavailable */
 	RPC_CANTDECODEARGS=11,		/* decode arguments error */
 	RPC_SYSTEMERROR=12,		/* generic "other problem" */
 	/*
 	 * rpc_call & clnt_create errors
 	 */
 	RPC_UNKNOWNHOST=13,		/* unknown host name */
 	RPC_UNKNOWNPROTO=17,		/* unknown protocol */
 	RPC_UNKNOWNADDR = 19,		/* Remote address unknown */
 	RPC_NOBROADCAST = 21,		/* Broadcasting not supported */
 	/*
 	 * rpcbind errors
 	 */
 	RPC_RPCBFAILURE=14,		/* the pmapper failed in its call */
 #define RPC_PMAPFAILURE RPC_RPCBFAILURE
 	RPC_PROGNOTREGISTERED=15,	/* remote program is not registered */
 	RPC_N2AXLATEFAILURE = 22,	/* name -> addr translation failed */
 	/*
 	 * Misc error in the TLI library (provided for compatibility)
 	 */
 	RPC_TLIERROR = 20,
 	/*
 	 * unspecified error
 	 */
 	RPC_FAILED=16,
 	/*
 	 * asynchronous errors
 	 */
 	RPC_INPROGRESS = 24,
 	RPC_STALERACHANDLE = 25
 };
 /*
  * 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 {
 			rpcvers_t low;	/* lowest version supported */
 			rpcvers_t high;	/* highest version supported */
 		} RE_vers;
 		struct {		/* maybe meaningful if RPC_FAILED */
 			int32_t s1;
 			int32_t 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
 #define	re_lb		ru.RE_lb
 };
 /*
  * Client rpc handle.
  * Created by individual implementations
  * Client is responsible for initializing auth, see e.g. auth_none.c.
  */
 typedef struct __rpc_client {
 	AUTH	*cl_auth;			/* authenticator */
 	const struct clnt_ops {
 		/* call remote procedure */
 		enum clnt_stat	(*cl_call)(struct __rpc_client *,
 				    rpcproc_t, xdrproc_t, const char *,
 				    xdrproc_t, caddr_t, struct timeval);
 		/* abort a call */
 		void		(*cl_abort)(struct __rpc_client *);
 		/* get specific error code */
 		void		(*cl_geterr)(struct __rpc_client *,
 				    struct rpc_err *);
 		/* frees results */
 		bool_t		(*cl_freeres)(struct __rpc_client *,
 				    xdrproc_t, caddr_t);
 		/* destroy this structure */
 		void		(*cl_destroy)(struct __rpc_client *);
 		/* the ioctl() of rpc */
-		bool_t          (*cl_control)(struct __rpc_client *, unsigned,
+		bool_t          (*cl_control)(struct __rpc_client *,
-				    char *);
+				    unsigned int, char *);
 	} *cl_ops;
 	void 			*cl_private;	/* private stuff */
 	char			*cl_netid;	/* network token */
 	char			*cl_tp;		/* device name */
 } CLIENT;
 /*
  * Timers used for the pseudo-transport protocol when using datagrams
  */
 struct rpc_timers {
 	unsigned short	rt_srtt;	/* smoothed round-trip time */
 	unsigned short	rt_deviate;	/* estimated deviation */
 	unsigned long	rt_rtxcur;	/* current (backed-off) rto */
 };
 /*
  * Feedback values used for possible congestion and rate control
  */
 #define FEEDBACK_REXMIT1	1	/* first retransmit */
 #define FEEDBACK_OK		2	/* no retransmits */
 /* Used to set version of portmapper used in broadcast */
 #define CLCR_SET_LOWVERS	3
 #define CLCR_GET_LOWVERS	4
 #define RPCSMALLMSGSIZE 400	/* a more reasonable packet size */
 /*
  * client side rpc interface ops
+ *
  * Parameter types are:
+ *
  */
 /*
  * enum clnt_stat
  * CLNT_CALL(rh, proc, xargs, argsp, xres, resp, timeout)
  * 	CLIENT *rh;
  *	rpcproc_t proc;
  *	xdrproc_t xargs;
  *	caddr_t argsp;
  *	xdrproc_t xres;
  *	caddr_t resp;
  *	struct timeval timeout;
  */
 #define	CLNT_CALL(rh, proc, xargs, argsp, xres, resp, secs)		\
 	((*(rh)->cl_ops->cl_call)(rh, proc, (xdrproc_t)xargs,		\
 	(const char *)(const void *)(argsp), (xdrproc_t)xres,		\
 	(caddr_t)(void *)resp, secs))
 #define	clnt_call(rh, proc, xargs, argsp, xres, resp, secs)		\
 	((*(rh)->cl_ops->cl_call)(rh, proc, (xdrproc_t)xargs,		\
 	(const char *)(const void *)(argsp), (xdrproc_t)xres,		\
 	(caddr_t)(void *)resp, secs))
 /*
  * void
  * CLNT_ABORT(rh);
  * 	CLIENT *rh;
  */
 #define	CLNT_ABORT(rh)	((*(rh)->cl_ops->cl_abort)(rh))
 #define	clnt_abort(rh)	((*(rh)->cl_ops->cl_abort)(rh))
 /*
  * struct rpc_err
  * CLNT_GETERR(rh);
  * 	CLIENT *rh;
  */
 #define	CLNT_GETERR(rh,errp)	((*(rh)->cl_ops->cl_geterr)(rh, errp))
 #define	clnt_geterr(rh,errp)	((*(rh)->cl_ops->cl_geterr)(rh, errp))
 /*
  * bool_t
  * CLNT_FREERES(rh, xres, resp);
  * 	CLIENT *rh;
  *	xdrproc_t xres;
  *	caddr_t resp;
  */
 #define	CLNT_FREERES(rh,xres,resp) ((*(rh)->cl_ops->cl_freeres)(rh,xres,resp))
 #define	clnt_freeres(rh,xres,resp) ((*(rh)->cl_ops->cl_freeres)(rh,xres,resp))
 /*
  * bool_t
  * CLNT_CONTROL(cl, request, info)
  *      CLIENT *cl;
  *      unsigned request;
  *      char *info;
  */
 #define	CLNT_CONTROL(cl,rq,in) ((*(cl)->cl_ops->cl_control)(cl,rq,in))
 #define	clnt_control(cl,rq,in) ((*(cl)->cl_ops->cl_control)(cl,rq,in))
 /*
  * control operations that apply to both udp and tcp 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	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 */
 /*
  * Connectionless only control operations
  */
 #define CLSET_RETRY_TIMEOUT 4   /* set retry timeout (timeval) */
 #define CLGET_RETRY_TIMEOUT 5   /* get retry timeout (timeval) */
 /*
  * void
  * CLNT_DESTROY(rh);
  * 	CLIENT *rh;
  */
 #define	CLNT_DESTROY(rh)	((*(rh)->cl_ops->cl_destroy)(rh))
 #define	clnt_destroy(rh)	((*(rh)->cl_ops->cl_destroy)(rh))
 /*
  * RPCTEST is a test program which is accessible on every rpc
  * transport/port.  It is used for testing, performance evaluation,
  * and network administration.
  */
 #define RPCTEST_PROGRAM		((rpcprog_t)1)
 #define RPCTEST_VERSION		((rpcvers_t)1)
 #define RPCTEST_NULL_PROC	((rpcproc_t)2)
 #define RPCTEST_NULL_BATCH_PROC	((rpcproc_t)3)
 /*
  * By convention, procedure 0 takes null arguments and returns them
  */
 #define NULLPROC ((rpcproc_t)0)
 /*
  * Below are the client handle creation routines for the various
  * implementations of client side rpc.  They can return NULL if a
  * creation failure occurs.
  */
 /*
  * Generic client creation routine. Supported protocols are those that
  * belong to the nettype namespace (/etc/netconfig).
  * CLIENT *
  * clnt_create(host, prog, vers, prot);
  *	const char *host; 	-- hostname
  *	const rpcprog_t prog;	-- program number
  *	const rpcvers_t vers;	-- version number
  *	const char *prot;	-- protocol
  */
 __BEGIN_DECLS
 extern CLIENT *clnt_create(const char *, const rpcprog_t, const rpcvers_t,
 				const char *);
 /*
+ *
  * 	const char *hostname;			-- hostname
  *	const rpcprog_t prog;			-- program number
  *	const rpcvers_t vers;			-- version number
  *	const char *nettype;			-- network type
  */
 /*
  * Generic client creation routine. Supported protocols are which belong
  * to the nettype name space.
  */
 extern CLIENT *clnt_create_vers(const char *, const rpcprog_t, rpcvers_t *,
 				     const rpcvers_t, const rpcvers_t,
 				     const char *);
 /*
  *	const char *host;		-- hostname
  *	const rpcprog_t prog;		-- program number
  *	rpcvers_t *vers_out;		-- servers highest available version
  *	const rpcvers_t vers_low;	-- low version number
  *	const rpcvers_t vers_high;	-- high version number
  *	const char *nettype;		-- network type
  */
 /*
  * Generic client creation routine. It takes a netconfig structure
  * instead of nettype
  */
 extern CLIENT *clnt_tp_create(const char *, const rpcprog_t,
 				   const rpcvers_t, const struct netconfig *);
 /*
  *	const char *hostname;			-- hostname
  *	const rpcprog_t prog;			-- program number
  *	const rpcvers_t vers;			-- version number
  *	const struct netconfig *netconf; 	-- network config structure
  */
 /*
  * Generic TLI create routine. Only provided for compatibility.
  */
 extern CLIENT *clnt_tli_create(const int, const struct netconfig *,
 				    const struct netbuf *, const rpcprog_t,
-				    const rpcvers_t, const unsigned,
+				    const rpcvers_t, const unsigned int,
-				    const unsigned);
+				    const unsigned int);
 /*
  *	const register int fd;		-- fd
  *	const struct netconfig *nconf;	-- netconfig structure
  *	const struct netbuf *svcaddr;		-- servers address
  *	const unsigned long prog;		-- program number
  *	const unsigned long vers;		-- version number
  *	const unsigned sendsz;			-- send size
  *	const unsigned recvsz;			-- recv size
  */
 /*
  * Low level clnt create routine for connectionful transports, e.g. tcp.
  */
 extern CLIENT *clnt_vc_create(const int, const struct netbuf *,
 				   const rpcprog_t, const rpcvers_t,
-				   const unsigned, const unsigned);
+				   const unsigned int, const unsigned int);
 /*
  *	const int fd;				-- open file descriptor
  *	const struct netbuf *svcaddr;		-- servers address
  *	const rpcprog_t prog;			-- program number
  *	const rpcvers_t vers;			-- version number
  *	const unsigned sendsz;			-- buffer recv size
  *	const unsigned recvsz;			-- buffer send size
  */
 /*
  * Low level clnt create routine for connectionless transports, e.g. udp.
  */
 extern CLIENT *clnt_dg_create(const int, const struct netbuf *,
 				   const rpcprog_t, const rpcvers_t,
-				   const unsigned, const unsigned);
+				   const unsigned int, const unsigned int);
 /*
  *	const int fd;				-- open file descriptor
  *	const struct netbuf *svcaddr;		-- servers address
  *	const rpcprog_t program;		-- program number
  *	const rpcvers_t version;		-- version number
  *	const unsigned sendsz;			-- buffer recv size
  *	const unsigned recvsz;			-- buffer send size
  */
 /*
  * Memory based rpc (for speed check and testing)
  * CLIENT *
  * clnt_raw_create(prog, vers)
  *	unsigned long prog;
  *	unsigned long vers;
  */
 extern CLIENT *clnt_raw_create	(rpcprog_t, rpcvers_t);
 __END_DECLS
 /*
  * Print why creation failed
  */
 __BEGIN_DECLS
 extern void clnt_pcreateerror	(const char *);		/* stderr */
 extern char *clnt_spcreateerror	(const char *);		/* string */
 __END_DECLS
 /*
  * Like clnt_perror(), but is more verbose in its output
  */
 __BEGIN_DECLS
 extern void clnt_perrno		(enum clnt_stat);		/* stderr */
 extern char *clnt_sperrno	(enum clnt_stat);		/* string */
 __END_DECLS
 /*
  * Print an English error message, given the client error code
  */
 __BEGIN_DECLS
 extern void clnt_perror		(CLIENT *, const char *); 	/* stderr */
 extern char *clnt_sperror	(CLIENT *, const char *);	/* string */
 __END_DECLS
 /*
  * If a creation fails, the following allows the user to figure out why.
  */
 struct rpc_createerr {
 	enum clnt_stat cf_stat;
 	struct rpc_err cf_error; /* useful when cf_stat == RPC_PMAPFAILURE */
 };
 __BEGIN_DECLS
 extern struct rpc_createerr	*__rpc_createerr(void);
 __END_DECLS
 #define rpc_createerr		(*(__rpc_createerr()))
 /*
  * The simplified interface:
  * enum clnt_stat
  * rpc_call(host, prognum, versnum, procnum, inproc, in, outproc, out, nettype)
  *	const char *host;
  *	const rpcprog_t prognum;
  *	const rpcvers_t versnum;
  *	const rpcproc_t procnum;
  *	const xdrproc_t inproc, outproc;
  *	const char *in;
  *	char *out;
  *	const char *nettype;
  */
 __BEGIN_DECLS
 extern enum clnt_stat rpc_call(const char *, const rpcprog_t,
 				    const rpcvers_t, const rpcproc_t,
 				    const xdrproc_t, const char *,
 				    const xdrproc_t, char *, const char *);
 __END_DECLS
 /*
  * RPC broadcast interface
  * The call is broadcasted to all locally connected nets.
+ *
  * extern enum clnt_stat
  * rpc_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp,
  *			eachresult, nettype)
  *	const rpcprog_t		prog;		-- program number
  *	const rpcvers_t		vers;		-- version number
  *	const rpcproc_t		proc;		-- procedure number
  *	const xdrproc_t	xargs;		-- xdr routine for args
  *	caddr_t		argsp;		-- pointer to args
  *	const xdrproc_t	xresults;	-- xdr routine for results
  *	caddr_t		resultsp;	-- pointer to results
  *	const resultproc_t	eachresult;	-- call with each result
  *	const char		*nettype;	-- Transport type
+ *
  * For each valid response received, the procedure eachresult is called.
  * Its form is:
  *		done = eachresult(resp, raddr, nconf)
  *			bool_t done;
  *			caddr_t resp;
  *			struct netbuf *raddr;
  *			struct netconfig *nconf;
  * where resp points to the results of the call and raddr is the
  * address if the responder to the broadcast.  nconf is the transport
  * on which the response was received.
+ *
  * extern enum clnt_stat
  * rpc_broadcast_exp(prog, vers, proc, xargs, argsp, xresults, resultsp,
  *			eachresult, inittime, waittime, nettype)
  *	const rpcprog_t		prog;		-- program number
  *	const rpcvers_t		vers;		-- version number
  *	const rpcproc_t		proc;		-- procedure number
  *	const xdrproc_t	xargs;		-- xdr routine for args
  *	caddr_t		argsp;		-- pointer to args
  *	const xdrproc_t	xresults;	-- xdr routine for results
  *	caddr_t		resultsp;	-- pointer to results
  *	const resultproc_t	eachresult;	-- call with each result
  *	const int 		inittime;	-- how long to wait initially
  *	const int 		waittime;	-- maximum time to wait
  *	const char		*nettype;	-- Transport type
  */
 typedef bool_t (*resultproc_t)(caddr_t, ...);
 __BEGIN_DECLS
 extern enum clnt_stat rpc_broadcast(const rpcprog_t, const rpcvers_t,
     const rpcproc_t, const xdrproc_t, const char *, const xdrproc_t, caddr_t,
     const resultproc_t, const char *);
 extern enum clnt_stat rpc_broadcast_exp(const rpcprog_t, const rpcvers_t,
     const rpcproc_t, const xdrproc_t, const char *, const xdrproc_t, caddr_t,
     const resultproc_t, const int, const int, const char *);
 __END_DECLS
 /* For backward compatibility */
 #include <rpc/clnt_soc.h>
 #endif /* !_RPC_CLNT_H_ */

 @@ -1,559 +1,559 @@
 %/*
 % * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
 % * unrestricted use provided that this legend is included on all tape
 % * media and as a part of the software program in whole or part.  Users
 % * may copy or modify Sun RPC without charge, but are not authorized
 % * to license or distribute it to anyone else except as part of a product or
 % * program developed by the user.
 % *
 % * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
 % * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
 % * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
 % *
 % * Sun RPC is provided with no support and without any obligation on the
 % * part of Sun Microsystems, Inc. to assist in its use, correction,
 % * modification or enhancement.
 % *
 % * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
 % * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
 % * OR ANY PART THEREOF.
 % *
 % * In no event will Sun Microsystems, Inc. be liable for any lost revenue
 % * or profits or other special, indirect and consequential damages, even if
 % * Sun has been advised of the possibility of such damages.
 % *
 % * Sun Microsystems, Inc.
 % * 2550 Garcia Avenue
 % * Mountain View, California  94043
 % */
 %/*
 % * Copyright (c) 1988 by Sun Microsystems, Inc.
 % */
 %/* from rpcb_prot.x */
 #ifdef RPC_HDR
+%
 %/* #pragma ident	"@(#)rpcb_prot.x	1.5	94/04/29 SMI" */
+%
 %#ifndef _KERNEL
+%
 #endif
 /*
  * rpcb_prot.x
  * rpcbind protocol, versions 3 and 4, in RPC Language
  */
+%
 %/*
 % * The following procedures are supported by the protocol in version 3:
 % *
 % * RPCBPROC_NULL() returns ()
 % * 	takes nothing, returns nothing
 % *
 % * RPCBPROC_SET(rpcb) returns (bool_t)
 % * 	TRUE is success, FALSE is failure.  Registers the tuple
 % *	[prog, vers, address, owner, netid].
 % *	Finds out owner and netid information on its own.
 % *
 % * RPCBPROC_UNSET(rpcb) returns (bool_t)
 % *	TRUE is success, FALSE is failure.  Un-registers tuple
 % *	[prog, vers, netid].  addresses is ignored.
 % *	If netid is NULL, unregister all.
 % *
 % * RPCBPROC_GETADDR(rpcb) returns (string).
 % *	0 is failure.  Otherwise returns the universal address where the
 % *	triple [prog, vers, netid] is registered.  Ignore address and owner.
 % *
 % * RPCBPROC_DUMP() RETURNS (rpcblist_ptr)
 % *	used to dump the entire rpcbind maps
 % *
 % * RPCBPROC_CALLIT(rpcb_rmtcallargs)
 % * 	RETURNS (rpcb_rmtcallres);
 % * 	Calls the procedure on the remote machine.  If it is not registered,
 % *	this procedure is quiet; i.e. it does not return error information!!!
 % *	This routine only passes null authentication parameters.
 % *	It has no interface to xdr routines for RPCBPROC_CALLIT.
 % *
 % * RPCBPROC_GETTIME() returns (int).
 % *	Gets the remote machines time
 % *
 % * RPCBPROC_UADDR2TADDR(strint) RETURNS (struct netbuf)
 % *	Returns the netbuf address from universal address.
 % *
 % * RPCBPROC_TADDR2UADDR(struct netbuf) RETURNS (string)
 % *	Returns the universal address from netbuf address.
 % *
 % * END OF RPCBIND VERSION 3 PROCEDURES
 % */
 %/*
 % * Except for RPCBPROC_CALLIT, the procedures above are carried over to
 % * rpcbind version 4.  Those below are added or modified for version 4.
 % * NOTE: RPCBPROC_BCAST HAS THE SAME FUNCTIONALITY AND PROCEDURE NUMBER
 % * AS RPCBPROC_CALLIT.
 % *
 % * RPCBPROC_BCAST(rpcb_rmtcallargs)
 % * 	RETURNS (rpcb_rmtcallres);
 % * 	Calls the procedure on the remote machine.  If it is not registered,
 % *	this procedure IS quiet; i.e. it DOES NOT return error information!!!
 % *	This routine should be used for broadcasting and nothing else.
 % *
 % * RPCBPROC_GETVERSADDR(rpcb) returns (string).
 % *	0 is failure.  Otherwise returns the universal address where the
 % *	triple [prog, vers, netid] is registered.  Ignore address and owner.
 % *	Same as RPCBPROC_GETADDR except that if the given version number
 % *	is not available, the address is not returned.
 % *
 % * RPCBPROC_INDIRECT(rpcb_rmtcallargs)
 % * 	RETURNS (rpcb_rmtcallres);
 % * 	Calls the procedure on the remote machine.  If it is not registered,
 % *	this procedure is NOT quiet; i.e. it DOES return error information!!!
 % * 	as any normal application would expect.
 % *
 % * RPCBPROC_GETADDRLIST(rpcb) returns (rpcb_entry_list_ptr).
 % *	Same as RPCBPROC_GETADDR except that it returns a list of all the
 % *	addresses registered for the combination (prog, vers) (for all
 % *	transports).
 % *
 % * RPCBPROC_GETSTAT(void) returns (rpcb_stat_byvers)
 % *	Returns the statistics about the kind of requests received by rpcbind.
 % */
+%
 %/*
 % * A mapping of (program, version, network ID) to address
 % */
 struct rpcb {
 	rpcprog_t r_prog;		/* program number */
 	rpcvers_t r_vers;		/* version number */
 	string r_netid<>;		/* network id */
 	string r_addr<>;		/* universal address */
 	string r_owner<>;		/* owner of this service */
 };
 #ifdef RPC_HDR
+%
 %typedef rpcb RPCB;
+%
 #endif
+%
 %/*
 % * A list of mappings
 % *
 % * Below are two definitions for the rpcblist structure.  This is done because
 % * xdr_rpcblist() is specified to take a struct rpcblist **, rather than a
 % * struct rpcblist * that rpcgen would produce.  One version of the rpcblist
 % * structure (actually called rp__list) is used with rpcgen, and the other is
 % * defined only in the header file for compatibility with the specified
 % * interface.
 % */
 struct rp__list {
 	rpcb rpcb_map;
 	struct rp__list *rpcb_next;
 };
 typedef rp__list *rpcblist_ptr;		/* results of RPCBPROC_DUMP */
 #ifdef RPC_HDR
+%
 %typedef struct rp__list rpcblist;
 %typedef struct rp__list RPCBLIST;
+%
 %#ifndef __cplusplus
 %struct rpcblist {
 %	RPCB rpcb_map;
 %	struct rpcblist *rpcb_next;
 %};
 %#endif
+%
 %#ifdef __cplusplus
 %extern "C" {
 %#endif
 %#if __STDC__
 %extern  bool_t xdr_rpcblist(XDR *, rpcblist**);
 %#else /* K&R C */
 %bool_t xdr_rpcblist();
 %#endif
 %#ifdef	__cplusplus
 %}
 %#endif
+%
 #endif
+%
 %/*
 % * Arguments of remote calls
 % */
 struct rpcb_rmtcallargs {
 	rpcprog_t prog;			/* program number */
 	rpcvers_t vers;			/* version number */
 	rpcproc_t proc;			/* procedure number */
 	opaque args<>;			/* argument */
 };
 #ifdef RPC_HDR
+%
 %/*
 % * Client-side only representation of rpcb_rmtcallargs structure.
 % *
 % * The routine that XDRs the rpcb_rmtcallargs structure must deal with the
 % * opaque arguments in the "args" structure.  xdr_rpcb_rmtcallargs() needs to
 % * be passed the XDR routine that knows the args' structure.  This routine
 % * doesn't need to go over-the-wire (and it wouldn't make sense anyway) since
 % * the application being called already knows the args structure.  So we use a
 % * different "XDR" structure on the client side, r_rpcb_rmtcallargs, which
 % * includes the args' XDR routine.
 % */
 %struct r_rpcb_rmtcallargs {
 %	rpcprog_t prog;
 %	rpcvers_t vers;
 %	rpcproc_t proc;
 %	struct {
-%		unsigned args_len;
+%		unsigned int args_len;
 %		const char *args_val;
 %	} args;
 %	xdrproc_t	xdr_args;	/* encodes args */
 %};
+%
 #endif	/* def RPC_HDR */
+%
 %/*
 % * Results of the remote call
 % */
 struct rpcb_rmtcallres {
 	string addr<>;			/* remote universal address */
 	opaque results<>;		/* result */
 };
 #ifdef RPC_HDR
+%
 %/*
 % * Client-side only representation of rpcb_rmtcallres structure.
 % */
 %struct r_rpcb_rmtcallres {
 %	char *addr;
 %	struct {
 %		uint32_t results_len;
 %		char *results_val;
 %	} results;
 %	xdrproc_t	xdr_res;	/* decodes results */
 %};
 #endif /* RPC_HDR */
+%
 %/*
 % * rpcb_entry contains a merged address of a service on a particular
 % * transport, plus associated netconfig information.  A list of rpcb_entrys
 % * is returned by RPCBPROC_GETADDRLIST.  See netconfig.h for values used
 % * in r_nc_* fields.
 % */
 struct rpcb_entry {
 	string		r_maddr<>;	/* merged address of service */
 	string		r_nc_netid<>;	/* netid field */
 	unsigned int	r_nc_semantics;	/* semantics of transport */
 	string		r_nc_protofmly<>; /* protocol family */
 	string		r_nc_proto<>;	/* protocol name */
 };
+%
 %/*
 % * A list of addresses supported by a service.
 % */
 struct rpcb_entry_list {
 	rpcb_entry rpcb_entry_map;
 	struct rpcb_entry_list *rpcb_entry_next;
 };
 typedef rpcb_entry_list *rpcb_entry_list_ptr;
+%
 %/*
 % * rpcbind statistics
 % */
+%
 const rpcb_highproc_2 = RPCBPROC_CALLIT;
 const rpcb_highproc_3 = RPCBPROC_TADDR2UADDR;
 const rpcb_highproc_4 = RPCBPROC_GETSTAT;
 const RPCBSTAT_HIGHPROC = 13;	/* # of procs in rpcbind V4 plus one */
 const RPCBVERS_STAT = 3;	/* provide only for rpcbind V2, V3 and V4 */
 const RPCBVERS_4_STAT = 2;
 const RPCBVERS_3_STAT = 1;
 const RPCBVERS_2_STAT = 0;
+%
 %/* Link list of all the stats about getport and getaddr */
 struct rpcbs_addrlist {
 	rpcprog_t prog;
 	rpcvers_t vers;
 	int success;
 	int failure;
 	string netid<>;
 	struct rpcbs_addrlist *next;
 };
+%
 %/* Link list of all the stats about rmtcall */
 struct rpcbs_rmtcalllist {
 	rpcprog_t prog;
 	rpcvers_t vers;
 	rpcproc_t proc;
 	int success;
 	int failure;
 	int indirect;	/* whether callit or indirect */
 	string netid<>;
 	struct rpcbs_rmtcalllist *next;
 };
 typedef int rpcbs_proc[RPCBSTAT_HIGHPROC];
 typedef rpcbs_addrlist *rpcbs_addrlist_ptr;
 typedef rpcbs_rmtcalllist *rpcbs_rmtcalllist_ptr;
 struct rpcb_stat {
 	rpcbs_proc		info;
 	int			setinfo;
 	int			unsetinfo;
 	rpcbs_addrlist_ptr	addrinfo;
 	rpcbs_rmtcalllist_ptr	rmtinfo;
 };
+%
 %/*
 % * One rpcb_stat structure is returned for each version of rpcbind
 % * being monitored.
 % */
 typedef rpcb_stat rpcb_stat_byvers[RPCBVERS_STAT];
 #ifdef RPC_HDR
+%
 %/*
 % * We don't define netbuf in RPCL, since it would contain structure member
 % * names that would conflict with the definition of struct netbuf in
 % * <tiuser.h>.  Instead we merely declare the XDR routine xdr_netbuf() here,
 % * and implement it ourselves in rpc/rpcb_prot.c.
 % */
 %#ifdef __cplusplus
 %extern "C" bool_t xdr_netbuf(XDR *, struct netbuf *);
+%
 %#elif __STDC__
 %extern  bool_t xdr_netbuf(XDR *, struct netbuf *);
+%
 %#else /* K&R C */
 %bool_t xdr_netbuf();
+%
 %#endif /* K&R C*/
 #endif /* def RPC_HDR */
 /*
  * rpcbind procedures
  */
 program RPCBPROG {
 	version RPCBVERS {
 		bool
 		RPCBPROC_SET(rpcb) = 1;
 		bool
 		RPCBPROC_UNSET(rpcb) = 2;
 		string
 		RPCBPROC_GETADDR(rpcb) = 3;
 		rpcblist_ptr
 		RPCBPROC_DUMP(void) = 4;
 		rpcb_rmtcallres
 		RPCBPROC_CALLIT(rpcb_rmtcallargs) = 5;
 		unsigned int
 		RPCBPROC_GETTIME(void) = 6;
 		struct netbuf
 		RPCBPROC_UADDR2TADDR(string) = 7;
 		string
 		RPCBPROC_TADDR2UADDR(struct netbuf) = 8;
 	} = 3;
 	version RPCBVERS4 {
 		bool
 		RPCBPROC_SET(rpcb) = 1;
 		bool
 		RPCBPROC_UNSET(rpcb) = 2;
 		string
 		RPCBPROC_GETADDR(rpcb) = 3;
 		rpcblist_ptr
 		RPCBPROC_DUMP(void) = 4;
 		/*
 		 * NOTE: RPCBPROC_BCAST has the same functionality as CALLIT;
 		 * the new name is intended to indicate that this
 		 * procedure should be used for broadcast RPC, and
 		 * RPCBPROC_INDIRECT should be used for indirect calls.
 		 */
 		rpcb_rmtcallres
 		RPCBPROC_BCAST(rpcb_rmtcallargs) = RPCBPROC_CALLIT;
 		unsigned int
 		RPCBPROC_GETTIME(void) = 6;
 		struct netbuf
 		RPCBPROC_UADDR2TADDR(string) = 7;
 		string
 		RPCBPROC_TADDR2UADDR(struct netbuf) = 8;
 		string
 		RPCBPROC_GETVERSADDR(rpcb) = 9;
 		rpcb_rmtcallres
 		RPCBPROC_INDIRECT(rpcb_rmtcallargs) = 10;
 		rpcb_entry_list_ptr
 		RPCBPROC_GETADDRLIST(rpcb) = 11;
 		rpcb_stat_byvers
 		RPCBPROC_GETSTAT(void) = 12;
 	} = 4;
 } = 100000;
 #ifdef RPC_HDR
+%
 %#define	RPCBVERS_3		RPCBVERS
 %#define	RPCBVERS_4		RPCBVERS4
+%
 %#define	_PATH_RPCBINDSOCK	"/var/run/rpcbind.sock"
+%
 %#else		/* ifndef _KERNEL */
 %#ifdef __cplusplus
 %extern "C" {
 %#endif
+%
 %/*
 % * A mapping of (program, version, network ID) to address
 % */
 %struct rpcb {
 %	rpcprog_t r_prog;		/* program number */
 %	rpcvers_t r_vers;		/* version number */
 %	char *r_netid;			/* network id */
 %	char *r_addr;			/* universal address */
 %	char *r_owner;			/* owner of the mapping */
 %};
 %typedef struct rpcb RPCB;
+%
 %/*
 % * A list of mappings
 % */
 %struct rpcblist {
 %	RPCB rpcb_map;
 %	struct rpcblist *rpcb_next;
 %};
 %typedef struct rpcblist RPCBLIST;
 %typedef struct rpcblist *rpcblist_ptr;
+%
 %/*
 % * Remote calls arguments
 % */
 %struct rpcb_rmtcallargs {
 %	rpcprog_t prog;			/* program number */
 %	rpcvers_t vers;			/* version number */
 %	rpcproc_t proc;			/* procedure number */
 %	uint32_t arglen;			/* arg len */
 %	caddr_t args_ptr;		/* argument */
 %	xdrproc_t xdr_args;		/* XDR routine for argument */
 %};
 %typedef struct rpcb_rmtcallargs rpcb_rmtcallargs;
+%
 %/*
 % * Remote calls results
 % */
 %struct rpcb_rmtcallres {
 %	char *addr_ptr;			/* remote universal address */
 %	uint32_t resultslen;		/* results length */
 %	caddr_t results_ptr;		/* results */
 %	xdrproc_t xdr_results;		/* XDR routine for result */
 %};
 %typedef struct rpcb_rmtcallres rpcb_rmtcallres;
+%
 %struct rpcb_entry {
 %	char *r_maddr;
 %	char *r_nc_netid;
 %	unsigned int r_nc_semantics;
 %	char *r_nc_protofmly;
 %	char *r_nc_proto;
 %};
 %typedef struct rpcb_entry rpcb_entry;
+%
 %/*
 % * A list of addresses supported by a service.
 % */
+%
 %struct rpcb_entry_list {
 %	rpcb_entry rpcb_entry_map;
 %	struct rpcb_entry_list *rpcb_entry_next;
 %};
 %typedef struct rpcb_entry_list rpcb_entry_list;
+%
 %typedef rpcb_entry_list *rpcb_entry_list_ptr;
+%
 %/*
 % * rpcbind statistics
 % */
+%
 %#define	rpcb_highproc_2 RPCBPROC_CALLIT
 %#define	rpcb_highproc_3 RPCBPROC_TADDR2UADDR
 %#define	rpcb_highproc_4 RPCBPROC_GETSTAT
 %#define	RPCBSTAT_HIGHPROC 13
 %#define	RPCBVERS_STAT 3
 %#define	RPCBVERS_4_STAT 2
 %#define	RPCBVERS_3_STAT 1
 %#define	RPCBVERS_2_STAT 0
+%
 %/* Link list of all the stats about getport and getaddr */
+%
 %struct rpcbs_addrlist {
 %	rpcprog_t prog;
 %	rpcvers_t vers;
 %	int success;
 %	int failure;
 %	char *netid;
 %	struct rpcbs_addrlist *next;
 %};
 %typedef struct rpcbs_addrlist rpcbs_addrlist;
+%
 %/* Link list of all the stats about rmtcall */
+%
 %struct rpcbs_rmtcalllist {
 %	rpcprog_t prog;
 %	rpcvers_t vers;
 %	rpcproc_t proc;
 %	int success;
 %	int failure;
 %	int indirect;
 %	char *netid;
 %	struct rpcbs_rmtcalllist *next;
 %};
 %typedef struct rpcbs_rmtcalllist rpcbs_rmtcalllist;
+%
 %typedef int rpcbs_proc[RPCBSTAT_HIGHPROC];
+%
 %typedef rpcbs_addrlist *rpcbs_addrlist_ptr;
+%
 %typedef rpcbs_rmtcalllist *rpcbs_rmtcalllist_ptr;
+%
 %struct rpcb_stat {
 %	rpcbs_proc info;
 %	int setinfo;
 %	int unsetinfo;
 %	rpcbs_addrlist_ptr addrinfo;
 %	rpcbs_rmtcalllist_ptr rmtinfo;
 %};
 %typedef struct rpcb_stat rpcb_stat;
+%
 %/*
 % * One rpcb_stat structure is returned for each version of rpcbind
 % * being monitored.
 % */
+%
 %typedef rpcb_stat rpcb_stat_byvers[RPCBVERS_STAT];
+%
 %#ifdef __cplusplus
 %}
 %#endif
+%
 %#endif		/* ifndef _KERNEL */
 #endif		/* RPC_HDR */

 @@ -1,446 +1,449 @@
-/*	$NetBSD: svc.h,v 1.30 2016/01/23 01:05:30 dholland Exp $	*/
+/*	$NetBSD: svc.h,v 1.31 2016/01/23 02:34:09 dholland Exp $	*/
 /*
  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  * unrestricted use provided that this legend is included on all tape
  * media and as a part of the software program in whole or part.  Users
  * may copy or modify Sun RPC without charge, but are not authorized
  * to license or distribute it to anyone else except as part of a product or
  * program developed by the user.
+ *
  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ *
  * Sun RPC is provided with no support and without any obligation on the
  * part of Sun Microsystems, Inc. to assist in its use, correction,
  * modification or enhancement.
+ *
  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  * OR ANY PART THEREOF.
+ *
  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  * or profits or other special, indirect and consequential damages, even if
  * Sun has been advised of the possibility of such damages.
+ *
  * Sun Microsystems, Inc.
  * 2550 Garcia Avenue
  * Mountain View, California  94043
+ *
  *	from: @(#)svc.h 1.35 88/12/17 SMI
  *	@(#)svc.h      1.27    94/04/25 SMI
  */
 /*
  * svc.h, Server-side remote procedure call interface.
+ *
  * Copyright (C) 1986-1993 by Sun Microsystems, Inc.
  */
 #ifndef _RPC_SVC_H_
 #define _RPC_SVC_H_
 #include <sys/cdefs.h>
 #include <rpc/rpc_com.h>
 /*
  * This interface must manage two items concerning remote procedure calling:
+ *
  * 1) An arbitrary number of transport connections upon which rpc requests
  * are received.  The two most notable transports are TCP and UDP;  they are
  * created and registered by routines in svc_tcp.c and svc_udp.c, respectively;
  * they in turn call xprt_register and xprt_unregister.
+ *
  * 2) An arbitrary number of locally registered services.  Services are
  * described by the following four data: program number, version number,
  * "service dispatch" function, a transport handle, and a boolean that
  * indicates whether or not the exported program should be registered with a
  * local binder service;  if true the program's number and version and the
  * port number from the transport handle are registered with the binder.
  * These data are registered with the rpc svc system via svc_register.
+ *
  * A service's dispatch function is called whenever an rpc request comes in
  * on a transport.  The request's program and version numbers must match
  * those of the registered service.  The dispatch function is passed two
  * parameters, struct svc_req * and SVCXPRT *, defined below.
  */
 /*
  *	Service control requests
  */
 #define SVCGET_VERSQUIET	1
 #define SVCSET_VERSQUIET	2
 #define SVCGET_CONNMAXREC	3
 #define SVCSET_CONNMAXREC	4
 enum xprt_stat {
 	XPRT_DIED,
 	XPRT_MOREREQS,
 	XPRT_IDLE
 };
 /*
  * Server side transport handle
  */
 typedef struct __rpc_svcxprt {
 	int		xp_fd;
 	unsigned short	xp_port;	 /* associated port number */
 	const struct xp_ops {
 		/* receive incomming requests */
 		bool_t	(*xp_recv)(struct __rpc_svcxprt *, struct rpc_msg *);
 		/* get transport status */
 		enum xprt_stat (*xp_stat)(struct __rpc_svcxprt *);
 		/* get arguments */
 		bool_t	(*xp_getargs)(struct __rpc_svcxprt *, xdrproc_t,
 			    caddr_t);
 		/* send reply */
 		bool_t	(*xp_reply)(struct __rpc_svcxprt *, struct rpc_msg *);
 		/* free mem allocated for args */
 		bool_t	(*xp_freeargs)(struct __rpc_svcxprt *, xdrproc_t,
 			    caddr_t);
 		/* destroy this struct */
 		void	(*xp_destroy)(struct __rpc_svcxprt *);
 	} *xp_ops;
 	int		xp_addrlen;	 /* length of remote address */
 	struct sockaddr_in xp_raddr;	 /* rem. addr. (backward ABI compat) */
 	/* XXX - fvdl stick this here for ABI backward compat reasons */
 	const struct xp_ops2 {
 		/* catch-all function */
-		bool_t  (*xp_control)(struct __rpc_svcxprt *, const unsigned,
+		bool_t  (*xp_control)(struct __rpc_svcxprt *,
-					   void *);
+					   const unsigned int, void *);
 	} *xp_ops2;
 	char		*xp_tp;		 /* transport provider device name */
 	char		*xp_netid;	 /* network token */
 	struct netbuf	xp_ltaddr;	 /* local transport address */
 	struct netbuf	xp_rtaddr;	 /* remote transport address */
 	struct opaque_auth xp_verf;	 /* raw response verifier */
 	void		*xp_p1;		 /* private: for use by svc ops */
 	void		*xp_p2;		 /* private: for use by svc ops */
 	void		*xp_p3;		 /* private: for use by svc lib */
 	int		xp_type;	 /* transport type */
 } SVCXPRT;
 /*
  * Service request
  */
 struct svc_req {
 	uint32_t	rq_prog;	/* service program number */
 	uint32_t	rq_vers;	/* service protocol version */
 	uint32_t	rq_proc;	/* the desired procedure */
 	struct opaque_auth rq_cred;	/* raw creds from the wire */
 	void		*rq_clntcred;	/* read only cooked cred */
 	SVCXPRT		*rq_xprt;	/* associated transport */
 };
 /*
  * Approved way of getting address of caller
  */
 #define svc_getrpccaller(x) (&(x)->xp_rtaddr)
 /*
  * NetBSD-only definition to get the creds of the caller (AF_LOCAL).
  */
 #define __svc_getcallercreds(x) ((struct sockcred *)(x)->xp_p2)
 /*
  * Operations defined on an SVCXPRT handle
+ *
  * SVCXPRT		*xprt;
  * struct rpc_msg	*msg;
  * xdrproc_t		 xargs;
  * caddr_t		 argsp;
  */
 #define SVC_RECV(xprt, msg)				\
 	(*(xprt)->xp_ops->xp_recv)((xprt), (msg))
 #define svc_recv(xprt, msg)				\
 	(*(xprt)->xp_ops->xp_recv)((xprt), (msg))
 #define SVC_STAT(xprt)					\
 	(*(xprt)->xp_ops->xp_stat)(xprt)
 #define svc_stat(xprt)					\
 	(*(xprt)->xp_ops->xp_stat)(xprt)
 #define SVC_GETARGS(xprt, xargs, argsp)			\
 	(*(xprt)->xp_ops->xp_getargs)((xprt), ((xdrproc_t)(xargs)), (argsp))
 #define svc_getargs(xprt, xargs, argsp)			\
 	(*(xprt)->xp_ops->xp_getargs)((xprt), ((xdrproc_t)(xargs)), (argsp))
 #define SVC_REPLY(xprt, msg)				\
 	(*(xprt)->xp_ops->xp_reply) ((xprt), (msg))
 #define svc_reply(xprt, msg)				\
 	(*(xprt)->xp_ops->xp_reply) ((xprt), (msg))
 #define SVC_FREEARGS(xprt, xargs, argsp)		\
 	(*(xprt)->xp_ops->xp_freeargs)((xprt), ((xdrproc_t)(xargs)), (argsp))
 #define svc_freeargs(xprt, xargs, argsp)		\
 	(*(xprt)->xp_ops->xp_freeargs)((xprt), ((xdrproc_t)(xargs)), (argsp))
 #define SVC_DESTROY(xprt)				\
 	(*(xprt)->xp_ops->xp_destroy)(xprt)
 #define svc_destroy(xprt)				\
 	(*(xprt)->xp_ops->xp_destroy)(xprt)
 #define SVC_CONTROL(xprt, rq, in)			\
 	(*(xprt)->xp_ops2->xp_control)((xprt), (rq), (in))
 /*
  * Service registration
+ *
  * svc_reg(xprt, prog, vers, dispatch, nconf)
  *	const SVCXPRT *xprt;
  *	const rpcprog_t prog;
  *	const rpcvers_t vers;
  *	const void (*dispatch)(...);
  *	const struct netconfig *nconf;
  */
 __BEGIN_DECLS
 extern bool_t	svc_reg(SVCXPRT *, const rpcprog_t, const rpcvers_t,
 			void (*)(struct svc_req *, SVCXPRT *),
 			const struct netconfig *);
 __END_DECLS
 /*
  * Service un-registration
+ *
  * svc_unreg(prog, vers)
  *	const rpcprog_t prog;
  *	const rpcvers_t vers;
  */
 __BEGIN_DECLS
 extern void	svc_unreg(const rpcprog_t, const rpcvers_t);
 __END_DECLS
 /*
  * Transport registration.
+ *
  * xprt_register(xprt)
  *	SVCXPRT *xprt;
  */
 __BEGIN_DECLS
 extern bool_t	xprt_register	(SVCXPRT *);
 __END_DECLS
 /*
  * Transport un-register
+ *
  * xprt_unregister(xprt)
  *	SVCXPRT *xprt;
  */
 __BEGIN_DECLS
 extern void	xprt_unregister	(SVCXPRT *);
 __END_DECLS
 /*
  * When the service routine is called, it must first check to see if it
  * knows about the procedure;  if not, it should call svcerr_noproc
  * and return.  If so, it should deserialize its arguments via
  * SVC_GETARGS (defined above).  If the deserialization does not work,
  * svcerr_decode should be called followed by a return.  Successful
  * decoding of the arguments should be followed the execution of the
  * procedure's code and a call to svc_sendreply.
+ *
  * Also, if the service refuses to execute the procedure due to too-
  * weak authentication parameters, svcerr_weakauth should be called.
  * Note: do not confuse access-control failure with weak authentication!
+ *
  * NB: In pure implementations of rpc, the caller always waits for a reply
  * msg.  This message is sent when svc_sendreply is called.
  * Therefore pure service implementations should always call
  * svc_sendreply even if the function logically returns void;  use
  * xdr.h - xdr_void for the xdr routine.  HOWEVER, tcp based rpc allows
  * for the abuse of pure rpc via batched calling or pipelining.  In the
  * case of a batched call, svc_sendreply should NOT be called since
  * this would send a return message, which is what batching tries to avoid.
  * It is the service/protocol writer's responsibility to know which calls are
  * batched and which are not.  Warning: responding to batch calls may
  * deadlock the caller and server processes!
  */
 __BEGIN_DECLS
 extern bool_t	svc_sendreply	(SVCXPRT *, xdrproc_t, const char *);
 extern void	svcerr_decode	(SVCXPRT *);
 extern void	svcerr_weakauth	(SVCXPRT *);
 extern void	svcerr_noproc	(SVCXPRT *);
 extern void	svcerr_progvers	(SVCXPRT *, rpcvers_t, rpcvers_t);
 extern void	svcerr_auth	(SVCXPRT *, enum auth_stat);
 extern void	svcerr_noprog	(SVCXPRT *);
 extern void	svcerr_systemerr(SVCXPRT *);
 extern int	rpc_reg(rpcprog_t, rpcvers_t, rpcproc_t,
 			     char *(*)(char *), xdrproc_t, xdrproc_t,
 			     char *);
 __END_DECLS
 /*
  * Lowest level dispatching -OR- who owns this process anyway.
  * Somebody has to wait for incoming requests and then call the correct
  * service routine.  The routine svc_run does infinite waiting; i.e.,
  * svc_run never returns.
  * Since another (co-existent) package may wish to selectively wait for
  * incoming calls or other events outside of the rpc architecture, the
  * routine svc_getreq is provided.  It must be passed readfds, the
  * "in-place" results of a select system call (see select, section 2).
  */
 /*
  * Global keeper of rpc service descriptors in use
  * dynamic; must be inspected before each call to select
  */
 #ifdef SVC_LEGACY
 extern int svc_maxfd;
 extern fd_set svc_fdset;
 #else
 #define svc_maxfd (*svc_fdset_getmax())
 #define svc_fdset (*svc_fdset_get())
 #define svc_pollfd svc_pollfd_get()
 #define svc_max_pollfd (*svc_fdset_getmax())
 #endif
 #define svc_fds svc_fdset.fds_bits[0]	/* compatibility */
 /*
  * a small program implemented by the svc_rpc implementation itself;
  * also see clnt.h for protocol numbers.
  */
 __BEGIN_DECLS
 extern void rpctest_service(void);
 __END_DECLS
 __BEGIN_DECLS
 #define SVC_FDSET_MT	1	/* each thread gets own fd_set/pollfd */
 #define SVC_FDSET_POLL	2	/* use poll in svc_run */
 extern void	svc_fdset_init(int);
 extern void	svc_fdset_zero(void);
 extern int	svc_fdset_isset(int);
 extern int	svc_fdset_clr(int);
 extern int	svc_fdset_set(int);
 extern fd_set  *svc_fdset_get(void);
 extern int	svc_fdset_getsize(int);
 extern int     *svc_fdset_getmax(void);
 extern fd_set  *svc_fdset_copy(const fd_set *);
 extern struct pollfd *svc_pollfd_get(void);
 extern int	svc_pollfd_getsize(int);
 extern int     *svc_pollfd_getmax(void);
 extern struct pollfd *svc_pollfd_copy(const struct pollfd *);
 extern void	svc_getreq	(int);
 extern void	svc_getreqset	(fd_set *);
 extern void	svc_getreqset2	(fd_set *, int);
 extern void	svc_getreq_common	(int);
 struct pollfd;
 extern void	svc_getreq_poll(struct pollfd *, int);
 extern void	svc_run		(void);
 extern void	svc_exit	(void);
 __END_DECLS
 /*
  * Socket to use on svcxxx_create call to get default socket
  */
 #define	RPC_ANYSOCK	-1
 #define RPC_ANYFD	RPC_ANYSOCK
 /*
  * These are the existing service side transport implementations
  */
 __BEGIN_DECLS
 /*
  * Transport independent svc_create routine.
  */
 extern int svc_create(void (*)(struct svc_req *, SVCXPRT *),
 			   const rpcprog_t, const rpcvers_t, const char *);
 /*
  *	void (*dispatch)(...);		-- dispatch routine
  *	const rpcprog_t prognum;	-- program number
  *	const rpcvers_t versnum;	-- version number
  *	const char *nettype;		-- network type
  */
 /*
  * Generic server creation routine. It takes a netconfig structure
  * instead of a nettype.
  */
 extern SVCXPRT *svc_tp_create(void (*)(struct svc_req *, SVCXPRT *),
 				   const rpcprog_t, const rpcvers_t,
 				   const struct netconfig *);
 /*
  *	void (*dispatch)(...);		-- dispatch routine
  *	const rpcprog_t prognum;	-- program number
  *	const rpcvers_t versnum;	-- version number
  *	const struct netconfig *nconf;	-- netconfig structure
  */
 /*
  * Generic TLI create routine
  */
 extern SVCXPRT *svc_tli_create(const int, const struct netconfig *,
-				    const struct t_bind *, const unsigned,
+				    const struct t_bind *, const unsigned int,
-				    const unsigned);
+				    const unsigned int);
 /*
  *	const int fd;			-- connection end point
  *	const struct netconfig *nconf;	-- netconfig structure for network
  *	const struct t_bind *bindaddr;	-- local bind address
  *	const unsigned sendsz;		-- max sendsize
  *	const unsigned recvsz;		-- max recvsize
  */
 /*
  * Connectionless and connectionful create routines
  */
-extern SVCXPRT *svc_vc_create(const int, const unsigned, const unsigned);
+extern SVCXPRT *svc_vc_create(const int, const unsigned int,
 				const unsigned int);
 /*
  *	const int fd;			-- open connection end point
  *	const unsigned sendsize;	-- max send size
  *	const unsigned recvsize;	-- max recv size
  */
-extern SVCXPRT *svc_dg_create(const int, const unsigned, const unsigned);
+extern SVCXPRT *svc_dg_create(const int, const unsigned int,
 				const unsigned int);
 /*
  *	const int fd;			-- open connection
  *	const unsigned sendsize;	-- max send size
  *	const unsigned recvsize;	-- max recv size
  */
 /*
  * the routine takes any *open* connection
  * descriptor as its first input and is used for open connections.
  */
-extern SVCXPRT *svc_fd_create(const int, const unsigned, const unsigned);
+extern SVCXPRT *svc_fd_create(const int, const unsigned int,
 				const unsigned int);
 /*
  *	const int fd;			-- open connection end point
  *	const unsigned sendsize;	-- max send size
  *	const unsigned recvsize;	-- max recv size
  */
 /*
  * Memory based rpc (for speed check and testing)
  */
 extern SVCXPRT *svc_raw_create(void);
 /*
  * svc_dg_enable_cache() enables the cache on dg transports.
  */
-int svc_dg_enablecache(SVCXPRT *, const unsigned);
+int svc_dg_enablecache(SVCXPRT *, const unsigned int);
 __END_DECLS
 /* for backward compatibility */
 #include <rpc/svc_soc.h>
 #endif /* !_RPC_SVC_H_ */

 @@ -1,359 +1,361 @@
-/*	$NetBSD: xdr.h,v 1.28 2016/01/23 01:05:30 dholland Exp $	*/
+/*	$NetBSD: xdr.h,v 1.29 2016/01/23 02:34:09 dholland Exp $	*/
 /*
  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  * unrestricted use provided that this legend is included on all tape
  * media and as a part of the software program in whole or part.  Users
  * may copy or modify Sun RPC without charge, but are not authorized
  * to license or distribute it to anyone else except as part of a product or
  * program developed by the user.
+ *
  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ *
  * Sun RPC is provided with no support and without any obligation on the
  * part of Sun Microsystems, Inc. to assist in its use, correction,
  * modification or enhancement.
+ *
  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  * OR ANY PART THEREOF.
+ *
  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  * or profits or other special, indirect and consequential damages, even if
  * Sun has been advised of the possibility of such damages.
+ *
  * Sun Microsystems, Inc.
  * 2550 Garcia Avenue
  * Mountain View, California  94043
+ *
  *	from: @(#)xdr.h 1.19 87/04/22 SMI
  *	@(#)xdr.h	2.2 88/07/29 4.0 RPCSRC
  */
 /*
  * xdr.h, External Data Representation Serialization Routines.
+ *
  * Copyright (C) 1984, Sun Microsystems, Inc.
  */
 #ifndef _RPC_XDR_H_
 #define _RPC_XDR_H_
 #include <sys/cdefs.h>
 /*
  * XDR provides a conventional way for converting between C data
  * types and an external bit-string representation.  Library supplied
  * routines provide for the conversion on built-in C data types.  These
  * routines and utility routines defined here are used to help implement
  * a type encode/decode routine for each user-defined type.
+ *
  * Each data type provides a single procedure which takes two arguments:
+ *
  *	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
  * converted.  The XDR handle contains an operation field which indicates
  * which of the operations (ENCODE, DECODE * or FREE) is to be performed.
+ *
  * XDR_DECODE may allocate space if the pointer argresp is null.  This
  * data can be freed with the XDR_FREE operation.
+ *
  * We write only one procedure per data type to make it easy
  * to keep the encode and decode procedures for a data type consistent.
  * In many cases the same code performs all operations on a user defined type,
  * because all the hard work is done in the component type routines.
  * decode as a series of calls on the nested data types.
  */
 /*
  * Xdr operations.  XDR_ENCODE causes the type to be encoded into the
  * stream.  XDR_DECODE causes the type to be extracted from the stream.
  * 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
 };
 /*
  * This is the number of bytes per unit of external data.
  */
 #define BYTES_PER_XDR_UNIT	(4)
 #define RNDUP(x)  ((((x) + BYTES_PER_XDR_UNIT - 1) / BYTES_PER_XDR_UNIT) \
 		    * BYTES_PER_XDR_UNIT)
 /*
  * The XDR handle.
  * Contains operation which is being applied to the stream,
  * an operations vector for the paticular implementation (e.g. see xdr_mem.c),
  * and two private fields for the use of the particular impelementation.
  */
 typedef struct __rpc_xdr {
 	enum xdr_op	x_op;		/* operation; fast additional param */
 	const struct xdr_ops {
 		/* get a long from underlying stream */
 		bool_t	(*x_getlong)(struct __rpc_xdr *, long *);
 		/* put a long to " */
 		bool_t	(*x_putlong)(struct __rpc_xdr *, const long *);
 		/* get some bytes from " */
-		bool_t	(*x_getbytes)(struct __rpc_xdr *, char *, unsigned);
+		bool_t	(*x_getbytes)(struct __rpc_xdr *, char *, unsigned int);
 		/* put some bytes to " */
 		bool_t	(*x_putbytes)(struct __rpc_xdr *, const char *,
-					unsigned);
+					unsigned int);
 		/* returns bytes off from beginning */
 		unsigned (*x_getpostn)(struct __rpc_xdr *);
 		/* lets you reposition the stream */
-		bool_t  (*x_setpostn)(struct __rpc_xdr *, unsigned);
+		bool_t  (*x_setpostn)(struct __rpc_xdr *, unsigned int);
 		/* buf quick ptr to buffered data */
-		int32_t	*(*x_inline)(struct __rpc_xdr *, unsigned);
+		int32_t	*(*x_inline)(struct __rpc_xdr *, unsigned int);
 		/* free privates of this xdr_stream */
 		void	(*x_destroy)(struct __rpc_xdr *);
 		bool_t	(*x_control)(struct __rpc_xdr *, int, void *);
 	} *x_ops;
 	char *	 	x_public;	/* users' data */
 	void *		x_private;	/* pointer to private data */
 	char * 		x_base;		/* private used for position info */
-	unsigned	x_handy;	/* extra private word */
+	unsigned int	x_handy;	/* extra private word */
 } XDR;
 /*
  * A xdrproc_t exists for each data type which is to be encoded or decoded.
+ *
  * The second argument to the xdrproc_t is a pointer to an opaque pointer.
  * 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.
  */
 typedef	bool_t (*xdrproc_t)(XDR *, const void *);
 /*
  * Operations defined on a XDR handle
+ *
  * XDR		*xdrs;
  * long		*longp;
  * char *	 addr;
  * unsigned	 len;
  * unsigned	 pos;
  */
 #define XDR_GETLONG(xdrs, longp)			\
 	(*(xdrs)->x_ops->x_getlong)(xdrs, longp)
 #define xdr_getlong(xdrs, longp)			\
 	(*(xdrs)->x_ops->x_getlong)(xdrs, longp)
 #define XDR_PUTLONG(xdrs, longp)			\
 	(*(xdrs)->x_ops->x_putlong)(xdrs, longp)
 #define xdr_putlong(xdrs, longp)			\
 	(*(xdrs)->x_ops->x_putlong)(xdrs, longp)
 static __inline int
 xdr_getint32(XDR *xdrs, int32_t *ip)
+{
 	long l;
 	if (!xdr_getlong(xdrs, &l))
 		return 0;
 	*ip = (int32_t)l;
 	return 1;
+}
 static __inline int
 xdr_putint32(XDR *xdrs, int32_t *ip)
+{
 	long l;
 	l = (long)*ip;
 	return xdr_putlong(xdrs, &l);
+}
 #define XDR_GETINT32(xdrs, int32p)	xdr_getint32(xdrs, int32p)
 #define XDR_PUTINT32(xdrs, int32p)	xdr_putint32(xdrs, int32p)
 #define XDR_GETBYTES(xdrs, addr, len)			\
 	(*(xdrs)->x_ops->x_getbytes)(xdrs, addr, len)
 #define xdr_getbytes(xdrs, addr, len)			\
 	(*(xdrs)->x_ops->x_getbytes)(xdrs, addr, len)
 #define XDR_PUTBYTES(xdrs, addr, len)			\
 	(*(xdrs)->x_ops->x_putbytes)(xdrs, addr, len)
 #define xdr_putbytes(xdrs, addr, len)			\
 	(*(xdrs)->x_ops->x_putbytes)(xdrs, addr, len)
 #define XDR_GETPOS(xdrs)				\
 	(*(xdrs)->x_ops->x_getpostn)(xdrs)
 #define xdr_getpos(xdrs)				\
 	(*(xdrs)->x_ops->x_getpostn)(xdrs)
 #define XDR_SETPOS(xdrs, pos)				\
 	(*(xdrs)->x_ops->x_setpostn)(xdrs, pos)
 #define xdr_setpos(xdrs, pos)				\
 	(*(xdrs)->x_ops->x_setpostn)(xdrs, pos)
 #define	XDR_INLINE(xdrs, len)				\
 	(*(xdrs)->x_ops->x_inline)(xdrs, len)
 #define	xdr_inline(xdrs, len)				\
 	(*(xdrs)->x_ops->x_inline)(xdrs, len)
 #define	XDR_DESTROY(xdrs)				\
 	if ((xdrs)->x_ops->x_destroy) 			\
 		(*(xdrs)->x_ops->x_destroy)(xdrs)
 #define	xdr_destroy(xdrs)				\
 	if ((xdrs)->x_ops->x_destroy) 			\
 		(*(xdrs)->x_ops->x_destroy)(xdrs)
 #define XDR_CONTROL(xdrs, req, op)			\
 	if ((xdrs)->x_ops->x_control)			\
 		(*(xdrs)->x_ops->x_control)(xdrs, req, op)
 #define xdr_control(xdrs, req, op) XDR_CONTROL(xdrs, req, op)
 /*
  * Solaris strips the '_t' from these types -- not sure why.
  * But, let's be compatible.
  */
 #define xdr_rpcvers(xdrs, versp) xdr_u_int32(xdrs, versp)
 #define xdr_rpcprog(xdrs, progp) xdr_u_int32(xdrs, progp)
 #define xdr_rpcproc(xdrs, procp) xdr_u_int32(xdrs, procp)
 #define xdr_rpcprot(xdrs, protp) xdr_u_int32(xdrs, protp)
 #define xdr_rpcport(xdrs, portp) xdr_u_int32(xdrs, portp)
 /*
  * Support struct for discriminated unions.
  * You create an array of xdrdiscrim structures, terminated with
  * a entry with a null procedure pointer.  The xdr_union routine gets
  * the discriminant value and then searches the array of structures
  * for a matching value.  If a match is found the associated xdr routine
  * is called to handle that part of the union.  If there is
  * no match, then a default routine may be called.
  * 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;
 };
 /*
  * In-line routines for fast encode/decode of primitive data types.
  * Caveat emptor: these use single memory cycles to get the
  * 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 (0);
  *	<<< macro calls >>>
  * where ``count'' is the number of bytes of data occupied
  * by the primitive data types.
+ *
  * N.B. and frozen for all time: each data type here uses 4 bytes
  * of external representation.
  */
 #define IXDR_GET_INT32(buf)		((int32_t)ntohl((uint32_t)*(buf)++))
 #define IXDR_PUT_INT32(buf, v)		(*(buf)++ =(int32_t)htonl((uint32_t)v))
 #define IXDR_GET_U_INT32(buf)		((uint32_t)IXDR_GET_INT32(buf))
 #define IXDR_PUT_U_INT32(buf, v)	IXDR_PUT_INT32((buf), ((int32_t)(v)))
 #define IXDR_GET_LONG(buf)		((long)ntohl((uint32_t)*(buf)++))
 #define IXDR_PUT_LONG(buf, v)		(*(buf)++ =(int32_t)htonl((uint32_t)v))
 #define IXDR_GET_BOOL(buf)		((bool_t)IXDR_GET_LONG(buf))
 #define IXDR_GET_ENUM(buf, t)		((t)IXDR_GET_LONG(buf))
 #define IXDR_GET_U_LONG(buf)		((unsigned long)IXDR_GET_LONG(buf))
 #define IXDR_GET_SHORT(buf)		((short)IXDR_GET_LONG(buf))
 #define IXDR_GET_U_SHORT(buf)		((unsigned short)IXDR_GET_LONG(buf))
 #define IXDR_PUT_BOOL(buf, v)		IXDR_PUT_LONG((buf), (v))
 #define IXDR_PUT_ENUM(buf, v)		IXDR_PUT_LONG((buf), (v))
 #define IXDR_PUT_U_LONG(buf, v)		IXDR_PUT_LONG((buf), (v))
 #define IXDR_PUT_SHORT(buf, v)		IXDR_PUT_LONG((buf), (v))
 #define IXDR_PUT_U_SHORT(buf, v)	IXDR_PUT_LONG((buf), (v))
 /*
  * These are the "generic" xdr routines.
  */
 __BEGIN_DECLS
 extern bool_t	xdr_void(void);
 extern bool_t	xdr_int(XDR *, int *);
-extern bool_t	xdr_u_int(XDR *, unsigned *);
+extern bool_t	xdr_u_int(XDR *, unsigned int *);
 extern bool_t	xdr_long(XDR *, long *);
 extern bool_t	xdr_u_long(XDR *, unsigned long *);
 extern bool_t	xdr_short(XDR *, short *);
 extern bool_t	xdr_u_short(XDR *, unsigned short *);
 extern bool_t	xdr_int16_t(XDR *, int16_t *);
 extern bool_t	xdr_u_int16_t(XDR *, uint16_t *);
 extern bool_t	xdr_int32_t(XDR *, int32_t *);
 extern bool_t	xdr_u_int32_t(XDR *, uint32_t *);
 extern bool_t	xdr_int64_t(XDR *, int64_t *);
 extern bool_t	xdr_u_int64_t(XDR *, uint64_t *);
 extern bool_t	xdr_bool(XDR *, bool_t *);
 extern bool_t	xdr_enum(XDR *, enum_t *);
-extern bool_t	xdr_array(XDR *, char **, unsigned *, unsigned, unsigned, xdrproc_t);
+extern bool_t	xdr_array(XDR *, char **, unsigned int *, unsigned int,
-extern bool_t	xdr_bytes(XDR *, char **, unsigned *, unsigned);
+			unsigned int, xdrproc_t);
-extern bool_t	xdr_opaque(XDR *, char *, unsigned);
+extern bool_t	xdr_bytes(XDR *, char **, unsigned int *, unsigned int);
-extern bool_t	xdr_string(XDR *, char **, unsigned);
+extern bool_t	xdr_opaque(XDR *, char *, unsigned int);
 extern bool_t	xdr_string(XDR *, char **, unsigned int);
 extern bool_t	xdr_union(XDR *, enum_t *, char *, const struct xdr_discrim *, xdrproc_t);
 extern bool_t	xdr_char(XDR *, char *);
 extern bool_t	xdr_u_char(XDR *, unsigned char *);
-extern bool_t	xdr_vector(XDR *, char *, unsigned, unsigned, xdrproc_t);
+extern bool_t	xdr_vector(XDR *, char *, unsigned int, unsigned int,
 			xdrproc_t);
 extern bool_t	xdr_float(XDR *, float *);
 extern bool_t	xdr_double(XDR *, double *);
 extern bool_t	xdr_quadruple(XDR *, long double *);
-extern bool_t	xdr_reference(XDR *, char **, unsigned, xdrproc_t);
+extern bool_t	xdr_reference(XDR *, char **, unsigned int, xdrproc_t);
-extern bool_t	xdr_pointer(XDR *, char **, unsigned, xdrproc_t);
+extern bool_t	xdr_pointer(XDR *, char **, unsigned int, xdrproc_t);
 extern bool_t	xdr_wrapstring(XDR *, char **);
 extern void	xdr_free(xdrproc_t, char *);
 extern bool_t	xdr_hyper(XDR *, longlong_t *);
 extern bool_t	xdr_u_hyper(XDR *, u_longlong_t *);
 extern bool_t	xdr_longlong_t(XDR *, longlong_t *);
 extern bool_t	xdr_u_longlong_t(XDR *, u_longlong_t *);
 extern unsigned long xdr_sizeof(xdrproc_t, void *);
 __END_DECLS
 /*
  * Common opaque bytes objects used by many rpc protocols;
  * declared here due to commonality.
  */
 #define MAX_NETOBJ_SZ 1024
 struct netobj {
-	unsigned n_len;
+	unsigned int n_len;
 	char	*n_bytes;
 };
 typedef struct netobj netobj;
 extern bool_t   xdr_netobj(XDR *, struct netobj *);
 /*
  * These are the public routines for the various implementations of
  * xdr streams.
  */
 __BEGIN_DECLS
 /* XDR using memory buffers */
-extern void   xdrmem_create(XDR *, char *, unsigned, enum xdr_op);
+extern void   xdrmem_create(XDR *, char *, unsigned int, enum xdr_op);
 /* XDR using stdio library */
 #ifdef _STDIO_H_
 extern void   xdrstdio_create(XDR *, FILE *, enum xdr_op);
 #endif
 /* XDR pseudo records for tcp */
-extern void   xdrrec_create(XDR *, unsigned, unsigned, char *,
+extern void   xdrrec_create(XDR *, unsigned int, unsigned int, char *,
 				int (*)(char *, char *, int),
 				int (*)(char *, char *, int));
 /* make end of xdr record */
 extern bool_t xdrrec_endofrecord(XDR *, int);
 /* move to beginning of next record */
 extern bool_t xdrrec_skiprecord(XDR *);
 /* true if no more input */
 extern bool_t xdrrec_eof(XDR *);
-extern unsigned xdrrec_readbytes(XDR *, caddr_t, unsigned);
+extern unsigned xdrrec_readbytes(XDR *, caddr_t, unsigned int);
 __END_DECLS
 #endif /* !_RPC_XDR_H_ */