BSD 4_3_Net_2 development

[unix-history] / usr / src / contrib / isode / psap2-lpp / llib-lpsap2-lpp

/* llib-lpsap2-lpp - lint library for -lpsap2-lpp */

/* 
* $Header: /f/osi/psap2-lpp/RCS/llib-lpsap2-lpp,v 7.1 91/02/22 09:37:59 mrose Interim $
*
* Contributed by The Wollongong Group, Inc.
*
*
* $Log:        llib-lpsap2-lpp,v $
* Revision 7.1  91/02/22  09:37:59  mrose
* Interim 6.8
* 
* Revision 7.0  89/11/23  22:15:48  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 "psap2.h"

/* \f */

/* 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, multiple, ctxlist, defctxresult,
       prequirements, srequirements, isn, settings, ref, data, ndata, pi)
int     sd;
struct PSAPaddr *responding;
int     status,
       multiple,
       prequirements,
       srequirements,
       settings,
       ndata;
long    isn;
struct PSAPctxlist *ctxlist;
int     defctxresult;
struct SSAPref *ref;
PE     *data;
struct PSAPindication *pi;
{
   return PConnResponse (sd, status, responding, multiple, ctxlist,
               defctxresult, prequirements, srequirements, isn, settings, ref,
               data, ndata, pi);
}


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

int     PAsynConnRequest (calling, called, multiple, ctxlist, defctxname,
       prequirements, srequirements, isn, settings, ref, data, ndata, qos,
       pc, pi, async)
struct PSAPaddr *calling,
               *called;
int     multiple,
       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, multiple, 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);

}


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


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