8d96d5b3a759119baa5937624b8716c8abb4d572jroberts

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#pragma ident "%Z%%M% %I% %E% SMI"

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <sys/types.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <thread.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <synch.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <fcntl.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <sys/des.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <des/softdes.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <des/desdata.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <rpc/rpc.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <rpc/key_prot.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <rpc/des_crypt.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <rpc/pmap_prot.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <sys/ioctl.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <netdir.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <nss_netdir.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <nss_dbdefs.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <sac.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <netconfig.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <ndbm.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <rpcsvc/yp_prot.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <rpcsvc/ypclnt.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <rpcsvc/yppasswd.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <rpcsvc/ypupd.h>

d58fda4376e4bf67072ce2e69f6f47036f9dbb68jbeloro#include <rpcsvc/nis.h>

#include <rpcsvc/nis_callback.h>

#include <rpcsvc/nislib.h>

#include <rpcsvc/nispasswd.h>

#include <sys/stream.h>

#include <sys/stropts.h>

#include <sys/tihdr.h>

#include <sys/timod.h>

#include <tiuser.h>

#ifdef t_errno

#undef t_errno

#endif

extern int t_errno;

int cbc_crypt(char *key, char *buf, size_t len, uint_t mode, char *ivec);

int ecb_crypt(char *key, char *buf, size_t len, uint_t mode);

void des_setparity(char *p);

int __des_crypt(char *buf, unsigned len, struct desparams *desp);

int _des_crypt(char *buf, unsigned len, struct desparams *desp);

void undial(int fd);

void __gen_dhkeys(char *public, char *secret, char *pass);

int getpublickey(const char *netname, char *pkey);

int __getpublickey_cached(char *netname, char *pkey, int *from_cache);

void __getpublickey_flush(const char *netname);

int getsecretkey(const char *netname, char *skey, const char *passwd);

int xencrypt(char *secret, char *passwd);

int xdecrypt(char *secret, char *passwd);

int passwd2des(char *pw, char *key);

int *__nderror(void);

int netdir_getbyname(struct netconfig *tp, struct nd_hostserv *serv,

struct nd_addrlist **addrs);

int netdir_getbyaddr(struct netconfig *tp, struct nd_hostservlist **serv,

struct netbuf *addr);

int __netdir_getbyaddr_nosrv(struct netconfig *tp,

struct nd_hostservlist **serv,

struct netbuf *addr);

int netdir_options(struct netconfig *tp, int option, int fd, char *par);

struct netbuf *uaddr2taddr(struct netconfig *tp, char *addr);

char *taddr2uaddr(struct netconfig *tp, struct netbuf *addr);

void netdir_free(void *ptr, int type);

char *netdir_sperror(void);

void netdir_perror(char *s);

void *setnetconfig(void);

int endnetconfig(void *vdata);

struct netconfig *getnetconfig(void *vdata);

struct netconfig *getnetconfigent(const char *netid);

void freenetconfigent(struct netconfig *netp);

void *setnetpath(void);

int endnetpath(void *vdata);

struct netconfig *getnetpath(void *vdata);

char *nc_sperror(void);

void nc_perror(const char *string);

#ifdef notdef

nis_error __nis_CacheInit(NisCache **cache);

#endif

nis_error __nis_CacheBind(char *dname, directory_obj *dobj);

bool_t __nis_CacheRemoveEntry(directory_obj *dobj);

nis_error __nis_CacheSearch(char *dname, directory_obj *dobj);

void __nis_CacheRestart(void);

void __nis_CachePrint(void);

bool_t __nis_CacheAddEntry(fd_result *, directory_obj *);

uint32_t __nis_CacheLocalLoadPref(void);

nis_error __nis_CacheLocalInit(uint32_t *exp_time);

nis_error __nis_CacheMgrInit(void);

void __nis_CacheMgrCleanup(void);

nis_error __nis_CacheMgrBindReplica(char *dname);

nis_error __nis_CacheMgrBindMaster(char *dname);

nis_error __nis_CacheMgrBindServer(nis_server *srv, int nsrv);

int __nis_CacheMgrRefreshBinding(nis_bound_directory *binding);

int __nis_CacheMgrRefreshAddress(nis_bound_endpoint *bep);

int __nis_CacheMgrRefreshCallback(nis_bound_endpoint *bep);

int __nis_CacheMgrUpdateUaddr(char *uaddr);

void __nis_CacheMgrMarkUp(void);

uint32_t __nis_CacheMgrTimers(void);

uint32_t __nis_CacheMgrRefreshCache(void);

uint32_t __nis_serverRefreshCache(void);

bool_t writeColdStartFile(directory_obj *dobj);

int __nis_destroy_callback(void);

nis_server *__nis_init_callback(CLIENT *svc_clnt, int (*cbfunc)(),

void *userdata);

int __nis_run_callback(netobj *srvid, rpcproc_t srvproc,

struct timeval *timeout, CLIENT *myserv);

enum clnt_stat __nis_cast_proc(nis_bound_directory *binding, int base,

int nbep, rpcproc_t procnum,

xdrproc_t xdr_inproc, void *in,

xdrproc_t xdr_outproc, void *out,

int *fastest, int mytimeout);

bool_t xdr_obj_p(XDR *xdrs, obj_p *objp);

bool_t xdr_cback_data(XDR *xdrs, cback_data *objp);

typedef nis_result *(*nis_lookup_func)(nis_name, u_int);

int __nis_group_cache_stats(int *grpcachecall, int *grpcachehits,

int *grpcachemisses);

bool_t nis_ismember(nis_name princp, nis_name group);

bool_t __do_ismember(nis_name princp, nis_object *obj, nis_lookup_func lookup);

void nis_print_group_entry(nis_name group);

void nis_flushgroups(void);

void __nis_flush_group_exp_name(nis_name groupname);

nis_name __nis_map_group_r(const nis_name name, char *buf, size_t bufsize);

nis_error nis_addmember(nis_name princp, nis_name group);

nis_error nis_removemember(nis_name princp, nis_name group);

nis_error nis_verifygroup(nis_name group);

nis_error __nis_creategroup_obj(nis_name name, uint_t flags, nis_object *obj);

nis_error nis_creategroup(nis_name name, uint_t flags);

nis_error nis_destroygroup(nis_name name);

int nis_in_table(nis_name name, NIS_HASH_TABLE *table, int *key);

int nis_insert_item(NIS_HASH_ITEM *item, NIS_HASH_TABLE *table);

NIS_HASH_ITEM *nis_find_item(nis_name name, NIS_HASH_TABLE *table);

NIS_HASH_ITEM *nis_pop_item(NIS_HASH_TABLE *table);

NIS_HASH_ITEM *nis_remove_item(nis_name name, NIS_HASH_TABLE *table);

void nis_insert_name(nis_name name, NIS_HASH_TABLE *table);

void nis_remove_name(nis_name name, NIS_HASH_TABLE *table);

nis_result *__nis_remote_lookup(ib_request *req, u_int flags, int list_op,

void *cbdata, int (*cback)());

nis_result *__nis_core_lookup(ib_request *req, u_int flags, int list_op,

void *cbdata, int (*cback)());

fd_result *__nis_finddirectory_remote(nis_bound_directory **binding,

char *dname);

fd_result *__nis_finddirectory(nis_bound_directory **binding, char *dname);

fd_result *nis_finddirectory(directory_obj *dobj, nis_name name);

void __nis_pingproc(nis_server *srv, nis_name name, uint32_t mtime);

void nis_ping(nis_name name, uint32_t mtime, nis_object *obj);

log_result *nis_dumplog(nis_server *host, nis_name name, uint32_t dtime);

log_result *nis_dump(nis_server *host, nis_name name, int (*cback)());

void nis_free_binding(nis_bound_directory *binding);

void __nis_path_free(char **names, int len);

nis_error __nis_path(char *from, char *to, int *path_length, char ***namesp);

int __nis_host_is_server(nis_server *, int);

void __nis_print_result(nis_result *);

struct netconfig *__nis_get_netconfig(endpoint *);

void __nis_auth2princ(char *name, int flavor, caddr_t auth, bool_t refresh,

int verbose);

bool_t __nis_ck_perms(u_int right, u_int mask, nis_object *obj,

nis_name pr, int level);

bool_t __nis_ismaster(char *host, char *domain);

bool_t __nis_isadmin(char *princ, char *table, char *domain);

nis_server * __nis_host2nis_server(char *host, bool_t addpubkey, int *errcode);

int __nis_parse_path(char *path, nis_name *list, int max);

nis_name *nis_getnames(nis_name name);

void nis_freenames(nis_name *namelist);

char *nis_sperrno(nis_error stat);

void nis_perror(nis_error stat, char *str);

char *nis_sperror_r(nis_error stat, char *str, char buf[], int len);

char *nis_sperror(nis_error stat, char *str);

void nis_lerror(nis_error stat, char *str);

typedef struct {

nis_server *srv;

int nsrv;

char *name;

int parent_first;

u_int flags;

struct timeval timeout;

nis_error niserror;

uint32_t aticks;

int state;

nis_bound_directory *binding;

int base;

int end;

int count;

int start;

int cur;

int bound_to;

int refresh_count;

} nis_call_state;

void __nis_reset_state(void);

void __nis_bad_auth_server(CLIENT *c);

void __nis_release_server(nis_call_state *state, CLIENT *c,

enum clnt_stat status);

CLIENT *__nis_get_server(nis_call_state *state);

int __start_clock(int clk);

unsigned int __stop_clock(int clk);

name_pos nis_dir_cmp(nis_name n1, nis_name n2);

nis_name nis_local_group(void);

nis_name nis_domain_of(char *s);

nis_name nis_leaf_of_r(const nis_name s, char *buf, size_t bufsize);

nis_name nis_leaf_of(char *s);

nis_name nis_name_of(char *s);

nis_name nis_local_directory(void);

int __nis_principal(char *principal_name, uid_t uid, char *directory);

nis_name nis_local_principal(void);

nis_name nis_local_host(void);

void nis_destroy_object(nis_object *obj);

nis_object *nis_clone_object(nis_object *obj, nis_object *dest);

char **__break_name(nis_name name, int *levels);

int __name_distance(char **targ, char **test);

nis_result *nis_make_error(nis_error err, uint32_t aticks, uint32_t cticks,

uint32_t dticks, uint32_t zticks);

nis_attr *__cvt2attr(int *na, char **attrs);

void nis_free_request(ib_request *req);

nis_error nis_get_request(nis_name name, nis_object *obj, netobj *cookie,

ib_request *reqreq);

nis_object *nis_read_obj(char *f);

int nis_write_obj(char *f, nis_object *o);

CLIENT *nis_make_rpchandle(nis_server *srv, int cback, rpcprog_t prog,

rpcvers_t ver, u_int flags, int inbuf, int outbuf);

void *nis_get_static_storage(struct nis_sdata *bs, u_int el, u_int nel);

char *nis_old_data(char *s);

char *nis_data(char *s);

nis_name __nis_local_root(void);

void nis_freeservlist(nis_server **servers);

nis_server **nis_getservlist(nis_name name);

nis_error nis_stats(nis_server *srv, nis_tag *tags, int ntags,

nis_tag **result);

nis_error nis_servstate(nis_server *srv, nis_tag *tags, int ntags,

nis_tag **result);

void nis_freetags(nis_tag *tags, int ntags);

bool_t xdr_nis_attr(XDR *xdrs, nis_attr *objp);

bool_t xdr_nis_name(XDR *xdrs, nis_name *objp);

bool_t xdr_endpoint(XDR *xdrs, endpoint *objp);

bool_t xdr_nis_server(XDR *xdrs, nis_server *objp);

bool_t xdr_directory_obj(XDR *xdrs, directory_obj *objp);

bool_t xdr_entry_obj(XDR *xdrs, entry_obj *objp);

bool_t xdr_table_obj(XDR *xdrs, table_obj *objp);

bool_t xdr_objdata(XDR *xdrs, objdata *objp);

bool_t xdr_nis_oid(XDR *xdrs, nis_oid *objp);

bool_t xdr_nis_object(XDR *xdrs, nis_object *objp);

bool_t xdr_nis_object(XDR *xdrs, nis_object *objp);

bool_t xdr_nis_error(XDR *xdrs, nis_error *objp);

bool_t xdr_nis_result(XDR *xdrs, nis_result *objp);

bool_t xdr_ns_request(XDR *xdrs, ns_request *objp);

bool_t xdr_ib_request(XDR *xdrs, ib_request *objp);

bool_t xdr_ping_args(XDR *xdrs, ping_args *objp);

bool_t xdr_log_entry_t(XDR *xdrs, log_entry_t *objp);

bool_t xdr_log_entry(XDR *xdrs, log_entry *objp);

bool_t xdr_log_result(XDR *xdrs, log_result *objp);

bool_t xdr_cp_result(XDR *xdrs, cp_result *objp);

bool_t xdr_nis_tag(XDR *xdrs, nis_tag *objp);

bool_t xdr_nis_taglist(XDR *xdrs, nis_taglist *objp);

bool_t xdr_dump_args(XDR *xdrs, dump_args *objp);

bool_t xdr_fd_args(XDR *xdrs, fd_args *objp);

bool_t xdr_fd_result(XDR *xdrs, fd_result *objp);

bool_t xdr_nis_bound_endpoint(XDR *xdrs, nis_bound_endpoint *objp);

bool_t xdr_nis_bound_directory(XDR *xdrs, nis_bound_directory *objp);

bool_t xdr_nis_active_endpoint(XDR *xdrs, nis_active_endpoint *objp);

void nis_freeresult(nis_result *res);

void __nis_freelogresult(log_result *lres);

nis_error nis_bind_dir(char *dname, int parent_first,

nis_bound_directory **binding, u_int flags);

nis_result *nis_lookup(nis_name name, uint_t flags);

nis_result *nis_list(nis_name name, uint_t flags, int (*cback)(),

void *cbdata);

nis_result *nis_add(nis_name name, nis_object *obj);

nis_result *nis_remove(nis_name name, nis_object *obj);

nis_result *nis_modify(nis_name name, nis_object *obj);

nis_result *nis_add_entry(nis_name name, nis_object *obj, uint_t flags);

nis_result *nis_remove_entry(nis_name name, nis_object *obj, uint_t flags);

nis_result *nis_modify_entry(nis_name name, nis_object *obj, uint_t flags);

nis_result *nis_first_entry(nis_name table);

nis_result *nis_next_entry(nis_name table, netobj *cookie);

nis_result *nis_checkpoint(nis_name name);

nis_error nis_mkdir(nis_name name, nis_server *srv);

nis_error nis_rmdir(nis_name name, nis_server *srv);

nis_error __nis_send_msg(nis_server *srv, int proc, xdrproc_t out, char *msg);

nis_result *__nis_list_localcb(nis_name name, u_int flags,

int (*cback)(), void *cbdata);

bool_t __npd_ecb_crypt(uint32_t *val1, uint32_t *val2, des_block *buf,

uint_t bufsize, uint_t mode, des_block *deskey);

bool_t __npd_cbc_crypt(uint32_t *val, char *str, uint_t strsize,

npd_newpass *buf, uint_t bufsize, uint_t mode,

des_block *deskey);

void nis_print_rights(u_int r);

void nis_print_directory(directory_obj *r);

void nis_print_group(group_obj *g);

void nis_print_table(table_obj *t);

void nis_print_link(link_obj *l);

void nis_print_entry(entry_obj *edata);

void nis_print_object(nis_object *o);

int *__t_errno(void);

int t_accept(int, int, struct t_call *);

char *t_alloc(int, int, int);

int t_bind(int, struct t_bind *, struct t_bind *);

int t_close(int);

int t_connect(int, struct t_call *, struct t_call *);

void t_error(const char *);

int t_free(char *, int);

int t_getinfo(int, struct t_info *);

int t_getname(int, struct netbuf *, int);

int t_getstate(int);

int t_listen(int, struct t_call *);

int t_look(int);

int t_open(const char *, int, struct t_info *);

int t_optmgmt(int, struct t_optmgmt *, struct t_optmgmt *);

int t_rcv(int, char *, unsigned, int *);

int t_rcvconnect(int, struct t_call *);

int t_rcvdis(int, struct t_discon *);

int t_rcvrel(int);

int t_rcvudata(int, struct t_unitdata *, int *);

int t_rcvuderr(int, struct t_uderr *);

int t_snd(int, char *, unsigned, int);

int t_snddis(int, struct t_call *);

int t_sndrel(int);

int t_sndudata(int, struct t_unitdata *);

char *_t_strerror(int);

int t_sync(int);

int t_unbind(int);

struct t_iovec {

void *iov_base;

size_t iov_len;

};

int t_sndv(int, const struct t_iovec *, unsigned int, int);

int t_sndvudata(int, struct t_unitdata *, struct t_iovec *, unsigned int);

int t_sndreldata(int, struct t_discon *);

int t_rcvv(int, struct t_iovec *, unsigned int, int *);

int t_rcvvudata(int, struct t_unitdata *, struct t_iovec *,

unsigned int, int *);

extern int t_rcvreldata(int, struct t_discon *);

int t_sysconf(int);

int _xti_accept(int, int, struct t_call *);

int _xti_xns5_accept(int, int, struct t_call *);

char *_xti_alloc(int, int, int);

int _xti_bind(int, struct t_bind *, struct t_bind *);

int _xti_close(int);

int _xti_connect(int, struct t_call *, struct t_call *);

int _xti_error(char *);

int _xti_free(char *, int);

int _xti_getinfo(int, struct t_info *);

int _xti_getprotaddr(int, struct t_bind *, struct t_bind *);

int _xti_getstate(int);

int _xti_listen(int, struct t_call *);

int _xti_look(int);

int _xti_open(char *, int, struct t_info *);

int _xti_optmgmt(int, struct t_optmgmt *, struct t_optmgmt *);

int _xti_rcv(int, char *, unsigned int, int *);

int _xti_rcvconnect(int, struct t_call *);

int _xti_rcvdis(int, struct t_discon *);

int _xti_rcvrel(int);

int _xti_rcvreldata(int, struct t_discon *);

int _xti_rcvudata(int, struct t_unitdata *, int *);

int _xti_rcvuderr(int, struct t_uderr *);

int _xti_rcvv(int, struct t_iovec *, unsigned int, int *);

int _xti_rcvvudata(int, struct t_unitdata *, struct t_iovec *,

unsigned int, int *);

int _xti_snd(int, char *, unsigned int, int);

int _xti_xns5_snd(int, char *, unsigned int, int);

int _xti_snddis(int, struct t_call *);

int _xti_sndrel(int);

int _xti_sndreldata(int, struct t_discon *);

int _xti_sndudata(int, struct t_unitdata *);

int _xti_sndv(int, const struct t_iovec *, unsigned int, int);

int _xti_sndvudata(int, struct t_unitdata *, struct t_iovec *, unsigned int);

char *_xti_strerror(int);

int _xti_sync(int);

int _xti_sysconf(int);

int _xti_unbind(int);

struct hostent *_uncached_gethostbyname_r(const char *nam,

struct hostent *result,

char *buffer, int buflen, int *h_errnop);

struct hostent *_uncached_gethostbyaddr_r(const char *addr, int length,

int type, struct hostent *result,

char *buffer, int buflen, int *h_errnop);

struct hostent *gethostbyname_r(const char *nam, struct hostent *result,

char *buffer, int buflen, int *h_errnop);

struct hostent *gethostbyaddr_r(const char *addr, int length, int type,

struct hostent *result,

char *buffer, int buflen, int *h_errnop);

struct hostent *gethostbyname(const char *nam);

struct hostent *gethostbyaddr(const void *addr, socklen_t len, int type);

struct hostent *gethostent(void);

int sethostent(int stay);

int endhostent(void);

struct hostent *gethostent_r(struct hostent *result, char *buffer, int buflen,

int *h_errnop);

void freehostent(struct hostent *hent);

struct hostent *getipnodebyaddr(const void *src, size_t len, int type,

int *error_num);

struct hostent *getipnodebyname(const char *name, int af, int flags,

int *error_num);

struct rpcent *getrpcbyname(const char *nam);

struct rpcent *getrpcbynumber(const int num);

struct rpcent *getrpcent(void);

struct rpcent *getrpcbyname_r(const char *name, struct rpcent *result,

char *buffer, int buflen);

struct rpcent *getrpcbynumber_r(const int number, struct rpcent *result,

char *buffer, int buflen);

void setrpcent(const int stay);

void endrpcent(void);

struct rpcent *getrpcent_r(struct rpcent *result, char *buffer, int buflen);

const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);

int inet_pton(int af, const char *src, void *dst);

int _get_hostserv_inetnetdir_byname(struct netconfig *nconf,

struct nss_netdirbyname_in *args,

union nss_netdirbyname_out *res);

int _get_hostserv_inetnetdir_byaddr(struct netconfig *nconf,

struct nss_netdirbyaddr_in *args,

union nss_netdirbyaddr_out *res);

int __nss2herrno(nss_status_t nsstat);

nss_status_t _herrno2nss(int h_errno);

struct hostent *_switch_gethostbyname_r(const char *name,

struct hostent *result,

char *buffer, int buflen, int *h_errnop);

struct hostent *_switch_gethostbyaddr_r(const char *addr, int len, int type,

struct hostent *result,

char *buffer, int buflen, int *h_errnop);

int str2servent(const char *instr, int lenstr, void *ent,

char *buffer, int buflen);

void *__inet_get_local_interfaces(void);

void __inet_free_local_interfaces(void *p);

int __inet_address_is_local(void *p, struct in_addr addr);

int __inet_uaddr_is_local(void *p, struct netconfig *nc, char *uaddr);

int __inet_address_count(void *p);

ulong_t __inet_get_addr(void *p, int n);

char *__inet_get_uaddr(void *p, struct netconfig *nc, int n);

char *__inet_get_networka(void *p, int n);

AUTH *authdes_seccreate(const char *servername, uint_t win,

const char *timehost, const des_block *ckey);

AUTH *authnone_create(void);

AUTH *authsys_create(const char *machname, uid_t uid, gid_t gid, int len,

const gid_t *aup_gids);

AUTH *authsys_create_default(void);

bool_t xdr_authdes_cred(XDR *xdrs, struct authdes_cred *cred);

bool_t xdr_authdes_verf(XDR *xdrs, struct authdes_verf *verf);

bool_t xdr_authsys_parms(XDR *xdrs, struct authsys_parms *p);

bool_t xdr_uid_t(XDR *xdrs, uid_t *ip);

bool_t xdr_gid_t(XDR *xdrs, gid_t *ip);

enum clnt_stat 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 *netclass);

enum clnt_stat 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 *netclass);

CLIENT *clnt_dg_create(int fd, struct netbuf *svcaddr, rpcprog_t program,

rpcvers_t version, uint_t sendsz, uint_t recvsz);

CLIENT *clnt_door_create(rpcprog_t program, rpcvers_t version, uint_t sendsz);

CLIENT *clnt_create_vers(const char *hostname, rpcprog_t prog,

rpcvers_t *vers_out, rpcvers_t vers_low,

rpcvers_t vers_high, const char *nettype);

CLIENT *clnt_create_vers_timed(const char *hostname, rpcprog_t prog,

rpcvers_t *vers_out, rpcvers_t vers_low,

rpcvers_t vers_high, const char *nettype,

const struct timeval *tp);

CLIENT *clnt_create(const char *hostname, rpcprog_t prog, rpcvers_t vers,

const char *nettype);

CLIENT *clnt_create_timed(const char *hostname, rpcprog_t prog, rpcvers_t vers,

const char *netclass, const struct timeval *tp);

CLIENT *clnt_tp_create(const char *hostname, rpcprog_t prog, rpcvers_t vers,

const struct netconfig *nconf);

CLIENT *clnt_tp_create_timed(const char *hostname, rpcprog_t prog,

rpcvers_t vers, const struct netconfig *nconf,

const struct timeval *tp);

CLIENT *clnt_tli_create(int fd, const struct netconfig *nconf,

struct netbuf *svcaddr, rpcprog_t prog, rpcvers_t vers,

uint_t sendsz, uint_t recvsz);

char *clnt_sperror(const CLIENT *cl, const char *s);

void clnt_perror(const CLIENT *cl, const char *s);

void clnt_perrno(enum clnt_stat num);

char *clnt_spcreateerror(const char *s);

void clnt_pcreateerror(const char *s);

const char *clnt_sperrno(const enum clnt_stat stat);

CLIENT *clnt_raw_create(rpcprog_t prog, rpcvers_t vers);

enum clnt_stat rpc_call(const char *host, rpcprog_t prognum, rpcvers_t versnum,

rpcproc_t procnum, xdrproc_t inproc, const char *in,

xdrproc_t outproc, char *out, const char *netclass);

CLIENT *clnt_vc_create(int fd, struct netbuf *svcaddr, rpcprog_t prog,

rpcvers_t vers, uint_t sendsz, uint_t recvsz);

int getdomainname(char *name, int namelen);

int setdomainname(char *domain, int len);

int gethostname(char *hname, int hlen);

char *inet_ntoa_r(struct in_addr in, char b[]);

char *inet_ntoa(struct in_addr in);

in_addr_t inet_addr(const char *cp);

in_addr_t inet_netof(struct in_addr in);

int key_setsecret(const char *secretkey);

int key_secretkey_is_set(void);

int key_encryptsession_pk(const char *remotename, netobj *remotekey,

des_block *deskey);

int key_decryptsession_pk(const char *remotename, netobj *remotekey,

des_block *deskey);

int key_encryptsession(const char *remotename, des_block *deskey);

int key_decryptsession(const char *remotename, des_block *deskey);

int key_gendes(des_block *key);

int key_setnet(struct key_netstarg *arg);

int key_get_conv(char *pkey, des_block *deskey);

int key_call(ulong_t proc, xdrproc_t xdr_arg, char *arg, xdrproc_t xdr_rslt,

char *rslt);

bool_t xdr_keystatus(XDR *xdrs, keystatus *objp);

bool_t xdr_keybuf(XDR *xdrs, keybuf objp);

bool_t xdr_netnamestr(XDR *xdrs, netnamestr *objp);

bool_t xdr_cryptkeyarg(XDR *xdrs, cryptkeyarg *objp);

bool_t xdr_cryptkeyarg2(XDR *xdrs, cryptkeyarg2 *objp);

bool_t xdr_cryptkeyres(XDR *xdrs, cryptkeyres *objp);

bool_t xdr_unixcred(XDR *xdrs, unixcred *objp);

bool_t xdr_getcredres(XDR *xdrs, getcredres *objp);

bool_t xdr_key_netstarg(XDR *xdrs, key_netstarg *objp);

bool_t xdr_key_netstres(XDR *xdrs, key_netstres *objp);

#ifdef rpc_createerr

#undef rpc_createerr

#endif

struct rpc_createerr *__rpc_createerr(void);

int getnetname(char *name);

int __getnetnamebyuid(char *name, uid_t uid);

int user2netname(char *netname, const uid_t uid, const char *domain);

int host2netname(char *netname, const char *host, const char *domain);

int netname2user(const char *netname, uid_t *uidp, gid_t *gidp,

int *gidlenp, gid_t *gidlist);

int netname2host(const char *netname, char *hostname, int hostlen);

int pmap_set(rpcprog_t program, rpcvers_t version, rpcprot_t protocol, ushort_t port);

bool_t pmap_unset(rpcprog_t program, rpcvers_t version);

ushort_t pmap_getport(struct sockaddr_in *address, rpcprog_t program,

rpcvers_t version, rpcprot_t protocol);

struct pmaplist *pmap_getmaps(struct sockaddr_in *address);

enum clnt_stat pmap_rmtcall(struct sockaddr_in *addr, rpcprog_t prog,

rpcvers_t vers, rpcproc_t proc, xdrproc_t xdrargs,

caddr_t argsp, xdrproc_t xdrres, caddr_t resp,

struct timeval tout, rpcport_t *port_ptr);

bool_t xdr_pmap(XDR *xdrs, struct pmap *objp);

bool_t xdr_pmaplist_ptr(XDR *xdrs, pmaplist_ptr *rp);

bool_t xdr_pmaplist(XDR *xdrs, PMAPLIST **rp);

bool_t xdr_rmtcallargs(XDR *xdrs, struct p_rmtcallargs *cap);

bool_t xdr_rmtcallres(XDR *xdrs, struct p_rmtcallres *crp);

bool_t xdr_callmsg(XDR *xdrs, struct rpc_msg *cmsg);

int __rpc_dtbsize(void);

uint_t __rpc_get_t_size(t_scalar_t size, t_scalar_t bufsize);

uint_t __rpc_get_a_size(t_scalar_t size);

struct netconfig *__rpc_getconfip(char *nettype);

void *__rpc_setconf(char *nettype);

struct netconfig *__rpc_getconf(void *vhandle);

void __rpc_endconf(void *vhandle);

struct netconfig *__rpcfd_to_nconf(int fd, int servtype);

int __rpc_matchserv(int servtype, unsigned int nc_semantics);

bool_t xdr_opaque_auth(XDR *xdrs, struct opaque_auth *ap);

bool_t xdr_des_block(XDR *xdrs, des_block *blkp);

bool_t xdr_accepted_reply(XDR *xdrs, struct accepted_reply *ar);

bool_t xdr_rejected_reply(XDR *xdrs, struct rejected_reply *rr);

bool_t xdr_replymsg(XDR *xdrs, struct rpc_msg *rmsg);

bool_t xdr_callhdr(XDR *xdrs, struct rpc_msg *cmsg);

void __seterr_reply(struct rpc_msg *msg, struct rpc_err *error);

int __rpc_select_to_poll(int fdmax, fd_set *fdset, struct pollfd *p0);

int __rpc_timeval_to_msec(struct timeval *t);

CLIENT *clntudp_bufcreate(struct sockaddr_in *raddr, rpcprog_t prog,

rpcvers_t vers, struct timeval wait, int *sockp,

uint_t sendsz, uint_t recvsz);

CLIENT *clntudp_create(struct sockaddr_in *raddr, rpcprog_t program,

rpcvers_t version, struct timeval wait, int *sockp);

CLIENT *clnttcp_create(struct sockaddr_in *raddr, rpcprog_t prog,

rpcvers_t vers, int *sockp, uint_t sendsz,

uint_t recvsz);

CLIENT *clntraw_create(rpcprog_t prog, rpcvers_t vers);

SVCXPRT *svctcp_create(int fd, uint_t sendsize, uint_t recvsize);

SVCXPRT *svcudp_bufcreate(int fd, uint_t sendsize, uint_t recvsize);

SVCXPRT *svcfd_create(int fd, uint_t sendsize, uint_t recvsize);

SVCXPRT *svcudp_create(int fd);

SVCXPRT *svcraw_create(void);

int __rpc_bindresvport(int fd, struct sockaddr_in *sin, int *portp, int qlen);

void get_myaddress(struct sockaddr_in *addr);

ushort_t getrpcport(char *host, rpcprog_t prognum, rpcvers_t versnum, rpcprot_t proto);

int callrpc(char *host, rpcprog_t prognum, rpcvers_t versnum, rpcproc_t procnum,

xdrproc_t inproc, char *in, xdrproc_t outproc, char *out);

int registerrpc(rpcprog_t prognum, rpcvers_t versnum, rpcproc_t procnum,

char *(*progname)(), xdrproc_t inproc, xdrproc_t outproc);

enum clnt_stat clnt_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);

AUTH *authdes_create(char *servername, uint_t window,

struct sockaddr_in *syncaddr, des_block *ckey);

bool_t __rpc_control(int request, void *info);

bool_t rpcb_set(rpcprog_t program, rpcvers_t version,

const struct netconfig *nconf, const struct netbuf *address);

bool_t rpcb_unset(rpcprog_t program, rpcvers_t version,

const struct netconfig *nconf);

int rpcb_getaddr(rpcprog_t program, rpcvers_t version,

const struct netconfig *nconf, struct netbuf *address,

const char *host);

rpcblist *rpcb_getmaps(const struct netconfig *nconf, const char *host);

enum clnt_stat 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,

struct netbuf *addr_ptr);

bool_t rpcb_gettime(const char *host, time_t *timep);

char *rpcb_taddr2uaddr(struct netconfig *nconf, struct netbuf *taddr);

struct netbuf *rpcb_uaddr2taddr(struct netconfig *nconf, char *uaddr);

bool_t xdr_rpcb(XDR *xdrs, RPCB *objp);

bool_t xdr_rpcblist_ptr(XDR *xdrs, rpcblist_ptr *rp);

bool_t xdr_rpcblist(XDR *xdrs, RPCBLIST **rp);

bool_t xdr_rpcb_entry(XDR *xdrs, rpcb_entry *objp);

bool_t xdr_rpcb_entry_list_ptr(XDR *xdrs, rpcb_entry_list_ptr *rp);

bool_t xdr_rpcb_rmtcallargs(XDR *xdrs, struct r_rpcb_rmtcallargs *objp);

bool_t xdr_rpcb_rmtcallres(XDR *xdrs, struct r_rpcb_rmtcallres *objp);

bool_t xdr_netbuf(XDR *xdrs, struct netbuf *objp);

bool_t xdr_rpcbs_addrlist(XDR *xdrs, rpcbs_addrlist *objp);

bool_t xdr_rpcbs_addrlist(XDR *xdrs, rpcbs_addrlist *objp);

bool_t xdr_rpcbs_rmtcalllist(XDR *xdrs, rpcbs_rmtcalllist *objp);

bool_t xdr_rpcbs_proc(XDR *xdrs, rpcbs_proc objp);

bool_t xdr_rpcbs_addrlist_ptr(XDR *xdrs, rpcbs_addrlist_ptr *objp);

bool_t xdr_rpcbs_rmtcalllist_ptr(XDR *xdrs, rpcbs_rmtcalllist_ptr *objp);

bool_t xdr_rpcb_stat(XDR *xdrs, rpcb_stat *objp);

bool_t xdr_rpcb_stat_byvers(XDR *xdrs, rpcb_stat_byvers objp);

int __rpc_get_default_domain(char **domain);

AUTH *rpc_gss_seccreate(CLIENT *clnt, char *principal, char *mechanism,

rpc_gss_service_t service_type, char *qop,

rpc_gss_options_req_t *options_req,

rpc_gss_options_ret_t *options_ret);

bool_t rpc_gss_set_defaults(AUTH *auth, rpc_gss_service_t service, char *qop);

bool_t rpc_gss_get_principal_name(rpc_gss_principal_t *principal, char

*mechanism, char *user_name, char *node, char *secdomain);

char **rpc_gss_get_mechanisms(void);

char **rpc_gss_get_mech_info(char *mechanism, rpc_gss_service_t *service);

bool_t rpc_gss_get_versions(u_int *vers_hi, u_int *vers_lo);

bool_t rpc_gss_is_installed(char *mechanism);

bool_t rpc_gss_set_svc_name(char *principal, char *mechanism, uint_t req_time,

uint_t program, uint_t version);

bool_t rpc_gss_set_callback(rpc_gss_callback_t *cb);

bool_t rpc_gss_getcred(struct svc_req *req, rpc_gss_rawcred_t **rcred,

rpc_gss_ucred_t **ucred, void **cookie);

bool_t rpc_gss_mech_to_oid(char *mech, rpc_gss_OID *oid);

bool_t rpc_gss_qop_to_num(char *qop, char *mech, u_int *num);

int rpc_gss_max_data_length(AUTH *rpcgss_handle, int max_tp_unit_len);

int rpc_gss_svc_max_data_length(struct svc_req *req, int max_tp_unit_len);

void rpc_gss_get_error(rpc_gss_error_t *error);

int rtime_tli(char *host, struct timeval *timep, struct timeval *timeout);

void xprt_register(const SVCXPRT *xprt);

void xprt_unregister(const SVCXPRT *xprt);

bool_t svc_reg(const SVCXPRT *xprt, rpcprog_t prog, rpcvers_t vers,

void (*dispatch)(), const struct netconfig *nconf);

void svc_unreg(rpcprog_t prog, rpcvers_t vers);

bool_t svc_register(SVCXPRT *xprt, rpcprog_t prog, rpcvers_t vers,

void (*dispatch)(), int protocol);

void svc_unregister(rpcprog_t prog, rpcvers_t vers);

bool_t svc_sendreply(const SVCXPRT *xprt, xdrproc_t xdr_results,

caddr_t xdr_location);

void svcerr_noproc(const SVCXPRT *xprt);

void svcerr_decode(const SVCXPRT *xprt);

void svcerr_systemerr(const SVCXPRT *xprt);

void svcerr_auth(const SVCXPRT *xprt, enum auth_stat why);

void svcerr_weakauth(const SVCXPRT *xprt);

void svcerr_noprog(const SVCXPRT *xprt);

void svcerr_progvers(const SVCXPRT *xprt, rpcvers_t low_vers,

rpcvers_t high_vers);

void svc_getreq(int rdfds);

void svc_getreqset(fd_set *readfds);

void svc_getreq_poll(struct pollfd *pfdp, int pollretval);

void svc_getreq_common(int fd);

SVCXPRT *svc_xprt_alloc(void);

void svc_xprt_free(SVCXPRT *xprt);

bool_t svc_get_local_cred(SVCXPRT *xprt, svc_local_cred_t *lcred);

SVCAUTH *__svc_get_svcauth(SVCXPRT *);

void *__svc_set_proc_cleanup_cb(void *cb);

enum auth_stat __authenticate(struct svc_req *rqst, struct rpc_msg *msg);

int svc_auth_reg(int cred_flavor, enum auth_stat (*handler)());

SVCXPRT *svc_dg_create(int fd, uint_t sendsize, uint_t recvsize);

int svc_dg_enablecache(SVCXPRT *xprt, uint_t size);

SVCXPRT *svc_door_create(void (*dispatch)(), rpcprog_t prognum,