Return to rt2ssinitiat.c CVS log

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

Annotation of 43BSDReno/contrib/isode-beta/rtsap/rt2ssinitiat.c, revision 1.1

1.1     ! root        1: /* rt2ssinitiat.c - RTPM: initiator */
        !             2: 
        !             3: #ifndef        lint
        !             4: static char *rcsid = "$Header: /f/osi/rtsap/RCS/rt2ssinitiat.c,v 7.2 90/07/27 08:47:57 mrose Exp $";
        !             5: #endif
        !             6: 
        !             7: /* 
        !             8:  * $Header: /f/osi/rtsap/RCS/rt2ssinitiat.c,v 7.2 90/07/27 08:47:57 mrose Exp $
        !             9:  *
        !            10:  *
        !            11:  * $Log:       rt2ssinitiat.c,v $
        !            12:  * Revision 7.2  90/07/27  08:47:57  mrose
        !            13:  * update
        !            14:  * 
        !            15:  * Revision 7.1  90/07/01  21:07:10  mrose
        !            16:  * pepsy
        !            17:  * 
        !            18:  * Revision 6.1  89/06/24  00:55:57  mrose
        !            19:  * reason
        !            20:  * 
        !            21:  * Revision 6.0  89/03/18  23:43:20  mrose
        !            22:  * Release 5.0
        !            23:  * 
        !            24:  */
        !            25: 
        !            26: /*
        !            27:  *                               NOTICE
        !            28:  *
        !            29:  *    Acquisition, use, and distribution of this module and related
        !            30:  *    materials are subject to the restrictions of a license agreement.
        !            31:  *    Consult the Preface in the User's Manual for the full terms of
        !            32:  *    this agreement.
        !            33:  *
        !            34:  */
        !            35: 
        !            36: 
        !            37: /* LINTLIBRARY */
        !            38: 
        !            39: #include <stdio.h>
        !            40: #include <signal.h>
        !            41: #include "RTS-types.h"
        !            42: #include "OACS-types.h"
        !            43: #include "rtpkt.h"
        !            44: #include "isoservent.h"
        !            45: #include "tailor.h"
        !            46: 
        !            47: /*    RT-BEGIN.REQUEST (X.410 OPEN.REQUEST) */
        !            48: 
        !            49: int    RtBeginRequest2 (called, calling, mode, turn, data, rtc, rti)
        !            50: struct RtSAPaddr *called, *calling;
        !            51: int    mode,
        !            52:        turn;
        !            53: PE     data;
        !            54: struct RtSAPconnect *rtc;
        !            55: struct RtSAPindication *rti;
        !            56: {
        !            57:     SBV     smask;
        !            58:     int     result;
        !            59: 
        !            60:     isodetailor (NULLCP, 0);
        !            61: 
        !            62:     missingP (called);
        !            63:     switch (mode) {
        !            64:        case RTS_MONOLOGUE:
        !            65:        case RTS_TWA:
        !            66:            break;
        !            67: 
        !            68:        default:
        !            69:            return rtsaplose (rti, RTS_PARAMETER, NULLCP,
        !            70:                    "bad value for mode parameter");
        !            71:     }
        !            72:     switch (turn) {
        !            73:        case RTS_INITIATOR:
        !            74:        case RTS_RESPONDER:
        !            75:            break;
        !            76: 
        !            77:        default:
        !            78:            return rtsaplose (rti, RTS_PARAMETER, NULLCP,
        !            79:                    "bad value for turn parameter");
        !            80:     }
        !            81:     missingP (rtc);
        !            82:     bzero ((char *) rtc, sizeof *rtc);
        !            83:     missingP (rti);
        !            84: 
        !            85:     smask = sigioblock ();
        !            86: 
        !            87:     result = RtBeginRequestAux (called, calling, mode, turn, data, rtc, rti);
        !            88: 
        !            89:     (void) sigiomask (smask);
        !            90: 
        !            91:     return result;
        !            92: }
        !            93: 
        !            94: /*  */
        !            95: 
        !            96: static int  RtBeginRequestAux (called, calling, mode, turn, data, rtc, rti)
        !            97: struct RtSAPaddr *called, *calling;
        !            98: int    mode,
        !            99:        turn;
        !           100: PE     data;
        !           101: struct RtSAPconnect *rtc;
        !           102: struct RtSAPindication *rti;
        !           103: {
        !           104:     int            len,
        !           105:            result,
        !           106:            settings;
        !           107:     char   *base;
        !           108: #ifdef notdef
        !           109:     register struct isoservent *is;
        !           110: #endif
        !           111:     register PE        pe,
        !           112:                p,
        !           113:                q,
        !           114:                r;
        !           115:     register struct assocblk *acb;
        !           116:     struct SSAPref srs;
        !           117:     register struct SSAPref *sr = &srs;
        !           118:     struct SSAPconnect scs;
        !           119:     register struct SSAPconnect *sc = &scs;
        !           120:     struct SSAPindication sis;
        !           121:     register struct SSAPindication *si = &sis;
        !           122:     register struct SSAPabort *sa = &si -> si_abort;
        !           123:     struct type_OACS_PAccept *paccpt = (struct type_OACS_PAccept *)0;
        !           124: 
        !           125:     if ((acb = newacblk ()) == NULL)
        !           126:        return rtsaplose (rti, RTS_CONGEST, NULLCP, "out of memory");
        !           127: 
        !           128: /* begin PConnect PSDU */
        !           129:     if ((pe = pe_alloc (PE_CLASS_UNIV, PE_FORM_CONS, PE_CONS_SET)) == NULLPE) {
        !           130: no_mem: ;
        !           131:        result = rtsaplose (rti, RTS_CONGEST, NULLCP, "out of memory");
        !           132:        goto out1;
        !           133:     }
        !           134:     if (set_add (pe, p = pe_alloc (PE_CLASS_CONT, PE_FORM_CONS, PCONN_DTS))
        !           135:                == NOTOK
        !           136:            || set_add (p, num2prim (SYN_X409, PE_CLASS_CONT, DTS_SYNTAX))
        !           137:                    == NOTOK
        !           138:            || set_add (pe, p = pe_alloc (PE_CLASS_CONT, PE_FORM_CONS,
        !           139:                    PCONN_DATA)) == NOTOK
        !           140:            || (DEFAULT_CKPOINT != PCONN_CK_DFLT
        !           141:                    && set_add (p, num2prim (DEFAULT_CKPOINT, PE_CLASS_CONT,
        !           142:                                             PCONN_DATA_CK)) == NOTOK)
        !           143:            || (DEFAULT_WINDOW != PCONN_WD_DFLT
        !           144:                    && set_add (p, num2prim (DEFAULT_WINDOW, PE_CLASS_CONT,
        !           145:                                             PCONN_DATA_WD)) == NOTOK)
        !           146:            || set_add (p, num2prim (mode == RTS_TWA ? PCONN_DM_TWA
        !           147:                    : PCONN_DM_MONO, PE_CLASS_CONT, PCONN_DATA_DM)) == NOTOK
        !           148:            || set_add (p, q = pe_alloc (PE_CLASS_CONT, PE_FORM_CONS,
        !           149:                    PCONN_DATA_CN)) == NOTOK
        !           150:            || set_add (q, r = pe_alloc (PE_CLASS_CONT, PE_FORM_CONS,
        !           151:                    CN_OPEN)) == NOTOK
        !           152:            || set_add (r, data ? data : pe_alloc (PE_CLASS_CONT,
        !           153:                    PE_FORM_PRIM, 0)) == NOTOK
        !           154:            || set_add (p, num2prim ((int) ntohs (called -> rta_port),
        !           155:                    PE_CLASS_CONT, PCONN_DATA_AP)) == NOTOK)
        !           156:        goto no_mem;
        !           157: /* end PConnect PSDU */
        !           158: 
        !           159:     PLOGP (rtsap_log,OACS_PConnect, pe, "PConnect", 0);
        !           160: 
        !           161:     if (pe2ssdu (pe, &base, &len) == NOTOK)
        !           162:        goto no_mem;
        !           163: 
        !           164:     if (data)
        !           165:        (void) pe_extract (pe, data), data = NULLPE;
        !           166:     pe_free (pe);
        !           167:     pe = NULLPE;
        !           168: 
        !           169: #ifdef notdef          /* SEK doesn't like this */
        !           170:     if (called -> rta_addr.sa_selectlen == 0) {
        !           171:        if ((is = getisoserventbyname ("rts", "ssap")) == NULL) {
        !           172:            result = rtsaplose (rti, RTS_ADDRESS, NULLCP,
        !           173:                            "ssap/rts: unknown entity");
        !           174:            goto out2;
        !           175:        }
        !           176:        if (is -> is_selectlen > SSSIZE) {      /* XXX */
        !           177:            result = rosaplose (rti, RTS_ADDRESS, NULLCP,
        !           178:                        "ssap/rts: selector too long (%d octets)",
        !           179:                        is -> is_selectlen);
        !           180:            goto out2;
        !           181:        }
        !           182:        bcopy (is -> is_selector, called -> rta_addr.sa_selector,
        !           183:            called -> rta_addr.sa_selectlen = is -> is_selectlen);
        !           184:     }
        !           185: #endif
        !           186: 
        !           187:     acb -> acb_requirements = RTS_MYREQUIRE;
        !           188:     settings = 0;
        !           189: #define dotoken(requires,shift,bit,type) \
        !           190: { \
        !           191:     if (acb -> acb_requirements & requires) \
        !           192:        if (turn == RTS_INITIATOR) \
        !           193:            settings |= ST_INIT_VALUE << shift; \
        !           194:        else \
        !           195:            settings |= ST_RESP_VALUE << shift; \
        !           196: }
        !           197:     dotokens ();
        !           198: #undef dotoken
        !           199: 
        !           200:     if ((sr = addr2ref (SLocalHostName ())) == NULL) {
        !           201:        result = rtsaplose (rti, RTS_CONGEST, NULLCP, "out of memory");
        !           202:        goto out2;
        !           203:     }
        !           204:     acb -> acb_connect = *sr;  /* struct copy */
        !           205: 
        !           206:     if (SConnRequest (sr, calling ? &calling -> rta_addr : NULLSA,
        !           207:                      &called -> rta_addr, acb -> acb_requirements,
        !           208:            settings, SERIAL_NONE, base, len, NULLQOS, sc, si) == NOTOK) {
        !           209:        result = ss2rtslose (NULLACB, rti, "SConnRequest", sa);
        !           210:        goto out2;
        !           211:     }
        !           212:     free (base);
        !           213: 
        !           214:     if (sc -> sc_result == SC_ACCEPT) {
        !           215:        acb -> acb_fd = sc -> sc_sd;
        !           216:        acb -> acb_uabort = SUAbortRequest;
        !           217:     }
        !           218:     else
        !           219:         if (sc -> sc_result == SC_ABORT) {
        !           220:            acb -> acb_fd = NOTOK;
        !           221: 
        !           222:            (void) ss2rtsabort (acb, sa, rti);
        !           223: 
        !           224:            rtc -> rtc_sd = NOTOK;
        !           225:            rtc -> rtc_result = RTS_ABORTED;
        !           226: 
        !           227:            return OK;
        !           228:        }
        !           229: 
        !           230:     if ((pe = ssdu2pe (sc -> sc_data, sc -> sc_cc, NULLCP, &result))
        !           231:            == NULLPE) {
        !           232:        if (sc -> sc_result != SC_ACCEPT) {
        !           233:            bzero ((char *) sa, sizeof *sa);
        !           234:            sa -> sa_reason = sc -> sc_result;
        !           235:            acb -> acb_fd = NOTOK;
        !           236:            (void) ss2rtslose (acb, rti, "SConnRequest(pseudo)", sa);
        !           237: 
        !           238:            rtc -> rtc_sd = NOTOK;
        !           239:            rtc -> rtc_result = rti -> rti_abort.rta_reason;
        !           240: 
        !           241:            result = OK;
        !           242:        }
        !           243:        else
        !           244:            result = rtpktlose (acb, rti, result != PS_ERR_NMEM ? RTS_PROTOCOL
        !           245:                    : RTS_CONGEST, NULLCP, "%s", ps_error (result));
        !           246:        goto out1;
        !           247:     }
        !           248: 
        !           249:     SCFREE (sc);
        !           250: 
        !           251:     if (sc -> sc_result != SC_ACCEPT) {
        !           252:        struct type_OACS_PRefuse *pref;
        !           253: 
        !           254:        if (parse_OACS_PRefuse (pe, 1, NULLIP, NULLVP, &pref) == NOTOK) {
        !           255:            result = pylose ();
        !           256:            goto out1;
        !           257:        }
        !           258: 
        !           259:        PLOGP (rtsap_log,OACS_PRefuse, pe, "PRefuse", 1);
        !           260: 
        !           261:        pe_free (pe);
        !           262:        
        !           263:        freeacblk (acb);
        !           264: 
        !           265:        rtc -> rtc_sd = NOTOK;
        !           266:        switch (pref->parm) {
        !           267:            case REFUSE_BUSY: 
        !           268:                rtc -> rtc_result = RTS_BUSY;
        !           269:                break;
        !           270: 
        !           271:            case REFUSE_VALIDATE: 
        !           272:                rtc -> rtc_result = RTS_VALIDATE;
        !           273:                break;
        !           274: 
        !           275:            case REFUSE_MODE:
        !           276:                rtc -> rtc_result = RTS_MODE;
        !           277:                break;
        !           278: 
        !           279:            default: 
        !           280:                rtc -> rtc_result = RTS_PROTOCOL;
        !           281:                break;
        !           282:        }
        !           283: 
        !           284:        free_OACS_RefuseReason(pref);
        !           285:        return OK;
        !           286:     }
        !           287: 
        !           288:     acb -> acb_flags = ACB_CONN | ACB_RTS | ACB_INIT;
        !           289:     SetSS2RtService (acb);
        !           290:     if (turn == RTS_INITIATOR)
        !           291:        acb -> acb_flags |= ACB_TURN;
        !           292:     if (mode == RTS_TWA)
        !           293:        acb -> acb_flags |= ACB_TWA;
        !           294:     if ((acb -> acb_requirements = sc -> sc_requirements) != RTS_MYREQUIRE) {
        !           295:        result = rtpktlose (acb, rti, RTS_PROTOCOL, NULLCP,
        !           296:                    "desired session requirements denied");
        !           297:        goto out1;
        !           298:     }
        !           299: 
        !           300: #define dotoken(requires,shift,bit,type) \
        !           301: { \
        !           302:     if (acb -> acb_requirements & requires) \
        !           303:        switch (sc -> sc_settings & (ST_MASK << shift)) { \
        !           304:            case ST_INIT_VALUE << shift: \
        !           305:                acb -> acb_owned |= bit; \
        !           306:                acb -> acb_avail |= bit; \
        !           307:                break; \
        !           308:  \
        !           309:            case ST_RESP_VALUE << shift: \
        !           310:                acb -> acb_avail |= bit; \
        !           311:                break; \
        !           312:  \
        !           313:            default: \
        !           314:                result = rtpktlose (acb, rti, RTS_PROTOCOL, NULLCP, \
        !           315:                            "%s token management botched", type); \
        !           316:                goto out1; \
        !           317:        } \
        !           318: }
        !           319:        dotokens ();
        !           320: #undef dotoken
        !           321:     switch (turn) {
        !           322:        case RTS_INITIATOR:
        !           323:            if (acb -> acb_owned == acb -> acb_avail)
        !           324:                break;
        !           325:            result = rtsaplose (rti, RTS_PROTOCOL, NULLCP,
        !           326:                    "token management botched");
        !           327:            goto out1;
        !           328: 
        !           329:        case RTS_RESPONDER:
        !           330:            if (acb -> acb_owned == 0)
        !           331:                break;
        !           332:            result = rtsaplose (rti, RTS_PROTOCOL, NULLCP,
        !           333:                    "token management botched");
        !           334:            goto out1;
        !           335:     }
        !           336:     acb -> acb_ssdusize = sc -> sc_ssdusize;
        !           337: 
        !           338:     PLOGP (rtsap_log,OACS_PAccept, pe, "PAccept", 1);
        !           339: 
        !           340:     if (parse_OACS_PAccept (pe, 1, NULLIP, NULLVP, &paccpt) == NOTOK) {
        !           341:        result = pylose ();
        !           342:        goto out1;
        !           343:     }
        !           344: 
        !           345:     acb -> acb_ckpoint = paccpt -> pUserData -> checkpointSize;
        !           346:     acb -> acb_window = paccpt -> pUserData -> windowsize;
        !           347: 
        !           348:     rtc -> rtc_sd = acb -> acb_fd;
        !           349:     rtc -> rtc_result = RTS_ACCEPT;
        !           350:     {
        !           351:        struct type_OACS_ConnectionData *pdat = paccpt -> pUserData -> member_OACS_5;
        !           352: 
        !           353:        if (pdat -> offset == type_OACS_ConnectionData_open)
        !           354:            rtc -> rtc_data = pe_expunge (pe, pdat -> un.open);
        !           355:        else
        !           356:            rtc -> rtc_data = NULLPE;
        !           357:     }
        !           358: 
        !           359:     if (paccpt)
        !           360:        free_OACS_PAccept (paccpt);
        !           361:     return OK;
        !           362: 
        !           363: out2: ;
        !           364:     free (base);
        !           365: 
        !           366: out1: ;
        !           367:     SCFREE (sc);
        !           368:     if (pe) {
        !           369:        if (data)
        !           370:            (void) pe_extract (pe, data);
        !           371:        pe_free (pe);
        !           372:     }
        !           373:     freeacblk (acb);
        !           374:     if (paccpt)
        !           375:        free_OACS_PAccept (paccpt);
        !           376: 
        !           377:     return result;
        !           378: }

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