Return to llib-lpsap2 CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / psap2

Annotation of 43BSDReno/contrib/isode-beta/psap2/llib-lpsap2, revision 1.1

1.1     ! root        1: /* llib-lpsap2 - lint library for -lpsap2 */
        !             2: 
        !             3: /* 
        !             4:  * $Header: /f/osi/psap2/RCS/llib-lpsap2,v 7.0 89/11/23 22:14:13 mrose Rel $
        !             5:  *
        !             6:  *
        !             7:  * $Log:       llib-lpsap2,v $
        !             8:  * Revision 7.0  89/11/23  22:14:13  mrose
        !             9:  * Release 6.0
        !            10:  * 
        !            11:  */
        !            12: 
        !            13: /*
        !            14:  *                               NOTICE
        !            15:  *
        !            16:  *    Acquisition, use, and distribution of this module and related
        !            17:  *    materials are subject to the restrictions of a license agreement.
        !            18:  *    Consult the Preface in the User's Manual for the full terms of
        !            19:  *    this agreement.
        !            20:  *
        !            21:  */
        !            22: 
        !            23: 
        !            24: /* LINTLIBRARY */
        !            25: 
        !            26: #include "psap2.h"
        !            27: 
        !            28: /*  */
        !            29: 
        !            30: /* SERVER only */
        !            31: 
        !            32: int    PExec (ss, pi, arg1, arg2, hook, setperms)
        !            33: struct SSAPstart *ss;
        !            34: struct PSAPindication *pi;
        !            35: char   *arg1,
        !            36:        *arg2;
        !            37: IFP    hook,
        !            38:        setperms;
        !            39: {
        !            40:     return PExec (ss, pi, arg1, arg2, hook, setperms);
        !            41: }
        !            42: 
        !            43: 
        !            44: /* P-CONNECT.INDICATION */
        !            45: 
        !            46: int    PInit (vecp, vec, ps, pi)
        !            47: int    vecp;
        !            48: char  **vec;
        !            49: struct PSAPstart *ps;
        !            50: struct PSAPindication *pi;
        !            51: {
        !            52:     return PInit (vecp, vec, ps, pi);
        !            53: }
        !            54: 
        !            55: 
        !            56: /* P-CONNECT.RESPONSE */
        !            57: 
        !            58: int    PConnResponse (sd, status, responding, ctxlist, defctxresult,
        !            59:        prequirements, srequirements, isn, settings, ref, data, ndata, pi)
        !            60: int    sd;
        !            61: struct PSAPaddr *responding;
        !            62: int    status,
        !            63:        prequirements,
        !            64:        srequirements,
        !            65:        settings,
        !            66:        ndata;
        !            67: long   isn;
        !            68: struct PSAPctxlist *ctxlist;
        !            69: int    defctxresult;
        !            70: struct SSAPref *ref;
        !            71: PE     *data;
        !            72: struct PSAPindication *pi;
        !            73: {
        !            74:     return PConnResponse (sd, status, responding, ctxlist, defctxresult,
        !            75:                prequirements, srequirements, isn, settings, ref,
        !            76:                data, ndata, pi);
        !            77: }
        !            78: 
        !            79: 
        !            80: /* P-(ASYN-)CONNECT.REQUEST */
        !            81: 
        !            82: int    PAsynConnRequest (calling, called, ctxlist, defctxname, prequirements,
        !            83:        srequirements, isn, settings, ref, data, ndata, qos, pc, pi, async)
        !            84: struct PSAPaddr *calling,
        !            85:                *called;
        !            86: int    prequirements,
        !            87:        srequirements,
        !            88:        settings,
        !            89:        ndata,
        !            90:        async;
        !            91: long   isn;
        !            92: struct PSAPctxlist *ctxlist;
        !            93: OID    defctxname;
        !            94: struct SSAPref *ref;
        !            95: PE    *data;
        !            96: struct QOStype *qos;
        !            97: struct PSAPconnect *pc;
        !            98: struct PSAPindication *pi;
        !            99: {
        !           100:     return PAsynConnRequest (calling, called, ctxlist, defctxname,
        !           101:                prequirements, srequirements, isn, settings, ref, data,
        !           102:                ndata, qos, pc, pi, async);
        !           103: }
        !           104: 
        !           105: 
        !           106: /* P-ASYN-RETRY.REQUEST (pseudo) */
        !           107: 
        !           108: int    PAsynRetryRequest (sd, pc, pi)
        !           109: int    sd;
        !           110: struct PSAPconnect *pc;
        !           111: struct PSAPindication *pi;
        !           112: {
        !           113:     return PAsynRetryRequest (sd, pc, pi);
        !           114: }
        !           115: 
        !           116: 
        !           117: /* P-ASYN-NEXT.REQUEST (pseudo) */
        !           118: 
        !           119: int    PAsynNextRequest (sd, pc, pi)
        !           120: int    sd;
        !           121: struct PSAPconnect *pc;
        !           122: struct PSAPindication *pi;
        !           123: {
        !           124:     return PAsynNextRequest (sd, pc, pi);
        !           125: }
        !           126: 
        !           127: 
        !           128: /* P-[*-]DATA.REQUEST */
        !           129: 
        !           130: int    PDataRequest (sd, data, ndata, pi)
        !           131: int    sd;
        !           132: PE     *data;
        !           133: int    ndata;
        !           134: struct PSAPindication *pi;
        !           135: {
        !           136:     return PDataRequest (sd, data, ndata, pi);
        !           137: }
        !           138: 
        !           139: 
        !           140: int    PDataRequestAux (sd, data, ndata, pi, dtype, sfunc, stype, text, ppdu)
        !           141: int    sd;
        !           142: PE     *data;
        !           143: int    ndata,
        !           144:        ppdu;
        !           145: struct PSAPindication *pi;
        !           146: char   *dtype,
        !           147:        *stype,
        !           148:        *text;
        !           149: IFP    sfunc;
        !           150: {
        !           151:     return PDataRequestAux (sd, data, ndata, pi, dtype, sfunc, stype, text,
        !           152:                            ppdu);
        !           153: }
        !           154: 
        !           155: 
        !           156: /* P-READ.REQUEST (pseudo) */
        !           157: 
        !           158: int    PReadRequest (sd, px, secs, pi)
        !           159: int    sd;
        !           160: struct PSAPdata *px;
        !           161: int    secs;
        !           162: struct PSAPindication *pi;
        !           163: {
        !           164:     return PReadRequest (sd, px, secs, pi);
        !           165: }
        !           166: 
        !           167: 
        !           168: /* P-TOKEN-GIVE.REQUEST */
        !           169: 
        !           170: int    PGTokenRequest (sd, tokens, pi)
        !           171: int    sd;
        !           172: int    tokens;
        !           173: struct PSAPindication *pi;
        !           174: {
        !           175:     return PGTokenRequest (sd, tokens, pi);
        !           176: }
        !           177: 
        !           178: 
        !           179: /* P-TOKEN-PLEASE.REQUEST */
        !           180: 
        !           181: int    PPTokenRequest (sd, tokens, data, ndata, pi)
        !           182: int    sd;
        !           183: int    tokens,
        !           184:        ndata;
        !           185: PE     *data;
        !           186: struct PSAPindication *pi;
        !           187: {
        !           188:     return PPTokenRequest (sd, tokens, data, ndata, pi);
        !           189: }
        !           190: 
        !           191: 
        !           192: /* P-CONTROL-GIVE.REQUEST */
        !           193: 
        !           194: int    PGControlRequest (sd, pi)
        !           195: int    sd;
        !           196: struct PSAPindication *pi;
        !           197: {
        !           198:     return PGControlRequest (sd, pi);
        !           199: }
        !           200: 
        !           201: 
        !           202: /* P-{MAJOR-SYNC,ACTIVITY-END}.REQUEST */
        !           203: 
        !           204: int    PMajSyncRequestAux (sd, ssn, data, ndata, pi, dtype, sfunc, stype)
        !           205: int    sd;
        !           206: long   *ssn;
        !           207: int     ndata;
        !           208: PE     *data;
        !           209: struct PSAPindication *pi;
        !           210: char   *dtype,
        !           211:        *stype;
        !           212: IFP    sfunc;
        !           213: {
        !           214:     return PMajSyncRequestAux (sd, ssn, data, ndata, pi, dtype, sfunc, stype);
        !           215: }
        !           216: 
        !           217: 
        !           218: /* P-{MAJOR-SYNC,ACTIVITY-END}.RESPONSE */
        !           219: 
        !           220: int    PMajSyncResponseAux (sd, data, ndata, pi, dtype, sfunc, stype)
        !           221: int    sd;
        !           222: int    ndata;
        !           223: PE     *data;
        !           224: struct PSAPindication *pi;
        !           225: char   *dtype,
        !           226:        *stype;
        !           227: IFP    sfunc;
        !           228: {
        !           229:     return PMajSyncResponseAux (sd, data, ndata, pi, dtype, sfunc, stype);
        !           230: }
        !           231: 
        !           232: 
        !           233: /* P-MINOR-SYNC.REQUEST */
        !           234: 
        !           235: int    PMinSyncRequest (sd, type, ssn, data, ndata, pi)
        !           236: int    sd;
        !           237: int    type,
        !           238:        ndata;
        !           239: long   *ssn;
        !           240: PE     *data;
        !           241: struct PSAPindication *pi;
        !           242: {
        !           243:     return PMinSyncRequest (sd, type, ssn, data, ndata, pi);
        !           244: }
        !           245: 
        !           246: 
        !           247: /* P-MINOR-SYNC.RESPONSE */
        !           248: 
        !           249: int    PMinSyncResponse (sd, ssn, data, ndata, pi)
        !           250: int    sd;
        !           251: int     ndata;
        !           252: long    ssn;
        !           253: PE     *data;
        !           254: struct PSAPindication *pi;
        !           255: {
        !           256:     return PMinSyncResponse (sd, ssn, data, ndata, pi);
        !           257: }
        !           258: 
        !           259: 
        !           260: /* P-RESYNCHRONIZE.REQUEST */
        !           261: 
        !           262: int    PReSyncRequest (sd, type, ssn, settings, data, ndata, pi)
        !           263: int    sd;
        !           264: int    type,
        !           265:        settings,
        !           266:        ndata;
        !           267: long   ssn;
        !           268: PE     *data;
        !           269: struct PSAPindication *pi;
        !           270: {
        !           271:     return PReSyncRequest (sd, type, ssn, settings, data, ndata, pi);
        !           272: }
        !           273: 
        !           274: 
        !           275: /* P-RESYNCHRONIZE.RESPONSE */
        !           276: 
        !           277: int    PReSyncResponse (sd, ssn, settings, data, ndata, pi)
        !           278: int    sd;
        !           279: int    settings,
        !           280:        ndata;
        !           281: long   ssn;
        !           282: PE     *data;
        !           283: struct PSAPindication *pi;
        !           284: {
        !           285:     return PReSyncResponse (sd, ssn, settings, data, ndata, pi);
        !           286: }
        !           287: 
        !           288: 
        !           289: /* P-ACTIVITY-START.REQUEST */
        !           290: 
        !           291: int    PActStartRequest (sd, id, data, ndata, pi)
        !           292: int    sd;
        !           293: struct SSAPactid *id;
        !           294: int    ndata;
        !           295: PE     *data;
        !           296: struct PSAPindication *pi;
        !           297: {
        !           298:     return PActStartRequest (sd, id, data, ndata, pi);
        !           299: }
        !           300: 
        !           301: 
        !           302: /* P-ACTIVITY-RESUME.REQUEST */
        !           303: 
        !           304: int    PActResumeRequest (sd, id, oid, ssn, ref, data, ndata, pi)
        !           305: int    sd;
        !           306: struct SSAPactid *id,
        !           307:                 *oid;
        !           308: long   ssn;
        !           309: int    ndata;
        !           310: struct SSAPref *ref;
        !           311: PE     *data;
        !           312: struct PSAPindication *pi;
        !           313: {
        !           314:     return PActResumeRequest (sd, id, oid, ssn, ref, data, ndata, pi);
        !           315: }
        !           316: 
        !           317: 
        !           318: /* P-ACTIVITY-{INTERRUPT,DISCARD}.REQUEST */
        !           319: 
        !           320: int    PActIntrRequestAux (sd, reason, pi, sfunc, stype)
        !           321: int    sd;
        !           322: int    reason;
        !           323: struct PSAPindication *pi;
        !           324: IFP    sfunc;
        !           325: char   *stype;
        !           326: {
        !           327:     return PActIntrRequestAux (sd, reason, pi, sfunc, stype);
        !           328: }
        !           329: 
        !           330: 
        !           331: /* P-ACTIVITY-{INTERRUPT,DISCARD}.RESPONSE */
        !           332: 
        !           333: int    PActIntrResponseAux (sd, pi, sfunc, stype)
        !           334: int    sd;
        !           335: struct PSAPindication *pi;
        !           336: IFP    sfunc;
        !           337: char   *stype;
        !           338: {
        !           339:     return PActIntrResponseAux (sd, pi, sfunc, stype);
        !           340: }
        !           341: 
        !           342: 
        !           343: /* P-U-ABORT.REQUEST */
        !           344: 
        !           345: int    PUAbortRequest (sd, data, ndata, pi)
        !           346: int    sd;
        !           347: PE     *data;
        !           348: int    ndata;
        !           349: struct PSAPindication *pi;
        !           350: {
        !           351:     return PUAbortRequest (sd, data, ndata, pi);
        !           352: }
        !           353: 
        !           354: 
        !           355: /* P-U-EXCEPTION-REPORT.REQUEST */
        !           356: 
        !           357: int    PUReportRequest (sd, reason, data, ndata, pi)
        !           358: int    sd;
        !           359: int    reason,
        !           360:        ndata;
        !           361: PE     *data;
        !           362: struct PSAPindication *pi;
        !           363: {
        !           364:     return PUReportRequest (sd, reason, data, ndata, pi);
        !           365: }
        !           366: 
        !           367: 
        !           368: /* P-RELEASE.REQUEST */
        !           369: 
        !           370: int    PRelRequest (sd, data, ndata, secs, pr, pi)
        !           371: int    sd;
        !           372: PE     *data;
        !           373: int    ndata;
        !           374: int    secs;
        !           375: struct PSAPrelease *pr;
        !           376: struct PSAPindication *pi;
        !           377: {
        !           378:     return PRelRequest (sd, data, ndata, secs, pr, pi);
        !           379: }
        !           380: 
        !           381: 
        !           382: /* P-RELEASE-Retry.REQUEST (pseudo) */
        !           383: 
        !           384: int    PRelRetryRequest (sd, secs, pr, pi)
        !           385: int    sd;
        !           386: int    secs;
        !           387: struct PSAPrelease *pr;
        !           388: struct PSAPindication *pi;
        !           389: {
        !           390:     return PRelRetryRequest (sd, secs, pr, pi);
        !           391: }
        !           392: 
        !           393: 
        !           394: /* P-RELEASE.RESPONSE */
        !           395: 
        !           396: int    PRelResponse (sd, status, data, ndata, pi)
        !           397: int    sd;
        !           398: int    status;
        !           399: PE     *data;
        !           400: int    ndata;
        !           401: struct PSAPindication *pi;
        !           402: {
        !           403:     return PRelResponse (sd, status, data, ndata, pi);
        !           404: }
        !           405: 
        !           406: 
        !           407: /* define vectors for INDICATION events */
        !           408: 
        !           409: int    PSetIndications (sd, data, tokens, sync, activity, report, finish,
        !           410:                abort, pi)
        !           411: int    sd;
        !           412: IFP    data,
        !           413:        tokens,
        !           414:        sync,
        !           415:        activity,
        !           416:        report,
        !           417:        finish,
        !           418:        abort;
        !           419: struct PSAPindication *pi;
        !           420: {
        !           421:     return PSetIndications (sd, data, tokens, sync, activity, report, finish,
        !           422:                abort, pi);
        !           423: }
        !           424: 
        !           425: 
        !           426: /* map presentation descriptors for select() */
        !           427: 
        !           428: int    PSelectMask (sd, mask, nfds, pi)
        !           429: int    sd;
        !           430: fd_set *mask;
        !           431: int    *nfds;
        !           432: struct PSAPindication *pi;
        !           433: {
        !           434:     return PSelectMask (sd, mask, nfds, pi);
        !           435: }
        !           436: 
        !           437: 
        !           438: /* return PSAP error code in string form */
        !           439: 
        !           440: char    *PErrString (c)
        !           441: int    c;
        !           442: {
        !           443:     return PErrString (c);
        !           444: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.