Add printing support for vsockmon devices.

[tcpdump] / print-ip6.c

diff --git a/print-ip6.c b/print-ip6.c
index 2e1803f05d5155cf0ce6d1d1825f92ab40a26480..9f8b4dbf63734ed7cf5f7fc3dd53eaf43723f36e 100644 (file)
--- a/print-ip6.c
+++ b/print-ip6.c
@@ -22,10 +22,10 @@
 /* \summary: IPv6 printer */
 
 #ifdef HAVE_CONFIG_H
 /* \summary: IPv6 printer */
 
 #ifdef HAVE_CONFIG_H

-#include "config.h"
+#include <config.h>

 #endif
 
 #endif
 

-#include <netdissect-stdinc.h>
+#include "netdissect-stdinc.h"

 
 #include <string.h>
 
 
 #include <string.h>
 


@@ -48,18 +48,19 @@ ip6_finddst(netdissect_options *ndo, struct in6_addr *dst,
             const struct ip6_hdr *ip6)
 {
        const u_char *cp;
             const struct ip6_hdr *ip6)
 {
        const u_char *cp;

-       int advance;
+       u_int advance;

        u_int nh;
        u_int nh;

-       const struct in6_addr *dst_addr;
+       const void *dst_addr;

        const struct ip6_rthdr *dp;
        const struct ip6_rthdr0 *dp0;
        const struct ip6_rthdr *dp;
        const struct ip6_rthdr0 *dp0;

-       const struct in6_addr *addr;
+       const struct ip6_srh *srh;
+       const u_char *p;

        int i, len;
 
        cp = (const u_char *)ip6;
        advance = sizeof(struct ip6_hdr);
        int i, len;
 
        cp = (const u_char *)ip6;
        advance = sizeof(struct ip6_hdr);

-       nh = ip6->ip6_nxt;
-       dst_addr = &ip6->ip6_dst;
+       nh = GET_U_1(ip6->ip6_nxt);
+       dst_addr = (const void *)ip6->ip6_dst;

 
        while (cp < ndo->ndo_snapend) {
                cp += advance;
 
        while (cp < ndo->ndo_snapend) {
                cp += advance;


@@ -76,9 +77,9 @@ ip6_finddst(netdissect_options *ndo, struct in6_addr *dst,
                         * the header, in units of 8 octets, excluding
                         * the first 8 octets.
                         */
                         * the header, in units of 8 octets, excluding
                         * the first 8 octets.
                         */

-                       ND_TCHECK2(*cp, 2);
-                       advance = (int)((*(cp + 1) + 1) << 3);
-                       nh = *cp;
+                       ND_TCHECK_2(cp);
+                       advance = (GET_U_1(cp + 1) + 1) << 3;
+                       nh = GET_U_1(cp);

                        break;
 
                case IPPROTO_FRAGMENT:
                        break;
 
                case IPPROTO_FRAGMENT:


@@ -87,9 +88,9 @@ ip6_finddst(netdissect_options *ndo, struct in6_addr *dst,
                         * marked as reserved, and the header is always
                         * the same size.
                         */
                         * marked as reserved, and the header is always
                         * the same size.
                         */

-                       ND_TCHECK2(*cp, 1);
+                       ND_TCHECK_1(cp);

                        advance = sizeof(struct ip6_frag);
                        advance = sizeof(struct ip6_frag);

-                       nh = *cp;
+                       nh = GET_U_1(cp);

                        break;
 
                case IPPROTO_ROUTING:
                        break;
 
                case IPPROTO_ROUTING:


@@ -97,9 +98,9 @@ ip6_finddst(netdissect_options *ndo, struct in6_addr *dst,
                         * OK, we found it.
                         */
                        dp = (const struct ip6_rthdr *)cp;
                         * OK, we found it.
                         */
                        dp = (const struct ip6_rthdr *)cp;

-                       ND_TCHECK(*dp);
-                       len = dp->ip6r_len;
-                       switch (dp->ip6r_type) {
+                       ND_TCHECK_SIZE(dp);
+                       len = GET_U_1(dp->ip6r_len);
+                       switch (GET_U_1(dp->ip6r_type)) {

 
                        case IPV6_RTHDR_TYPE_0:
                        case IPV6_RTHDR_TYPE_2:         /* Mobile IPv6 ID-20 */
 
                        case IPV6_RTHDR_TYPE_0:
                        case IPV6_RTHDR_TYPE_2:         /* Mobile IPv6 ID-20 */


@@ -107,15 +108,26 @@ ip6_finddst(netdissect_options *ndo, struct in6_addr *dst,
                                if (len % 2 == 1)
                                        goto trunc;
                                len >>= 1;
                                if (len % 2 == 1)
                                        goto trunc;
                                len >>= 1;

-                               addr = &dp0->ip6r0_addr[0];
+                               p = (const u_char *) dp0->ip6r0_addr;

                                for (i = 0; i < len; i++) {
                                for (i = 0; i < len; i++) {

-                                       if ((const u_char *)(addr + 1) > ndo->ndo_snapend)
-                                               goto trunc;
-
-                                       dst_addr = addr;
-                                       addr++;
+                                       ND_TCHECK_16(p);
+                                       dst_addr = (const void *)p;
+                                       p += 16;

                                }
                                break;
                                }
                                break;

+                       case IPV6_RTHDR_TYPE_4:
+                               /* IPv6 Segment Routing Header (SRH) */
+                               srh = (const struct ip6_srh *)dp;
+                               if (len % 2 == 1)
+                                       goto trunc;
+                               p = (const u_char *) srh->srh_segments;
+                               /*
+                                * The list of segments are encoded in the reverse order.
+                                * Accordingly, the final DA is encoded in srh_segments[0]
+                                */
+                               ND_TCHECK_16(p);
+                               dst_addr = (const void *)p;
+                               break;

 
                        default:
                                break;
 
                        default:
                                break;


@@ -153,13 +165,13 @@ ip6_finddst(netdissect_options *ndo, struct in6_addr *dst,
 
 done:
 trunc:
 
 done:
 trunc:

-       UNALIGNED_MEMCPY(dst, dst_addr, sizeof(struct in6_addr));
+       UNALIGNED_MEMCPY(dst, dst_addr, sizeof(nd_ipv6));

 }
 
 /*
  * Compute a V6-style checksum by building a pseudoheader.
  */
 }
 
 /*
  * Compute a V6-style checksum by building a pseudoheader.
  */

-int
+uint16_t

 nextproto6_cksum(netdissect_options *ndo,
                  const struct ip6_hdr *ip6, const uint8_t *data,
                 u_int len, u_int covlen, u_int next_proto)
 nextproto6_cksum(netdissect_options *ndo,
                  const struct ip6_hdr *ip6, const uint8_t *data,
                 u_int len, u_int covlen, u_int next_proto)


@@ -172,11 +184,13 @@ nextproto6_cksum(netdissect_options *ndo,
                 uint8_t        ph_nxt;
         } ph;
         struct cksum_vec vec[2];
                 uint8_t        ph_nxt;
         } ph;
         struct cksum_vec vec[2];

+        u_int nh;

 
         /* pseudo-header */
         memset(&ph, 0, sizeof(ph));
 
         /* pseudo-header */
         memset(&ph, 0, sizeof(ph));

-        UNALIGNED_MEMCPY(&ph.ph_src, &ip6->ip6_src, sizeof (struct in6_addr));
-        switch (ip6->ip6_nxt) {
+        UNALIGNED_MEMCPY(&ph.ph_src, ip6->ip6_src, sizeof (struct in6_addr));
+        nh = GET_U_1(ip6->ip6_nxt);
+        switch (nh) {

 
         case IPPROTO_HOPOPTS:
         case IPPROTO_DSTOPTS:
 
         case IPPROTO_HOPOPTS:
         case IPPROTO_DSTOPTS:


@@ -193,7 +207,8 @@ nextproto6_cksum(netdissect_options *ndo,
                 break;
 
         default:
                 break;
 
         default:

-                UNALIGNED_MEMCPY(&ph.ph_dst, &ip6->ip6_dst, sizeof (struct in6_addr));
+                UNALIGNED_MEMCPY(&ph.ph_dst, ip6->ip6_dst,
+                                 sizeof (struct in6_addr));

                 break;
         }
         ph.ph_len = htonl(len);
                 break;
         }
         ph.ph_len = htonl(len);


@@ -213,60 +228,62 @@ nextproto6_cksum(netdissect_options *ndo,
 void
 ip6_print(netdissect_options *ndo, const u_char *bp, u_int length)
 {
 void
 ip6_print(netdissect_options *ndo, const u_char *bp, u_int length)
 {

-       register const struct ip6_hdr *ip6;
-       register int advance;
+       const struct ip6_hdr *ip6;
+       int advance;

        u_int len;
        const u_char *ipend;
        u_int len;
        const u_char *ipend;

-       register const u_char *cp;
-       register u_int payload_len;
-       int nh;
+       const u_char *cp;
+       u_int payload_len;
+       u_int nh;

        int fragmented = 0;
        u_int flow;
 
        int fragmented = 0;
        u_int flow;
 

+       ndo->ndo_protocol = "ip6";

        ip6 = (const struct ip6_hdr *)bp;
 
        ip6 = (const struct ip6_hdr *)bp;
 

-       ND_TCHECK(*ip6);
+       ND_TCHECK_SIZE(ip6);

        if (length < sizeof (struct ip6_hdr)) {
        if (length < sizeof (struct ip6_hdr)) {

-               ND_PRINT((ndo, "truncated-ip6 %u", length));
+               ND_PRINT("truncated-ip6 %u", length);

                return;
        }
 
         if (!ndo->ndo_eflag)
                return;
        }
 
         if (!ndo->ndo_eflag)

-            ND_PRINT((ndo, "IP6 "));
+            ND_PRINT("IP6 ");

 
        if (IP6_VERSION(ip6) != 6) {
 
        if (IP6_VERSION(ip6) != 6) {

-          ND_PRINT((ndo,"version error: %u != 6", IP6_VERSION(ip6)));
+          ND_PRINT("version error: %u != 6", IP6_VERSION(ip6));

           return;
        }
 
           return;
        }
 

-       payload_len = EXTRACT_16BITS(&ip6->ip6_plen);
+       payload_len = GET_BE_U_2(ip6->ip6_plen);

        len = payload_len + sizeof(struct ip6_hdr);
        if (length < len)
        len = payload_len + sizeof(struct ip6_hdr);
        if (length < len)

-               ND_PRINT((ndo, "truncated-ip6 - %u bytes missing!",
-                       len - length));
+               ND_PRINT("truncated-ip6 - %u bytes missing!",
+                       len - length);

 
 

+        nh = GET_U_1(ip6->ip6_nxt);

         if (ndo->ndo_vflag) {
         if (ndo->ndo_vflag) {

-            flow = EXTRACT_32BITS(&ip6->ip6_flow);
-            ND_PRINT((ndo, "("));
+            flow = GET_BE_U_4(ip6->ip6_flow);
+            ND_PRINT("(");

 #if 0
             /* rfc1883 */
             if (flow & 0x0f000000)
 #if 0
             /* rfc1883 */
             if (flow & 0x0f000000)

-               ND_PRINT((ndo, "pri 0x%02x, ", (flow & 0x0f000000) >> 24));
+               ND_PRINT("pri 0x%02x, ", (flow & 0x0f000000) >> 24);

             if (flow & 0x00ffffff)
             if (flow & 0x00ffffff)

-               ND_PRINT((ndo, "flowlabel 0x%06x, ", flow & 0x00ffffff));
+               ND_PRINT("flowlabel 0x%06x, ", flow & 0x00ffffff);

 #else
             /* RFC 2460 */
             if (flow & 0x0ff00000)
 #else
             /* RFC 2460 */
             if (flow & 0x0ff00000)

-               ND_PRINT((ndo, "class 0x%02x, ", (flow & 0x0ff00000) >> 20));
+               ND_PRINT("class 0x%02x, ", (flow & 0x0ff00000) >> 20);

             if (flow & 0x000fffff)
             if (flow & 0x000fffff)

-               ND_PRINT((ndo, "flowlabel 0x%05x, ", flow & 0x000fffff));
+               ND_PRINT("flowlabel 0x%05x, ", flow & 0x000fffff);

 #endif
 
 #endif
 

-            ND_PRINT((ndo, "hlim %u, next-header %s (%u) payload length: %u) ",
-                         ip6->ip6_hlim,
-                         tok2str(ipproto_values,"unknown",ip6->ip6_nxt),
-                         ip6->ip6_nxt,
-                         payload_len));
+            ND_PRINT("hlim %u, next-header %s (%u) payload length: %u) ",
+                         GET_U_1(ip6->ip6_hlim),
+                         tok2str(ipproto_values,"unknown",nh),
+                         nh,
+                         payload_len);

         }
 
        /*
         }
 
        /*


@@ -278,32 +295,41 @@ ip6_print(netdissect_options *ndo, const u_char *bp, u_int length)
 
        cp = (const u_char *)ip6;
        advance = sizeof(struct ip6_hdr);
 
        cp = (const u_char *)ip6;
        advance = sizeof(struct ip6_hdr);

-       nh = ip6->ip6_nxt;
+       /* Process extension headers */

        while (cp < ndo->ndo_snapend && advance > 0) {
        while (cp < ndo->ndo_snapend && advance > 0) {

+               if (len < (u_int)advance)
+                       goto trunc;

                cp += advance;
                len -= advance;
 
                if (cp == (const u_char *)(ip6 + 1) &&
                    nh != IPPROTO_TCP && nh != IPPROTO_UDP &&
                    nh != IPPROTO_DCCP && nh != IPPROTO_SCTP) {
                cp += advance;
                len -= advance;
 
                if (cp == (const u_char *)(ip6 + 1) &&
                    nh != IPPROTO_TCP && nh != IPPROTO_UDP &&
                    nh != IPPROTO_DCCP && nh != IPPROTO_SCTP) {

-                       ND_PRINT((ndo, "%s > %s: ", ip6addr_string(ndo, &ip6->ip6_src),
-                                    ip6addr_string(ndo, &ip6->ip6_dst)));
+                       ND_PRINT("%s > %s: ", ip6addr_string(ndo, ip6->ip6_src),
+                                    ip6addr_string(ndo, ip6->ip6_dst));

                }
 
                switch (nh) {
                }
 
                switch (nh) {

+

                case IPPROTO_HOPOPTS:
                        advance = hbhopt_print(ndo, cp);
                case IPPROTO_HOPOPTS:
                        advance = hbhopt_print(ndo, cp);

-                       nh = *cp;
+                       if (advance < 0)
+                               return;
+                       nh = GET_U_1(cp);

                        break;
                        break;

+

                case IPPROTO_DSTOPTS:
                        advance = dstopt_print(ndo, cp);
                case IPPROTO_DSTOPTS:
                        advance = dstopt_print(ndo, cp);

-                       nh = *cp;
+                       if (advance < 0)
+                               return;
+                       nh = GET_U_1(cp);

                        break;
                        break;

+

                case IPPROTO_FRAGMENT:
                        advance = frag6_print(ndo, cp, (const u_char *)ip6);
                case IPPROTO_FRAGMENT:
                        advance = frag6_print(ndo, cp, (const u_char *)ip6);

-                       if (ndo->ndo_snapend <= cp + advance)
+                       if (advance < 0 || ndo->ndo_snapend <= cp + advance)

                                return;
                                return;

-                       nh = *cp;
+                       nh = GET_U_1(cp);

                        fragmented = 1;
                        break;
 
                        fragmented = 1;
                        break;
 


@@ -318,91 +344,34 @@ ip6_print(netdissect_options *ndo, const u_char *bp, u_int length)
                         * mobility header.
                         */
                        advance = mobility_print(ndo, cp, (const u_char *)ip6);
                         * mobility header.
                         */
                        advance = mobility_print(ndo, cp, (const u_char *)ip6);

-                       nh = *cp;
+                       if (advance < 0)
+                               return;
+                       nh = GET_U_1(cp);

                        return;
                        return;

+

                case IPPROTO_ROUTING:
                case IPPROTO_ROUTING:

+                       ND_TCHECK_1(cp);

                        advance = rt6_print(ndo, cp, (const u_char *)ip6);
                        advance = rt6_print(ndo, cp, (const u_char *)ip6);

-                       nh = *cp;
-                       break;
-               case IPPROTO_SCTP:
-                       sctp_print(ndo, cp, (const u_char *)ip6, len);
-                       return;
-               case IPPROTO_DCCP:
-                       dccp_print(ndo, cp, (const u_char *)ip6, len);
-                       return;
-               case IPPROTO_TCP:
-                       tcp_print(ndo, cp, len, (const u_char *)ip6, fragmented);
-                       return;
-               case IPPROTO_UDP:
-                       udp_print(ndo, cp, len, (const u_char *)ip6, fragmented);
-                       return;
-               case IPPROTO_ICMPV6:
-                       icmp6_print(ndo, cp, len, (const u_char *)ip6, fragmented);
-                       return;
-               case IPPROTO_AH:
-                       advance = ah_print(ndo, cp);
-                       nh = *cp;
-                       break;
-               case IPPROTO_ESP:
-                   {
-                       int enh, padlen;
-                       advance = esp_print(ndo, cp, len, (const u_char *)ip6, &enh, &padlen);
-                       nh = enh & 0xff;
-                       len -= padlen;
-                       break;
-                   }
-               case IPPROTO_IPCOMP:
-                   {
-                       ipcomp_print(ndo, cp);
-                       /*
-                        * Either this has decompressed the payload and
-                        * printed it, in which case there's nothing more
-                        * to do, or it hasn't, in which case there's
-                        * nothing more to do.
-                        */
-                       advance = -1;
+                       if (advance < 0)
+                               return;
+                       nh = GET_U_1(cp);

                        break;
                        break;

-                   }
-
-               case IPPROTO_PIM:
-                       pim_print(ndo, cp, len, (const u_char *)ip6);
-                       return;
-
-               case IPPROTO_OSPF:
-                       ospf6_print(ndo, cp, len);
-                       return;
-
-               case IPPROTO_IPV6:
-                       ip6_print(ndo, cp, len);
-                       return;
-
-               case IPPROTO_IPV4:
-                       ip_print(ndo, cp, len);
-                       return;
-
-                case IPPROTO_PGM:
-                        pgm_print(ndo, cp, len, (const u_char *)ip6);
-                        return;
-
-               case IPPROTO_GRE:
-                       gre_print(ndo, cp, len);
-                       return;
-
-               case IPPROTO_RSVP:
-                       rsvp_print(ndo, cp, len);
-                       return;
-
-               case IPPROTO_NONE:
-                       ND_PRINT((ndo, "no next header"));
-                       return;

 
                default:
 
                default:

-                       ND_PRINT((ndo, "ip-proto-%d %d", nh, len));
+                       /*
+                        * Not an extension header; hand off to the
+                        * IP protocol demuxer.
+                        */
+                       ip_print_demux(ndo, cp, len, 6, fragmented,
+                           GET_U_1(ip6->ip6_hlim), nh, bp);

                        return;
                }
                        return;
                }

+
+               /* ndo_protocol reassignment after xxx_print() calls */
+               ndo->ndo_protocol = "ip6";

        }
 
        return;
 trunc:
        }
 
        return;
 trunc:

-       ND_PRINT((ndo, "[|ip6]"));
+       nd_print_trunc(ndo);

 }
 }