Return to rosapinvoke.c CVS log

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

Annotation of 43BSDReno/contrib/isode-beta/rosap/rosapinvoke.c, revision 1.1

1.1     ! root        1: /* rosapinvoke.c - ROPM: invoke */
        !             2: 
        !             3: #ifndef        lint
        !             4: static char *rcsid = "$Header: /f/osi/rosap/RCS/rosapinvoke.c,v 7.1 90/07/01 21:06:02 mrose Exp $";
        !             5: #endif
        !             6: 
        !             7: /* 
        !             8:  * $Header: /f/osi/rosap/RCS/rosapinvoke.c,v 7.1 90/07/01 21:06:02 mrose Exp $
        !             9:  *
        !            10:  * Based on an TCP-based implementation by George Michaelson of University
        !            11:  * College London.
        !            12:  *
        !            13:  *
        !            14:  * $Log:       rosapinvoke.c,v $
        !            15:  * Revision 7.1  90/07/01  21:06:02  mrose
        !            16:  * pepsy
        !            17:  * 
        !            18:  * Revision 6.0  89/03/18  23:42:26  mrose
        !            19:  * Release 5.0
        !            20:  * 
        !            21:  */
        !            22: 
        !            23: /*
        !            24:  *                               NOTICE
        !            25:  *
        !            26:  *    Acquisition, use, and distribution of this module and related
        !            27:  *    materials are subject to the restrictions of a license agreement.
        !            28:  *    Consult the Preface in the User's Manual for the full terms of
        !            29:  *    this agreement.
        !            30:  *
        !            31:  */
        !            32: 
        !            33: 
        !            34: /* LINTLIBRARY */
        !            35: 
        !            36: #include <stdio.h>
        !            37: #include <signal.h>
        !            38: #include "ROS-types.h"
        !            39: #include "ropkt.h"
        !            40: 
        !            41: /*    RO-INVOKE.REQUEST */
        !            42: 
        !            43: int    RoInvokeRequest (sd, op, class, args, invokeID, linkedID, priority, roi)
        !            44: int    sd;
        !            45: int    op,
        !            46:        class,
        !            47:        invokeID,
        !            48:        *linkedID,
        !            49:        priority;
        !            50: PE     args;
        !            51: struct RoSAPindication *roi;
        !            52: {
        !            53:     SBV            smask;
        !            54:     int     result;
        !            55:     register struct assocblk   *acb;
        !            56: 
        !            57:     switch (class) {
        !            58:        case ROS_SYNC: 
        !            59:        case ROS_ASYNC: 
        !            60:            break;
        !            61: 
        !            62:        default: 
        !            63:            return rosaplose (roi, ROS_PARAMETER, NULLCP,
        !            64:                    "bad value for class parameter");
        !            65:     }
        !            66:     missingP (roi);
        !            67: 
        !            68:     smask = sigioblock ();
        !            69: 
        !            70:     rosapPsig (acb, sd);
        !            71: 
        !            72:     result = RoInvokeRequestAux (acb, op, class, args, invokeID, linkedID,
        !            73:                priority, roi);
        !            74: 
        !            75:     (void) sigiomask (smask);
        !            76: 
        !            77:     return result;
        !            78: }
        !            79: 
        !            80: /*  */
        !            81: 
        !            82: static int  RoInvokeRequestAux (acb, op, class, args, invokeID, linkedID,
        !            83:                priority, roi)
        !            84: register struct assocblk   *acb;
        !            85: int    op,
        !            86:        class,
        !            87:        invokeID,
        !            88:        *linkedID,
        !            89:        priority;
        !            90: PE     args;
        !            91: struct RoSAPindication *roi;
        !            92: {
        !            93:     PE pe;
        !            94: 
        !            95:     struct type_ROS_ROSEapdus  papdu;
        !            96:     struct type_ROS_ROIVapdu   piv;
        !            97:     struct type_ROS_InvokeIDType pidt;
        !            98:     struct type_ROS_Operation  prop;
        !            99: 
        !           100:     if (!(acb -> acb_flags & ACB_INIT) && (acb -> acb_flags & ACB_ROS))
        !           101:        return rosaplose (roi, ROS_OPERATION, NULLCP, "not initiator");
        !           102:     if (!(acb -> acb_flags & ACB_ACS)) {
        !           103:        missingP (args);
        !           104:        if (linkedID)
        !           105:            return rosaplose (roi, ROS_OPERATION, NULLCP,
        !           106:                        "linked operations not permitted");
        !           107:     }
        !           108:                    
        !           109:     if (acb -> acb_ready
        !           110:            && !(acb -> acb_flags & ACB_TURN)
        !           111:            && (*acb -> acb_ready) (acb, priority, roi) == NOTOK)
        !           112:        return NOTOK;
        !           113:        
        !           114:     if ((acb -> acb_flags & ACB_ACS) == 0) { /* want OPDU */
        !           115:         struct type_ROS_OPDU   opdu;
        !           116:        struct  type_ROS_Invoke s_invoke;
        !           117: 
        !           118:        s_invoke.invokeID = invokeID;
        !           119:        s_invoke.element_ROS_2 = &prop;
        !           120:        prop.parm = op;
        !           121:        s_invoke.argument = args;
        !           122:        opdu.offset = type_ROS_OPDU_1;  /* ROS-Invoke */
        !           123:        opdu.un.choice_ROS_8 = &s_invoke;
        !           124:        if (encode_ROS_OPDU (&pe, 1, 0, NULLCP, &opdu) == NOTOK)
        !           125:            return NOTOK;
        !           126: 
        !           127:     }
        !           128:     else {
        !           129:        if (linkedID) {
        !           130:            piv.optionals = opt_ROS_ROIVapdu_linked__ID;
        !           131:            piv.linked__ID = *linkedID;
        !           132:        } else
        !           133:            piv.optionals = 0;
        !           134: 
        !           135:        piv.invokeID = &pidt;
        !           136:        pidt.parm = invokeID;
        !           137:        piv.operation__value = &prop;
        !           138:        prop.parm = op;
        !           139:        piv.argument = args;
        !           140:        papdu.offset = type_ROS_ROSEapdus_roiv__apdu;
        !           141:        papdu.un.roiv__apdu = &piv;
        !           142: 
        !           143:        if (encode_ROS_ROSEapdus (&pe, 1, 0, NULLCP, &papdu) == NOTOK)
        !           144:            return NOTOK;
        !           145:     }
        !           146: 
        !           147:     if ((*acb -> acb_putosdu) (acb, pe, args, priority, roi) == NOTOK)
        !           148:        return NOTOK;
        !           149: 
        !           150:     return (class == ROS_SYNC
        !           151:            ? (*acb -> acb_rowaitrequest)  (acb, &invokeID, NOTOK, roi)
        !           152:            : OK);
        !           153: }

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