![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to psaprovider.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 psaprovider.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / psap2 |
1.1 root 1: /* psaprovider.c - implement the presentation protocol */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/psap2/RCS/psaprovider.c,v 7.3 90/07/01 21:05:11 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/psap2/RCS/psaprovider.c,v 7.3 90/07/01 21:05:11 mrose Exp $
9: *
10: *
11: * $Log: psaprovider.c,v $
12: * Revision 7.3 90/07/01 21:05:11 mrose
13: * pepsy
14: *
15: * Revision 7.2 90/03/23 17:27:48 mrose
16: * update
17: *
18: * Revision 7.1 89/11/24 16:22:20 mrose
19: * sync
20: *
21: * Revision 7.0 89/11/23 22:14:33 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 "tailor.h"
44:
45: /* DATA */
46:
47: static int once_only = 0;
48: static struct psapblk psapque;
49: static struct psapblk *PHead = &psapque;
50:
51:
52: struct pair preq_pairs[] = {
53: PR_MANAGEMENT, bit_PS_Presentation__requirements_context__management,
54: PR_RESTORATION, bit_PS_Presentation__requirements_restoration,
55: 0, 0
56: };
57:
58:
59: struct pair sreq_pairs[] = {
60: SR_HALFDUPLEX, bit_PS_User__session__requirements_half__duplex,
61: SR_DUPLEX, bit_PS_User__session__requirements_duplex,
62: SR_EXPEDITED, bit_PS_User__session__requirements_expedited__data,
63: SR_MINORSYNC, bit_PS_User__session__requirements_minor__synchronize,
64: SR_MAJORSYNC, bit_PS_User__session__requirements_major__synchronize,
65: SR_RESYNC, bit_PS_User__session__requirements_resynchronize,
66: SR_ACTIVITY, bit_PS_User__session__requirements_activity__management,
67: SR_NEGOTIATED, bit_PS_User__session__requirements_negotiated__release,
68: SR_CAPABILITY, bit_PS_User__session__requirements_capability__data,
69: SR_EXCEPTIONS, bit_PS_User__session__requirements_exceptions,
70: SR_TYPEDATA, bit_PS_User__session__requirements_typed__data,
71: 0, 0
72: };
73:
74: /* */
75:
76: #define doABORT ss2psabort
77:
78:
79: int DATAser (), TOKENser (), SYNCser (), ACTIVITYser (), REPORTser (),
80: FINISHser (), ABORTser ();
81:
82:
83: /* P-[*-]DATA.REQUEST */
84:
85: int PDataRequest (sd, data, ndata, pi)
86: int sd;
87: PE *data;
88: int ndata;
89: struct PSAPindication *pi;
90: {
91: return PDataRequestAux (sd, data, ndata, pi, "user", SDataRequest,
92: "SDataRequest", "P-DATA user-data", PPDU_TD);
93: }
94:
95: /* */
96:
97: int PDataRequestAux (sd, data, ndata, pi, dtype, sfunc, stype, text, ppdu)
98: int sd;
99: PE *data;
100: int ndata;
101: struct PSAPindication *pi;
102: char *dtype,
103: *stype,
104: *text;
105: IFP sfunc;
106: int ppdu;
107: {
108: SBV smask;
109: int i,
110: len,
111: result;
112: char *base,
113: *realbase;
114: register struct psapblk *pb;
115: struct SSAPindication sis;
116: register struct SSAPabort *sa = &sis.si_abort;
117: register PE *d,
118: p;
119:
120: missingP (data);
121: toomuchP (data, ndata, NPDATA, dtype);
122: if (ndata <= 0)
123: return psaplose (pi, PC_PARAMETER, NULLCP,
124: "illegal number of PDVs (%d)", ndata);
125: missingP (pi);
126: missingP (sfunc);
127: missingP (stype);
128: missingP (text);
129:
130: smask = sigioblock ();
131:
132: psapPsig (pb, sd);
133:
134: if (ppdu == PPDU_TE) {
135: for (d = data, i = 0; i < ndata; i++)
136: if ((p = *d++) && p -> pe_context != PE_DFLT_CTX) {
137: (void) sigiomask (smask);
138: return psaplose (pi, PC_OPERATION, NULLCP,
139: "defined context not permited with expedited service");
140: }
141: }
142:
143: if (ppdu == PPDU_TTD && !(pb -> pb_urequirements & SR_TYPEDATA)) {
144: (void) sigiomask (smask);
145: return psaplose (pi, PC_OPERATION, NULLCP,
146: "typed data service unavailable");
147: }
148:
149: if ((result = info2ssdu (pb, pi, data, ndata, &realbase, &base, &len, text,
150: ppdu)) != OK)
151: goto out2;
152:
153: if ((result = (*sfunc) (sd, base, len, &sis)) == NOTOK)
154: if (SC_FATAL (sa -> sa_reason))
155: (void) ss2pslose (pb, pi, stype, sa);
156: else {
157: (void) ss2pslose (NULLPB, pi, stype, sa);
158: goto out1;
159: }
160:
161: out2: ;
162: if (result == NOTOK)
163: freepblk (pb);
164: else
165: if (result == DONE)
166: result = NOTOK;
167: out1: ;
168: if (realbase)
169: free (realbase);
170: else
171: if (base)
172: free (base);
173:
174: (void) sigiomask (smask);
175:
176: return result;
177: }
178:
179: /* P-READ.REQUEST (pseudo) */
180:
181: int PReadRequest (sd, px, secs, pi)
182: int sd;
183: struct PSAPdata *px;
184: int secs;
185: struct PSAPindication *pi;
186: {
187: SBV smask;
188: int result;
189: register struct psapblk *pb;
190:
191: missingP (px);
192: missingP (pi);
193:
194: smask = sigioblock ();
195:
196: psapPsig (pb, sd);
197:
198: result = PReadRequestAux (pb, px, secs, pi);
199:
200: (void) sigiomask (smask);
201:
202: return result;
203: }
204:
205: /* */
206:
207: static int PReadRequestAux (pb, px, secs, pi)
208: register struct psapblk *pb;
209: struct PSAPdata *px;
210: int secs;
211: register struct PSAPindication *pi;
212: {
213: int result;
214: struct SSAPdata sxs;
215: register struct SSAPdata *sx = &sxs;
216: struct SSAPindication sis;
217: register struct SSAPindication *si = &sis;
218:
219: bzero ((char *) px, sizeof *px);
220: bzero ((char *) pi, sizeof *pi);
221:
222: for (;;) {
223: switch (result = SReadRequest (pb -> pb_fd, sx, secs, si)) {
224: case NOTOK:
225: return doABORT (pb, &si -> si_abort, pi);
226:
227: case OK:
228: return doDATA (pb, sx, px, pi);
229:
230: case DONE:
231: switch (si -> si_type) {
232: case SI_TOKEN:
233: return doTOKEN (pb, &si -> si_token, pi);
234:
235: case SI_SYNC:
236: return doSYNC (pb, &si -> si_sync, pi);
237:
238: case SI_ACTIVITY:
239: return doACTIVITY (pb, &si -> si_activity, pi);
240:
241: case SI_REPORT:
242: return doREPORT (pb, &si -> si_report, pi);
243:
244: case SI_FINISH:
245: return doFINISH (pb, &si -> si_finish, pi);
246:
247: default:
248: (void) ppktlose (pb, pi, PC_PROTOCOL, PPDU_NONE,
249: NULLCP,
250: "unknown indication (0x%x) from session",
251: si -> si_type);
252: break;
253: }
254: break;
255:
256: default:
257: (void) ppktlose (pb, pi, PC_PROTOCOL, PPDU_NONE, NULLCP,
258: "unexpected return from SReadRequest=%d", result);
259: break;
260: }
261: break;
262: }
263:
264: freepblk (pb);
265: return NOTOK;
266: }
267:
268: /* */
269:
270: static int doDATA (pb, sx, px, pi)
271: register struct psapblk *pb;
272: register struct SSAPdata *sx;
273: register struct PSAPdata *px;
274: struct PSAPindication *pi;
275: {
276: int ppdu,
277: result;
278: char *text;
279:
280: switch (px -> px_type = sx -> sx_type) {
281: case SX_NORMAL:
282: ppdu = PPDU_TD;
283: text = "P-DATA user-data";
284: break;
285:
286: case SX_EXPEDITED:
287: ppdu = PPDU_TE;
288: text = "P-EXPEDITED-DATA user-data";
289: break;
290:
291: case SX_CAPDIND:
292: ppdu = PPDU_TC;
293: goto capd;
294: case SX_CAPDCNF:
295: ppdu = PPDU_TCC;
296: capd: ;
297: text = "P-CAPABILITY-DATA user-data";
298: break;
299:
300: case SX_TYPED:
301: ppdu = PPDU_TTD;
302: text = "P-TYPED-DATA user-data";
303: break;
304:
305: default:
306: result = ppktlose (pb, pi, PC_PROTOCOL, PPDU_NONE, NULLCP,
307: "unknown data indication type=0x%x, %d bytes",
308: sx -> sx_type, sx -> sx_cc);
309: freepblk (pb);
310: goto out;
311: }
312:
313: result = qbuf2info (pb, pi, &sx -> sx_qbuf, sx -> sx_cc,
314: px -> px_info, &px -> px_ninfo, text, ppdu);
315:
316: out: ;
317: if (result == NOTOK)
318: SXFREE (sx);
319:
320: return result;
321: }
322:
323: /* */
324:
325: static int doTOKEN (pb, st, pi)
326: register struct psapblk *pb;
327: register struct SSAPtoken *st;
328: struct PSAPindication *pi;
329: {
330: int result;
331: register struct PSAPtoken *pt = &pi -> pi_token;
332:
333: pi -> pi_type = PI_TOKEN;
334:
335: pt -> pt_type = st -> st_type;
336: pt -> pt_tokens = st -> st_tokens;
337: pt -> pt_owned = pb -> pb_owned = st -> st_owned;
338:
339: result = ssdu2info (pb, pi, st -> st_data, st -> st_cc, pt -> pt_info,
340: &pt -> pt_ninfo, "P-PLEASE-TOKEN user-data", PPDU_NONE);
341:
342: STFREE (st);
343:
344: return (result != NOTOK ? DONE : NOTOK);
345: }
346:
347: /* */
348:
349: static int doSYNC (pb, sn, pi)
350: register struct psapblk *pb;
351: register struct SSAPsync *sn;
352: struct PSAPindication *pi;
353: {
354: int result;
355: register struct PSAPsync *pn = &pi -> pi_sync;
356:
357: pi -> pi_type = PI_SYNC;
358:
359: pn -> pn_type = sn -> sn_type;
360: pn -> pn_options = sn -> sn_options;
361: pn -> pn_ssn = sn -> sn_ssn;
362: pn -> pn_settings = sn -> sn_settings;
363:
364: result = ssdu2info (pb, pi, sn -> sn_data, sn -> sn_cc, pn -> pn_info,
365: &pn -> pn_ninfo, sn -> sn_type <= SN_MAJORCNF
366: ? "P-MAJOR-SYNC user-data"
367: : sn -> sn_type <= SN_MINORCNF
368: ? "P-MINOR-SYNC user-data"
369: : "P-RESYNCHRONIZE user-data",
370: sn -> sn_type == SN_RESETIND
371: ? PPDU_RS
372: : sn -> sn_type == SN_RESETCNF
373: ? PPDU_RSA
374: : PPDU_NONE);
375:
376: SNFREE (sn);
377:
378: return (result != NOTOK ? DONE : NOTOK);
379: }
380:
381: /* */
382:
383: static int doACTIVITY (pb, sv, pi)
384: register struct psapblk *pb;
385: register struct SSAPactivity *sv;
386: struct PSAPindication *pi;
387: {
388: int result;
389: register struct PSAPactivity *pv = &pi -> pi_activity;
390:
391: pi -> pi_type = PI_ACTIVITY;
392:
393: pv -> pv_type = sv -> sv_type;
394: pv -> pv_id = sv -> sv_id; /* struct copy */
395: pv -> pv_oid = sv -> sv_oid; /* struct copy */
396: pv -> pv_connect = sv -> sv_connect; /* struct copy */
397: pv -> pv_ssn = sv -> sv_ssn;
398: pv -> pv_reason = sv -> sv_reason;
399:
400: result = ssdu2info (pb, pi, sv -> sv_data, sv -> sv_cc, pv -> pv_info,
401: &pv -> pv_ninfo, sv -> sv_type <= SV_START
402: ? "P-ACTIVITY-START user-data"
403: : sv -> sv_type <= SV_RESUME
404: ? "P-ACTIVITY-RESUME user-data"
405: : "P-ACTIVITY-END user-data", PPDU_NONE);
406:
407: SVFREE (sv);
408:
409: return (result != NOTOK ? DONE : NOTOK);
410: }
411:
412: /* */
413:
414: static int doREPORT (pb, sp, pi)
415: register struct psapblk *pb;
416: register struct SSAPreport *sp;
417: struct PSAPindication *pi;
418: {
419: int result;
420: register struct PSAPreport *pp = &pi -> pi_report;
421:
422: pi -> pi_type = PI_REPORT;
423:
424: pp -> pp_peer = sp -> sp_peer;
425: pp -> pp_reason = sp -> sp_reason;
426:
427: result = ssdu2info (pb, pi, sp -> sp_data, sp -> sp_cc, pp -> pp_info,
428: &pp -> pp_ninfo, "P-U-EXCEPTION-REPORT user-data", PPDU_NONE);
429:
430: SPFREE (sp);
431:
432: return (result != NOTOK ? DONE : NOTOK);
433: }
434:
435: /* */
436:
437: static int doFINISH (pb, sf, pi)
438: register struct psapblk *pb;
439: register struct SSAPfinish *sf;
440: struct PSAPindication *pi;
441: {
442: int result;
443: register struct PSAPfinish *pf = &pi -> pi_finish;
444:
445: pi -> pi_type = PI_FINISH;
446:
447: result = ssdu2info (pb, pi, sf -> sf_data, sf -> sf_cc, pf -> pf_info,
448: &pf -> pf_ninfo, "P-RELEASE user-data", PPDU_NONE);
449:
450: SFFREE (sf);
451:
452: if (result == NOTOK)
453: return NOTOK;
454:
455: pb -> pb_flags |= PB_FINN;
456:
457: return DONE;
458: }
459:
460: /* */
461:
462: int ss2psabort (pb, sa, pi)
463: register struct psapblk *pb;
464: register struct SSAPabort *sa;
465: struct PSAPindication *pi;
466: {
467: int result,
468: ppdu;
469: register PE pe;
470: register struct PSAPabort *pa = &pi -> pi_abort;
471: struct type_PS_Abort__type *pdu;
472: register struct element_PS_3 *aru;
473: register struct type_PS_ARP__PPDU *arp;
474: register struct type_PS_User__data *info;
475:
476: pdu = NULL, pe = NULLPE;
477: if (!sa -> sa_peer) {
478: if (sa -> sa_reason == SC_TIMER)
479: return psaplose (pi, PC_TIMER, NULLCP, NULLCP);
480:
481: (void) ss2pslose (pb, pi, NULLCP, sa);
482: goto out;
483: }
484:
485: if (sa -> sa_cc == 0) {
486: (void) psaplose (pi, PC_ABORTED, NULLCP, NULLCP);
487: goto out;
488: }
489:
490: bzero ((char *) pi, sizeof *pi);
491: pi -> pi_type = PI_ABORT;
492:
493: if ((pe = ssdu2pe (sa -> sa_info, sa -> sa_cc, NULLCP, &result))
494: == NULLPE) {
495: (void) psaplose (pi, result == PS_ERR_NMEM ? PC_CONGEST : PC_PROTOCOL,
496: NULLCP, "%s", ps_error (result));
497: goto out;
498: }
499:
500: if (decode_PS_Abort__type (pe, 1, NULLIP, NULLVP, &pdu) == NOTOK) {
501: (void) psaplose (pi, PC_UNRECOGNIZED, NULLCP, "%s", PY_pepy);
502: goto out;
503: }
504:
505: PLOGP (psap2_log,PS_Abort__type, pe, "Abort-type", 1);
506:
507: switch (pdu -> offset) {
508: default:
509: pa -> pa_peer = 1;
510: pa -> pa_reason = PC_ABORTED;
511: info = NULL, ppdu = PPDU_NONE;
512: break;
513:
514: case type_PS_Abort__type_normal__mode:
515: aru = pdu -> un.normal__mode;
516: pa -> pa_peer = 1;
517: pa -> pa_reason = PC_ABORTED;
518: info = aru -> user__data, ppdu = PPDU_ARU;
519: break;
520:
521: case type_PS_Abort__type_provider__abort:
522: if ((arp = pdu -> un.provider__abort) -> provider__reason) {
523: if ((result = arp -> provider__reason -> parm) == 0)
524: result = PC_NOTSPECIFIED;
525: else
526: result += PC_ABORT_BASE;
527: }
528: else
529: result = PC_NOTSPECIFIED;
530:
531: (void) psaplose (pi, result, NULLCP, NULLCP);
532: info = NULL, ppdu = PPDU_ARP;
533: break;
534: }
535:
536: (void) ppdu2info (pb, pi, info, pa -> pa_info, &pa -> pa_ninfo, ppdu);
537:
538: out: ;
539: SAFREE (sa);
540: if (pe)
541: pe_free (pe);
542: if (pdu)
543: free_PS_Abort__type (pdu);
544: pb -> pb_fd = NOTOK;
545: freepblk (pb);
546:
547: return NOTOK;
548: }
549:
550: /* define vectors for INDICATION events */
551:
552: #define e(i) (data ? (i) : NULLIFP)
553:
554:
555: int PSetIndications (sd, data, tokens, sync, activity, report, finish,
556: abort, pi)
557: int sd;
558: IFP data,
559: tokens,
560: sync,
561: activity,
562: report,
563: finish,
564: abort;
565: struct PSAPindication *pi;
566: {
567: SBV smask;
568: register struct psapblk *pb;
569: struct SSAPindication sis;
570: register struct SSAPabort *sa = &sis.si_abort;
571:
572: if (data || tokens || sync || activity || report || finish || abort) {
573: missingP (data);
574: missingP (tokens);
575: missingP (sync);
576: missingP (activity);
577: missingP (report);
578: missingP (finish);
579: missingP (abort);
580: }
581:
582: smask = sigioblock ();
583:
584: psapPsig (pb, sd);
585:
586: if (SSetIndications (pb -> pb_fd, e (DATAser), e (TOKENser),
587: e (SYNCser), e (ACTIVITYser), e (REPORTser), e (FINISHser),
588: e (ABORTser), &sis) == NOTOK)
589: switch (sa -> sa_reason) {
590: case SC_WAITING:
591: (void) sigiomask (smask);
592: return psaplose (pi, PC_WAITING, NULLCP, NULLCP);
593:
594: default:
595: (void) ss2pslose (pb, pi, "SSetIndications", sa);
596: freepblk (pb);
597: (void) sigiomask (smask);
598: return NOTOK;
599: }
600:
601: if (pb -> pb_DataIndication = data)
602: pb -> pb_flags |= PB_ASYN;
603: else
604: pb -> pb_flags &= ~PB_ASYN;
605: pb -> pb_TokenIndication = tokens;
606: pb -> pb_SyncIndication = sync;
607: pb -> pb_ActivityIndication = activity;
608: pb -> pb_ReportIndication = report;
609: pb -> pb_ReleaseIndication = finish;
610: pb -> pb_AbortIndication = abort;
611:
612: (void) sigiomask (smask);
613:
614: return OK;
615: }
616:
617: #undef e
618:
619: /* SSAP interface */
620:
621: int ss2pslose (pb, pi, event, sa)
622: register struct psapblk *pb;
623: register struct PSAPindication *pi;
624: char *event;
625: register struct SSAPabort *sa;
626: {
627: int reason;
628: char *cp,
629: buffer[BUFSIZ];
630:
631: if (event && SC_FATAL (sa -> sa_reason))
632: SLOG (psap2_log, LLOG_EXCEPTIONS, NULLCP,
633: (sa -> sa_cc > 0 ? "%s: %s [%*.*s]": "%s: %s", event,
634: SErrString (sa -> sa_reason), sa -> sa_cc, sa -> sa_cc,
635: sa -> sa_data));
636:
637: cp = "";
638: switch (sa -> sa_reason) {
639: case SC_SSAPID:
640: case SC_SSUSER:
641: case SC_ADDRESS:
642: reason = PC_ADDRESS;
643: break;
644:
645: case SC_REFUSED:
646: reason = PC_REFUSED;
647: break;
648:
649: case SC_CONGEST:
650: reason = PC_CONGEST;
651: break;
652:
653: case SC_TRANSPORT:
654: case SC_ABORT:
655: reason = PC_SESSION;
656: break;
657:
658: default:
659: reason = PC_SESSION;
660: if (pb == NULLPB)
661: switch (sa -> sa_reason) {
662: case SC_PARAMETER:
663: reason = PC_PARAMETER;
664: break;
665:
666: case SC_OPERATION:
667: reason = PC_OPERATION;
668: break;
669:
670: case SC_TIMER:
671: reason = PC_TIMER;
672: break;
673:
674: case SC_WAITING:
675: reason = PC_WAITING;
676: break;
677: }
678: (void) sprintf (cp = buffer, " (%s at session)",
679: SErrString (sa -> sa_reason));
680: break;
681: }
682:
683: if (pb) {
684: if (sa -> sa_cc > 0)
685: return ppktlose (pb, pi, reason, PPDU_NONE, NULLCP, "%*.*s%s",
686: sa -> sa_cc, sa -> sa_cc, sa -> sa_data, cp);
687: else
688: return ppktlose (pb, pi, reason, PPDU_NONE, NULLCP, "%s",
689: *cp ? cp + 1 : cp);
690: }
691: else {
692: if (sa -> sa_cc > 0)
693: return psaplose (pi, reason, NULLCP, "%*.*s%s",
694: sa -> sa_cc, sa -> sa_cc, sa -> sa_data, cp);
695: else
696: return psaplose (pi, reason, NULLCP, "%s",
697: *cp ? cp + 1 : cp);
698: }
699: }
700:
701: /* */
702:
703: static int DATAser (sd, sx)
704: int sd;
705: register struct SSAPdata *sx;
706: {
707: IFP abort;
708: register struct psapblk *pb;
709: struct PSAPindication pis;
710: register struct PSAPindication *pi = &pis;
711: register struct PSAPdata *px = &pi -> pi_data;
712:
713: if ((pb = findpblk (sd)) == NULL)
714: return;
715:
716: bzero ((char *) px, sizeof *px);
717: bzero ((char *) pi, sizeof *pi);
718: abort = pb -> pb_AbortIndication;
719:
720: if (doDATA (pb, sx, px, pi) == NOTOK)
721: (*abort) (sd, &pi -> pi_abort);
722: else
723: (*pb -> pb_DataIndication) (sd, px);
724: }
725:
726: /* */
727:
728: static int TOKENser (sd, st)
729: int sd;
730: register struct SSAPtoken *st;
731: {
732: IFP abort;
733: register struct psapblk *pb;
734: struct PSAPindication pis;
735: register struct PSAPindication *pi = &pis;
736:
737: if ((pb = findpblk (sd)) == NULL)
738: return;
739:
740: bzero ((char *) pi, sizeof *pi);
741: abort = pb -> pb_AbortIndication;
742:
743: if (doTOKEN (pb, st, pi) == NOTOK)
744: (*abort) (sd, &pi -> pi_abort);
745: else
746: (*pb -> pb_TokenIndication) (sd, &pi -> pi_token);
747: }
748:
749: /* */
750:
751: static int SYNCser (sd, sn)
752: int sd;
753: register struct SSAPsync *sn;
754: {
755: IFP abort;
756: register struct psapblk *pb;
757: struct PSAPindication pis;
758: register struct PSAPindication *pi = &pis;
759:
760: if ((pb = findpblk (sd)) == NULL)
761: return;
762:
763: bzero ((char *) pi, sizeof *pi);
764: abort = pb -> pb_AbortIndication;
765:
766: if (doSYNC (pb, sn, pi) == NOTOK)
767: (*abort) (sd, &pi -> pi_abort);
768: else
769: (*pb -> pb_SyncIndication) (sd, &pi -> pi_sync);
770: }
771:
772: /* */
773:
774: static int ACTIVITYser (sd, sv)
775: int sd;
776: register struct SSAPactivity *sv;
777: {
778: IFP abort;
779: register struct psapblk *pb;
780: struct PSAPindication pis;
781: register struct PSAPindication *pi = &pis;
782:
783: if ((pb = findpblk (sd)) == NULL)
784: return;
785:
786: bzero ((char *) pi, sizeof *pi);
787: abort = pb -> pb_AbortIndication;
788:
789: if (doACTIVITY (pb, sv, pi) == NOTOK)
790: (*abort) (sd, &pi -> pi_abort);
791: else
792: (*pb -> pb_ActivityIndication) (sd, &pi -> pi_activity);
793: }
794:
795: /* */
796:
797: static int REPORTser (sd, sp)
798: int sd;
799: register struct SSAPreport *sp;
800: {
801: IFP abort;
802: register struct psapblk *pb;
803: struct PSAPindication pis;
804: register struct PSAPindication *pi = &pis;
805:
806: if ((pb = findpblk (sd)) == NULL)
807: return;
808:
809: bzero ((char *) pi, sizeof *pi);
810: abort = pb -> pb_AbortIndication;
811:
812: if (doREPORT (pb, sp, pi) == NOTOK)
813: (*abort) (sd, &pi -> pi_abort);
814: else
815: (*pb -> pb_ReportIndication) (sd, &pi -> pi_report);
816: }
817:
818: /* */
819:
820: static int FINISHser (sd, sf)
821: int sd;
822: register struct SSAPfinish *sf;
823: {
824: IFP abort;
825: register struct psapblk *pb;
826: struct PSAPindication pis;
827: register struct PSAPindication *pi = &pis;
828:
829: if ((pb = findpblk (sd)) == NULL)
830: return;
831:
832: bzero ((char *) pi, sizeof *pi);
833: abort = pb -> pb_AbortIndication;
834:
835: if (doFINISH (pb, sf, pi) == NOTOK)
836: (*abort) (sd, &pi -> pi_abort);
837: else
838: (*pb -> pb_ReleaseIndication) (sd, &pi -> pi_finish);
839: }
840:
841: /* */
842:
843: static int ABORTser (sd, sa)
844: int sd;
845: register struct SSAPabort *sa;
846: {
847: IFP abort;
848: register struct psapblk *pb;
849: struct PSAPindication pis;
850: register struct PSAPindication *pi = &pis;
851:
852: if ((pb = findpblk (sd)) == NULL)
853: return;
854:
855: bzero ((char *) pi, sizeof *pi);
856: abort = pb -> pb_AbortIndication;
857:
858: (void) doABORT (pb, sa, pi);
859: (*abort) (sd, &pi -> pi_abort);
860: }
861:
862: /* INTERNAL */
863:
864: struct psapblk *newpblk () {
865: register struct psapblk *pb;
866:
867: pb = (struct psapblk *) calloc (1, sizeof *pb);
868: if (pb == NULL)
869: return NULL;
870:
871: pb -> pb_fd = NOTOK;
872:
873: if (once_only == 0) {
874: PHead -> pb_forw = PHead -> pb_back = PHead;
875: once_only++;
876: }
877:
878: insque (pb, PHead -> pb_back);
879:
880: return pb;
881: }
882:
883:
884: int freepblk (pb)
885: register struct psapblk *pb;
886: {
887: register int i;
888: register struct PSAPcontext *qp;
889:
890: if (pb == NULL)
891: return;
892:
893: if (pb -> pb_fd != NOTOK) {
894: struct SSAPindication sis;
895:
896: (void) SUAbortRequest (pb -> pb_fd, NULLCP, 0, &sis);
897: }
898:
899: if (pb -> pb_realbase)
900: free (pb -> pb_realbase);
901: else
902: if (pb -> pb_retry)
903: free (pb -> pb_retry);
904:
905: for (qp = pb -> pb_contexts, i = pb -> pb_ncontext - 1;
906: i >= 0;
907: qp++, i--) {
908: if (qp -> pc_asn)
909: oid_free (qp -> pc_asn);
910: if (qp -> pc_atn)
911: oid_free (qp -> pc_atn);
912: }
913: if (pb -> pb_asn)
914: oid_free (pb -> pb_asn);
915: if (pb -> pb_atn)
916: oid_free (pb -> pb_atn);
917:
918: if (pb -> pb_ber)
919: oid_free (pb -> pb_ber);
920:
921: remque (pb);
922:
923: free ((char *) pb);
924: }
925:
926: /* */
927:
928: struct psapblk *findpblk (sd)
929: register int sd;
930: {
931: register struct psapblk *pb;
932:
933: if (once_only == 0)
934: return NULL;
935:
936: for (pb = PHead -> pb_forw; pb != PHead; pb = pb -> pb_forw)
937: if (pb -> pb_fd == sd)
938: return pb;
939:
940: return NULL;
941: }
942:
943: /* */
944:
945: struct type_PS_User__data *info2ppdu (pb, pi, data, ndata, ppdu)
946: register struct psapblk *pb;
947: struct PSAPindication *pi;
948: PE *data;
949: int ndata,
950: ppdu;
951: {
952: register int i,
953: j;
954: register PE *d,
955: pe;
956: register struct qbuf *qb;
957: register struct PSAPcontext *qp;
958: OID atn;
959: struct type_PS_User__data *pdu;
960: register struct type_PS_Simply__encoded__data *simple;
961: register struct type_PS_Fully__encoded__data **complex,
962: *full;
963:
964: if ((pdu = (struct type_PS_User__data *) calloc (1, sizeof *pdu))
965: == NULL) {
966: no_mem: ;
967: (void) psaplose (pi, PC_CONGEST, NULLCP, "out of memory");
968: goto out;
969: }
970:
971: pdu -> offset = type_PS_User__data_simple;
972: for (d = data, i = 0; i < ndata; i++) {
973: if ((pe = *d++) == NULLPE) {
974: (void) psaplose (pi, PC_PARAMETER, NULLCP,
975: "missing %d%s PDV in PSDU", i + 1,
976: i == 0 ? "st" : i == 1 ? "nd" : i == 2 ? "rd" : "th");
977: goto out;
978: }
979: if (pb -> pb_ncontext > 0
980: && pe -> pe_context == PE_DFLT_CTX) {
981: if (ppdu != PPDU_TE) {
982: (void) psaplose (pi, PC_PARAMETER, NULLCP,
983: "default context not permitted");
984: goto out;
985: }
986: }
987: else
988: if (ppdu == PPDU_CP
989: || (pb -> pb_ncontext > 1
990: && pe -> pe_context != PE_DFLT_CTX))
991: pdu -> offset = type_PS_User__data_complex;
992: }
993:
994: if (pdu -> offset == type_PS_User__data_simple) {
995: if ((qb = (struct qbuf *) malloc (sizeof *qb)) == NULL)
996: goto no_mem;
997: simple = pdu -> un.simple = qb;
998: qb -> qb_forw = qb -> qb_back = qb;
999: qb -> qb_data = NULL, qb -> qb_len = 0;
1000:
1001: j = 0;
1002: for (d = data, i = 0; i < ndata; i++)
1003: j += ps_get_abs (*d++);
1004: qb -> qb_len = j;
1005: if ((qb = (struct qbuf *) malloc (sizeof *qb + ((unsigned)j))) == NULL)
1006: goto no_mem;
1007: qb -> qb_data = qb -> qb_base, qb -> qb_len = j;
1008: insque (qb, simple -> qb_back);
1009: }
1010: else
1011: complex = &pdu -> un.complex;
1012:
1013: for (d = data, i = 0; i < ndata; i++) {
1014: pe = *d++;
1015: switch (pe -> pe_context) {
1016: case PE_DFLT_CTX:
1017: atn = pb -> pb_atn;
1018: break;
1019:
1020: default:
1021: for (j = 0, qp = pb -> pb_contexts;
1022: j < pb -> pb_ncontext;
1023: j++, qp++)
1024: if (qp -> pc_id == pe -> pe_context)
1025: break;
1026: if (j >= pb -> pb_ncontext) {
1027: (void) psaplose (pi, PC_PARAMETER, NULLCP,
1028: "context %d is undefined", pe -> pe_context);
1029: goto out;
1030: }
1031: if (qp -> pc_result != PC_ACCEPT) {
1032: (void) psaplose (pi, PC_PARAMETER, NULLCP,
1033: "context %d is unsupported", pe -> pe_context);
1034: goto out;
1035: }
1036: atn = qp -> pc_atn;
1037: break;
1038: }
1039:
1040: if (!atn_is_ber (pb, atn)) {
1041: (void) psaplose (pi, PC_PARAMETER, NULLCP,
1042: "ATN not BER for context %d", pe -> pe_context);
1043: goto out;
1044: }
1045:
1046: if (pdu -> offset == type_PS_User__data_simple) {
1047: if (info2qb (pe, qb, pi) == NULL)
1048: goto out;
1049: }
1050: else {
1051: register PE *q;
1052:
1053: if ((full = (struct type_PS_Fully__encoded__data *)
1054: calloc (1, sizeof *full)) == NULL)
1055: goto no_mem;
1056: *complex = full;
1057: complex = &full -> next;
1058: if ((full -> PDV__list = (struct type_PS_PDV__list *)
1059: calloc (1, sizeof *full -> PDV__list))
1060: == NULL)
1061: goto no_mem;
1062: full -> PDV__list -> identifier = pe -> pe_context;
1063: if ((full -> PDV__list -> presentation__data__values =
1064: (struct choice_PS_0 *)
1065: calloc (1, sizeof (struct choice_PS_0))) == NULL)
1066: goto no_mem;
1067:
1068: for (q = d, j = i + 1; j < ndata; q++, j++)
1069: if ((*q) -> pe_context != pe -> pe_context)
1070: break;
1071: q--, j--;
1072:
1073: if (i == j) {
1074: full -> PDV__list -> presentation__data__values ->
1075: offset = choice_PS_0_single__ASN1__type;
1076: (full -> PDV__list -> presentation__data__values ->
1077: un.single__ASN1__type = pe) -> pe_refcnt++;
1078: }
1079: else {
1080: register struct qbuf *qb2;
1081:
1082: full -> PDV__list -> presentation__data__values ->
1083: offset = choice_PS_0_octet__aligned;
1084: if ((qb2 = (struct qbuf *) malloc (sizeof *qb2)) == NULL)
1085: goto no_mem;
1086: full -> PDV__list -> presentation__data__values ->
1087: un.octet__aligned = qb2;
1088: qb2 -> qb_forw = qb2 -> qb_back = qb2;
1089: qb2 -> qb_data = NULL, qb2 -> qb_len = 0;
1090: for (d--, j++; i < j; i++) {
1091: if ((qb = info2qb (*d++, (struct qbuf *) NULL, pi))
1092: == NULL)
1093: goto out;
1094: qb2 -> qb_len += qb -> qb_len;
1095: insque (qb, qb2 -> qb_back);
1096: }
1097: }
1098: }
1099: }
1100:
1101: return pdu;
1102:
1103: out: ;
1104: if (pdu)
1105: free_PS_User__data (pdu);
1106:
1107: return NULL;
1108: }
1109:
1110: /* */
1111:
1112: int ppdu2info (pb, pi, info, data, ndata, ppdu)
1113: register struct psapblk *pb;
1114: struct PSAPindication *pi;
1115: struct type_PS_User__data *info;
1116: PE *data;
1117: int *ndata,
1118: ppdu;
1119: {
1120: register int i,
1121: j;
1122: int ctx,
1123: result;
1124: PE pe;
1125: register struct type_PS_Fully__encoded__data *full;
1126:
1127: *ndata = 0;
1128: if (info == NULL)
1129: return OK;
1130:
1131: i = 0;
1132: switch (info -> offset) {
1133: case type_PS_User__data_simple:
1134: if (pb -> pb_ncontext < 1 || ppdu == PPDU_TE)
1135: ctx = PE_DFLT_CTX;
1136: else
1137: if (pb -> pb_ncontext > 1)
1138: return ppktlose (pb, pi, PC_INVALID, ppdu, NULLCP,
1139: "unexpected Simply-encoded-data");
1140: else
1141: ctx = pb -> pb_contexts[0].pc_id;
1142: while ((result = qb2info (info -> un.simple, &pe)) == PS_ERR_NONE){
1143: if (i++ >= NPDATA) {
1144: pe_free (pe);
1145: return ppktlose (pb, pi, PC_CONGEST, ppdu, NULLCP,
1146: "too much user information");
1147: }
1148: (*data++ = pe) -> pe_context = ctx;
1149: }
1150: if (result != PS_ERR_EOF)
1151: return ppktlose (pb, pi, result != PS_ERR_NMEM ? PC_INVALID
1152: : PC_CONGEST, ppdu, NULLCP, "%s",
1153: ps_error (result));
1154: break;
1155:
1156: case type_PS_User__data_complex:
1157: for (full = info -> un.complex; full; full = full -> next) {
1158: struct qbuf *qb;
1159: register struct PSAPcontext *qp;
1160: register struct type_PS_PDV__list *pdv = full -> PDV__list;
1161:
1162: ctx = pdv -> identifier;
1163: for (j = 0, qp = pb -> pb_contexts;
1164: j < pb -> pb_ncontext;
1165: j++, qp++)
1166: if (qp -> pc_id == ctx)
1167: break;
1168: if (j >= pb -> pb_ncontext)
1169: return ppktlose (pb, pi, PC_INVALID, ppdu, NULLCP,
1170: "unexpected use of context %d", ctx);
1171: switch (pdv -> presentation__data__values -> offset) {
1172: case choice_PS_0_single__ASN1__type:
1173: if (i++ >= NPDATA)
1174: return ppktlose (pb, pi, PC_CONGEST, ppdu, NULLCP,
1175: "too much user information");
1176: pe = pdv -> presentation__data__values ->
1177: un.single__ASN1__type;
1178: pdv -> presentation__data__values ->
1179: un.single__ASN1__type = NULLPE;
1180: (*data++ = pe) -> pe_context = ctx;
1181: break;
1182:
1183: case choice_PS_0_octet__aligned:
1184: qb = pdv -> presentation__data__values ->
1185: un.octet__aligned;
1186: while ((result = qb2info (qb, &pe)) == PS_ERR_NONE) {
1187: pe -> pe_context = ctx;
1188: if (i++ >= NPDATA) {
1189: pe_free (pe);
1190: return ppktlose (pb, pi, PC_CONGEST, ppdu,
1191: NULLCP,
1192: "too much user information");
1193: }
1194: (*data++ = pe) -> pe_context = ctx;
1195: }
1196: if (result != PS_ERR_EOF)
1197: return ppktlose (pb, pi, result != PS_ERR_NMEM
1198: ? PC_INVALID : PC_CONGEST, ppdu,
1199: NULLCP, "%s", ps_error (result));
1200: break;
1201:
1202: default:
1203: return ppktlose (pb, pi, PC_INVALID, ppdu, NULLCP,
1204: "not expecting non-BER encoding");
1205: }
1206: }
1207: break;
1208: }
1209: *ndata = i;
1210:
1211: return OK;
1212: }
1213:
1214: /* */
1215:
1216: #ifndef DEBUG
1217: /* ARGSUSED */
1218: #endif
1219:
1220: int info2ssdu (pb, pi, data, ndata, realbase, base, len, text, ppdu)
1221: register struct psapblk *pb;
1222: struct PSAPindication *pi;
1223: PE *data;
1224: int ndata;
1225: char **realbase,
1226: **base;
1227: int *len;
1228: char *text;
1229: int ppdu;
1230: {
1231: int result;
1232: PE pe;
1233: struct type_PS_User__data *info;
1234:
1235: *realbase = *base = NULLCP, *len = 0;
1236: if (data == NULLPEP || ndata <= 0)
1237: return OK;
1238:
1239: if ((info = info2ppdu (pb, pi, data, ndata, ppdu)) == NULL)
1240: return (PC_FATAL (pi -> pi_abort.pa_reason) ? NOTOK : DONE);
1241:
1242: if (ppdu == PPDU_TTD) {
1243: pe = NULLPE;
1244: if ((result = encode_PS_User__data (&pe, 1, 0, NULLCP, info))
1245: == NOTOK) {
1246: losing: ;
1247: free_PS_User__data (info);
1248: return psaplose (pi, PC_CONGEST, NULLCP, "error encoding PDU: %s",
1249: PY_pepy);
1250: }
1251:
1252: PLOGP (psap2_log,PS_User__data, pe, text, 0);
1253:
1254: goto serialize;
1255: }
1256: else
1257: if (ppdu == PPDU_RS || ppdu == PPDU_RSA) {
1258: /* this works 'cause RS-PPDU == RSA-PPDU */
1259: struct type_PS_RS__PPDU rss;
1260: register struct type_PS_RS__PPDU *rs = &rss;
1261:
1262: if ((rs -> context__list = silly_list (pb, pi)) == NULL)
1263: return (PC_FATAL (pi -> pi_abort.pa_reason) ? NOTOK : DONE);
1264: rs -> user__data = info;
1265:
1266: pe = NULLPE;
1267: if ((result = encode_PS_RS__PPDU (&pe, 1, 0, NULLCP, rs))
1268: == NOTOK) {
1269: free_PS_Identifier__list (rs -> context__list);
1270: goto losing;
1271: }
1272:
1273: PLOGP (psap2_log,PS_RS__PPDU, pe, text, 0);
1274:
1275: free_PS_Identifier__list (rs -> context__list);
1276:
1277: goto serialize;
1278: }
1279:
1280: if (info -> offset == type_PS_User__data_simple) {
1281: register struct qbuf *qb;
1282:
1283: qb = info -> un.simple;
1284: *len = qb -> qb_len;
1285:
1286: qb = qb -> qb_forw;
1287: remque (qb);
1288:
1289: *realbase = (char *) qb, *base = qb -> qb_base;
1290:
1291: #ifdef DEBUG
1292: if (psap2_log -> ll_events & LLOG_PDUS)
1293: while (ndata-- > 0)
1294: pvpdu (psap2_log, vunknown_P, *data++, text, 0);
1295: #endif
1296: }
1297: else {
1298: pe = NULLPE;
1299: if (encode_PS_Fully__encoded__data (&pe, 0, 0, NULLCP,
1300: info -> un.complex) == NOTOK)
1301: goto losing;
1302: pe -> pe_class = PE_CLASS_APPL, pe -> pe_id = 1;
1303:
1304: PLOGP (psap2_log,PS_User__data, pe, text, 0);
1305:
1306: serialize: ;
1307: result = pe2ssdu (pe, base, len);
1308:
1309: pe_free (pe);
1310:
1311: if (result == NOTOK) {
1312: free_PS_User__data (info);
1313: return psaplose (pi, PC_CONGEST, NULLCP, NULLCP);
1314: }
1315: }
1316: free_PS_User__data (info);
1317:
1318: return OK;
1319: }
1320:
1321: /* */
1322:
1323: #ifndef DEBUG
1324: /* ARGSUSED */
1325: #endif
1326:
1327: int ssdu2info (pb, pi, base, len, data, ndata, text, ppdu)
1328: register struct psapblk *pb;
1329: struct PSAPindication *pi;
1330: char *base;
1331: int len;
1332: PE *data;
1333: int *ndata;
1334: char *text;
1335: int ppdu;
1336: {
1337: int result;
1338: register PE pe;
1339: register struct type_PS_User__data *info;
1340:
1341: *ndata = 0;
1342: if (base == NULLCP || len <= 0)
1343: return OK;
1344:
1345: if (ppdu == PPDU_RS || ppdu == PPDU_RSA) {
1346: struct type_PS_RS__PPDU *rs;/* this works 'cause RS-PPDU == RSA-PPDU */
1347:
1348: if ((pe = ssdu2pe (base, len, NULLCP, &result)) == NULLPE)
1349: return ppktlose (pb, pi, result == PS_ERR_NMEM ? PC_CONGEST
1350: : PC_PROTOCOL, ppdu, NULLCP, "%s",
1351: ps_error (result));
1352:
1353: rs = NULL, info = NULL;
1354: result = decode_PS_RS__PPDU (pe, 1, NULLIP, NULLVP, &rs);
1355:
1356: #ifdef DEBUG
1357: if (result == OK && (psap2_log -> ll_events & LLOG_PDUS))
1358: pvpdu (psap2_log, print_PS_RS__PPDU_P, pe, text, 1);
1359: #endif
1360:
1361: info = rs -> user__data, rs -> user__data = NULL;
1362: free_PS_RS__PPDU (rs);
1363:
1364: goto punch_it;
1365: }
1366:
1367: if ((info = (struct type_PS_User__data *) calloc (1, sizeof *info))
1368: == NULL) {
1369: no_mem: ;
1370: (void) psaplose (pi, PC_CONGEST, NULLCP, "out of memory");
1371: out: ;
1372: if (info)
1373: free_PS_User__data (info);
1374: return NOTOK;
1375: }
1376:
1377: if (pb -> pb_ncontext <= 1 || ppdu == PPDU_TE) {
1378: register struct qbuf *qb;
1379:
1380: info -> offset = type_PS_User__data_simple;
1381:
1382: if ((qb = (struct qbuf *) malloc (sizeof *qb)) == NULL)
1383: goto no_mem;
1384: info -> un.simple = qb;
1385: qb -> qb_forw = qb -> qb_back = qb;
1386: qb -> qb_data = NULL, qb -> qb_len = len;
1387: if ((qb = (struct qbuf *) malloc (sizeof *qb)) == NULL)
1388: goto no_mem;
1389: insque (qb, info -> un.simple);
1390: qb -> qb_data = base, qb -> qb_len = len;
1391: }
1392: else {
1393: info -> offset = type_PS_User__data_complex;
1394:
1395: if ((pe = ssdu2pe (base, len, NULLCP, &result)) == NULLPE) {
1396: (void) ppktlose (pb, pi, result == PS_ERR_NMEM ? PC_CONGEST
1397: : PC_PROTOCOL, ppdu, NULLCP, "%s",
1398: ps_error (result));
1399: goto out;
1400: }
1401:
1402: if (pe -> pe_class != PE_CLASS_APPL
1403: || pe -> pe_form != PE_FORM_CONS
1404: || pe -> pe_id != 1) {
1405: PY_advise (NULLCP,
1406: "Fully-encoded-data bad class/form/id: %s/%d/0x%x",
1407: pe_classlist[pe -> pe_class], pe -> pe_form,
1408: pe -> pe_id);
1409: result = NOTOK;
1410: }
1411: else
1412: result = decode_PS_Fully__encoded__data (pe, 0, NULLIP, NULLVP,
1413: &info -> un.complex);
1414:
1415: #ifdef DEBUG
1416: if (result == OK && (psap2_log -> ll_events & LLOG_PDUS))
1417: pvpdu (psap2_log, print_PS_User__data_P, pe, text, 1);
1418: #endif
1419:
1420: punch_it: ;
1421: pe_free (pe);
1422:
1423: if (result == NOTOK) {
1424: (void) ppktlose (pb, pi, PC_UNRECOGNIZED, ppdu, NULLCP, "%s",
1425: PY_pepy);
1426: goto out;
1427: }
1428: }
1429:
1430: if ((result = ppdu2info (pb, pi, info, data, ndata, ppdu)) == NOTOK)
1431: result = PC_FATAL (pi -> pi_abort.pa_reason) ? NOTOK : DONE;
1432:
1433: #ifdef DEBUG
1434: if (result == OK
1435: && ppdu != PPDU_RS
1436: && ppdu != PPDU_RSA
1437: && info -> offset == type_PS_User__data_simple
1438: && (psap2_log -> ll_events & LLOG_PDUS)) {
1439: register int i;
1440:
1441: for (i = *ndata; i > 0; i--)
1442: pvpdu (psap2_log, vunknown_P, *data++, text, 1);
1443: }
1444: #endif
1445:
1446: free_PS_User__data (info);
1447:
1448: return result;
1449: }
1450:
1451: /* */
1452:
1453: #ifndef DEBUG
1454: /* ARGSUSED */
1455: #endif
1456:
1457: int qbuf2info (pb, pi, qb, len, data, ndata, text, ppdu)
1458: register struct psapblk *pb;
1459: struct PSAPindication *pi;
1460: struct qbuf *qb;
1461: int len;
1462: PE *data;
1463: int *ndata;
1464: char *text;
1465: int ppdu;
1466: {
1467: int result;
1468: register PE pe;
1469: register struct qbuf *qp;
1470: struct type_PS_User__data *info;
1471:
1472: *ndata = 0;
1473: if (qb == NULL || len <= 0)
1474: return OK;
1475:
1476: if (ppdu == PPDU_TTD) {
1477: if ((pe = qbuf2pe (qb, len, &result)) == NULLPE)
1478: return ppktlose (pb, pi, result == PS_ERR_NMEM ? PC_CONGEST
1479: : PC_PROTOCOL, ppdu, NULLCP, "%s",
1480: ps_error (result));
1481:
1482: info = NULL;
1483: result = decode_PS_User__data (pe, 1, NULLIP, NULLVP, &info);
1484:
1485: #ifdef DEBUG
1486: if (result == OK && (psap2_log -> ll_events & LLOG_PDUS))
1487: pvpdu (psap2_log, print_PS_User__data_P, pe, text, 1);
1488: #endif
1489:
1490: goto punch_it;
1491: }
1492:
1493: if ((info = (struct type_PS_User__data *) calloc (1, sizeof *info))
1494: == NULL) {
1495: no_mem: ;
1496: (void) psaplose (pi, PC_CONGEST, NULLCP, "out of memory");
1497: goto out;
1498: }
1499:
1500: if (pb -> pb_ncontext <= 1 || ppdu == PPDU_TE) {
1501: register struct qbuf *qbp,
1502: *qpp;
1503:
1504: info -> offset = type_PS_User__data_simple;
1505: if ((qp = (struct qbuf *) malloc (sizeof *qp)) == NULL)
1506: goto no_mem;
1507: info -> un.simple = qpp = qp;
1508: qp -> qb_forw = qp -> qb_back = qp;
1509: qp -> qb_data = NULL, qp -> qb_len = len;
1510: for (qp = qb -> qb_forw; qp != qb; qp = qbp) {
1511: qbp = qp -> qb_forw;
1512:
1513: remque (qp);
1514: insque (qp, qpp -> qb_back);
1515: }
1516: }
1517: else {
1518: info -> offset = type_PS_User__data_complex;
1519:
1520: if ((pe = qbuf2pe (qb, len, &result)) == NULLPE) {
1521: (void) ppktlose (pb, pi, result == PS_ERR_NMEM ? PC_CONGEST
1522: : PC_PROTOCOL, ppdu, NULLCP, "%s",
1523: ps_error (result));
1524: goto out;
1525: }
1526: if (pe -> pe_class != PE_CLASS_APPL
1527: || pe -> pe_form != PE_FORM_CONS
1528: || pe -> pe_id != 1) {
1529: PY_advise (NULLCP,
1530: "Fully-encoded-data bad class/form/id: %s/%d/0x%x",
1531: pe_classlist[pe -> pe_class], pe -> pe_form,
1532: pe -> pe_id);
1533: result = NOTOK;
1534: }
1535: else
1536: result = decode_PS_Fully__encoded__data (pe, 0, NULLIP, NULLVP,
1537: &info -> un.complex);
1538:
1539: #ifdef DEBUG
1540: if (result == OK && (psap2_log -> ll_events & LLOG_PDUS))
1541: pvpdu (psap2_log, print_PS_User__data_P, pe, text, 1);
1542: #endif
1543:
1544: punch_it: ;
1545: pe_free (pe);
1546:
1547: if (result == NOTOK) {
1548: (void) ppktlose (pb, pi, PC_UNRECOGNIZED, ppdu, NULLCP, "%s",
1549: PY_pepy);
1550: goto out;
1551: }
1552: }
1553:
1554: if ((result = ppdu2info (pb, pi, info, data, ndata, ppdu)) == NOTOK)
1555: result = PC_FATAL (pi -> pi_abort.pa_reason) ? NOTOK : DONE;
1556:
1557: #ifdef DEBUG
1558: if (result == OK
1559: && ppdu != PPDU_TTD
1560: && info -> offset == type_PS_User__data_simple
1561: && (psap2_log -> ll_events & LLOG_PDUS)) {
1562: register int i;
1563:
1564: for (i = *ndata; i > 0; i--)
1565: pvpdu (psap2_log, vunknown_P, *data++, text, 1);
1566: }
1567: #endif
1568:
1569: free_PS_User__data (info);
1570:
1571: return result;
1572:
1573: out: ;
1574: if (info)
1575: free_PS_User__data (info);
1576:
1577: return NOTOK;
1578: }
1579:
1580: /* */
1581:
1582: struct qbuf *info2qb (pe, qp, pi)
1583: register PE pe;
1584: register struct qbuf *qp;
1585: struct PSAPindication *pi;
1586: {
1587: int len;
1588: register struct qbuf *qb;
1589: register PS ps;
1590:
1591: if ((qb = qp) == NULL) {
1592: if ((qb = (struct qbuf *) malloc ((unsigned) sizeof *qb
1593: + (len = ps_get_abs (pe))))
1594: == NULL) {
1595: no_mem: ;
1596: (void) psaplose (pi, PC_CONGEST, NULLCP, NULLCP);
1597: goto out;
1598: }
1599:
1600: qb -> qb_data = qb -> qb_base, qb -> qb_len = len;
1601: }
1602:
1603: if ((ps = ps_alloc (str_open)) == NULLPS)
1604: goto no_mem;
1605: if (str_setup (ps, qb -> qb_data, qb -> qb_len, 1) == NOTOK
1606: || pe2ps_aux (ps, pe, 0) == NOTOK) {
1607: (void) psaplose (pi, PC_CONGEST, NULLCP, "error encoding user-info");
1608: ps_free (ps);
1609: goto out;
1610: }
1611:
1612: len = ps -> ps_ptr - ps -> ps_base;
1613: if (qp)
1614: qp -> qb_data += len, qp -> qb_len -= len;
1615: else
1616: qb -> qb_len = len;
1617:
1618: #ifdef DEBUG
1619: if (psap_log -> ll_events & LLOG_PDUS)
1620: pe2text (psap_log, pe, 0, len);
1621: #endif
1622:
1623: ps_free (ps);
1624:
1625: return qb;
1626:
1627: out: ;
1628: if (qb && qb != qp)
1629: free ((char *) qb);
1630:
1631: return NULL;
1632: }
1633:
1634: /* */
1635:
1636: int qb2info (qb, pe)
1637: register struct qbuf *qb;
1638: PE *pe;
1639: {
1640: int result;
1641: #ifdef DEBUG
1642: int len;
1643: #endif
1644: PE p;
1645: register PS ps;
1646:
1647: *pe = NULLPE;
1648:
1649: if ((ps = ps_alloc (qbuf_open)) == NULLPS)
1650: return PS_ERR_NMEM;
1651: #ifdef DEBUG
1652: len = ps -> ps_byteno;
1653: #endif
1654: if (qbuf_setup (ps, qb) == NOTOK || (p = ps2pe (ps)) == NULLPE) {
1655: if ((result = ps -> ps_errno) == PS_ERR_NONE)
1656: result = PS_ERR_EOF;
1657: }
1658: else {
1659: result = PS_ERR_NONE;
1660: *pe = p;
1661: }
1662:
1663: ps -> ps_addr = NULL; /* so ps_free doesn't free remainder of qbuf */
1664: #ifdef DEBUG
1665: len = ps -> ps_byteno - len;
1666: #endif
1667: ps_free (ps);
1668:
1669: #ifdef DEBUG
1670: if (p && (psap_log -> ll_events & LLOG_PDUS))
1671: pe2text (psap_log, p, 1, len);
1672: #endif
1673:
1674: return result;
1675: }
1676:
1677: /* */
1678:
1679: struct type_PS_Identifier__list *silly_list (pb, pi)
1680: register struct psapblk *pb;
1681: struct PSAPindication *pi;
1682: {
1683: register int j;
1684: register struct PSAPcontext *qp;
1685: struct type_PS_Identifier__list *list;
1686: register struct type_PS_Identifier__list *lp,
1687: **mp;
1688:
1689: list = NULL;
1690: mp = &list;
1691:
1692: for (j = 0, qp = pb -> pb_contexts;
1693: j < pb -> pb_ncontext;
1694: j++, qp++) {
1695: if ((lp = (struct type_PS_Identifier__list *)
1696: calloc (1, sizeof *lp)) == NULL) {
1697: no_mem: ;
1698: (void) psaplose (pi, PC_CONGEST, NULLCP, "out of memory");
1699: free_PS_Identifier__list (list);
1700: return NULL;
1701: }
1702: *mp = lp;
1703: mp = &lp -> next;
1704: if ((lp -> element_PS_10 = (struct element_PS_11 *)
1705: calloc (1, sizeof (struct element_PS_11))) == NULL
1706: || (lp -> element_PS_10 -> transfer__syntax =
1707: oid_cpy (qp -> pc_atn)) == NULLOID)
1708: goto no_mem;
1709: lp -> element_PS_10 -> identifier = qp -> pc_id;
1710: }
1711:
1712: return list;
1713: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.