d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use ANSI C prototypes. Eliminates -Wold-style-definition warnings.

Browse Source
This commit is contained in:
rodrigc 2015-09-22 15:40:07 +00:00
parent 3fa0d9942f
commit 5200f4be66
35 changed files with 235 additions and 409 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
lib/libc/rpc/auth_unix.c
View File

@ -91,12 +91,7 @@ struct audata {
* Returns an auth handle with the given stuff in it.
*/
AUTH *
authunix_create(machname, uid, gid, len, aup_gids)
char *machname;
u_int uid;
u_int gid;
int len;
u_int *aup_gids;
authunix_create(char *machname, u_int uid, u_int gid, int len, u_int *aup_gids)
{
struct authunix_parms aup;
char mymem[MAX_AUTH_BYTES];
@ -182,7 +177,7 @@ authunix_create(machname, uid, gid, len, aup_gids)
* syscalls.
*/
AUTH *
authunix_create_default()
authunix_create_default(void)
{
AUTH *auth;
int ngids;
@ -218,16 +213,13 @@ authunix_create_default()
/* ARGSUSED */
static void
authunix_nextverf(auth)
AUTH *auth;
authunix_nextverf(AUTH *auth)
{
/* no action necessary */
}
static bool_t
authunix_marshal(auth, xdrs)
AUTH *auth;
XDR *xdrs;
authunix_marshal(AUTH *auth, XDR *xdrs)
{
struct audata *au;
@ -239,9 +231,7 @@ authunix_marshal(auth, xdrs)
}
static bool_t
authunix_validate(auth, verf)
AUTH *auth;
struct opaque_auth *verf;
authunix_validate(AUTH *auth, struct opaque_auth *verf)
{
struct audata *au;
XDR xdrs;
@ -317,8 +307,7 @@ authunix_refresh(AUTH *auth, void *dummy)
}
static void
authunix_destroy(auth)
AUTH *auth;
authunix_destroy(AUTH *auth)
{
struct audata *au;
@ -343,8 +332,7 @@ authunix_destroy(auth)
* sets private data, au_marshed and au_mpos
*/
static void
marshal_new_auth(auth)
AUTH *auth;
marshal_new_auth(AUTH *auth)
{
XDR xdr_stream;
XDR *xdrs = &xdr_stream;
@ -363,7 +351,7 @@ marshal_new_auth(auth)
}
static struct auth_ops *
authunix_ops()
authunix_ops(void)
{
static struct auth_ops ops;

8
lib/libc/rpc/authdes_prot.c
View File

@ -49,9 +49,7 @@ __FBSDID("$FreeBSD$");
#define ATTEMPT(xdr_op) if (!(xdr_op)) return (FALSE)
bool_t
xdr_authdes_cred(xdrs, cred)
XDR *xdrs;
struct authdes_cred *cred;
xdr_authdes_cred(XDR *xdrs, struct authdes_cred *cred)
{
enum authdes_namekind *padc_namekind = &cred->adc_namekind;
/*
@ -78,9 +76,7 @@ xdr_authdes_cred(xdrs, cred)
bool_t
xdr_authdes_verf(xdrs, verf)
XDR *xdrs;
struct authdes_verf *verf;
xdr_authdes_verf(XDR *xdrs, struct authdes_verf *verf)
{
/*
* Unrolled xdr

4
lib/libc/rpc/authunix_prot.c
View File

@ -55,9 +55,7 @@ __FBSDID("$FreeBSD$");
* XDR for unix authentication parameters.
*/
bool_t
xdr_authunix_parms(xdrs, p)
XDR *xdrs;
struct authunix_parms *p;
xdr_authunix_parms(XDR *xdrs, struct authunix_parms *p)
{
u_int **paup_gids;

8
lib/libc/rpc/bindresvport.c
View File

@ -61,9 +61,7 @@ __FBSDID("$FreeBSD$");
* Bind a socket to a privileged IP port
*/
int
bindresvport(sd, sin)
int sd;
struct sockaddr_in *sin;
bindresvport(int sd, struct sockaddr_in *sin)
{
return bindresvport_sa(sd, (struct sockaddr *)sin);
}
@ -72,9 +70,7 @@ bindresvport(sd, sin)
* Bind a socket to a privileged IP port
*/
int
bindresvport_sa(sd, sa)
int sd;
struct sockaddr *sa;
bindresvport_sa(int sd, struct sockaddr *sa)
{
int old, error, af;
struct sockaddr_storage myaddr;

61
lib/libc/rpc/clnt_bcast.c
View File

@ -225,21 +225,26 @@ __rpc_broadenable(int af, int s, struct broadif *bip)
return 0;
}
/*
* rpc_broadcast_exp()
*
* prog - program number
* vers - version number
* proc - procedure number
* xargs - xdr routine for args
* argsp - pointer to args
* xresults - xdr routine for results
* resultsp - pointer to results
* eachresult - call with each result obtained
* inittime - how long to wait initially
* waittime - maximum time to wait
* nettype - transport type
*/
enum clnt_stat
rpc_broadcast_exp(prog, vers, proc, xargs, argsp, xresults, resultsp,
eachresult, inittime, waittime, nettype)
rpcprog_t prog; /* program number */
rpcvers_t vers; /* version number */
rpcproc_t proc; /* procedure number */
xdrproc_t xargs; /* xdr routine for args */
caddr_t argsp; /* pointer to args */
xdrproc_t xresults; /* xdr routine for results */
caddr_t resultsp; /* pointer to results */
resultproc_t eachresult; /* call with each result obtained */
int inittime; /* how long to wait initially */
int waittime; /* maximum time to wait */
const char *nettype; /* transport type */
rpc_broadcast_exp(rpcprog_t prog, rpcvers_t vers, rpcproc_t proc,
xdrproc_t xargs, caddr_t argsp, xdrproc_t xresults, caddr_t resultsp,
resultproc_t eachresult, int inittime, int waittime,
const char *nettype)
{
enum clnt_stat stat = RPC_SUCCESS; /* Return status */
XDR xdr_stream; /* XDR stream */
@ -649,19 +654,23 @@ rpc_broadcast_exp(prog, vers, proc, xargs, argsp, xresults, resultsp,
return (stat);
}
/*
* rpc_broadcast()
*
* prog - program number
* vers - version number
* proc - procedure number
* xargs - xdr routine for args
* argsp - pointer to args
* xresults - xdr routine for results
* resultsp - pointer to results
* eachresult - call with each result obtained
* nettype - transport type
*/
enum clnt_stat
rpc_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp,
eachresult, nettype)
rpcprog_t prog; /* program number */
rpcvers_t vers; /* version number */
rpcproc_t proc; /* procedure number */
xdrproc_t xargs; /* xdr routine for args */
caddr_t argsp; /* pointer to args */
xdrproc_t xresults; /* xdr routine for results */
caddr_t resultsp; /* pointer to results */
resultproc_t eachresult; /* call with each result obtained */
const char *nettype; /* transport type */
rpc_broadcast(rpcprog_t prog, rpcvers_t vers, rpcproc_t proc, xdrproc_t xargs,
caddr_t argsp, xdrproc_t xresults, caddr_t resultsp,
resultproc_t eachresult, const char *nettype)
{
enum clnt_stat dummy;

25
lib/libc/rpc/clnt_perror.c
View File

@ -61,7 +61,7 @@ static char *auth_errmsg(enum auth_stat);
#define CLNT_PERROR_BUFLEN 256
static char *
_buf()
_buf(void)
{
if (buf == 0)
@ -73,9 +73,7 @@ _buf()
* Print reply error info
*/
char *
clnt_sperror(rpch, s)
CLIENT *rpch;
const char *s;
clnt_sperror(CLIENT *rpch, const char *s)
{
struct rpc_err e;
char *err;
@ -180,9 +178,7 @@ clnt_sperror(rpch, s)
}
void
clnt_perror(rpch, s)
CLIENT *rpch;
const char *s;
clnt_perror(CLIENT *rpch, const char *s)
{
assert(rpch != NULL);
@ -217,8 +213,7 @@ static const char *const rpc_errlist[] = {
* This interface for use by clntrpc
*/
char *
clnt_sperrno(stat)
enum clnt_stat stat;
clnt_sperrno(enum clnt_stat stat)
{
unsigned int errnum = stat;
@ -230,16 +225,14 @@ clnt_sperrno(stat)
}
void
clnt_perrno(num)
enum clnt_stat num;
clnt_perrno(enum clnt_stat num)
{
(void) fprintf(stderr, "%s\n", clnt_sperrno(num));
}
char *
clnt_spcreateerror(s)
const char *s;
clnt_spcreateerror(const char *s)
{
char *str;
size_t len, i;
@ -291,8 +284,7 @@ clnt_spcreateerror(s)
}
void
clnt_pcreateerror(s)
const char *s;
clnt_pcreateerror(const char *s)
{
assert(s != NULL);
@ -319,8 +311,7 @@ static const char *const auth_errlist[] = {
};
static char *
auth_errmsg(stat)
enum auth_stat stat;
auth_errmsg(enum auth_stat stat)
{
unsigned int errnum = stat;

36
lib/libc/rpc/clnt_raw.c
View File

@ -87,9 +87,7 @@ static struct clnt_ops *clnt_raw_ops(void);
* Create a client handle for memory based rpc.
*/
CLIENT *
clnt_raw_create(prog, vers)
rpcprog_t prog;
rpcvers_t vers;
clnt_raw_create(rpcprog_t prog, rpcvers_t vers)
{
struct clntraw_private *clp;
struct rpc_msg call_msg;
@ -142,14 +140,8 @@ clnt_raw_create(prog, vers)
/* ARGSUSED */
static enum clnt_stat
clnt_raw_call(h, proc, xargs, argsp, xresults, resultsp, timeout)
CLIENT *h;
rpcproc_t proc;
xdrproc_t xargs;
void *argsp;
xdrproc_t xresults;
void *resultsp;
struct timeval timeout;
clnt_raw_call(CLIENT *h, rpcproc_t proc, xdrproc_t xargs, void *argsp,
xdrproc_t xresults, void *resultsp, struct timeval timeout)
{
struct clntraw_private *clp = clntraw_private;
XDR *xdrs = &clp->xdr_stream;
@ -240,19 +232,14 @@ clnt_raw_call(h, proc, xargs, argsp, xresults, resultsp, timeout)
/*ARGSUSED*/
static void
clnt_raw_geterr(cl, err)
CLIENT *cl;
struct rpc_err *err;
clnt_raw_geterr(CLIENT *cl, struct rpc_err *err)
{
}
/* ARGSUSED */
static bool_t
clnt_raw_freeres(cl, xdr_res, res_ptr)
CLIENT *cl;
xdrproc_t xdr_res;
void *res_ptr;
clnt_raw_freeres(CLIENT *cl, xdrproc_t xdr_res, void *res_ptr)
{
struct clntraw_private *clp = clntraw_private;
XDR *xdrs = &clp->xdr_stream;
@ -271,30 +258,25 @@ clnt_raw_freeres(cl, xdr_res, res_ptr)
/*ARGSUSED*/
static void
clnt_raw_abort(cl)
CLIENT *cl;
clnt_raw_abort(CLIENT *cl)
{
}
/*ARGSUSED*/
static bool_t
clnt_raw_control(cl, ui, str)
CLIENT *cl;
u_int ui;
void *str;
clnt_raw_control(CLIENT *cl, u_int ui, void *str)
{
return (FALSE);
}
/*ARGSUSED*/
static void
clnt_raw_destroy(cl)
CLIENT *cl;
clnt_raw_destroy(CLIENT *cl)
{
}
static struct clnt_ops *
clnt_raw_ops()
clnt_raw_ops(void)
{
static struct clnt_ops ops;

20
lib/libc/rpc/clnt_simple.c
View File

@ -107,17 +107,19 @@ rpc_call_key_init(void)
* the future calls to same prog, vers, host and nettype combination.
*
* The total time available is 25 seconds.
*
* host - host name
* prognum - program number
* versnum - version number
* procnum - procedure number
* inproc, outproc - in/out XDR procedures
* in, out - recv/send data
* nettype - nettype
*/
enum clnt_stat
rpc_call(host, prognum, versnum, procnum, inproc, in, outproc, out, nettype)
const char *host; /* host name */
rpcprog_t prognum; /* program number */
rpcvers_t versnum; /* version number */
rpcproc_t procnum; /* procedure number */
xdrproc_t inproc, outproc; /* in/out XDR procedures */
const char *in;
char *out; /* recv/send data */
const char *nettype; /* nettype */
rpc_call(const char *host, const rpcprog_t prognum, const rpcvers_t versnum,
const rpcproc_t procnum, const xdrproc_t inproc, const char *in,
const xdrproc_t outproc, char *out, const char *nettype)
{
struct rpc_call_private *rcp = (struct rpc_call_private *) 0;
enum clnt_stat clnt_stat;

71
lib/libc/rpc/clnt_vc.c
View File

@ -153,15 +153,17 @@ static const char __no_mem_str[] = "out of memory";
* set this something more useful.
*
* fd should be an open socket
*
* fd - open file descriptor
* raddr - servers address
* prog - program number
* vers - version number
* sendsz - buffer send size
* recvsz - buffer recv size
*/
CLIENT *
clnt_vc_create(fd, raddr, prog, vers, sendsz, recvsz)
int fd; /* open file descriptor */
const struct netbuf *raddr; /* servers address */
const rpcprog_t prog; /* program number */
const rpcvers_t vers; /* version number */
u_int sendsz; /* buffer recv size */
u_int recvsz; /* buffer send size */
clnt_vc_create(int fd, const struct netbuf *raddr, const rpcprog_t prog,
const rpcvers_t vers, u_int sendsz, u_int recvsz)
{
CLIENT *cl; /* client handle */
struct ct_data *ct = NULL; /* client handle */
@ -311,14 +313,8 @@ clnt_vc_create(fd, raddr, prog, vers, sendsz, recvsz)
}
static enum clnt_stat
clnt_vc_call(cl, proc, xdr_args, args_ptr, xdr_results, results_ptr, timeout)
CLIENT *cl;
rpcproc_t proc;
xdrproc_t xdr_args;
void *args_ptr;
xdrproc_t xdr_results;
void *results_ptr;
struct timeval timeout;
clnt_vc_call(CLIENT *cl, rpcproc_t proc, xdrproc_t xdr_args, void *args_ptr,
xdrproc_t xdr_results, void *results_ptr, struct timeval timeout)
{
struct ct_data *ct = (struct ct_data *) cl->cl_private;
XDR *xdrs = &(ct->ct_xdrs);
@ -461,9 +457,7 @@ clnt_vc_call(cl, proc, xdr_args, args_ptr, xdr_results, results_ptr, timeout)
}
static void
clnt_vc_geterr(cl, errp)
CLIENT *cl;
struct rpc_err *errp;
clnt_vc_geterr(CLIENT *cl, struct rpc_err *errp)
{
struct ct_data *ct;
@ -475,10 +469,7 @@ clnt_vc_geterr(cl, errp)
}
static bool_t
clnt_vc_freeres(cl, xdr_res, res_ptr)
CLIENT *cl;
xdrproc_t xdr_res;
void *res_ptr;
clnt_vc_freeres(CLIENT *cl, xdrproc_t xdr_res, void *res_ptr)
{
struct ct_data *ct;
XDR *xdrs;
@ -507,16 +498,12 @@ clnt_vc_freeres(cl, xdr_res, res_ptr)
/*ARGSUSED*/
static void
clnt_vc_abort(cl)
CLIENT *cl;
clnt_vc_abort(CLIENT *cl)
{
}
static bool_t
clnt_vc_control(cl, request, info)
CLIENT *cl;
u_int request;
void *info;
clnt_vc_control(CLIENT *cl, u_int request, void *info)
{
struct ct_data *ct;
void *infop = info;
@ -644,8 +631,7 @@ clnt_vc_control(cl, request, info)
static void
clnt_vc_destroy(cl)
CLIENT *cl;
clnt_vc_destroy(CLIENT *cl)
{
struct ct_data *ct = (struct ct_data *) cl->cl_private;
int ct_fd = ct->ct_fd;
@ -684,10 +670,7 @@ clnt_vc_destroy(cl)
* around for the rpc level.
*/
static int
read_vc(ctp, buf, len)
void *ctp;
void *buf;
int len;
read_vc(void *ctp, void *buf, int len)
{
struct sockaddr sa;
socklen_t sal;
@ -741,10 +724,7 @@ read_vc(ctp, buf, len)
}
static int
write_vc(ctp, buf, len)
void *ctp;
void *buf;
int len;
write_vc(void *ctp, void *buf, int len)
{
struct sockaddr sa;
socklen_t sal;
@ -775,7 +755,7 @@ write_vc(ctp, buf, len)
}
static struct clnt_ops *
clnt_vc_ops()
clnt_vc_ops(void)
{
static struct clnt_ops ops;
sigset_t mask, newmask;
@ -803,18 +783,14 @@ clnt_vc_ops()
* Note this is different from time_not_ok in clnt_dg.c
*/
static bool_t
time_not_ok(t)
struct timeval *t;
time_not_ok(struct timeval *t)
{
return (t->tv_sec <= -1 || t->tv_sec > 100000000 ||
t->tv_usec <= -1 || t->tv_usec > 1000000);
}
static int
__msgread(sock, buf, cnt)
int sock;
void *buf;
size_t cnt;
__msgread(int sock, void *buf, size_t cnt)
{
struct iovec iov[1];
struct msghdr msg;
@ -839,10 +815,7 @@ __msgread(sock, buf, cnt)
}
static int
__msgwrite(sock, buf, cnt)
int sock;
void *buf;
size_t cnt;
__msgwrite(int sock, void *buf, size_t cnt)
{
struct iovec iov[1];
struct msghdr msg;

2
lib/libc/rpc/des_crypt.c
View File

@ -41,7 +41,7 @@ static char sccsid[] = "@(#)des_crypt.c 2.2 88/08/10 4.0 RPCSRC; from 1.13 88/02
__FBSDID("$FreeBSD$");
static int common_crypt( char *, char *, unsigned, unsigned, struct desparams * );
int (*__des_crypt_LOCAL)() = 0;
int (*__des_crypt_LOCAL)(char *, unsigned, struct desparams *) = 0;
extern int _des_crypt_call(char *, int, struct desparams *);
/*
* Copy 8 bytes

31
lib/libc/rpc/getnetconfig.c
View File

@ -147,7 +147,7 @@ nc_key_init(void)
#define MAXNETCONFIGLINE 1000
static int *
__nc_error()
__nc_error(void)
{
static int nc_error = 0;
int *nc_addr;
@ -194,7 +194,7 @@ __nc_error()
* the netconfig database is not present).
*/
void *
setnetconfig()
setnetconfig(void)
{
struct netconfig_vars *nc_vars;
@ -240,8 +240,7 @@ setnetconfig()
*/
struct netconfig *
getnetconfig(handlep)
void *handlep;
getnetconfig(void *handlep)
{
struct netconfig_vars *ncp = (struct netconfig_vars *)handlep;
char *stringp; /* tmp string pointer */
@ -378,8 +377,7 @@ void *handlep;
* previously).
*/
int
endnetconfig(handlep)
void *handlep;
endnetconfig(void *handlep)
{
struct netconfig_vars *nc_handlep = (struct netconfig_vars *)handlep;
@ -444,8 +442,7 @@ void *handlep;
*/
struct netconfig *
getnetconfigent(netid)
const char *netid;
getnetconfigent(const char *netid)
{
FILE *file; /* NETCONFIG db's file pointer */
char *linep; /* holds current netconfig line */
@ -536,8 +533,7 @@ getnetconfigent(netid)
*/
void
freenetconfigent(netconfigp)
struct netconfig *netconfigp;
freenetconfigent(struct netconfig *netconfigp)
{
if (netconfigp != NULL) {
free(netconfigp->nc_netid); /* holds all netconfigp's strings */
@ -558,12 +554,13 @@ freenetconfigent(netconfigp)
* Note that we modify stringp (putting NULLs after tokens) and
* we set the ncp's string field pointers to point to these tokens within
* stringp.
*
* stringp - string to parse
* ncp - where to put results
*/
static int
parse_ncp(stringp, ncp)
char *stringp; /* string to parse */
struct netconfig *ncp; /* where to put results */
parse_ncp(char *stringp, struct netconfig *ncp)
{
char *tokenp; /* for processing tokens */
char *lasts;
@ -655,7 +652,7 @@ struct netconfig *ncp; /* where to put results */
* Returns a string describing the reason for failure.
*/
char *
nc_sperror()
nc_sperror(void)
{
const char *message;
@ -686,8 +683,7 @@ nc_sperror()
* Prints a message onto standard error describing the reason for failure.
*/
void
nc_perror(s)
const char *s;
nc_perror(const char *s)
{
fprintf(stderr, "%s: %s\n", s, nc_sperror());
}
@ -696,8 +692,7 @@ nc_perror(s)
* Duplicates the matched netconfig buffer.
*/
static struct netconfig *
dup_ncp(ncp)
struct netconfig *ncp;
dup_ncp(struct netconfig *ncp)
{
struct netconfig *p;
char *tmp;

16
lib/libc/rpc/getnetpath.c
View File

@ -82,7 +82,7 @@ char *_get_next_token(char *, int);
*/
void *
setnetpath()
setnetpath(void)
{
struct netpath_vars *np_sessionp; /* this session's variables */
@ -141,8 +141,7 @@ setnetpath()
*/
struct netconfig *
getnetpath(handlep)
void *handlep;
getnetpath(void *handlep)
{
struct netpath_vars *np_sessionp = (struct netpath_vars *)handlep;
struct netconfig *ncp = NULL; /* temp. holds a netconfig session */
@ -197,8 +196,7 @@ getnetpath(handlep)
* (e.g. if setnetpath() was not called previously.
*/
int
endnetpath(handlep)
void *handlep;
endnetpath(void *handlep)
{
struct netpath_vars *np_sessionp = (struct netpath_vars *)handlep;
struct netpath_chain *chainp, *lastp;
@ -231,12 +229,12 @@ endnetpath(handlep)
* Returns pointer to the rest-of-the-string after the current token.
* The token itself starts at arg, and we null terminate it. We return NULL
* if either the arg is empty, or if this is the last token.
*
* npp - string
* token - char to parse string for
*/
char *
_get_next_token(npp, token)
char *npp; /* string */
int token; /* char to parse string for */
_get_next_token(char *npp, int token)
{
char *cp; /* char pointer */
char *np; /* netpath pointer */

4
lib/libc/rpc/getrpcent.c
View File

@ -989,7 +989,7 @@ getrpcbynumber(int number)
}
struct rpcent *
getrpcent()
getrpcent(void)
{
union key key;
@ -1023,7 +1023,7 @@ setrpcent(int stayopen)
}
void
endrpcent()
endrpcent(void)
{
#ifdef NS_CACHING
static const nss_cache_info cache_info = NS_MP_CACHE_INFO_INITIALIZER(

4
lib/libc/rpc/getrpcport.c
View File

@ -53,9 +53,7 @@ __FBSDID("$FreeBSD$");
#include "un-namespace.h"
int
getrpcport(host, prognum, versnum, proto)
char *host;
int prognum, versnum, proto;
getrpcport(char *host, int prognum, int versnum, int proto)
{
struct sockaddr_in addr;
struct hostent *hp;

2
lib/libc/rpc/mt_misc.c
View File

@ -93,7 +93,7 @@ rce_key_init(void)
}
struct rpc_createerr *
__rpc_createerr()
__rpc_createerr(void)
{
struct rpc_createerr *rce_addr = 0;

13
lib/libc/rpc/netname.c
View File

@ -79,8 +79,7 @@ static char *OPSYS = "unix";
* Figure out my fully qualified network name
*/
int
getnetname(name)
char name[MAXNETNAMELEN+1];
getnetname(char name[MAXNETNAMELEN+1])
{
uid_t uid;
@ -97,10 +96,7 @@ getnetname(name)
* Convert unix cred to network-name
*/
int
user2netname(netname, uid, domain)
char netname[MAXNETNAMELEN + 1];
const uid_t uid;
const char *domain;
user2netname(char netname[MAXNETNAMELEN + 1], const uid_t uid, const char *domain)
{
char *dfltdom;
@ -122,10 +118,7 @@ user2netname(netname, uid, domain)
* Convert host to network-name
*/
int
host2netname(netname, host, domain)
char netname[MAXNETNAMELEN + 1];
const char *host;
const char *domain;
host2netname(char netname[MAXNETNAMELEN + 1], const char *host, const char *domain)
{
char *dfltdom;
char hostname[MAXHOSTNAMELEN+1];

20
lib/libc/rpc/netnamer.c
View File

@ -68,12 +68,8 @@ static int _getgroups( char *, gid_t * );
* Convert network-name into unix credential
*/
int
netname2user(netname, uidp, gidp, gidlenp, gidlist)
char netname[MAXNETNAMELEN + 1];
uid_t *uidp;
gid_t *gidp;
int *gidlenp;
gid_t *gidlist;
netname2user(char netname[MAXNETNAMELEN + 1], uid_t *uidp, gid_t *gidp,
int *gidlenp, gid_t *gidlist)
{
char *p;
int gidlen;
@ -149,9 +145,7 @@ netname2user(netname, uidp, gidp, gidlenp, gidlist)
*/
static int
_getgroups(uname, groups)
char *uname;
gid_t groups[NGRPS];
_getgroups(char *uname, gid_t groups[NGRPS])
{
gid_t ngroups = 0;
struct group *grp;
@ -190,10 +184,7 @@ _getgroups(uname, groups)
* Convert network-name to hostname
*/
int
netname2host(netname, hostname, hostlen)
char netname[MAXNETNAMELEN + 1];
char *hostname;
int hostlen;
netname2host(char netname[MAXNETNAMELEN + 1], char *hostname, int hostlen)
{
int err;
char valbuf[1024];
@ -239,8 +230,7 @@ netname2host(netname, hostname, hostlen)
* network information service.
*/
int
getnetid(key, ret)
char *key, *ret;
getnetid(char *key, char *ret)
{
char buf[1024]; /* big enough */
char *res;

3
lib/libc/rpc/pmap_getmaps.c
View File

@ -70,8 +70,7 @@ __FBSDID("$FreeBSD$");
* Calls the pmap service remotely to do get the maps.
*/
struct pmaplist *
pmap_getmaps(address)
struct sockaddr_in *address;
pmap_getmaps(struct sockaddr_in *address)
{
struct pmaplist *head = NULL;
int sock = -1;

7
lib/libc/rpc/pmap_getport.c
View File

@ -66,11 +66,8 @@ static const struct timeval tottimeout = { 60, 0 };
* Returns 0 if no map exists.
*/
u_short
pmap_getport(address, program, version, protocol)
struct sockaddr_in *address;
u_long program;
u_long version;
u_int protocol;
pmap_getport(struct sockaddr_in *address, u_long program, u_long version,
u_int protocol)
{
u_short port = 0;
int sock = -1;

4
lib/libc/rpc/pmap_prot.c
View File

@ -52,9 +52,7 @@ __FBSDID("$FreeBSD$");
bool_t
xdr_pmap(xdrs, regs)
XDR *xdrs;
struct pmap *regs;
xdr_pmap(XDR *xdrs, struct pmap *regs)
{
assert(xdrs != NULL);

8
lib/libc/rpc/pmap_prot2.c
View File

@ -90,9 +90,7 @@ __FBSDID("$FreeBSD$");
* this sounds like a job for xdr_reference!
*/
bool_t
xdr_pmaplist(xdrs, rp)
XDR *xdrs;
struct pmaplist **rp;
xdr_pmaplist(XDR *xdrs, struct pmaplist **rp)
{
/*
* more_elements is pre-computed in case the direction is
@ -134,9 +132,7 @@ xdr_pmaplist(xdrs, rp)
* functionality to xdr_pmaplist().
*/
bool_t
xdr_pmaplist_ptr(xdrs, rp)
XDR *xdrs;
struct pmaplist *rp;
xdr_pmaplist_ptr(XDR *xdrs, struct pmaplist *rp)
{
return xdr_pmaplist(xdrs, (struct pmaplist **)(void *)rp);
}

19
lib/libc/rpc/pmap_rmt.c
View File

@ -76,14 +76,9 @@ static const struct timeval timeout = { 3, 0 };
* programs to do a lookup and call in one step.
*/
enum clnt_stat
pmap_rmtcall(addr, prog, vers, proc, xdrargs, argsp, xdrres, resp, tout,
port_ptr)
struct sockaddr_in *addr;
u_long prog, vers, proc;
xdrproc_t xdrargs, xdrres;
caddr_t argsp, resp;
struct timeval tout;
u_long *port_ptr;
pmap_rmtcall(struct sockaddr_in *addr, u_long prog, u_long vers, u_long proc,
xdrproc_t xdrargs, caddr_t argsp, xdrproc_t xdrres, caddr_t resp,
struct timeval tout, u_long *port_ptr)
{
int sock = -1;
CLIENT *client;
@ -122,9 +117,7 @@ pmap_rmtcall(addr, prog, vers, proc, xdrargs, argsp, xdrres, resp, tout,
* written for XDR_ENCODE direction only
*/
bool_t
xdr_rmtcall_args(xdrs, cap)
XDR *xdrs;
struct rmtcallargs *cap;
xdr_rmtcall_args(XDR *xdrs, struct rmtcallargs *cap)
{
u_int lenposition, argposition, position;
@ -156,9 +149,7 @@ xdr_rmtcall_args(xdrs, cap)
* written for XDR_DECODE direction only
*/
bool_t
xdr_rmtcallres(xdrs, crp)
XDR *xdrs;
struct rmtcallres *crp;
xdr_rmtcallres(XDR *xdrs, struct rmtcallres *crp)
{
caddr_t port_ptr;

4
lib/libc/rpc/rpc_callmsg.c
View File

@ -54,9 +54,7 @@ __FBSDID("$FreeBSD$");
* XDR a call message
*/
bool_t
xdr_callmsg(xdrs, cmsg)
XDR *xdrs;
struct rpc_msg *cmsg;
xdr_callmsg(XDR *xdrs, struct rpc_msg *cmsg)
{
enum msg_type *prm_direction;
int32_t *buf;

35
lib/libc/rpc/rpc_generic.c
View File

@ -111,7 +111,7 @@ static int getnettype(const char *);
* expensive call every time.
*/
int
__rpc_dtbsize()
__rpc_dtbsize(void)
{
static int tbsize;
struct rlimit rl;
@ -132,12 +132,12 @@ __rpc_dtbsize()
/*
* Find the appropriate buffer size
*
* size - Size requested
*/
u_int
/*ARGSUSED*/
__rpc_get_t_size(af, proto, size)
int af, proto;
int size; /* Size requested */
__rpc_get_t_size(int af, int proto, int size)
{
int maxsize, defsize;
@ -164,8 +164,7 @@ __rpc_get_t_size(af, proto, size)
* Find the appropriate address buffer size
*/
u_int
__rpc_get_a_size(af)
int af;
__rpc_get_a_size(int af)
{
switch (af) {
case AF_INET:
@ -184,8 +183,7 @@ __rpc_get_a_size(af)
#if 0
static char *
strlocase(p)
char *p;
strlocase(char *p)
{
char *t = p;
@ -201,8 +199,7 @@ strlocase(p)
* If nettype is NULL, it defaults to NETPATH.
*/
static int
getnettype(nettype)
const char *nettype;
getnettype(const char *nettype)
{
int i;
@ -237,8 +234,7 @@ keys_init(void)
* This should be freed by calling freenetconfigent()
*/
struct netconfig *
__rpc_getconfip(nettype)
const char *nettype;
__rpc_getconfip(const char *nettype)
{
char *netid;
char *netid_tcp = (char *) NULL;
@ -309,8 +305,7 @@ __rpc_getconfip(nettype)
* __rpc_getconf().
*/
void *
__rpc_setconf(nettype)
const char *nettype;
__rpc_setconf(const char *nettype)
{
struct handle *handle;
@ -353,8 +348,7 @@ __rpc_setconf(nettype)
* __rpc_setconf() should have been called previously.
*/
struct netconfig *
__rpc_getconf(vhandle)
void *vhandle;
__rpc_getconf(void *vhandle)
{
struct handle *handle;
struct netconfig *nconf;
@ -430,8 +424,7 @@ __rpc_getconf(vhandle)
}
void
__rpc_endconf(vhandle)
void * vhandle;
__rpc_endconf(void *vhandle)
{
struct handle *handle;
@ -452,8 +445,7 @@ __rpc_endconf(vhandle)
* Returns NULL if fails, else a non-NULL pointer.
*/
void *
rpc_nullproc(clnt)
CLIENT *clnt;
rpc_nullproc(CLIENT *clnt)
{
struct timeval TIMEOUT = {25, 0};
@ -469,8 +461,7 @@ rpc_nullproc(clnt)
* one succeeds in finding the netconf for the given fd.
*/
struct netconfig *
__rpcgettp(fd)
int fd;
__rpcgettp(int fd)
{
const char *netid;
struct __rpc_sockinfo si;

8
lib/libc/rpc/rpc_prot.c
View File

@ -265,9 +265,7 @@ accepted(enum accept_stat acpt_stat, struct rpc_err *error)
}
static void
rejected(rjct_stat, error)
enum reject_stat rjct_stat;
struct rpc_err *error;
rejected(enum reject_stat rjct_stat, struct rpc_err *error)
{
assert(error != NULL);
@ -292,9 +290,7 @@ rejected(rjct_stat, error)
* given a reply message, fills in the error
*/
void
_seterr_reply(msg, error)
struct rpc_msg *msg;
struct rpc_err *error;
_seterr_reply(struct rpc_msg *msg, struct rpc_err *error)
{
assert(msg != NULL);

2
lib/libc/rpc/rpc_soc.c
View File

@ -270,7 +270,7 @@ svcudp_create(int fd)
}
SVCXPRT *
svcraw_create()
svcraw_create(void)
{
return svc_raw_create();

33
lib/libc/rpc/rpcb_clnt.c
View File

@ -194,10 +194,8 @@ delete_cache(struct netbuf *addr)
}
static void
add_cache(host, netid, taddr, uaddr)
const char *host, *netid;
char *uaddr;
struct netbuf *taddr;
add_cache(const char *host, const char *netid, struct netbuf *taddr,
char *uaddr)
{
struct address_cache *ad_cache, *cptr, *prevptr;
@ -428,7 +426,7 @@ getclnthandle(const char *host, const struct netconfig *nconf, char **targaddr)
* rpcbind. Returns NULL on error and free's everything.
*/
static CLIENT *
local_rpcb()
local_rpcb(void)
{
CLIENT *client;
static struct netconfig *loopnconf;
@ -1101,19 +1099,20 @@ rpcb_getmaps(const struct netconfig *nconf, const char *host)
* which will look up a service program in the address maps, and then
* remotely call that routine with the given parameters. This allows
* programs to do a lookup and call in one step.
*/
*
* nconf -Netconfig structure
* host - Remote host name
* proc - Remote proc identifiers
* xdrargs, xdrres; XDR routines
* argsp, resp - Argument and Result
* tout - Timeout value for this call
* addr_ptr - Preallocated netbuf address
*/
enum clnt_stat
rpcb_rmtcall(nconf, host, prog, vers, proc, xdrargs, argsp,
xdrres, resp, tout, addr_ptr)
const struct netconfig *nconf; /* Netconfig structure */
const char *host; /* Remote host name */
rpcprog_t prog;
rpcvers_t vers;
rpcproc_t proc; /* Remote proc identifiers */
xdrproc_t xdrargs, xdrres; /* XDR routines */
caddr_t argsp, resp; /* Argument and Result */
struct timeval tout; /* Timeout value for this call */
const struct netbuf *addr_ptr; /* Preallocated netbuf address */
rpcb_rmtcall(const struct netconfig *nconf, const char *host, rpcprog_t prog,
rpcvers_t vers, rpcproc_t proc, xdrproc_t xdrargs, caddr_t argsp,
xdrproc_t xdrres, caddr_t resp, struct timeval tout,
const struct netbuf *addr_ptr)
{
CLIENT *client;
enum clnt_stat stat;

32
lib/libc/rpc/rpcb_prot.c
View File

@ -54,9 +54,7 @@ __FBSDID("$FreeBSD$");
#include "un-namespace.h"
bool_t
xdr_rpcb(xdrs, objp)
XDR *xdrs;
RPCB *objp;
xdr_rpcb(XDR *xdrs, RPCB *objp)
{
if (!xdr_u_int32_t(xdrs, &objp->r_prog)) {
return (FALSE);
@ -100,9 +98,7 @@ xdr_rpcb(xdrs, objp)
*/
bool_t
xdr_rpcblist_ptr(xdrs, rp)
XDR *xdrs;
rpcblist_ptr *rp;
xdr_rpcblist_ptr(XDR *xdrs, rpcblist_ptr *rp)
{
/*
* more_elements is pre-computed in case the direction is
@ -154,9 +150,7 @@ xdr_rpcblist_ptr(xdrs, rp)
* functionality to xdr_rpcblist_ptr().
*/
bool_t
xdr_rpcblist(xdrs, rp)
XDR *xdrs;
RPCBLIST **rp;
xdr_rpcblist(XDR *xdrs, RPCBLIST **rp)
{
bool_t dummy;
@ -166,9 +160,7 @@ xdr_rpcblist(xdrs, rp)
bool_t
xdr_rpcb_entry(xdrs, objp)
XDR *xdrs;
rpcb_entry *objp;
xdr_rpcb_entry(XDR *xdrs, rpcb_entry *objp)
{
if (!xdr_string(xdrs, &objp->r_maddr, (u_int)~0)) {
return (FALSE);
@ -189,9 +181,7 @@ xdr_rpcb_entry(xdrs, objp)
}
bool_t
xdr_rpcb_entry_list_ptr(xdrs, rp)
XDR *xdrs;
rpcb_entry_list_ptr *rp;
xdr_rpcb_entry_list_ptr(XDR *xdrs, rpcb_entry_list_ptr *rp)
{
/*
* more_elements is pre-computed in case the direction is
@ -244,9 +234,7 @@ xdr_rpcb_entry_list_ptr(xdrs, rp)
* written for XDR_ENCODE direction only
*/
bool_t
xdr_rpcb_rmtcallargs(xdrs, p)
XDR *xdrs;
struct rpcb_rmtcallargs *p;
xdr_rpcb_rmtcallargs(XDR *xdrs, struct rpcb_rmtcallargs *p)
{
struct r_rpcb_rmtcallargs *objp =
(struct r_rpcb_rmtcallargs *)(void *)p;
@ -296,9 +284,7 @@ xdr_rpcb_rmtcallargs(xdrs, p)
* written for XDR_DECODE direction only
*/
bool_t
xdr_rpcb_rmtcallres(xdrs, p)
XDR *xdrs;
struct rpcb_rmtcallres *p;
xdr_rpcb_rmtcallres(XDR *xdrs, struct rpcb_rmtcallres *p)
{
bool_t dummy;
struct r_rpcb_rmtcallres *objp = (struct r_rpcb_rmtcallres *)(void *)p;
@ -314,9 +300,7 @@ xdr_rpcb_rmtcallres(xdrs, p)
}
bool_t
xdr_netbuf(xdrs, objp)
XDR *xdrs;
struct netbuf *objp;
xdr_netbuf(XDR *xdrs, struct netbuf *objp)
{
bool_t dummy;
void **pp;

28
lib/libc/rpc/rpcb_st_xdr.c
View File

@ -47,9 +47,7 @@ __FBSDID("$FreeBSD$");
/* Link list of all the stats about getport and getaddr */
bool_t
xdr_rpcbs_addrlist(xdrs, objp)
XDR *xdrs;
rpcbs_addrlist *objp;
xdr_rpcbs_addrlist(XDR *xdrs, rpcbs_addrlist *objp)
{
struct rpcbs_addrlist **pnext;
@ -83,9 +81,7 @@ xdr_rpcbs_addrlist(xdrs, objp)
/* Link list of all the stats about rmtcall */
bool_t
xdr_rpcbs_rmtcalllist(xdrs, objp)
XDR *xdrs;
rpcbs_rmtcalllist *objp;
xdr_rpcbs_rmtcalllist(XDR *xdrs, rpcbs_rmtcalllist *objp)
{
int32_t *buf;
struct rpcbs_rmtcalllist **pnext;
@ -198,9 +194,7 @@ xdr_rpcbs_rmtcalllist(xdrs, objp)
}
bool_t
xdr_rpcbs_proc(xdrs, objp)
XDR *xdrs;
rpcbs_proc objp;
xdr_rpcbs_proc(XDR *xdrs, rpcbs_proc objp)
{
if (!xdr_vector(xdrs, (char *)(void *)objp, RPCBSTAT_HIGHPROC,
sizeof (int), (xdrproc_t)xdr_int)) {
@ -210,9 +204,7 @@ xdr_rpcbs_proc(xdrs, objp)
}
bool_t
xdr_rpcbs_addrlist_ptr(xdrs, objp)
XDR *xdrs;
rpcbs_addrlist_ptr *objp;
xdr_rpcbs_addrlist_ptr(XDR *xdrs, rpcbs_addrlist_ptr *objp)
{
if (!xdr_pointer(xdrs, (char **)objp, sizeof (rpcbs_addrlist),
(xdrproc_t)xdr_rpcbs_addrlist)) {
@ -222,9 +214,7 @@ xdr_rpcbs_addrlist_ptr(xdrs, objp)
}
bool_t
xdr_rpcbs_rmtcalllist_ptr(xdrs, objp)
XDR *xdrs;
rpcbs_rmtcalllist_ptr *objp;
xdr_rpcbs_rmtcalllist_ptr(XDR *xdrs, rpcbs_rmtcalllist_ptr *objp)
{
if (!xdr_pointer(xdrs, (char **)objp, sizeof (rpcbs_rmtcalllist),
(xdrproc_t)xdr_rpcbs_rmtcalllist)) {
@ -234,9 +224,7 @@ xdr_rpcbs_rmtcalllist_ptr(xdrs, objp)
}
bool_t
xdr_rpcb_stat(xdrs, objp)
XDR *xdrs;
rpcb_stat *objp;
xdr_rpcb_stat(XDR *xdrs, rpcb_stat *objp)
{
if (!xdr_rpcbs_proc(xdrs, objp->info)) {
@ -262,9 +250,7 @@ xdr_rpcb_stat(xdrs, objp)
* being monitored.
*/
bool_t
xdr_rpcb_stat_byvers(xdrs, objp)
XDR *xdrs;
rpcb_stat_byvers objp;
xdr_rpcb_stat_byvers(XDR *xdrs, rpcb_stat_byvers objp)
{
if (!xdr_vector(xdrs, (char *)(void *)objp, RPCBVERS_STAT,
sizeof (rpcb_stat), (xdrproc_t)xdr_rpcb_stat)) {

4
lib/libc/rpc/svc_auth.c
View File

@ -95,9 +95,7 @@ struct svc_auth_ops svc_auth_null_ops;
* invalid.
*/
enum auth_stat
_authenticate(rqst, msg)
struct svc_req *rqst;
struct rpc_msg *msg;
_authenticate(struct svc_req *rqst, struct rpc_msg *msg)
{
int cred_flavor;
struct authsvc *asp;

8
lib/libc/rpc/svc_auth_unix.c
View File

@ -56,9 +56,7 @@ __FBSDID("$FreeBSD$");
* Unix longhand authenticator
*/
enum auth_stat
_svcauth_unix(rqst, msg)
struct svc_req *rqst;
struct rpc_msg *msg;
_svcauth_unix(struct svc_req *rqst, struct rpc_msg *msg)
{
enum auth_stat stat;
XDR xdrs;
@ -147,9 +145,7 @@ _svcauth_unix(rqst, msg)
*/
/*ARGSUSED*/
enum auth_stat
_svcauth_short(rqst, msg)
struct svc_req *rqst;
struct rpc_msg *msg;
_svcauth_short(struct svc_req *rqst, struct rpc_msg *msg)
{
return (AUTH_REJECTEDCRED);
}

36
lib/libc/rpc/svc_generic.c
View File

@ -72,13 +72,14 @@ extern int __svc_vc_setflag(SVCXPRT *, int);
* It creates a link list of all the handles it could create.
* If svc_create() is called multiple times, it uses the handle
* created earlier instead of creating a new handle every time.
*
* prognum - Program number
* versnum - Version number
* nettype - Networktype token
*/
int
svc_create(dispatch, prognum, versnum, nettype)
void (*dispatch)(struct svc_req *, SVCXPRT *);
rpcprog_t prognum; /* Program number */
rpcvers_t versnum; /* Version number */
const char *nettype; /* Networktype token */
svc_create(void (*dispatch)(struct svc_req *, SVCXPRT *),
rpcprog_t prognum, rpcvers_t versnum, const char *nettype)
{
struct xlist {
SVCXPRT *xprt; /* Server handle */
@ -143,13 +144,14 @@ svc_create(dispatch, prognum, versnum, nettype)
* The high level interface to svc_tli_create().
* It tries to create a server for "nconf" and registers the service
* with the rpcbind. It calls svc_tli_create();
*
* prognum - Program number
* versnum - Version number
* ncofn - Netconfig structure for the network
*/
SVCXPRT *
svc_tp_create(dispatch, prognum, versnum, nconf)
void (*dispatch)(struct svc_req *, SVCXPRT *);
rpcprog_t prognum; /* Program number */
rpcvers_t versnum; /* Version number */
const struct netconfig *nconf; /* Netconfig structure for the network */
svc_tp_create(void (*dispatch)(struct svc_req *, SVCXPRT *),
rpcprog_t prognum, rpcvers_t versnum, const struct netconfig *nconf)
{
SVCXPRT *xprt;
@ -184,14 +186,16 @@ svc_tp_create(dispatch, prognum, versnum, nconf)
* is set to 8.
*
* If sendsz or recvsz are zero, their default values are chosen.
*
* fd - Connection end point
* nconf - Netconfig struct for nettoken
* bindaddr - Local bind address
* sendsz - Max sendsize
* recvxz - Max recvsize
*/
SVCXPRT *
svc_tli_create(fd, nconf, bindaddr, sendsz, recvsz)
int fd; /* Connection end point */
const struct netconfig *nconf; /* Netconfig struct for nettoken */
const struct t_bind *bindaddr; /* Local bind address */
u_int sendsz; /* Max sendsize */
u_int recvsz; /* Max recvsize */
svc_tli_create(int fd, const struct netconfig *nconf,
const struct t_bind *bindaddr, u_int sendsz, u_int recvsz)
{
SVCXPRT *xprt = NULL; /* service handle */
bool_t madefd = FALSE; /* whether fd opened here */

34
lib/libc/rpc/svc_raw.c
View File

@ -82,7 +82,7 @@ static bool_t svc_raw_control(SVCXPRT *, const u_int, void *);
char *__rpc_rawcombuf = NULL;
SVCXPRT *
svc_raw_create()
svc_raw_create(void)
{
struct svc_raw_private *srp;
/* VARIABLES PROTECTED BY svcraw_lock: svc_raw_private, srp */
@ -125,17 +125,14 @@ svc_raw_create()
/*ARGSUSED*/
static enum xprt_stat
svc_raw_stat(xprt)
SVCXPRT *xprt; /* args needed to satisfy ANSI-C typechecking */
svc_raw_stat(SVCXPRT *xprt)
{
return (XPRT_IDLE);
}
/*ARGSUSED*/
static bool_t
svc_raw_recv(xprt, msg)
SVCXPRT *xprt;
struct rpc_msg *msg;
svc_raw_recv(SVCXPRT *xprt, struct rpc_msg *msg)
{
struct svc_raw_private *srp;
XDR *xdrs;
@ -159,9 +156,7 @@ svc_raw_recv(xprt, msg)
/*ARGSUSED*/
static bool_t
svc_raw_reply(xprt, msg)
SVCXPRT *xprt;
struct rpc_msg *msg;
svc_raw_reply(SVCXPRT *xprt, struct rpc_msg *msg)
{
struct svc_raw_private *srp;
XDR *xdrs;
@ -201,10 +196,7 @@ svc_raw_reply(xprt, msg)
/*ARGSUSED*/
static bool_t
svc_raw_getargs(xprt, xdr_args, args_ptr)
SVCXPRT *xprt;
xdrproc_t xdr_args;
void *args_ptr;
svc_raw_getargs(SVCXPRT *xprt, xdrproc_t xdr_args, void *args_ptr)
{
struct svc_raw_private *srp;
@ -222,10 +214,7 @@ svc_raw_getargs(xprt, xdr_args, args_ptr)
/*ARGSUSED*/
static bool_t
svc_raw_freeargs(xprt, xdr_args, args_ptr)
SVCXPRT *xprt;
xdrproc_t xdr_args;
void *args_ptr;
svc_raw_freeargs(SVCXPRT *xprt, xdrproc_t xdr_args, void *args_ptr)
{
struct svc_raw_private *srp;
XDR *xdrs;
@ -245,24 +234,19 @@ svc_raw_freeargs(xprt, xdr_args, args_ptr)
/*ARGSUSED*/
static void
svc_raw_destroy(xprt)
SVCXPRT *xprt;
svc_raw_destroy(SVCXPRT *xprt)
{
}
/*ARGSUSED*/
static bool_t
svc_raw_control(xprt, rq, in)
SVCXPRT *xprt;
const u_int rq;
void *in;
svc_raw_control(SVCXPRT *xprt, const u_int rq, void *in)
{
return (FALSE);
}
static void
svc_raw_ops(xprt)
SVCXPRT *xprt;
svc_raw_ops(SVCXPRT *xprt)
{
static struct xp_ops ops;
static struct xp_ops2 ops2;

4
lib/libc/rpc/svc_run.c
View File

@ -54,7 +54,7 @@ __FBSDID("$FreeBSD$");
#include "mt_misc.h"
void
svc_run()
svc_run(void)
{
fd_set readfds, cleanfds;
struct timeval timeout;
@ -89,7 +89,7 @@ svc_run()
* more work to do.
*/
void
svc_exit()
svc_exit(void)
{
rwlock_wrlock(&svc_fd_lock);
FD_ZERO(&svc_fdset);

22
lib/libc/rpc/svc_simple.c
View File

@ -92,16 +92,18 @@ static const char __no_mem_str[] = "out of memory";
* is also limited by the recvsize for that transport, even if it is
* a COTS transport. This may be wrong, but for cases like these, they
* should not use the simplified interfaces like this.
*
* prognum - program number
* versnum - version number
* procnum - procedure number
* progname - Server routine
* inproc, outproc - in/out XDR procedures
* nettype - nettype
*/
int
rpc_reg(prognum, versnum, procnum, progname, inproc, outproc, nettype)
rpcprog_t prognum; /* program number */
rpcvers_t versnum; /* version number */
rpcproc_t procnum; /* procedure number */
char *(*progname)(char *); /* Server routine */
xdrproc_t inproc, outproc; /* in/out XDR procedures */
char *nettype; /* nettype */
rpc_reg(rpcprog_t prognum, rpcvers_t versnum, rpcproc_t procnum,
char *(*progname)(char *), xdrproc_t inproc, xdrproc_t outproc,
char *nettype)
{
struct netconfig *nconf;
int done = FALSE;
@ -242,9 +244,7 @@ rpc_reg(prognum, versnum, procnum, progname, inproc, outproc, nettype)
*/
static void
universal(rqstp, transp)
struct svc_req *rqstp;
SVCXPRT *transp;
universal(struct svc_req *rqstp, SVCXPRT *transp)
{
rpcprog_t prog;
rpcvers_t vers;