X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=senf%2FPackets%2F80221Bundle%2FTLVParser.cc;h=ce24b1b1c7b84415805975401ad77ca6e2b2fd29;hb=refs%2Fheads%2Fmaster;hp=db7ef8b045997babc3e1b37d5c2f4e32e6683f1c;hpb=33adfa86c0b25cb6eeda0fa12d47e077e488375a;p=senf.git diff --git a/senf/Packets/80221Bundle/TLVParser.cc b/senf/Packets/80221Bundle/TLVParser.cc index db7ef8b..ce24b1b 100644 --- a/senf/Packets/80221Bundle/TLVParser.cc +++ b/senf/Packets/80221Bundle/TLVParser.cc @@ -2,23 +2,28 @@ // // Copyright (C) 2007 // Fraunhofer Institute for Open Communication Systems (FOKUS) -// Competence Center NETwork research (NET), St. Augustin, GERMANY -// Thorsten Horstmann // -// This program is free software; you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation; either version 2 of the License, or -// (at your option) any later version. +// The contents of this file are subject to the Fraunhofer FOKUS Public License +// Version 1.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// http://senf.berlios.de/license.html // -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. +// The Fraunhofer FOKUS Public License Version 1.0 is based on, +// but modifies the Mozilla Public License Version 1.1. +// See the full license text for the amendments. // -// You should have received a copy of the GNU General Public License -// along with this program; if not, write to the -// Free Software Foundation, Inc., -// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// Software distributed under the License is distributed on an "AS IS" basis, +// WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +// for the specific language governing rights and limitations under the License. +// +// The Original Code is Fraunhofer FOKUS code. +// +// The Initial Developer of the Original Code is Fraunhofer-Gesellschaft e.V. +// (registered association), Hansastraße 27 c, 80686 Munich, Germany. +// All Rights Reserved. +// +// Contributor(s): +// Thorsten Horstmann /** \file \brief TLVParser non-inline non-template implementation */ @@ -27,19 +32,52 @@ //#include "TLVParser.ih" // Custom includes -#include #include #include +#include "Exceptions.hh" #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_ void senf::MIHBaseTLVParser::validateType(boost::uint8_t expectedType) + const +{ + if (! check( 1 + senf::bytes(length_()) + length()) ) + 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, MIHLengthParser::value_type expectedLength) + const +{ + validateType( expectedType); + if (length() != expectedLength) + throw InvalidMIHPacketException("invalid length in TLV.") << " Type: " << unsigned(type()) + << ", expected length: " << expectedLength << " got " << length(); +} + +//-///////////////////////////////////////////////////////////////////////////////////////////////// +// senf::MIHBaseListTLVParser + +prefix_ void senf::MIHBaseListTLVParser::maxListSize(MIHLengthParser::value_type maxl) + const +{ + protect(), listSize_().capacity( maxl); + maxLength( maxl + senf::bytes(listSize_())); +} + +//-///////////////////////////////////////////////////////////////////////////////////////////////// // senf::MIHFIdTLVParser prefix_ void senf::MIHFIdTLVParser::dump(std::ostream & os) @@ -56,23 +94,24 @@ prefix_ void senf::MIHFIdTLVParser::dump(std::ostream & os) prefix_ void senf::MIHFIdTLVParser::finalize() { protect(), idLength_().finalize(); - length_() << idLength() + idLength_().bytes(); + length_() << idLength() + senf::bytes(idLength_()); MIHBaseTLVParser::finalize(); } -prefix_ void senf::MIHFIdTLVParser::maxIdLength(boost::uint8_t maxLength) +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 (maxLength > 253) + if (maxl > 253) throw std::length_error("maximum length of a MIHF_ID is 253 octets"); - protect(), idLength_().maxValue( maxLength); - maxLengthValue( maxLength + senf::bytes(idLength_())); + protect(), idLength_().capacity( maxl); + maxLength( maxl + senf::bytes(idLength_())); } 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(); @@ -88,9 +127,9 @@ 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); } @@ -128,7 +167,7 @@ prefix_ senf::MIHFId senf::MIHFIdTLVParser::valueAs(MIHFId::Type type) { if (length() == 0) return MIHFId(); switch (type) { - case MIHFId::Empty: + case MIHFId::MulticastType: return MIHFId(); case MIHFId::MACAddress: return MIHFId( valueAsMACAddress()); @@ -145,7 +184,7 @@ prefix_ senf::MIHFId senf::MIHFIdTLVParser::valueAs(MIHFId::Type type) } -/////////////////////////////////////////////////////////////////////////// +//-///////////////////////////////////////////////////////////////////////////////////////////////// // senf::MIHFSrcIdTLVParser prefix_ void senf::MIHFSrcIdTLVParser::dump(std::ostream & os) @@ -156,7 +195,14 @@ prefix_ void senf::MIHFSrcIdTLVParser::dump(std::ostream & os) MIHFIdTLVParser::dump(os); } -/////////////////////////////////////////////////////////////////////////// +prefix_ void senf::MIHFSrcIdTLVParser::validate() + const +{ + validateType( typeId); +} + + +//-///////////////////////////////////////////////////////////////////////////////////////////////// // senf::MIHFDstIdTLVParser prefix_ void senf::MIHFDstIdTLVParser::dump(std::ostream & os) @@ -167,7 +213,13 @@ prefix_ void senf::MIHFDstIdTLVParser::dump(std::ostream & os) MIHFIdTLVParser::dump(os); } -/////////////////////////////////////////////////////////////////////////// +prefix_ void senf::MIHFDstIdTLVParser::validate() + const +{ + validateType( typeId); +} + +//-///////////////////////////////////////////////////////////////////////////////////////////////// // senf::MIHStatusTLVParser prefix_ void senf::MIHStatusTLVParser::dump(std::ostream & os) @@ -183,7 +235,7 @@ prefix_ void senf::MIHStatusTLVParser::dump(std::ostream & os) case Success: os << " (Success)" << std::endl; return; - case UnspecifiedFailure: + case UnspecifiedFailure: os << " (Unspecified Failure)" << std::endl; return; case Rejected: @@ -199,7 +251,15 @@ prefix_ void senf::MIHStatusTLVParser::dump(std::ostream & os) os << " (???; invalid value!)" << std::endl; } -/////////////////////////////////////////////////////////////////////////// +prefix_ void senf::MIHStatusTLVParser::validate() + const +{ + validateTypeLength( typeId, 1); + if (value() >= 4) + throw InvalidMIHPacketException("invalid value in MIHStatusTLV ") << unsigned( value()); +} + +//-///////////////////////////////////////////////////////////////////////////////////////////////// // senf::MIHRegisterReqCodeTLVParser prefix_ void senf::MIHRegisterReqCodeTLVParser::dump(std::ostream & os) @@ -222,7 +282,15 @@ prefix_ void senf::MIHRegisterReqCodeTLVParser::dump(std::ostream & os) os << " (???; invalid value!)" << std::endl; } -/////////////////////////////////////////////////////////////////////////// +prefix_ void senf::MIHRegisterReqCodeTLVParser::validate() + const +{ + validateTypeLength( typeId, 1); + if (value() >= 2) + throw InvalidMIHPacketException("invalid value in MIHRegisterReqCodeTLV ") << unsigned( value()); +} + +//-///////////////////////////////////////////////////////////////////////////////////////////////// // senf::MIHValidTimeIntervalTLVParser prefix_ void senf::MIHValidTimeIntervalTLVParser::dump(std::ostream & os) @@ -237,10 +305,16 @@ prefix_ void senf::MIHValidTimeIntervalTLVParser::dump(std::ostream & os) << ( value()==0 ? " (infinite)" : " seconds") << std::endl; } -/////////////////////////////////////////////////////////////////////////// -// senf::MIHTLVLengthParser +prefix_ void senf::MIHValidTimeIntervalTLVParser::validate() + const +{ + validateTypeLength( typeId, 4); +} + +//-///////////////////////////////////////////////////////////////////////////////////////////////// +// senf::MIHLengthParser -prefix_ senf::MIHTLVLengthParser::value_type senf::MIHTLVLengthParser::value() const +prefix_ senf::MIHLengthParser::value_type senf::MIHLengthParser::value() const { switch (bytes() ) { case 1: @@ -254,39 +328,39 @@ prefix_ senf::MIHTLVLengthParser::value_type senf::MIHTLVLengthParser::value() c case 5: return parse( 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(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(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(1) = v - (v>128 ? 128 : 0); break; case 5: parse(1) = v - (v>128 ? 128 : 0); break; default: - throw( MIHTLVLengthException()); + throw( MIHLengthException()); }; underflow_flag() = (v <= 128); } -prefix_ senf::MIHTLVLengthParser::value_type senf::MIHTLVLengthParser::maxValue() +prefix_ senf::MIHLengthParser::value_type senf::MIHLengthParser::capacity() const { switch (bytes() ) { @@ -299,25 +373,25 @@ 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()); + 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; + 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(); @@ -340,7 +414,7 @@ prefix_ void senf::MIHTLVLengthParser::finalize() if (b != 5) resize_(5); } -prefix_ void senf::MIHTLVLengthParser::maxValue(MIHTLVLengthParser::value_type v) +prefix_ void senf::MIHLengthParser::capacity(MIHLengthParser::value_type v) { if (v <= 128) return; @@ -360,7 +434,7 @@ prefix_ void senf::MIHTLVLengthParser::maxValue(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); @@ -374,7 +448,7 @@ prefix_ void senf::MIHTLVLengthParser::resize_(size_type size) } -///////////////////////////////cc.e//////////////////////////////////////// +//-///////////////////////////////////////////////////////////////////////////////////////////////// #undef prefix_