llib-lcommon

来自「ftam等标准协议服务器和客户端的源代码。」· 代码 · 共 2,062 行 · 第 1/2 页

{
	(void) want_oc_hierarchy();
} 

load_obj_hier (sep,newname) 
char * sep; 
char * newname; 
{
	return load_obj_hier(sep,newname);
} 

void dumpalloid () 
{
	dumpalloid();
} 

objectclass * str2oc (str)
char * str;
{
	return (str2oc (str));
}

add_oc_macro (buf,ptr) 
char * buf, *ptr; 
{
	(void) add_oc_macro(buf,ptr);
} 

oid_seq_free (ptr) 
struct oid_seq * ptr; 
{
	(void) oid_seq_free(ptr);
} 

struct oid_seq *oid_seq_merge (a,b) 
struct oid_seq *a; 
struct oid_seq *b; 
{
	return (oid_seq_merge(a,b));
} 

oid_seq_cmp (a,b) 
struct oid_seq *a, *b; 
{
	return (oid_seq_cmp(a,b));
} 

struct oid_seq * oid_seq_cpy (a) 
struct oid_seq * a; 
{
	return (oid_seq_cpy(a));
} 

oid_seq_print (ps,ptr,format) 
PS ps; 
register struct oid_seq * ptr; 
int format; 
{
	(void) oid_seq_print(ps,ptr,format);
} 

struct oid_seq * str2oidseq (str) 
char * str; 
{
	return (str2oidseq(str));
} 

parse_error (a,b) 
char *a, *b; 
{
	(void) parse_error(a,b);
} 

pref_deliv_syntax ()
{
	(void) pref_deliv_syntax ();
}

pe_print (ps, pe, format) 
register PS ps; 
register PE pe; 
int format; 
{
	(void) pe_print (ps,pe,format);
} 

PE asn2pe (str) 
char * str; 
{
	return (asn2pe(str));
} 

char * show_picture (picture,picture_process,len) 
char *picture; 
char *picture_process; 
int len; 
{
	return (show_picture(picture,picture_process,len));
} 

exec_print (ps,av,proc) 
PS ps; 
AttributeValue av; 
char * proc; 
{
	(void) exec_print(ps,av,proc);
} 

hide_picture () 
{
	(void) hide_picture();
} 

picture_print (ps,pe,format) 
PS ps; 
PE pe; 
int format; 
{
	(void) picture_print(ps,pe,format);
} 

photo_syntax () 
{
	(void) photo_syntax();
} 

post_syntax () 
{
	(void) post_syntax();
} 


psap_free (psap) 
struct PSAPaddr * psap; 
{
	(void) psap_free(psap);
} 

struct PSAPaddr * psap_cpy (a) 
struct PSAPaddr * a; 
{
	return (psap_cpy(a));
} 

psap_dup (r,a) 
struct PSAPaddr * r, * a; 
{
	(void) psap_dup(r,a);
} 

psap_syntax () 
{
	(void) psap_syntax();
} 

quipu_syntaxes () 
{
	(void) quipu_syntaxes();
} 

rdn_cmp_comp (a,b) 
RDN a,b; 
{
	return (rdn_cmp_comp(a,b));
} 

rdn_cmp (a,b) 
register RDN a,b; 
{
	return (rdn_cmp(a,b));
} 


RDN rdn_comp_cpy (rdn) 
RDN rdn; 
{
	return (rdn_comp_cpy(rdn));
} 

RDN rdn_cpy (rdn) 
RDN rdn; 
{
	return (rdn_cpy(rdn));
} 


rdn_comp_free (rdn) 
RDN rdn; 
{
	(void) rdn_comp_free(rdn);
} 

rdn_free (rdn) 
RDN rdn; 
{
	(void) rdn_free(rdn);
} 


RDN rdn_merge (a,b) 
RDN a,b; 
{
	return (rdn_merge(a,b));
} 


RDN rdn_comp_new (at,av) 
AttributeType at; 
AttributeValue av; 
{
	return (rdn_comp_new(at,av));
} 


rdn_comp_print (ps,rdn,format) 
PS ps; 
RDN rdn; 
int format; 
{
	(void) rdn_comp_print(ps,rdn,format);
} 

rdn_print (ps,rdn,format) 
RDN rdn; 
PS ps; 
int format; 
{
	(void) rdn_print(ps,rdn,format);
} 


RDN str2rdn_aux (str) 
char * str; 
{
	return (str2rdn_aux(str));
} 

RDN str2rdn (str) 
char * str; 
{
	return (str2rdn(str));
} 

stop_listeners () 
{
	(void) stop_listeners();
} 

soundex_cmp (a,b)
register char * a;
register char * b;
{
	return (soundex_cmp (a,b));
}

soundex_match (fitem,avs) 
register struct filter_item *fitem; 
register AV_Sequence avs; 
{
	return (soundex_match(fitem,avs));
} 

standard_syntaxes () 
{
	(void) standard_syntaxes();
} 

char * octparse (str) 
char * str; 
{
	return (octparse(str));
} 

char * prtparse (str) 
char * str; 
{
	return (prtparse(str));
} 

sfree (x) 
char *x; 
{
	(void) sfree(x);
} 

pstrcmp (a,b)
char * a, *b;
{
	return pstrcmp (a,b);
}

telcmp (a, b) 
char *a, 
*b; 
{
	return (telcmp(a,b));
} 

strprint (ps,str,format) 
PS ps; 
char * str; 
int format; 
{
	(void) strprint(ps,str,format);
} 

octprint (ps,str,format) 
PS ps; 
char * str; 
int format; 
{
	(void) octprint(ps,str,format);
} 

case_exact_match (sntx) 
short sntx; 
{
	return (case_exact_match(sntx));
} 

approx_string (sntx) 
short sntx; 
{
	return (approx_string(sntx));
} 

sub_string (sntx) 
short sntx; 
{
	return (sub_string(sntx));
} 

string_syntaxes () 
{
	(void) string_syntaxes();
} 


teletex_syntax () 
{
	(void) teletex_syntax();
} 

telex_syntax () 
{
	(void) telex_syntax();
} 

utcprint (ps,xtime,format)
PS ps;
char *xtime;
int format;
{
	(void) utcprint (ps,xtime,format);
}

time_syntax () 
{
	(void) time_syntax();
} 

schema_syntax () 
{
	(void) schema_syntax();
} 

char * SkipSpace (ptr) 
register char * ptr; 
{
	return (SkipSpace(ptr));
} 

void StripSpace (b) 
register char *b; 
{
	StripSpace (b);
} 

void StripSpace2 (b) 
register char *b; 
{
	StripSpace2 (b);
} 

char * TidyString (a) 
register char * a; 
{
	return (TidyString(a));
} 

test_prim_pe (pe,class,id) 
PE pe; 
PElementClass class; 
PElementID id; 
{
	return (test_prim_pe(pe,class,id));
} 

/* VARARGS2 */
ps_printf (ps,fmt) 
PS ps; 
char * fmt; 
{
	(void) ps_printf(ps,fmt);
} 

fatal (code,fmt) 
int code; 
char *fmt; 
{
	(void) fatal(code,fmt);
} 

pslog (lp,event,str,func,ptr) 
LLog * lp; 
int event; 
char * str; 
int (*func) (); 
caddr_t ptr; 
{
	(void) pslog(lp,event,str,func,ptr);
} 

quipu_pe_cmp (a,b) 
register PE a,b; 
{
	return (quipu_pe_cmp(a,b));
} 

struct acl_info * acl_dflt () 
{
	return (acl_dflt());
} 

/* VARARGS2 */
dsap_init(acptr,avptr)
int *acptr;
char *** avptr;
{
        (void) dsap_init(acptr,avptr);
}

dsap_tai (argc, argv)
char    **argv;
{
        return (dsap_tai (argc, argv));
}

tai_args (acptr,avptr)
int *acptr;
char ***avptr;
{
        (void) tai_args (acptr,avptr);
}

dsap_tai_init()
{
        return (dsap_tai_init());
}


tai_string (str)
char * str;
{
        return (tai_string (str));
}

ds_error (ps,err)
PS ps;
struct DSError *err;
{
	(void) ds_error (ps,err);
}
ds_bind_error_aux (ps, err, mode)
PS ps;
struct ds_bind_error *err;
int mode;
{
	(void) ds_bind_error_aux (ps, err, mode);
}
char * print_bind_error (err, mode)
struct ds_bind_error *err;
int mode;
{
	return print_bind_error (err, mode);
}

log_ds_error (err)
struct DSError *err;
{
	(void) log_ds_error (err);
}

ds_error_free (err)
struct DSError * err;
{
	(void) ds_error_free (err);
}

struct subordinate * subord_cpy (x) 
struct subordinate * x; 
{
	return (subord_cpy(x));
} 

cache_list (ptr, prob,dn,sizelimit) 
struct subordinate *ptr; 
int prob; 
DN dn; 
int sizelimit; 
{
	(void) cache_list (ptr,prob,dn,sizelimit);
} 

delete_list_cache (adn)
DN adn;
{
	(void) delete_list_cache (adn);
}

struct list_cache *find_list_cache (dn,sizelimit) 
DN dn; 
int sizelimit; 
{
	return (find_list_cache(dn,sizelimit));
} 

cache_entry (ptr, complete, vals) 
EntryInfo *ptr; 
char complete; 
char vals; 
{
	(void) cache_entry (ptr, complete, vals);
} 

delete_cache (adn) 
DN adn; 
{
	(void) delete_cache(adn);
} 

Entry local_find_entry (object,deref) 
DN object; 
char deref; 
{
	return (local_find_entry(object,deref));
} 

Entry local_find_entry_aux (object,deref) 
DN object; 
char deref; 
{
	return (local_find_entry_aux(object,deref));
} 

DN get_copy_dn (entryptr) 
Entry entryptr; 
{
	return (get_copy_dn(entryptr));
} 

unravel_attribute (eptr,error) 
Entry eptr; 
struct DSError * error; 
{
	return (unravel_attribute(eptr,error));
} 

check_schema (eptr,as,error) 
Entry eptr; 
Attr_Sequence as; 
struct DSError * error; 
{
	return (check_schema(eptr,as,error));
} 

char * new_version ()
{
	return new_version();
}

directory_free (directory) 
Entry directory; 
{
	(void) directory_free(directory);
} 

entry_free (entryptr) 
Entry entryptr; 
{
	(void) entry_free(entryptr);
} 

Entry entry_cpy (entryptr) 
register Entry entryptr; 
{
	return (entry_cpy(entryptr));
} 

Entry get_default_entry (parent) 
Entry parent; 
{
	return (get_default_entry(parent));
} 

check_known_oids () 
{
	(void) check_known_oids();
} 

char * getline (file)
FILE * file;
{
	return getline (file);
}

Attr_Sequence get_attributes_aux (file) 
FILE * file; 
{
	return (get_attributes_aux(file));
} 

Attr_Sequence get_attributes (file) 
FILE * file; 
{
	return (get_attributes(file));
} 

Entry get_entry_aux (file,parent,dtype) 
FILE * file; 
Entry parent; 
int dtype; 
{
	return (get_entry_aux(file,parent,dtype));
} 

Entry get_entry (file,parent,dtype) 
FILE * file; 
Entry parent; 
int dtype; 
{
	return (get_entry(file,parent,dtype));
} 

Entry new_constructor (parent) 
Entry parent; 
{
	return (new_constructor(parent));
} 

Entry make_path (dn) 
DN dn; 
{
	return (make_path(dn));
} 


DNS DNS_append (a,b)
DNS a, b;
{
	return DNS_append (a,b);
}

dnSelect (s,dlist,interact,el)
char * s;
DNS *dlist;
DNS (* interact) ();
DNS el;
{
	return dnSelect (s,dlist,interact,el);
}

ufn_search (base, subtree, filt, res, s, interact, el)
DN base;
char subtree;
Filter filt;
DNS * res;
char * s;
DNS (* interact) ();
DNS el;
{
	return ufn_search (base, subtree, filt, res, s, interact, el);
}

envlist read_envlist()
{
	return read_envlist();
}

ufn_match (c,v,interact,result,el)
int c;
char ** v;
DNS (* interact) ();
DNS * result;
envlist el;
{
	return ufn_match (c,v,interact,result,el);
}


ufn_init ()
{
	return ufn_init ();
}


aet_match (c,v,interact,result,el,context)
int c;
char ** v;
DNS *result;
DNS (* interact) ();
envlist el;
char * context;
{
	return aet_match (c,v,interact,result,el,context);
}

set_lookup_ufn (flag)
char	flag;
{
    set_lookup_ufn (flag);
}

set_lookup_dap (flag)
char flag;
{
	set_lookup_dap (flag);
}


reset_arg () 
{
	(void) reset_arg();
} 

print_arg_error (opt) 
PS opt; 
{
	return (print_arg_error(opt));
} 

int test_arg (x, y, c) 
char *x; 
char *y; 
int c; 
{
	return test_arg (x, y, c);
} 


set_default_service (opt) 
PS opt; 
{
	return (set_default_service(opt));
} 

int get_default_service (ca) 
CommonArgs * ca; 
{
	return (get_default_service(ca));
} 

int service_control (opt,argc, argv, ca) 
PS opt; 
int argc; 
char **argv; 
CommonArgs *ca; 
{
	return service_control (opt,argc, argv, ca);
} 

int do_service_control (opt,argc, argv, ca) 
PS opt; 
int argc; 
char **argv; 
CommonArgs *ca; 
{
	return do_service_control (opt,argc, argv, ca);
} 

shuffle_up (argc, argv, start) 
register int argc; 
char **argv; 
register int start; 
{
	(void) shuffle_up (argc, argv, start);
} 

new_service (ptr) 
char * ptr; 
{
	(void) new_service(ptr);
} 


subords_free(subp) 
struct subordinate *subp; 
{
	(void) subords_free(subp);
} 

ems_free(emp) 
struct entrymod *emp; 
{
	(void) ems_free(emp);
} 

aps_free(app) 
struct access_point *app; 
{
	(void) aps_free(app);
} 

crefs_free(crefp) 
ContinuationRef crefp; 
{
	(void) crefs_free(crefp);
} 


avl_insert( root, data, fcmp, fdup )
Avlnode	**root;
caddr_t	data;
IFP	fcmp;
IFP	fdup;
{
	return( avl_insert( root, data, fcmp, fdup) );
}

caddr_t avl_delete( root, data, fcmp )
Avlnode	**root;
caddr_t	data;
IFP	fcmp;
{
	return( avl_delete( root, data, fcmp ) );
}

avl_inapply( root, fn, arg, stopflag )
Avlnode	*root;
IFP	fn;
caddr_t	arg;
int	stopflag;
{
return avl_inapply( root, fn, arg, stopflag );
}

avl_postapply( root, fn, arg, stopflag )
Avlnode	*root;
IFP	fn;
caddr_t	arg;
int	stopflag;
{
return avl_postapply( root, fn, arg, stopflag );
}

avl_preapply( root, fn, arg, stopflag )
Avlnode	*root;
IFP	fn;
caddr_t	arg;
int	stopflag;
{
return avl_preapply( root, fn, arg, stopflag );
}

/*
 * avl_apply -- avl tree root is traversed, function fn is called with
 * arguments arg and the data portion of each node.  if fn returns stopflag,
 * the traversal is cut short, otherwise it continues.  Do not use -6 as
 * a stopflag.
 */

avl_apply( root, fn, arg, stopflag, type )
Avlnode	*root;
IFP	fn;
caddr_t	arg;
int	stopflag;
int	type;
{
return avl_apply( root, fn, arg, stopflag, type );
}

avl_prefixapply( root, data, fmatch, marg, fcmp, carg, stopflag )
Avlnode	*root;
caddr_t	data;
IFP	fmatch;
caddr_t	marg;
IFP	fcmp;
caddr_t	carg;
int	stopflag;
{
return avl_prefixapply( root, data, fmatch, marg, fcmp, carg, stopflag );
}

avl_free( root, dfree )
Avlnode	*root;
IFP	dfree;
{
return avl_free( root, dfree );
}

caddr_t avl_find( root, data, fcmp )
Avlnode	*root;
caddr_t	data;
IFP	fcmp;
{
return avl_find( root, data, fcmp );
}

caddr_t avl_getfirst( root )
Avlnode	*root;
{
return avl_getfirst( root );
}

caddr_t avl_getnext()
{
return avl_getnext();
}

build_trees ()
{
return build_trees();
}

int decode_t4 (data, name, size)
char *data;
char *name;
int   size;
{
return decode_t4 (data, name, size);
}

int decode_t4_aux (inbuf, winname, length, twoDimensional)
char *inbuf;
char *winname;
int   length;
int   twoDimensional;
{
return decode_t4_aux (inbuf, winname, length, twoDimensional);
}

void as_write_files (as,where)
Attr_Sequence as;
char *where;
{
	as_write_files (as,where);
}

struct signature *
nullsigned(data, type, module)
	char           *data;
	int             type;
	modtyp         *module;
{
	return (nullsigned(data, type, module));
}


int
nullverify(data, type, module, sig, pubkey, keyparms, hashparms)
	char           *data;
	int             type;
	modtyp         *module;
	struct signature *sig;
	struct GenericPublicKey  *pubkey; 	
	struct GenericParameters *keyparms;  	
	struct GenericHashParameters *hashparms; 
{
return nullverify(data, type, module, sig, pubkey, keyparms, hashparms);
}

int
null_ckpath(data, type, module, path, sig, nameptr)
	caddr_t         data;
	int             type;
	modtyp         *module;
	struct certificate_list *path;
	struct signature *sig;
	DN             *nameptr;
{
	return (null_ckpath(data, type, module, path, sig, nameptr));
}

struct certificate_list *
null_mkpath()
{
	return null_mkpath();
}

struct encrypted *
nullencrypted(concrete, type, module, publickey, parms)
	char           *concrete;
	int             type;
	modtyp         *module;
	struct GenericPublicKey *publickey;	
	struct GenericParameters *parms;	
{
	return (nullencrypted(concrete, type, module, publickey, parms));
}


int
nulldecrypted(enc, type, module, concrete, privkey, parms)
	struct encrypted *enc;
	int             type;
	modtyp         *module;
	char          **concrete;
	struct GenericSecretKey *privkey;	 
	struct GenericParameters *parms;	
{
	return nulldecrypted(enc, type, module, concrete, privkey, parms);
}

struct Nonce *
nullmknonce(previous)
	struct Nonce *previous;
{
	return nullmknonce(previous);
}

int
nullcknonce(nonce)
	struct Nonce *nonce;
{
	return nullcknonce(nonce);
}