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