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