Return to llib-lftam CVS log

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

Annotation of 43BSDReno/contrib/isode-beta/ftam/llib-lftam, revision 1.1

1.1     ! root        1: /* llib-lftam - lint library for -lftam */
        !             2: 
        !             3: /* 
        !             4:  * $Header: /f/osi/ftam/RCS/llib-lftam,v 7.0 89/11/23 21:53:58 mrose Rel $
        !             5:  *
        !             6:  *
        !             7:  * $Log:       llib-lftam,v $
        !             8:  * Revision 7.0  89/11/23  21:53:58  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 "ftam.h"
        !            27: 
        !            28: /*  */
        !            29: 
        !            30: /* F-INITIALIZE.INDICATION */
        !            31: 
        !            32: int    FInit (vecp, vec, fts, tracing, fti)
        !            33: int    vecp;
        !            34: char  **vec;
        !            35: struct FTAMstart *fts;
        !            36: IFP    tracing;
        !            37: struct FTAMindication *fti;
        !            38: {
        !            39:     return FInit (vecp, vec, fts, tracing, fti);
        !            40: }
        !            41: 
        !            42: 
        !            43: /* F-INITIALIZE.RESPONSE */
        !            44: 
        !            45: int    FInitializeResponse (sd, state, action, context, respondtitle,
        !            46:        respondaddr, manage, class, units, attrs, sharedASE, fqos, contents,
        !            47:        diag, ndiag, fti)
        !            48: int    sd;
        !            49: int    state,
        !            50:        action,
        !            51:        manage,
        !            52:        class,
        !            53:        units,
        !            54:        attrs,
        !            55:        fqos;
        !            56: OID    context;
        !            57: AEI    respondtitle;
        !            58: struct PSAPaddr *respondaddr;
        !            59: PE     sharedASE;
        !            60: struct FTAMcontentlist *contents;
        !            61: struct FTAMdiagnostic diag[];
        !            62: int    ndiag;
        !            63: struct FTAMindication *fti;
        !            64: {
        !            65:     return FInitializeResponse (sd, state, action, context, respondtitle,
        !            66:            respondaddr, manage, class, units, attrs, sharedASE, fqos, contents,
        !            67:            diag, ndiag, fti);
        !            68: }
        !            69: 
        !            70: 
        !            71: /* F-INITIALIZE.REQUEST */
        !            72: 
        !            73: int    FInitializeRequest (context, callingtitle, calledtitle, callingaddr,
        !            74:        calledaddr, manage, class, units, attrs, sharedASE, fqos, contents,
        !            75:        initiator, account, password, passlen, qos, tracing, ftc, fti)
        !            76: OID    context;
        !            77: AEI    callingtitle,
        !            78:        calledtitle;
        !            79: struct PSAPaddr *callingaddr,
        !            80:                *calledaddr;
        !            81: int    manage,
        !            82:        class,
        !            83:        units,
        !            84:        attrs,
        !            85:        fqos,
        !            86:        passlen;
        !            87: PE     sharedASE;
        !            88: struct FTAMcontentlist *contents;
        !            89: char   *initiator,
        !            90:        *account,
        !            91:        *password;
        !            92: struct QOStype *qos;
        !            93: IFP    tracing;
        !            94: struct FTAMconnect *ftc;
        !            95: struct FTAMindication *fti;
        !            96: {
        !            97:     return FInitializeRequest (context, callingtitle, calledtitle, callingaddr,
        !            98:            calledaddr, manage, class, units, attrs, sharedASE, fqos,
        !            99:            contents, initiator, account, password, passlen, qos, tracing,
        !           100:            ftc, fti);
        !           101: }
        !           102: 
        !           103: 
        !           104: /* F-TERMINATE.REQUEST */
        !           105: 
        !           106: int    FTerminateRequest (sd, sharedASE, ftr, fti)
        !           107: int    sd;
        !           108: PE     sharedASE;
        !           109: struct FTAMrelease *ftr;
        !           110: struct FTAMindication *fti;
        !           111: {
        !           112:     return FTerminateRequest (sd, sharedASE, ftr, fti);
        !           113: }
        !           114: 
        !           115: 
        !           116: /* F-TERMINATE.RESPONSE */
        !           117: 
        !           118: int    FTerminateResponse (sd, sharedASE, charging, fti)
        !           119: int    sd;
        !           120: PE     sharedASE;
        !           121: struct FTAMcharging *charging;
        !           122: struct FTAMindication *fti;
        !           123: {
        !           124:     return FTerminateResponse (sd, sharedASE, charging, fti);
        !           125: }
        !           126: 
        !           127: 
        !           128: /* F-U-ABORT.REQUEST */
        !           129: 
        !           130: int    FUAbortRequest (sd, action, diag, ndiag, fti)
        !           131: int    sd;
        !           132: int    action;
        !           133: struct FTAMdiagnostic diag[];
        !           134: int    ndiag;
        !           135: struct FTAMindication *fti;
        !           136: {
        !           137:     return FUAbortRequest (sd, action, diag, ndiag, fti);
        !           138: }
        !           139: 
        !           140: 
        !           141: /* F-WAIT.REQUEST (pseudo) */
        !           142: 
        !           143: int    FWaitRequest (sd, secs, fti)
        !           144: int    sd;
        !           145: int    secs;
        !           146: struct FTAMindication *fti;
        !           147: {
        !           148:     return FWaitRequest (sd, secs, fti);
        !           149: }
        !           150: 
        !           151: 
        !           152: /* F-MANAGE.REQUEST (group) */
        !           153: 
        !           154: int     FManageRequest (sd, ftg, fti)
        !           155: int     sd;
        !           156: struct FTAMgroup   *ftg;
        !           157: struct FTAMindication  *fti;
        !           158: {
        !           159:     return FManageRequest (sd, ftg, fti);
        !           160: }
        !           161: 
        !           162: 
        !           163: /* F-MANAGE.RESPONSE (group) */
        !           164: 
        !           165: int     FManageResponse (sd, ftg, fti)
        !           166: int     sd;
        !           167: struct FTAMgroup   *ftg;
        !           168: struct FTAMindication  *fti;
        !           169: {
        !           170:     return FManageResponse (sd, ftg, fti);
        !           171: }
        !           172: 
        !           173: 
        !           174: /* F-BULK-BEGIN.REQUEST (group) */
        !           175: 
        !           176: int     FBulkBeginRequest (sd, ftg, fti)
        !           177: int     sd;
        !           178: struct FTAMgroup   *ftg;
        !           179: struct FTAMindication  *fti;
        !           180: {
        !           181:     return FBulkBeginRequest (sd, ftg, fti);
        !           182: }
        !           183: 
        !           184: 
        !           185: /* F-BULK-BEGIN.RESPONSE (group) */
        !           186: 
        !           187: int     FBulkBeginResponse (sd, ftg, fti)
        !           188: int     sd;
        !           189: struct FTAMgroup   *ftg;
        !           190: struct FTAMindication  *fti;
        !           191: {
        !           192:     return FBulkBeginResponse (sd, ftg, fti);
        !           193: }
        !           194: 
        !           195: 
        !           196: /* F-BULK-END.REQUEST (group) */
        !           197: 
        !           198: int     FBulkEndRequest (sd, ftg, fti)
        !           199: int     sd;
        !           200: struct FTAMgroup   *ftg;
        !           201: struct FTAMindication  *fti;
        !           202: {
        !           203:     return FBulkEndRequest (sd, ftg, fti);
        !           204: }
        !           205: 
        !           206: 
        !           207: /* F-BULK-END.RESPONSE (group) */
        !           208: 
        !           209: int     FBulkEndResponse (sd, ftg, fti)
        !           210: int     sd;
        !           211: struct FTAMgroup   *ftg;
        !           212: struct FTAMindication  *fti;
        !           213: {
        !           214:     return FBulkEndResponse (sd, ftg, fti);
        !           215: }
        !           216: 
        !           217: 
        !           218: /* F-{LOCATE,ERASE}.REQUEST */
        !           219: 
        !           220: int    FAccessRequest (sd, operation, identity, fti)
        !           221: int    sd;
        !           222: int    operation;
        !           223: struct FADUidentity *identity;
        !           224: struct FTAMindication *fti;
        !           225: {
        !           226:     return FAccessRequest (sd, operation, identity, fti);
        !           227: }
        !           228: 
        !           229: 
        !           230: /* F-{LOCATE,ERASE}.RESPONSE */
        !           231: 
        !           232: int    FAccessResponse (sd, action, identity, diag, ndiag, fti)
        !           233: int    sd;
        !           234: int    action;
        !           235: struct FADUidentity *identity; /* F-LOCATE.RESPONSE only */
        !           236: struct FTAMdiagnostic diag[];
        !           237: int    ndiag;
        !           238: struct FTAMindication *fti;
        !           239: {
        !           240:     return FAccessResponse (sd, action, identity, diag, ndiag, fti);
        !           241: }
        !           242: 
        !           243: 
        !           244: /* F-{READ,WRITE}.REQUEST */
        !           245: 
        !           246: int    FReadWriteRequest (sd, operation, identity, context, level, lock, fti)
        !           247: int    sd;
        !           248: int    operation;
        !           249: struct FADUidentity *identity;
        !           250: int    context,                /* F-READ.REQUEST only */
        !           251:        level,                  /*   .. */
        !           252:        lock;
        !           253: struct FTAMindication *fti;
        !           254: {
        !           255:     return FReadWriteRequest (sd, operation, identity, context, level, lock,
        !           256:                              fti);
        !           257: }
        !           258: 
        !           259: 
        !           260: /* F-DATA.REQUEST */
        !           261: 
        !           262: int    FDataRequest (sd, fadus, nfadu, fti)
        !           263: int    sd;
        !           264: PE     fadus[];
        !           265: int    nfadu;
        !           266: struct FTAMindication *fti;
        !           267: {
        !           268:     return FDataRequest (sd, fadus, nfadu, fti);
        !           269: }
        !           270: 
        !           271: 
        !           272: /* F-DATA-END.REQUEST */
        !           273: 
        !           274: int    FDataEndRequest (sd, action, diag, ndiag, fti)
        !           275: int    sd;
        !           276: int    action;
        !           277: struct FTAMdiagnostic diag[];
        !           278: int    ndiag;
        !           279: struct FTAMindication *fti;
        !           280: {
        !           281:     return FDataEndRequest (sd, action, diag, ndiag, fti);
        !           282: }
        !           283: 
        !           284: 
        !           285: /* F-CANCEL.REQUEST */
        !           286: 
        !           287: int    FCancelRequest (sd, action, sharedASE, diag, ndiag, fti)
        !           288: int    sd;
        !           289: int    action;
        !           290: PE     sharedASE;
        !           291: struct FTAMdiagnostic diag[];
        !           292: int    ndiag;
        !           293: struct FTAMindication *fti;
        !           294: {
        !           295:     return FCancelRequest (sd, action, sharedASE, diag, ndiag, fti);
        !           296: }
        !           297: 
        !           298: 
        !           299: /* F-CANCEL.RESPONSE */
        !           300: 
        !           301: int    FCancelResponse (sd, action, sharedASE, diag, ndiag, fti)
        !           302: int    sd;
        !           303: int    action;
        !           304: PE     sharedASE;
        !           305: struct FTAMdiagnostic diag[];
        !           306: int    ndiag;
        !           307: struct FTAMindication *fti;
        !           308: {
        !           309:     return FCancelResponse (sd, action, sharedASE, diag, ndiag, fti);
        !           310: }
        !           311: 
        !           312: 
        !           313: /* F-TRANSFER-END.REQUEST */
        !           314: 
        !           315: int    FTransEndRequest (sd, sharedASE, fti)
        !           316: int    sd;
        !           317: PE     sharedASE;
        !           318: struct FTAMindication *fti;
        !           319: {
        !           320:     return FTransEndRequest (sd, sharedASE, fti);
        !           321: }
        !           322: 
        !           323: 
        !           324: /* F-TRANSFER-END.RESPONSE */
        !           325: 
        !           326: int    FTransEndResponse (sd, action, sharedASE, diag, ndiag, fti)
        !           327: int    sd;
        !           328: int    action;
        !           329: PE     sharedASE;
        !           330: struct FTAMdiagnostic diag[];
        !           331: int    ndiag;
        !           332: struct FTAMindication *fti;
        !           333: {
        !           334:     return FTransEndResponse (sd, action, sharedASE, diag, ndiag, fti);
        !           335: }
        !           336: 
        !           337: 
        !           338: /* define vector for INDICATION events */
        !           339: 
        !           340: int    FSetIndications (sd, indication, fti)
        !           341: int    sd;
        !           342: IFP    indication;
        !           343: struct FTAMindication *fti;
        !           344: {
        !           345:     return FSetIndications (sd, indication, fti);
        !           346: }
        !           347: 
        !           348: 
        !           349: /* map ftam descriptors for select() */
        !           350: 
        !           351: int    FSelectMask (sd, mask, nfds, fti)
        !           352: int    sd;
        !           353: fd_set *mask;
        !           354: int    *nfds;
        !           355: struct FTAMindication *fti;
        !           356: {
        !           357:     return FSelectMask (sd, mask, nfds, fti);
        !           358: }
        !           359: 
        !           360: 
        !           361: /* set tracing */
        !           362: 
        !           363: int    FHookRequest (sd, tracing, fti)
        !           364: int    sd;
        !           365: IFP    tracing;
        !           366: struct FTAMindication *fti;
        !           367: {
        !           368:     return FHookRequest (sd, tracing, fti);
        !           369: }
        !           370: 
        !           371: 
        !           372: /* user-defined tracing */
        !           373: 
        !           374: int    FTraceHook (sd, event, fpdu, pe, rw)
        !           375: int    sd;
        !           376: char   *event,
        !           377:        *fpdu;
        !           378: PE     pe;
        !           379: int    rw;
        !           380: {
        !           381:     return FTraceHook (sd, event, fpdu, pe, rw);
        !           382: }
        !           383: 
        !           384: 
        !           385: /* return FTAM error code in string form */
        !           386: 
        !           387: char   *FErrString (code)
        !           388: int    code;
        !           389: {
        !           390:     return FErrString (code);
        !           391: }
        !           392: 
        !           393: 
        !           394: /* free list of attributes */
        !           395: 
        !           396: void   FAFREE (fa)
        !           397: struct FTAMattributes *fa;
        !           398: {
        !           399:     FAFREE (fa);
        !           400: }
        !           401: 
        !           402: /*  isodocuments routines */
        !           403: 
        !           404: 
        !           405: int    setisodocument (f)
        !           406: int    f;
        !           407: {
        !           408:     return setisodocument (f);
        !           409: }
        !           410: 
        !           411: 
        !           412: int    endisodocument ()
        !           413: {
        !           414:     return endisodocument ();
        !           415: }
        !           416: 
        !           417: 
        !           418: struct isodocument *getisodocument ()
        !           419: {
        !           420:     return getisodocument ();
        !           421: }
        !           422: 
        !           423: 
        !           424: struct isodocument *getisodocumentbyentry (entry)
        !           425: char   *entry;
        !           426: {
        !           427:     return getisodocumentbyentry (entry);
        !           428: }
        !           429: 
        !           430: 
        !           431: struct isodocument *getisodocumentbytype (type)
        !           432: OID    type;
        !           433: {
        !           434:     return getisodocumentbytype (type);
        !           435: }

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