X-Git-Url: https://git.tcpdump.org/tcpdump/blobdiff_plain/cc7b519792b78b74e898e63e90e959dc6dc43e33..ffa1470e5c7ff0e50028d085a481dc797b0b51ed:/print-icmp6.c diff --git a/print-icmp6.c b/print-icmp6.c index 1b47c89c..5bf0f7e1 100644 --- a/print-icmp6.c +++ b/print-icmp6.c @@ -20,8 +20,8 @@ */ #ifndef lint -static const char rcsid[] = - "@(#) $Header: /tcpdump/master/tcpdump/print-icmp6.c,v 1.52 2001-06-01 04:08:57 itojun Exp $"; +static const char rcsid[] _U_ = + "@(#) $Header: /tcpdump/master/tcpdump/print-icmp6.c,v 1.79.2.6 2005-09-05 09:29:28 guy Exp $"; #endif #ifdef HAVE_CONFIG_H @@ -30,26 +30,18 @@ static const char rcsid[] = #ifdef INET6 -#include - -#include -#include -#include -#include - - -#include - -#include +#include #include -#include - -#include "ip6.h" -#include "icmp6.h" +#include #include "interface.h" #include "addrtoname.h" +#include "extract.h" + +#include "ip6.h" +#include "icmp6.h" +#include "ipproto.h" #include "udp.h" #include "ah.h" @@ -57,20 +49,104 @@ static const char rcsid[] = static const char *get_rtpref(u_int); static const char *get_lifetime(u_int32_t); static void print_lladdr(const u_char *, size_t); -void icmp6_opt_print(const u_char *, int); -void mld6_print(const u_char *); -static struct udphdr *get_upperlayer(u_char *, int *); +static void icmp6_opt_print(const u_char *, int); +static void mld6_print(const u_char *); +static void mldv2_report_print(const u_char *, u_int); +static void mldv2_query_print(const u_char *, u_int); +static struct udphdr *get_upperlayer(u_char *, u_int *); static void dnsname_print(const u_char *, const u_char *); -void icmp6_nodeinfo_print(int, const u_char *, const u_char *); -void icmp6_rrenum_print(int, const u_char *, const u_char *); +static void icmp6_nodeinfo_print(u_int, const u_char *, const u_char *); +static void icmp6_rrenum_print(const u_char *, const u_char *); #ifndef abs #define abs(a) ((0 < (a)) ? (a) : -(a)) #endif -#ifndef ND_RA_FLAG_RTPREF_MASK -#define ND_RA_FLAG_RTPREF_MASK 0x18 -#endif +static struct tok icmp6_type_values[] = { + { ICMP6_DST_UNREACH, "destination unreachable"}, + { ICMP6_PACKET_TOO_BIG, "packet too big"}, + { ICMP6_TIME_EXCEEDED, "time exceeded in-transit"}, + { ICMP6_PARAM_PROB, "parameter problem"}, + { ICMP6_ECHO_REQUEST, "echo request"}, + { ICMP6_ECHO_REPLY, "echo reply"}, + { MLD6_LISTENER_QUERY, "multicast listener query"}, + { MLD6_LISTENER_REPORT, "multicast listener report"}, + { MLD6_LISTENER_DONE, "multicast listener done"}, + { ND_ROUTER_SOLICIT, "router solicitation"}, + { ND_ROUTER_ADVERT, "router advertisement"}, + { ND_NEIGHBOR_SOLICIT, "neighbor solicitation"}, + { ND_NEIGHBOR_ADVERT, "neighbor advertisement"}, + { ND_REDIRECT, "redirect"}, + { ICMP6_ROUTER_RENUMBERING, "router renumbering"}, + { IND_SOLICIT, "inverse neighbor solicitation"}, + { IND_ADVERT, "inverse neighbor advertisement"}, + { MLDV2_LISTENER_REPORT, "multicast listener report v2"}, + { ICMP6_HADISCOV_REQUEST, "ha discovery request"}, + { ICMP6_HADISCOV_REPLY, "ha discovery reply"}, + { ICMP6_MOBILEPREFIX_SOLICIT, "mobile router solicitation"}, + { ICMP6_MOBILEPREFIX_ADVERT, "mobile router advertisement"}, + { ICMP6_WRUREQUEST, "who-are-you request"}, + { ICMP6_WRUREPLY, "who-are-you reply"}, + { ICMP6_NI_QUERY, "node information query"}, + { ICMP6_NI_REPLY, "node information reply"}, + { MLD6_MTRACE, "mtrace message"}, + { MLD6_MTRACE_RESP, "mtrace response"}, + { 0, NULL } +}; + +static struct tok icmp6_dst_unreach_code_values[] = { + { ICMP6_DST_UNREACH_NOROUTE, "unreachable route" }, + { ICMP6_DST_UNREACH_ADMIN, " unreachable prohibited"}, + { ICMP6_DST_UNREACH_BEYONDSCOPE, "beyond scope"}, + { ICMP6_DST_UNREACH_ADDR, "unreachable address"}, + { ICMP6_DST_UNREACH_NOPORT, "unreachable port"}, + { 0, NULL } +}; + +static struct tok icmp6_opt_pi_flag_values[] = { + { ND_OPT_PI_FLAG_ONLINK, "onlink" }, + { ND_OPT_PI_FLAG_AUTO, "auto" }, + { ND_OPT_PI_FLAG_ROUTER, "router" }, + { 0, NULL } +}; + +static struct tok icmp6_opt_ra_flag_values[] = { + { ND_RA_FLAG_MANAGED, "managed" }, + { ND_RA_FLAG_OTHER, "other stateful"}, + { ND_RA_FLAG_HOME_AGENT, "home agent"}, + { 0, NULL } +}; + +static struct tok icmp6_nd_na_flag_values[] = { + { ND_NA_FLAG_ROUTER, "router" }, + { ND_NA_FLAG_SOLICITED, "solicited" }, + { ND_NA_FLAG_OVERRIDE, "override" }, + { 0, NULL } +}; + + +static struct tok icmp6_opt_values[] = { + { ND_OPT_SOURCE_LINKADDR, "source link-address"}, + { ND_OPT_TARGET_LINKADDR, "destination link-address"}, + { ND_OPT_PREFIX_INFORMATION, "prefix info"}, + { ND_OPT_REDIRECTED_HEADER, "redirected header"}, + { ND_OPT_MTU, "mtu"}, + { ND_OPT_ADVINTERVAL, "advertisement interval"}, + { ND_OPT_HOMEAGENT_INFO, "homeagent information"}, + { ND_OPT_ROUTE_INFO, "route info"}, + { 0, NULL } +}; + +/* mldv2 report types */ +static struct tok mldv2report2str[] = { + { 1, "is_in" }, + { 2, "is_ex" }, + { 3, "to_in" }, + { 4, "to_ex" }, + { 5, "allow" }, + { 6, "block" }, + { 0, NULL } +}; static const char * get_rtpref(u_int v) @@ -113,111 +189,157 @@ print_lladdr(const u_int8_t *p, size_t l) } } +static int icmp6_cksum(const struct ip6_hdr *ip6, const struct icmp6_hdr *icp, + u_int len) +{ + size_t i; + register const u_int16_t *sp; + u_int32_t sum; + union { + struct { + struct in6_addr ph_src; + struct in6_addr ph_dst; + u_int32_t ph_len; + u_int8_t ph_zero[3]; + u_int8_t ph_nxt; + } ph; + u_int16_t pa[20]; + } phu; + + /* pseudo-header */ + memset(&phu, 0, sizeof(phu)); + phu.ph.ph_src = ip6->ip6_src; + phu.ph.ph_dst = ip6->ip6_dst; + phu.ph.ph_len = htonl(len); + phu.ph.ph_nxt = IPPROTO_ICMPV6; + + sum = 0; + for (i = 0; i < sizeof(phu.pa) / sizeof(phu.pa[0]); i++) + sum += phu.pa[i]; + + sp = (const u_int16_t *)icp; + + for (i = 0; i < (len & ~1); i += 2) + sum += *sp++; + + if (len & 1) + sum += htons((*(const u_int8_t *)sp) << 8); + + while (sum > 0xffff) + sum = (sum & 0xffff) + (sum >> 16); + sum = ~sum & 0xffff; + + return (sum); +} + void -icmp6_print(const u_char *bp, const u_char *bp2) +icmp6_print(const u_char *bp, u_int length, const u_char *bp2, int fragmented) { const struct icmp6_hdr *dp; const struct ip6_hdr *ip; - const char *str; const struct ip6_hdr *oip; const struct udphdr *ouh; int dport; const u_char *ep; - char buf[256]; - int icmp6len, prot; - -#if 0 -#define TCHECK(var) if ((u_char *)&(var) > ep - sizeof(var)) goto trunc -#endif + u_int prot; dp = (struct icmp6_hdr *)bp; ip = (struct ip6_hdr *)bp2; oip = (struct ip6_hdr *)(dp + 1); - str = buf; /* 'ep' points to the end of available data. */ ep = snapend; - if (ip->ip6_plen) - icmp6len = (ntohs(ip->ip6_plen) + sizeof(struct ip6_hdr) - - (bp - bp2)); - else /* XXX: jumbo payload case... */ - icmp6len = snapend - bp; - -#if 0 - (void)printf("%s > %s: ", - ip6addr_string(&ip->ip6_src), - ip6addr_string(&ip->ip6_dst)); -#endif - TCHECK(dp->icmp6_code); + TCHECK(dp->icmp6_cksum); + + if (vflag && !fragmented) { + int sum = dp->icmp6_cksum; + + if (TTEST2(bp[0], length)) { + sum = icmp6_cksum(ip, dp, length); + if (sum != 0) + (void)printf("[bad icmp6 cksum %x!] ", sum); + else + (void)printf("[icmp6 sum ok] "); + } + } + + printf("ICMP6, %s", tok2str(icmp6_type_values,"unknown icmp6 type (%u)",dp->icmp6_type)); + + /* display cosmetics: print the packet length for printer that use the vflag now */ + if (vflag && (dp->icmp6_type == + ND_ROUTER_SOLICIT || + ND_ROUTER_ADVERT || + ND_NEIGHBOR_ADVERT || + ND_NEIGHBOR_SOLICIT || + ND_REDIRECT || + ICMP6_HADISCOV_REPLY || + ICMP6_MOBILEPREFIX_ADVERT )) + printf(", length %u", length); + switch (dp->icmp6_type) { case ICMP6_DST_UNREACH: TCHECK(oip->ip6_dst); + printf(", %s", tok2str(icmp6_dst_unreach_code_values,"unknown unreach code (%u)",dp->icmp6_code)); switch (dp->icmp6_code) { - case ICMP6_DST_UNREACH_NOROUTE: - printf("icmp6: %s unreachable route", - ip6addr_string(&oip->ip6_dst)); - break; + + case ICMP6_DST_UNREACH_NOROUTE: /* fall through */ case ICMP6_DST_UNREACH_ADMIN: - printf("icmp6: %s unreachable prohibited", - ip6addr_string(&oip->ip6_dst)); - break; + case ICMP6_DST_UNREACH_ADDR: + printf(" %s",ip6addr_string(&oip->ip6_dst)); + break; case ICMP6_DST_UNREACH_BEYONDSCOPE: - printf("icmp6: %s beyond scope of source address %s", + printf(" %s, source address %s", ip6addr_string(&oip->ip6_dst), ip6addr_string(&oip->ip6_src)); break; - case ICMP6_DST_UNREACH_ADDR: - printf("icmp6: %s unreachable address", - ip6addr_string(&oip->ip6_dst)); - break; case ICMP6_DST_UNREACH_NOPORT: if ((ouh = get_upperlayer((u_char *)oip, &prot)) == NULL) goto trunc; - dport = ntohs(ouh->uh_dport); + dport = EXTRACT_16BITS(&ouh->uh_dport); switch (prot) { case IPPROTO_TCP: - printf("icmp6: %s tcp port %s unreachable", + printf(", %s tcp port %s", ip6addr_string(&oip->ip6_dst), tcpport_string(dport)); break; case IPPROTO_UDP: - printf("icmp6: %s udp port %s unreachable", + printf(", %s udp port %s", ip6addr_string(&oip->ip6_dst), udpport_string(dport)); break; default: - printf("icmp6: %s protocol %d port %d unreachable", + printf(", %s protocol %d port %d unreachable", ip6addr_string(&oip->ip6_dst), oip->ip6_nxt, dport); break; } break; default: - printf("icmp6: %s unreachable code-#%d", - ip6addr_string(&oip->ip6_dst), - dp->icmp6_code); - break; + if (vflag <= 1) { + print_unknown_data(bp,"\n\t",length); + return; + } + break; } break; case ICMP6_PACKET_TOO_BIG: TCHECK(dp->icmp6_mtu); - printf("icmp6: too big %u", (u_int32_t)ntohl(dp->icmp6_mtu)); + printf(", mtu %u", EXTRACT_32BITS(&dp->icmp6_mtu)); break; case ICMP6_TIME_EXCEEDED: TCHECK(oip->ip6_dst); switch (dp->icmp6_code) { case ICMP6_TIME_EXCEED_TRANSIT: - printf("icmp6: time exceeded in-transit for %s", + printf(" for %s", ip6addr_string(&oip->ip6_dst)); break; case ICMP6_TIME_EXCEED_REASSEMBLY: - printf("icmp6: ip6 reassembly time exceeded"); + printf(" (reassembly)"); break; default: - printf("icmp6: time exceeded code-#%d", - dp->icmp6_code); + printf(", unknown code (%u)", dp->icmp6_code); break; } break; @@ -225,82 +347,66 @@ icmp6_print(const u_char *bp, const u_char *bp2) TCHECK(oip->ip6_dst); switch (dp->icmp6_code) { case ICMP6_PARAMPROB_HEADER: - printf("icmp6: parameter problem errorneous - octet %u", - (u_int32_t)ntohl(dp->icmp6_pptr)); + printf(", errorneous - octet %u", EXTRACT_32BITS(&dp->icmp6_pptr)); break; case ICMP6_PARAMPROB_NEXTHEADER: - printf("icmp6: parameter problem next header - octet %u", - (u_int32_t)ntohl(dp->icmp6_pptr)); + printf(", next header - octet %u", EXTRACT_32BITS(&dp->icmp6_pptr)); break; case ICMP6_PARAMPROB_OPTION: - printf("icmp6: parameter problem option - octet %u", - (u_int32_t)ntohl(dp->icmp6_pptr)); + printf(", option - octet %u", EXTRACT_32BITS(&dp->icmp6_pptr)); break; default: - printf("icmp6: parameter problem code-#%d", + printf(", code-#%d", dp->icmp6_code); break; } break; case ICMP6_ECHO_REQUEST: - printf("icmp6: echo request"); - break; case ICMP6_ECHO_REPLY: - printf("icmp6: echo reply"); + TCHECK(dp->icmp6_seq); + printf(", seq %u", EXTRACT_16BITS(&dp->icmp6_seq)); break; case ICMP6_MEMBERSHIP_QUERY: - printf("icmp6: multicast listener query "); - mld6_print((const u_char *)dp); + if (length == MLD_MINLEN) { + mld6_print((const u_char *)dp); + } else if (length >= MLDV2_MINLEN) { + printf("v2 "); + mldv2_query_print((const u_char *)dp, length); + } else { + printf(" unknown-version (len %u) ", length); + } break; case ICMP6_MEMBERSHIP_REPORT: - printf("icmp6: multicast listener report "); mld6_print((const u_char *)dp); break; case ICMP6_MEMBERSHIP_REDUCTION: - printf("icmp6: multicast listener done "); mld6_print((const u_char *)dp); break; case ND_ROUTER_SOLICIT: - printf("icmp6: router solicitation "); - if (vflag) { #define RTSOLLEN 8 + if (vflag) { icmp6_opt_print((const u_char *)dp + RTSOLLEN, - icmp6len - RTSOLLEN); + length - RTSOLLEN); } break; case ND_ROUTER_ADVERT: - printf("icmp6: router advertisement"); +#define RTADVLEN 16 if (vflag) { struct nd_router_advert *p; p = (struct nd_router_advert *)dp; TCHECK(p->nd_ra_retransmit); - printf("(chlim=%d, ", (int)p->nd_ra_curhoplimit); - if (p->nd_ra_flags_reserved & ND_RA_FLAG_MANAGED) - printf("M"); - if (p->nd_ra_flags_reserved & ND_RA_FLAG_OTHER) - printf("O"); -#ifndef ND_RA_FLAG_HA -#define ND_RA_FLAG_HA 0x20 -#endif - if (p->nd_ra_flags_reserved & ND_RA_FLAG_HA) - printf("H"); + printf("\n\thop limit %u, Flags [%s]" \ + ", pref %s, router lifetime %us, reachable time %us, retrans time %us", + (u_int)p->nd_ra_curhoplimit, + bittok2str(icmp6_opt_ra_flag_values,"none",(p->nd_ra_flags_reserved)), + get_rtpref(p->nd_ra_flags_reserved), + EXTRACT_16BITS(&p->nd_ra_router_lifetime), + EXTRACT_32BITS(&p->nd_ra_reachable), + EXTRACT_32BITS(&p->nd_ra_retransmit)); - if ((p->nd_ra_flags_reserved & ~ND_RA_FLAG_RTPREF_MASK) - != 0) - printf(" "); - - printf("pref=%s, ", - get_rtpref(p->nd_ra_flags_reserved)); - - printf("router_ltime=%d, ", ntohs(p->nd_ra_router_lifetime)); - printf("reachable_time=%u, ", - (u_int32_t)ntohl(p->nd_ra_reachable)); - printf("retrans_time=%u)", - (u_int32_t)ntohl(p->nd_ra_retransmit)); -#define RTADVLEN 16 icmp6_opt_print((const u_char *)dp + RTADVLEN, - icmp6len - RTADVLEN); + length - RTADVLEN); } break; case ND_NEIGHBOR_SOLICIT: @@ -308,12 +414,11 @@ icmp6_print(const u_char *bp, const u_char *bp2) struct nd_neighbor_solicit *p; p = (struct nd_neighbor_solicit *)dp; TCHECK(p->nd_ns_target); - printf("icmp6: neighbor sol: who has %s", - ip6addr_string(&p->nd_ns_target)); + printf(", who has %s", ip6addr_string(&p->nd_ns_target)); if (vflag) { #define NDSOLLEN 24 icmp6_opt_print((const u_char *)dp + NDSOLLEN, - icmp6len - NDSOLLEN); + length - NDSOLLEN); } } break; @@ -323,29 +428,16 @@ icmp6_print(const u_char *bp, const u_char *bp2) p = (struct nd_neighbor_advert *)dp; TCHECK(p->nd_na_target); - printf("icmp6: neighbor adv: tgt is %s", + printf(", tgt is %s", ip6addr_string(&p->nd_na_target)); if (vflag) { -#define ND_NA_FLAG_ALL \ - (ND_NA_FLAG_ROUTER|ND_NA_FLAG_SOLICITED|ND_NA_FLAG_OVERRIDE) - /* we don't need ntohl() here. see advanced-api-04. */ - if (p->nd_na_flags_reserved & ND_NA_FLAG_ALL) { -#undef ND_NA_FLAG_ALL - u_int32_t flags; - - flags = p->nd_na_flags_reserved; - printf("("); - if (flags & ND_NA_FLAG_ROUTER) - printf("R"); - if (flags & ND_NA_FLAG_SOLICITED) - printf("S"); - if (flags & ND_NA_FLAG_OVERRIDE) - printf("O"); - printf(")"); - } + printf(", Flags [%s]", + bittok2str(icmp6_nd_na_flag_values, + "none", + EXTRACT_32BITS(&p->nd_na_flags_reserved))); #define NDADVLEN 24 icmp6_opt_print((const u_char *)dp + NDADVLEN, - icmp6len - NDADVLEN); + length - NDADVLEN); #undef NDADVLEN } } @@ -353,39 +445,81 @@ icmp6_print(const u_char *bp, const u_char *bp2) case ND_REDIRECT: #define RDR(i) ((struct nd_redirect *)(i)) TCHECK(RDR(dp)->nd_rd_dst); - printf("icmp6: redirect %s", - getname6((const u_char *)&RDR(dp)->nd_rd_dst)); + printf(", %s", getname6((const u_char *)&RDR(dp)->nd_rd_dst)); + TCHECK(RDR(dp)->nd_rd_target); printf(" to %s", getname6((const u_char*)&RDR(dp)->nd_rd_target)); #define REDIRECTLEN 40 if (vflag) { icmp6_opt_print((const u_char *)dp + REDIRECTLEN, - icmp6len - REDIRECTLEN); + length - REDIRECTLEN); } break; #undef REDIRECTLEN #undef RDR case ICMP6_ROUTER_RENUMBERING: - icmp6_rrenum_print(icmp6len, bp, ep); + icmp6_rrenum_print(bp, ep); break; case ICMP6_NI_QUERY: case ICMP6_NI_REPLY: - icmp6_nodeinfo_print(icmp6len, bp, ep); + icmp6_nodeinfo_print(length, bp, ep); break; - default: - printf("icmp6: type-#%d", dp->icmp6_type); + case IND_SOLICIT: + case IND_ADVERT: break; - } + case ICMP6_V2_MEMBERSHIP_REPORT: + mldv2_report_print((const u_char *) dp, length); + break; + case ICMP6_MOBILEPREFIX_SOLICIT: /* fall through */ + case ICMP6_HADISCOV_REQUEST: + TCHECK(dp->icmp6_data16[0]); + printf(", id 0x%04x", EXTRACT_16BITS(&dp->icmp6_data16[0])); + break; + case ICMP6_HADISCOV_REPLY: + if (vflag) { + struct in6_addr *in6; + u_char *cp; + + TCHECK(dp->icmp6_data16[0]); + printf(", id 0x%04x", EXTRACT_16BITS(&dp->icmp6_data16[0])); + cp = (u_char *)dp + length; + in6 = (struct in6_addr *)(dp + 1); + for (; (u_char *)in6 < cp; in6++) { + TCHECK(*in6); + printf(", %s", ip6addr_string(in6)); + } + } + break; + case ICMP6_MOBILEPREFIX_ADVERT: + if (vflag) { + TCHECK(dp->icmp6_data16[0]); + printf(", id 0x%04x", EXTRACT_16BITS(&dp->icmp6_data16[0])); + if (dp->icmp6_data16[1] & 0xc0) + printf(" "); + if (dp->icmp6_data16[1] & 0x80) + printf("M"); + if (dp->icmp6_data16[1] & 0x40) + printf("O"); +#define MPADVLEN 8 + icmp6_opt_print((const u_char *)dp + MPADVLEN, + length - MPADVLEN); + } + break; + default: + printf(", length %u", length); + if (vflag <= 1) + print_unknown_data(bp,"\n\t", length); + return; + } + if (!vflag) + printf(", length %u", length); return; trunc: fputs("[|icmp6]", stdout); -#if 0 -#undef TCHECK -#endif } static struct udphdr * -get_upperlayer(u_char *bp, int *prot) +get_upperlayer(u_char *bp, u_int *prot) { const u_char *ep; struct ip6_hdr *ip6 = (struct ip6_hdr *)bp; @@ -393,18 +527,19 @@ get_upperlayer(u_char *bp, int *prot) struct ip6_hbh *hbh; struct ip6_frag *fragh; struct ah *ah; - int nh, hlen; + u_int nh; + int hlen; /* 'ep' points to the end of available data. */ ep = snapend; - if (TTEST(ip6->ip6_nxt) == 0) + if (!TTEST(ip6->ip6_nxt)) return NULL; nh = ip6->ip6_nxt; hlen = sizeof(struct ip6_hdr); - while (bp < snapend) { + while (bp < ep) { bp += hlen; switch(nh) { @@ -423,7 +558,7 @@ get_upperlayer(u_char *bp, int *prot) case IPPROTO_DSTOPTS: case IPPROTO_ROUTING: hbh = (struct ip6_hbh *)bp; - if (TTEST(hbh->ip6h_len) == 0) + if (!TTEST(hbh->ip6h_len)) return(NULL); nh = hbh->ip6h_nxt; hlen = (hbh->ip6h_len + 1) << 3; @@ -431,10 +566,10 @@ get_upperlayer(u_char *bp, int *prot) case IPPROTO_FRAGMENT: /* this should be odd, but try anyway */ fragh = (struct ip6_frag *)bp; - if (TTEST(fragh->ip6f_offlg) == 0) + if (!TTEST(fragh->ip6f_offlg)) return(NULL); /* fragments with non-zero offset are meaningless */ - if ((fragh->ip6f_offlg & IP6F_OFF_MASK) != 0) + if ((EXTRACT_16BITS(&fragh->ip6f_offlg) & IP6F_OFF_MASK) != 0) return(NULL); nh = fragh->ip6f_nxt; hlen = sizeof(struct ip6_frag); @@ -442,7 +577,7 @@ get_upperlayer(u_char *bp, int *prot) case IPPROTO_AH: ah = (struct ah *)bp; - if (TTEST(ah->ah_len) == 0) + if (!TTEST(ah->ah_len)) return(NULL); nh = ah->ah_nxt; hlen = (ah->ah_len + 2) << 2; @@ -457,7 +592,7 @@ get_upperlayer(u_char *bp, int *prot) return(NULL); /* should be notreached, though */ } -void +static void icmp6_opt_print(const u_char *bp, int resid) { const struct nd_opt_hdr *op; @@ -466,6 +601,7 @@ icmp6_opt_print(const u_char *bp, int resid) const struct icmp6_opts_redirect *opr; const struct nd_opt_mtu *opm; const struct nd_opt_advinterval *opa; + const struct nd_opt_homeagent_info *oph; const struct nd_opt_route_info *opri; const u_char *cp, *ep; struct in6_addr in6, *in6p; @@ -488,82 +624,58 @@ icmp6_opt_print(const u_char *bp, int resid) if (cp + (op->nd_opt_len << 3) > ep) goto trunc; + printf("\n\t %s option (%u), length %u (%u): ", + tok2str(icmp6_opt_values, "unknown", op->nd_opt_type), + op->nd_opt_type, + op->nd_opt_len << 3, + op->nd_opt_len); + switch (op->nd_opt_type) { case ND_OPT_SOURCE_LINKADDR: opl = (struct nd_opt_hdr *)op; - printf("(src lladdr: "); l = (op->nd_opt_len << 3) - 2; print_lladdr(cp + 2, l); - /*(*/ - printf(")"); break; case ND_OPT_TARGET_LINKADDR: opl = (struct nd_opt_hdr *)op; - printf("(tgt lladdr: "); l = (op->nd_opt_len << 3) - 2; print_lladdr(cp + 2, l); - /*(*/ - printf(")"); break; case ND_OPT_PREFIX_INFORMATION: opp = (struct nd_opt_prefix_info *)op; TCHECK(opp->nd_opt_pi_prefix); - printf("(prefix info: "); /*)*/ - if (op->nd_opt_len != 4) { - printf("badlen"); - /*(*/ - printf(")"); - break; - } - if (opp->nd_opt_pi_flags_reserved & ND_OPT_PI_FLAG_ONLINK) - printf("L"); - if (opp->nd_opt_pi_flags_reserved & ND_OPT_PI_FLAG_AUTO) - printf("A"); - if (opp->nd_opt_pi_flags_reserved & ND_OPT_PI_FLAG_ROUTER) - printf("R"); - if (opp->nd_opt_pi_flags_reserved) - printf(" "); - printf("valid_ltime=%s,", - get_lifetime((u_int32_t)ntohl(opp->nd_opt_pi_valid_time))); - printf("preferred_ltime=%s,", - get_lifetime((u_int32_t)ntohl(opp->nd_opt_pi_preferred_time))); - printf("prefix=%s/%d", - ip6addr_string(&opp->nd_opt_pi_prefix), - opp->nd_opt_pi_prefix_len); - if (opp->nd_opt_pi_len != 4) - printf("!"); - /*(*/ - printf(")"); + printf("%s/%u%s, Flags [%s], valid time %ss", + ip6addr_string(&opp->nd_opt_pi_prefix), + opp->nd_opt_pi_prefix_len, + (op->nd_opt_len != 4) ? "badlen" : "", + bittok2str(icmp6_opt_pi_flag_values, "none", opp->nd_opt_pi_flags_reserved), + get_lifetime(EXTRACT_32BITS(&opp->nd_opt_pi_valid_time))); + printf(", pref. time %ss", get_lifetime(EXTRACT_32BITS(&opp->nd_opt_pi_preferred_time))); break; case ND_OPT_REDIRECTED_HEADER: opr = (struct icmp6_opts_redirect *)op; - printf("(redirect)"); + print_unknown_data(bp,"\n\t ",op->nd_opt_len<<3); /* xxx */ break; case ND_OPT_MTU: opm = (struct nd_opt_mtu *)op; TCHECK(opm->nd_opt_mtu_mtu); - printf("(mtu:"); /*)*/ - if (op->nd_opt_len != 1) { - printf("badlen"); - /*(*/ - printf(")"); - break; - } - printf(" mtu=%u", (u_int32_t)ntohl(opm->nd_opt_mtu_mtu)); - if (opm->nd_opt_mtu_len != 1) - printf("!"); - printf(")"); - break; + printf(" %u%s", + EXTRACT_32BITS(&opm->nd_opt_mtu_mtu), + (op->nd_opt_len != 1) ? "bad option length" : "" ); + break; case ND_OPT_ADVINTERVAL: opa = (struct nd_opt_advinterval *)op; TCHECK(opa->nd_opt_adv_interval); - printf("(advint:"); /*)*/ - printf(" advint=%u", - (u_int32_t)ntohl(opa->nd_opt_adv_interval)); - /*(*/ - printf(")"); - break; + printf(" %us", EXTRACT_32BITS(&opa->nd_opt_adv_interval)); + break; + case ND_OPT_HOMEAGENT_INFO: + oph = (struct nd_opt_homeagent_info *)op; + TCHECK(oph->nd_opt_hai_lifetime); + printf(" preference %u, lifetime %u", + EXTRACT_16BITS(&oph->nd_opt_hai_preference), + EXTRACT_16BITS(&oph->nd_opt_hai_lifetime)); + break; case ND_OPT_ROUTE_INFO: opri = (struct nd_opt_route_info *)op; TCHECK(opri->nd_opt_rti_lifetime); @@ -583,20 +695,22 @@ icmp6_opt_print(const u_char *bp, int resid) default: goto trunc; } - printf("(rtinfo:"); /*)*/ printf(" %s/%u", ip6addr_string(&in6), opri->nd_opt_rti_prefixlen); printf(", pref=%s", get_rtpref(opri->nd_opt_rti_flags)); printf(", lifetime=%s", - get_lifetime((u_int32_t)ntohl(opri->nd_opt_rti_lifetime))); - /*(*/ - printf(")"); + get_lifetime(EXTRACT_32BITS(&opri->nd_opt_rti_lifetime))); break; default: - printf("(unknwon opt_type=%d, opt_len=%d)", - op->nd_opt_type, op->nd_opt_len); - break; + if (vflag <= 1) { + print_unknown_data(cp+2,"\n\t ", (op->nd_opt_len << 3) - 2); /* skip option header */ + return; + } + break; } + /* do we want to see an additional hexdump ? */ + if (vflag> 1) + print_unknown_data(cp+2,"\n\t ", (op->nd_opt_len << 3) - 2); /* skip option header */ cp += op->nd_opt_len << 3; resid -= op->nd_opt_len << 3; @@ -609,7 +723,7 @@ icmp6_opt_print(const u_char *bp, int resid) #undef ECHECK } -void +static void mld6_print(const u_char *bp) { struct mld6_hdr *mp = (struct mld6_hdr *)bp; @@ -621,11 +735,135 @@ mld6_print(const u_char *bp) if ((u_char *)mp + sizeof(*mp) > ep) return; - printf("max resp delay: %d ", ntohs(mp->mld6_maxdelay)); + printf("max resp delay: %d ", EXTRACT_16BITS(&mp->mld6_maxdelay)); printf("addr: %s", ip6addr_string(&mp->mld6_addr)); } static void +mldv2_report_print(const u_char *bp, u_int len) +{ + struct icmp6_hdr *icp = (struct icmp6_hdr *) bp; + u_int group, nsrcs, ngroups; + u_int i, j; + + /* Minimum len is 8 */ + if (len < 8) { + printf(" [invalid len %d]", len); + return; + } + + TCHECK(icp->icmp6_data16[1]); + ngroups = ntohs(icp->icmp6_data16[1]); + printf(", %d group record(s)", ngroups); + if (vflag > 0) { + /* Print the group records */ + group = 8; + for (i = 0; i < ngroups; i++) { + /* type(1) + auxlen(1) + numsrc(2) + grp(16) */ + if (len < group + 20) { + printf(" [invalid number of groups]"); + return; + } + TCHECK2(bp[group + 4], sizeof(struct in6_addr)); + printf(" [gaddr %s", ip6addr_string(&bp[group + 4])); + printf(" %s", tok2str(mldv2report2str, " [v2-report-#%d]", + bp[group])); + nsrcs = (bp[group + 2] << 8) + bp[group + 3]; + /* Check the number of sources and print them */ + if (len < group + 20 + (nsrcs * sizeof(struct in6_addr))) { + printf(" [invalid number of sources %d]", nsrcs); + return; + } + if (vflag == 1) + printf(", %d source(s)", nsrcs); + else { + /* Print the sources */ + (void)printf(" {"); + for (j = 0; j < nsrcs; j++) { + TCHECK2(bp[group + 20 + j * sizeof(struct in6_addr)], + sizeof(struct in6_addr)); + printf(" %s", ip6addr_string(&bp[group + 20 + j * sizeof(struct in6_addr)])); + } + (void)printf(" }"); + } + /* Next group record */ + group += 20 + nsrcs * sizeof(struct in6_addr); + printf("]"); + } + } + return; +trunc: + (void)printf("[|icmp6]"); + return; +} + +static void +mldv2_query_print(const u_char *bp, u_int len) +{ + struct icmp6_hdr *icp = (struct icmp6_hdr *) bp; + u_int mrc; + int mrt, qqi; + u_int nsrcs; + register u_int i; + + /* Minimum len is 28 */ + if (len < 28) { + printf(" [invalid len %d]", len); + return; + } + TCHECK(icp->icmp6_data16[0]); + mrc = ntohs(icp->icmp6_data16[0]); + if (mrc < 32768) { + mrt = mrc; + } else { + mrt = ((mrc & 0x0fff) | 0x1000) << (((mrc & 0x7000) >> 12) + 3); + } + if (vflag) { + (void)printf(" [max resp delay=%d]", mrt); + } + TCHECK2(bp[8], sizeof(struct in6_addr)); + printf(" [gaddr %s", ip6addr_string(&bp[8])); + + if (vflag) { + TCHECK(bp[25]); + if (bp[24] & 0x08) { + printf(" sflag"); + } + if (bp[24] & 0x07) { + printf(" robustness=%d", bp[24] & 0x07); + } + if (bp[25] < 128) { + qqi = bp[25]; + } else { + qqi = ((bp[25] & 0x0f) | 0x10) << (((bp[25] & 0x70) >> 4) + 3); + } + printf(" qqi=%d", qqi); + } + + TCHECK2(bp[26], 2); + nsrcs = ntohs(*(u_short *)&bp[26]); + if (nsrcs > 0) { + if (len < 28 + nsrcs * sizeof(struct in6_addr)) + printf(" [invalid number of sources]"); + else if (vflag > 1) { + printf(" {"); + for (i = 0; i < nsrcs; i++) { + TCHECK2(bp[28 + i * sizeof(struct in6_addr)], + sizeof(struct in6_addr)); + printf(" %s", ip6addr_string(&bp[28 + i * sizeof(struct in6_addr)])); + } + printf(" }"); + } else + printf(", %d source(s)", nsrcs); + } + printf("]"); + return; +trunc: + (void)printf("[|icmp6]"); + return; +} + +void dnsname_print(const u_char *cp, const u_char *ep) { int i; @@ -661,15 +899,17 @@ dnsname_print(const u_char *cp, const u_char *ep) printf("\""); } -void -icmp6_nodeinfo_print(int icmp6len, const u_char *bp, const u_char *ep) +static void +icmp6_nodeinfo_print(u_int icmp6len, const u_char *bp, const u_char *ep) { struct icmp6_nodeinfo *ni6; struct icmp6_hdr *dp; const u_char *cp; - int siz, i; + size_t siz, i; int needcomma; + if (ep < bp) + return; dp = (struct icmp6_hdr *)bp; ni6 = (struct icmp6_nodeinfo *)bp; siz = ep - bp; @@ -678,21 +918,21 @@ icmp6_nodeinfo_print(int icmp6len, const u_char *bp, const u_char *ep) case ICMP6_NI_QUERY: if (siz == sizeof(*dp) + 4) { /* KAME who-are-you */ - printf("icmp6: who-are-you request"); + printf(" who-are-you request"); break; } - printf("icmp6: node information query"); + printf(" node information query"); TCHECK2(*dp, sizeof(*ni6)); ni6 = (struct icmp6_nodeinfo *)dp; printf(" ("); /*)*/ - switch (ntohs(ni6->ni_qtype)) { + switch (EXTRACT_16BITS(&ni6->ni_qtype)) { case NI_QTYPE_NOOP: printf("noop"); break; case NI_QTYPE_SUPTYPES: printf("supported qtypes"); - i = ntohs(ni6->ni_flags); + i = EXTRACT_16BITS(&ni6->ni_flags); if (i) printf(" [%s]", (i & 0x01) ? "C" : ""); break; @@ -797,7 +1037,7 @@ icmp6_nodeinfo_print(int icmp6len, const u_char *bp, const u_char *ep) needcomma = 0; ni6 = (struct icmp6_nodeinfo *)dp; - printf("icmp6: node information reply"); + printf(" node information reply"); printf(" ("); /*)*/ switch (ni6->ni_code) { case ICMP6_NI_SUCCESS: @@ -828,7 +1068,7 @@ icmp6_nodeinfo_print(int icmp6len, const u_char *bp, const u_char *ep) break; } - switch (ntohs(ni6->ni_qtype)) { + switch (EXTRACT_16BITS(&ni6->ni_qtype)) { case NI_QTYPE_NOOP: if (needcomma) printf(", "); @@ -841,7 +1081,7 @@ icmp6_nodeinfo_print(int icmp6len, const u_char *bp, const u_char *ep) if (needcomma) printf(", "); printf("supported qtypes"); - i = ntohs(ni6->ni_flags); + i = EXTRACT_16BITS(&ni6->ni_flags); if (i) printf(" [%s]", (i & 0x01) ? "C" : ""); break; @@ -863,7 +1103,7 @@ icmp6_nodeinfo_print(int icmp6len, const u_char *bp, const u_char *ep) printf("\""); } else dnsname_print(cp, ep); - if ((ntohs(ni6->ni_flags) & 0x01) != 0) + if ((EXTRACT_16BITS(&ni6->ni_flags) & 0x01) != 0) printf(" [TTL=%u]", *(u_int32_t *)(ni6 + 1)); break; case NI_QTYPE_NODEADDR: @@ -876,7 +1116,7 @@ icmp6_nodeinfo_print(int icmp6len, const u_char *bp, const u_char *ep) break; printf(" %s", getname6(bp + i)); i += sizeof(struct in6_addr); - printf("(%d)", (int32_t)ntohl(*(int32_t *)(bp + i))); + printf("(%d)", (int32_t)EXTRACT_32BITS(bp + i)); i += sizeof(int32_t); } i = ni6->ni_flags; @@ -908,21 +1148,19 @@ trunc: fputs("[|icmp6]", stdout); } -void -icmp6_rrenum_print(int icmp6len, const u_char *bp, const u_char *ep) +static void +icmp6_rrenum_print(const u_char *bp, const u_char *ep) { struct icmp6_router_renum *rr6; - struct icmp6_hdr *dp; - size_t siz; const char *cp; struct rr_pco_match *match; struct rr_pco_use *use; char hbuf[NI_MAXHOST]; int n; - dp = (struct icmp6_hdr *)bp; + if (ep < bp) + return; rr6 = (struct icmp6_router_renum *)bp; - siz = ep - bp; cp = (const char *)(rr6 + 1); TCHECK(rr6->rr_reserved); @@ -941,7 +1179,7 @@ icmp6_rrenum_print(int icmp6len, const u_char *bp, const u_char *ep) break; } - printf(", seq=%u", (u_int32_t)ntohl(rr6->rr_seqnum)); + printf(", seq=%u", EXTRACT_32BITS(&rr6->rr_seqnum)); if (vflag) { #define F(x, y) ((rr6->rr_flags) & (x) ? (y) : "") @@ -956,7 +1194,7 @@ icmp6_rrenum_print(int icmp6len, const u_char *bp, const u_char *ep) printf("seg=%u,", rr6->rr_segnum); printf("maxdelay=%u", rr6->rr_maxdelay); if (rr6->rr_reserved) - printf("rsvd=0x%x", (u_int16_t)ntohs(rr6->rr_reserved)); + printf("rsvd=0x%x", EXTRACT_16BITS(&rr6->rr_reserved)); /*[*/ printf("]"); #undef F @@ -1021,12 +1259,12 @@ icmp6_rrenum_print(int icmp6len, const u_char *bp, const u_char *ep) printf("vltime=infty,"); else printf("vltime=%u,", - (u_int32_t)ntohl(use->rpu_vltime)); + EXTRACT_32BITS(&use->rpu_vltime)); if (~use->rpu_pltime == 0) printf("pltime=infty,"); else printf("pltime=%u,", - (u_int32_t)ntohl(use->rpu_pltime)); + EXTRACT_32BITS(&use->rpu_pltime)); } if (inet_ntop(AF_INET6, &use->rpu_prefix, hbuf, sizeof(hbuf)))