+2001-06-28 Ezra Peisach <epeisach@mit.edu>
+
+ * auth.h: Provide full prototype for xdr_des_block.
+
+ * auth_gssapi.h: Complete prototypes for
+ _svcauth_gssapi_unset_names().
+
+ * clnt.h: Prototype dispatch functions and all functions.
+
+ * clnt_perror.c: Prototype static auth_errmsg().
+
+ * clnt_raw.h clnt_tcp.c, clnt_udp.c: Provide prototypes to static
+ functions and match dispatch table prototypes. control function
+ takes void * instead of caddr_t.
+
+ * pmap_rmt.c: Move prototype for resultproc_t to pmap_clnt.h.
+
+ * rpc.h: get_myaddress returns int. Add prototypes for callrpc and
+ getrpcport.
+
+ * rpc_commondata.c (rpc_createerr): When initializing rpc_creaerr
+ use RPC_SUCCESS instead of 0.
+
+ * get_myaddress.c, rpc_dtablesize.c: Include gssrpc/rpc.h for
+ prototype.
+
+ * pmap_clnt.h, pmap_prot.h, pmap_rmt.h, rpc_msg.h: Full prototypes
+ for all functions.
+
+ * svc.c: Provide full prototype for static function.
+
+ * svc.h: Prototypes for dispatch functions added. Flushed out
+ prototypes for all functions missing prototypes. Added prototype
+ for svcfd_create.
+
+ * svc_auth.c: Prototypes for all functions referenced.
+
+ * svc_auth.h: Prototype dispatch functions to svc_auth_ops.
+
+ * svc_auth_any.c: Replace use of authany_wrap() with a new local
+ function that matches svc_auth_ops dispatch table.
+
+ * svc_simple.c: Provide prototype for static function
+ universal. Fill in missing types of parameters to
+ gssrpc_registerrpc.
+
+ * svc_raw.c svc_tcp.c, svc_udp.c: Provide prototypes for static
+ functions and match prototypes in dispatch table. Change getargs
+ and freeargs argument to void * from caddr_t.
+
+ * xdr.c (xdr_void): Function to match prototype of arguments given.
+
+ * xdr.h: Provide full prototypes for xdr_ops dispatch table and
+ xdr_void().
+
+ * svc_auth_gssapi.c, xdr_alloc.c, xdr_mem.c, xdr_rec.c,
+ xdr_stdio.c: Provide protypes for static functions and match
+ dispatch tables.
+
2001-06-27 Ezra Peisach <epeisach@mit.edu>
* bindresvport.c: Include gssrpc/rpc.h for prototype.
};
typedef union des_block des_block;
#define xdr_des_block gssrpc_xdr_des_block
-extern bool_t xdr_des_block();
+extern bool_t xdr_des_block(XDR *, des_block *);
/*
* Authentication info. Opaque to client.
bool_t _svcauth_gssapi_set_names
PROTOTYPE((auth_gssapi_name *names, int num));
void _svcauth_gssapi_unset_names
-PROTOTYPE(());
+PROTOTYPE((void));
void _svcauth_gssapi_set_log_badauth_func
PROTOTYPE((auth_gssapi_log_badauth_func func,
* Created by individual implementations, see e.g. rpc_udp.c.
* Client is responsible for initializing auth, see e.g. auth_none.c.
*/
-typedef struct {
+typedef struct __rpc_client {
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 */
+ /* call remote procedure */
+ enum clnt_stat (*cl_call)(struct __rpc_client *,
+ rpc_u_int32, xdrproc_t, void *,
+ xdrproc_t, void *,
+ 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, void *);
+ /* destroy this structure */
+ void (*cl_destroy)(struct __rpc_client *);
+ /* the ioctl() of rpc */
+ bool_t (*cl_control)(struct __rpc_client *, int,
+ void *);
} *cl_ops;
caddr_t cl_private; /* private stuff */
} CLIENT;
* rpc_u_int32 vers;
*/
#define clntraw_create gssrpc_clntraw_create
-extern CLIENT *clntraw_create();
+extern CLIENT *clntraw_create(rpc_u_int32, rpc_u_int32);
/*
*/
#define clnt_create gssrpc_clnt_create
extern CLIENT *
-clnt_create(/*host, prog, vers, prot*/); /*
- char *host; -- hostname
- rpc_u_int32 prog; -- program number
- rpc_u_int32 vers; -- version number
- char *prot; -- protocol
-*/
-
+clnt_create(char *, rpc_u_int32, rpc_u_int32, char *);
* unsigned int recvsz;
*/
#define clnttcp_create gssrpc_clnttcp_create
-extern CLIENT *clnttcp_create();
+extern CLIENT *clnttcp_create(struct sockaddr_in *, rpc_u_int32, rpc_u_int32,
+ int *, unsigned int, unsigned int);
/*
* UDP based rpc.
*/
#define clntudp_create gssrpc_clntudp_create
#define clntudp_bufcreate gssrpc_clntudp_bufcreate
-extern CLIENT *clntudp_create();
-extern CLIENT *clntudp_bufcreate();
+extern CLIENT *clntudp_create(struct sockaddr_in *, rpc_u_int32,
+ rpc_u_int32, struct timeval, int *);
+extern CLIENT *clntudp_bufcreate(struct sockaddr_in *, rpc_u_int32,
+ rpc_u_int32, struct timeval, int *,
+ unsigned int, unsigned int);
#define _rpc_dtablesize _gssrpc_rpc_dtablesize
extern int _rpc_dtablesize(void);
*/
#define clnt_pcreateerror gssrpc_clnt_pcreateerror
#define clnt_spcreateerror gssrpc_clnt_spcreateerror
-void clnt_pcreateerror(/* char *msg */); /* stderr */
-char *clnt_spcreateerror(/* char *msg */); /* string */
+void clnt_pcreateerror(char *); /* stderr */
+char *clnt_spcreateerror(char *); /* string */
/*
* Like clnt_perror(), but is more verbose in its output
*/
#define clnt_perrno gssrpc_clnt_perrno
-void clnt_perrno(/* enum clnt_stat num */); /* stderr */
+void clnt_perrno(enum clnt_stat num); /* stderr */
/*
* Print an English error message, given the client error code
*/
#define clnt_perror gssrpc_clnt_perror
#define clnt_sperror gssrpc_clnt_sperror
-void clnt_perror(/* CLIENT *clnt, char *msg */); /* stderr */
-char *clnt_sperror(/* CLIENT *clnt, char *msg */); /* string */
+void clnt_perror(CLIENT *, char *); /* stderr */
+char *clnt_sperror(CLIENT *, char *); /* string */
/*
* If a creation fails, the following allows the user to figure out why.
* Copy error message to buffer.
*/
#define clnt_sperrno gssrpc_clnt_sperrno
-char *clnt_sperrno(/* enum clnt_stat num */); /* string */
+char *clnt_sperrno(enum clnt_stat num); /* string */
#define UDPMSGSIZE 8800 /* rpc imposed limit on udp msg size */
#define RPCSMALLMSGSIZE 400 /* a more reasonable packet size */
#undef strerror
#define strerror(N) (((N) > 0 && (N) < sys_nerr) ? sys_errlist[N] : (char *)0)
#endif /* HAVE_STRERROR */
-static char *auth_errmsg();
+static char *auth_errmsg(enum auth_stat);
unsigned int mcnt;
} *clntraw_private;
-static enum clnt_stat clntraw_call();
-static void clntraw_abort();
-static void clntraw_geterr();
-static bool_t clntraw_freeres();
-static bool_t clntraw_control();
-static void clntraw_destroy();
+static enum clnt_stat clntraw_call(CLIENT *, rpc_u_int32, xdrproc_t,
+ void *, xdrproc_t, void *,
+ struct timeval);
+static void clntraw_abort(CLIENT *);
+static void clntraw_geterr(CLIENT *, struct rpc_err *);
+static bool_t clntraw_freeres(CLIENT *, xdrproc_t, void *);
+static bool_t clntraw_control(CLIENT *, int, void *);
+static void clntraw_destroy(CLIENT *);
static struct clnt_ops client_ops = {
clntraw_call,
CLIENT *h;
rpc_u_int32 proc;
xdrproc_t xargs;
- caddr_t argsp;
+ void * argsp;
xdrproc_t xresults;
- caddr_t resultsp;
+ void * resultsp;
struct timeval timeout;
{
register struct clntraw_private *clp = clntraw_private;
* specifies a receive buffer size that is too small.)
* This memory must be free()ed to avoid a leak.
*/
- int op = xdrs->x_op;
+ enum xdr_op op = xdrs->x_op;
xdrs->x_op = XDR_FREE;
xdr_replymsg(xdrs, &msg);
xdrs->x_op = op;
return (status);
}
+/*ARGSUSED*/
static void
-clntraw_geterr()
+clntraw_geterr(cl, err)
+ CLIENT *cl;
+ struct rpc_err *err;
{
}
clntraw_freeres(cl, xdr_res, res_ptr)
CLIENT *cl;
xdrproc_t xdr_res;
- caddr_t res_ptr;
+ void *res_ptr;
{
register struct clntraw_private *clp = clntraw_private;
register XDR *xdrs = &clp->xdr_stream;
return ((*xdr_res)(xdrs, res_ptr));
}
+/*ARGSUSED*/
static void
-clntraw_abort()
+clntraw_abort(cl)
+ CLIENT *cl;
{
}
+/*ARGSUSED*/
static bool_t
-clntraw_control()
+clntraw_control(cl, request, info)
+ CLIENT *cl;
+ int request;
+ void *info;
{
return (FALSE);
}
+/*ARGSUSED*/
static void
-clntraw_destroy()
+clntraw_destroy(cl)
+ CLIENT *cl;
{
}
extern int errno;
-static int readtcp();
-static int writetcp();
-
-static enum clnt_stat clnttcp_call();
-static void clnttcp_abort();
-static void clnttcp_geterr();
-static bool_t clnttcp_freeres();
-static bool_t clnttcp_control();
-static void clnttcp_destroy();
+static enum clnt_stat clnttcp_call(CLIENT *, rpc_u_int32, xdrproc_t, void *,
+ xdrproc_t, void *, struct timeval);
+static void clnttcp_abort(CLIENT *);
+static void clnttcp_geterr(CLIENT *, struct rpc_err *);
+static bool_t clnttcp_freeres(CLIENT *, xdrproc_t, void *);
+static bool_t clnttcp_control(CLIENT *, int, void *);
+static void clnttcp_destroy(CLIENT *);
static struct clnt_ops tcp_ops = {
clnttcp_call,
XDR ct_xdrs;
};
+static int readtcp(struct ct_data *, caddr_t, int);
+static int writetcp(struct ct_data *, caddr_t, int);
+
+
/*
* Create a client handle for a tcp/ip connection.
* If *sockp<0, *sockp is set to a newly created TCP socket and it is
register CLIENT *h;
rpc_u_int32 proc;
xdrproc_t xdr_args;
- caddr_t args_ptr;
+ void * args_ptr;
xdrproc_t xdr_results;
- caddr_t results_ptr;
+ void * results_ptr;
struct timeval timeout;
{
register struct ct_data *ct = (struct ct_data *) h->cl_private;
* to avoid leaks, since it may allocate
* memory from partially successful decodes.
*/
- int op = xdrs->x_op;
+ enum xdr_op op = xdrs->x_op;
xdrs->x_op = XDR_FREE;
xdr_replymsg(xdrs, &reply_msg);
xdrs->x_op = op;
clnttcp_freeres(cl, xdr_res, res_ptr)
CLIENT *cl;
xdrproc_t xdr_res;
- caddr_t res_ptr;
+ void * res_ptr;
{
register struct ct_data *ct = (struct ct_data *)cl->cl_private;
register XDR *xdrs = &(ct->ct_xdrs);
return ((*xdr_res)(xdrs, res_ptr));
}
+/*ARGSUSED*/
static void
-clnttcp_abort()
+clnttcp_abort(cl)
+ CLIENT *cl;
{
}
clnttcp_control(cl, request, info)
CLIENT *cl;
int request;
- char *info;
+ void *info;
{
register struct ct_data *ct = (struct ct_data *)cl->cl_private;
int len;
/*
* 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 *, rpc_u_int32, xdrproc_t, void *,
+ xdrproc_t, void *, struct timeval);
+static void clntudp_abort(CLIENT *);
+static void clntudp_geterr(CLIENT *, struct rpc_err *);
+static bool_t clntudp_freeres(CLIENT *, xdrproc_t, void *);
+static bool_t clntudp_control(CLIENT *, int, void *);
+static void clntudp_destroy(CLIENT *);
static struct clnt_ops udp_ops = {
clntudp_call,
register CLIENT *cl; /* client handle */
rpc_u_int32 proc; /* procedure number */
xdrproc_t xargs; /* xdr routine for args */
- caddr_t argsp; /* pointer to args */
+ void * argsp; /* pointer to args */
xdrproc_t xresults; /* xdr routine for results */
- caddr_t resultsp; /* pointer to results */
+ void * resultsp; /* pointer to results */
struct timeval utimeout; /* seconds to wait before giving up */
{
register struct cu_data *cu = (struct cu_data *)cl->cl_private;
* specifies a receive buffer size that is too small.)
* This memory must be free()ed to avoid a leak.
*/
- int op = reply_xdrs.x_op;
+ enum xdr_op op = reply_xdrs.x_op;
reply_xdrs.x_op = XDR_FREE;
xdr_replymsg(&reply_xdrs, &reply_msg);
reply_xdrs.x_op = op;
clntudp_freeres(cl, xdr_res, res_ptr)
CLIENT *cl;
xdrproc_t xdr_res;
- caddr_t res_ptr;
+ void *res_ptr;
{
register struct cu_data *cu = (struct cu_data *)cl->cl_private;
register XDR *xdrs = &(cu->cu_outxdrs);
return ((*xdr_res)(xdrs, res_ptr));
}
+
+/*ARGSUSED*/
static void
-clntudp_abort(/*h*/)
- /*CLIENT *h;*/
+clntudp_abort(h)
+ CLIENT *h;
{
}
clntudp_control(cl, request, info)
CLIENT *cl;
int request;
- char *info;
+ void *info;
{
register struct cu_data *cu = (struct cu_data *)cl->cl_private;
#ifdef GSSAPI_KRB5
#include <string.h>
#include <gssrpc/types.h>
+#include <gssrpc/rpc.h>
#include <gssrpc/pmap_prot.h>
#include <sys/socket.h>
#include <netinet/in.h>
#define clnt_broadcast gssrpc_clnt_broadcast
#define pmap_getport gssrpc_pmap_getport
-extern bool_t pmap_set();
-extern bool_t pmap_unset();
-extern struct pmaplist *pmap_getmaps();
-enum clnt_stat pmap_rmtcall();
-enum clnt_stat clnt_broadcast();
-extern unsigned short pmap_getport();
+extern bool_t pmap_set(rpc_u_int32, rpc_u_int32, int,
+ unsigned short);
+extern bool_t pmap_unset(rpc_u_int32, rpc_u_int32);
+extern struct pmaplist *pmap_getmaps(struct sockaddr_in *);
+enum clnt_stat pmap_rmtcall(struct sockaddr_in *, rpc_u_int32,
+ rpc_u_int32, rpc_u_int32, xdrproc_t,
+ caddr_t, xdrproc_t, caddr_t,
+ struct timeval, rpc_u_int32 *);
+
+typedef bool_t (*resultproc_t)(caddr_t, struct sockaddr_in *);
+
+enum clnt_stat clnt_broadcast(rpc_u_int32, rpc_u_int32, rpc_u_int32,
+ xdrproc_t, caddr_t, xdrproc_t,
+ caddr_t, resultproc_t);
+extern unsigned short pmap_getport(struct sockaddr_in *,
+ rpc_u_int32,
+ rpc_u_int32, unsigned int);
};
#define xdr_pmap gssrpc_xdr_pmap
-extern bool_t xdr_pmap();
+extern bool_t xdr_pmap(XDR *, struct pmap *);
struct pmaplist {
struct pmap pml_map;
};
#define xdr_pmaplist gssrpc_xdr_pmaplist
-extern bool_t xdr_pmaplist();
+extern bool_t xdr_pmaplist(XDR *, struct pmaplist **);
return (i);
}
-typedef bool_t (*resultproc_t)();
-
enum clnt_stat
clnt_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp, eachresult)
rpc_u_int32 prog; /* program number */
};
#define xdr_rmtcall_args gssrpc_xdr_rmtcall_args
-bool_t xdr_rmtcall_args();
+bool_t xdr_rmtcall_args(XDR *, struct rmtcallargs *);
struct rmtcallres {
rpc_u_int32 *port_ptr;
};
#define xdr_rmtcallres gssrpc_xdr_rmtcallres
-bool_t xdr_rmtcallres();
+bool_t xdr_rmtcallres(XDR *, struct rmtcallres *);
* name service library functions
*/
#define get_myaddress gssrpc_get_myaddress
-extern void get_myaddress (struct sockaddr_in *);
+extern int get_myaddress (struct sockaddr_in *);
#define bindresvport gssrpc_bindresvport
extern int bindresvport(int, struct sockaddr_in *);
+#define callrpc gssrpc_callrpc
+extern int callrpc (char *, int, int, int, xdrproc_t, char *,
+ xdrproc_t , char *);
+
+#define getrpcport gssrpc_getrpcport
+extern int getrpcport (char *, int, int, int);
+
#endif /* ndef __RPC_HEADER__ */
#else
int svc_fds = 0;
#endif /* def FD_SETSIZE */
-struct rpc_createerr rpc_createerr = {0};
+struct rpc_createerr rpc_createerr = {RPC_SUCCESS};
#endif
#include <unistd.h>
+#include <gssrpc/rpc.h>
/*
* Cache the result of getdtablesize(), so we don't have to do an
* struct rpc_msg *cmsg;
*/
#define xdr_callmsg gssrpc_xdr_callmsg
-extern bool_t xdr_callmsg();
+extern bool_t xdr_callmsg(XDR *, struct rpc_msg *);
/*
* XDR routine to pre-serialize the static part of a rpc message.
* struct rpc_msg *cmsg;
*/
#define xdr_callhdr gssrpc_xdr_callhdr
-extern bool_t xdr_callhdr();
+extern bool_t xdr_callhdr(XDR *, struct rpc_msg *);
/*
* XDR routine to handle a rpc reply.
* struct rpc_msg *rmsg;
*/
#define xdr_replymsg gssrpc_xdr_replymsg
-extern bool_t xdr_replymsg();
+extern bool_t xdr_replymsg(XDR *, struct rpc_msg *);
/*
* Fills in the error part of a reply message.
*/
#define _seterr_reply _gssrpc_seterr_reply
#define sunrpc_seterr_reply _seterr_reply
-extern void _seterr_reply();
+extern void _seterr_reply(struct rpc_msg *, struct rpc_err *);
+
+/* XDR the MSG_ACCEPTED part of a reply message union */
+#define xdr_accepted_reply gssrpc_xdr_accepted_reply
+extern bool_t xdr_accepted_reply(XDR *, struct accepted_reply *);
+
+/* XDR the MSG_DENIED part of a reply message union */
+#define xdr_rejected_reply gssrpc_xdr_rejected_reply
+extern bool_t xdr_rejected_reply(XDR *, struct rejected_reply *);
+
void (*sc_dispatch)();
} *svc_head;
-static struct svc_callout *svc_find();
+static struct svc_callout *svc_find(rpc_u_int32, rpc_u_int32,
+ struct svc_callout **);
/* *************** SVCXPRT related stuff **************** */
/*
* Server side transport handle
*/
-typedef struct {
+typedef struct __rpc_svcxprt {
int xp_sock;
unsigned short xp_port; /* associated port number */
struct xp_ops {
- bool_t (*xp_recv)(); /* receive incomming 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 */
+ /* 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,
+ void *);
+ /* 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,
+ void *);
+ /* destroy this struct */
+ void (*xp_destroy)(struct __rpc_svcxprt *);
} *xp_ops;
int xp_addrlen; /* length of remote address */
struct sockaddr_in xp_raddr; /* remote address */
* rpc_u_int32 vers;
* void (*dispatch)();
* int protocol; like TCP or UDP, zero means do not register
+ *
+ * registerrpc(prog, vers, proc, routine, inproc, outproc)
+ * returns 0 upon success, -1 if error.
*/
#define svc_register gssrpc_svc_register
-extern bool_t svc_register();
+extern bool_t svc_register(SVCXPRT *, rpc_u_int32, rpc_u_int32,
+ void (*)(struct svc_req *, SVCXPRT *), int);
+
+#define registerrpc gssrpc_registerrpc
+extern int registerrpc(rpc_u_int32, rpc_u_int32, rpc_u_int32,
+ char *(*)(void *),
+ xdrproc_t, xdrproc_t);
/*
* Service un-registration
* rpc_u_int32 vers;
*/
#define svc_unregister gssrpc_svc_unregister
-extern void svc_unregister();
+extern void svc_unregister(rpc_u_int32, rpc_u_int32);
/*
* Transport registration.
* SVCXPRT *xprt;
*/
#define xprt_register gssrpc_xprt_register
-extern void xprt_register();
+extern void xprt_register(SVCXPRT *);
/*
* Transport un-register
* SVCXPRT *xprt;
*/
#define xprt_unregister gssrpc_xprt_unregister
-extern void xprt_unregister();
+extern void xprt_unregister(SVCXPRT *);
#define svcerr_noprog gssrpc_svcerr_noprog
#define svcerr_systemerr gssrpc_svcerr_systemerr
-extern bool_t svc_sendreply();
-extern void svcerr_decode();
-extern void svcerr_weakauth();
-extern void svcerr_noproc();
-extern void svcerr_progvers();
-extern void svcerr_auth();
-extern void svcerr_noprog();
-extern void svcerr_systemerr();
+extern bool_t svc_sendreply(SVCXPRT *, xdrproc_t, caddr_t);
+extern void svcerr_decode(SVCXPRT *);
+extern void svcerr_weakauth(SVCXPRT *);
+extern void svcerr_noproc(SVCXPRT *);
+extern void svcerr_progvers(SVCXPRT *, rpc_u_int32, rpc_u_int32);
+extern void svcerr_auth(SVCXPRT *, enum auth_stat);
+extern void svcerr_noprog(SVCXPRT *);
+extern void svcerr_systemerr(SVCXPRT *);
/*
* Lowest level dispatching -OR- who owns this process anyway.
#define svc_getreqset gssrpc_svc_getreqset
#define svc_run gssrpc_svc_run
-extern void svc_getreq();
-extern void svc_getreqset(); /* takes fdset instead of int */
-extern void svc_run(); /* never returns */
+extern void svc_getreq(int);
+#ifdef FD_SETSIZE
+extern void svc_getreqset(fd_set *);/* takes fdset instead of int */
+#else
+extern void svc_getreqset(int *);
+#endif
+extern void svc_run(void); /* never returns */
/*
* Socket to use on svcxxx_create call to get default socket
* Memory based rpc for testing and timing.
*/
#define svcraw_create gssrpc_svcraw_create
-extern SVCXPRT *svcraw_create();
+extern SVCXPRT *svcraw_create(void);
/*
* Udp based rpc.
*/
#define svcudp_create gssrpc_svcudp_create
#define svcudp_bufcreate gssrpc_svcudp_bufcreate
-extern SVCXPRT *svcudp_create();
-extern SVCXPRT *svcudp_bufcreate();
+extern SVCXPRT *svcudp_create(int);
+extern SVCXPRT *svcudp_bufcreate(int, unsigned int, unsigned int);
/*
* Tcp based rpc.
*/
#define svctcp_create gssrpc_svctcp_create
-extern SVCXPRT *svctcp_create();
+extern SVCXPRT *svctcp_create(int, unsigned int, unsigned int);
+
+/*
+ * Like svtcp_create(), except the routine takes any *open* UNIX file
+ * descriptor as its first input.
+ */
+#define svcfd_create gssrpc_svcfd_create
+extern SVCXPRT *svcfd_create(int, u_int, u_int);
#endif /* !__SVC_HEADER__ */
+
#define _svcauth_unix _gssrpc_svcauth_unix
#define _svcauth_short _gssrpc_svcauth_short
-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 */
-enum auth_stat _svcauth_gssapi(); /* GSS-API style */
+/* no authentication */
+enum auth_stat _svcauth_null(struct svc_req *, struct rpc_msg *, bool_t *);
+/* unix style (uid, gids) */
+enum auth_stat _svcauth_unix(struct svc_req *, struct rpc_msg *, bool_t *);
+/* short hand unix style */
+enum auth_stat _svcauth_short(struct svc_req *, struct rpc_msg *, bool_t *);
+/* GSS-API style */
+enum auth_stat _svcauth_gssapi(struct svc_req *, struct rpc_msg *, bool_t *);
static struct svcauthsw_type {
unsigned int flavor;
- enum auth_stat (*authenticator)();
+ enum auth_stat (*authenticator)(struct svc_req *, struct rpc_msg *,
+ bool_t *);
} svcauthsw[] = {
{AUTH_GSSAPI, _svcauth_gssapi}, /* AUTH_GSSAPI */
{AUTH_NONE, _svcauth_null}, /* AUTH_NULL */
}
enum auth_stat
-_svcauth_null(rqst, msg)
+_svcauth_null(rqst, msg, no_dispatch)
struct svc_req *rqst;
struct rpc_msg *msg;
+ bool_t *no_dispatch;
{
rqst->rq_xprt->xp_auth = &svc_auth_any;
return (AUTH_OK);
/*
* Interface to server-side authentication flavors.
*/
-typedef struct {
+
+typedef struct __rpc_svc_auth {
struct svc_auth_ops {
- int (*svc_ah_wrap)();
- int (*svc_ah_unwrap)();
+ int (*svc_ah_wrap)(struct __rpc_svc_auth *, XDR *, xdrproc_t,
+ caddr_t);
+ int (*svc_ah_unwrap)(struct __rpc_svc_auth *, XDR *, xdrproc_t,
+ caddr_t);
} *svc_ah_ops;
caddr_t svc_ah_private;
} SVCAUTH;
#include <stdio.h>
#include <gssrpc/rpc.h>
-extern int authany_wrap();
+static int svc_authany_wrap(SVCAUTH *, XDR *, xdrproc_t, caddr_t);
struct svc_auth_ops svc_auth_any_ops = {
- authany_wrap,
- authany_wrap,
+ svc_authany_wrap,
+ svc_authany_wrap,
};
SVCAUTH svc_auth_any = {
&svc_auth_any_ops,
NULL,
};
+
+static int
+svc_authany_wrap(auth, xdrs, xfunc, xwhere)
+ SVCAUTH *auth;
+ XDR *xdrs;
+ xdrproc_t xfunc;
+ caddr_t xwhere;
+{
+ return (*xfunc)(xdrs, xwhere);
+}
+
+
+
#define SVCAUTH_PRIVATE(auth) \
((svc_auth_gssapi_data *)(auth)->svc_ah_private)
-static bool_t svc_auth_gssapi_wrap();
-static bool_t svc_auth_gssapi_unwrap();
-static svc_auth_gssapi_data *create_client();
+static bool_t svc_auth_gssapi_wrap(SVCAUTH *, XDR *, xdrproc_t, caddr_t);
+static bool_t svc_auth_gssapi_unwrap(SVCAUTH *, XDR *, xdrproc_t, caddr_t);
+static svc_auth_gssapi_data *create_client(void);
static svc_auth_gssapi_data *get_client
-PROTOTYPE((gss_buffer_t client_handle));
+ PROTOTYPE((gss_buffer_t client_handle));
static void destroy_client
-PROTOTYPE((svc_auth_gssapi_data *client_data));
-static void clean_client(), cleanup();
+ PROTOTYPE((svc_auth_gssapi_data *client_data));
+static void clean_client(void), cleanup(void);
static void client_expire
-PROTOTYPE((svc_auth_gssapi_data *client_data, rpc_u_int32 exp));
+ PROTOTYPE((svc_auth_gssapi_data *client_data, rpc_u_int32 exp));
static void dump_db
PROTOTYPE((char *msg));
char verf_body[MAX_AUTH_BYTES];
} *svcraw_private;
-static bool_t svcraw_recv();
-static enum xprt_stat svcraw_stat();
-static bool_t svcraw_getargs();
-static bool_t svcraw_reply();
-static bool_t svcraw_freeargs();
-static void svcraw_destroy();
+static bool_t svcraw_recv(SVCXPRT *, struct rpc_msg *);
+static enum xprt_stat svcraw_stat(SVCXPRT *);
+static bool_t svcraw_getargs(SVCXPRT *, xdrproc_t, void *);
+static bool_t svcraw_reply(SVCXPRT *, struct rpc_msg *);
+static bool_t svcraw_freeargs(SVCXPRT *, xdrproc_t, void *);
+static void svcraw_destroy(SVCXPRT *);
static struct xp_ops server_ops = {
svcraw_recv,
}
static enum xprt_stat
-svcraw_stat()
+svcraw_stat(xprt)
+ SVCXPRT *xprt;
{
return (XPRT_IDLE);
svcraw_getargs(xprt, xdr_args, args_ptr)
SVCXPRT *xprt;
xdrproc_t xdr_args;
- caddr_t args_ptr;
+ void * args_ptr;
{
register struct svcraw_private *srp = svcraw_private;
svcraw_freeargs(xprt, xdr_args, args_ptr)
SVCXPRT *xprt;
xdrproc_t xdr_args;
- caddr_t args_ptr;
+ void * args_ptr;
{
register struct svcraw_private *srp = svcraw_private;
register XDR *xdrs;
}
static void
-svcraw_destroy()
+svcraw_destroy(xprt)
+ SVCXPRT *xprt;
{
}
xdrproc_t p_inproc, p_outproc;
struct proglst *p_nxt;
} *proglst;
-static void universal();
+static void universal(struct svc_req *, SVCXPRT *);
static SVCXPRT *transp;
int
gssrpc_registerrpc(prognum, versnum, procnum, progname, inproc, outproc)
char *(*progname)();
xdrproc_t inproc, outproc;
+ rpc_u_int32 prognum, versnum, procnum;
{
struct proglst *pl;
/*
* Ops vector for TCP/IP based rpc service handle
*/
-static bool_t svctcp_recv();
-static enum xprt_stat svctcp_stat();
-static bool_t svctcp_getargs();
-static bool_t svctcp_reply();
-static bool_t svctcp_freeargs();
-static void svctcp_destroy();
+static bool_t svctcp_recv(SVCXPRT *, struct rpc_msg *);
+static enum xprt_stat svctcp_stat(SVCXPRT *);
+static bool_t svctcp_getargs(SVCXPRT *, xdrproc_t, void *);
+static bool_t svctcp_reply(SVCXPRT *, struct rpc_msg *);
+static bool_t svctcp_freeargs(SVCXPRT *, xdrproc_t, void *);
+static void svctcp_destroy(SVCXPRT *);
static struct xp_ops svctcp_op = {
svctcp_recv,
/*
* Ops vector for TCP/IP rendezvous handler
*/
-static bool_t rendezvous_request();
-static bool_t abortx();
-static enum xprt_stat rendezvous_stat();
+static bool_t rendezvous_request(SVCXPRT *, struct rpc_msg *);
+static bool_t abortx(void);
+static bool_t abortx_getargs(SVCXPRT *, xdrproc_t, void *);
+static bool_t abortx_reply(SVCXPRT *, struct rpc_msg *);
+static bool_t abortx_freeargs(SVCXPRT *, xdrproc_t, void *);
+static enum xprt_stat rendezvous_stat(SVCXPRT *);
static struct xp_ops svctcp_rendezvous_op = {
rendezvous_request,
rendezvous_stat,
- abortx,
- abortx,
- abortx,
+ abortx_getargs,
+ abortx_reply,
+ abortx_freeargs,
svctcp_destroy
};
-static int readtcp(), writetcp();
-static SVCXPRT *makefd_xprt();
+static int readtcp(SVCXPRT *, caddr_t, int), writetcp(SVCXPRT *, caddr_t, int);
+static SVCXPRT *makefd_xprt(int, unsigned int, unsigned int);
struct tcp_rendezvous { /* kept in xprt->xp_p1 */
unsigned int sendsize;
}
static bool_t
-rendezvous_request(xprt)
+rendezvous_request(xprt, msg)
register SVCXPRT *xprt;
+ struct rpc_msg *msg;
{
int sock;
struct tcp_rendezvous *r;
}
static enum xprt_stat
-rendezvous_stat()
+rendezvous_stat(xprt)
+ register SVCXPRT *xprt;
{
return (XPRT_IDLE);
svctcp_getargs(xprt, xdr_args, args_ptr)
SVCXPRT *xprt;
xdrproc_t xdr_args;
- caddr_t args_ptr;
+ void *args_ptr;
{
if (! SVCAUTH_UNWRAP(xprt->xp_auth,
&(((struct tcp_conn *)(xprt->xp_p1))->xdrs),
svctcp_freeargs(xprt, xdr_args, args_ptr)
SVCXPRT *xprt;
xdrproc_t xdr_args;
- caddr_t args_ptr;
+ void * args_ptr;
{
register XDR *xdrs =
&(((struct tcp_conn *)(xprt->xp_p1))->xdrs);
return 1;
}
+static bool_t abortx_getargs(xprt, proc, info)
+ SVCXPRT *xprt;
+ xdrproc_t proc;
+ void *info;
+{
+ return abortx();
+}
+
+
+static bool_t abortx_reply(xprt, msg)
+ SVCXPRT *xprt;
+ struct rpc_msg *msg;
+{
+ return abortx();
+}
+
+static bool_t abortx_freeargs(xprt, proc, info)
+ SVCXPRT *xprt;
+ xdrproc_t proc;
+ void * info;
+{
+ return abortx();
+}
+
#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 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, void *);
+static bool_t svcudp_freeargs(SVCXPRT *, xdrproc_t, void *);
+static void svcudp_destroy(SVCXPRT *);
-static void cache_set();
-static int cache_get();
+static void cache_set(SVCXPRT *, rpc_u_int32);
+static int cache_get(SVCXPRT *, struct rpc_msg *, char **, rpc_u_int32 *);
static struct xp_ops svcudp_op = {
svcudp_recv,
svcudp_getargs(xprt, xdr_args, args_ptr)
SVCXPRT *xprt;
xdrproc_t xdr_args;
- caddr_t args_ptr;
+ void * args_ptr;
{
if (! SVCAUTH_UNWRAP(xprt->xp_auth, &(su_data(xprt)->su_xdrs),
xdr_args, args_ptr)) {
svcudp_freeargs(xprt, xdr_args, args_ptr)
SVCXPRT *xprt;
xdrproc_t xdr_args;
- caddr_t args_ptr;
+ void * args_ptr;
{
register XDR *xdrs = &(su_data(xprt)->su_xdrs);
* XDR nothing
*/
bool_t
-xdr_void(/* xdrs, addr */)
- /* XDR *xdrs; */
- /* caddr_t addr; */
+xdr_void(xdrs, addr )
+ XDR *xdrs;
+ void *addr;
{
return (TRUE);
* 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 *);
+ *
+ * XXX can't actually prototype it, because some take three args!!!
*/
typedef bool_t (*xdrproc_t)();
* 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 {
+typedef struct __xdr_s {
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 " */
- unsigned int (*x_getpostn)();/* returns bytes off from beginning */
- bool_t (*x_setpostn)();/* lets you reposition the stream */
- rpc_int32 * (*x_inline)(); /* buf quick ptr to buffered data */
- void (*x_destroy)(); /* free privates of this xdr_stream */
+ /* get a long from underlying stream */
+ bool_t (*x_getlong)(struct __xdr_s *, long *);
+
+ /* put a long to underlying stream */
+ bool_t (*x_putlong)(struct __xdr_s *, long *);
+
+ /* get some bytes from underlying stream */
+ bool_t (*x_getbytes)(struct __xdr_s *, caddr_t, unsigned int);
+
+ /* put some bytes to underlying stream */
+ bool_t (*x_putbytes)(struct __xdr_s *, caddr_t, unsigned int);
+
+ /* returns bytes off from beginning */
+ unsigned int (*x_getpostn)(struct __xdr_s *);
+
+ /* lets you reposition the stream */
+ bool_t (*x_setpostn)(struct __xdr_s *, unsigned int);
+
+ /* buf quick ptr to buffered data */
+ rpc_int32 * (*x_inline)(struct __xdr_s *, int);
+
+ /* free privates of this xdr_stream */
+ void (*x_destroy)(struct __xdr_s *);
} *x_ops;
caddr_t x_public; /* users' data */
caddr_t x_private; /* pointer to private data */
#define xdr_pointer gssrpc_xdr_pointer
#define xdr_wrapstring gssrpc_xdr_wrapstring
-extern bool_t xdr_void();
+extern bool_t xdr_void(XDR *, void *);
extern bool_t xdr_int
PROTOTYPE((XDR *, int *));
extern bool_t xdr_u_int
#include <gssrpc/xdr.h>
#include <dyn.h>
-static bool_t xdralloc_putlong();
-static bool_t xdralloc_putbytes();
-static unsigned int xdralloc_getpos();
-static rpc_int32 * xdralloc_inline();
-static void xdralloc_destroy();
-static bool_t xdralloc_notsup();
-
+static bool_t xdralloc_putlong(XDR *, long *);
+static bool_t xdralloc_putbytes(XDR *, caddr_t, unsigned int);
+static unsigned int xdralloc_getpos(XDR *);
+static rpc_int32 * xdralloc_inline(XDR *, int);
+static void xdralloc_destroy(XDR *);
+static bool_t xdralloc_notsup_getlong(XDR *, long *);
+static bool_t xdralloc_notsup_getbytes(XDR *, caddr_t, unsigned int);
+static bool_t xdralloc_notsup_setpos(XDR *, unsigned int);
static struct xdr_ops xdralloc_ops = {
- xdralloc_notsup,
+ xdralloc_notsup_getlong,
xdralloc_putlong,
- xdralloc_notsup,
+ xdralloc_notsup_getbytes,
xdralloc_putbytes,
xdralloc_getpos,
- xdralloc_notsup,
+ xdralloc_notsup_setpos,
xdralloc_inline,
xdralloc_destroy,
};
DynDestroy((DynObject) xdrs->x_private);
}
-static bool_t xdralloc_notsup()
+static bool_t xdralloc_notsup_getlong(xdrs, lp)
+ register XDR *xdrs;
+ long *lp;
{
return FALSE;
}
static bool_t xdralloc_putlong(xdrs, lp)
register XDR *xdrs;
- rpc_int32 *lp;
+ long *lp;
{
int l = htonl((rpc_u_int32) *(int *)lp);
return (TRUE);
}
+
+static bool_t xdralloc_notsup_getbytes(xdrs, addr, len)
+ register XDR *xdrs;
+ caddr_t addr;
+ register unsigned int len;
+{
+ return FALSE;
+}
+
+
static bool_t xdralloc_putbytes(xdrs, addr, len)
register XDR *xdrs;
caddr_t addr;
return DynSize((DynObject) xdrs->x_private);
}
+static bool_t xdralloc_notsup_setpos(xdrs, lp)
+ register XDR *xdrs;
+ unsigned int lp;
+{
+ return FALSE;
+}
+
+
static rpc_int32 *xdralloc_inline(xdrs, len)
register XDR *xdrs;
#include <stdio.h>
#include <string.h>
-static bool_t xdrmem_getlong();
-static bool_t xdrmem_putlong();
-static bool_t xdrmem_getbytes();
-static bool_t xdrmem_putbytes();
-static unsigned int xdrmem_getpos();
-static bool_t xdrmem_setpos();
-static rpc_int32 * xdrmem_inline();
-static void xdrmem_destroy();
+static bool_t xdrmem_getlong(XDR *, long *);
+static bool_t xdrmem_putlong(XDR *, long *);
+static bool_t xdrmem_getbytes(XDR *, caddr_t, unsigned int);
+static bool_t xdrmem_putbytes(XDR *, caddr_t, unsigned int);
+static unsigned int xdrmem_getpos(XDR *);
+static bool_t xdrmem_setpos(XDR *, unsigned int);
+static rpc_int32 * xdrmem_inline(XDR *, int);
+static void xdrmem_destroy(XDR *);
static struct xdr_ops xdrmem_ops = {
xdrmem_getlong,
}
static void
-xdrmem_destroy(/*xdrs*/)
- /*XDR *xdrs;*/
+xdrmem_destroy(xdrs)
+ XDR *xdrs;
{
}
#include <unistd.h>
#include <string.h>
-static unsigned int fix_buf_size();
-static bool_t flush_out();
-static bool_t get_input_bytes();
-static bool_t set_input_fragment();
-static bool_t skip_input_bytes();
-
-static bool_t xdrrec_getlong();
-static bool_t xdrrec_putlong();
-static bool_t xdrrec_getbytes();
-static bool_t xdrrec_putbytes();
-static unsigned int xdrrec_getpos();
-static bool_t xdrrec_setpos();
-static rpc_int32 * xdrrec_inline();
-static void xdrrec_destroy();
+static bool_t xdrrec_getlong(XDR *, long *);
+static bool_t xdrrec_putlong(XDR *, long *);
+static bool_t xdrrec_getbytes(XDR *, caddr_t, unsigned int);
+static bool_t xdrrec_putbytes(XDR *, caddr_t, unsigned int);
+static unsigned int xdrrec_getpos(XDR *);
+static bool_t xdrrec_setpos(XDR *, unsigned int);
+static rpc_int32 * xdrrec_inline(XDR *, int);
+static void xdrrec_destroy(XDR *);
static struct xdr_ops xdrrec_ops = {
xdrrec_getlong,
unsigned int recvsize;
} RECSTREAM;
+static unsigned int fix_buf_size(unsigned int);
+static bool_t flush_out(RECSTREAM *, bool_t);
+static bool_t get_input_bytes(RECSTREAM *, caddr_t, int);
+static bool_t set_input_fragment(RECSTREAM *);
+static bool_t skip_input_bytes(RECSTREAM *, rpc_int32);
/*
* Create an xdr handle for xdrrec
#include <stdio.h>
#include <gssrpc/xdr.h>
-static bool_t xdrstdio_getlong();
-static bool_t xdrstdio_putlong();
-static bool_t xdrstdio_getbytes();
-static bool_t xdrstdio_putbytes();
-static unsigned int xdrstdio_getpos();
-static bool_t xdrstdio_setpos();
-static rpc_int32 * 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, unsigned int);
+static bool_t xdrstdio_putbytes(XDR *, caddr_t, unsigned int);
+static unsigned int xdrstdio_getpos(XDR *);
+static bool_t xdrstdio_setpos(XDR *, unsigned int);
+static rpc_int32 * xdrstdio_inline(XDR *, int);
+static void xdrstdio_destroy(XDR *);
/*
* Ops vector for stdio type XDR
XDR *xdrs;
register long *lp;
{
- rpc_int32 tmp;
+ rpc_int32 tmp;
if (fread((caddr_t)&tmp,
sizeof(rpc_int32), 1, (FILE *)xdrs->x_private) != 1)
return (FALSE);
static rpc_int32 *
xdrstdio_inline(xdrs, len)
XDR *xdrs;
- unsigned int len;
+ int len;
{
/*
projects / krb5.git / commitdiff