Changeset 633339d for lib

Timestamp:

06/23/17 14:24:23 (4 years ago)

Author:

Shane Alcock <salcock@…>

Branches:

cachetimestamps, develop, dpdk-ndag, etsilive, master, ndag_format, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance

Children:

fdf1f7b

Parents:

f398c61

Message:

Push pcap_get_direction() function to format_helper.c

This means we don't have duplicate "get direction" code
in multiple pcap-based format modules. The future addition of
pcapng will be able to use this function too.

Location:

lib

Files:

• format_helper.c (modified) (1 diff)
• format_helper.h (modified) (1 diff)
• format_pcap.c (modified) (3 diffs)
• format_pcapfile.c (modified) (1 diff)

lib/format_helper.c

@@ -323 +323 @@
         va_end(va);
 }
+
+/** Attempts to determine the direction for a pcap (or pcapng) packet.
+ *
+ * @param packet        The packet in question.
+ * @return A valid libtrace_direction_t describing the direction that the
+ *         packet was travelling, if direction can be determined. Otherwise
+ *         returns TRACE_DIR_UNKNOWN.
+ * @internal
+ *
+ * Note that we can determine the direction for only certain types of packets
+ * if they are captured using pcap/pcapng, specifically SLL and PFLOG captures.
+ */
+libtrace_direction_t pcap_get_direction(const libtrace_packet_t *packet) {
+        libtrace_direction_t direction  = -1;
+        switch(pcap_linktype_to_libtrace(rt_to_pcap_linktype(packet->type))) {
+                /* We can only get the direction for PCAP packets that have
+                 * been encapsulated in Linux SLL or PFLOG */
+                case TRACE_TYPE_LINUX_SLL:
+                {
+                        libtrace_sll_header_t *sll;
+                        libtrace_linktype_t linktype;
+
+                        sll = (libtrace_sll_header_t*)trace_get_packet_buffer(
+                                        packet,
+                                        &linktype,
+                                        NULL);
+                        if (!sll) {
+                                trace_set_err(packet->trace,
+                                        TRACE_ERR_BAD_PACKET,
+                                                "Bad or missing packet");
+                                return -1;
+                        }
+                        /* 0 == LINUX_SLL_HOST */
+                        /* the Waikato Capture point defines "packets
+                         * originating locally" (ie, outbound), with a
+                         * direction of 0, and "packets destined locally"
+                         * (ie, inbound), with a direction of 1.
+                         * This is kind-of-opposite to LINUX_SLL.
+                         * We return consistent values here, however
+                         *
+                         * Note that in recent versions of pcap, you can
+                         * use "inbound" and "outbound" on ppp in linux
+                         */
+                        if (ntohs(sll->pkttype == 0)) {
+                                direction = TRACE_DIR_INCOMING;
+                        } else {
+                                direction = TRACE_DIR_OUTGOING;
+                        }
+                        break;
+
+                }
+               case TRACE_TYPE_PFLOG:
+                {
+                        libtrace_pflog_header_t *pflog;
+                        libtrace_linktype_t linktype;
+
+                        pflog=(libtrace_pflog_header_t*)trace_get_packet_buffer(
+                                        packet,&linktype,NULL);
+                        if (!pflog) {
+                                trace_set_err(packet->trace,
+                                                TRACE_ERR_BAD_PACKET,
+                                                "Bad or missing packet");
+                                return -1;
+                        }
+                        /* enum    { PF_IN=0, PF_OUT=1 }; */
+                        if (ntohs(pflog->dir==0)) {
+
+                                direction = TRACE_DIR_INCOMING;
+                        }
+                        else {
+                                direction = TRACE_DIR_OUTGOING;
+                        }
+                        break;
+                }
+                default:
+                        break;
+        }       
+        return direction;
+}
+
+

lib/format_helper.h

@@ -87 +87 @@
                 int level,
                 int filemode);
+
+
+/** Attempts to determine the direction for a pcap (or pcapng) packet.
+ *
+ * @param packet        The packet in question.
+ * @return A valid libtrace_direction_t describing the direction that the
+ *         packet was travelling, if direction can be determined. Otherwise
+ *         returns TRACE_DIR_UNKNOWN.
+ *
+ * Note that we can determine the direction for only certain types of packets
+ * if they are captured using pcap/pcapng, specifically SLL and PFLOG captures.
+ */
+libtrace_direction_t pcap_get_direction(const libtrace_packet_t *packet);
+
+
+
 #endif /* FORMAT_HELPER_H */

lib/format_pcap.c

@@ -628 +628 @@
 }
 
-static libtrace_direction_t pcap_get_direction(const libtrace_packet_t *packet) {
-        libtrace_direction_t direction  = -1;
-        switch(pcap_get_link_type(packet)) {
-                /* Only packets encapsulated in Linux SLL or PFLOG have any
-                 * direction information */
-
-                case TRACE_TYPE_LINUX_SLL:
-                {
-                        libtrace_sll_header_t *sll;
-                        sll = trace_get_packet_buffer(packet, NULL, NULL);
-                        /* TODO: should check remaining>=sizeof(*sll) */
-                        if (!sll) {
-                                trace_set_err(packet->trace,
-                                        TRACE_ERR_BAD_PACKET,
-                                                "Bad or missing packet");
-                                return -1;
-                        }
-                        /* 0 == LINUX_SLL_HOST */
-                        /* the Waikato Capture point defines "packets
-                         * originating locally" (ie, outbound), with a
-                         * direction of 0, and "packets destined locally"
-                         * (ie, inbound), with a direction of 1.
-                         * This is kind-of-opposite to LINUX_SLL.
-                         * We return consistent values here, however
-                         *
-                         * Note that in recent versions of pcap, you can
-                         * use "inbound" and "outbound" on ppp in linux
-                         */
-                        if (sll->pkttype == TRACE_SLL_OUTGOING) {
-                                direction = TRACE_DIR_OUTGOING;
-                        } else {
-                                direction = TRACE_DIR_INCOMING;
-                        }
-                        break;
-
-                }
-                case TRACE_TYPE_PFLOG:
-                {
-                        libtrace_pflog_header_t *pflog;
-                        pflog = trace_get_packet_buffer(packet, NULL, NULL);
-                        /* TODO: should check remaining >= sizeof(*pflog) */
-                        if (!pflog) {
-                                trace_set_err(packet->trace,
-                                                TRACE_ERR_BAD_PACKET,
-                                                "Bad or missing packet");
-                                return -1;
-                        }
-                        /* enum    { PF_IN=0, PF_OUT=1 }; */
-                        if (ntohs(pflog->dir==0)) {
-
-                                direction = TRACE_DIR_INCOMING;
-                        }
-                        else {
-                                direction = TRACE_DIR_OUTGOING;
-                        }
-                        break;
-                }
-                default:
-                        break;
-        }       
-        return direction;
+static libtrace_direction_t pcapint_get_direction(const libtrace_packet_t *packet) {
+        /* This function is defined in format_helper.c */
+        return pcap_get_direction(packet);
 }
 
@@ -816 +758 @@
         pcap_write_packet,              /* write_packet */
         pcap_get_link_type,             /* get_link_type */
-        pcap_get_direction,             /* get_direction */
+        pcapint_get_direction,          /* get_direction */
         pcap_set_direction,             /* set_direction */
         NULL,                           /* get_erf_timestamp */
@@ -860 +802 @@
         pcapint_write_packet,           /* write_packet */
         pcap_get_link_type,             /* get_link_type */
-        pcap_get_direction,             /* get_direction */
+        pcapint_get_direction,          /* get_direction */
         pcap_set_direction,             /* set_direction */
         NULL,                           /* get_erf_timestamp */

lib/format_pcapfile.c

@@ -541 +541 @@
 static libtrace_direction_t pcapfile_get_direction(const libtrace_packet_t *packet) 
 {
-        libtrace_direction_t direction  = -1;
-        switch(pcapfile_get_link_type(packet)) {
-                /* We can only get the direction for PCAP packets that have
-                 * been encapsulated in Linux SLL or PFLOG */
-                case TRACE_TYPE_LINUX_SLL:
-                {
-                        libtrace_sll_header_t *sll;
-                        libtrace_linktype_t linktype;
-
-                        sll = (libtrace_sll_header_t*)trace_get_packet_buffer(
-                                        packet,
-                                        &linktype,
-                                        NULL);
-                        if (!sll) {
-                                trace_set_err(packet->trace,
-                                        TRACE_ERR_BAD_PACKET,
-                                                "Bad or missing packet");
-                                return -1;
-                        }
-                        /* 0 == LINUX_SLL_HOST */
-                        /* the Waikato Capture point defines "packets
-                         * originating locally" (ie, outbound), with a
-                         * direction of 0, and "packets destined locally"
-                         * (ie, inbound), with a direction of 1.
-                         * This is kind-of-opposite to LINUX_SLL.
-                         * We return consistent values here, however
-                         *
-                         * Note that in recent versions of pcap, you can
-                         * use "inbound" and "outbound" on ppp in linux
-                         */
-                        if (ntohs(sll->pkttype == 0)) {
-                                direction = TRACE_DIR_INCOMING;
-                        } else {
-                                direction = TRACE_DIR_OUTGOING;
-                        }
-                        break;
-
-                }
-                case TRACE_TYPE_PFLOG:
-                {
-                        libtrace_pflog_header_t *pflog;
-                        libtrace_linktype_t linktype;
-
-                        pflog=(libtrace_pflog_header_t*)trace_get_packet_buffer(
-                                        packet,&linktype,NULL);
-                        if (!pflog) {
-                                trace_set_err(packet->trace,
-                                                TRACE_ERR_BAD_PACKET,
-                                                "Bad or missing packet");
-                                return -1;
-                        }
-                        /* enum    { PF_IN=0, PF_OUT=1 }; */
-                        if (ntohs(pflog->dir==0)) {
-
-                                direction = TRACE_DIR_INCOMING;
-                        }
-                        else {
-                                direction = TRACE_DIR_OUTGOING;
-                        }
-                        break;
-                }
-                default:
-                        break;
-        }       
-        return direction;
+        /* This function can be found in format_helper.c */
+        return pcap_get_direction(packet);
 }