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
31 #include <senf/Packets/Packets.hh>
32 #include "MIHTypes.hh"
34 //#include "TLVParser.mpp"
35 ///////////////////////////////hh.p////////////////////////////////////////
39 struct MIHTLVLengthException : public senf::Exception
41 MIHTLVLengthException()
42 : senf::Exception("MIHTLVLengthException") {}
46 class MIHTLVLengthParser
47 : public detail::packet::IntParserOps<MIHTLVLengthParser, boost::uint32_t>,
48 public PacketParserBase
51 MIHTLVLengthParser(data_iterator i, state_type s) : PacketParserBase(i,s) {}
53 typedef boost::uint32_t value_type;
54 static const size_type init_bytes = 1;
55 static value_type const min_value = 0;
56 static value_type const max_value = 4294967295u;
58 value_type value() const;
59 void value(value_type const & v);
61 MIHTLVLengthParser const & operator= (value_type other);
62 size_type bytes() const;
65 # include SENF_PARSER()
66 SENF_PARSER_PRIVATE_FIELD ( length_field, UInt8Parser );
67 SENF_PARSER_GOTO( length_field );
68 SENF_PARSER_PRIVATE_BITFIELD ( extended_length_flag, 1, bool );
69 SENF_PARSER_PRIVATE_BITFIELD ( underflow_flag, 1, bool );
70 SENF_PARSER_PRIVATE_BITFIELD ( fixed_length_field, 6, unsigned );
73 void capacity(value_type v);
74 value_type capacity() const;
77 void resize_(size_type size);
81 /** \brief Base class for MIH TLV parsers
83 MIHBaseTLVParser is the abstract base class for MIH TLV parsers. It defines the
84 \ref type() field as an \ref senf::UInt8Parser and the \ref length() field as a
85 MIHTLVLengthParser. The length field is read-only.
87 To create your own \c TLVParser you have to inherit from MIHBaseTLVParser (don't
88 forget \ref SENF_PARSER_INHERIT) and define the \c value field. In the following example
89 the value is a vector of MacAddresses:
91 struct MacAddressesTLVParser : public MIHBaseTLVParser {
92 # include SENF_PARSER()
93 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
94 SENF_PARSER_VECTOR ( value, bytes(length), senf::MACAddressParser );
95 SENF_PARSER_FINALIZE( MacAddressesTLVParser );
99 You have to adjust the maximum length value with the \ref maxLength function
100 before the length value is set. The default maximum value is 128. So, in the above
101 example adding more than 21 MACAddresses to the vector will throw a TLVLengthException
102 if you don't call \c maxLength( \e some_value) before.
104 \see MIHTLVLengthParser \n
105 MIHGenericTLVParser \n
107 class MIHBaseTLVParser : public PacketParserBase
110 # include SENF_PARSER()
111 SENF_PARSER_FIELD ( type, UInt8Parser );
112 SENF_PARSER_FIELD_RO ( length, MIHTLVLengthParser );
113 SENF_PARSER_FINALIZE ( MIHBaseTLVParser );
115 /** \brief shrink size of the TLV length field to minimum
117 The size of the length field will be decreased to minimum necessary to hold
118 the current length value.
122 typedef GenericTLVParserRegistry<MIHBaseTLVParser> Registry;
125 /** \brief set maximum value of TLV length field
127 The size of the length field will be increased if necessary.
128 \param v maximum value of length field
130 void maxLength(MIHTLVLengthParser::value_type maxl) const;
135 /** \brief Parser for a generic TLV packet
137 struct MIHGenericTLVParser
138 : public GenericTLVParserBase<MIHBaseTLVParser>
140 typedef senf::GenericTLVParserBase<MIHBaseTLVParser> base;
141 MIHGenericTLVParser(data_iterator i, state_type s) : base(i,s) {}
145 maxLength( MIHTLVLengthParser::max_value);
149 using base::maxLength;
153 /** \brief Base class for list TLV parser
155 struct MIHBaseListTLVParser
156 : public MIHBaseTLVParser
158 # include SENF_PARSER()
159 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
160 SENF_PARSER_FIELD_RO ( listSize, MIHTLVLengthParser );
161 SENF_PARSER_FINALIZE ( MIHBaseListTLVParser );
163 void maxListSize(MIHTLVLengthParser::value_type maxl) const;
166 template <class Self>
167 struct MIHListTLVParserMixin
173 /** \brief Parse a MIHF_ID
175 Note that the maximum length of a MIHF_ID is 253 octets (see F.3.11 in 802.21)
176 We could set maxLength in init(), but for the most MIHF_IDs the default
177 maximum length of 128 should be enough.
179 \note you must call maxIdLength( 253) *before* setting MIHF_IDs values longer
184 class MIHFIdTLVParser : public MIHBaseTLVParser
186 # include SENF_PARSER()
187 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
188 SENF_PARSER_FIELD_RO ( idLength, MIHTLVLengthParser );
189 SENF_PARSER_LABEL ( idValue );
190 SENF_PARSER_SKIP ( idLength(), 0 );
191 SENF_PARSER_FINALIZE ( MIHFIdTLVParser );
194 ///\name Value setters
196 void value( MIHFId const & id);
198 void value( std::string const & id );
199 void value( senf::MACAddress const & addr);
200 void value( senf::INet4Address const & addr);
201 void value( senf::INet6Address const & addr);
202 void value( senf::EUI64 const & addr);
205 ///\name Value getters
207 MIHFId valueAs( MIHFId::Type type) const;
209 std::string valueAsString() const;
210 senf::MACAddress valueAsMACAddress() const;
211 senf::INet4Address valueAsINet4Address() const;
212 senf::INet6Address valueAsINet6Address() const;
213 senf::EUI64 valueAsEUI64() const;
216 ///\name Value comparisons
218 bool valueEquals( MIHFId const & id) const;
220 bool valueEquals( std::string const & id ) const;
221 bool valueEquals( senf::MACAddress const & addr) const;
222 bool valueEquals( senf::INet4Address const & addr) const;
223 bool valueEquals( senf::INet6Address const & addr) const;
224 bool valueEquals( senf::EUI64 const & addr) const;
227 void dump(std::ostream & os) const;
228 void maxIdLength(boost::uint8_t maxl) const;
232 /// resize the packet after the length field to given size
233 senf::safe_data_iterator resizeValueField(MIHTLVLengthParser::value_type size);
235 data_iterator valueBegin() const;
236 data_iterator valueEnd() const;
238 template <class OutputIterator>
239 struct binaryNAIEncoder {
240 binaryNAIEncoder(OutputIterator & i);
241 void operator()(boost::uint8_t v);
245 template <class OutputIterator>
246 static boost::function_output_iterator<binaryNAIEncoder<OutputIterator> >
247 getNAIEncodedOutputIterator(OutputIterator i);
249 struct binaryNAIDecoder {
251 bool operator()(boost::uint8_t v);
255 template <class Iterator>
256 static boost::filter_iterator<binaryNAIDecoder, Iterator>
257 getNAIDecodedIterator(Iterator begin, Iterator end);
259 struct ValueSetterVisitor : public boost::static_visitor<> {
260 MIHFIdTLVParser & parser;
261 ValueSetterVisitor( MIHFIdTLVParser & p) : parser(p) {}
262 void operator()( boost::blank ) const {
263 parser.value( std::string());
265 template <typename MIHFIdType>
266 void operator()( MIHFIdType const & id ) const {
271 struct ValueEqualsVisitor : public boost::static_visitor<bool> {
272 MIHFIdTLVParser const & parser;
273 ValueEqualsVisitor( MIHFIdTLVParser const & p) : parser(p) {}
274 bool operator()( boost::blank ) const {
275 return parser.idLength() == 0;
277 template <typename MIHFIdType>
278 bool operator()( MIHFIdType const & id ) const {
279 return parser.valueEquals( id);
284 /** \brief Parser for 802.21 source MIHF_ID TLV
286 struct MIHFSrcIdTLVParser : public MIHFIdTLVParser
288 MIHFSrcIdTLVParser(data_iterator i, state_type s) : MIHFIdTLVParser(i,s) {}
294 static type_t::value_type const typeId = 1;
295 void dump(std::ostream & os) const;
298 /** \brief Parser for 802.21 destination MIHF_ID TLV
300 struct MIHFDstIdTLVParser : public MIHFIdTLVParser
302 MIHFDstIdTLVParser(data_iterator i, state_type s) : MIHFIdTLVParser(i,s) {}
308 static type_t::value_type const typeId = 2;
309 void dump(std::ostream & os) const;
312 /** \brief Parser for 802.21 Status TLV
314 struct MIHStatusTLVParser : public MIHBaseTLVParser
316 # include SENF_PARSER()
317 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
318 SENF_PARSER_FIELD ( value, UInt8Parser );
319 SENF_PARSER_FINALIZE( MIHStatusTLVParser );
326 static type_t::value_type const typeId = 3;
327 void dump(std::ostream & os) const; ///< dump string representation to given stream
330 Success, UnspecifiedFailure, Rejected, AuthorizationFailure, NetworkError };
333 struct MIHRegisterReqCodeTLVParser : public MIHBaseTLVParser
335 # include SENF_PARSER()
336 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
337 SENF_PARSER_FIELD ( value, UInt8Parser );
338 SENF_PARSER_FINALIZE ( MIHRegisterReqCodeTLVParser );
345 static type_t::value_type const typeId = 11;
346 void dump(std::ostream & os) const; ///< dump string representation to given stream
348 enum RequestCode { Registration, ReRegistration };
351 struct MIHValidTimeIntervalTLVParser : public MIHBaseTLVParser
353 # include SENF_PARSER()
354 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
355 SENF_PARSER_FIELD ( value, UInt32Parser );
356 SENF_PARSER_FINALIZE ( MIHValidTimeIntervalTLVParser );
363 static type_t::value_type const typeId = 12;
364 void dump(std::ostream & os) const; ///< dump string representation to given stream
370 ///////////////////////////////hh.e////////////////////////////////////////
371 #include "TLVParser.cci"
372 #include "TLVParser.ct"
373 #include "TLVParser.cti"
380 // c-file-style: "senf"
381 // indent-tabs-mode: nil
382 // ispell-local-dictionary: "american"
383 // compile-command: "scons -u test"
384 // comment-column: 40