Annotation of 43BSDReno/contrib/isode-beta/acsap/llib-lacsap, revision 1.1.1.1

1.1       root        1: /* llib-lacsap - lint library for -lacsap */
                      2: 
                      3: /* 
                      4:  * $Header: /f/osi/acsap/RCS/llib-lacsap,v 7.1 90/07/09 14:31:18 mrose Exp $
                      5:  *
                      6:  *
                      7:  * $Log:       llib-lacsap,v $
                      8:  * Revision 7.1  90/07/09  14:31:18  mrose
                      9:  * sync
                     10:  * 
                     11:  * Revision 7.0  89/11/23  21:22:15  mrose
                     12:  * Release 6.0
                     13:  * 
                     14:  */
                     15: 
                     16: /*
                     17:  *                               NOTICE
                     18:  *
                     19:  *    Acquisition, use, and distribution of this module and related
                     20:  *    materials are subject to the restrictions of a license agreement.
                     21:  *    Consult the Preface in the User's Manual for the full terms of
                     22:  *    this agreement.
                     23:  *
                     24:  */
                     25: 
                     26: 
                     27: /* LINTLIBRARY */
                     28: 
                     29: #include "acsap.h"
                     30: #include "tsap.h"
                     31: #include "isoservent.h"
                     32: 
                     33: /*  */
                     34: 
                     35: /* A-ASSOCIATE.INDICATION */
                     36: 
                     37: int    AcInit (vecp, vec, acs, aci)
                     38: int    vecp;
                     39: char  **vec;
                     40: struct AcSAPstart *acs;
                     41: struct AcSAPindication *aci;
                     42: {
                     43:     return AcInit (vecp, vec, acs, aci);
                     44: }
                     45: 
                     46: 
                     47: /* A-ASSOCIATE.RESPONSE */
                     48: 
                     49: int    AcAssocResponse (sd, status, reason, context, respondtitle,
                     50:        respondaddr, ctxlist, defctxresult, prequirements, srequirements, isn,
                     51:        settings, ref, data, ndata, aci)
                     52: int    sd;
                     53: int    status,
                     54:        reason;
                     55: OID    context;
                     56: AEI    respondtitle;
                     57: struct PSAPaddr *respondaddr;
                     58: int    prequirements,
                     59:        srequirements,
                     60:        settings,
                     61:        ndata;
                     62: long   isn;
                     63: struct PSAPctxlist *ctxlist;
                     64: int    defctxresult;
                     65: struct SSAPref *ref;
                     66: PE     *data;
                     67: struct AcSAPindication *aci;
                     68: {
                     69:     return AcAssocResponse (sd, status, reason, context, respondtitle,
                     70:            respondaddr, ctxlist, defctxresult, prequirements, srequirements,
                     71:            isn, settings, ref, data, ndata, aci);
                     72: }
                     73: 
                     74: 
                     75: /* A-(ASYN-)ASSOCIATE.REQUEST */
                     76: 
                     77: int    AcAsynAssocRequest (context, callingtitle, calledtitle, callingaddr,
                     78:        calledaddr, ctxlist, defctxname, prequirements, srequirements, isn,
                     79:        settings, ref, data, ndata, qos, acc, aci, async)
                     80: OID    context;
                     81: AEI    callingtitle,
                     82:        calledtitle;
                     83: struct PSAPaddr *callingaddr,
                     84:                *calledaddr;
                     85: int    prequirements,
                     86:        srequirements,
                     87:        settings,
                     88:        ndata,
                     89:        async;
                     90: long   isn;
                     91: struct PSAPctxlist *ctxlist;
                     92: OID    defctxname;
                     93: struct SSAPref *ref;
                     94: PE    *data;
                     95: struct QOStype *qos;
                     96: struct AcSAPconnect *acc;
                     97: struct AcSAPindication *aci;
                     98: {
                     99:     return AcAsynAssocRequest (context, callingtitle, calledtitle, callingaddr,
                    100:            calledaddr, ctxlist, defctxname, prequirements, srequirements, isn,
                    101:            settings, ref, data, ndata, qos, acc, aci, async);
                    102: }
                    103: 
                    104: 
                    105: /* A-ASYN-RETRY.REQUEST (pseudo) */
                    106: 
                    107: int    AcAsynRetryRequest (sd, acc, aci)
                    108: int    sd;
                    109: struct AcSAPconnect *acc;
                    110: struct AcSAPindication *aci;
                    111: {
                    112:     return AcAsynRetryRequest (sd, acc, aci);
                    113: }
                    114: 
                    115: 
                    116: /* A-ASYN-NEXT.REQUEST (pseudo) */
                    117: 
                    118: int    AcAsynNextRequest (sd, acc, aci)
                    119: int    sd;
                    120: struct AcSAPconnect *acc;
                    121: struct AcSAPindication *aci;
                    122: {
                    123:     return AcAsynNextRequest (sd, acc, aci);
                    124: }
                    125: 
                    126: 
                    127: /* A-RELEASE.REQUEST */
                    128: 
                    129: int    AcRelRequest (sd, reason, data, ndata, secs, acr, aci)
                    130: int    sd;
                    131: int    reason;
                    132: PE     *data;
                    133: int    ndata;
                    134: int    secs;
                    135: struct AcSAPrelease *acr;
                    136: struct AcSAPindication *aci;
                    137: {
                    138:     return AcRelRequest (sd, reason, data, ndata, secs, acr, aci);
                    139: }
                    140: 
                    141: 
                    142: /* A-RELEASE-RETRY.REQUEST (pseudo) */
                    143: 
                    144: int    AcRelRetryRequest (sd, secs, acr, aci)
                    145: int    sd;
                    146: int    secs;
                    147: struct AcSAPrelease *acr;
                    148: struct AcSAPindication *aci;
                    149: {
                    150:     return AcRelRetryRequest (sd, secs, acr, aci);
                    151: }
                    152: 
                    153: 
                    154: /* A-RELEASE.RESPONSE */
                    155: 
                    156: int    AcRelResponse (sd, status, reason, data, ndata, aci)
                    157: int    sd;
                    158: int    status,
                    159:        reason;
                    160: PE     *data;
                    161: int    ndata;
                    162: struct AcSAPindication *aci;
                    163: {
                    164:     return AcRelResponse (sd, status, reason, data, ndata, aci);
                    165: }
                    166: 
                    167: 
                    168: /* A-ABORT.REQUEST */
                    169: 
                    170: int    AcUAbortRequest (sd, data, ndata, aci)
                    171: int    sd;
                    172: PE     *data;
                    173: int    ndata;
                    174: struct AcSAPindication *aci;
                    175: {
                    176:     return AcUAbortRequest (sd, data, ndata, aci);
                    177: }
                    178: 
                    179: 
                    180: /* handle P-RELEASE.INDICATION */
                    181: 
                    182: int    AcFINISHser (sd, pf, aci)
                    183: int    sd;
                    184: struct PSAPfinish *pf;
                    185: struct AcSAPindication *aci;
                    186: {
                    187:     return AcFINISHser (sd, pf, aci);
                    188: }
                    189: 
                    190: 
                    191: /* handle P-{U,P}-ABORT.INDICATION */
                    192: 
                    193: int    AcABORTser (sd, pa, aci)
                    194: int    sd;
                    195: struct PSAPabort *pa;
                    196: struct AcSAPindication *aci;
                    197: {
                    198:     return AcABORTser (sd, pa, aci);
                    199: }
                    200: 
                    201: 
                    202: /* return PCI used by ACSE */
                    203: 
                    204: int    AcFindPCI (sd, pci, aci)
                    205: int    sd;
                    206: int    *pci;
                    207: struct AcSAPindication *aci;
                    208: {
                    209:     return AcFindPCI (sd, pci, aci);
                    210: }
                    211: 
                    212: 
                    213: /* return AcSAP error code in string form */
                    214: 
                    215: char   *AcErrString (code)
                    216: int    code;
                    217: {
                    218:     return AcErrString (code);
                    219: }
                    220: 
                    221: 
                    222: /* string to application entity info */
                    223: 
                    224: AEI    _str2aei (designator, qualifier, context, interactive)
                    225: char   *designator,
                    226:        *qualifier,
                    227:        *context;
                    228: int     interactive;
                    229: {
                    230:     return _str2aei (designator, qualifier, context, interactive);
                    231: }
                    232: 
                    233: 
                    234: char   *sprintaei (aei)
                    235: AEI    aei;
                    236: {
                    237:     return sprintaei (aei);
                    238: }
                    239: 
                    240: 
                    241: /* application entity info to PSAPaddr */
                    242: 
                    243: struct PSAPaddr *aei2addr (aei)
                    244: AEI    aei;
                    245: {
                    246:     return aei2addr (aei);
                    247: }
                    248: 
                    249: 
                    250: int    setisoentity (f)
                    251: int    f;
                    252: {
                    253:     return setisoentity (f);
                    254: }
                    255: 
                    256: 
                    257: int    endisoentity ()
                    258: {
                    259:     return endisoentity ();
                    260: }
                    261: 
                    262: struct isoentity *getisoentity ()
                    263: {
                    264:     return getisoentity ();
                    265: }
                    266: 
                    267: 
                    268: AEI    oid2aei (oid)
                    269: OID    oid;
                    270: {
                    271:     return oid2aei (oid);
                    272: }
                    273: 
                    274: 
                    275: /* old-style */
                    276: 
                    277: struct PSAPaddr *is2paddr (host, service, is)
                    278: char   *host,
                    279:        *service;
                    280: struct isoservent *is;
                    281: {
                    282:     return is2paddr (host, service, is);
                    283: }
                    284: 
                    285: 
                    286: /* old-style */
                    287: 
                    288: struct SSAPaddr *is2saddr (host, service, is)
                    289: char   *host,
                    290:        *service;
                    291: struct isoservent *is;
                    292: {
                    293:     return is2saddr (host, service, is);
                    294: }
                    295: 
                    296: 
                    297: /* old-style */
                    298: 
                    299: struct TSAPaddr *is2taddr (host, service, is)
                    300: char   *host,
                    301:        *service;
                    302: struct isoservent *is;
                    303: {
                    304:     return is2taddr (host, service, is);
                    305: }
                    306: 
                    307: 
                    308: /* "higher-performance" name service */
                    309: 
                    310: PE     name2value (name, attribute, real_name)
                    311: char   *name,
                    312:        *attribute;
                    313: PE     *real_name;
                    314: {
                    315:     return name2value (name, attribute, real_name);
                    316: }
                    317: 
                    318: 
                    319: /* generic server dispatch */
                    320: 
                    321: int    isodeserver (argc, argv, aei, initfnx, workfnx, losefnx, td)
                    322: int    argc;
                    323: char  **argv;
                    324: AEI    aei;
                    325: IFP    initfnx,
                    326:        workfnx,
                    327:        losefnx;
                    328: struct TSAPdisconnect *td;
                    329: {
                    330:     return isodeserver (argc, argv, aei, initfnx, workfnx, losefnx, td);
                    331: }

unix.superglobalmegacorp.com

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