X-Git-Url: https://git.tcpdump.org/tcpdump/blobdiff_plain/3c252e8be08ba708471186184d006f34b4270190..ffa1470e5c7ff0e50028d085a481dc797b0b51ed:/print-dhcp6.c diff --git a/print-dhcp6.c b/print-dhcp6.c index b23b7887..73b7b383 100644 --- a/print-dhcp6.c +++ b/print-dhcp6.c @@ -27,12 +27,18 @@ * SUCH DAMAGE. */ /* - * draft-ietf-dhc-dhcpv6-26.txt + * RFC3315: DHCPv6 + * supported DHCPv6 options: + * RFC3319, + * RFC3633, + * RFC3646, + * draft-ietf-dhc-dhcpv6-opt-timeconfig-03.txt, + * draft-ietf-dhc-lifetime-00.txt, */ #ifndef lint -static const char rcsid[] = - "@(#) $Header: /tcpdump/master/tcpdump/print-dhcp6.c,v 1.24 2002-12-11 22:29:21 guy Exp $"; +static const char rcsid[] _U_ = + "@(#) $Header: /tcpdump/master/tcpdump/print-dhcp6.c,v 1.35 2004-07-06 22:16:03 guy Exp $"; #endif #ifdef HAVE_CONFIG_H @@ -66,7 +72,12 @@ static const char rcsid[] = #define DH6_RENEW 5 #define DH6_REBIND 6 #define DH6_REPLY 7 +#define DH6_RELEASE 8 +#define DH6_DECLINE 9 +#define DH6_RECONFIGURE 10 #define DH6_INFORM_REQ 11 +#define DH6_RELAY_FORW 12 +#define DH6_RELAY_REPLY 13 /* DHCP6 base packet format */ struct dhcp6 { @@ -80,56 +91,105 @@ struct dhcp6 { #define dh6_xid dh6_msgtypexid.x #define DH6_XIDMASK 0x00ffffff -/* option */ +/* DHCPv6 relay messages */ +struct dhcp6_relay { + u_int8_t dh6relay_msgtype; + u_int8_t dh6relay_hcnt; + u_int8_t dh6relay_linkaddr[16]; /* XXX: badly aligned */ + u_int8_t dh6relay_peeraddr[16]; + /* options follow */ +}; + +/* options */ #define DH6OPT_CLIENTID 1 #define DH6OPT_SERVERID 2 -#define DH6OPT_IA 3 +#define DH6OPT_IA_NA 3 #define DH6OPT_IA_TMP 4 #define DH6OPT_IADDR 5 #define DH6OPT_ORO 6 #define DH6OPT_PREFERENCE 7 -# define DH6OPT_PREF_UNDEF -1 # define DH6OPT_PREF_MAX 255 #define DH6OPT_ELAPSED_TIME 8 -#define DH6OPT_CLIENT_MSG 9 -#define DH6OPT_SERVER_MSG 10 +#define DH6OPT_RELAY_MSG 9 +/*#define DH6OPT_SERVER_MSG 10 deprecated */ #define DH6OPT_AUTH 11 +# define DH6OPT_AUTHPROTO_DELAYED 2 +# define DH6OPT_AUTHPROTO_RECONFIG 3 +# define DH6OPT_AUTHALG_HMACMD5 1 +# define DH6OPT_AUTHRDM_MONOCOUNTER 0 +# define DH6OPT_AUTHRECONFIG_KEY 1 +# define DH6OPT_AUTHRECONFIG_HMACMD5 2 #define DH6OPT_UNICAST 12 #define DH6OPT_STATUS_CODE 13 # define DH6OPT_STCODE_SUCCESS 0 # define DH6OPT_STCODE_UNSPECFAIL 1 -# define DH6OPT_STCODE_AUTHFAILED 2 -# define DH6OPT_STCODE_ADDRUNAVAIL 3 -# define DH6OPT_STCODE_NOADDRAVAIL 4 -# define DH6OPT_STCODE_NOBINDING 5 -# define DH6OPT_STCODE_CONFNOMATCH 6 -# define DH6OPT_STCODE_NOTONLINK 7 -# define DH6OPT_STCODE_USEMULTICAST 8 +# define DH6OPT_STCODE_NOADDRAVAIL 2 +# define DH6OPT_STCODE_NOBINDING 3 +# define DH6OPT_STCODE_NOTONLINK 4 +# define DH6OPT_STCODE_USEMULTICAST 5 +# define DH6OPT_STCODE_NOPREFIXAVAIL 6 #define DH6OPT_RAPID_COMMIT 14 #define DH6OPT_USER_CLASS 15 #define DH6OPT_VENDOR_CLASS 16 #define DH6OPT_VENDOR_OPTS 17 #define DH6OPT_INTERFACE_ID 18 #define DH6OPT_RECONF_MSG 19 +#define DH6OPT_RECONF_ACCEPT 20 +#define DH6OPT_SIP_SERVER_D 21 +#define DH6OPT_SIP_SERVER_A 22 +#define DH6OPT_DNS 23 +#define DH6OPT_DNSNAME 24 +#define DH6OPT_IA_PD 25 +#define DH6OPT_IA_PD_PREFIX 26 /* - * The option type has not been assigned for the following options. - * We temporarily adopt values used in the service specification document + * The old prefix delegation option used in the service specification document * (200206xx version) by NTT Communications. - * Note that we'll change the following definitions if different type values - * are officially assigned. */ -#define DH6OPT_DNS 25 #define DH6OPT_PREFIX_DELEGATION 30 #define DH6OPT_PREFIX_INFORMATION 31 #define DH6OPT_PREFIX_REQUEST 32 +/* + * The following one is an unassigned number. + * We temporarily use values as of KAME snap 20040322. + */ +#define DH6OPT_NTP_SERVERS 35 +#define DH6OPT_LIFETIME 36 + struct dhcp6opt { u_int16_t dh6opt_type; u_int16_t dh6opt_len; /* type-dependent data follows */ }; +struct dhcp6_ia { + u_int16_t dh6opt_ia_type; + u_int16_t dh6opt_ia_len; + u_int32_t dh6opt_ia_iaid; + u_int32_t dh6opt_ia_t1; + u_int32_t dh6opt_ia_t2; +}; + +struct dhcp6_ia_prefix { + u_int16_t dh6opt_ia_prefix_type; + u_int16_t dh6opt_ia_prefix_len; + u_int32_t dh6opt_ia_prefix_pltime; + u_int32_t dh6opt_ia_prefix_vltime; + u_int8_t dh6opt_ia_prefix_plen; + struct in6_addr dh6opt_ia_prefix_addr; +} __attribute__ ((__packed__)); + +struct dhcp6_auth { + u_int16_t dh6opt_auth_type; + u_int16_t dh6opt_auth_len; + u_int8_t dh6opt_auth_proto; + u_int8_t dh6opt_auth_alg; + u_int8_t dh6opt_auth_rdm; + u_int8_t dh6opt_auth_rdinfo[8]; + /* authentication information follows */ +} __attribute__ ((__packed__)); + static const char * dhcp6opt_name(int type) { @@ -143,22 +203,58 @@ dhcp6opt_name(int type) return "client ID"; case DH6OPT_SERVERID: return "server ID"; + case DH6OPT_IA_NA: + return "IA_NA"; case DH6OPT_ORO: return "option request"; case DH6OPT_PREFERENCE: return "preference"; + case DH6OPT_ELAPSED_TIME: + return "elapsed time"; + case DH6OPT_RELAY_MSG: + return "relay message"; + case DH6OPT_AUTH: + return "authentication"; + case DH6OPT_UNICAST: + return "server unicast"; case DH6OPT_STATUS_CODE: return "status code"; case DH6OPT_RAPID_COMMIT: return "rapid commit"; + case DH6OPT_USER_CLASS: + return "user class"; + case DH6OPT_VENDOR_CLASS: + return "vendor class"; + case DH6OPT_VENDOR_OPTS: + return "vendor-specific info"; + case DH6OPT_INTERFACE_ID: + return "interface ID"; + case DH6OPT_RECONF_MSG: + return "reconfigure message"; + case DH6OPT_RECONF_ACCEPT: + return "reconfigure accept"; + case DH6OPT_SIP_SERVER_D: + return "SIP servers domain"; + case DH6OPT_SIP_SERVER_A: + return "SIP servers address"; case DH6OPT_DNS: return "DNS"; + case DH6OPT_DNSNAME: + return "DNS name"; case DH6OPT_PREFIX_DELEGATION: return "prefix delegation"; case DH6OPT_PREFIX_INFORMATION: return "prefix information"; + case DH6OPT_IA_PD: + return "IA_PD"; + case DH6OPT_IA_PD_PREFIX: + return "IA_PD prefix"; + case DH6OPT_NTP_SERVERS: + return "NTP Server"; + case DH6OPT_LIFETIME: + return "lifetime"; default: - sprintf(genstr, "opt_%d", type); + snprintf(genstr, sizeof(genstr), "opt_%d", type); return(genstr); } } @@ -176,28 +272,24 @@ dhcp6stcode(int code) return "success"; case DH6OPT_STCODE_UNSPECFAIL: return "unspec failure"; - case DH6OPT_STCODE_AUTHFAILED: - return "auth fail"; - case DH6OPT_STCODE_ADDRUNAVAIL: - return "address unavailable"; case DH6OPT_STCODE_NOADDRAVAIL: return "no addresses"; case DH6OPT_STCODE_NOBINDING: return "no binding"; - case DH6OPT_STCODE_CONFNOMATCH: - return "confirm no match"; case DH6OPT_STCODE_NOTONLINK: return "not on-link"; case DH6OPT_STCODE_USEMULTICAST: return "use multicast"; + case DH6OPT_STCODE_NOPREFIXAVAIL: + return "no prefixes"; default: - sprintf(genstr, "code%d", code); + snprintf(genstr, sizeof(genstr), "code%d", code); return(genstr); } } static void -dhcp6opt_print(u_char *cp, u_char *ep) +dhcp6opt_print(const u_char *cp, const u_char *ep) { struct dhcp6opt *dh6o; u_char *tp; @@ -207,6 +299,10 @@ dhcp6opt_print(u_char *cp, u_char *ep) u_int16_t val16; u_int32_t val32; struct in6_addr addr6; + struct dhcp6_ia ia; + struct dhcp6_ia_prefix ia_prefix; + struct dhcp6_auth authopt; + u_int authinfolen, authrealmlen; if (cp == ep) return; @@ -294,10 +390,142 @@ dhcp6opt_print(u_char *cp, u_char *ep) } printf(" %d)", *((u_char *)(dh6o + 1) + 1)); break; + case DH6OPT_ELAPSED_TIME: + if (optlen != 2) { + printf(" ?)"); + break; + } + memcpy(&val16, dh6o + 1, sizeof(val16)); + val16 = ntohs(val16); + printf(" %d)", (int)val16); + break; + case DH6OPT_RELAY_MSG: + printf(" ("); + dhcp6_print((const u_char *)(dh6o + 1), optlen); + printf(")"); + break; + case DH6OPT_AUTH: + if (optlen < sizeof(authopt) - sizeof(*dh6o)) { + printf(" ?)"); + break; + } + memcpy(&authopt, dh6o, sizeof(authopt)); + switch (authopt.dh6opt_auth_proto) { + case DH6OPT_AUTHPROTO_DELAYED: + printf(" proto: delayed"); + break; + case DH6OPT_AUTHPROTO_RECONFIG: + printf(" proto: reconfigure"); + break; + default: + printf(" proto: %d", + authopt.dh6opt_auth_proto); + break; + } + switch (authopt.dh6opt_auth_alg) { + case DH6OPT_AUTHALG_HMACMD5: + /* XXX: may depend on the protocol */ + printf(", alg: HMAC-MD5"); + break; + default: + printf(", alg: %d", authopt.dh6opt_auth_alg); + break; + } + switch (authopt.dh6opt_auth_rdm) { + case DH6OPT_AUTHRDM_MONOCOUNTER: + printf(", RDM: mono"); + break; + default: + printf(", RDM: %d", authopt.dh6opt_auth_rdm); + break; + } + tp = (u_char *)&authopt.dh6opt_auth_rdinfo; + printf(", RD:"); + for (i = 0; i < 4; i++, tp += sizeof(val16)) + printf(" %04x", EXTRACT_16BITS(tp)); + + /* protocol dependent part */ + tp = (u_char *)dh6o + sizeof(authopt); + authinfolen = + optlen + sizeof(*dh6o) - sizeof(authopt); + switch (authopt.dh6opt_auth_proto) { + case DH6OPT_AUTHPROTO_DELAYED: + if (authinfolen == 0) + break; + if (authinfolen < 20) { + printf(" ??"); + break; + } + authrealmlen = authinfolen - 20; + if (authrealmlen > 0) { + printf(", realm: "); + } + for (i = 0; i < authrealmlen; i++, tp++) + printf("%02x", *tp); + printf(", key ID: %08x", EXTRACT_32BITS(tp)); + tp += 4; + printf(", HMAC-MD5:"); + for (i = 0; i < 4; i++, tp+= 4) + printf(" %08x", EXTRACT_32BITS(tp)); + break; + case DH6OPT_AUTHPROTO_RECONFIG: + if (authinfolen != 17) { + printf(" ??"); + break; + } + switch (*tp++) { + case DH6OPT_AUTHRECONFIG_KEY: + printf(" reconfig-key"); + break; + case DH6OPT_AUTHRECONFIG_HMACMD5: + printf(" type: HMAC-MD5"); + break; + default: + printf(" type: ??"); + break; + } + printf(" value:"); + for (i = 0; i < 4; i++, tp+= 4) + printf(" %08x", EXTRACT_32BITS(tp)); + break; + default: + printf(" ??"); + break; + } + + printf(")"); + break; case DH6OPT_RAPID_COMMIT: /* nothing todo */ printf(")"); break; + case DH6OPT_INTERFACE_ID: + /* + * Since we cannot predict the encoding, print hex dump + * at most 10 characters. + */ + for (i = 0; i < optlen && i < 10; i++) + printf("%02x", ((u_char *)(dh6o + 1))[i]); + break; + case DH6OPT_RECONF_MSG: + tp = (u_char *)(dh6o + 1); + switch (*tp) { + case DH6_RENEW: + printf(" for renew)"); + break; + case DH6_INFORM_REQ: + printf(" for inf-req)"); + break; + default: + printf(" for ?\?\?(%02x))", *tp); + break; + } + break; + case DH6OPT_RECONF_ACCEPT: /* nothing todo */ + printf(")"); + break; + case DH6OPT_SIP_SERVER_A: case DH6OPT_DNS: + case DH6OPT_NTP_SERVERS: if (optlen % 16) { printf(" ?)"); break; @@ -327,12 +555,68 @@ dhcp6opt_print(u_char *cp, u_char *ep) printf(" lease-duration: %u)", val32); break; case DH6OPT_STATUS_CODE: - if (optlen < 2) + if (optlen < 2) { printf(" ?)"); + break; + } memcpy(&val16, (u_char *)(dh6o + 1), sizeof(val16)); val16 = ntohs(val16); printf(" %s)", dhcp6stcode(val16)); break; + case DH6OPT_IA_NA: + case DH6OPT_IA_PD: + if (optlen < sizeof(ia) - 4) { + printf(" ?)"); + break; + } + memcpy(&ia, (u_char *)dh6o, sizeof(ia)); + ia.dh6opt_ia_iaid = ntohl(ia.dh6opt_ia_iaid); + ia.dh6opt_ia_t1 = ntohl(ia.dh6opt_ia_t1); + ia.dh6opt_ia_t2 = ntohl(ia.dh6opt_ia_t2); + printf(" IAID:%lu T1:%lu T2:%lu", + (unsigned long)ia.dh6opt_ia_iaid, + (unsigned long)ia.dh6opt_ia_t1, + (unsigned long)ia.dh6opt_ia_t2); + if (optlen > sizeof(ia) - 4) { + /* there are sub-options */ + dhcp6opt_print((u_char *)dh6o + sizeof(ia), + (u_char *)(dh6o + 1) + optlen); + } + printf(")"); + break; + case DH6OPT_IA_PD_PREFIX: + if (optlen < sizeof(ia_prefix) - 4) { + printf(" ?)"); + break; + } + memcpy(&ia_prefix, (u_char *)dh6o, sizeof(ia_prefix)); + printf(" %s/%d", + ip6addr_string(&ia_prefix.dh6opt_ia_prefix_addr), + ia_prefix.dh6opt_ia_prefix_plen); + ia_prefix.dh6opt_ia_prefix_pltime = + ntohl(ia_prefix.dh6opt_ia_prefix_pltime); + ia_prefix.dh6opt_ia_prefix_vltime = + ntohl(ia_prefix.dh6opt_ia_prefix_vltime); + printf(" pltime:%lu vltime:%lu", + (unsigned long)ia_prefix.dh6opt_ia_prefix_pltime, + (unsigned long)ia_prefix.dh6opt_ia_prefix_vltime); + if (optlen > sizeof(ia_prefix) - 4) { + /* there are sub-options */ + dhcp6opt_print((u_char *)dh6o + + sizeof(ia_prefix), + (u_char *)(dh6o + 1) + optlen); + } + printf(")"); + break; + case DH6OPT_LIFETIME: + if (optlen != 4) { + printf(" ?)"); + break; + } + memcpy(&val32, dh6o + 1, sizeof(val32)); + val32 = ntohl(val32); + printf(" %d)", (int)val32); + break; default: printf(")"); break; @@ -350,19 +634,22 @@ trunc: * Print dhcp6 packets */ void -dhcp6_print(register const u_char *cp, u_int length, - u_int16_t sport, u_int16_t dport) +dhcp6_print(const u_char *cp, u_int length) { struct dhcp6 *dh6; - u_char *ep; + struct dhcp6_relay *dh6relay; + const u_char *ep; u_char *extp; const char *name; printf("dhcp6"); ep = (u_char *)snapend; + if (cp + length < ep) + ep = cp + length; dh6 = (struct dhcp6 *)cp; + dh6relay = (struct dhcp6_relay *)cp; TCHECK(dh6->dh6_xid); switch (dh6->dh6_msgtype) { case DH6_SOLICIT: @@ -386,9 +673,24 @@ dhcp6_print(register const u_char *cp, u_int length, case DH6_REPLY: name = "reply"; break; + case DH6_RELEASE: + name = "release"; + break; + case DH6_DECLINE: + name = "decline"; + break; + case DH6_RECONFIGURE: + name = "reconfigure"; + break; case DH6_INFORM_REQ: name= "inf-req"; break; + case DH6_RELAY_FORW: + name= "relay-fwd"; + break; + case DH6_RELAY_REPLY: + name= "relay-reply"; + break; default: name = NULL; break; @@ -397,8 +699,10 @@ dhcp6_print(register const u_char *cp, u_int length, if (!vflag) { if (name) printf(" %s", name); - else + else if (dh6->dh6_msgtype != DH6_RELAY_FORW && + dh6->dh6_msgtype != DH6_RELAY_REPLY) { printf(" msgtype-%u", dh6->dh6_msgtype); + } return; } @@ -408,9 +712,24 @@ dhcp6_print(register const u_char *cp, u_int length, printf(" %s (", name); /*)*/ else printf(" msgtype-%u (", dh6->dh6_msgtype); /*)*/ - printf("xid=%x", EXTRACT_32BITS(&dh6->dh6_xid) & DH6_XIDMASK); - extp = (u_char *)(dh6 + 1); - dhcp6opt_print(extp, ep); + if (dh6->dh6_msgtype != DH6_RELAY_FORW && + dh6->dh6_msgtype != DH6_RELAY_REPLY) { + printf("xid=%x", EXTRACT_32BITS(&dh6->dh6_xid) & DH6_XIDMASK); + extp = (u_char *)(dh6 + 1); + dhcp6opt_print(extp, ep); + } else { /* relay messages */ + struct in6_addr addr6; + + TCHECK(dh6relay->dh6relay_peeraddr); + + memcpy(&addr6, dh6relay->dh6relay_linkaddr, sizeof (addr6)); + printf("linkaddr=%s", ip6addr_string(&addr6)); + + memcpy(&addr6, dh6relay->dh6relay_peeraddr, sizeof (addr6)); + printf(" peeraddr=%s", ip6addr_string(&addr6)); + + dhcp6opt_print((u_char *)(dh6relay + 1), ep); + } /*(*/ printf(")"); return;