Changeset 1254

Timestamp:

09/04/07 16:50:19 (6 years ago)

Author:

spa1

Message:

• Updated autotools to detect DAG 3.X drivers. The new detection method will also catch DAG 2.5, but this is not a problem because the API is the same so DAG 2.5 and DAG 3 can use the same code within libtrace.
• Changed format_dag25.c to manage the dag stream manually, similar to format_dag24.c.
• Libtrace programs using DAG 2.5 and greater should now detach the DAG stream properly, provided they are exited cleanly.
• The snaplen can now be configured for DAG 2.5 and DAG 3.0 inputs

Location:

trunk

Files:

• configure.in (modified) (4 diffs)
• lib/format_dag25.c (modified) (11 diffs)
• lib/libtrace_int.h (modified) (1 diff)

trunk/configure.in

@@ -173 +173 @@
 ])
 
+# DAG 3.0 actually puts header files and shared libraries into sensible
+# places now, so we should be able to do a simple CHECK_LIB to see if
+# they're there!
+
+# Addendum: It turns out DAG 2.5 does this too, so we'll match DAG2.5 in here
+# also. This isn't such a bad thing, the DAG2.5 API is essentially the same as
+# DAG 3.0 and libtrace will use the same format_dagXX source for both
+libtrace_dag=false
+libtrace_dag_version=none
+
+if test "$with_dag" != no; then
+        AC_CHECK_LIB(dag, dag_open, dag_found=1, dag_found=0)
+        if test "$dag_found" = 1; then
+                ADD_LIBS="$ADD_LIBS -ldag"
+                AC_DEFINE(HAVE_DAG_API, 1, [define if you have a DAG API])
+                AC_DEFINE(HAVE_DAG,1,[conditional for building with DAG support])
+                libtrace_dag=true
+                
+                AC_DEFINE(DAG_VERSION,30,[defines the DAG driver version])
+                libtrace_dag_version=30
+        fi
+fi
+
 # turn the test part of the next block into a function, so it can be 
 # called multiple times for $dag_root, /root/dag, /usr/local/lib
-libtrace_dag=false
-libtrace_dag2_4=false
-dag_drv_v="DAG not present"
-if test "$with_dag" != no; then
-        AC_MSG_CHECKING(whether we have DAG API)
+#dag_drv_v="DAG not present"
+
+# Now check for 2.4 DAG drivers which don't install as cleanly!
+if test "$with_dag" != no -a "$libtrace_dag" = false; then
+        AC_MSG_CHECKING(whether we have DAG 2.4 API)
 
         if test -r "$dag_root/lib"; then
@@ -206 +229 @@
                 AC_DEFINE(HAVE_DAG_API, 1, [define if you have a DAG API])
                 AC_DEFINE(HAVE_DAG,1,[conditional for building with DAG support])
+                AC_DEFINE(DAG_VERSION, 24, [defines the DAG driver version])
+                libtrace_dag_version=24
         else
                 if test "$want_dag" = yes; then
@@ -215 +240 @@
         AC_MSG_RESULT($libtrace_dag)
 
-        if test "$libtrace_dag" != false; then
-                AC_MSG_CHECKING(if we are using DAG 2.4)
-                if grep '2.4.' $dag_root/VERSION > /dev/null 2>&1; then
-                        libtrace_dag2_4=true
-                        AC_DEFINE(DAG_VERSION_2_4, 1, [define if using DAG 2.4])
-                else
-                        libtrace_dag2_4=false
-                fi
-                AC_MSG_RESULT($libtrace_dag2_4)
-                dag_drv_v=`cat $dag_root/VERSION`
-        fi
-fi
-DAG_VERSION_NUM=$dag_drv_v
+fi
+
 AC_CHECK_LIB(z, gzopen)
 
 AM_CONDITIONAL([HAVE_BPF], [test "$ac_cv_have_decl_BIOCSETIF" = yes ])
 AM_CONDITIONAL([HAVE_DAG], [test "$libtrace_dag" = true])
-AM_CONDITIONAL([DAG2_4], [test "$libtrace_dag2_4" = true])
+AM_CONDITIONAL([DAG2_4], [test "$libtrace_dag_version" = 24])
+AM_CONDITIONAL([DAG2_5], [test "$libtrace_dag_version" = 25])
+AM_CONDITIONAL([DAG3_0], [test "$libtrace_dag_version" = 30])
 AM_CONDITIONAL([HAVE_ZLIB], [test "$ac_cv_lib_z_gzopen" = yes])
 AM_CONDITIONAL([HAVE_NETPACKET_PACKET_H], [test "$libtrace_netpacket_packet_h" = true])
@@ -269 +285 @@
 reportopt "Compiled with compressed trace (zlib) support" $ac_cv_lib_z_gzopen
 if test x"$libtrace_dag" = xtrue; then
-        if test x"$libtrace_dag2_4"; then
+        if test "$libtrace_dag_version" = 24; then
                 AC_MSG_NOTICE([Compiled with DAG support: 2.4])
+        elif test "$libtrace_dag_version" = 30; then
+                AC_MSG_NOTICE([Compiled with DAG support: 3.0])
         else
                 AC_MSG_NOTICE([Compiled with DAG support: 2.5])
-        fi
+        fi      
 else
         AC_MSG_NOTICE([Compiled with DAG support: No])

trunk/lib/format_dag25.c

@@ -75 +75 @@
         int fd;
         unsigned int dagstream;
+        int stream_attached;
+        uint8_t *bottom;
+        uint8_t *top;
 };
 
@@ -105 +108 @@
         DUCK.last_pkt = 0;
         DUCK.dummy_duck = NULL;
-
+        FORMAT_DATA->stream_attached = 0;
+        
         return 0;
 }
@@ -111 +115 @@
 static int dag_config_input(libtrace_t *libtrace, trace_option_t option,
                                 void *data) {
-        switch(option) {
+        char conf_str[4096];
+        switch(option) {
                 case TRACE_OPTION_META_FREQ:
                         DUCK.duck_freq = *(int *)data;
                         return 0;
                 case TRACE_OPTION_SNAPLEN:
-                        /* Surely we can set this?? Fall through for now*/
-                        return -1;
+                        snprintf(conf_str, 4096, "varlen slen=%i", *(int *)data);
+                        if (dag_configure(FORMAT_DATA->fd, conf_str) != 0) {
+                                trace_set_err(libtrace, errno, "Failed to configure snaplen on DAG card: %s", libtrace->uridata);
+                                return -1;
+                        }
+                        return 0;
                 case TRACE_OPTION_PROMISC:
                         /* DAG already operates in a promisc fashion */
@@ -152 +161 @@
                 return -1;
         }
+        FORMAT_DATA->stream_attached = 1;
         /* We don't want the dag card to do any sleeping */
         dag_set_stream_poll(FORMAT_DATA->fd, 
@@ -158 +168 @@
         
         /* Should probably flush the memory hole now */
+        
         do {
                 top = dag_advance_stream(FORMAT_DATA->fd,
@@ -164 +175 @@
                 assert(top && bottom);
                 diff = top - bottom;
+                bottom -= diff;
         } while (diff != 0);
 
@@ -180 +192 @@
                 return -1;
         }
-
+        FORMAT_DATA->stream_attached = 0;
         return 0;
 }
 
 static int dag_fin_input(libtrace_t *libtrace) {
+        if (FORMAT_DATA->stream_attached)
+                dag_pause_input(libtrace);
+        dag_close(FORMAT_DATA->fd);
         if (DUCK.dummy_duck)
                 trace_destroy_dead(DUCK.dummy_duck);
@@ -193 +208 @@
 static int dag_get_duckinfo(libtrace_t *libtrace,
                                 libtrace_packet_t *packet) {
-        daginf_t lt_dag_inf;
-
         if (packet->buf_control == TRACE_CTRL_EXTERNAL ||
                         !packet->buffer) {
@@ -224 +237 @@
 }
 
-dag_record_t *dag_get_record(libtrace_t *libtrace) {
+static int dag_available(libtrace_t *libtrace) {
+        uint32_t diff = FORMAT_DATA->top - FORMAT_DATA->bottom;
+        if (diff >= dag_record_size)
+                return diff;
+        FORMAT_DATA->top = dag_advance_stream(FORMAT_DATA->fd, 
+                        FORMAT_DATA->dagstream, 
+                        &(FORMAT_DATA->bottom));
+        if (FORMAT_DATA->top == NULL) {
+                trace_set_err(libtrace, errno, "dag_advance_stream failed!");
+                return -1;
+        }
+        diff = FORMAT_DATA->top - FORMAT_DATA->bottom;
+        return diff;
+}
+
+static dag_record_t *dag_get_record(libtrace_t *libtrace) {
         dag_record_t *erfptr = NULL;
         uint16_t size;
-        erfptr = (dag_record_t *) dag_rx_stream_next_record(FORMAT_DATA->fd,
-                        FORMAT_DATA->dagstream);
+        erfptr = (dag_record_t *)FORMAT_DATA->bottom;
         if (!erfptr)
                 return NULL;
         size = ntohs(erfptr->rlen);
         assert( size >= dag_record_size );
+        /* Make certain we have the full packet available */
+        if (size > (FORMAT_DATA->top - FORMAT_DATA->bottom))
+                return NULL;
+        FORMAT_DATA->bottom += size;
         return erfptr;
 }
 
-void dag_form_packet(dag_record_t *erfptr, libtrace_packet_t *packet) {
+static void dag_form_packet(dag_record_t *erfptr, libtrace_packet_t *packet) {
         packet->buffer = erfptr;
         packet->header = erfptr;
@@ -257 +288 @@
         struct timeval tv;
         dag_record_t *erfptr = NULL;
-
+        int numbytes = 0;
+        
         if (DUCK.last_pkt - DUCK.last_duck > DUCK.duck_freq &&
                         DUCK.duck_freq != 0) {
@@ -276 +308 @@
 
         do {
+                numbytes = dag_available(libtrace);
+                if (numbytes < 0)
+                        return numbytes;
+                if (numbytes < dag_record_size)
+                        /* Block until we see a packet */
+                        continue;
                 erfptr = dag_get_record(libtrace);
         } while (erfptr == NULL);

trunk/lib/libtrace_int.h

@@ -109 +109 @@
 #  include "dagnew.h"
 #  include "dagapi.h"
-#       ifndef DAG_VERSION_2_4
+#       if DAG_VERSION == 25
 #               include <daginf.h>
 #       endif