X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=senf%2FPackets%2F80221Bundle%2FTLVParser.cc;h=ce24b1b1c7b84415805975401ad77ca6e2b2fd29;hb=refs%2Fheads%2Fmaster;hp=ddc3340f55455468682c80af4e3745ae0e7b41e4;hpb=ab7ff164ab5ae711ec09ce2b24228510f1ffdcff;p=senf.git

diff --git a/senf/Packets/80221Bundle/TLVParser.cc b/senf/Packets/80221Bundle/TLVParser.cc
index ddc3340..ce24b1b 100644
--- a/senf/Packets/80221Bundle/TLVParser.cc
+++ b/senf/Packets/80221Bundle/TLVParser.cc
@@ -51,23 +51,26 @@ prefix_ void senf::MIHBaseTLVParser::validateType(boost::uint8_t expectedType)
     const
 {
     if (! check( 1 + senf::bytes(length_()) + length()) )
-        throw InvalidMIHPacketException("truncated TLV.") << " Type: " << unsigned(type());
+        throw InvalidMIHPacketException("truncated TLV.") << " Type: " << unsigned(type())
+            << ", size:" << 1 + senf::bytes(length_()) + length()
+            << ", available: " << std::distance(i(), data().end());
     if (type() != expectedType)
         throw InvalidMIHPacketException("wrong TLV type. expected ") << unsigned(expectedType) << " got " << unsigned(type());
 }
 
-prefix_ void senf::MIHBaseTLVParser::validateTypeLength(boost::uint8_t expectedType, MIHTLVLengthParser::value_type expectedLength)
+prefix_ void senf::MIHBaseTLVParser::validateTypeLength(boost::uint8_t expectedType, MIHLengthParser::value_type expectedLength)
     const
 {
     validateType( expectedType);
     if (length() != expectedLength)
-        throw InvalidMIHPacketException("invalid length in TLV.") << " Type: " << unsigned(type());
+        throw InvalidMIHPacketException("invalid length in TLV.") << " Type: " << unsigned(type())
+                << ", expected length: " << expectedLength << " got " << length();
 }
 
 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 // senf::MIHBaseListTLVParser
 
-prefix_ void senf::MIHBaseListTLVParser::maxListSize(MIHTLVLengthParser::value_type maxl)
+prefix_ void senf::MIHBaseListTLVParser::maxListSize(MIHLengthParser::value_type maxl)
     const
 {
     protect(), listSize_().capacity( maxl);
@@ -106,9 +109,9 @@ prefix_ void senf::MIHFIdTLVParser::maxIdLength(boost::uint8_t maxl)
 }
 
 prefix_ senf::safe_data_iterator senf::MIHFIdTLVParser::resizeValueField(
-        MIHTLVLengthParser::value_type size)
+        MIHLengthParser::value_type size)
 {
-    MIHTLVLengthParser::value_type current_length ( idLength());
+    MIHLengthParser::value_type current_length ( idLength());
     idLength_() << size;
     length_() << size + idLength_().bytes();
 
@@ -309,9 +312,9 @@ prefix_ void senf::MIHValidTimeIntervalTLVParser::validate()
 }
 
 //-/////////////////////////////////////////////////////////////////////////////////////////////////
-// senf::MIHTLVLengthParser
+// senf::MIHLengthParser
 
-prefix_ senf::MIHTLVLengthParser::value_type senf::MIHTLVLengthParser::value() const
+prefix_ senf::MIHLengthParser::value_type senf::MIHLengthParser::value() const
 {
     switch (bytes() ) {
     case 1:
@@ -325,39 +328,39 @@ prefix_ senf::MIHTLVLengthParser::value_type senf::MIHTLVLengthParser::value() c
     case 5:
         return parse<UInt32Parser>( 1 ).value() + (underflow_flag() ? 0 : 128u);
     default:
-        throw( MIHTLVLengthException());
+        throw( MIHLengthException());
     };
 }
 
-prefix_ void senf::MIHTLVLengthParser::value(value_type const & v)
+prefix_ void senf::MIHLengthParser::value(value_type v)
 {
     switch (bytes() ) {
     case 1:
-        if (v > 128) throw( MIHTLVLengthException());
+        if (v > 128) throw( MIHLengthException());
         length_field() = v;
         return;
     case 2:
-        if (v > UInt8Parser::max_value + 128) throw( MIHTLVLengthException());
+        if (v > UInt8Parser::max_value + 128) throw( MIHLengthException());
         parse<UInt8Parser>(1) = v - (v>128 ? 128 : 0);
         break;
     case 3:
-        if (v > UInt16Parser::max_value + 128) throw( MIHTLVLengthException());
+        if (v > UInt16Parser::max_value + 128) throw( MIHLengthException());
         parse<UInt16Parser>(1) = v - (v>128 ? 128 : 0);
         break;;
     case 4:
-        if (v > UInt24Parser::max_value + 128) throw( MIHTLVLengthException());
+        if (v > UInt24Parser::max_value + 128) throw( MIHLengthException());
         parse<UInt24Parser>(1) = v - (v>128 ? 128 : 0);
         break;
     case 5:
         parse<UInt32Parser>(1) = v - (v>128 ? 128 : 0);
         break;
     default:
-        throw( MIHTLVLengthException());
+        throw( MIHLengthException());
     };
     underflow_flag() = (v <= 128);
 }
 
-prefix_ senf::MIHTLVLengthParser::value_type senf::MIHTLVLengthParser::capacity()
+prefix_ senf::MIHLengthParser::value_type senf::MIHLengthParser::capacity()
     const
 {
     switch (bytes() ) {
@@ -372,23 +375,23 @@ prefix_ senf::MIHTLVLengthParser::value_type senf::MIHTLVLengthParser::capacity(
     case 5:
         return UInt32Parser::max_value;
     default:
-        throw( MIHTLVLengthException());
+        throw( MIHLengthException());
     };
 }
 
-prefix_ senf::MIHTLVLengthParser const & senf::MIHTLVLengthParser::operator= (value_type other)
+prefix_ senf::MIHLengthParser const & senf::MIHLengthParser::operator= (value_type other)
 {
     value(other);
     return *this;
 }
 
-prefix_ void senf::MIHTLVLengthParser::init() const
+prefix_ void senf::MIHLengthParser::init() const
 {
     defaultInit();
     extended_length_flag() = false;
 }
 
-prefix_ void senf::MIHTLVLengthParser::finalize()
+prefix_ void senf::MIHLengthParser::finalize()
 {
     value_type v = value();
     size_type b = bytes();
@@ -411,7 +414,7 @@ prefix_ void senf::MIHTLVLengthParser::finalize()
     if (b != 5) resize_(5);
 }
 
-prefix_ void senf::MIHTLVLengthParser::capacity(MIHTLVLengthParser::value_type v)
+prefix_ void senf::MIHLengthParser::capacity(MIHLengthParser::value_type v)
 {
     if (v <= 128)
         return;
@@ -431,7 +434,7 @@ prefix_ void senf::MIHTLVLengthParser::capacity(MIHTLVLengthParser::value_type v
     if (b < 5) resize_(5);
 }
 
-prefix_ void senf::MIHTLVLengthParser::resize_(size_type size)
+prefix_ void senf::MIHLengthParser::resize_(size_type size)
 {
     value_type v = value();
     resize(bytes(), size);