Changeset 7428ab2 for lib

Timestamp:

06/22/15 17:44:39 (6 years ago)

Author:

Shane Alcock <salcock@…>

Branches:

4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, libtrace4, master, ndag_format, pfring, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes

Children:

84d137d, d280f48

Parents:

8b12caf

Message:

Add trace_strip_packet to libtrace API

This function will allow callers to strip MPLS and VLAN headers from
libtrace packets. Some analysis tools (especially those written with
libpcap in the days before these technologies were popular) don't
work so well when these headers are present.

Stripping VLAN headers also makes BPF filtering easier.

Location:

lib

Files:

• libtrace.h.in (modified) (1 diff)
• protocols_l2.c (modified) (2 diffs)

lib/libtrace.h.in

@@ -1603 +1603 @@
 void *trace_get_link(const libtrace_packet_t *packet);
 
+/**
+ * Supported masks for stripping headers from packets.
+ */ 
+enum {
+        TRACE_STRIP_VLAN = 0x01, /**< Strip 802.1Q (VLAN tag) headers */
+        TRACE_STRIP_MPLS = 0x02  /**< Strip MPLS headers */
+};
+
+/** Strips certain headers from a given packet.
+ * @param packet        The packet to strip headers from.
+ * @param stripopts     A mask to indicate which headers should be stripped.
+ * If multiple header types are to be stripped, these should be ORed together
+ * to create the full mask. A mask of zero will strip all strippable headers.
+ *
+ * @return The packet with the requested headers removed (if they were
+ * present).
+ *
+ * This function is intended for removing those pesky layer 2.5 headers
+ * that are not supported by other packet analysis applications, e.g. VLAN
+ * and MPLS headers. If successful, the resulting packet will be a simple
+ * Ethernet-IP-Transport packet that just about anything should be able to
+ * parse without difficulty.
+ *
+ * If this function encounters a layer 2 or 2.5 header that it does not
+ * support, stripping will cease and the packet returning will be stripped
+ * up to but not including the unsupported header.
+ *
+ * New in libtrace 4.0.0
+ *
+ * @note This function only supports stripping headers from Ethernet packets
+ * for now. Passing in packets of other link types will simply result in
+ * the original packet being returned unmodified.
+ *
+ * @note Depending on the input source, this function may need to copy the
+ * original packet to be able to safely modify the contents. This may have
+ * a major impact on performance so avoid stripping packets unless absolutely
+ * necessary.
+ */
+DLLEXPORT libtrace_packet_t *trace_strip_packet(libtrace_packet_t *packet,
+                int stripopts);
+
 /** Get a pointer to the IPv4 header (if any) for a given packet
  * @param packet        The packet to get the IPv4 header for

lib/protocols_l2.c

@@ -37 +37 @@
 #include <assert.h>
 #include <stdlib.h>
+#include <string.h>
 
 
@@ -97 +98 @@
 
         return (void*)((char *)ethernet + sizeof(*vlanhdr));
+
+}
+
+libtrace_packet_t *trace_strip_packet(libtrace_packet_t *packet, 
+                int stripopts) {
+
+        libtrace_ether_t *ethernet;
+        libtrace_linktype_t linktype;
+        uint16_t ethertype;
+        uint32_t remaining;
+        libtrace_packet_t *copy;
+        void *payload;
+        uint16_t finalethertype = 0;
+        uint16_t caplen, removed = 0;
+        char *dest;
+        uint8_t done = 0;
+        uint32_t oldrem;
+
+        /* For now, this will just work for Ethernet packets. */
+        ethernet = (libtrace_ether_t *)trace_get_layer2(packet, 
+                        &linktype, &remaining);
+
+        if (linktype != TRACE_TYPE_ETH) {
+                return packet;
+        }
+
+        /* No headers to strip, return the original packet */
+        if (ethernet->ether_type == TRACE_ETHERTYPE_IP ||
+                        ethernet->ether_type == TRACE_ETHERTYPE_IPV6) {
+                return packet;
+        }
+
+        /* Copy the packet as we need to be sure that the packet
+         * payload is contiguous. This won't be guaranteed for live
+         * formats, for instance.
+         */
+        if (packet->buf_control == TRACE_CTRL_EXTERNAL) {
+                copy = trace_copy_packet(packet);
+                trace_destroy_packet(packet);
+                packet = copy;
+
+                /* Re-grab the ethernet header from the copy */
+                ethernet = (libtrace_ether_t *)trace_get_layer2(packet,
+                        &linktype, &remaining);
+
+        }
+
+        payload = trace_get_payload_from_layer2(ethernet, linktype,
+                        &ethertype, &remaining);
+
+        dest = ((char *)ethernet) + sizeof(libtrace_ether_t);
+        caplen = trace_get_capture_length(packet);
+        while (!done) {
+
+                if (payload == NULL || remaining == 0)
+                        break;
+
+                oldrem = remaining;
+                switch (ethertype) {
+
+                case TRACE_ETHERTYPE_8021Q:
+                        payload = (void *)trace_get_payload_from_vlan(payload,
+                                        &ethertype, &remaining);
+                        if (stripopts == 0 || (stripopts & TRACE_STRIP_VLAN))
+                        {
+                                removed += (oldrem - remaining);
+                                memmove(dest, payload, remaining);
+                                payload = dest;
+
+                        } else {
+                                if (finalethertype == 0) {
+                                        finalethertype = TRACE_ETHERTYPE_8021Q;
+                                }
+                                dest = payload;
+                        }
+                        break;
+
+                case TRACE_ETHERTYPE_MPLS:
+                        payload = (void *)trace_get_payload_from_mpls(payload,
+                                        &ethertype, &remaining);
+                        if (stripopts == 0 || (stripopts & TRACE_STRIP_MPLS))
+                        {
+                                removed += (oldrem - remaining);
+                                memmove(dest, payload, remaining);
+                                payload = dest;
+
+                        } else {
+                                if (finalethertype == 0) {
+                                        finalethertype = TRACE_ETHERTYPE_MPLS;
+                                }
+                                dest = payload;
+                        }
+                        break;
+
+                case TRACE_ETHERTYPE_IP:
+                case TRACE_ETHERTYPE_IPV6:
+                default:
+                        if (finalethertype == 0)
+                                finalethertype = ethertype;
+                        done = true;
+                        break;
+                }
+        }
+
+        /* Update the preceding headers to match the new packet contents */
+        ethernet->ether_type = ntohs(finalethertype);
+        trace_set_capture_length(packet, caplen - removed);
+        return packet;
 
 }