Packets/PacketParser.hh

   1 // Copyright (C) 2007
   2 // Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
   3 // Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
   4 //     Stefan Bund <g0dil@berlios.be>
   5 //
   6 // This program is free software; you can redistribute it and/or modify
   7 // it under the terms of the GNU General Public License as published by
   8 // the Free Software Foundation; either version 2 of the License, or
   9 // (at your option) any later version.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the
  18 // Free Software Foundation, Inc.,
  19 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20
  21 /** \file
  22     \brief PacketParser public header */
  23
  24 /** \defgroup packetparser The PacketParser facility
  25
  26     The PacketParser facility provides a framework to implement very lightweight classes which parse
  27     the raw content of a packet into meaningful values. PacketParsers are always passed around
  28     <em>by value</em>, they can be understood as pointers into the packet data with added type
  29     information providing parsing functions.
  30
  31     Parsers are built hierarchically. A high-level parser will return other parsers when accessing
  32     an element (Example: Asking an EthernetParser for the ethertype field by calling the parsers \c
  33     type() member will return an \c UInt16 parser). The lowest level building blocks then return the
  34     values. This hierarchical structure greatly simplifies building complex parsers.
  35
  36     Since parsers are very lightweight and are passed by value, packet fields are accessed using the
  37     corresponding accessor method:
  38     \code
  39       SomePacket p (...)
  40       SomePacket q (...)
  41
  42       // Assign new value to an integer parser
  43       p->someField() = 10;
  44
  45       // Write out above value
  46       std::cerr << p->someField() << "\n";
  47
  48       // Use the generic parser-assignment operator '<<' to copy field values
  49       p->someVector()[1].someOtherField() << q->someField();
  50       p->someVector() << q->someVector()
  51     \endcode
  52
  53     Here \c someField(), \c someOtherField() and \c someVector() are accessor methods named after
  54     the field name. Each returns a parser object. Simple parsers can be used like their
  55     corresponding basic type (e.g. a Parse_UInt16 field can be used like an unsigned integer), more
  56     complex parsers provide type specific access members. Assigning a value to a parser will change
  57     the underlying representation (the packet data).
  58
  59     More complex parsers (especially those representing a collection of values) provide an
  60     additional wrapper class for mutating access (e.g. Parse_Vector provides a container wrapper
  61     with am STL compatible random-access sequence interface). See the documentation of the specific
  62     parser for the wrapper specification.
  63
  64     Every parser is derived from senf::PacketParserBase. This class provides the necessary
  65     housekeeping information and provides the parsers with access to the data.
  66  */
  67
  68 #ifndef HH_PacketParser_
  69 #define HH_PacketParser_ 1
  70
  71 // Custom includes
  72 #include <boost/utility/enable_if.hpp>
  73 #include <boost/type_traits.hpp>
  74 #include <boost/optional.hpp>
  75 #include "Utils/SafeBool.hh"
  76 #include "PacketTypes.hh"
  77 #define HH_PacketData_DeclOnly
  78 #include "PacketData.hh"
  79 #undef HH_PacketData_DeclOnly
  80
  81 #include "PacketParser.mpp"
  82 ///////////////////////////////hh.p////////////////////////////////////////
  83
  84 namespace senf {
  85
  86     /** \brief Parser Base class
  87
  88         Parsers come in two favors: fixed and dynamically sized parsers. A <em>fixed size
  89         parser</em> has a constant size, it will always parse a fixed number of bytes. The low-level
  90         'final'  parsers (like the integer parsers) are fixed size parsers as are composite parsers
  91         built up only of fixed-size fields.
  92
  93         A <em>dynamically sized</em> parser on the other hand infers it's size from the contents of
  94         the data parsed. Any parser containing at least one dynamically sized sub-parser will itself
  95         be dynamically sized.
  96
  97         Both kinds of parser need to derive from PacketParserBase and implement several required
  98         members. Which members to implement depends on the parsers flavor. There are two ways how to
  99         do this.
 100         \li If the parser just consists of a simple sequence of consecutive fields (sub-parsers),
 101             the \ref SENF_PACKET_PARSER_DEFINE_FIELDS and \ref
 102             SENF_PACKET_PARSER_DEFINE_FIXED_FIELDS macros provide a simple and convenient way to
 103             define the packet
 104         \li In more complex cases, you need to implement the necessary members manually.
 105
 106         This documentation is about the manual implementation. You should nevertheless read through
 107         this to understand, what above macros are doing.
 108
 109         The following example documents the interface (which must be) provided by a parser:
 110         \code
 111           struct FooParser : public PacketParserBase
 112           {
 113               FooParser(data_iterator i, state_type s) : PacketParserBase(i,s) {}
 114
 115               // If this parser has a fixed size, you must define this size here This definition
 116               // allows the parser to be used within the list, vector and array parsers static
 117               static const size_type fixed_bytes = some_constant_size;
 118
 119               // If the parser does not have a fixed size, you must implement the bytes() member to
 120               // return the size. ONLY EVER DEFINE ONE OF fixed_bytes OR bytes().
 121               size_type bytes() const;
 122
 123               // If you define bytes(), you also need to define the init_bytes. This is the number
 124               // of bytes to allocate when creating a new object
 125               static const size_type init_bytes = some_constant_size;
 126
 127               // You also may define an init() member. This will be called to initialize a newly
 128               // created data object. The default implementation just does nothing.
 129               void init() const;
 130
 131               // ////////////////////////////////////////////////////////////////////////
 132
 133               // Add here members returning (sub-)parsers for the fields. The 'parse' member is
 134               // used to construct the sub-parsers. This member either takes an iterator to the
 135               // data to be parsed or just an offset in bytes.
 136
 137               senf::Parse_UInt16 type() const { return parse<Parse_UInt16>( 0 ); }
 138               senf::Parse_UInt16 size() const { return parse<Parse_UInt16>( 2 ); }
 139           };
 140         \endcode
 141
 142         You should never call the \c bytes() member of a parser directly. Instead you should use the
 143         freestanding senf::bytes() function. This function will return the correct size irrespective
 144         of the parsers flavor. You may access \c fixed_bytes directly, however be aware that this
 145         will restrict your code to fixed size parsers (which depending on the circumstances may be
 146         exactly what you want).
 147
 148         In the same way, don't access \c init_bytes directly, always use the senf::init_bytes
 149         meta-function class which correctly supports fixed size parsers.
 150
 151         \ingroup packetparser
 152       */
 153     class PacketParserBase
 154     {
 155     public:
 156         ///////////////////////////////////////////////////////////////////////////
 157         // Types
 158
 159         typedef detail::packet::iterator data_iterator; ///< Raw data iterator type
 160         typedef detail::packet::size_type size_type; ///< Unsigned integral type
 161         typedef detail::packet::difference_type difference_type; ///< Signed integral type
 162         typedef detail::packet::byte byte; ///< Unsigned 8bit value, the raw value type
 163         typedef PacketData * state_type; ///< Type of the 'state' parameter
 164
 165         ///////////////////////////////////////////////////////////////////////////
 166         ///\name Structors and default members
 167         ///@{
 168
 169         // no default constructor
 170         // default copy
 171         // default destructor
 172         // no conversion constructors
 173
 174         ///@}
 175         ///////////////////////////////////////////////////////////////////////////
 176
 177         data_iterator i() const;        ///< Return beginning of data to parse
 178                                         /**< The parser is expected to interpret the data beginning
 179                                              here. The size of the interpreted is given by
 180                                              <tt>senf::bytes(</tt><em>parser
 181                                              instance</em><tt>)</tt>. */
 182         state_type state() const;       ///< Return state of this parser
 183                                         /**< The value returned should be interpreted as an opaque
 184                                              value provided just to be forwarded to other
 185                                              parsers. */
 186         PacketData & data() const;      ///< Access the packets raw data container
 187                                         /**< This member will return the raw data container holding
 188                                              the data which is parsed by \c this parser. */
 189
 190         void init() const;              ///< Default implementation
 191                                         /**< This is just an empty default
 192                                              implementation. Re-implement this member in your own
 193                                              parsers if needed. */
 194
 195     protected:
 196         PacketParserBase(data_iterator i, state_type s); ///< Standard constructor
 197                                         /**< This is the constructor used by most parsers. The
 198                                              parameters are just forwarded from the derived classes
 199                                              constructor parameters. */
 200         PacketParserBase(data_iterator i, state_type s, size_type size);
 201                                         ///< Size checking constructor
 202                                         /**< In addition to the standard constructor, this
 203                                              constructor will validate, that there is enough data in
 204                                              the raw data container to parse \a size bytes after \a
 205                                              i.
 206
 207                                              This constructor is called by all 'final' parsers
 208                                              (e.g. the integer parsers) and \e only by those
 209                                              parsers. Most parsers do \e not check the validity of
 210                                              the iterator, this is delayed until the very last
 211                                              parser. This allows to partial parse truncated
 212                                              packets.
 213
 214                                              \throw TruncatedPacketException if the raw data
 215                                                  container does not hold at least \a size bytes
 216                                                  beginning at \a i. */
 217
 218         bool check(size_type size);     ///< Check size of data container
 219                                         /**< \returns \c true, if the data container holds at least
 220                                              \a size beginning at i(), \c false otherwise. */
 221         void validate(size_type size);  ///< Validate size of data container
 222                                         /**< \throws TruncatedPacketException if the raw data
 223                                              container does not hold at least \a size bytes
 224                                              beginning at i(). */
 225
 226         template <class Parser> Parser parse(data_iterator i) const; ///< Create sub-parser
 227                                         /**< Creates a new instance of \a Parser to parse data
 228                                              beginning at \a i. Automatically passes \a state() to
 229                                              the new parser. */
 230         template <class Parser> Parser parse(size_type n) const; ///< Create sub-parser
 231                                         /**< Creates a new instance of \a Parser to parse data
 232                                          * beginning at i()<tt> + </tt>\a n. Automatically passes \a
 233                                              state() to the new parser. */
 234
 235         void defaultInit() const;       ///< Default implementation
 236                                         /**< This is just an empty default
 237                                              implementation. Re-implement this member in your own
 238                                              parsers if needed. */
 239
 240     private:
 241         data_iterator end();
 242
 243         data_iterator i_;
 244         PacketData * data_;
 245
 246         template <class Parser> friend class SafePacketParser;
 247     };
 248
 249     /** \brief Return raw size parsed by the given parser object
 250
 251         This function will either call <tt>p.bytes()</tt> or return <tt>Parser::fixed_bytes</tt>
 252         depending on the type of parser.
 253
 254         The value returned does \e not take into account the amount of data actually available. So
 255         you always need to validate this value against the packet size if you directly access the
 256         data. The standard low-level parses all do this check automatically to guard against
 257         malformed packets.
 258
 259         \param[in] p Parser object to check
 260         \returns number of bytes this parser expects to parser
 261         \ingroup packetparser
 262      */
 263     template <class Parser>
 264     PacketParserBase::size_type bytes(Parser p);
 265
 266     namespace detail { template <class Parser> class ParserInitBytes; }
 267
 268     /** \brief Return number of bytes to allocate to new object of given type
 269
 270         This meta-function is called like
 271         \code
 272             senf::init_bytes<SomeParser>::value
 273         \endcode
 274
 275         This expression evaluates to a compile-time constant integral expression of type
 276         senf::PacketParserBase::size_type. This meta-function will return \c Parser::fixed_bytes or
 277         \c Parser::init_bytes depending on the type of parser.
 278
 279         \param[in] Parser The Parser to return init_bytes for
 280         \returns Number of bytes to allocate to the new object
 281         \ingroup packetparser
 282      */
 283     template <class Parser>
 284     struct init_bytes : public detail::ParserInitBytes<Parser>
 285     {};
 286
 287     /** \brief Generic parser copying
 288
 289         This operator allows to copy the values of identical parsers. This operation does \e not
 290         depend on the parsers detailed implementation, it will just replace the data bytes of the
 291         target parser with those from the source parser. This allows to easily copy around complex
 292         packet substructures.
 293
 294         This operation is different from the ordinary assignment operator: It does not change the \a
 295         target parser, it changes the data referenced by the \a target parser.
 296
 297         \ingroup packetparser
 298      */
 299     template <class Parser>
 300     typename boost::enable_if<
 301         boost::is_base_of<PacketParserBase, Parser>,
 302         Parser >::type
 303     operator<<(Parser target, Parser source);
 304
 305     /** \brief Generic parser value assignment
 306
 307         This operator allows to assign a value to parsers which implement a <tt>value(</tt>\a
 308         value<tt>)</tt> member. This operator allows to use a common syntax for assigning values or
 309         parsers to a parser.
 310
 311         \ingroup packetparser
 312      */
 313     template <class Parser, class Value>
 314     typename boost::enable_if_c <
 315         boost::is_base_of<PacketParserBase, Parser>::value
 316             && ! boost::is_base_of<PacketParserBase, Value>::value,
 317         Parser >::type
 318     operator<<(Parser target, Value const & value);
 319
 320     /** \defgroup packetparsermacros Helper macros for defining new packet parsers
 321
 322         To simplify the definition of simple packet parsers, several macros are provided. Before
 323         using these macros you should familiarize yourself with the packet parser interface as
 324         described in senf::PacketParserBase.
 325
 326         These macros simplify providing the above defined interface. A typical packet declaration
 327         using these macros has the following form (This is a concrete example from the definition of
 328         the ethernet packet in <tt>DefaultBundle/EthernetPacket.hh</tt>)
 329
 330         \dontinclude EthernetPacket.hh
 331         \skipline struct Parse_EthVLan : public PacketParserBase
 332         \until };
 333
 334         The macros take care of the following:
 335         \li They define the accessor functions returning parsers of the given type.
 336         \li They automatically calculate the offset of the fields from the preceding fields.
 337         \li The macros provide a definition for \c init()
 338         \li The macros define the \c bytes(), \c fixed_bytes and \c init_bytes members as needed.
 339
 340         You may define either a fixed or a dynamically sized parser. Fixed size parsers are defined
 341         using \ref SENF_PACKET_PARSER_DEFINE_FIXED_FIELDS, dynamically sized parsers are defined
 342         using \ref SENF_PACKET_PARSER_DEFINE_FIELDS. The different members are implemented such
 343         that:
 344
 345         \li The needed parser constructor is defined
 346         \li \c init() calls \c defaultInit(). \c defaultInit() is defined to call \c init() on each
 347             of the fields.
 348         \li \c bytes() (on dynamically sized parser) respectively \c fixed_bytes (on fixed size
 349             parsers) is defined to return the sum of the sizes of all fields.
 350         \li On dynamically sized parsers, \c init_bytes is defined to return the sum of the
 351             \c init_size's of all fields
 352
 353         The central definition macros are \ref SENF_PACKET_PARSER_DEFINE_FIXED_FIELDS and \ref
 354         SENF_PACKET_PARSER_DEFINE_FIELDS. The argument to both has the same structure. It is a
 355         (boost preprocessor style) sequence of field definitions where each field definition
 356         provides the builder macro to use and the name and type of the field to define:
 357         \code
 358           SENF_PACKET_PARSER_DEFINE[_FIXED]_FIELDS(
 359               (( <builder> )( <name>, <type> ))
 360               ...
 361           )
 362         \endcode
 363
 364         For each field, this command will define
 365         \li A method \a name() returning an instance of the \a type parser
 366         \li \a name<tt>_t</tt> as a typedef for \a type, the fields value
 367         \li \a name<tt>_offset</tt> to give the offset of the field from the beginning of the
 368             parser. If the parser is a fixed size parser, this will be a static constant, otherwise
 369             it will be a method.
 370
 371         The \a builder argument selects, how the field is defined
 372         \li <tt>Field</tt> defines a field and increments the current position by the size of the
 373             field
 374         \li <tt>OverlayField</tt> defines a field like <tt>Field</tt> but does \e not increment the
 375             position. In the above example, this is used to overlay the different bitfield parsers:
 376             All overlaying bitfield parser except the last one (the one with the highest bit
 377             numbers) is marked as OverlayField.
 378
 379         The \a name argument defines the name of the accessor method.
 380
 381         The \a type argument is the parser to return for that field. Since none of the arguments may
 382         contain a comma, <em>This argument cannot be a multi-parameter template</em>. Always use
 383         typedefs to access templated parsers as shown above.
 384
 385         The \ref SENF_PACKET_PARSER_INIT macro defines the constructor and the \c init() member. If
 386         you want to provide your own \c init() implementation, use \ref
 387         SENF_PACKET_PARSER_NO_INIT. The first statement in your init method should probably to call
 388         \c defaultInit(). This will call the \c init() member of all the fields. Afterwards you can
 389         set up the field values as needed:
 390         \code
 391           struct SomePacket : public senf::PacketParserBase
 392           {
 393               SENF_PACKET_PARSER_NO_INIT(SomePacket);
 394
 395               typedef senf::Parse_UInt8 Parse_Type;
 396               typedef senf::Parse_Vector< senf::Parse_UInt32,
 397                                           senf::SimpleVectorSizer<senf::Parse_UInt16>
 398                                         > Parse_Elements;
 399
 400               SENF_PACKET_PARSER_DEFINE_FIELDS(
 401                   ((Field)( type,     Parse_Type     ))
 402                   ((Field)( elements, Parse_Elements ))
 403               );
 404
 405               void init() const {
 406                   defaultInit();
 407                   type() = 0x01;
 408                   elements().push_back(0x01020304u);
 409               }
 410           }
 411         \endcode
 412
 413         \ingroup packetparser
 414      */
 415
 416     /** \brief Define initialization members of a parser
 417
 418         This macro defines the packet parser constructor and the \c init() member. \c init() is
 419         defined to just call \c defaultInit() which is defined by the other macros to call \c init()
 420         on each of the parsers fields.
 421
 422         \ingroup packetparsermacros
 423         \hideinitializer
 424      */
 425 #   define SENF_PACKET_PARSER_INIT(name)                                                          \
 426     name(data_iterator i, state_type s) : senf::PacketParserBase(i,s) {}                          \
 427     void init() const { defaultInit(); }
 428
 429     /** \brief Define initialization members of a parser except init()
 430
 431         This macro is like SENF_PACKET_PARSER_INIT but does \e not define \c init(). This allows you
 432         to provide your own implementation. You should call \c defaultInit() first before
 433         initializing your data fields.
 434
 435         \ingroup packetparsermacros
 436         \hideinitializer
 437      */
 438 #   define SENF_PACKET_PARSER_NO_INIT(name)                                                       \
 439     name(data_iterator i, state_type s) : senf::PacketParserBase(i,s) {}
 440
 441     /** \brief Define fields for a dynamically sized parser
 442
 443         Define the fields as specified in \a fields. This macro supports dynamically sized
 444         subfields, the resulting parser will be dynamically sized.
 445
 446         \ingroup packetparsermacros
 447         \hideinitializer
 448      */
 449 #   define SENF_PACKET_PARSER_DEFINE_FIELDS(fields)                                               \
 450     SENF_PACKET_PARSER_I_DEFINE_FIELDS(0,fields)
 451
 452     /** \brief Define fields for a dynamically sized parser (with offset)
 453
 454         Define the fields as specified in \a fields. This macro supports dynamically sized
 455         subfields, the resulting parser will be dynamically sized.
 456
 457         The \a offset argument gives the byte offset at which to start parsing the fields. This
 458         helps defining extended parser deriving from a base parser:
 459         \code
 460            struct ExtendedParser : public BaseParser
 461            {
 462                SENF_PACKET_PARSER_NO_INIT(ExtendedParser);
 463
 464                SENF_PACKET_PARSER_DEFINE_FIELDS_OFFSET(senf::bytes(BaseParser(*this)),
 465                  ( ... fields ... ) );
 466
 467                void init() {
 468                    BaseParser::init();
 469                    defaultInit();
 470                    // other init code
 471                }
 472            }
 473         \endcode
 474
 475         \ingroup packetparsermacros
 476         \hideinitializer
 477      */
 478 #   define SENF_PACKET_PARSER_DEFINE_FIELDS_OFFSET(offset,fields)                                 \
 479     SENF_PACKET_PARSER_I_DEFINE_FIELDS(offset,fields)
 480
 481     /** \brief Define fields for a fixed size parser
 482
 483         Define the fields as specified in \a fields. This macro only supports fixed size
 484         subfields, the resulting parser will also be a fixed size parser.
 485
 486         \ingroup packetparsermacros
 487         \hideinitializer
 488      */
 489 #   define SENF_PACKET_PARSER_DEFINE_FIXED_FIELDS(fields)                                         \
 490     SENF_PACKET_PARSER_I_DEFINE_FIXED_FIELDS(0,fields)
 491
 492     /** \brief Define fields for a fixed size parser
 493
 494         Define the fields as specified in \a fields. This macro only supports fixed size
 495         subfields, the resulting parser will also be a fixed size parser.
 496
 497         The \a offset argument gives the byte offset at which to start parsing the fields. This
 498         helps defining extended parser deriving from a base parser:
 499         \code
 500            struct ExtendedParser : public BaseParser
 501            {
 502                SENF_PACKET_PARSER_NO_INIT(ExtendedParser);
 503
 504                SENF_PACKET_PARSER_DEFINE_FIXED_FIELDS_OFFSET(BaseParser::fixed_bytes,
 505                  ( ... fields ... ) );
 506
 507                void init() {
 508                    BaseParser::init();
 509                    defaultInit();
 510                    // other init code
 511                }
 512            }
 513         \endcode
 514
 515         \ingroup packetparsermacros
 516         \hideinitializer
 517      */
 518 #   define SENF_PACKET_PARSER_DEFINE_FIXED_FIELDS_OFFSET(offset,fields)                           \
 519     SENF_PACKET_PARSER_I_DEFINE_FIXED_FIELDS(offset,fields)
 520
 521     struct VoidPacketParser
 522         : public PacketParserBase
 523     {
 524         SENF_PACKET_PARSER_INIT(VoidPacketParser);
 525     };
 526
 527     /** \brief Iterator re-validating Parser wrapper
 528
 529         An ordinary parser will be invalidated whenever the raw data container's size is
 530         changed. This can complicate some algorithms considerably.
 531
 532         This wrapper will update the parsers iterator (the value returned by the i() member) on
 533         every access. This ensures that the iterator will stay valid.
 534
 535         \attention Beware however, if you insert or remove data before the safe wrapper, the
 536             location will \e not be updated accordingly and therefore the parser will be
 537             invalid.
 538
 539         Additionally a SafePacketparser has an uninitialized state. The only allowed operations in
 540         this state are the boolean test for validity and assigning another parser.
 541       */
 542     template <class Parser>
 543     class SafePacketParser
 544         : public SafeBool< SafePacketParser<Parser> >
 545     {
 546     public:
 547         ///////////////////////////////////////////////////////////////////////////
 548         // Types
 549
 550         ///////////////////////////////////////////////////////////////////////////
 551         ///\name Structors and default members
 552         ///@{
 553
 554         // default copy constructor
 555         // default copy assignment
 556         // default destructor
 557         SafePacketParser();             ///< Create an empty uninitialized SafePacketParser
 558
 559         // conversion constructors
 560         SafePacketParser(Parser parser); ///< Initialize SafePacketParser from \a parser
 561
 562         SafePacketParser & operator=(Parser parser); ///< Assign \a parser to \c this
 563
 564         ///@}
 565         ///////////////////////////////////////////////////////////////////////////
 566
 567         Parser operator*() const;       ///< Access the stored parser
 568                                         /**< On every access, the stored parsers iterator will be
 569                                              updated / re-validated. */
 570         Parser const * operator->() const; ///< Access the stored parser
 571                                         /**< On every access, the stored parsers iterator will be
 572                                              updated / re-validated. */
 573         bool boolean_test() const;      ///< Check validity
 574
 575     protected:
 576
 577     private:
 578         mutable boost::optional<Parser> parser_;
 579         senf::safe_data_iterator i_;
 580     };
 581
 582 }
 583
 584 ///////////////////////////////hh.e////////////////////////////////////////
 585 #include "PacketParser.cci"
 586 #include "PacketParser.ct"
 587 #include "PacketParser.cti"
 588 #endif
 589
 590 \f
 591 // Local Variables:
 592 // mode: c++
 593 // fill-column: 100
 594 // c-file-style: "senf"
 595 // indent-tabs-mode: nil
 596 // ispell-local-dictionary: "american"
 597 // compile-command: "scons -u test"
 598 // comment-column: 40
 599 // End:
 600
 601 //  LocalWords:  templated PacketParser defgroup packetparser PacketParsers li
 602 //  LocalWords:  EthernetParser ethertype UInt senf PacketParserBase tt
 603 //  LocalWords:  struct FooParser const init endcode ingroup param SomeParser
 604 //  LocalWords:  ethernet DefaultBundle EthernetPacket hh EthVLan UIntField CFI
 605 //  LocalWords:  VLanId OverlayField cfi vlanId accessor defaultInit bitfield
 606 //  LocalWords:  SomePacket SimpleVectorSizer packetparsermacros Fraunhofer std
 607 //  LocalWords:  hideinitializer Institut fuer offene Kommunikationssysteme STL
 608 //  LocalWords:  FOKUS Kompetenzzentrum Satelitenkommunikation SatCom Bund cerr
 609 //  LocalWords:  berlios dil Structors someField someVector someOtherField
 610 //  LocalWords:  TruncatedPacketException