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 maxValue(value_type v);
74 value_type maxValue() 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 maxLengthValue function
100 before the length value is set. The default maximum value is 127. 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 macAddressesTLVPacket->maxLengthValue( \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 set maximum value of length field
117 The size of the length field will be increased if necessary.
118 \param v maximum value of length field
120 void maxLengthValue(MIHTLVLengthParser::value_type v) const {
121 protect(), length_().maxValue(v);
124 /** \brief shrink size of length field to minimum
126 The size of the length field will be decreased to minimum necessary to hold
127 the current length value.
129 void finalizeLength() {
130 protect(), length_().finalize();
133 typedef GenericTLVParserRegistry<MIHBaseTLVParser> Registry;
136 /// resize the packet after the length field to given size
137 senf::safe_data_iterator resizeValueField(MIHTLVLengthParser::value_type size);
141 /** \brief Parser for a generic TLV packet
143 struct MIHGenericTLVParser
144 : public GenericTLVParserBase<MIHBaseTLVParser>
146 typedef senf::GenericTLVParserBase<MIHBaseTLVParser> base;
147 MIHGenericTLVParser(data_iterator i, state_type s) : base(i,s) {}
151 maxLengthValue( MIHTLVLengthParser::max_value);
157 /** \brief Parse a MIHF_ID
159 the maximum length of a MIHF_ID is 253 octets (see F.3.11 in 802.21)
160 we could set maxLengthValue in init(), but for the most MIHF_IDs the default
161 maximum length of 127 should be enough.
163 \note you must call mihfIdPacket.maxLengthValue( 253) *before*
164 setting longer MIHF_IDs values.
166 class MIHFIdTLVParser : public MIHBaseTLVParser
168 # include SENF_PARSER()
169 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
170 SENF_PARSER_SKIP ( length(), 0 );
171 SENF_PARSER_FINALIZE ( MIHFIdTLVParser );
174 ///\name value setters
176 void value( MIHFId const & id);
178 void value( std::string const & id );
179 void value( senf::MACAddress const & addr);
180 void value( senf::INet4Address const & addr);
181 void value( senf::INet6Address const & addr);
182 void value( senf::EUI64 const & addr);
185 ///\name value getters
187 MIHFId valueAs( MIHFId::Type type) const;
189 std::string valueAsString() const;
190 senf::MACAddress valueAsMACAddress() const;
191 senf::INet4Address valueAsINet4Address() const;
192 senf::INet6Address valueAsINet6Address() const;
193 senf::EUI64 valueAsEUI64() const;
196 ///\name value comparisons
198 bool valueEquals( MIHFId const & id) const;
200 bool valueEquals( std::string const & id ) const;
201 bool valueEquals( senf::MACAddress const & addr) const;
202 bool valueEquals( senf::INet4Address const & addr) const;
203 bool valueEquals( senf::INet6Address const & addr) const;
204 bool valueEquals( senf::EUI64 const & addr) const;
207 void dump(std::ostream & os) const;
210 template <class OutputIterator>
211 struct binaryNAIEncoder {
212 binaryNAIEncoder(OutputIterator & i);
213 void operator()(boost::uint8_t v);
217 template <class OutputIterator>
218 static boost::function_output_iterator<binaryNAIEncoder<OutputIterator> >
219 getNAIEncodedOutputIterator(OutputIterator i);
221 struct binaryNAIDecoder {
223 bool operator()(boost::uint8_t v);
227 template <class Iterator>
228 static boost::filter_iterator<binaryNAIDecoder, Iterator>
229 getNAIDecodedIterator(Iterator begin, Iterator end);
231 struct ValueSetterVisitor : public boost::static_visitor<> {
232 MIHFIdTLVParser & parser;
233 ValueSetterVisitor( MIHFIdTLVParser & p) : parser(p) {}
234 void operator()( boost::blank ) const {
235 parser.value( std::string());
237 template <typename MIHFIdType>
238 void operator()( MIHFIdType const & id ) const {
243 struct ValueEqualsVisitor : public boost::static_visitor<bool> {
244 MIHFIdTLVParser const & parser;
245 ValueEqualsVisitor( MIHFIdTLVParser const & p) : parser(p) {}
246 bool operator()( boost::blank ) const {
247 return parser.length() == 0;
249 template <typename MIHFIdType>
250 bool operator()( MIHFIdType const & id ) const {
251 return parser.valueEquals( id);
256 struct MIHFSrcIdTLVParser : public MIHFIdTLVParser
258 MIHFSrcIdTLVParser(data_iterator i, state_type s) : MIHFIdTLVParser(i,s) {}
264 static type_t::value_type const typeId = 1;
265 void dump(std::ostream & os) const;
268 struct MIHFDstIdTLVParser : public MIHFIdTLVParser
270 MIHFDstIdTLVParser(data_iterator i, state_type s) : MIHFIdTLVParser(i,s) {}
276 static type_t::value_type const typeId = 2;
277 void dump(std::ostream & os) const;
280 /** \brief Parser for 802.21 Status TLV
282 struct MIHStatusTLVParser : public MIHBaseTLVParser
284 # include SENF_PARSER()
285 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
286 SENF_PARSER_FIELD ( value, UInt8Parser );
287 SENF_PARSER_FINALIZE( MIHStatusTLVParser );
294 static type_t::value_type const typeId = 3;
295 void dump(std::ostream & os) const; ///< dump string representation to given stream
298 Success, UnspecifiedFailure, Rejected, AuthorizationFailure, NetworkError };
301 struct MIHRegisterReqCodeTLVParser : public MIHBaseTLVParser
303 # include SENF_PARSER()
304 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
305 SENF_PARSER_FIELD ( value, UInt8Parser );
306 SENF_PARSER_FINALIZE ( MIHRegisterReqCodeTLVParser );
313 static type_t::value_type const typeId = 11;
314 void dump(std::ostream & os) const; ///< dump string representation to given stream
316 enum RequestCode { Registration, ReRegistration };
319 struct MIHValidTimeIntervalTLVParser : public MIHBaseTLVParser
321 # include SENF_PARSER()
322 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
323 SENF_PARSER_FIELD ( value, UInt32Parser );
324 SENF_PARSER_FINALIZE ( MIHValidTimeIntervalTLVParser );
331 static type_t::value_type const typeId = 12;
332 void dump(std::ostream & os) const; ///< dump string representation to given stream
338 ///////////////////////////////hh.e////////////////////////////////////////
339 #include "TLVParser.cci"
340 //#include "TLVParser.ct"
341 #include "TLVParser.cti"
348 // c-file-style: "senf"
349 // indent-tabs-mode: nil
350 // ispell-local-dictionary: "american"
351 // compile-command: "scons -u test"
352 // comment-column: 40