xref: /freebsd/contrib/tcpdump/print-isoclns.c (revision 195ebc7e9e4b129de810833791a19dfb4349d6a9)
1 /*
2  * Copyright (c) 1992, 1993, 1994, 1995, 1996
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  * Original code by Matt Thomas, Digital Equipment Corporation
22  *
23  * Extensively modified by Hannes Gredler (hannes@juniper.net) for more
24  * complete IS-IS & CLNP support.
25  *
26  * $FreeBSD$
27  */
28 
29 #ifndef lint
30 static const char rcsid[] _U_ =
31     "@(#) $Header: /tcpdump/master/tcpdump/print-isoclns.c,v 1.163 2007-03-02 09:16:19 hannes Exp $ (LBL)";
32 #endif
33 
34 #ifdef HAVE_CONFIG_H
35 #include "config.h"
36 #endif
37 
38 #include <tcpdump-stdinc.h>
39 
40 #include <stdio.h>
41 #include <string.h>
42 
43 #include "interface.h"
44 #include "addrtoname.h"
45 #include "ethertype.h"
46 #include "ether.h"
47 #include "nlpid.h"
48 #include "extract.h"
49 #include "gmpls.h"
50 #include "oui.h"
51 
52 /*
53  * IS-IS is defined in ISO 10589.  Look there for protocol definitions.
54  */
55 
56 #define SYSTEM_ID_LEN	ETHER_ADDR_LEN
57 #define NODE_ID_LEN     SYSTEM_ID_LEN+1
58 #define LSP_ID_LEN      SYSTEM_ID_LEN+2
59 
60 #define ISIS_VERSION	1
61 #define ESIS_VERSION	1
62 #define CLNP_VERSION	1
63 
64 #define ISIS_PDU_TYPE_MASK      0x1F
65 #define ESIS_PDU_TYPE_MASK      0x1F
66 #define CLNP_PDU_TYPE_MASK      0x1F
67 #define CLNP_FLAG_MASK          0xE0
68 #define ISIS_LAN_PRIORITY_MASK  0x7F
69 
70 #define ISIS_PDU_L1_LAN_IIH	15
71 #define ISIS_PDU_L2_LAN_IIH	16
72 #define ISIS_PDU_PTP_IIH	17
73 #define ISIS_PDU_L1_LSP       	18
74 #define ISIS_PDU_L2_LSP       	20
75 #define ISIS_PDU_L1_CSNP  	24
76 #define ISIS_PDU_L2_CSNP  	25
77 #define ISIS_PDU_L1_PSNP        26
78 #define ISIS_PDU_L2_PSNP        27
79 
80 static struct tok isis_pdu_values[] = {
81     { ISIS_PDU_L1_LAN_IIH,       "L1 Lan IIH"},
82     { ISIS_PDU_L2_LAN_IIH,       "L2 Lan IIH"},
83     { ISIS_PDU_PTP_IIH,          "p2p IIH"},
84     { ISIS_PDU_L1_LSP,           "L1 LSP"},
85     { ISIS_PDU_L2_LSP,           "L2 LSP"},
86     { ISIS_PDU_L1_CSNP,          "L1 CSNP"},
87     { ISIS_PDU_L2_CSNP,          "L2 CSNP"},
88     { ISIS_PDU_L1_PSNP,          "L1 PSNP"},
89     { ISIS_PDU_L2_PSNP,          "L2 PSNP"},
90     { 0, NULL}
91 };
92 
93 /*
94  * A TLV is a tuple of a type, length and a value and is normally used for
95  * encoding information in all sorts of places.  This is an enumeration of
96  * the well known types.
97  *
98  * list taken from rfc3359 plus some memory from veterans ;-)
99  */
100 
101 #define ISIS_TLV_AREA_ADDR           1   /* iso10589 */
102 #define ISIS_TLV_IS_REACH            2   /* iso10589 */
103 #define ISIS_TLV_ESNEIGH             3   /* iso10589 */
104 #define ISIS_TLV_PART_DIS            4   /* iso10589 */
105 #define ISIS_TLV_PREFIX_NEIGH        5   /* iso10589 */
106 #define ISIS_TLV_ISNEIGH             6   /* iso10589 */
107 #define ISIS_TLV_ISNEIGH_VARLEN      7   /* iso10589 */
108 #define ISIS_TLV_PADDING             8   /* iso10589 */
109 #define ISIS_TLV_LSP                 9   /* iso10589 */
110 #define ISIS_TLV_AUTH                10  /* iso10589, rfc3567 */
111 #define ISIS_TLV_CHECKSUM            12  /* rfc3358 */
112 #define ISIS_TLV_CHECKSUM_MINLEN 2
113 #define ISIS_TLV_LSP_BUFFERSIZE      14  /* iso10589 rev2 */
114 #define ISIS_TLV_LSP_BUFFERSIZE_MINLEN 2
115 #define ISIS_TLV_EXT_IS_REACH        22  /* draft-ietf-isis-traffic-05 */
116 #define ISIS_TLV_IS_ALIAS_ID         24  /* draft-ietf-isis-ext-lsp-frags-02 */
117 #define ISIS_TLV_DECNET_PHASE4       42
118 #define ISIS_TLV_LUCENT_PRIVATE      66
119 #define ISIS_TLV_INT_IP_REACH        128 /* rfc1195, rfc2966 */
120 #define ISIS_TLV_PROTOCOLS           129 /* rfc1195 */
121 #define ISIS_TLV_EXT_IP_REACH        130 /* rfc1195, rfc2966 */
122 #define ISIS_TLV_IDRP_INFO           131 /* rfc1195 */
123 #define ISIS_TLV_IDRP_INFO_MINLEN      1
124 #define ISIS_TLV_IPADDR              132 /* rfc1195 */
125 #define ISIS_TLV_IPAUTH              133 /* rfc1195 */
126 #define ISIS_TLV_TE_ROUTER_ID        134 /* draft-ietf-isis-traffic-05 */
127 #define ISIS_TLV_EXTD_IP_REACH       135 /* draft-ietf-isis-traffic-05 */
128 #define ISIS_TLV_HOSTNAME            137 /* rfc2763 */
129 #define ISIS_TLV_SHARED_RISK_GROUP   138 /* draft-ietf-isis-gmpls-extensions */
130 #define ISIS_TLV_NORTEL_PRIVATE1     176
131 #define ISIS_TLV_NORTEL_PRIVATE2     177
132 #define ISIS_TLV_RESTART_SIGNALING   211 /* rfc3847 */
133 #define ISIS_TLV_RESTART_SIGNALING_FLAGLEN 1
134 #define ISIS_TLV_RESTART_SIGNALING_HOLDTIMELEN 2
135 #define ISIS_TLV_MT_IS_REACH         222 /* draft-ietf-isis-wg-multi-topology-05 */
136 #define ISIS_TLV_MT_SUPPORTED        229 /* draft-ietf-isis-wg-multi-topology-05 */
137 #define ISIS_TLV_MT_SUPPORTED_MINLEN 2
138 #define ISIS_TLV_IP6ADDR             232 /* draft-ietf-isis-ipv6-02 */
139 #define ISIS_TLV_MT_IP_REACH         235 /* draft-ietf-isis-wg-multi-topology-05 */
140 #define ISIS_TLV_IP6_REACH           236 /* draft-ietf-isis-ipv6-02 */
141 #define ISIS_TLV_MT_IP6_REACH        237 /* draft-ietf-isis-wg-multi-topology-05 */
142 #define ISIS_TLV_PTP_ADJ             240 /* rfc3373 */
143 #define ISIS_TLV_IIH_SEQNR           241 /* draft-shen-isis-iih-sequence-00 */
144 #define ISIS_TLV_IIH_SEQNR_MINLEN 4
145 #define ISIS_TLV_VENDOR_PRIVATE      250 /* draft-ietf-isis-experimental-tlv-01 */
146 #define ISIS_TLV_VENDOR_PRIVATE_MINLEN 3
147 
148 static struct tok isis_tlv_values[] = {
149     { ISIS_TLV_AREA_ADDR,	   "Area address(es)"},
150     { ISIS_TLV_IS_REACH,           "IS Reachability"},
151     { ISIS_TLV_ESNEIGH,            "ES Neighbor(s)"},
152     { ISIS_TLV_PART_DIS,           "Partition DIS"},
153     { ISIS_TLV_PREFIX_NEIGH,       "Prefix Neighbors"},
154     { ISIS_TLV_ISNEIGH,            "IS Neighbor(s)"},
155     { ISIS_TLV_ISNEIGH_VARLEN,     "IS Neighbor(s) (variable length)"},
156     { ISIS_TLV_PADDING,            "Padding"},
157     { ISIS_TLV_LSP,                "LSP entries"},
158     { ISIS_TLV_AUTH,               "Authentication"},
159     { ISIS_TLV_CHECKSUM,           "Checksum"},
160     { ISIS_TLV_LSP_BUFFERSIZE,     "LSP Buffersize"},
161     { ISIS_TLV_EXT_IS_REACH,       "Extended IS Reachability"},
162     { ISIS_TLV_IS_ALIAS_ID,        "IS Alias ID"},
163     { ISIS_TLV_DECNET_PHASE4,      "DECnet Phase IV"},
164     { ISIS_TLV_LUCENT_PRIVATE,     "Lucent Proprietary"},
165     { ISIS_TLV_INT_IP_REACH,       "IPv4 Internal Reachability"},
166     { ISIS_TLV_PROTOCOLS,          "Protocols supported"},
167     { ISIS_TLV_EXT_IP_REACH,       "IPv4 External Reachability"},
168     { ISIS_TLV_IDRP_INFO,          "Inter-Domain Information Type"},
169     { ISIS_TLV_IPADDR,             "IPv4 Interface address(es)"},
170     { ISIS_TLV_IPAUTH,             "IPv4 authentication (deprecated)"},
171     { ISIS_TLV_TE_ROUTER_ID,       "Traffic Engineering Router ID"},
172     { ISIS_TLV_EXTD_IP_REACH,      "Extended IPv4 Reachability"},
173     { ISIS_TLV_SHARED_RISK_GROUP,  "Shared Risk Link Group"},
174     { ISIS_TLV_NORTEL_PRIVATE1,    "Nortel Proprietary"},
175     { ISIS_TLV_NORTEL_PRIVATE2,    "Nortel Proprietary"},
176     { ISIS_TLV_HOSTNAME,           "Hostname"},
177     { ISIS_TLV_RESTART_SIGNALING,  "Restart Signaling"},
178     { ISIS_TLV_MT_IS_REACH,        "Multi Topology IS Reachability"},
179     { ISIS_TLV_MT_SUPPORTED,       "Multi Topology"},
180     { ISIS_TLV_IP6ADDR,            "IPv6 Interface address(es)"},
181     { ISIS_TLV_MT_IP_REACH,        "Multi-Topology IPv4 Reachability"},
182     { ISIS_TLV_IP6_REACH,          "IPv6 reachability"},
183     { ISIS_TLV_MT_IP6_REACH,       "Multi-Topology IP6 Reachability"},
184     { ISIS_TLV_PTP_ADJ,            "Point-to-point Adjacency State"},
185     { ISIS_TLV_IIH_SEQNR,          "Hello PDU Sequence Number"},
186     { ISIS_TLV_VENDOR_PRIVATE,     "Vendor Private"},
187     { 0, NULL }
188 };
189 
190 #define ESIS_OPTION_PROTOCOLS        129
191 #define ESIS_OPTION_QOS_MAINTENANCE  195 /* iso9542 */
192 #define ESIS_OPTION_SECURITY         197 /* iso9542 */
193 #define ESIS_OPTION_ES_CONF_TIME     198 /* iso9542 */
194 #define ESIS_OPTION_PRIORITY         205 /* iso9542 */
195 #define ESIS_OPTION_ADDRESS_MASK     225 /* iso9542 */
196 #define ESIS_OPTION_SNPA_MASK        226 /* iso9542 */
197 
198 static struct tok esis_option_values[] = {
199     { ESIS_OPTION_PROTOCOLS,       "Protocols supported"},
200     { ESIS_OPTION_QOS_MAINTENANCE, "QoS Maintenance" },
201     { ESIS_OPTION_SECURITY,        "Security" },
202     { ESIS_OPTION_ES_CONF_TIME,    "ES Configuration Time" },
203     { ESIS_OPTION_PRIORITY,        "Priority" },
204     { ESIS_OPTION_ADDRESS_MASK,    "Addressk Mask" },
205     { ESIS_OPTION_SNPA_MASK,       "SNPA Mask" },
206     { 0, NULL }
207 };
208 
209 #define CLNP_OPTION_DISCARD_REASON   193
210 #define CLNP_OPTION_QOS_MAINTENANCE  195 /* iso8473 */
211 #define CLNP_OPTION_SECURITY         197 /* iso8473 */
212 #define CLNP_OPTION_SOURCE_ROUTING   200 /* iso8473 */
213 #define CLNP_OPTION_ROUTE_RECORDING  203 /* iso8473 */
214 #define CLNP_OPTION_PADDING          204 /* iso8473 */
215 #define CLNP_OPTION_PRIORITY         205 /* iso8473 */
216 
217 static struct tok clnp_option_values[] = {
218     { CLNP_OPTION_DISCARD_REASON,  "Discard Reason"},
219     { CLNP_OPTION_PRIORITY,        "Priority"},
220     { CLNP_OPTION_QOS_MAINTENANCE, "QoS Maintenance"},
221     { CLNP_OPTION_SECURITY, "Security"},
222     { CLNP_OPTION_SOURCE_ROUTING, "Source Routing"},
223     { CLNP_OPTION_ROUTE_RECORDING, "Route Recording"},
224     { CLNP_OPTION_PADDING, "Padding"},
225     { 0, NULL }
226 };
227 
228 static struct tok clnp_option_rfd_class_values[] = {
229     { 0x0, "General"},
230     { 0x8, "Address"},
231     { 0x9, "Source Routeing"},
232     { 0xa, "Lifetime"},
233     { 0xb, "PDU Discarded"},
234     { 0xc, "Reassembly"},
235     { 0, NULL }
236 };
237 
238 static struct tok clnp_option_rfd_general_values[] = {
239     { 0x0, "Reason not specified"},
240     { 0x1, "Protocol procedure error"},
241     { 0x2, "Incorrect checksum"},
242     { 0x3, "PDU discarded due to congestion"},
243     { 0x4, "Header syntax error (cannot be parsed)"},
244     { 0x5, "Segmentation needed but not permitted"},
245     { 0x6, "Incomplete PDU received"},
246     { 0x7, "Duplicate option"},
247     { 0, NULL }
248 };
249 
250 static struct tok clnp_option_rfd_address_values[] = {
251     { 0x0, "Destination address unreachable"},
252     { 0x1, "Destination address unknown"},
253     { 0, NULL }
254 };
255 
256 static struct tok clnp_option_rfd_source_routeing_values[] = {
257     { 0x0, "Unspecified source routeing error"},
258     { 0x1, "Syntax error in source routeing field"},
259     { 0x2, "Unknown address in source routeing field"},
260     { 0x3, "Path not acceptable"},
261     { 0, NULL }
262 };
263 
264 static struct tok clnp_option_rfd_lifetime_values[] = {
265     { 0x0, "Lifetime expired while data unit in transit"},
266     { 0x1, "Lifetime expired during reassembly"},
267     { 0, NULL }
268 };
269 
270 static struct tok clnp_option_rfd_pdu_discard_values[] = {
271     { 0x0, "Unsupported option not specified"},
272     { 0x1, "Unsupported protocol version"},
273     { 0x2, "Unsupported security option"},
274     { 0x3, "Unsupported source routeing option"},
275     { 0x4, "Unsupported recording of route option"},
276     { 0, NULL }
277 };
278 
279 static struct tok clnp_option_rfd_reassembly_values[] = {
280     { 0x0, "Reassembly interference"},
281     { 0, NULL }
282 };
283 
284 /* array of 16 error-classes */
285 static struct tok *clnp_option_rfd_error_class[] = {
286     clnp_option_rfd_general_values,
287     NULL,
288     NULL,
289     NULL,
290     NULL,
291     NULL,
292     NULL,
293     NULL,
294     clnp_option_rfd_address_values,
295     clnp_option_rfd_source_routeing_values,
296     clnp_option_rfd_lifetime_values,
297     clnp_option_rfd_pdu_discard_values,
298     clnp_option_rfd_reassembly_values,
299     NULL,
300     NULL,
301     NULL
302 };
303 
304 #define CLNP_OPTION_OPTION_QOS_MASK 0x3f
305 #define CLNP_OPTION_SCOPE_MASK      0xc0
306 #define CLNP_OPTION_SCOPE_SA_SPEC   0x40
307 #define CLNP_OPTION_SCOPE_DA_SPEC   0x80
308 #define CLNP_OPTION_SCOPE_GLOBAL    0xc0
309 
310 static struct tok clnp_option_scope_values[] = {
311     { CLNP_OPTION_SCOPE_SA_SPEC, "Source Address Specific"},
312     { CLNP_OPTION_SCOPE_DA_SPEC, "Destination Address Specific"},
313     { CLNP_OPTION_SCOPE_GLOBAL, "Globally unique"},
314     { 0, NULL }
315 };
316 
317 static struct tok clnp_option_sr_rr_values[] = {
318     { 0x0, "partial"},
319     { 0x1, "complete"},
320     { 0, NULL }
321 };
322 
323 static struct tok clnp_option_sr_rr_string_values[] = {
324     { CLNP_OPTION_SOURCE_ROUTING, "source routing"},
325     { CLNP_OPTION_ROUTE_RECORDING, "recording of route in progress"},
326     { 0, NULL }
327 };
328 
329 static struct tok clnp_option_qos_global_values[] = {
330     { 0x20, "reserved"},
331     { 0x10, "sequencing vs. delay"},
332     { 0x08, "congested"},
333     { 0x04, "delay vs. cost"},
334     { 0x02, "error vs. delay"},
335     { 0x01, "error vs. cost"},
336     { 0, NULL }
337 };
338 
339 #define ISIS_SUBTLV_EXT_IS_REACH_ADMIN_GROUP           3 /* draft-ietf-isis-traffic-05 */
340 #define ISIS_SUBTLV_EXT_IS_REACH_LINK_LOCAL_REMOTE_ID  4 /* rfc4205 */
341 #define ISIS_SUBTLV_EXT_IS_REACH_LINK_REMOTE_ID        5 /* draft-ietf-isis-traffic-05 */
342 #define ISIS_SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR        6 /* draft-ietf-isis-traffic-05 */
343 #define ISIS_SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR    8 /* draft-ietf-isis-traffic-05 */
344 #define ISIS_SUBTLV_EXT_IS_REACH_MAX_LINK_BW           9 /* draft-ietf-isis-traffic-05 */
345 #define ISIS_SUBTLV_EXT_IS_REACH_RESERVABLE_BW        10 /* draft-ietf-isis-traffic-05 */
346 #define ISIS_SUBTLV_EXT_IS_REACH_UNRESERVED_BW        11 /* rfc4124 */
347 #define ISIS_SUBTLV_EXT_IS_REACH_BW_CONSTRAINTS_OLD   12 /* draft-ietf-tewg-diff-te-proto-06 */
348 #define ISIS_SUBTLV_EXT_IS_REACH_TE_METRIC            18 /* draft-ietf-isis-traffic-05 */
349 #define ISIS_SUBTLV_EXT_IS_REACH_LINK_ATTRIBUTE       19 /* draft-ietf-isis-link-attr-01 */
350 #define ISIS_SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE 20 /* rfc4205 */
351 #define ISIS_SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR    21 /* rfc4205 */
352 #define ISIS_SUBTLV_EXT_IS_REACH_BW_CONSTRAINTS       22 /* rfc4124 */
353 
354 static struct tok isis_ext_is_reach_subtlv_values[] = {
355     { ISIS_SUBTLV_EXT_IS_REACH_ADMIN_GROUP,            "Administrative groups" },
356     { ISIS_SUBTLV_EXT_IS_REACH_LINK_LOCAL_REMOTE_ID,   "Link Local/Remote Identifier" },
357     { ISIS_SUBTLV_EXT_IS_REACH_LINK_REMOTE_ID,         "Link Remote Identifier" },
358     { ISIS_SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR,         "IPv4 interface address" },
359     { ISIS_SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR,     "IPv4 neighbor address" },
360     { ISIS_SUBTLV_EXT_IS_REACH_MAX_LINK_BW,            "Maximum link bandwidth" },
361     { ISIS_SUBTLV_EXT_IS_REACH_RESERVABLE_BW,          "Reservable link bandwidth" },
362     { ISIS_SUBTLV_EXT_IS_REACH_UNRESERVED_BW,          "Unreserved bandwidth" },
363     { ISIS_SUBTLV_EXT_IS_REACH_TE_METRIC,              "Traffic Engineering Metric" },
364     { ISIS_SUBTLV_EXT_IS_REACH_LINK_ATTRIBUTE,         "Link Attribute" },
365     { ISIS_SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE,   "Link Protection Type" },
366     { ISIS_SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR,      "Interface Switching Capability" },
367     { ISIS_SUBTLV_EXT_IS_REACH_BW_CONSTRAINTS_OLD,     "Bandwidth Constraints (old)" },
368     { ISIS_SUBTLV_EXT_IS_REACH_BW_CONSTRAINTS,         "Bandwidth Constraints" },
369     { 250,                                             "Reserved for cisco specific extensions" },
370     { 251,                                             "Reserved for cisco specific extensions" },
371     { 252,                                             "Reserved for cisco specific extensions" },
372     { 253,                                             "Reserved for cisco specific extensions" },
373     { 254,                                             "Reserved for cisco specific extensions" },
374     { 255,                                             "Reserved for future expansion" },
375     { 0, NULL }
376 };
377 
378 #define ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG32          1 /* draft-ietf-isis-admin-tags-01 */
379 #define ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG64          2 /* draft-ietf-isis-admin-tags-01 */
380 #define ISIS_SUBTLV_EXTD_IP_REACH_MGMT_PREFIX_COLOR  117 /* draft-ietf-isis-wg-multi-topology-05 */
381 
382 static struct tok isis_ext_ip_reach_subtlv_values[] = {
383     { ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG32,           "32-Bit Administrative tag" },
384     { ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG64,           "64-Bit Administrative tag" },
385     { ISIS_SUBTLV_EXTD_IP_REACH_MGMT_PREFIX_COLOR,     "Management Prefix Color" },
386     { 0, NULL }
387 };
388 
389 static struct tok isis_subtlv_link_attribute_values[] = {
390     { 0x01, "Local Protection Available" },
391     { 0x02, "Link excluded from local protection path" },
392     { 0x04, "Local maintenance required"},
393     { 0, NULL }
394 };
395 
396 #define ISIS_SUBTLV_AUTH_SIMPLE        1
397 #define ISIS_SUBTLV_AUTH_MD5          54
398 #define ISIS_SUBTLV_AUTH_MD5_LEN      16
399 #define ISIS_SUBTLV_AUTH_PRIVATE     255
400 
401 static struct tok isis_subtlv_auth_values[] = {
402     { ISIS_SUBTLV_AUTH_SIMPLE,	"simple text password"},
403     { ISIS_SUBTLV_AUTH_MD5,	"HMAC-MD5 password"},
404     { ISIS_SUBTLV_AUTH_PRIVATE,	"Routing Domain private password"},
405     { 0, NULL }
406 };
407 
408 #define ISIS_SUBTLV_IDRP_RES           0
409 #define ISIS_SUBTLV_IDRP_LOCAL         1
410 #define ISIS_SUBTLV_IDRP_ASN           2
411 
412 static struct tok isis_subtlv_idrp_values[] = {
413     { ISIS_SUBTLV_IDRP_RES,         "Reserved"},
414     { ISIS_SUBTLV_IDRP_LOCAL,       "Routing-Domain Specific"},
415     { ISIS_SUBTLV_IDRP_ASN,         "AS Number Tag"},
416     { 0, NULL}
417 };
418 
419 #define CLNP_SEGMENT_PART  0x80
420 #define CLNP_MORE_SEGMENTS 0x40
421 #define CLNP_REQUEST_ER    0x20
422 
423 static struct tok clnp_flag_values[] = {
424     { CLNP_SEGMENT_PART, "Segmentation permitted"},
425     { CLNP_MORE_SEGMENTS, "more Segments"},
426     { CLNP_REQUEST_ER, "request Error Report"},
427     { 0, NULL}
428 };
429 
430 #define ISIS_MASK_LSP_OL_BIT(x)            ((x)&0x4)
431 #define ISIS_MASK_LSP_ISTYPE_BITS(x)       ((x)&0x3)
432 #define ISIS_MASK_LSP_PARTITION_BIT(x)     ((x)&0x80)
433 #define ISIS_MASK_LSP_ATT_BITS(x)          ((x)&0x78)
434 #define ISIS_MASK_LSP_ATT_ERROR_BIT(x)     ((x)&0x40)
435 #define ISIS_MASK_LSP_ATT_EXPENSE_BIT(x)   ((x)&0x20)
436 #define ISIS_MASK_LSP_ATT_DELAY_BIT(x)     ((x)&0x10)
437 #define ISIS_MASK_LSP_ATT_DEFAULT_BIT(x)   ((x)&0x8)
438 
439 #define ISIS_MASK_MTID(x)                  ((x)&0x0fff)
440 #define ISIS_MASK_MTFLAGS(x)               ((x)&0xf000)
441 
442 static struct tok isis_mt_flag_values[] = {
443     { 0x4000,                  "sub-TLVs present"},
444     { 0x8000,                  "ATT bit set"},
445     { 0, NULL}
446 };
447 
448 #define ISIS_MASK_TLV_EXTD_IP_UPDOWN(x)     ((x)&0x80)
449 #define ISIS_MASK_TLV_EXTD_IP_SUBTLV(x)     ((x)&0x40)
450 
451 #define ISIS_MASK_TLV_EXTD_IP6_IE(x)        ((x)&0x40)
452 #define ISIS_MASK_TLV_EXTD_IP6_SUBTLV(x)    ((x)&0x20)
453 
454 #define ISIS_LSP_TLV_METRIC_SUPPORTED(x)   ((x)&0x80)
455 #define ISIS_LSP_TLV_METRIC_IE(x)          ((x)&0x40)
456 #define ISIS_LSP_TLV_METRIC_UPDOWN(x)      ((x)&0x80)
457 #define ISIS_LSP_TLV_METRIC_VALUE(x)	   ((x)&0x3f)
458 
459 #define ISIS_MASK_TLV_SHARED_RISK_GROUP(x) ((x)&0x1)
460 
461 static struct tok isis_mt_values[] = {
462     { 0,    "IPv4 unicast"},
463     { 1,    "In-Band Management"},
464     { 2,    "IPv6 unicast"},
465     { 3,    "Multicast"},
466     { 4095, "Development, Experimental or Proprietary"},
467     { 0, NULL }
468 };
469 
470 static struct tok isis_iih_circuit_type_values[] = {
471     { 1,    "Level 1 only"},
472     { 2,    "Level 2 only"},
473     { 3,    "Level 1, Level 2"},
474     { 0, NULL}
475 };
476 
477 #define ISIS_LSP_TYPE_UNUSED0   0
478 #define ISIS_LSP_TYPE_LEVEL_1   1
479 #define ISIS_LSP_TYPE_UNUSED2   2
480 #define ISIS_LSP_TYPE_LEVEL_2   3
481 
482 static struct tok isis_lsp_istype_values[] = {
483     { ISIS_LSP_TYPE_UNUSED0,	"Unused 0x0 (invalid)"},
484     { ISIS_LSP_TYPE_LEVEL_1,	"L1 IS"},
485     { ISIS_LSP_TYPE_UNUSED2,	"Unused 0x2 (invalid)"},
486     { ISIS_LSP_TYPE_LEVEL_2,	"L2 IS"},
487     { 0, NULL }
488 };
489 
490 /*
491  * Katz's point to point adjacency TLV uses codes to tell us the state of
492  * the remote adjacency.  Enumerate them.
493  */
494 
495 #define ISIS_PTP_ADJ_UP   0
496 #define ISIS_PTP_ADJ_INIT 1
497 #define ISIS_PTP_ADJ_DOWN 2
498 
499 static struct tok isis_ptp_adjancey_values[] = {
500     { ISIS_PTP_ADJ_UP,    "Up" },
501     { ISIS_PTP_ADJ_INIT,  "Initializing" },
502     { ISIS_PTP_ADJ_DOWN,  "Down" },
503     { 0, NULL}
504 };
505 
506 struct isis_tlv_ptp_adj {
507     u_int8_t adjacency_state;
508     u_int8_t extd_local_circuit_id[4];
509     u_int8_t neighbor_sysid[SYSTEM_ID_LEN];
510     u_int8_t neighbor_extd_local_circuit_id[4];
511 };
512 
513 static void osi_print_cksum(const u_int8_t *pptr, u_int16_t checksum,
514                             u_int checksum_offset, u_int length);
515 static int clnp_print(const u_int8_t *, u_int);
516 static void esis_print(const u_int8_t *, u_int);
517 static int isis_print(const u_int8_t *, u_int);
518 
519 struct isis_metric_block {
520     u_int8_t metric_default;
521     u_int8_t metric_delay;
522     u_int8_t metric_expense;
523     u_int8_t metric_error;
524 };
525 
526 struct isis_tlv_is_reach {
527     struct isis_metric_block isis_metric_block;
528     u_int8_t neighbor_nodeid[NODE_ID_LEN];
529 };
530 
531 struct isis_tlv_es_reach {
532     struct isis_metric_block isis_metric_block;
533     u_int8_t neighbor_sysid[SYSTEM_ID_LEN];
534 };
535 
536 struct isis_tlv_ip_reach {
537     struct isis_metric_block isis_metric_block;
538     u_int8_t prefix[4];
539     u_int8_t mask[4];
540 };
541 
542 static struct tok isis_is_reach_virtual_values[] = {
543     { 0,    "IsNotVirtual"},
544     { 1,    "IsVirtual"},
545     { 0, NULL }
546 };
547 
548 static struct tok isis_restart_flag_values[] = {
549     { 0x1,  "Restart Request"},
550     { 0x2,  "Restart Acknowledgement"},
551     { 0x4,  "Suppress adjacency advertisement"},
552     { 0, NULL }
553 };
554 
555 struct isis_common_header {
556     u_int8_t nlpid;
557     u_int8_t fixed_len;
558     u_int8_t version;			/* Protocol version */
559     u_int8_t id_length;
560     u_int8_t pdu_type;		        /* 3 MSbits are reserved */
561     u_int8_t pdu_version;		/* Packet format version */
562     u_int8_t reserved;
563     u_int8_t max_area;
564 };
565 
566 struct isis_iih_lan_header {
567     u_int8_t circuit_type;
568     u_int8_t source_id[SYSTEM_ID_LEN];
569     u_int8_t holding_time[2];
570     u_int8_t pdu_len[2];
571     u_int8_t priority;
572     u_int8_t lan_id[NODE_ID_LEN];
573 };
574 
575 struct isis_iih_ptp_header {
576     u_int8_t circuit_type;
577     u_int8_t source_id[SYSTEM_ID_LEN];
578     u_int8_t holding_time[2];
579     u_int8_t pdu_len[2];
580     u_int8_t circuit_id;
581 };
582 
583 struct isis_lsp_header {
584     u_int8_t pdu_len[2];
585     u_int8_t remaining_lifetime[2];
586     u_int8_t lsp_id[LSP_ID_LEN];
587     u_int8_t sequence_number[4];
588     u_int8_t checksum[2];
589     u_int8_t typeblock;
590 };
591 
592 struct isis_csnp_header {
593     u_int8_t pdu_len[2];
594     u_int8_t source_id[NODE_ID_LEN];
595     u_int8_t start_lsp_id[LSP_ID_LEN];
596     u_int8_t end_lsp_id[LSP_ID_LEN];
597 };
598 
599 struct isis_psnp_header {
600     u_int8_t pdu_len[2];
601     u_int8_t source_id[NODE_ID_LEN];
602 };
603 
604 struct isis_tlv_lsp {
605     u_int8_t remaining_lifetime[2];
606     u_int8_t lsp_id[LSP_ID_LEN];
607     u_int8_t sequence_number[4];
608     u_int8_t checksum[2];
609 };
610 
611 #define ISIS_COMMON_HEADER_SIZE (sizeof(struct isis_common_header))
612 #define ISIS_IIH_LAN_HEADER_SIZE (sizeof(struct isis_iih_lan_header))
613 #define ISIS_IIH_PTP_HEADER_SIZE (sizeof(struct isis_iih_ptp_header))
614 #define ISIS_LSP_HEADER_SIZE (sizeof(struct isis_lsp_header))
615 #define ISIS_CSNP_HEADER_SIZE (sizeof(struct isis_csnp_header))
616 #define ISIS_PSNP_HEADER_SIZE (sizeof(struct isis_psnp_header))
617 
618 void isoclns_print(const u_int8_t *p, u_int length, u_int caplen)
619 {
620 	const struct isis_common_header *header;
621 
622 	header = (const struct isis_common_header *)p;
623 
624         if (caplen <= 1) { /* enough bytes on the wire ? */
625             printf("|OSI");
626             return;
627         }
628 
629         if (eflag)
630             printf("OSI NLPID %s (0x%02x): ",
631                    tok2str(nlpid_values,"Unknown",*p),
632                    *p);
633 
634 	switch (*p) {
635 
636 	case NLPID_CLNP:
637 		if (!clnp_print(p, length))
638                         print_unknown_data(p,"\n\t",caplen);
639 		break;
640 
641 	case NLPID_ESIS:
642 		esis_print(p, length);
643 		return;
644 
645 	case NLPID_ISIS:
646 		if (!isis_print(p, length))
647                         print_unknown_data(p,"\n\t",caplen);
648 		break;
649 
650 	case NLPID_NULLNS:
651 		(void)printf("%slength: %u",
652 		             eflag ? "" : ", ",
653                              length);
654 		break;
655 
656         case NLPID_Q933:
657                 q933_print(p+1, length-1);
658                 break;
659 
660         case NLPID_IP:
661 		ip_print(gndo, p+1, length-1);
662                 break;
663 
664 #ifdef INET6
665         case NLPID_IP6:
666                 ip6_print(p+1, length-1);
667                 break;
668 #endif
669 
670         case NLPID_PPP:
671                 ppp_print(p+1, length-1);
672                 break;
673 
674 	default:
675                 if (!eflag)
676                     printf("OSI NLPID 0x%02x unknown",*p);
677 		(void)printf("%slength: %u",
678 		             eflag ? "" : ", ",
679                              length);
680 		if (caplen > 1)
681                         print_unknown_data(p,"\n\t",caplen);
682 		break;
683 	}
684 }
685 
686 #define	CLNP_PDU_ER	 1
687 #define	CLNP_PDU_DT	28
688 #define	CLNP_PDU_MD	29
689 #define	CLNP_PDU_ERQ	30
690 #define	CLNP_PDU_ERP	31
691 
692 static struct tok clnp_pdu_values[] = {
693     { CLNP_PDU_ER,  "Error Report"},
694     { CLNP_PDU_MD,  "MD"},
695     { CLNP_PDU_DT,  "Data"},
696     { CLNP_PDU_ERQ, "Echo Request"},
697     { CLNP_PDU_ERP, "Echo Response"},
698     { 0, NULL }
699 };
700 
701 struct clnp_header_t {
702     u_int8_t nlpid;
703     u_int8_t length_indicator;
704     u_int8_t version;
705     u_int8_t lifetime; /* units of 500ms */
706     u_int8_t type;
707     u_int8_t segment_length[2];
708     u_int8_t cksum[2];
709 };
710 
711 struct clnp_segment_header_t {
712     u_int8_t data_unit_id[2];
713     u_int8_t segment_offset[2];
714     u_int8_t total_length[2];
715 };
716 
717 /*
718  * clnp_print
719  * Decode CLNP packets.  Return 0 on error.
720  */
721 
722 static int clnp_print (const u_int8_t *pptr, u_int length)
723 {
724 	const u_int8_t *optr,*source_address,*dest_address;
725         u_int li,tlen,nsap_offset,source_address_length,dest_address_length, clnp_pdu_type, clnp_flags;
726 	const struct clnp_header_t *clnp_header;
727 	const struct clnp_segment_header_t *clnp_segment_header;
728         u_int8_t rfd_error_major,rfd_error_minor;
729 
730 	clnp_header = (const struct clnp_header_t *) pptr;
731         TCHECK(*clnp_header);
732 
733         li = clnp_header->length_indicator;
734         optr = pptr;
735 
736         if (!eflag)
737             printf("CLNP");
738 
739         /*
740          * Sanity checking of the header.
741          */
742 
743         if (clnp_header->version != CLNP_VERSION) {
744             printf("version %d packet not supported", clnp_header->version);
745             return (0);
746         }
747 
748         /* FIXME further header sanity checking */
749 
750         clnp_pdu_type = clnp_header->type & CLNP_PDU_TYPE_MASK;
751         clnp_flags = clnp_header->type & CLNP_FLAG_MASK;
752 
753         pptr += sizeof(struct clnp_header_t);
754         li -= sizeof(struct clnp_header_t);
755         dest_address_length = *pptr;
756         dest_address = pptr + 1;
757 
758         pptr += (1 + dest_address_length);
759         li -= (1 + dest_address_length);
760         source_address_length = *pptr;
761         source_address = pptr +1;
762 
763         pptr += (1 + source_address_length);
764         li -= (1 + source_address_length);
765 
766         if (vflag < 1) {
767             printf("%s%s > %s, %s, length %u",
768                    eflag ? "" : ", ",
769                    isonsap_string(source_address, source_address_length),
770                    isonsap_string(dest_address, dest_address_length),
771                    tok2str(clnp_pdu_values,"unknown (%u)",clnp_pdu_type),
772                    length);
773             return (1);
774         }
775         printf("%slength %u",eflag ? "" : ", ",length);
776 
777         printf("\n\t%s PDU, hlen: %u, v: %u, lifetime: %u.%us, Segment PDU length: %u, checksum: 0x%04x",
778                tok2str(clnp_pdu_values, "unknown (%u)",clnp_pdu_type),
779                clnp_header->length_indicator,
780                clnp_header->version,
781                clnp_header->lifetime/2,
782                (clnp_header->lifetime%2)*5,
783                EXTRACT_16BITS(clnp_header->segment_length),
784                EXTRACT_16BITS(clnp_header->cksum));
785 
786         osi_print_cksum(optr, EXTRACT_16BITS(clnp_header->cksum), 7,
787                         clnp_header->length_indicator);
788 
789         printf("\n\tFlags [%s]",
790                bittok2str(clnp_flag_values,"none",clnp_flags));
791 
792         printf("\n\tsource address (length %u): %s\n\tdest   address (length %u): %s",
793                source_address_length,
794                isonsap_string(source_address, source_address_length),
795                dest_address_length,
796                isonsap_string(dest_address,dest_address_length));
797 
798         if (clnp_flags & CLNP_SEGMENT_PART) {
799             	clnp_segment_header = (const struct clnp_segment_header_t *) pptr;
800                 TCHECK(*clnp_segment_header);
801                 printf("\n\tData Unit ID: 0x%04x, Segment Offset: %u, Total PDU Length: %u",
802                        EXTRACT_16BITS(clnp_segment_header->data_unit_id),
803                        EXTRACT_16BITS(clnp_segment_header->segment_offset),
804                        EXTRACT_16BITS(clnp_segment_header->total_length));
805                 pptr+=sizeof(const struct clnp_segment_header_t);
806                 li-=sizeof(const struct clnp_segment_header_t);
807         }
808 
809         /* now walk the options */
810         while (li >= 2) {
811             u_int op, opli;
812             const u_int8_t *tptr;
813 
814             TCHECK2(*pptr, 2);
815             if (li < 2) {
816                 printf(", bad opts/li");
817                 return (0);
818             }
819             op = *pptr++;
820             opli = *pptr++;
821             li -= 2;
822             TCHECK2(*pptr, opli);
823             if (opli > li) {
824                 printf(", opt (%d) too long", op);
825                 return (0);
826             }
827             li -= opli;
828             tptr = pptr;
829             tlen = opli;
830 
831             printf("\n\t  %s Option #%u, length %u, value: ",
832                    tok2str(clnp_option_values,"Unknown",op),
833                    op,
834                    opli);
835 
836             switch (op) {
837 
838 
839             case CLNP_OPTION_ROUTE_RECORDING: /* those two options share the format */
840             case CLNP_OPTION_SOURCE_ROUTING:
841                     printf("%s %s",
842                            tok2str(clnp_option_sr_rr_values,"Unknown",*tptr),
843                            tok2str(clnp_option_sr_rr_string_values,"Unknown Option %u",op));
844                     nsap_offset=*(tptr+1);
845                     if (nsap_offset == 0) {
846                             printf(" Bad NSAP offset (0)");
847                             break;
848                     }
849                     nsap_offset-=1; /* offset to nsap list */
850                     if (nsap_offset > tlen) {
851                             printf(" Bad NSAP offset (past end of option)");
852                             break;
853                     }
854                     tptr+=nsap_offset;
855                     tlen-=nsap_offset;
856                     while (tlen > 0) {
857                             source_address_length=*tptr;
858                             if (tlen < source_address_length+1) {
859                                     printf("\n\t    NSAP address goes past end of option");
860                                     break;
861                             }
862                             if (source_address_length > 0) {
863                                     source_address=(tptr+1);
864                                     TCHECK2(*source_address, source_address_length);
865                                     printf("\n\t    NSAP address (length %u): %s",
866                                            source_address_length,
867                                            isonsap_string(source_address, source_address_length));
868                             }
869                             tlen-=source_address_length+1;
870                     }
871                     break;
872 
873             case CLNP_OPTION_PRIORITY:
874                     printf("0x%1x", *tptr&0x0f);
875                     break;
876 
877             case CLNP_OPTION_QOS_MAINTENANCE:
878                     printf("\n\t    Format Code: %s",
879                            tok2str(clnp_option_scope_values,"Reserved",*tptr&CLNP_OPTION_SCOPE_MASK));
880 
881                     if ((*tptr&CLNP_OPTION_SCOPE_MASK) == CLNP_OPTION_SCOPE_GLOBAL)
882                             printf("\n\t    QoS Flags [%s]",
883                                    bittok2str(clnp_option_qos_global_values,
884                                               "none",
885                                               *tptr&CLNP_OPTION_OPTION_QOS_MASK));
886                     break;
887 
888             case CLNP_OPTION_SECURITY:
889                     printf("\n\t    Format Code: %s, Security-Level %u",
890                            tok2str(clnp_option_scope_values,"Reserved",*tptr&CLNP_OPTION_SCOPE_MASK),
891                            *(tptr+1));
892                     break;
893 
894             case CLNP_OPTION_DISCARD_REASON:
895                 rfd_error_major = (*tptr&0xf0) >> 4;
896                 rfd_error_minor = *tptr&0x0f;
897                 printf("\n\t    Class: %s Error (0x%01x), %s (0x%01x)",
898                        tok2str(clnp_option_rfd_class_values,"Unknown",rfd_error_major),
899                        rfd_error_major,
900                        tok2str(clnp_option_rfd_error_class[rfd_error_major],"Unknown",rfd_error_minor),
901                        rfd_error_minor);
902                 break;
903 
904             case CLNP_OPTION_PADDING:
905                     printf("padding data");
906                 break;
907 
908                 /*
909                  * FIXME those are the defined Options that lack a decoder
910                  * you are welcome to contribute code ;-)
911                  */
912 
913             default:
914                 print_unknown_data(tptr,"\n\t  ",opli);
915                 break;
916             }
917             if (vflag > 1)
918                 print_unknown_data(pptr,"\n\t  ",opli);
919             pptr += opli;
920         }
921 
922         switch (clnp_pdu_type) {
923 
924         case    CLNP_PDU_ER: /* fall through */
925         case 	CLNP_PDU_ERP:
926             TCHECK(*pptr);
927             if (*(pptr) == NLPID_CLNP) {
928                 printf("\n\t-----original packet-----\n\t");
929                 /* FIXME recursion protection */
930                 clnp_print(pptr, length-clnp_header->length_indicator);
931                 break;
932             }
933 
934         case 	CLNP_PDU_DT:
935         case 	CLNP_PDU_MD:
936         case 	CLNP_PDU_ERQ:
937 
938         default:
939             /* dump the PDU specific data */
940             if (length-(pptr-optr) > 0) {
941                 printf("\n\t  undecoded non-header data, length %u",length-clnp_header->length_indicator);
942                 print_unknown_data(pptr,"\n\t  ",length-(pptr-optr));
943             }
944         }
945 
946         return (1);
947 
948  trunc:
949     fputs("[|clnp]", stdout);
950     return (1);
951 
952 }
953 
954 
955 #define	ESIS_PDU_REDIRECT	6
956 #define	ESIS_PDU_ESH	        2
957 #define	ESIS_PDU_ISH	        4
958 
959 static struct tok esis_pdu_values[] = {
960     { ESIS_PDU_REDIRECT, "redirect"},
961     { ESIS_PDU_ESH,      "ESH"},
962     { ESIS_PDU_ISH,      "ISH"},
963     { 0, NULL }
964 };
965 
966 struct esis_header_t {
967 	u_int8_t nlpid;
968 	u_int8_t length_indicator;
969 	u_int8_t version;
970 	u_int8_t reserved;
971 	u_int8_t type;
972 	u_int8_t holdtime[2];
973 	u_int8_t cksum[2];
974 };
975 
976 static void
977 esis_print(const u_int8_t *pptr, u_int length)
978 {
979 	const u_int8_t *optr;
980 	u_int li,esis_pdu_type,source_address_length, source_address_number;
981 	const struct esis_header_t *esis_header;
982 
983         if (!eflag)
984             printf("ES-IS");
985 
986 	if (length <= 2) {
987 		if (qflag)
988 			printf("bad pkt!");
989 		else
990 			printf("no header at all!");
991 		return;
992 	}
993 
994 	esis_header = (const struct esis_header_t *) pptr;
995         TCHECK(*esis_header);
996         li = esis_header->length_indicator;
997         optr = pptr;
998 
999         /*
1000          * Sanity checking of the header.
1001          */
1002 
1003         if (esis_header->nlpid != NLPID_ESIS) {
1004             printf(" nlpid 0x%02x packet not supported", esis_header->nlpid);
1005             return;
1006         }
1007 
1008         if (esis_header->version != ESIS_VERSION) {
1009             printf(" version %d packet not supported", esis_header->version);
1010             return;
1011         }
1012 
1013 	if (li > length) {
1014             printf(" length indicator(%d) > PDU size (%d)!", li, length);
1015             return;
1016 	}
1017 
1018 	if (li < sizeof(struct esis_header_t) + 2) {
1019             printf(" length indicator < min PDU size %d:", li);
1020             while (--length != 0)
1021                 printf("%02X", *pptr++);
1022             return;
1023 	}
1024 
1025         esis_pdu_type = esis_header->type & ESIS_PDU_TYPE_MASK;
1026 
1027         if (vflag < 1) {
1028             printf("%s%s, length %u",
1029                    eflag ? "" : ", ",
1030                    tok2str(esis_pdu_values,"unknown type (%u)",esis_pdu_type),
1031                    length);
1032             return;
1033         } else
1034             printf("%slength %u\n\t%s (%u)",
1035                    eflag ? "" : ", ",
1036                    length,
1037                    tok2str(esis_pdu_values,"unknown type: %u", esis_pdu_type),
1038                    esis_pdu_type);
1039 
1040         printf(", v: %u%s", esis_header->version, esis_header->version == ESIS_VERSION ? "" : "unsupported" );
1041         printf(", checksum: 0x%04x", EXTRACT_16BITS(esis_header->cksum));
1042 
1043         osi_print_cksum(pptr, EXTRACT_16BITS(esis_header->cksum), 7, li);
1044 
1045         printf(", holding time: %us, length indicator: %u",EXTRACT_16BITS(esis_header->holdtime),li);
1046 
1047         if (vflag > 1)
1048             print_unknown_data(optr,"\n\t",sizeof(struct esis_header_t));
1049 
1050 	pptr += sizeof(struct esis_header_t);
1051 	li -= sizeof(struct esis_header_t);
1052 
1053 	switch (esis_pdu_type) {
1054 	case ESIS_PDU_REDIRECT: {
1055 		const u_int8_t *dst, *snpa, *neta;
1056 		u_int dstl, snpal, netal;
1057 
1058 		TCHECK(*pptr);
1059 		if (li < 1) {
1060 			printf(", bad redirect/li");
1061 			return;
1062 		}
1063 		dstl = *pptr;
1064 		pptr++;
1065 		li--;
1066 		TCHECK2(*pptr, dstl);
1067 		if (li < dstl) {
1068 			printf(", bad redirect/li");
1069 			return;
1070 		}
1071 		dst = pptr;
1072 		pptr += dstl;
1073                 li -= dstl;
1074 		printf("\n\t  %s", isonsap_string(dst,dstl));
1075 
1076 		TCHECK(*pptr);
1077 		if (li < 1) {
1078 			printf(", bad redirect/li");
1079 			return;
1080 		}
1081 		snpal = *pptr;
1082 		pptr++;
1083 		li--;
1084 		TCHECK2(*pptr, snpal);
1085 		if (li < snpal) {
1086 			printf(", bad redirect/li");
1087 			return;
1088 		}
1089 		snpa = pptr;
1090 		pptr += snpal;
1091                 li -= snpal;
1092 		TCHECK(*pptr);
1093 		if (li < 1) {
1094 			printf(", bad redirect/li");
1095 			return;
1096 		}
1097 		netal = *pptr;
1098 		pptr++;
1099 		TCHECK2(*pptr, netal);
1100 		if (li < netal) {
1101 			printf(", bad redirect/li");
1102 			return;
1103 		}
1104 		neta = pptr;
1105 		pptr += netal;
1106                 li -= netal;
1107 
1108 		if (netal == 0)
1109 			printf("\n\t  %s", etheraddr_string(snpa));
1110 		else
1111 			printf("\n\t  %s", isonsap_string(neta,netal));
1112 		break;
1113 	}
1114 
1115 	case ESIS_PDU_ESH:
1116             TCHECK(*pptr);
1117             if (li < 1) {
1118                 printf(", bad esh/li");
1119                 return;
1120             }
1121             source_address_number = *pptr;
1122             pptr++;
1123             li--;
1124 
1125             printf("\n\t  Number of Source Addresses: %u", source_address_number);
1126 
1127             while (source_address_number > 0) {
1128                 TCHECK(*pptr);
1129             	if (li < 1) {
1130                     printf(", bad esh/li");
1131             	    return;
1132             	}
1133                 source_address_length = *pptr;
1134                 pptr++;
1135             	li--;
1136 
1137                 TCHECK2(*pptr, source_address_length);
1138             	if (li < source_address_length) {
1139                     printf(", bad esh/li");
1140             	    return;
1141             	}
1142                 printf("\n\t  NET (length: %u): %s",
1143                        source_address_length,
1144                        isonsap_string(pptr,source_address_length));
1145                 pptr += source_address_length;
1146                 li -= source_address_length;
1147                 source_address_number--;
1148             }
1149 
1150             break;
1151 
1152 	case ESIS_PDU_ISH: {
1153             TCHECK(*pptr);
1154             if (li < 1) {
1155                 printf(", bad ish/li");
1156                 return;
1157             }
1158             source_address_length = *pptr;
1159             pptr++;
1160             li--;
1161             TCHECK2(*pptr, source_address_length);
1162             if (li < source_address_length) {
1163                 printf(", bad ish/li");
1164                 return;
1165             }
1166             printf("\n\t  NET (length: %u): %s", source_address_length, isonsap_string(pptr, source_address_length));
1167             pptr += source_address_length;
1168             li -= source_address_length;
1169             break;
1170 	}
1171 
1172 	default:
1173             if (vflag <= 1) {
1174 		    if (pptr < snapend)
1175                             print_unknown_data(pptr,"\n\t  ",snapend-pptr);
1176             }
1177             return;
1178 	}
1179 
1180         /* now walk the options */
1181         while (li >= 2) {
1182             u_int op, opli;
1183             const u_int8_t *tptr;
1184 
1185             TCHECK2(*pptr, 2);
1186             if (li < 2) {
1187                 printf(", bad opts/li");
1188                 return;
1189             }
1190             op = *pptr++;
1191             opli = *pptr++;
1192             li -= 2;
1193             if (opli > li) {
1194                 printf(", opt (%d) too long", op);
1195                 return;
1196             }
1197             li -= opli;
1198             tptr = pptr;
1199 
1200             printf("\n\t  %s Option #%u, length %u, value: ",
1201                    tok2str(esis_option_values,"Unknown",op),
1202                    op,
1203                    opli);
1204 
1205             switch (op) {
1206 
1207             case ESIS_OPTION_ES_CONF_TIME:
1208                 TCHECK2(*pptr, 2);
1209                 printf("%us", EXTRACT_16BITS(tptr));
1210                 break;
1211 
1212             case ESIS_OPTION_PROTOCOLS:
1213                 while (opli>0) {
1214                     TCHECK(*pptr);
1215                     printf("%s (0x%02x)",
1216                            tok2str(nlpid_values,
1217                                    "unknown",
1218                                    *tptr),
1219                            *tptr);
1220                     if (opli>1) /* further NPLIDs ? - put comma */
1221                         printf(", ");
1222                     tptr++;
1223                     opli--;
1224                 }
1225                 break;
1226 
1227                 /*
1228                  * FIXME those are the defined Options that lack a decoder
1229                  * you are welcome to contribute code ;-)
1230                  */
1231 
1232             case ESIS_OPTION_QOS_MAINTENANCE:
1233             case ESIS_OPTION_SECURITY:
1234             case ESIS_OPTION_PRIORITY:
1235             case ESIS_OPTION_ADDRESS_MASK:
1236             case ESIS_OPTION_SNPA_MASK:
1237 
1238             default:
1239                 print_unknown_data(tptr,"\n\t  ",opli);
1240                 break;
1241             }
1242             if (vflag > 1)
1243                 print_unknown_data(pptr,"\n\t  ",opli);
1244             pptr += opli;
1245         }
1246 trunc:
1247 	return;
1248 }
1249 
1250 /* shared routine for printing system, node and lsp-ids */
1251 static char *
1252 isis_print_id(const u_int8_t *cp, int id_len)
1253 {
1254     int i;
1255     static char id[sizeof("xxxx.xxxx.xxxx.yy-zz")];
1256     char *pos = id;
1257 
1258     for (i = 1; i <= SYSTEM_ID_LEN; i++) {
1259         snprintf(pos, sizeof(id) - (pos - id), "%02x", *cp++);
1260 	pos += strlen(pos);
1261 	if (i == 2 || i == 4)
1262 	    *pos++ = '.';
1263 	}
1264     if (id_len >= NODE_ID_LEN) {
1265         snprintf(pos, sizeof(id) - (pos - id), ".%02x", *cp++);
1266 	pos += strlen(pos);
1267     }
1268     if (id_len == LSP_ID_LEN)
1269         snprintf(pos, sizeof(id) - (pos - id), "-%02x", *cp);
1270     return (id);
1271 }
1272 
1273 /* print the 4-byte metric block which is common found in the old-style TLVs */
1274 static int
1275 isis_print_metric_block (const struct isis_metric_block *isis_metric_block)
1276 {
1277     printf(", Default Metric: %d, %s",
1278            ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_default),
1279            ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_default) ? "External" : "Internal");
1280     if (!ISIS_LSP_TLV_METRIC_SUPPORTED(isis_metric_block->metric_delay))
1281         printf("\n\t\t  Delay Metric: %d, %s",
1282                ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_delay),
1283                ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_delay) ? "External" : "Internal");
1284     if (!ISIS_LSP_TLV_METRIC_SUPPORTED(isis_metric_block->metric_expense))
1285         printf("\n\t\t  Expense Metric: %d, %s",
1286                ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_expense),
1287                ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_expense) ? "External" : "Internal");
1288     if (!ISIS_LSP_TLV_METRIC_SUPPORTED(isis_metric_block->metric_error))
1289         printf("\n\t\t  Error Metric: %d, %s",
1290                ISIS_LSP_TLV_METRIC_VALUE(isis_metric_block->metric_error),
1291                ISIS_LSP_TLV_METRIC_IE(isis_metric_block->metric_error) ? "External" : "Internal");
1292 
1293     return(1); /* everything is ok */
1294 }
1295 
1296 static int
1297 isis_print_tlv_ip_reach (const u_int8_t *cp, const char *ident, int length)
1298 {
1299 	int prefix_len;
1300 	const struct isis_tlv_ip_reach *tlv_ip_reach;
1301 
1302 	tlv_ip_reach = (const struct isis_tlv_ip_reach *)cp;
1303 
1304 	while (length > 0) {
1305 		if ((size_t)length < sizeof(*tlv_ip_reach)) {
1306 			printf("short IPv4 Reachability (%d vs %lu)",
1307                                length,
1308                                (unsigned long)sizeof(*tlv_ip_reach));
1309 			return (0);
1310 		}
1311 
1312 		if (!TTEST(*tlv_ip_reach))
1313 		    return (0);
1314 
1315 		prefix_len = mask2plen(EXTRACT_32BITS(tlv_ip_reach->mask));
1316 
1317 		if (prefix_len == -1)
1318 			printf("%sIPv4 prefix: %s mask %s",
1319                                ident,
1320 			       ipaddr_string((tlv_ip_reach->prefix)),
1321 			       ipaddr_string((tlv_ip_reach->mask)));
1322 		else
1323 			printf("%sIPv4 prefix: %15s/%u",
1324                                ident,
1325 			       ipaddr_string((tlv_ip_reach->prefix)),
1326 			       prefix_len);
1327 
1328 		printf(", Distribution: %s, Metric: %u, %s",
1329                        ISIS_LSP_TLV_METRIC_UPDOWN(tlv_ip_reach->isis_metric_block.metric_default) ? "down" : "up",
1330                        ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_default),
1331                        ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_default) ? "External" : "Internal");
1332 
1333 		if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->isis_metric_block.metric_delay))
1334                     printf("%s  Delay Metric: %u, %s",
1335                            ident,
1336                            ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_delay),
1337                            ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_delay) ? "External" : "Internal");
1338 
1339 		if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->isis_metric_block.metric_expense))
1340                     printf("%s  Expense Metric: %u, %s",
1341                            ident,
1342                            ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_expense),
1343                            ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_expense) ? "External" : "Internal");
1344 
1345 		if (!ISIS_LSP_TLV_METRIC_SUPPORTED(tlv_ip_reach->isis_metric_block.metric_error))
1346                     printf("%s  Error Metric: %u, %s",
1347                            ident,
1348                            ISIS_LSP_TLV_METRIC_VALUE(tlv_ip_reach->isis_metric_block.metric_error),
1349                            ISIS_LSP_TLV_METRIC_IE(tlv_ip_reach->isis_metric_block.metric_error) ? "External" : "Internal");
1350 
1351 		length -= sizeof(struct isis_tlv_ip_reach);
1352 		tlv_ip_reach++;
1353 	}
1354 	return (1);
1355 }
1356 
1357 /*
1358  * this is the common IP-REACH subTLV decoder it is called
1359  * from various EXTD-IP REACH TLVs (135,235,236,237)
1360  */
1361 
1362 static int
1363 isis_print_ip_reach_subtlv (const u_int8_t *tptr,int subt,int subl,const char *ident) {
1364 
1365         /* first lets see if we know the subTLVs name*/
1366 	printf("%s%s subTLV #%u, length: %u",
1367 	       ident,
1368                tok2str(isis_ext_ip_reach_subtlv_values,
1369                        "unknown",
1370                        subt),
1371                subt,
1372                subl);
1373 
1374 	if (!TTEST2(*tptr,subl))
1375 	    goto trunctlv;
1376 
1377     switch(subt) {
1378     case ISIS_SUBTLV_EXTD_IP_REACH_MGMT_PREFIX_COLOR: /* fall through */
1379     case ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG32:
1380         while (subl >= 4) {
1381 	    printf(", 0x%08x (=%u)",
1382 		   EXTRACT_32BITS(tptr),
1383 		   EXTRACT_32BITS(tptr));
1384 	    tptr+=4;
1385 	    subl-=4;
1386 	}
1387 	break;
1388     case ISIS_SUBTLV_EXTD_IP_REACH_ADMIN_TAG64:
1389         while (subl >= 8) {
1390 	    printf(", 0x%08x%08x",
1391 		   EXTRACT_32BITS(tptr),
1392 		   EXTRACT_32BITS(tptr+4));
1393 	    tptr+=8;
1394 	    subl-=8;
1395 	}
1396 	break;
1397     default:
1398 	if(!print_unknown_data(tptr,"\n\t\t    ",
1399 			       subl))
1400 	  return(0);
1401 	break;
1402     }
1403     return(1);
1404 
1405 trunctlv:
1406     printf("%spacket exceeded snapshot",ident);
1407     return(0);
1408 }
1409 
1410 /*
1411  * this is the common IS-REACH subTLV decoder it is called
1412  * from isis_print_ext_is_reach()
1413  */
1414 
1415 static int
1416 isis_print_is_reach_subtlv (const u_int8_t *tptr,u_int subt,u_int subl,const char *ident) {
1417 
1418         u_int te_class,priority_level,gmpls_switch_cap;
1419         union { /* int to float conversion buffer for several subTLVs */
1420             float f;
1421             u_int32_t i;
1422         } bw;
1423 
1424         /* first lets see if we know the subTLVs name*/
1425 	printf("%s%s subTLV #%u, length: %u",
1426 	       ident,
1427                tok2str(isis_ext_is_reach_subtlv_values,
1428                        "unknown",
1429                        subt),
1430                subt,
1431                subl);
1432 
1433 	if (!TTEST2(*tptr,subl))
1434 	    goto trunctlv;
1435 
1436         switch(subt) {
1437         case ISIS_SUBTLV_EXT_IS_REACH_ADMIN_GROUP:
1438         case ISIS_SUBTLV_EXT_IS_REACH_LINK_LOCAL_REMOTE_ID:
1439         case ISIS_SUBTLV_EXT_IS_REACH_LINK_REMOTE_ID:
1440 	    if (subl >= 4) {
1441 	      printf(", 0x%08x", EXTRACT_32BITS(tptr));
1442 	      if (subl == 8) /* rfc4205 */
1443 	        printf(", 0x%08x", EXTRACT_32BITS(tptr+4));
1444 	    }
1445 	    break;
1446         case ISIS_SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR:
1447         case ISIS_SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR:
1448             if (subl >= sizeof(struct in_addr))
1449               printf(", %s", ipaddr_string(tptr));
1450             break;
1451         case ISIS_SUBTLV_EXT_IS_REACH_MAX_LINK_BW :
1452 	case ISIS_SUBTLV_EXT_IS_REACH_RESERVABLE_BW:
1453             if (subl >= 4) {
1454               bw.i = EXTRACT_32BITS(tptr);
1455               printf(", %.3f Mbps", bw.f*8/1000000 );
1456             }
1457             break;
1458         case ISIS_SUBTLV_EXT_IS_REACH_UNRESERVED_BW :
1459             if (subl >= 32) {
1460               for (te_class = 0; te_class < 8; te_class++) {
1461                 bw.i = EXTRACT_32BITS(tptr);
1462                 printf("%s  TE-Class %u: %.3f Mbps",
1463                        ident,
1464                        te_class,
1465                        bw.f*8/1000000 );
1466 		tptr+=4;
1467 	      }
1468             }
1469             break;
1470         case ISIS_SUBTLV_EXT_IS_REACH_BW_CONSTRAINTS: /* fall through */
1471         case ISIS_SUBTLV_EXT_IS_REACH_BW_CONSTRAINTS_OLD:
1472             printf("%sBandwidth Constraints Model ID: %s (%u)",
1473                    ident,
1474                    tok2str(diffserv_te_bc_values, "unknown", *tptr),
1475                    *tptr);
1476             tptr++;
1477             /* decode BCs until the subTLV ends */
1478             for (te_class = 0; te_class < (subl-1)/4; te_class++) {
1479                 bw.i = EXTRACT_32BITS(tptr);
1480                 printf("%s  Bandwidth constraint CT%u: %.3f Mbps",
1481                        ident,
1482                        te_class,
1483                        bw.f*8/1000000 );
1484 		tptr+=4;
1485             }
1486             break;
1487         case ISIS_SUBTLV_EXT_IS_REACH_TE_METRIC:
1488             if (subl >= 3)
1489               printf(", %u", EXTRACT_24BITS(tptr));
1490             break;
1491         case ISIS_SUBTLV_EXT_IS_REACH_LINK_ATTRIBUTE:
1492             if (subl == 2) {
1493                printf(", [ %s ] (0x%04x)",
1494                       bittok2str(isis_subtlv_link_attribute_values,
1495                                  "Unknown",
1496                                  EXTRACT_16BITS(tptr)),
1497                       EXTRACT_16BITS(tptr));
1498             }
1499             break;
1500         case ISIS_SUBTLV_EXT_IS_REACH_LINK_PROTECTION_TYPE:
1501             if (subl >= 2) {
1502               printf(", %s, Priority %u",
1503 		   bittok2str(gmpls_link_prot_values, "none", *tptr),
1504                    *(tptr+1));
1505             }
1506             break;
1507         case ISIS_SUBTLV_EXT_IS_REACH_INTF_SW_CAP_DESCR:
1508             if (subl >= 36) {
1509               gmpls_switch_cap = *tptr;
1510               printf("%s  Interface Switching Capability:%s",
1511                    ident,
1512                    tok2str(gmpls_switch_cap_values, "Unknown", gmpls_switch_cap));
1513               printf(", LSP Encoding: %s",
1514                    tok2str(gmpls_encoding_values, "Unknown", *(tptr+1)));
1515 	      tptr+=4;
1516               printf("%s  Max LSP Bandwidth:",ident);
1517               for (priority_level = 0; priority_level < 8; priority_level++) {
1518                 bw.i = EXTRACT_32BITS(tptr);
1519                 printf("%s    priority level %d: %.3f Mbps",
1520                        ident,
1521                        priority_level,
1522                        bw.f*8/1000000 );
1523 		tptr+=4;
1524               }
1525               subl-=36;
1526               switch (gmpls_switch_cap) {
1527               case GMPLS_PSC1:
1528               case GMPLS_PSC2:
1529               case GMPLS_PSC3:
1530               case GMPLS_PSC4:
1531                 bw.i = EXTRACT_32BITS(tptr);
1532                 printf("%s  Min LSP Bandwidth: %.3f Mbps", ident, bw.f*8/1000000);
1533                 printf("%s  Interface MTU: %u", ident, EXTRACT_16BITS(tptr+4));
1534                 break;
1535               case GMPLS_TSC:
1536                 bw.i = EXTRACT_32BITS(tptr);
1537                 printf("%s  Min LSP Bandwidth: %.3f Mbps", ident, bw.f*8/1000000);
1538                 printf("%s  Indication %s", ident,
1539                        tok2str(gmpls_switch_cap_tsc_indication_values, "Unknown (%u)", *(tptr+4)));
1540                 break;
1541               default:
1542                 /* there is some optional stuff left to decode but this is as of yet
1543                    not specified so just lets hexdump what is left */
1544                 if(subl>0){
1545                   if(!print_unknown_data(tptr,"\n\t\t    ",
1546                                          subl))
1547                     return(0);
1548                 }
1549               }
1550             }
1551             break;
1552         default:
1553             if(!print_unknown_data(tptr,"\n\t\t    ",
1554 				   subl))
1555                 return(0);
1556             break;
1557         }
1558         return(1);
1559 
1560 trunctlv:
1561     printf("%spacket exceeded snapshot",ident);
1562     return(0);
1563 }
1564 
1565 
1566 /*
1567  * this is the common IS-REACH decoder it is called
1568  * from various EXTD-IS REACH style TLVs (22,24,222)
1569  */
1570 
1571 static int
1572 isis_print_ext_is_reach (const u_int8_t *tptr,const char *ident, int tlv_type) {
1573 
1574     char ident_buffer[20];
1575     int subtlv_type,subtlv_len,subtlv_sum_len;
1576     int proc_bytes = 0; /* how many bytes did we process ? */
1577 
1578     if (!TTEST2(*tptr, NODE_ID_LEN))
1579         return(0);
1580 
1581     printf("%sIS Neighbor: %s", ident, isis_print_id(tptr, NODE_ID_LEN));
1582     tptr+=(NODE_ID_LEN);
1583 
1584     if (tlv_type != ISIS_TLV_IS_ALIAS_ID) { /* the Alias TLV Metric field is implicit 0 */
1585         if (!TTEST2(*tptr, 3))    /* and is therefore skipped */
1586 	    return(0);
1587 	printf(", Metric: %d",EXTRACT_24BITS(tptr));
1588 	tptr+=3;
1589     }
1590 
1591     if (!TTEST2(*tptr, 1))
1592         return(0);
1593     subtlv_sum_len=*(tptr++); /* read out subTLV length */
1594     proc_bytes=NODE_ID_LEN+3+1;
1595     printf(", %ssub-TLVs present",subtlv_sum_len ? "" : "no ");
1596     if (subtlv_sum_len) {
1597         printf(" (%u)",subtlv_sum_len);
1598         while (subtlv_sum_len>0) {
1599             if (!TTEST2(*tptr,2))
1600                 return(0);
1601             subtlv_type=*(tptr++);
1602             subtlv_len=*(tptr++);
1603             /* prepend the ident string */
1604             snprintf(ident_buffer, sizeof(ident_buffer), "%s  ",ident);
1605             if(!isis_print_is_reach_subtlv(tptr,subtlv_type,subtlv_len,ident_buffer))
1606                 return(0);
1607             tptr+=subtlv_len;
1608             subtlv_sum_len-=(subtlv_len+2);
1609             proc_bytes+=(subtlv_len+2);
1610         }
1611     }
1612     return(proc_bytes);
1613 }
1614 
1615 /*
1616  * this is the common Multi Topology ID decoder
1617  * it is called from various MT-TLVs (222,229,235,237)
1618  */
1619 
1620 static int
1621 isis_print_mtid (const u_int8_t *tptr,const char *ident) {
1622 
1623     if (!TTEST2(*tptr, 2))
1624         return(0);
1625 
1626     printf("%s%s",
1627            ident,
1628            tok2str(isis_mt_values,
1629                    "Reserved for IETF Consensus",
1630                    ISIS_MASK_MTID(EXTRACT_16BITS(tptr))));
1631 
1632     printf(" Topology (0x%03x), Flags: [%s]",
1633            ISIS_MASK_MTID(EXTRACT_16BITS(tptr)),
1634            bittok2str(isis_mt_flag_values, "none",ISIS_MASK_MTFLAGS(EXTRACT_16BITS(tptr))));
1635 
1636     return(2);
1637 }
1638 
1639 /*
1640  * this is the common extended IP reach decoder
1641  * it is called from TLVs (135,235,236,237)
1642  * we process the TLV and optional subTLVs and return
1643  * the amount of processed bytes
1644  */
1645 
1646 static int
1647 isis_print_extd_ip_reach (const u_int8_t *tptr, const char *ident, u_int16_t afi) {
1648 
1649     char ident_buffer[20];
1650 #ifdef INET6
1651     u_int8_t prefix[sizeof(struct in6_addr)]; /* shared copy buffer for IPv4 and IPv6 prefixes */
1652 #else
1653     u_int8_t prefix[sizeof(struct in_addr)]; /* shared copy buffer for IPv4 prefixes */
1654 #endif
1655     u_int metric, status_byte, bit_length, byte_length, sublen, processed, subtlvtype, subtlvlen;
1656 
1657     if (!TTEST2(*tptr, 4))
1658         return (0);
1659     metric = EXTRACT_32BITS(tptr);
1660     processed=4;
1661     tptr+=4;
1662 
1663     if (afi == AF_INET) {
1664         if (!TTEST2(*tptr, 1)) /* fetch status byte */
1665             return (0);
1666         status_byte=*(tptr++);
1667         bit_length = status_byte&0x3f;
1668         if (bit_length > 32) {
1669             printf("%sIPv4 prefix: bad bit length %u",
1670                    ident,
1671                    bit_length);
1672             return (0);
1673         }
1674         processed++;
1675 #ifdef INET6
1676     } else if (afi == AF_INET6) {
1677         if (!TTEST2(*tptr, 1)) /* fetch status & prefix_len byte */
1678             return (0);
1679         status_byte=*(tptr++);
1680         bit_length=*(tptr++);
1681         if (bit_length > 128) {
1682             printf("%sIPv6 prefix: bad bit length %u",
1683                    ident,
1684                    bit_length);
1685             return (0);
1686         }
1687         processed+=2;
1688 #endif
1689     } else
1690         return (0); /* somebody is fooling us */
1691 
1692     byte_length = (bit_length + 7) / 8; /* prefix has variable length encoding */
1693 
1694     if (!TTEST2(*tptr, byte_length))
1695         return (0);
1696     memset(prefix, 0, sizeof prefix);   /* clear the copy buffer */
1697     memcpy(prefix,tptr,byte_length);    /* copy as much as is stored in the TLV */
1698     tptr+=byte_length;
1699     processed+=byte_length;
1700 
1701     if (afi == AF_INET)
1702         printf("%sIPv4 prefix: %15s/%u",
1703                ident,
1704                ipaddr_string(prefix),
1705                bit_length);
1706 #ifdef INET6
1707     if (afi == AF_INET6)
1708         printf("%sIPv6 prefix: %s/%u",
1709                ident,
1710                ip6addr_string(prefix),
1711                bit_length);
1712 #endif
1713 
1714     printf(", Distribution: %s, Metric: %u",
1715            ISIS_MASK_TLV_EXTD_IP_UPDOWN(status_byte) ? "down" : "up",
1716            metric);
1717 
1718     if (afi == AF_INET && ISIS_MASK_TLV_EXTD_IP_SUBTLV(status_byte))
1719         printf(", sub-TLVs present");
1720 #ifdef INET6
1721     if (afi == AF_INET6)
1722         printf(", %s%s",
1723                ISIS_MASK_TLV_EXTD_IP6_IE(status_byte) ? "External" : "Internal",
1724                ISIS_MASK_TLV_EXTD_IP6_SUBTLV(status_byte) ? ", sub-TLVs present" : "");
1725 #endif
1726 
1727     if ((afi == AF_INET  && ISIS_MASK_TLV_EXTD_IP_SUBTLV(status_byte))
1728 #ifdef INET6
1729      || (afi == AF_INET6 && ISIS_MASK_TLV_EXTD_IP6_SUBTLV(status_byte))
1730 #endif
1731 	) {
1732         /* assume that one prefix can hold more
1733            than one subTLV - therefore the first byte must reflect
1734            the aggregate bytecount of the subTLVs for this prefix
1735         */
1736         if (!TTEST2(*tptr, 1))
1737             return (0);
1738         sublen=*(tptr++);
1739         processed+=sublen+1;
1740         printf(" (%u)",sublen);   /* print out subTLV length */
1741 
1742         while (sublen>0) {
1743             if (!TTEST2(*tptr,2))
1744                 return (0);
1745             subtlvtype=*(tptr++);
1746             subtlvlen=*(tptr++);
1747             /* prepend the ident string */
1748             snprintf(ident_buffer, sizeof(ident_buffer), "%s  ",ident);
1749             if(!isis_print_ip_reach_subtlv(tptr,subtlvtype,subtlvlen,ident_buffer))
1750                 return(0);
1751             tptr+=subtlvlen;
1752             sublen-=(subtlvlen+2);
1753         }
1754     }
1755     return (processed);
1756 }
1757 
1758 /*
1759  * isis_print
1760  * Decode IS-IS packets.  Return 0 on error.
1761  */
1762 
1763 static int isis_print (const u_int8_t *p, u_int length)
1764 {
1765     const struct isis_common_header *isis_header;
1766 
1767     const struct isis_iih_lan_header *header_iih_lan;
1768     const struct isis_iih_ptp_header *header_iih_ptp;
1769     const struct isis_lsp_header *header_lsp;
1770     const struct isis_csnp_header *header_csnp;
1771     const struct isis_psnp_header *header_psnp;
1772 
1773     const struct isis_tlv_lsp *tlv_lsp;
1774     const struct isis_tlv_ptp_adj *tlv_ptp_adj;
1775     const struct isis_tlv_is_reach *tlv_is_reach;
1776     const struct isis_tlv_es_reach *tlv_es_reach;
1777 
1778     u_int8_t pdu_type, max_area, id_length, tlv_type, tlv_len, tmp, alen, lan_alen, prefix_len;
1779     u_int8_t ext_is_len, ext_ip_len, mt_len;
1780     const u_int8_t *optr, *pptr, *tptr;
1781     u_short packet_len,pdu_len;
1782     u_int i,vendor_id;
1783 
1784     packet_len=length;
1785     optr = p; /* initialize the _o_riginal pointer to the packet start -
1786                  need it for parsing the checksum TLV */
1787     isis_header = (const struct isis_common_header *)p;
1788     TCHECK(*isis_header);
1789     pptr = p+(ISIS_COMMON_HEADER_SIZE);
1790     header_iih_lan = (const struct isis_iih_lan_header *)pptr;
1791     header_iih_ptp = (const struct isis_iih_ptp_header *)pptr;
1792     header_lsp = (const struct isis_lsp_header *)pptr;
1793     header_csnp = (const struct isis_csnp_header *)pptr;
1794     header_psnp = (const struct isis_psnp_header *)pptr;
1795 
1796     if (!eflag)
1797         printf("IS-IS");
1798 
1799     /*
1800      * Sanity checking of the header.
1801      */
1802 
1803     if (isis_header->version != ISIS_VERSION) {
1804 	printf("version %d packet not supported", isis_header->version);
1805 	return (0);
1806     }
1807 
1808     if ((isis_header->id_length != SYSTEM_ID_LEN) && (isis_header->id_length != 0)) {
1809 	printf("system ID length of %d is not supported",
1810 	       isis_header->id_length);
1811 	return (0);
1812     }
1813 
1814     if (isis_header->pdu_version != ISIS_VERSION) {
1815 	printf("version %d packet not supported", isis_header->pdu_version);
1816 	return (0);
1817     }
1818 
1819     max_area = isis_header->max_area;
1820     switch(max_area) {
1821     case 0:
1822 	max_area = 3;	 /* silly shit */
1823 	break;
1824     case 255:
1825 	printf("bad packet -- 255 areas");
1826 	return (0);
1827     default:
1828 	break;
1829     }
1830 
1831     id_length = isis_header->id_length;
1832     switch(id_length) {
1833     case 0:
1834         id_length = 6;	 /* silly shit again */
1835 	break;
1836     case 1:              /* 1-8 are valid sys-ID lenghts */
1837     case 2:
1838     case 3:
1839     case 4:
1840     case 5:
1841     case 6:
1842     case 7:
1843     case 8:
1844         break;
1845     case 255:
1846         id_length = 0;   /* entirely useless */
1847 	break;
1848     default:
1849         break;
1850     }
1851 
1852     /* toss any non 6-byte sys-ID len PDUs */
1853     if (id_length != 6 ) {
1854 	printf("bad packet -- illegal sys-ID length (%u)", id_length);
1855 	return (0);
1856     }
1857 
1858     pdu_type=isis_header->pdu_type;
1859 
1860     /* in non-verbose mode print the basic PDU Type plus PDU specific brief information*/
1861     if (vflag < 1) {
1862         printf("%s%s",
1863                eflag ? "" : ", ",
1864                tok2str(isis_pdu_values,"unknown PDU-Type %u",pdu_type));
1865 
1866 	switch (pdu_type) {
1867 
1868 	case ISIS_PDU_L1_LAN_IIH:
1869 	case ISIS_PDU_L2_LAN_IIH:
1870 	    printf(", src-id %s",
1871                    isis_print_id(header_iih_lan->source_id,SYSTEM_ID_LEN));
1872 	    printf(", lan-id %s, prio %u",
1873                    isis_print_id(header_iih_lan->lan_id,NODE_ID_LEN),
1874                    header_iih_lan->priority);
1875 	    break;
1876 	case ISIS_PDU_PTP_IIH:
1877 	    printf(", src-id %s", isis_print_id(header_iih_ptp->source_id,SYSTEM_ID_LEN));
1878 	    break;
1879 	case ISIS_PDU_L1_LSP:
1880 	case ISIS_PDU_L2_LSP:
1881 	    printf(", lsp-id %s, seq 0x%08x, lifetime %5us",
1882 		   isis_print_id(header_lsp->lsp_id, LSP_ID_LEN),
1883 		   EXTRACT_32BITS(header_lsp->sequence_number),
1884 		   EXTRACT_16BITS(header_lsp->remaining_lifetime));
1885 	    break;
1886 	case ISIS_PDU_L1_CSNP:
1887 	case ISIS_PDU_L2_CSNP:
1888 	    printf(", src-id %s", isis_print_id(header_csnp->source_id,NODE_ID_LEN));
1889 	    break;
1890 	case ISIS_PDU_L1_PSNP:
1891 	case ISIS_PDU_L2_PSNP:
1892 	    printf(", src-id %s", isis_print_id(header_psnp->source_id,NODE_ID_LEN));
1893 	    break;
1894 
1895 	}
1896 	printf(", length %u", length);
1897 
1898         return(1);
1899     }
1900 
1901     /* ok they seem to want to know everything - lets fully decode it */
1902     printf("%slength %u", eflag ? "" : ", ",length);
1903 
1904     printf("\n\t%s, hlen: %u, v: %u, pdu-v: %u, sys-id-len: %u (%u), max-area: %u (%u)",
1905            tok2str(isis_pdu_values,
1906                    "unknown, type %u",
1907                    pdu_type),
1908            isis_header->fixed_len,
1909            isis_header->version,
1910            isis_header->pdu_version,
1911 	   id_length,
1912 	   isis_header->id_length,
1913            max_area,
1914            isis_header->max_area);
1915 
1916     if (vflag > 1) {
1917         if(!print_unknown_data(optr,"\n\t",8)) /* provide the _o_riginal pointer */
1918             return(0);                         /* for optionally debugging the common header */
1919     }
1920 
1921     switch (pdu_type) {
1922 
1923     case ISIS_PDU_L1_LAN_IIH:
1924     case ISIS_PDU_L2_LAN_IIH:
1925 	if (isis_header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE)) {
1926 	    printf(", bogus fixed header length %u should be %lu",
1927 		   isis_header->fixed_len, (unsigned long)ISIS_IIH_LAN_HEADER_SIZE);
1928 	    return (0);
1929 	}
1930 
1931 	pdu_len=EXTRACT_16BITS(header_iih_lan->pdu_len);
1932 	if (packet_len>pdu_len) {
1933             packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
1934             length=pdu_len;
1935 	}
1936 
1937 	TCHECK(*header_iih_lan);
1938 	printf("\n\t  source-id: %s,  holding time: %us, Flags: [%s]",
1939                isis_print_id(header_iih_lan->source_id,SYSTEM_ID_LEN),
1940                EXTRACT_16BITS(header_iih_lan->holding_time),
1941                tok2str(isis_iih_circuit_type_values,
1942                        "unknown circuit type 0x%02x",
1943                        header_iih_lan->circuit_type));
1944 
1945 	printf("\n\t  lan-id:    %s, Priority: %u, PDU length: %u",
1946                isis_print_id(header_iih_lan->lan_id, NODE_ID_LEN),
1947                (header_iih_lan->priority) & ISIS_LAN_PRIORITY_MASK,
1948                pdu_len);
1949 
1950         if (vflag > 1) {
1951             if(!print_unknown_data(pptr,"\n\t  ",ISIS_IIH_LAN_HEADER_SIZE))
1952                 return(0);
1953         }
1954 
1955 	packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE);
1956 	pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_LAN_HEADER_SIZE);
1957 	break;
1958 
1959     case ISIS_PDU_PTP_IIH:
1960 	if (isis_header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_PTP_HEADER_SIZE)) {
1961 	    printf(", bogus fixed header length %u should be %lu",
1962 		   isis_header->fixed_len, (unsigned long)ISIS_IIH_PTP_HEADER_SIZE);
1963 	    return (0);
1964 	}
1965 
1966 	pdu_len=EXTRACT_16BITS(header_iih_ptp->pdu_len);
1967 	if (packet_len>pdu_len) {
1968             packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
1969             length=pdu_len;
1970 	}
1971 
1972 	TCHECK(*header_iih_ptp);
1973 	printf("\n\t  source-id: %s, holding time: %us, Flags: [%s]",
1974                isis_print_id(header_iih_ptp->source_id,SYSTEM_ID_LEN),
1975                EXTRACT_16BITS(header_iih_ptp->holding_time),
1976                tok2str(isis_iih_circuit_type_values,
1977                        "unknown circuit type 0x%02x",
1978                        header_iih_ptp->circuit_type));
1979 
1980 	printf("\n\t  circuit-id: 0x%02x, PDU length: %u",
1981                header_iih_ptp->circuit_id,
1982                pdu_len);
1983 
1984         if (vflag > 1) {
1985             if(!print_unknown_data(pptr,"\n\t  ",ISIS_IIH_PTP_HEADER_SIZE))
1986                 return(0);
1987         }
1988 
1989 	packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_PTP_HEADER_SIZE);
1990 	pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_IIH_PTP_HEADER_SIZE);
1991 	break;
1992 
1993     case ISIS_PDU_L1_LSP:
1994     case ISIS_PDU_L2_LSP:
1995 	if (isis_header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_LSP_HEADER_SIZE)) {
1996 	    printf(", bogus fixed header length %u should be %lu",
1997 		   isis_header->fixed_len, (unsigned long)ISIS_LSP_HEADER_SIZE);
1998 	    return (0);
1999 	}
2000 
2001 	pdu_len=EXTRACT_16BITS(header_lsp->pdu_len);
2002 	if (packet_len>pdu_len) {
2003             packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
2004             length=pdu_len;
2005 	}
2006 
2007 	TCHECK(*header_lsp);
2008 	printf("\n\t  lsp-id: %s, seq: 0x%08x, lifetime: %5us\n\t  chksum: 0x%04x",
2009                isis_print_id(header_lsp->lsp_id, LSP_ID_LEN),
2010                EXTRACT_32BITS(header_lsp->sequence_number),
2011                EXTRACT_16BITS(header_lsp->remaining_lifetime),
2012                EXTRACT_16BITS(header_lsp->checksum));
2013 
2014 
2015         osi_print_cksum((u_int8_t *)header_lsp->lsp_id,
2016                         EXTRACT_16BITS(header_lsp->checksum), 12, length-12);
2017 
2018 	printf(", PDU length: %u, Flags: [ %s",
2019                pdu_len,
2020                ISIS_MASK_LSP_OL_BIT(header_lsp->typeblock) ? "Overload bit set, " : "");
2021 
2022 	if (ISIS_MASK_LSP_ATT_BITS(header_lsp->typeblock)) {
2023 	    printf("%s", ISIS_MASK_LSP_ATT_DEFAULT_BIT(header_lsp->typeblock) ? "default " : "");
2024 	    printf("%s", ISIS_MASK_LSP_ATT_DELAY_BIT(header_lsp->typeblock) ? "delay " : "");
2025 	    printf("%s", ISIS_MASK_LSP_ATT_EXPENSE_BIT(header_lsp->typeblock) ? "expense " : "");
2026 	    printf("%s", ISIS_MASK_LSP_ATT_ERROR_BIT(header_lsp->typeblock) ? "error " : "");
2027 	    printf("ATT bit set, ");
2028 	}
2029 	printf("%s", ISIS_MASK_LSP_PARTITION_BIT(header_lsp->typeblock) ? "P bit set, " : "");
2030 	printf("%s ]", tok2str(isis_lsp_istype_values,"Unknown(0x%x)",ISIS_MASK_LSP_ISTYPE_BITS(header_lsp->typeblock)));
2031 
2032         if (vflag > 1) {
2033             if(!print_unknown_data(pptr,"\n\t  ",ISIS_LSP_HEADER_SIZE))
2034                 return(0);
2035         }
2036 
2037 	packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_LSP_HEADER_SIZE);
2038 	pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_LSP_HEADER_SIZE);
2039 	break;
2040 
2041     case ISIS_PDU_L1_CSNP:
2042     case ISIS_PDU_L2_CSNP:
2043 	if (isis_header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_CSNP_HEADER_SIZE)) {
2044 	    printf(", bogus fixed header length %u should be %lu",
2045 		   isis_header->fixed_len, (unsigned long)ISIS_CSNP_HEADER_SIZE);
2046 	    return (0);
2047 	}
2048 
2049 	pdu_len=EXTRACT_16BITS(header_csnp->pdu_len);
2050 	if (packet_len>pdu_len) {
2051             packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
2052             length=pdu_len;
2053 	}
2054 
2055 	TCHECK(*header_csnp);
2056 	printf("\n\t  source-id:    %s, PDU length: %u",
2057                isis_print_id(header_csnp->source_id, NODE_ID_LEN),
2058                pdu_len);
2059 	printf("\n\t  start lsp-id: %s",
2060                isis_print_id(header_csnp->start_lsp_id, LSP_ID_LEN));
2061 	printf("\n\t  end lsp-id:   %s",
2062                isis_print_id(header_csnp->end_lsp_id, LSP_ID_LEN));
2063 
2064         if (vflag > 1) {
2065             if(!print_unknown_data(pptr,"\n\t  ",ISIS_CSNP_HEADER_SIZE))
2066                 return(0);
2067         }
2068 
2069 	packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_CSNP_HEADER_SIZE);
2070 	pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_CSNP_HEADER_SIZE);
2071         break;
2072 
2073     case ISIS_PDU_L1_PSNP:
2074     case ISIS_PDU_L2_PSNP:
2075 	if (isis_header->fixed_len != (ISIS_COMMON_HEADER_SIZE+ISIS_PSNP_HEADER_SIZE)) {
2076 	    printf("- bogus fixed header length %u should be %lu",
2077 		   isis_header->fixed_len, (unsigned long)ISIS_PSNP_HEADER_SIZE);
2078 	    return (0);
2079 	}
2080 
2081 	pdu_len=EXTRACT_16BITS(header_psnp->pdu_len);
2082 	if (packet_len>pdu_len) {
2083             packet_len=pdu_len; /* do TLV decoding as long as it makes sense */
2084             length=pdu_len;
2085 	}
2086 
2087 	TCHECK(*header_psnp);
2088 	printf("\n\t  source-id:    %s, PDU length: %u",
2089                isis_print_id(header_psnp->source_id, NODE_ID_LEN),
2090                pdu_len);
2091 
2092         if (vflag > 1) {
2093             if(!print_unknown_data(pptr,"\n\t  ",ISIS_PSNP_HEADER_SIZE))
2094                 return(0);
2095         }
2096 
2097 	packet_len -= (ISIS_COMMON_HEADER_SIZE+ISIS_PSNP_HEADER_SIZE);
2098 	pptr = p + (ISIS_COMMON_HEADER_SIZE+ISIS_PSNP_HEADER_SIZE);
2099 	break;
2100 
2101     default:
2102 	if(!print_unknown_data(pptr,"\n\t  ",length))
2103 	    return(0);
2104 	return (0);
2105     }
2106 
2107     /*
2108      * Now print the TLV's.
2109      */
2110 
2111     while (packet_len >= 2) {
2112         if (pptr == snapend) {
2113 	    return (1);
2114         }
2115 
2116 	if (!TTEST2(*pptr, 2)) {
2117 	    printf("\n\t\t packet exceeded snapshot (%ld) bytes",
2118                    (long)(pptr-snapend));
2119 	    return (1);
2120 	}
2121 	tlv_type = *pptr++;
2122 	tlv_len = *pptr++;
2123         tmp =tlv_len; /* copy temporary len & pointer to packet data */
2124         tptr = pptr;
2125 	packet_len -= 2;
2126 	if (tlv_len > packet_len) {
2127 	    break;
2128 	}
2129 
2130         /* first lets see if we know the TLVs name*/
2131 	printf("\n\t    %s TLV #%u, length: %u",
2132                tok2str(isis_tlv_values,
2133                        "unknown",
2134                        tlv_type),
2135                tlv_type,
2136                tlv_len);
2137 
2138         if (tlv_len == 0) /* something is malformed */
2139 	    continue;
2140 
2141         /* now check if we have a decoder otherwise do a hexdump at the end*/
2142 	switch (tlv_type) {
2143 	case ISIS_TLV_AREA_ADDR:
2144 	    if (!TTEST2(*tptr, 1))
2145 		goto trunctlv;
2146 	    alen = *tptr++;
2147 	    while (tmp && alen < tmp) {
2148 		printf("\n\t      Area address (length: %u): %s",
2149                        alen,
2150                        isonsap_string(tptr,alen));
2151 		tptr += alen;
2152 		tmp -= alen + 1;
2153 		if (tmp==0) /* if this is the last area address do not attemt a boundary check */
2154                     break;
2155 		if (!TTEST2(*tptr, 1))
2156 		    goto trunctlv;
2157 		alen = *tptr++;
2158 	    }
2159 	    break;
2160 	case ISIS_TLV_ISNEIGH:
2161 	    while (tmp >= ETHER_ADDR_LEN) {
2162                 if (!TTEST2(*tptr, ETHER_ADDR_LEN))
2163                     goto trunctlv;
2164                 printf("\n\t      SNPA: %s",isis_print_id(tptr,ETHER_ADDR_LEN));
2165                 tmp -= ETHER_ADDR_LEN;
2166                 tptr += ETHER_ADDR_LEN;
2167 	    }
2168 	    break;
2169 
2170         case ISIS_TLV_ISNEIGH_VARLEN:
2171             if (!TTEST2(*tptr, 1) || tmp < 3) /* min. TLV length */
2172 		goto trunctlv;
2173 	    lan_alen = *tptr++; /* LAN address length */
2174 	    if (lan_alen == 0) {
2175                 printf("\n\t      LAN address length 0 bytes (invalid)");
2176                 break;
2177             }
2178             tmp --;
2179             printf("\n\t      LAN address length %u bytes ",lan_alen);
2180 	    while (tmp >= lan_alen) {
2181                 if (!TTEST2(*tptr, lan_alen))
2182                     goto trunctlv;
2183                 printf("\n\t\tIS Neighbor: %s",isis_print_id(tptr,lan_alen));
2184                 tmp -= lan_alen;
2185                 tptr +=lan_alen;
2186             }
2187             break;
2188 
2189 	case ISIS_TLV_PADDING:
2190 	    break;
2191 
2192         case ISIS_TLV_MT_IS_REACH:
2193             while (tmp >= 2+NODE_ID_LEN+3+1) {
2194                 mt_len = isis_print_mtid(tptr, "\n\t      ");
2195                 if (mt_len == 0) /* did something go wrong ? */
2196                     goto trunctlv;
2197                 tptr+=mt_len;
2198                 tmp-=mt_len;
2199 
2200                 ext_is_len = isis_print_ext_is_reach(tptr,"\n\t      ",tlv_type);
2201                 if (ext_is_len == 0) /* did something go wrong ? */
2202                     goto trunctlv;
2203 
2204                 tmp-=ext_is_len;
2205                 tptr+=ext_is_len;
2206             }
2207             break;
2208 
2209         case ISIS_TLV_IS_ALIAS_ID:
2210 	    while (tmp >= NODE_ID_LEN+1) { /* is it worth attempting a decode ? */
2211 	        ext_is_len = isis_print_ext_is_reach(tptr,"\n\t      ",tlv_type);
2212 		if (ext_is_len == 0) /* did something go wrong ? */
2213 	            goto trunctlv;
2214 		tmp-=ext_is_len;
2215 		tptr+=ext_is_len;
2216 	    }
2217 	    break;
2218 
2219         case ISIS_TLV_EXT_IS_REACH:
2220             while (tmp >= NODE_ID_LEN+3+1) { /* is it worth attempting a decode ? */
2221                 ext_is_len = isis_print_ext_is_reach(tptr,"\n\t      ",tlv_type);
2222                 if (ext_is_len == 0) /* did something go wrong ? */
2223                     goto trunctlv;
2224                 tmp-=ext_is_len;
2225                 tptr+=ext_is_len;
2226             }
2227             break;
2228         case ISIS_TLV_IS_REACH:
2229 	    if (!TTEST2(*tptr,1))  /* check if there is one byte left to read out the virtual flag */
2230                 goto trunctlv;
2231             printf("\n\t      %s",
2232                    tok2str(isis_is_reach_virtual_values,
2233                            "bogus virtual flag 0x%02x",
2234                            *tptr++));
2235 	    tlv_is_reach = (const struct isis_tlv_is_reach *)tptr;
2236             while (tmp >= sizeof(struct isis_tlv_is_reach)) {
2237 		if (!TTEST(*tlv_is_reach))
2238 		    goto trunctlv;
2239 		printf("\n\t      IS Neighbor: %s",
2240 		       isis_print_id(tlv_is_reach->neighbor_nodeid, NODE_ID_LEN));
2241                 isis_print_metric_block(&tlv_is_reach->isis_metric_block);
2242 		tmp -= sizeof(struct isis_tlv_is_reach);
2243 		tlv_is_reach++;
2244 	    }
2245             break;
2246 
2247         case ISIS_TLV_ESNEIGH:
2248 	    tlv_es_reach = (const struct isis_tlv_es_reach *)tptr;
2249             while (tmp >= sizeof(struct isis_tlv_es_reach)) {
2250 		if (!TTEST(*tlv_es_reach))
2251 		    goto trunctlv;
2252 		printf("\n\t      ES Neighbor: %s",
2253                        isis_print_id(tlv_es_reach->neighbor_sysid,SYSTEM_ID_LEN));
2254                 isis_print_metric_block(&tlv_es_reach->isis_metric_block);
2255 		tmp -= sizeof(struct isis_tlv_es_reach);
2256 		tlv_es_reach++;
2257 	    }
2258             break;
2259 
2260             /* those two TLVs share the same format */
2261 	case ISIS_TLV_INT_IP_REACH:
2262 	case ISIS_TLV_EXT_IP_REACH:
2263 	    if (!isis_print_tlv_ip_reach(pptr, "\n\t      ", tlv_len))
2264 		return (1);
2265 	    break;
2266 
2267 	case ISIS_TLV_EXTD_IP_REACH:
2268 	    while (tmp>0) {
2269                 ext_ip_len = isis_print_extd_ip_reach(tptr, "\n\t      ", AF_INET);
2270                 if (ext_ip_len == 0) /* did something go wrong ? */
2271                     goto trunctlv;
2272                 tptr+=ext_ip_len;
2273 		tmp-=ext_ip_len;
2274 	    }
2275 	    break;
2276 
2277         case ISIS_TLV_MT_IP_REACH:
2278             mt_len = isis_print_mtid(tptr, "\n\t      ");
2279             if (mt_len == 0) { /* did something go wrong ? */
2280                 goto trunctlv;
2281             }
2282             tptr+=mt_len;
2283             tmp-=mt_len;
2284 
2285             while (tmp>0) {
2286                 ext_ip_len = isis_print_extd_ip_reach(tptr, "\n\t      ", AF_INET);
2287                 if (ext_ip_len == 0) /* did something go wrong ? */
2288                     goto trunctlv;
2289                 tptr+=ext_ip_len;
2290 		tmp-=ext_ip_len;
2291 	    }
2292 	    break;
2293 
2294 #ifdef INET6
2295 	case ISIS_TLV_IP6_REACH:
2296 	    while (tmp>0) {
2297                 ext_ip_len = isis_print_extd_ip_reach(tptr, "\n\t      ", AF_INET6);
2298                 if (ext_ip_len == 0) /* did something go wrong ? */
2299                     goto trunctlv;
2300                 tptr+=ext_ip_len;
2301 		tmp-=ext_ip_len;
2302 	    }
2303 	    break;
2304 
2305 	case ISIS_TLV_MT_IP6_REACH:
2306             mt_len = isis_print_mtid(tptr, "\n\t      ");
2307             if (mt_len == 0) { /* did something go wrong ? */
2308                 goto trunctlv;
2309             }
2310             tptr+=mt_len;
2311             tmp-=mt_len;
2312 
2313 	    while (tmp>0) {
2314                 ext_ip_len = isis_print_extd_ip_reach(tptr, "\n\t      ", AF_INET6);
2315                 if (ext_ip_len == 0) /* did something go wrong ? */
2316                     goto trunctlv;
2317                 tptr+=ext_ip_len;
2318 		tmp-=ext_ip_len;
2319 	    }
2320 	    break;
2321 
2322 	case ISIS_TLV_IP6ADDR:
2323 	    while (tmp>=sizeof(struct in6_addr)) {
2324 		if (!TTEST2(*tptr, sizeof(struct in6_addr)))
2325 		    goto trunctlv;
2326 
2327                 printf("\n\t      IPv6 interface address: %s",
2328 		       ip6addr_string(tptr));
2329 
2330 		tptr += sizeof(struct in6_addr);
2331 		tmp -= sizeof(struct in6_addr);
2332 	    }
2333 	    break;
2334 #endif
2335 	case ISIS_TLV_AUTH:
2336 	    if (!TTEST2(*tptr, 1))
2337 		goto trunctlv;
2338 
2339             printf("\n\t      %s: ",
2340                    tok2str(isis_subtlv_auth_values,
2341                            "unknown Authentication type 0x%02x",
2342                            *tptr));
2343 
2344 	    switch (*tptr) {
2345 	    case ISIS_SUBTLV_AUTH_SIMPLE:
2346 		for(i=1;i<tlv_len;i++) {
2347 		    if (!TTEST2(*(tptr+i), 1))
2348 			goto trunctlv;
2349 		    printf("%c",*(tptr+i));
2350 		}
2351 		break;
2352 	    case ISIS_SUBTLV_AUTH_MD5:
2353 		for(i=1;i<tlv_len;i++) {
2354 		    if (!TTEST2(*(tptr+i), 1))
2355 			goto trunctlv;
2356 		    printf("%02x",*(tptr+i));
2357 		}
2358 		if (tlv_len != ISIS_SUBTLV_AUTH_MD5_LEN+1)
2359                     printf(", (malformed subTLV) ");
2360 		break;
2361 	    case ISIS_SUBTLV_AUTH_PRIVATE:
2362 	    default:
2363 		if(!print_unknown_data(tptr+1,"\n\t\t  ",tlv_len-1))
2364 		    return(0);
2365 		break;
2366 	    }
2367 	    break;
2368 
2369 	case ISIS_TLV_PTP_ADJ:
2370 	    tlv_ptp_adj = (const struct isis_tlv_ptp_adj *)tptr;
2371 	    if(tmp>=1) {
2372 		if (!TTEST2(*tptr, 1))
2373 		    goto trunctlv;
2374 		printf("\n\t      Adjacency State: %s (%u)",
2375 		       tok2str(isis_ptp_adjancey_values, "unknown", *tptr),
2376                         *tptr);
2377 		tmp--;
2378 	    }
2379 	    if(tmp>sizeof(tlv_ptp_adj->extd_local_circuit_id)) {
2380 		if (!TTEST2(tlv_ptp_adj->extd_local_circuit_id,
2381                             sizeof(tlv_ptp_adj->extd_local_circuit_id)))
2382 		    goto trunctlv;
2383 		printf("\n\t      Extended Local circuit-ID: 0x%08x",
2384 		       EXTRACT_32BITS(tlv_ptp_adj->extd_local_circuit_id));
2385 		tmp-=sizeof(tlv_ptp_adj->extd_local_circuit_id);
2386 	    }
2387 	    if(tmp>=SYSTEM_ID_LEN) {
2388 		if (!TTEST2(tlv_ptp_adj->neighbor_sysid, SYSTEM_ID_LEN))
2389 		    goto trunctlv;
2390 		printf("\n\t      Neighbor System-ID: %s",
2391 		       isis_print_id(tlv_ptp_adj->neighbor_sysid,SYSTEM_ID_LEN));
2392 		tmp-=SYSTEM_ID_LEN;
2393 	    }
2394 	    if(tmp>=sizeof(tlv_ptp_adj->neighbor_extd_local_circuit_id)) {
2395 		if (!TTEST2(tlv_ptp_adj->neighbor_extd_local_circuit_id,
2396                             sizeof(tlv_ptp_adj->neighbor_extd_local_circuit_id)))
2397 		    goto trunctlv;
2398 		printf("\n\t      Neighbor Extended Local circuit-ID: 0x%08x",
2399 		       EXTRACT_32BITS(tlv_ptp_adj->neighbor_extd_local_circuit_id));
2400 	    }
2401 	    break;
2402 
2403 	case ISIS_TLV_PROTOCOLS:
2404 	    printf("\n\t      NLPID(s): ");
2405 	    while (tmp>0) {
2406 		if (!TTEST2(*(tptr), 1))
2407 		    goto trunctlv;
2408 		printf("%s (0x%02x)",
2409                        tok2str(nlpid_values,
2410                                "unknown",
2411                                *tptr),
2412                        *tptr);
2413 		if (tmp>1) /* further NPLIDs ? - put comma */
2414 		    printf(", ");
2415                 tptr++;
2416                 tmp--;
2417 	    }
2418 	    break;
2419 
2420 	case ISIS_TLV_TE_ROUTER_ID:
2421 	    if (!TTEST2(*pptr, sizeof(struct in_addr)))
2422 		goto trunctlv;
2423 	    printf("\n\t      Traffic Engineering Router ID: %s", ipaddr_string(pptr));
2424 	    break;
2425 
2426 	case ISIS_TLV_IPADDR:
2427 	    while (tmp>=sizeof(struct in_addr)) {
2428 		if (!TTEST2(*tptr, sizeof(struct in_addr)))
2429 		    goto trunctlv;
2430 		printf("\n\t      IPv4 interface address: %s", ipaddr_string(tptr));
2431 		tptr += sizeof(struct in_addr);
2432 		tmp -= sizeof(struct in_addr);
2433 	    }
2434 	    break;
2435 
2436 	case ISIS_TLV_HOSTNAME:
2437 	    printf("\n\t      Hostname: ");
2438 	    while (tmp>0) {
2439 		if (!TTEST2(*tptr, 1))
2440 		    goto trunctlv;
2441 		printf("%c",*tptr++);
2442                 tmp--;
2443 	    }
2444 	    break;
2445 
2446 	case ISIS_TLV_SHARED_RISK_GROUP:
2447 	    if (tmp < NODE_ID_LEN)
2448 	        break;
2449 	    if (!TTEST2(*tptr, NODE_ID_LEN))
2450                 goto trunctlv;
2451 	    printf("\n\t      IS Neighbor: %s", isis_print_id(tptr, NODE_ID_LEN));
2452 	    tptr+=(NODE_ID_LEN);
2453 	    tmp-=(NODE_ID_LEN);
2454 
2455 	    if (tmp < 1)
2456 	        break;
2457 	    if (!TTEST2(*tptr, 1))
2458                 goto trunctlv;
2459 	    printf(", Flags: [%s]", ISIS_MASK_TLV_SHARED_RISK_GROUP(*tptr++) ? "numbered" : "unnumbered");
2460 	    tmp--;
2461 
2462 	    if (tmp < sizeof(struct in_addr))
2463 	        break;
2464 	    if (!TTEST2(*tptr,sizeof(struct in_addr)))
2465                 goto trunctlv;
2466 	    printf("\n\t      IPv4 interface address: %s", ipaddr_string(tptr));
2467 	    tptr+=sizeof(struct in_addr);
2468 	    tmp-=sizeof(struct in_addr);
2469 
2470 	    if (tmp < sizeof(struct in_addr))
2471 	        break;
2472 	    if (!TTEST2(*tptr,sizeof(struct in_addr)))
2473                 goto trunctlv;
2474 	    printf("\n\t      IPv4 neighbor address: %s", ipaddr_string(tptr));
2475 	    tptr+=sizeof(struct in_addr);
2476 	    tmp-=sizeof(struct in_addr);
2477 
2478 	    while (tmp>=4) {
2479                 if (!TTEST2(*tptr, 4))
2480                     goto trunctlv;
2481                 printf("\n\t      Link-ID: 0x%08x", EXTRACT_32BITS(tptr));
2482                 tptr+=4;
2483                 tmp-=4;
2484 	    }
2485 	    break;
2486 
2487 	case ISIS_TLV_LSP:
2488 	    tlv_lsp = (const struct isis_tlv_lsp *)tptr;
2489 	    while(tmp>=sizeof(struct isis_tlv_lsp)) {
2490 		if (!TTEST((tlv_lsp->lsp_id)[LSP_ID_LEN-1]))
2491 		    goto trunctlv;
2492 		printf("\n\t      lsp-id: %s",
2493                        isis_print_id(tlv_lsp->lsp_id, LSP_ID_LEN));
2494 		if (!TTEST2(tlv_lsp->sequence_number, 4))
2495 		    goto trunctlv;
2496 		printf(", seq: 0x%08x",EXTRACT_32BITS(tlv_lsp->sequence_number));
2497 		if (!TTEST2(tlv_lsp->remaining_lifetime, 2))
2498 		    goto trunctlv;
2499 		printf(", lifetime: %5ds",EXTRACT_16BITS(tlv_lsp->remaining_lifetime));
2500 		if (!TTEST2(tlv_lsp->checksum, 2))
2501 		    goto trunctlv;
2502 		printf(", chksum: 0x%04x",EXTRACT_16BITS(tlv_lsp->checksum));
2503 		tmp-=sizeof(struct isis_tlv_lsp);
2504 		tlv_lsp++;
2505 	    }
2506 	    break;
2507 
2508 	case ISIS_TLV_CHECKSUM:
2509 	    if (tmp < ISIS_TLV_CHECKSUM_MINLEN)
2510 	        break;
2511 	    if (!TTEST2(*tptr, ISIS_TLV_CHECKSUM_MINLEN))
2512 		goto trunctlv;
2513 	    printf("\n\t      checksum: 0x%04x ", EXTRACT_16BITS(tptr));
2514             /* do not attempt to verify the checksum if it is zero
2515              * most likely a HMAC-MD5 TLV is also present and
2516              * to avoid conflicts the checksum TLV is zeroed.
2517              * see rfc3358 for details
2518              */
2519             osi_print_cksum(optr, EXTRACT_16BITS(tptr), tptr-optr, length);
2520 	    break;
2521 
2522 	case ISIS_TLV_MT_SUPPORTED:
2523             if (tmp < ISIS_TLV_MT_SUPPORTED_MINLEN)
2524                 break;
2525 	    while (tmp>1) {
2526 		/* length can only be a multiple of 2, otherwise there is
2527 		   something broken -> so decode down until length is 1 */
2528 		if (tmp!=1) {
2529                     mt_len = isis_print_mtid(tptr, "\n\t      ");
2530                     if (mt_len == 0) /* did something go wrong ? */
2531                         goto trunctlv;
2532                     tptr+=mt_len;
2533                     tmp-=mt_len;
2534 		} else {
2535 		    printf("\n\t      malformed MT-ID");
2536 		    break;
2537 		}
2538 	    }
2539 	    break;
2540 
2541 	case ISIS_TLV_RESTART_SIGNALING:
2542             /* first attempt to decode the flags */
2543             if (tmp < ISIS_TLV_RESTART_SIGNALING_FLAGLEN)
2544                 break;
2545             if (!TTEST2(*tptr, ISIS_TLV_RESTART_SIGNALING_FLAGLEN))
2546                 goto trunctlv;
2547             printf("\n\t      Flags [%s]",
2548                    bittok2str(isis_restart_flag_values, "none", *tptr));
2549             tptr+=ISIS_TLV_RESTART_SIGNALING_FLAGLEN;
2550             tmp-=ISIS_TLV_RESTART_SIGNALING_FLAGLEN;
2551 
2552             /* is there anything other than the flags field? */
2553             if (tmp == 0)
2554                 break;
2555 
2556             if (tmp < ISIS_TLV_RESTART_SIGNALING_HOLDTIMELEN)
2557                 break;
2558             if (!TTEST2(*tptr, ISIS_TLV_RESTART_SIGNALING_HOLDTIMELEN))
2559                 goto trunctlv;
2560 
2561             printf(", Remaining holding time %us", EXTRACT_16BITS(tptr));
2562             tptr+=ISIS_TLV_RESTART_SIGNALING_HOLDTIMELEN;
2563             tmp-=ISIS_TLV_RESTART_SIGNALING_HOLDTIMELEN;
2564 
2565             /* is there an additional sysid field present ?*/
2566             if (tmp == SYSTEM_ID_LEN) {
2567                     if (!TTEST2(*tptr, SYSTEM_ID_LEN))
2568                             goto trunctlv;
2569                     printf(", for %s",isis_print_id(tptr,SYSTEM_ID_LEN));
2570             }
2571 	    break;
2572 
2573         case ISIS_TLV_IDRP_INFO:
2574 	    if (tmp < ISIS_TLV_IDRP_INFO_MINLEN)
2575 	        break;
2576             if (!TTEST2(*tptr, ISIS_TLV_IDRP_INFO_MINLEN))
2577                 goto trunctlv;
2578             printf("\n\t      Inter-Domain Information Type: %s",
2579                    tok2str(isis_subtlv_idrp_values,
2580                            "Unknown (0x%02x)",
2581                            *tptr));
2582             switch (*tptr++) {
2583             case ISIS_SUBTLV_IDRP_ASN:
2584                 if (!TTEST2(*tptr, 2)) /* fetch AS number */
2585                     goto trunctlv;
2586                 printf("AS Number: %u",EXTRACT_16BITS(tptr));
2587                 break;
2588             case ISIS_SUBTLV_IDRP_LOCAL:
2589             case ISIS_SUBTLV_IDRP_RES:
2590             default:
2591                 if(!print_unknown_data(tptr,"\n\t      ",tlv_len-1))
2592                     return(0);
2593                 break;
2594             }
2595             break;
2596 
2597         case ISIS_TLV_LSP_BUFFERSIZE:
2598 	    if (tmp < ISIS_TLV_LSP_BUFFERSIZE_MINLEN)
2599 	        break;
2600             if (!TTEST2(*tptr, ISIS_TLV_LSP_BUFFERSIZE_MINLEN))
2601                 goto trunctlv;
2602             printf("\n\t      LSP Buffersize: %u",EXTRACT_16BITS(tptr));
2603             break;
2604 
2605         case ISIS_TLV_PART_DIS:
2606             while (tmp >= SYSTEM_ID_LEN) {
2607                 if (!TTEST2(*tptr, SYSTEM_ID_LEN))
2608                     goto trunctlv;
2609                 printf("\n\t      %s",isis_print_id(tptr,SYSTEM_ID_LEN));
2610                 tptr+=SYSTEM_ID_LEN;
2611                 tmp-=SYSTEM_ID_LEN;
2612             }
2613             break;
2614 
2615         case ISIS_TLV_PREFIX_NEIGH:
2616 	    if (tmp < sizeof(struct isis_metric_block))
2617 	        break;
2618             if (!TTEST2(*tptr, sizeof(struct isis_metric_block)))
2619                 goto trunctlv;
2620             printf("\n\t      Metric Block");
2621             isis_print_metric_block((const struct isis_metric_block *)tptr);
2622             tptr+=sizeof(struct isis_metric_block);
2623             tmp-=sizeof(struct isis_metric_block);
2624 
2625             while(tmp>0) {
2626                 if (!TTEST2(*tptr, 1))
2627                     goto trunctlv;
2628                 prefix_len=*tptr++; /* read out prefix length in semioctets*/
2629                 if (prefix_len < 2) {
2630                     printf("\n\t\tAddress: prefix length %u < 2", prefix_len);
2631                     break;
2632                 }
2633                 tmp--;
2634                 if (tmp < prefix_len/2)
2635                     break;
2636                 if (!TTEST2(*tptr, prefix_len/2))
2637                     goto trunctlv;
2638                 printf("\n\t\tAddress: %s/%u",
2639                        isonsap_string(tptr,prefix_len/2),
2640                        prefix_len*4);
2641                 tptr+=prefix_len/2;
2642                 tmp-=prefix_len/2;
2643             }
2644             break;
2645 
2646         case ISIS_TLV_IIH_SEQNR:
2647 	    if (tmp < ISIS_TLV_IIH_SEQNR_MINLEN)
2648 	        break;
2649             if (!TTEST2(*tptr, ISIS_TLV_IIH_SEQNR_MINLEN)) /* check if four bytes are on the wire */
2650                 goto trunctlv;
2651             printf("\n\t      Sequence number: %u", EXTRACT_32BITS(tptr) );
2652             break;
2653 
2654         case ISIS_TLV_VENDOR_PRIVATE:
2655 	    if (tmp < ISIS_TLV_VENDOR_PRIVATE_MINLEN)
2656 	        break;
2657             if (!TTEST2(*tptr, ISIS_TLV_VENDOR_PRIVATE_MINLEN)) /* check if enough byte for a full oui */
2658                 goto trunctlv;
2659             vendor_id = EXTRACT_24BITS(tptr);
2660             printf("\n\t      Vendor: %s (%u)",
2661                    tok2str(oui_values,"Unknown",vendor_id),
2662                    vendor_id);
2663             tptr+=3;
2664             tmp-=3;
2665             if (tmp > 0) /* hexdump the rest */
2666                 if(!print_unknown_data(tptr,"\n\t\t",tmp))
2667                     return(0);
2668             break;
2669             /*
2670              * FIXME those are the defined TLVs that lack a decoder
2671              * you are welcome to contribute code ;-)
2672              */
2673 
2674         case ISIS_TLV_DECNET_PHASE4:
2675         case ISIS_TLV_LUCENT_PRIVATE:
2676         case ISIS_TLV_IPAUTH:
2677         case ISIS_TLV_NORTEL_PRIVATE1:
2678         case ISIS_TLV_NORTEL_PRIVATE2:
2679 
2680 	default:
2681             if (vflag <= 1) {
2682                 if(!print_unknown_data(pptr,"\n\t\t",tlv_len))
2683                     return(0);
2684             }
2685 	    break;
2686 	}
2687         /* do we want to see an additionally hexdump ? */
2688         if (vflag> 1) {
2689 	    if(!print_unknown_data(pptr,"\n\t      ",tlv_len))
2690 	        return(0);
2691         }
2692 
2693 	pptr += tlv_len;
2694 	packet_len -= tlv_len;
2695     }
2696 
2697     if (packet_len != 0) {
2698 	printf("\n\t      %u straggler bytes", packet_len);
2699     }
2700     return (1);
2701 
2702  trunc:
2703     fputs("[|isis]", stdout);
2704     return (1);
2705 
2706  trunctlv:
2707     printf("\n\t\t packet exceeded snapshot");
2708     return(1);
2709 }
2710 
2711 static void
2712 osi_print_cksum (const u_int8_t *pptr, u_int16_t checksum,
2713                     u_int checksum_offset, u_int length)
2714 {
2715         u_int16_t calculated_checksum;
2716 
2717         /* do not attempt to verify the checksum if it is zero */
2718         if (!checksum) {
2719                 printf("(unverified)");
2720         } else {
2721                 calculated_checksum = create_osi_cksum(pptr, checksum_offset, length);
2722                 if (checksum == calculated_checksum) {
2723                         printf(" (correct)");
2724                 } else {
2725                         printf(" (incorrect should be 0x%04x)", calculated_checksum);
2726                 }
2727         }
2728 }
2729 
2730 /*
2731  * Local Variables:
2732  * c-style: whitesmith
2733  * c-basic-offset: 8
2734  * End:
2735  */
2736