llib-lcommon

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

/* llib-lcommon - lint library for QUIPU-common */

/*
 * $Header: /xtel/isode/isode/dsap/common/RCS/llib-lcommon,v 9.0 1992/06/16 12:12:39 isode Rel $
 *
 *
 * $Log: llib-lcommon,v $
 * Revision 9.0  1992/06/16  12:12:39  isode
 * Release 8.0
 *
 */

/*
 *                                NOTICE
 *
 *    Acquisition, use, and distribution of this module and related
 *    materials are subject to the restrictions of a license agreement.
 *    Consult the Preface in the User's Manual for the full terms of
 *    this agreement.
 *
 */


/* LINTLIBRARY */

#include <signal.h>
#include "quipu/util.h"
#include "quipu/entry.h"
#include "quipu/common.h"
#include "quipu/connection.h"
#include "quipu/list.h"     
#include "quipu/ds_search.h"
#include "quipu/ufn.h"
#include "pepsy.h"
#include "osisec-stub.h"


struct acl_info * acl_info_new (x,y,z) 
register int x,y; 
struct dn_seq * z; 
{
	return (acl_info_new(x,y,z));
} 

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

int	  acl_cmp (acl1, acl2)
struct acl	* acl1;
struct acl	* acl2;
{
	return (acl_cmp(acl1,acl2));
}

get_default_acl () 
{
	(void) get_default_acl();
} 

set_default_acl (ai_ptr) 
struct acl_info * ai_ptr; 
{
	(void) set_default_acl(ai_ptr);
} 

test_acl_default (a)
struct acl_info * a;
{
	return (test_acl_default (a));
}

acl_syntax ()
{
	(void) (acl_syntax ());
}

as_cmp_comp (a,b) 
Attr_Sequence a,b; 
{
	return (as_cmp_comp(a,b));
} 

as_cmp (a,b) 
Attr_Sequence a,b; 
{
	return (as_cmp(a,b));
} 


Attr_Sequence as_comp_cpy (as) 
Attr_Sequence as; 
{
	return (as_comp_cpy(as));
} 

Attr_Sequence as_cpy (as) 
Attr_Sequence as; 
{
	return (as_cpy(as));
} 


as_delnext (as) 
Attr_Sequence as; 
{
	(void) as_delnext(as);
} 


Attr_Sequence as_find_type (a,b) 
Attr_Sequence a; 
AttributeType b; 
{
	return (as_find_type(a,b));
} 


as_comp_free (as) 
Attr_Sequence as; 
{
	(void) as_comp_free(as);
} 

as_free (as) 
Attr_Sequence as; 
{
	(void) as_free(as);
} 

Attr_Sequence as_merge_aux (a,b) 
Attr_Sequence a,b; 
{
	return (as_merge_aux (a,b));
} 

Attr_Sequence as_merge (a,b) 
Attr_Sequence a,b; 
{
	return (as_merge(a,b));
} 


Attr_Sequence as_comp_new (at,as,acl) 
AttributeType at; 
AV_Sequence as; 
struct acl_info * acl; 
{
	return (as_comp_new(at,as,acl));
} 


as_comp_print (ps,as,format) 
PS ps; 
Attr_Sequence as; 
int format; 
{
	(void) as_comp_print(ps,as,format);
} 

as_print (ps,as,format) 
Attr_Sequence as; 
PS ps; 
int format; 
{
	(void) as_print(ps,as,format);
} 


Attr_Sequence str2as (str) 
register char * str; 
{
	return (str2as(str));
} 

Attr_Sequence as_combine (as,str,allownull) 
Attr_Sequence as; 
register char * str; 
char allownull;
{
	return (as_combine(as,str,allownull));
} 

oid_table_attr * AttrT_new_aux (name) 
register char * name; 
{
	return (AttrT_new_aux(name));
} 

AttributeType AttrT_new (name) 
register char * name; 
{
	return (AttrT_new(name));
} 


AttrT_print (ps,x,format) 
register PS ps; 
register AttributeType x; 
register int format; 
{
	(void) AttrT_print(ps,x,format);
} 

short add_attribute_syntax (sntx,enc,dec,parse,print,cpy,cmp,sfree,print_pe,approx,multiline) 
char * sntx; 
IFP enc,dec,parse,print,cpy,cmp,sfree,approx; 
char * print_pe; 
char multiline; 
{
	return (add_attribute_syntax(sntx,enc,dec,parse,print,cpy,cmp,sfree,print_pe,approx,multiline));
} 

set_attribute_syntax (sntx,enc,dec,parse,print,cpy,cmp,sfree,print_pe,approx,multiline) 
short sntx; 
IFP enc,dec,parse,print,cpy,cmp,sfree,approx; 
char * print_pe; 
char multiline; 
{
	(void) set_attribute_syntax(sntx,enc,dec,parse,print,cpy,cmp,sfree,print_pe,approx,multiline);
} 

set_av_pe_print (sntx,print_pe) 
short sntx; 
char * print_pe; 
{
	(void) set_av_pe_print(sntx,print_pe);
} 
set_av_printer (sntx,print_pe) 
short sntx; 
IFP print_pe; 
{
	(void) set_av_printer (sntx,print_pe);
} 
short modify_av_printer (at,sntx,print)
AttributeType at;
char * sntx;
IFP print;
{
	return modify_av_printer (at,sntx,print);
}

split_attr (as) 
Attr_Sequence as; 
{
	return (split_attr(as));
} 

IFP approxfn (x) 
short x; 
{
	return (approxfn(x));
} 

char * syntax2str (sntx) 
int sntx; 
{
	return (syntax2str(sntx));
} 

short str2syntax (str) 
char * str; 
{
	return (str2syntax(str));
} 

sntx_table * get_syntax_table (x) 
short x; 
{
	return (get_syntax_table(x));
} 

AttrV_free (x) 
register AttributeValue x; 
{
	(void) AttrV_free(x);
} 

AttrV_free_aux (x) 
register AttributeValue x; 
{
	(void) AttrV_free_aux(x);
} 

PE grab_pe(av) 
AttributeValue av; 
{
	return (grab_pe(av));
} 

AttrV_decode(x,y) 
register AttributeType x; 
register AttributeValue y; 
{
	return (AttrV_decode(x,y));
} 


str_at2AttrV_aux (str,at,rav)
char * str;
AttributeType at;
AttributeValue rav;
{
	return str_at2AttrV_aux (str,at,rav);
}

AttributeValue str_at2AttrV (str,at)
char * str;
AttributeType at;
{
	return str_at2AttrV (str,at);
}

AttributeValue str2AttrV (str,syntax)
register char * str;
short syntax;
{
	return (str2AttrV (str,syntax));
}

str2AttrV_aux (str,syntax,x)
register char * str;
short syntax;
AttributeValue x;
{
	return str2AttrV_aux(str,syntax,x);
}

AttributeValue AttrV_cpy (x)
register AttributeValue x;
{
	return ( AttrV_cpy (x));
}

AttrV_cpy_aux (x,y)
register AttributeValue x;
register AttributeValue y;
{
	(void) AttrV_cpy_aux (x,y);
}

AttrV_cpy_enc (x,y)
register AttributeValue x;
register AttributeValue y;
{
	(void) AttrV_cpy_enc (x,y);
}

AttrV_cmp (x,y)
register AttributeValue x,y;
{
	return AttrV_cmp (x,y);
}

IFP av_cmp_fn (syntax)
int syntax;
{
	return av_cmp_fn (syntax);
}

AttrV_print (ps,x,format)
register PS ps;
register AttributeValue x;
register int format;
{
	(void) AttrV_print (ps,x,format);
}

avs_cmp (a,b) 
AV_Sequence a,b; 
{
	return (avs_cmp(a,b));
} 

AV_Sequence avs_comp_cpy (avs) 
AV_Sequence avs; 
{
	return (avs_comp_cpy(avs));
} 

AV_Sequence avs_cpy (avs) 
AV_Sequence avs; 
{
	return (avs_cpy(avs));
} 

AV_Sequence avs_cpy_enc (avs) 
AV_Sequence avs; 
{
	return (avs_cpy_enc(avs));
} 


avs_delnext (avs) 
AV_Sequence avs; 
{
	(void) avs_delnext(avs);
} 


avs_comp_free (avs) 
AV_Sequence avs; 
{
	(void) avs_comp_free(avs);
} 

avs_free (avs) 
AV_Sequence avs; 
{
	(void) avs_free(avs);
} 

AV_Sequence avs_merge (a,b) 
AV_Sequence a,b; 
{
	return (avs_merge(a,b));
} 


avs_comp_fill (ptr,pe) 
AV_Sequence ptr; 
AttributeValue pe; 
{
	(void) avs_comp_fill(ptr,pe);
} 

AV_Sequence avs_comp_new (pe) 
AttributeValue pe; 
{
	return (avs_comp_new(pe));
} 

avs_print (ps,avs,format) 
AV_Sequence avs; 
PS ps; 
int format; 
{
	(void) avs_print(ps,avs,format);
} 

avs_print_aux (ps,avs,format,sep) 
AV_Sequence avs; 
PS ps; 
int format; 
char * sep;
{
	(void) avs_print_aux(ps,avs,format,sep);
} 


AV_Sequence str2avs (str,at) 
char * str; 
AttributeType at; 
{
	return (str2avs(str,at));
} 

boolean_syntax () 
{
	(void) boolean_syntax();
} 


struct common_args * get_ca_ref(dsarg) 
struct ds_op_arg * dsarg; 
{
	return get_ca_ref(dsarg);
} 

cha_loopdetected(cha) 
struct chain_arg * cha; 
{
	return cha_loopdetected(cha);
} 

ti_is_elem(ti, ti_list) 
struct trace_info * ti; 
struct trace_info * ti_list; 
{
	return ti_is_elem(ti,ti_list);
} 

struct trace_info * ti_cpy(ti) 
struct trace_info * ti; 
{
	return ti_cpy(ti);
} 


correlate_search_results(sr_res) 
struct ds_search_result * sr_res; 
{
	(void) correlate_search_results(sr_res);
} 

merge_search_results(sr_res, sr_tmp) 
struct ds_search_result * sr_res; 
struct ds_search_result * sr_tmp; 
{
	(void) merge_search_results(sr_res,sr_tmp);
} 

search_result_free(arg) 
struct ds_search_result * arg; 
{
	(void) search_result_free(arg);
} 


dn_append (a,b) 
DN a,b; 
{
	(void) dn_append(a,b);
} 


dn_cmp (a,b) 
register DN a,b; 
{
	return (dn_cmp(a,b));
} 

dn_cmp_prefix (a,b) 
register DN a,b; 
{
	return (dn_cmp_prefix(a,b));
} 


DN dn_comp_cpy (dn) 
register DN dn; 
{
	return (dn_comp_cpy(dn));
} 

DN dn_cpy (dn) 
register DN dn; 
{
	return (dn_cpy(dn));
} 


dn_comp_free (dn) 
DN dn; 
{
	(void) dn_comp_free(dn);
} 
dn_free (dn) 
DN dn; 
{
	(void) dn_free(dn);
} 


DN dn_comp_new (rdn) 
RDN rdn; 
{
	return (dn_comp_new(rdn));
} 


void dn_print (ps,dn,format) 
DN dn; 
PS ps; 
int format; 
{
	dn_print(ps,dn,format);
} 

void ufn_dn_print (ps,dn,multiline)
PS  ps;
DN  dn;
char multiline;
{
	ufn_dn_print (ps,dn,multiline);
}
void dn_rfc_print(ps, dn, sep)
PS ps;
DN dn;
char * sep;
{
	dn_rfc_print(ps, dn, sep);
}

ufn_dn_print_aux (ps,dn,marker,multiline)
PS  ps;
DN  dn;
DN marker;
int	multiline;
{
	(void) ufn_dn_print_aux (ps,dn,marker,multiline);
} 

void ufn_rdn_print (ps,rdn)
RDN  rdn;
PS   ps;
{	
	(void) ufn_rdn_print (ps,rdn);
}
char * dn2str(dn)
DN dn;
{
	return dn2str(dn);
}
char * dn2ufn(dn,multiline)
DN dn;
char multiline;
{
	return dn2ufn(dn,multiline);
}

char   *dn2rfc (dn,sep)
DN	dn;
char   *sep;
{
	return dn2rfc(dn,sep);
}
dn_seq_free (dnseq) 
struct dn_seq * dnseq; 
{
	(void) dn_seq_free(dnseq);
} 

struct dn_seq * dn_seq_cpy (dnseq) 
struct dn_seq * dnseq; 
{
	return (dn_seq_cpy(dnseq));
} 

check_dnseq (dnseq,who) 
struct dn_seq * dnseq; 
DN who; 
{
	return (check_dnseq(dnseq,who));
} 

dn_seq_cmp (a,b) 
struct dn_seq * a, * b; 
{
	return (dn_seq_cmp(a,b));
} 

check_dnseq_prefix (dnseq,who) 
struct dn_seq * dnseq; 
DN who; 
{
	return (check_dnseq_prefix(dnseq,who));
} 

dn_seq_print (ps,dnseq,format) 
PS ps; 
struct dn_seq * dnseq; 
int format; 
{
	(void) dn_seq_print(ps,dnseq,format);
} 

struct dn_seq * str2dnseq (str) 
register char * str; 
{
	return (str2dnseq(str));
} 

int       dn_in_dnseq(dn, dnseq)
DN                dn;
struct dn_seq   * dnseq;
{
	return (dn_in_dnseq(dn, dnseq));
}

struct dn_seq   * dn_seq_push(dn,dnseq)
DN                dn;
struct dn_seq   * dnseq;
{
	return dn_seq_push(dn,dnseq);
}

struct dn_seq   * dn_seq_pop(dnseq)
struct dn_seq   * dnseq;
{
	return dn_seq_pop(dnseq);
}

DN str2dn (str) 
register char * str; 
{
	return (str2dn(str));
} 

DN str2dn_aux (str,alias) 
char * str; 
char *alias; 
{
	return (str2dn_aux(str,alias));
} 

DN str2dnX (str) 
register char * str; 
{
	return (str2dnX(str));
} 

DN dn_dec (pe)
PE pe;
{
	return dn_dec (pe);
}

PE dn_enc (dn)
DN dn;
{
	return dn_enc (dn);
}

dn_syntax ()
{
	(void) dn_syntax ();
}

DN dq2dn (designator, qualifier) 
char *designator, 
*qualifier; 
{
	return (dq2dn(designator,qualifier));
} 

edbinfo_syntax ()
{
	(void) edbinfo_syntax ();
}

entryinfo_comp_free (a,state) 
register EntryInfo *a; 
int state; 
{
	(void) entryinfo_comp_free(a,state);
} 

entryinfo_free (a,state) 
register EntryInfo * a; 
register int state; 
{
	(void) entryinfo_free(a,state);
} 

entryinfo_cpy (a,b) 
register EntryInfo *a; 
register EntryInfo *b; 
{
	(void) entryinfo_cpy(a,b);
} 

entryinfo_append (a,b) 
register EntryInfo *a,*b; 
{
	(void) entryinfo_append(a,b);
} 

entryinfo_merge (a,b,fast) 
EntryInfo *a,*b;
int fast; 
{
	(void) entryinfo_merge(a,b,fast);
} 

entryinfo_print (ps,entryinfo,format) 
PS ps; 
EntryInfo *entryinfo; 
int format; 
{
	(void) entryinfo_print(ps,entryinfo,format);
} 

fax_syntax ()
{
	(void) fax_syntax ();
}

struct file_syntax * fileattr_cpy (fs) 
struct file_syntax * fs; 
{
	return (fileattr_cpy(fs));
} 

file_cmp (a,b) 
struct file_syntax *a, *b; 
{
	return (file_cmp(a,b));
} 

PE grab_filepe (av) 
AttributeValue av; 
{
	return (grab_filepe(av));
}


file_decode (x)
AttributeValue x;
{
	(void) file_decode (x);
}

#ifndef SYS5
/* ARGSUSED */
#endif
int dflt_attr_file (at,x,full) 
AttributeType at; 
AttributeValue x; 
char full;
{
	return (dflt_attr_file(at,x,full));
} 

fileattr_print (ps,y,format) 
PS ps; 
AttributeValue y; 
int format; 
{
	(void) fileattr_print(ps,y,format);
} 


str2file_aux (str,at,x) 
char * str; 
AttributeType at; 
AttributeValue x; 
{
	return (str2file_aux(str,at,x));
} 

AttributeValue str2file (str,at) 
char * str; 
AttributeType at; 
{
	return (str2file(str,at));
} 

file_free (fs) 
struct file_syntax * fs; 
{
	(void) file_free(fs);
} 

filter_free (filt) 
Filter filt; 
{
	(void) filter_free(filt);
} 

filter_append (a,b) 
Filter a,b; 
{
	(void) filter_append(a,b);
} 

Filter strfilter (at,s,type)
AttributeType at;
char * s;
char type;
{
	return strfilter (at,s,type);
}

Filter ocfilter (s)
char * s;
{
	return ocfilter (s);
}

Filter joinfilter (f, type)
Filter f;
char type;
{
	return joinfilter (f, type);
}

print_filter (nps, fi, level)
PS nps;
register Filter fi;
int     level;
{
	(void) print_filter (nps, fi, level);
}

guide_syntax ()
{
	(void) guide_syntax ();
}

integer_syntax () 
{
	(void) integer_syntax();
} 

mailbox_syntax () 
{
	(void) mailbox_syntax();
} 

objectclass * oc_add (oid) 
OID oid; 
{
	return (oc_add(oid));
} 

check_in_oc (oid,avs) 
OID oid; 
AV_Sequence avs; 
{
	return (check_in_oc(oid,avs));
} 

oc_print (ps,oc,format)
PS ps;
objectclass * oc;
int format;
{
	(void) oc_print (ps,oc,format);
}

objectclass_syntax () 
{
	(void) objectclass_syntax();
} 

int load_oid_table (table) 
char * table; 
{
	return load_oid_table(table);
} 

add_entry_aux (a,b,c,d) 
char * a; 
caddr_t b; 
int c; 
char * d; 
{
	(void) add_entry_aux(a,b,c,d);
} 

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

oid_table_attr *name2attr(nodename) 
char * nodename; 
{
	return (name2attr(nodename));
} 

set_heap (x) 
AttributeType x; 
{
	return (set_heap(x));
} 

oid_table_attr *oid2attr(oid) 
OID oid; 
{
	return (oid2attr(oid));
} 

objectclass *name2oc(nodename) 
register char * nodename; 
{
	return (name2oc(nodename));
} 

objectclass *oid2oc(oid) 
OID oid; 
{
	return (oid2oc(oid));
} 

char *attr2name(oa,format) 
register oid_table_attr *oa; 
int format; 
{
	return (attr2name(oa,format));
} 

char *oc2name(oc,format) 
register objectclass *oc; 
int format; 
{
	return (oc2name(oc,format));
} 

char *oid2name(oid,format) 
OID oid; 
int format; 
{
	return (oid2name(oid,format));
} 

OID name2oid (str) 
register char * str; 
{
	return (name2oid(str));
} 

PE oid2pe (o) 
OID o; 
{
	return (oid2pe(o));
} 

oidprint (ps,o,format) 
PS ps; 
OID o; 
int format; 
{
	(void) oidprint(ps,o,format);
} 

OID dup_prim2oid (pe) 
PE pe; 
{
	return (dup_prim2oid(pe));
} 

oid_syntax () 
{
	(void) oid_syntax();
} 

want_oc_hierarchy ()