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

/* llib-lrosy - lint library for -lrosy */

/* 
 * $Header: /xtel/isode/isode/rosy/RCS/llib-lrosy,v 9.0 1992/06/16 12:37:29 isode Rel $
 *
 *
 * $Log: llib-lrosy,v $
 * Revision 9.0  1992/06/16  12:37:29  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 "rosy.h"

/*  */

/* WAIT */

int	RyWait (sd, id, out, secs, roi)
int	sd,
       *id,
	secs;
caddr_t *out;
struct RoSAPindication *roi;
{
    return RyWait (sd, id, out, secs, roi);
}


/* Initiator */

/* STUB */

int	RyStub (sd, ryo, op, id, linked, in, rfx, efx, class, roi)
int	sd;
struct RyOperation *ryo;
int	op,
	id,
       *linked,
    	class;
caddr_t	in;
IFP	rfx,
    	efx;
struct RoSAPindication *roi;
{
    return RyStub (sd, ryo, op, id, linked, in, rfx, efx, class, roi);
}


/* DISCARD */

int	RyDiscard (sd, id, roi)
int	sd,
	id;
struct RoSAPindication *roi;
{
    return RyDiscard (sd, id, roi);
}


/* OPERATION */

int	RyOperation (sd, ryo, op, in, out, response, roi)
int	sd;
struct RyOperation *ryo;
int	op,
       *response;
caddr_t	in,
       *out;
struct RoSAPindication *roi;
{
    return RyOperation (sd, ryo, op, in, out, response, roi);
}


/* INVOKE */

int	RyOpInvoke (sd, ryo, op, in, out, rfx, efx, class, invokeID, linkedID,
		    priority, roi)
int	sd;
struct RyOperation *ryo;
int	op,
	class,
	invokeID,
       *linkedID,
	priority;
caddr_t	in,
       *out;
IFP	rfx,
	efx;
struct RoSAPindication *roi;
{
    return RyOpInvoke (sd, ryo, op, in, out, rfx, efx, class, invokeID,
		       linkedID, priority, roi);
}


/* generate unique invoke ID */

int	RyGenID (sd)
int	sd;
{
    return RyGenID (sd);
}


/* Responder */

/* DISPATCH */

int	RyDispatch (sd, ryo, op, fnx, roi)
int	sd;
struct RyOperation *ryo;
int	op;
IFP	fnx;
struct RoSAPindication *roi;
{
    return RyDispatch (sd, ryo, op, fnx, roi);
}


/* RESULT */

int	RyDsResult (sd, id, out, priority, roi)
int	sd;
int	id,
	priority;
caddr_t out;
struct RoSAPindication *roi;
{
    return RyDsResult (sd, id, out, priority, roi);
}


/* ERROR */

int	RyDsError (sd, id, err, out, priority, roi)
int	sd;
int	id,
	err,
	priority;
caddr_t	out;
struct RoSAPindication *roi;
{
    return RyDsError (sd, id, err, out, priority, roi);
}


/* U-REJECT */

int	RyDsUReject (sd, id, reason, priority, roi)
int	sd;
int	id,
	reason,
	priority;
struct RoSAPindication *roi;
{
    return RyDsUReject (sd, id, reason, priority, roi);
}


/* clean-up after association termination */

int	RyLose (sd, roi)
int	sd;
struct RoSAPindication *roi;
{
    return RyLose (sd, roi);
}


/* find operations and errors by numbers and names */

struct RyOperation *findopbyop (ryo, op)
struct RyOperation *ryo;
int	op;
{
    return findopbyop (ryo, op);
}


struct RyOperation *findopbyname (ryo, name)
struct RyOperation *ryo;
char   *name;
{
    return findopbyname (ryo, name);
}


struct RyError *finderrbyerr (rye, err)
struct RyError *rye;
int	err;
{
    return finderrbyerr (rye, err);
}


struct RyError *finderrbyname (rye, name)
struct RyError *rye;
char   *name;
{
    return finderrbyname (rye, name);
}
/* llib-lronot - lint library for -lronot */

/*
 *				  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 "ronot.h"

/* ^L   RO-BIND.INDICATION */

/* ARGSUSED */

int       RoBindInit (vecp, vec, acs, rni)
int                       vecp;
char                    **vec;
struct AcSAPstart       * acs;
struct RoNOTindication  * rni;
{
	return ( RoBindInit (vecp, vec, acs, rni) );
}

int       ParseRoBindArgument (acs, rni)
struct AcSAPstart       * acs;
struct RoNOTindication  * rni;
{
	return ( ParseRoBindArgument (acs, rni) );
}

/* ^L   RO-BIND.RESULT */

/* ARGSUSED */

int       RoBindResult (sd, context, respondtitle, respondaddr, ctxlist,
                defctxresult, prequirements, srequirements, isn, settings,
                ref, bindrespe, rni)
int                       sd;
OID                       context;
AEI                       respondtitle;
struct PSAPaddr         * respondaddr;
struct PSAPctxlist      * ctxlist;
int                       defctxresult;
int                       prequirements;
int                       srequirements;
long                      isn;
int                       settings;
struct SSAPref          * ref;
PE                        bindrespe;
struct RoNOTindication  * rni;
{
	return ( RoBindResult (sd, context, respondtitle, respondaddr, ctxlist,
                defctxresult, prequirements, srequirements, isn, settings,
                ref, bindrespe, rni) );
}

/* ^L   RO-BIND.ERROR */

/* ARGSUSED */

int       RoBindError (sd, context, respondtitle,
                respondaddr, ctxlist, defctxresult, prequirements,
                srequirements, isn, settings, ref, binderrpe, rni)
int                       sd;
OID                       context;
AEI                       respondtitle;
struct PSAPaddr         * respondaddr;
struct PSAPctxlist      * ctxlist;
int                       defctxresult;
int                       prequirements;
int                       srequirements;
long                      isn;
int                       settings;
struct SSAPref          * ref;
PE                        binderrpe;
struct RoNOTindication  * rni;
{
	return ( RoBindError (sd, context, respondtitle,
                respondaddr, ctxlist, defctxresult, prequirements,
                srequirements, isn, settings, ref, binderrpe, rni) );
}

/* ^L   RO-BIND.REJECT */

/* ARGSUSED */

int       RoBindReject (acs, status, reason, rni)
struct AcSAPstart       * acs;
int			  status;
int			  reason;
struct RoNOTindication  * rni;
{
	return ( RoBindReject (acs, status, reason, rni) );
}

/*  RO-BIND.REQUEST */

/* ARGSUSED */

int	RoAsynBindRequest (context, callingtitle, calledtitle,
		callingaddr, calledaddr, ctxlist, defctxname,
		prequirements, srequirements, isn, settings, ref,
		bindargpe, qos, acc, rni, async)
OID                       context;
AEI                       callingtitle;
AEI                       calledtitle;
struct PSAPaddr         * callingaddr;
struct PSAPaddr         * calledaddr;
struct PSAPctxlist      * ctxlist;
OID                       defctxname;
int                       prequirements;
int                       srequirements;
long                      isn;
int                       settings;
struct SSAPref          * ref;
PE                        bindargpe;
struct QOStype          * qos;
struct AcSAPconnect     * acc;
struct RoNOTindication  * rni;
int                       async;
{
	return ( RoAsynBindRequest (context, callingtitle, calledtitle,
                callingaddr, calledaddr, ctxlist, defctxname,
                prequirements, srequirements, isn, settings, ref,
                bindargpe, qos, acc, rni, async) );
}

/* ^L   RO-BIND.RETRY */

/* ARGSUSED */

int       RoAsynBindRetry (ad, do_next_nsap, acc, rni)
int                       ad;
int                       do_next_nsap;
struct AcSAPconnect     * acc;
struct RoNOTindication  * rni;
{
	return ( RoAsynBindRetry (ad, do_next_nsap, acc, rni) );
}

/* ARGSUSED */

int       ParseRoBindResponse (acc, rni)
struct AcSAPconnect *acc;
struct RoNOTindication  * rni;
{
	return ( ParseRoBindResponse (acc, rni) );
}

/* ^L   RO-UNBIND.REQUEST */

/* ARGSUSED */

int       RoUnBindRequest (sd, unbindargpe, secs, acr, rni)
int                       sd;
PE                        unbindargpe;
int                       secs;
struct AcSAPrelease     * acr;
struct RoNOTindication  * rni;
{
	return ( RoUnBindRequest (sd, unbindargpe, secs, acr, rni) );
}

/* ^L   RO-UNBIND.RETRY */

/* ARGSUSED */

int       RoUnBindRetry (sd, secs, acr, rni)
int                       sd;
int                       secs;
struct AcSAPrelease     * acr;
struct RoNOTindication  * rni;
{
	return ( RoUnBindRetry (sd, secs, acr, rni) );
}

/* ARGSUSED */

int       ParseRoUnBindResponse (acr, rni)
struct AcSAPrelease     * acr;
struct RoNOTindication  * rni;
{
	return ( ParseRoUnBindResponse (acr, rni) );
}

/* ^L   RO-UNBIND.RESULT */

/* ARGSUSED */

int       RoUnBindResult (sd, unbindrespe, rni)
int                       sd;
PE                        unbindrespe;
struct RoNOTindication  * rni;
{
	return ( RoUnBindResult (sd, unbindrespe, rni) );
}

/* ^L   RO-UNBIND.ERROR */

/* ARGSUSED */

int       RoUnBindError (sd, unbinderrpe, rni)
int                       sd;
PE                        unbinderrpe;
struct RoNOTindication  * rni;
{
	return ( RoUnBindError (sd, unbinderrpe, rni) );
}

/* ^L   RO-UNBIND.REJECT */

/* ARGSUSED */

int       RoUnBindReject (sd, status, reason, rni)
int                       sd;
int                       status;
int                       reason;
struct RoNOTindication  * rni;
{
	return ( RoUnBindReject (sd, status, reason, rni) );
}

/* ^L   ACSAP interface */

/* ARGSUSED */

int       acs2roblose (rni, event, aca)
struct RoNOTindication  * rni;
char                    * event;
struct AcSAPabort       * aca;
{
	return ( acs2roblose (rni, event, aca) );
}

/* llib-lrosap - lint library for -lrosap */

/* 
 * $Header: /xtel/isode/isode/rosap/RCS/llib-lrosap,v 9.0 1992/06/16 12:37:02 isode Rel $
 *
 *
 * Based on an TCP-based implementation by George Michaelson of University
 * College London.
 *
 * $Log: llib-lrosap,v $
 * Revision 9.0  1992/06/16  12:37:02  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 "rosap.h"

/*  */

/* SERVER only */

int	RoExec (ss, roi, arg1, arg2, hook, setperms)
struct SSAPstart *ss;
char   *arg1,
       *arg2;
struct RoSAPindication *roi;
IFP	hook,
	setperms;
{
    return RoExec (ss, roi, arg1, arg2, hook, setperms);
}

/* RO-BEGIN.INDICATION */

int	RoInit (vecp, vec, ros, roi)
int	vecp;
char  **vec;
struct RoSAPstart *ros;
struct RoSAPindication *roi;
{
    return RoInit (vecp, vec, ros, roi);
}

/* RO-BEGIN.RESPONSE */

int	RoBeginResponse (sd, status, data, roi)
int	sd;
int	status;
PE	data;
struct RoSAPindication *roi;
{
    return RoBeginResponse (sd, status, data, roi);
}

/* RO-BEGIN.REQUEST */

int	RoBeginRequest (called, data, roc, roi)
struct	RoSAPaddr *called;
PE	data;
struct RoSAPconnect *roc;
struct RoSAPindication *roi;
{
    return RoBeginRequest (called, data, roc, roi);
}

/* RO-INVOKE.REQUEST */

int	RoInvokeRequest (sd, op, class, args, invokeID, linkedID, priority, roi)
int	sd;
int	op,
	class,
	invokeID,
       *linkedID,
	priority;
PE	args;
struct RoSAPindication *roi;
{
    return RoInvokeRequest (sd, op, class, args, invokeID, linkedID, priority,
		roi);
}

/* RO-RESULT.REQUEST */

int	RoResultRequest (sd, invokeID, op, result, priority, roi)
int	sd;
int	invokeID,
	op,
	priority;
PE	result;
struct RoSAPindication *roi;
{
    return RoResultRequest (sd, invokeID, op, result, priority, roi);
}

/* RO-ERROR.REQUEST */

int	RoErrorRequest (sd, invokeID, error, params, priority, roi)
int	sd;
int	invokeID,
	error,
	priority;
PE	params;
struct RoSAPindication *roi;
{
    return RoErrorRequest (sd, invokeID, error, params, priority, roi);
}

/* RO-U-REJECT.REQUEST */

int	RoURejectRequest (sd, invokeID, reason, priority, roi)
int	sd;
int    *invokeID,
	reason,
	priority;
struct RoSAPindication *roi;
{
    return RoURejectRequest (sd, invokeID, reason, priority, roi);
}

/* RO-INVOKE.REQUEST (interruptable) */

int	RoIntrRequest (sd, op, args, invokeID, linkedID, priority, roi)
int	sd;
int	op,
	invokeID,
       *linkedID,
	priority;
PE	args;
struct RoSAPindication *roi;
{
    return RoIntrRequest (sd, op, args, invokeID, linkedID, priority, roi);
}

/* RO-WAIT.REQUEST (pseudo) */

int	RoWaitRequest (sd, secs, roi)
int	sd;
int	secs;
struct RoSAPindication *roi;
{
    return RoWaitRequest (sd, secs, roi);
}

/* RO-END.REQUEST */

int	RoEndRequest (sd, priority, roi)
int	sd;
int	priority;
struct RoSAPindication *roi;
{
    return RoEndRequest (sd, priority, roi);
}

/* RO-END.RESPONSE */

int	RoEndResponse (sd, roi)
int	sd;
struct RoSAPindication *roi;
{
    return RoEndResponse (sd, roi);
}


/* define vectors for INDICATION events */

int	RoSetIndications (sd, indication, roi)
int	sd;
IFP	indication;
struct RoSAPindication *roi;
{
    return RoSetIndications (sd, indication, roi);
}


/* map association descriptors for select() */

int	RoSelectMask (sd, mask, nfds, roi)
int	sd;
fd_set *mask;
int    *nfds;
struct RoSAPindication *roi;
{
    return RoSelectMask (sd, mask, nfds, roi);
}


/* bind underlying service */

int	RoSetService (sd, bfunc, roi)
int	sd;
IFP	bfunc;
struct RoSAPindication *roi;
{
    return RoSetService (sd, bfunc, roi);
}


/* modify underyling service */

int	RoSetThorn (sd, roi)
int	sd;
struct RoSAPindication *roi;
{
    return RoSetThorn (sd, roi);
}


/* return RoSAP error code in string form */

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

/* 
 * $Header: /xtel/isode/isode/rtsap/RCS/llib-lrtsap,v 9.0 1992/06/16 12:37:45 isode Rel $
 *
 *
 * $Log: llib-lrtsap,v $
 * Revision 9.0  1992/06/16  12:37:45  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 "rtsap.h"

/*    RTSE primitives */

/* RT-OPEN.INDICATION */

int	RtInit_Aux (vecp, vec, rts, rti, oid)
int	vecp;
char  **vec;
struct RtSAPstart *rts;
struct RtSAPindication *rti;
OID	oid;
{
    return RtInit_Aux (vecp, vec, rts, rti, oid);
}

/* RT-OPEN.RESPONSE */

int	RtOpenResponse (sd, status, context, respondtitle, respondaddr,
	ctxlist, defctxresult, data, rti)
int	sd,
	status;
OID	context;
AEI	respondtitle;
struct PSAPaddr *respondaddr;
struct PSAPctxlist *ctxlist;
int	defctxresult;
PE	data;
struct RtSAPindication *rti;
{
    return RtOpenResponse (sd, status, context, respondtitle, respondaddr,
	ctxlist, defctxresult, data, rti);
}

/* RT-OPEN.REQUEST */

int	RtOpenRequest2 (mode, turn, context, callingtitle, calledtitle,
	callingaddr, calledaddr, ctxlist, defctxname, data, qos, oid,
	rtc, rti)
int	mode,
	turn;
OID	context;
AEI	callingtitle,
	calledtitle;
struct PSAPaddr *callingaddr,
		*calledaddr;
struct PSAPctxlist *ctxlist;
OID	defctxname;
PE	data;
struct QOStype *qos;
OID	oid;
struct RtSAPconnect *rtc;
struct RtSAPindication *rti;
{
    return RtOpenRequest2 (mode, turn, context, callingtitle, calledtitle,
	callingaddr, calledaddr, ctxlist, defctxname, data, qos, oid,
	rtc, rti);
}

/* RT-CLOSE.REQUEST */

int	RtCloseRequest (sd, reason, data, acr, rti)
int	sd,
	reason;
PE	data;
struct AcSAPrelease *acr;
struct RtSAPindication *rti;
{
    return RtCloseRequest (sd, reason, data, acr, rti);
}

/* RT-CLOSE.RESPONSE */

int	RtCloseResponse (sd, reason, data, rti)
int	sd,
	reason;
PE	data;
struct RtSAPindication *rti;
{
    return RtCloseResponse (sd, reason, data, rti);
}

/* RT-U-ABORT.REQUEST */

int	RtUAbortRequest (sd, data, rti)
int	sd;
PE	data;
struct RtSAPindication *rti;
{
    return RtUAbortRequest (sd, data, rti);
}

/*    X.410 primitives */

/* SERVER only */

int	RtExec (ss, rti, arg1, arg2, hook, setperms)
struct SSAPstart *ss;
char   *arg1,
       *arg2;
struct RtSAPindication *rti;
IFP	hook,
	setperms;
{
    return RtExec (ss, rti, arg1, arg2, hook, setperms);
}

/* .. */

int	RtBInit (vecp, vec, rts, rti)
int	vecp;
char  **vec;
struct RtSAPstart *rts;
struct RtSAPindication *rti;
{
    return RtBInit (vecp, vec, rts, rti);
}

/* RT-BEGIN.RESPONSE (X.410 OPEN.RESPONSE) */

int	RtBeginResponse (sd, status, data, rti)
int	sd;
int	status;
PE	data;
struct RtSAPindication *rti;
{
    return RtBeginResponse (sd, status, data, rti);
}

/* RT-BEGIN.REQUEST (X.410 OPEN.REQUEST) */

int	RtBeginRequest2 (called, calling, mode, turn, data, rtc, rti)
struct RtSAPaddr *called, *calling;
int	mode,
	turn;
PE	data;
struct RtSAPconnect *rtc;
struct RtSAPindication *rti;
{
    return RtBeginRequest2 (called, calling, mode, turn, data, rtc, rti);
}

/* RT-END.REQUEST (X.410 CLOSE.REQUEST) */

int	RtEndRequest (sd, rti)
int	sd;
struct RtSAPindication *rti;
{
    return RtEndRequest (sd, rti);
}

/* RT-END.RESPONSE (X.410 CLOSE.RESPONSE) */

int	RtEndResponse (sd, rti)
int	sd;
struct RtSAPindication *rti;
{
    return RtEndResponse (sd, rti);
}

/* RT-TURN-PLEASE.REQUEST */

int	RtPTurnRequest (sd, priority, rti)
int	sd;
int	priority;
struct RtSAPindication *rti;
{
    return RtPTurnRequest (sd, priority, rti);
}

/* RT-TURN-GIVE.REQUEST */

int	RtGTurnRequest (sd, rti)
int	sd;
struct RtSAPindication *rti;
{
    return RtGTurnRequest (sd, rti);
}

/* RT-TRANSFER.REQUEST */

int	RtTransferRequest (sd, data, secs, rti)
int	sd;
PE	data;
int	secs;
struct RtSAPindication *rti;
{
    return RtTransferRequest (sd, data, secs, rti);
}

/* RT-WAIT.REQUEST (pseudo) */

int	RtWaitRequest (sd, secs, rti)
int	sd;
int	secs;
struct RtSAPindication *rti;
{
    return RtWaitRequest (sd, secs, rti);
}

/* define vectors for INDICATION events */

int	RtSetIndications (sd, indication, rti)
int	sd;
IFP	indication;
struct RtSAPindication *rti;
{
    return RtSetIndications (sd, indication, rti);
}

/* map association descriptors for select() */

int	RtSelectMask (sd, mask, nfds, rti)
int	sd;
fd_set *mask;
int    *nfds;
struct RtSAPindication *rti;
{
    return RtSelectMask (sd, mask, nfds, rti);
}

/* set downtrans upcall */

int	RtSetDownTrans (sd, fnx, rti)
int	sd;
IFP	fnx;
struct RtSAPindication *rti;
{
    return RtSetDownTrans (sd, fnx, rti);
}

/* set uptrans upcall */

int	RtSetUpTrans (sd, fnx, rti)
int	sd;
IFP	fnx;
struct RtSAPindication *rti;
{
    return RtSetUpTrans (sd, fnx, rti);
}

/* return RtSAP error code in string form */

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

/* 
 * $Header: /xtel/isode/isode/acsap/RCS/llib-lacsap,v 9.0 1992/06/16 12:05:59 isode Rel $
 *
 *
 * $Log: llib-lacsap,v $
 * Revision 9.0  1992/06/16  12:05:59  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 "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, context, interactive, userdn,
		  password)
char   *designator,
       *qualifier,
       *context,
       *userdn,
       *password;
int     interactive;
{
    return _str2aei (designator, qualifier, context, interactive, userdn,
		     password);
}


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);
}


/* "user-friendly" name service */

set_lookup_dase (flag)
char	flag;
{
	set_lookup_dase (flag);
}



/* 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-lpsap2 - lint library for -lpsap2 */

/* 
 * $Header: /xtel/isode/isode/psap2/RCS/llib-lpsap2,v 9.0 1992/06/16 12:29:42 isode Rel $
 *
 *
 * $Log: llib-lpsap2,v $
 * Revision 9.0  1992/06/16  12:29:42  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 "psap2.h"

/*  */

/* SERVER only */

int	PExec (ss, pi, arg1, arg2, hook, setperms)
struct SSAPstart *ss;
struct PSAPindication *pi;
char   *arg1,
       *arg2;
IFP	hook,
	setperms;
{
    return PExec (ss, pi, arg1, arg2, hook, setperms);
}


/* P-CONNECT.INDICATION */

int	PInit (vecp, vec, ps, pi)
int	vecp;
char  **vec;
struct PSAPstart *ps;
struct PSAPindication *pi;
{
    return PInit (vecp, vec, ps, pi);
}


/* P-CONNECT.RESPONSE */

int	PConnResponse (sd, status, responding, ctxlist, defctxresult,
	prequirements, srequirements, isn, settings, ref, data, ndata, pi)
int	sd;
struct PSAPaddr *responding;
int	status,
	prequirements,
	srequirements,
	settings,
	ndata;
long	isn;
struct PSAPctxlist *ctxlist;
int	defctxresult;
struct SSAPref *ref;
PE     *data;
struct PSAPindication *pi;
{
    return PConnResponse (sd, status, responding, ctxlist, defctxresult,
		prequirements, srequirements, isn, settings, ref,
		data, ndata, pi);
}


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

int	PAsynConnRequest (calling, called, ctxlist, defctxname, prequirements,
	srequirements, isn, settings, ref, data, ndata, qos, pc, pi, async)
struct PSAPaddr *calling,
		*called;
int	prequirements,
	srequirements,
	settings,
	ndata,
	async;
long	isn;
struct PSAPctxlist *ctxlist;
OID	defctxname;
struct SSAPref *ref;
PE    *data;
struct QOStype *qos;
struct PSAPconnect *pc;
struct PSAPindication *pi;
{
    return PAsynConnRequest (calling, called, ctxlist, defctxname,
		prequirements, srequirements, isn, settings, ref, data,
		ndata, qos, pc, pi, async);
}


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

int	PAsynRetryRequest (sd, pc, pi)
int	sd;
struct PSAPconnect *pc;
struct PSAPindication *pi;
{
    return PAsynRetryRequest (sd, pc, pi);
}


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

int	PAsynNextRequest (sd, pc, pi)
int	sd;
struct PSAPconnect *pc;
struct PSAPindication *pi;
{
    return PAsynNextRequest (sd, pc, pi);
}


/* P-[*-]DATA.REQUEST */

int	PDataRequest (sd, data, ndata, pi)
int	sd;
PE     *data;
int	ndata;
struct PSAPindication *pi;
{
    return PDataRequest (sd, data, ndata, pi);
}


int	PDataRequestAux (sd, data, ndata, pi, dtype, sfunc, stype, text, ppdu)
int	sd;
PE     *data;
int	ndata,
	ppdu;
struct PSAPindication *pi;
char   *dtype,
       *stype,
       *text;
IFP	sfunc;
{
    return PDataRequestAux (sd, data, ndata, pi, dtype, sfunc, stype, text,
			    ppdu);
}


/* P-READ.REQUEST (pseudo) */

int	PReadRequest (sd, px, secs, pi)
int	sd;
struct PSAPdata *px;
int	secs;
struct PSAPindication *pi;
{
    return PReadRequest (sd, px, secs, pi);
}


/* P-TOKEN-GIVE.REQUEST */

int	PGTokenRequest (sd, tokens, pi)
int	sd;
int	tokens;
struct PSAPindication *pi;
{
    return PGTokenRequest (sd, tokens, pi);
}


/* P-TOKEN-PLEASE.REQUEST */

int	PPTokenRequest (sd, tokens, data, ndata, pi)
int	sd;
int	tokens,
	ndata;
PE     *data;
struct PSAPindication *pi;
{
    return PPTokenRequest (sd, tokens, data, ndata, pi);
}


/* P-CONTROL-GIVE.REQUEST */

int	PGControlRequest (sd, pi)
int	sd;
struct PSAPindication *pi;
{
    return PGControlRequest (sd, pi);
}


/* P-{MAJOR-SYNC,ACTIVITY-END}.REQUEST */

int	PMajSyncRequestAux (sd, ssn, data, ndata, pi, dtype, sfunc, stype)
int	sd;
long   *ssn;
int     ndata;
PE     *data;
struct PSAPindication *pi;
char   *dtype,
       *stype;
IFP	sfunc;
{
    return PMajSyncRequestAux (sd, ssn, data, ndata, pi, dtype, sfunc, stype);
}


/* P-{MAJOR-SYNC,ACTIVITY-END}.RESPONSE */

int	PMajSyncResponseAux (sd, data, ndata, pi, dtype, sfunc, stype)
int	sd;
int	ndata;
PE     *data;
struct PSAPindication *pi;
char   *dtype,
       *stype;
IFP	sfunc;
{
    return PMajSyncResponseAux (sd, data, ndata, pi, dtype, sfunc, stype);
}


/* P-MINOR-SYNC.REQUEST */

int	PMinSyncRequest (sd, type, ssn, data, ndata, pi)
int	sd;
int	type,
	ndata;
long   *ssn;
PE     *data;
struct PSAPindication *pi;
{
    return PMinSyncRequest (sd, type, ssn, data, ndata, pi);
}


/* P-MINOR-SYNC.RESPONSE */

int	PMinSyncResponse (sd, ssn, data, ndata, pi)
int	sd;
int     ndata;
long    ssn;
PE     *data;
struct PSAPindication *pi;
{
    return PMinSyncResponse (sd, ssn, data, ndata, pi);
}


/* P-RESYNCHRONIZE.REQUEST */

int	PReSyncRequest (sd, type, ssn, settings, data, ndata, pi)
int	sd;
int	type,
	settings,
	ndata;
long	ssn;
PE     *data;
struct PSAPindication *pi;
{
    return PReSyncRequest (sd, type, ssn, settings, data, ndata, pi);
}


/* P-RESYNCHRONIZE.RESPONSE */

int	PReSyncResponse (sd, ssn, settings, data, ndata, pi)
int	sd;
int	settings,
	ndata;
long	ssn;
PE     *data;
struct PSAPindication *pi;
{
    return PReSyncResponse (sd, ssn, settings, data, ndata, pi);
}


/* P-ACTIVITY-START.REQUEST */

int	PActStartRequest (sd, id, data, ndata, pi)
int	sd;
struct SSAPactid *id;
int	ndata;
PE     *data;
struct PSAPindication *pi;
{
    return PActStartRequest (sd, id, data, ndata, pi);
}


/* P-ACTIVITY-RESUME.REQUEST */

int	PActResumeRequest (sd, id, oid, ssn, ref, data, ndata, pi)
int	sd;
struct SSAPactid *id,
		 *oid;
long	ssn;
int	ndata;
struct SSAPref *ref;
PE     *data;
struct PSAPindication *pi;
{
    return PActResumeRequest (sd, id, oid, ssn, ref, data, ndata, pi);
}


/* P-ACTIVITY-{INTERRUPT,DISCARD}.REQUEST */

int	PActIntrRequestAux (sd, reason, pi, sfunc, stype)
int	sd;
int	reason;
struct PSAPindication *pi;
IFP	sfunc;
char   *stype;
{
    return PActIntrRequestAux (sd, reason, pi, sfunc, stype);
}


/* P-ACTIVITY-{INTERRUPT,DISCARD}.RESPONSE */

int	PActIntrResponseAux (sd, pi, sfunc, stype)
int	sd;
struct PSAPindication *pi;
IFP	sfunc;
char   *stype;
{
    return PActIntrResponseAux (sd, pi, sfunc, stype);
}


/* P-U-ABORT.REQUEST */

int	PUAbortRequest (sd, data, ndata, pi)
int	sd;
PE     *data;
int	ndata;
struct PSAPindication *pi;
{
    return PUAbortRequest (sd, data, ndata, pi);
}


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

int	PUReportRequest (sd, reason, data, ndata, pi)
int	sd;
int	reason,
	ndata;
PE     *data;
struct PSAPindication *pi;
{
    return PUReportRequest (sd, reason, data, ndata, pi);
}


/* P-RELEASE.REQUEST */

int	PRelRequest (sd, data, ndata, secs, pr, pi)
int	sd;
PE     *data;
int	ndata;
int	secs;
struct PSAPrelease *pr;
struct PSAPindication *pi;
{
    return PRelRequest (sd, data, ndata, secs, pr, pi);
}


/* P-RELEASE-Retry.REQUEST (pseudo) */

int	PRelRetryRequest (sd, secs, pr, pi)
int	sd;
int	secs;
struct PSAPrelease *pr;
struct PSAPindication *pi;
{
    return PRelRetryRequest (sd, secs, pr, pi);
}


/* P-RELEASE.RESPONSE */

int	PRelResponse (sd, status, data, ndata, pi)
int	sd;
int	status;
PE     *data;
int	ndata;
struct PSAPindication *pi;
{
    return PRelResponse (sd, status, data, ndata, pi);
}


/* define vectors for INDICATION events */

int	PSetIndications (sd, data, tokens, sync, activity, report, finish,
		abort, pi)
int	sd;
IFP	data,
	tokens,
	sync,
	activity,
	report,
	finish,
	abort;
struct PSAPindication *pi;
{
    return PSetIndications (sd, data, tokens, sync, activity, report, finish,
		abort, pi);
}


/* map presentation descriptors for select() */

int	PSelectMask (sd, mask, nfds, pi)
int	sd;
fd_set *mask;
int    *nfds;
struct PSAPindication *pi;
{
    return PSelectMask (sd, mask, nfds, pi);
}


/* return PSAP error code in string form */

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

/* 
 * $Header: /xtel/isode/isode/psap/RCS/llib-lpsap,v 9.0 1992/06/16 12:25:44 isode Rel $
 *
 *
 * $Log: llib-lpsap,v $
 * Revision 9.0  1992/06/16  12:25:44  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 <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_aux (qb, class, id, in_line)
struct qbuf *qb;
PElementClass	class;
PElementID	id;
int	in_line;
{
    return qb2prim_aux (qb, class, id, in_line);
}

/*    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);
}

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

struct isobject  *getisobject () {
       return getisobject ();
}

struct isobject *getisobjectbyname (descriptor)
char *descriptor;
{
	return getisobjectbyname (descriptor);
}
struct isobject *getisobjectbyoid (oid)
OID	oid;
{
	return getisobjectbyoid (oid);
}

int endisobject ()
{
}

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_addon (pe, last, new)
PE	pe, last, new;
{
	return set_addon(pe, last, new);
}

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_addon (pe, last, new)
PE      pe,
        last,
        new;
{
	return seq_addon (pe, last, new);
}


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, in_line)
PS	ps;
IFP	io;
PElementData data;
PElementLen n;
int	in_line;
{
    return ps_io (ps, io, data, n, in_line);
}


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


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


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, in_line)
PS	ps;
char   *cp;
int	cc,
	in_line;
{
    return str_setup (ps, cp, cc, in_line);
}


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


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

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);
}

int     ts_read (fd, q)
int     fd;
struct qbuf **q;
{
    return ts_read(fd, q);
}

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

/*    PStream <-> PElement */

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


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_aux (oid, quoted)
OID	oid;
int	quoted;
{
    return oid2ode_aux (oid, quoted);
}

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

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

/*  */

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


PE	qbuf2pe_f (result)
int    *result;
{
    return qbuf2pe_f (result);
}


#undef	qbuf2pe
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-lpepsy (which doesn't exist!) */

/* VARARGS2 */

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

/* VARARGS1 */
myyerror (fmt)
char   *fmt;
{
    myyerror (fmt);
}

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


/* VARARGS1 */

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

vstring (pe)
PE pe;
{
	(void) vstring (pe);
}

vpush() 
{
}

vpop ()
{
}
#undef	vunknown
vunknown (pe)
PE	pe;
{
    vunknown (pe);
}


vsetfp (fp, s)
FILE   *fp;
char   *s;
{
    vsetfp (fp, 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 ()
{}


vpushquipu (ps)
PS	ps;
{
    vpushquipu (ps);
}

vpopquipu ()
{}


_vpdu (lp, fnx, pe, text, rw)
LLog   *lp;
IFP	fnx;
PE	pe;
char   *text;
int	rw;
{
    _vpdu (lp, fnx, pe, text, rw);
}


#include "pepsy.h"

int	enc_f (typ, mod, pe, explicit, len, buf, parm)
int     typ;
modtyp *mod;
PE     *pe;
int     explicit;
int     len;
char   *buf;
char	*parm;
{
    return enc_f (typ, mod, pe, explicit, len, buf, parm);
}


int	dec_f (typ, mod, pe, explicit, len, buf, parm)
int     typ;
modtyp	*mod;
PE      pe;
int	explicit;
int	*len;
char	**buf;
char	**parm;
{
    return dec_f (typ, mod, pe, explicit, len, buf, parm);
}


int	fre_obj (parm, p, mod, dofree)
modtyp *mod;
tpe    *p;
char   *parm;
{
    return fre_obj (parm, p, mod, dofree);
}


#undef	pvpdu
pvpdu (lp, ind, mod, pe, text, rw)
LLog   *lp;
int	ind;
modtyp *mod;
PE	pe;
char   *text;
int	rw;
{
    pvpdu (lp, ind, mod, pe, text, rw);
}

_pvpdu (lp, pe, text, rw)
LLog   *lp;
PE	pe;
char   *text;
int	rw;
{
    _pvpdu (lp, pe, text, rw);
}


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

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);
}

/* external variables */
PE	pe_list;
char	PY_pepy[];
int	pe_maxclass;
int	pe_maxuniv;
int	pe_maxappl;
char	**pe_applist;
int	ps_len_strategy;
char	*pe_classlist[];
int	pe_maxpriv;
char	**pe_privlist;
char	*pepy_strings[];
int	Len;
char	*Qcp, *Ecp;
int	Byteno;
int	Qbrefs;
struct qbuf    *Hqb;
struct qbuf    *Fqb;
struct qbuf    *Qb;
int  pe_allocs;
char	*psapversion;
int  pe_frees;
int  pe_most;
/* llib-lssap - lint library for -lssap */

/* 
 * $Header: /xtel/isode/isode/ssap/RCS/llib-lssap,v 9.0 1992/06/16 12:39:41 isode Rel $
 *
 *
 * $Log: llib-lssap,v $
 * Revision 9.0  1992/06/16  12:39:41  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 "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-SEND.REQUEST (segmented) */

int	SSendRequest (sd, data, cc, begin, end, si)
int	sd;
char   *data;
int	cc,
	begin,
	end;
struct SSAPindication  *si;
{
    return SSendRequest (sd, data, cc, begin, end, 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: /xtel/isode/isode/tsap/RCS/llib-ltsap,v 9.0 1992/06/16 12:40:39 isode Rel $
 *
 *
 * $Log: llib-ltsap,v $
 * Revision 9.0  1992/06/16  12:40: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 "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-ldirent - lint library for -ldirent */

/* 
 * $Header: /xtel/isode/isode/dirent/RCS/llib-ldirent,v 9.0 1992/06/16 12:12:04 isode Rel $
 *
 *
 * $Log: llib-ldirent,v $
 * Revision 9.0  1992/06/16  12:12:04  isode
 * Release 8.0
 *
 */

/*
 * This package was generously supplied by Doug Gwyn.  It is a public domain
 * implementation of the SVR3 directory access routines.
 *
 * I have slightly edited the package to produce a stand-alone library
 * (normally it updates libc.a).  The reason for this, is that the package
 * is used primarily for ISODE's ftam responder, and it's too much heartburn
 * to ask someone to reload libc.a just for that (sorry, doug!)
 *
 * I've also prepended a "_" to the names to avoid any conflicts with routines
 * which might already be installed (especially for lint)
 *
 */


/* LINTLIBRARY */

#include "general.h"
#include "manifest.h"
#include "usr.dirent.h"

/*  */

#ifndef	GETDENTS
/* open a directory stream */

DIR    *opendir (name)
char   *name;
{
    return opendir (name);
}


/* read next entry from a directory stream */

struct dirent *readdir (dp)
DIR    *dp;
{
    return readdir (dp);
}


/* report directory stream position */

off_t	telldir (dp)
DIR    *dp;
{
    return telldir (dp);
}


/* reposition a directory stream */

void	seekdir (dp, loc)
DIR    *dp;
off_t	loc;
{
    seekdir (dp, loc);
}


/* rewind a directory stream */

void	rewinddir (dp)
DIR    *dp;
{
    rewinddir (dp);
}


/* close a directory stream */

int	closedir (dp)
DIR    *dp;
{
    return closedir (dp);
}


/* get directory entries in a FS independent format */

int	getdents (fd, buffer, n)
int	fd;
char   *buffer;
unsigned int n;
{
    return getdents (fd, buffer, n);
}

#endif

/* get current working directory name */

char   *getcwd (buffer, n)
char   *buffer;
int	n;
{
    return getcwd (buffer, n);
}
/* llib-licompat - lint library for -licompat */

/* 
 * $Header: /xtel/isode/isode/compat/RCS/llib-lcompat,v 9.0 1992/06/16 12:07:00 isode Rel $
 *
 *
 * $Log: llib-lcompat,v $
 * Revision 9.0  1992/06/16  12:07:00  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 <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 char2bcd (s, n, d)
char *s;
int  n;
u_char *d;
{
	return char2bcd (s,n,d);
}

int     bcd2char (s, d, len)
u_char *s;
char  *d;
int     len;
{
	bcd2char (s, d, len);
}

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);
}


int	ll_defmhdr (bufferp, headerp, dheaderp)
char   *bufferp,
       *headerp,
       *dheaderp;
{
    return ll_defmhdr (bufferp, headerp, dheaderp);
}


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_check_fd (fd, fnx, data)
int	fd;
IFP	fnx;
caddr_t data;
{
    return set_check_fd (fd, fnx, data);
}


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	explode (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, docomma)
char   *s,
      **vec,
    	brk;
int	nmask,
       *mask,
	docomma;
{
    return str2vecX (s, vec, nmask, mask, brk, docomma);
}


int	chkpassword (usrname, pwpass, usrpass)
char   *usrname;
char   *pwpass;
char   *usrpass;
{
    return chkpassword (usrname, pwpass, usrpass);
}


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);
}


VFP	set_smalloc_handler (fnx)
VFP fnx;
{
	return set_smalloc_handler (fnx);
}

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 (myname)
char   *myname;
{
    isodexport (myname);
}


/*    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);
}


int	norm2na (p, len, na)
char   *p;
int	len;
struct NSAPaddr *na;
{
    return norm2na (p, len, 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