Use nd_ipv6 rather than struct in6_addr in packet-layout structures.

Also, use it, and nd_ipv4, in sizeof() operations.

diff --git a/print-aodv.c b/print-aodv.c
index b716097a3c40bbde6b9b3cb9245e060277f2d632..abec010414a43605f1831b71e4956adeda05652c 100644 (file)
--- a/print-aodv.c
+++ b/print-aodv.c
@@ -62,9 +62,9 @@ struct aodv_rreq6 {
        nd_uint8_t      rreq_zero0;     /* reserved, set to zero */
        nd_uint8_t      rreq_hops;      /* number of hops from originator */
        nd_uint32_t     rreq_id;        /* request ID */
-       struct in6_addr rreq_da;        /* destination IPv6 address */
+       nd_ipv6         rreq_da;        /* destination IPv6 address */
        nd_uint32_t     rreq_ds;        /* destination sequence number */
-       struct in6_addr rreq_oa;        /* originator IPv6 address */
+       nd_ipv6         rreq_oa;        /* originator IPv6 address */
        nd_uint32_t     rreq_os;        /* originator sequence number */
 };
 struct aodv_rreq6_draft_01 {
@@ -75,8 +75,8 @@ struct aodv_rreq6_draft_01 {
        nd_uint32_t     rreq_id;        /* request ID */
        nd_uint32_t     rreq_ds;        /* destination sequence number */
        nd_uint32_t     rreq_os;        /* originator sequence number */
-       struct in6_addr rreq_da;        /* destination IPv6 address */
-       struct in6_addr rreq_oa;        /* originator IPv6 address */
+       nd_ipv6         rreq_da;        /* destination IPv6 address */
+       nd_ipv6         rreq_oa;        /* originator IPv6 address */
 };
 
 #define        RREQ_JOIN       0x80            /* join (reserved for multicast */
@@ -101,9 +101,9 @@ struct aodv_rrep6 {
        nd_uint8_t      rrep_flags;     /* various flags */
        nd_uint8_t      rrep_ps;        /* prefix size */
        nd_uint8_t      rrep_hops;      /* number of hops from o to d */
-       struct in6_addr rrep_da;        /* destination IPv6 address */
+       nd_ipv6         rrep_da;        /* destination IPv6 address */
        nd_uint32_t     rrep_ds;        /* destination sequence number */
-       struct in6_addr rrep_oa;        /* originator IPv6 address */
+       nd_ipv6         rrep_oa;        /* originator IPv6 address */
        nd_uint32_t     rrep_life;      /* lifetime of this route */
 };
 struct aodv_rrep6_draft_01 {
@@ -112,8 +112,8 @@ struct aodv_rrep6_draft_01 {
        nd_uint8_t      rrep_ps;        /* prefix size */
        nd_uint8_t      rrep_hops;      /* number of hops from o to d */
        nd_uint32_t     rrep_ds;        /* destination sequence number */
-       struct in6_addr rrep_da;        /* destination IPv6 address */
-       struct in6_addr rrep_oa;        /* originator IPv6 address */
+       nd_ipv6         rrep_da;        /* destination IPv6 address */
+       nd_ipv6         rrep_oa;        /* originator IPv6 address */
        nd_uint32_t     rrep_life;      /* lifetime of this route */
 };
 
@@ -127,11 +127,11 @@ struct rerr_unreach {
        nd_uint32_t     u_ds;   /* sequence number */
 };
 struct rerr_unreach6 {
-       struct in6_addr u_da;   /* IPv6 address */
+       nd_ipv6         u_da;   /* IPv6 address */
        nd_uint32_t     u_ds;   /* sequence number */
 };
 struct rerr_unreach6_draft_01 {
-       struct in6_addr u_da;   /* IPv6 address */
+       nd_ipv6         u_da;   /* IPv6 address */
        nd_uint32_t     u_ds;   /* sequence number */
 };
 

diff --git a/print-bgp.c b/print-bgp.c
index dd1f6d38ce15ed3674a28116af3eeb9d9c9f3d6d..f3a86e15bb819b28252222ad10ab3c95af8c5fb2 100644 (file)
--- a/print-bgp.c
+++ b/print-bgp.c
@@ -633,12 +633,12 @@ bgp_vpn_ip_print(netdissect_options *ndo,
     char *pos = addr;
 
     switch(addr_length) {
-    case (sizeof(struct in_addr) << 3): /* 32 */
-        ND_TCHECK_LEN(pptr, sizeof(struct in_addr));
+    case (sizeof(nd_ipv4) << 3): /* 32 */
+        ND_TCHECK_LEN(pptr, sizeof(nd_ipv4));
         nd_snprintf(pos, sizeof(addr), "%s", ipaddr_string(ndo, pptr));
         break;
-    case (sizeof(struct in6_addr) << 3): /* 128 */
-        ND_TCHECK_LEN(pptr, sizeof(struct in6_addr));
+    case (sizeof(nd_ipv6) << 3): /* 128 */
+        ND_TCHECK_LEN(pptr, sizeof(nd_ipv6));
         nd_snprintf(pos, sizeof(addr), "%s", ip6addr_string(ndo, pptr));
         break;
     default:
@@ -888,12 +888,12 @@ decode_mdt_vpn_nlri(netdissect_options *ndo,
     pptr += 8;
 
     /* IPv4 address */
-    ND_TCHECK_LEN(pptr, sizeof(struct in_addr));
+    ND_TCHECK_LEN(pptr, sizeof(nd_ipv4));
     vpn_ip = pptr;
-    pptr += sizeof(struct in_addr);
+    pptr += sizeof(nd_ipv4);
 
     /* MDT Group Address */
-    ND_TCHECK_LEN(pptr, sizeof(struct in_addr));
+    ND_TCHECK_LEN(pptr, sizeof(nd_ipv4));
 
     nd_snprintf(buf, buflen, "RD: %s, VPN IP Address: %s, MC Group Address: %s",
              bgp_vpn_rd_print(ndo, rd), ipaddr_string(ndo, vpn_ip), ipaddr_string(ndo, pptr));
@@ -1716,74 +1716,74 @@ bgp_attr_print(netdissect_options *ndo,
                 case (AFNUM_INET<<8 | SAFNUM_RT_ROUTING_INFO):
                 case (AFNUM_INET<<8 | SAFNUM_MULTICAST_VPN):
                 case (AFNUM_INET<<8 | SAFNUM_MDT):
-                    if (tlen < sizeof(struct in_addr)) {
+                    if (tlen < sizeof(nd_ipv4)) {
                         ND_PRINT("invalid len");
                         tlen = 0;
                     } else {
-                        ND_TCHECK_LEN(tptr, sizeof(struct in_addr));
+                        ND_TCHECK_LEN(tptr, sizeof(nd_ipv4));
                         ND_PRINT("%s",ipaddr_string(ndo, tptr));
-                        tlen -= sizeof(struct in_addr);
-                        tptr += sizeof(struct in_addr);
+                        tlen -= sizeof(nd_ipv4);
+                        tptr += sizeof(nd_ipv4);
                     }
                     break;
                 case (AFNUM_INET<<8 | SAFNUM_VPNUNICAST):
                 case (AFNUM_INET<<8 | SAFNUM_VPNMULTICAST):
                 case (AFNUM_INET<<8 | SAFNUM_VPNUNIMULTICAST):
-                    if (tlen < sizeof(struct in_addr)+BGP_VPN_RD_LEN) {
+                    if (tlen < sizeof(nd_ipv4)+BGP_VPN_RD_LEN) {
                         ND_PRINT("invalid len");
                         tlen = 0;
                     } else {
                         ND_TCHECK_LEN(tptr,
-                                      sizeof(struct in_addr) + BGP_VPN_RD_LEN);
+                                      sizeof(nd_ipv4) + BGP_VPN_RD_LEN);
                         ND_PRINT("RD: %s, %s",
                                   bgp_vpn_rd_print(ndo, tptr),
                                   ipaddr_string(ndo, tptr+BGP_VPN_RD_LEN));
-                        tlen -= (sizeof(struct in_addr)+BGP_VPN_RD_LEN);
-                        tptr += (sizeof(struct in_addr)+BGP_VPN_RD_LEN);
+                        tlen -= (sizeof(nd_ipv4)+BGP_VPN_RD_LEN);
+                        tptr += (sizeof(nd_ipv4)+BGP_VPN_RD_LEN);
                     }
                     break;
                 case (AFNUM_INET6<<8 | SAFNUM_UNICAST):
                 case (AFNUM_INET6<<8 | SAFNUM_MULTICAST):
                 case (AFNUM_INET6<<8 | SAFNUM_UNIMULTICAST):
                 case (AFNUM_INET6<<8 | SAFNUM_LABUNICAST):
-                    if (tlen < sizeof(struct in6_addr)) {
+                    if (tlen < sizeof(nd_ipv6)) {
                         ND_PRINT("invalid len");
                         tlen = 0;
                     } else {
-                        ND_TCHECK_LEN(tptr, sizeof(struct in6_addr));
+                        ND_TCHECK_LEN(tptr, sizeof(nd_ipv6));
                         ND_PRINT("%s", ip6addr_string(ndo, tptr));
-                        tlen -= sizeof(struct in6_addr);
-                        tptr += sizeof(struct in6_addr);
+                        tlen -= sizeof(nd_ipv6);
+                        tptr += sizeof(nd_ipv6);
                     }
                     break;
                 case (AFNUM_INET6<<8 | SAFNUM_VPNUNICAST):
                 case (AFNUM_INET6<<8 | SAFNUM_VPNMULTICAST):
                 case (AFNUM_INET6<<8 | SAFNUM_VPNUNIMULTICAST):
-                    if (tlen < sizeof(struct in6_addr)+BGP_VPN_RD_LEN) {
+                    if (tlen < sizeof(nd_ipv6)+BGP_VPN_RD_LEN) {
                         ND_PRINT("invalid len");
                         tlen = 0;
                     } else {
                         ND_TCHECK_LEN(tptr,
-                                      sizeof(struct in6_addr) + BGP_VPN_RD_LEN);
+                                      sizeof(nd_ipv6) + BGP_VPN_RD_LEN);
                         ND_PRINT("RD: %s, %s",
                                   bgp_vpn_rd_print(ndo, tptr),
                                   ip6addr_string(ndo, tptr+BGP_VPN_RD_LEN));
-                        tlen -= (sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
-                        tptr += (sizeof(struct in6_addr)+BGP_VPN_RD_LEN);
+                        tlen -= (sizeof(nd_ipv6)+BGP_VPN_RD_LEN);
+                        tptr += (sizeof(nd_ipv6)+BGP_VPN_RD_LEN);
                     }
                     break;
                 case (AFNUM_VPLS<<8 | SAFNUM_VPLS):
                 case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNICAST):
                 case (AFNUM_L2VPN<<8 | SAFNUM_VPNMULTICAST):
                 case (AFNUM_L2VPN<<8 | SAFNUM_VPNUNIMULTICAST):
-                    if (tlen < sizeof(struct in_addr)) {
+                    if (tlen < sizeof(nd_ipv4)) {
                         ND_PRINT("invalid len");
                         tlen = 0;
                     } else {
-                        ND_TCHECK_LEN(tptr, sizeof(struct in_addr));
+                        ND_TCHECK_LEN(tptr, sizeof(nd_ipv4));
                         ND_PRINT("%s", ipaddr_string(ndo, tptr));
-                        tlen -= (sizeof(struct in_addr));
-                        tptr += (sizeof(struct in_addr));
+                        tlen -= (sizeof(nd_ipv4));
+                        tptr += (sizeof(nd_ipv4));
                     }
                     break;
                 case (AFNUM_NSAP<<8 | SAFNUM_UNICAST):

diff --git a/print-domain.c b/print-domain.c
index 52b8e1ff6b2485053324fe01d496802c1a581900..80f021ce54860b4755fedf333d811dc4345c6188 100644 (file)
--- a/print-domain.c
+++ b/print-domain.c
@@ -431,7 +431,7 @@ ns_rprint(netdissect_options *ndo,
 
        switch (typ) {
        case T_A:
-               if (!ND_TTEST_LEN(cp, sizeof(struct in_addr)))
+               if (!ND_TTEST_LEN(cp, sizeof(nd_ipv4)))
                        return(NULL);
                ND_PRINT(" %s", intoa(EXTRACT_IPV4_TO_NETWORK_ORDER(cp)));
                break;
@@ -502,7 +502,7 @@ ns_rprint(netdissect_options *ndo,
            {
                char ntop_buf[INET6_ADDRSTRLEN];
 
-               if (!ND_TTEST_LEN(cp, sizeof(struct in6_addr)))
+               if (!ND_TTEST_LEN(cp, sizeof(nd_ipv6)))
                        return(NULL);
                ND_PRINT(" %s",
                    addrtostr6(cp, ntop_buf, sizeof(ntop_buf)));

diff --git a/print-esp.c b/print-esp.c
index 6bf6402f820ebb9ec5f3bcbe74228f84eaa4e8ea..fbe99ad2394e685ed58bcb53a57d30790e608f84 100644 (file)
--- a/print-esp.c
+++ b/print-esp.c
@@ -717,7 +717,7 @@ esp_print(netdissect_options *ndo,
                        if (sa->spi == EXTRACT_BE_U_4(esp->esp_spi) &&
                            sa->daddr_version == 6 &&
                            UNALIGNED_MEMCMP(&sa->daddr.in6, &ip6->ip6_dst,
-                                  sizeof(struct in6_addr)) == 0) {
+                                  sizeof(nd_ipv6)) == 0) {
                                break;
                        }
                }
@@ -733,7 +733,7 @@ esp_print(netdissect_options *ndo,
                        if (sa->spi == EXTRACT_BE_U_4(esp->esp_spi) &&
                            sa->daddr_version == 4 &&
                            UNALIGNED_MEMCMP(&sa->daddr.in4, &ip->ip_dst,
-                                  sizeof(struct in_addr)) == 0) {
+                                  sizeof(nd_ipv4)) == 0) {
                                break;
                        }
                }

diff --git a/print-icmp6.c b/print-icmp6.c
index 9453ce9b73e0cfec44b0bffccb96ccd60819b2bd..df3e997e21b9fc12dad453be5dc6086686df6130 100644 (file)
--- a/print-icmp6.c
+++ b/print-icmp6.c
@@ -175,7 +175,7 @@ struct icmp6_hdr {
  */
 struct mld6_hdr {
        struct icmp6_hdr        mld6_hdr;
-       struct in6_addr         mld6_addr; /* multicast address */
+       nd_ipv6                 mld6_addr; /* multicast address */
 };
 
 #define mld6_type      mld6_hdr.icmp6_type
@@ -232,7 +232,7 @@ struct nd_router_advert {   /* router advertisement */
 
 struct nd_neighbor_solicit {   /* neighbor solicitation */
        struct icmp6_hdr        nd_ns_hdr;
-       struct in6_addr         nd_ns_target;   /*target address */
+       nd_ipv6                 nd_ns_target;   /*target address */
        /* could be followed by options */
 };
 
@@ -243,7 +243,7 @@ struct nd_neighbor_solicit {        /* neighbor solicitation */
 
 struct nd_neighbor_advert {    /* neighbor advertisement */
        struct icmp6_hdr        nd_na_hdr;
-       struct in6_addr         nd_na_target;   /* target address */
+       nd_ipv6                 nd_na_target;   /* target address */
        /* could be followed by options */
 };
 
@@ -258,8 +258,8 @@ struct nd_neighbor_advert { /* neighbor advertisement */
 
 struct nd_redirect {           /* redirect */
        struct icmp6_hdr        nd_rd_hdr;
-       struct in6_addr         nd_rd_target;   /* target address */
-       struct in6_addr         nd_rd_dst;      /* destination address */
+       nd_ipv6                 nd_rd_target;   /* target address */
+       nd_ipv6                 nd_rd_dst;      /* destination address */
        /* could be followed by options */
 };
 
@@ -286,14 +286,14 @@ struct nd_opt_hdr {               /* Neighbor discovery option header */
 #define ND_OPT_DNSSL                   31
 
 struct nd_opt_prefix_info {    /* prefix information */
-       nd_uint8_t              nd_opt_pi_type;
-       nd_uint8_t              nd_opt_pi_len;
-       nd_uint8_t              nd_opt_pi_prefix_len;
-       nd_uint8_t              nd_opt_pi_flags_reserved;
-       nd_uint32_t             nd_opt_pi_valid_time;
-       nd_uint32_t             nd_opt_pi_preferred_time;
-       nd_uint32_t             nd_opt_pi_reserved2;
-       struct in6_addr nd_opt_pi_prefix;
+       nd_uint8_t      nd_opt_pi_type;
+       nd_uint8_t      nd_opt_pi_len;
+       nd_uint8_t      nd_opt_pi_prefix_len;
+       nd_uint8_t      nd_opt_pi_flags_reserved;
+       nd_uint32_t     nd_opt_pi_valid_time;
+       nd_uint32_t     nd_opt_pi_preferred_time;
+       nd_uint32_t     nd_opt_pi_reserved2;
+       nd_ipv6         nd_opt_pi_prefix;
 };
 
 #define ND_OPT_PI_FLAG_ONLINK          0x80
@@ -320,7 +320,7 @@ struct nd_opt_rdnss {               /* RDNSS RFC 6106 5.1 */
        nd_uint8_t      nd_opt_rdnss_len;
        nd_uint16_t     nd_opt_rdnss_reserved;
        nd_uint32_t     nd_opt_rdnss_lifetime;
-       struct in6_addr nd_opt_rdnss_addr[1];   /* variable-length */
+       nd_ipv6         nd_opt_rdnss_addr[1];   /* variable-length */
 };
 
 struct nd_opt_dnssl {          /* DNSSL RFC 6106 5.2 */
@@ -1275,13 +1275,13 @@ icmp6_print(netdissect_options *ndo,
                 break;
        case ICMP6_HADISCOV_REPLY:
                if (ndo->ndo_vflag) {
-                       const struct in6_addr *in6;
+                       const nd_ipv6 *in6;
                        const u_char *cp;
 
                        ND_TCHECK_2(dp->icmp6_data16[0]);
                        ND_PRINT(", id 0x%04x", EXTRACT_BE_U_2(dp->icmp6_data16[0]));
                        cp = (const u_char *)dp + length;
-                       in6 = (const struct in6_addr *)(dp + 1);
+                       in6 = (const nd_ipv6 *)(dp + 1);
                        for (; (const u_char *)in6 < cp; in6++) {
                                ND_TCHECK_SIZE(in6);
                                ND_PRINT(", %s", ip6addr_string(ndo, in6));
@@ -1511,7 +1511,7 @@ icmp6_opt_print(netdissect_options *ndo, const u_char *bp, int resid)
                        opri = (const struct nd_opt_route_info *)op;
                        ND_TCHECK_4(opri->nd_opt_rti_lifetime);
                        memset(&in6, 0, sizeof(in6));
-                       in6p = (const struct in6_addr *)(opri + 1);
+                       in6p = (const nd_ipv6 *)(opri + 1);
                        switch (opt_len) {
                        case 1:
                                break;
@@ -1595,13 +1595,13 @@ mldv2_report_print(netdissect_options *ndo, const u_char *bp, u_int len)
                     ND_PRINT(" [invalid number of groups]");
                     return;
            }
-            ND_TCHECK_LEN(bp + 4 + group, sizeof(struct in6_addr));
+            ND_TCHECK_LEN(bp + 4 + group, sizeof(nd_ipv6));
             ND_PRINT(" [gaddr %s", ip6addr_string(ndo, bp + group + 4));
            ND_PRINT(" %s", tok2str(mldv2report2str, " [v2-report-#%u]",
                                          EXTRACT_U_1(bp + group)));
             nsrcs = EXTRACT_BE_U_2(bp + group + 2);
            /* Check the number of sources and print them */
-           if (len < group + 20 + (nsrcs * sizeof(struct in6_addr))) {
+           if (len < group + 20 + (nsrcs * sizeof(nd_ipv6))) {
                     ND_PRINT(" [invalid number of sources %u]", nsrcs);
                     return;
            }
@@ -1611,14 +1611,14 @@ mldv2_report_print(netdissect_options *ndo, const u_char *bp, u_int len)
                /* Print the sources */
                     ND_PRINT(" {");
                 for (j = 0; j < nsrcs; j++) {
-                    ND_TCHECK_LEN(bp + group + 20 + (j * sizeof(struct in6_addr)),
-                                  sizeof(struct in6_addr));
-                   ND_PRINT(" %s", ip6addr_string(ndo, bp + group + 20 + (j * sizeof(struct in6_addr))));
+                    ND_TCHECK_LEN(bp + group + 20 + (j * sizeof(nd_ipv6)),
+                                  sizeof(nd_ipv6));
+                   ND_PRINT(" %s", ip6addr_string(ndo, bp + group + 20 + (j * sizeof(nd_ipv6))));
                }
                 ND_PRINT(" }");
             }
            /* Next group record */
-            group += 20 + nsrcs * sizeof(struct in6_addr);
+            group += 20 + nsrcs * sizeof(nd_ipv6);
            ND_PRINT("]");
         }
     }
@@ -1652,7 +1652,7 @@ mldv2_query_print(netdissect_options *ndo, const u_char *bp, u_int len)
     if (ndo->ndo_vflag) {
             ND_PRINT(" [max resp delay=%u]", mrt);
     }
-    ND_TCHECK_LEN(bp + 8, sizeof(struct in6_addr));
+    ND_TCHECK_LEN(bp + 8, sizeof(nd_ipv6));
     ND_PRINT(" [gaddr %s", ip6addr_string(ndo, bp + 8));
 
     if (ndo->ndo_vflag) {
@@ -1675,14 +1675,14 @@ mldv2_query_print(netdissect_options *ndo, const u_char *bp, u_int len)
     ND_TCHECK_2(bp + 26);
     nsrcs = EXTRACT_BE_U_2(bp + 26);
     if (nsrcs > 0) {
-       if (len < 28 + nsrcs * sizeof(struct in6_addr))
+       if (len < 28 + nsrcs * sizeof(nd_ipv6))
            ND_PRINT(" [invalid number of sources]");
        else if (ndo->ndo_vflag > 1) {
            ND_PRINT(" {");
            for (i = 0; i < nsrcs; i++) {
-               ND_TCHECK_LEN(bp + 28 + (i * sizeof(struct in6_addr)),
-                              sizeof(struct in6_addr));
-               ND_PRINT(" %s", ip6addr_string(ndo, bp + 28 + (i * sizeof(struct in6_addr))));
+               ND_TCHECK_LEN(bp + 28 + (i * sizeof(nd_ipv6)),
+                              sizeof(nd_ipv6));
+               ND_PRINT(" %s", ip6addr_string(ndo, bp + 28 + (i * sizeof(nd_ipv6))));
            }
            ND_PRINT(" }");
        } else
@@ -1812,9 +1812,9 @@ icmp6_nodeinfo_print(netdissect_options *ndo, u_int icmp6len, const u_char *bp,
 
                switch (EXTRACT_U_1(ni6->ni_code)) {
                case ICMP6_NI_SUBJ_IPV6:
-                       if (!ND_TTEST_LEN(dp, sizeof(*ni6) + sizeof(struct in6_addr)))
+                       if (!ND_TTEST_LEN(dp, sizeof(*ni6) + sizeof(nd_ipv6)))
                                break;
-                       if (siz != sizeof(*ni6) + sizeof(struct in6_addr)) {
+                       if (siz != sizeof(*ni6) + sizeof(nd_ipv6)) {
                                if (ndo->ndo_vflag)
                                        ND_PRINT(", invalid subject len");
                                break;
@@ -1840,9 +1840,9 @@ icmp6_nodeinfo_print(netdissect_options *ndo, u_int icmp6len, const u_char *bp,
                                dnsname_print(ndo, cp, ep);
                        break;
                case ICMP6_NI_SUBJ_IPV4:
-                       if (!ND_TTEST_LEN(dp, sizeof(*ni6) + sizeof(struct in_addr)))
+                       if (!ND_TTEST_LEN(dp, sizeof(*ni6) + sizeof(nd_ipv4)))
                                break;
-                       if (siz != sizeof(*ni6) + sizeof(struct in_addr)) {
+                       if (siz != sizeof(*ni6) + sizeof(nd_ipv4)) {
                                if (ndo->ndo_vflag)
                                        ND_PRINT(", invalid subject len");
                                break;
@@ -1945,12 +1945,12 @@ icmp6_nodeinfo_print(netdissect_options *ndo, u_int icmp6len, const u_char *bp,
                        ND_PRINT("node addresses");
                        i = sizeof(*ni6);
                        while (i < siz) {
-                               if (i + sizeof(uint32_t) + sizeof(struct in6_addr) > siz)
+                               if (i + sizeof(uint32_t) + sizeof(nd_ipv6) > siz)
                                        break;
                                ND_PRINT(" %s(%u)",
                                    ip6addr_string(ndo, bp + i + sizeof(uint32_t)),
                                    EXTRACT_BE_U_4(bp + i));
-                               i += sizeof(uint32_t) + sizeof(struct in6_addr);
+                               i += sizeof(uint32_t) + sizeof(nd_ipv6);
                        }
                        i = EXTRACT_BE_U_2(ni6->ni_flags);
                        if (!i)

diff --git a/print-ip6.c b/print-ip6.c
index a8870ca2cf8877294ce688ba47a74ef4a061359a..53815402bfd97b1228cd00a9400d52a21721ac14 100644 (file)
--- a/print-ip6.c
+++ b/print-ip6.c
@@ -151,7 +151,7 @@ ip6_finddst(netdissect_options *ndo, struct in6_addr *dst,
 
 done:
 trunc:
-       UNALIGNED_MEMCPY(dst, dst_addr, sizeof(struct in6_addr));
+       UNALIGNED_MEMCPY(dst, dst_addr, sizeof(nd_ipv6));
 }
 
 /*

diff --git a/print-isakmp.c b/print-isakmp.c
index 84229ec5c2b19de8127234de1e715b9c1a6de69e..b13aff118bd562397984c53a7759cea8f5d128cd 100644 (file)
--- a/print-isakmp.c
+++ b/print-isakmp.c
@@ -780,14 +780,14 @@ cookie_record(const cookie_t *in, const u_char *bp2)
        switch (IP_V(ip)) {
        case 4:
                cookiecache[ninitiator].version = 4;
-               UNALIGNED_MEMCPY(&cookiecache[ninitiator].iaddr.in4, &ip->ip_src, sizeof(struct in_addr));
-               UNALIGNED_MEMCPY(&cookiecache[ninitiator].raddr.in4, &ip->ip_dst, sizeof(struct in_addr));
+               UNALIGNED_MEMCPY(&cookiecache[ninitiator].iaddr.in4, &ip->ip_src, sizeof(nd_ipv4));
+               UNALIGNED_MEMCPY(&cookiecache[ninitiator].raddr.in4, &ip->ip_dst, sizeof(nd_ipv4));
                break;
        case 6:
                ip6 = (const struct ip6_hdr *)bp2;
                cookiecache[ninitiator].version = 6;
-               UNALIGNED_MEMCPY(&cookiecache[ninitiator].iaddr.in6, &ip6->ip6_src, sizeof(struct in6_addr));
-               UNALIGNED_MEMCPY(&cookiecache[ninitiator].raddr.in6, &ip6->ip6_dst, sizeof(struct in6_addr));
+               UNALIGNED_MEMCPY(&cookiecache[ninitiator].iaddr.in6, &ip6->ip6_src, sizeof(nd_ipv6));
+               UNALIGNED_MEMCPY(&cookiecache[ninitiator].raddr.in6, &ip6->ip6_dst, sizeof(nd_ipv6));
                break;
        default:
                return;
@@ -810,10 +810,10 @@ cookie_sidecheck(int i, const u_char *bp2, int initiator)
                if (cookiecache[i].version != 4)
                        return 0;
                if (initiator) {
-                       if (UNALIGNED_MEMCMP(&ip->ip_src, &cookiecache[i].iaddr.in4, sizeof(struct in_addr)) == 0)
+                       if (UNALIGNED_MEMCMP(&ip->ip_src, &cookiecache[i].iaddr.in4, sizeof(nd_ipv4)) == 0)
                                return 1;
                } else {
-                       if (UNALIGNED_MEMCMP(&ip->ip_src, &cookiecache[i].raddr.in4, sizeof(struct in_addr)) == 0)
+                       if (UNALIGNED_MEMCMP(&ip->ip_src, &cookiecache[i].raddr.in4, sizeof(nd_ipv4)) == 0)
                                return 1;
                }
                break;
@@ -822,10 +822,10 @@ cookie_sidecheck(int i, const u_char *bp2, int initiator)
                        return 0;
                ip6 = (const struct ip6_hdr *)bp2;
                if (initiator) {
-                       if (UNALIGNED_MEMCMP(&ip6->ip6_src, &cookiecache[i].iaddr.in6, sizeof(struct in6_addr)) == 0)
+                       if (UNALIGNED_MEMCMP(&ip6->ip6_src, &cookiecache[i].iaddr.in6, sizeof(nd_ipv6)) == 0)
                                return 1;
                } else {
-                       if (UNALIGNED_MEMCMP(&ip6->ip6_src, &cookiecache[i].raddr.in6, sizeof(struct in6_addr)) == 0)
+                       if (UNALIGNED_MEMCMP(&ip6->ip6_src, &cookiecache[i].raddr.in6, sizeof(nd_ipv6)) == 0)
                                return 1;
                }
                break;
@@ -1402,7 +1402,7 @@ ikev1_id_print(netdissect_options *ndo, u_char tpay _U_,
                        if (len < 8)
                                ND_PRINT(" len=%u [bad: < 8]", len);
                        else {
-                               mask = data + sizeof(struct in_addr);
+                               mask = data + sizeof(nd_ipv4);
                                ND_PRINT(" len=%u %s/%u.%u.%u.%u", len,
                                          ipaddr_string(ndo, data),
                                          EXTRACT_U_1(mask), EXTRACT_U_1(mask + 1),
@@ -1424,7 +1424,7 @@ ikev1_id_print(netdissect_options *ndo, u_char tpay _U_,
                        if (len < 32)
                                ND_PRINT(" len=%u [bad: < 32]", len);
                        else {
-                               mask = (const u_char *)(data + sizeof(struct in6_addr));
+                               mask = (const u_char *)(data + sizeof(nd_ipv6));
                                /*XXX*/
                                ND_PRINT(" len=%u %s/0x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", len,
                                          ip6addr_string(ndo, data),
@@ -1442,7 +1442,7 @@ ikev1_id_print(netdissect_options *ndo, u_char tpay _U_,
                        else {
                                ND_PRINT(" len=%u %s-%s", len,
                                          ipaddr_string(ndo, data),
-                                         ipaddr_string(ndo, data + sizeof(struct in_addr)));
+                                         ipaddr_string(ndo, data + sizeof(nd_ipv4)));
                        }
                        len = 0;
                        break;
@@ -1452,7 +1452,7 @@ ikev1_id_print(netdissect_options *ndo, u_char tpay _U_,
                        else {
                                ND_PRINT(" len=%u %s-%s", len,
                                          ip6addr_string(ndo, data),
-                                         ip6addr_string(ndo, data + sizeof(struct in6_addr)));
+                                         ip6addr_string(ndo, data + sizeof(nd_ipv6)));
                        }
                        len = 0;
                        break;

diff --git a/print-isoclns.c b/print-isoclns.c
index b8252301d3b029e644b85908a305781c16b74105..e5de4ab11b125efa22de328ae6d911e891b33dda 100644 (file)
--- a/print-isoclns.c
+++ b/print-isoclns.c
@@ -1929,7 +1929,7 @@ isis_print_ext_is_reach(netdissect_options *ndo,
                 break;
             case ISIS_SUBTLV_EXT_IS_REACH_IPV4_INTF_ADDR:
             case ISIS_SUBTLV_EXT_IS_REACH_IPV4_NEIGHBOR_ADDR:
-                if (subtlv_len >= sizeof(struct in_addr))
+                if (subtlv_len >= sizeof(nd_ipv4))
                     ND_PRINT(", %s", ipaddr_string(ndo, tptr));
                 break;
             case ISIS_SUBTLV_EXT_IS_REACH_MAX_LINK_BW :
@@ -2124,7 +2124,7 @@ isis_print_extd_ip_reach(netdissect_options *ndo,
                          const uint8_t *tptr, const char *ident, uint16_t afi)
 {
     char ident_buffer[20];
-    uint8_t prefix[sizeof(struct in6_addr)]; /* shared copy buffer for IPv4 and IPv6 prefixes */
+    uint8_t prefix[sizeof(nd_ipv6)]; /* shared copy buffer for IPv4 and IPv6 prefixes */
     u_int metric, status_byte, bit_length, byte_length, sublen, processed, subtlvtype, subtlvlen;
 
     if (!ND_TTEST_4(tptr))
@@ -2825,14 +2825,14 @@ isis_print(netdissect_options *ndo,
            break;
 
        case ISIS_TLV_IP6ADDR:
-           while (tmp>=sizeof(struct in6_addr)) {
-               ND_TCHECK_LEN(tptr, sizeof(struct in6_addr));
+           while (tmp>=sizeof(nd_ipv6)) {
+               ND_TCHECK_LEN(tptr, sizeof(nd_ipv6));
 
                 ND_PRINT("\n\t      IPv6 interface address: %s",
                       ip6addr_string(ndo, tptr));
 
-               tptr += sizeof(struct in6_addr);
-               tmp -= sizeof(struct in6_addr);
+               tptr += sizeof(nd_ipv6);
+               tmp -= sizeof(nd_ipv6);
            }
            break;
        case ISIS_TLV_AUTH:
@@ -2958,16 +2958,16 @@ isis_print(netdissect_options *ndo,
       break;
 
        case ISIS_TLV_TE_ROUTER_ID:
-           ND_TCHECK_LEN(pptr, sizeof(struct in_addr));
+           ND_TCHECK_LEN(pptr, sizeof(nd_ipv4));
            ND_PRINT("\n\t      Traffic Engineering Router ID: %s", ipaddr_string(ndo, pptr));
            break;
 
        case ISIS_TLV_IPADDR:
-           while (tmp>=sizeof(struct in_addr)) {
-               ND_TCHECK_LEN(tptr, sizeof(struct in_addr));
+           while (tmp>=sizeof(nd_ipv4)) {
+               ND_TCHECK_LEN(tptr, sizeof(nd_ipv4));
                ND_PRINT("\n\t      IPv4 interface address: %s", ipaddr_string(ndo, tptr));
-               tptr += sizeof(struct in_addr);
-               tmp -= sizeof(struct in_addr);
+               tptr += sizeof(nd_ipv4);
+               tmp -= sizeof(nd_ipv4);
            }
            break;
 
@@ -2992,19 +2992,19 @@ isis_print(netdissect_options *ndo,
            tptr++;
            tmp--;
 
-           if (tmp < sizeof(struct in_addr))
+           if (tmp < sizeof(nd_ipv4))
                break;
-           ND_TCHECK_LEN(tptr, sizeof(struct in_addr));
+           ND_TCHECK_LEN(tptr, sizeof(nd_ipv4));
            ND_PRINT("\n\t      IPv4 interface address: %s", ipaddr_string(ndo, tptr));
-           tptr+=sizeof(struct in_addr);
-           tmp-=sizeof(struct in_addr);
+           tptr+=sizeof(nd_ipv4);
+           tmp-=sizeof(nd_ipv4);
 
-           if (tmp < sizeof(struct in_addr))
+           if (tmp < sizeof(nd_ipv4))
                break;
-           ND_TCHECK_LEN(tptr, sizeof(struct in_addr));
+           ND_TCHECK_LEN(tptr, sizeof(nd_ipv4));
            ND_PRINT("\n\t      IPv4 neighbor address: %s", ipaddr_string(ndo, tptr));
-           tptr+=sizeof(struct in_addr);
-           tmp-=sizeof(struct in_addr);
+           tptr+=sizeof(nd_ipv4);
+           tmp-=sizeof(nd_ipv4);
 
            while (tmp>=4) {
                 ND_TCHECK_4(tptr);

diff --git a/print-ldp.c b/print-ldp.c
index ce0489b0e2bd89743c829b302d52bffc4f3b3b4c..4f89186a7cc49fdbd11af2b4f319d58c56e9ab60 100644 (file)
--- a/print-ldp.c
+++ b/print-ldp.c
@@ -303,19 +303,19 @@ ldp_tlv_print(netdissect_options *ndo,
                tok2str(af_values, "Unknown (%u)", af));
         switch (af) {
         case AFNUM_INET:
-           while(tlv_tlen >= sizeof(struct in_addr)) {
-               ND_TCHECK_LEN(tptr, sizeof(struct in_addr));
+           while(tlv_tlen >= sizeof(nd_ipv4)) {
+               ND_TCHECK_LEN(tptr, sizeof(nd_ipv4));
                ND_PRINT(" %s", ipaddr_string(ndo, tptr));
-               tlv_tlen-=sizeof(struct in_addr);
-               tptr+=sizeof(struct in_addr);
+               tlv_tlen-=sizeof(nd_ipv4);
+               tptr+=sizeof(nd_ipv4);
            }
             break;
         case AFNUM_INET6:
-           while(tlv_tlen >= sizeof(struct in6_addr)) {
-               ND_TCHECK_LEN(tptr, sizeof(struct in6_addr));
+           while(tlv_tlen >= sizeof(nd_ipv6)) {
+               ND_TCHECK_LEN(tptr, sizeof(nd_ipv6));
                ND_PRINT(" %s", ip6addr_string(ndo, tptr));
-               tlv_tlen-=sizeof(struct in6_addr);
-               tptr+=sizeof(struct in6_addr);
+               tlv_tlen-=sizeof(nd_ipv6);
+               tptr+=sizeof(nd_ipv6);
            }
             break;
         default:

diff --git a/print-lwres.c b/print-lwres.c
index 0e0d1aa24df540b6f7575fad6107e7139194987b..b2a32be6d36be9f806e4e1705f056ac70cd2928d 100644 (file)
--- a/print-lwres.c
+++ b/print-lwres.c
@@ -281,13 +281,13 @@ lwres_printaddr(netdissect_options *ndo,
                if (l < 4)
                        return -1;
                ND_PRINT(" %s", ipaddr_string(ndo, p));
-               p += sizeof(struct in_addr);
+               p += sizeof(nd_ipv4);
                break;
        case 2: /* IPv6 */
                if (l < 16)
                        return -1;
                ND_PRINT(" %s", ip6addr_string(ndo, p));
-               p += sizeof(struct in6_addr);
+               p += sizeof(nd_ipv6);
                break;
        default:
                ND_PRINT(" %u/", EXTRACT_BE_U_4(ap->family));

diff --git a/print-olsr.c b/print-olsr.c
index 3fa980c16396875ea1b7428d284af314feb9c29d..7f446d6df302e46f4cd5df146309a82b109df989 100644 (file)
--- a/print-olsr.c
+++ b/print-olsr.c
@@ -290,17 +290,17 @@ olsr_print_neighbor(netdissect_options *ndo,
     ND_PRINT("\n\t      neighbor\n\t\t");
     neighbor = 1;
 
-    while (hello_len >= sizeof(struct in_addr)) {
+    while (hello_len >= sizeof(nd_ipv4)) {
 
-        if (!ND_TTEST_LEN(msg_data, sizeof(struct in_addr)))
+        if (!ND_TTEST_LEN(msg_data, sizeof(nd_ipv4)))
             return (-1);
         /* print 4 neighbors per line */
 
         ND_PRINT("%s%s", ipaddr_string(ndo, msg_data),
                neighbor % 4 == 0 ? "\n\t\t" : " ");
 
-        msg_data += sizeof(struct in_addr);
-        hello_len -= sizeof(struct in_addr);
+        msg_data += sizeof(nd_ipv4);
+        hello_len -= sizeof(nd_ipv4);
     }
     return (0);
 }
@@ -514,10 +514,10 @@ olsr_print(netdissect_options *ndo,
 
         case OLSR_MID_MSG:
         {
-            size_t addr_size = sizeof(struct in_addr);
+            size_t addr_size = sizeof(nd_ipv4);
 
             if (is_ipv6)
-                addr_size = sizeof(struct in6_addr);
+                addr_size = sizeof(nd_ipv6);
 
             while (msg_tlen >= addr_size) {
                 ND_TCHECK_LEN(msg_data, addr_size);

diff --git a/print-ospf6.c b/print-ospf6.c
index 8704c25273e742ffa759f5156abe3b1e91c32cef..426e7cefc7179a84921431da25fd3a42c2a31ea2 100644 (file)
--- a/print-ospf6.c
+++ b/print-ospf6.c
@@ -208,7 +208,7 @@ struct lsa6 {
            } llsa_priandopt;
 #define llsa_priority  llsa_priandopt.pri
 #define llsa_options   llsa_priandopt.opt
-           struct in6_addr llsa_lladdr;
+           nd_ipv6     llsa_lladdr;
            nd_uint32_t llsa_nprefix;
            struct lsa6_prefix llsa_prefix[1];
        } un_llsa;
@@ -419,7 +419,7 @@ ospf6_print_lsaprefix(netdissect_options *ndo,
        lsa_length -= sizeof (*lsapp) - IPV6_ADDR_LEN_BYTES;
        ND_TCHECK_LEN(lsapp, sizeof(*lsapp) - IPV6_ADDR_LEN_BYTES);
        wordlen = (EXTRACT_U_1(lsapp->lsa_p_len) + 31) / 32;
-       if (wordlen * 4 > sizeof(struct in6_addr)) {
+       if (wordlen * 4 > sizeof(nd_ipv6)) {
                ND_PRINT(" bogus prefixlen /%u", EXTRACT_U_1(lsapp->lsa_p_len));
                goto trunc;
        }
@@ -602,9 +602,9 @@ ospf6_print_lsa(netdissect_options *ndo,
                tptr += bytelen;
 
                if ((flags32 & ASLA_FLAG_FWDADDR) != 0) {
-                       const struct in6_addr *fwdaddr6;
+                       const nd_ipv6 *fwdaddr6;
 
-                       fwdaddr6 = (const struct in6_addr *)tptr;
+                       fwdaddr6 = (const nd_ipv6 *)tptr;
                        if (lsa_length < sizeof (*fwdaddr6))
                                return (1);
                        lsa_length -= sizeof (*fwdaddr6);

diff --git a/print-pgm.c b/print-pgm.c
index 8656faaca6e2b8d15fac5ae1bc4b5d49dc441b40..171acce955eaa2eaa5383ff59be686fe524140b4 100644 (file)
--- a/print-pgm.c
+++ b/print-pgm.c
@@ -230,14 +230,14 @@ pgm_print(netdissect_options *ndo,
 
            switch (EXTRACT_BE_U_2(spm->pgms_nla_afi)) {
            case AFNUM_INET:
-               ND_TCHECK_LEN(bp, sizeof(struct in_addr));
+               ND_TCHECK_LEN(bp, sizeof(nd_ipv4));
                addrtostr(bp, nla_buf, sizeof(nla_buf));
-               bp += sizeof(struct in_addr);
+               bp += sizeof(nd_ipv4);
                break;
            case AFNUM_INET6:
-               ND_TCHECK_LEN(bp, sizeof(struct in6_addr));
+               ND_TCHECK_LEN(bp, sizeof(nd_ipv6));
                addrtostr6(bp, nla_buf, sizeof(nla_buf));
-               bp += sizeof(struct in6_addr);
+               bp += sizeof(nd_ipv6);
                break;
            default:
                goto trunc;
@@ -273,14 +273,14 @@ pgm_print(netdissect_options *ndo,
 
            switch (EXTRACT_BE_U_2(polr->pgmp_nla_afi)) {
            case AFNUM_INET:
-               ND_TCHECK_LEN(bp, sizeof(struct in_addr));
+               ND_TCHECK_LEN(bp, sizeof(nd_ipv4));
                addrtostr(bp, nla_buf, sizeof(nla_buf));
-               bp += sizeof(struct in_addr);
+               bp += sizeof(nd_ipv4);
                break;
            case AFNUM_INET6:
-               ND_TCHECK_LEN(bp, sizeof(struct in6_addr));
+               ND_TCHECK_LEN(bp, sizeof(nd_ipv6));
                addrtostr6(bp, nla_buf, sizeof(nla_buf));
-               bp += sizeof(struct in6_addr);
+               bp += sizeof(nd_ipv6);
                break;
            default:
                goto trunc;
@@ -344,14 +344,14 @@ pgm_print(netdissect_options *ndo,
             */
            switch (EXTRACT_BE_U_2(nak->pgmn_source_afi)) {
            case AFNUM_INET:
-               ND_TCHECK_LEN(bp, sizeof(struct in_addr));
+               ND_TCHECK_LEN(bp, sizeof(nd_ipv4));
                addrtostr(bp, source_buf, sizeof(source_buf));
-               bp += sizeof(struct in_addr);
+               bp += sizeof(nd_ipv4);
                break;
            case AFNUM_INET6:
-               ND_TCHECK_LEN(bp, sizeof(struct in6_addr));
+               ND_TCHECK_LEN(bp, sizeof(nd_ipv6));
                addrtostr6(bp, source_buf, sizeof(source_buf));
-               bp += sizeof(struct in6_addr);
+               bp += sizeof(nd_ipv6);
                break;
            default:
                goto trunc;
@@ -366,14 +366,14 @@ pgm_print(netdissect_options *ndo,
            ND_TCHECK_2(bp);
            switch (EXTRACT_BE_U_2(bp)) {
            case AFNUM_INET:
-               ND_TCHECK_LEN(bp, sizeof(struct in_addr));
+               ND_TCHECK_LEN(bp, sizeof(nd_ipv4));
                addrtostr(bp, group_buf, sizeof(group_buf));
-               bp += sizeof(struct in_addr);
+               bp += sizeof(nd_ipv4);
                break;
            case AFNUM_INET6:
-               ND_TCHECK_LEN(bp, sizeof(struct in6_addr));
+               ND_TCHECK_LEN(bp, sizeof(nd_ipv6));
                addrtostr6(bp, group_buf, sizeof(group_buf));
-               bp += sizeof(struct in6_addr);
+               bp += sizeof(nd_ipv6);
                break;
            default:
                goto trunc;
@@ -589,26 +589,26 @@ pgm_print(netdissect_options *ndo,
                    bp += 2+2;
                    switch (nla_afnum) {
                    case AFNUM_INET:
-                       if (opt_len != PGM_OPT_REDIRECT_FIXED_LEN + sizeof(struct in_addr)) {
+                       if (opt_len != PGM_OPT_REDIRECT_FIXED_LEN + sizeof(nd_ipv4)) {
                            ND_PRINT("[Bad OPT_REDIRECT option, length %u != %u + address size]",
                                opt_len, PGM_OPT_REDIRECT_FIXED_LEN);
                            return;
                        }
-                       ND_TCHECK_LEN(bp, sizeof(struct in_addr));
+                       ND_TCHECK_LEN(bp, sizeof(nd_ipv4));
                        addrtostr(bp, nla_buf, sizeof(nla_buf));
-                       bp += sizeof(struct in_addr);
-                       opts_len -= PGM_OPT_REDIRECT_FIXED_LEN + sizeof(struct in_addr);
+                       bp += sizeof(nd_ipv4);
+                       opts_len -= PGM_OPT_REDIRECT_FIXED_LEN + sizeof(nd_ipv4);
                        break;
                    case AFNUM_INET6:
-                       if (opt_len != PGM_OPT_REDIRECT_FIXED_LEN + sizeof(struct in6_addr)) {
+                       if (opt_len != PGM_OPT_REDIRECT_FIXED_LEN + sizeof(nd_ipv6)) {
                            ND_PRINT("[Bad OPT_REDIRECT option, length %u != %u + address size]",
                                PGM_OPT_REDIRECT_FIXED_LEN, opt_len);
                            return;
                        }
-                       ND_TCHECK_LEN(bp, sizeof(struct in6_addr));
+                       ND_TCHECK_LEN(bp, sizeof(nd_ipv6));
                        addrtostr6(bp, nla_buf, sizeof(nla_buf));
-                       bp += sizeof(struct in6_addr);
-                       opts_len -= PGM_OPT_REDIRECT_FIXED_LEN + sizeof(struct in6_addr);
+                       bp += sizeof(nd_ipv6);
+                       opts_len -= PGM_OPT_REDIRECT_FIXED_LEN + sizeof(nd_ipv6);
                        break;
                    default:
                        goto trunc;
@@ -746,26 +746,26 @@ pgm_print(netdissect_options *ndo,
                    bp += 2+2;
                    switch (nla_afnum) {
                    case AFNUM_INET:
-                       if (opt_len != PGM_OPT_PGMCC_DATA_FIXED_LEN + sizeof(struct in_addr)) {
+                       if (opt_len != PGM_OPT_PGMCC_DATA_FIXED_LEN + sizeof(nd_ipv4)) {
                            ND_PRINT("[Bad OPT_PGMCC_DATA option, length %u != %u + address size]",
                                opt_len, PGM_OPT_PGMCC_DATA_FIXED_LEN);
                            return;
                        }
-                       ND_TCHECK_LEN(bp, sizeof(struct in_addr));
+                       ND_TCHECK_LEN(bp, sizeof(nd_ipv4));
                        addrtostr(bp, nla_buf, sizeof(nla_buf));
-                       bp += sizeof(struct in_addr);
-                       opts_len -= PGM_OPT_PGMCC_DATA_FIXED_LEN + sizeof(struct in_addr);
+                       bp += sizeof(nd_ipv4);
+                       opts_len -= PGM_OPT_PGMCC_DATA_FIXED_LEN + sizeof(nd_ipv4);
                        break;
                    case AFNUM_INET6:
-                       if (opt_len != PGM_OPT_PGMCC_DATA_FIXED_LEN + sizeof(struct in6_addr)) {
+                       if (opt_len != PGM_OPT_PGMCC_DATA_FIXED_LEN + sizeof(nd_ipv6)) {
                            ND_PRINT("[Bad OPT_PGMCC_DATA option, length %u != %u + address size]",
                                opt_len, PGM_OPT_PGMCC_DATA_FIXED_LEN);
                            return;
                        }
-                       ND_TCHECK_LEN(bp, sizeof(struct in6_addr));
+                       ND_TCHECK_LEN(bp, sizeof(nd_ipv6));
                        addrtostr6(bp, nla_buf, sizeof(nla_buf));
-                       bp += sizeof(struct in6_addr);
-                       opts_len -= PGM_OPT_PGMCC_DATA_FIXED_LEN + sizeof(struct in6_addr);
+                       bp += sizeof(nd_ipv6);
+                       opts_len -= PGM_OPT_PGMCC_DATA_FIXED_LEN + sizeof(nd_ipv6);
                        break;
                    default:
                        goto trunc;
@@ -789,26 +789,26 @@ pgm_print(netdissect_options *ndo,
                    bp += 2+2;
                    switch (nla_afnum) {
                    case AFNUM_INET:
-                       if (opt_len != PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN + sizeof(struct in_addr)) {
+                       if (opt_len != PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN + sizeof(nd_ipv4)) {
                            ND_PRINT("[Bad OPT_PGMCC_FEEDBACK option, length %u != %u + address size]",
                                opt_len, PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN);
                            return;
                        }
-                       ND_TCHECK_LEN(bp, sizeof(struct in_addr));
+                       ND_TCHECK_LEN(bp, sizeof(nd_ipv4));
                        addrtostr(bp, nla_buf, sizeof(nla_buf));
-                       bp += sizeof(struct in_addr);
-                       opts_len -= PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN + sizeof(struct in_addr);
+                       bp += sizeof(nd_ipv4);
+                       opts_len -= PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN + sizeof(nd_ipv4);
                        break;
                    case AFNUM_INET6:
-                       if (opt_len != PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN + sizeof(struct in6_addr)) {
+                       if (opt_len != PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN + sizeof(nd_ipv6)) {
                            ND_PRINT("[Bad OPT_PGMCC_FEEDBACK option, length %u != %u + address size]",
                                opt_len, PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN);
                            return;
                        }
-                       ND_TCHECK_LEN(bp, sizeof(struct in6_addr));
+                       ND_TCHECK_LEN(bp, sizeof(nd_ipv6));
                        addrtostr6(bp, nla_buf, sizeof(nla_buf));
-                       bp += sizeof(struct in6_addr);
-                       opts_len -= PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN + sizeof(struct in6_addr);
+                       bp += sizeof(nd_ipv6);
+                       opts_len -= PGM_OPT_PGMCC_FEEDBACK_FIXED_LEN + sizeof(nd_ipv6);
                        break;
                    default:
                        goto trunc;

diff --git a/print-pim.c b/print-pim.c
index e9bb9a716c87e289d37ac264ae4f160d9851f89f..d30cf8f45e8b27849ae5415ff1c72dac3faa75ab 100644 (file)
--- a/print-pim.c
+++ b/print-pim.c
@@ -169,9 +169,9 @@ pimv1_join_prune_print(netdissect_options *ndo,
                return;
        }
 
-       if (len < sizeof(struct in_addr))
+       if (len < sizeof(nd_ipv4))
                goto trunc;
-       ND_TCHECK_LEN(bp, sizeof(struct in_addr));
+       ND_TCHECK_LEN(bp, sizeof(nd_ipv4));
        if (ndo->ndo_vflag > 1)
                ND_PRINT("\n");
        ND_PRINT(" Upstream Nbr: %s", ipaddr_string(ndo, bp));
@@ -202,13 +202,13 @@ pimv1_join_prune_print(netdissect_options *ndo,
                 */
                if (len < 4)
                        goto trunc;
-               ND_TCHECK_LEN(bp, sizeof(struct in_addr));
+               ND_TCHECK_LEN(bp, sizeof(nd_ipv4));
                ND_PRINT("\n\tGroup: %s", ipaddr_string(ndo, bp));
                bp += 4;
                len -= 4;
                if (len < 4)
                        goto trunc;
-               ND_TCHECK_LEN(bp, sizeof(struct in_addr));
+               ND_TCHECK_LEN(bp, sizeof(nd_ipv4));
                if (EXTRACT_BE_U_4(bp) != 0xffffffff)
                        ND_PRINT("/%s", ipaddr_string(ndo, bp));
                bp += 4;
@@ -290,7 +290,7 @@ pimv1_print(netdissect_options *ndo,
                          ipaddr_string(ndo, bp + 24));
                break;
        case PIMV1_TYPE_REGISTER_STOP:
-               ND_TCHECK_LEN(bp + 12, sizeof(struct in_addr));
+               ND_TCHECK_LEN(bp + 12, sizeof(nd_ipv4));
                ND_PRINT(" for %s > %s", ipaddr_string(ndo, bp + 8),
                          ipaddr_string(ndo, bp + 12));
                break;
@@ -305,7 +305,7 @@ pimv1_print(netdissect_options *ndo,
                }
                break;
        case PIMV1_TYPE_ASSERT:
-               ND_TCHECK_LEN(bp + 16, sizeof(struct in_addr));
+               ND_TCHECK_LEN(bp + 16, sizeof(nd_ipv4));
                ND_PRINT(" for %s > %s", ipaddr_string(ndo, bp + 16),
                          ipaddr_string(ndo, bp + 8));
                if (EXTRACT_BE_U_4(bp + 12) != 0xffffffff)
@@ -575,11 +575,11 @@ pimv2_addr_print(netdissect_options *ndo,
                switch (EXTRACT_U_1(bp)) {
                case 1:
                        af = AF_INET;
-                       addr_len = (u_int)sizeof(struct in_addr);
+                       addr_len = (u_int)sizeof(nd_ipv4);
                        break;
                case 2:
                        af = AF_INET6;
-                       addr_len = (u_int)sizeof(struct in6_addr);
+                       addr_len = (u_int)sizeof(nd_ipv6);
                        break;
                default:
                        return -1;
@@ -589,10 +589,10 @@ pimv2_addr_print(netdissect_options *ndo,
                hdrlen = 2;
        } else {
                switch (addr_len) {
-               case sizeof(struct in_addr):
+               case sizeof(nd_ipv4):
                        af = AF_INET;
                        break;
-               case sizeof(struct in6_addr):
+               case sizeof(nd_ipv6):
                        af = AF_INET6;
                        break;
                default:

diff --git a/print-ripng.c b/print-ripng.c
index a253655ef3319f5a2b8b0847f2955a516cf55faa..12c8815984ddb5f1f573854e15fe160356222e86 100644 (file)
--- a/print-ripng.c
+++ b/print-ripng.c
@@ -65,7 +65,7 @@
 #define        RIP6_RESPONSE   2
 
 struct netinfo6 {
-       struct in6_addr rip6_dest;
+       nd_ipv6         rip6_dest;
        nd_uint16_t     rip6_tag;
        nd_uint8_t      rip6_plen;
        nd_uint8_t      rip6_metric;
@@ -85,13 +85,11 @@ struct      rip6 {
 
 #define        HOPCNT_INFINITY6        16
 
-#if !defined(IN6_IS_ADDR_UNSPECIFIED) && !defined(_MSC_VER) /* MSVC inline */
-static int IN6_IS_ADDR_UNSPECIFIED(const struct in6_addr *addr)
+static int ND_IN6_IS_ADDR_UNSPECIFIED(const nd_ipv6 *addr)
 {
     static const struct in6_addr in6addr_any;        /* :: */
     return (memcmp(addr, &in6addr_any, sizeof(*addr)) == 0);
 }
-#endif
 
 static int
 rip6_entry_print(netdissect_options *ndo, const struct netinfo6 *ni, u_int metric)
@@ -130,7 +128,7 @@ ripng_print(netdissect_options *ndo, const u_char *dat, unsigned int length)
                if (j == 1) {
                        ND_TCHECK_SIZE(rp->rip6_nets);
                        if (EXTRACT_U_1(rp->rip6_nets->rip6_metric) == HOPCNT_INFINITY6
-                           &&  IN6_IS_ADDR_UNSPECIFIED(&rp->rip6_nets->rip6_dest)) {
+                           && ND_IN6_IS_ADDR_UNSPECIFIED(&rp->rip6_nets->rip6_dest)) {
                                ND_PRINT(" ripng-req dump");
                                break;
                        }

diff --git a/print-rsvp.c b/print-rsvp.c
index 38f6ef70e92cdeadd90a2c58034989772d46891b..eb4c917ec189bb0033336d681994b681ed214792 100644 (file)
--- a/print-rsvp.c
+++ b/print-rsvp.c
@@ -743,7 +743,7 @@ rsvp_obj_print(netdissect_options *ndo,
                 ND_PRINT("%s  IPv4 DestAddress: %s, Protocol ID: 0x%02x",
                        indent,
                        ipaddr_string(ndo, obj_tptr),
-                       EXTRACT_U_1(obj_tptr + sizeof(struct in_addr)));
+                       EXTRACT_U_1(obj_tptr + sizeof(nd_ipv4)));
                 ND_PRINT("%s  Flags: [0x%02x], DestPort %u",
                        indent,
                        EXTRACT_U_1((obj_tptr + 5)),
@@ -757,11 +757,11 @@ rsvp_obj_print(netdissect_options *ndo,
                 ND_PRINT("%s  IPv6 DestAddress: %s, Protocol ID: 0x%02x",
                        indent,
                        ip6addr_string(ndo, obj_tptr),
-                       EXTRACT_U_1(obj_tptr + sizeof(struct in6_addr)));
+                       EXTRACT_U_1(obj_tptr + sizeof(nd_ipv6)));
                 ND_PRINT("%s  Flags: [0x%02x], DestPort %u",
                        indent,
-                       EXTRACT_U_1((obj_tptr + sizeof(struct in6_addr) + 1)),
-                       EXTRACT_BE_U_2(obj_tptr + sizeof(struct in6_addr) + 2));
+                       EXTRACT_U_1((obj_tptr + sizeof(nd_ipv6) + 1)),
+                       EXTRACT_BE_U_2(obj_tptr + sizeof(nd_ipv6) + 2));
                 obj_tlen-=20;
                 obj_tptr+=20;
                 break;
@@ -820,22 +820,22 @@ rsvp_obj_print(netdissect_options *ndo,
         case RSVP_OBJ_CONFIRM:
             switch(rsvp_obj_ctype) {
             case RSVP_CTYPE_IPV4:
-                if (obj_tlen < sizeof(struct in_addr))
+                if (obj_tlen < sizeof(nd_ipv4))
                     return -1;
                 ND_PRINT("%s  IPv4 Receiver Address: %s",
                        indent,
                        ipaddr_string(ndo, obj_tptr));
-                obj_tlen-=sizeof(struct in_addr);
-                obj_tptr+=sizeof(struct in_addr);
+                obj_tlen-=sizeof(nd_ipv4);
+                obj_tptr+=sizeof(nd_ipv4);
                 break;
             case RSVP_CTYPE_IPV6:
-                if (obj_tlen < sizeof(struct in6_addr))
+                if (obj_tlen < sizeof(nd_ipv6))
                     return -1;
                 ND_PRINT("%s  IPv6 Receiver Address: %s",
                        indent,
                        ip6addr_string(ndo, obj_tptr));
-                obj_tlen-=sizeof(struct in6_addr);
-                obj_tptr+=sizeof(struct in6_addr);
+                obj_tlen-=sizeof(nd_ipv6);
+                obj_tptr+=sizeof(nd_ipv6);
                 break;
             default:
                 hexdump=TRUE;
@@ -845,22 +845,22 @@ rsvp_obj_print(netdissect_options *ndo,
         case RSVP_OBJ_NOTIFY_REQ:
             switch(rsvp_obj_ctype) {
             case RSVP_CTYPE_IPV4:
-                if (obj_tlen < sizeof(struct in_addr))
+                if (obj_tlen < sizeof(nd_ipv4))
                     return -1;
                 ND_PRINT("%s  IPv4 Notify Node Address: %s",
                        indent,
                        ipaddr_string(ndo, obj_tptr));
-                obj_tlen-=sizeof(struct in_addr);
-                obj_tptr+=sizeof(struct in_addr);
+                obj_tlen-=sizeof(nd_ipv4);
+                obj_tptr+=sizeof(nd_ipv4);
                 break;
             case RSVP_CTYPE_IPV6:
-                if (obj_tlen < sizeof(struct in6_addr))
+                if (obj_tlen < sizeof(nd_ipv6))
                     return-1;
                 ND_PRINT("%s  IPv6 Notify Node Address: %s",
                        indent,
                        ip6addr_string(ndo, obj_tptr));
-                obj_tlen-=sizeof(struct in6_addr);
-                obj_tptr+=sizeof(struct in6_addr);
+                obj_tlen-=sizeof(nd_ipv6);
+                obj_tptr+=sizeof(nd_ipv6);
                 break;
             default:
                 hexdump=TRUE;