// Custom includes
#include <iomanip>
-#include <senf/Utils/hexdump.hh>
+#include "../../Utils/hexdump.hh"
#define prefix_
///////////////////////////////cc.p////////////////////////////////////////
+prefix_ senf::safe_data_iterator senf::BaseTLVPacketParser::resizeValue(
+ DynamicTLVLengthParser::value_type size)
+{
+ DynamicTLVLengthParser::value_type current_length ( length());
+ length( size);
+
+ safe_data_iterator si (data(), boost::next(i(), 1 + length_bytes() ));
+ if (current_length > size)
+ data().erase( si, boost::next(si, current_length-size));
+ else
+ data().insert( si, size-current_length, 0);
+ return si;
+}
+
+
prefix_ senf::DynamicTLVLengthParser::value_type senf::DynamicTLVLengthParser::value() const
{
switch (bytes() ) {
case 5:
return parse<UInt32Parser>( 1 ).value();
default:
- throw(UnsuportedTLVPacketException());
+ throw(TLVLengthException());
};
}
+
prefix_ void senf::DynamicTLVLengthParser::value(value_type const & v)
{
- SafePacketParserWrapper<DynamicTLVLengthParser> safeThis (*this);
- if (v < 128u) {
- if (bytes() != 1)
- resize(1, safeThis);
- safeThis->fixed_length_field() = v;
+ switch (bytes() ) {
+ case 1:
+ if (v > 127) throw( TLVLengthException());
+ fixed_length_field() = v;
return;
- }
- if (v <= UInt8Parser::max_value) {
- if (bytes() != 2)
- resize(2, safeThis);
- safeThis->parse<UInt8Parser>(1) = v;
+ case 2:
+ if (v > UInt8Parser::max_value) throw( TLVLengthException());
+ parse<UInt8Parser>(1) = v;
return;
- }
- if (v <= UInt16Parser::max_value) {
- if (bytes() != 3)
- resize(3, safeThis);
- safeThis->parse<UInt16Parser>(1) = v;
+ case 3:
+ if (v > UInt16Parser::max_value) throw( TLVLengthException());
+ parse<UInt16Parser>(1) = v;
return;
- }
- if (v <= UInt24Parser::max_value) {
- if (bytes() != 4)
- resize(4, safeThis);
- safeThis->parse<UInt24Parser>(1) = v;
+ case 4:
+ if (v > UInt24Parser::max_value) throw( TLVLengthException());
+ parse<UInt24Parser>(1) = v;
return;
- }
- if (v <= UInt32Parser::max_value) {
- if (bytes() != 5)
- resize(5, safeThis);
- safeThis->parse<UInt32Parser>(1) = v;
+ case 5:
+ parse<UInt32Parser>(1) = v;
return;
- }
- throw(UnsuportedTLVPacketException());
+ default:
+ throw( TLVLengthException());
+ };
}
+
prefix_ senf::DynamicTLVLengthParser const & senf::DynamicTLVLengthParser::operator= (value_type other)
{
value(other);
return *this;
}
+
prefix_ senf::DynamicTLVLengthParser::size_type senf::DynamicTLVLengthParser::bytes() const
{
if ( extended_length_flag() )
return 1;
}
+
prefix_ void senf::DynamicTLVLengthParser::init() const
{
defaultInit();
- extended_length_flag() = 0;
+ extended_length_flag() = false;
+}
+
+
+prefix_ void senf::DynamicTLVLengthParser::shrink()
+{
+ value_type v = value();
+ size_type b = bytes();
+ if (v <= 127) {
+ if (b != 1) resize(1);
+ return;
+ }
+ if (v <= UInt8Parser::max_value) {
+ if (b != 2) resize(2);
+ return;
+ }
+ if (v <= UInt16Parser::max_value) {
+ if (b != 3) resize(3);
+ return;
+ }
+ if (v <= UInt24Parser::max_value) {
+ if (b != 4) resize(4);
+ return;
+ }
+ if (b != 5) resize(5);
}
-prefix_ void senf::DynamicTLVLengthParser::resize(
- size_type size, SafePacketParserWrapper<DynamicTLVLengthParser> &safeThis)
+
+prefix_ void senf::DynamicTLVLengthParser:: maxValue(DynamicTLVLengthParser::value_type v)
+{
+ if (v <= 127)
+ return;
+ size_type b = bytes();
+ if (v <= UInt8Parser::max_value) {
+ if (b < 2) resize(2);
+ return;
+ }
+ if (v <= UInt16Parser::max_value) {
+ if (b < 3) resize(3);
+ return;
+ }
+ if (v <= UInt24Parser::max_value) {
+ if (b < 4) resize(4);
+ return;
+ }
+ if (b < 5) resize(5);
+}
+
+
+prefix_ void senf::DynamicTLVLengthParser::resize(size_type size)
{
- std::cout << "DynamicTLVLengthParser::resize " << unsigned( size) << "\n";
+ value_type v = value();
+ size_type current_size (bytes());
+ SafePacketParserWrapper<DynamicTLVLengthParser> safeThis (*this);
+
+ if (current_size > size)
+ data().erase( i(), boost::next(i(), current_size-size));
+ else
+ data().insert( i(), size-current_size, 0);
+
if (size > 1) {
safeThis->extended_length_flag() = true;
safeThis->fixed_length_field() = size - 1;
} else {
safeThis->extended_length_flag() = false;
}
-
- size_type current_size (bytes());
- safe_data_iterator si (data(), i());
-
- if (current_size > size)
- data().erase( si, boost::next(si, current_size-size));
- else
- data().insert( si, size-current_size, 0);
+ safeThis->value(v);
+}
+
+
+prefix_ senf::PacketInterpreterBase::range senf::GenericTLVPacketParser::value()
+ const
+{
+ senf::PacketData::iterator begin (boost::next(data().begin(), 1 + length_bytes() ));
+ return PacketInterpreterBase::range(
+ begin, boost::next( begin, length()) );
}
+
prefix_ void senf::GenericTLVPacketType::dump(packet p, std::ostream & os)
{
boost::io::ios_all_saver ias(os);
os << "GenericTLVPacket:\n"
<< std::dec
<< " type: " << unsigned( p->type()) << "\n"
- << " length: " << unsigned( p->length()) << "\n";
+ << " length: " << unsigned( p->length()) << "\n"
+ << " value\n:";
+ senf::hexdump( p->value().begin(), p->value().end(), os);
}
-//prefix_ void senf::GenericTLVPacketType::finalize(packet p)
-//{
-// try {
-// PacketData::size_type size = p.next().data().size();
-// if ( size > DynamicTLVLengthParser::max_value )
-// throw(UnsuportedTLVPacketException());
-// p->length() = size;
-// }
-// catch (InvalidPacketChainException & ex) {
-// ;
-// }
-//}
-
-
-//template <class TypeParser, class LengthParser>
-//prefix_ senf::PacketInterpreterBase::optional_range
-//senf::TLVPacketType<TypeParser, LengthParser>::nextPacketRange(packet p)
-//{
-// if (p.data().size() < 5)
-// return no_range();
-// return range(
-// boost::next(p.data().begin(), 4 + senf::bytes(p->length()) ),
-// p.data().end() );
-//}
+
+prefix_ void senf::GenericTLVPacketType::finalize(packet p)
+{
+ p->shrinkLength();
+}
///////////////////////////////cc.e////////////////////////////////////////
projects / senf.git / blobdiff