4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
6 // Thorsten Horstmann <tho@berlios.de>
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 2 of the License, or
11 // (at your option) any later version.
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the
20 // Free Software Foundation, Inc.,
21 // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24 \brief TLVParser public header */
26 #ifndef HH_SENF_Packets_80221Bundle_TLVParser_
27 #define HH_SENF_Packets_80221Bundle_TLVParser_ 1
30 #include <senf/Packets/Packets.hh>
31 #include "MIHTypes.hh"
33 //#include "TLVParser.mpp"
34 //-/////////////////////////////////////////////////////////////////////////////////////////////////
38 struct MIHTLVLengthException : public senf::Exception
40 MIHTLVLengthException()
41 : senf::Exception("MIHTLVLengthException") {}
45 class MIHTLVLengthParser
46 : public detail::packet::IntParserOps<MIHTLVLengthParser, boost::uint32_t>,
47 public PacketParserBase
50 MIHTLVLengthParser(data_iterator i, state_type s) : PacketParserBase(i,s) {}
52 typedef boost::uint32_t value_type;
53 static const size_type init_bytes = 1;
54 static value_type const min_value = 0;
55 static value_type const max_value = 4294967295u;
57 value_type value() const;
58 void value(value_type const & v);
60 MIHTLVLengthParser const & operator= (value_type other);
61 size_type bytes() const;
64 # include SENF_PARSER()
65 SENF_PARSER_PRIVATE_FIELD ( length_field, UInt8Parser );
66 SENF_PARSER_GOTO( length_field );
67 SENF_PARSER_PRIVATE_BITFIELD ( extended_length_flag, 1, bool );
68 SENF_PARSER_PRIVATE_BITFIELD ( underflow_flag, 1, bool );
69 SENF_PARSER_PRIVATE_BITFIELD ( fixed_length_field, 6, unsigned );
72 void capacity(value_type v);
73 value_type capacity() const;
76 void resize_(size_type size);
80 /** \brief Base class for MIH TLV parsers
82 MIHBaseTLVParser is the abstract base class for MIH TLV parsers. It defines the
83 \ref type() field as an \ref senf::UInt8Parser and the \ref length() field as a
84 MIHTLVLengthParser. The length field is read-only.
86 To create your own \c TLVParser you have to inherit from MIHBaseTLVParser (don't
87 forget \ref SENF_PARSER_INHERIT) and define the \c value field. In the following example
88 the value is a vector of MacAddresses:
90 struct MacAddressesTLVParser : public MIHBaseTLVParser {
91 # include SENF_PARSER()
92 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
93 SENF_PARSER_VECTOR ( value, bytes(length), senf::MACAddressParser );
94 SENF_PARSER_FINALIZE( MacAddressesTLVParser );
98 You have to adjust the maximum length value with the \ref maxLength function
99 before the length value is set. The default maximum value is 128. So, in the above
100 example adding more than 21 MACAddresses to the vector will throw a TLVLengthException
101 if you don't call \c maxLength( \e some_value) before.
103 \see MIHTLVLengthParser \n
104 MIHGenericTLVParser \n
106 class MIHBaseTLVParser : public PacketParserBase
109 # include SENF_PARSER()
110 SENF_PARSER_FIELD ( type, UInt8Parser );
111 SENF_PARSER_FIELD_RO ( length, MIHTLVLengthParser );
112 SENF_PARSER_FINALIZE ( MIHBaseTLVParser );
114 /** \brief shrink size of the TLV length field to minimum
116 The size of the length field will be decreased to minimum necessary to hold
117 the current length value.
121 typedef GenericTLVParserRegistry<MIHBaseTLVParser> Registry;
124 /** \brief set maximum value of TLV length field
126 The size of the length field will be increased if necessary.
127 \param v maximum value of length field
129 void maxLength(MIHTLVLengthParser::value_type maxl) const;
131 std::pair<bool, std::string> validateTL(boost::uint8_t type, MIHTLVLengthParser::value_type length) const;
136 /** \brief Parser for a generic TLV packet
138 struct MIHGenericTLVParser
139 : public GenericTLVParserBase<MIHBaseTLVParser>
141 typedef senf::GenericTLVParserBase<MIHBaseTLVParser> base;
142 MIHGenericTLVParser(data_iterator i, state_type s) : base(i,s) {}
146 maxLength( MIHTLVLengthParser::max_value);
150 using base::maxLength;
154 /** \brief Base class for list TLV parser
156 struct MIHBaseListTLVParser
157 : public MIHBaseTLVParser
159 # include SENF_PARSER()
160 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
161 SENF_PARSER_FIELD_RO ( listSize, MIHTLVLengthParser );
162 SENF_PARSER_FINALIZE ( MIHBaseListTLVParser );
164 void maxListSize(MIHTLVLengthParser::value_type maxl) const;
167 template <class Self>
168 struct MIHListTLVParserMixin
174 /** \brief Parse a MIHF_ID
176 Note that the maximum length of a MIHF_ID is 253 octets (see F.3.11 in 802.21)
177 We could set maxLength in init(), but for the most MIHF_IDs the default
178 maximum length of 128 should be enough.
180 \note you must call maxIdLength( 253) *before* setting MIHF_IDs values longer
185 class MIHFIdTLVParser : public MIHBaseTLVParser
187 # include SENF_PARSER()
188 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
189 SENF_PARSER_FIELD_RO ( idLength, MIHTLVLengthParser );
190 SENF_PARSER_LABEL ( idValue );
191 SENF_PARSER_SKIP ( idLength(), 0 );
192 SENF_PARSER_FINALIZE ( MIHFIdTLVParser );
195 ///\name Value setters
197 void value( MIHFId const & id);
199 void value( std::string const & id );
200 void value( senf::MACAddress const & addr);
201 void value( senf::INet4Address const & addr);
202 void value( senf::INet6Address const & addr);
203 void value( senf::EUI64 const & addr);
206 ///\name Value getters
208 MIHFId valueAs( MIHFId::Type type) const;
210 std::string valueAsString() const;
211 senf::MACAddress valueAsMACAddress() const;
212 senf::INet4Address valueAsINet4Address() const;
213 senf::INet6Address valueAsINet6Address() const;
214 senf::EUI64 valueAsEUI64() const;
217 ///\name Value comparisons
219 bool valueEquals( MIHFId const & id) const;
221 bool valueEquals( std::string const & id ) const;
222 bool valueEquals( senf::MACAddress const & addr) const;
223 bool valueEquals( senf::INet4Address const & addr) const;
224 bool valueEquals( senf::INet6Address const & addr) const;
225 bool valueEquals( senf::EUI64 const & addr) const;
228 void dump(std::ostream & os) const;
229 void maxIdLength(boost::uint8_t maxl) const;
233 /// resize the packet after the length field to given size
234 senf::safe_data_iterator resizeValueField(MIHTLVLengthParser::value_type size);
236 data_iterator valueBegin() const;
237 data_iterator valueEnd() const;
239 template <class OutputIterator>
240 struct binaryNAIEncoder {
241 binaryNAIEncoder(OutputIterator & i);
242 void operator()(boost::uint8_t v);
246 template <class OutputIterator>
247 static boost::function_output_iterator<binaryNAIEncoder<OutputIterator> >
248 getNAIEncodedOutputIterator(OutputIterator i);
250 struct binaryNAIDecoder {
252 bool operator()(boost::uint8_t v);
256 template <class Iterator>
257 static boost::filter_iterator<binaryNAIDecoder, Iterator>
258 getNAIDecodedIterator(Iterator begin, Iterator end);
260 struct ValueSetterVisitor : public boost::static_visitor<> {
261 MIHFIdTLVParser & parser;
262 ValueSetterVisitor( MIHFIdTLVParser & p) : parser(p) {}
263 void operator()( boost::blank ) const {
264 parser.value( std::string());
266 template <typename MIHFIdType>
267 void operator()( MIHFIdType const & id ) const {
272 struct ValueEqualsVisitor : public boost::static_visitor<bool> {
273 MIHFIdTLVParser const & parser;
274 ValueEqualsVisitor( MIHFIdTLVParser const & p) : parser(p) {}
275 bool operator()( boost::blank ) const {
276 return parser.idLength() == 0;
278 template <typename MIHFIdType>
279 bool operator()( MIHFIdType const & id ) const {
280 return parser.valueEquals( id);
285 /** \brief Parser for 802.21 source MIHF_ID TLV
287 struct MIHFSrcIdTLVParser : public MIHFIdTLVParser
289 MIHFSrcIdTLVParser(data_iterator i, state_type s) : MIHFIdTLVParser(i,s) {}
295 static type_t::value_type const typeId = 1;
296 void dump(std::ostream & os) const;
297 std::pair<bool, std::string> validate() const;
300 /** \brief Parser for 802.21 destination MIHF_ID TLV
302 struct MIHFDstIdTLVParser : public MIHFIdTLVParser
304 MIHFDstIdTLVParser(data_iterator i, state_type s) : MIHFIdTLVParser(i,s) {}
310 static type_t::value_type const typeId = 2;
311 void dump(std::ostream & os) const;
312 std::pair<bool, std::string> validate() const;
315 /** \brief Parser for 802.21 Status TLV
317 struct MIHStatusTLVParser : public MIHBaseTLVParser
319 # include SENF_PARSER()
320 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
321 SENF_PARSER_FIELD ( value, UInt8Parser );
322 SENF_PARSER_FINALIZE( MIHStatusTLVParser );
329 static type_t::value_type const typeId = 3;
330 void dump(std::ostream & os) const; ///< dump string representation to given stream
331 std::pair<bool, std::string> validate() const;
334 Success, UnspecifiedFailure, Rejected, AuthorizationFailure, NetworkError };
337 struct MIHRegisterReqCodeTLVParser : public MIHBaseTLVParser
339 # include SENF_PARSER()
340 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
341 SENF_PARSER_FIELD ( value, UInt8Parser );
342 SENF_PARSER_FINALIZE ( MIHRegisterReqCodeTLVParser );
349 static type_t::value_type const typeId = 11;
350 void dump(std::ostream & os) const; ///< dump string representation to given stream
351 std::pair<bool, std::string> validate() const;
353 enum RequestCode { Registration, ReRegistration };
356 struct MIHValidTimeIntervalTLVParser : public MIHBaseTLVParser
358 # include SENF_PARSER()
359 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
360 SENF_PARSER_FIELD ( value, UInt32Parser );
361 SENF_PARSER_FINALIZE ( MIHValidTimeIntervalTLVParser );
368 static type_t::value_type const typeId = 12;
369 void dump(std::ostream & os) const; ///< dump string representation to given stream
370 std::pair<bool, std::string> validate() const;
376 //-/////////////////////////////////////////////////////////////////////////////////////////////////
377 #include "TLVParser.cci"
378 #include "TLVParser.ct"
379 #include "TLVParser.cti"
386 // c-file-style: "senf"
387 // indent-tabs-mode: nil
388 // ispell-local-dictionary: "american"
389 // compile-command: "scons -u test"
390 // comment-column: 40