![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to text2spkt.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 text2spkt.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / ssap |
1.1 root 1: /* text2spkt.c - read/write a SPDU thru a debug filter */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/ssap/RCS/text2spkt.c,v 7.0 89/11/23 22:25:54 mrose Rel $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/ssap/RCS/text2spkt.c,v 7.0 89/11/23 22:25:54 mrose Rel $
9: *
10: *
11: * $Log: text2spkt.c,v $
12: * Revision 7.0 89/11/23 22:25:54 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 "logger.h"
33:
34:
35: #define sprintc(v,b) sprintb ((int) (v), (b))
36:
37: /* */
38:
39: #define SPDU_TYPE(e) (void) ll_printf (lp, "%sCODE/ %s\n", rw, e)
40:
41: #define DMASK "\020\01RELEASE\02USER\03PROTOCOL\04UNKNOWN"
42: #define EMASK "\020\01BEGIN\02END"
43: #define OMASK "\020\01EXTD"
44: #define RMASK \
45: "\020\01HALFDUPLEX\02DUPLEX\03EXPEDITED\04MINORSYNC\05MAJORSYNC\06RESYNC\07ACTIVITY\010NEGOTIATED\011CAPABILITY\012EXCEPTIONS\013TYPEDATA"
46: #define SMASK "\020\01NOEND"
47: #define TMASK "\020\01DATA\03SYNC\05ACTIVITY\07RELEASE"
48: #define YMASK "\020\01NOEXPLICIT"
49:
50:
51:
52: void spkt2text (lp, s, read)
53: register LLog *lp;
54: register struct ssapkt *s;
55: int read;
56: {
57: char *rw = read ? "<--- " : "---> ";
58:
59: LLOG (lp, LLOG_ALL,
60: ("dump of SPDU 0x%x, errno=0x%x mask=0x%x%s",
61: s, s -> s_errno, s -> s_mask,
62: s -> s_mask & SMASK_SPDU_EXPD ? " (expedited)" : ""));
63: (void) ll_printf (lp, "%s(\n", rw);
64:
65: (void) ll_printf (lp, "%sLI/ %d\n", rw, s -> s_li);
66:
67: switch (s -> s_code) {
68: case SPDU_CN:
69: case SPDU_AC:
70: SPDU_TYPE (s -> s_code == SPDU_CN ? "CONNECT" : "ACCEPT");
71: if (s -> s_mask & SMASK_CN_REF)
72: type_ref (lp, rw, &s -> s_cn_reference);
73: if (s -> s_mask & SMASK_CN_OPT)
74: type_bits (lp, rw, "OPTIONS", s -> s_options, CR_OPT_MASK,
75: OMASK);
76: if (s -> s_mask & SMASK_CN_TSDU)
77: type_tsdu (lp, rw, s -> s_tsdu_init, s -> s_tsdu_resp);
78: if (s -> s_mask & SMASK_CN_VRSN)
79: type_vrsn (lp, rw, s -> s_cn_version);
80: if (s -> s_mask & SMASK_CN_ISN)
81: type_ssn (lp, rw, "ISN", s -> s_isn);
82: if (s -> s_mask & SMASK_CN_SET)
83: type_settings (lp, rw, s -> s_settings);
84: if (s -> s_code == SPDU_AC && (s -> s_mask & SMASK_AC_TOKEN))
85: type_bits (lp, rw, "TOKENS", s -> s_ac_token, -1, TMASK);
86: if (s -> s_mask & SMASK_CN_REQ)
87: type_bits (lp, rw, "REQUIREMENTS", s -> s_cn_require,
88: -1, RMASK);
89: if (s -> s_mask & SMASK_CN_CALLING)
90: type_id (lp, "CALLING", rw, s -> s_calling, s -> s_callinglen);
91: if (s -> s_mask & SMASK_CN_CALLED)
92: type_id (lp, "CALLED", rw, s -> s_called, s -> s_calledlen);
93: break;
94:
95: case SPDU_RF:
96: SPDU_TYPE ("REFUSE");
97: if (s -> s_mask & SMASK_RF_REF)
98: type_ref (lp, rw, &s -> s_rf_reference);
99: if (s -> s_mask & SMASK_RF_DISC)
100: type_bits (lp, rw, "DISCONNECT", s -> s_rf_disconnect,
101: RF_DISC_MASK, DMASK);
102: if (s -> s_mask & SMASK_RF_REQ)
103: type_bits (lp, rw, "REQUIREMENTS", s -> s_rf_require,
104: -1, RMASK);
105: if (s -> s_mask & SMASK_RF_VRSN)
106: type_vrsn (lp, rw, s -> s_rf_version);
107: if (s -> s_rlen > 0) {
108: type_reason (lp, rw, *s -> s_rdata & 0xff);
109: if (s -> s_rlen > 1)
110: type_data (lp, "REASON", rw, s -> s_rlen - 1,
111: s -> s_rdata + 1);
112: }
113: break;
114:
115: case SPDU_FN:
116: SPDU_TYPE ("FINISH");
117: if (s -> s_mask & SMASK_FN_DISC)
118: type_bits (lp, rw, "DISCONNECT", s -> s_fn_disconnect,
119: FN_DISC_MASK, DMASK);
120: break;
121:
122: case SPDU_DN:
123: SPDU_TYPE ("DISCONNECT");
124: break;
125:
126: case SPDU_NF:
127: SPDU_TYPE ("NOT FINISHED");
128: break;
129:
130: case SPDU_AB:
131: #ifdef notdef
132: case SPDU_AI: /* aka SPDU_AB */
133: #endif
134: if (s -> s_mask & SMASK_SPDU_AB) {
135: SPDU_TYPE ("ABORT");
136: if (s -> s_mask & SMASK_AB_DISC)
137: type_bits (lp, rw, "DISCONNECT", s -> s_ab_disconnect,
138: AB_DISC_MASK, DMASK);
139: if (s -> s_mask & SMASK_AB_REFL)
140: type_data (lp, "REFLECT", rw, sizeof s -> s_reflect,
141: (char *) s -> s_reflect);
142: break;
143: }
144: SPDU_TYPE ("ACTIVITY INTERRUPT");
145: if (s -> s_mask & SMASK_AI_REASON)
146: type_error (lp, rw, s -> s_ai_reason);
147: break;
148:
149: case SPDU_AA:
150: #ifdef notdef
151: case SPDU_AIA: /* aka SPDU_AA */
152: #endif
153: if (s -> s_mask & SMASK_SPDU_AA)
154: SPDU_TYPE ("ABORT ACCEPT");
155: else
156: SPDU_TYPE ("ACTIVITY INTERRUPT ACK");
157: break;
158:
159: case SPDU_GT:
160: #ifdef notdef
161: case SPDU_DT: /* aka SPDU_GT */
162: #endif
163: if (s -> s_mask & SMASK_SPDU_GT) {
164: SPDU_TYPE ("GIVE TOKENS");
165: if (s -> s_mask & SMASK_GT_TOKEN)
166: type_bits (lp, rw, "TOKENS", s -> s_gt_token, -1, TMASK);
167: }
168: else
169: SPDU_TYPE ("DATA TRANSFER");
170: break;
171:
172: case SPDU_EX:
173: SPDU_TYPE ("EXPEDITED");
174: break;
175:
176: case SPDU_TD:
177: SPDU_TYPE ("TYPED DATA");
178: break;
179:
180: case SPDU_CD:
181: SPDU_TYPE ("CAPABILITY DATA");
182: break;
183:
184: case SPDU_CDA:
185: SPDU_TYPE ("CAPABILITY DATA ACK");
186: break;
187:
188: case SPDU_PT:
189: SPDU_TYPE ("PLEASE TOKENS");
190: if (s -> s_mask & SMASK_PT_TOKEN)
191: type_bits (lp, rw, "TOKENS", s -> s_pt_token, -1, TMASK);
192: break;
193:
194: case SPDU_GTC:
195: SPDU_TYPE ("GIVE TOKENS CONFIRM");
196: break;
197:
198: case SPDU_GTA:
199: SPDU_TYPE ("GIVE TOKENS ACK");
200: break;
201:
202: case SPDU_MIP:
203: SPDU_TYPE ("MINOR SYNCHRONIZATION POINT");
204: if (s -> s_mask & SMASK_MIP_SYNC)
205: type_bits (lp, rw, "SYNC", s -> s_mip_sync, MIP_SYNC_MASK,
206: YMASK);
207: if (s -> s_mask & SMASK_MIP_SERIAL)
208: type_ssn (lp, rw, "SSN", s -> s_mip_serial);
209: break;
210:
211: case SPDU_MIA:
212: SPDU_TYPE ("MINOR SYNC ACK");
213: if (s -> s_mask & SMASK_MIA_SERIAL)
214: type_ssn (lp, rw, "SSN", s -> s_mia_serial);
215: break;
216:
217: case SPDU_MAP:
218: #ifdef notdef
219: case SPDU_AE: /* aka SPDU_MAP */
220: #endif
221: if ((s -> s_mask & SMASK_MAP_SYNC)
222: && (s -> s_map_sync & MAP_SYNC_NOEND)) {
223: SPDU_TYPE ("MAJOR SYNCHRONIZATION POINT");
224: type_bits (lp, rw, "SYNC", s -> s_map_sync, MAP_SYNC_MASK,
225: SMASK);
226: }
227: else
228: SPDU_TYPE ("ACTIVITY END");
229: if (s -> s_mask & SMASK_MAP_SERIAL)
230: type_ssn (lp, rw, "SSN", s -> s_map_serial);
231: break;
232:
233: case SPDU_MAA:
234: #ifdef notdef
235: case SPDU_AEA: /* aka SPDU_MAA */
236: #endif
237: SPDU_TYPE ("MAJOR SYNC/ACTIVITY END ACK");
238: if (s -> s_mask & SMASK_MAA_SERIAL)
239: type_ssn (lp, rw, "SSN", s -> s_maa_serial);
240: break;
241:
242: case SPDU_RS:
243: SPDU_TYPE ("RESYNCHRONIZE");
244: if (s -> s_mask & SMASK_RS_SET)
245: type_settings (lp, rw, s -> s_rs_settings);
246: if (s -> s_mask & SMASK_RS_TYPE)
247: type_resync (lp, rw, s -> s_rs_type);
248: if (s -> s_mask & SMASK_RS_SSN)
249: type_ssn (lp, rw, "RSN", s -> s_rs_serial);
250: break;
251:
252: case SPDU_RA:
253: SPDU_TYPE ("RESYNCHRONIZE ACK");
254: if (s -> s_mask & SMASK_RA_SET)
255: type_settings (lp, rw, s -> s_ra_settings);
256: if (s -> s_mask & SMASK_RA_SSN)
257: type_ssn (lp, rw, "RSN", s -> s_ra_serial);
258: break;
259:
260: case SPDU_PR:
261: SPDU_TYPE ("PREPARE");
262: type_prepare (lp, rw, s -> s_pr_type);
263: break;
264:
265: case SPDU_ER:
266: SPDU_TYPE ("EXCEPTION REPORT");
267: break;
268:
269: case SPDU_ED:
270: SPDU_TYPE ("EXCEPTION DATA");
271: if (s -> s_mask & SMASK_ED_REASON)
272: type_error (lp, rw, s -> s_ed_reason);
273: break;
274:
275: case SPDU_AS:
276: SPDU_TYPE ("ACTIVITY START");
277: if (s -> s_mask & SMASK_AS_ID) {
278: (void) ll_printf (lp, "%s", rw);
279: type_info (lp, "ID/ %d", (int) s -> s_as_id.sd_len,
280: s -> s_as_id.sd_data);
281: (void) ll_printf (lp, "\n");
282: }
283: break;
284:
285: case SPDU_AR:
286: SPDU_TYPE ("ACTIVITY RESUME");
287: if (s -> s_mask & SMASK_AR_REF)
288: type_ref (lp, rw, &s -> s_ar_reference);
289: if (s -> s_mask & SMASK_AR_OID) {
290: (void) ll_printf (lp, "%s", rw);
291: type_info (lp, "OLD ID/ %d", (int) s -> s_ar_oid.sd_len,
292: s -> s_ar_oid.sd_data);
293: (void) ll_printf (lp, "\n");
294: }
295: if (s -> s_mask & SMASK_AR_SSN)
296: type_ssn (lp, rw, "SSN", s -> s_ar_serial);
297: if (s -> s_mask & SMASK_AR_ID) {
298: (void) ll_printf (lp, "%s", rw);
299: type_info (lp, "ID/ %d", (int) s -> s_ar_id.sd_len,
300: s -> s_ar_id.sd_data);
301: (void) ll_printf (lp, "\n");
302: }
303: break;
304:
305: case SPDU_AD:
306: SPDU_TYPE ("ACTIVITY DISCARD");
307: if (s -> s_mask & SMASK_AD_REASON)
308: type_error (lp, rw, s -> s_ad_reason);
309: break;
310:
311: case SPDU_ADA:
312: SPDU_TYPE ("ACTIVITY DISCARD ACK");
313: break;
314:
315: default:
316: (void) ll_printf (lp, "%sCODE/ 0x%x\n", rw, s -> s_code);
317: break;
318: }
319:
320: if (s -> s_mask & SMASK_ENCLOSE)
321: type_bits (lp, rw, "ENCLOSURE", s -> s_enclose, ENCL_MASK, EMASK);
322:
323: if (s -> s_udata)
324: if (s -> s_code == SPDU_ER)
325: type_data (lp, "REFLECT", rw, s -> s_ulen, s -> s_udata);
326: else
327: if (s -> s_mask & SMASK_UDATA_PGI)
328: type_data (lp, "USER", rw, s -> s_ulen, s -> s_udata);
329: else {
330: (void) ll_printf (lp, "%sUSER INFO/ ", rw);
331: type_info (lp, "%d", s -> s_ulen, s -> s_udata);
332: (void) ll_printf (lp, "\n");
333: }
334: (void) ll_printf (lp, "%s)\n", rw);
335:
336: (void) ll_sync (lp);
337: }
338:
339: /* */
340:
341: static type_id (lp, type, rw, selector, len)
342: LLog *lp;
343: char *type,
344: *rw;
345: char *selector;
346: int len;
347: {
348: char buffer[BUFSIZ];
349:
350: buffer[explode (buffer, (u_char *) selector, len)] = NULL;
351:
352: (void) ll_printf (lp, "%s%s/ %d/\"%s\"\n", rw, type, len, buffer);
353: }
354:
355:
356: static type_ssn (lp, rw, what, ssn)
357: LLog *lp;
358: char *rw,
359: *what;
360: u_long ssn;
361: {
362: (void) ll_printf (lp, "%s%s/ %d\n", rw, what, ssn);
363: }
364:
365:
366: static type_bits (lp, rw, s, bits, mask, t)
367: LLog *lp;
368: char *rw,
369: *s,
370: *t;
371: u_char bits,
372: mask;
373: {
374: (void) ll_printf (lp, "%s%s/ %s", rw, s, sprintc (bits & mask, t));
375: if (bits & ~mask)
376: (void) ll_printf (lp, ": illegal use of %s", sprintc (bits & ~mask, t));
377: (void) ll_printf (lp, "\n");
378: }
379:
380:
381: #define dotoken(requires,shift,bit,type) \
382: { \
383: token = (settings >> shift) & ST_MASK; \
384: (void) ll_printf (lp, " %s:%s", type, token == ST_INIT_VALUE ? "initiator" \
385: : token == ST_RESP_VALUE ? "responder" \
386: : token == ST_CALL_VALUE ? "choice" \
387: : "reserved"); \
388: }
389:
390: static type_settings (lp, rw, settings)
391: LLog *lp;
392: char *rw;
393: u_char settings;
394: {
395: int token;
396:
397: (void) ll_printf (lp, "%sSETTINGS/", rw);
398: dotokens ();
399: (void) ll_printf (lp, "\n");
400: }
401:
402: #undef dotoken
403:
404:
405: static type_tsdu (lp, rw, init, resp)
406: LLog *lp;
407: char *rw;
408: u_short init,
409: resp;
410: {
411: (void) ll_printf (lp, "%sTSDU/ INITIATOR: %d, RESPONDER: %d\n",
412: rw, init, resp);
413: }
414:
415:
416: static type_ref (lp, rw, ref)
417: LLog *lp;
418: char *rw;
419: struct SSAPref *ref;
420: {
421: (void) ll_printf (lp, "%sREFERENCE/", rw);
422: if (ref -> sr_vlen)
423: type_info (lp, "<CALLING %d", (int) ref -> sr_calling_len,
424: ref -> sr_calling);
425: else
426: type_info (lp, " <USER %d", (int) ref -> sr_ulen, ref -> sr_udata);
427: type_info (lp, ", COMMON %d", (int) ref -> sr_clen, ref -> sr_cdata);
428: type_info (lp, ", ADDITIONAL %d", (int) ref -> sr_alen, ref -> sr_adata);
429: if (ref -> sr_vlen)
430: type_info (lp, ", CALLED %d", (int) ref -> sr_called_len,
431: ref -> sr_called);
432: (void) ll_printf (lp, ">\n");
433: }
434:
435:
436: static type_vrsn (lp, rw, version)
437: LLog *lp;
438: char *rw;
439: u_char version;
440: {
441: (void) ll_printf (lp, "%sVERSION/ 0x%x\n", rw, version);
442: }
443:
444:
445: static type_reason (lp, rw, reason)
446: LLog *lp;
447: char *rw;
448: int reason;
449: {
450: (void) ll_printf (lp, "%sREASON/ 0x%x: %s\n", rw, reason,
451: SErrString ((int) reason));
452: }
453:
454:
455: static type_prepare (lp, rw, type)
456: LLog *lp;
457: char *rw;
458: u_char type;
459: {
460: (void) ll_printf (lp, "%sTYPE/ ", rw);
461: switch (type) {
462: case PR_MAA:
463: (void) ll_printf (lp, "MAA");
464: break;
465: case PR_RS:
466: (void) ll_printf (lp, "RS");
467: break;
468: case PR_RA:
469: (void) ll_printf (lp, "RA");
470: break;
471: case PR_AB:
472: (void) ll_printf (lp, "AB");
473: break;
474: default:
475: (void) ll_printf (lp, "%d: illegal value", type);
476: break;
477: }
478: (void) ll_printf (lp, "\n");
479: }
480:
481:
482: static type_error (lp, rw, reason)
483: LLog *lp;
484: char *rw;
485: u_char reason;
486: {
487: (void) ll_printf (lp, "%sREASON/ ", rw);
488: switch (reason) {
489: case SP_NOREASON:
490: (void) ll_printf (lp, "No specific reason stated");
491: break;
492: case SP_JEOPARDY:
493: (void) ll_printf (lp, "User receiving ability jeopardized");
494: break;
495: case SP_SEQUENCE:
496: (void) ll_printf (lp, "User sequence error");
497: break;
498: case SP_LOCAL:
499: (void) ll_printf (lp, "Local SS-user error");
500: break;
501: case SP_PROCEDURAL:
502: (void) ll_printf (lp, "Unrecoverable procedural error");
503: break;
504: case SP_DEMAND:
505: (void) ll_printf (lp, "Demand data token");
506: break;
507: default:
508: (void) ll_printf (lp, "%d: illegal value", reason);
509: break;
510: }
511: (void) ll_printf (lp, "\n");
512: }
513:
514:
515: static type_resync (lp, rw, type)
516: LLog *lp;
517: char *rw;
518: u_char type;
519: {
520: (void) ll_printf (lp, "%sTYPE/ ", rw);
521: switch (type) {
522: case SYNC_RESTART:
523: (void) ll_printf (lp, "restart");
524: break;
525: case SYNC_ABANDON:
526: (void) ll_printf (lp, "abandon");
527: break;
528: case SYNC_SET:
529: (void) ll_printf (lp, "set");
530: break;
531: default:
532: (void) ll_printf (lp, "%d: illegal value", type);
533: break;
534: }
535: (void) ll_printf (lp, "\n");
536: }
537:
538:
539: static type_data (lp, type, rw, len, data)
540: LLog *lp;
541: char *type,
542: *rw,
543: *data;
544: int len;
545: {
546: (void) ll_printf (lp, "%s%s DATA/ ", rw, type);
547: type_info (lp, "%d", len, data);
548: (void) ll_printf (lp, "\n");
549: }
550:
551:
552: static type_info (lp, fmt, len, data)
553: LLog *lp;
554: char *fmt,
555: *data;
556: int len;
557: {
558: char buffer[BUFSIZ];
559:
560: (void) ll_printf (lp, fmt, len);
561: if (0 < len && len < sizeof buffer / 2) {
562: buffer[explode (buffer, (u_char *) data, len)] = NULL;
563: (void) ll_printf (lp, " %s", buffer);
564: }
565: }
566:
567: /* */
568:
569: /* ARGSUSED */
570:
571: void text2spkt (s)
572: struct ssapkt *s;
573: {
574: /* NOT YET IMPLEMENTED */
575: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.