/* llib-lisode - lint library for -lisode */

/* llib-lacsap - lint library for -lacsap */

/* 
 * $Header: /f/osi/acsap/RCS/llib-lacsap,v 7.0 89/11/23 21:22:15 mrose Rel $
 *
 *
 * $Log:	llib-lacsap,v $
 * Revision 7.0  89/11/23  21:22:15  mrose
 * Release 6.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 "acsap.h"
#include "tsap.h"
#include "isoservent.h"

/*  */

/* A-ASSOCIATE.INDICATION */

int	AcInit (vecp, vec, acs, aci)
int	vecp;
char  **vec;
struct AcSAPstart *acs;
struct AcSAPindication *aci;
{
    return AcInit (vecp, vec, acs, aci);
}


/* A-ASSOCIATE.RESPONSE */

int	AcAssocResponse (sd, status, reason, context, respondtitle,
	respondaddr, ctxlist, defctxresult, prequirements, srequirements, isn,
	settings, ref, data, ndata, aci)
int	sd;
int	status,
	reason;
OID	context;
AEI	respondtitle;
struct PSAPaddr *respondaddr;
int	prequirements,
	srequirements,
	settings,
	ndata;
long	isn;
struct PSAPctxlist *ctxlist;
int	defctxresult;
struct SSAPref *ref;
PE     *data;
struct AcSAPindication *aci;
{
    return AcAssocResponse (sd, status, reason, context, respondtitle,
	    respondaddr, ctxlist, defctxresult, prequirements, srequirements,
	    isn, settings, ref, data, ndata, aci);
}


/* A-(ASYN-)ASSOCIATE.REQUEST */

int	AcAsynAssocRequest (context, callingtitle, calledtitle, callingaddr,
	calledaddr, ctxlist, defctxname, prequirements, srequirements, isn,
	settings, ref, data, ndata, qos, acc, aci, async)
OID	context;
AEI	callingtitle,
	calledtitle;
struct PSAPaddr *callingaddr,
		*calledaddr;
int	prequirements,
	srequirements,
	settings,
	ndata,
	async;
long	isn;
struct PSAPctxlist *ctxlist;
OID	defctxname;
struct SSAPref *ref;
PE    *data;
struct QOStype *qos;
struct AcSAPconnect *acc;
struct AcSAPindication *aci;
{
    return AcAsynAssocRequest (context, callingtitle, calledtitle, callingaddr,
	    calledaddr, ctxlist, defctxname, prequirements, srequirements, isn,
	    settings, ref, data, ndata, qos, acc, aci, async);
}


/* A-ASYN-RETRY.REQUEST (pseudo) */

int	AcAsynRetryRequest (sd, acc, aci)
int	sd;
struct AcSAPconnect *acc;
struct AcSAPindication *aci;
{
    return AcAsynRetryRequest (sd, acc, aci);
}


/* A-ASYN-NEXT.REQUEST (pseudo) */

int	AcAsynNextRequest (sd, acc, aci)
int	sd;
struct AcSAPconnect *acc;
struct AcSAPindication *aci;
{
    return AcAsynNextRequest (sd, acc, aci);
}


/* A-RELEASE.REQUEST */

int	AcRelRequest (sd, reason, data, ndata, secs, acr, aci)
int	sd;
int	reason;
PE     *data;
int	ndata;
int	secs;
struct AcSAPrelease *acr;
struct AcSAPindication *aci;
{
    return AcRelRequest (sd, reason, data, ndata, secs, acr, aci);
}


/* A-RELEASE-RETRY.REQUEST (pseudo) */

int	AcRelRetryRequest (sd, secs, acr, aci)
int	sd;
int	secs;
struct AcSAPrelease *acr;
struct AcSAPindication *aci;
{
    return AcRelRetryRequest (sd, secs, acr, aci);
}


/* A-RELEASE.RESPONSE */

int	AcRelResponse (sd, status, reason, data, ndata, aci)
int	sd;
int	status,
	reason;
PE     *data;
int	ndata;
struct AcSAPindication *aci;
{
    return AcRelResponse (sd, status, reason, data, ndata, aci);
}


/* A-ABORT.REQUEST */

int	AcUAbortRequest (sd, data, ndata, aci)
int	sd;
PE     *data;
int	ndata;
struct AcSAPindication *aci;
{
    return AcUAbortRequest (sd, data, ndata, aci);
}


/* handle P-RELEASE.INDICATION */

int	AcFINISHser (sd, pf, aci)
int	sd;
struct PSAPfinish *pf;
struct AcSAPindication *aci;
{
    return AcFINISHser (sd, pf, aci);
}


/* handle P-{U,P}-ABORT.INDICATION */

int	AcABORTser (sd, pa, aci)
int	sd;
struct PSAPabort *pa;
struct AcSAPindication *aci;
{
    return AcABORTser (sd, pa, aci);
}


/* return PCI used by ACSE */

int	AcFindPCI (sd, pci, aci)
int	sd;
int    *pci;
struct AcSAPindication *aci;
{
    return AcFindPCI (sd, pci, aci);
}


/* return AcSAP error code in string form */

char   *AcErrString (code)
int	code;
{
    return AcErrString (code);
}


/* string to application entity info */

AEI	str2aei (designator, qualifier)
char   *designator,
       *qualifier;
{
    return str2aei (designator, qualifier);
}


char   *sprintaei (aei)
AEI	aei;
{
    return sprintaei (aei);
}


/* application entity info to PSAPaddr */

struct PSAPaddr *aei2addr (aei)
AEI	aei;
{
    return aei2addr (aei);
}


int	setisoentity (f)
int	f;
{
    return setisoentity (f);
}


int	endisoentity ()
{
    return endisoentity ();
}

struct isoentity *getisoentity ()
{
    return getisoentity ();
}


AEI	oid2aei (oid)
OID	oid;
{
    return oid2aei (oid);
}


/* old-style */

struct PSAPaddr *is2paddr (host, service, is)
char   *host,
       *service;
struct isoservent *is;
{
    return is2paddr (host, service, is);
}


/* old-style */

struct SSAPaddr *is2saddr (host, service, is)
char   *host,
       *service;
struct isoservent *is;
{
    return is2saddr (host, service, is);
}


/* old-style */

struct TSAPaddr *is2taddr (host, service, is)
char   *host,
       *service;
struct isoservent *is;
{
    return is2taddr (host, service, is);
}


/* "higher-performance" name service */

PE	name2value (name, attribute, real_name)
char   *name,
       *attribute;
PE     *real_name;
{
    return name2value (name, attribute, real_name);
}


/* generic server dispatch */

int	isodeserver (argc, argv, aei, initfnx, workfnx, losefnx, td)
int	argc;
char  **argv;
AEI	aei;
IFP	initfnx,
	workfnx,
	losefnx;
struct TSAPdisconnect *td;
{
    return isodeserver (argc, argv, aei, initfnx, workfnx, losefnx, td);
}
/* llib-lpsap - lint library for -lpsap */

/* 
 * $Header: /f/osi/psap/RCS/llib-lpsap,v 7.0 89/11/23 22:12:42 mrose Rel $
 *
 *
 * $Log:	llib-lpsap,v $
 * Revision 7.0  89/11/23  22:12:42  mrose
 * Release 6.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 <stdio.h>
#include "psap.h"
#include "ssap.h"
#include "logger.h"

/*    Primitives (Built-in Types) <-> Data */

int     prim2flag (pe)
PE	pe;
{
    return prim2flag (pe);
}


PE	flag2prim (b, class, id)
int     b;
PElementClass	class;
PElementID	id;
{
    return flag2prim (b, class, id);
}


integer prim2num (pe)
PE	pe;
{
    return prim2num (pe);
}


PE	num2prim (i, class, id)
integer i;
PElementClass	class;
PElementID	id;
{
    return num2prim (i, class, id);
}


double	prim2real (pe)
PE	pe;
{
    return prim2real (pe);
}


PE	real2prim (d, class, id)
double	d;
PElementClass class;
PElementID id;
{
    return real2prim (d, class, id);
}


char   *prim2str (pe, len)
PE	pe;
int    *len;
{
    return prim2str (pe, len);
}


PE	str2prim (s, len, class, id)
char   *s;
int     len;
PElementClass	class;
PElementID	id;
{
    return str2prim (s, len, class, id);
}


struct qbuf *prim2qb (pe)
PE	pe;
{
    return prim2qb (pe);
}


PE	qb2prim (qb, class, id)
struct qbuf *qb;
PElementClass	class;
PElementID	id;
{
    return qb2prim (qb, class, id);
}

/*    BITSTRING manipulation */

PE	prim2bit (pe)
PE	pe;
{
    return prim2bit (pe);
}


PE	bit2prim (pe)
PE	pe;
{
    return bit2prim (pe);
}


int     bit_on (pe, i)
PE	pe;
int     i;
{
    return bit_on (pe, i);
}


int     bit_off (pe, i)
PE	pe;
int     i;
{
    return bit_off (pe, i);
}


int     bit_test (pe, i)
PE	pe;
int     i;
{
    return bit_test (pe, i);
}

/*    Routines for pepy */

char   *int2strb (n, len)
int	n,
	len;
{
    return int2strb (n, len);
}


int	strb2int (cp, len)
char   *cp;
int	len;
{
    return strb2int (cp, len);
}


PE	strb2bitstr (cp, len, class, id)
char   *cp;
int	len;
PElementClass class;
PElementID id;
{
    return strb2bitstr (cp, len, class, id);
}


char   *bitstr2strb (pe, len)
PE	pe;
int    *len;
{
    return bitstr2strb (pe, len);
}


/*    Primitives (Defined Types) <-> Data */

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


PE	obj2prim (o, class, id)
OID	o;
PElementClass	class;
PElementID	id;
{
    return obj2prim (o, class, id);
}


UTC	prim2time (pe, generalized)
PE	pe;
int	generalized;
{
    return prim2time (pe, generalized);
}


PE	time2prim (u, generalized, class, id)
UTC	u;
int	generalized;
PElementClass	class;
PElementID	id;
{
    return time2prim (u, generalized, class, id);
}


char   *time2str (u, generalized)
UTC	u;
int	generalized;
{
    return time2str (u, generalized);
}


UTC	str2utct (cp, len)
char   *cp;
int	len;
{
    return str2utct (cp, len);
}


UTC	str2gent (cp, len)
char   *cp;
int	len;
{
    return str2gent (cp, len);
}

/*    LIST manipulation */

PE	prim2set (pe)
PE	pe;
{
    return prim2set (pe);
}


int     set_add (pe, r)
PE	pe,
	r;
{
    return set_add (pe, r);
}


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


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


int     seq_add (pe, r, i)
PE	pe,
	r;
int     i;
{
    return seq_add (pe, r, i);
}


int     seq_del (pe, i)
PE	pe;
int     i;
{
    return seq_del (pe, i);
}


PE	seq_find (pe, i)
PE	pe;
int     i;
{
    return seq_find (pe, i);
}

/*    PElement manipulation */

PE	pe_alloc (class, form, id)
PElementClass class;
PElementForm form;
PElementID id;
{
    return pe_alloc (class, form, id);
}


int	pe_free (pe)
PE	pe;
{
    (void) pe_free (pe);
}


int     pe_cmp (p, q)
PE	p,
	q;
{
    return pe_cmp (p, q);
}


PE	pe_cpy (pe)
PE	pe;
{
    return pe_cpy (pe);
}


int     pe_pullup (pe)
PE	pe;
{
    return pe_pullup (pe);
}


PE	pe_expunge (pe, r)
PE	pe,
	r;
{
    return pe_expunge (pe, r);
}


int	pe_extract (pe, r)
PE	pe,
	r;
{
    return pe_extract (pe, r);
}


PE	str2pe (s, len, advance, result)
char   *s;
int	len,
       *advance,
       *result;
{
    return str2pe (s, len, advance, result);
}


PE	qb2pe (qb, len, depth, result)
struct qbuf *qb;
int	len,
	depth,
       *result;
{
    return qb2pe (qb, len, depth, result);
}


/*    PStream manipulation */

PS	ps_alloc (io)
IFP	io;
{
    return ps_alloc (io);
}


void	ps_free (ps)
PS	ps;
{
    ps_free (ps);
}

/*    PStream I/O */

int     ps_io (ps, io, data, n, inline)
PS	ps;
IFP	io;
PElementData data;
PElementLen n;
int	inline;
{
    return ps_io (ps, io, data, n, inline);
}


int	ps_flush (ps)
PS	ps;
{
    return ps_flush (ps);
}


int	ps_prime (ps)
PS	ps;
{
    return ps_prime (ps);
}


int     std_open (ps)
PS	ps;
{
    return std_open (ps);
}


int     str_open (ps)
PS	ps;
{
    return str_open (ps);
}


int     str_setup (ps, cp, cc, inline)
PS	ps;
char   *cp;
int	cc,
	inline;
{
    return str_setup (ps, cp, cc, inline);
}


int	dg_open (ps)
PS	ps;
{
    return df_open (ps);
}


int	dg_setup (ps, fd, size, rfx, wfx)
PS	ps;
int	fd,
	size;
IFP	rfx,
	wfx;
{
    return dg_setup (ps, fd, size, rfx, wfx);
}

int	fdx_open (ps)
PS	ps;
{
    return fdx_open (ps);
}


int	fdx_setup (ps, fd)
PS	ps;
int	fd;
{
    return fdx_setup (ps, fd);
}


int	qbuf_open (ps)
PS	ps;
{
    return qbuf_open (ps);
}


int	uvec_open (ps)
PS	ps;
{
    return uvec_open (ps);
}


int	uvec_setup (ps, len)
PS	ps;
int	len;
{
    return uvec_setup (ps, len);
}

/*    PStream <-> PElement */

PE	ps2pe_aux (ps, top)
PS	ps;
int     top;
{
    return ps2pe_aux (ps, top);
}


int     pe2ps_aux (ps, pe, eval)
PS	ps;
PE	pe;
int	eval;
{
    return pe2ps_aux (ps, pe, eval);
}

/*    PList <-> PElement */

PE	pl2pe (ps)
PS	ps;
{
    return pl2pe (ps);
}


int     pe2pl (ps, pe)
PS	ps;
PE	pe;
{
    return pe2pl (ps, pe);
}


int	ps_get_abs (pe)
PE	pe;
{
    return ps_get_abs (pe);
}

/*    Diagnostics */

char   *pe_error (c)
int     c;
{
    return pe_error (c);
}

char   *ps_error (c)
int     c;
{
    return ps_error (c);
}

/*    Object IDentifiers */

OID	ode2oid (descriptor)
char   *descriptor;
{
    return ode2oid (descriptor);
}


int	oid_cmp (p, q)
OID	p,
	q;
{
    return oid_cmp (p, q);
}


int	elem_cmp (ip, i, jp, j)
int	i,
	j;
unsigned int *ip,
	     *jp;
{
    return elem_cmp (ip, i, jp, j);
}


OID	oid_cpy (oid)
OID	oid;
{
    return oid_cpy (oid);
}

int	oid_free (oid)
OID	oid;
{
    (void) oid_free (oid);
}

char   *oid2ode (oid)
OID	oid;
{
    return oid2ode (oid);
}

char   *sprintoid (oid)
OID	oid;
{
    return sprintoid (oid);
}

OID	str2oid (s)
char   *s;
{
    return str2oid (s);
}

/*  */

PE	qbuf2pe (qb, len, result)
struct qbuf *qb;
int	len;
int    *result;
{
    return qbuf2pe (qb, len, result);
}

char   *qb2str (q)
struct qbuf *q;
{
    return qb2str (q);
}

struct qbuf *str2qb (s, len, head)
char   *s;
int	len,
	head;
{
    return str2qb (s, len, head);
}

int	qb_pullup (qb)
struct qbuf *qb;
{
    return qb_pullup (qb);
}

int	qb_free (qb)
struct qbuf *qb;
{
    (void) qb_free (qb);
}

int	pe2ssdu (pe, base, len)
PE	pe;
char  **base;
int    *len;
{
    return pe2ssdu (pe, base, len);
}

PE	ssdu2pe (base, len, realbase, result)
char   *base,
       *realbase;
int	len;
int   *result;
{
    return ssdu2pe (base, len, realbase, result);
}

void	pe2text (lp, pe, rw, cc)
LLog   *lp;
PE	pe;
int	rw,
	cc;
{
    pe2text (lp, pe, rw, cc);
}

int	pe2uvec (pe, uv)
PE	pe;
struct udvec **uv;
{
    return pe2uvec (pe, uv);
}

/*  */

long	gtime (tm)
struct tm *tm;
{
    return gtime (tm);
}

struct tm *ut2tm (ut)
UTC	ut;
{
    return ut2tm (ut);
}

void	tm2ut (tm, ut)
struct tm *tm;
UTC	ut;
{
    tm2ut (tm, ut);
}

struct SSAPref *addr2ref (addr)
char   *addr;
{
    return addr2ref (addr);
}

char   *sprintref (sr)
struct SSAPref *sr;
{
    return sprintref (sr);
}


/* these really belong in llib-lpepy (which doesn't exist!) */

/* VARARGS */

void	PY_advise (what, fmt)
char   *what,
       *fmt;
{
    PY_advise (what, fmt);
}


int	PY_pp (argc, argv, envp, pfx)
int	argc;
char  **argv,
      **envp;
IFP	pfx;
{
    return PY_pp (argc, argv, envp, pfx);
}


int	testdebug (pe, s)
PE	pe;
char   *s;
{
    return testdebug (pe, s);
}


/* VARARGS1 */

vprint (fmt)
char   *fmt;
{
    vprint (fmt);
}


char *bit2str (pe, s)
PE	pe;
char   *s;
{
    return bit2str (pe, s);
}


vpushfp (fp, pe, s, rw)
FILE   *fp;
PE	pe;
char   *s;
int	rw;
{
    vpushfp (fp, pe, s, rw);
}


vpopfp ()
{
}


vpushstr (cp)
char   *cp;
{
    vpushstr (cp);
}


vpopstr ()
{
}


vpushpp (pv, pfnx, pe, text, rw)
caddr_t pv;
IFP	pfnx;
register PE	pe;
char   *text;
int	rw;
{
    vpushpp (pv, pfnx, pe, text, rw);
}


vpopp ()
{
}

_vpdu (lp, fnx, pe, text, rw)
LLog   *lp;
IFP	fnx;
PE	pe;
char   *text;
int	rw;
{
    _vpdu (lp, fnx, pe, text, rw);
}
/* llib-lssap - lint library for -lssap */

/* 
 * $Header: /f/osi/ssap/RCS/llib-lssap,v 7.0 89/11/23 22:25:18 mrose Rel $
 *
 *
 * $Log:	llib-lssap,v $
 * Revision 7.0  89/11/23  22:25:18  mrose
 * Release 6.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 "ssap.h"

/*  */

/* SERVER only */

int	SExec (ts, si, hook, setperms)
struct TSAPstart *ts;
struct SSAPindication *si;
IFP	hook,
	setperms;
{
    return SExec (ts, si, hook, setperms);
}


/* S-CONNECT.INDICATION */

int	SInit (vecp, vec, ss, si)
int	vecp;
char  **vec;
struct SSAPstart *ss;
struct SSAPindication *si;
{
    return SInit (vecp, vec, ss, si);
}


/* S-CONNECT.RESPONSE */

int	SConnResponse (sd, ref, responding, result, requirements, settings,
	isn, data, cc, si)
int	sd;
struct SSAPref *ref;
struct SSAPaddr *responding;
int	result,
	requirements,
	settings,
	cc;
long	isn;
char   *data;
struct SSAPindication *si;
{
    return SConnResponse (sd, ref, responding, result, requirements, settings,
		isn, data, cc, si);
}


/* S-(ASYN-)CONNECT.REQUEST */

int	SAsynConnRequest (ref, calling, called, requirements, settings, isn,
	data, cc, qos, sc, si, async)
struct SSAPref *ref;
struct SSAPaddr *calling,
		*called;
int	requirements,
	settings,
	cc,
	async;
long	isn;
char   *data;
struct QOStype *qos;
struct SSAPconnect *sc;
struct SSAPindication *si;
{
    return SAsynConnRequest (ref, calling, called, requirements, settings, isn,
		data, cc, qos, sc, si, async);
}


/* S-ASYN-RETRY.REQUEST (pseudo) */

int	SAsynRetryRequest (sd, sc, si)
int	sd;
struct SSAPconnect *sc;
struct SSAPindication *si;
{
    return SAsynRetryRequest (sd, sc, si);
}


/* S-ASYN-NEXT.REQUEST (pseudo) */

int	SAsynNextRequest (sd, sc, si)
int	sd;
struct SSAPconnect *sc;
struct SSAPindication *si;
{
    return SAsynNextRequest (sd, sc, si);
}


/* S-DATA.REQUEST */

int	SDataRequest (sd, data, cc, si)
int	sd;
char   *data;
int	cc;
struct SSAPindication  *si;
{
    return SDataRequest (sd, data, cc, si);
}


/* S-WRITE.REQUEST (pseudo, write user data vectors) */

int	SWriteRequest (sd, typed, uv, si)
int	sd;
int	typed;
struct udvec *uv;
struct SSAPindication *si;
{
    return SWriteRequest (sd, typed, uv, si);
}


/* S-EXPEDITED-DATA.REQUEST */

int	SExpdRequest (sd, data, cc, si)
int	sd;
char   *data;
int	cc;
struct SSAPindication  *si;
{
    return SExpdRequest (sd, data, cc, si);
}


/* S-TYPED-DATA.REQUEST */

int	STypedRequest (sd, data, cc, si)
int	sd;
char   *data;
int	cc;
struct SSAPindication *si;
{
    return STypedRequest (sd, data, cc, si);
}


/* S-CAPABILITY-DATA.REQUEST */

int	SCapdRequest (sd, data, cc, si)
int	sd;
char   *data;
int	cc;
struct SSAPindication *si;
{
    return SCapdRequest (sd, data, cc, si);
}


/* S-CAPABILITY-DATA.RESPONSE */

int	SCapdResponse (sd, data, cc, si)
int	sd;
char   *data;
int	cc;
struct SSAPindication *si;
{
    return SCapdResponse (sd, data, cc, si);
}


/* S-READ.REQUEST (pseudo; synchronous read) */

int	SReadRequest (sd, sx, secs, si)
int	sd;
struct SSAPdata *sx;
int	secs;
struct SSAPindication  *si;
{
    return SReadRequest (sd, sx, secs, si);
}


/* S-TOKEN-GIVE.REQUEST */

int	SGTokenRequest (sd, tokens, si)
int	sd;
int	tokens;
struct SSAPindication  *si;
{
    return SGTokenRequest (sd, tokens, si);
}


/* S-TOKEN-PLEASE.REQUEST */

int	SPTokenRequest (sd, tokens, data, cc, si)
int	sd;
int	tokens,
	cc;
char   *data;
struct SSAPindication  *si;
{
    return SPTokenRequest (sd, tokens, data, cc, si);
}


/* S-CONTROL-GIVE.REQUEST */

int	SGControlRequest (sd, si)
int	sd;
struct SSAPindication *si;
{
    return SGControlRequest (sd, si);
}


/* S-MAJOR-SYNC.REQUEST */

int	SMajSyncRequest (sd, ssn, data, cc, si)
int	sd;
long   *ssn;
char   *data;
int	cc;
struct SSAPindication *si;
{
    return SMajSyncRequest (sd, ssn, data, cc, si);
}


/* S-MAJOR-SYNC.RESPONSE */

int	SMajSyncResponse (sd, data, cc, si)
int	sd;
char   *data;
int	cc;
struct SSAPindication *si;
{
    return SMajSyncResponse (sd, data, cc, si);
}


/* S-MINOR-SYNC.REQUEST */

int	SMinSyncRequest (sd, type, ssn, data, cc, si)
int	sd;
int	type;
long   *ssn;
char   *data;
int	cc;
struct SSAPindication *si;
{
    return SMinSyncRequest (sd, type, ssn, data, cc, si);
}


/* S-MINOR-SYNC.RESPONSE */

int	SMinSyncResponse (sd, ssn, data, cc, si)
int	sd;
long	ssn;
char   *data;
int	cc;
struct SSAPindication *si;
{
    return SMinSyncResponse (sd, ssn, data, cc, si);
}


/* S-RESYNCHRONIZE.REQUEST */

int	SReSyncRequest (sd, type, ssn, settings, data, cc, si)
int	sd;
int	type,
	settings;
long	ssn;
char   *data;
int	cc;
struct SSAPindication *si;
{
    return SReSyncRequest (sd, type, ssn, settings, data, cc, si);
}


/* S-RESYNCHRONIZE.RESPONSE */

int	SReSyncResponse (sd, ssn, settings, data, cc, si)
int	sd;
int     settings;
long	ssn;
char   *data;
int	cc;
struct SSAPindication *si;
{
    return SReSyncResponse (sd, ssn, settings, data, cc, si);
}


/* S-ACTIVITY-START.REQUEST */

int	SActStartRequest (sd, id, data, cc, si)
int	sd;
struct SSAPactid *id;
char   *data;
int	cc;
struct SSAPindication *si;
{
    return SActStartRequest (sd, id, data, cc, si);
}

/* S-ACTIVITY-RESUME.REQUEST */

int	SActResumeRequest (sd, id, oid, ssn, ref, data, cc, si)
int	sd;
struct SSAPactid *id,
		 *oid;
long	ssn;
struct SSAPref *ref;
char   *data;
int	cc;
struct SSAPindication *si;
{
    return SActResumeRequest (sd, id, oid, ssn, ref, data, cc, si);
}

/* S-ACTIVITY-INTERRUPT.REQUEST */

int	SActIntrRequest (sd, reason, si)
int	sd;
int	reason;
struct SSAPindication *si;
{
    return SActIntrRequest (sd, reason, si);
}

/* S-ACTIVITY-INTERRUPT.RESPONSE */

int	SActIntrResponse (sd, si)
int	sd;
struct SSAPindication *si;
{
    return SActIntrResponse (sd, si);
}

/* S-ACTIVITY-DISCARD.REQUEST */

int	SActDiscRequest (sd, reason, si)
int	sd;
int	reason;
struct SSAPindication *si;
{
    return SActDiscRequest (sd, reason, si);
}

/* S-ACTIVITY-DISCARD.RESPONSE */

int	SActDiscResponse (sd, si)
int	sd;
struct SSAPindication *si;
{
    return SActDiscResponse (sd, si);
}

/* S-ACTIVITY-END.REQUEST */

int	SActEndRequest (sd, ssn, data, cc, si)
int	sd;
long   *ssn;
char   *data;
int	cc;
struct SSAPindication *si;
{
    return SActEndRequest (sd, ssn, data, cc, si);
}

/* S-ACTIVITY-END.RESPONSE */

int	SActEndResponse (sd, data, cc, si)
int	sd;
char   *data;
int	cc;
struct SSAPindication *si;
{
    return SActEndResponse (sd, data, cc, si);
}

/* S-U-ABORT.REQUEST */

int	SUAbortRequest (sd, data, cc, si)
int	sd;
char   *data;
int	cc;
struct SSAPindication  *si;
{
    return SUAbortRequest (sd, data, cc, si);
}


/* S-U-EXCEPTION-REPORT.REQUEST */

int	SUReportRequest (sd, reason, data, cc, si)
int	sd;
int	reason;
char   *data;
int	cc;
struct SSAPindication *si;
{
    return SUReportRequest (sd, reason, data, cc, si);
}

/* S-RELEASE.REQUEST */

int	SRelRequest (sd, data, cc, secs, sr, si)
int	sd;
char   *data;
int	cc;
int	secs;
struct SSAPrelease *sr;
struct SSAPindication  *si;
{
    return SRelRequest (sd, data, cc, secs, sr, si);
}


/* S-RELEASE-RETRY.REQUEST (pseudo) */

int	SRelRetryRequest (sd, secs, sr, si)
int	sd;
int	secs;
struct SSAPrelease *sr;
struct SSAPindication *si;
{
    return SRelRetryRequest (sd, secs, sr, si);
}


/* S-RELEASE.RESPONSE */

int	SRelResponse (sd, result, data, cc, si)
int	sd;
int	result,
	cc;
char   *data;
struct SSAPindication  *si;
{
    return SRelResponse (sd, result, data, cc, si);
}


/* define vectors for INDICATION events */

int	SSetIndications (sd, data, tokens, sync, activity, report, finish,
	abort, si)
int	sd;
IFP	data,
	tokens,
	sync,
	activity,
	report,
	finish,
	abort;
struct SSAPindication *si;
{
    return SSetIndications (sd, data, tokens, sync, activity, report, finish,
		abort, si);
}


/* map session descriptors for select() */

int 	SSelectMask (sd, mask, nfds, si)
int	sd;
fd_set *mask;
int    *nfds;
struct SSAPindication *si;
{
    return SSelectMask (sd, mask, nfds, si);
}


/* return SSAP error code in string form */

char    *SErrString (c)
int	c;
{
    return SErrString (c);
}
/* llib-ltsap - lint library for -ltsap */

/* 
 * $Header: /f/osi/tsap/RCS/llib-ltsap,v 7.1 89/12/18 17:50:13 mrose Exp $
 *
 *
 * $Log:	llib-ltsap,v $
 * Revision 7.1  89/12/18  17:50:13  mrose
 * update
 * 
 * Revision 7.0  89/11/23  22:30:29  mrose
 * Release 6.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 "tsap.h"

/*  */

/* T-CONNECT.INDICATION */

int     TInit (vecp, vec, ts, td)
int     vecp;
char  **vec;
struct TSAPstart   *ts;
struct TSAPdisconnect  *td;
{
    return TInit (vecp, vec, ts, td);
}


/* T-CONNECT.RESPONSE */

int     TConnResponse (sd, responding, expedited, data, cc, qos, td)
int     sd;
struct TSAPaddr  *responding;
int     expedited,
	cc;
char   *data;
struct QOStype *qos;
struct TSAPdisconnect  *td;
{
    return TConnResponse (sd, responding, expedited, data, cc, qos, td);
}


/* T-(ASYN-)CONNECT.REQUEST */

int     TAsynConnRequest (calling, called, expedited, data, cc, qos,
			  tc, td, async)
struct TSAPaddr *calling,
		*called;
int     expedited,
        cc,
	async;
char   *data;
struct QOStype *qos;
struct TSAPconnect *tc;
struct TSAPdisconnect  *td;
{
    return TAsynConnRequest (calling, called, expedited, data, cc, qos,
			     tc, td, async);
}


/* T-ASYN-RETRY.REQUEST (pseudo) */

int	TAsynRetryRequest (sd, tc, td)
int	sd;
struct TSAPconnect *tc;
struct TSAPdisconnect *td;
{
    return TAsynRetryRequest (sd, tc, td);
}


/* T-ASYN-NEXT.REQUEST (pseudo) */

int	TAsynNextRequest (sd, tc, td)
int	sd;
struct TSAPconnect *tc;
struct TSAPdisconnect *td;
{
    return TAsynNextRequest (sd, tc, td);
}


/* T-DATA.REQUEST */

int     TDataRequest (sd, data, cc, td)
int     sd;
char   *data;
int	cc;
struct TSAPdisconnect  *td;
{
    return TDataRequest (sd, data, cc, td);
}


/* T-WRITE.REQUEST (pseudo, write user data vectors) */

int     TWriteRequest (sd, uv, td)
int     sd;
struct udvec *uv;
struct TSAPdisconnect  *td;
{
    return TWriteRequest (sd, uv, td);
}


/* T-EXPEDITED-DATA.REQUEST */

int     TExpdRequest (sd, data, cc, td)
int     sd;
char   *data;
int	cc;
struct TSAPdisconnect  *td;
{
    return TExpdRequest (sd, data, cc, td);
}


/* T-READ.REQUEST (pseudo; synchronous read) */

int     TReadRequest (sd, tx, secs, td)
int     sd;
struct TSAPdata *tx;
int	secs;
struct TSAPdisconnect  *td;
{
    return TReadRequest (sd, tx, secs, td);
}


/* T-DISCONNECT.REQUEST */

int     TDiscRequest (sd, data, cc, td)
int     sd;
char   *data;
int	cc;
struct TSAPdisconnect  *td;
{
    return TDiscRequest (sd, data, cc, td);
}


/* define vectors for INDICATION events */

int     TSetIndications (sd, data, disc, td)
int     sd;
IFP     data,
        disc;
struct TSAPdisconnect  *td;
{
    return TSetIndications (sd, data, disc, td);
}


/* map transport descriptors for select() */

int     TSelectMask (sd, mask, nfds, td)
int     sd;
fd_set *mask;
int    *nfds;
struct TSAPdisconnect  *td;
{
    return TSelectMask (sd, mask, nfds, td);
}


/* estimate of octets that might be returned */

int	TSelectOctets (sd, nbytes, td)
int	sd;
long   *nbytes;
struct TSAPdisconnect *td;
{
    return TSelectOctets (sd, nbytes, td);
}


/* get TSAPs */

int	TGetAddresses (sd, initiating, responding, td)
int	sd;
struct TSAPaddr *initiating,
		*responding;
struct TSAPdisconnect *td;
{
    return TGetAddresses (sd, initiating, responding, td);
}


/* define transport manager */

#ifdef	MGMT
int	TSetManager (sd, fnx, td)
int	sd;
IFP	fnx;
struct TSAPdisconnect *td;
{
    return TSetManager (sd, fnx, td);
}
#endif


/* save the state of a connection */

int	TSaveState (sd, vec, td)
int	sd;
char  **vec;
struct TSAPdisconnect  *td;
{
    return TSaveState (sd, vec, td);
}


/* restore the state of a connection */

int	TRestoreState (buffer, ts, td)
char   *buffer;
struct TSAPstart  *ts;
struct TSAPdisconnect  *td;
{
    return TRestoreState (buffer, ts, td);
}


/* return TSAP error code in string form */

char   *TErrString (c)
int     c;
{
    return TErrString (c);
}


/* start listening on an TSAP */

int	TNetListen (ta, td)
struct TSAPaddr *ta;
struct TSAPdisconnect *td;
{
    return TNetListen (ta, td);
}


/* start listening on a set of unique TSAPs */

int	TNetUnique (ta, td)
struct TSAPaddr *ta;
struct TSAPdisconnect *td;
{
    return TNetUnique (ta, td);
}


/* accept a call on an TSAP */

int	TNetAcceptAux (vecp, vec, newfd, ta, nfds, rfds, wfds, efds, secs, td)
int    *vecp;
char  **vec;
int    *newfd;
struct TSAPaddr *ta;
int	nfds;
fd_set *rfds,
       *wfds,
       *efds;
int	secs;
struct TSAPdisconnect *td;
{
    return TNetAcceptAux (vecp, vec, newfd, ta, nfds, rfds, wfds, efds, secs,
			  td);
}


/* stop listening on an TSAP */

int	TNetClose (ta, td)
struct TSAPaddr *ta;
struct TSAPdisconnect *td;
{
    return TNetClose (ta, td);
}


/* fork after accepting a connection */

int	TNetFork (vecp, vec, td)
int	vecp;
char  **vec;
struct TSAPdisconnect *td;
{
    return TNetFork (vecp, vec, td);
}


/* enable/disable queued (non-blocking) writes */

int	TSetQueuesOK (sd, onoff, td)
int	sd;
int	onoff;
struct TSAPdisconnect *td;
{
    return TSetQueuesOK (sd, onoff, td);
}
/* llib-licompat - lint library for -licompat */

/* 
 * $Header: /f/osi/compat/RCS/llib-lcompat,v 7.3 90/01/11 18:35:13 mrose Exp $
 *
 *
 * $Log:	llib-lcompat,v $
 * Revision 7.3  90/01/11  18:35:13  mrose
 * real-sync
 * 
 * Revision 7.2  89/12/19  16:17:55  mrose
 * dgram
 * 
 * Revision 7.1  89/11/30  23:53:14  mrose
 * pa2str
 * 
 * Revision 7.0  89/11/23  21:23:14  mrose
 * Release 6.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 <varargs.h>
#include "manifest.h"
#include "general.h"
#include "isoaddrs.h"
#include "isoservent.h"
#include "logger.h"
#ifdef	TCP
#include "internet.h"
#endif
#ifdef	X25
#include "x25.h"
#endif
#ifdef	TP4
#include "tp4.h"
#endif

/*  */

/*    EMULATION */

#ifdef	SYS5
int	dup2 (d1, d2)
int	d1,
	d2;
{
    return dup2 (d1, d2);
}
#endif


#ifndef	SWABLIB
#undef	ntohs
u_short	ntohs (netshort) u_short netshort; { return ntohs (netshort); }

#undef	htons
u_short	htons (hostshort) u_short hostshort; { return htons (hostshort); }

#undef	ntohl
u_long	ntohl (netlong) u_long netlong; { return ntohl (netlong); }

#undef	htonl
u_long	htonl (hostlong) u_long hostlong; { return htonl (hostlong); }
#endif


int	ll_open (lp)
LLog   *lp;
{
    return ll_open (lp);
}


int	ll_close (lp)
LLog   *lp;
{
    return ll_close (lp);
}


/* VARARGS4 */

int	ll_log (lp, event, what, fmt)
LLog   *lp;
int	event;
char   *what,
       *fmt;
{
    return ll_log (lp, event, what, fmt);
}


int	_ll_log (lp, event, ap)
LLog   *lp;
int	event;
va_list ap;
{
    return _ll_log (lp, event, ap);
}


void	ll_hdinit (lp, prefix)
LLog   *lp;
char   *prefix;
{
    ll_hdinit (lp, prefix);
}


void	ll_dbinit (lp, prefix)
LLog   *lp;
char   *prefix;
{
    ll_dbinit (lp, prefix);
}


/* VARARGS2 */

int	ll_printf (lp, fmt)
LLog   *lp;
char   *fmt;
{
    return ll_printf (lp, fmt);
}


int	ll_sync (lp)
LLog   *lp;
{
    return ll_sync (lp);
}


/* VARARGS1 */

char   *ll_preset (fmt)
char   *fmt;
{
    return ll_preset (fmt);
}


int	ll_check (lp)
LLog   *lp;
{
    return ll_check (lp);
}

/*
 * ll_defmhdr - Default "make header" routine.
 */
int	ll_defmhdr(bufferp, headerp, dheaderp)
char	*bufferp;		/* Buffer pointer */
char	*headerp;		/* Static header string */
char	*dheaderp;		/* Dynamic header string */
{
    ll_defmhdr(bufferp, headerp, dheaderp);
}

/*
 * ll_setmhdr - Set "make header" routine, overriding default.
 */
IFP	ll_setmhdr(make_header_routine) 
IFP	make_header_routine;
{
    return (ll_setmhdr(make_header_routine));
}


int	selsocket (nfds, rfds, wfds, efds, secs)
int	nfds;
fd_set *rfds,
       *wfds,
       *efds;
int	secs;
{
    return selsocket (nfds, rfds, wfds, efds, secs);
}


IFP	set_select_fd (fd, fnx)
int	fd;
IFP	fnx;
{
    return set_select_fd (fd, fnx);
}


int	xselect (nfds, rfds, wfds, efds, secs)
int	nfds;
fd_set *rfds,
       *wfds,
       *efds;
int	secs;
{
    return xselect (nfds, rfds, wfds, efds, secs);
}


#ifdef	BSDSIGS
#ifdef	AIX
IFP	signal (sig, func)
int	sig;
IFP	func;
{
    return signal (sig, func);
}
#endif
#else
int	sigblock (mask)
int	mask;
{
    return sigblock (mask);
}

int	sigsetmask (mask)
int	mask;
{
    return sigsetmask (mask);
}
#endif

/*    UTILITY */

void	asprintf (bp, ap)
char   *bp;
va_list	ap;
{
    asprintf (bp, ap);
}


void	_asprintf (bp, what, ap)
char   *bp,
       *what;
va_list	ap;
{
    _asprintf (bp, what, ap);
}


int	expode (a, b, n)
char   *a;
u_char *b;
int	n;
{
    return explode (a, b, n);
}


int	implode (a, b, n)
u_char *a;
char   *b;
int	n;
{
    return implode (a, b, n);
}


char   *_isodefile (path, file)
char   *path,
       *file;
{
    return _isodefile (path, file);
}


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


char   *sel2str (sel, len, quoted)
char   *sel;
int	len,
	quoted;
{
    return sel2str (sel, len, quoted);
}


char   *sys_errname (i)
int	i;
{
    return sys_errname (i);
}


char  *sprintb (v, bits)
int	v;
char   *bits;
{
    return sprintb (v, bits);
}


int	str2elem (s, elements)
char   *s;
unsigned int elements[];
{
    return str2elem (s, elements);
}


int	str2sel (s, quoted, sel, n)
char   *s,
       *sel;
int	quoted,
	n;
{
    return str2sel (s, quoted, sel, n);
}


int	str2vecX (s, vec, nmask, mask, brk)
char   *s,
      **vec,
    	brk;
int	nmask,
       *mask;
{
    return str2vecX (s, vec, nmask, mask, brk);
}


char   *getpassword (prompt)
char   *prompt;
{
    return getpassword (prompt);
}


int	baduser (file, user)
char   *file,
       *user;
{
    return baduser (file, user);
}


int	setenv (name, value)
char   *name,
       *value;
{
    return setenv (name, value);
}


int	unsetenv (name)
char   *name;
{
    unsetenv (name);
}


#include "cmd_srch.h"

int	cmd_src (str, cmd)
char   *str;
CMD_TABLE *cmd;
{
    return cmd_src (str, cmd);
}


int	lexequ (str1, str2)
char   *str1,
       *str2;
{
    return lexequ (str1, str2);
}


int	lexnequ (str1, str2, len)
char   *str1,
       *str2;
int	len;
{
    return lexnequ (str1, str2, len);
}


int	log_tai (lgptr, av, ac)
LLog   *lgptr;
char  **av;
int	ac;
{
    log_tai (lgptr, av, ac);
}


char   *rcmd_srch (val, cmd)
int	val;
CMD_TABLE *cmd;
{
    return rcmd_srch (val, cmd);
}


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


int	sstr2arg (srcptr, maxpf, argv, dlmstr)
char   *srcptr;
int	maxpf;
char   *argv[],
       *dlmstr;
{
    return sstr2arg (srcptr, maxpf, argv, dlmstr);
}


char   *smalloc (size)
int	size;
{
    return smalloc (size);
}


char   *isodesetailor (file)
char   *file;
{
    return isodesetailor (file);
}


void	isodetailor (myname, wantuser)
char   *myname;
int	wantuser;
{
    isodetailor (myname, wantuser);
}

int	isodesetvar (name, value, dynamic)
char   *name,
       *value;
int	dynamic;
{
    return isodesetvar (name, value, dynamic);
}


void	isodexport ()
{
    isodexport ();
}


/*    ISOSERVENT */

int     setisoservent (f)
int     f;
{
    return setisoservent (f);
}


int     endisoservent () {
    return endisoservent ();
}


struct isoservent  *getisoservent () {
    return getisoservent ();
}


struct isoservent  *getisoserventbyname (entity, provider)
char   *entity,
       *provider;
{
    return getisoserventbyname (entity, provider);
}


struct isoservent  *getisoserventbyselector (provider, selector, selectlen)
char   *provider,
       *selector;
int	selectlen;
{
    return getisoserventbyselector (provider, selector, selectlen);
}


struct isoservent  *getisoserventbyport (provider, port)
char   *provider;
unsigned short port;
{
    return getisoserventbyport (provider, port);
}

/*    NETWORK */

struct PSAPaddr *str2paddr (str)
char   *str;
{
    return str2paddr (str);
}


struct TSAPaddr *str2taddr (str)
char   *str;
{
    return str2taddr (str);
}


char   *_paddr2str (pa, na, compact)
struct PSAPaddr *pa;
struct NSAPaddr *na;
int	compact;
{
    return _paddr2str (pa, na, compact);
}


char   *saddr2str (sa)
struct SSAPaddr *sa;
{
    return saddr2str (sa);
}


char   *taddr2str (ta)
struct TSAPaddr *ta;
{
    return taddr2str (ta);
}


struct NSAPaddr *na2norm (na)
struct NSAPaddr *na;
{
    return na2norm (na);
}


char   *na2str (na)
struct NSAPaddr *na;
{
    return na2str (na);
}


char   *pa2str (pa)
struct PSAPaddr *pa;
{
    return pa2str (pa);
}

/*    TCP */

#ifdef	TCP

int	start_tcp_client (sock, priv)
struct sockaddr_in *sock;
int	priv;
{
    return start_tcp_client (sock, priv);
}


int	start_tcp_server (sock, backlog, opt1, opt2)
struct sockaddr_in *sock;
int	backlog,
    	opt1,
    	opt2;
{
    return start_tcp_server (sock, backlog, opt1, opt2);
}


#ifndef	join_tcp_client
int	join_tcp_client (fd, sock)
int	fd;
struct sockaddr_in *sock;
{
    return join_tcp_client (fd, sock);
}
#endif


struct hostent *gethostbystring (s)
char   *s;
{
    return gethostbystring (s);
}


#ifdef	EXOS
struct hostent *gethostbyaddr (addr, len, type)
char   *addr;
int	len,
	type;
{
    return gethostbyaddr (addr, len, type);
}


struct hostent *gethostbyname (name)
char   *name;
{
    return gethostbyname (name);
}


struct servent *getservbyname (name, proto)
char   *name,
       *proto;
{
    return getservbyname (name, proto);
}


char   *inet_ntoa (in)
struct in_addr in;
{
    return inet_ntoa (in);
}


u_long	inet_addr (cp)
char   *cp;
{
    return inet_addr (cp);
}
#endif

#endif

/*    DGRAM */

#if	defined(SOCKETS) && (defined(TCP) || defined(CLTS))

#ifdef	TCP
int	start_udp_server (sock, backlog, opt1, opt2)
struct sockaddr_in *sock;
int	backlog,
	opt1,
	opt2;
{
    return start_udp_server (sock, backlog, opt1, opt2);
}
#endif


#ifdef	CLTS
int	start_clts_server (sock, backlog, opt1, opt2)
union sockaddr_osi *sock;
int	backlog,
	opt1,
	opt2;
{
    return start_clts_server (sock, backlog, opt1, opt2);
}
#endif


int	join_dgram_aux (fd, sock, newfd)
int	fd,
	newfd;
struct sockaddr *sock;
{
    return join_dgram_aux (fd, sock, newfd);
}


int	read_dgram_socket (fd, qb)
int	fd;
struct qbuf **qb;
{
    return read_dgram_socket (fd, qb);
}


int	hack_dgram_socket (fd, sock)
int	fd;
struct sockaddr *sock;
{
    return hack_dgram_socket (fd, sock);
}


int	write_dgram_socket (fd, qb)
int	fd;
struct qbuf *qb;
{
    return write_dgram_socket (fd, qb);
}


int	close_dgram_socket (fd)
int	fd;
{
    return close_dgram_socket (fd);
}


int	select_dgram_socket (nfds, rfds, wfds, efds, secs)
int	nfds;
fd_set *rfds,
       *wfds,
       *efds;
int	secs;
{
    return select_dgram_socket (nfds, rfds, wfds, efds, secs);
}
#endif

/*    X.25 */

#ifdef	X25
CONN_DB *gen2if (generic, specific, context)
struct NSAPaddr *generic;
CONN_DB *specific;
int	context;
{
    return gen2if (generic, specific, context);
}


struct NSAPaddr *if2gen (generic, specific, context)
struct NSAPaddr *generic;
CONN_DB *specific;
int	context;
{
    return if2gen (generic, specific, context);
}
#endif
