Ignore:
Timestamp:
08/24/04 13:25:38 (18 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:
882ff88a
Parents:
505c421
Message:

Fixes to TCP
Fixes to ASN1 parsing

File:
1 edited

Legend:

Unmodified
Added
Removed
  • examples/tracedump/asn1.cc

    rd2e3359 r258c1fb  
    99#endif
    1010#include "asn1.h"
     11#include <boost/format.hpp>
    1112
    1213
     
    4445};
    4546
    46 void ASN_data::toString(void) {
     47void ASN_data::display(void) {
    4748                        printf(" ASN: %s %s 0x%x\n",
    4849                                        ASN_type_class_t_names[(int)type.getClass()],
     
    7778                                printf("\n");
    7879                        }
    79                 }; // toString
     80                }; // display
     81
    8082ASN_data::~ASN_data() {};
    8183
     84std::string ASN_data::toString(void) {
     85        return std::string("Unknown");
     86};
    8287
    8388bool ASN::eof(void) const {
     
    9398                        return *buffer.begin()!=0;
    9499                }
    95                 void toString(void) const {
     100                void display(void) const {
    96101                        printf(" ASN: Bool:\t%s\n",getValue()
    97102                                                ?"True":
     
    113118                        return val;
    114119                }
    115                 void toString(void) {
     120                void display(void) {
    116121                        printf(" ASN: Int:\t0x");
    117122                        // Yeah, this is a dirty trick
     
    125130};
    126131
     132// Type 3 -- Bitstring
     133class ASN_bitstring : public ASN_data {
     134        public:
     135                ASN_bitstring(ASN_type t,uint64_t l) : ASN_data(t,l) {};
     136                void display(void) {
     137                        printf(" DEBUG: %i bytes\n",buffer.size());
     138                        printf(" ASN: Bitstring:\t0b");
     139                        buffer_t::const_iterator i=buffer.begin();
     140                        //int bits=*i;
     141                        i++;
     142                        for( ;
     143                                        i!=buffer.end();
     144                                        i++) {
     145                                for (int j=0;j<7;j++) {
     146                                        if (*i & (1<<(7-j))) {
     147                                                printf("1");
     148                                        }
     149                                        else {
     150                                                printf("0");
     151                                        }
     152                                }
     153                                printf(" ");
     154                        }
     155                        printf("\n");
     156                }
     157};
    127158// Types - Simple Strings
    128159class ASN_string : public ASN_data {
     
    138169                        return s;
    139170                }
    140                 void toString(void) {
     171                void display(void) {
    141172                        printf(" ASN: String:\t%s\n",getValue().c_str());
    142173                }
     
    146177        public:
    147178                ASN_null(ASN_type t,uint64_t l) : ASN_data(t,l) {};
    148                 void toString(void) { printf(" ASN: NULL\n"); }
    149 };
    150 
    151 // Abstract Container for sets and sequences
    152 class ASN_container : public ASN_data {
    153         private:
    154                 std::vector<ASN_data *> subencodings;
    155         public:
    156                 typedef std::vector<ASN_data *>::const_iterator const_iterator;
    157                 ASN_container(ASN_type t,uint64_t l) : ASN_data(t,l) {};
    158                 void parse() {
    159                         ASN n;
    160                         n.feed(buffer,len);
    161                         while (!n.eof()) {
    162                                 subencodings.push_back(n.getEncoding());
    163                         }
    164                 };
    165                 const_iterator begin(void) { return (const_iterator)subencodings.begin(); }
    166                 const_iterator end(void) { return (const_iterator)subencodings.end(); }
    167 };
    168 
    169 // Type 16 - Sequence
    170 class ASN_sequence : public ASN_container {
    171         public:
    172                 ASN_sequence(ASN_type t,uint64_t l) : ASN_container(t,l) {};
    173                 void toString(void) {
    174                         printf(" ASN: Sequence begin\n");
    175                         for(const_iterator i=begin();
    176                                         i!=end();
    177                                         i++)
    178                                 (*i)->toString();
    179                         printf(" ASN: Sequence end\n");
    180                 }
    181 };
    182 // Type 17 - Set
    183 class ASN_set : public ASN_container {
    184         public:
    185                 ASN_set(ASN_type t,uint64_t l) : ASN_container(t,l) {};
    186                 void toString(void) {
    187                         printf(" ASN: Set begin\n");
    188                         for(const_iterator i=begin();
    189                                         i!=end();
    190                                         i++)
    191                                 (*i)->toString();
    192                         printf(" ASN: Set end\n");
    193                 }
     179                void display(void) { printf(" ASN: NULL\n"); }
    194180};
    195181
     
    217203                                oid.push_back(decodeInt());
    218204                };
    219                 void toString(void) {
     205                void display(void) {
    220206                        printf(" ASN: OID");
    221207                        for(std::vector<uint64_t>::const_iterator i=oid.begin();
     
    226212                        printf("\n");
    227213                };
     214                std::string toString(void) {
     215                        std::string ret;
     216                        for(std::vector<uint64_t>::const_iterator i=oid.begin();
     217                                        i!=oid.end();
     218                                        i++) {
     219                                ret+=(boost::format(" %i") % *i).str();
     220                        }
     221                        return ret;
     222                }
     223};
     224
     225
     226// Abstract Container for sets and sequences
     227class ASN_container : public ASN_data {
     228        protected:
     229                std::vector<ASN_data *> subencodings;
     230        public:
     231                typedef std::vector<ASN_data *>::const_iterator const_iterator;
     232                ASN_container(ASN_type t,uint64_t l) : ASN_data(t,l) {};
     233                void parse() {
     234                        ASN n;
     235                        n.feed(buffer,len);
     236                        while (!n.eof()) {
     237                                subencodings.push_back(n.getEncoding());
     238                        }
     239                };
     240                const_iterator begin(void) { return (const_iterator)subencodings.begin(); }
     241                const_iterator end(void) { return (const_iterator)subencodings.end(); }
     242};
     243
     244// Type 16 - Sequence
     245class ASN_sequence : public ASN_container {
     246        public:
     247                ASN_sequence(ASN_type t,uint64_t l) : ASN_container(t,l) {};
     248                void display(void) {
     249                        if (subencodings.size()==2
     250                          &&subencodings[0]->type.getTag() == 6) {
     251                                printf(" ASN: Sequence OID (%s)\n",subencodings[0]->toString().c_str());
     252                                subencodings[1]->display();
     253                                return;
     254                        }
     255
     256                        printf(" ASN: Sequence begin (%i items)\n",subencodings.size());
     257                        for(const_iterator i=begin();
     258                                        i!=end();
     259                                        i++)
     260                                (*i)->display();
     261                        printf(" ASN: Sequence end\n");
     262                }
     263};
     264// Type 17 - Set
     265class ASN_set : public ASN_container {
     266        public:
     267                ASN_set(ASN_type t,uint64_t l) : ASN_container(t,l) {};
     268                void display(void) {
     269                        if (subencodings.size()==1) {
     270                                printf(" ASN: Single item set\n");
     271                                subencodings[0]->display();
     272                                return;
     273                        }
     274                        printf(" ASN: Set begin\n");
     275                        for(const_iterator i=begin();
     276                                        i!=end();
     277                                        i++)
     278                                (*i)->display();
     279                        printf(" ASN: Set end\n");
     280                }
    228281};
    229282
     
    268321        uint64_t l=getLength();
    269322        ASN_data *ret;
    270         switch(t.getTag()) {
    271                 case 1:
    272                         ret=new ASN_bool(t,l);
    273                         break;
    274                 case 2:
    275                         ret=new ASN_int(t,l);
    276                         break;
    277                 case 5:
    278                         ret=new ASN_null(t,l);
    279                         break;
    280                 case 6:
    281                         ret=new ASN_oid(t,l);
    282                         break;
    283                 case 16:
    284                         ret=new ASN_sequence(t,l);
    285                         break;
    286                 case 17:
    287                         ret=new ASN_set(t,l);
    288                         break;
    289                 case 18:
    290                 case 19:
    291                 case 20:
    292                 case 21:
    293                 case 22:
    294                 case 25:
    295                 case 26:
    296                 case 27:
    297                         ret=new ASN_string(t,l);
     323        switch(t.getClass()) {
     324                case Universal:
     325                        switch(t.getTag()) {
     326                                case 1:
     327                                        ret=new ASN_bool(t,l);
     328                                        break;
     329                                case 2:
     330                                        ret=new ASN_int(t,l);
     331                                        break;
     332                                case 3:
     333                                        ret=new ASN_bitstring(t,l);
     334                                        break;
     335                                case 5:
     336                                        ret=new ASN_null(t,l);
     337                                        break;
     338                                case 6:
     339                                        ret=new ASN_oid(t,l);
     340                                        break;
     341                                case 16:
     342                                        ret=new ASN_sequence(t,l);
     343                                        break;
     344                                case 17:
     345                                        ret=new ASN_set(t,l);
     346                                        break;
     347                                case 18:
     348                                case 19:
     349                                case 20:
     350                                case 21:
     351                                case 22:
     352                                case 25:
     353                                case 26:
     354                                case 27:
     355                                        ret=new ASN_string(t,l);
     356                                        break;
     357                                default:
     358                                        ret=new ASN_data(t,l);
     359                                        break;
     360                        }
    298361                        break;
    299362                default:
     
    334397        asn->feed(buffer,size);
    335398
    336         ASN_data *data= asn->getEncoding();
    337        
    338         data->toString();
    339         data->toString();
     399        while(!asn->eof()) {
     400                ASN_data *data= asn->getEncoding();
     401
     402                data->display();
     403        }
    340404
    341405        return 0;
Note: See TracChangeset for help on using the changeset viewer.