usr/othersrc/contrib/isode/tsap/llib-ltsap

/* llib-ltsap - lint library for -ltsap */

/*
 * $Header: /f/osi/tsap/RCS/llib-ltsap,v 7.2 91/02/22 09:47:07 mrose Interim $
 *
 *
 * $Log:        llib-ltsap,v $
 * Revision 7.2  91/02/22  09:47:07  mrose
 * Interim 6.8
 *
 * 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"

/* \f */

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