X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=senf%2FPackets%2F80221Bundle%2FTLVParser.cc;h=5d6a20c01aa644a2f9513c3e2ebe04466802c8d9;hb=d0c31526ac12869eed085891e3ae13e8b21072e6;hp=8f9d942caa3ed09efcfa366642384cf4541985cc;hpb=482523171f06cf239fd7e8c991f81711c02cf0ba;p=senf.git diff --git a/senf/Packets/80221Bundle/TLVParser.cc b/senf/Packets/80221Bundle/TLVParser.cc index 8f9d942..5d6a20c 100644 --- a/senf/Packets/80221Bundle/TLVParser.cc +++ b/senf/Packets/80221Bundle/TLVParser.cc @@ -27,126 +27,295 @@ //#include "TLVParser.ih" // Custom includes -#include #include +#include +#include #define prefix_ -///////////////////////////////cc.p//////////////////////////////////////// +//-///////////////////////////////////////////////////////////////////////////////////////////////// SENF_PACKET_TLV_REGISTRY_REGISTER( senf::MIHFSrcIdTLVParser ); SENF_PACKET_TLV_REGISTRY_REGISTER( senf::MIHFDstIdTLVParser ); +SENF_PACKET_TLV_REGISTRY_REGISTER( senf::MIHStatusTLVParser ); +SENF_PACKET_TLV_REGISTRY_REGISTER( senf::MIHValidTimeIntervalTLVParser ); -/////////////////////////////////////////////////////////////////////////// +//-///////////////////////////////////////////////////////////////////////////////////////////////// +// MIHBaseTLVParser + +prefix_ std::pair senf::MIHBaseTLVParser::validateTL(boost::uint8_t expectedType, MIHTLVLengthParser::value_type expectedLength) + const +{ + if (! check( 1 + senf::bytes(length_()) + length()) ) + return std::make_pair(false, "truncated TLV. Type: " + senf::str(type())); + if (type() != expectedType) + return std::make_pair(false, "invalid TLV type: " + senf::str(type())); + if (length() != expectedLength) + return std::make_pair(false, "invalid length in TLV. Type: " + senf::str(type())); + return std::make_pair(true, ""); +} + +//-///////////////////////////////////////////////////////////////////////////////////////////////// +// senf::MIHBaseListTLVParser + +prefix_ void senf::MIHBaseListTLVParser::maxListSize(MIHTLVLengthParser::value_type maxl) + const +{ + protect(), listSize_().capacity( maxl); + maxLength( maxl + senf::bytes(listSize_())); +} + + +//-///////////////////////////////////////////////////////////////////////////////////////////////// // senf::MIHFIdTLVParser prefix_ void senf::MIHFIdTLVParser::dump(std::ostream & os) const { - os << senf::fieldName(" type") << unsigned (type()) << "\n" - << senf::fieldName(" length") << unsigned (length()) << "\n" - << " value:\n"; - std::string src_mihfId (asString()); + senf::format::IndentHelper indent; + os << indent << "type: " << unsigned (type()) << std::endl + << indent << "length: " << unsigned (length()) << std::endl + << indent << "value:\n"; + std::string src_mihfId (valueAsString()); hexdump(src_mihfId.begin(), src_mihfId.end(), os); } -prefix_ void senf::MIHFIdTLVParser::setString(std::string const &id) +prefix_ void senf::MIHFIdTLVParser::finalize() +{ + protect(), idLength_().finalize(); + length_() << idLength() + senf::bytes(idLength_()); + MIHBaseTLVParser::finalize(); +} + +prefix_ void senf::MIHFIdTLVParser::maxIdLength(boost::uint8_t maxl) + const +{ + // the maximum length of a MIHF_ID is 253 octets (see F.3.11 in 802.21) + if (maxl > 253) + throw std::length_error("maximum length of a MIHF_ID is 253 octets"); + protect(), idLength_().capacity( maxl); + maxLength( maxl + senf::bytes(idLength_())); +} + +prefix_ senf::safe_data_iterator senf::MIHFIdTLVParser::resizeValueField( + MIHTLVLengthParser::value_type size) +{ + MIHTLVLengthParser::value_type current_length ( idLength()); + idLength_() << size; + length_() << size + idLength_().bytes(); + + safe_data_iterator si (data(), valueBegin()); + if (current_length > size) + data().erase( si, boost::next(si, current_length-size)); + else + data().insert( si, size-current_length, 0); + return si; +} + +prefix_ void senf::MIHFIdTLVParser::value(std::string const & id) { size_type str_size (id.size()); // the maximum length of a MIHF_ID is 253 octets (see F.3.11 in 802.21) - if (str_size > 253) + if (str_size > 253) throw std::length_error("maximum length of a MIHF_ID is 253 octets"); - safe_data_iterator si = resizeValueField( str_size); + safe_data_iterator si = resizeValueField( str_size); std::copy( id.begin(), id.end(), si); } -prefix_ void senf::MIHFIdTLVParser::setMACAddress(senf::MACAddress const &mac) +prefix_ void senf::MIHFIdTLVParser::value(senf::MACAddress const & addr) { - safe_data_iterator si = resizeValueField(12); - std::copy( mac.begin(), mac.end(), getNAIEncodedOutputIterator(si)); + safe_data_iterator si = resizeValueField(6*2); + std::copy( addr.begin(), addr.end(), getNAIEncodedOutputIterator(si)); } -prefix_ void senf::MIHFIdTLVParser::setINet4Address(senf::INet4Address const &addr) +prefix_ void senf::MIHFIdTLVParser::value(senf::INet4Address const & addr) { - safe_data_iterator si = resizeValueField(8); + safe_data_iterator si = resizeValueField(4*2); std::copy( addr.begin(), addr.end(), getNAIEncodedOutputIterator(si)); } -prefix_ void senf::MIHFIdTLVParser::setINet6Address(senf::INet6Address const &addr) +prefix_ void senf::MIHFIdTLVParser::value(senf::INet6Address const & addr) { - safe_data_iterator si = resizeValueField(32); + safe_data_iterator si = resizeValueField(16*2); std::copy( addr.begin(), addr.end(), getNAIEncodedOutputIterator(si)); } -prefix_ void senf::MIHFIdTLVParser::setEUI64(senf::EUI64 const &addr) +prefix_ void senf::MIHFIdTLVParser::value(senf::EUI64 const & addr) { - safe_data_iterator si = resizeValueField(16); + safe_data_iterator si = resizeValueField(8*2); std::copy( addr.begin(), addr.end(), getNAIEncodedOutputIterator(si)); } +prefix_ void senf::MIHFIdTLVParser::value( MIHFId const & id) +{ + boost::apply_visitor( ValueSetterVisitor(*this), id); +} + prefix_ senf::MIHFId senf::MIHFIdTLVParser::valueAs(MIHFId::Type type) const { if (length() == 0) return MIHFId(); switch (type) { - case MIHFId::Empty: + case MIHFId::MulticastType: return MIHFId(); case MIHFId::MACAddress: - return MIHFId( asMACAddress()); + return MIHFId( valueAsMACAddress()); case MIHFId::INet4Address: - return MIHFId( asINet4Address()); + return MIHFId( valueAsINet4Address()); case MIHFId::INet6Address: - return MIHFId( asINet6Address()); + return MIHFId( valueAsINet6Address()); case MIHFId::String: - return MIHFId( asINet6Address()); + return MIHFId( valueAsString()); case MIHFId::EUI64: - return MIHFId( asINet6Address()); + return MIHFId( valueAsEUI64()); } return MIHFId(); } -/////////////////////////////////////////////////////////////////////////// +//-///////////////////////////////////////////////////////////////////////////////////////////////// // senf::MIHFSrcIdTLVParser prefix_ void senf::MIHFSrcIdTLVParser::dump(std::ostream & os) const { - os << " source MIHF_Id TLV:\n"; + senf::format::IndentHelper indent; + os << indent << "source MIHF_Id TLV:\n"; MIHFIdTLVParser::dump(os); } -/////////////////////////////////////////////////////////////////////////// +prefix_ std::pair senf::MIHFSrcIdTLVParser::validate() + const +{ + if (! check( 1 + senf::bytes(length_()) + length()) ) + return std::make_pair(false, "truncated TLV. Type: " + senf::str(type())); + if (type() != typeId) + return std::make_pair(false, "invalid TLV type: " + senf::str(type())); + return std::make_pair(true, ""); +} + + +//-///////////////////////////////////////////////////////////////////////////////////////////////// // senf::MIHFDstIdTLVParser prefix_ void senf::MIHFDstIdTLVParser::dump(std::ostream & os) const { - os << " destination MIHF_Id TLV:\n"; + senf::format::IndentHelper indent; + os << indent << "destination MIHF_Id TLV:\n"; MIHFIdTLVParser::dump(os); } -/////////////////////////////////////////////////////////////////////////// -// MIHBaseTLVParser +prefix_ std::pair senf::MIHFDstIdTLVParser::validate() + const +{ + if (! check( 1 + senf::bytes(length_()) + length()) ) + return std::make_pair(false, "truncated TLV. Type: " + senf::str(type())); + if (type() != typeId) + return std::make_pair(false, "invalid TLV type: " + senf::str(type())); + return std::make_pair(true, ""); +} -prefix_ senf::safe_data_iterator senf::MIHBaseTLVParser::resizeValueField( - MIHTLVLengthParser::value_type size) +//-///////////////////////////////////////////////////////////////////////////////////////////////// +// senf::MIHStatusTLVParser + +prefix_ void senf::MIHStatusTLVParser::dump(std::ostream & os) + const { - MIHTLVLengthParser::value_type current_length ( length()); - length_() << size; + senf::format::IndentHelper indent; + os << indent << "Status TLV:" << std::endl; + indent.increase(); + os << indent << "type: " << unsigned( type()) << std::endl + << indent << "length: " << unsigned( length()) << " byte(s)" << std::endl + << indent << "value: " << unsigned( value()); + switch (value()) { + case Success: + os << " (Success)" << std::endl; + return; + case UnspecifiedFailure: + os << " (Unspecified Failure)" << std::endl; + return; + case Rejected: + os << " (Rejected)" << std::endl; + return; + case AuthorizationFailure: + os << " (Authorization Failure)" << std::endl; + return; + case NetworkError: + os << " (Network Error)" << std::endl; + return; + } + os << " (???; invalid value!)" << std::endl; +} - 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_ std::pair senf::MIHStatusTLVParser::validate() + const +{ + if (! validateTL( typeId, 1).first) + return validateTL( typeId, 1); + if (value() >= 4) + return std::make_pair(false, "invalid value in MIHStatusTLV " + senf::str(value())); + return std::make_pair(true, ""); } +//-///////////////////////////////////////////////////////////////////////////////////////////////// +// senf::MIHRegisterReqCodeTLVParser + +prefix_ void senf::MIHRegisterReqCodeTLVParser::dump(std::ostream & os) + const +{ + senf::format::IndentHelper indent; + os << indent << "Register Request Code TLV:" << std::endl; + indent.increase(); + os << indent << "type: " << unsigned( type()) << std::endl + << indent << "length: " << unsigned( length()) << " byte(s)" << std::endl + << indent << "value: " << unsigned( value()); + switch (value()) { + case Registration: + os << " (Registration)" << std::endl; + return; + case ReRegistration: + os << " (Re-Registration)" << std::endl; + return; + } + os << " (???; invalid value!)" << std::endl; +} + +prefix_ std::pair senf::MIHRegisterReqCodeTLVParser::validate() + const +{ + if (! validateTL( typeId, 1).first) + return validateTL( typeId, 1); + if (value() >= 2) + return std::make_pair(false, "invalid value in MIHRegisterReqCodeTLV " + senf::str(value())); + return std::make_pair(true, ""); +} + +//-///////////////////////////////////////////////////////////////////////////////////////////////// +// senf::MIHValidTimeIntervalTLVParser + +prefix_ void senf::MIHValidTimeIntervalTLVParser::dump(std::ostream & os) + const +{ + senf::format::IndentHelper indent; + os << indent << "Valid Time Interval TLV:" << std::endl; + indent.increase(); + os << indent << "type: " << unsigned( type()) << std::endl + << indent << "length: " << unsigned( length()) << " byte(s)" << std::endl + << indent << "value: " << unsigned( value()) + << ( value()==0 ? " (infinite)" : " seconds") << std::endl; +} + +prefix_ std::pair senf::MIHValidTimeIntervalTLVParser::validate() + const +{ + if (! validateTL( typeId, 4).first) return validateTL( typeId, 4); + return std::make_pair(true, ""); +} -/////////////////////////////////////////////////////////////////////////// +//-///////////////////////////////////////////////////////////////////////////////////////////////// // senf::MIHTLVLengthParser -prefix_ senf::MIHTLVLengthParser::value_type senf::MIHTLVLengthParser::value() const +prefix_ senf::MIHTLVLengthParser::value_type senf::MIHTLVLengthParser::value() const { switch (bytes() ) { case 1: @@ -164,7 +333,7 @@ prefix_ senf::MIHTLVLengthParser::value_type senf::MIHTLVLengthParser::value() c }; } -prefix_ void senf::MIHTLVLengthParser::value(value_type const & v) +prefix_ void senf::MIHTLVLengthParser::value(value_type const & v) { switch (bytes() ) { case 1: @@ -192,7 +361,7 @@ prefix_ void senf::MIHTLVLengthParser::value(value_type const & v) underflow_flag() = (v <= 128); } -prefix_ senf::MIHTLVLengthParser::value_type senf::MIHTLVLengthParser::maxValue() +prefix_ senf::MIHTLVLengthParser::value_type senf::MIHTLVLengthParser::capacity() const { switch (bytes() ) { @@ -205,19 +374,19 @@ prefix_ senf::MIHTLVLengthParser::value_type senf::MIHTLVLengthParser::maxValue( case 4: return UInt24Parser::max_value + 128; case 5: - return UInt32Parser::max_value; + return UInt32Parser::max_value; default: throw( MIHTLVLengthException()); }; } -prefix_ senf::MIHTLVLengthParser const & senf::MIHTLVLengthParser::operator= (value_type other) +prefix_ senf::MIHTLVLengthParser const & senf::MIHTLVLengthParser::operator= (value_type other) { value(other); - return *this; + return *this; } -prefix_ void senf::MIHTLVLengthParser::init() const +prefix_ void senf::MIHTLVLengthParser::init() const { defaultInit(); extended_length_flag() = false; @@ -246,7 +415,7 @@ prefix_ void senf::MIHTLVLengthParser::finalize() if (b != 5) resize_(5); } -prefix_ void senf::MIHTLVLengthParser:: maxValue(MIHTLVLengthParser::value_type v) +prefix_ void senf::MIHTLVLengthParser::capacity(MIHTLVLengthParser::value_type v) { if (v <= 128) return; @@ -280,7 +449,7 @@ prefix_ void senf::MIHTLVLengthParser::resize_(size_type size) } -///////////////////////////////cc.e//////////////////////////////////////// +//-///////////////////////////////////////////////////////////////////////////////////////////////// #undef prefix_