Changeset f01e6a8


Ignore:
Timestamp:
05/06/10 14:59:38 (11 years ago)
Author:
Perry Lorier <perry@…>
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:
9da93dc
Parents:
8e580c5
Message:

Be smarter about where you search for decoders.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • libpacketdump/libpacketdump.cc

    r6e90062 rf01e6a8  
    128128}
    129129
     130static void *open_so_decoder(const char *name,int type)
     131{
     132        char path[1024];
     133        void *hdl;
     134        /* Only check LIBPKTDUMPDIR if we're not setuid.  Not bulletproof, but hopefully anyone who
     135         * sets uid == euid will also clear the environment (eg sudo).
     136         */
     137        if (getuid() == geteuid() && getenv("LIBPKTDUMPDIR")) {
     138                snprintf(path,sizeof(path),"%s/%s_%i.so",getenv("LIBPKTDUMPDIR"),name,type);
     139                hdl = dlopen(path,RTLD_LAZY);
     140                if (hdl)
     141                        return hdl;
     142        }
     143        /* If the variable isn't set, *or* if we don't find anything, try the system location. */
     144        snprintf(path,sizeof(path),DIRNAME "/%s_%i.so",name,type);
     145        hdl = dlopen(path,RTLD_LAZY);
     146        if (hdl)
     147                return hdl;
     148
     149        return hdl;
     150}
     151
     152static void *open_protocol_decoder(const char *name, int type)
     153{
     154        char path[1024];
     155        void *hdl;
     156        /* Only check LIBPKTDUMPDIR if we're not setuid.  Not bulletproof, but hopefully anyone who
     157         * sets uid == euid will also clear the environment (eg sudo).
     158         */
     159        if (getuid() == geteuid() && getenv("LIBPKTDUMPDIR")) {
     160                snprintf(path,sizeof(path),"%s/%s_%i.protocol",getenv("LIBPKTDUMPDIR"),name,type);
     161                hdl = parse_protocol_file(path);
     162                if (hdl)
     163                        return hdl;
     164        }
     165        /* Try the system directory */
     166        snprintf(path,sizeof(path),DIRNAME "/%s_%i.protocol",
     167                name,type);
     168        hdl = parse_protocol_file(path);
     169
     170        if (!hdl)
     171                return hdl;
     172
     173        return hdl;
     174}
     175
    130176void decode_next(const char *packet,int len,const char *proto_name,int type)
    131177{
     
    136182        if (decoders[sname].find(type)==decoders[sname].end()) {
    137183                void *hdl;
    138                 char name[1024];
    139184                decode_funcs_t *func = new decode_funcs_t;
    140185                decode_t dec;
    141                 snprintf(name,sizeof(name),"%s/%s_%i.so",DIRNAME,sname.c_str(),type);
    142                 hdl = dlopen(name,RTLD_LAZY);
     186
     187                /* Try and find a .so to handle this protocol */
     188                hdl = open_so_decoder(sname.c_str(),type);
     189                if (hdl) {
     190                        void *s=dlsym(hdl,"decode");
     191                        if (s) {
     192                                // use the shared library
     193                                func->decode_n = (decode_norm_t)s;
     194                                dec.style = DECODE_NORMAL;
     195                                dec.el = NULL;
     196                        }
     197                        else {
     198                                dlclose(hdl);
     199                                hdl = NULL;
     200                        }
     201                }
     202
     203                /* We didn't successfully open the .so, try finding a .protocol that we can use */
    143204                if (!hdl) {
    144                         // if there is no shared library, try a protocol file
    145                         snprintf(name,sizeof(name),"%s/%s_%i.protocol",
    146                                 DIRNAME,sname.c_str(),type);
    147                         hdl = parse_protocol_file(name);
    148 
    149                         if(!hdl)
    150                         {
    151                                 // no protocol file either, use a generic one
    152                                 func->decode_n = generic_decode;
    153                                 dec.style = DECODE_NORMAL;
    154                                 dec.el = NULL;
    155                         } else {
     205                        hdl = open_protocol_decoder(sname.c_str(),type);
     206                        if (hdl) {
    156207                                // use the protocol file
    157208                                func->decode_p = decode_protocol_file;
     
    159210                                dec.el = (element_t*)hdl;
    160211                        }
    161                 } else {
    162                         void *s=dlsym(hdl,"decode");
    163                         if (!s) {
    164                                 // the shared library doesnt have a decode func
    165                                 // TODO should try the protocol file now
    166                                 func->decode_n = generic_decode;
    167                                 dec.style = DECODE_NORMAL;
    168                                 dec.el = NULL;
    169                         }
    170                         else
    171                         {
    172                                 // use the shared library
    173                                 func->decode_n = (decode_norm_t)s;
    174                                 dec.style = DECODE_NORMAL;
    175                                 dec.el = NULL;
    176                         }
    177                 }
     212                }
     213
     214                /* No matches found, fall back to the generic decoder. */
     215                /* TODO: We should have a variety of fallback decoders based on the protocol. */
     216                if(!hdl)
     217                {
     218                        // no protocol file either, use a generic one
     219                        func->decode_n = generic_decode;
     220                        dec.style = DECODE_NORMAL;
     221                        dec.el = NULL;
     222                }
     223
    178224                dec.func = func;
    179225                decoders[sname][type] = dec;
    180226        }
    181227
     228        /* TODO: Instead of haxing this here, we should provide a series of generic_decode's
     229         * and let the code above deal with it.
     230         */
    182231        if (decoders[sname][type].func->decode_n == generic_decode) {
    183232                /* We can't decode a link, so lets skip that and see if libtrace
     
    196245                        if (network) {
    197246                                printf("skipping unknown link header of type %i to network type %i\n",type,newtype);
     247                                /* Should hex dump this too. */
    198248                                decode_next(network,newlen,"eth",newtype);
    199249                                return;
Note: See TracChangeset for help on using the changeset viewer.