]> The Tcpdump Group git mirrors - tcpdump/blob - print-isoclns.c
projects / tcpdump / blob


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