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