1 // ANNA - Anna is Not Nothingness Anymore //
3 // (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo //
5 // See project site at http://redmine.teslayout.com/projects/anna-suite //
6 // See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //
9 #ifndef anna_diameter_codec_Avp_hpp
10 #define anna_diameter_codec_Avp_hpp
14 #include <anna/config/defines.hpp>
15 #include <anna/diameter/defines.hpp>
16 #include <anna/diameter/codec/basetypes/basetypes.hpp>
17 #include <anna/diameter/codec/functions.hpp>
18 #include <anna/diameter/stack/Avp.hpp>
20 #include <anna/core/RuntimeException.hpp>
26 //------------------------------------------------------------------------------
27 //---------------------------------------------------------------------- #define
28 //------------------------------------------------------------------------------
64 class DiameterIdentity;
77 typedef std::map < int /* key: insertion pos */, Avp* > avp_container;
78 typedef avp_container::iterator avp_iterator;
79 typedef avp_container::const_iterator const_avp_iterator;
81 // Cache avp-find system
82 typedef std::pair < AvpId, unsigned int /* position */ > find_key;
83 typedef std::map<find_key, Avp*> find_container;
84 typedef std::map<find_key, Avp*>::iterator find_iterator;
87 using namespace basetypes;
90 * Diameter avp generic container
92 * RFC 3588 Diameter Based Protocol September 2003
95 * The fields in the AVP header MUST be sent in network byte order. The
96 * format of the header is:
99 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
100 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
102 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
103 * | AVP Flags | AVP Length |
104 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
105 * | Vendor-ID (opt) |
106 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
111 * AVP Flags: V (vendor-specific), M (mandatory), P (end to end encryption)
117 * The AVP Length field is three octets, and indicates the number of
118 * octets in this AVP including the AVP Code, AVP Length, AVP Flags,
119 * Vendor-ID field (if present) and the AVP data.
121 * Vendor-ID: IANA "SMI Network Management Private Enterprise Codes" [ASSIGNNO]
122 * http://www.iana.org/assignments/enterprise-numbers
127 AvpId a_id; // code and vendor-code
131 int a_insertionPositionForChilds; // used at grouped type
134 // --- Developer notes ---
135 // 'AVP Length' does not include posible data padding. Thanks to this, 'Data Length'
136 // is the difference between 'AVP Length' and sum of code, length, flags and
137 // optionally the vendor-ID (all of them are 32-bit boundary), that is to say:
138 // 8 or 12 (vendor-specific avps).
140 // Grouped avps 'AVP Length' includes own headers plus the total length of all
141 // underlying AVPs, including their headers and padding, then 'AVP Length' is
142 // always multiple of 4 (library will check this), and smae for 'Data Length'
143 // which is an 'whole avp Length with padding' itself.
146 OctetString *a_OctetString;
147 Integer32 *a_Integer32;
148 Integer64 *a_Integer64;
149 Unsigned32 *a_Unsigned32;
150 Unsigned64 *a_Unsigned64;
153 avp_container a_avps; // Grouped
156 UTF8String *a_UTF8String;
157 DiameterIdentity *a_DiameterIdentity;
158 DiameterURI *a_DiameterURI;
159 Enumerated *a_Enumerated;
160 IPFilterRule *a_IPFilterRule;
161 QoSFilterRule *a_QoSFilterRule;
165 find_container a_finds; // fast access for grouped and message first-level avps
168 // Static functions are used when you want a function that is the same for every instance of a class. Such functions do not have access
169 // to "this" pointer and thus cannot access any non static fields. They are used often when you want a function that can be used without
170 // instantiating the class. Friend functions are functions which are not in the class and you want to give them access to private members
173 // Common (also for Message class)
174 static avp_iterator avp_find(avp_container &avps, AvpId id, unsigned int position) throw();
175 static const_avp_iterator avp_find(const avp_container &avps, AvpId id, unsigned int position) throw() {
176 return (const_avp_iterator)avp_find((avp_container &)avps, id, position);
178 static Avp * addAvp(avp_container &avps, int &insertionPositionForChilds, AvpId id, Engine *engine) throw();
179 static bool removeAvp(avp_container &avps, find_container &finds, AvpId id, int ocurrence, Engine *engine) throw();
180 static void fix(avp_container &avps, find_container &finds, int &insertionPositionForChilds, anna::diameter::stack::const_avprule_iterator ruleBegin, anna::diameter::stack::const_avprule_iterator ruleEnd) throw();
181 static bool validLevel(const avp_container &avps, anna::diameter::stack::const_avprule_iterator ruleBegin, anna::diameter::stack::const_avprule_iterator ruleEnd, Engine * engine, const anna::diameter::codec::parent_t & parent, Message *answer) throw(anna::RuntimeException); // validates mandatory/fixed and cardinality
182 static const Avp* getAvp(const avp_container &avps, find_container &finds, AvpId id, int ocurrence, Engine *engine, anna::Exception::Mode::_v emode) throw(anna::RuntimeException);
183 static int countAvp(const avp_container &avps, AvpId id) throw();
184 static const Avp* firstAvp(const avp_container &avps, AvpId id) throw();
185 static int countChilds(const avp_container &avps) throw();
186 static int addChild(avp_container &avps, int &insertionPositionForChilds, Avp *avp) throw() {
189 avps[insertionPositionForChilds++] = avp;
190 return insertionPositionForChilds;
192 static const anna::diameter::stack::Avp *getStackAvp(AvpId id, Engine *engine) throw();
193 const Avp* _getAvp(const char *name, int ocurrence, anna::Exception::Mode::_v emode) const throw(anna::RuntimeException);
194 const Avp* _getAvp(AvpId id, int ocurrence, anna::Exception::Mode::_v emode) const throw(anna::RuntimeException);
197 avp_iterator avp_begin() throw() { return a_avps.begin(); }
198 avp_iterator avp_end() throw() { return a_avps.end(); }
199 static Avp* avp(avp_iterator ii) throw() { return ii->second; }
200 const_avp_iterator avp_begin() const throw() { return a_avps.begin(); }
201 const_avp_iterator avp_end() const throw() { return a_avps.end(); }
202 static const Avp* avp(const_avp_iterator ii) throw() { return ii->second; }
205 bool flagsOK() const throw(); // flags coherence regarding dictionary. Only must be called when AVP is identified at the dictionary.
206 int addChild(Avp *avp) throw(anna::RuntimeException) { assertFormat("Grouped"); return addChild(a_avps, a_insertionPositionForChilds, avp); }
207 bool hasChildren() throw() { return a_avps.size() != 0; }
209 static bool contain(const_avp_iterator begin, const_avp_iterator end, const Avp *parent) throw() { return true; }
213 Fix grouped content regarding dictionary avp positions.
214 Avp could remain invalid because of possible fixed/mandatory avps.
215 This is useful to give flexibility to the application during message construction before encoding or representing the data.
216 Is not recommended to fix a recently decoded message because possible validation problems will be hidden.
221 Validates an Avp regarding dictionary rules like enumerated range, flags coherence, mandatory and fixed types, cardinality qualifiers, etc.
223 @param parent Parent description. Internally used for alarms, tracing and Failed-AVP construction
224 @param answer Answer could be modified with any validation problem during requests validation
226 @return Boolean indicating validation result
228 bool valid(const anna::diameter::codec::parent_t & parent, Message *answer) const throw(anna::RuntimeException);
231 Decodes buffer provided over class content. If an error ocurred, decoding will stop launching exception (fatal error) or a warning trace (perhaps the achieved
232 message is valid against all odds then validation will go on). In case that validation is enabled (codec::Engine::ValidationMode) an exception will be launched
233 depending on validation depth (codec::Engine::ValidationDepth).
235 @param db Buffer data block processed
236 @param parent Parent description. Internally used for alarms, tracing and Failed-AVP construction
237 @param answer Answer built for request decoding/validation
239 void decode(const anna::DataBlock &db, const anna::diameter::codec::parent_t & parent, Message *answer) throw(anna::RuntimeException);
242 /////////////////////////////////////////////
243 // Inherit format-specific virtual methods //
244 /////////////////////////////////////////////
247 * Initializes Avp class information.
248 * Default implementation supports all anna::diameter formats (including derived ones).
249 * Diameter basic formats are managed at #initialize, which will invoke this method at the end.
251 virtual void initializeByFormat() throw() {};
254 * Gets avp data-part length.
255 * Default implementation supports all anna::diameter formats (including derived ones).
256 * Diameter basic formats are managed at #initialize, which will invoke this method at the end.
258 * @param stackFormat Stack avp format in which data extraction is based.
260 * @return Avp data-part size.
262 virtual U24 getLengthByFormat(const anna::diameter::stack::Format *stackFormat) const throw() { return 0; };
265 Gets data or hexadecimal data depending on avp format, for xml creating
266 Default implementation supports all anna::diameter formats (including derived ones).
267 Diameter basic formats are managed at #initialize, which will invoke this method at the end.
269 \param isHex Hexadecimal/Natural data when apply.
270 \param stackFormat Stack avp format in which data extraction is based.
271 \return xml data representation
273 virtual std::string getXMLdataByFormat(bool & isHex, const anna::diameter::stack::Format *stackFormat) const throw() { return ""; };
276 Interpret xml data in order to dump over the class content.
277 Default implementation supports all anna::diameter formats (including derived ones).
278 Diameter basic formats are managed at #initialize, which will invoke this method at the end.
280 \param data Avp data attribute
281 \param hexData Avp hex-data attribute
282 \param stackFormat Stack avp format in which data extraction is based.
284 virtual void fromXMLByFormat(const anna::xml::Attribute* data, const anna::xml::Attribute* hexData, const anna::diameter::stack::Format *stackFormat) throw(anna::RuntimeException) {};
288 Encodes buffer with the class content.
289 Default implementation supports all anna::diameter formats (including derived ones).
290 Diameter basic formats are managed at #initialize, which will invoke this method at the end.
292 @param dataPart Data-part begin pointer
293 @param stackFormat Stack avp format in which data extraction is based.
295 virtual void codeByFormat(char* dataPart, const anna::diameter::stack::Format *stackFormat) const throw(anna::RuntimeException) {};
299 Decodes Avp data part.
300 Default implementation supports all anna::diameter formats (including derived ones).
301 Diameter basic formats are managed at #initialize, which will invoke this method at the end.
303 @param buffer Avp data part start pointer
304 @param size Avp data part size
305 @param stackFormat Stack avp format in which data extraction is based.
307 virtual void decodeDataPartByFormat(const char * buffer, int size, const anna::diameter::stack::Format *stackFormat) throw(anna::RuntimeException) {};
310 Reserves memory for data part depending on avp format for the identifier provided.
311 Default implementation supports all anna::diameter formats (including derived ones).
312 Diameter basic formats are managed at #initialize, which will invoke this method at the end.
314 @param stackFormat Stack avp format in which data extraction is based.
316 virtual void allocationByFormat(const anna::diameter::stack::Format *stackFormat) throw() {};
319 * Clears Avp data-part format containers.
321 virtual void clearByFormat() throw() {};
328 mutable Engine *a_engine;
330 /** Codec Engine getter: avoids have to create base engine when using its child */
331 virtual Engine * getEngine() const throw(anna::RuntimeException);
334 * Initializes Avp class information.
336 void initialize() throw();
339 * Assert format regarding dictionary
341 void assertFormat(const std::string &name) const throw(anna::RuntimeException);
344 * Gets avp total length based on internal data part and header configuration.
345 * Padding octets are not included, only header and data part length.
346 * The only format which always have total length equal to sum of all its parts is Grouped,
347 * because of the 4-multiple nature of its data part length.
349 U24 getLength() const throw();
352 Gets data or hexadecimal data depending on avp format, for xml creating
354 \param isHex Hexadecimal/Natural data when apply.
355 \param stackFormat Stack avp format in which data extraction is based.
356 \return xml data representation
358 std::string getXMLdata(bool & isHex, const anna::diameter::stack::Format *stackFormat) const throw();
362 Decodes Avp data part.
364 @param buffer Avp data part start pointer
365 @param size Avp data part size
366 @param parent Parent description. Internally used for alarms, tracing and Failed-AVP construction
367 @param answer Answer built for request decoding/validation
369 void decodeDataPart(const char * buffer, int size, const anna::diameter::codec::parent_t & parent, Message *answer) throw(anna::RuntimeException);
375 * Default constructor
380 * Identified constructor
381 * @param id Avp identifier as pair (code,vendor-id).
387 static const int HeaderLengthVactive;
388 static const int HeaderLengthVinactive;
397 // (encry)P(tion) (end to end encryption)
398 // r(eserved) - these flag bits are reserved for future use, and
399 // MUST be set to zero, and ignored by the receiver.
400 static const U8 VBitMask;
401 static const U8 MBitMask;
402 static const U8 PBitMask;
413 * Clears and initializes Avp class information.
414 * Application should clear auxiliary avp objects before setting data in a new context.
416 void clear() throw(anna::RuntimeException);
420 Sets the avp identifier and clear the former content.
421 Internally reserves memory for data part depending on avp format for the identifier provided.
422 This must be called at first place because Avp class content is cleared when identifier is configured.
423 Generic AVP assignment have no sense and will be ignored.
425 @param id Avp identifier as pair (code,vendor-id).
427 void setId(AvpId id) throw(anna::RuntimeException);
430 Same as #setId but providing dictionary logical name for Avp searched
432 void setId(const char *name) throw(anna::RuntimeException);
435 Sets/unsets M bit activation.
436 Application should not have to use this because dictionary information is used in order to configure flags when Avp identifier is stored.
437 Anyway, could be useful when build unknown-type avps.
439 The 'M' Bit, known as the Mandatory bit, indicates whether support of the AVP is required. If an AVP with the 'M' bit set is received by
440 a Diameter client, server, proxy, or translation agent and either the AVP or its value is unrecognized, the message MUST be rejected.
441 Diameter Relay and redirect agents MUST NOT reject messages with unrecognized AVPs.
443 @param activate Activates/deactivates the bit. True by default.
445 void setMandatoryBit(bool activate = true) throw() { if(activate) a_flags |= MBitMask; else a_flags &= (~MBitMask); }
448 Sets/unsets P bit activation.
449 Application should not have to use this because dictionary information is used in order to configure flags when Avp identifier is stored.
450 Anyway, could be useful when build unknown-type avps.
452 @param activate Activates/deactivates the bit. True by default.
454 void setEncryptionBit(bool activate = true) throw() { if(activate) a_flags |= PBitMask; else a_flags &= (~PBitMask); }
458 Adds an avp child providing its identifier and reserve internal memory it.
459 An exception is launched is the Avp is not a grouped avp.
461 @param id Avp identifier as pair (code,vendor-id).
463 @return Pointer to the new created avp.
465 Avp * addAvp(AvpId id) throw(anna::RuntimeException) { assertFormat("Grouped"); return addAvp(a_avps, a_insertionPositionForChilds, id, getEngine()); }
469 Same as #addAvp but providing dictionary logical name for Avp searched
471 Avp * addAvp(const char *name) throw(anna::RuntimeException);
475 Adds an avp child providing a persistent pointer (must be maintained by application).
476 An exception is launched is the Avp is not a grouped avp.
478 @param avp Avp external pointer. If NULL provided, nothing is done and NULL returned.
480 @return Pointer to the added avp (again).
482 Avp * addAvp(Avp * avp) throw(anna::RuntimeException) { if(!avp) return NULL; addChild(avp); return avp; }
485 /** Access content for OctetString Avp in order to set data part */
486 OctetString * getOctetString() throw(anna::RuntimeException) { assertFormat("OctetString"); return a_OctetString; }
487 /** Access content for Integer32 Avp in order to set data part */
488 Integer32 * getInteger32() throw(anna::RuntimeException) { assertFormat("Integer32"); return a_Integer32; }
489 /** Access content for Integer64 Avp in order to set data part */
490 Integer64 * getInteger64() throw(anna::RuntimeException) { assertFormat("Integer64"); return a_Integer64; }
491 /** Access content for Unsigned32 Avp in order to set data part */
492 Unsigned32 * getUnsigned32() throw(anna::RuntimeException) { assertFormat("Unsigned32"); return a_Unsigned32; }
493 /** Access content for Unsigned64 Avp in order to set data part */
494 Unsigned64 * getUnsigned64() throw(anna::RuntimeException) { assertFormat("Unsigned64"); return a_Unsigned64; }
495 /** Access content for Float32 Avp in order to set data part */
496 Float32 * getFloat32() throw(anna::RuntimeException) { assertFormat("Float32"); return a_Float32; }
497 /** Access content for Float64 Avp in order to set data part */
498 Float64 * getFloat64() throw(anna::RuntimeException) { assertFormat("Float64"); return a_Float64; }
499 /** Access content for Address Avp in order to set data part */
500 Address * getAddress() throw(anna::RuntimeException) { assertFormat("Address"); return a_Address; }
501 /** Access content for Time Avp in order to set data part */
502 Time * getTime() throw(anna::RuntimeException) { assertFormat("Time"); return a_Time; }
503 /** Access content for UTF8String Avp in order to set data part */
504 UTF8String * getUTF8String() throw(anna::RuntimeException) { assertFormat("UTF8String"); return a_UTF8String; }
505 /** Access content for DiameterIdentity Avp in order to set data part */
506 DiameterIdentity * getDiameterIdentity() throw(anna::RuntimeException) { assertFormat("DiameterIdentity"); return a_DiameterIdentity; }
507 /** Access content for DiameterURI Avp in order to set data part */
508 DiameterURI * getDiameterURI() throw(anna::RuntimeException) { assertFormat("DiameterURI"); return a_DiameterURI; }
509 /** Access content for Enumerated Avp in order to set data part */
510 Enumerated * getEnumerated() throw(anna::RuntimeException) { assertFormat("Enumerated"); return a_Enumerated; }
511 /** Access content for IPFilterRule Avp in order to set data part */
512 IPFilterRule * getIPFilterRule() throw(anna::RuntimeException) { assertFormat("IPFilterRule"); return a_IPFilterRule; }
513 /** Access content for QoSFilterRule Avp in order to set data part */
514 QoSFilterRule * getQoSFilterRule() throw(anna::RuntimeException) { assertFormat("QoSFilterRule"); return a_QoSFilterRule; }
515 /** Access content for Unknown Avp in order to set data part */
516 Unknown * getUnknown() throw(anna::RuntimeException) { assertFormat("Unknown"); return a_Unknown; }
520 Removes an Avp within grouped type (first level) and free resources.
522 @param id Avp identifier (pair code + vendor-id).
523 @param ocurrence Order of appearance for the searched avp. Zero value means remove all avps with provided identifier at first level (no recursiveness would be allowed in the API in order to avoid unexpected behaviour).
524 Negative values could be used to reverse access positions: i.e. -1 is the last ocurrence, -2 is the second to last (penultimate), etc.
526 @return Returns true if something was removed. False in other cases (including i.e. when this Avp is empty or is not a grouped avp).
528 bool removeAvp(AvpId id, int ocurrence = 1) throw(anna::RuntimeException) { assertFormat("Grouped"); return removeAvp(a_avps, (find_container&)a_finds, id, ocurrence, getEngine()); }
532 Same as #removeAvp but providing dictionary logical name for Avp searched
534 bool removeAvp(const char *name, int ocurrence = 1) throw(anna::RuntimeException);
539 Gets Avp identifier as pair (code, vendor-id).
541 const AvpId & getId() const throw() { return a_id; }
546 int getVendorId() const throw() { return a_id.second; }
549 Gets stack avp (dictionary avp reference).
551 const anna::diameter::stack::Avp *getStackAvp() const throw(anna::RuntimeException) { return getStackAvp(a_id, getEngine()); }
553 /** Returns V bit activation state */
554 bool vendorBit() const throw() { return ((a_flags & VBitMask) != 0x00); }
556 /** Returns M bit activation state */
557 bool mandatoryBit() const throw() { return ((a_flags & MBitMask) != 0x00); }
559 /** Returns P bit activation state */
560 bool encryptionBit() const throw() { return ((a_flags & PBitMask) != 0x00); }
563 /** Access content for OctetString Avp */
564 const OctetString * getOctetString() const throw(anna::RuntimeException) { assertFormat("OctetString"); return a_OctetString; }
565 /** Access content for Integer32 Avp */
566 const Integer32 * getInteger32() const throw(anna::RuntimeException) { assertFormat("Integer32"); return a_Integer32; }
567 /** Access content for Integer64 Avp */
568 const Integer64 * getInteger64() const throw(anna::RuntimeException) { assertFormat("Integer64"); return a_Integer64; }
569 /** Access content for Unsigned32 Avp */
570 const Unsigned32 * getUnsigned32() const throw(anna::RuntimeException) { assertFormat("Unsigned32"); return a_Unsigned32; }
571 /** Access content for Unsigned64 Avp */
572 const Unsigned64 * getUnsigned64() const throw(anna::RuntimeException) { assertFormat("Unsigned64"); return a_Unsigned64; }
573 /** Access content for Float32 Avp */
574 const Float32 * getFloat32() const throw(anna::RuntimeException) { assertFormat("Float32"); return a_Float32; }
575 /** Access content for Float64 Avp */
576 const Float64 * getFloat64() const throw(anna::RuntimeException) { assertFormat("Float64"); return a_Float64; }
579 Access content for Grouped Avp. Exception mode allows different combinations like cascade access:
583 message->getAvp(anna::diameter::helpers::base::AVP__Multiple_Services_Credit_Control, anna::Exception::Mode::Throw)
584 ->getAvp(anna::diameter::helpers::base::AVP__Rating_Group, anna::Exception::Mode::Throw);
586 catch(anna::RuntimeException) {;}
592 const Avp *mscc = message->getAvp(anna::diameter::helpers::base::AVP__Multiple_Services_Credit_Control);
594 if (mscc) rg = mscc->getAvp(anna::diameter::helpers::base::AVP__Rating_Group);
597 Replacing procedures becomes easy because an Avp can be searched and its pointer reconfigured by mean #setId and data part setters.
598 Deleting procedures must use #removeAvp.
599 Access is internally cached to speed up the search operations. This cache is reset after calling #fix or #removeAvp methods.
601 @param id Avp identifier (pair code + vendor-id).
602 @param ocurrence Order of appearance for the searched avp. Zero position is rejected, but negative values could be used to reverse
603 access positions: i.e. -1 is the last ocurrence, -2 is the second to last (penultimate), etc.
604 @param emode Excepcion mode handling when avp is not found: Ignore (no action is taken but debug trace), Throw (excepcion launched, by default), Trace (trace warning).
605 If avp format is not grouped, always exception will be launched and no matter what mode is provided. It would be a development
606 error and must be solved.
608 const Avp* getAvp(AvpId id, int ocurrence = 1, anna::Exception::Mode::_v emode = anna::Exception::Mode::Throw) const throw(anna::RuntimeException) {
609 return _getAvp(id, ocurrence, emode);
612 Avp* getAvp(AvpId id, int ocurrence = 1, anna::Exception::Mode::_v emode = anna::Exception::Mode::Throw) throw(anna::RuntimeException) {
613 return const_cast<Avp*>(_getAvp(id, ocurrence, emode));
617 Same as #getAvp but providing dictionary logical name for Avp searched
619 const Avp* getAvp(const char *name, int ocurrence = 1, anna::Exception::Mode::_v emode = anna::Exception::Mode::Throw) const throw(anna::RuntimeException) {
620 return _getAvp(name, ocurrence, emode);
623 Avp* getAvp(const char *name, int ocurrence = 1, anna::Exception::Mode::_v emode = anna::Exception::Mode::Throw) throw(anna::RuntimeException) {
624 return const_cast<Avp*>(_getAvp(name, ocurrence, emode));
629 /** Access content for Address Avp */
630 const Address * getAddress() const throw(anna::RuntimeException) { assertFormat("Address"); return a_Address; }
631 /** Access content for Time Avp */
632 const Time * getTime() const throw(anna::RuntimeException) { assertFormat("Time"); return a_Time; }
633 /** Access content for UTF8String Avp */
634 const UTF8String * getUTF8String() const throw(anna::RuntimeException) { assertFormat("UTF8String"); return a_UTF8String; }
635 /** Access content for DiameterIdentity Avp */
636 const DiameterIdentity * getDiameterIdentity() const throw(anna::RuntimeException) { assertFormat("DiameterIdentity"); return a_DiameterIdentity; }
637 /** Access content for DiameterURI Avp */
638 const DiameterURI * getDiameterURI() const throw(anna::RuntimeException) { assertFormat("DiameterURI"); return a_DiameterURI; }
639 /** Access content for Enumerated Avp */
640 const Enumerated * getEnumerated() const throw(anna::RuntimeException) { assertFormat("Enumerated"); return a_Enumerated; }
641 /** Access content for IPFilterRule Avp */
642 const IPFilterRule * getIPFilterRule() const throw(anna::RuntimeException) { assertFormat("IPFilterRule"); return a_IPFilterRule; }
643 /** Access content for QoSFilterRule Avp */
644 const QoSFilterRule * getQoSFilterRule() const throw(anna::RuntimeException) { assertFormat("QoSFilterRule"); return a_QoSFilterRule; }
645 /** Access content for Unknown Avp */
646 const Unknown * getUnknown() const throw(anna::RuntimeException) { assertFormat("Unknown"); return a_Unknown; }
650 Decodes buffer provided over class content. If an error ocurred, decoding will stop launching exception (fatal error) or a warning trace (perhaps the achieved
651 avp is valid against all odds then validation will go on). In case that validation is enabled (codec::Engine::ValidationMode) an exception will be launched
652 depending on validation depth (codec::Engine::ValidationDepth).
654 Useful as serialization procedure with #code
656 @param db Buffer data block processed
658 void decode(const anna::DataBlock &db) throw(anna::RuntimeException);
662 Interpret xml data in order to dump over the class content.
664 \param avpNode Avp root node
666 void fromXML(const anna::xml::Node* avpNode) throw(anna::RuntimeException);
670 Encodes buffer with the class content. This method is internally used to encode diameter messages, but is declared as public, to allow
671 its use as serialization procedure. Then, it's assumed that this Avp is valid (validation shall be applied as part of a whole diameter
672 message but nothing will be verified now).
674 * @param buffer Raw data to be encoded (shall be externally allocated)
675 * @param size Size of raw data to be encoded
677 void code(char* buffer, int &size) const throw(anna::RuntimeException);
683 Class xml representation
684 \param parent Parent XML node on which hold this instance information.
685 \return XML document with relevant information for this instance.
687 anna::xml::Node* asXML(anna::xml::Node* parent) const throw();
690 Class xml string representation
691 \return XML string representation with relevant information for this instance.
693 std::string asXMLString() const throw();
696 Comparison operator by mean serialization
698 @param a1 Instance 1 for Avp class
699 @param a2 Instance 2 for Avp class
701 @return Comparison result
703 friend bool operator == (const Avp & a1, const Avp & a2) throw() { return (a1.asXMLString() == a2.asXMLString()); }
706 Match a regular expression (string pattern) regarding xml string serialization for this avp.
707 This works same as #Message::isLike
709 @param pattern Pattern to match
711 \return Returns the match result
713 bool isLike(const std::string &pattern) const throw();
716 Counts the number of ocurrences of Avps (first level) with the identifier provided
718 @param id Avp identifier (pair code + vendor-id).
720 int countAvp(AvpId id) const throw(anna::RuntimeException) { assertFormat("Grouped"); return countAvp(a_avps, id); }
723 Same as #countAvp but providing dictionary logical name for Avp searched
725 int countAvp(const char *name) const throw(anna::RuntimeException);
728 Counts the number of children within a grouped avp
730 @param id Avp identifier (pair code + vendor-id).
732 int countChilds() const throw(anna::RuntimeException) { assertFormat("Grouped"); return countChilds(a_avps); }
735 The 'M' Bit, known as the Mandatory bit, indicates whether support of the AVP is required. If an AVP with the 'M' bit set is received by
736 a Diameter client, server, proxy, or translation agent and either the AVP or its value is unrecognized, the message MUST be rejected.
737 Diameter Relay and redirect agents MUST NOT reject messages with unrecognized AVPs.
739 Default implementation launch alarm and counter indicating the anomaly but don't launch exception (traces at warning level).
740 Relay and Redirect agents could reimplement this method to avoid oam management (another way is avoid alarm/counter registration on
741 these applications). Result-Code DIAMETER_AVP_UNSUPPORTED will be stored for possible answer message.
743 virtual void unknownAvpWithMandatoryBit() const throw(anna::RuntimeException);
746 friend class Message;