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 std::string asString() const;
175 void setString(std::string const &id);
177 senf::MACAddress asMACAddress() const;
178 void setMACAddress(senf::MACAddress const &mac);
180 senf::INet4Address asINet4Address() const;
181 void setINet4Address(senf::INet4Address const &addr);
183 senf::INet6Address asINet6Address() const;
184 void setINet6Address(senf::INet6Address const &addr);
186 senf::EUI64 asEUI64() const;
187 void setEUI64(senf::EUI64 const &addr);
189 MIHFId valueAs(MIHFId::Type type) const;
191 void dump(std::ostream & os) const;
194 template <class OutputIterator>
195 struct binaryNAIEncoder {
196 binaryNAIEncoder(OutputIterator &i) : i_(i) {}
197 void operator()(const boost::uint8_t &v) const {
203 template <class OutputIterator>
204 static boost::function_output_iterator<binaryNAIEncoder<OutputIterator> > getNAIEncodedOutputIterator(OutputIterator i) {
205 return boost::make_function_output_iterator(binaryNAIEncoder<OutputIterator>(i));
208 struct binaryNAIDecoder {
209 binaryNAIDecoder() : readNextByte_(true) {}
210 bool operator()(const boost::uint8_t &v) {
211 readNextByte_ = readNextByte_ ? false : true;
212 return readNextByte_;
216 template <class Iterator>
217 static boost::filter_iterator<binaryNAIDecoder, Iterator> getNAIDecodedIterator(Iterator begin, Iterator end) {
218 return boost::make_filter_iterator<binaryNAIDecoder>(begin, end);
222 struct MIHFSrcIdTLVParser : public MIHFIdTLVParser
224 MIHFSrcIdTLVParser(data_iterator i, state_type s) : MIHFIdTLVParser(i,s) {}
230 static type_t::value_type const typeId = 1;
232 void dump(std::ostream & os) const;
235 struct MIHFDstIdTLVParser : public MIHFIdTLVParser
237 MIHFDstIdTLVParser(data_iterator i, state_type s) : MIHFIdTLVParser(i,s) {}
243 static type_t::value_type const typeId = 2;
245 void dump(std::ostream & os) const;
248 /** \brief Parser for 802.21 Status TLV
250 struct MIHStatusTLVParser : public MIHBaseTLVParser
252 # include SENF_PARSER()
253 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
254 SENF_PARSER_FIELD ( value, UInt8Parser );
255 SENF_PARSER_FINALIZE( MIHStatusTLVParser );
261 static type_t::value_type const typeId = 3;
262 void dump(std::ostream & os) const; ///< dump string representation to given stream
265 Success, UnspecifiedFailure, Rejected, AuthorizationFailure, NetworkError };
268 struct MIHRegisterReqCodeTLVParser : public MIHBaseTLVParser
270 # include SENF_PARSER()
271 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
272 SENF_PARSER_FIELD ( value, UInt8Parser );
273 SENF_PARSER_FINALIZE ( MIHRegisterReqCodeTLVParser );
280 static type_t::value_type const typeId = 11;
281 void dump(std::ostream & os) const; ///< dump string representation to given stream
283 enum RequestCode { Registration, ReRegistration };
286 struct MIHValidTimeIntervalTLVParser : public MIHBaseTLVParser
288 # include SENF_PARSER()
289 SENF_PARSER_INHERIT ( MIHBaseTLVParser );
290 SENF_PARSER_FIELD ( value, UInt32Parser );
291 SENF_PARSER_FINALIZE ( MIHValidTimeIntervalTLVParser );
298 static type_t::value_type const typeId = 12;
299 void dump(std::ostream & os) const; ///< dump string representation to given stream
305 ///////////////////////////////hh.e////////////////////////////////////////
306 #include "TLVParser.cci"
307 //#include "TLVParser.ct"
308 //#include "TLVParser.cti"
315 // c-file-style: "senf"
316 // indent-tabs-mode: nil
317 // ispell-local-dictionary: "american"
318 // compile-command: "scons -u test"
319 // comment-column: 40