Avp.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_diameter_codec_Avp_hpp
#define anna_diameter_codec_Avp_hpp


// Local
#include <anna/config/defines.hpp>
#include <anna/diameter/defines.hpp>
#include <anna/diameter/codec/basetypes/basetypes.hpp>
#include <anna/diameter/codec/functions.hpp>
#include <anna/diameter/stack/Avp.hpp>

#include <anna/core/RuntimeException.hpp>

// STL
#include <string>
#include <map>

//------------------------------------------------------------------------------
//---------------------------------------------------------------------- #define
//------------------------------------------------------------------------------

namespace anna {

class DataBlock;

namespace xml {
class Node;
class Attribute;
}
}

namespace anna {

namespace diameter {


namespace stack {
class Dictionary;
class Format;
class Avp;
}

namespace codec {

namespace basetypes {
class OctetString;
class Integer32;
class Integer64;
class Unsigned32;
class Unsigned64;
class Float32;
class Float64;
class Address;
class Time;
class UTF8String;
class DiameterIdentity;
class DiameterURI;
class Enumerated;
class IPFilterRule;
class QoSFilterRule;
class Unknown;
}

class Avp;
class Message;
class Engine;


typedef std::map < int /* key: insertion pos */, Avp* > avp_container;
typedef avp_container::iterator avp_iterator;
typedef avp_container::const_iterator const_avp_iterator;

// Cache avp-find system
typedef std::pair < AvpId, unsigned int /* position */ > find_key;
typedef std::map<find_key, Avp*> find_container;
typedef std::map<find_key, Avp*>::iterator find_iterator;


using namespace basetypes;

class Avp {

  AvpId a_id;          // code and vendor-code
  U8 a_flags;

  // auxiliary
  int a_insertionPositionForChilds; // used at grouped type


  // --- Developer notes ---
  // 'AVP Length' does not include posible data padding. Thanks to this, 'Data Length'
  // is the difference between 'AVP Length' and sum of code, length, flags and
  // optionally the vendor-ID (all of them are 32-bit boundary), that is to say:
  // 8 or 12 (vendor-specific avps).
  //
  // Grouped avps 'AVP Length' includes own headers plus the total length of all
  //  underlying AVPs, including their headers and padding, then 'AVP Length' is
  //  always multiple of 4 (library will check this), and smae for 'Data Length'
  //  which is an 'whole avp Length with padding' itself.

  // Data containers
  OctetString *a_OctetString;
  Integer32 *a_Integer32;
  Integer64 *a_Integer64;
  Unsigned32 *a_Unsigned32;
  Unsigned64 *a_Unsigned64;
  Float32 *a_Float32;
  Float64 *a_Float64;
  avp_container a_avps; // Grouped
  Address *a_Address;
  Time *a_Time;
  UTF8String *a_UTF8String;
  DiameterIdentity *a_DiameterIdentity;
  DiameterURI *a_DiameterURI;
  Enumerated *a_Enumerated;
  IPFilterRule *a_IPFilterRule;
  QoSFilterRule *a_QoSFilterRule;
  Unknown *a_Unknown;

  // Grouped helpers
  find_container a_finds; // fast access for grouped and message first-level avps


  // 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
  //  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
  //  instantiating the class. Friend functions are functions which are not in the class and you want to give them access to private members
  //  of your class.

  // Common (also for Message class)
  static avp_iterator avp_find(avp_container &avps, AvpId id, unsigned int position) ;
  static const_avp_iterator avp_find(const avp_container &avps, AvpId id, unsigned int position) {
    return (const_avp_iterator)avp_find((avp_container &)avps, id, position);
  }
  static Avp * addAvp(avp_container &avps, int &insertionPositionForChilds, AvpId id, Engine *engine) ;
  static bool removeAvp(avp_container &avps, find_container &finds, AvpId id, int ocurrence, Engine *engine) ;
  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) ;
  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) noexcept(false); // validates mandatory/fixed and cardinality
  static const Avp* getAvp(const avp_container &avps, find_container &finds, AvpId id, int ocurrence, Engine *engine, anna::Exception::Mode::_v emode) noexcept(false);
  static int countAvp(const avp_container &avps, AvpId id) ;
  static const Avp* firstAvp(const avp_container &avps, AvpId id) ;
  static int countChilds(const avp_container &avps) ;
  static int addChild(avp_container &avps, int &insertionPositionForChilds, Avp *avp) {
    if(!avp) return -1;

    avps[insertionPositionForChilds++] = avp;
    return insertionPositionForChilds;
  }
  static const anna::diameter::stack::Avp *getStackAvp(AvpId id, Engine *engine) ;
  const Avp* _getAvp(const char *name, int ocurrence, anna::Exception::Mode::_v emode) const noexcept(false);
  const Avp* _getAvp(AvpId id, int ocurrence, anna::Exception::Mode::_v emode) const noexcept(false);

  // Own
  avp_iterator avp_begin() { return a_avps.begin(); }
  avp_iterator avp_end() { return a_avps.end(); }
  static Avp* avp(avp_iterator ii) { return ii->second; }
  const_avp_iterator avp_begin() const { return a_avps.begin(); }
  const_avp_iterator avp_end() const { return a_avps.end(); }
  static const Avp* avp(const_avp_iterator ii) { return ii->second; }

  // Internal
  bool flagsOK() const ; // flags coherence regarding dictionary. Only must be called when AVP is identified at the dictionary.
  int addChild(Avp *avp) noexcept(false) { assertFormat("Grouped"); return addChild(a_avps, a_insertionPositionForChilds, avp); }
  bool hasChildren() { return a_avps.size() != 0; }

  static bool contain(const_avp_iterator begin, const_avp_iterator end, const Avp *parent) { return true; }


  void fix() ;

  bool valid(const anna::diameter::codec::parent_t & parent, Message *answer) const noexcept(false);

  void decode(const anna::DataBlock &db, const anna::diameter::codec::parent_t & parent, Message *answer) noexcept(false);


  // Inherit format-specific virtual methods //

  virtual void initializeByFormat() {};

  virtual U24 getLengthByFormat(const anna::diameter::stack::Format *stackFormat) const { return 0; };

  virtual std::string getXMLdataByFormat(bool & isHex, const anna::diameter::stack::Format *stackFormat) const { return ""; };

  virtual void fromXMLByFormat(const anna::xml::Attribute* data, const anna::xml::Attribute* hexData, const anna::diameter::stack::Format *stackFormat) noexcept(false) {};


  virtual void codeByFormat(char* dataPart, const anna::diameter::stack::Format *stackFormat) const noexcept(false) {};


  virtual void decodeDataPartByFormat(const char * buffer, int size, const anna::diameter::stack::Format *stackFormat) noexcept(false) {};

  virtual void allocationByFormat(const anna::diameter::stack::Format *stackFormat) {};

  virtual void clearByFormat() {};



protected:

  mutable Engine *a_engine;

  virtual Engine * getEngine() const noexcept(false);

  void initialize() ;

  void assertFormat(const std::string &name) const noexcept(false);

  U24 getLength() const ;

  std::string getXMLdata(bool & isHex, const anna::diameter::stack::Format *stackFormat) const ;


  void decodeDataPart(const char * buffer, int size, const anna::diameter::codec::parent_t & parent, Message *answer) noexcept(false);


public:

  Avp(Engine *engine = NULL);

  Avp(AvpId id, Engine *engine = NULL);


  void setEngine(Engine *engine) ;


  // Length references
  static const int HeaderLengthVactive;
  static const int HeaderLengthVinactive;

  //    AVP Flags
  //    +-+-+-+-+-+-+-+-+
  //    |V M P r r r r r|
  //    +-+-+-+-+-+-+-+-+
  //
  //      V(endor-specific)
  //      M(andatory)
  //      (encry)P(tion) (end to end encryption)
  //      r(eserved)  - these flag bits are reserved for future use, and
  //                    MUST be set to zero, and ignored by the receiver.
  static const U8 VBitMask;
  static const U8 MBitMask;
  static const U8 PBitMask;

  virtual ~Avp();


  // setters

  void clear() noexcept(false);


  void setId(AvpId id) noexcept(false);

  void setId(const char *name) noexcept(false);

  void setMandatoryBit(bool activate = true) { if(activate) a_flags |= MBitMask; else a_flags &= (~MBitMask); }

  void setEncryptionBit(bool activate = true) { if(activate) a_flags |= PBitMask; else a_flags &= (~PBitMask); }


  Avp * addAvp(AvpId id) noexcept(false) { assertFormat("Grouped"); return addAvp(a_avps, a_insertionPositionForChilds, id, getEngine()); }


  Avp * addAvp(const char *name) noexcept(false);

  Avp * addAvp(Avp * avp) noexcept(false);


  // Data part access
  OctetString *        getOctetString() noexcept(false) { assertFormat("OctetString"); return a_OctetString; }
  Integer32 *          getInteger32() noexcept(false) { assertFormat("Integer32"); return a_Integer32; }
  Integer64 *          getInteger64() noexcept(false) { assertFormat("Integer64"); return a_Integer64; }
  Unsigned32 *         getUnsigned32() noexcept(false) { assertFormat("Unsigned32"); return a_Unsigned32; }
  Unsigned64 *         getUnsigned64() noexcept(false) { assertFormat("Unsigned64"); return a_Unsigned64; }
  Float32 *            getFloat32() noexcept(false) { assertFormat("Float32"); return a_Float32; }
  Float64 *            getFloat64() noexcept(false) { assertFormat("Float64"); return a_Float64; }
  Address *            getAddress() noexcept(false) { assertFormat("Address"); return a_Address; }
  Time *               getTime() noexcept(false) { assertFormat("Time"); return a_Time; }
  UTF8String *         getUTF8String() noexcept(false) { assertFormat("UTF8String"); return a_UTF8String; }
  DiameterIdentity *   getDiameterIdentity() noexcept(false) { assertFormat("DiameterIdentity"); return a_DiameterIdentity; }
  DiameterURI *        getDiameterURI() noexcept(false) { assertFormat("DiameterURI"); return a_DiameterURI; }
  Enumerated *         getEnumerated() noexcept(false) { assertFormat("Enumerated"); return a_Enumerated; }
  IPFilterRule *       getIPFilterRule() noexcept(false) { assertFormat("IPFilterRule"); return a_IPFilterRule; }
  QoSFilterRule *      getQoSFilterRule() noexcept(false) { assertFormat("QoSFilterRule"); return a_QoSFilterRule; }
  Unknown *            getUnknown() noexcept(false) { assertFormat("Unknown"); return a_Unknown; }


  bool removeAvp(AvpId id, int ocurrence = 1) noexcept(false) { assertFormat("Grouped"); return removeAvp(a_avps, (find_container&)a_finds, id, ocurrence, getEngine()); }


  bool removeAvp(const char *name, int ocurrence = 1) noexcept(false);

  // getters

  const AvpId & getId() const { return a_id; }

  int getVendorId() const { return a_id.second; }

  const anna::diameter::stack::Avp *getStackAvp() const noexcept(false) { return getStackAvp(a_id, getEngine()); }

  bool vendorBit() const { return ((a_flags & VBitMask) != 0x00); }

  bool mandatoryBit() const { return ((a_flags & MBitMask) != 0x00); }

  bool encryptionBit() const { return ((a_flags & PBitMask) != 0x00); }

  // Data part access
  const OctetString *        getOctetString() const noexcept(false) { assertFormat("OctetString"); return a_OctetString; }
  const Integer32 *          getInteger32() const noexcept(false) { assertFormat("Integer32"); return a_Integer32; }
  const Integer64 *          getInteger64() const noexcept(false) { assertFormat("Integer64"); return a_Integer64; }
  const Unsigned32 *         getUnsigned32() const noexcept(false) { assertFormat("Unsigned32"); return a_Unsigned32; }
  const Unsigned64 *         getUnsigned64() const noexcept(false) { assertFormat("Unsigned64"); return a_Unsigned64; }
  const Float32 *            getFloat32() const noexcept(false) { assertFormat("Float32"); return a_Float32; }
  const Float64 *            getFloat64() const noexcept(false) { assertFormat("Float64"); return a_Float64; }

  const Avp* getAvp(AvpId id, int ocurrence = 1, anna::Exception::Mode::_v emode = anna::Exception::Mode::Throw) const noexcept(false) {
    return _getAvp(id, ocurrence, emode);
  }

  Avp* getAvp(AvpId id, int ocurrence = 1, anna::Exception::Mode::_v emode = anna::Exception::Mode::Throw) noexcept(false) {
    return const_cast<Avp*>(_getAvp(id, ocurrence, emode));
  }

  const Avp* getAvp(const char *name, int ocurrence = 1, anna::Exception::Mode::_v emode = anna::Exception::Mode::Throw) const noexcept(false) {
    return _getAvp(name, ocurrence, emode);
  }

  Avp* getAvp(const char *name, int ocurrence = 1, anna::Exception::Mode::_v emode = anna::Exception::Mode::Throw) noexcept(false) {
    return const_cast<Avp*>(_getAvp(name, ocurrence, emode));
  }



  const Address *            getAddress() const noexcept(false) { assertFormat("Address"); return a_Address; }
  const Time *               getTime() const noexcept(false) { assertFormat("Time"); return a_Time; }
  const UTF8String *         getUTF8String() const noexcept(false) { assertFormat("UTF8String"); return a_UTF8String; }
  const DiameterIdentity *   getDiameterIdentity() const noexcept(false) { assertFormat("DiameterIdentity"); return a_DiameterIdentity; }
  const DiameterURI *        getDiameterURI() const noexcept(false) { assertFormat("DiameterURI"); return a_DiameterURI; }
  const Enumerated *         getEnumerated() const noexcept(false) { assertFormat("Enumerated"); return a_Enumerated; }
  const IPFilterRule *       getIPFilterRule() const noexcept(false) { assertFormat("IPFilterRule"); return a_IPFilterRule; }
  const QoSFilterRule *      getQoSFilterRule() const noexcept(false) { assertFormat("QoSFilterRule"); return a_QoSFilterRule; }
  const Unknown *            getUnknown() const noexcept(false) { assertFormat("Unknown"); return a_Unknown; }


  void decode(const anna::DataBlock &db) noexcept(false);


  void fromXML(const anna::xml::Node* avpNode) noexcept(false);


  void code(char* buffer, int &size) const noexcept(false);


  // Helpers

  anna::xml::Node* asXML(anna::xml::Node* parent) const ;

  std::string asXMLString(bool normalize = false) const ;

  friend bool operator == (const Avp & a1, const Avp & a2) { return (a1.asXMLString() == a2.asXMLString()); }

  bool isLike(const std::string &pattern) const ;

  int countAvp(AvpId id) const noexcept(false) { assertFormat("Grouped"); return countAvp(a_avps, id); }

  int countAvp(const char *name) const noexcept(false);

  int countChilds() const noexcept(false) { assertFormat("Grouped"); return countChilds(a_avps); }

  virtual void unknownAvpWithMandatoryBit() const noexcept(false);


  friend class Message;
  friend class Engine;
};

}
}
}


#endif