print-bootp.c revision 147904 
1/*
2 * Copyright (c) 1990, 1991, 1993, 1994, 1995, 1996, 1997
3 *	The Regents of the University of California.  All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that: (1) source code distributions
7 * retain the above copyright notice and this paragraph in its entirety, (2)
8 * distributions including binary code include the above copyright notice and
9 * this paragraph in its entirety in the documentation or other materials
10 * provided with the distribution, and (3) all advertising materials mentioning
11 * features or use of this software display the following acknowledgement:
12 * ``This product includes software developed by the University of California,
13 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
14 * the University nor the names of its contributors may be used to endorse
15 * or promote products derived from this software without specific prior
16 * written permission.
17 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
18 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
20 *
21 * Format and print bootp packets.
22 *
23 * $FreeBSD: head/contrib/tcpdump/print-bootp.c 147904 2005-07-11 04:14:02Z sam $
24 */
25#ifndef lint
26static const char rcsid[] _U_ =
27    "@(#) $Header: /tcpdump/master/tcpdump/print-bootp.c,v 1.78.2.2 2005/05/06 04:19:39 guy Exp $ (LBL)";
28#endif
29
30#ifdef HAVE_CONFIG_H
31#include "config.h"
32#endif
33
34#include <tcpdump-stdinc.h>
35
36#include <stdio.h>
37#include <string.h>
38
39#include "interface.h"
40#include "addrtoname.h"
41#include "extract.h"
42#include "ether.h"
43#include "bootp.h"
44
45static void rfc1048_print(const u_char *);
46static void cmu_print(const u_char *);
47
48static char tstr[] = " [|bootp]";
49
50static const struct tok bootp_flag_values[] = {
51    { 0x8000,                   "Broadcast" },
52    { 0, NULL}
53};
54
55static const struct tok bootp_op_values[] = {
56    { BOOTPREQUEST,             "Request" },
57    { BOOTPREPLY,               "Reply" },
58    { 0, NULL}
59};
60
61/*
62 * Print bootp requests
63 */
64void
65bootp_print(register const u_char *cp, u_int length)
66{
67	register const struct bootp *bp;
68	static const u_char vm_cmu[4] = VM_CMU;
69	static const u_char vm_rfc1048[4] = VM_RFC1048;
70
71	bp = (const struct bootp *)cp;
72	TCHECK(bp->bp_op);
73
74        printf("BOOTP/DHCP, %s",
75	       tok2str(bootp_op_values, "unknown (0x%02x)", bp->bp_op));
76
77	if (bp->bp_htype == 1 && bp->bp_hlen == 6 && bp->bp_op == BOOTPREQUEST) {
78		TCHECK2(bp->bp_chaddr[0], 6);
79		printf(" from %s", etheraddr_string(bp->bp_chaddr));
80	}
81
82        printf(", length: %u", length);
83
84        if (!vflag)
85            return;
86
87	TCHECK(bp->bp_secs);
88
89	/* The usual hardware address type is 1 (10Mb Ethernet) */
90	if (bp->bp_htype != 1)
91		printf(", htype-#%d", bp->bp_htype);
92
93	/* The usual length for 10Mb Ethernet address is 6 bytes */
94	if (bp->bp_htype != 1 || bp->bp_hlen != 6)
95		printf(", hlen:%d", bp->bp_hlen);
96
97	/* Only print interesting fields */
98	if (bp->bp_hops)
99		printf(", hops:%d", bp->bp_hops);
100	if (bp->bp_xid)
101		printf(", xid:0x%x", EXTRACT_32BITS(&bp->bp_xid));
102	if (bp->bp_secs)
103		printf(", secs:%d", EXTRACT_16BITS(&bp->bp_secs));
104
105	printf(", flags: [%s]",
106	       bittok2str(bootp_flag_values, "none", EXTRACT_16BITS(&bp->bp_flags)));
107	if (vflag>1)
108	  printf( " (0x%04x)", EXTRACT_16BITS(&bp->bp_flags));
109
110	/* Client's ip address */
111	TCHECK(bp->bp_ciaddr);
112	if (bp->bp_ciaddr.s_addr)
113		printf("\n\t  Client IP: %s", ipaddr_string(&bp->bp_ciaddr));
114
115	/* 'your' ip address (bootp client) */
116	TCHECK(bp->bp_yiaddr);
117	if (bp->bp_yiaddr.s_addr)
118		printf("\n\t  Your IP: %s", ipaddr_string(&bp->bp_yiaddr));
119
120	/* Server's ip address */
121	TCHECK(bp->bp_siaddr);
122	if (bp->bp_siaddr.s_addr)
123		printf("\n\t  Server IP: %s", ipaddr_string(&bp->bp_siaddr));
124
125	/* Gateway's ip address */
126	TCHECK(bp->bp_giaddr);
127	if (bp->bp_giaddr.s_addr)
128		printf("\n\t  Gateway IP: %s", ipaddr_string(&bp->bp_giaddr));
129
130	/* Client's Ethernet address */
131	if (bp->bp_htype == 1 && bp->bp_hlen == 6) {
132		TCHECK2(bp->bp_chaddr[0], 6);
133		printf("\n\t  Client Ethernet Address: %s", etheraddr_string(bp->bp_chaddr));
134	}
135
136	TCHECK2(bp->bp_sname[0], 1);		/* check first char only */
137	if (*bp->bp_sname) {
138		printf("\n\t  sname \"");
139		if (fn_print(bp->bp_sname, snapend)) {
140			putchar('"');
141			fputs(tstr + 1, stdout);
142			return;
143		}
144		putchar('"');
145	}
146	TCHECK2(bp->bp_file[0], 1);		/* check first char only */
147	if (*bp->bp_file) {
148		printf("\n\t  file \"");
149		if (fn_print(bp->bp_file, snapend)) {
150			putchar('"');
151			fputs(tstr + 1, stdout);
152			return;
153		}
154		putchar('"');
155	}
156
157	/* Decode the vendor buffer */
158	TCHECK(bp->bp_vend[0]);
159	if (memcmp((const char *)bp->bp_vend, vm_rfc1048,
160		 sizeof(u_int32_t)) == 0)
161		rfc1048_print(bp->bp_vend);
162	else if (memcmp((const char *)bp->bp_vend, vm_cmu,
163		      sizeof(u_int32_t)) == 0)
164		cmu_print(bp->bp_vend);
165	else {
166		u_int32_t ul;
167
168		ul = EXTRACT_32BITS(&bp->bp_vend);
169		if (ul != 0)
170			printf("\n\t  Vendor-#0x%x", ul);
171	}
172
173	return;
174trunc:
175	fputs(tstr, stdout);
176}
177
178/*
179 * The first character specifies the format to print:
180 *     i - ip address (32 bits)
181 *     p - ip address pairs (32 bits + 32 bits)
182 *     l - long (32 bits)
183 *     L - unsigned long (32 bits)
184 *     s - short (16 bits)
185 *     b - period-seperated decimal bytes (variable length)
186 *     x - colon-seperated hex bytes (variable length)
187 *     a - ascii string (variable length)
188 *     B - on/off (8 bits)
189 *     $ - special (explicit code to handle)
190 */
191static struct tok tag2str[] = {
192/* RFC1048 tags */
193	{ TAG_PAD,		" PAD" },
194	{ TAG_SUBNET_MASK,	"iSM" },	/* subnet mask (RFC950) */
195	{ TAG_TIME_OFFSET,	"LTZ" },	/* seconds from UTC */
196	{ TAG_GATEWAY,		"iDG" },	/* default gateway */
197	{ TAG_TIME_SERVER,	"iTS" },	/* time servers (RFC868) */
198	{ TAG_NAME_SERVER,	"iIEN" },	/* IEN name servers (IEN116) */
199	{ TAG_DOMAIN_SERVER,	"iNS" },	/* domain name (RFC1035) */
200	{ TAG_LOG_SERVER,	"iLOG" },	/* MIT log servers */
201	{ TAG_COOKIE_SERVER,	"iCS" },	/* cookie servers (RFC865) */
202	{ TAG_LPR_SERVER,	"iLPR" },	/* lpr server (RFC1179) */
203	{ TAG_IMPRESS_SERVER,	"iIM" },	/* impress servers (Imagen) */
204	{ TAG_RLP_SERVER,	"iRL" },	/* resource location (RFC887) */
205	{ TAG_HOSTNAME,		"aHN" },	/* ascii hostname */
206	{ TAG_BOOTSIZE,		"sBS" },	/* 512 byte blocks */
207	{ TAG_END,		" END" },
208/* RFC1497 tags */
209	{ TAG_DUMPPATH,		"aDP" },
210	{ TAG_DOMAINNAME,	"aDN" },
211	{ TAG_SWAP_SERVER,	"iSS" },
212	{ TAG_ROOTPATH,		"aRP" },
213	{ TAG_EXTPATH,		"aEP" },
214/* RFC2132 tags */
215	{ TAG_IP_FORWARD,	"BIPF" },
216	{ TAG_NL_SRCRT,		"BSRT" },
217	{ TAG_PFILTERS,		"pPF" },
218	{ TAG_REASS_SIZE,	"sRSZ" },
219	{ TAG_DEF_TTL,		"bTTL" },
220	{ TAG_MTU_TIMEOUT,	"lMA" },
221	{ TAG_MTU_TABLE,	"sMT" },
222	{ TAG_INT_MTU,		"sMTU" },
223	{ TAG_LOCAL_SUBNETS,	"BLSN" },
224	{ TAG_BROAD_ADDR,	"iBR" },
225	{ TAG_DO_MASK_DISC,	"BMD" },
226	{ TAG_SUPPLY_MASK,	"BMS" },
227	{ TAG_DO_RDISC,		"BRD" },
228	{ TAG_RTR_SOL_ADDR,	"iRSA" },
229	{ TAG_STATIC_ROUTE,	"pSR" },
230	{ TAG_USE_TRAILERS,	"BUT" },
231	{ TAG_ARP_TIMEOUT,	"lAT" },
232	{ TAG_ETH_ENCAP,	"BIE" },
233	{ TAG_TCP_TTL,		"bTT" },
234	{ TAG_TCP_KEEPALIVE,	"lKI" },
235	{ TAG_KEEPALIVE_GO,	"BKG" },
236	{ TAG_NIS_DOMAIN,	"aYD" },
237	{ TAG_NIS_SERVERS,	"iYS" },
238	{ TAG_NTP_SERVERS,	"iNTP" },
239	{ TAG_VENDOR_OPTS,	"bVO" },
240	{ TAG_NETBIOS_NS,	"iWNS" },
241	{ TAG_NETBIOS_DDS,	"iWDD" },
242	{ TAG_NETBIOS_NODE,	"$WNT" },
243	{ TAG_NETBIOS_SCOPE,	"aWSC" },
244	{ TAG_XWIN_FS,		"iXFS" },
245	{ TAG_XWIN_DM,		"iXDM" },
246	{ TAG_NIS_P_DOMAIN,	"sN+D" },
247	{ TAG_NIS_P_SERVERS,	"iN+S" },
248	{ TAG_MOBILE_HOME,	"iMH" },
249	{ TAG_SMPT_SERVER,	"iSMTP" },
250	{ TAG_POP3_SERVER,	"iPOP3" },
251	{ TAG_NNTP_SERVER,	"iNNTP" },
252	{ TAG_WWW_SERVER,	"iWWW" },
253	{ TAG_FINGER_SERVER,	"iFG" },
254	{ TAG_IRC_SERVER,	"iIRC" },
255	{ TAG_STREETTALK_SRVR,	"iSTS" },
256	{ TAG_STREETTALK_STDA,	"iSTDA" },
257	{ TAG_REQUESTED_IP,	"iRQ" },
258	{ TAG_IP_LEASE,		"lLT" },
259	{ TAG_OPT_OVERLOAD,	"$OO" },
260	{ TAG_TFTP_SERVER,	"aTFTP" },
261	{ TAG_BOOTFILENAME,	"aBF" },
262	{ TAG_DHCP_MESSAGE,	" DHCP" },
263	{ TAG_SERVER_ID,	"iSID" },
264	{ TAG_PARM_REQUEST,	"bPR" },
265	{ TAG_MESSAGE,		"aMSG" },
266	{ TAG_MAX_MSG_SIZE,	"sMSZ" },
267	{ TAG_RENEWAL_TIME,	"lRN" },
268	{ TAG_REBIND_TIME,	"lRB" },
269	{ TAG_VENDOR_CLASS,	"aVC" },
270	{ TAG_CLIENT_ID,	"$CID" },
271/* RFC 2485 */
272	{ TAG_OPEN_GROUP_UAP,	"aUAP" },
273/* RFC 2563 */
274	{ TAG_DISABLE_AUTOCONF,	"BNOAUTO" },
275/* RFC 2610 */
276	{ TAG_SLP_DA,		"bSLP-DA" },	/*"b" is a little wrong */
277	{ TAG_SLP_SCOPE,	"bSLP-SCOPE" },	/*"b" is a little wrong */
278/* RFC 2937 */
279	{ TAG_NS_SEARCH,	"sNSSEARCH" },	/* XXX 's' */
280/* RFC 3011 */
281	{ TAG_IP4_SUBNET_SELECT, "iSUBNET" },
282/* http://www.iana.org/assignments/bootp-dhcp-extensions/index.htm */
283	{ TAG_USER_CLASS,	"aCLASS" },
284	{ TAG_SLP_NAMING_AUTH,	"aSLP-NA" },
285	{ TAG_CLIENT_FQDN,	"$FQDN" },
286	{ TAG_AGENT_CIRCUIT,	"bACKT" },
287	{ TAG_AGENT_REMOTE,	"bARMT" },
288	{ TAG_AGENT_MASK,	"bAMSK" },
289	{ TAG_TZ_STRING,	"aTZSTR" },
290	{ TAG_FQDN_OPTION,	"bFQDNS" },	/* XXX 'b' */
291	{ TAG_AUTH,		"bAUTH" },	/* XXX 'b' */
292	{ TAG_VINES_SERVERS,	"iVINES" },
293	{ TAG_SERVER_RANK,	"sRANK" },
294	{ TAG_CLIENT_ARCH,	"sARCH" },
295	{ TAG_CLIENT_NDI,	"bNDI" },	/* XXX 'b' */
296	{ TAG_CLIENT_GUID,	"bGUID" },	/* XXX 'b' */
297	{ TAG_LDAP_URL,		"aLDAP" },
298	{ TAG_6OVER4,		"i6o4" },
299	{ TAG_PRINTER_NAME,	"aPRTR" },
300	{ TAG_MDHCP_SERVER,	"bMDHCP" },	/* XXX 'b' */
301	{ TAG_IPX_COMPAT,	"bIPX" },	/* XXX 'b' */
302	{ TAG_NETINFO_PARENT,	"iNI" },
303	{ TAG_NETINFO_PARENT_TAG, "aNITAG" },
304	{ TAG_URL,		"aURL" },
305	{ TAG_FAILOVER,		"bFAIL" },	/* XXX 'b' */
306	{ 0,			NULL }
307};
308/* 2-byte extended tags */
309static struct tok xtag2str[] = {
310	{ 0,			NULL }
311};
312
313/* DHCP "options overload" types */
314static struct tok oo2str[] = {
315	{ 1,			"file" },
316	{ 2,			"sname" },
317	{ 3,			"file+sname" },
318	{ 0,			NULL }
319};
320
321/* NETBIOS over TCP/IP node type options */
322static struct tok nbo2str[] = {
323	{ 0x1,			"b-node" },
324	{ 0x2,			"p-node" },
325	{ 0x4,			"m-node" },
326	{ 0x8,			"h-node" },
327	{ 0,			NULL }
328};
329
330/* ARP Hardware types, for Client-ID option */
331static struct tok arp2str[] = {
332	{ 0x1,			"ether" },
333	{ 0x6,			"ieee802" },
334	{ 0x7,			"arcnet" },
335	{ 0xf,			"frelay" },
336	{ 0x17,			"strip" },
337	{ 0x18,			"ieee1394" },
338	{ 0,			NULL }
339};
340
341static void
342rfc1048_print(register const u_char *bp)
343{
344	register u_int16_t tag;
345	register u_int len, size;
346	register const char *cp;
347	register char c;
348	int first;
349	u_int32_t ul;
350	u_int16_t us;
351	u_int8_t uc;
352
353	printf("\n\t  Vendor-rfc1048:");
354
355	/* Step over magic cookie */
356	bp += sizeof(int32_t);
357
358	/* Loop while we there is a tag left in the buffer */
359	while (bp + 1 < snapend) {
360		tag = *bp++;
361		if (tag == TAG_PAD)
362			continue;
363		if (tag == TAG_END)
364			return;
365		if (tag == TAG_EXTENDED_OPTION) {
366			TCHECK2(*(bp + 1), 2);
367			tag = EXTRACT_16BITS(bp + 1);
368			/* XXX we don't know yet if the IANA will
369			 * preclude overlap of 1-byte and 2-byte spaces.
370			 * If not, we need to offset tag after this step.
371			 */
372			cp = tok2str(xtag2str, "?xT%u", tag);
373		} else
374			cp = tok2str(tag2str, "?T%u", tag);
375		c = *cp++;
376		printf("\n\t    %s:", cp);
377
378		/* Get the length; check for truncation */
379		if (bp + 1 >= snapend) {
380			fputs(tstr, stdout);
381			return;
382		}
383		len = *bp++;
384		if (bp + len >= snapend) {
385			printf("[|bootp %u]", len);
386			return;
387		}
388
389		if (tag == TAG_DHCP_MESSAGE && len == 1) {
390			uc = *bp++;
391			switch (uc) {
392			case DHCPDISCOVER:	printf("DISCOVER");	break;
393			case DHCPOFFER:		printf("OFFER");	break;
394			case DHCPREQUEST:	printf("REQUEST");	break;
395			case DHCPDECLINE:	printf("DECLINE");	break;
396			case DHCPACK:		printf("ACK");		break;
397			case DHCPNAK:		printf("NACK");		break;
398			case DHCPRELEASE:	printf("RELEASE");	break;
399			case DHCPINFORM:	printf("INFORM");	break;
400			default:		printf("%u", uc);	break;
401			}
402			continue;
403		}
404
405		if (tag == TAG_PARM_REQUEST) {
406			first = 1;
407			while (len-- > 0) {
408				uc = *bp++;
409				cp = tok2str(tag2str, "?T%u", uc);
410				if (!first)
411					putchar('+');
412				printf("%s", cp + 1);
413				first = 0;
414			}
415			continue;
416		}
417		if (tag == TAG_EXTENDED_REQUEST) {
418			first = 1;
419			while (len > 1) {
420				len -= 2;
421				us = EXTRACT_16BITS(bp);
422				bp += 2;
423				cp = tok2str(xtag2str, "?xT%u", us);
424				if (!first)
425					putchar('+');
426				printf("%s", cp + 1);
427				first = 0;
428			}
429			continue;
430		}
431
432		/* Print data */
433		size = len;
434		if (c == '?') {
435			/* Base default formats for unknown tags on data size */
436			if (size & 1)
437				c = 'b';
438			else if (size & 2)
439				c = 's';
440			else
441				c = 'l';
442		}
443		first = 1;
444		switch (c) {
445
446		case 'a':
447			/* ascii strings */
448			putchar('"');
449			if (fn_printn(bp, size, snapend)) {
450				putchar('"');
451				goto trunc;
452			}
453			putchar('"');
454			bp += size;
455			size = 0;
456			break;
457
458		case 'i':
459		case 'l':
460		case 'L':
461			/* ip addresses/32-bit words */
462			while (size >= sizeof(ul)) {
463				if (!first)
464					putchar(',');
465				ul = EXTRACT_32BITS(bp);
466				if (c == 'i') {
467					ul = htonl(ul);
468					printf("%s", ipaddr_string(&ul));
469				} else if (c == 'L')
470					printf("%d", ul);
471				else
472					printf("%u", ul);
473				bp += sizeof(ul);
474				size -= sizeof(ul);
475				first = 0;
476			}
477			break;
478
479		case 'p':
480			/* IP address pairs */
481			while (size >= 2*sizeof(ul)) {
482				if (!first)
483					putchar(',');
484				memcpy((char *)&ul, (const char *)bp, sizeof(ul));
485				printf("(%s:", ipaddr_string(&ul));
486				bp += sizeof(ul);
487				memcpy((char *)&ul, (const char *)bp, sizeof(ul));
488				printf("%s)", ipaddr_string(&ul));
489				bp += sizeof(ul);
490				size -= 2*sizeof(ul);
491				first = 0;
492			}
493			break;
494
495		case 's':
496			/* shorts */
497			while (size >= sizeof(us)) {
498				if (!first)
499					putchar(',');
500				us = EXTRACT_16BITS(bp);
501				printf("%u", us);
502				bp += sizeof(us);
503				size -= sizeof(us);
504				first = 0;
505			}
506			break;
507
508		case 'B':
509			/* boolean */
510			while (size > 0) {
511				if (!first)
512					putchar(',');
513				switch (*bp) {
514				case 0:
515					putchar('N');
516					break;
517				case 1:
518					putchar('Y');
519					break;
520				default:
521					printf("%u?", *bp);
522					break;
523				}
524				++bp;
525				--size;
526				first = 0;
527			}
528			break;
529
530		case 'b':
531		case 'x':
532		default:
533			/* Bytes */
534			while (size > 0) {
535				if (!first)
536					putchar(c == 'x' ? ':' : '.');
537				if (c == 'x')
538					printf("%02x", *bp);
539				else
540					printf("%u", *bp);
541				++bp;
542				--size;
543				first = 0;
544			}
545			break;
546
547		case '$':
548			/* Guys we can't handle with one of the usual cases */
549			switch (tag) {
550
551			case TAG_NETBIOS_NODE:
552				tag = *bp++;
553				--size;
554				fputs(tok2str(nbo2str, NULL, tag), stdout);
555				break;
556
557			case TAG_OPT_OVERLOAD:
558				tag = *bp++;
559				--size;
560				fputs(tok2str(oo2str, NULL, tag), stdout);
561				break;
562
563			case TAG_CLIENT_FQDN:
564				/* option 81 should be at least 4 bytes long */
565				if (len < 4)  {
566                                        printf("ERROR: options 81 len %u < 4 bytes", len);
567					break;
568				}
569				if (*bp++)
570					printf("[svrreg]");
571				if (*bp)
572					printf("%u/%u/", *bp, *(bp+1));
573				bp += 2;
574				putchar('"');
575				if (fn_printn(bp, size - 3, snapend)) {
576					putchar('"');
577					goto trunc;
578				}
579				putchar('"');
580				bp += size - 3;
581				size = 0;
582				break;
583
584			case TAG_CLIENT_ID:
585			    {	int type = *bp++;
586				size--;
587				if (type == 0) {
588					putchar('"');
589					if (fn_printn(bp, size, snapend)) {
590						putchar('"');
591						goto trunc;
592					}
593					putchar('"');
594					bp += size;
595					size = 0;
596					break;
597				} else {
598					printf("[%s]", tok2str(arp2str, "type-%d", type));
599				}
600				while (size > 0) {
601					if (!first)
602						putchar(':');
603					printf("%02x", *bp);
604					++bp;
605					--size;
606					first = 0;
607				}
608				break;
609			    }
610
611			default:
612				printf("[unknown special tag %u, size %u]",
613				    tag, size);
614				bp += size;
615				size = 0;
616				break;
617			}
618			break;
619		}
620		/* Data left over? */
621		if (size) {
622			printf("[len %u]", len);
623			bp += size;
624		}
625	}
626	return;
627trunc:
628	printf("|[rfc1048]");
629}
630
631static void
632cmu_print(register const u_char *bp)
633{
634	register const struct cmu_vend *cmu;
635
636#define PRINTCMUADDR(m, s) { TCHECK(cmu->m); \
637    if (cmu->m.s_addr != 0) \
638	printf(" %s:%s", s, ipaddr_string(&cmu->m.s_addr)); }
639
640	printf(" vend-cmu");
641	cmu = (const struct cmu_vend *)bp;
642
643	/* Only print if there are unknown bits */
644	TCHECK(cmu->v_flags);
645	if ((cmu->v_flags & ~(VF_SMASK)) != 0)
646		printf(" F:0x%x", cmu->v_flags);
647	PRINTCMUADDR(v_dgate, "DG");
648	PRINTCMUADDR(v_smask, cmu->v_flags & VF_SMASK ? "SM" : "SM*");
649	PRINTCMUADDR(v_dns1, "NS1");
650	PRINTCMUADDR(v_dns2, "NS2");
651	PRINTCMUADDR(v_ins1, "IEN1");
652	PRINTCMUADDR(v_ins2, "IEN2");
653	PRINTCMUADDR(v_ts1, "TS1");
654	PRINTCMUADDR(v_ts2, "TS2");
655	return;
656
657trunc:
658	fputs(tstr, stdout);
659#undef PRINTCMUADDR
660}
661