4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
6 // The contents of this file are subject to the Fraunhofer FOKUS Public License
7 // Version 1.0 (the "License"); you may not use this file except in compliance
8 // with the License. You may obtain a copy of the License at
9 // http://senf.berlios.de/license.html
11 // The Fraunhofer FOKUS Public License Version 1.0 is based on,
12 // but modifies the Mozilla Public License Version 1.1.
13 // See the full license text for the amendments.
15 // Software distributed under the License is distributed on an "AS IS" basis,
16 // WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
17 // for the specific language governing rights and limitations under the License.
19 // The Original Code is Fraunhofer FOKUS code.
21 // The Initial Developer of the Original Code is Fraunhofer-Gesellschaft e.V.
22 // (registered association), Hansastraße 27 c, 80686 Munich, Germany.
23 // All Rights Reserved.
26 // Thorsten Horstmann <tho@berlios.de>
29 \brief TLVParser public header */
31 #ifndef HH_SENF_Packets_80221Bundle_TLVParser_
32 #define HH_SENF_Packets_80221Bundle_TLVParser_ 1
35 #include <senf/Packets/Packets.hh>
36 #include "MIHTypes.hh"
38 //#include "TLVParser.mpp"
39 //-/////////////////////////////////////////////////////////////////////////////////////////////////
44 : public detail::packet::IntParserOps<MIHLengthParser, boost::uint32_t>,
45 public PacketParserBase
48 MIHLengthParser(data_iterator i, state_type s) : PacketParserBase(i,s) {}
50 typedef boost::uint32_t value_type;
51 static const size_type init_bytes = 1;
52 static value_type const min_value = 0;
53 static value_type const max_value = 4294967295u;
55 value_type value() const;
56 void value(value_type v);
58 MIHLengthParser const & operator= (value_type other);
59 size_type bytes() const;
62 # include SENF_PARSER()
63 SENF_PARSER_PRIVATE_FIELD ( length_field, UInt8Parser );
64 SENF_PARSER_GOTO( length_field );
65 SENF_PARSER_PRIVATE_BITFIELD ( extended_length_flag, 1, bool );
66 SENF_PARSER_PRIVATE_BITFIELD ( underflow_flag, 1, bool );
67 SENF_PARSER_PRIVATE_BITFIELD ( fixed_length_field, 6, unsigned );
70 void capacity(value_type v);
71 value_type capacity() const;
74 void resize_(size_type size);
78 /** \brief Base class for MIH TLV parsers
80 MIHBaseTLVParser is the abstract base class for MIH TLV parsers. It defines the
81 \ref type() field as an \ref senf::UInt8Parser and the \ref length() field as a
82 MIHLengthParser. The length field is read-only.
84 To create your own \c TLVParser you have to inherit from MIHBaseTLVParser (don't
85 forget \ref SENF_PARSER_INHERIT) and define the \c value field. In the following example
86 the value is a vector of MacAddresses:
88 struct MacAddressesTLVParser : public MIHBaseTLVParser {
89 # include SENF_PARSER()
90 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
91 SENF_PARSER_VECTOR ( value, bytes(length), senf::MACAddressParser );
92 SENF_PARSER_FINALIZE( MacAddressesTLVParser );
96 You have to adjust the maximum length value with the \ref maxLength function
97 before the length value is set. The default maximum value is 128. So, in the above
98 example adding more than 21 MACAddresses to the vector will throw a TLVLengthException
99 if you don't call \c maxLength( \e some_value) before.
101 \see MIHLengthParser \n
102 MIHGenericTLVParser \n
104 class MIHBaseTLVParser : public PacketParserBase
107 # include SENF_PARSER()
108 SENF_PARSER_FIELD ( type, UInt8Parser );
109 SENF_PARSER_FIELD_RO ( length, MIHLengthParser );
110 SENF_PARSER_FINALIZE ( MIHBaseTLVParser );
112 /** \brief shrink size of the TLV length field to minimum
114 The size of the length field will be decreased to minimum necessary to hold
115 the current length value.
119 typedef GenericTLVParserRegistry<MIHBaseTLVParser> Registry;
122 /** \brief set maximum value of TLV length field
124 The size of the length field will be increased if necessary.
125 \param v maximum value of length field
127 void maxLength(MIHLengthParser::value_type maxl) const;
129 void validateType(boost::uint8_t type) const;
130 void validateTypeLength(boost::uint8_t type, MIHLengthParser::value_type length) 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( MIHLengthParser::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, MIHLengthParser );
161 SENF_PARSER_FINALIZE ( MIHBaseListTLVParser );
163 void maxListSize(MIHLengthParser::value_type maxl = MIHLengthParser::max_value) 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, MIHLengthParser );
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(MIHLengthParser::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;
296 void validate() const;
299 /** \brief Parser for 802.21 destination MIHF_ID TLV
301 struct MIHFDstIdTLVParser : public MIHFIdTLVParser
303 MIHFDstIdTLVParser(data_iterator i, state_type s) : MIHFIdTLVParser(i,s) {}
309 static type_t::value_type const typeId = 2;
310 void dump(std::ostream & os) const;
311 void validate() const;
314 /** \brief Parser for 802.21 Status TLV
316 struct MIHStatusTLVParser : public MIHBaseTLVParser
318 # include SENF_PARSER()
319 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
320 SENF_PARSER_FIELD ( value, UInt8Parser );
321 SENF_PARSER_FINALIZE( MIHStatusTLVParser );
328 static type_t::value_type const typeId = 3;
329 void dump(std::ostream & os) const; ///< dump string representation to given stream
330 void validate() const;
333 Success, UnspecifiedFailure, Rejected, AuthorizationFailure, NetworkError };
336 struct MIHRegisterReqCodeTLVParser : public MIHBaseTLVParser
338 # include SENF_PARSER()
339 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
340 SENF_PARSER_FIELD ( value, UInt8Parser );
341 SENF_PARSER_FINALIZE ( MIHRegisterReqCodeTLVParser );
348 static type_t::value_type const typeId = 11;
349 void dump(std::ostream & os) const; ///< dump string representation to given stream
350 void validate() const;
352 enum RequestCode { Registration, ReRegistration };
355 struct MIHValidTimeIntervalTLVParser : public MIHBaseTLVParser
357 # include SENF_PARSER()
358 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
359 SENF_PARSER_FIELD ( value, UInt32Parser );
360 SENF_PARSER_FINALIZE ( MIHValidTimeIntervalTLVParser );
367 static type_t::value_type const typeId = 12;
368 void dump(std::ostream & os) const; ///< dump string representation to given stream
369 void validate() const;
375 //-/////////////////////////////////////////////////////////////////////////////////////////////////
376 #include "TLVParser.cci"
377 #include "TLVParser.ct"
378 #include "TLVParser.cti"
385 // c-file-style: "senf"
386 // indent-tabs-mode: nil
387 // ispell-local-dictionary: "american"
388 // compile-command: "scons -u test"
389 // comment-column: 40