Changeset c909fad for lib

Timestamp:

03/06/13 13:28:51 (8 years ago)

Author:

Shane Alcock <salcock@…>

Branches:

4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, getfragoff, help, 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:

68b7f29

Parents:

af27241

Message:

• Added checksumming functions for both the IP and transport layer. The functions will calculate the correct checksum for that packet and also return a pointer to the checksum field in the appropriate header so that the caller can either evaluate whether the checksum is correct, replace the existing checksum, or do whatever they want.
• Also managed to fix a bunch of broken Revision svn tags

Location:

lib

Files:

• Makefile.am (modified) (1 diff)
• checksum.c (added)
• checksum.h (added)
• format_bpf.c (modified) (2 diffs)
• format_dag24.c (modified) (1 diff)
• format_dag25.c (modified) (1 diff)
• format_erf.c (modified) (1 diff)
• format_legacy.c (modified) (4 diffs)
• format_linux.c (modified) (3 diffs)
• format_pcap.c (modified) (2 diffs)
• format_pcapfile.c (modified) (1 diff)
• format_tsh.c (modified) (1 diff)
• libtrace.h.in (modified) (1 diff)
• protocols_l3.c (modified) (2 diffs)
• protocols_transport.c (modified) (2 diffs)

lib/Makefile.am

@@ -34 +34 @@
                 libtrace_int.h lt_inttypes.h \
                 linktypes.c link_wireless.c \
+                checksum.c checksum.h \
                 protocols_pktmeta.c protocols_l2.c protocols_l3.c \
                 protocols_transport.c protocols.h protocols_ospf.c \

lib/format_bpf.c

@@ -516 +516 @@
 /* Prints some slightly useful help text for the BPF capture format */
 static void bpf_help() {
-        printf("bpf format module: $Revision$\n");
+        printf("bpf format module: $Revision: 1782 $\n");
         printf("Supported input URIs:\n");
         printf("\tbpf:\n");
@@ -567 +567 @@
 /* Prints some slightly useful help text for the BPF capture format */
 static void bpf_help() {
-        printf("bpf format module: $Revision$\n");
+        printf("bpf format module: $Revision: 1782 $\n");
         printf("Not supported on this host\n");
         return;

lib/format_dag24.c

@@ -506 +506 @@
 /* Prints some semi-useful help text about the DAG format module */
 static void dag_help(void) {
-        printf("dag format module: $Revision$\n");
+        printf("dag format module: $Revision: 1715 $\n");
         printf("Supported input URIs:\n");
         printf("\tdag:/dev/dagn\n");

lib/format_dag25.c

@@ -1159 +1159 @@
 /* Prints some semi-useful help text about the DAG format module */
 static void dag_help(void) {
-        printf("dag format module: $Revision$\n");
+        printf("dag format module: $Revision: 1755 $\n");
         printf("Supported input URIs:\n");
         printf("\tdag:/dev/dagn\n");

lib/format_erf.c

@@ -748 +748 @@
 
 static void erf_help(void) {
-        printf("erf format module: $Revision$\n");
+        printf("erf format module: $Revision: 1752 $\n");
         printf("Supported input URIs:\n");
         printf("\terf:/path/to/file\t(uncompressed)\n");

lib/format_legacy.c

@@ -467 +467 @@
 
 static void legacypos_help(void) {
-        printf("legacypos format module: $Revision$\n");
+        printf("legacypos format module: $Revision: 1753 $\n");
         printf("Supported input URIs:\n");
         printf("\tlegacypos:/path/to/file\t(uncompressed)\n");
@@ -478 +478 @@
 
 static void legacyatm_help(void) {
-        printf("legacyatm format module: $Revision$\n");
+        printf("legacyatm format module: $Revision: 1753 $\n");
         printf("Supported input URIs:\n");
         printf("\tlegacyatm:/path/to/file\t(uncompressed)\n");
@@ -489 +489 @@
 
 static void legacyeth_help(void) {
-        printf("legacyeth format module: $Revision$\n");
+        printf("legacyeth format module: $Revision: 1753 $\n");
         printf("Supported input URIs:\n");
         printf("\tlegacyeth:/path/to/file\t(uncompressed)\n");
@@ -500 +500 @@
 
 static void legacynzix_help(void) {
-        printf("legacynzix format module: $Revision$\n");
+        printf("legacynzix format module: $Revision: 1753 $\n");
         printf("Supported input URIs:\n");
         printf("\tlegacynzix:/path/to/file\t(uncompressed)\n");

lib/format_linux.c

@@ -1482 +1482 @@
 #ifdef HAVE_NETPACKET_PACKET_H
 static void linuxnative_help(void) {
-        printf("linuxnative format module: $Revision$\n");
+        printf("linuxnative format module: $Revision: 1793 $\n");
         printf("Supported input URIs:\n");
         printf("\tint:eth0\n");
@@ -1493 +1493 @@
 
 static void linuxring_help(void) {
-        printf("linuxring format module: $Revision$\n");
+        printf("linuxring format module: $Revision: 1793 $\n");
         printf("Supported input URIs:\n");
         printf("\tring:eth0\n");
@@ -1590 +1590 @@
 #else
 static void linuxnative_help(void) {
-        printf("linuxnative format module: $Revision$\n");
+        printf("linuxnative format module: $Revision: 1793 $\n");
         printf("Not supported on this host\n");
 }
 static void linuxring_help(void) {
-        printf("linuxring format module: $Revision$\n");
+        printf("linuxring format module: $Revision: 1793 $\n");
         printf("Not supported on this host\n");
 }

lib/format_pcap.c

@@ -737 +737 @@
 
 static void pcap_help(void) {
-        printf("pcap format module: $Revision$\n");
+        printf("pcap format module: $Revision: 1729 $\n");
         printf("Supported input URIs:\n");
         printf("\tpcap:/path/to/file\n");
@@ -749 +749 @@
 
 static void pcapint_help(void) {
-        printf("pcapint format module: $Revision$\n");
+        printf("pcapint format module: $Revision: 1729 $\n");
         printf("Supported input URIs:\n");
         printf("\tpcapint:interface\n");

lib/format_pcapfile.c

@@ -683 +683 @@
 
 static void pcapfile_help(void) {
-        printf("pcapfile format module: $Revision$\n");
+        printf("pcapfile format module: $Revision: 1768 $\n");
         printf("Supported input URIs:\n");
         printf("\tpcapfile:/path/to/file\n");

lib/format_tsh.c

@@ -218 +218 @@
 
 static void tsh_help(void) {
-        printf("tsh format module: $Revision$\n");
+        printf("tsh format module: $Revision: 1611 $\n");
         printf("Supported input URIs:\n");
         printf("\ttsh:/path/to/file\t(uncompressed)\n");

lib/libtrace.h.in

@@ -1673 +1673 @@
                 uint16_t *ethertype, uint32_t *remaining);
 
+/** Calculates the expected IP checksum for a packet.
+ * @param packet        The libtrace packet to calculate the checksum for
+ * @param[out] csum     The checksum that is calculated by this function. This
+ *                      may not be NULL.
+ * 
+ * @return A pointer to the original checksum field within the IP
+ * header. If the checksum field is not present in the packet, NULL is returned.
+ *
+ * @note The return value points to the checksum that exists within the current
+ * packet. The value in csum is the value that the checksum should be, given
+ * the current packet contents.  
+ *
+ * @note This function involves the use of a memcpy, so be careful about
+ * calling it excessively if performance is a concern for you.
+ * 
+ * New in libtrace 3.0.17
+ */
+DLLEXPORT uint16_t *trace_checksum_layer3(libtrace_packet_t *packet, 
+                uint16_t *csum);
+
+/** Calculates the expected checksum for the transport header in a packet.
+ * @param packet        The libtrace packet to calculate the checksum for
+ * @param[out] csum     The checksum that is calculated by this function. This
+ *                      may not be NULL.
+ * 
+ * @return A pointer to the original checksum field within the transport 
+ * header. If the checksum field is not present in the packet, NULL is returned.
+ *
+ * @note The return value points to the checksum that exists within the current
+ * packet. The value in csum is the value that the checksum should be, given
+ * the current packet contents.  
+ *
+ * @note This function involves the use of a memcpy, so be careful about
+ * calling it excessively if performance is a concern for you.
+ * 
+ * @note Because transport checksums are calculated across the entire payload,
+ * truncated packets will result in NULL being returned.
+ *
+ * This function will determine the appropriate checksum for whatever transport
+ * layer header is present in the provided packet. At this stage, this only
+ * currently works for TCP, UDP and ICMP packets.
+ *
+ * Be wary of TCP checksum offloading if you are examining the checksum of
+ * packets captured on the same host that generated them!
+ *
+ * New in libtrace 3.0.17
+ */
+DLLEXPORT uint16_t *trace_checksum_transport(libtrace_packet_t *packet,
+                uint16_t *csum);
+
 /** Gets a pointer to the transport layer header (if any)
  * @param packet   The libtrace packet to find the transport header for

lib/protocols_l3.c

@@ -36 +36 @@
 #include "libtrace.h"
 #include "protocols.h"
+#include "checksum.h"
 #include <assert.h>
 #include <stdlib.h>
@@ -676 +677 @@
 }
 
+DLLEXPORT uint16_t *trace_checksum_layer3(libtrace_packet_t *packet, 
+                uint16_t *csum) {
+
+        void *l3;
+        uint16_t ethertype;
+        uint32_t remaining;
+        uint16_t *csum_ptr;
+
+        uint8_t safety[65536];
+
+        if (csum == NULL)
+                return NULL;
+        
+        l3 = trace_get_layer3(packet, &ethertype, &remaining);
+                
+        if (l3 == NULL)
+                return NULL;
+        
+        if (ethertype == TRACE_ETHERTYPE_IP) {
+                libtrace_ip_t *ip = (libtrace_ip_t *)l3;
+                if (remaining < sizeof(libtrace_ip_t))
+                        return NULL;
+
+                csum_ptr = &ip->ip_sum;
+
+                /* I hate memcpys, but this is the only truly safe way to
+                 * do this without modifying the packet. I'm trying to be
+                 * careful about not creating any more thread-safety issues
+                 * than there already are :) */
+                memcpy(safety, ip, ip->ip_hl * sizeof(uint32_t));
+                
+                /* Set the checksum to zero, so we can do the calculation */
+                ip = (libtrace_ip_t *)safety;
+                ip->ip_sum = 0;
+
+                *csum = checksum_buffer(safety, ip->ip_hl * sizeof(uint32_t));
+                
+                /* Remember to byteswap appropriately */
+                *csum = ntohs(*csum);
+                
+                return csum_ptr;
+        }
+
+        return NULL;
+}
+

lib/protocols_transport.c

@@ -35 +35 @@
 #include "libtrace.h"
 #include "protocols.h"
+#include "checksum.h"
 #include <assert.h>
 #include <stdlib.h>
 #include <stdio.h> // fprintf
+#include <string.h>
 
 /* This file contains all the protocol decoding functions for transport layer
@@ -419 +421 @@
 }
 
-
+DLLEXPORT uint16_t *trace_checksum_transport(libtrace_packet_t *packet, 
+                uint16_t *csum) {
+
+        void *header = NULL;
+        uint16_t ethertype;
+        uint32_t remaining;
+        uint32_t sum = 0;
+        uint8_t proto = 0;
+        uint16_t *csum_ptr = NULL;
+        int plen = 0;
+
+        uint8_t safety[65536];
+        uint8_t *ptr = safety;
+
+        header = trace_get_layer3(packet, &ethertype, &remaining);
+
+        if (header == NULL)
+                return NULL;
+        
+        if (ethertype == TRACE_ETHERTYPE_IP) {
+                libtrace_ip_t *ip = (libtrace_ip_t *)header;
+
+                if (remaining < sizeof(libtrace_ip_t))
+                        return NULL;
+
+                sum = ipv4_pseudo_checksum(ip);
+
+        } else if (ethertype == TRACE_ETHERTYPE_IPV6) {
+                libtrace_ip6_t *ip = (libtrace_ip6_t *)header;
+                
+                if (remaining < sizeof(libtrace_ip6_t))
+                        return 0;
+
+                sum = ipv6_pseudo_checksum(ip);
+        
+        }
+
+        header = trace_get_transport(packet, &proto, &remaining);
+
+        if (proto == TRACE_IPPROTO_TCP) {
+                libtrace_tcp_t *tcp = (libtrace_tcp_t *)header;
+                header = trace_get_payload_from_tcp(tcp, &remaining);
+                
+                csum_ptr = &tcp->check;
+
+                memcpy(ptr, tcp, tcp->doff * 4);
+
+                tcp = (libtrace_tcp_t *)ptr;
+                tcp->check = 0;
+
+                ptr += (tcp->doff * 4);
+        } 
+        
+        else if (proto == TRACE_IPPROTO_UDP) {
+
+                libtrace_udp_t *udp = (libtrace_udp_t *)header;
+                header = trace_get_payload_from_udp(udp, &remaining);
+                
+                csum_ptr = &udp->check;
+                memcpy(ptr, udp, sizeof(libtrace_udp_t));
+
+                udp = (libtrace_udp_t *)ptr;
+                udp->check = 0;
+
+                ptr += sizeof(libtrace_udp_t);
+        } 
+        
+        else if (proto == TRACE_IPPROTO_ICMP) {
+                /* ICMP doesn't use the pseudo header */
+                sum = 0;
+
+                libtrace_icmp_t *icmp = (libtrace_icmp_t *)header;
+                header = trace_get_payload_from_icmp(icmp, &remaining);
+                
+                csum_ptr = &icmp->checksum;
+                memcpy(ptr, icmp, sizeof(libtrace_icmp_t));
+
+                icmp = (libtrace_icmp_t *)ptr;
+                icmp->checksum = 0;
+                
+                ptr += sizeof(libtrace_icmp_t);
+
+        } 
+        else {
+                return NULL;
+        }
+
+        sum += add_checksum(safety, (uint16_t)(ptr - safety));
+
+        plen = trace_get_payload_length(packet);
+        if (plen < 0)
+                return NULL;
+
+        if (remaining < (uint32_t)plen)
+                return NULL;
+
+        if (header == NULL)
+                return NULL;
+
+        sum += add_checksum(header, (uint16_t)plen);
+        *csum = ntohs(finish_checksum(sum));
+        //assert(0);
+        
+        return csum_ptr;
+}