![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tsdu2spkt.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 / ssap|
Return to tsdu2spkt.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / ssap |
1.1 root 1: /* tsdu2spkt.c - read/write a SPDU to a TSDU */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/ssap/RCS/tsdu2spkt.c,v 7.0 89/11/23 22:25:55 mrose Rel $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/ssap/RCS/tsdu2spkt.c,v 7.0 89/11/23 22:25:55 mrose Rel $
9: *
10: *
11: * $Log: tsdu2spkt.c,v $
12: * Revision 7.0 89/11/23 22:25:55 mrose
13: * Release 6.0
14: *
15: */
16:
17: /*
18: * NOTICE
19: *
20: * Acquisition, use, and distribution of this module and related
21: * materials are subject to the restrictions of a license agreement.
22: * Consult the Preface in the User's Manual for the full terms of
23: * this agreement.
24: *
25: */
26:
27:
28: /* LINTLIBRARY */
29:
30: #include <stdio.h>
31: #include "spkt.h"
32: #include "tailor.h"
33:
34: /* */
35:
36: struct local_buf {
37: char *top; /* Top of buffer */
38: char *ptr; /* Pointer to working buffer */
39: int pgi; /* Offset of last PGI li */
40: int left; /* Number of bytes left */
41: int li; /* Running spdu length */
42: int allocli; /* Allocated li */
43: int len; /* Current buffer size */
44: };
45:
46: /* */
47:
48: #define PMASK_NODATA 0x000000
49: #define PMASK_CN_ID 0x000001 /* 1: Connection ID */
50: #define PMASK_CN_ITEMS 0x000002 /* 5: Connect/Accept Item */
51: #define PMASK_SYNC 0x000004 /* 15: Sync Type Item */
52: #define PMASK_TOKEN 0x000008 /* 16: Token Item */
53: #define PMASK_TDISC 0x000010 /* 17: Transport Disc */
54: #define PMASK_USER_REQ 0x000020 /* 20: Session User Req */
55: #define PMASK_VERSION 0x000040 /* 22: Version Number */
56: #define PMASK_PREPARE 0x000080 /* 24: Prepare type */
57: #define PMASK_ENCLOSE 0x000100 /* 25: Enclosure Item */
58: #define PMASK_TOKEN_SET 0x000200 /* 26: Token Setting Item */
59: #define PMASK_RESYNC 0x000400 /* 27: Resync type */
60: #define PMASK_LINK 0x000800 /* 33: Linking information */
61: #define PMASK_ACT_ID 0x001000 /* 41: Activity ID */
62: #define PMASK_SERIAL 0x002000 /* 42: Serial Number */
63: #define PMASK_MIA_DATA 0x004000 /* 46: MIA User Data */
64: #define PMASK_REFLECT 0x008000 /* 49: Reflect parameter */
65: #define PMASK_REASON 0x010000 /* 50: Refusal Reason */
66: #define PMASK_SSAP_CALLING 0x020000 /* 51: Calling SSAP ID */
67: #define PMASK_SSAP_CALLED 0x040000 /* 52: Called SSAP ID */
68: #define PMASK_UDATA 0x080000 /* 193: User data */
69: #define PMASK_XDATA 0x100000 /* 194: Extended user data */
70:
71: #define PMASK_VARLEN 0x800000 /* PI is Variable Len */
72: #define PMASK_NOTSUPPORTED -1 /* Type not supported */
73:
74:
75: static int si_table[] = {
76: PMASK_REFLECT, /* 0x00: SPDU_ER */
77: PMASK_ENCLOSE /* 0x01: SPDU_GT & SPDU_DT */
78: | PMASK_TOKEN,
79: PMASK_TOKEN /* 0x02: SPDU_PT */
80: | PMASK_ENCLOSE
81: | PMASK_UDATA,
82: PMASK_NOTSUPPORTED, /* 0x03 */
83: PMASK_NOTSUPPORTED, /* 0x04 */
84: PMASK_NODATA, /* 0x05: SPDU_EX */
85: PMASK_NOTSUPPORTED, /* 0x06 */
86: PMASK_PREPARE, /* 0x07: SPDU_PR */
87: PMASK_ENCLOSE /* 0x08: SPDU_NF */
88: | PMASK_UDATA,
89: PMASK_TDISC /* 0x09: SPDU_FN */
90: | PMASK_ENCLOSE
91: | PMASK_UDATA,
92: PMASK_ENCLOSE /* 0x0a: SPDU_DN */
93: | PMASK_UDATA,
94: PMASK_NOTSUPPORTED, /* 0x0b */
95: PMASK_CN_ID /* 0x0c: SPDU_RF */
96: | PMASK_TDISC
97: | PMASK_USER_REQ
98: | PMASK_VERSION
99: | PMASK_ENCLOSE
100: | PMASK_REASON,
101: PMASK_CN_ID /* 0x0d: SPDU_CN */
102: | PMASK_CN_ITEMS
103: | PMASK_USER_REQ
104: | PMASK_VERSION
105: | PMASK_SSAP_CALLING
106: | PMASK_SSAP_CALLED
107: | PMASK_UDATA
108: | PMASK_XDATA,
109: PMASK_CN_ID /* 0x0e: SPDU_AC */
110: | PMASK_CN_ITEMS
111: | PMASK_USER_REQ
112: | PMASK_VERSION
113: | PMASK_SSAP_CALLING
114: | PMASK_TOKEN
115: | PMASK_ENCLOSE
116: | PMASK_SSAP_CALLED
117: | PMASK_UDATA,
118: PMASK_NOTSUPPORTED, /* 0x0f */
119: PMASK_NOTSUPPORTED, /* 0x10 */
120: PMASK_NOTSUPPORTED, /* 0x11 */
121: PMASK_NOTSUPPORTED, /* 0x12 */
122: PMASK_NOTSUPPORTED, /* 0x13 */
123: PMASK_NOTSUPPORTED, /* 0x14 */
124: PMASK_NODATA, /* 0x15: SPDU_GTC */
125: PMASK_NODATA, /* 0x16: SPDU_GTA */
126: PMASK_NOTSUPPORTED, /* 0x17 */
127: PMASK_NOTSUPPORTED, /* 0x18 */
128: PMASK_TDISC /* 0x19: SPDU_AB & SPDU_AI */
129: | PMASK_REFLECT
130: | PMASK_REASON
131: | PMASK_ENCLOSE
132: | PMASK_UDATA,
133: PMASK_NODATA, /* 0x1a: SPDU_AA & SPDU_AIA */
134: PMASK_NOTSUPPORTED, /* 0x1b */
135: PMASK_NOTSUPPORTED, /* 0x1c */
136: PMASK_LINK /* 0x1d: SPDU_AR */
137: | PMASK_ACT_ID
138: | PMASK_ENCLOSE
139: | PMASK_SERIAL
140: | PMASK_UDATA,
141: PMASK_NOTSUPPORTED, /* 0x1e */
142: PMASK_NOTSUPPORTED, /* 0x1f */
143: PMASK_NOTSUPPORTED, /* 0x20 */
144: PMASK_ENCLOSE, /* 0x21: SPDU_TD */
145: PMASK_TOKEN_SET /* 0x22: SPDU_RA */
146: | PMASK_ENCLOSE
147: | PMASK_SERIAL
148: | PMASK_UDATA,
149: PMASK_NOTSUPPORTED, /* 0x23 */
150: PMASK_NOTSUPPORTED, /* 0x24 */
151: PMASK_NOTSUPPORTED, /* 0x25 */
152: PMASK_NOTSUPPORTED, /* 0x26 */
153: PMASK_NOTSUPPORTED, /* 0x27 */
154: PMASK_NOTSUPPORTED, /* 0x28 */
155: PMASK_SYNC /* 0x29: SPDU_MAP & SPDU_AE */
156: | PMASK_ENCLOSE
157: | PMASK_SERIAL
158: | PMASK_UDATA,
159: PMASK_ENCLOSE /* 0x2a: SPDU_MAA & SPDU_AEA */
160: | PMASK_SERIAL
161: | PMASK_UDATA,
162: PMASK_NOTSUPPORTED, /* 0x2b */
163: PMASK_NOTSUPPORTED, /* 0x2c */
164: PMASK_ENCLOSE /* 0x2d: SPDU_AS */
165: | PMASK_ACT_ID
166: | PMASK_UDATA,
167: PMASK_NOTSUPPORTED, /* 0x2e */
168: PMASK_NOTSUPPORTED, /* 0x2f */
169: PMASK_ENCLOSE /* 0x30: SPDU_ED */
170: | PMASK_REASON
171: | PMASK_UDATA,
172: PMASK_SYNC /* 0x31: SPDU_MIP */
173: | PMASK_ENCLOSE
174: | PMASK_SERIAL
175: | PMASK_UDATA,
176: PMASK_ENCLOSE /* 0x32: SPDU_MIA */
177: | PMASK_SERIAL
178: | PMASK_MIA_DATA,
179: PMASK_NOTSUPPORTED, /* 0x33 */
180: PMASK_NOTSUPPORTED, /* 0x34 */
181: PMASK_TOKEN_SET /* 0x35: SPDU_RS */
182: | PMASK_ENCLOSE
183: | PMASK_RESYNC
184: | PMASK_SERIAL
185: | PMASK_UDATA,
186: PMASK_NOTSUPPORTED, /* 0x36 */
187: PMASK_NOTSUPPORTED, /* 0x37 */
188: PMASK_NOTSUPPORTED, /* 0x38 */
189: PMASK_REASON, /* 0x39: SPDU_AD */
190: PMASK_NODATA, /* 0x3a: SPDU_ADA */
191: PMASK_NOTSUPPORTED, /* 0x3b */
192: PMASK_NOTSUPPORTED, /* 0x3c */
193: PMASK_ENCLOSE /* 0x3d: SPDU_CD */
194: | PMASK_UDATA,
195: PMASK_ENCLOSE /* 0x3e: SPDU_CDA */
196: | PMASK_UDATA
197: };
198: #define SI_TABLE_LEN ((sizeof si_table) / (sizeof si_table[0]))
199:
200: /* */
201:
202: #define PGI_CN_ID 1
203: #define PI_CALLED_SS 9
204: #define PI_CALLING_SS 10
205: #define PI_COMMON_REF 11
206: #define PI_ADD_INFO 12
207: #define PGI_CN_ITEMS 5
208: #define PI_PROTOCOL_OPT 19
209: #define PI_TSDU_MAXSIZ 21
210: #define PI_VERSION 22
211: #define PI_ISN 23
212: #define PI_TOKEN_SET 26
213: #define PI_ISN2 55
214: #define PI_SYNC 15
215: #define PI_TOKEN 16
216: #define PI_TDISC 17
217: #define PI_USER_REQ 20
218: #define PI_PREPARE 24
219: #define PI_ENCLOSE 25
220: #define PI_RESYNC 27
221: #define PGI_AR_LINK 33
222: #define PI_AR_CALLED 9
223: #define PI_AR_CALLING 10
224: #define PI_AR_COMMON 11
225: #define PI_AR_ADDT 12
226: #define PI_AR_OLD 41
227: #define PI_AR_SERIAL 42
228: #define PI_ACT_ID 41
229: #define PI_SERIAL 42
230: #define PI_MIA_DATA 46
231: #define PI_REFLECT 49
232: #define PI_REASON 50
233: #define PI_SSAP_CALLING 51
234: #define PI_SSAP_CALLED 52
235: #define PI_UDATA 193
236: #define PI_XDATA 194
237:
238:
239: static int pi_table[] = {
240: 0, /* 0x00 */
241: PMASK_VARLEN | PMASK_CN_ID, /* 0x01: Connection ID */
242: 0, 0, 0, /* 0x02-04 */
243: PMASK_VARLEN | PMASK_CN_ITEMS, /* 0x05: Connect/Accept Item */
244: 0, 0, 0, /* 0x06-08 */
245: PMASK_VARLEN | PMASK_CN_ID | PMASK_LINK,/* 0x09: Called Session SS */
246: PMASK_VARLEN | PMASK_CN_ID | PMASK_LINK,/* 0x0a: Calling Session SS */
247: PMASK_VARLEN | PMASK_CN_ID | PMASK_LINK,/* 0x0b: Common Reference */
248: PMASK_VARLEN | PMASK_CN_ID | PMASK_LINK,/* 0x0c: Additional Info */
249: 0, 0, /* 0x0d-0e */
250: PMASK_SYNC, /* 0x0f: Sync Type Item */
251: PMASK_TOKEN, /* 0x10: Token Item */
252: PMASK_TDISC, /* 0x11: Transport Disc */
253: 0, /* 0x12 */
254: PMASK_CN_ITEMS, /* 0x13: Protocol Option */
255: PMASK_USER_REQ, /* 0x14: Session User Req */
256: PMASK_VARLEN | PMASK_CN_ITEMS, /* 0x15: TSDU Max Size */
257: PMASK_VERSION, /* 0x16: Version Number */
258: PMASK_VARLEN | PMASK_CN_ITEMS, /* 0x17: Initial Serial Num */
259: PMASK_PREPARE, /* 0x18: Prepare Type */
260: PMASK_ENCLOSE, /* 0x19: Enclosure Item */
261: PMASK_CN_ITEMS | PMASK_TOKEN_SET, /* 0x1a: Token setting item */
262: PMASK_RESYNC, /* 0x1b: Resync type */
263: 0, 0, 0, 0, 0, /* 0x1c-20 */
264: PMASK_VARLEN | PMASK_LINK, /* 0x21: Activity Link */
265: 0, 0, 0, 0, 0, 0, 0, /* 0x22-28 */
266: PMASK_VARLEN | PMASK_ACT_ID, /* 0x29: Activity ID */
267: PMASK_VARLEN | PMASK_SERIAL, /* 0x2a: Serial Number */
268: 0, 0, 0, /* 0x2b-2d */
269: PMASK_VARLEN | PMASK_MIA_DATA, /* 0x2e: MIA User Data */
270: 0, 0, /* 0x2f-30 */
271: PMASK_VARLEN | PMASK_REFLECT, /* 0x31: Reflect parameter */
272: PMASK_VARLEN | PMASK_REASON, /* 0x32: Refusal Reason */
273: PMASK_VARLEN | PMASK_SSAP_CALLING, /* 0x33: Calling SSAP ID */
274: PMASK_VARLEN | PMASK_SSAP_CALLED, /* 0x34: Called SSAP ID */
275: 0, 0, /* 0x35-36 */
276: PMASK_VARLEN | PMASK_CN_ITEMS /* 0x17: 2nd initial s/n */
277: };
278: #define PI_TABLE_LEN ((sizeof pi_table) / (sizeof pi_table[0]))
279:
280: /* */
281:
282: static int pi_length[PI_TABLE_LEN] = {
283: 0, /* 0x00 */
284: SREF_USER_SIZE /* 0x01: Connection ID */
285: + SREF_COMM_SIZE
286: + SREF_ADDT_SIZE
287: + 6,
288: 0, 0, 0, /* 0x02-04 */
289: 1 + 4 + 1 + 6 + 1 + 10, /* 0x05: Connect/Accept Item */
290: 0, 0, 0, /* 0x06-08 */
291: SREF_USER_SIZE, /* 0x09: Called Session SS */
292: SREF_USER_SIZE, /* 0x0a: Calling Session SS */
293: SREF_COMM_SIZE, /* 0x0b: Common Reference */
294: SREF_ADDT_SIZE, /* 0x0c: Additional Info */
295: 0, 0, /* 0x0d-0e */
296: 1, /* 0x0f: Sync Type Item */
297: 1, /* 0x10: Token Item */
298: 1, /* 0x11: Transport Disc */
299: 0, /* 0x12 */
300: 1, /* 0x13: Protocol Option */
301: 2, /* 0x14: Session User Req */
302: 4, /* 0x15: TSDU Max Size */
303: 1, /* 0x16: Version Number */
304: SIZE_CN_ISN, /* 0x17: Initial Serial Num */
305: 1, /* 0x18: Prepare Type */
306: 1, /* 0x19: Enclosure Item */
307: 1, /* 0x1a: Token setting item */
308: 1, /* 0x1b: Resync type */
309: 0, 0, 0, 0, 0, /* 0x1c-20 */
310: 2 * SREF_USER_SIZE /* 0x21: Activity Link */
311: + SREF_COMM_SIZE
312: + SREF_ADDT_SIZE
313: + SID_DATA_SIZE
314: + SIZE_CN_ISN
315: + 6 * 2,
316: 0, 0, 0, 0, 0, 0, 0, /* 0x22-28 */
317: SID_DATA_SIZE, /* 0x29: Activity ID */
318: SIZE_CN_ISN, /* 0x2a: Serial Number */
319: 0, 0, 0, /* 0x2b-2d */
320: SEGMENT_MAX /* MIA_SIZE */, /* 0x2e: MIA User Data */
321: 0, 0, /* 0x2f-30 */
322: SEGMENT_MAX, /* 0x31: Reflect parameter */
323: RF_SIZE, /* 0x32: Refusal Reason */
324: SSSIZE, /* 0x33: Calling SSAP ID */
325: SSSIZE, /* 0x34: Called SSAP ID */
326: 0, 0, /* 0x35-36 */
327: SIZE_CN_ISN, /* 0x37: 2nd initial s/n */
328: };
329:
330: /* */
331:
332: #define If_Set(flag) if (s -> s_mask & (flag))
333: #define If_Reset(flag) if (!(s -> s_mask & (flag)))
334: #define Set(flag) s -> s_mask |= (flag)
335: #define Reset(flag) s -> s_mask &= ~(flag)
336:
337: #define Put_Item(code,value) \
338: put2spdu((code), pi_length[(code)], (value), &c)
339:
340: #define Put_Ref(r,code) \
341: { \
342: start_pgi (PGI_CN_ID, &c); \
343: if (r.sr_ulen) \
344: put2spdu (code, (int) r.sr_ulen, r.sr_udata, &c); \
345: if (r.sr_clen) \
346: put2spdu (PI_COMMON_REF, (int) r.sr_clen, r.sr_cdata, &c); \
347: if (r.sr_alen) \
348: put2spdu (PI_ADD_INFO, (int) r.sr_alen, r.sr_adata, &c); \
349: end_pgi (&c); \
350: }
351:
352: #define Put_SSN(code,ssn) \
353: { \
354: if ((ssn) > SERIAL_MAX + 1) { \
355: if (c.len) \
356: free (c.top); \
357: s -> s_errno = SC_PROTOCOL; \
358: return NOTOK; \
359: } \
360: (void) sprintf (isn, "%lu", (ssn)); \
361: put2spdu ((code), strlen (isn), isn, &c); \
362: }
363:
364: /* this used to check
365:
366: if (s -> s_ulen > (csize)) {
367: if (c.len)
368: free (c.top);
369: s -> s_errno = SC_PROTOCOL;
370: return NOTOK;
371: }
372:
373: but with version 2 session, there's really no point... */
374:
375: #define Put_UData(csize) \
376: { \
377: if (s -> s_udata) { \
378: put2spdu (PI_UDATA, s -> s_ulen, s -> s_udata, &c); \
379: } \
380: }
381:
382: #define Put_XData(csize) \
383: { \
384: if (s -> s_udata) { \
385: put2spdu (s -> s_ulen > csize ? PI_XDATA : PI_UDATA, s -> s_ulen, \
386: s -> s_udata, &c); \
387: } \
388: }
389:
390: #define Put_MData(csize) \
391: { \
392: if (s -> s_udata) { \
393: put2spdu (PI_MIA_DATA, s -> s_ulen, s -> s_udata, &c); \
394: } \
395: }
396:
397: /* */
398:
399: static start_spdu (s, c, basesize)
400: struct ssapkt *s;
401: struct local_buf *c;
402: int basesize;
403: {
404: if (s -> s_udata)
405: switch (s -> s_code) {
406: case SPDU_DT: /* caller responsible for this... */
407: case SPDU_EX:
408: case SPDU_TD:
409: break;
410:
411: default:
412: if (s -> s_ulen)
413: basesize += s -> s_ulen + (s -> s_ulen > 254 ? 4 : 2);
414: break;
415: }
416:
417: switch (s -> s_code) {
418: case SPDU_CN:
419: case SPDU_AC:
420: If_Set (SMASK_CN_REF) {
421: basesize += 2;
422: if (s -> s_cn_reference.sr_ulen)
423: basesize += 2 + s -> s_cn_reference.sr_ulen;
424: if (s -> s_cn_reference.sr_clen)
425: basesize += 2 + s -> s_cn_reference.sr_clen;
426: if (s -> s_cn_reference.sr_alen)
427: basesize += 2 + s -> s_cn_reference.sr_alen;
428: }
429: If_Set (SMASK_CN_CALLING)
430: basesize += s -> s_callinglen + 2;
431: If_Set (SMASK_CN_CALLED)
432: basesize += s -> s_calledlen + 2;
433: break;
434:
435: case SPDU_RF:
436: If_Set (SMASK_RF_REF) {
437: basesize += 2;
438: if (s -> s_rf_reference.sr_ulen)
439: basesize += 2 + s -> s_rf_reference.sr_ulen;
440: if (s -> s_rf_reference.sr_clen)
441: basesize += 2 + s -> s_rf_reference.sr_clen;
442: if (s -> s_rf_reference.sr_alen)
443: basesize += 2 + s -> s_rf_reference.sr_alen;
444: }
445: break;
446:
447: case SPDU_AR:
448: basesize += 2;
449: If_Set (SMASK_AR_REF) {
450: if (s -> s_ar_reference.sr_ulen)
451: basesize += 2 + s -> s_ar_reference.sr_ulen;
452: if (s -> s_ar_reference.sr_clen)
453: basesize += 2 + s -> s_ar_reference.sr_clen;
454: if (s -> s_ar_reference.sr_alen)
455: basesize += 2 + s -> s_ar_reference.sr_alen;
456: if (s -> s_ar_reference.sr_vlen)
457: basesize += 2 + s -> s_ar_reference.sr_vlen;
458: }
459: break;
460: }
461:
462: if (basesize < 254)
463: basesize = 254;
464: c -> li = c -> pgi = 0;
465: c -> len = basesize + ((basesize > 254) ? 4 : 2);
466: if ((c -> top = malloc ((unsigned) c -> len)) == NULL) {
467: c -> len = 0;
468: s -> s_errno = SC_CONGEST;
469: }
470: else
471: s -> s_errno = SC_ACCEPT;
472: if ((c -> allocli = c -> left = basesize) > 254)
473: c -> ptr = c -> top + 4;
474: else
475: c -> ptr = c -> top + 2;
476: }
477:
478: /* */
479:
480: static int end_spdu (code, c)
481: unsigned char code;
482: struct local_buf *c;
483: {
484: if (c -> len) {
485: if (c -> allocli > 254) {
486: if (c -> li < 255) {
487: bcopy ((c -> top + 2), c -> top, (c -> len - c -> left));
488: *(c -> top + 1) = c -> li;
489: c -> len = c -> li + 2;
490: }
491: else {
492: *(c -> top + 1) = 255;
493: *(c -> top + 2) = (c -> li >> 8) & 0xff;
494: *(c -> top + 3) = c -> li & 0xff;
495: c -> len = c -> li + 4;
496: }
497: }
498: else {
499: *(c -> top + 1) = c -> li;
500: c -> len = c -> ptr - c -> top;
501: }
502: *c -> top = code;
503: return OK;
504: }
505:
506: return NOTOK;
507: }
508:
509: /* */
510:
511: static start_pgi (code, c)
512: unsigned char code;
513: struct local_buf *c;
514: {
515: put2spdu ((int) code, 0, NULLCP, c);
516: if (c -> len)
517: c -> pgi = (c -> ptr - c -> top - 1);
518: }
519:
520:
521: static end_pgi (c)
522: struct local_buf *c;
523: {
524: if (c -> len)
525: *(c -> top + c -> pgi) = (c -> len - c -> left) - (c -> pgi + 1);
526: }
527:
528: /* */
529:
530: static put2spdu (code, li, value, c)
531: int code;
532: int li;
533: char *value;
534: struct local_buf *c;
535: {
536: int cl = li;
537: char *p1,
538: *p2;
539:
540: if (c -> len) {
541: cl += (li < 255) ? 2 : 4;
542: if (c -> left >= cl)
543: c -> left -= cl;
544: else {
545: /* XXX: this clause of Dwight's is all WRONG, WRONG, WRONG. I think we
546: should make start_spdu() smarter, if necessary and change this to
547:
548: c -> len = 0;
549: return;
550: */
551: char *cp;
552:
553: if (c -> allocli < 255)
554: cl += 2;
555: cp = realloc (c -> top, (unsigned) (c -> len += cl));
556: if (cp == NULL) {
557: c -> len = 0;
558: return;
559: }
560: c -> ptr = (c -> top = cp) + (c -> len - c -> left);
561: if (c -> allocli < 255) {
562: c -> allocli += cl;
563: cl = c -> len - c -> left + 2;
564: for (p1 = c -> ptr, p2 = p1 + 2; cl; cl--)
565: *p2-- = *p1--;
566: c -> pgi += 2;
567: c -> left -= 2;
568: }
569: }
570: *c -> ptr++ = code & 0xff;
571: if (li < 255) {
572: *c -> ptr++ = li;
573: c -> li += 2 + li;
574: }
575: else {
576: *c -> ptr++ = 255;
577: *c -> ptr++ = (li >> 8) & 0xff;
578: *c -> ptr++ = li & 0xff;
579: c -> li += 4 + li;
580: }
581:
582: bcopy (value, c -> ptr, li);
583: c -> ptr += li;
584: }
585: }
586:
587: /* */
588:
589: int spkt2tsdu (s, base, len)
590: register struct ssapkt *s;
591: char **base;
592: int *len;
593: {
594: struct local_buf c;
595: char isn[SIZE_CN_ISN + 1];
596:
597: c.len = 0;
598: switch (s -> s_code) {
599: case SPDU_CN:
600: start_spdu (s, &c, CN_BASE_SIZE);
601: If_Set (SMASK_CN_REF)
602: Put_Ref (s -> s_cn_reference, PI_CALLING_SS);
603: If_Set (SMASK_CN_OPT | SMASK_CN_TSDU | SMASK_CN_VRSN | SMASK_CN_ISN
604: | SMASK_CN_SET) {
605: start_pgi (PGI_CN_ITEMS, &c);
606: If_Set (SMASK_CN_OPT)
607: Put_Item (PI_PROTOCOL_OPT, (char *) &s -> s_options);
608: If_Set (SMASK_CN_TSDU) {
609: u_long tsdu_maxsize = (s -> s_tsdu_init & 0xffff) << 16
610: | s -> s_tsdu_resp & 0xffff;
611: tsdu_maxsize = htonl (tsdu_maxsize);
612: Put_Item (PI_TSDU_MAXSIZ, (char *) &tsdu_maxsize);
613: }
614: If_Set (SMASK_CN_VRSN)
615: Put_Item (PI_VERSION, (char *) &s -> s_cn_version);
616: If_Set (SMASK_CN_ISN)
617: Put_SSN (PI_ISN, s -> s_isn);
618: If_Set (SMASK_CN_SET)
619: Put_Item (PI_TOKEN_SET, (char *) &s -> s_settings);
620: end_pgi (&c);
621: }
622: If_Set (SMASK_CN_REQ) {
623: u_short requirements = htons (s -> s_cn_require);
624: Put_Item (PI_USER_REQ, (char *) &requirements);
625: }
626: If_Set (SMASK_CN_CALLING)
627: put2spdu (PI_SSAP_CALLING, s -> s_callinglen,
628: s -> s_calling, &c);
629: If_Set (SMASK_CN_CALLED)
630: put2spdu (PI_SSAP_CALLED, s -> s_calledlen,
631: s -> s_called, &c);
632: Put_XData (CN_SIZE);
633: break;
634:
635: case SPDU_AC:
636: start_spdu (s, &c, AC_BASE_SIZE);
637: If_Set (SMASK_CN_REF)
638: Put_Ref (s -> s_cn_reference, PI_CALLED_SS);
639: If_Set (SMASK_CN_OPT | SMASK_CN_TSDU | SMASK_CN_VRSN | SMASK_CN_ISN
640: | SMASK_CN_SET) {
641: start_pgi (PGI_CN_ITEMS, &c);
642: If_Set (SMASK_CN_OPT)
643: Put_Item (PI_PROTOCOL_OPT, (char *) &s -> s_options);
644: If_Set (SMASK_CN_TSDU) {
645: u_long tsdu_maxsize = (s -> s_tsdu_init & 0xffff) << 16
646: | s -> s_tsdu_resp & 0xffff;
647: tsdu_maxsize = htonl (tsdu_maxsize);
648: Put_Item (PI_TSDU_MAXSIZ, (char *) &tsdu_maxsize);
649: }
650: If_Set (SMASK_CN_VRSN)
651: Put_Item (PI_VERSION, (char *) &s -> s_cn_version);
652: If_Set (SMASK_CN_ISN)
653: Put_SSN (PI_ISN, s -> s_isn);
654: If_Set (SMASK_CN_SET)
655: Put_Item (PI_TOKEN_SET, (char *) &s -> s_settings);
656: end_pgi (&c);
657: }
658: If_Set (SMASK_AC_TOKEN)
659: Put_Item (PI_TOKEN, (char *) &s -> s_ac_token);
660: If_Set (SMASK_CN_REQ) {
661: u_short requirements = htons (s -> s_cn_require);
662: Put_Item (PI_USER_REQ, (char *) &requirements);
663: }
664: If_Set (SMASK_CN_CALLING)
665: put2spdu (PI_SSAP_CALLING, s -> s_callinglen,
666: s -> s_calling, &c);
667: If_Set (SMASK_CN_CALLED)
668: put2spdu (PI_SSAP_CALLED, s -> s_calledlen,
669: s -> s_called, &c);
670: If_Set (SMASK_ENCLOSE)
671: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
672: Put_UData (AC_SIZE);
673: break;
674:
675: case SPDU_RF:
676: start_spdu (s, &c, RF_BASE_SIZE);
677: If_Set (SMASK_RF_REF)
678: Put_Ref (s -> s_rf_reference, PI_CALLED_SS);
679: If_Set (SMASK_RF_DISC)
680: Put_Item (PI_TDISC, (char *) &s -> s_rf_disconnect);
681: If_Set (SMASK_RF_REQ) {
682: u_short requirements = htons (s -> s_rf_require);
683: Put_Item (PI_USER_REQ, (char *) &requirements);
684: }
685: If_Set (SMASK_RF_VRSN)
686: Put_Item (PI_VERSION, (char *) &s -> s_rf_version);
687: if (s -> s_rlen > RF_SIZE) {
688: if (c.len)
689: free (c.top);
690: s -> s_errno = SC_PROTOCOL;
691: return NOTOK;
692: }
693: If_Set (SMASK_ENCLOSE)
694: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
695: if (s -> s_rlen > 0)
696: put2spdu (PI_REASON, s -> s_rlen, s -> s_rdata, &c);
697: break;
698:
699: case SPDU_FN:
700: start_spdu (s, &c, FN_BASE_SIZE);
701: If_Set (SMASK_FN_DISC)
702: Put_Item (PI_TDISC, (char *) &s -> s_fn_disconnect);
703: If_Set (SMASK_ENCLOSE)
704: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
705: Put_UData (FN_SIZE);
706: break;
707:
708: case SPDU_DN:
709: start_spdu (s, &c, DN_BASE_SIZE);
710: If_Set (SMASK_ENCLOSE)
711: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
712: Put_UData (DN_SIZE);
713: break;
714:
715: case SPDU_NF:
716: start_spdu (s, &c, NF_BASE_SIZE);
717: If_Set (SMASK_ENCLOSE)
718: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
719: Put_UData (NF_SIZE);
720: break;
721:
722: case SPDU_AB:
723: #ifdef notdef
724: case SPDU_AI: /* aka SPDU_AB */
725: #endif
726: If_Set (SMASK_SPDU_AB) {
727: start_spdu (s, &c, AB_BASE_SIZE);
728: If_Reset (SMASK_AB_DISC) {
729: s -> s_errno = SC_PROTOCOL;
730: break;
731: }
732: Put_Item (PI_TDISC, (char *) &s -> s_ab_disconnect);
733: If_Set (SMASK_AB_REFL)
734: put2spdu (PI_REFLECT, AB_REFL_SIZE,
735: (char *) s -> s_reflect, &c);
736: If_Set (SMASK_ENCLOSE)
737: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
738: Put_UData (AB_SIZE);
739: break;
740: }
741: start_spdu (s, &c, AI_BASE_SIZE);
742: If_Set (SMASK_AI_REASON)
743: put2spdu (PI_REASON, 1, (char *) &s -> s_ai_reason, &c);
744: break;
745:
746: case SPDU_AA:
747: #ifdef notdef
748: case SPDU_AIA: /* aka SPDU_AA */
749: #endif
750: If_Set (SMASK_SPDU_AA) {
751: start_spdu (s, &c, AA_BASE_SIZE);
752: break;
753: }
754: start_spdu (s, &c, AIA_BASE_SIZE);
755: break;
756:
757: case SPDU_GT:
758: #ifdef notdef
759: case SPDU_DT: /* aka SPDU_GT */
760: #endif
761: If_Set (SMASK_SPDU_GT) {
762: start_spdu (s, &c, GT_BASE_SIZE);
763: If_Set (SMASK_GT_TOKEN)
764: Put_Item (PI_TOKEN, (char *) &s -> s_gt_token);
765: break;
766: } /* else fall */
767: start_spdu (s, &c, DT_BASE_SIZE);
768: If_Set (SMASK_ENCLOSE)
769: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
770: /* NB: caller responsible for mapping s -> s_udata to user info */
771: break;
772:
773: case SPDU_TD:
774: start_spdu (s, &c, TD_BASE_SIZE);
775: If_Set (SMASK_ENCLOSE)
776: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
777: /* NB: caller responsible for mapping s -> s_udata to user info */
778: break;
779:
780: case SPDU_EX:
781: start_spdu (s, &c, EX_BASE_SIZE);
782: /* NB: caller responsible for mapping s -> s_udata to user info */
783: break;
784:
785: case SPDU_CD:
786: start_spdu (s, &c, CD_BASE_SIZE);
787: If_Set (SMASK_ENCLOSE)
788: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
789: Put_UData (CD_SIZE);
790: break;
791:
792: case SPDU_CDA:
793: start_spdu (s, &c, CDA_BASE_SIZE);
794: If_Set (SMASK_ENCLOSE)
795: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
796: Put_UData (CDA_SIZE);
797: break;
798:
799: case SPDU_PT:
800: start_spdu (s, &c, PT_BASE_SIZE);
801: If_Set (SMASK_PT_TOKEN)
802: Put_Item (PI_TOKEN, (char *) &s -> s_pt_token);
803: If_Set (SMASK_ENCLOSE)
804: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
805: Put_UData (PT_SIZE);
806: break;
807:
808: case SPDU_GTC:
809: start_spdu (s, &c, GTC_BASE_SIZE);
810: break;
811:
812: case SPDU_GTA:
813: start_spdu (s, &c, GTA_BASE_SIZE);
814: break;
815:
816: case SPDU_MIP:
817: start_spdu (s, &c, MIP_BASE_SIZE);
818: If_Set (SMASK_MIP_SYNC)
819: Put_Item (PI_SYNC, (char *) &s -> s_mip_sync);
820: If_Reset (SMASK_MIP_SERIAL) {
821: s -> s_errno = SC_PROTOCOL;
822: break;
823: }
824: Put_SSN (PI_SERIAL, s -> s_mip_serial);
825: If_Set (SMASK_ENCLOSE)
826: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
827: Put_UData (MIP_SIZE);
828: break;
829:
830: case SPDU_MAP:
831: #ifdef notdef
832: case SPDU_AE: /* aka SPDU_MAP */
833: #endif
834: If_Set (SMASK_MAP_SYNC) {
835: start_spdu (s, &c, MAP_BASE_SIZE);
836: Put_Item (PI_SYNC, (char *) &s -> s_map_sync);
837: }
838: else
839: start_spdu (s, &c, AE_BASE_SIZE);
840: If_Reset (SMASK_MAP_SERIAL) {
841: s -> s_errno = SC_PROTOCOL;
842: break;
843: }
844: Put_SSN (PI_SERIAL, s -> s_map_serial);
845: If_Set (SMASK_ENCLOSE)
846: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
847: Put_UData (MAP_SIZE);
848: break;
849:
850: case SPDU_MIA:
851: start_spdu (s, &c, MIA_BASE_SIZE);
852: If_Reset (SMASK_MIA_SERIAL) {
853: s -> s_errno = SC_PROTOCOL;
854: break;
855: }
856: Put_SSN (PI_SERIAL, s -> s_mia_serial);
857: If_Set (SMASK_ENCLOSE)
858: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
859: Put_MData (MIA_SIZE);
860: break;
861:
862: case SPDU_MAA:
863: #ifdef notdef
864: case SPDU_AEA: /* aka SPDU_MAA */
865: #endif
866: start_spdu (s, &c, MAA_BASE_SIZE);
867: If_Reset (SMASK_MAA_SERIAL) {
868: s -> s_errno = SC_PROTOCOL;
869: break;
870: }
871: Put_SSN (PI_SERIAL, s -> s_maa_serial);
872: If_Set (SMASK_ENCLOSE)
873: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
874: Put_UData (MAA_SIZE);
875: break;
876:
877: case SPDU_RS:
878: start_spdu (s, &c, RS_BASE_SIZE);
879: If_Set (SMASK_RS_SET)
880: Put_Item (PI_TOKEN_SET, (char *) &s -> s_rs_settings);
881: If_Reset (SMASK_RS_TYPE) {
882: s -> s_errno = SC_PROTOCOL;
883: break;
884: }
885: Put_Item (PI_RESYNC, (char *) &s -> s_rs_type);
886: If_Reset (SMASK_RS_SSN) {
887: s -> s_errno = SC_PROTOCOL;
888: break;
889: }
890: Put_SSN (PI_SERIAL, s -> s_rs_serial);
891: If_Set (SMASK_ENCLOSE)
892: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
893: Put_UData (RS_SIZE);
894: break;
895:
896: case SPDU_RA:
897: start_spdu (s, &c, RA_BASE_SIZE);
898: If_Set (SMASK_RA_SET)
899: Put_Item (PI_TOKEN_SET, (char *) &s -> s_ra_settings);
900: If_Reset (SMASK_RA_SSN) {
901: s -> s_errno = SC_PROTOCOL;
902: break;
903: }
904: Put_SSN (PI_SERIAL, s -> s_ra_serial);
905: If_Set (SMASK_ENCLOSE)
906: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
907: Put_UData (RA_SIZE);
908: break;
909:
910: case SPDU_PR:
911: start_spdu (s, &c, PR_BASE_SIZE);
912: If_Reset (SMASK_PR_TYPE) {
913: s -> s_errno = SC_PROTOCOL;
914: break;
915: }
916: Put_Item (PI_PREPARE, (char *) &s -> s_pr_type);
917: break;
918:
919: case SPDU_ER: /* we don't do these! */
920: s -> s_errno = SC_PROTOCOL;
921: break;
922:
923: case SPDU_ED:
924: start_spdu (s, &c, ED_BASE_SIZE);
925: If_Reset (SMASK_ED_REASON) {
926: s -> s_errno = SC_PROTOCOL;
927: break;
928: }
929: put2spdu (PI_REASON, 1, (char *) &s -> s_ed_reason, &c);
930: If_Set (SMASK_ENCLOSE)
931: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
932: Put_UData (ED_SIZE);
933: break;
934:
935: case SPDU_AS:
936: start_spdu (s, &c, AS_BASE_SIZE);
937: If_Reset (SMASK_AS_ID) {
938: s -> s_errno = SC_PROTOCOL;
939: break;
940: }
941: put2spdu (PI_ACT_ID, (int) s -> s_as_id.sd_len,
942: s -> s_as_id.sd_data, &c);
943: If_Set (SMASK_ENCLOSE)
944: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
945: Put_UData (AS_SIZE);
946: break;
947:
948: case SPDU_AR:
949: start_spdu (s, &c, AR_BASE_SIZE);
950: start_pgi (PGI_AR_LINK, &c);
951: If_Set (SMASK_AR_REF) {
952: if (s -> s_ar_reference.sr_called_len)
953: put2spdu (PI_AR_CALLED,
954: (int) s -> s_ar_reference.sr_called_len,
955: s -> s_ar_reference.sr_called, &c);
956: if (s -> s_ar_reference.sr_calling_len)
957: put2spdu (PI_AR_CALLING,
958: (int) s -> s_ar_reference.sr_calling_len,
959: s -> s_ar_reference.sr_calling, &c);
960: if (s -> s_ar_reference.sr_clen)
961: put2spdu (PI_AR_COMMON, (int) s -> s_ar_reference.sr_clen,
962: s -> s_ar_reference.sr_cdata, &c);
963: if (s -> s_ar_reference.sr_alen)
964: put2spdu (PI_AR_ADDT, (int) s -> s_ar_reference.sr_alen,
965: s -> s_ar_reference.sr_adata, &c);
966: }
967: If_Reset (SMASK_AR_OID) {
968: s -> s_errno = SC_PROTOCOL;
969: break;
970: }
971: put2spdu (PI_ACT_ID, (int) s -> s_ar_oid.sd_len,
972: s -> s_ar_oid.sd_data, &c);
973: If_Reset (SMASK_AR_SSN) {
974: s -> s_errno = SC_PROTOCOL;
975: break;
976: }
977: Put_SSN (PI_SERIAL, s -> s_ar_serial);
978: end_pgi (&c);
979: If_Reset (SMASK_AR_ID) {
980: s -> s_errno = SC_PROTOCOL;
981: break;
982: }
983: put2spdu (PI_ACT_ID, (int) s -> s_ar_id.sd_len,
984: s -> s_ar_id.sd_data, &c);
985: If_Set (SMASK_ENCLOSE)
986: Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
987: Put_UData (AR_SIZE);
988: break;
989:
990: case SPDU_AD:
991: start_spdu (s, &c, AD_BASE_SIZE);
992: If_Set (SMASK_AD_REASON)
993: put2spdu (PI_REASON, 1, (char *) &s -> s_ad_reason, &c);
994: break;
995:
996: case SPDU_ADA:
997: start_spdu (s, &c, ADA_BASE_SIZE);
998: break;
999:
1000: default:
1001: s -> s_errno = SC_PROTOCOL;
1002: break;
1003: }
1004:
1005: if ((end_spdu (s -> s_code, &c) == NOTOK) || (s -> s_errno != SC_ACCEPT)) {
1006: if (s -> s_errno == SC_ACCEPT)
1007: s -> s_errno = SC_CONGEST;
1008: if (c.len) {
1009: free (c.top);
1010: c.len = 0;
1011: }
1012: *base = NULL;
1013: *len = 0;
1014: }
1015: else {
1016: *base = c.top;
1017: *len = c.len;
1018: s -> s_li = c.li;
1019: }
1020:
1021: #ifdef DEBUG
1022: if (ssap_log -> ll_events & LLOG_PDUS)
1023: spkt2text (ssap_log, s, 0);
1024: #endif
1025:
1026: return c.len ? OK : NOTOK;
1027: }
1028:
1029: /* */
1030:
1031: static u_long str2ssn (s, n)
1032: register char *s;
1033: register int n;
1034: {
1035: register u_long u;
1036:
1037: for (u = 0L; n > 0; n--)
1038: u = u * 10 + *s++ - '0';
1039:
1040: return u;
1041: }
1042:
1043: /* */
1044:
1045: /* this is used to pull PCI, not user data... */
1046:
1047: #define advance(n) \
1048: if (base >= xbase) { \
1049: if ((base = pullqb (qb, (n))) == NULL) { \
1050: s -> s_errno = SC_PROTOCOL; \
1051: break; \
1052: } \
1053: xbase = base + (n); \
1054: nread += (n); \
1055: } \
1056: else
1057:
1058: static char *pullqb (qb, n)
1059: struct qbuf *qb;
1060: int n;
1061: {
1062: register int i;
1063: int once;
1064: register char *cp;
1065: register struct qbuf *qp;
1066: static char *buffer = NULL;
1067:
1068: if (n > SEGMENT_MAX)
1069: return NULLCP;
1070:
1071: for (once = 1, cp = buffer, qp = NULL; n > 0; once = 0, cp += i, n -= i) {
1072: if (qp == NULL && (qp = qb -> qb_forw) == qb)
1073: return NULLCP;
1074:
1075: i = min (qp -> qb_len, n);
1076: if (once && i == n) { /* special case */
1077: cp = qp -> qb_data;
1078: qp -> qb_data += i, qp -> qb_len -= i;
1079: return cp;
1080: }
1081:
1082: if (buffer == NULL) {
1083: if ((buffer = malloc ((unsigned) SEGMENT_MAX)) == NULL)
1084: return NULLCP;
1085: cp = buffer;
1086: }
1087: bcopy (qp -> qb_data, cp, i);
1088:
1089: qp -> qb_data += i, qp -> qb_len -= i;
1090: if (qp -> qb_len <= 0) {
1091: remque (qp);
1092:
1093: free ((char *) qp);
1094: qp = NULL;
1095: }
1096: }
1097:
1098: return buffer;
1099: }
1100:
1101: /* */
1102:
1103: struct ssapkt *tsdu2spkt (qb, len, cc)
1104: struct qbuf *qb;
1105: int len,
1106: *cc;
1107: {
1108: register int li;
1109: int cat0,
1110: nread,
1111: pktlen,
1112: pgilen,
1113: pmask,
1114: xlen;
1115: register char *base;
1116: char *xbase;
1117: unsigned char code,
1118: si;
1119: register struct ssapkt *s;
1120:
1121: if (cc) {
1122: cat0 = *cc;
1123: *cc = 0;
1124: }
1125: else
1126: cat0 = 1;
1127: if ((base = pullqb (qb, nread = 2)) == NULL
1128: || (s = newspkt ((int) (si = *base++))) == NULL)
1129: return NULLSPKT;
1130:
1131: if (*((u_char *) base) == 255) {
1132: if ((base = pullqb (qb, 2)) == NULL) {
1133: s -> s_errno = SC_PROTOCOL;
1134: return s;
1135: }
1136: nread += 2;
1137: s -> s_li =
1138: (*((u_char *) base) << 8) + *((u_char *) (base + 1));
1139: }
1140: else
1141: s -> s_li = *((u_char *) base);
1142: pgilen = pktlen = s -> s_li;
1143:
1144: if (cat0)
1145: switch (si) {
1146: case SPDU_GT:
1147: Set (SMASK_SPDU_GT);
1148: break;
1149:
1150: case SPDU_AB:
1151: Set (SMASK_SPDU_AB);
1152: break;
1153:
1154: case SPDU_AA:
1155: Set (SMASK_SPDU_AA);
1156: break;
1157:
1158: default:
1159: break;
1160: }
1161:
1162: if ((si >= SI_TABLE_LEN)
1163: || ((pmask = si_table[si]) == PMASK_NOTSUPPORTED)) {
1164: s -> s_errno = SC_PROTOCOL;
1165: return s;
1166: }
1167: if (len < pktlen + nread) {
1168: s -> s_errno = SC_PROTOCOL;
1169: return s;
1170: }
1171:
1172: s -> s_errno = SC_ACCEPT;
1173: xbase = base;
1174: while (pktlen && (s -> s_errno == SC_ACCEPT)) {
1175: advance (2);
1176: code = *base++;
1177: if (*((u_char *) base) == 255) {
1178: base++;
1179: advance (2);
1180: li = (*((u_char *) base) << 8) + *((u_char *) (base + 1));
1181: xlen = 2;
1182: }
1183: else {
1184: li = *((u_char *) base);
1185: xlen = 1;
1186: }
1187: base += xlen;
1188: if (xlen > 1)
1189: xlen += 2;
1190: else
1191: xlen++;
1192: switch (code) {
1193: case PI_UDATA:
1194: if (!(pmask & PMASK_UDATA))
1195: s -> s_errno = SC_PROTOCOL;
1196: break;
1197:
1198: case PI_XDATA:
1199: if (!(pmask & PMASK_XDATA))
1200: s -> s_errno = SC_PROTOCOL;
1201: break;
1202:
1203: default:
1204: if (code >= PI_TABLE_LEN || !(pmask & pi_table[code]))
1205: s -> s_errno = SC_PROTOCOL;
1206: break;
1207: }
1208: if (s -> s_errno != SC_ACCEPT)
1209: break;
1210: if (!pgilen)
1211: pgilen = pktlen;
1212: pktlen -= (xlen + li);
1213: if (li > (pgilen -= xlen)) {
1214: s -> s_errno = SC_PROTOCOL;
1215: break;
1216: }
1217: pgilen -= li;
1218: if (li)
1219: advance (li);
1220: if (code < PI_TABLE_LEN) {
1221: if (li) {
1222: if (pi_table[code] & PMASK_VARLEN) {
1223: if (li > pi_length[code]) {
1224: s -> s_errno = SC_PROTOCOL;
1225: break;
1226: }
1227: }
1228: else
1229: if (li != pi_length[code]) {
1230: s -> s_errno = SC_PROTOCOL;
1231: break;
1232: }
1233: }
1234: }
1235:
1236: switch (code) {
1237: case PGI_AR_LINK:
1238: Set (SMASK_AR_OID);/* HACK! */
1239: goto do_pgi;
1240:
1241: case PGI_CN_ID:
1242: Set (SMASK_CN_REF);/* fall */
1243: case PGI_CN_ITEMS:
1244: do_pgi: ;
1245: pktlen += li;
1246: pgilen = li;
1247: li = 0;
1248: break;
1249:
1250: case PI_CALLED_SS:
1251: case PI_CALLING_SS:
1252: #ifdef notdef
1253: case PI_AR_CALLED:
1254: case PI_AR_CALLING:
1255: #endif
1256: switch (si) {
1257: case SPDU_CN:
1258: case SPDU_AC:
1259: s -> s_cn_reference.sr_ulen = li;
1260: bcopy (base, s -> s_cn_reference.sr_udata, li);
1261: Set (SMASK_CN_REF);
1262: break;
1263: case SPDU_RF:
1264: s -> s_rf_reference.sr_ulen = li;
1265: bcopy (base, s -> s_rf_reference.sr_udata, li);
1266: Set (SMASK_RF_REF);
1267: break;
1268: case SPDU_AR:
1269: switch (code) {
1270: case PI_AR_CALLED:
1271: s -> s_ar_reference.sr_called_len = li;
1272: bcopy (base, s -> s_ar_reference.sr_called,
1273: li);
1274: Set (SMASK_AR_REF);
1275: break;
1276: case PI_AR_CALLING:
1277: s -> s_ar_reference.sr_calling_len = li;
1278: bcopy (base, s -> s_ar_reference.sr_calling,
1279: li);
1280: Set (SMASK_AR_REF);
1281: break;
1282: default:
1283: s -> s_errno = SC_PROTOCOL;
1284: break;
1285: }
1286: break;
1287: default:
1288: s -> s_errno = SC_PROTOCOL;
1289: break;
1290: }
1291: base += li;
1292: break;
1293:
1294: case PI_COMMON_REF:
1295: #ifdef notdef
1296: case PI_AR_COMMON:
1297: #endif
1298: switch (si) {
1299: case SPDU_CN:
1300: case SPDU_AC:
1301: s -> s_cn_reference.sr_clen = li;
1302: bcopy (base, s -> s_cn_reference.sr_cdata, li);
1303: Set (SMASK_CN_REF);
1304: break;
1305: case SPDU_RF:
1306: s -> s_rf_reference.sr_clen = li;
1307: bcopy (base, s -> s_rf_reference.sr_cdata, li);
1308: Set (SMASK_RF_REF);
1309: break;
1310: case SPDU_AR:
1311: s -> s_ar_reference.sr_clen = li;
1312: bcopy (base, s -> s_ar_reference.sr_cdata, li);
1313: Set (SMASK_AR_REF);
1314: break;
1315: default:
1316: s -> s_errno = SC_PROTOCOL;
1317: break;
1318: }
1319: base += li;
1320: break;
1321:
1322: case PI_ADD_INFO:
1323: #ifdef notdef
1324: case PI_AR_ADDT:
1325: #endif
1326: switch (si) {
1327: case SPDU_CN:
1328: case SPDU_AC:
1329: s -> s_cn_reference.sr_alen = li;
1330: bcopy (base, s -> s_cn_reference.sr_adata, li);
1331: Set (SMASK_CN_REF);
1332: break;
1333: case SPDU_RF:
1334: s -> s_rf_reference.sr_alen = li;
1335: bcopy (base, s -> s_rf_reference.sr_adata, li);
1336: Set (SMASK_RF_REF);
1337: break;
1338: case SPDU_AR:
1339: s -> s_ar_reference.sr_alen = li;
1340: bcopy (base, s -> s_ar_reference.sr_adata, li);
1341: Set (SMASK_AR_REF);
1342: break;
1343: default:
1344: s -> s_errno = SC_PROTOCOL;
1345: break;
1346: }
1347: base += li;
1348: break;
1349:
1350: case PI_PROTOCOL_OPT:
1351: if ((s -> s_options = *base++) & ~CR_OPT_MASK)
1352: s -> s_errno = SC_PROTOCOL;
1353: else
1354: Set (SMASK_CN_OPT);
1355: break;
1356:
1357: case PI_TSDU_MAXSIZ:
1358: {
1359: u_long tsdu_maxsize;
1360: bcopy (base, (char *) &tsdu_maxsize,
1361: pi_length[PI_TSDU_MAXSIZ]);
1362: tsdu_maxsize = ntohl (tsdu_maxsize);
1363: s -> s_tsdu_init = (tsdu_maxsize >> 16) & 0xffff;
1364: s -> s_tsdu_resp = tsdu_maxsize & 0xffff;
1365: Set (SMASK_CN_TSDU);
1366: }
1367: base += pi_length[PI_TSDU_MAXSIZ];
1368: break;
1369:
1370: case PI_VERSION:
1371: switch (si) {
1372: case SPDU_CN:
1373: case SPDU_AC:
1374: s -> s_cn_version = *base++;
1375: Set (SMASK_CN_VRSN);
1376: break;
1377: case SPDU_RF:
1378: s -> s_rf_version = *base++;
1379: Set (SMASK_RF_VRSN);
1380: break;
1381: default:
1382: s -> s_errno = SC_PROTOCOL;
1383: break;
1384: }
1385: break;
1386:
1387: case PI_SYNC:
1388: switch (si) {
1389: case SPDU_MIP:
1390: if ((s -> s_mip_sync = *base++) & ~MIP_SYNC_MASK)
1391: s -> s_errno = SC_PROTOCOL;
1392: else
1393: Set (SMASK_MIP_SYNC);
1394: break;
1395: case SPDU_MAP:
1396: if ((s -> s_map_sync = *base++) & ~MAP_SYNC_MASK)
1397: s -> s_errno = SC_PROTOCOL;
1398: else
1399: Set (SMASK_MAP_SYNC);
1400: break;
1401: }
1402: break;
1403:
1404: case PI_TOKEN_SET:
1405: switch (si) {
1406: case SPDU_CN:
1407: case SPDU_AC:
1408: s -> s_settings = *base++;
1409: Set (SMASK_CN_SET);
1410: break;
1411: case SPDU_RS:
1412: s -> s_rs_settings = *base++;
1413: Set (SMASK_RS_SET);
1414: break;
1415: case SPDU_RA:
1416: s -> s_ra_settings = *base++;
1417: Set (SMASK_RA_SET);
1418: break;
1419: default:
1420: s -> s_errno = SC_PROTOCOL;
1421: break;
1422: }
1423: break;
1424:
1425: case PI_TOKEN:
1426: switch (si) {
1427: case SPDU_AC:
1428: s -> s_ac_token = *base++;
1429: Set (SMASK_AC_TOKEN);
1430: break;
1431: case SPDU_GT:
1432: If_Reset (SMASK_SPDU_GT) {
1433: s -> s_errno = SC_PROTOCOL;
1434: break;
1435: }
1436: s -> s_gt_token = *base++;
1437: Set (SMASK_GT_TOKEN);
1438: break;
1439: case SPDU_PT:
1440: s -> s_pt_token = *base++;
1441: Set (SMASK_PT_TOKEN);
1442: break;
1443: default:
1444: s -> s_errno = SC_PROTOCOL;
1445: break;
1446: }
1447: break;
1448:
1449: case PI_TDISC:
1450: switch (si) {
1451: case SPDU_RF:
1452: if ((s -> s_rf_disconnect = *base++) & ~RF_DISC_MASK)
1453: s -> s_errno = SC_PROTOCOL;
1454: else
1455: Set (SMASK_RF_DISC);
1456: break;
1457: case SPDU_FN:
1458: if ((s -> s_fn_disconnect = *base++) & ~FN_DISC_MASK)
1459: s -> s_errno = SC_PROTOCOL;
1460: else
1461: Set (SMASK_FN_DISC);
1462: break;
1463: case SPDU_AB:
1464: If_Reset (SMASK_SPDU_AB) {
1465: s -> s_errno = SC_PROTOCOL;
1466: break;
1467: }
1468: if ((s -> s_ab_disconnect = *base++) & ~AB_DISC_MASK)
1469: s -> s_errno = SC_PROTOCOL;
1470: else
1471: Set (SMASK_AB_DISC);
1472: break;
1473: default:
1474: s -> s_errno = SC_PROTOCOL;
1475: break;
1476: }
1477: break;
1478:
1479: case PI_USER_REQ:
1480: {
1481: u_short requirements;
1482: bcopy (base, (char *) &requirements, 2);
1483: requirements = ntohs (requirements);
1484: if (si != SPDU_RF) {
1485: s -> s_cn_require = requirements;
1486: Set (SMASK_CN_REQ);
1487: }
1488: else {
1489: s -> s_rf_require = requirements;
1490: Set (SMASK_RF_REQ);
1491: }
1492: }
1493: base += 2;
1494: break;
1495:
1496: case PI_ISN:
1497: switch (si) {
1498: case SPDU_CN:
1499: case SPDU_AC:
1500: s -> s_isn = str2ssn (base, li);
1501: Set (SMASK_CN_ISN);
1502: break;
1503: default:
1504: s -> s_errno = SC_PROTOCOL;
1505: break;
1506: }
1507: case PI_ISN2: /* not supported yet */
1508: base += li;
1509: break;
1510:
1511: case PI_ENCLOSE:
1512: if ((si == SPDU_DT && (s -> s_mask & SMASK_SPDU_GT))
1513: || (si == SPDU_AI && !(s -> s_mask & SMASK_SPDU_AB))) {
1514: s -> s_errno = SC_PROTOCOL;
1515: break;
1516: }
1517: if ((s -> s_enclose = *base++) & ~ENCL_MASK)
1518: s -> s_errno = SC_PROTOCOL;
1519: else
1520: Set (SMASK_ENCLOSE);
1521: break;
1522:
1523: case PI_RESYNC:
1524: s -> s_rs_type = *base++;
1525: if (SYNC_OK (s -> s_rs_type))
1526: Set (SMASK_RS_TYPE);
1527: else
1528: s -> s_errno = SC_PROTOCOL;
1529: break;
1530:
1531: case PI_ACT_ID:
1532: switch (si) {
1533: case SPDU_AS:
1534: s -> s_as_id.sd_len = li;
1535: bcopy (base, s -> s_as_id.sd_data, li);
1536: Set (SMASK_AS_ID);
1537: break;
1538:
1539: case SPDU_AR:
1540: if ((s -> s_mask & SMASK_AR_OID)
1541: && s -> s_ar_oid.sd_len == 0) {
1542: s -> s_ar_oid.sd_len = li;
1543: bcopy (base, s -> s_ar_oid.sd_data, li);
1544: }
1545: else {
1546: s -> s_ar_id.sd_len = li;
1547: bcopy (base, s -> s_ar_id.sd_data, li);
1548: Set (SMASK_AR_ID);
1549: }
1550: break;
1551:
1552: default:
1553: s -> s_errno = SC_PROTOCOL;
1554: break;
1555: }
1556: base += li;
1557: break;
1558:
1559: case PI_SERIAL:
1560: switch (si) {
1561: case SPDU_MIP:
1562: s -> s_mip_serial = str2ssn (base, li);
1563: Set (SMASK_MIP_SERIAL);
1564: break;
1565: case SPDU_MAP:
1566: s -> s_map_serial = str2ssn (base, li);
1567: Set (SMASK_MAP_SERIAL);
1568: break;
1569: case SPDU_MIA:
1570: s -> s_mia_serial = str2ssn (base, li);
1571: Set (SMASK_MIA_SERIAL);
1572: break;
1573: case SPDU_MAA:
1574: s -> s_maa_serial = str2ssn (base, li);
1575: Set (SMASK_MAA_SERIAL);
1576: break;
1577: case SPDU_RS:
1578: s -> s_rs_serial = str2ssn (base, li);
1579: Set (SMASK_RS_SSN);
1580: break;
1581: case SPDU_RA:
1582: s -> s_ra_serial = str2ssn (base, li);
1583: Set (SMASK_RA_SSN);
1584: break;
1585: case SPDU_AR:
1586: s -> s_ar_serial = str2ssn (base, li);
1587: Set (SMASK_AR_SSN);
1588: break;
1589: default:
1590: s -> s_errno = SC_PROTOCOL;
1591: break;
1592: }
1593: base += li;
1594: break;
1595:
1596: case PI_MIA_DATA:
1597: case PI_UDATA:
1598: case PI_XDATA:
1599: Set (SMASK_UDATA_PGI);
1600: if (!li)
1601: break;
1602: if (si == SPDU_AB && !(s -> s_mask & SMASK_SPDU_AB)) {
1603: s -> s_errno = SC_PROTOCOL;
1604: break;
1605: }
1606: else
1607: if (li > (code != PI_XDATA ? SEGMENT_MAX : CONNECT_MAX)) {
1608: s -> s_errno = SC_PROTOCOL;
1609: break;
1610: }
1611: s -> s_udata = malloc ((unsigned) (s -> s_ulen = li));
1612: if (s -> s_udata == NULL) {
1613: s -> s_errno = SC_CONGEST;
1614: break;
1615: }
1616: bcopy (base, s -> s_udata, li);
1617: base += li;
1618: break;
1619:
1620: case PI_REASON:
1621: switch (si) {
1622: case SPDU_RF:
1623: s -> s_rdata = malloc ((unsigned) (s -> s_rlen = li));
1624: if (s -> s_rdata == NULL) {
1625: s -> s_errno = SC_CONGEST;
1626: break;
1627: }
1628: bcopy (base, s -> s_rdata, li);
1629: base += li;
1630: break;
1631: case SPDU_ED:
1632: s -> s_ed_reason = *base++;
1633: if (li == 1 && SP_OK (s -> s_ed_reason))
1634: Set (SMASK_ED_REASON);
1635: else
1636: s -> s_errno = SC_PROTOCOL;
1637: break;
1638: case SPDU_AI:
1639: If_Set (SMASK_SPDU_AB) {
1640: s -> s_errno = SC_PROTOCOL;
1641: break;
1642: }
1643: s -> s_ai_reason = *base++;
1644: if (li == 1 && SP_OK (s -> s_ai_reason))
1645: Set (SMASK_AI_REASON);
1646: else
1647: s -> s_errno = SC_PROTOCOL;
1648: break;
1649: case SPDU_AD:
1650: s -> s_ad_reason = *base++;
1651: if (li == 1 && SP_OK (s -> s_ad_reason))
1652: Set (SMASK_AD_REASON);
1653: else
1654: s -> s_errno = SC_PROTOCOL;
1655: break;
1656: default:
1657: s -> s_errno = SC_PROTOCOL;
1658: break;
1659: }
1660: break;
1661:
1662: case PI_REFLECT:
1663: switch (si) {
1664: case SPDU_AB:
1665: If_Reset (SMASK_SPDU_AB) {
1666: s -> s_errno = SC_PROTOCOL;
1667: break;
1668: }
1669: if (li > AB_REFL_SIZE) {
1670: s -> s_errno = SC_PROTOCOL;
1671: break;
1672: }
1673: bcopy (base, (char *) s -> s_reflect, li);
1674: Set (SMASK_AB_REFL);
1675: break;
1676: case SPDU_ER:
1677: s -> s_udata = malloc ((unsigned) (s -> s_ulen = li));
1678: if (s -> s_udata == NULL) {
1679: s -> s_errno = SC_CONGEST;
1680: break;
1681: }
1682: bcopy (base, s -> s_udata, li);
1683: break;
1684: default:
1685: s -> s_errno = SC_PROTOCOL;
1686: break;
1687: }
1688: base += li;
1689: break;
1690:
1691: case PI_SSAP_CALLING:
1692: bcopy (base, s -> s_calling, s -> s_callinglen = li);
1693: Set (SMASK_CN_CALLING);
1694: base += li;
1695: break;
1696:
1697: case PI_SSAP_CALLED:
1698: bcopy (base, s -> s_called, s -> s_calledlen = li);
1699: Set (SMASK_CN_CALLED);
1700: base += li;
1701: break;
1702:
1703: case PI_PREPARE:
1704: if ((s -> s_pr_type = *base++) > PR_MAX)
1705: s -> s_errno = SC_PROTOCOL;
1706: else
1707: Set (SMASK_PR_TYPE);
1708: break;
1709:
1710: default:
1711: s -> s_errno = SC_PROTOCOL;
1712: break;
1713: }
1714: }
1715: /* NB: caller responsible for mapping user info to s -> s_qbuf */
1716:
1717: if (cc)
1718: *cc = nread;
1719: { /* "dangling" qbuf */
1720: register struct qbuf *qp;
1721:
1722: if ((qp = qb -> qb_forw) != qb && qp -> qb_len <= 0) {
1723: remque (qp);
1724:
1725: free ((char *) qp);
1726: }
1727: }
1728:
1729: switch (s -> s_code) {
1730: case SPDU_AB:
1731: If_Set (SMASK_SPDU_AB) {
1732: If_Reset (SMASK_AB_DISC)
1733: s -> s_errno = SC_PROTOCOL;
1734: }
1735: break;
1736:
1737: case SPDU_MIP:
1738: If_Reset (SMASK_MIP_SERIAL)
1739: s -> s_errno = SC_PROTOCOL;
1740: break;
1741:
1742: case SPDU_MAP:
1743: If_Reset (SMASK_MAP_SERIAL)
1744: s -> s_errno = SC_PROTOCOL;
1745: break;
1746:
1747: case SPDU_MIA:
1748: If_Reset (SMASK_MIA_SERIAL)
1749: s -> s_errno = SC_PROTOCOL;
1750: break;
1751:
1752: case SPDU_MAA:
1753: If_Reset (SMASK_MAA_SERIAL)
1754: s -> s_errno = SC_PROTOCOL;
1755: break;
1756:
1757: case SPDU_RS:
1758: If_Reset (SMASK_RS_TYPE)
1759: s -> s_errno = SC_PROTOCOL;
1760: If_Reset (SMASK_RS_SSN)
1761: s -> s_errno = SC_PROTOCOL;
1762: break;
1763:
1764: case SPDU_RA:
1765: If_Reset (SMASK_RA_SSN)
1766: s -> s_errno = SC_PROTOCOL;
1767: break;
1768:
1769: case SPDU_PR:
1770: If_Reset (SMASK_PR_TYPE)
1771: s -> s_errno = SC_PROTOCOL;
1772: break;
1773:
1774: case SPDU_ED:
1775: If_Reset (SMASK_ED_REASON)
1776: s -> s_errno = SC_PROTOCOL;
1777: break;
1778:
1779: case SPDU_AS:
1780: If_Reset (SMASK_AS_ID)
1781: s -> s_errno = SC_PROTOCOL;
1782: break;
1783:
1784: case SPDU_AR:
1785: If_Reset (SMASK_AR_OID)
1786: s -> s_errno = SC_PROTOCOL;
1787: If_Reset (SMASK_AR_SSN)
1788: s -> s_errno = SC_PROTOCOL;
1789: If_Reset (SMASK_AR_ID)
1790: s -> s_errno = SC_PROTOCOL;
1791: break;
1792: }
1793:
1794: #ifdef DEBUG
1795: if (ssap_log -> ll_events & LLOG_PDUS)
1796: spkt2text (ssap_log, s, 1);
1797: #endif
1798:
1799: return s;
1800: }
1801:
1802: /* */
1803:
1804: struct ssapkt *newspkt (code)
1805: int code;
1806: {
1807: register struct ssapkt *s;
1808:
1809: s = (struct ssapkt *) calloc (1, sizeof *s);
1810: if (s == NULL)
1811: return NULL;
1812:
1813: s -> s_code = code;
1814: s -> s_qbuf.qb_forw = s -> s_qbuf.qb_back = &s -> s_qbuf;
1815:
1816: return s;
1817: }
1818:
1819:
1820: int freespkt (s)
1821: register struct ssapkt *s;
1822: {
1823: if (s == NULL)
1824: return;
1825:
1826: switch (s -> s_code) {
1827: case SPDU_RF:
1828: if (s -> s_rdata)
1829: free (s -> s_rdata);/* and fall... */
1830:
1831: default:
1832: if (s -> s_udata)
1833: free (s -> s_udata);
1834: QBFREE (&s -> s_qbuf);
1835: break;
1836: }
1837:
1838: free ((char *) s);
1839: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.