print.c revision 1.10 
1/*	$OpenBSD: print.c,v 1.10 2006/04/17 16:23:01 deraadt Exp $ */
2
3/*
4 * Copyright (c) 1993-96 Mats O Jansson.  All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 *    notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27#ifndef lint
28static const char rcsid[] =
29    "$OpenBSD: print.c,v 1.10 2006/04/17 16:23:01 deraadt Exp $";
30#endif
31
32#include <sys/types.h>
33#include <stdio.h>
34
35#include "os.h"
36#include "common/mopdef.h"
37#include "common/nmadef.h"
38#include "common/nma.h"
39#include "common/cmp.h"
40#include "common/get.h"
41
42#define SHORT_PRINT
43
44void
45mopPrintHWA(FILE *fd, u_char *ap)
46{
47	fprintf(fd, "%x:%x:%x:%x:%x:%x", ap[0], ap[1], ap[2], ap[3], ap[4],
48	    ap[5]);
49	if (ap[0] < 16) fprintf(fd, " ");
50	if (ap[1] < 16) fprintf(fd, " ");
51	if (ap[2] < 16) fprintf(fd, " ");
52	if (ap[3] < 16) fprintf(fd, " ");
53	if (ap[4] < 16) fprintf(fd, " ");
54	if (ap[5] < 16) fprintf(fd, " ");
55}
56
57void
58mopPrintBPTY(FILE *fd, u_char bpty)
59{
60	switch (bpty) {
61	case MOP_K_BPTY_SYS:
62		fprintf(fd, "System Processor");
63		break;
64	case MOP_K_BPTY_COM:
65		fprintf(fd, "Communication Processor");
66		break;
67	default:
68		fprintf(fd, "Unknown");
69		break;
70	};
71}
72
73void
74mopPrintPGTY(FILE *fd, u_char pgty)
75{
76	switch (pgty) {
77	case MOP_K_PGTY_SECLDR:
78		fprintf(fd, "Secondary Loader");
79		break;
80	case MOP_K_PGTY_TERLDR:
81		fprintf(fd, "Tertiary Loader");
82		break;
83	case MOP_K_PGTY_OPRSYS:
84		fprintf(fd, "Operating System");
85		break;
86	case MOP_K_PGTY_MGNTFL:
87		fprintf(fd, "Management File");
88		break;
89	default:
90		fprintf(fd, "Unknown");
91		break;
92	};
93}
94
95void
96mopPrintOneline(FILE *fd, u_char *pkt, int trans)
97{
98	int	 index = 0;
99	u_char	*dst, *src, code;
100	u_short	 proto;
101	int	 len;
102
103	trans = mopGetTrans(pkt, trans);
104	mopGetHeader(pkt, &index, &dst, &src, &proto, &len, trans);
105	code = mopGetChar(pkt, &index);
106
107	switch (proto) {
108	case MOP_K_PROTO_DL:
109		fprintf(fd, "MOP DL ");
110		break;
111	case MOP_K_PROTO_RC:
112		fprintf(fd, "MOP RC ");
113		break;
114	case MOP_K_PROTO_LP:
115		fprintf(fd, "MOP LP ");
116		break;
117	default:
118		switch ((proto % 256) * 256 + (proto / 256)) {
119		case MOP_K_PROTO_DL:
120			fprintf(fd, "MOP DL ");
121			proto = MOP_K_PROTO_DL;
122			break;
123		case MOP_K_PROTO_RC:
124			fprintf(fd, "MOP RC ");
125			proto = MOP_K_PROTO_RC;
126			break;
127		case MOP_K_PROTO_LP:
128			fprintf(fd, "MOP LP ");
129			proto = MOP_K_PROTO_LP;
130			break;
131		default:
132			fprintf(fd, "MOP ?? ");
133			break;
134		}
135	}
136
137	if (trans == TRANS_8023)
138		fprintf(fd, "802.3 ");
139
140	mopPrintHWA(fd, src); fprintf(fd, " > ");
141	mopPrintHWA(fd, dst);
142	if (len < 1600)
143	fprintf(fd, " len %4d code %02x ", len, code);
144	else
145		fprintf(fd, " len %4d code %02x ",
146		    (len % 256)*256 + (len /256), code);
147
148	switch (proto) {
149	case MOP_K_PROTO_DL:
150	switch (code) {
151		case MOP_K_CODE_MLT:
152			fprintf(fd, "MLT ");
153			break;
154		case MOP_K_CODE_DCM:
155			fprintf(fd, "DCM ");
156			break;
157		case MOP_K_CODE_MLD:
158			fprintf(fd, "MLD ");
159			break;
160		case MOP_K_CODE_ASV:
161			fprintf(fd, "ASV ");
162			break;
163		case MOP_K_CODE_RMD:
164			fprintf(fd, "RMD ");
165			break;
166		case MOP_K_CODE_RPR:
167			fprintf(fd, "RPR ");
168			break;
169		case MOP_K_CODE_RML:
170			fprintf(fd, "RML ");
171			break;
172		case MOP_K_CODE_RDS:
173			fprintf(fd, "RDS ");
174			break;
175		case MOP_K_CODE_MDD:
176			fprintf(fd, "MDD ");
177			break;
178		case MOP_K_CODE_PLT:
179			fprintf(fd, "PLT ");
180			break;
181		default:
182			fprintf(fd, "??? ");
183			break;
184		}
185		break;
186	case MOP_K_PROTO_RC:
187		switch (code) {
188		case MOP_K_CODE_RID:
189			fprintf(fd, "RID ");
190			break;
191		case MOP_K_CODE_BOT:
192			fprintf(fd, "BOT ");
193			break;
194		case MOP_K_CODE_SID:
195			fprintf(fd, "SID ");
196			break;
197		case MOP_K_CODE_RQC:
198			fprintf(fd, "RQC ");
199			break;
200		case MOP_K_CODE_CNT:
201			fprintf(fd, "CNT ");
202			break;
203		case MOP_K_CODE_RVC:
204			fprintf(fd, "RVC ");
205			break;
206		case MOP_K_CODE_RLC:
207			fprintf(fd, "RLC ");
208			break;
209		case MOP_K_CODE_CCP:
210			fprintf(fd, "CCP ");
211			break;
212		case MOP_K_CODE_CRA:
213			fprintf(fd, "CRA ");
214			break;
215		default:
216			fprintf(fd, "??? ");
217			break;
218		}
219		break;
220	case MOP_K_PROTO_LP:
221		switch (code) {
222		case MOP_K_CODE_ALD:
223			fprintf(fd, "ALD ");
224			break;
225		case MOP_K_CODE_PLD:
226			fprintf(fd, "PLD ");
227			break;
228		default:
229			fprintf(fd, "??? ");
230			break;
231		}
232		break;
233	default:
234		fprintf(fd, "??? ");
235		break;
236	}
237	fprintf(fd, "\n");
238}
239
240void
241mopPrintHeader(FILE *fd, u_char *pkt, int trans)
242{
243	u_char	*dst, *src;
244	u_short	 proto;
245	int	 len, index = 0;
246
247	trans = mopGetTrans(pkt, trans);
248	mopGetHeader(pkt, &index, &dst, &src, &proto, &len, trans);
249
250	fprintf(fd, "\nDst          : ");
251	mopPrintHWA(fd, dst);
252	if (mopCmpEAddr(dl_mcst, dst) == 0)
253		fprintf(fd, " MOP Dump/Load Multicast");
254	if (mopCmpEAddr(rc_mcst, dst) == 0)
255		fprintf(fd, " MOP Remote Console Multicast");
256	fprintf(fd, "\n");
257
258	fprintf(fd, "Src          : ");
259	mopPrintHWA(fd, src);
260	fprintf(fd, "\n");
261	fprintf(fd, "Proto        : %04x ", proto);
262
263	switch (proto) {
264	case MOP_K_PROTO_DL:
265		switch (trans) {
266		case TRANS_8023:
267			fprintf(fd, "MOP Dump/Load (802.3)\n");
268			break;
269		default:
270			fprintf(fd, "MOP Dump/Load\n");
271		}
272		break;
273	case MOP_K_PROTO_RC:
274		switch (trans) {
275		case TRANS_8023:
276			fprintf(fd, "MOP Remote Console (802.3)\n");
277			break;
278		default:
279			fprintf(fd, "MOP Remote Console\n");
280		}
281		break;
282	case MOP_K_PROTO_LP:
283		switch (trans) {
284		case TRANS_8023:
285			fprintf(fd, "MOP Loopback (802.3)\n");
286			break;
287		default:
288			fprintf(fd, "MOP Loopback\n");
289		}
290		break;
291	default:
292		fprintf(fd, "\n");
293		break;
294	}
295
296	fprintf(fd, "Length       : %04x (%d)\n", len, len);
297}
298
299void
300mopPrintMopHeader(FILE *fd, u_char *pkt, int trans)
301{
302	u_char	*dst, *src;
303	u_short	 proto;
304	int	 len, index = 0;
305	u_char   code;
306
307	trans = mopGetTrans(pkt, trans);
308	mopGetHeader(pkt, &index, &dst, &src, &proto, &len, trans);
309
310	code = mopGetChar(pkt, &index);
311
312	fprintf(fd, "Code         :   %02x ", code);
313
314	switch (proto) {
315	case MOP_K_PROTO_DL:
316		switch (code) {
317		case MOP_K_CODE_MLT:
318			fprintf(fd, "Memory Load with transfer address\n");
319			break;
320		case MOP_K_CODE_DCM:
321			fprintf(fd, "Dump Complete\n");
322			break;
323		case MOP_K_CODE_MLD:
324			fprintf(fd, "Memory Load\n");
325			break;
326		case MOP_K_CODE_ASV:
327			fprintf(fd, "Assistance volunteer\n");
328			break;
329		case MOP_K_CODE_RMD:
330			fprintf(fd, "Request memory dump\n");
331			break;
332		case MOP_K_CODE_RPR:
333			fprintf(fd, "Request program\n");
334			break;
335		case MOP_K_CODE_RML:
336			fprintf(fd, "Request memory load\n");
337			break;
338		case MOP_K_CODE_RDS:
339			fprintf(fd, "Request Dump Service\n");
340			break;
341		case MOP_K_CODE_MDD:
342			fprintf(fd, "Memory dump data\n");
343			break;
344		case MOP_K_CODE_PLT:
345			fprintf(fd, "Parameter load with transfer address\n");
346			break;
347		default:
348			fprintf(fd, "(unknown)\n");
349			break;
350		}
351		break;
352	case MOP_K_PROTO_RC:
353		switch (code) {
354		case MOP_K_CODE_RID:
355			fprintf(fd, "Request ID\n");
356			break;
357		case MOP_K_CODE_BOT:
358			fprintf(fd, "Boot\n");
359			break;
360		case MOP_K_CODE_SID:
361			fprintf(fd, "System ID\n");
362			break;
363		case MOP_K_CODE_RQC:
364			fprintf(fd, "Request Counters\n");
365			break;
366		case MOP_K_CODE_CNT:
367			fprintf(fd, "Counters\n");
368			break;
369		case MOP_K_CODE_RVC:
370			fprintf(fd, "Reserve Console\n");
371			break;
372		case MOP_K_CODE_RLC:
373			fprintf(fd, "Release Console\n");
374			break;
375		case MOP_K_CODE_CCP:
376			fprintf(fd, "Console Command and Poll\n");
377			break;
378		case MOP_K_CODE_CRA:
379			fprintf(fd, "Console Response and Acknnowledge\n");
380			break;
381		default:
382			fprintf(fd, "(unknown)\n");
383			break;
384		}
385		break;
386	case MOP_K_PROTO_LP:
387		switch (code) {
388		case MOP_K_CODE_ALD:
389			fprintf(fd, "Active loop data\n");
390			break;
391		case MOP_K_CODE_PLD:
392			fprintf(fd, "Passive looped data\n");
393			break;
394		default:
395			fprintf(fd, "(unknown)\n");
396			break;
397		}
398		break;
399	default:
400		fprintf(fd, "(unknown)\n");
401		break;
402	}
403}
404
405void
406mopPrintDevice(FILE *fd, u_char device)
407{
408	char	*sname, *name;
409
410	sname = nmaGetShort((int) device);
411	name = nmaGetDevice((int) device);
412
413	fprintf(fd, "%s '%s'", sname, name);
414}
415
416void
417mopPrintTime(FILE *fd, u_char *ap)
418{
419	fprintf(fd, "%04d-%02d-%02d %02d:%02d:%02d.%02d %d:%02d",
420	    ap[0] * 100 + ap[1], ap[2], ap[3], ap[4], ap[5], ap[6], ap[7],
421	    ap[8], ap[9]);
422}
423
424void
425mopPrintInfo(FILE *fd, u_char *pkt, int *index, u_short moplen, u_char mopcode,
426    int trans)
427{
428	u_short itype, tmps;
429	u_char  ilen, tmpc, device;
430	u_char  uc1, uc2, uc3, *ucp;
431	int     i;
432
433	device = 0;
434
435	switch (trans) {
436	case TRANS_ETHER:
437		moplen = moplen + 16;
438		break;
439	case TRANS_8023:
440		moplen = moplen + 14;
441		break;
442	}
443
444	itype = mopGetShort(pkt, index);
445
446	while (*index < (moplen + 2)) {
447		ilen = mopGetChar(pkt, index);
448		switch (itype) {
449		case 0:
450			tmpc  = mopGetChar(pkt, index);
451			*index = *index + tmpc;
452			break;
453		case MOP_K_INFO_VER:
454			uc1 = mopGetChar(pkt, index);
455			uc2 = mopGetChar(pkt, index);
456			uc3 = mopGetChar(pkt, index);
457			fprintf(fd, "Maint Version: %d.%d.%d\n", uc1, uc2, uc3);
458			break;
459		case MOP_K_INFO_MFCT:
460			tmps = mopGetShort(pkt, index);
461			fprintf(fd, "Maint Funcion: %04x ( ", tmps);
462			if (tmps &   1) fprintf(fd, "Loop ");
463			if (tmps &   2) fprintf(fd, "Dump ");
464			if (tmps &   4) fprintf(fd, "Pldr ");
465			if (tmps &   8) fprintf(fd, "MLdr ");
466			if (tmps &  16) fprintf(fd, "Boot ");
467			if (tmps &  32) fprintf(fd, "CC ");
468			if (tmps &  64) fprintf(fd, "DLC ");
469			if (tmps & 128) fprintf(fd, "CCR ");
470			fprintf(fd, ")\n");
471			break;
472		case MOP_K_INFO_CNU:
473			ucp = pkt + *index;
474			*index = *index + 6;
475			fprintf(fd, "Console User : ");
476			mopPrintHWA(fd, ucp);
477			fprintf(fd, "\n");
478			break;
479		case MOP_K_INFO_RTM:
480			tmps = mopGetShort(pkt, index);
481			fprintf(fd, "Reserv Timer : %04x (%d)\n", tmps, tmps);
482			break;
483		case MOP_K_INFO_CSZ:
484			tmps = mopGetShort(pkt, index);
485			fprintf(fd, "Cons Cmd Size: %04x (%d)\n", tmps, tmps);
486			break;
487		case MOP_K_INFO_RSZ:
488			tmps = mopGetShort(pkt, index);
489			fprintf(fd, "Cons Res Size: %04x (%d)\n", tmps, tmps);
490			break;
491		case MOP_K_INFO_HWA:
492			ucp = pkt + *index;
493			*index = *index + 6;
494			fprintf(fd, "Hardware Addr: ");
495			mopPrintHWA(fd, ucp);
496			fprintf(fd, "\n");
497			break;
498		case MOP_K_INFO_TIME:
499			ucp = pkt + *index;
500			*index = *index + 10;
501			fprintf(fd, "System Time: ");
502			mopPrintTime(fd, ucp);
503			fprintf(fd, "\n");
504			break;
505		case MOP_K_INFO_SOFD:
506			device = mopGetChar(pkt, index);
507			fprintf(fd, "Comm Device  :   %02x ", device);
508			mopPrintDevice(fd, device);
509			fprintf(fd, "\n");
510			break;
511		case MOP_K_INFO_SFID:
512			tmpc = mopGetChar(pkt, index);
513			fprintf(fd, "Software ID  :   %02x ", tmpc);
514			if ((tmpc == 0))
515				fprintf(fd, "No software id");
516			if ((tmpc == 254)) {
517				fprintf(fd, "Maintenance system");
518				tmpc = 0;
519			}
520			if ((tmpc == 255)) {
521				fprintf(fd, "Standard operating system");
522				tmpc = 0;
523			}
524			if ((tmpc > 0)) {
525				fprintf(fd, "'");
526				for (i = 0; i < ((int) tmpc); i++)
527					fprintf(fd, "%c",
528					    mopGetChar(pkt, index));
529				fprintf(fd, "'");
530			}
531			fprintf(fd, "\n");
532			break;
533		case MOP_K_INFO_PRTY:
534			tmpc = mopGetChar(pkt, index);
535			fprintf(fd, "System Proc  :   %02x ", tmpc);
536			switch (tmpc) {
537			case MOP_K_PRTY_11:
538				fprintf(fd, "PDP-11\n");
539				break;
540			case MOP_K_PRTY_CMSV:
541				fprintf(fd, "Communication Server\n");
542				break;
543			case MOP_K_PRTY_PRO:
544				fprintf(fd, "Professional\n");
545				break;
546			case MOP_K_PRTY_SCO:
547				fprintf(fd, "Scorpio\n");
548				break;
549			case MOP_K_PRTY_AMB:
550				fprintf(fd, "Amber\n");
551				break;
552			case MOP_K_PRTY_BRI:
553				fprintf(fd, "XLII Bridge\n");
554				break;
555			default:
556				fprintf(fd, "Unknown\n");
557				break;
558			};
559			break;
560		case MOP_K_INFO_DLTY:
561			tmpc = mopGetChar(pkt, index);
562			fprintf(fd, "DLnk Type    :   %02x ", tmpc);
563			switch (tmpc) {
564			case MOP_K_DLTY_NI:
565				fprintf(fd, "Ethernet\n");
566				break;
567			case MOP_K_DLTY_DDCMP:
568				fprintf(fd, "DDCMP\n");
569				break;
570			case MOP_K_DLTY_LAPB:
571				fprintf(fd, "LAPB (X.25)\n");
572				break;
573			default:
574				fprintf(fd, "Unknown\n");
575				break;
576			};
577			break;
578		case MOP_K_INFO_DLBSZ:
579			tmps = mopGetShort(pkt, index);
580			fprintf(fd, "DLnk Buf Size: %04x (%d)\n", tmps, tmps);
581			break;
582		default:
583			if (((device == NMA_C_SOFD_LCS) ||  /* DECserver 100 */
584			     (device == NMA_C_SOFD_DS2) ||  /* DECserver 200 */
585			     (device == NMA_C_SOFD_DP2) ||  /* DECserver 250 */
586			     (device == NMA_C_SOFD_DS3)) && /* DECserver 300 */
587			    ((itype > 101) && (itype < 107)))
588			{
589			switch (itype) {
590				case 102:
591					ucp = pkt + *index;
592					*index = *index + ilen;
593					fprintf(fd, "ROM SW Ver   :   %02x '",
594					    ilen);
595					for (i = 0; i < ilen; i++)
596						fprintf(fd, "%c", ucp[i]);
597					fprintf(fd, "'\n");
598					break;
599				case 103:
600					ucp = pkt + *index;
601					*index = *index + ilen;
602					fprintf(fd, "Loaded SW Ver:   %02x '",
603					    ilen);
604					for (i = 0; i < ilen; i++)
605						fprintf(fd, "%c", ucp[i]);
606					fprintf(fd, "'\n");
607					break;
608				case 104:
609					tmps = mopGetShort(pkt, index);
610					fprintf(fd,
611					    "DECnet Addr  : %d.%d (%d)\n",
612					    tmps / 1024, tmps % 1024, tmps);
613					break;
614				case 105:
615					ucp = pkt + *index;
616					*index = *index + ilen;
617					fprintf(fd, "Node Name    :   %02x '",
618					    ilen);
619					for (i = 0; i < ilen; i++)
620						fprintf(fd, "%c", ucp[i]);
621					fprintf(fd, "'\n");
622					break;
623				case 106:
624					ucp = pkt + *index;
625					*index = *index + ilen;
626					fprintf(fd, "Node Ident   :   %02x '",
627					    ilen);
628					for (i = 0; i < ilen; i++)
629						fprintf(fd, "%c", ucp[i]);
630					fprintf(fd, "'\n");
631					break;
632				}
633			} else {
634				ucp = pkt + *index;
635				*index = *index + ilen;
636				fprintf(fd, "Info Type    : %04x (%d)\n",
637				    itype, itype);
638				fprintf(fd, "Info Data    :   %02x ", ilen);
639				for (i = 0; i < ilen; i++) {
640					if ((i % 16) == 0)
641						if ((i / 16) != 0)
642							fprintf(fd,
643						     "\n                    ");
644					fprintf(fd, "%02x ", ucp[i]);
645				}
646				fprintf(fd, "\n");
647			}
648		}
649		itype = mopGetShort(pkt, index);
650	}
651}
652
653