Return to llib-lrtsap CVS log

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

Annotation of 43BSDReno/contrib/isode-beta/rtsap/llib-lrtsap, revision 1.1

1.1     ! root        1: /* llib-lrtsap - lint library for -lrtsap */
        !             2: 
        !             3: /* 
        !             4:  * $Header: /f/osi/rtsap/RCS/llib-lrtsap,v 7.2 90/07/27 08:47:34 mrose Exp $
        !             5:  *
        !             6:  *
        !             7:  * $Log:       llib-lrtsap,v $
        !             8:  * Revision 7.2  90/07/27  08:47:34  mrose
        !             9:  * update
        !            10:  * 
        !            11:  * Revision 7.1  90/05/08  08:55:16  mrose
        !            12:  * touch-up
        !            13:  * 
        !            14:  * Revision 7.0  89/11/23  22:22:16  mrose
        !            15:  * Release 6.0
        !            16:  * 
        !            17:  */
        !            18: 
        !            19: /*
        !            20:  *                               NOTICE
        !            21:  *
        !            22:  *    Acquisition, use, and distribution of this module and related
        !            23:  *    materials are subject to the restrictions of a license agreement.
        !            24:  *    Consult the Preface in the User's Manual for the full terms of
        !            25:  *    this agreement.
        !            26:  *
        !            27:  */
        !            28: 
        !            29: 
        !            30: /* LINTLIBRARY */
        !            31: 
        !            32: #include "rtsap.h"
        !            33: 
        !            34: /*    RTSE primitives */
        !            35: 
        !            36: /* RT-OPEN.INDICATION */
        !            37: 
        !            38: int    RtInit_Aux (vecp, vec, rts, rti, oid)
        !            39: int    vecp;
        !            40: char  **vec;
        !            41: struct RtSAPstart *rts;
        !            42: struct RtSAPindication *rti;
        !            43: OID    oid;
        !            44: {
        !            45:     return RtInit_Aux (vecp, vec, rts, rti, oid);
        !            46: }
        !            47: 
        !            48: /* RT-OPEN.RESPONSE */
        !            49: 
        !            50: int    RtOpenResponse (sd, status, context, respondtitle, respondaddr,
        !            51:        ctxlist, defctxresult, data, rti)
        !            52: int    sd,
        !            53:        status;
        !            54: OID    context;
        !            55: AEI    respondtitle;
        !            56: struct PSAPaddr *respondaddr;
        !            57: struct PSAPctxlist *ctxlist;
        !            58: int    defctxresult;
        !            59: PE     data;
        !            60: struct RtSAPindication *rti;
        !            61: {
        !            62:     return RtOpenResponse (sd, status, context, respondtitle, respondaddr,
        !            63:        ctxlist, defctxresult, data, rti);
        !            64: }
        !            65: 
        !            66: /* RT-OPEN.REQUEST */
        !            67: 
        !            68: int    RtOpenRequest2 (mode, turn, context, callingtitle, calledtitle,
        !            69:        callingaddr, calledaddr, ctxlist, defctxname, data, qos, oid,
        !            70:        rtc, rti)
        !            71: int    mode,
        !            72:        turn;
        !            73: OID    context;
        !            74: AEI    callingtitle,
        !            75:        calledtitle;
        !            76: struct PSAPaddr *callingaddr,
        !            77:                *calledaddr;
        !            78: struct PSAPctxlist *ctxlist;
        !            79: OID    defctxname;
        !            80: PE     data;
        !            81: struct QOStype *qos;
        !            82: OID    oid;
        !            83: struct RtSAPconnect *rtc;
        !            84: struct RtSAPindication *rti;
        !            85: {
        !            86:     return RtOpenRequest2 (mode, turn, context, callingtitle, calledtitle,
        !            87:        callingaddr, calledaddr, ctxlist, defctxname, data, qos, oid,
        !            88:        rtc, rti);
        !            89: }
        !            90: 
        !            91: /* RT-CLOSE.REQUEST */
        !            92: 
        !            93: int    RtCloseRequest (sd, reason, data, acr, rti)
        !            94: int    sd,
        !            95:        reason;
        !            96: PE     data;
        !            97: struct AcSAPrelease *acr;
        !            98: struct RtSAPindication *rti;
        !            99: {
        !           100:     return RtCloseRequest (sd, reason, data, acr, rti);
        !           101: }
        !           102: 
        !           103: /* RT-CLOSE.RESPONSE */
        !           104: 
        !           105: int    RtCloseResponse (sd, reason, data, rti)
        !           106: int    sd,
        !           107:        reason;
        !           108: PE     data;
        !           109: struct RtSAPindication *rti;
        !           110: {
        !           111:     return RtCloseResponse (sd, reason, data, rti);
        !           112: }
        !           113: 
        !           114: /* RT-U-ABORT.REQUEST */
        !           115: 
        !           116: int    RtUAbortRequest (sd, data, rti)
        !           117: int    sd;
        !           118: PE     data;
        !           119: struct RtSAPindication *rti;
        !           120: {
        !           121:     return RtUAbortRequest (sd, data, rti);
        !           122: }
        !           123: 
        !           124: /*    X.410 primitives */
        !           125: 
        !           126: /* SERVER only */
        !           127: 
        !           128: int    RtExec (ss, rti, arg1, arg2, hook, setperms)
        !           129: struct SSAPstart *ss;
        !           130: char   *arg1,
        !           131:        *arg2;
        !           132: struct RtSAPindication *rti;
        !           133: IFP    hook,
        !           134:        setperms;
        !           135: {
        !           136:     return RtExec (ss, rti, arg1, arg2, hook, setperms);
        !           137: }
        !           138: 
        !           139: /* .. */
        !           140: 
        !           141: int    RtBInit (vecp, vec, rts, rti)
        !           142: int    vecp;
        !           143: char  **vec;
        !           144: struct RtSAPstart *rts;
        !           145: struct RtSAPindication *rti;
        !           146: {
        !           147:     return RtBInit (vecp, vec, rts, rti);
        !           148: }
        !           149: 
        !           150: /* RT-BEGIN.RESPONSE (X.410 OPEN.RESPONSE) */
        !           151: 
        !           152: int    RtBeginResponse (sd, status, data, rti)
        !           153: int    sd;
        !           154: int    status;
        !           155: PE     data;
        !           156: struct RtSAPindication *rti;
        !           157: {
        !           158:     return RtBeginResponse (sd, status, data, rti);
        !           159: }
        !           160: 
        !           161: /* RT-BEGIN.REQUEST (X.410 OPEN.REQUEST) */
        !           162: 
        !           163: int    RtBeginRequest2 (called, calling, mode, turn, data, rtc, rti)
        !           164: struct RtSAPaddr *called, calling;
        !           165: int    mode,
        !           166:        turn;
        !           167: PE     data;
        !           168: struct RtSAPconnect *rtc;
        !           169: struct RtSAPindication *rti;
        !           170: {
        !           171:     return RtBeginRequest2 (called, calling, mode, turn, data, rtc, rti);
        !           172: }
        !           173: 
        !           174: /* RT-END.REQUEST (X.410 CLOSE.REQUEST) */
        !           175: 
        !           176: int    RtEndRequest (sd, rti)
        !           177: int    sd;
        !           178: struct RtSAPindication *rti;
        !           179: {
        !           180:     return RtEndRequest (sd, rti);
        !           181: }
        !           182: 
        !           183: /* RT-END.RESPONSE (X.410 CLOSE.RESPONSE) */
        !           184: 
        !           185: int    RtEndResponse (sd, rti)
        !           186: int    sd;
        !           187: struct RtSAPindication *rti;
        !           188: {
        !           189:     return RtEndResponse (sd, rti);
        !           190: }
        !           191: 
        !           192: /* RT-TURN-PLEASE.REQUEST */
        !           193: 
        !           194: int    RtPTurnRequest (sd, priority, rti)
        !           195: int    sd;
        !           196: int    priority;
        !           197: struct RtSAPindication *rti;
        !           198: {
        !           199:     return RtPTurnRequest (sd, priority, rti);
        !           200: }
        !           201: 
        !           202: /* RT-TURN-GIVE.REQUEST */
        !           203: 
        !           204: int    RtGTurnRequest (sd, rti)
        !           205: int    sd;
        !           206: struct RtSAPindication *rti;
        !           207: {
        !           208:     return RtGTurnRequest (sd, rti);
        !           209: }
        !           210: 
        !           211: /* RT-TRANSFER.REQUEST */
        !           212: 
        !           213: int    RtTransferRequest (sd, data, secs, rti)
        !           214: int    sd;
        !           215: PE     data;
        !           216: int    secs;
        !           217: struct RtSAPindication *rti;
        !           218: {
        !           219:     return RtTransferRequest (sd, data, secs, rti);
        !           220: }
        !           221: 
        !           222: /* RT-WAIT.REQUEST (pseudo) */
        !           223: 
        !           224: int    RtWaitRequest (sd, secs, rti)
        !           225: int    sd;
        !           226: int    secs;
        !           227: struct RtSAPindication *rti;
        !           228: {
        !           229:     return RtWaitRequest (sd, secs, rti);
        !           230: }
        !           231: 
        !           232: /* define vectors for INDICATION events */
        !           233: 
        !           234: int    RtSetIndications (sd, indication, rti)
        !           235: int    sd;
        !           236: IFP    indication;
        !           237: struct RtSAPindication *rti;
        !           238: {
        !           239:     return RtSetIndications (sd, indication, rti);
        !           240: }
        !           241: 
        !           242: /* map association descriptors for select() */
        !           243: 
        !           244: int    RtSelectMask (sd, mask, nfds, rti)
        !           245: int    sd;
        !           246: fd_set *mask;
        !           247: int    *nfds;
        !           248: struct RtSAPindication *rti;
        !           249: {
        !           250:     return RtSelectMask (sd, mask, nfds, rti);
        !           251: }
        !           252: 
        !           253: /* set downtrans upcall */
        !           254: 
        !           255: int    RtSetDownTrans (sd, fnx, rti)
        !           256: int    sd;
        !           257: IFP    fnx;
        !           258: struct RtSAPindication *rti;
        !           259: {
        !           260:     return RtSetDownTrans (sd, fnx, rti);
        !           261: }
        !           262: 
        !           263: /* set uptrans upcall */
        !           264: 
        !           265: int    RtSetUpTrans (sd, fnx, rti)
        !           266: int    sd;
        !           267: IFP    fnx;
        !           268: struct RtSAPindication *rti;
        !           269: {
        !           270:     return RtSetUpTrans (sd, fnx, rti);
        !           271: }
        !           272: 
        !           273: /* return RtSAP error code in string form */
        !           274: 
        !           275: char   *RtErrString (c)
        !           276: int    c;
        !           277: {
        !           278:     return RtErrString (c);
        !           279: }

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