Changeset abc66e7

Timestamp:

05/18/06 11:57:14 (15 years ago)

Author:

Brendon Jones <brendonj@…>

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:

003cb8a

Parents:

cd7eec7

Message:

If the .so used to decode a particular layer doesn't exist, it will now try
to find a similarly named .protocol file which specifies in plain text how
it should be decoded. Slight differences between the two means that it isn't
quite a drop in replacement - a union is required to know which to use.

File:

• libpacketdump/libpacketdump.cc (modified) (2 diffs)

libpacketdump/libpacketdump.cc

@@ -46 +46 @@
 #include <ctype.h>
 #include "libpacketdump.h"
+extern "C"{
+#include "parser/parser.h"
+}
 
-typedef void (*decode_t)(uint16_t type,char *packet,int len);
+enum decode_style_t {
+    DECODE_NORMAL,
+    DECODE_PARSER
+};
+
+typedef void (*decode_norm_t)(uint16_t type,char *packet,int len);
+typedef void (*decode_parser_t)(uint16_t type,char *packet,int len, element_t* el);
+
+typedef union decode_funcs {
+    decode_norm_t decode_n;
+    decode_parser_t decode_p;
+} decode_funcs_t;
+
+typedef struct decoder {
+    enum decode_style_t style;
+    decode_funcs_t *func;
+    element_t *el; // make a union of structs with all args in it for all funcs?
+} decode_t;
+
 
 static std::map<std::string,std::map<uint16_t,decode_t> > decoders;
@@ -102 +123 @@
 {
         std::string sname(proto_name);
+
+        // if we haven't worked out how to decode this type yet, load the
+        // appropriate files to do so
         if (decoders[sname].find(type)==decoders[sname].end()) {
                 void *hdl;
                 char name[1024];
+                decode_funcs_t *func = new decode_funcs_t;
+                decode_t dec;
                 snprintf(name,sizeof(name),"%s/%s_%i.so",DIRNAME,sname.c_str(),type);
                 hdl = dlopen(name,RTLD_LAZY);
-                if (!hdl) 
-                        decoders[sname][type]=generic_decode;
-                else {
+                if (!hdl) {
+                        // if there is no shared library, try a protocol file
+                        snprintf(name,sizeof(name),"%s/%s_%i.protocol",
+                                DIRNAME,sname.c_str(),type);
+                        hdl = parse_protocol_file(name);
+
+                        if(!hdl)
+                        {
+                                // no protocol file either, use a generic one
+                                func->decode_n = generic_decode;
+                                dec.style = DECODE_NORMAL;
+                                dec.el = NULL;
+                        } else {
+                                // use the protocol file
+                                func->decode_p = decode_protocol_file;
+                                dec.style = DECODE_PARSER;
+                                dec.el = (element_t*)hdl;
+                        }
+                } else {
                         void *s=dlsym(hdl,"decode");
                         if (!s) {
-                                decoders[sname][type]=generic_decode;
+                                // the shared library doesnt have a decode func
+                                // TODO should try the protocol file now
+                                func->decode_n = generic_decode;
+                                dec.style = DECODE_NORMAL;
+                                dec.el = NULL;
                         }
                         else
-                                decoders[sname][type]=(decode_t)s;
+                        {
+                                // use the shared library
+                                func->decode_n = (decode_norm_t)s;
+                                dec.style = DECODE_NORMAL;
+                                dec.el = NULL; 
+                        }
                 }
+                dec.func = func;
+                decoders[sname][type] = dec;
         }
-        decoders[sname][type](type,packet,len);
+
+        // decode using the appropriate function
+        switch(decoders[sname][type].style)
+        {
+                case DECODE_NORMAL:
+                        decoders[sname][type].func->decode_n(type,packet,len);
+                        break;
+
+                case DECODE_PARSER:
+                        decoders[sname][type].func->decode_p(type,packet,len,
+                                decoders[sname][type].el);
+                        break;
+
+        };
 }
-
-