]> The Tcpdump Group git mirrors - tcpdump/blob - print-icmp6.c
projects / tcpdump / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Use the new GET_ macros instead of the EXTRACT_ ones
[tcpdump] / print-icmp6.c
1 /*
2 * Copyright (c) 1988, 1989, 1990, 1991, 1993, 1994
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
22 /* \summary: IPv6 Internet Control Message Protocol (ICMPv6) printer */
23
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27
28 #include "netdissect-stdinc.h"
29
30 #include <stdio.h>
31 #include <string.h>
32
33 #include "netdissect.h"
34 #include "addrtoname.h"
35 #include "addrtostr.h"
36 #include "extract.h"
37
38 #include "ip6.h"
39 #include "ipproto.h"
40
41 #include "udp.h"
42 #include "ah.h"
43
44 /* NetBSD: icmp6.h,v 1.13 2000/08/03 16:30:37 itojun Exp */
45 /* $KAME: icmp6.h,v 1.22 2000/08/03 15:25:16 jinmei Exp $ */
46
47 /*
48 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
49 * All rights reserved.
50 *
51 * Redistribution and use in source and binary forms, with or without
52 * modification, are permitted provided that the following conditions
53 * are met:
54 * 1. Redistributions of source code must retain the above copyright
55 * notice, this list of conditions and the following disclaimer.
56 * 2. Redistributions in binary form must reproduce the above copyright
57 * notice, this list of conditions and the following disclaimer in the
58 * documentation and/or other materials provided with the distribution.
59 * 3. Neither the name of the project nor the names of its contributors
60 * may be used to endorse or promote products derived from this software
61 * without specific prior written permission.
62 *
63 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
64 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
65 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
66 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
67 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
68 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
69 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
70 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
71 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
72 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
73 * SUCH DAMAGE.
74 */
75
76 struct icmp6_hdr {
77 nd_uint8_t icmp6_type; /* type field */
78 nd_uint8_t icmp6_code; /* code field */
79 nd_uint16_t icmp6_cksum; /* checksum field */
80 union {
81 nd_uint32_t icmp6_un_data32[1]; /* type-specific field */
82 nd_uint16_t icmp6_un_data16[2]; /* type-specific field */
83 nd_uint8_t icmp6_un_data8[4]; /* type-specific field */
84 nd_byte icmp6_un_data[1]; /* type-specific field */
85 } icmp6_dataun;
86 };
87
88 #define icmp6_data32 icmp6_dataun.icmp6_un_data32
89 #define icmp6_data16 icmp6_dataun.icmp6_un_data16
90 #define icmp6_data8 icmp6_dataun.icmp6_un_data8
91 #define icmp6_data icmp6_dataun.icmp6_un_data
92 #define icmp6_pptr icmp6_data32[0] /* parameter prob */
93 #define icmp6_mtu icmp6_data32[0] /* packet too big */
94 #define icmp6_id icmp6_data16[0] /* echo request/reply */
95 #define icmp6_seq icmp6_data16[1] /* echo request/reply */
96 #define icmp6_maxdelay icmp6_data16[0] /* mcast group membership */
97
98 #define ICMP6_DST_UNREACH 1 /* dest unreachable, codes: */
99 #define ICMP6_PACKET_TOO_BIG 2 /* packet too big */
100 #define ICMP6_TIME_EXCEEDED 3 /* time exceeded, code: */
101 #define ICMP6_PARAM_PROB 4 /* ip6 header bad */
102
103 #define ICMP6_ECHO_REQUEST 128 /* echo service */
104 #define ICMP6_ECHO_REPLY 129 /* echo reply */
105 #define ICMP6_MEMBERSHIP_QUERY 130 /* group membership query */
106 #define MLD6_LISTENER_QUERY 130 /* multicast listener query */
107 #define ICMP6_MEMBERSHIP_REPORT 131 /* group membership report */
108 #define MLD6_LISTENER_REPORT 131 /* multicast listener report */
109 #define ICMP6_MEMBERSHIP_REDUCTION 132 /* group membership termination */
110 #define MLD6_LISTENER_DONE 132 /* multicast listener done */
111
112 #define ND_ROUTER_SOLICIT 133 /* router solicitation */
113 #define ND_ROUTER_ADVERT 134 /* router advertisement */
114 #define ND_NEIGHBOR_SOLICIT 135 /* neighbor solicitation */
115 #define ND_NEIGHBOR_ADVERT 136 /* neighbor advertisement */
116 #define ND_REDIRECT 137 /* redirect */
117
118 #define ICMP6_ROUTER_RENUMBERING 138 /* router renumbering */
119
120 #define ICMP6_WRUREQUEST 139 /* who are you request */
121 #define ICMP6_WRUREPLY 140 /* who are you reply */
122 #define ICMP6_FQDN_QUERY 139 /* FQDN query */
123 #define ICMP6_FQDN_REPLY 140 /* FQDN reply */
124 #define ICMP6_NI_QUERY 139 /* node information request - RFC 4620 */
125 #define ICMP6_NI_REPLY 140 /* node information reply - RFC 4620 */
126 #define IND_SOLICIT 141 /* inverse neighbor solicitation */
127 #define IND_ADVERT 142 /* inverse neighbor advertisement */
128
129 #define ICMP6_V2_MEMBERSHIP_REPORT 143 /* v2 membership report */
130 #define MLDV2_LISTENER_REPORT 143 /* v2 multicast listener report */
131 #define ICMP6_HADISCOV_REQUEST 144
132 #define ICMP6_HADISCOV_REPLY 145
133 #define ICMP6_MOBILEPREFIX_SOLICIT 146
134 #define ICMP6_MOBILEPREFIX_ADVERT 147
135
136 #define MLD6_MTRACE_RESP 200 /* mtrace response(to sender) */
137 #define MLD6_MTRACE 201 /* mtrace messages */
138
139 #define ICMP6_MAXTYPE 201
140
141 #define ICMP6_DST_UNREACH_NOROUTE 0 /* no route to destination */
142 #define ICMP6_DST_UNREACH_ADMIN 1 /* administratively prohibited */
143 #define ICMP6_DST_UNREACH_NOTNEIGHBOR 2 /* not a neighbor(obsolete) */
144 #define ICMP6_DST_UNREACH_BEYONDSCOPE 2 /* beyond scope of source address */
145 #define ICMP6_DST_UNREACH_ADDR 3 /* address unreachable */
146 #define ICMP6_DST_UNREACH_NOPORT 4 /* port unreachable */
147
148 #define ICMP6_TIME_EXCEED_TRANSIT 0 /* ttl==0 in transit */
149 #define ICMP6_TIME_EXCEED_REASSEMBLY 1 /* ttl==0 in reass */
150
151 #define ICMP6_PARAMPROB_HEADER 0 /* erroneous header field */
152 #define ICMP6_PARAMPROB_NEXTHEADER 1 /* unrecognized next header */
153 #define ICMP6_PARAMPROB_OPTION 2 /* unrecognized option */
154
155 #define ICMP6_INFOMSG_MASK 0x80 /* all informational messages */
156
157 #define ICMP6_NI_SUBJ_IPV6 0 /* Query Subject is an IPv6 address */
158 #define ICMP6_NI_SUBJ_FQDN 1 /* Query Subject is a Domain name */
159 #define ICMP6_NI_SUBJ_IPV4 2 /* Query Subject is an IPv4 address */
160
161 #define ICMP6_NI_SUCCESS 0 /* node information successful reply */
162 #define ICMP6_NI_REFUSED 1 /* node information request is refused */
163 #define ICMP6_NI_UNKNOWN 2 /* unknown Qtype */
164
165 #define ICMP6_ROUTER_RENUMBERING_COMMAND 0 /* rr command */
166 #define ICMP6_ROUTER_RENUMBERING_RESULT 1 /* rr result */
167 #define ICMP6_ROUTER_RENUMBERING_SEQNUM_RESET 255 /* rr seq num reset */
168
169 /* Used in kernel only */
170 #define ND_REDIRECT_ONLINK 0 /* redirect to an on-link node */
171 #define ND_REDIRECT_ROUTER 1 /* redirect to a better router */
172
173 /*
174 * Multicast Listener Discovery
175 */
176 struct mld6_hdr {
177 struct icmp6_hdr mld6_hdr;
178 nd_ipv6 mld6_addr; /* multicast address */
179 };
180
181 #define mld6_type mld6_hdr.icmp6_type
182 #define mld6_code mld6_hdr.icmp6_code
183 #define mld6_cksum mld6_hdr.icmp6_cksum
184 #define mld6_maxdelay mld6_hdr.icmp6_data16[0]
185 #define mld6_reserved mld6_hdr.icmp6_data16[1]
186
187 #define MLD_MINLEN 24
188 #define MLDV2_MINLEN 28
189
190 /*
191 * Neighbor Discovery
192 */
193
194 struct nd_router_solicit { /* router solicitation */
195 struct icmp6_hdr nd_rs_hdr;
196 /* could be followed by options */
197 };
198
199 #define nd_rs_type nd_rs_hdr.icmp6_type
200 #define nd_rs_code nd_rs_hdr.icmp6_code
201 #define nd_rs_cksum nd_rs_hdr.icmp6_cksum
202 #define nd_rs_reserved nd_rs_hdr.icmp6_data32[0]
203
204 struct nd_router_advert { /* router advertisement */
205 struct icmp6_hdr nd_ra_hdr;
206 nd_uint32_t nd_ra_reachable; /* reachable time */
207 nd_uint32_t nd_ra_retransmit; /* retransmit timer */
208 /* could be followed by options */
209 };
210
211 #define nd_ra_type nd_ra_hdr.icmp6_type
212 #define nd_ra_code nd_ra_hdr.icmp6_code
213 #define nd_ra_cksum nd_ra_hdr.icmp6_cksum
214 #define nd_ra_curhoplimit nd_ra_hdr.icmp6_data8[0]
215 #define nd_ra_flags_reserved nd_ra_hdr.icmp6_data8[1]
216 #define ND_RA_FLAG_MANAGED 0x80
217 #define ND_RA_FLAG_OTHER 0x40
218 #define ND_RA_FLAG_HOME_AGENT 0x20
219 #define ND_RA_FLAG_IPV6ONLY 0x02
220
221 /*
222 * Router preference values based on draft-draves-ipngwg-router-selection-01.
223 * These are non-standard definitions.
224 */
225 #define ND_RA_FLAG_RTPREF_MASK 0x18 /* 00011000 */
226
227 #define ND_RA_FLAG_RTPREF_HIGH 0x08 /* 00001000 */
228 #define ND_RA_FLAG_RTPREF_MEDIUM 0x00 /* 00000000 */
229 #define ND_RA_FLAG_RTPREF_LOW 0x18 /* 00011000 */
230 #define ND_RA_FLAG_RTPREF_RSV 0x10 /* 00010000 */
231
232 #define nd_ra_router_lifetime nd_ra_hdr.icmp6_data16[1]
233
234 struct nd_neighbor_solicit { /* neighbor solicitation */
235 struct icmp6_hdr nd_ns_hdr;
236 nd_ipv6 nd_ns_target; /*target address */
237 /* could be followed by options */
238 };
239
240 #define nd_ns_type nd_ns_hdr.icmp6_type
241 #define nd_ns_code nd_ns_hdr.icmp6_code
242 #define nd_ns_cksum nd_ns_hdr.icmp6_cksum
243 #define nd_ns_reserved nd_ns_hdr.icmp6_data32[0]
244
245 struct nd_neighbor_advert { /* neighbor advertisement */
246 struct icmp6_hdr nd_na_hdr;
247 nd_ipv6 nd_na_target; /* target address */
248 /* could be followed by options */
249 };
250
251 #define nd_na_type nd_na_hdr.icmp6_type
252 #define nd_na_code nd_na_hdr.icmp6_code
253 #define nd_na_cksum nd_na_hdr.icmp6_cksum
254 #define nd_na_flags_reserved nd_na_hdr.icmp6_data32[0]
255
256 #define ND_NA_FLAG_ROUTER 0x80000000
257 #define ND_NA_FLAG_SOLICITED 0x40000000
258 #define ND_NA_FLAG_OVERRIDE 0x20000000
259
260 struct nd_redirect { /* redirect */
261 struct icmp6_hdr nd_rd_hdr;
262 nd_ipv6 nd_rd_target; /* target address */
263 nd_ipv6 nd_rd_dst; /* destination address */
264 /* could be followed by options */
265 };
266
267 #define nd_rd_type nd_rd_hdr.icmp6_type
268 #define nd_rd_code nd_rd_hdr.icmp6_code
269 #define nd_rd_cksum nd_rd_hdr.icmp6_cksum
270 #define nd_rd_reserved nd_rd_hdr.icmp6_data32[0]
271
272 struct nd_opt_hdr { /* Neighbor discovery option header */
273 nd_uint8_t nd_opt_type;
274 nd_uint8_t nd_opt_len;
275 /* followed by option specific data*/
276 };
277
278 #define ND_OPT_SOURCE_LINKADDR 1
279 #define ND_OPT_TARGET_LINKADDR 2
280 #define ND_OPT_PREFIX_INFORMATION 3
281 #define ND_OPT_REDIRECTED_HEADER 4
282 #define ND_OPT_MTU 5
283 #define ND_OPT_ADVINTERVAL 7
284 #define ND_OPT_HOMEAGENT_INFO 8
285 #define ND_OPT_ROUTE_INFO 24 /* RFC4191 */
286 #define ND_OPT_RDNSS 25
287 #define ND_OPT_DNSSL 31
288
289 struct nd_opt_prefix_info { /* prefix information */
290 nd_uint8_t nd_opt_pi_type;
291 nd_uint8_t nd_opt_pi_len;
292 nd_uint8_t nd_opt_pi_prefix_len;
293 nd_uint8_t nd_opt_pi_flags_reserved;
294 nd_uint32_t nd_opt_pi_valid_time;
295 nd_uint32_t nd_opt_pi_preferred_time;
296 nd_uint32_t nd_opt_pi_reserved2;
297 nd_ipv6 nd_opt_pi_prefix;
298 };
299
300 #define ND_OPT_PI_FLAG_ONLINK 0x80
301 #define ND_OPT_PI_FLAG_AUTO 0x40
302 #define ND_OPT_PI_FLAG_ROUTER 0x20 /*2292bis*/
303
304 struct nd_opt_rd_hdr { /* redirected header */
305 nd_uint8_t nd_opt_rh_type;
306 nd_uint8_t nd_opt_rh_len;
307 nd_uint16_t nd_opt_rh_reserved1;
308 nd_uint32_t nd_opt_rh_reserved2;
309 /* followed by IP header and data */
310 };
311
312 struct nd_opt_mtu { /* MTU option */
313 nd_uint8_t nd_opt_mtu_type;
314 nd_uint8_t nd_opt_mtu_len;
315 nd_uint16_t nd_opt_mtu_reserved;
316 nd_uint32_t nd_opt_mtu_mtu;
317 };
318
319 struct nd_opt_rdnss { /* RDNSS RFC 6106 5.1 */
320 nd_uint8_t nd_opt_rdnss_type;
321 nd_uint8_t nd_opt_rdnss_len;
322 nd_uint16_t nd_opt_rdnss_reserved;
323 nd_uint32_t nd_opt_rdnss_lifetime;
324 nd_ipv6 nd_opt_rdnss_addr[1]; /* variable-length */
325 };
326
327 struct nd_opt_dnssl { /* DNSSL RFC 6106 5.2 */
328 nd_uint8_t nd_opt_dnssl_type;
329 nd_uint8_t nd_opt_dnssl_len;
330 nd_uint16_t nd_opt_dnssl_reserved;
331 nd_uint32_t nd_opt_dnssl_lifetime;
332 /* followed by list of DNS search domains, variable-length */
333 };
334
335 struct nd_opt_advinterval { /* Advertisement interval option */
336 nd_uint8_t nd_opt_adv_type;
337 nd_uint8_t nd_opt_adv_len;
338 nd_uint16_t nd_opt_adv_reserved;
339 nd_uint32_t nd_opt_adv_interval;
340 };
341
342 struct nd_opt_homeagent_info { /* Home Agent info */
343 nd_uint8_t nd_opt_hai_type;
344 nd_uint8_t nd_opt_hai_len;
345 nd_uint16_t nd_opt_hai_reserved;
346 nd_uint16_t nd_opt_hai_preference;
347 nd_uint16_t nd_opt_hai_lifetime;
348 };
349
350 struct nd_opt_route_info { /* route info */
351 nd_uint8_t nd_opt_rti_type;
352 nd_uint8_t nd_opt_rti_len;
353 nd_uint8_t nd_opt_rti_prefixlen;
354 nd_uint8_t nd_opt_rti_flags;
355 nd_uint32_t nd_opt_rti_lifetime;
356 /* prefix follows */
357 };
358
359 /*
360 * icmp6 namelookup
361 */
362
363 struct icmp6_namelookup {
364 struct icmp6_hdr icmp6_nl_hdr;
365 nd_byte icmp6_nl_nonce[8];
366 nd_int32_t icmp6_nl_ttl;
367 #if 0
368 nd_uint8_t icmp6_nl_len;
369 nd_byte icmp6_nl_name[3];
370 #endif
371 /* could be followed by options */
372 };
373
374 /*
375 * icmp6 node information
376 */
377 struct icmp6_nodeinfo {
378 struct icmp6_hdr icmp6_ni_hdr;
379 nd_byte icmp6_ni_nonce[8];
380 /* could be followed by reply data */
381 };
382
383 #define ni_type icmp6_ni_hdr.icmp6_type
384 #define ni_code icmp6_ni_hdr.icmp6_code
385 #define ni_cksum icmp6_ni_hdr.icmp6_cksum
386 #define ni_qtype icmp6_ni_hdr.icmp6_data16[0]
387 #define ni_flags icmp6_ni_hdr.icmp6_data16[1]
388
389 #define NI_QTYPE_NOOP 0 /* NOOP */
390 #define NI_QTYPE_SUPTYPES 1 /* Supported Qtypes (drafts up to 09) */
391 #define NI_QTYPE_FQDN 2 /* FQDN (draft 04) */
392 #define NI_QTYPE_DNSNAME 2 /* DNS Name */
393 #define NI_QTYPE_NODEADDR 3 /* Node Addresses */
394 #define NI_QTYPE_IPV4ADDR 4 /* IPv4 Addresses */
395
396 /* network endian */
397 #define NI_SUPTYPE_FLAG_COMPRESS ((uint16_t)htons(0x1))
398 #define NI_FQDN_FLAG_VALIDTTL ((uint16_t)htons(0x1))
399
400 /* network endian */
401 #define NI_NODEADDR_FLAG_TRUNCATE ((uint16_t)htons(0x1))
402 #define NI_NODEADDR_FLAG_ALL ((uint16_t)htons(0x2))
403 #define NI_NODEADDR_FLAG_COMPAT ((uint16_t)htons(0x4))
404 #define NI_NODEADDR_FLAG_LINKLOCAL ((uint16_t)htons(0x8))
405 #define NI_NODEADDR_FLAG_SITELOCAL ((uint16_t)htons(0x10))
406 #define NI_NODEADDR_FLAG_GLOBAL ((uint16_t)htons(0x20))
407 #define NI_NODEADDR_FLAG_ANYCAST ((uint16_t)htons(0x40)) /* just experimental. not in spec */
408
409 struct ni_reply_fqdn {
410 nd_uint32_t ni_fqdn_ttl; /* TTL */
411 nd_uint8_t ni_fqdn_namelen; /* length in octets of the FQDN */
412 nd_byte ni_fqdn_name[3]; /* XXX: alignment */
413 };
414
415 /*
416 * Router Renumbering. as router-renum-08.txt
417 */
418 struct icmp6_router_renum { /* router renumbering header */
419 struct icmp6_hdr rr_hdr;
420 nd_uint8_t rr_segnum;
421 nd_uint8_t rr_flags;
422 nd_uint16_t rr_maxdelay;
423 nd_uint32_t rr_reserved;
424 };
425 #define ICMP6_RR_FLAGS_TEST 0x80
426 #define ICMP6_RR_FLAGS_REQRESULT 0x40
427 #define ICMP6_RR_FLAGS_FORCEAPPLY 0x20
428 #define ICMP6_RR_FLAGS_SPECSITE 0x10
429 #define ICMP6_RR_FLAGS_PREVDONE 0x08
430
431 #define rr_type rr_hdr.icmp6_type
432 #define rr_code rr_hdr.icmp6_code
433 #define rr_cksum rr_hdr.icmp6_cksum
434 #define rr_seqnum rr_hdr.icmp6_data32[0]
435
436 struct rr_pco_match { /* match prefix part */
437 nd_uint8_t rpm_code;
438 nd_uint8_t rpm_len;
439 nd_uint8_t rpm_ordinal;
440 nd_uint8_t rpm_matchlen;
441 nd_uint8_t rpm_minlen;
442 nd_uint8_t rpm_maxlen;
443 nd_uint16_t rpm_reserved;
444 nd_ipv6 rpm_prefix;
445 };
446
447 #define RPM_PCO_ADD 1
448 #define RPM_PCO_CHANGE 2
449 #define RPM_PCO_SETGLOBAL 3
450 #define RPM_PCO_MAX 4
451
452 struct rr_pco_use { /* use prefix part */
453 nd_uint8_t rpu_uselen;
454 nd_uint8_t rpu_keeplen;
455 nd_uint8_t rpu_ramask;
456 nd_uint8_t rpu_raflags;
457 nd_uint32_t rpu_vltime;
458 nd_uint32_t rpu_pltime;
459 nd_uint32_t rpu_flags;
460 nd_ipv6 rpu_prefix;
461 };
462 #define ICMP6_RR_PCOUSE_RAFLAGS_ONLINK 0x80
463 #define ICMP6_RR_PCOUSE_RAFLAGS_AUTO 0x40
464
465 /* network endian */
466 #define ICMP6_RR_PCOUSE_FLAGS_DECRVLTIME ((uint32_t)htonl(0x80000000))
467 #define ICMP6_RR_PCOUSE_FLAGS_DECRPLTIME ((uint32_t)htonl(0x40000000))
468
469 struct rr_result { /* router renumbering result message */
470 nd_uint16_t rrr_flags;
471 nd_uint8_t rrr_ordinal;
472 nd_uint8_t rrr_matchedlen;
473 nd_uint32_t rrr_ifid;
474 nd_ipv6 rrr_prefix;
475 };
476 /* network endian */
477 #define ICMP6_RR_RESULT_FLAGS_OOB ((uint16_t)htons(0x0002))
478 #define ICMP6_RR_RESULT_FLAGS_FORBIDDEN ((uint16_t)htons(0x0001))
479
480 static const char *get_rtpref(u_int);
481 static const char *get_lifetime(uint32_t);
482 static void print_lladdr(netdissect_options *ndo, const u_char *, size_t);
483 static int icmp6_opt_print(netdissect_options *ndo, const u_char *, int);
484 static void mld6_print(netdissect_options *ndo, const u_char *);
485 static void mldv2_report_print(netdissect_options *ndo, const u_char *, u_int);
486 static void mldv2_query_print(netdissect_options *ndo, const u_char *, u_int);
487 static const struct udphdr *get_upperlayer(netdissect_options *ndo, const u_char *, u_int *);
488 static void dnsname_print(netdissect_options *ndo, const u_char *, const u_char *);
489 static void icmp6_nodeinfo_print(netdissect_options *ndo, u_int, const u_char *, const u_char *);
490 static void icmp6_rrenum_print(netdissect_options *ndo, const u_char *, const u_char *);
491
492 #ifndef abs
493 #define abs(a) ((0 < (a)) ? (a) : -(a))
494 #endif
495
496 /*
497 * DIO: Updated to RFC6550, as published in 2012: section 6. (page 30)
498 */
499
500 #define ND_RPL_MESSAGE 155 /* 0x9B */
501
502 enum ND_RPL_CODE {
503 ND_RPL_DAG_IS=0x00,
504 ND_RPL_DAG_IO=0x01,
505 ND_RPL_DAO =0x02,
506 ND_RPL_DAO_ACK=0x03,
507 ND_RPL_SEC_DAG_IS = 0x80,
508 ND_RPL_SEC_DAG_IO = 0x81,
509 ND_RPL_SEC_DAG = 0x82,
510 ND_RPL_SEC_DAG_ACK= 0x83,
511 ND_RPL_SEC_CONSIST= 0x8A
512 };
513
514 enum ND_RPL_DIO_FLAGS {
515 ND_RPL_DIO_GROUNDED = 0x80,
516 ND_RPL_DIO_DATRIG = 0x40,
517 ND_RPL_DIO_DASUPPORT= 0x20,
518 ND_RPL_DIO_RES4 = 0x10,
519 ND_RPL_DIO_RES3 = 0x08,
520 ND_RPL_DIO_PRF_MASK = 0x07 /* 3-bit preference */
521 };
522
523 #define DAGID_LEN 16
524
525 /* section 6 of draft-ietf-roll-rpl-19 */
526 struct nd_rpl_security {
527 nd_uint8_t rpl_sec_t_reserved; /* bit 7 is T-bit */
528 nd_uint8_t rpl_sec_algo;
529 nd_uint16_t rpl_sec_kim_lvl_flags; /* bit 15/14, KIM */
530 /* bit 10-8, LVL, bit 7-0 flags */
531 nd_uint32_t rpl_sec_counter;
532 #if 0
533 nd_byte rpl_sec_ki[0]; /* depends upon kim */
534 #endif
535 };
536
537 /* section 6.2.1, DODAG Information Solication (DIS_IS) */
538 struct nd_rpl_dis_is {
539 nd_uint8_t rpl_dis_flags;
540 nd_uint8_t rpl_dis_reserved;
541 #if 0
542 nd_byte rpl_dis_options[0];
543 #endif
544 };
545
546 /* section 6.3.1, DODAG Information Object (DIO) */
547 struct nd_rpl_dio {
548 nd_uint8_t rpl_instanceid;
549 nd_uint8_t rpl_version;
550 nd_uint16_t rpl_dagrank;
551 nd_uint8_t rpl_mopprf; /* bit 7=G, 5-3=MOP, 2-0=PRF */
552 nd_uint8_t rpl_dtsn; /* Dest. Advertisement Trigger Sequence Number */
553 nd_uint8_t rpl_flags; /* no flags defined yet */
554 nd_uint8_t rpl_resv1;
555 nd_byte rpl_dagid[DAGID_LEN];
556 };
557 #define RPL_DIO_GROUND_FLAG 0x80
558 #define RPL_DIO_MOP_SHIFT 3
559 #define RPL_DIO_MOP_MASK (7 << RPL_DIO_MOP_SHIFT)
560 #define RPL_DIO_PRF_SHIFT 0
561 #define RPL_DIO_PRF_MASK (7 << RPL_DIO_PRF_SHIFT)
562 #define RPL_DIO_GROUNDED(X) ((X)&RPL_DIO_GROUND_FLAG)
563 #define RPL_DIO_MOP(X) (enum RPL_DIO_MOP)(((X)&RPL_DIO_MOP_MASK) >> RPL_DIO_MOP_SHIFT)
564 #define RPL_DIO_PRF(X) (((X)&RPL_DIO_PRF_MASK) >> RPL_DIO_PRF_SHIFT)
565
566 enum RPL_DIO_MOP {
567 RPL_DIO_NONSTORING= 0x0,
568 RPL_DIO_STORING = 0x1,
569 RPL_DIO_NONSTORING_MULTICAST = 0x2,
570 RPL_DIO_STORING_MULTICAST = 0x3
571 };
572
573 enum RPL_SUBOPT {
574 RPL_OPT_PAD1 = 0,
575 RPL_OPT_PADN = 1,
576 RPL_DIO_METRICS = 2,
577 RPL_DIO_ROUTINGINFO = 3,
578 RPL_DIO_CONFIG = 4,
579 RPL_DAO_RPLTARGET = 5,
580 RPL_DAO_TRANSITINFO = 6,
581 RPL_DIO_DESTPREFIX = 8,
582 RPL_DAO_RPLTARGET_DESC=9
583 };
584
585 struct rpl_genoption {
586 nd_uint8_t rpl_dio_type;
587 nd_uint8_t rpl_dio_len; /* suboption length, not including type/len */
588 };
589 #define RPL_GENOPTION_LEN 2
590
591 #define RPL_DIO_LIFETIME_INFINITE 0xffffffff
592 #define RPL_DIO_LIFETIME_DISCONNECT 0
593
594 struct rpl_dio_destprefix {
595 nd_uint8_t rpl_dio_type;
596 nd_uint8_t rpl_dio_len;
597 nd_uint8_t rpl_dio_prefixlen; /* in bits */
598 nd_uint8_t rpl_dio_prf; /* flags, including Route Preference */
599 nd_uint32_t rpl_dio_prefixlifetime; /* in seconds */
600 #if 0
601 nd_byte rpl_dio_prefix[0]; /* variable number of bytes */
602 #endif
603 };
604
605 /* section 6.4.1, DODAG Information Object (DIO) */
606 struct nd_rpl_dao {
607 nd_uint8_t rpl_instanceid;
608 nd_uint8_t rpl_flags; /* bit 7=K, 6=D */
609 nd_uint8_t rpl_resv;
610 nd_uint8_t rpl_daoseq;
611 nd_byte rpl_dagid[DAGID_LEN]; /* present when D set. */
612 };
613 #define ND_RPL_DAO_MIN_LEN 4 /* length without DAGID */
614
615 /* indicates if this DAO is to be acK'ed */
616 #define RPL_DAO_K_SHIFT 7
617 #define RPL_DAO_K_MASK (1 << RPL_DAO_K_SHIFT)
618 #define RPL_DAO_K(X) (((X)&RPL_DAO_K_MASK) >> RPL_DAO_K_SHIFT)
619
620 /* indicates if the DAGID is present */
621 #define RPL_DAO_D_SHIFT 6
622 #define RPL_DAO_D_MASK (1 << RPL_DAO_D_SHIFT)
623 #define RPL_DAO_D(X) (((X)&RPL_DAO_D_MASK) >> RPL_DAO_D_SHIFT)
624
625 struct rpl_dao_target {
626 nd_uint8_t rpl_dao_type;
627 nd_uint8_t rpl_dao_len;
628 nd_uint8_t rpl_dao_flags; /* unused */
629 nd_uint8_t rpl_dao_prefixlen; /* in bits */
630 #if 0
631 nd_byte rpl_dao_prefix[0]; /* variable number of bytes */
632 #endif
633 };
634
635 /* section 6.5.1, Destination Advertisement Object Acknowledgement (DAO-ACK) */
636 struct nd_rpl_daoack {
637 nd_uint8_t rpl_instanceid;
638 nd_uint8_t rpl_flags; /* bit 7=D */
639 nd_uint8_t rpl_daoseq;
640 nd_uint8_t rpl_status;
641 nd_byte rpl_dagid[DAGID_LEN]; /* present when D set. */
642 };
643 #define ND_RPL_DAOACK_MIN_LEN 4 /* length without DAGID */
644 /* indicates if the DAGID is present */
645 #define RPL_DAOACK_D_SHIFT 7
646 #define RPL_DAOACK_D_MASK (1 << RPL_DAOACK_D_SHIFT)
647 #define RPL_DAOACK_D(X) (((X)&RPL_DAOACK_D_MASK) >> RPL_DAOACK_D_SHIFT)
648
649 static const struct tok icmp6_type_values[] = {
650 { ICMP6_DST_UNREACH, "destination unreachable"},
651 { ICMP6_PACKET_TOO_BIG, "packet too big"},
652 { ICMP6_TIME_EXCEEDED, "time exceeded in-transit"},
653 { ICMP6_PARAM_PROB, "parameter problem"},
654 { ICMP6_ECHO_REQUEST, "echo request"},
655 { ICMP6_ECHO_REPLY, "echo reply"},
656 { MLD6_LISTENER_QUERY, "multicast listener query"},
657 { MLD6_LISTENER_REPORT, "multicast listener report"},
658 { MLD6_LISTENER_DONE, "multicast listener done"},
659 { ND_ROUTER_SOLICIT, "router solicitation"},
660 { ND_ROUTER_ADVERT, "router advertisement"},
661 { ND_NEIGHBOR_SOLICIT, "neighbor solicitation"},
662 { ND_NEIGHBOR_ADVERT, "neighbor advertisement"},
663 { ND_REDIRECT, "redirect"},
664 { ICMP6_ROUTER_RENUMBERING, "router renumbering"},
665 { IND_SOLICIT, "inverse neighbor solicitation"},
666 { IND_ADVERT, "inverse neighbor advertisement"},
667 { MLDV2_LISTENER_REPORT, "multicast listener report v2"},
668 { ICMP6_HADISCOV_REQUEST, "ha discovery request"},
669 { ICMP6_HADISCOV_REPLY, "ha discovery reply"},
670 { ICMP6_MOBILEPREFIX_SOLICIT, "mobile router solicitation"},
671 { ICMP6_MOBILEPREFIX_ADVERT, "mobile router advertisement"},
672 { ICMP6_WRUREQUEST, "who-are-you request"},
673 { ICMP6_WRUREPLY, "who-are-you reply"},
674 { ICMP6_NI_QUERY, "node information query"},
675 { ICMP6_NI_REPLY, "node information reply"},
676 { MLD6_MTRACE, "mtrace message"},
677 { MLD6_MTRACE_RESP, "mtrace response"},
678 { ND_RPL_MESSAGE, "RPL"},
679 { 0, NULL }
680 };
681
682 static const struct tok icmp6_dst_unreach_code_values[] = {
683 { ICMP6_DST_UNREACH_NOROUTE, "unreachable route" },
684 { ICMP6_DST_UNREACH_ADMIN, " unreachable prohibited"},
685 { ICMP6_DST_UNREACH_BEYONDSCOPE, "beyond scope"},
686 { ICMP6_DST_UNREACH_ADDR, "unreachable address"},
687 { ICMP6_DST_UNREACH_NOPORT, "unreachable port"},
688 { 0, NULL }
689 };
690
691 static const struct tok icmp6_opt_pi_flag_values[] = {
692 { ND_OPT_PI_FLAG_ONLINK, "onlink" },
693 { ND_OPT_PI_FLAG_AUTO, "auto" },
694 { ND_OPT_PI_FLAG_ROUTER, "router" },
695 { 0, NULL }
696 };
697
698 static const struct tok icmp6_opt_ra_flag_values[] = {
699 { ND_RA_FLAG_MANAGED, "managed" },
700 { ND_RA_FLAG_OTHER, "other stateful"},
701 { ND_RA_FLAG_HOME_AGENT, "home agent"},
702 { ND_RA_FLAG_IPV6ONLY, "ipv6 only"},
703 { 0, NULL }
704 };
705
706 static const struct tok icmp6_nd_na_flag_values[] = {
707 { ND_NA_FLAG_ROUTER, "router" },
708 { ND_NA_FLAG_SOLICITED, "solicited" },
709 { ND_NA_FLAG_OVERRIDE, "override" },
710 { 0, NULL }
711 };
712
713
714 static const struct tok icmp6_opt_values[] = {
715 { ND_OPT_SOURCE_LINKADDR, "source link-address"},
716 { ND_OPT_TARGET_LINKADDR, "destination link-address"},
717 { ND_OPT_PREFIX_INFORMATION, "prefix info"},
718 { ND_OPT_REDIRECTED_HEADER, "redirected header"},
719 { ND_OPT_MTU, "mtu"},
720 { ND_OPT_RDNSS, "rdnss"},
721 { ND_OPT_DNSSL, "dnssl"},
722 { ND_OPT_ADVINTERVAL, "advertisement interval"},
723 { ND_OPT_HOMEAGENT_INFO, "homeagent information"},
724 { ND_OPT_ROUTE_INFO, "route info"},
725 { 0, NULL }
726 };
727
728 /* mldv2 report types */
729 static const struct tok mldv2report2str[] = {
730 { 1, "is_in" },
731 { 2, "is_ex" },
732 { 3, "to_in" },
733 { 4, "to_ex" },
734 { 5, "allow" },
735 { 6, "block" },
736 { 0, NULL }
737 };
738
739 static const char *
740 get_rtpref(u_int v)
741 {
742 static const char *rtpref_str[] = {
743 "medium", /* 00 */
744 "high", /* 01 */
745 "rsv", /* 10 */
746 "low" /* 11 */
747 };
748
749 return rtpref_str[((v & ND_RA_FLAG_RTPREF_MASK) >> 3) & 0xff];
750 }
751
752 static const char *
753 get_lifetime(uint32_t v)
754 {
755 static char buf[20];
756
757 if (v == (uint32_t)~0UL)
758 return "infinity";
759 else {
760 nd_snprintf(buf, sizeof(buf), "%us", v);
761 return buf;
762 }
763 }
764
765 static void
766 print_lladdr(netdissect_options *ndo, const uint8_t *p, size_t l)
767 {
768 const uint8_t *ep, *q;
769
770 q = p;
771 ep = p + l;
772 while (l > 0 && q < ep) {
773 if (q > p)
774 ND_PRINT(":");
775 ND_PRINT("%02x", GET_U_1(q));
776 q++;
777 l--;
778 }
779 }
780
781 static uint16_t icmp6_cksum(netdissect_options *ndo, const struct ip6_hdr *ip6,
782 const struct icmp6_hdr *icp, u_int len)
783 {
784 return nextproto6_cksum(ndo, ip6, (const uint8_t *)(const void *)icp, len, len,
785 IPPROTO_ICMPV6);
786 }
787
788 static const struct tok rpl_mop_values[] = {
789 { RPL_DIO_NONSTORING, "nonstoring"},
790 { RPL_DIO_STORING, "storing"},
791 { RPL_DIO_NONSTORING_MULTICAST, "nonstoring-multicast"},
792 { RPL_DIO_STORING_MULTICAST, "storing-multicast"},
793 { 0, NULL},
794 };
795
796 static const struct tok rpl_subopt_values[] = {
797 { RPL_OPT_PAD1, "pad1"},
798 { RPL_OPT_PADN, "padN"},
799 { RPL_DIO_METRICS, "metrics"},
800 { RPL_DIO_ROUTINGINFO, "routinginfo"},
801 { RPL_DIO_CONFIG, "config"},
802 { RPL_DAO_RPLTARGET, "rpltarget"},
803 { RPL_DAO_TRANSITINFO, "transitinfo"},
804 { RPL_DIO_DESTPREFIX, "destprefix"},
805 { RPL_DAO_RPLTARGET_DESC, "rpltargetdesc"},
806 { 0, NULL},
807 };
808
809 static void
810 rpl_printopts(netdissect_options *ndo, const uint8_t *opts, u_int length)
811 {
812 const struct rpl_genoption *opt;
813 uint8_t dio_type;
814 u_int optlen;
815
816 while (length != 0) {
817 opt = (const struct rpl_genoption *)opts;
818 ND_TCHECK_1(opt->rpl_dio_type);
819 dio_type = GET_U_1(opt->rpl_dio_type);
820 if (dio_type == RPL_OPT_PAD1) {
821 optlen = 1;
822 ND_PRINT(" opt:pad1");
823 } else {
824 if (length < RPL_GENOPTION_LEN)
825 goto trunc;
826 optlen = GET_U_1(opt->rpl_dio_len)+RPL_GENOPTION_LEN;
827 ND_PRINT(" opt:%s len:%u ",
828 tok2str(rpl_subopt_values, "subopt:%u", dio_type),
829 optlen);
830 ND_TCHECK_LEN(opt, optlen);
831 if (length < optlen)
832 goto trunc;
833 if (ndo->ndo_vflag > 2) {
834 hex_print(ndo,
835 " ",
836 opts + RPL_GENOPTION_LEN, /* content of DIO option */
837 optlen - RPL_GENOPTION_LEN);
838 }
839 }
840 opts += optlen;
841 length -= optlen;
842 }
843 return;
844 trunc:
845 nd_print_trunc(ndo);
846 return;
847 }
848
849 static void
850 rpl_dio_print(netdissect_options *ndo,
851 const u_char *bp, u_int length)
852 {
853 const struct nd_rpl_dio *dio = (const struct nd_rpl_dio *)bp;
854 const char *dagid_str;
855
856 ND_TCHECK_SIZE(dio);
857 dagid_str = ip6addr_string (ndo, dio->rpl_dagid);
858
859 ND_PRINT(" [dagid:%s,seq:%u,instance:%u,rank:%u,%smop:%s,prf:%u]",
860 dagid_str,
861 GET_U_1(dio->rpl_dtsn),
862 GET_U_1(dio->rpl_instanceid),
863 GET_BE_U_2(dio->rpl_dagrank),
864 RPL_DIO_GROUNDED(GET_U_1(dio->rpl_mopprf)) ? "grounded,":"",
865 tok2str(rpl_mop_values, "mop%u", RPL_DIO_MOP(GET_U_1(dio->rpl_mopprf))),
866 RPL_DIO_PRF(GET_U_1(dio->rpl_mopprf)));
867
868 if(ndo->ndo_vflag > 1) {
869 rpl_printopts(ndo, bp + sizeof(struct nd_rpl_dio),
870 length - sizeof(struct nd_rpl_dio));
871 }
872 return;
873 trunc:
874 nd_print_trunc(ndo);
875 return;
876 }
877
878 static void
879 rpl_dao_print(netdissect_options *ndo,
880 const u_char *bp, u_int length)
881 {
882 const struct nd_rpl_dao *dao = (const struct nd_rpl_dao *)bp;
883 const char *dagid_str = "<elided>";
884 uint8_t rpl_flags;
885
886 ND_TCHECK_SIZE(dao);
887 if (length < ND_RPL_DAO_MIN_LEN)
888 goto tooshort;
889
890 bp += ND_RPL_DAO_MIN_LEN;
891 length -= ND_RPL_DAO_MIN_LEN;
892 rpl_flags = GET_U_1(dao->rpl_flags);
893 if(RPL_DAO_D(rpl_flags)) {
894 ND_TCHECK_LEN(dao->rpl_dagid, DAGID_LEN);
895 if (length < DAGID_LEN)
896 goto tooshort;
897 dagid_str = ip6addr_string (ndo, dao->rpl_dagid);
898 bp += DAGID_LEN;
899 length -= DAGID_LEN;
900 }
901
902 ND_PRINT(" [dagid:%s,seq:%u,instance:%u%s%s,%02x]",
903 dagid_str,
904 GET_U_1(dao->rpl_daoseq),
905 GET_U_1(dao->rpl_instanceid),
906 RPL_DAO_K(rpl_flags) ? ",acK":"",
907 RPL_DAO_D(rpl_flags) ? ",Dagid":"",
908 rpl_flags);
909
910 if(ndo->ndo_vflag > 1) {
911 rpl_printopts(ndo, bp, length);
912 }
913 return;
914
915 trunc:
916 nd_print_trunc(ndo);
917 return;
918
919 tooshort:
920 ND_PRINT(" [|length too short]");
921 return;
922 }
923
924 static void
925 rpl_daoack_print(netdissect_options *ndo,
926 const u_char *bp, u_int length)
927 {
928 const struct nd_rpl_daoack *daoack = (const struct nd_rpl_daoack *)bp;
929 const char *dagid_str = "<elided>";
930
931 ND_TCHECK_LEN(daoack, ND_RPL_DAOACK_MIN_LEN);
932 if (length < ND_RPL_DAOACK_MIN_LEN)
933 goto tooshort;
934
935 bp += ND_RPL_DAOACK_MIN_LEN;
936 length -= ND_RPL_DAOACK_MIN_LEN;
937 if(RPL_DAOACK_D(GET_U_1(daoack->rpl_flags))) {
938 ND_TCHECK_LEN(daoack->rpl_dagid, DAGID_LEN);
939 if (length < DAGID_LEN)
940 goto tooshort;
941 dagid_str = ip6addr_string (ndo, daoack->rpl_dagid);
942 bp += DAGID_LEN;
943 length -= DAGID_LEN;
944 }
945
946 ND_PRINT(" [dagid:%s,seq:%u,instance:%u,status:%u]",
947 dagid_str,
948 GET_U_1(daoack->rpl_daoseq),
949 GET_U_1(daoack->rpl_instanceid),
950 GET_U_1(daoack->rpl_status));
951
952 /* no officially defined options for DAOACK, but print any we find */
953 if(ndo->ndo_vflag > 1) {
954 rpl_printopts(ndo, bp, length);
955 }
956 return;
957
958 trunc:
959 nd_print_trunc(ndo);
960 return;
961
962 tooshort:
963 ND_PRINT(" [|dao-length too short]");
964 return;
965 }
966
967 static void
968 rpl_print(netdissect_options *ndo,
969 uint8_t icmp6_code,
970 const u_char *bp, u_int length)
971 {
972 int secured = icmp6_code & 0x80;
973 int basecode= icmp6_code & 0x7f;
974
975 if(secured) {
976 ND_PRINT(", (SEC) [worktodo]");
977 /* XXX
978 * the next header pointer needs to move forward to
979 * skip the secure part.
980 */
981 return;
982 } else {
983 ND_PRINT(", (CLR)");
984 }
985
986 switch(basecode) {
987 case ND_RPL_DAG_IS:
988 ND_PRINT("DODAG Information Solicitation");
989 if(ndo->ndo_vflag) {
990 }
991 break;
992 case ND_RPL_DAG_IO:
993 ND_PRINT("DODAG Information Object");
994 if(ndo->ndo_vflag) {
995 rpl_dio_print(ndo, bp, length);
996 }
997 break;
998 case ND_RPL_DAO:
999 ND_PRINT("Destination Advertisement Object");
1000 if(ndo->ndo_vflag) {
1001 rpl_dao_print(ndo, bp, length);
1002 }
1003 break;
1004 case ND_RPL_DAO_ACK:
1005 ND_PRINT("Destination Advertisement Object Ack");
1006 if(ndo->ndo_vflag) {
1007 rpl_daoack_print(ndo, bp, length);
1008 }
1009 break;
1010 default:
1011 ND_PRINT("RPL message, unknown code %u",icmp6_code);
1012 break;
1013 }
1014 return;
1015
1016 #if 0
1017 trunc:
1018 nd_print_trunc(ndo);
1019 return;
1020 #endif
1021
1022 }
1023
1024
1025 void
1026 icmp6_print(netdissect_options *ndo,
1027 const u_char *bp, u_int length, const u_char *bp2, int fragmented)
1028 {
1029 const struct icmp6_hdr *dp;
1030 uint8_t icmp6_type, icmp6_code;
1031 const struct ip6_hdr *ip;
1032 const struct ip6_hdr *oip;
1033 const struct udphdr *ouh;
1034 u_int dport;
1035 const u_char *ep;
1036 u_int prot;
1037
1038 ndo->ndo_protocol = "icmp6";
1039 dp = (const struct icmp6_hdr *)bp;
1040 ip = (const struct ip6_hdr *)bp2;
1041 oip = (const struct ip6_hdr *)(dp + 1);
1042 /* 'ep' points to the end of available data. */
1043 ep = ndo->ndo_snapend;
1044 if (length == 0) {
1045 ND_PRINT("ICMP6, length 0");
1046 nd_print_invalid(ndo);
1047 return;
1048 }
1049
1050 if (ndo->ndo_vflag && !fragmented) {
1051 uint16_t sum, udp_sum;
1052
1053 if (ND_TTEST_LEN(bp, length)) {
1054 ND_TCHECK_2(dp->icmp6_cksum);
1055 udp_sum = GET_BE_U_2(dp->icmp6_cksum);
1056 sum = icmp6_cksum(ndo, ip, dp, length);
1057 if (sum != 0)
1058 ND_PRINT("[bad icmp6 cksum 0x%04x -> 0x%04x!] ",
1059 udp_sum,
1060 in_cksum_shouldbe(udp_sum, sum));
1061 else
1062 ND_PRINT("[icmp6 sum ok] ");
1063 }
1064 }
1065
1066 ND_TCHECK_1(dp->icmp6_type);
1067 icmp6_type = GET_U_1(dp->icmp6_type);
1068 ND_PRINT("ICMP6, %s", tok2str(icmp6_type_values,"unknown icmp6 type (%u)",icmp6_type));
1069
1070 /* display cosmetics: print the packet length for printer that use the vflag now */
1071 if (ndo->ndo_vflag && (icmp6_type == ND_ROUTER_SOLICIT ||
1072 icmp6_type == ND_ROUTER_ADVERT ||
1073 icmp6_type == ND_NEIGHBOR_ADVERT ||
1074 icmp6_type == ND_NEIGHBOR_SOLICIT ||
1075 icmp6_type == ND_REDIRECT ||
1076 icmp6_type == ICMP6_HADISCOV_REPLY ||
1077 icmp6_type == ICMP6_MOBILEPREFIX_ADVERT ))
1078 ND_PRINT(", length %u", length);
1079
1080 ND_TCHECK_1(dp->icmp6_code);
1081 icmp6_code = GET_U_1(dp->icmp6_code);
1082
1083 switch (icmp6_type) {
1084 case ICMP6_DST_UNREACH:
1085 ND_TCHECK_16(oip->ip6_dst);
1086 ND_PRINT(", %s", tok2str(icmp6_dst_unreach_code_values,"unknown unreach code (%u)",icmp6_code));
1087 switch (icmp6_code) {
1088
1089 case ICMP6_DST_UNREACH_NOROUTE: /* fall through */
1090 case ICMP6_DST_UNREACH_ADMIN:
1091 case ICMP6_DST_UNREACH_ADDR:
1092 ND_PRINT(" %s",ip6addr_string(ndo, oip->ip6_dst));
1093 break;
1094 case ICMP6_DST_UNREACH_BEYONDSCOPE:
1095 ND_PRINT(" %s, source address %s",
1096 ip6addr_string(ndo, oip->ip6_dst),
1097 ip6addr_string(ndo, oip->ip6_src));
1098 break;
1099 case ICMP6_DST_UNREACH_NOPORT:
1100 if ((ouh = get_upperlayer(ndo, (const u_char *)oip, &prot))
1101 == NULL)
1102 goto trunc;
1103
1104 dport = GET_BE_U_2(ouh->uh_dport);
1105 switch (prot) {
1106 case IPPROTO_TCP:
1107 ND_PRINT(", %s tcp port %s",
1108 ip6addr_string(ndo, oip->ip6_dst),
1109 tcpport_string(ndo, dport));
1110 break;
1111 case IPPROTO_UDP:
1112 ND_PRINT(", %s udp port %s",
1113 ip6addr_string(ndo, oip->ip6_dst),
1114 udpport_string(ndo, dport));
1115 break;
1116 default:
1117 ND_PRINT(", %s protocol %u port %u unreachable",
1118 ip6addr_string(ndo, oip->ip6_dst),
1119 prot, dport);
1120 break;
1121 }
1122 break;
1123 default:
1124 if (ndo->ndo_vflag <= 1) {
1125 print_unknown_data(ndo, bp,"\n\t",length);
1126 return;
1127 }
1128 break;
1129 }
1130 break;
1131 case ICMP6_PACKET_TOO_BIG:
1132 ND_TCHECK_4(dp->icmp6_mtu);
1133 ND_PRINT(", mtu %u", GET_BE_U_4(dp->icmp6_mtu));
1134 break;
1135 case ICMP6_TIME_EXCEEDED:
1136 ND_TCHECK_16(oip->ip6_dst);
1137 switch (icmp6_code) {
1138 case ICMP6_TIME_EXCEED_TRANSIT:
1139 ND_PRINT(" for %s",
1140 ip6addr_string(ndo, oip->ip6_dst));
1141 break;
1142 case ICMP6_TIME_EXCEED_REASSEMBLY:
1143 ND_PRINT(" (reassembly)");
1144 break;
1145 default:
1146 ND_PRINT(", unknown code (%u)", icmp6_code);
1147 break;
1148 }
1149 break;
1150 case ICMP6_PARAM_PROB:
1151 ND_TCHECK_16(oip->ip6_dst);
1152 switch (icmp6_code) {
1153 case ICMP6_PARAMPROB_HEADER:
1154 ND_PRINT(", erroneous - octet %u",
1155 GET_BE_U_4(dp->icmp6_pptr));
1156 break;
1157 case ICMP6_PARAMPROB_NEXTHEADER:
1158 ND_PRINT(", next header - octet %u",
1159 GET_BE_U_4(dp->icmp6_pptr));
1160 break;
1161 case ICMP6_PARAMPROB_OPTION:
1162 ND_PRINT(", option - octet %u",
1163 GET_BE_U_4(dp->icmp6_pptr));
1164 break;
1165 default:
1166 ND_PRINT(", code-#%u",
1167 icmp6_code);
1168 break;
1169 }
1170 break;
1171 case ICMP6_ECHO_REQUEST:
1172 case ICMP6_ECHO_REPLY:
1173 /* The check below covers both icmp6_id and icmp6_seq. */
1174 ND_TCHECK_2(dp->icmp6_seq);
1175 ND_PRINT(", id %u, seq %u", GET_BE_U_2(dp->icmp6_id),
1176 GET_BE_U_2(dp->icmp6_seq));
1177 break;
1178 case ICMP6_MEMBERSHIP_QUERY:
1179 if (length == MLD_MINLEN) {
1180 mld6_print(ndo, (const u_char *)dp);
1181 } else if (length >= MLDV2_MINLEN) {
1182 ND_PRINT(" v2");
1183 mldv2_query_print(ndo, (const u_char *)dp, length);
1184 } else {
1185 ND_PRINT(" unknown-version (len %u) ", length);
1186 }
1187 break;
1188 case ICMP6_MEMBERSHIP_REPORT:
1189 mld6_print(ndo, (const u_char *)dp);
1190 break;
1191 case ICMP6_MEMBERSHIP_REDUCTION:
1192 mld6_print(ndo, (const u_char *)dp);
1193 break;
1194 case ND_ROUTER_SOLICIT:
1195 #define RTSOLLEN 8
1196 if (ndo->ndo_vflag) {
1197 if (icmp6_opt_print(ndo, (const u_char *)dp + RTSOLLEN,
1198 length - RTSOLLEN) == -1)
1199 goto trunc;
1200 }
1201 break;
1202 case ND_ROUTER_ADVERT:
1203 #define RTADVLEN 16
1204 if (ndo->ndo_vflag) {
1205 const struct nd_router_advert *p;
1206
1207 p = (const struct nd_router_advert *)dp;
1208 ND_TCHECK_4(p->nd_ra_retransmit);
1209 ND_PRINT("\n\thop limit %u, Flags [%s]"
1210 ", pref %s, router lifetime %us, reachable time %ums, retrans timer %ums",
1211 GET_U_1(p->nd_ra_curhoplimit),
1212 bittok2str(icmp6_opt_ra_flag_values,"none",GET_U_1(p->nd_ra_flags_reserved)),
1213 get_rtpref(GET_U_1(p->nd_ra_flags_reserved)),
1214 GET_BE_U_2(p->nd_ra_router_lifetime),
1215 GET_BE_U_4(p->nd_ra_reachable),
1216 GET_BE_U_4(p->nd_ra_retransmit));
1217
1218 if (icmp6_opt_print(ndo, (const u_char *)dp + RTADVLEN,
1219 length - RTADVLEN) == -1)
1220 goto trunc;
1221 }
1222 break;
1223 case ND_NEIGHBOR_SOLICIT:
1224 {
1225 const struct nd_neighbor_solicit *p;
1226 p = (const struct nd_neighbor_solicit *)dp;
1227 ND_TCHECK_16(p->nd_ns_target);
1228 ND_PRINT(", who has %s", ip6addr_string(ndo, p->nd_ns_target));
1229 if (ndo->ndo_vflag) {
1230 #define NDSOLLEN 24
1231 if (icmp6_opt_print(ndo, (const u_char *)dp + NDSOLLEN,
1232 length - NDSOLLEN) == -1)
1233 goto trunc;
1234 }
1235 }
1236 break;
1237 case ND_NEIGHBOR_ADVERT:
1238 {
1239 const struct nd_neighbor_advert *p;
1240
1241 p = (const struct nd_neighbor_advert *)dp;
1242 ND_TCHECK_16(p->nd_na_target);
1243 ND_PRINT(", tgt is %s",
1244 ip6addr_string(ndo, p->nd_na_target));
1245 if (ndo->ndo_vflag) {
1246 ND_PRINT(", Flags [%s]",
1247 bittok2str(icmp6_nd_na_flag_values,
1248 "none",
1249 GET_BE_U_4(p->nd_na_flags_reserved)));
1250 #define NDADVLEN 24
1251 if (icmp6_opt_print(ndo, (const u_char *)dp + NDADVLEN,
1252 length - NDADVLEN) == -1)
1253 goto trunc;
1254 #undef NDADVLEN
1255 }
1256 }
1257 break;
1258 case ND_REDIRECT:
1259 {
1260 const struct nd_redirect *p;
1261
1262 p = (const struct nd_redirect *)dp;
1263 ND_TCHECK_16(p->nd_rd_dst);
1264 ND_PRINT(", %s", ip6addr_string(ndo, p->nd_rd_dst));
1265 ND_TCHECK_16(p->nd_rd_target);
1266 ND_PRINT(" to %s", ip6addr_string(ndo, p->nd_rd_target));
1267 #define REDIRECTLEN 40
1268 if (ndo->ndo_vflag) {
1269 if (icmp6_opt_print(ndo, (const u_char *)dp + REDIRECTLEN,
1270 length - REDIRECTLEN) == -1)
1271 goto trunc;
1272 #undef REDIRECTLEN
1273 }
1274 }
1275 break;
1276 case ICMP6_ROUTER_RENUMBERING:
1277 icmp6_rrenum_print(ndo, bp, ep);
1278 break;
1279 case ICMP6_NI_QUERY:
1280 case ICMP6_NI_REPLY:
1281 icmp6_nodeinfo_print(ndo, length, bp, ep);
1282 break;
1283 case IND_SOLICIT:
1284 case IND_ADVERT:
1285 break;
1286 case ICMP6_V2_MEMBERSHIP_REPORT:
1287 mldv2_report_print(ndo, (const u_char *) dp, length);
1288 break;
1289 case ICMP6_MOBILEPREFIX_SOLICIT: /* fall through */
1290 case ICMP6_HADISCOV_REQUEST:
1291 ND_TCHECK_2(dp->icmp6_data16[0]);
1292 ND_PRINT(", id 0x%04x", GET_BE_U_2(dp->icmp6_data16[0]));
1293 break;
1294 case ICMP6_HADISCOV_REPLY:
1295 if (ndo->ndo_vflag) {
1296 const u_char *cp;
1297 const u_char *p;
1298
1299 ND_TCHECK_2(dp->icmp6_data16[0]);
1300 ND_PRINT(", id 0x%04x",
1301 GET_BE_U_2(dp->icmp6_data16[0]));
1302 cp = (const u_char *)dp + length;
1303 p = (const u_char *)(dp + 1);
1304 while (p < cp) {
1305 ND_TCHECK_16(p);
1306 ND_PRINT(", %s", ip6addr_string(ndo, p));
1307 p += 16;
1308 }
1309 }
1310 break;
1311 case ICMP6_MOBILEPREFIX_ADVERT:
1312 if (ndo->ndo_vflag) {
1313 uint16_t flags;
1314
1315 ND_TCHECK_2(dp->icmp6_data16[0]);
1316 ND_PRINT(", id 0x%04x",
1317 GET_BE_U_2(dp->icmp6_data16[0]));
1318 ND_TCHECK_2(dp->icmp6_data16[1]);
1319 flags = GET_BE_U_2(dp->icmp6_data16[1]);
1320 if (flags & 0xc000)
1321 ND_PRINT(" ");
1322 if (flags & 0x8000)
1323 ND_PRINT("M");
1324 if (flags & 0x4000)
1325 ND_PRINT("O");
1326 #define MPADVLEN 8
1327 if (icmp6_opt_print(ndo, (const u_char *)dp + MPADVLEN,
1328 length - MPADVLEN) == -1)
1329 goto trunc;
1330 }
1331 break;
1332 case ND_RPL_MESSAGE:
1333 /* plus 4, because struct icmp6_hdr contains 4 bytes of icmp payload */
1334 rpl_print(ndo, icmp6_code, dp->icmp6_data, length-sizeof(struct icmp6_hdr)+4);
1335 break;
1336 default:
1337 ND_PRINT(", length %u", length);
1338 if (ndo->ndo_vflag <= 1)
1339 print_unknown_data(ndo, bp,"\n\t", length);
1340 return;
1341 }
1342 if (!ndo->ndo_vflag)
1343 ND_PRINT(", length %u", length);
1344 return;
1345 trunc:
1346 nd_print_trunc(ndo);
1347 }
1348
1349 static const struct udphdr *
1350 get_upperlayer(netdissect_options *ndo, const u_char *bp, u_int *prot)
1351 {
1352 const u_char *ep;
1353 const struct ip6_hdr *ip6 = (const struct ip6_hdr *)bp;
1354 const struct udphdr *uh;
1355 const struct ip6_hbh *hbh;
1356 const struct ip6_frag *fragh;
1357 const struct ah *ah;
1358 u_int nh;
1359 int hlen;
1360
1361 /* 'ep' points to the end of available data. */
1362 ep = ndo->ndo_snapend;
1363
1364 if (!ND_TTEST_1(ip6->ip6_nxt))
1365 return NULL;
1366
1367 nh = GET_U_1(ip6->ip6_nxt);
1368 hlen = sizeof(struct ip6_hdr);
1369
1370 while (bp < ep) {
1371 bp += hlen;
1372
1373 switch(nh) {
1374 case IPPROTO_UDP:
1375 case IPPROTO_TCP:
1376 uh = (const struct udphdr *)bp;
1377 if (ND_TTEST_2(uh->uh_dport)) {
1378 *prot = nh;
1379 return(uh);
1380 }
1381 else
1382 return(NULL);
1383 /* NOTREACHED */
1384
1385 case IPPROTO_HOPOPTS:
1386 case IPPROTO_DSTOPTS:
1387 case IPPROTO_ROUTING:
1388 hbh = (const struct ip6_hbh *)bp;
1389 if (!ND_TTEST_1(hbh->ip6h_len))
1390 return(NULL);
1391 nh = GET_U_1(hbh->ip6h_nxt);
1392 hlen = (GET_U_1(hbh->ip6h_len) + 1) << 3;
1393 break;
1394
1395 case IPPROTO_FRAGMENT: /* this should be odd, but try anyway */
1396 fragh = (const struct ip6_frag *)bp;
1397 if (!ND_TTEST_2(fragh->ip6f_offlg))
1398 return(NULL);
1399 /* fragments with non-zero offset are meaningless */
1400 if ((GET_BE_U_2(fragh->ip6f_offlg) & IP6F_OFF_MASK) != 0)
1401 return(NULL);
1402 nh = GET_U_1(fragh->ip6f_nxt);
1403 hlen = sizeof(struct ip6_frag);
1404 break;
1405
1406 case IPPROTO_AH:
1407 ah = (const struct ah *)bp;
1408 if (!ND_TTEST_1(ah->ah_len))
1409 return(NULL);
1410 nh = GET_U_1(ah->ah_nxt);
1411 hlen = (GET_U_1(ah->ah_len) + 2) << 2;
1412 break;
1413
1414 default: /* unknown or undecodable header */
1415 *prot = nh; /* meaningless, but set here anyway */
1416 return(NULL);
1417 }
1418 }
1419
1420 return(NULL); /* should be notreached, though */
1421 }
1422
1423 static int
1424 icmp6_opt_print(netdissect_options *ndo, const u_char *bp, int resid)
1425 {
1426 const struct nd_opt_hdr *op;
1427 uint8_t opt_type, opt_len;
1428 const struct nd_opt_prefix_info *opp;
1429 const struct nd_opt_mtu *opm;
1430 const struct nd_opt_rdnss *oprd;
1431 const struct nd_opt_dnssl *opds;
1432 const struct nd_opt_advinterval *opa;
1433 const struct nd_opt_homeagent_info *oph;
1434 const struct nd_opt_route_info *opri;
1435 const u_char *cp, *ep, *domp;
1436 struct in6_addr in6;
1437 size_t l;
1438 u_int i;
1439
1440 cp = bp;
1441 /* 'ep' points to the end of available data. */
1442 ep = ndo->ndo_snapend;
1443
1444 while (cp < ep) {
1445 op = (const struct nd_opt_hdr *)cp;
1446
1447 ND_TCHECK_1(op->nd_opt_len);
1448 if (resid <= 0)
1449 return 0;
1450 opt_type = GET_U_1(op->nd_opt_type);
1451 opt_len = GET_U_1(op->nd_opt_len);
1452 if (opt_len == 0)
1453 goto trunc;
1454 if (cp + (opt_len << 3) > ep)
1455 goto trunc;
1456
1457 ND_PRINT("\n\t %s option (%u), length %u (%u): ",
1458 tok2str(icmp6_opt_values, "unknown", opt_type),
1459 opt_type,
1460 opt_len << 3,
1461 opt_len);
1462
1463 switch (opt_type) {
1464 case ND_OPT_SOURCE_LINKADDR:
1465 l = (opt_len << 3) - 2;
1466 print_lladdr(ndo, cp + 2, l);
1467 break;
1468 case ND_OPT_TARGET_LINKADDR:
1469 l = (opt_len << 3) - 2;
1470 print_lladdr(ndo, cp + 2, l);
1471 break;
1472 case ND_OPT_PREFIX_INFORMATION:
1473 opp = (const struct nd_opt_prefix_info *)op;
1474 ND_TCHECK_16(opp->nd_opt_pi_prefix);
1475 ND_PRINT("%s/%u%s, Flags [%s], valid time %s",
1476 ip6addr_string(ndo, opp->nd_opt_pi_prefix),
1477 GET_U_1(opp->nd_opt_pi_prefix_len),
1478 (opt_len != 4) ? "badlen" : "",
1479 bittok2str(icmp6_opt_pi_flag_values, "none", GET_U_1(opp->nd_opt_pi_flags_reserved)),
1480 get_lifetime(GET_BE_U_4(opp->nd_opt_pi_valid_time)));
1481 ND_PRINT(", pref. time %s",
1482 get_lifetime(GET_BE_U_4(opp->nd_opt_pi_preferred_time)));
1483 break;
1484 case ND_OPT_REDIRECTED_HEADER:
1485 print_unknown_data(ndo, bp,"\n\t ",opt_len<<3);
1486 /* xxx */
1487 break;
1488 case ND_OPT_MTU:
1489 opm = (const struct nd_opt_mtu *)op;
1490 ND_TCHECK_4(opm->nd_opt_mtu_mtu);
1491 ND_PRINT(" %u%s",
1492 GET_BE_U_4(opm->nd_opt_mtu_mtu),
1493 (opt_len != 1) ? "bad option length" : "" );
1494 break;
1495 case ND_OPT_RDNSS:
1496 oprd = (const struct nd_opt_rdnss *)op;
1497 l = (opt_len - 1) / 2;
1498 ND_PRINT(" lifetime %us,",
1499 GET_BE_U_4(oprd->nd_opt_rdnss_lifetime));
1500 for (i = 0; i < l; i++) {
1501 ND_TCHECK_16(oprd->nd_opt_rdnss_addr[i]);
1502 ND_PRINT(" addr: %s",
1503 ip6addr_string(ndo, oprd->nd_opt_rdnss_addr[i]));
1504 }
1505 break;
1506 case ND_OPT_DNSSL:
1507 opds = (const struct nd_opt_dnssl *)op;
1508 ND_PRINT(" lifetime %us, domain(s):",
1509 GET_BE_U_4(opds->nd_opt_dnssl_lifetime));
1510 domp = cp + 8; /* domain names, variable-sized, RFC1035-encoded */
1511 while (domp < cp + (opt_len << 3) && GET_U_1(domp) != '\0')
1512 {
1513 ND_PRINT(" ");
1514 if ((domp = ns_nprint(ndo, domp, bp)) == NULL)
1515 goto trunc;
1516 }
1517 break;
1518 case ND_OPT_ADVINTERVAL:
1519 opa = (const struct nd_opt_advinterval *)op;
1520 ND_TCHECK_4(opa->nd_opt_adv_interval);
1521 ND_PRINT(" %ums",
1522 GET_BE_U_4(opa->nd_opt_adv_interval));
1523 break;
1524 case ND_OPT_HOMEAGENT_INFO:
1525 oph = (const struct nd_opt_homeagent_info *)op;
1526 ND_TCHECK_2(oph->nd_opt_hai_lifetime);
1527 ND_PRINT(" preference %u, lifetime %u",
1528 GET_BE_U_2(oph->nd_opt_hai_preference),
1529 GET_BE_U_2(oph->nd_opt_hai_lifetime));
1530 break;
1531 case ND_OPT_ROUTE_INFO:
1532 opri = (const struct nd_opt_route_info *)op;
1533 ND_TCHECK_4(opri->nd_opt_rti_lifetime);
1534 memset(&in6, 0, sizeof(in6));
1535 switch (opt_len) {
1536 case 1:
1537 break;
1538 case 2:
1539 ND_TCHECK_8(opri + 1);
1540 memcpy(&in6, opri + 1, 8);
1541 break;
1542 case 3:
1543 ND_TCHECK_16(opri + 1);
1544 memcpy(&in6, opri + 1, 16);
1545 break;
1546 default:
1547 goto trunc;
1548 }
1549 ND_PRINT(" %s/%u", ip6addr_string(ndo, (const u_char *)&in6),
1550 GET_U_1(opri->nd_opt_rti_prefixlen));
1551 ND_PRINT(", pref=%s",
1552 get_rtpref(GET_U_1(opri->nd_opt_rti_flags)));
1553 ND_PRINT(", lifetime=%s",
1554 get_lifetime(GET_BE_U_4(opri->nd_opt_rti_lifetime)));
1555 break;
1556 default:
1557 if (ndo->ndo_vflag <= 1) {
1558 print_unknown_data(ndo,cp+2,"\n\t ", (opt_len << 3) - 2); /* skip option header */
1559 return 0;
1560 }
1561 break;
1562 }
1563 /* do we want to see an additional hexdump ? */
1564 if (ndo->ndo_vflag> 1)
1565 print_unknown_data(ndo, cp+2,"\n\t ", (opt_len << 3) - 2); /* skip option header */
1566
1567 cp += opt_len << 3;
1568 resid -= opt_len << 3;
1569 }
1570 return 0;
1571
1572 trunc:
1573 return -1;
1574 }
1575
1576 static void
1577 mld6_print(netdissect_options *ndo, const u_char *bp)
1578 {
1579 const struct mld6_hdr *mp = (const struct mld6_hdr *)bp;
1580 const u_char *ep;
1581
1582 /* 'ep' points to the end of available data. */
1583 ep = ndo->ndo_snapend;
1584
1585 if ((const u_char *)mp + sizeof(*mp) > ep)
1586 return;
1587
1588 ND_PRINT("max resp delay: %u ", GET_BE_U_2(mp->mld6_maxdelay));
1589 ND_PRINT("addr: %s", ip6addr_string(ndo, mp->mld6_addr));
1590 }
1591
1592 static void
1593 mldv2_report_print(netdissect_options *ndo, const u_char *bp, u_int len)
1594 {
1595 const struct icmp6_hdr *icp = (const struct icmp6_hdr *) bp;
1596 u_int group, nsrcs, ngroups;
1597 u_int i, j;
1598
1599 /* Minimum len is 8 */
1600 if (len < 8) {
1601 ND_PRINT(" [invalid len %u]", len);
1602 return;
1603 }
1604
1605 ND_TCHECK_2(icp->icmp6_data16[1]);
1606 ngroups = GET_BE_U_2(icp->icmp6_data16[1]);
1607 ND_PRINT(", %u group record(s)", ngroups);
1608 if (ndo->ndo_vflag > 0) {
1609 /* Print the group records */
1610 group = 8;
1611 for (i = 0; i < ngroups; i++) {
1612 /* type(1) + auxlen(1) + numsrc(2) + grp(16) */
1613 if (len < group + 20) {
1614 ND_PRINT(" [invalid number of groups]");
1615 return;
1616 }
1617 ND_TCHECK_LEN(bp + 4 + group, sizeof(nd_ipv6));
1618 ND_PRINT(" [gaddr %s", ip6addr_string(ndo, bp + group + 4));
1619 ND_PRINT(" %s", tok2str(mldv2report2str, " [v2-report-#%u]",
1620 GET_U_1(bp + group)));
1621 nsrcs = GET_BE_U_2(bp + group + 2);
1622 /* Check the number of sources and print them */
1623 if (len < group + 20 + (nsrcs * sizeof(nd_ipv6))) {
1624 ND_PRINT(" [invalid number of sources %u]", nsrcs);
1625 return;
1626 }
1627 if (ndo->ndo_vflag == 1)
1628 ND_PRINT(", %u source(s)", nsrcs);
1629 else {
1630 /* Print the sources */
1631 ND_PRINT(" {");
1632 for (j = 0; j < nsrcs; j++) {
1633 ND_TCHECK_LEN(bp + group + 20 + (j * sizeof(nd_ipv6)),
1634 sizeof(nd_ipv6));
1635 ND_PRINT(" %s", ip6addr_string(ndo, bp + group + 20 + (j * sizeof(nd_ipv6))));
1636 }
1637 ND_PRINT(" }");
1638 }
1639 /* Next group record */
1640 group += 20 + nsrcs * sizeof(nd_ipv6);
1641 ND_PRINT("]");
1642 }
1643 }
1644 return;
1645 trunc:
1646 nd_print_trunc(ndo);
1647 return;
1648 }
1649
1650 static void
1651 mldv2_query_print(netdissect_options *ndo, const u_char *bp, u_int len)
1652 {
1653 const struct icmp6_hdr *icp = (const struct icmp6_hdr *) bp;
1654 u_int mrc;
1655 u_int mrt, qqi;
1656 u_int nsrcs;
1657 u_int i;
1658
1659 /* Minimum len is 28 */
1660 if (len < 28) {
1661 ND_PRINT(" [invalid len %u]", len);
1662 return;
1663 }
1664 ND_TCHECK_2(icp->icmp6_data16[0]);
1665 mrc = GET_BE_U_2(icp->icmp6_data16[0]);
1666 if (mrc < 32768) {
1667 mrt = mrc;
1668 } else {
1669 mrt = ((mrc & 0x0fff) | 0x1000) << (((mrc & 0x7000) >> 12) + 3);
1670 }
1671 if (ndo->ndo_vflag) {
1672 ND_PRINT(" [max resp delay=%u]", mrt);
1673 }
1674 ND_TCHECK_LEN(bp + 8, sizeof(nd_ipv6));
1675 ND_PRINT(" [gaddr %s", ip6addr_string(ndo, bp + 8));
1676
1677 if (ndo->ndo_vflag) {
1678 ND_TCHECK_1(bp + 25);
1679 if (GET_U_1(bp + 24) & 0x08) {
1680 ND_PRINT(" sflag");
1681 }
1682 if (GET_U_1(bp + 24) & 0x07) {
1683 ND_PRINT(" robustness=%u", GET_U_1(bp + 24) & 0x07);
1684 }
1685 if (GET_U_1(bp + 25) < 128) {
1686 qqi = GET_U_1(bp + 25);
1687 } else {
1688 qqi = ((GET_U_1(bp + 25) & 0x0f) | 0x10) <<
1689 (((GET_U_1(bp + 25) & 0x70) >> 4) + 3);
1690 }
1691 ND_PRINT(" qqi=%u", qqi);
1692 }
1693
1694 ND_TCHECK_2(bp + 26);
1695 nsrcs = GET_BE_U_2(bp + 26);
1696 if (nsrcs > 0) {
1697 if (len < 28 + nsrcs * sizeof(nd_ipv6))
1698 ND_PRINT(" [invalid number of sources]");
1699 else if (ndo->ndo_vflag > 1) {
1700 ND_PRINT(" {");
1701 for (i = 0; i < nsrcs; i++) {
1702 ND_TCHECK_LEN(bp + 28 + (i * sizeof(nd_ipv6)),
1703 sizeof(nd_ipv6));
1704 ND_PRINT(" %s", ip6addr_string(ndo, bp + 28 + (i * sizeof(nd_ipv6))));
1705 }
1706 ND_PRINT(" }");
1707 } else
1708 ND_PRINT(", %u source(s)", nsrcs);
1709 }
1710 ND_PRINT("]");
1711 return;
1712 trunc:
1713 nd_print_trunc(ndo);
1714 return;
1715 }
1716
1717 static void
1718 dnsname_print(netdissect_options *ndo, const u_char *cp, const u_char *ep)
1719 {
1720 int i;
1721
1722 /* DNS name decoding - no decompression */
1723 ND_PRINT(", \"");
1724 while (cp < ep) {
1725 i = GET_U_1(cp);
1726 cp++;
1727 if (i) {
1728 if (i > ep - cp) {
1729 ND_PRINT("???");
1730 break;
1731 }
1732 while (i-- && cp < ep) {
1733 fn_print_char(ndo, GET_U_1(cp));
1734 cp++;
1735 }
1736 if (cp + 1 < ep && GET_U_1(cp))
1737 ND_PRINT(".");
1738 } else {
1739 if (cp == ep) {
1740 /* FQDN */
1741 ND_PRINT(".");
1742 } else if (cp + 1 == ep && GET_U_1(cp) == '\0') {
1743 /* truncated */
1744 } else {
1745 /* invalid */
1746 ND_PRINT("???");
1747 }
1748 break;
1749 }
1750 }
1751 ND_PRINT("\"");
1752 }
1753
1754 static void
1755 icmp6_nodeinfo_print(netdissect_options *ndo, u_int icmp6len, const u_char *bp, const u_char *ep)
1756 {
1757 const struct icmp6_nodeinfo *ni6;
1758 const struct icmp6_hdr *dp;
1759 const u_char *cp;
1760 size_t siz, i;
1761 int needcomma;
1762
1763 if (ep < bp)
1764 return;
1765 dp = (const struct icmp6_hdr *)bp;
1766 ni6 = (const struct icmp6_nodeinfo *)bp;
1767 siz = ep - bp;
1768
1769 switch (GET_U_1(ni6->ni_type)) {
1770 case ICMP6_NI_QUERY:
1771 if (siz == sizeof(*dp) + 4) {
1772 /* KAME who-are-you */
1773 ND_PRINT(" who-are-you request");
1774 break;
1775 }
1776 ND_PRINT(" node information query");
1777
1778 ND_TCHECK_LEN(dp, sizeof(*ni6));
1779 ni6 = (const struct icmp6_nodeinfo *)dp;
1780 ND_PRINT(" ("); /*)*/
1781 switch (GET_BE_U_2(ni6->ni_qtype)) {
1782 case NI_QTYPE_NOOP:
1783 ND_PRINT("noop");
1784 break;
1785 case NI_QTYPE_SUPTYPES:
1786 ND_PRINT("supported qtypes");
1787 i = GET_BE_U_2(ni6->ni_flags);
1788 if (i)
1789 ND_PRINT(" [%s]", (i & 0x01) ? "C" : "");
1790 break;
1791 case NI_QTYPE_FQDN:
1792 ND_PRINT("DNS name");
1793 break;
1794 case NI_QTYPE_NODEADDR:
1795 ND_PRINT("node addresses");
1796 i = GET_BE_U_2(ni6->ni_flags);
1797 if (!i)
1798 break;
1799 /* NI_NODEADDR_FLAG_TRUNCATE undefined for query */
1800 ND_PRINT(" [%s%s%s%s%s%s]",
1801 (i & NI_NODEADDR_FLAG_ANYCAST) ? "a" : "",
1802 (i & NI_NODEADDR_FLAG_GLOBAL) ? "G" : "",
1803 (i & NI_NODEADDR_FLAG_SITELOCAL) ? "S" : "",
1804 (i & NI_NODEADDR_FLAG_LINKLOCAL) ? "L" : "",
1805 (i & NI_NODEADDR_FLAG_COMPAT) ? "C" : "",
1806 (i & NI_NODEADDR_FLAG_ALL) ? "A" : "");
1807 break;
1808 default:
1809 ND_PRINT("unknown");
1810 break;
1811 }
1812
1813 if (GET_BE_U_2(ni6->ni_qtype) == NI_QTYPE_NOOP ||
1814 GET_BE_U_2(ni6->ni_qtype) == NI_QTYPE_SUPTYPES) {
1815 if (siz != sizeof(*ni6))
1816 if (ndo->ndo_vflag)
1817 ND_PRINT(", invalid len");
1818 /*(*/
1819 ND_PRINT(")");
1820 break;
1821 }
1822
1823
1824 /* XXX backward compat, icmp-name-lookup-03 */
1825 if (siz == sizeof(*ni6)) {
1826 ND_PRINT(", 03 draft");
1827 /*(*/
1828 ND_PRINT(")");
1829 break;
1830 }
1831
1832 cp = (const u_char *)(ni6 + 1);
1833 switch (GET_U_1(ni6->ni_code)) {
1834 case ICMP6_NI_SUBJ_IPV6:
1835 if (!ND_TTEST_LEN(dp, sizeof(*ni6) + sizeof(nd_ipv6)))
1836 break;
1837 if (siz != sizeof(*ni6) + sizeof(nd_ipv6)) {
1838 if (ndo->ndo_vflag)
1839 ND_PRINT(", invalid subject len");
1840 break;
1841 }
1842 ND_PRINT(", subject=%s",
1843 ip6addr_string(ndo, cp));
1844 break;
1845 case ICMP6_NI_SUBJ_FQDN:
1846 ND_PRINT(", subject=DNS name");
1847 if (GET_U_1(cp) == ep - cp - 1) {
1848 /* icmp-name-lookup-03, pascal string */
1849 if (ndo->ndo_vflag)
1850 ND_PRINT(", 03 draft");
1851 cp++;
1852 ND_PRINT(", \"");
1853 while (cp < ep) {
1854 fn_print_char(ndo, GET_U_1(cp));
1855 cp++;
1856 }
1857 ND_PRINT("\"");
1858 } else
1859 dnsname_print(ndo, cp, ep);
1860 break;
1861 case ICMP6_NI_SUBJ_IPV4:
1862 if (!ND_TTEST_LEN(dp, sizeof(*ni6) + sizeof(nd_ipv4)))
1863 break;
1864 if (siz != sizeof(*ni6) + sizeof(nd_ipv4)) {
1865 if (ndo->ndo_vflag)
1866 ND_PRINT(", invalid subject len");
1867 break;
1868 }
1869 ND_PRINT(", subject=%s",
1870 ipaddr_string(ndo, cp));
1871 break;
1872 default:
1873 ND_PRINT(", unknown subject");
1874 break;
1875 }
1876
1877 /*(*/
1878 ND_PRINT(")");
1879 break;
1880
1881 case ICMP6_NI_REPLY:
1882 if (icmp6len > siz)
1883 goto trunc;
1884
1885 needcomma = 0;
1886
1887 ND_TCHECK_LEN(dp, sizeof(*ni6));
1888 ni6 = (const struct icmp6_nodeinfo *)dp;
1889 ND_PRINT(" node information reply");
1890 ND_PRINT(" ("); /*)*/
1891 switch (GET_U_1(ni6->ni_code)) {
1892 case ICMP6_NI_SUCCESS:
1893 if (ndo->ndo_vflag) {
1894 ND_PRINT("success");
1895 needcomma++;
1896 }
1897 break;
1898 case ICMP6_NI_REFUSED:
1899 ND_PRINT("refused");
1900 needcomma++;
1901 if (siz != sizeof(*ni6))
1902 if (ndo->ndo_vflag)
1903 ND_PRINT(", invalid length");
1904 break;
1905 case ICMP6_NI_UNKNOWN:
1906 ND_PRINT("unknown");
1907 needcomma++;
1908 if (siz != sizeof(*ni6))
1909 if (ndo->ndo_vflag)
1910 ND_PRINT(", invalid length");
1911 break;
1912 }
1913
1914 if (GET_U_1(ni6->ni_code) != ICMP6_NI_SUCCESS) {
1915 /*(*/
1916 ND_PRINT(")");
1917 break;
1918 }
1919
1920 switch (GET_BE_U_2(ni6->ni_qtype)) {
1921 case NI_QTYPE_NOOP:
1922 if (needcomma)
1923 ND_PRINT(", ");
1924 ND_PRINT("noop");
1925 if (siz != sizeof(*ni6))
1926 if (ndo->ndo_vflag)
1927 ND_PRINT(", invalid length");
1928 break;
1929 case NI_QTYPE_SUPTYPES:
1930 if (needcomma)
1931 ND_PRINT(", ");
1932 ND_PRINT("supported qtypes");
1933 i = GET_BE_U_2(ni6->ni_flags);
1934 if (i)
1935 ND_PRINT(" [%s]", (i & 0x01) ? "C" : "");
1936 break;
1937 case NI_QTYPE_FQDN:
1938 if (needcomma)
1939 ND_PRINT(", ");
1940 ND_PRINT("DNS name");
1941 cp = (const u_char *)(ni6 + 1) + 4;
1942 ND_TCHECK_1(cp);
1943 if (GET_U_1(cp) == ep - cp - 1) {
1944 /* icmp-name-lookup-03, pascal string */
1945 if (ndo->ndo_vflag)
1946 ND_PRINT(", 03 draft");
1947 cp++;
1948 ND_PRINT(", \"");
1949 while (cp < ep) {
1950 fn_print_char(ndo, GET_U_1(cp));
1951 cp++;
1952 }
1953 ND_PRINT("\"");
1954 } else
1955 dnsname_print(ndo, cp, ep);
1956 if ((GET_BE_U_2(ni6->ni_flags) & 0x01) != 0)
1957 ND_PRINT(" [TTL=%u]", GET_BE_U_4(ni6 + 1));
1958 break;
1959 case NI_QTYPE_NODEADDR:
1960 if (needcomma)
1961 ND_PRINT(", ");
1962 ND_PRINT("node addresses");
1963 i = sizeof(*ni6);
1964 while (i < siz) {
1965 if (i + sizeof(uint32_t) + sizeof(nd_ipv6) > siz)
1966 break;
1967 ND_PRINT(" %s(%u)",
1968 ip6addr_string(ndo, bp + i + sizeof(uint32_t)),
1969 GET_BE_U_4(bp + i));
1970 i += sizeof(uint32_t) + sizeof(nd_ipv6);
1971 }
1972 i = GET_BE_U_2(ni6->ni_flags);
1973 if (!i)
1974 break;
1975 ND_PRINT(" [%s%s%s%s%s%s%s]",
1976 (i & NI_NODEADDR_FLAG_ANYCAST) ? "a" : "",
1977 (i & NI_NODEADDR_FLAG_GLOBAL) ? "G" : "",
1978 (i & NI_NODEADDR_FLAG_SITELOCAL) ? "S" : "",
1979 (i & NI_NODEADDR_FLAG_LINKLOCAL) ? "L" : "",
1980 (i & NI_NODEADDR_FLAG_COMPAT) ? "C" : "",
1981 (i & NI_NODEADDR_FLAG_ALL) ? "A" : "",
1982 (i & NI_NODEADDR_FLAG_TRUNCATE) ? "T" : "");
1983 break;
1984 default:
1985 if (needcomma)
1986 ND_PRINT(", ");
1987 ND_PRINT("unknown");
1988 break;
1989 }
1990
1991 /*(*/
1992 ND_PRINT(")");
1993 break;
1994 }
1995 return;
1996
1997 trunc:
1998 nd_print_trunc(ndo);
1999 }
2000
2001 static void
2002 icmp6_rrenum_print(netdissect_options *ndo, const u_char *bp, const u_char *ep)
2003 {
2004 const struct icmp6_router_renum *rr6;
2005 const char *cp;
2006 const struct rr_pco_match *match;
2007 const struct rr_pco_use *use;
2008 char hbuf[NI_MAXHOST];
2009 int n;
2010
2011 if (ep < bp)
2012 return;
2013 rr6 = (const struct icmp6_router_renum *)bp;
2014 cp = (const char *)(rr6 + 1);
2015
2016 ND_TCHECK_4(rr6->rr_reserved);
2017 switch (GET_U_1(rr6->rr_code)) {
2018 case ICMP6_ROUTER_RENUMBERING_COMMAND:
2019 ND_PRINT("router renum: command");
2020 break;
2021 case ICMP6_ROUTER_RENUMBERING_RESULT:
2022 ND_PRINT("router renum: result");
2023 break;
2024 case ICMP6_ROUTER_RENUMBERING_SEQNUM_RESET:
2025 ND_PRINT("router renum: sequence number reset");
2026 break;
2027 default:
2028 ND_PRINT("router renum: code-#%u", GET_U_1(rr6->rr_code));
2029 break;
2030 }
2031
2032 ND_PRINT(", seq=%u", GET_BE_U_4(rr6->rr_seqnum));
2033
2034 if (ndo->ndo_vflag) {
2035 uint8_t rr_flags = GET_U_1(rr6->rr_flags);
2036 #define F(x, y) (rr_flags & (x) ? (y) : "")
2037 ND_PRINT("["); /*]*/
2038 if (rr_flags) {
2039 ND_PRINT("%s%s%s%s%s,", F(ICMP6_RR_FLAGS_TEST, "T"),
2040 F(ICMP6_RR_FLAGS_REQRESULT, "R"),
2041 F(ICMP6_RR_FLAGS_FORCEAPPLY, "A"),
2042 F(ICMP6_RR_FLAGS_SPECSITE, "S"),
2043 F(ICMP6_RR_FLAGS_PREVDONE, "P"));
2044 }
2045 ND_PRINT("seg=%u,", GET_U_1(rr6->rr_segnum));
2046 ND_PRINT("maxdelay=%u", GET_BE_U_2(rr6->rr_maxdelay));
2047 if (GET_BE_U_4(rr6->rr_reserved))
2048 ND_PRINT("rsvd=0x%x", GET_BE_U_4(rr6->rr_reserved));
2049 /*[*/
2050 ND_PRINT("]");
2051 #undef F
2052 }
2053
2054 if (GET_U_1(rr6->rr_code) == ICMP6_ROUTER_RENUMBERING_COMMAND) {
2055 match = (const struct rr_pco_match *)cp;
2056 cp = (const char *)(match + 1);
2057
2058 ND_TCHECK_16(match->rpm_prefix);
2059
2060 if (ndo->ndo_vflag > 1)
2061 ND_PRINT("\n\t");
2062 else
2063 ND_PRINT(" ");
2064 ND_PRINT("match("); /*)*/
2065 switch (GET_U_1(match->rpm_code)) {
2066 case RPM_PCO_ADD: ND_PRINT("add"); break;
2067 case RPM_PCO_CHANGE: ND_PRINT("change"); break;
2068 case RPM_PCO_SETGLOBAL: ND_PRINT("setglobal"); break;
2069 default: ND_PRINT("#%u",
2070 GET_U_1(match->rpm_code)); break;
2071 }
2072
2073 if (ndo->ndo_vflag) {
2074 ND_PRINT(",ord=%u", GET_U_1(match->rpm_ordinal));
2075 ND_PRINT(",min=%u", GET_U_1(match->rpm_minlen));
2076 ND_PRINT(",max=%u", GET_U_1(match->rpm_maxlen));
2077 }
2078 if (addrtostr6(match->rpm_prefix, hbuf, sizeof(hbuf)))
2079 ND_PRINT(",%s/%u", hbuf, GET_U_1(match->rpm_matchlen));
2080 else
2081 ND_PRINT(",?/%u", GET_U_1(match->rpm_matchlen));
2082 /*(*/
2083 ND_PRINT(")");
2084
2085 n = GET_U_1(match->rpm_len) - 3;
2086 if (n % 4)
2087 goto trunc;
2088 n /= 4;
2089 while (n-- > 0) {
2090 use = (const struct rr_pco_use *)cp;
2091 cp = (const char *)(use + 1);
2092
2093 ND_TCHECK_16(use->rpu_prefix);
2094
2095 if (ndo->ndo_vflag > 1)
2096 ND_PRINT("\n\t");
2097 else
2098 ND_PRINT(" ");
2099 ND_PRINT("use("); /*)*/
2100 if (GET_U_1(use->rpu_flags)) {
2101 #define F(x, y) (GET_U_1(use->rpu_flags) & (x) ? (y) : "")
2102 ND_PRINT("%s%s,",
2103 F(ICMP6_RR_PCOUSE_FLAGS_DECRVLTIME, "V"),
2104 F(ICMP6_RR_PCOUSE_FLAGS_DECRPLTIME, "P"));
2105 #undef F
2106 }
2107 if (ndo->ndo_vflag) {
2108 ND_PRINT("mask=0x%x,",
2109 GET_U_1(use->rpu_ramask));
2110 ND_PRINT("raflags=0x%x,",
2111 GET_U_1(use->rpu_raflags));
2112 if (GET_BE_U_4(use->rpu_vltime) == 0xffffffff)
2113 ND_PRINT("vltime=infty,");
2114 else
2115 ND_PRINT("vltime=%u,",
2116 GET_BE_U_4(use->rpu_vltime));
2117 if (GET_BE_U_4(use->rpu_pltime) == 0xffffffff)
2118 ND_PRINT("pltime=infty,");
2119 else
2120 ND_PRINT("pltime=%u,",
2121 GET_BE_U_4(use->rpu_pltime));
2122 }
2123 if (addrtostr6(use->rpu_prefix, hbuf, sizeof(hbuf)))
2124 ND_PRINT("%s/%u/%u", hbuf,
2125 GET_U_1(use->rpu_uselen),
2126 GET_U_1(use->rpu_keeplen));
2127 else
2128 ND_PRINT("?/%u/%u", GET_U_1(use->rpu_uselen),
2129 GET_U_1(use->rpu_keeplen));
2130 /*(*/
2131 ND_PRINT(")");
2132 }
2133 }
2134
2135 return;
2136
2137 trunc:
2138 nd_print_trunc(ndo);
2139 }
[mirror] the TCPdump network dissector