Changeset 9a6bdbc for lib

Timestamp:

01/07/19 10:35:07 (22 months ago)

Author:

Jacob Van Walraven <jcv9@…>

Branches:

develop

Children:

51276bd

Parents:

979ab1a0

git-author:

Jacob Van Walraven <jcv9@…> (12/14/18 09:31:48)

git-committer:

Jacob Van Walraven <jcv9@…> (01/07/19 10:35:07)

Message:

Added can_write functions to each output format, Fixed pcapng_get_header_type incorrectly flipping type bytes

Location:

lib

Files:

• format_dag25.c (modified) (3 diffs)
• format_dpdk.c (modified) (2 diffs)
• format_erf.c (modified) (3 diffs)
• format_linux_int.c (modified) (2 diffs)
• format_linux_ring.c (modified) (3 diffs)
• format_pcap.c (modified) (3 diffs)
• format_pcapfile.c (modified) (5 diffs)
• format_pcapng.c (modified) (12 diffs)
• trace.c (modified) (1 diff)

lib/format_dag25.c

@@ -174 +174 @@
  * many times or close a device that we're still using */
 struct dag_dev_t *open_dags = NULL;
+
+static bool dag_can_write(libtrace_packet_t *packet) {
+        /* Get the linktype */
+        libtrace_linktype_t ltype = trace_get_link_type(packet);
+
+        if (ltype == TRACE_TYPE_ERF_META
+                || ltype == TRACE_TYPE_NONDATA) {
+
+                return false;
+        }
+
+        return true;
+}
 
 /* Returns the amount of padding between the ERF header and the start of the
@@ -1186 +1199 @@
 static int dag_write_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet)
 {
+        /* Check dag can write this type of packet */
+        if (!dag_can_write(packet)) {
+                return 0;
+        }
+
         /* This is heavily borrowed from erf_write_packet(). Yes, CnP
          * coding sucks, sorry about that.
@@ -1200 +1218 @@
                 return -1;
         }
-
-        if (trace_get_link_type(packet) == TRACE_TYPE_NONDATA)
-                return 0;
 
         pad = dag_get_padding(packet);

lib/format_dpdk.c

@@ -144 +144 @@
         uint32_t cap_len; /* The size to say the capture is */
 };
+
+static bool dpdk_can_write(libtrace_packet_t *packet) {
+        return true;
+}
 
 /**
@@ -1557 +1561 @@
 static int dpdk_write_packet(libtrace_out_t *trace,
                              libtrace_packet_t *packet){
+
+        /* Check dpdk can write this type of packet */
+        if (!dpdk_can_write(packet)) {
+                return 0;
+        }
+
         struct rte_mbuf* m_buff[1];
 

lib/format_erf.c

@@ -119 +119 @@
 } erf_index_t;
 
+static bool erf_can_write(libtrace_packet_t *packet) {
+        /* Get the linktype */
+        libtrace_linktype_t ltype = trace_get_link_type(packet);
+
+        if (ltype == TRACE_TYPE_PCAPNG_META
+                || ltype == TRACE_TYPE_NONDATA) {
+
+                return false;
+        }
+
+        return true;
+}
+
 /* Ethernet packets have a 2 byte padding before the packet
  * so that the IP header is aligned on a 32 bit boundary.
@@ -670 +683 @@
                 libtrace_packet_t *packet) 
 {
+
+        /* Check erf can write this type of packet */
+        if (!erf_can_write(packet)) {
+                return 0;
+        }
+
         int numbytes = 0;
         dag_record_t *dag_hdr = (dag_record_t *)packet->header;
@@ -679 +698 @@
                 return -1;
         }
-
-        if (trace_get_link_type(packet) == TRACE_TYPE_NONDATA)
-                return 0;
 
         if (!packet->header) {

lib/format_linux_int.c

@@ -56 +56 @@
 #ifdef HAVE_NETPACKET_PACKET_H
 
+static bool linuxnative_can_write(libtrace_packet_t *packet) {
+        /* Get the linktype */
+        libtrace_linktype_t ltype = trace_get_link_type(packet);
+
+        if (ltype == TRACE_TYPE_NONDATA) {
+                return false;
+        }
+
+        return true;
+}
 
 static int linuxnative_start_input(libtrace_t *libtrace)
@@ -336 +346 @@
                 libtrace_packet_t *packet) 
 {
+        /* Check linuxnative can write this type of packet */
+        if (!linuxnative_can_write(packet)) {
+                return 0;
+        }
+
         struct sockaddr_ll hdr;
         int ret = 0;
-
-        if (trace_get_link_type(packet) == TRACE_TYPE_NONDATA)
-                return 0;
 
         hdr.sll_family = AF_PACKET;

lib/format_linux_ring.c

@@ -71 +71 @@
 static int pagesize = 0;
 
+static bool linuxring_can_write(libtrace_packet_t *packet) {
+        /* Get the linktype */
+        libtrace_linktype_t ltype = trace_get_link_type(packet);
+
+        if (ltype == TRACE_TYPE_NONDATA) {
+                return false;
+        }
+
+        return true;
+}
 
 /*
@@ -709 +719 @@
                                   libtrace_packet_t *packet)
 {
+        /* Check linuxring can write this type of packet */
+        if (!linuxring_can_write(packet)) {
+                return 0;
+        }
+
         struct tpacket2_hdr *header;
         struct pollfd pollset;
@@ -715 +730 @@
         unsigned max_size;
         void * off;
-
-        if (trace_get_link_type(packet) == TRACE_TYPE_NONDATA)
-                return 0;
 
         max_size = FORMAT_DATA_OUT->req.tp_frame_size -

lib/format_pcap.c

@@ -97 +97 @@
         } output;
 };
+
+static bool pcap_can_write(libtrace_packet_t *packet) {
+        /* Get the linktype */
+        libtrace_linktype_t ltype = trace_get_link_type(packet);
+
+        if (ltype == TRACE_TYPE_PCAPNG_META
+                || ltype == TRACE_TYPE_CONTENT_INVALID
+                || ltype == TRACE_TYPE_UNKNOWN
+                || ltype == TRACE_TYPE_ERF_META
+                || ltype == TRACE_TYPE_NONDATA) {
+
+                return false;
+        }
+
+        return true;
+}
 
 static int pcap_init_input(libtrace_t *libtrace) {
@@ -521 +537 @@
 {
 
+        /* Check pcap can write this type of packet */
+        if (!pcap_can_write(packet)) {
+                return 0;
+        }
+
         if (!libtrace) {
                 fprintf(stderr, "NULL trace passed into pcap_write_packet()\n");
@@ -536 +557 @@
 
         link = trace_get_packet_buffer(packet,&linktype,&remaining);
-
-        /* Silently discard RT metadata packets and packets with an
-         * unknown linktype. */
-        if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN || linktype == TRACE_TYPE_ERF_META || linktype == TRACE_TYPE_CONTENT_INVALID) {
-                return 0;
-        }
 
         /* We may have to convert this packet into a suitable PCAP packet */

lib/format_pcapfile.c

@@ -68 +68 @@
 #define MAGIC2_REV  0x4d3cb2a1
 
+static bool pcapfile_can_write(libtrace_packet_t *packet) {
+        /* Get the linktype */
+        libtrace_linktype_t ltype = trace_get_link_type(packet);
+
+        if (ltype == TRACE_TYPE_PCAPNG_META
+                || ltype == TRACE_TYPE_CONTENT_INVALID
+                || ltype == TRACE_TYPE_UNKNOWN
+                || ltype == TRACE_TYPE_ERF_META
+                || ltype == TRACE_TYPE_NONDATA) {
+
+                return false;
+        }
+
+        return true;
+}
+
 static inline int header_is_backwards_magic(pcapfile_header_t *header) {
         return (header->magic_number == MAGIC1_REV || header->magic_number == MAGIC2_REV);
@@ -175 +191 @@
         if (!DATA(libtrace))
                 return num;
-        
+
         /* We can use the PCAP magic number to determine the byte order */
         if (header_is_backwards_magic(&(DATA(libtrace)->header)))
@@ -371 +387 @@
                         packet->buffer,
                         sizeof(libtrace_pcapfile_pkt_hdr_t));
+
         if (err<0) {
                 trace_set_err(libtrace,TRACE_ERR_WANDIO_FAILED,"reading packet");
@@ -432 +449 @@
                 libtrace_packet_t *packet)
 {
+
+        /* Check pcapfile can write this type of packet */
+        if (!pcapfile_can_write(packet)) {
+                return 0;
+        }
+
         struct libtrace_pcapfile_pkt_hdr_t hdr;
         struct timeval tv = trace_get_timeval(packet);
@@ -441 +464 @@
 
         ptr = trace_get_packet_buffer(packet,&linktype,&remaining);
-        
-        /* Silently discard RT metadata packets and packets with an
-         * unknown linktype. */
-        if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN || linktype == TRACE_TYPE_ERF_META || linktype == TRACE_TYPE_CONTENT_INVALID) {
-                return 0;
-        }
 
         /* If this packet cannot be converted to a pcap linktype then

lib/format_pcapng.c

@@ -198 +198 @@
 #define DATAOUT(x) ((struct pcapng_format_data_out_t*)((x)->format_data))
 
+static bool pcapng_can_write(libtrace_packet_t *packet) {
+        /* Get the linktype */
+        libtrace_linktype_t ltype = trace_get_link_type(packet);
+
+        if (ltype == TRACE_TYPE_CONTENT_INVALID
+                || ltype == TRACE_TYPE_UNKNOWN
+                || ltype == TRACE_TYPE_ERF_META
+                || ltype == TRACE_TYPE_NONDATA) {
+
+                return false;
+        }
+
+        return true;
+}
+
 static pcapng_interface_t *lookup_interface(libtrace_t *libtrace,
                 uint32_t intid) {
@@ -224 +239 @@
         /* Section blocks, interface blocks, name resolution blocks, stats blocks and
          * Custom blocks are all of type trace_type_pcapng_meta */
-        if (trace_get_link_type(packet) == TRACE_TYPE_PCAPNG_META) {
-                if (DATAOUT(packet->trace)->byteswapped) {
-                        return byteswap32(*type);
-                } else {
-                        return *type;
-                }
-        /* Only check for enhanced or simple packet blocks */
-        } else {
-                if (DATAOUT(packet->trace)->byteswapped) {
-                        *type = byteswap32(*type);
-                }
-                if (*type == 0x00000006 || *type == 0x00000003) {
-                        return *type;
-                }
+        if (packet->type == TRACE_RT_PCAPNG_META) {
+                return *type;
+        }
+
+        if (packet->type == 0x00000006 || packet->type == 0x00000003) {
+                return *type;
         }
         /* not a pcapng header type */
@@ -269 +276 @@
 
 static struct pcapng_timestamp pcapng_get_timestamp(libtrace_packet_t *packet) {
-        struct timespec ts = trace_get_timespec(packet);
-        uint64_t time = (((uint64_t) ts.tv_sec) * 1000000LL) + ts.tv_nsec / 1000;
+        struct timeval tv = trace_get_timeval(packet);
+        uint64_t time = ((uint64_t)tv.tv_sec * (uint64_t)1000000) + tv.tv_usec;
 
         struct pcapng_timestamp timestamp;
@@ -555 +562 @@
         }
 
-        libtrace_linktype_t linktype;
-
-        linktype = trace_get_link_type(packet);
-        /* discard meta packets from other capture types and unknown packets
-         * could try to convert erf meta packets? */
-        if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN
-                || linktype == TRACE_TYPE_ERF_META || linktype == TRACE_TYPE_CONTENT_INVALID) {
-                return 0;
-        }
+        /* Check pcapng can write this type of packet */
+        if (!pcapng_can_write(packet)) {
+                return 0;
+        }
+
+        libtrace_linktype_t linktype = trace_get_link_type(packet);
 
         /* If the file is not open, open it */
@@ -572 +576 @@
                         DATAOUT(libtrace)->flag);
         }
-        fprintf(stderr, "switch\n");
+
         /* If the packet is already encapsulated in a pcapng frame just output it */
         switch (pcapng_get_header_type(packet)) {
@@ -693 +697 @@
                                 DATAOUT(libtrace)->lastdlt = linktype;
                         }
+
                         break;
                 }
@@ -711 +716 @@
         epkthdr.caplen = trace_get_capture_length(packet);
 
+        /* trace_get_wirelength includes FCS, while pcapng doesn't */
+        if (trace_get_link_type(packet)==TRACE_TYPE_ETH) {
+                if (epkthdr.wlen >= 4) {
+                        epkthdr.wlen -= 4;
+                } else {
+                        epkthdr.wlen = 0;
+                }
+        }
         /* capture length should always be less than the wirelength */
         if (epkthdr.caplen > epkthdr.wlen) {
@@ -819 +832 @@
         }
 
-        packet->type = pcapng_linktype_to_rt(TRACE_RT_PCAPNG_META);
+        packet->type = TRACE_RT_PCAPNG_META;
         if (pcapng_prepare_packet(libtrace, packet, packet->buffer,
                         packet->type, flags)) {
@@ -886 +899 @@
         bodyptr = (char *) packet->buffer + sizeof(pcapng_int_t);
 
-        packet->type = pcapng_linktype_to_rt(TRACE_RT_PCAPNG_META);
+        packet->type = TRACE_RT_PCAPNG_META;
 
         if (pcapng_prepare_packet(libtrace, packet, packet->buffer,
@@ -951 +964 @@
         }
 
-        packet->type = pcapng_linktype_to_rt(TRACE_RT_PCAPNG_META);
+        packet->type = TRACE_RT_PCAPNG_META;
         if (pcapng_prepare_packet(libtrace, packet, packet->buffer,
                         packet->type, flags)) {
@@ -995 +1008 @@
         }
 
-        packet->type = pcapng_linktype_to_rt(TRACE_RT_PCAPNG_META);
+        packet->type = TRACE_RT_PCAPNG_META;
         if (pcapng_prepare_packet(libtrace, packet, packet->buffer,
                         packet->type, flags)) {
@@ -1414 +1427 @@
 static libtrace_linktype_t pcapng_get_link_type(const libtrace_packet_t *packet) {
 
-        struct pcapng_peeker *hdr = (struct pcapng_peeker *)packet->buffer;
-
-        if (hdr->blocktype == PCAPNG_SECTION_TYPE
-                || hdr->blocktype == PCAPNG_INTERFACE_TYPE
-                || hdr->blocktype == PCAPNG_NAME_RESOLUTION_TYPE
-                || hdr->blocktype == PCAPNG_INTERFACE_STATS_TYPE
-                || hdr->blocktype == PCAPNG_CUSTOM_TYPE) {
+        if (packet->type == TRACE_RT_PCAPNG_META) {
                 return TRACE_TYPE_PCAPNG_META;
         }

lib/trace.c

@@ -1718 +1718 @@
         linktype = trace_get_link_type(packet);
 
-        if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_ERF_META)
+        if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_ERF_META
+                || linktype == TRACE_TYPE_PCAPNG_META)
                 return 1;