![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to psapinitiate.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / psap2|
Return to psapinitiate.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / psap2 |
1.1 ! root 1: /* psapinitiate.c - PPM: initiator */ ! 2: ! 3: #ifndef lint ! 4: static char *rcsid = "$Header: /f/osi/psap2/RCS/psapinitiate.c,v 7.3 90/07/01 21:05:00 mrose Exp $"; ! 5: #endif ! 6: ! 7: /* ! 8: * $Header: /f/osi/psap2/RCS/psapinitiate.c,v 7.3 90/07/01 21:05:00 mrose Exp $ ! 9: * ! 10: * ! 11: * $Log: psapinitiate.c,v $ ! 12: * Revision 7.3 90/07/01 21:05:00 mrose ! 13: * pepsy ! 14: * ! 15: * Revision 7.2 90/01/27 10:26:29 mrose ! 16: * touch-up ! 17: * ! 18: * Revision 7.1 89/11/24 16:22:14 mrose ! 19: * sync ! 20: * ! 21: * Revision 7.0 89/11/23 22:14:20 mrose ! 22: * Release 6.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 "PS-types.h" ! 42: #include "ppkt.h" ! 43: #include "isoservent.h" ! 44: #include "tailor.h" ! 45: ! 46: /* P-(ASYN-)CONNECT.REQUEST */ ! 47: ! 48: int PAsynConnRequest (calling, called, ctxlist, defctxname, prequirements, ! 49: srequirements, isn, settings, ref, data, ndata, qos, pc, pi, async) ! 50: struct PSAPaddr *calling, ! 51: *called; ! 52: int prequirements, ! 53: srequirements, ! 54: settings, ! 55: ndata, ! 56: async; ! 57: long isn; ! 58: struct PSAPctxlist *ctxlist; ! 59: OID defctxname; ! 60: struct SSAPref *ref; ! 61: PE *data; ! 62: struct QOStype *qos; ! 63: struct PSAPconnect *pc; ! 64: struct PSAPindication *pi; ! 65: { ! 66: SBV smask; ! 67: int result; ! 68: ! 69: isodetailor (NULLCP, 0); ! 70: ! 71: #ifdef notdef ! 72: missingP (calling); ! 73: #endif ! 74: missingP (called); ! 75: ! 76: if (ctxlist && ctxlist -> pc_nctx > NPCTX) ! 77: return psaplose (pi, PC_PARAMETER, NULLCP, ! 78: "only %d proposed presentation contexts supported", NPCTX); ! 79: if (prequirements & ~PR_MYREQUIRE) ! 80: return psaplose (pi, PC_PARAMETER, NULLCP, ! 81: "presentation requirements settings not supported"); ! 82: if ((prequirements & PR_RESTORATION) ! 83: && !(prequirements & PR_MANAGEMENT)) ! 84: return psaplose (pi, PC_PARAMETER, NULLCP, ! 85: "context restoration service requires context management service"); ! 86: ! 87: /* let session provider catch errors in session parameters */ ! 88: ! 89: toomuchP (data, ndata, NPDATA, "initial"); ! 90: missingP (pc); ! 91: missingP (pi); ! 92: ! 93: smask = sigioblock (); ! 94: ! 95: result = PConnRequestAux (calling, called, ctxlist, defctxname, ! 96: prequirements, srequirements, isn, settings, ref, data, ndata, ! 97: qos, pc, pi, async); ! 98: ! 99: (void) sigiomask (smask); ! 100: ! 101: return result; ! 102: } ! 103: ! 104: /* */ ! 105: ! 106: static int PConnRequestAux (calling, called, ctxlist, defctxname, ! 107: prequirements, srequirements, isn, settings, ref, data, ndata, qos, ! 108: pc, pi, async) ! 109: struct PSAPaddr *calling, ! 110: *called; ! 111: int prequirements, ! 112: srequirements, ! 113: settings, ! 114: ndata, ! 115: async; ! 116: long isn; ! 117: struct PSAPctxlist *ctxlist; ! 118: OID defctxname; ! 119: struct SSAPref *ref; ! 120: PE *data; ! 121: struct QOStype *qos; ! 122: struct PSAPconnect *pc; ! 123: struct PSAPindication *pi; ! 124: { ! 125: int i, ! 126: len, ! 127: result; ! 128: PE pe; ! 129: register struct psapblk *pb; ! 130: struct SSAPconnect scs; ! 131: register struct SSAPconnect *sc = &scs; ! 132: struct SSAPindication sis; ! 133: register struct SSAPindication *si = &sis; ! 134: register struct SSAPabort *sa = &si -> si_abort; ! 135: register struct type_PS_CP__type *pdu; ! 136: register struct element_PS_0 *normal; ! 137: ! 138: if ((pb = newpblk ()) == NULL) ! 139: return psaplose (pi, PC_CONGEST, NULLCP, "out of memory"); ! 140: ! 141: pb -> pb_srequirements = pb -> pb_urequirements = srequirements; ! 142: ! 143: #ifdef notdef ! 144: if (called -> pa_selectlen > 0) { ! 145: if (calling == NULLPA) { ! 146: static struct PSAPaddr pas; ! 147: ! 148: calling = &pas; ! 149: bzero ((char *) calling, sizeof *calling); ! 150: } ! 151: ! 152: if (calling -> pa_selectlen == 0) { ! 153: calling -> pa_port = ! 154: htons ((u_short) (0x8000 | (getpid () & 0x7fff))); ! 155: calling -> pa_selectlen = sizeof calling -> pa_port; ! 156: } ! 157: } ! 158: #endif ! 159: ! 160: pe = NULLPE; ! 161: if ((pdu = (struct type_PS_CP__type *) calloc (1, sizeof *pdu)) == NULL) { ! 162: no_mem: ; ! 163: (void) psaplose (pi, PC_CONGEST, NULLCP, "out of memory"); ! 164: goto out2; ! 165: } ! 166: if ((pdu -> mode = (struct type_PS_Mode__selector *) ! 167: malloc (sizeof *pdu -> mode)) == NULL) ! 168: goto no_mem; ! 169: pdu -> mode -> parm = int_PS_Mode__selector_normal__mode; ! 170: if ((pdu -> normal__mode = (struct element_PS_0 *) ! 171: calloc (1, sizeof *pdu -> normal__mode)) ! 172: == NULL) ! 173: goto no_mem; ! 174: normal = pdu -> normal__mode; ! 175: if (calling ! 176: && calling -> pa_selectlen > 0 ! 177: && (normal -> calling = str2qb (calling -> pa_selector, ! 178: calling -> pa_selectlen, 1)) ! 179: == NULL) ! 180: goto no_mem; ! 181: if (called -> pa_selectlen > 0 ! 182: && (normal -> called = str2qb (called -> pa_selector, ! 183: called -> pa_selectlen, 1)) ! 184: == NULL) ! 185: goto no_mem; ! 186: ! 187: if ((pb -> pb_asn = ode2oid (DFLT_ASN)) == NULLOID) { ! 188: (void) psaplose (pi, PC_ABSTRACT, NULLCP, "%s: unknown", DFLT_ASN); ! 189: goto out2; ! 190: } ! 191: if ((pb -> pb_asn = oid_cpy (pb -> pb_asn)) == NULLOID) ! 192: goto no_mem; ! 193: if ((pb -> pb_atn = ode2oid (DFLT_ATN)) == NULLOID) { ! 194: (void) psaplose (pi, PC_TRANSFER, NULLCP, "%s: unknown", DFLT_ATN); ! 195: goto out2; ! 196: } ! 197: if ((pb -> pb_atn = oid_cpy (pb -> pb_atn)) == NULLOID) ! 198: goto no_mem; ! 199: if ((pb -> pb_ber = oid_cpy (pb -> pb_atn)) == NULLOID) ! 200: goto no_mem; ! 201: ! 202: if (ctxlist && ctxlist -> pc_nctx > 0) { ! 203: register struct type_PS_Definition__list *cd, ! 204: **cp; ! 205: register struct PSAPcontext *pp, ! 206: *qp; ! 207: ! 208: cp = &normal -> context__list; ! 209: ! 210: i = ctxlist -> pc_nctx - 1; ! 211: for (pp = ctxlist -> pc_ctx, qp = pb -> pb_contexts; ! 212: i >= 0; ! 213: i--, pp++, qp++){ ! 214: if (!((qp -> pc_id = pp -> pc_id) & 01)) { ! 215: (void) psaplose (pi, PC_PARAMETER, NULLCP, ! 216: "only odd values allowed for context identifiers"); ! 217: goto out2; ! 218: } ! 219: ! 220: if (pp -> pc_asn == NULLOID) { ! 221: (void) psaplose (pi, PC_PARAMETER, NULLCP, ! 222: "no abstract syntax name given for context %d", ! 223: pp -> pc_id); ! 224: goto out2; ! 225: } ! 226: if ((qp -> pc_asn = oid_cpy (pp -> pc_asn)) == NULLOID) ! 227: goto no_mem; ! 228: ! 229: if (pp -> pc_atn && !atn_is_ok (pb, pp -> pc_atn)) { ! 230: (void) psaplose (pi, PC_TRANSFER, NULLCP, ! 231: "unknown transfer syntax name given for context %d", ! 232: pp -> pc_id); ! 233: goto out2; ! 234: } ! 235: if ((qp -> pc_atn = oid_cpy (pp -> pc_atn ? pp -> pc_atn ! 236: : pb -> pb_atn)) == NULLOID) ! 237: goto no_mem; ! 238: ! 239: if ((cd =(struct type_PS_Definition__list *) ! 240: calloc (1, sizeof *cd)) == NULL) ! 241: goto no_mem; ! 242: *cp = cd; ! 243: cp = &cd -> next; ! 244: if ((cd -> element_PS_5 = (struct element_PS_6 *) ! 245: calloc (1, sizeof *cd -> element_PS_5)) == NULL) ! 246: goto no_mem; ! 247: cd -> element_PS_5 -> identifier = qp -> pc_id; ! 248: if ((cd -> element_PS_5 -> abstract__syntax = ! 249: oid_cpy (qp -> pc_asn)) == NULLOID ! 250: || (cd -> element_PS_5 -> transfer__syntax__list = ! 251: (struct element_PS_7 *) ! 252: calloc (1, sizeof (struct element_PS_7))) ! 253: == NULL ! 254: || (cd -> element_PS_5 -> transfer__syntax__list -> ! 255: Transfer__syntax__name = ! 256: oid_cpy (qp -> pc_atn)) ! 257: == NULL) ! 258: goto no_mem; ! 259: ! 260: qp -> pc_result = PC_ACCEPT; ! 261: ! 262: pb -> pb_ncontext++; ! 263: } ! 264: } ! 265: ! 266: if (defctxname) { ! 267: oid_free (pb -> pb_asn); ! 268: if ((pb -> pb_asn = oid_cpy (defctxname)) == NULLOID ! 269: || (normal -> default__context = ! 270: (struct type_PS_Context__name *) ! 271: calloc (1, sizeof *normal -> default__context)) ! 272: == NULL ! 273: || (normal -> default__context -> abstract__syntax = ! 274: oid_cpy (pb -> pb_asn)) == NULLOID ! 275: /* perhaps should be user-definable */ ! 276: || (normal -> default__context -> transfer__syntax = ! 277: oid_cpy (pb -> pb_atn)) == NULLOID) ! 278: goto no_mem; ! 279: } ! 280: pb -> pb_result = PC_ACCEPT; ! 281: ! 282: if ((pb -> pb_prequirements = prequirements) != PR_MYREQUIRE) { ! 283: register struct pair *pp; ! 284: ! 285: if ((normal -> presentation__fu = prim2bit (pe_alloc (PE_CLASS_UNIV, ! 286: PE_FORM_PRIM, ! 287: PE_PRIM_BITS))) ! 288: == NULL) ! 289: goto no_mem; ! 290: ! 291: for (pp = preq_pairs; pp -> p_mask; pp++) ! 292: if ((pb -> pb_prequirements & pp -> p_mask) ! 293: && bit_on (normal -> presentation__fu, pp -> p_bitno) ! 294: == NOTOK) ! 295: goto no_mem; ! 296: ! 297: if (bit2prim (normal -> presentation__fu) == NULLPE) ! 298: goto no_mem; ! 299: } ! 300: ! 301: if (pb -> pb_prequirements & PR_MANAGEMENT) ! 302: pb -> pb_srequirements |= SR_TYPEDATA; ! 303: if (pb -> pb_urequirements != pb -> pb_srequirements) { ! 304: register struct pair *pp; ! 305: ! 306: if ((normal -> session__fu = prim2bit (pe_alloc (PE_CLASS_UNIV, ! 307: PE_FORM_PRIM, ! 308: PE_PRIM_BITS))) ! 309: == NULL) ! 310: goto no_mem; ! 311: ! 312: for (pp = sreq_pairs; pp -> p_mask; pp++) ! 313: if ((pb -> pb_urequirements & pp -> p_mask) ! 314: && bit_on (normal -> session__fu, pp -> p_bitno) == NOTOK) ! 315: goto no_mem; ! 316: ! 317: if (bit2prim (normal -> session__fu) == NULLPE) ! 318: goto no_mem; ! 319: } ! 320: ! 321: if (data ! 322: && ndata > 0 ! 323: && (normal -> user__data = info2ppdu (pb, pi, data, ndata, ! 324: PPDU_CP)) == NULL) ! 325: goto out2; ! 326: ! 327: if (encode_PS_CP__type (&pe, 1, 0, NULLCP, pdu) == NOTOK) { ! 328: (void) psaplose (pi, PC_CONGEST, NULLCP, "error encoding PDU: %s", ! 329: PY_pepy); ! 330: goto out2; ! 331: } ! 332: ! 333: PLOGP (psap2_log,PS_CP__type, pe, "CP-type", 0); ! 334: ! 335: if (pe2ssdu (pe, &pb -> pb_retry, &len) == NOTOK) ! 336: goto no_mem; ! 337: ! 338: free_PS_CP__type (pdu); ! 339: pdu = NULL; ! 340: ! 341: pe_free (pe); ! 342: pe = NULLPE; ! 343: ! 344: if ((result = SAsynConnRequest (ref, calling ? &calling -> pa_addr ! 345: : NULLSA, &called -> pa_addr, pb -> pb_srequirements, settings, ! 346: isn, pb -> pb_retry, len, qos, sc, si, async)) == NOTOK) { ! 347: (void) ss2pslose (NULLPB, pi, "SAsynConnRequest", sa); ! 348: goto out1; ! 349: } ! 350: ! 351: pb -> pb_fd = sc -> sc_sd; ! 352: ! 353: if (async) { ! 354: switch (result) { ! 355: case CONNECTING_1: ! 356: case CONNECTING_2: ! 357: pc -> pc_sd = pb -> pb_fd; ! 358: return result; ! 359: } ! 360: } ! 361: if ((result = PAsynRetryAux (pb, sc, si, pc, pi)) == DONE && !async) ! 362: result = OK; ! 363: return result; ! 364: ! 365: out2: ; ! 366: if (pe) ! 367: pe_free (pe); ! 368: if (pdu) ! 369: free_PS_CP__type (pdu); ! 370: ! 371: out1: ; ! 372: freepblk (pb); ! 373: ! 374: return NOTOK; ! 375: } ! 376: ! 377: /* P-ASYN-RETRY.REQUEST (pseudo) */ ! 378: ! 379: int PAsynRetryRequest (sd, pc, pi) ! 380: int sd; ! 381: struct PSAPconnect *pc; ! 382: struct PSAPindication *pi; ! 383: { ! 384: SBV smask; ! 385: int result; ! 386: register struct psapblk *pb; ! 387: struct SSAPconnect scs; ! 388: register struct SSAPconnect *sc = &scs; ! 389: struct SSAPindication sis; ! 390: register struct SSAPindication *si = &sis; ! 391: register struct SSAPabort *sa = &si -> si_abort; ! 392: ! 393: missingP (pc); ! 394: missingP (pi); ! 395: ! 396: smask = sigioblock (); ! 397: ! 398: if ((pb = findpblk (sd)) == NULL) { ! 399: (void) sigiomask (smask); ! 400: return psaplose (pi, PC_PARAMETER, NULLCP, ! 401: "invalid presentation descriptor"); ! 402: } ! 403: if (pb -> pb_flags & PB_CONN) { ! 404: (void) sigiomask (smask); ! 405: return psaplose (pi, PC_OPERATION, NULLCP, ! 406: "presentation descriptor connected"); ! 407: } ! 408: ! 409: switch (result = SAsynRetryRequest (pb -> pb_fd, sc, si)) { ! 410: case NOTOK: ! 411: pb -> pb_fd = NOTOK; ! 412: (void) ss2pslose (pb, pi, "SAsynRetryRequest", sa); ! 413: freepblk (pb); ! 414: break; ! 415: ! 416: case CONNECTING_1: ! 417: case CONNECTING_2: ! 418: break; ! 419: ! 420: case DONE: ! 421: result = PAsynRetryAux (pb, sc, si, pc, pi); ! 422: break; ! 423: } ! 424: ! 425: (void) sigiomask (smask); ! 426: ! 427: return result; ! 428: } ! 429: ! 430: /* */ ! 431: ! 432: static int PAsynRetryAux (pb, sc, si, pc, pi) ! 433: register struct psapblk *pb; ! 434: struct SSAPconnect *sc; ! 435: struct SSAPindication *si; ! 436: struct PSAPconnect *pc; ! 437: struct PSAPindication *pi; ! 438: { ! 439: int i, ! 440: result; ! 441: PE pe; ! 442: struct qbuf *qb; ! 443: register struct SSAPabort *sa = &si -> si_abort; ! 444: struct type_PS_CPA__type *cpa; ! 445: register struct element_PS_1 *cpa_normal; ! 446: struct type_PS_CPR__type *cpr; ! 447: register struct element_PS_2 *cpr_normal; ! 448: struct type_PS_ARP__PPDU *arp; ! 449: ! 450: pe = NULLPE; ! 451: ! 452: free (pb -> pb_retry); ! 453: pb -> pb_retry = NULL; ! 454: ! 455: bzero ((char *) pc, sizeof *pc); ! 456: ! 457: if (sc -> sc_result == SC_ABORT) { ! 458: (void) ss2psabort (pb, sa, pi); ! 459: ! 460: pc -> pc_sd = NOTOK; ! 461: pc -> pc_result = PC_ABORTED; ! 462: ! 463: return DONE; ! 464: } ! 465: ! 466: cpa = NULL, cpr = NULL, arp = NULL; ! 467: if ((pe = ssdu2pe (sc -> sc_data, sc -> sc_cc, NULLCP, &result)) ! 468: == NULLPE) { ! 469: if (sc -> sc_result != SC_ACCEPT) { ! 470: bzero ((char *) sa, sizeof *sa); ! 471: sa -> sa_reason = sc -> sc_result; ! 472: pb -> pb_fd = NOTOK; ! 473: (void) ss2pslose (pb, pi, "SAsynConnRequest(pseudo)", sa); ! 474: ! 475: pc -> pc_sd = NOTOK; ! 476: pc -> pc_result = pi -> pi_abort.pa_reason; ! 477: ! 478: result = DONE; ! 479: goto out1; ! 480: } ! 481: else ! 482: (void) ppktlose (pb, pi, result != PS_ERR_NMEM ? PC_UNRECOGNIZED ! 483: : PC_NOTSPECIFIED, sc -> sc_result == SC_ACCEPT ? PPDU_CPA ! 484: : PPDU_CPR, NULLCP, "%s", ps_error (result)); ! 485: goto out2; ! 486: } ! 487: ! 488: SCFREE (sc); ! 489: ! 490: if (sc -> sc_result == SC_ACCEPT) { ! 491: pb -> pb_flags |= PB_CONN; ! 492: ! 493: pb -> pb_srequirements = sc -> sc_requirements; ! 494: pb -> pb_urequirements &= pb -> pb_srequirements; ! 495: ! 496: #define dotoken(requires,shift,bit,type) \ ! 497: { \ ! 498: if (pb -> pb_srequirements & requires) \ ! 499: switch (sc -> sc_settings & (ST_MASK << shift)) { \ ! 500: case ST_INIT_VALUE << shift: \ ! 501: pb -> pb_owned |= bit; \ ! 502: pb -> pb_avail |= bit; \ ! 503: break; \ ! 504: \ ! 505: case ST_RESP_VALUE << shift: \ ! 506: pb -> pb_avail |= bit; \ ! 507: break; \ ! 508: } \ ! 509: } ! 510: dotokens (); ! 511: #undef dotoken ! 512: ! 513: pb -> pb_ssdusize = sc -> sc_ssdusize; ! 514: ! 515: if (decode_PS_CPA__type (pe, 1, NULLIP, NULLVP, &cpa) == NOTOK) { ! 516: (void) ppktlose (pb, pi, PC_UNRECOGNIZED, PPDU_CPA, NULLCP, "%s", ! 517: PY_pepy); ! 518: goto out2; ! 519: } ! 520: ! 521: PLOGP (psap2_log,PS_CPA__type, pe, "CPA-type", 1); ! 522: ! 523: if (cpa -> mode -> parm != int_PS_Mode__selector_normal__mode) { ! 524: (void) ppktlose (pb, pi, PC_INVALID, PPDU_CPA, NULLCP, ! 525: "X.410 mode mismatch"); ! 526: goto out2; ! 527: } ! 528: cpa_normal = cpa -> normal__mode; ! 529: ! 530: pc -> pc_sd = pb -> pb_fd; ! 531: } ! 532: else { ! 533: if (sc -> sc_result == SC_NOTSPECIFIED) { ! 534: if (decode_PS_ARP__PPDU (pe, 1, NULLIP, NULLVP, &arp) == NOTOK) { ! 535: (void) ppktlose (pb, pi, PC_UNRECOGNIZED, PPDU_ARP, NULLCP, ! 536: "%s", PY_pepy); ! 537: goto out2; ! 538: } ! 539: ! 540: PLOGP (psap2_log,PS_ARP__PPDU, pe, "ARP-PPDU", 1); ! 541: ! 542: if (arp -> provider__reason) { ! 543: if ((result = arp -> provider__reason -> parm) == 0) ! 544: result = PC_NOTSPECIFIED; ! 545: else ! 546: result += PC_ABORT_BASE; ! 547: } ! 548: else ! 549: result = PC_NOTSPECIFIED; ! 550: ! 551: (void) psaplose (pi, result, NULLCP, NULLCP); ! 552: goto out2; ! 553: } ! 554: ! 555: if (decode_PS_CPR__type (pe, 1, NULLIP, NULLVP, &cpr) == NOTOK) { ! 556: (void) ppktlose (pb, pi, PC_UNRECOGNIZED, PPDU_CPR, NULLCP, "%s", ! 557: PY_pepy); ! 558: goto out2; ! 559: } ! 560: ! 561: PLOGP (psap2_log,PS_CPR__type, pe, "CPR-type", 1); ! 562: ! 563: if (cpr -> offset != type_PS_CPR__type_normal__mode) { ! 564: (void) ppktlose (pb, pi, PC_INVALID, PPDU_CPR, NULLCP, ! 565: "X.410 mode mismatch"); ! 566: goto out2; ! 567: } ! 568: cpr_normal = cpr -> un.normal__mode; ! 569: ! 570: pc -> pc_sd = NOTOK; ! 571: } ! 572: ! 573: pb -> pb_responding.pa_addr = sc -> sc_responding; /* struct copy */ ! 574: if (qb = cpa ? cpa_normal -> responding : cpr_normal -> responding) { ! 575: char *base; ! 576: ! 577: if ((base = qb2str (qb)) == NULLCP ! 578: && sc -> sc_result == SC_ACCEPT) { ! 579: (void) ppktlose (pb, pi, PC_INVALID, PPDU_CPA, NULLCP, ! 580: "malformed PSAP selector"); ! 581: goto out2; ! 582: } ! 583: if (base) { ! 584: if (qb -> qb_len > sizeof pc -> pc_responding.pa_selector) ! 585: qb -> qb_len = sizeof pc -> pc_responding.pa_selector; ! 586: bcopy (base, pb -> pb_responding.pa_selector, ! 587: pb -> pb_responding.pa_selectlen = qb -> qb_len); ! 588: free (base); ! 589: } ! 590: } ! 591: pc -> pc_responding = pb -> pb_responding; /* struct copy */ ! 592: ! 593: { ! 594: register struct PSAPcontext *pp, ! 595: *qp; ! 596: register struct type_PS_Definition__result__list *lp, ! 597: *mp; ! 598: ! 599: i = 0; ! 600: lp = cpa ? cpa_normal -> context__list : cpr_normal -> context__list; ! 601: for (mp = lp; mp; mp = mp -> next) ! 602: i++; ! 603: if (i != pb -> pb_ncontext && i != 0) { ! 604: if (sc -> sc_result != SC_ACCEPT) { ! 605: pc -> pc_ctxlist.pc_nctx = 0; ! 606: goto carry_on; ! 607: } ! 608: ! 609: (void) ppktlose (pb, pi, PC_INVALID, PPDU_CPA, NULLCP, ! 610: "proposed/resulting presentation contexts mismatch"); ! 611: goto out2; ! 612: } ! 613: ! 614: i = (pc -> pc_ctxlist.pc_nctx = pb -> pb_ncontext) - 1; ! 615: for (pp = pc -> pc_ctxlist.pc_ctx, qp = pb -> pb_contexts, mp = lp; ! 616: i >= 0; ! 617: i--, pp++, qp++) { ! 618: pp -> pc_id = qp -> pc_id; ! 619: pp -> pc_asn = pp -> pc_atn = NULLOID; ! 620: ! 621: if (lp == NULL) { ! 622: pp -> pc_result = PC_ACCEPT; ! 623: continue; ! 624: } ! 625: ! 626: switch (mp -> element_PS_12 -> result) { ! 627: case int_PS_result_acceptance: ! 628: /* assume they gave back ASN.1 */ ! 629: default: ! 630: pp -> pc_result = qp -> pc_result = PC_ACCEPT; ! 631: break; ! 632: ! 633: case int_PS_result_user__rejection: ! 634: pp -> pc_result = qp -> pc_result = PC_REJECTED; ! 635: break; ! 636: ! 637: case int_PS_result_provider__rejection: ! 638: if ((pp -> pc_result = ! 639: mp -> element_PS_12 -> provider__reason) == 0) ! 640: pp -> pc_result = PC_NOTSPECIFIED; ! 641: else ! 642: pp -> pc_result += PC_REASON_BASE; ! 643: qp -> pc_result = pp -> pc_result; ! 644: break; ! 645: } ! 646: ! 647: mp = mp -> next; ! 648: } ! 649: ! 650: i = pb -> pb_ncontext - 1; ! 651: for (qp = pb -> pb_contexts + i; i >= 0; i--, qp--) ! 652: if (qp -> pc_result != PC_ACCEPT) { ! 653: register struct PSAPcontext *qqp; ! 654: ! 655: qqp = pb -> pb_contexts + --pb -> pb_ncontext; ! 656: if (qp -> pc_asn) ! 657: oid_free (qp -> pc_asn); ! 658: if (qp -> pc_atn) ! 659: oid_free (qp -> pc_atn); ! 660: if (qp != qqp) ! 661: *qp = *qqp; /* struct copy */ ! 662: } ! 663: } ! 664: carry_on: ; ! 665: ! 666: if (cpr == NULL || cpr_normal -> default__context == NULL) ! 667: pc -> pc_defctxresult = PC_ACCEPT; ! 668: else ! 669: switch (cpr_normal -> default__context -> parm) { ! 670: case int_PS_Result_acceptance: ! 671: default: ! 672: pc -> pc_defctxresult = PC_ACCEPT; ! 673: break; ! 674: ! 675: case int_PS_Result_user__rejection: ! 676: pc -> pc_defctxresult = PC_REJECTED; ! 677: break; ! 678: ! 679: case int_PS_Result_provider__rejection: ! 680: pc -> pc_defctxresult = PC_NOTSPECIFIED; ! 681: break; ! 682: } ! 683: ! 684: if (ppdu2info (pb, pi, cpa ? cpa_normal -> user__data ! 685: : cpr_normal -> user__data, pc -> pc_info, ! 686: &pc -> pc_ninfo, cpa ? PPDU_CPA : PPDU_CPR) == NOTOK) ! 687: goto out2; ! 688: ! 689: if (sc -> sc_result == SC_ACCEPT) { ! 690: if (cpa_normal -> presentation__fu) { ! 691: register struct pair *pp; ! 692: ! 693: if (!(pb -> pb_srequirements & SR_TYPEDATA)) { ! 694: (void) bit_off (cpa_normal -> presentation__fu, ! 695: bit_PS_Presentation__requirements_context__management); ! 696: (void) bit_off (cpa_normal -> presentation__fu, ! 697: bit_PS_Presentation__requirements_restoration); ! 698: } ! 699: for (pp = preq_pairs; pp -> p_mask; pp++) ! 700: if (!(pb -> pb_prequirements & pp -> p_mask)) { ! 701: if (bit_test (cpa_normal -> presentation__fu, ! 702: pp -> p_bitno) == 1) { ! 703: (void) ppktlose (pb, pi, PC_INVALID, PPDU_CPA, NULLCP, ! 704: "presentation-requirements negotiation botched"); ! 705: goto out2; ! 706: } ! 707: } ! 708: else ! 709: if (bit_test (cpa_normal -> presentation__fu, ! 710: pp -> p_bitno) < 1) ! 711: pb -> pb_prequirements &= ~pp -> p_mask; ! 712: } ! 713: pc -> pc_prequirements = pb -> pb_prequirements; ! 714: ! 715: if (cpa_normal -> session__fu) { ! 716: register struct pair *pp; ! 717: ! 718: for (pp = preq_pairs; pp -> p_mask; pp++) ! 719: if (bit_test (cpa_normal -> session__fu, pp -> p_bitno) < 1) ! 720: pb -> pb_urequirements &= ~pp -> p_mask; ! 721: } ! 722: pc -> pc_srequirements = pb -> pb_urequirements; ! 723: pc -> pc_settings = sc -> sc_settings; ! 724: pc -> pc_please = sc -> sc_please; ! 725: pc -> pc_isn = sc -> sc_isn; ! 726: ! 727: pc -> pc_connect = sc -> sc_connect; /* struct copy */ ! 728: ! 729: pc -> pc_ssdusize = sc -> sc_ssdusize; ! 730: ! 731: pc -> pc_qos = sc -> sc_qos; /* struct copy */ ! 732: ! 733: pc -> pc_result = PC_ACCEPT; ! 734: ! 735: free_PS_CPA__type (cpa); ! 736: } ! 737: else { ! 738: if (cpr_normal -> optionals & opt_PS_element_PS_2_reason) ! 739: pc -> pc_result = cpr_normal -> reason + PC_PROV_BASE; ! 740: else ! 741: pc -> pc_result = PC_NOTSPECIFIED; ! 742: ! 743: free_PS_CPR__type (cpr); ! 744: freepblk (pb); ! 745: } ! 746: ! 747: pe_free (pe); ! 748: ! 749: return DONE; ! 750: ! 751: out2: ; ! 752: result = NOTOK; ! 753: if (pe) ! 754: pe_free (pe); ! 755: if (cpa) ! 756: free_PS_CPA__type (cpa); ! 757: if (cpr) ! 758: free_PS_CPR__type (cpr); ! 759: if (arp) ! 760: free_PS_ARP__PPDU (arp); ! 761: ! 762: out1: ; ! 763: SCFREE (sc); ! 764: freepblk (pb); ! 765: ! 766: return result; ! 767: } ! 768: ! 769: /* P-ASYN-NEXT.REQUEST (pseudo) */ ! 770: ! 771: int PAsynNextRequest (sd, pc, pi) ! 772: int sd; ! 773: struct PSAPconnect *pc; ! 774: struct PSAPindication *pi; ! 775: { ! 776: SBV smask; ! 777: int result; ! 778: register struct psapblk *pb; ! 779: struct SSAPconnect scs; ! 780: register struct SSAPconnect *sc = &scs; ! 781: struct SSAPindication sis; ! 782: register struct SSAPindication *si = &sis; ! 783: register struct SSAPabort *sa = &si -> si_abort; ! 784: ! 785: missingP (pc); ! 786: missingP (pi); ! 787: ! 788: smask = sigioblock (); ! 789: ! 790: if ((pb = findpblk (sd)) == NULL) { ! 791: (void) sigiomask (smask); ! 792: return psaplose (pi, PC_PARAMETER, NULLCP, ! 793: "invalid presentation descriptor"); ! 794: } ! 795: if (pb -> pb_flags & PB_CONN) { ! 796: (void) sigiomask (smask); ! 797: return psaplose (pi, PC_OPERATION, NULLCP, ! 798: "presentation descriptor connected"); ! 799: } ! 800: ! 801: switch (result = SAsynNextRequest (pb -> pb_fd, sc, si)) { ! 802: case NOTOK: ! 803: pb -> pb_fd = NOTOK; ! 804: (void) ss2pslose (pb, pi, "SAsynRetryRequest", sa); ! 805: freepblk (pb); ! 806: break; ! 807: ! 808: case CONNECTING_1: ! 809: case CONNECTING_2: ! 810: break; ! 811: ! 812: case DONE: ! 813: result = PAsynRetryAux (pb, sc, si, pc, pi); ! 814: break; ! 815: } ! 816: ! 817: (void) sigiomask (smask); ! 818: ! 819: return result; ! 820: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.