Changeset 7ac9705

Timestamp:

03/06/06 15:31:15 (16 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:

e4e1635

Parents:

eeab9832

Message:

Changed rt types so that every pcap dlt has a matching rt type
Added functions for conversion between rt type and pcap dlt
format_rt now uses trace_set_err appropriately if rt_connect fails
format_pcap will check if a trace is dead before trying to look at

format data

Dead traces now have their format_data set to NULL
packet->type is now 32 bits, not 8

Location:

lib

Files:

• format_pcap.c (modified) (3 diffs)
• format_rt.c (modified) (8 diffs)
• libtrace.h (modified) (1 diff)
• libtrace_int.h (modified) (1 diff)
• linktypes.c (modified) (2 diffs)
• rt_protocol.h (modified) (3 diffs)
• trace.c (modified) (1 diff)

lib/format_pcap.c

@@ -270 +270 @@
 static int pcap_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
         int pcapbytes = 0;
-        
-        packet->type = RT_DATA_PCAP;
+        int linktype;
+
+        assert(libtrace->format_data);
+        linktype = pcap_datalink(DATA(libtrace)->input.pcap);
+        packet->type = pcap_dlt_to_rt(linktype);
         
         pcapbytes = pcap_dispatch(INPUT.pcap,
@@ -318 +321 @@
         int linktype = 0;
         pcapptr = (struct pcap_pkthdr *)packet->header;
-        linktype = pcap_datalink(DATA(packet->trace)->input.pcap);
+
+        /* pcap doesn't store dlt in the framing header so we need
+         * rt to do it for us 
+         */
+        linktype = rt_to_pcap_dlt(packet->type);
+        /*
+        if (packet->trace->format_data == NULL) 
+                linktype = rt_to_pcap_dlt(packet->type);
+        else 
+                linktype = pcap_datalink(DATA(packet->trace)->input.pcap);
+        */
         return pcap_dlt_to_libtrace(linktype);
 }
@@ -420 +433 @@
 
 static int pcap_get_fd(const libtrace_t *trace) {
+
+        assert(trace->format_data);
         return pcap_fileno(DATA(trace)->input.pcap);
 }

lib/format_rt.c

@@ -128 +128 @@
         if (connect(RT_INFO->input_fd, (struct sockaddr *)&remote,
                                 sizeof(struct sockaddr)) == -1) {
-                perror("connect (inet)");
-                return -1;
+                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
+                                "Could not connect to host %s on port %d",
+                                RT_INFO->hostname, RT_INFO->port);
+                return -1;
         }
         
@@ -135 +137 @@
         
         if (recv(RT_INFO->input_fd, &connect_msg, sizeof(rt_header_t), 0) != sizeof(rt_header_t) ) {
-                printf("An error occured while connecting to %s\n", RT_INFO->hostname);
+                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
+                                "Could not receive connection message from %s",
+                                RT_INFO->hostname);
                 return -1;
         }
@@ -148 +152 @@
                         }       
                         reason = deny_hdr.reason;
-                        printf("Connection attempt is denied by the server: %s\n",
-                                        rt_deny_reason(reason));
+                        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
+                                "Connection attempt is denied: %s",
+                                rt_deny_reason(reason));        
                         return -1;
                 case RT_HELLO:
@@ -157 +162 @@
                                                 sizeof(rt_hello_t), 0)
                                         != sizeof(rt_hello_t)) {
-                                printf("Failed to read hello options\n");
-                                return 0;
+                                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
+                                        "Failed to receive RT_HELLO options");
+                                return -1;
                         }
                         reliability = hello_opts.reliable;
@@ -164 +170 @@
                         return 0;
                 default:
-                        printf("Unexpected message type: %d\n", connect_msg.type);
+                        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
+                                        "Unknown message type received: %d",
+                                        connect_msg.type);
                         return -1;
         }
-        
+        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
+                        "Somehow you managed to reach this unreachable code");
         return -1;
 }
@@ -276 +285 @@
 static int rt_set_format(libtrace_t *libtrace, libtrace_packet_t *packet) 
 {
+        
+        if (packet->type >= RT_DATA_PCAP) {
+                if (!RT_INFO->dummy_pcap) {
+                        RT_INFO->dummy_pcap = trace_create_dead("pcap:-");
+                }
+                packet->trace = RT_INFO->dummy_pcap;
+                return; 
+        }
+
         switch (packet->type) {
                 case RT_DATA_ERF:
@@ -282 +300 @@
                         }
                         packet->trace = RT_INFO->dummy_erf;
-                        break;
-                case RT_DATA_PCAP:
-                        if (!RT_INFO->dummy_pcap) {
-                                RT_INFO->dummy_pcap = trace_create_dead("pcap:-");
-                        }
-                        packet->trace = RT_INFO->dummy_pcap;
                         break;
                 case RT_DATA_WAG:
@@ -395 +407 @@
         packet->type = pkt_hdr.type;
         pkt_size = pkt_hdr.length;
-
-        switch(packet->type) {
-                case RT_DATA_ERF:
-                case RT_DATA_PCAP:
-                case RT_DATA_WAG:
-                case RT_DATA_LEGACY_ETH:
-                case RT_DATA_LEGACY_POS:
-                case RT_DATA_LEGACY_ATM:
-                        if (rt_read(libtrace, buffer, pkt_size) != pkt_size) {
-                                printf("Error receiving packet\n");
-                                return -1;
-                        }
-                        
-                        if (rt_set_format(libtrace, packet) < 0) {
-                                return -1;
+        packet->size = pkt_hdr.length;
+
+        if (packet->type >= RT_DATA_SIMPLE) {
+                if (rt_read(libtrace, buffer, pkt_size) != pkt_size) {
+                        printf("Error receiving packet\n");
+                        return -1;
+                }
+                
+                if (rt_set_format(libtrace, packet) < 0) {
+                        return -1;
+                }
+                rt_set_payload(packet);
+
+                if (reliability > 0) {
+                        
+                        if (rt_send_ack(libtrace, pkt_hdr.sequence) 
+                                        == -1)
+                        {
+                                return -1;
                         }
-                        rt_set_payload(packet);
-
-                        if (reliability > 0) {
-                                
-                                if (rt_send_ack(libtrace, pkt_hdr.sequence) 
-                                                == -1)
-                                {
-                                        return -1;
-                                }
-                        }
-                        break;
-                case RT_STATUS:
-                case RT_DUCK:
-                        if (rt_read(libtrace, buffer, pkt_size) !=
-                                        pkt_size) {
-                                printf("Error receiving status packet\n");
-                                return -1;
-                        }
-                        packet->header = 0;
-                        packet->payload = buffer;
-                        break;
-                case RT_END_DATA:
-                        return 0;
-                case RT_PAUSE_ACK:
-                        /* FIXME: Do something useful */
-                        break;
-                case RT_OPTION:
-                        /* FIXME: Do something useful here as well */
-                        break;
-                default:
-                        printf("Bad rt type for client receipt: %d\n",
+                }
+        } else {
+                switch(packet->type) {
+                        case RT_STATUS:
+                        case RT_DUCK:
+                                if (rt_read(libtrace, buffer, pkt_size) !=
+                                                pkt_size) {
+                                        printf("Error receiving status packet\n");
+                                        return -1;
+                                }
+                                packet->header = 0;
+                                packet->payload = buffer;
+                                break;
+                        case RT_END_DATA:
+                                return 0;
+                        case RT_PAUSE_ACK:
+                                /* FIXME: Do something useful */
+                                break;
+                        case RT_OPTION:
+                                /* FIXME: Do something useful here as well */
+                                break;
+                        default:
+                                printf("Bad rt type for client receipt: %d\n",
                                         pkt_hdr.type);
+                }
         }
         return trace_get_capture_length(packet)+trace_get_framing_length(packet);

lib/libtrace.h

@@ -112 +112 @@
         size_t size;            /**< trace_get_framing_length()
                                  * +trace_get_capture_length() */
-        uint8_t type;           /**< rt protocol type for the packet */
+        uint32_t type;          /**< rt protocol type for the packet */
 } libtrace_packet_t;
 

lib/libtrace_int.h

@@ -317 +317 @@
 libtrace_linktype_t pcap_dlt_to_libtrace(int dlt);
 char libtrace_to_pcap_dlt(libtrace_linktype_t type);
+enum rt_field_t pcap_dlt_to_rt(int dlt);
+int rt_to_pcap_dlt(enum rt_field_t rt_type);
 libtrace_linktype_t erf_type_to_libtrace(char erf);
 char libtrace_to_erf_type(libtrace_linktype_t linktype);

lib/linktypes.c

@@ -2 +2 @@
 #include <pcap.h>
 #include "dagformat.h"
+#include "rt_protocol.h"
+#include <assert.h>
 
 /* This file maps libtrace types to/from pcap DLT and erf types
@@ -46 +48 @@
 }
 
+enum rt_field_t pcap_dlt_to_rt(int dlt) 
+{
+        /* For pcap the rt type is just the dlt + a fixed value */
+        return dlt + RT_DATA_PCAP;
+}
+
+int rt_to_pcap_dlt(enum rt_field_t rt_type)
+{
+        assert(rt_type >= RT_DATA_PCAP);
+        return rt_type - RT_DATA_PCAP;
+}
+
 libtrace_linktype_t erf_type_to_libtrace(char erf)
 {

lib/rt_protocol.h

@@ -3 +3 @@
 
 #include "libtrace.h"
+#include <pcap.h>
 
 #define CAPTURE_PORT 3434
@@ -9 +10 @@
 #define RT_MAX_HDR_SIZE 256
 #define MAX_SEQUENCE 2147483647 
+
+#define RT_DATA_SIMPLE 1000
+#define RT_DATA_PCAP 2000
 
 /* Type field definitions */
@@ -24 +28 @@
  RT_OPTION      =11,    /* Option request */
  
- RT_DATA_ERF            =12,    /* Erf data packet */
- RT_DATA_PCAP           =13,    /* Pcap data packet */
- RT_DATA_WAG            =14,    /* Wag data packet */
- RT_DATA_LEGACY_ATM     =15,    /* Legacy ATM packet */
- RT_DATA_LEGACY_POS     =16,    /* Legacy POS packet */
- RT_DATA_LEGACY_ETH     =17     /* Legacy ETH packet */
+ RT_DATA_ERF            =RT_DATA_SIMPLE + TRACE_FORMAT_ERF, 
+ RT_DATA_WAG            =RT_DATA_SIMPLE + TRACE_FORMAT_WAG, 
+ RT_DATA_LEGACY_ATM     =RT_DATA_SIMPLE + TRACE_FORMAT_LEGACY_ATM, 
+ RT_DATA_LEGACY_POS     =RT_DATA_SIMPLE + TRACE_FORMAT_LEGACY_POS, 
+ RT_DATA_LEGACY_ETH     =RT_DATA_SIMPLE + TRACE_FORMAT_LEGACY_ETH, 
+
+ RT_DATA_PCAP_NULL              =RT_DATA_PCAP + DLT_NULL,
+ RT_DATA_PCAP_EN10MB            =RT_DATA_PCAP + DLT_EN10MB,
+ RT_DATA_PCAP_ATM_RFC1483       =RT_DATA_PCAP + DLT_ATM_RFC1483,
+ RT_DATA_PCAP_IEEE802_11        =RT_DATA_PCAP + DLT_IEEE802_11,
+#ifdef DLT_LINUX_SLL
+ RT_DATA_PCAP_LINUX_SLL         =RT_DATA_PCAP + DLT_LINUX_SLL,
+#endif
+#ifdef DLT_PFLOG
+ RT_DATA_PCAP_PFLOG             =RT_DATA_PCAP + DLT_PFLOG,
+#endif
+
 };
 

lib/trace.c

@@ -379 +379 @@
                 return 0;
         }
-        
+
+        libtrace->format_data = NULL;
         free(scan);
         return libtrace;