ccsrc/Ports/LibSip/module.mk

+sources := SipPort.cc
+includes := .
+

ccsrc/Ports/Naptr/NaptrPort.cc

+#include "NaptrPort.hh"
+#include "naptrPort_layer_factory.hh"
+#include "loggers.hh"
+
+namespace AtsImsIot__TestSystem {
+
+  NaptrPort::NaptrPort(const char *par_port_name): NaptrPort_BASE(par_port_name), _cfg_params(), _layer_params(), _layer(nullptr), _time_key("NaptrPort::outgoing_send") {
+    // Nothing to do
+  } // End of constructor
+
+  NaptrPort::~NaptrPort() {
+    loggers::get_instance().log(">>> NaptrPort::~NaptrPort");
+
+    if (_layer != nullptr) {
+      delete _layer;
+    }
+  } // End of destructor
+
+  void NaptrPort::set_parameter(const char * parameter_name, const char * parameter_value)
+  {
+    loggers::get_instance().log("NaptrPort::set_parameter: %s=%s", parameter_name, parameter_value);
+    _cfg_params.insert(std::pair<std::string, std::string>(std::string(parameter_name), std::string(parameter_value)));
+  }
+
+  /*void NaptrPort::Handle_Fd_Event(int fd, boolean is_readable,
+    boolean is_writable, boolean is_error) {}*/
+
+  void NaptrPort::Handle_Fd_Event_Error(int /*fd*/)
+  {
+
+  }
+
+  void NaptrPort::Handle_Fd_Event_Writable(int /*fd*/)
+  {
+
+  }
+
+  void NaptrPort::Handle_Fd_Event_Readable(int /*fd*/)
+  {
+
+  }
+
+  /*void NaptrPort::Handle_Timeout(double time_since_last_call) {}*/
+
+  void NaptrPort::user_map(const char * system_port)
+  {
+    loggers::get_instance().log(">>> NaptrPort::user_map: %s", system_port);
+    // Build layer stack
+    params::iterator it = _cfg_params.find(std::string("params"));
+    if (it != _cfg_params.end()) {
+      loggers::get_instance().log("NaptrPort::user_map: %s", it->second.c_str());
+      // Setup parameters
+      params::convert(_layer_params, it->second); // TODO This _layer_params seems to be useless
+      // Create layer
+      _layer = layer_stack_builder::get_instance()->create_layer_stack(it->second.c_str());
+      if (static_cast<naptr_layer *>(_layer) == nullptr) {
+        loggers::get_instance().error("NaptrPort::user_map: Invalid stack configuration: %s", it->second.c_str());
+      }
+      static_cast<naptr_layer *>(_layer)->add_upper_port(this);
+
+    } else {
+      loggers::get_instance().error("NaptrPort::user_map: No layers defined in configuration file");
+    }
+  } // End of user_map method
+
+  void NaptrPort::user_unmap(const char * system_port)
+  {
+    loggers::get_instance().log(">>> NaptrPort::user_unmap: %s", system_port);
+
+    // Reset layers
+    if (_layer != nullptr) {
+      delete _layer;
+      _layer = nullptr;
+    }
+  } // End of user_unmap method
+
+  void NaptrPort::user_start()
+  {
+    loggers::get_instance().log(">>> NaptrPort::user_start");
+
+  } // End of user_start method
+
+  void NaptrPort::user_stop()
+  {
+    loggers::get_instance().log(">>> NaptrPort::user_stop");
+
+  } // End of user_stop method
+
+  void NaptrPort::receiveMsg (const AtsImsIot__TypesAndValues::NAPTRmessage& p_ind, const params& p_params) {
+    loggers::get_instance().log_msg(">>> NaptrPort::receive_msg: ", p_ind);
+    
+    // Sanity check
+    if (!p_ind.is_bound()) {
+      return;
+    }
+
+      incoming_message(p_ind);
+    
+  } // End of method receiveMsg
+  
+  void NaptrPort::outgoing_send(const AtsImsIot__TypesAndValues::NAPTRmessage& send_par)
+  {
+    loggers::get_instance().log_msg(">>> NaptrPort::outgoing_send: ", send_par);
+
+    float duration;
+    loggers::get_instance().set_start_time(_time_key);
+    params params;
+    static_cast<naptr_layer*>(_layer)->sendMsg(send_par, params);
+    loggers::get_instance().set_stop_time(_time_key, duration);
+  } // End of outgoing_send
+  
+}
+

ccsrc/Ports/Naptr/NaptrPort.hh

+#pragma once
+
+#include "AtsImsIot_TestSystem.hh"
+
+#include "layer.hh"
+#include "params.hh"
+
+namespace AtsImsIot__TestSystem {
+
+  class NaptrPort : public NaptrPort_BASE {
+    params _cfg_params;
+    params _layer_params;
+    layer* _layer;
+    std::string _time_key;
+  public:
+    NaptrPort(const char *par_port_name);
+    ~NaptrPort();
+
+    void set_parameter(const char *parameter_name, const char *parameter_value);
+    
+    void receiveMsg (const AtsImsIot__TypesAndValues::NAPTRmessage& p_ind, const params& p_params);
+
+  private:
+    /* void Handle_Fd_Event(int fd, boolean is_readable,
+       boolean is_writable, boolean is_error); */
+    void Handle_Fd_Event_Error(int fd);
+    void Handle_Fd_Event_Writable(int fd);
+    void Handle_Fd_Event_Readable(int fd);
+    /* void Handle_Timeout(double time_since_last_call); */
+
+  protected:
+    void user_map(const char *system_port);
+    void user_unmap(const char *system_port);
+
+    void user_start();
+    void user_stop();
+
+  protected:
+    virtual void outgoing_send(const AtsImsIot__TypesAndValues::NAPTRmessage& send_par);
+  }; // End of class NaptrPort
+
+}
+

ccsrc/Ports/Naptr/module.mk

+sources := NaptrPort.cc
+includes := .
+

ccsrc/Ports/Sgi/SgiPort.cc

+#include "SgiPort.hh"
+#include "loggers.hh"
+
+namespace AtsImsIot__TestSystem {
+
+  SgiPort::SgiPort(const char *par_port_name): SgiPort_BASE(par_port_name), _cfg_params(), _layer_params(), _layer(nullptr), _time_key("SgiPort::outgoing_send") {
+    // Nothing to do
+  } // End of constructor
+
+  SgiPort::~SgiPort() {
+    loggers::get_instance().log(">>> SgiPort::~SgiPort");
+
+    if (_layer != nullptr) {
+      delete _layer;
+    }
+  } // End of destructor
+
+  void SgiPort::set_parameter(const char * parameter_name, const char * parameter_value)
+  {
+    loggers::get_instance().log("SgiPort::set_parameter: %s=%s", parameter_name, parameter_value);
+    _cfg_params.insert(std::pair<std::string, std::string>(std::string(parameter_name), std::string(parameter_value)));
+  }
+
+  /*void SgiPort::Handle_Fd_Event(int fd, boolean is_readable,
+    boolean is_writable, boolean is_error) {}*/
+
+  void SgiPort::Handle_Fd_Event_Error(int /*fd*/)
+  {
+
+  }
+
+  void SgiPort::Handle_Fd_Event_Writable(int /*fd*/)
+  {
+
+  }
+
+  void SgiPort::Handle_Fd_Event_Readable(int /*fd*/)
+  {
+
+  }
+
+  /*void SgiPort::Handle_Timeout(double time_since_last_call) {}*/
+
+  void SgiPort::user_map(const char * system_port)
+  {
+    loggers::get_instance().log(">>> SgiPort::user_map: %s", system_port);
+  } // End of user_map method
+
+  void SgiPort::user_unmap(const char * system_port)
+  {
+    loggers::get_instance().log(">>> SgiPort::user_unmap: %s", system_port);
+
+    // Reset layers
+    if (_layer != nullptr) {
+      delete _layer;
+      _layer = nullptr;
+    }
+  } // End of user_unmap method
+
+  void SgiPort::user_start()
+  {
+    loggers::get_instance().log(">>> SgiPort::user_start");
+
+  } // End of user_start method
+
+  void SgiPort::user_stop()
+  {
+    loggers::get_instance().log(">>> SgiPort::user_stop");
+
+  } // End of user_stop method
+  
+}
+

ccsrc/Ports/Sgi/SgiPort.hh

+#pragma once
+
+#include "AtsImsIot_TestSystem.hh"
+
+#include "layer.hh"
+#include "params.hh"
+
+namespace AtsImsIot__TestSystem {
+
+  class SgiPort : public SgiPort_BASE {
+    params _cfg_params;
+    params _layer_params;
+    layer* _layer;
+    std::string _time_key;
+  public:
+    SgiPort(const char *par_port_name);
+    ~SgiPort();
+
+    void set_parameter(const char *parameter_name, const char *parameter_value);
+    
+    void receiveMsg (const CHARSTRING& p_ind, const params& p_params) {};
+
+  private:
+    /* void Handle_Fd_Event(int fd, boolean is_readable,
+       boolean is_writable, boolean is_error); */
+    void Handle_Fd_Event_Error(int fd);
+    void Handle_Fd_Event_Writable(int fd);
+    void Handle_Fd_Event_Readable(int fd);
+    /* void Handle_Timeout(double time_since_last_call); */
+
+  protected:
+    void user_map(const char *system_port);
+    void user_unmap(const char *system_port);
+
+    void user_start();
+    void user_stop();
+
+  protected:
+  }; // End of class SgiPort
+
+}
+

ccsrc/Ports/Sgi/module.mk

+sources := SgiPort.cc
+includes := .
+

ccsrc/Protocols/Diameter/avp.cc

+#include <string>
+
+#include "avp.hh"
+
+#include "loggers.hh"
+#include "converter.hh"
+
+avp::avp(const int p_code, const unsigned char p_vendor_specific, const unsigned char p_mandatory, const unsigned char p_protected_, const int p_length, const int p_vendor_id, const int p_encoded_length, const std::vector<unsigned char> p_payload) : _code(p_code), _vendor_specific(p_vendor_specific), _mandatory(p_mandatory), _protected_(p_protected_), _length(p_length), _vendor_id(p_vendor_id), _encoded_length(p_encoded_length), _payload(p_payload),   _avp_header(LibDiameter__Types__Base__AVPs::AVP__Header(p_code, LibDiameter__Types__Base__AVPs::AVP__Flags( int2bit(p_vendor_specific, 1), int2bit(p_mandatory, 1), int2bit(p_protected_, 1), int2bit(0, 5)), p_length, (p_vendor_specific == 0) ? OPTIONAL<INTEGER>(OPTIONAL_OMIT) : OPTIONAL<INTEGER>(p_vendor_id))), _enc_avp() {
+  loggers::get_instance().log_msg("avp::avp (1): _avp_header:", _avp_header);
+  loggers::get_instance().log_to_hexa("avp::avp (1): _payload:", _payload.data(), _payload.size());
+} // End of ctor
+
+avp::avp(const int p_code, const unsigned char p_vendor_specific, const unsigned char p_mandatory, const unsigned char p_protected_, const int p_length, const int p_vendor_id, const int p_encoded_length, const std::vector<unsigned char> p_payload, const OCTETSTRING& p_enc_avp) : _code(p_code), _vendor_specific(p_vendor_specific), _mandatory(p_mandatory), _protected_(p_protected_), _length(p_length), _vendor_id(p_vendor_id), _encoded_length(p_encoded_length), _payload(p_payload),   _avp_header(LibDiameter__Types__Base__AVPs::AVP__Header(p_code, LibDiameter__Types__Base__AVPs::AVP__Flags( int2bit(p_vendor_specific, 1), int2bit(p_mandatory, 1), int2bit(p_protected_, 1), int2bit(0, 5)), p_length, (p_vendor_specific == 0) ? OPTIONAL<INTEGER>(OPTIONAL_OMIT) : OPTIONAL<INTEGER>(p_vendor_id))), _enc_avp(p_enc_avp) {
+  loggers::get_instance().log_msg("avp::avp (2): _avp_header:", _avp_header);
+  loggers::get_instance().log_to_hexa("avp::avp (2): _payload:", _payload.data(), _payload.size());
+  loggers::get_instance().log_msg("avp::avp (2): _enc_avp:", _enc_avp);
+} // End of ctor
+
+int avp::get_code() const {
+  return _code;
+}
+
+int avp::decode_session_id(LibDiameter__Types__Base__AVPs::Session__Id__AVP& p_avp) const {
+  loggers::get_instance().log(">>> avp::decode_session_id: '%d'", _code);
+  loggers::get_instance().log_to_hexa("avp::decode_session_id: _payload:", _payload.data(), _payload.size());
+
+  p_avp = LibDiameter__Types__Base__AVPs::Session__Id__AVP(LibDiameter__Types__Base__AVPs::AVP__Header(_avp_header), CHARSTRING(converter::get_instance().bytes_to_string(_payload).c_str()));
+  loggers::get_instance().log_msg("avp::decode_session_id: p_avp:", p_avp);
+
+  return 0;
+}
+
+int avp::decode_auth_session_state(LibDiameter__Types__Base__AVPs::Auth__Session__State__AVP& p_avp) const {
+  loggers::get_instance().log(">>> avp::decode_auth_session_state: '%d'", _code);
+  loggers::get_instance().log_to_hexa("avp::decode_auth_session_state: _payload:", _payload.data(), _payload.size());
+
+  // Sanity checks
+  if (_payload.size() != 4) {
+    loggers::get_instance().warning("avp::decode_auth_session_state: Wrong payload length: '%d'", _payload.size());
+    return -1;
+  }
+  p_avp = LibDiameter__Types__Base__AVPs::Auth__Session__State__AVP(LibDiameter__Types__Base__AVPs::AVP__Header(_avp_header), LibDiameter__Types__Base__AVPs::Auth__Session__State__Type(_payload[0] << 24 || _payload[1] << 16 || _payload[2] << 8 || _payload[3]));
+  loggers::get_instance().log_msg("avp::decode_auth_session_state: p_avp:", p_avp);
+
+  return 0;
+}
+
+int avp::decode_origin_host(LibDiameter__Types__Base__AVPs::Origin__Host__AVP& p_avp) const {
+  loggers::get_instance().log(">>> avp::decode_origin_host: '%d'", _code);
+  loggers::get_instance().log_to_hexa("avp::decode_origin_host: _payload:", _payload.data(), _payload.size());
+
+  p_avp = LibDiameter__Types__Base__AVPs::Origin__Host__AVP(LibDiameter__Types__Base__AVPs::AVP__Header(_avp_header), CHARSTRING(converter::get_instance().bytes_to_string(_payload).c_str()));
+  loggers::get_instance().log_msg("avp::decode_origin_host: p_avp:", p_avp);
+
+  return 0;
+}
+
+int avp::decode_origin_realm(LibDiameter__Types__Base__AVPs::Origin__Realm__AVP& p_avp) const {
+  loggers::get_instance().log(">>> avp::decode_origin_realm: '%d'", _code);
+  loggers::get_instance().log_to_hexa("avp::decode_origin_realm: _payload:", _payload.data(), _payload.size());
+
+  p_avp = LibDiameter__Types__Base__AVPs::Origin__Realm__AVP(LibDiameter__Types__Base__AVPs::AVP__Header(_avp_header), CHARSTRING(converter::get_instance().bytes_to_string(_payload).c_str()));
+  loggers::get_instance().log_msg("avp::decode_origin_realm: p_avp:", p_avp);
+
+  return 0;
+}
+
+int avp::decode_destination_host(LibDiameter__Types__Base__AVPs::Destination__Host__AVP& p_avp) const {
+  loggers::get_instance().log(">>> avp::decode_destination_host: '%d'", _code);
+  loggers::get_instance().log_to_hexa("avp::decode_destination_host: _payload:", _payload.data(), _payload.size());
+
+  p_avp = LibDiameter__Types__Base__AVPs::Destination__Host__AVP(LibDiameter__Types__Base__AVPs::AVP__Header(_avp_header), CHARSTRING(converter::get_instance().bytes_to_string(_payload).c_str()));
+  loggers::get_instance().log_msg("avp::decode_destination_host: p_avp:", p_avp);
+
+  return 0;
+}
+
+int avp::decode_destination_realm(LibDiameter__Types__Base__AVPs::Destination__Realm__AVP& p_avp) const {
+  loggers::get_instance().log(">>> avp::decode_destination_realm: '%d'", _code);
+  loggers::get_instance().log_to_hexa("avp::decode_destination_realm: _payload:", _payload.data(), _payload.size());
+
+  p_avp = LibDiameter__Types__Base__AVPs::Destination__Realm__AVP(LibDiameter__Types__Base__AVPs::AVP__Header(_avp_header), CHARSTRING(converter::get_instance().bytes_to_string(_payload).c_str()));
+  loggers::get_instance().log_msg("avp::decode_destination_realm: p_avp:", p_avp);
+
+  return 0;
+}
+

ccsrc/Protocols/Diameter/avp.hh

+#pragma once
+
+#include <vector>
+#include <memory>
+
+
+#include "LibDiameter_TypesAndValues.hh"
+
+class avp {
+    const int _code;
+    const unsigned char _vendor_specific;
+    const unsigned char _mandatory;
+    const unsigned char _protected_;
+    const int _length;
+    const int _vendor_id;
+    const int _encoded_length;
+    const std::vector<unsigned char> _payload;
+    const OCTETSTRING _enc_avp;
+    const LibDiameter__Types__Base__AVPs::AVP__Header _avp_header;
+public:
+  avp(const int p_code, const unsigned char p_vendor_specific, const unsigned char p_mandatory, const unsigned char p_protected_, const int p_length, const int p_vendor_id, const int p_encoded_length, const std::vector<unsigned char> p_payload);
+  avp(const int p_code, const unsigned char p_vendor_specific, const unsigned char p_mandatory, const unsigned char p_protected_, const int p_length, const int p_vendor_id, const int p_encoded_length, const std::vector<unsigned char> p_payload, const OCTETSTRING& p_enc_avp);
+  virtual ~avp() {};
+
+  int get_code() const;
+
+  int encode_auth_session_state(const LibDiameter__Types__Base__AVPs::Auth__Session__State__AVP& p_avp, std::unique_ptr<avp>& p_encoded_avp);
+
+  int decode_session_id(LibDiameter__Types__Base__AVPs::Session__Id__AVP& p_avp) const;
+  int decode_auth_session_state(LibDiameter__Types__Base__AVPs::Auth__Session__State__AVP& p_avp) const;
+  int decode_origin_host(LibDiameter__Types__Base__AVPs::Origin__Host__AVP& p_avp) const;
+  int decode_origin_realm(LibDiameter__Types__Base__AVPs::Origin__Realm__AVP& p_avp) const;
+  int decode_destination_host(LibDiameter__Types__Base__AVPs::Destination__Host__AVP& p_avp) const;
+  int decode_destination_realm(LibDiameter__Types__Base__AVPs::Destination__Realm__AVP& p_avp) const;
+
+}; // End of class avp
\ No newline at end of file

ccsrc/Protocols/Diameter/diameter_codec.cc

+#include <string>
+
+#include "LibDiameter_TypesAndValues.hh"
+
+#include "diameter_codec.hh"
+
+#include "loggers.hh"
+#include "converter.hh"
+
+template <typename T_type> class OPTIONAL;
+class TTCN_Buffer;
+class TTCN_EncDec;
+
+diameter_codec::~diameter_codec() {
+  loggers::get_instance().log(">>> diameter_codec::~diameter_codec");
+  if (_avps.size() != 0) {
+    _avps.clear();
+  }
+}
+
+int diameter_codec::encode_header(const LibDiameter__TypesAndValues::DiameterHeader& p_header, TTCN_Buffer& p_encoding_buffer) {
+  loggers::get_instance().log_msg(">>> diameter_codec::encode_header: ", (const Base_Type &)p_header);
+
+  p_encoding_buffer.put_c(p_header.version());
+
+  p_encoding_buffer.put_c(static_cast<const unsigned char>((p_header.msglen() >> 16) & 0xFF));
+  p_encoding_buffer.put_c(static_cast<const unsigned char>((p_header.msglen() >> 8) & 0xFF));
+  p_encoding_buffer.put_c(static_cast<const unsigned char>((p_header.msglen()) & 0xFF));
+
+  unsigned char cmdflags = 0x00;
+  BITSTRING bit_set = int2bit(1, 1);
+  if (p_header.cmdflags().r__bit() == bit_set) {
+    cmdflags |= 0x80;
+  }
+  if (p_header.cmdflags().p__bit() == bit_set) {
+    cmdflags |= 0x40;
+  }
+  if (p_header.cmdflags().e__bit() == bit_set) {
+    cmdflags |= 0x20;
+  }
+  if (p_header.cmdflags().t__bit() == bit_set) {
+    cmdflags |= 0x10;
+  }
+  p_encoding_buffer.put_c(cmdflags);
+
+  int cmdcode = _command_codes[p_header.cmdcode()];
+  p_encoding_buffer.put_c(static_cast<const unsigned char>((cmdcode >> 16) & 0xFF));
+  p_encoding_buffer.put_c(static_cast<const unsigned char>((cmdcode >> 8) & 0xFF));
+  p_encoding_buffer.put_c(static_cast<const unsigned char>(cmdcode & 0xFF));
+
+  p_encoding_buffer.put_c(static_cast<const unsigned char>((p_header.applid() >> 24) & 0xFF));
+  p_encoding_buffer.put_c(static_cast<const unsigned char>((p_header.applid() >> 16) & 0xFF));
+  p_encoding_buffer.put_c(static_cast<const unsigned char>((p_header.applid() >> 8) & 0xFF));
+  p_encoding_buffer.put_c(static_cast<const unsigned char>(p_header.applid() & 0xFF));
+
+  p_encoding_buffer.put_c(static_cast<const unsigned char>((p_header.hopid() >> 24) & 0xFF));
+  p_encoding_buffer.put_c(static_cast<const unsigned char>((p_header.hopid() >> 16) & 0xFF));
+  p_encoding_buffer.put_c(static_cast<const unsigned char>((p_header.hopid() >> 8) & 0xFF));
+  p_encoding_buffer.put_c(static_cast<const unsigned char>(p_header.hopid() & 0xFF));
+
+  p_encoding_buffer.put_c(static_cast<const unsigned char>((p_header.endid() >> 24) & 0xFF));
+  p_encoding_buffer.put_c(static_cast<const unsigned char>((p_header.endid() >> 16) & 0xFF));
+  p_encoding_buffer.put_c(static_cast<const unsigned char>((p_header.endid() >> 8) & 0xFF));
+  p_encoding_buffer.put_c(static_cast<const unsigned char>(p_header.endid() & 0xFF));
+
+  _avps.clear(); // unique_ptr class manages deletion of resources
+
+  loggers::get_instance().log_msg("<<< diameter_codec::encode_header: ", OCTETSTRING(p_encoding_buffer.get_len(), p_encoding_buffer.get_data()));
+  return 0;
+} // End of method encode_header
+
+int diameter_codec::encode_session_id(const LibDiameter__Types__Base__AVPs::Session__Id__AVP& p_avp, TTCN_Buffer& p_encoding_buffer) {
+  loggers::get_instance().log_msg(">>> diameter_codec::encode_session_id: ", OCTETSTRING(p_encoding_buffer.get_len(), p_encoding_buffer.get_data()));
+
+  // TODO Group
+
+  // Encode AVP header
+  int padding = 0;
+  if (encode_avp_header(p_avp.aVP__Header(), &padding, p_encoding_buffer) == -1) {
+    loggers::get_instance().warning("diameter_codec::encode_session_id: Failed to encode AVP header");
+    return -1;
+  }
+
+  const OCTETSTRING& os = unichar2oct(p_avp.aVP__Data());
+  p_encoding_buffer.put_string(os);
+
+  _avps.insert(
+               std::make_pair<const int, std::unique_ptr<avp> >(
+                                                                p_avp.aVP__Header().aVP__Code(), 
+                                                                std::unique_ptr<avp>(
+                                                                                     new avp(
+                                                                                             p_avp.aVP__Header().aVP__Code(),
+                                                                                             (p_avp.aVP__Header().aVP__vid().is_present()) ? 0x01 : 0x00,
+                                                                                             (p_avp.aVP__Header().aVP__flags().m__bit()[0].get_bit()) ? 0x01 : 0x00,
+                                                                                             (p_avp.aVP__Header().aVP__flags().p__bit()[0].get_bit()) ? 0x01 : 0x00,
+                                                                                             p_avp.aVP__Header().aVP__len(),
+                                                                                             (p_avp.aVP__Header().aVP__vid().is_present()) ? static_cast<int>(static_cast<const INTEGER&>(*p_avp.aVP__Header().aVP__vid().get_opt_value())) : 0,
+                                                                                             p_avp.aVP__Header().aVP__len(),
+                                                                                             std::vector<unsigned char>(static_cast<const unsigned char*>(os), static_cast<const unsigned char*>(os) + os.lengthof()),
+                                                                                             static_cast<const OCTETSTRING&>(OCTETSTRING(p_encoding_buffer.get_len(), p_encoding_buffer.get_data()))
+                                                                ))));
+
+  if (padding != 0) {
+    OCTETSTRING os = int2oct(0, padding);
+    p_encoding_buffer.put_string(os);
+  }
+
+  loggers::get_instance().log_msg("<<< diameter_codec::encode_session_id: ", OCTETSTRING(p_encoding_buffer.get_len(), p_encoding_buffer.get_data()));
+  return 0;
+}
+
+int diameter_codec::encode_origin_host(const LibDiameter__Types__Base__AVPs::Origin__Host__AVP& p_avp, TTCN_Buffer& p_encoding_buffer) {
+  loggers::get_instance().log_msg(">>> diameter_codec::encode_origin_host: ", OCTETSTRING(p_encoding_buffer.get_len(), p_encoding_buffer.get_data()));
+
+  // TODO Group
+
+  // Encode AVP header
+  int padding = 0;
+  if (encode_avp_header(p_avp.aVP__Header(), &padding, p_encoding_buffer) == -1) {
+    loggers::get_instance().warning("diameter_codec::encode_origin_host: Failed to encode AVP header");
+    return -1;
+  }
+
+  const OCTETSTRING& os = char2oct(p_avp.aVP__Data());
+  p_encoding_buffer.put_string(os);
+
+  _avps.insert(
+               std::make_pair<const int, std::unique_ptr<avp> >(
+                                                                p_avp.aVP__Header().aVP__Code(), 
+                                                                std::unique_ptr<avp>(
+                                                                                     new avp(
+                                                                                             p_avp.aVP__Header().aVP__Code(),
+                                                                                             (p_avp.aVP__Header().aVP__vid().is_present()) ? 0x01 : 0x00,
+                                                                                             (p_avp.aVP__Header().aVP__flags().m__bit()[0].get_bit()) ? 0x01 : 0x00,
+                                                                                             (p_avp.aVP__Header().aVP__flags().p__bit()[0].get_bit()) ? 0x01 : 0x00,
+                                                                                             p_avp.aVP__Header().aVP__len(),
+                                                                                             (p_avp.aVP__Header().aVP__vid().is_present()) ? static_cast<int>(static_cast<const INTEGER&>(*p_avp.aVP__Header().aVP__vid().get_opt_value())) : 0,
+                                                                                             p_avp.aVP__Header().aVP__len(),
+                                                                                             std::vector<unsigned char>(static_cast<const unsigned char*>(os), static_cast<const unsigned char*>(os) + os.lengthof()),
+                                                                                             static_cast<const OCTETSTRING&>(OCTETSTRING(p_encoding_buffer.get_len(), p_encoding_buffer.get_data()))
+                                                                ))));
+
+  if (padding != 0) {
+    OCTETSTRING os = int2oct(0, padding);
+    p_encoding_buffer.put_string(os);
+  }
+
+  loggers::get_instance().log_msg("<<< diameter_codec::encode_origin_host: ", OCTETSTRING(p_encoding_buffer.get_len(), p_encoding_buffer.get_data()));
+  return 0;
+}
+
+int diameter_codec::encode_origin_realm(const LibDiameter__Types__Base__AVPs::Origin__Realm__AVP& p_avp, TTCN_Buffer& p_encoding_buffer) {
+  loggers::get_instance().log_msg(">>> diameter_codec::encode_origin_realm: ", OCTETSTRING(p_encoding_buffer.get_len(), p_encoding_buffer.get_data()));
+
+  // TODO Group
+
+  // Encode AVP header
+  int padding = 0;
+  if (encode_avp_header(p_avp.aVP__Header(), &padding, p_encoding_buffer) == -1) {
+    loggers::get_instance().warning("diameter_codec::encode_origin_realm: Failed to encode AVP header");
+    return -1;
+  }
+
+  const OCTETSTRING& os = char2oct(p_avp.aVP__Data());
+  p_encoding_buffer.put_string(os);
+
+  _avps.insert(
+               std::make_pair<const int, std::unique_ptr<avp> >(
+                                                                p_avp.aVP__Header().aVP__Code(), 
+                                                                std::unique_ptr<avp>(
+                                                                                     new avp(
+                                                                                             p_avp.aVP__Header().aVP__Code(),
+                                                                                             (p_avp.aVP__Header().aVP__vid().is_present()) ? 0x01 : 0x00,
+                                                                                             (p_avp.aVP__Header().aVP__flags().m__bit()[0].get_bit()) ? 0x01 : 0x00,
+                                                                                             (p_avp.aVP__Header().aVP__flags().p__bit()[0].get_bit()) ? 0x01 : 0x00,
+                                                                                             p_avp.aVP__Header().aVP__len(),
+                                                                                             (p_avp.aVP__Header().aVP__vid().is_present()) ? static_cast<int>(static_cast<const INTEGER&>(*p_avp.aVP__Header().aVP__vid().get_opt_value())) : 0,
+                                                                                             p_avp.aVP__Header().aVP__len(),
+                                                                                             std::vector<unsigned char>(static_cast<const unsigned char*>(os), static_cast<const unsigned char*>(os) + os.lengthof()),
+                                                                                             static_cast<const OCTETSTRING&>(OCTETSTRING(p_encoding_buffer.get_len(), p_encoding_buffer.get_data()))
+                                                                ))));
+
+  if (padding != 0) {
+    OCTETSTRING os = int2oct(0, padding);
+    p_encoding_buffer.put_string(os);
+  }
+
+  loggers::get_instance().log_msg("<<< diameter_codec::encode_origin_realm: ", OCTETSTRING(p_encoding_buffer.get_len(), p_encoding_buffer.get_data()));
+  return 0;
+}
+
+int diameter_codec::encode_auth_session_state(const LibDiameter__Types__Base__AVPs::Auth__Session__State__AVP& p_avp, TTCN_Buffer& p_encoding_buffer) {
+  loggers::get_instance().log_msg(">>> diameter_codec::encode_auth_session_state: ", OCTETSTRING(p_encoding_buffer.get_len(), p_encoding_buffer.get_data()));
+
+  // TODO Group
+
+  // Encode AVP header
+  int padding = 0;
+  if (encode_avp_header(p_avp.aVP__Header(), &padding, p_encoding_buffer) == -1) {
+    loggers::get_instance().warning("diameter_codec::encode_auth_session_state: Failed to encode AVP header");
+    return -1;
+  }
+
+  int conv = p_avp.aVP__Data().as_int();
+  std::vector<unsigned char> v;
+  unsigned char c = static_cast<const unsigned char>((conv >> 24) & 0xFF);
+  v.push_back(c);
+  p_encoding_buffer.put_c(c);
+  c = static_cast<const unsigned char>((conv >> 16) & 0xFF);
+  p_encoding_buffer.put_c(c);
+  v.push_back(c);
+  c = static_cast<const unsigned char>((conv >> 8) & 0xFF);
+  p_encoding_buffer.put_c(c);
+  v.push_back(c);
+  c = static_cast<const unsigned char>(conv & 0xFF);
+  p_encoding_buffer.put_c(c);
+  v.push_back(c);
+
+  _avps.insert(
+               std::make_pair<const int, std::unique_ptr<avp> >(
+                                                                p_avp.aVP__Header().aVP__Code(), 
+                                                                std::unique_ptr<avp>(
+                                                                                     new avp(
+                                                                                             p_avp.aVP__Header().aVP__Code(),
+                                                                                             (p_avp.aVP__Header().aVP__vid().is_present()) ? 0x01 : 0x00,
+                                                                                             (p_avp.aVP__Header().aVP__flags().m__bit()[0].get_bit()) ? 0x01 : 0x00,
+                                                                                             (p_avp.aVP__Header().aVP__flags().p__bit()[0].get_bit()) ? 0x01 : 0x00,
+                                                                                             p_avp.aVP__Header().aVP__len(),
+                                                                                             (p_avp.aVP__Header().aVP__vid().is_present()) ? static_cast<int>(static_cast<const INTEGER&>(*p_avp.aVP__Header().aVP__vid().get_opt_value())) : 0,
+                                                                                             p_avp.aVP__Header().aVP__len(),
+                                                                                             v,
+                                                                                             static_cast<const OCTETSTRING&>(OCTETSTRING(p_encoding_buffer.get_len(), p_encoding_buffer.get_data()))
+                                                                ))));
+
+  if (padding != 0) {
+    OCTETSTRING os = int2oct(0, padding);
+    p_encoding_buffer.put_string(os);
+  }
+
+  loggers::get_instance().log_msg("<<< diameter_codec::encode_auth_session_state: ", OCTETSTRING(p_encoding_buffer.get_len(), p_encoding_buffer.get_data()));
+  return 0;
+}
+
+int diameter_codec::encode_avp_header(const LibDiameter__Types__Base__AVPs::AVP__Header& p_header, int* p_padding, TTCN_Buffer& p_encoding_buffer) {
+  loggers::get_instance().log_msg(">>> diameter_codec::encode_avp_header: ", OCTETSTRING(p_encoding_buffer.get_len(), p_encoding_buffer.get_data()));
+
+  int total_length = 4 + 4 + p_header.aVP__len();
+  loggers::get_instance().log("diameter_codec::encode_avp_header: total_length: '%d'", total_length);
+
+  if (p_header.aVP__vid().is_present()) {
+    total_length += 4;
+  }
+  int send_length = total_length;
+	if ((total_length % 4) != 0) { 
+			total_length = (total_length / 4 + 1) * 4;
+      *p_padding = total_length - send_length;
+  }
+  loggers::get_instance().log("diameter_codec::encode_avp_header: send_length: '%d'", send_length);
+  loggers::get_instance().log("diameter_codec::encode_avp_header: total_length after padding: '%d'", total_length);
+  loggers::get_instance().log("diameter_codec::encode_avp_header: *p_padding: '%d'", *p_padding);
+
+  int conv = p_header.aVP__Code();
+  p_encoding_buffer.put_c(static_cast<const char>((conv >> 24) & 0xFF));
+  p_encoding_buffer.put_c(static_cast<const char>((conv >> 16) & 0xFF));
+  p_encoding_buffer.put_c(static_cast<const char>((conv >> 8) & 0xFF));
+  p_encoding_buffer.put_c(static_cast<const char>(conv & 0xFF));
+
+  unsigned char flags = 0x00;
+  if (p_header.aVP__vid().is_present()) {
+    flags |= 0x80;
+  }
+  if (p_header.aVP__flags().m__bit()[0].get_bit()) {
+    flags |= 0x40;
+    
+  }
+  if (p_header.aVP__flags().p__bit()[0].get_bit()) {
+    flags |= 0x20;
+    
+  }
+  p_encoding_buffer.put_c(flags);
+
+  conv = send_length;
+  p_encoding_buffer.put_c(static_cast<const char>((send_length >> 16) & 0xFF));
+  p_encoding_buffer.put_c(static_cast<const char>((send_length >> 8) & 0xFF));
+  p_encoding_buffer.put_c(static_cast<const char>(send_length & 0xFF));
+
+  if (p_header.aVP__vid().is_present()) {
+    conv = static_cast<const INTEGER&>(*p_header.aVP__vid().get_opt_value());
+    p_encoding_buffer.put_c(static_cast<const char>((conv >> 24) & 0xFF));
+    p_encoding_buffer.put_c(static_cast<const char>((conv >> 16) & 0xFF));
+    p_encoding_buffer.put_c(static_cast<const char>((conv >> 8) & 0xFF));
+    p_encoding_buffer.put_c(static_cast<const char>(conv & 0xFF));
+  }
+
+  loggers::get_instance().log_msg("<<< diameter_codec::encode_auth_session_state: ", OCTETSTRING(p_encoding_buffer.get_len(), p_encoding_buffer.get_data()));
+  return 0;
+}
+
+int diameter_codec::decode_header(TTCN_Buffer& p_decoding_buffer, LibDiameter__TypesAndValues::DiameterHeader& p_header, const params& p_params) {
+  loggers::get_instance().log(">>> diameter_codec::decode_header: '%p'", _start);
+
+  // Sanity check
+  if (p_decoding_buffer.get_len() < 20) { // DiameterHeader size
+    loggers::get_instance().warning("diameter_codec::decode: Wrong packet length for daimeter message");
+    return -1;
+  }
+
+  _start = static_cast<const unsigned char*>(p_decoding_buffer.get_data());
+  _avps.clear(); // unique_ptr class manages deletion of resources
+
+  p_header.version() = static_cast<int>(*_start++ & 0xFF);
+  p_header.msglen() = static_cast<int>(static_cast<int>(*_start++ & 0xFF) << 16 | static_cast<int>(*_start++ & 0xFF) << 8 | static_cast<int>(*_start++ & 0xFF));
+  // Resize the docoding buffer
+  if ((int)p_header.msglen() > p_decoding_buffer.get_len()) {
+    loggers::get_instance().warning("diameter_codec::decode: Resize docoding buffer: '%d' to '%d'", p_header.msglen(), p_decoding_buffer.get_len());
+    p_header.msglen() = p_decoding_buffer.get_len();
+  }
+  _end = static_cast<const unsigned char*>(p_decoding_buffer.get_data()) + p_header.msglen();
+  loggers::get_instance().log("diameter_codec::decode: _end: '%p' - offset: '%d'", _end, static_cast<int>(_end - _start));
+  loggers::get_instance().log_to_hexa("diameter_codec::decode: diameter message:", _start, static_cast<int>(_end - _start));
+
+  p_header.cmdflags().r__bit() = int2bit(static_cast<int>(static_cast<unsigned char>(*_start & 0x80) != 0), 1);
+  p_header.cmdflags().p__bit() = int2bit(static_cast<int>(static_cast<unsigned char>(*_start & 0x40) != 0), 1);
+  p_header.cmdflags().e__bit() = int2bit(static_cast<int>(static_cast<unsigned char>(*_start & 0x20) != 0), 1);
+  p_header.cmdflags().t__bit() = int2bit(static_cast<int>(static_cast<unsigned char>(*_start & 0x10) != 0), 1);
+  p_header.cmdflags().reserved__bits() = int2bit(static_cast<int>(*_start++ & 0x0F), 4);
+
+  params::const_iterator it = p_params.find(std::string("Request"));
+  boolean is_request = true;
+  if (it != p_params.cend()) {
+    is_request = it->second.compare("1") == 0;
+  }
+  p_header.cmdcode() = LibDiameter__TypesAndValues::Command__Code::str_to_enum(
+                                                                               command_code_2_enumerated(
+                                                                                                         static_cast<int>(static_cast<int>(*_start++ & 0xFF) << 16 | static_cast<int>(*_start++ & 0xFF) << 8 | static_cast<int>(*_start++ & 0xFF)), 
+                                                                                                         static_cast<const boolean>(is_request)
+                                                                                                         ).c_str()
+                                                                               );
+
+  p_header.applid() = static_cast<int>(static_cast<int>(*_start++ & 0xFF) << 24 | static_cast<int>(*_start++ & 0xFF) << 16 | static_cast<int>(*_start++ & 0xFF) << 8 | static_cast<int>(*_start++ & 0xFF));
+
+  p_header.hopid() = static_cast<int>(static_cast<int>(*_start++ & 0xFF) << 24 | static_cast<int>(*_start++ & 0xFF) << 16 | static_cast<int>(*_start++ & 0xFF) << 8 | static_cast<int>(*_start++ & 0xFF));
+
+  p_header.endid() = static_cast<int>(static_cast<int>(*_start++ & 0xFF) << 24 | static_cast<int>(*_start++ & 0xFF) << 16 | static_cast<int>(*_start++ & 0xFF) << 8 | static_cast<int>(*_start++ & 0xFF));
+
+  loggers::get_instance().log_msg("diameter_codec::decode_header: p_header=", p_header);
+
+  return 0;
+} // End of method decode_header
+
+int diameter_codec::decode_avps(TTCN_Buffer& p_decoding_buffer, const LibDiameter__TypesAndValues::DiameterHeader& p_header, const params& p_params) {
+  loggers::get_instance().log(">>> diameter_codec::decode_avps: '%p'", _start);
+
+  while (_start < _end) {
+    avp* avp_ptr = nullptr;
+    if (decode_avp(p_decoding_buffer, p_header, p_params, &avp_ptr) == -1) {
+      loggers::get_instance().log("diameter_codec::decode_avps: Failed to decode AVP: current position: '%p' - offset:'%d' - value:'0x%02x'", _start, reinterpret_cast<std::uintptr_t>(_end) - reinterpret_cast<std::uintptr_t>(_start), static_cast<unsigned char>(*_start));
+      return -1;
+    }
+    _avps.insert(std::make_pair<const int, std::unique_ptr<avp> >(avp_ptr->get_code(), std::unique_ptr<avp>(avp_ptr)));
+  }   // End of 'while' statemement
+  loggers::get_instance().log(">>> diameter_codec::decode_avps: No more AVP to decode: '%p' / '%p'", _start, _end);
+
+  return 0;
+} // End of method decode_avps
+
+int diameter_codec::decode_avp(TTCN_Buffer& p_decoding_buffer, const LibDiameter__TypesAndValues::DiameterHeader& p_header, const params& p_params, avp** avp_ptr) {
+  loggers::get_instance().log(">>> diameter_codec::decode_avp: '%p'", _start);
+
+  // Sanity checks
+  if (static_cast<int>((_end - _start)) < 8) {
+    loggers::get_instance().warning("diameter_codec::decode_avp: Not enought bytes for AVP decoding");
+    return -1;
+  }
+
+  int code = static_cast<int>(static_cast<int>(*_start++ & 0xFF) << 24 | static_cast<int>(*_start++ & 0xFF) << 16 | static_cast<int>(*_start++ & 0xFF) << 8 | static_cast<int>(*_start++ & 0xFF));
+  loggers::get_instance().log("diameter_codec::decode_avp: code:'%d'", code);
+  unsigned char vendor_specific = static_cast<unsigned char>(static_cast<unsigned char>(*_start & 0x80) != 0);
+  loggers::get_instance().log("diameter_codec::decode_avp: vendor_specific:'0x%x'", vendor_specific);
+  unsigned char mandatory = static_cast<unsigned char>(static_cast<unsigned char>(*_start & 0x40) != 0);
+  loggers::get_instance().log("diameter_codec::decode_avp: mandatory:'0x%x'", mandatory);
+  unsigned char protected_ = static_cast<unsigned char>(static_cast<unsigned char>(*_start++ & 0x20) != 0);
+  loggers::get_instance().log("diameter_codec::decode_avp: protected_:'0x%x'", protected_);
+  int length = static_cast<int>(static_cast<int>(*_start++ & 0xFF) << 16 | static_cast<int>(*_start++ & 0xFF) << 8 | static_cast<int>(*_start++ & 0xFF));
+  loggers::get_instance().log("diameter_codec::decode_avp: length:'%d'", length);
+
+  int vendor_id = 0;
+  int payload_length = length;
+  if (vendor_specific) {
+    vendor_id = static_cast<int>(static_cast<int>(*_start++ & 0xFF) << 24 | static_cast<int>(*_start++ & 0xFF) << 16 | static_cast<int>(*_start++ & 0xFF) << 8 | static_cast<int>(*_start++ & 0xFF));
+    payload_length -= 12;  
+  } else {
+    payload_length -= 8;  
+  }
+  loggers::get_instance().log("diameter_codec::decode_avp: payload_length:'%d'", payload_length);
+  std::vector<unsigned char> payload(_start, _start + payload_length);
+
+  // if (length > static_cast<int>(_end - _start)) {
+  //   loggers::get_instance().warning("diameter_codec::decode_avp: Resize docoding buffer: '%d' to '%d'", length, static_cast<int>(_end - _start));
+  //   length = static_cast<int>(_end - _start);
+  // }
+
+  int encoded_length = length;
+  if ((encoded_length % 4) !=0) {
+    encoded_length = (encoded_length / 4 + 1) * 4;
+  } 
+  loggers::get_instance().log("diameter_codec::decode_avp: encoded_length:'%d'", encoded_length);
+
+  loggers::get_instance().log("diameter_codec::decode_avp: encoded_length:'%d'", encoded_length - length);
+  loggers::get_instance().log("diameter_codec::decode_avp: payload_length + (encoded_length - length):'%d'", payload_length + (encoded_length - length));
+  _start = _start + payload_length + (encoded_length - length);
+  loggers::get_instance().log("diameter_codec::decode_avp: new _start:'%p'", _start);
+
+  *avp_ptr = new avp(code, vendor_specific, mandatory, protected_, length, vendor_id, encoded_length, payload);
+
+  return 0;
+}
+
+const std::unique_ptr<avp>& diameter_codec::get_avp(const int p_code) {
+  loggers::get_instance().log(">>> diameter_codec::get_avp: '%d'", p_code);
+
+  if ((_it = _avps.find(p_code)) == _avps.cend()) {
+    loggers::get_instance().log("diameter_codec::get_avp: Failed to retrieve AVP '%d'", p_code);
+    return _nullptr;
+  }
+
+  loggers::get_instance().log("diameter_codec::get_avp: got AVP '%d'", _it->second->get_code());
+  return _it->second;
+}
+
+std::string diameter_codec::command_code_2_enumerated(const int p_code, const boolean p_request_flag) {
+
+  std::string code_enum;
+  if(p_request_flag) {
+    switch(p_code){
+      case Code_CE: code_enum.assign("CER_E"); break;
+      case Code_RA: code_enum.assign("RAR_E"); break;
+      case Code_AC: code_enum.assign("ACR_E"); break;
+      case Code_AS: code_enum.assign("ASR_E"); break;
+      case Code_ST: code_enum.assign("STR_E"); break;
+      case Code_DW: code_enum.assign("DWR_E"); break;
+      case Code_DP: code_enum.assign("DPR_E"); break;
+          //CxDx
+      case Code_UA: code_enum.assign("UAR_E"); break;
+      case Code_SA: code_enum.assign("SAR_E"); break;
+      case Code_LI: code_enum.assign("LIR_E"); break;
+      case Code_MA: code_enum.assign("MAR_E"); break;
+      case Code_RT: code_enum.assign("RTR_E"); break;
+      case Code_PP: code_enum.assign("PPR_E"); break;
+
+      /* Codes on Sh/Dh interface  */
+      case Code_UD: code_enum.assign("UDR_E"); break;// UDR User-Data-Request AS->HSS                UDR    (306)
+      case Code_PU: code_enum.assign("PUR_E"); break;// PUR Profile-Update-Request AS->HSS           PUR    (307)
+      case Code_SN: code_enum.assign("SNR_E"); break;// SNR Subscribe-Notifications-Request AS->HSS  SNR    (308)
+      case Code_PN: code_enum.assign("PNR_E"); break;// PNR Profile-Notification-Request HSS->AS     
+
+      //Rx
+      case Code_AA: code_enum.assign("AAR_E"); break;
+      //4006
+      case Code_CC: code_enum.assign("CCR_E"); break;
+
+      //s6a
+      case Code_UL: code_enum.assign("ULR_E"); break;  // Update-Location-Request                   ULR    (316)- Ref: TS 129 272 7.2.3-4
+      case Code_CL: code_enum.assign("CLR_E"); break;  // Cancel-Location-Request                   CLR    (317)- Ref: TS 129 272 7.2.7-8
+      case Code_AI: code_enum.assign("AIR_E"); break;  // Authentication-Information-Request        AIR    (318)- Ref: TS 129 272 7.2.5-6
+      case Code_ID: code_enum.assign("IDR_E"); break;  // Insert-Subscriber-Data-Request            IDR    (319)- Ref: TS 129 272 7.2.9-10
+      case Code_DS: code_enum.assign("DSR_E"); break;  // Delete-Subscriber-Data-Request            DSR    (320)- Ref: TS 129 272 7.2.11-12
+      case Code_PUE: code_enum.assign("PUER_E"); break; // Purge-UE-Request                          PUR    (321)- Ref: TS 129 272 7.2.13-14
+      case Code_RS: code_enum.assign("RSR_E"); break;  // Reset-Request                             DSR    (322)- Ref: TS 129 272 7.2.15-16
+      case Code_NO: code_enum.assign("NOR_E"); break;  // Notify-Request                            NOR    (323)- Ref: TS 129 272 7.2.17-18
+    }
+  } else {
+    switch(p_code) {
+      case Code_CE: code_enum.assign("CEA_E"); break;
+      case Code_RA: code_enum.assign("RAA_E"); break;
+      case Code_AC: code_enum.assign("ACA_E"); break;
+      case Code_AS: code_enum.assign("ASA_E"); break;
+      case Code_ST: code_enum.assign("STA_E"); break;
+      case Code_DW: code_enum.assign("DWA_E"); break;
+      case Code_DP: code_enum.assign("DPA_E"); break;
+      //CxDx
+      case Code_UA: code_enum.assign("UAA_E"); break;
+      case Code_SA: code_enum.assign("SAA_E"); break;
+      case Code_LI: code_enum.assign("LIA_E"); break;
+      case Code_MA: code_enum.assign("MAA_E"); break;
+      case Code_RT: code_enum.assign("RTA_E"); break;
+      case Code_PP: code_enum.assign("PPA_E"); break;
+
+      /* Codes on Sh/Dh interface  */
+      case Code_UD: code_enum.assign("UDA_E"); break;// UDR User-Data-Request AS->HSS                UDR    (306)
+      case Code_PU: code_enum.assign("PUA_E"); break;// PUR Profile-Update-Request AS->HSS           PUR    (307)
+      case Code_SN: code_enum.assign("SNA_E"); break;// SNR Subscribe-Notifications-Request AS->HSS  SNR    (308)
+      case Code_PN: code_enum.assign("PNA_E"); break;// PNR Profile-Notification-Request HSS->AS 
+      //Rx
+      case Code_AA: code_enum.assign("AAA_E"); break;
+      //4006
+      case Code_CC: code_enum.assign("CCA_E"); break;
+
+      //S6a
+      case Code_UL: code_enum.assign("ULA_E"); break;  // Update-Location-Request                   ULR    (316)- Ref: TS 129 272 7.2.3-4
+      case Code_CL: code_enum.assign("CLA_E"); break;  // Cancel-Location-Request                   CLR    (317)- Ref: TS 129 272 7.2.7-8
+      case Code_AI: code_enum.assign("AIA_E"); break;  // Authentication-Information-Request        AIR    (318)- Ref: TS 129 272 7.2.5-6
+      case Code_ID: code_enum.assign("IDA_E"); break;  // Insert-Subscriber-Data-Request            IDR    (319)- Ref: TS 129 272 7.2.9-10
+      case Code_DS: code_enum.assign("DSA_E"); break;  // Delete-Subscriber-Data-Request            DSR    (320)- Ref: TS 129 272 7.2.11-12
+      case Code_PUE: code_enum.assign("PUEA_E"); break; // Purge-UE-Request                          PUR    (321)- Ref: TS 129 272 7.2.13-14
+      case Code_RS: code_enum.assign("RSA_E"); break;  // Reset-Request                             DSR    (322)- Ref: TS 129 272 7.2.15-16
+      case Code_NO: code_enum.assign("NOA_E"); break;  // Notify-Request                            NOR    (323)- Ref: TS 129 272 7.2.17-1
+    }
+  } 
+  return code_enum;
+} // End of method command_code_2_enumerated
+
+const int diameter_codec::_command_codes[] = {
+  /* Ref: RFC3588 p.3.1 */
+
+  diameter_codec::Code_CE,  // Capabilities-Exchange-Request   CER  (257)
+  diameter_codec::Code_CE,  // Capabilities-Exchange-Answer   CEA  (257)
+  diameter_codec::Code_RA,  // Re-Auth-Request         RAR  (258)
+  diameter_codec::Code_RA,  // Re-Auth-Answer         RAA  (258)
+  /**/  
+  diameter_codec::Code_AC,  // Accounting-Request        ACR(271)
+  diameter_codec::Code_AC,  // Accounting-Answer        ACA (271)
+    /**/
+  diameter_codec::Code_AS,  // Abort-Session-Request      ASR (274)
+  diameter_codec::Code_AS,  // Abort-Sesion-Answer      ASA (274)
+  diameter_codec::Code_ST,  // Session-Termination-Request  STR (275)
+  diameter_codec::Code_ST,  // Session-Termination-Answer    STA (275)          
+/**/
+  diameter_codec::Code_DW,  // Device-Watchdog-Request    DWR (280)
+  diameter_codec::Code_DW,  // Device-Watchdog-Answer      DWA (280)
+  diameter_codec::Code_DP,  // Disconnect-Peer-Request      DPR (282)
+  diameter_codec::Code_DP,  // Disconnect-Peer-Answer      DPA (282) 
+
+/* Codes on Cx */
+  diameter_codec::Code_UA,     // User-Authorization-Request  UAR  300
+  diameter_codec::Code_UA,     // User-Authorization-Answer  UAA  300
+  diameter_codec::Code_SA,     // Server-Assignment-Request  SAR  301
+  diameter_codec::Code_SA,     // Server-Assignment-Answer    SAA  301
+  diameter_codec::Code_LI,     // Location-Info-Request    LIR  302
+  diameter_codec::Code_LI,     // Location-Info-Answer      LIA  302
+  diameter_codec::Code_MA,     // Multimedia-Auth-Request    MAR  303
+  diameter_codec::Code_MA,     // Multimedia-Auth-Answer    MAA  303
+  diameter_codec::Code_RT,    // Registration-Termination-Request  RTR  304
+  diameter_codec::Code_RT,    // Registration-Termination-Answer  RTA  304
+  diameter_codec::Code_PP,    // Push-Profile-Request      PPR  305
+  diameter_codec::Code_PP,    // Push-Profile-Answer      PPA  305  
+
+/* Codes on Sh/Dh interface  */
+  diameter_codec::Code_UD,  //  UDR User-Data-Request AS->HSS   306
+  diameter_codec::Code_UD,  //  UDA User-Data-Answer HSS->AS  306    
+  diameter_codec::Code_PU,   //  PUR Profile-Update-Request AS->HSS  307
+  diameter_codec::Code_PU,  //  PUA Profile-Update-Answer HSS->AS  307
+  diameter_codec::Code_SN,  //  SNR Subscribe-Notifications-Request AS->HSS  308
+  diameter_codec::Code_SN,  //  SNA Subscribe-Notifications-Answer HSS->AS  308
+  diameter_codec::Code_PN,  //  PNR Profile-Notification-Request HSS->AS  309
+  diameter_codec::Code_PN,  //  PNA Profile-Notification-Answer AS->HSS    309
+
+/* Codes on Rx interface  */
+  diameter_codec::Code_AA,  //  AAR Auth-Accounting-Request    265
+  diameter_codec::Code_AA,  //  AAA Auth-Accounting-Request   265
+
+/*RFC4006*/
+  diameter_codec::Code_CC,  //  CCR Credit-Control-Request    272
+  diameter_codec::Code_CC,  //  CCA Credit-Control-Answer     272
+
+    /* Codes on S6a interface - TS 129 272  */
+  diameter_codec::Code_UL,  // Update-Location-Request                   ULR    (316)- Ref: TS 129 272 7.2.3
+  diameter_codec::Code_UL,  // Update-Location-Answer                ULA    (316)- Ref: TS 129 272 7.2.4
+  diameter_codec::Code_CL,  // Cancel-Location-Request                   CLR    (317)- Ref: TS 129 272 7.2.7
+  diameter_codec::Code_CL,  // Cancel-Location-Answer                    CLA    (317)- Ref: TS 129 272 7.2.8
+  diameter_codec::Code_AI,  // Authentication-Information-Request        AIR    (318)- Ref: TS 129 272 7.2.5
+  diameter_codec::Code_AI,  // Authentication-Information-Answer         AIA    (318)- Ref: TS 129 272 7.2.6
+  diameter_codec::Code_ID,  // Insert-Subscriber-Data-Request            IDR    (319)- Ref: TS 129 272 7.2.9
+  diameter_codec::Code_ID,  // Insert-Subscriber-Data-Answer             IDA    (319)- Ref: TS 129 272 7.2.10
+  diameter_codec::Code_DS,  // Delete-Subscriber-Data-Request            DSR    (320)- Ref: TS 129 272 7.2.11
+  diameter_codec::Code_DS,  // Delete-Subscriber-Data-Answer             DSA    (320)- Ref: TS 129 272 7.2.12
+  diameter_codec::Code_PUE, // Purge-UE-Request                          PUR    (321)- Ref: TS 129 272 7.2.13
+  diameter_codec::Code_PUE, // Purge-UE-Answer                           PUA    (321)- Ref: TS 129 272 7.2.14
+  diameter_codec::Code_RS,  // Reset-Request                             DSR    (322)- Ref: TS 129 272 7.2.15
+  diameter_codec::Code_RS,  // Reset-Answer                              DSA    (322)- Ref: TS 129 272 7.2.16
+  diameter_codec::Code_NO,  // Notify-Request                            NOR    (323)- Ref: TS 129 272 7.2.17
+  diameter_codec::Code_NO   // Notify-Answer                             NOA    (323)- Ref: TS 129 272 7.2.18    
+};

ccsrc/Protocols/Diameter/diameter_codec.hh

+#pragma once
+
+#include <vector>
+#include <memory>
+
+#include "codec_gen.hh"
+#include "params.hh"
+
+#include "avp.hh" 
+
+class TTCN_Typedescriptor_t;
+class TTCN_Buffer;
+
+namespace LibDiameter__TypesAndValues {
+  class DiameterHeader; //! Forward declaration of TITAN class
+}
+
+class diameter_codec  {
+  std::map<const int, std::unique_ptr<avp> > _avps;
+  std::map<const int, std::unique_ptr<avp> >::const_iterator _it;
+  std::unique_ptr<avp> _nullptr;
+  const unsigned char* _start;
+  const unsigned char* _end;
+
+public:
+  explicit diameter_codec() : _avps(), _it(), _nullptr(nullptr), _start(nullptr) { };
+  virtual ~diameter_codec();
+
+  int encode_header(const LibDiameter__TypesAndValues::DiameterHeader& p_header, TTCN_Buffer& p_encoding_buffer);
+  int encode_session_id(const LibDiameter__Types__Base__AVPs::Session__Id__AVP& p_avp, TTCN_Buffer& p_encoding_buffer);
+  int encode_auth_session_state(const LibDiameter__Types__Base__AVPs::Auth__Session__State__AVP& p_avp, TTCN_Buffer& p_encoding_buffer);
+  int encode_origin_host(const LibDiameter__Types__Base__AVPs::Origin__Host__AVP& p_avp, TTCN_Buffer& p_encoding_buffer);
+  int encode_origin_realm(const LibDiameter__Types__Base__AVPs::Origin__Realm__AVP& p_avp, TTCN_Buffer& p_encoding_buffer);
+
+  int decode_header(TTCN_Buffer& p_decoding_buffer, LibDiameter__TypesAndValues::DiameterHeader& p_header, const params& p_params);
+  int decode_avps(TTCN_Buffer& p_decoding_buffer, const LibDiameter__TypesAndValues::DiameterHeader& p_header, const params& p_params);
+
+  const std::unique_ptr<avp>& get_avp(const int p_code);
+
+public:
+  int encode_avp_header(const LibDiameter__Types__Base__AVPs::AVP__Header& p_header, int* p_padding, TTCN_Buffer& p_encoding_buffer);
+
+  int decode_avp(TTCN_Buffer& p_decoding_buffer, const LibDiameter__TypesAndValues::DiameterHeader& p_header, const params& p_params, avp** avp_ptr);
+
+  std::string command_code_2_enumerated(const int p_code, const boolean p_request_flag);
+
+  /** Command code of Request/Answer */
+  static const int Code_CE=257;// Capabilities-Exchange
+  static const int Code_RA=258;// Re-Auth
+  static const int Code_AC=271;// Accounting
+  static const int Code_AS=274;// Abort-Session
+  static const int Code_ST=275;// Session-Termination
+  static const int Code_DW=280;// Device-Watchdog
+  static const int Code_DP=282;// Disconnect-Peer
+
+  /* Codes on Cx */
+  static const int Code_UA=300;// User-Authorization
+  static const int Code_SA=301;// Server-Assignment-Request        SAR    (284 in RFC4740 or 301 in TS 129 229)
+  static const int Code_LI=302;// Location-Info-Request            LIR    (285 in RFC4740 or 302 in TS 129 229)
+  static const int Code_MA=303;// Multimedia-Auth-Request          MAR    (286 in RFC4740 or 303 in TS 129 229)
+  static const int Code_RT=304;// Registration-Termination-Request RTR    (287 in RFC4740 or 304 in TS 129 229)
+  static const int Code_PP=305;// Push-Profile-Request             PPR    (288 in RFC4740 or 305 in TS 129 229)
+
+  /* Codes on Sh/Dh interface  */
+  static const int Code_UD=306;// UDR User-Data-Request AS->HSS                UDR    (306)
+  static const int Code_PU=307;// PUR Profile-Update-Request AS->HSS           PUR    (307)
+  static const int Code_SN=308;// SNR Subscribe-Notifications-Request AS->($1) ($2)    (308)
+  static const int Code_PN=309;// PNR Profile-Notification-Request HSS->AS     PNR    (309)
+
+  /* Codes on Rx interface  */
+  static const int Code_AA=265;// Auth-Accounting
+
+  /* Codes on Gx interface - RFC4006 and TS 129 212  */
+  static const int Code_CC=272;// Credit-Control 
+
+  /* Codes on S6a interface - TS 129 272  */
+  static const int Code_UL=316;  // Update-Location-Request                   ULR    (316)- Ref: TS 129 272 7.2.3-4
+  static const int Code_CL=317;  // Cancel-Location-Request                   CLR    (317)- Ref: TS 129 272 7.2.7-8
+  static const int Code_AI=318;  // Authentication-Information-Request        AIR    (318)- Ref: TS 129 272 7.2.5-6
+  static const int Code_ID=319;  // Insert-Subscriber-Data-Request            IDR    (319)- Ref: TS 129 272 7.2.9-10
+  static const int Code_DS=320;  // Delete-Subscriber-Data-Request            DSR    (320)- Ref: TS 129 272 7.2.11-12
+  static const int Code_PUE=321; // Purge-UE-Request                          PUR    (321)- Ref: TS 129 272 7.2.13-14
+  static const int Code_RS=322;  // Reset-Request                             DSR    (322)- Ref: TS 129 272 7.2.15-16
+  static const int Code_NO=323;  // Notify-Request                            NOR    (323)- Ref: TS 129 272 7.2.17-18
+
+
+  /*RFC3588 AVP codes*/
+  const int AVP_Accounting_Realtime_Required_AVP = 483; 			//Ref: RFC3588 9.8.7.  Accounting-Realtime-Required AVP
+  const int AVP_Accounting_Record_Number_AVP = 485;				    //Ref: RFC3588 9.8.3.  Accounting-Record-Number AVP
+  const int AVP_Accounting_Record_Type_AVP = 480; 					//Ref: RFC3588 9.8.1.  Accounting-Record-Type AVP
+  const int AVP_Accounting_Sub_Session_Id_AVP = 287;				//Ref: RFC3588 9.8.6.  Accounting-Sub-Session-Id AVP
+  const int AVP_Acct_Application_Id_AVP = 259; 					    //Ref: RFC3588 6.9.  Acct-Application-Id AVP
+  const int AVP_Acct_Interim_Interval_AVP = 85; 					//Ref: RFC3588 9.8.2.  Acct-Interim-Interval
+  const int AVP_Acct_Multi_Session_Id_AVP = 50; 					//Ref: RFC3588 9.8.5.  Acct-Multi-Session-Id AVP
+  const int AVP_Acct_Session_Id_AVP = 44; 							//Ref: RFC3588 9.8.4.  Acct-Session-Id AVP 
+  const int AVP_Auth_Application_Id_AVP = 258; 					    //Ref: RFC3588 6.8.  Auth-Application-Id AVP
+  const int AVP_Class_AVP = 25; 									//Ref: RFC3588 8.20.  Class AVP
+  const int AVP_Destination_Host_AVP = 293; 						//Ref: RFC3588 6.5.  Destination-Host AVP
+  const int AVP_Destination_Realm_AVP = 283; 						//Ref: RFC3588 6.6.  Destination-Realm AVP
+  const int AVP_Disconnect_Cause_AVP = 273; 						//Ref: RFC3588 5.4.3.  Disconnect-Cause AVP
+  const int AVP_Error_Message_AVP = 281; 							//Ref: RFC3588 7.3.  Error-Message AVP
+  const int AVP_Error_Reporting_Host_AVP = 294; 					//Ref: RFC3588 7.4.  Error-Reporting-Host AVP
+  const int AVP_Event_Timestamp_AVP = 55; 							//Ref: RFC3588 8.21.  Event-Timestamp AVP
+  const int AVP_Failed_AVP = 279; 									//Ref: RFC3588 7.5.  Failed-AVP AVP
+  const int AVP_Firmware_Revision_AVP = 267; 						//Ref: RFC3588 5.3.4.  Firmware-Revision AVP
+  const int AVP_Host_IP_Address_AVP = 257; 						    //Ref: RFC3588 5.3.5.  Host-IP-Address AVP
+  const int AVP_Inband_Security_Id_AVP = 299; 						//Ref: RFC3588 6.10.  Inband-Security-Id AVP
+  const int AVP_Origin_Host_AVP = 264; 							    //Ref: RFC3588 6.3.  Origin-Host AVP
+  const int AVP_Origin_Realm_AVP = 296; 							//Ref: RFC3588 6.4.  Origin-Realm AVP
+  const int AVP_Origin_State_Id_AVP = 278; 						    //Ref: RFC3588 8.16.  Origin-State-Id AVP
+  const int AVP_Product_Name_AVP = 269; 							//Ref: RFC3588 5.3.7.  Product-Name AVP
+  const int AVP_Proxy_Host_AVP = 280; 								//Ref: RFC3588 6.7.3.  Proxy-Host AVP
+  const int AVP_Proxy_Info_AVP = 284; 								//Ref: RFC3588 6.7.2.  Proxy-Info AVP
+  const int AVP_Proxy_State_AVP = 33; 								//Ref: RFC3588 6.7.4.  Proxy-State AVP
+  const int AVP_Re_Auth_Request_Type_AVP = 285; 					//Ref: RFC3588 8.12.  Re-Auth-Request-Type AVP
+  const int AVP_Redirect_Host_AVP = 292; 							//Ref: RFC3588 6.12.  Redirect-Host AVP
+  const int AVP_redirect_Max_Cache_Time_AVP = 262; 				//Ref: RFC3588 redirect_Max_Cache_Time_AVP is not defined. 
+  const int AVP_Redirect_Host_Usage_AVP = 261; 					    //Ref: RFC3588 6.13.  Redirect-Host-Usage AVP
+  const int AVP_Result_Code_AVP = 268; 							    //Ref: RFC3588 7.1.  Result-Code AVP
+  const int AVP_Route_Record_AVP = 282; 							//Ref: RFC3588 6.7.1.  Route-Record AVP
+  const int AVP_Session_Id_AVP = 263; 								//Ref: RFC3588 8.8.  Session-Id AVP
+  const int AVP_Supported_Vendor_Id_AVP = 265; 					    //Ref; RFC3588 5.3.6.  Supported-Vendor-Id AVP
+  const int AVP_Termination_Cause_AVP = 295; 						//Ref: RFC3588 8.15.  Termination-Cause AVP
+  const int AVP_User_Name_AVP = 1; 								    //Ref: RFC3588 8.14.  User-Name AVP
+  const int AVP_Vendor_Id_AVP = 266; 								//Ref: RFC3588 5.3.3.  Vendor-Id AVP
+  const int AVP_Vendor_Specific_Appl_Id_AVP = 260; 				    //Ref: RFC3588 6.11.  Vendor-Specific-Application-Id AVP
+  /*end RFC3588 AVP codes*/
+
+  //RFC4740 AVP codes{
+//  const int AVP_Auth_Grace_Period_AVP = 276; 						//Ref: RFC3588 8.10.  Auth-Grace-Period AVP								
+  const int AVP_Auth_Session_State_AVP = 277; 						//Ref: RFC3588 8.11.  Auth-Session-State AVP							
+//  const int AVP_Authorization_Lifetime_AVP = 291; 					//Ref: RFC3588 8.9.  Authorization-Lifetime AVP								
+//  const int AVP_Redirect_Max_Cache_Time_AVP = 262;					//Ref: RFC3588 6.14.  Redirect-Max-Cache-Time AVP							
+//  const int AVP_SIP_Accounting_Information_AVP = 368; 				//Ref: RFC4740 9.1.  SIP-Accounting-Information AVP								
+//  const int AVP_SIP_Accounting_Server_URI_AVP = 369; 				//Ref: RFC4740 9.1.1.  SIP-Accounting-Server-URI AVP								
+//  const int AVP_SIP_AOR_AVP = 122; 								//Ref: RFC4740 9.8.  SIP-AOR AVP							
+  const int AVP_SIP_Auth_Data_Item_RFC_AVP = 376; 						//Ref: RFC4740 9.5.  SIP-Auth-Data-Item AVP
+  const int AVP_SIP_Item_Number_AVP = 378;
+  const int AVP_SIP_Authenticate_RFC_AVP = 379; 						//Ref: RFC4740 9.5.3.  SIP-Authenticate AVP								
+//  const int AVP_SIP_Authentication_Info_AVP = 381;  				//Ref: RFC4740 9.5.5.  SIP-Authentication-Info AVP							
+  const int AVP_SIP_Authentication_Scheme_RFC_AVP = 377; 				//Ref: RFC4740 9.5.1.  SIP-Authentication-Scheme AVP							
+  const int AVP_SIP_Authorization_RFC_AVP = 380;  						//Ref: RFC4740 9.5.4.  SIP-Authorization AVP							
+//  const int AVP_SIP_Credit_Control_Server_URI_AVP = 370; 			//Ref: RFC4740 9.1.2.  SIP-Credit-Control-Server-URI AVP								
+//  const int AVP_SIP_Deregistration_Reason_AVP = 383; 				//Ref: RFC4740 9.5.5.  SIP-Authentication-Info AVP							
+//  const int AVP_SIP_Item_Number_AVP = 378; 						//Ref: RFC4740 9.5.2 SIP-Item-Number AVP							
+//  const int AVP_SIP_MandatoryCapability_AVP = 373; 				//Ref: RFC4740 9.3.1.  SIP-Mandatory-Capability AVP								
+  const int AVP_SIP_Method_AVP = 393; 								//Ref: RFC4740 9.14.  SIP-Method AVP								
+  const int AVP_SIP_Number_Auth_Items_RFC_AVP = 382; 					//Ref: RFC4740 9.6.  SIP-Number-Auth-Items AVP								
+//  const int AVP_SIP_OptionalCapability_AVP = 374; 					//Ref: RFC4740 9.3.2.  SIP-Optional-Capability AVP								
+//  const int AVP_SIP_Reason_Code_AVP = 384; 						//Ref: RFC4740 9.7.1.  SIP-Reason-Code AVP							
+//  const int AVP_SIP_Reason_Info_AVP = 385;  						//Ref: RFC4740 9.7.2.  SIP-Reason-Info AVP							
+//  const int AVP_SIP_Server_Assignment_Type_AVP = 375; 				//Ref: RFC4740 9.4.  SIP-Server-Assignment-Type AVP								
+//  const int AVP_SIP_Server_Capabilities_AVP = 372; 				//Ref: RFC4740 9.3.  SIP-Server-Capabilities AVP								
+//  const int AVP_SIP_Server_URI_AVP = 371; 							//Ref: RFC4740 9.2 SIP-Server-URI AVP							
+//  const int AVP_SIP_Supported_User_Data_Type_AVP = 388; 			//Ref: RFC4740 9.12.1.  SIP-User-Data-Type AVP								
+//  const int AVP_SIP_User_Authorization_Type_AVP = 387; 			//Ref: RFC4740 9.10.  SIP-User-Authorization-Type AVP						
+//  const int AVP_SIP_User_Data_Already_Available_AVP = 392; 		//Ref: RFC4740 9.13.  SIP-User-Data-Already-Available AVP								
+//  const int AVP_SIP_User_Data_AVP = 389; 							//Ref: RFC4740 9.12.  SIP-User-Data AVP								
+//  const int AVP_SIP_User_Data_Contents_AVP = 391; 					//Ref: RFC4740 9.12.2.  SIP-User-Data-Contents AVP								
+//  const int AVP_SIP_User_Data_Type_AVP = 390; 						//Ref: RFC4740 9.12.1.  SIP-User-Data-Type AVP								
+//  const int AVP_SIP_Visited_Network_Id_AVP = 386; 					//Ref: RFC4740 9.9.  SIP-Visited-Network-Id AVP							
+  //end of RFC4740 AVP codes
+
+  const int AVP_Digest_Realm_AVP = 104;
+  const int AVP_Digest_Nonce_AVP = 105;
+  const int AVP_Digest_Domain_AVP = 119;
+  const int AVP_Digest_Opaque_AVP = 116;
+  const int AVP_Digest_Stale_AVP = 120;
+  const int AVP_Digest_Algorithm_AVP = 111;
+  const int AVP_Digest_QoP_AVP = 110;
+  const int AVP_Digest_HA1_AVP = 121;
+  const int AVP_Digest_Auth_Param_AVP = 117;
+  const int AVP_Digest_Username_AVP = 115;
+  const int AVP_Digest_URI_AVP = 109;
+  const int AVP_Digest_Response_AVP = 103;
+  const int AVP_Digest_CNonce_AVP = 113;
+  const int AVP_Digest_Nonce_Count_AVP = 114;
+  const int AVP_Digest_Method_AVP = 108;
+  const int AVP_Digest_Entity_Body_Hash_AVP = 112;
+  const int AVP_Digest_Nextnonce_AVP = 107;
+  const int AVP_Digest_Response_Auth_AVP = 106;
+
+
+  //RFC4005 AVP codes
+  const int AVP_Called_Station_Id_AVP = 30;
+  const int AVP_Framed_IP_Address_AVP  = 8;
+  const int AVP_Framed_IPv6_Prefix_AVP = 97;
+  const int AVP_Framed_Interface_Id_AVP = 96;
+  //end of RFC4005 AVP codes
+
+  //RFC4006 AVP codes
+//  const int AVP_Rating_Group_AVP = 433; 							//Ref: RFC4006 8.29. Rating-Group AVP								
+const int AVP_Tariff_Time_Change_AVP = 451; 						//Ref: RFC4006 8.20. Tariff-Time-Change AVP								
+//  const int AVP_CC_Correlation_Id_AVP = 411; 						//Ref: RFC4006 8.1.  CC-Correlation-Id AVP								
+const int AVP_CC_Input_Octets_AVP = 412; 						//Ref: RFC4006 8.24. CC-Input-Octets AVP
+const int AVP_CC_Money_AVP = 413; 								//Ref: RFC4006 8.22. CC-Money AVP								
+const int AVP_CC_Output_Octets_AVP = 414; 						//Ref: RFC4006 8.25. CC-Output-Octets AVP								
+  const int AVP_CC_Request_Number_AVP = 415; 						//Ref: RFC4006 8.2.  CC-Request-Number AVP								
+  const int AVP_CC_Request_Type_AVP = 416; 						//Ref: RFC4006 8.3.  CC-Request-Type AVP								
+const int AVP_CC_Service_Specific_Units_AVP = 417; 				//Ref: RFC4006 8.26. CC-Service-Specific-Units AVP								
+const int AVP_CC_Session_Failover_AVP = 418; 					//Ref: RFC4006 8.4.  CC-Session-Failover AVP								
+//  const int AVP_vendIdCC_Sub_Session_Id_AVP = 419; 						//Ref: RFC4006 8.5.  CC-Sub-Session-Id AVP								
+const int AVP_CC_Time_AVP = 420; 								//Ref: RFC4006 8.21. CC-Time AVP								
+const int AVP_CC_Total_Octets_AVP = 421; 						//Ref: RFC4006 8.23. CC-Total-Octets AVP								
+const int AVP_CC_Unit_Type_AVP = 454; 							//Ref: RFC4006 8.32. CC-Unit-Type AVP								
+//  const int AVP_vendIdCheck_Balance_Result_AVP = 422; 					//Ref: RFC4006 8.6.  Check-Balance-Result AVP 12.8.  Check-Balance-Result AVP								
+const int AVP_Cost_Information_AVP = 423; 						//Ref: RFC4006 8.7.  Cost-Information AVP								
+const int AVP_Cost_Unit_AVP = 424; 								//Ref: RFC4006 8.12. Cost-Unit AVP								
+const int AVP_Credit_Control_Failure_Handling_AVP = 427; 		//Ref: RFC4006 8.14. Credit-Control-Failure-Handling AVP								
+const int AVP_Currency_Code_AVP = 425; 							//Ref: RFC4006 8.11. Currency-Code AVP								
+const int AVP_Direct_Debiting_Failure_Handling_AVP = 428; 		//Ref: RFC4006 8.15. Direct-Debiting-Failure-Handling AVP								
+const int AVP_Exponent_AVP = 429; 								//Ref: RFC4006 8.9.  Exponent AVP								
+const int AVP_Filter_Id_AVP = 11; 								//Ref: RFC4005 6.7.  Filter-Id AVP								
+const int AVP_Final_Unit_Action_AVP = 449; 						//Ref: RFC4006 8.35. Final-Unit-Action AVP								
+const int AVP_Final_Unit_Indication_AVP = 430; 					//Ref: RFC4006 8.34. Final-Unit-Indication AVP								
+const int AVP_G_S_U_Pool_Identifier_AVP = 453; 					//Ref: RFC4006 8.31. G-S-U-Pool-Identifier AVP								
+const int AVP_G_S_U_Pool_Reference_AVP = 457; 					//Ref: RFC4006 8.30. G-S-U-Pool-Reference AVP								
+const int AVP_Granted_Service_Unit_AVP = 431; 					//Ref: RFC4006 8.17. Granted-Service-Unit AVP								
+//  const int AVP_vendIdMultiple_Services_Credit_Control_AVP = 456; 		//Ref: RFC4006 8.16. Multiple-Services-Credit-Control AVP								
+const int AVP_Multiple_Services_Indicator_AVP = 455; 			//Ref: RFC4006 8.40. Multiple-Services-Indicator AVP								
+  const int AVP_Redirect_Address_Type_AVP = 433; 					//Ref: RFC4006 8.38. Redirect-Address-Type AVP								
+  const int AVP_Redirect_Server_Address_AVP = 435; 				//Ref: RFC4006 8.39. Redirect-Server-Address AVP								
+  const int AVP_Redirect_Server_AVP = 434; 						//Ref: RFC4006 8.37. Redirect-Server AVP								
+//  const int AVP_vendIdRequested_Action_AVP = 436; 						//Ref: RFC4006 8.41. Requested-Action AVP								
+const int AVP_Requested_Service_Unit_AVP = 437; 					//Ref: RFC4006 8.18. Requested-Service-Unit AVP								
+const int AVP_Restriction_Filter_Rule_AVP = 438; 				//Ref: RFC4006 8.36. Restriction-Filter-Rule AVP								
+  const int AVP_Service_Context_Id_AVP = 461; 						//Ref: RFC4006 8.42. Service-Context-Id AVP								
+  const int AVP_Service_Identifier_AVP = 439; 						//Ref: RFC4006 8.28. Service-Identifier AVP								
+  const int AVP_Requested_Action_AVP = 436;
+  //  const int AVP_vendIdService_Parameter_Info_AVP = 440; 					//Ref: RFC4006 8.43. Service-Parameter-Info AVP								
+//  const int AVP_vendIdService_Parameter_Type_AVP = 441; 					//Ref: RFC4006 8.44. Service-Parameter-Type AVP								
+//  const int AVP_vendIdService_Parameter_Value_AVP = 442; 				//Ref: RFC4006 8.45. Service-Parameter-Value AVP								
+  const int AVP_Subscription_Id_AVP = 443; 						//Ref: RFC4006 8.46. Subscription-Id AVP								
+  const int AVP_Subscription_Id_Data_AVP = 444; 					//Ref: RFC4006 								
+  const int AVP_Subscription_Id_Type_AVP = 450; 					//Ref: RFC4006 8.47. Subscription-Id-Type AVP								
+  const int AVP_Tariff_Change_Usage_AVP = 452;//Ref: RFC4006 8.27. Tariff-Change-Usage AVP 
+  const int AVP_Rating_Group_AVP = 433;								
+const int AVP_Unit_Value_AVP = 445; 								//Ref: RFC4006 8.8.  Unit-Value AVP								
+const int AVP_Used_Service_Unit_AVP = 446; 						//Ref: RFC4006 8.19. Used-Service-Unit AVP								
+//  const int AVP_vendIdUser_Equipment_Info_AVP = 458; 					//Ref: RFC4006 8.49. User-Equipment-Info AVP								
+//  const int AVP_vendIdUser_Equipment_Info_Type_AVP = 459; 				//Ref: RFC4006 8.50. User-Equipment-Info-Type AVP								
+//  const int AVP_vendIdUser_Equipment_Info_Value_AVP = 460; 				//Ref: RFC4006 8.51. User-Equipment-Info-Value AVP								
+const int AVP_Validity_Time_AVP = 448; 							//Ref: RFC4006 8.33. Validity-Time AVP								
+const int AVP_Value_Digits_AVP = 447; 							//Ref: RFC4006 8.10. Value-Digits AVP								
+  /*end of RFC4006 AVP codes*/
+
+  //TS129_229 AVP codes
+//  const int AVP_vendIdCharging_Information_AVP = 61; 							//Ref: ETSI TS 129 229 Charging_Information_AVP
+//  const int AVP_vendIdPrimary_Event_Charging_Function_Name_AVP = 619; 			//Ref: ETSI TS 129 229 Primary_Event_Charging_Function_Name_AVP
+//  const int AVP_vendIdSecondary_Event_Charging_Function_Name_AVP = 620; 		//Ref: ETSI TS 129 229 Secondary_Event_Charging_Function_Name_AVP
+//  const int AVP_vendIdPrimary_Charging_Collection_Function_Name_AVP = 621; 	//Ref: ETSI TS 129 229 Primary_Charging_Collection_Function_Name_AVP
+//  const int AVP_vendIdSecondary_Charging_Collection_Function_Name_AVP = 622; 	//Ref: ETSI TS 129 229 Secondary_Charging_Collection_Function_Name_AVP
+  const int AVP_Charging_Rule_Remove_AVP = 1002;
+  const int AVP_Charging_Rule_Install_AVP = 1001;
+  const int AVP_Charging_Rule_Report_AVP = 1018;
+  const int AVP_Routing_Rule_Install_AVP = 1081;
+  const int AVP_Routing_Rule_Remove_AVP = 1075;
+  const int AVP_QoS_Information_AVP = 1016;
+  const int AVP_Default_EPS_Bearer_QoS_AVP = 1049;
+  const int AVP_Server_Capabilities_AVP = 603;							//Ref: ETSI TS 129 229 Server_Capabilities_AVP
+//  const int AVP_vendIdMandatory_Capability_AVP = 604;							//Ref: ETSI TS 129 229 Mandatory_Capability_AVP
+//  const int AVP_vendIdOptional_Capability_AVP = 605;							//Ref: ETSI TS 129 229 Optional_Capability_AVP
+  const int AVP_IP_CAN_Type_AVP = 1027;
+  const int AVP_RAT_Type_AVP = 1032;                                 //Ref: ETSI TS 129 212 RAT_Type_AVP
+  const int AVP_Event_Trigger_AVP = 1006;
+  const int AVP_Session_Release_Cause_AVP = 1045;
+  const int AVP_Charging_Rule_Name_AVP = 1005;
+  const int AVP_AN_GW_Address_AVP = 1050;
+
+  const int AVP_Experimental_Result_AVP = 297;
+  const int AVP_Experimental_Result_Code_AVP = 298;
+  const int AVP_User_Data_AVP = 606;
+
+  /*end of TS129_229 AVP codes*/
+
+  //tS129_329
+  const int AVP_Public_Identity_AVP = 601;
+  const int AVP_Server_Name_AVP = 602;
+  const int AVP_Feature_List_ID_AVP = 629; //    Ref: 3GPP TS 29.229, clause 6.3.30
+  const int AVP_Feature_List_AVP = 630;             //    Ref: 3GPP TS 29.229, clause 6.3.31
+  const int AVP_Supported_Features_AVP = 628;                           //    Ref: 3GPP TS 29.329    6.3.11 Supported-Features AVP (See 3GPP TS 29.229, clause 6.3.29)
+  /*End TS129_329*/
+
+  //Sh AVP codes
+
+  ////const int AVP_Public_Identity_AVP = 601;
+  const int AVP_User_Identity_AVP = 700;
+  const int AVP_MSISDN_AVP= 701;
+  const int AVP_User_Data_Sh_AVP= 702;
+  const int AVP_Data_Reference_AVP = 703;
+  const int AVP_Service_Indication_AVP = 704;
+  const int AVP_Subs_Req_Type_AVP =705; 
+  const int AVP_Requested_Domain_AVP = 706;
+  const int AVP_Current_Location_AVP = 707;
+  const int AVP_Identity_Set_AVP = 708;
+  const int AVP_Expiry_Time_AVP= 709;
+  const int AVP_Send_Data_Indication_AVP = 710;
+  const int AVP_Repository_Data_ID_AVP = 715;									
+  const int AVP_Sequence_Number_AVP = 716;
+  ////const int AVP_Server_Name_AVP = 602;
+  ////const int AVP_Supported_Features_AVP = 628; 
+  ////const int AVP_Feature_List_ID_AVP = 629;
+  ////const int AVP_Feature_List_AVP = 630;
+  const int AVP_Wildcarded_PSI_AVP = 634;
+  const int AVP_Wildcarded_IMPU_AVP = 636;
+  const int AVP_DSAI_Tag_AVP = 711;
+  ////const int AVP_Experimental_Result_Code_AVP = 298;
+  ////const int AVP_Experimental_Result_AVP = 297; 
+  ////const int AVP_User_Data_AVP = 606;
+  //TS129_214 AVP codes
+  const int AVP_Media_Component_Description_AVP = 517;
+  const int AVP_Media_Component_Nr_AVP = 518;
+  const int AVP_Media_Sub_Component_AVP = 519;
+  const int AVP_AF_Application_Identifier_AVP = 504;
+  const int AVP_Media_Type_AVP = 520;
+  const int AVP_AF_Signalling_Protocol_AVP = 529;
+  const int AVP_Reservation_Priority_AVP = 458;
+  const int AVP_RS_Bandwidth_AVP = 522;
+  const int AVP_RR_Bandwidth_AVP = 521;
+  const int AVP_Codec_Data_AVP = 524;
+  const int AVP_Flow_Description_AVP = 507;
+  const int AVP_Flow_Number_AVP = 509;
+  const int AVP_Flow_Status_AVP = 511;
+  const int AVP_Flow_Usage_AVP = 512;
+  const int AVP_Specific_Action_AVP = 513;
+  const int AVP_Service_Info_Status_AVP = 527;
+  const int AVP_Rx_Request_Type_AVP = 533;
+
+  //TS129_215 AVP codes
+  const int AVP_QoS_Rule_Name_AVP = 1054;
+  const int AVP_Rule_Failure_Code_AVP = 1031;
+  const int AVP_PDN_Connection_ID_AVP = 1065;
+  const int AVP_QoS_Rule_Report_AVP = 1055;
+  const int AVP_QoS_Rule_Install_AVP = 1051;
+  const int AVP_Multiple_BBERF_Action_AVP = 2204;
+  const int AVP_Session_Linking_Indicator_AVP = 1064;
+  const int AVP_Subses_Decision_Info_AVP = 2200;
+  const int AVP_Subses_Enforcement_Info_AVP = 2201;
+  const int AVP_Subsession_Id_AVP = 2202;
+  const int AVP_Subsession_Operation_AVP = 2203;
+  //End TS129_215 AVP codes
+
+   //TS129_272 AVP codes
+   const int AVP_ULR_Flags_AVP = 1405;                                //ref: 7.3.7 ETSI TS 129 272
+   const int AVP_ULA_Flags_AVP = 1406;                                //ref: 7.3.8
+   const int AVP_Visited_PLMN_Id_AVP = 1407;                          //ref: 7.3.9
+   const int AVP_UE_SRVCC_Capability_AVP = 1615;                      //ref: 7.3.130
+   const int AVP_SGSN_Number_AVP = 1489;  							//ref: 7.3.102
+   const int AVP_Homogeneous_Support_AVP = 1493;  					//ref: 7.3.107
+
+   const int AVP_Context_Identifier_AVP = 1423;                      //ref: 7.3.27
+   const int AVP_Service_Selection_AVP  = 493;                       //ref: 7.3.36
+   const int AVP_MIP_Home_Agent_Address_AVP = 334;                   //ref: 7.3.42 - IETF RFC 4004 7.4
+   const int AVP_MIP_Home_Agent_Host_AVP = 348;                      //ref: 7.3.43 - IETF RFC 4004 7.11
+   const int AVP_MIP6_Home_Link_Prefix_AVP = 125;                    //ref:IETF RFC 5447 4.2.4
+   const int AVP_MIP6_Agent_Info_AVP    = 486;                       //ref: 7.3.45
+   const int AVP_Visited_Network_Identifier_AVP = 600;               //ref: 7.3.105 - TS 129 229 6.3.1
+   const int AVP_SIP_Authentication_Context_AVP = 611;
+   const int AVP_UAR_Flags_AVP = 637;
+   const int AVP_User_Authorization_Type_AVP = 623;
+   const int AVP_Server_Assignment_Type_AVP = 614;
+   const int AVP_User_Data_Already_Available_AVP = 624;
+   const int AVP_SIP_Digest_Authenticate_AVP = 635;
+   const int AVP_SCSCF_Restoration_Info_AVP = 639;
+   const int AVP_Restoration_Info_AVP = 649;
+   const int AVP_Path_AVP = 640;
+   const int AVP_Contact_AVP = 641;
+   const int AVP_Subscription_Info_AVP = 642;
+   const int AVP_Originating_Request_AVP = 652;
+   const int AVP_Deregistration_Reason_AVP = 615;
+   const int AVP_Reason_Code_AVP = 616;
+   const int AVP_Reason_Info_AVP = 617;
+   const int AVP_Specific_APN_Info_AVP  = 1472;                      //ref: 7.3.82
+   const int AVP_Active_APN_AVP = 1612;                              //ref: 7.3.127
+   const int AVP_Error_Diagnostic_AVP = 1614;						//ref: 7.3.128;
+   const int AVP_Subscriber_Status_AVP = 1424;
+   const int AVP_Operator_Determined_Barring_AVP = 1425;
+   const int AVP_HPLMN_ODB_AVP = 1418;
+   const int AVP_Access_Restriction_Data_AVP = 1426;
+   const int AVP_APN_OI_Replacement_AVP = 1427;
+   const int AVP_Max_Requested_Bandwidth_UL_AVP = 516;
+   const int AVP_Max_Requested_Bandwidth_DL_AVP = 515;
+   const int AVP_APN_Aggregate_Max_Bitrate_UL_AVP = 1041;
+   const int AVP_APN_Aggregate_Max_Bitrate_DL_AVP = 1040;
+   const int AVP_AMBR_AVP = 1435;
+
+   const int AVP_All_APN_Conf_Included_Id_AVP = 1428;
+   const int AVP_APN_Configuration_Profile_AVP = 1429;
+   const int AVP_PDN_Type_AVP = 1456;
+   const int AVP_QoS_Class_Identifier_AVP=1028;
+   const int AVP_Priority_Level_AVP = 1046;
+   const int AVP_Pre_emption_Capability_AVP = 1047;
+   const int AVP_Pre_emption_Vulnerability_AVP = 1048;
+
+   const int AVP_Allocation_Retention_Priority_AVP =1034;
+   const int AVP_EPS_Subscribed_QoS_Profile_AVP = 1431;
+   const int AVP_APN_Configuration_AVP = 1430;
+   const int AVP_GMLC_Address_AVP = 2405;                            //ref: 7.3.109 - TS 129 173 6.4.7
+   //....
+   const int AVP_Complete_DL_Included_Indicator_AVP = 1468;
+   const int AVP_QoS_Subscribed_AVP = 1404;
+   const int AVP_PDP_Type_AVP = 1470;
+   const int AVP_PDP_Context_AVP = 1469; 
+   const int AVP_GPRS_Subscription_Data_AVP = 1467;
+   const int AVP_Subscription_Data_AVP = 1400;                       //ref: 7.3.2
+   const int AVP_Immediate_Response_Preferred_AVP = 1412;            //ref: 7.3.16
+   const int AVP_Re_synchronization_Info_AVP = 1411;                 //ref: 7.3.15
+   const int AVP_Req_EUTRAN_Auth_Info_AVP = 1408;                    //ref: 7.3.11
+   const int AVP_Req_UTRAN_GERAN_Auth_Info_AVP = 1409;               //ref: 7.3.12
+
+   const int AVP_Item_Number_AVP = 1419;
+   const int AVP_RAND_AVP = 1447;
+   const int AVP_XRES_AVP = 1448;
+   const int AVP_AUTN_AVP = 1449;
+   const int AVP_KASME_AVP = 1450;
+   const int AVP_E_UTRAN_Vector_AVP = 1414;
+   const int AVP_SIP_Authentication_Scheme_3GPP_AVP = 608;
+   const int AVP_SIP_Authenticate_3GPP_AVP = 609;
+   const int AVP_SIP_Authorization_3GPP_AVP = 610;
+   const int AVP_SIP_Number_Auth_Items_3GPP_AVP = 607;
+   const int AVP_SIP_Auth_Data_Item_3GPP_AVP = 612;//ETSI TS 129 229 V10.5.0 (2013-04) Clause 6.3.13 SIP-Auth-Data-Item AVP
+   const int AVP_Identity_with_Emergency_Registration_AVP = 651;
+   const int AVP_Confidentiality_Key_AVP = 625;
+   const int AVP_Integrity_Key_AVP = 626;
+   const int AVP_Line_Identifier_AVP = 500;
+   const int AVP_UTRAN_Vector_AVP = 1415; 
+   const int AVP_SRES_AVP = 1454;
+   const int AVP_Kc_AVP = 1453;
+   const int AVP_GERAN_Vector_AVP = 1416;
+   const int AVP_Authentication_Info_AVP = 1413;
+
+   const int AVP_Cancellation_Type_AVP = 1420;
+   const int AVP_CLR_Flags_AVP = 1638;                               //ref: 7.3.152
+   const int AVP_IDR_Flags_AVP = 1490;                               //ref: 7.3.103
+   const int AVP_DSR_Flags_AVP = 1421;                               //ref: 7.3.25
+   const int AVP_DSA_Flags_AVP = 1422;                               //ref: 7.3.26
+   const int AVP_PUER_Flags_AVP= 1635;                               //ref: 7.3.149
+   const int AVP_PUEA_Flags_AVP= 1442;                               //ref: 7.3.48
+   const int AVP_IDA_Flags_AVP = 1441;                               //ref: 7.3.47
+   const int AVP_NOR_Flags_AVP = 1443;                               //ref: 7.3.49
+   const int AVP_IMS_Voice_PS_Sessions_Support_AVP = 1492;
+   const int AVP_Last_UE_Activity_Time_AVP = 1494;
+   const int AVP_EPS_User_State_AVP = 1495;
+   const int AVP_EPS_Location_Information_AVP = 1496;
+   //end TS129_272 AVP codes
+
+
+  //TS132_299 AVP codes
+   const int AVP_Charging_Information_AVP = 618;
+   const int AVP_Primary_Event_Charging_Function_Name_AVP = 619;
+   const int AVP_Secondary_Event_Charging_Function_Name_AVP = 620;
+   const int AVP_Primary_Charging_Collection_Function_Name_AVP = 621;
+   const int AVP_Secondary_Charging_Collection_Function_Name_AVP = 622;
+//  const int AVP_User_CSG_Information_AVP = 2319; 		//Ref: ETSI TS 132 299 User_CSG_Information_AVP
+//  const int AVP_CSG_Id_AVP = 1437; 						//Ref: ETSI TS 132 299 CSG_Id_AVP
+//  const int AVP_CSG_Access_Mode_AVP = 2317; 				//Ref: ETSI TS 132 299 CSG_Access_Mode_AVP
+//  const int AVP_CSG_Membership_Indication_AVP = 2318;	//Ref: ETSI TS 132 299 CSG_Membership_Indication_AVP
+  const int AVP_Service_Information_AVP = 873;			//Ref: ETSI TS 132 299 Service_Information_AVP
+  const int AVP_PS_Information_AVP = 874;				//Ref: ETSI TS 132 299 PS_Information_AVP
+  const int AVP_WLAN_Information_AVP = 875;				//Ref: ETSI TS 132 299 WLAN_Information_AVP
+  const int AVP_IMS_Information_AVP = 876;				//Ref: ETSI TS 132 299 IMS_Information_AVP
+//  const int AVP_MMS_Information_AVP = 877;				//Ref: ETSI TS 132 299 MMS_Information_AVP
+//  const int AVP_LCS_Information_AVP = 878;				//Ref: ETSI TS 132 299 LCS_Information_AVP
+//  const int AVP_PoC_Information_AVP = 879;				//Ref: ETSI TS 132 299 PoC_Information_AVP
+//  const int AVP_MBMS_Information_AVP = 880;				//Ref: ETSI TS 132 299 MBMS_Information_AVP
+  const int AVP_Service_Generic_Information_AVP = 1256;	//Ref: ETSI TS 132 299 Service_Generic_Information_AVP
+  const int AVP_Event_Type_AVP = 825;					//Ref: ETSI TS 132 299 Event_Type_AVP
+  const int AVP_Event_AVP = 823;							//Ref: ETSI TS 132 299 Event_AVP
+  const int AVP_Expires_AVP = 888;						//Ref: ETSI TS 132 299 Expires_AVP
+  const int AVP_Role_Of_Node_AVP = 829;					//Ref: ETSI TS 132 299 Role_Of_Node_AVP
+  const int AVP_Node_Functionality_AVP = 862;			//Ref: ETSI TS 132 299 Node_Functionality_AVP
+  const int AVP_User_Session_ID_AVP = 830;				//Ref: ETSI TS 132 299 User_Session_ID_AVP
+  const int AVP_Calling_Party_Address_AVP = 831;			//Ref: ETSI TS 132 299 Calling_Party_Address_AVP
+  const int AVP_Called_Party_Address_AVP = 832;			//Ref: ETSI TS 132 299 Called_Party_Address_AVP
+  const int AVP_Called_Asserted_Identity_AVP = 1250;		//Ref: ETSI TS 132 299 Called_Asserted_Identity_AVP
+  const int AVP_Alternate_Charged_Party_Address_AVP = 1280;//Ref: ETSI TS 132 299 Alternate_Charged_Party_Address_AVP
+  const int AVP_Requested_Party_Address_AVP = 1251;		//Ref: ETSI TS 132 299 Requested_Party_Address_AVP
+  const int AVP_Associated_URI_AVP = 856;				//Ref: ETSI TS 132 299 Associated_URI_AVP
+  const int AVP_Time_Stamps_AVP = 833;					//Ref: ETSI TS 132 299 Time_Stamps_AVP
+  const int AVP_SIP_Request_Timestamp_AVP = 834;			//Ref: ETSI TS 132 299 SIP_Request_Timestamp_AVP
+  const int AVP_SIP_Response_Timestamp_AVP = 835;		//Ref: ETSI TS 132 299 SIP_Response_Timestamp_AVP
+  const int AVP_Application_Server_Information_AVP = 850;//Ref: ETSI TS 132 299 Application_Server_Information_AVP
+  const int AVP_Application_Server_AVP = 836;			//Ref: ETSI TS 132 299 Application_Server_AVP
+  const int AVP_Application_Provided_Called_Party_Address_AVP = 837;		//Ref: ETSI TS 132 299 Application_Provided_Called_Party_Address_AVP
+  const int AVP_Inter_Operator_Identifier_AVP = 838;		//Ref: ETSI TS 132 299 Inter_Operator_Identifier_AVP
+  const int AVP_Originating_IOI_AVP = 839;				//Ref: ETSI TS 132 299 Originating_IOI_AVP
+  const int AVP_Terminating_IOI_AVP = 840;				//Ref: ETSI TS 132 299 Terminating_IOI_AVP
+  const int AVP_IMS_Charging_Identifier_AVP = 841;		//Ref: ETSI TS 132 299 IMS_Charging_Identifier_AVP
+  const int AVP_SDP_Session_Description_AVP = 842;		//Ref: ETSI TS 132 299 SDP_Session_Description_AVP
+  const int AVP_SDP_Media_Component_AVP = 844;				//Ref: ETSI TS 132 299 SDP_Media_Name_AVP
+//  const int AVP_SDP_Media_Name_AVP = 844;				//Ref: ETSI TS 132 299 SDP_Media_Name_AVP
+//  const int AVP_SDP_Media_Description_AVP = 845;			//Ref: ETSI TS 132 299 SDP_Media_Description_AVP
+//  const int AVP_Media_Initiator_Flag_AVP = 882;			//Ref: ETSI TS 132 299 Media_Initiator_Flag_AVP
+//  const int AVP_Media_Initiator_Party_AVP = 1288;		//Ref: ETSI TS 132 299 Media_Initiator_Party_AVP
+//  const int AVP_Authorized_QoS_AVP = 849;				//Ref: ETSI TS 132 299 Authorized_QoS_AVP
+  const int AVP_Served_Party_IP_Address_AVP = 848;		//Ref: ETSI TS 132 299 Served_Party_IP_Address_AVP
+  const int AVP_Trunk_Group_ID_AVP = 851;				//Ref: ETSI TS 132 299 Trunk_Group_ID_AVP
+  const int AVP_Incoming_Trunk_Group_ID_AVP = 852;		//Ref: ETSI TS 132 299 Incoming_Trunk_Group_ID_AVP
+  const int AVP_Outgoing_Trunk_Group_ID_AVP = 853;		//Ref: ETSI TS 132 299 Outgoing_Trunk_Group_ID_AVP
+
+  const int AVP_Delivery_Status_AVP =2104;
+  const int AVP_Application_Session_ID_AVP=2103;
+  const int AVP_Application_Service_Type_AVP=2102;
+  const int AVP_Application_Server_ID_AVP=2101;
+
+  const int AVP_Reporting_Reason_AVP=872;
+  const int AVP_Time_Quota_Threshold_AVP=868;
+  const int AVP_Volume_Quota_Threshold_AVP=869;
+  const int AVP_Unit_Quota_Threshold_AVP=1226;
+  const int AVP_Quota_Holding_Time_AVP=871;
+  const int AVP_Quota_Consumption_Time_AVP=881;
+  const int AVP_Time_Quota_Type_AVP=1271;
+  const int AVP_Base_Time_Interval_AVP=1265;
+  const int AVP_Time_Quota_Mechanism_AVP=1270;
+  const int AVP_Envelope_Start_Time_AVP=1269;
+  const int AVP_Envelope_End_Time_AVP=1267;
+  const int AVP_Envelope_AVP=1266;
+  const int AVP_Envelope_Reporting_AVP=1268;
+  const int AVP_Trigger_AVP=1264;
+  const int AVP_Trigger_Type_AVP=870;
+  const int AVP_Refund_Information_AVP=2022;
+  const int AVP_Multiple_Services_Credit_Control_AVP = 456;
+
+  const int AVP_Offline_Charging_AVP = 1278;
+  const int AVP_Low_Balance_Indication_AVP=2020;
+  const int AVP_Remaining_Balance_AVP = 2021;
+  //end of TS132_299 AVP codes
+
+private:
+  //NOTE: The order of constants in the following array is very important.
+  //It must exactly match order specified in TTCN-3 module.
+  static const int _command_codes[];
+
+}; // End of class diameter_codec

ccsrc/Protocols/Diameter/diameter_layer.cc

+#include "LibDiameter_Interface.hh"
+#include "LibDiameter_TypesAndValues.hh"
+
+#include "diameter_layer_factory.hh"
+
+#include "loggers.hh"
+
+#include "converter.hh"
+
+diameter_layer::diameter_layer(const std::string & p_type, const std::string & p_param) : t_layer<LibDiameter__Interface::DiameterPort>(p_type), _params() {
+  loggers::get_instance().log(">>> diameter_layer::diameter_layer: %s, %s", to_string().c_str(), p_param.c_str());
+  // Setup parameters
+  params::convert(_params, p_param);
+}
+
+void diameter_layer::sendMsg(const LibDiameter__TypesAndValues::DIAMETER__MSG& p_diameter_message, params& p_param) {
+  loggers::get_instance().log_msg(">>> diameter_layer::sendMsg: ", p_diameter_message);
+
+  // Encode DiameterMessage
+  OCTETSTRING data;
+  // _codec_register.encode(p_diameter_message, data);
+  // send_data(data, _params);
+}
+
+void diameter_layer::send_data(OCTETSTRING& data, params& p_params) {
+  loggers::get_instance().log_msg(">>> diameter_layer::send_data: ", data);
+
+  send_to_all_layers(data, p_params);
+}
+
+void diameter_layer::receive_data(OCTETSTRING& data, params& p_params)
+{
+  loggers::get_instance().log_msg(">>> diameter_layer::receive_data: ", data);
+
+  // Decode Diameter message
+}
+
+diameter_layer_factory diameter_layer_factory::_f;
+

ccsrc/Protocols/Diameter/diameter_layer.hh

+/*!
+ * \file      diameter_layer.hh
+ * \brief     Header file for ITS HTTP protocol layer.
+ * \author    ETSI STF549
+ * \copyright ETSI Copyright Notification
+ *            No part may be reproduced except as authorized by written permission.
+ *            The copyright and the foregoing restriction extend to reproduction in all media.
+ *            All rights reserved.
+ * \version   0.1
+ */
+#pragma once
+
+#include <memory>
+
+#include "t_layer.hh"
+
+namespace LibDiameter__Interface {
+  class DiameterPort; //! Forward declaration of TITAN class
+}
+
+namespace LibDiameter__TypesAndValues {
+  class DIAMETER__MSG; //! Forward declaration of TITAN class
+}
+
+class OCTETSTRING; //! Forward declaration of TITAN class
+
+/*!
+ * \class diameter_layer
+ * \brief  This class provides a factory class to create an diameter_layer class instance
+ */
+class diameter_layer : public t_layer<LibDiameter__Interface::DiameterPort> {
+  params _params;
+
+public: //! \publicsection
+  /*!
+   * \brief Specialised constructor
+   *        Create a new instance of the diameter_layer class
+   * \param[in] p_type \todo
+   * \param[in] p_param \todo
+   */
+  diameter_layer() : t_layer<LibDiameter__Interface::DiameterPort>(), _params() {};
+  /*!
+   * \brief Specialised constructor
+   *        Create a new instance of the diameter_layer class
+   * \param[in] p_type \todo
+   * \param[in] p_param \todo
+   */
+  diameter_layer(const std::string& p_type, const std::string& p_param);
+  /*!
+   * \brief Default destructor
+   */
+  virtual ~diameter_layer() { };
+
+  void sendMsg(const LibDiameter__TypesAndValues::DIAMETER__MSG& p_diameter_message, params& p_param);
+
+  /*!
+   * \virtual
+   * \fn void send_data(OCTETSTRING& data, params& p_params);
+   * \brief Send bytes formated data to the lower layers
+   * \param[in] p_data The data to be sent
+   * \param[in] p_params Some parameters to overwrite default value of the lower layers parameters
+   */
+  virtual void send_data(OCTETSTRING& data, params& p_params);
+  /*!
+   * \virtual
+   * \fn void receive_data(OCTETSTRING& data, params& p_params);
+   * \brief Receive bytes formated data from the lower layers
+   * \param[in] p_data The bytes formated data received
+   * \param[in] p_params Some lower layers parameters values when data was received
+   */
+  virtual void receive_data(OCTETSTRING& data, params& info);
+}; // End of class diameter_layer
+

ccsrc/Protocols/Diameter/diameter_layer_factory.hh

+/*!
+ * \file      diameter_layer_factory.hh
+ * \brief     Header file for Diameter protocol layer factory.
+ * \author    ETSI TTF T010
+ * \copyright ETSI Copyright Notification
+ *            No part may be reproduced except as authorized by written permission.
+ *            The copyright and the foregoing restriction extend to reproduction in all media.
+ *            All rights reserved.
+ * \version   0.1
+ */
+#pragma once
+
+#include "layer_stack_builder.hh"
+
+#include "diameter_layer.hh"
+
+/*!
+ * \class diameter_layer_factory
+ * \brief  This class provides a factory class to create an diameter_layer class instance
+ */
+class diameter_layer_factory : public layer_factory {
+  static diameter_layer_factory _f; //! Reference to the unique instance of this class
+public: //! \publicsection
+  /*!
+   * \brief Default constructor
+   *        Create a new instance of the udp_layer_factory class
+   * \remark The HTTP layer identifier is HTTP
+   */
+  diameter_layer_factory() {
+    // Register factory
+    layer_stack_builder::register_layer_factory("DIAMETER", this);
+  };
+  /*!
+   * \fn layer* create_layer(const std::string & type, const std::string & param);
+   * \brief  Create the layers stack based on the provided layers stack description
+   * \param[in] p_type The provided layers stack description
+   * \param[in] p_params Optional parameters
+   * \return 0 on success, -1 otherwise
+   * \inline
+   */
+  inline virtual layer* create_layer(const std::string& p_type, const std::string& p_param){
+    return new diameter_layer(p_type, p_param);
+  };
+}; // End of class diameter_layer_factory
+

ccsrc/Protocols/Diameter/diameter_uar_codec.cc

+#include <string>
+
+#include "avp.hh"
+
+#include "diameter_uar_codec.hh"
+
+#include "loggers.hh"
+#include "converter.hh"
+
+template <typename T_type> class OPTIONAL;
+class TTCN_EncDec;
+
+int diameter_uar_codec::encode(const LibDiameter__TypesAndValues::UAR__MSG& p_uar_msg, OCTETSTRING& p_data) {
+  loggers::get_instance().log_msg(">>> diameter_uar_codec::encode", (const Base_Type &)p_uar_msg);
+
+  TTCN_EncDec::clear_error();
+  TTCN_Buffer encoding_buffer;
+
+  if (_codec.encode_header(p_uar_msg.header(), encoding_buffer) == -1) {
+    loggers::get_instance().warning("diameter_uar_codec::encode: Failed to encode UAR header");
+    return -1;
+  }
+
+  if (encode_avps(p_uar_msg, encoding_buffer) == -1) {
+    loggers::get_instance().warning("diameter_uar_codec::encode: Failed to encode UAR AVPs");
+    return -1;
+  }
+
+  p_data = OCTETSTRING(encoding_buffer.get_len(), encoding_buffer.get_data());	
+  // Update length at offset #1 on 3 bytes
+
+  return 0;
+}
+
+int diameter_uar_codec::encode_avps(const LibDiameter__TypesAndValues::UAR__MSG& p_uar_msg, TTCN_Buffer p_encoding_buffer) {
+  loggers::get_instance().log_msg(">>> diameter_uar_codec::encode_avps: ", OCTETSTRING(p_encoding_buffer.get_len(), p_encoding_buffer.get_data()));
+
+  // SessionId
+  if (_codec.encode_session_id(p_uar_msg.session__Id(), p_encoding_buffer) == -1) {
+    loggers::get_instance().warning("diameter_uar_codec::encode_avps: Failed to encode session__Id__AVP");
+    return -1;
+  }
+
+  // Mandatory AVPs
+  if (_codec.encode_origin_host(p_uar_msg.uAR__Body().origin__Host(), p_encoding_buffer) == -1) {
+    loggers::get_instance().warning("diameter_uar_codec::encode_avps: Failed to encode  Origin__Host__AVP");
+    return -1;
+  }
+  if (_codec.encode_origin_realm(p_uar_msg.uAR__Body().origin__Realm(), p_encoding_buffer) == -1) {
+    loggers::get_instance().warning("diameter_uar_codec::encode_avps: Failed to encode  Origin__Realm__AVP");
+    return -1;
+  }
+
+
+
+  // Optional AVPs
+  if (_codec.encode_auth_session_state(p_uar_msg.uAR__Body().auth__Session__State(), p_encoding_buffer) == -1) {
+    loggers::get_instance().warning("diameter_uar_codec::encode_avps: AVP is missing");
+    return -1;
+  }
+  // TODO Continue
+
+  loggers::get_instance().log_msg("<<< diameter_uar_codec::encode_avps: ", OCTETSTRING(p_encoding_buffer.get_len(), p_encoding_buffer.get_data()));
+  return 0;
+}
+
+int diameter_uar_codec::decode(const OCTETSTRING& p_data, LibDiameter__TypesAndValues::UAR__MSG& p_uar_msg, params* p_params) {
+  loggers::get_instance().log_msg(">>> diameter_uar_codec::decode: ", (const Base_Type &)p_data);
+
+  TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL, TTCN_EncDec::EB_DEFAULT);
+  TTCN_EncDec::clear_error();
+  TTCN_Buffer decoding_buffer(p_data);
+
+  params _params;
+  _params.insert(std::make_pair<std::string, std::string>("Request", "1"));
+
+  if (_codec.decode_header(decoding_buffer, p_uar_msg.header(), static_cast<const params&>(_params)) == -1) {
+    loggers::get_instance().warning("diameter_uar_codec::decode: Failed to decode UAR message header");
+    return -1;
+  }
+
+  if (_codec.decode_avps(decoding_buffer, p_uar_msg.header(), static_cast<const params&>(_params)) == -1) {
+    loggers::get_instance().warning("diameter_uar_codec::decode: Failed to decode UAR AVPs");
+    return -1;
+  }
+
+  // Mandatory AVPs
+  if (decode_auth_session_state(p_uar_msg.uAR__Body().auth__Session__State()) == -1) {
+    loggers::get_instance().warning("diameter_uar_codec::decode: Missing Auth__Session__State__AVP");
+    return -1;
+  }
+  if (decode_origin_host(p_uar_msg.uAR__Body().origin__Host()) == -1) {
+    loggers::get_instance().warning("diameter_uar_codec::decode: Missing Origin__Host__AVP");
+    return -1;
+  }
+  if (decode_origin_realm(p_uar_msg.uAR__Body().origin__Realm()) == -1) {
+    loggers::get_instance().warning("diameter_uar_codec::decode: Missing Origin__Realm__AVP");
+    return -1;
+  }
+  if (decode_destination_realm(p_uar_msg.uAR__Body().destination__Realm()) == -1) {
+    loggers::get_instance().warning("diameter_uar_codec::decode: Missing Destination__Realm__AVP");
+    return -1;
+  }
+  if (decode_session_id(p_uar_msg.session__Id()) == -1) {
+    loggers::get_instance().warning("diameter_uar_codec::decode: Missing Destination__Realm__AVP");
+    return -1;
+  }
+
+  // Optinal AVPs
+  if (decode_destination_host(p_uar_msg.uAR__Body().destination__Host()) == -1) {
+    p_uar_msg.uAR__Body().destination__Host().set_to_omit();
+  }
+
+  p_uar_msg.uAR__Body().vendor__Specific__Application__Id().set_to_omit();
+  p_uar_msg.uAR__Body().auth__Application__Id().set_to_omit();
+  p_uar_msg.uAR__Body().sIP__AOR().set_to_omit();
+  p_uar_msg.uAR__Body().user__Name().set_to_omit();
+  p_uar_msg.uAR__Body().sIP__Visited__Network__Id().set_to_omit();
+  p_uar_msg.uAR__Body().sIP__User__Authorization__Type().set_to_omit();
+  p_uar_msg.uAR__Body().supported__Features().set_to_omit();
+  p_uar_msg.uAR__Body().public__Identity().set_to_omit();
+  p_uar_msg.uAR__Body().visited__Network__Identifier().set_to_omit();
+  p_uar_msg.uAR__Body().user__Authorization__Type().set_to_omit();
+  p_uar_msg.uAR__Body().uAR__Flags().set_to_omit();
+  p_uar_msg.uAR__Body().proxy__Info().set_to_omit();
+  p_uar_msg.uAR__Body().route__Record().set_to_omit();
+  p_uar_msg.uAR__Body().aVP__Type().set_to_omit();
+
+  return 0;
+}
+
+int diameter_uar_codec::decode_session_id(LibDiameter__Types__Base__AVPs::Session__Id__AVP& p_avp) {
+  loggers::get_instance().log("diameter_uar_codec::decode_session_id: looking for '%d", _codec.AVP_Session_Id_AVP);
+  const std::unique_ptr<avp>& avp_ptr = _codec.get_avp(_codec.AVP_Session_Id_AVP);
+  if (avp_ptr.get() == nullptr) {
+    loggers::get_instance().warning("diameter_uar_codec::decode_session_id: AVP is missing");
+    return -1;
+  }
+  avp_ptr->decode_session_id(p_avp);
+  loggers::get_instance().log_msg("diameter_uar_codec::decode_session_id: ", p_avp);
+
+  return 0;
+}
+
+int diameter_uar_codec::decode_auth_session_state(LibDiameter__Types__Base__AVPs::Auth__Session__State__AVP& p_avp) {
+  loggers::get_instance().log("diameter_uar_codec::decode_auth_session_state: looking for '%d", _codec.AVP_Auth_Session_State_AVP);
+  const std::unique_ptr<avp>& avp_ptr = _codec.get_avp(_codec.AVP_Auth_Session_State_AVP);
+  if (avp_ptr.get() == nullptr) {
+    loggers::get_instance().warning("diameter_uar_codec::decode_auth_session_state: AVP is missing");
+    return -1;
+  }
+  avp_ptr->decode_auth_session_state(p_avp);
+  loggers::get_instance().log_msg("diameter_uar_codec::decode_auth_session_state: ", p_avp);
+
+  return 0;
+}
+
+int diameter_uar_codec::decode_origin_host(LibDiameter__Types__Base__AVPs::Origin__Host__AVP& p_avp) {
+  loggers::get_instance().log("diameter_uar_codec::decode_origin_host: looking for '%d", _codec.AVP_Origin_Host_AVP);
+  const std::unique_ptr<avp>& avp_ptr = _codec.get_avp(_codec.AVP_Origin_Host_AVP);
+  if (avp_ptr.get() == nullptr) {
+    loggers::get_instance().warning("diameter_uar_codec::decode_origin_host: AVP is missing");
+    return -1;
+  }
+  avp_ptr->decode_origin_host(p_avp);
+  loggers::get_instance().log_msg("diameter_uar_codec::decode_origin_host: ", p_avp);
+
+  return 0;
+}
+
+int diameter_uar_codec::decode_destination_host(LibDiameter__Types__Base__AVPs::Destination__Host__AVP& p_avp) {
+  loggers::get_instance().log("diameter_uar_codec::decode_destination_host: looking for '%d", _codec.AVP_Destination_Host_AVP);
+  const std::unique_ptr<avp>& avp_ptr = _codec.get_avp(_codec.AVP_Destination_Host_AVP);
+  if (avp_ptr.get() == nullptr) {
+    loggers::get_instance().warning("diameter_uar_codec::decode_destination_host: AVP is missing");
+    return -1;
+  }
+  avp_ptr->decode_destination_host(p_avp);
+  loggers::get_instance().log_msg("diameter_uar_codec::decode_destination_host: ", p_avp);
+
+  return 0;
+}
+
+int diameter_uar_codec::decode_origin_realm(LibDiameter__Types__Base__AVPs::Origin__Realm__AVP& p_avp) {
+  loggers::get_instance().log("diameter_uar_codec::decode_origin_realm: looking for '%d", _codec.AVP_Origin_Realm_AVP);
+  const std::unique_ptr<avp>& avp_ptr = _codec.get_avp(_codec.AVP_Origin_Realm_AVP);
+  if (avp_ptr.get() == nullptr) {
+    loggers::get_instance().warning("diameter_uar_codec::decode_origin_realm: AVP is missing");
+    return -1;
+  }
+  avp_ptr->decode_origin_realm(p_avp);
+  loggers::get_instance().log_msg("diameter_uar_codec::decode_origin_realm: ", p_avp);
+
+  return 0;
+}
+
+int diameter_uar_codec::decode_destination_realm(LibDiameter__Types__Base__AVPs::Destination__Realm__AVP& p_avp) {
+  loggers::get_instance().log("diameter_uar_codec::decode_destination_realm: looking for '%d", _codec.AVP_Destination_Realm_AVP);
+  const std::unique_ptr<avp>& avp_ptr = _codec.get_avp(_codec.AVP_Destination_Realm_AVP);
+  if (avp_ptr.get() == nullptr) {
+    loggers::get_instance().warning("diameter_uar_codec::decode_destination_realm: AVP is missing");
+    return -1;
+  }
+  avp_ptr->decode_destination_realm(p_avp);
+  loggers::get_instance().log_msg("diameter_uar_codec::decode_destination_realm: ", p_avp);
+
+  return 0;
+}

ccsrc/Protocols/Diameter/diameter_uar_codec.hh

+#pragma once
+
+#include <vector>
+
+#include "codec_gen.hh"
+#include "params.hh"
+
+#include "avp.hh" 
+#include "diameter_codec.hh" 
+
+class Base_Type;
+class TTCN_Typedescriptor_t;
+class TTCN_Buffer;
+
+namespace LibDiameter__TypesAndValues {
+  class UAR__MSG; //! Forward declaration of TITAN class
+}
+
+class diameter_uar_codec: public codec_gen <
+  LibDiameter__TypesAndValues::UAR__MSG,
+  LibDiameter__TypesAndValues::UAR__MSG>
+{
+  std::vector<avp> avps;
+  diameter_codec   _codec;
+
+public:
+  diameter_uar_codec() : codec_gen<LibDiameter__TypesAndValues::UAR__MSG, LibDiameter__TypesAndValues::UAR__MSG>(), avps(), _codec() { };
+  virtual ~diameter_uar_codec() { };
+
+  virtual int encode (const LibDiameter__TypesAndValues::UAR__MSG& p_uar_msg, OCTETSTRING& p_data);
+  virtual int decode (const OCTETSTRING& p_data, LibDiameter__TypesAndValues::UAR__MSG& p_uar_msg, params* p_params = NULL);
+
+private:
+  int encode_avps(const LibDiameter__TypesAndValues::UAR__MSG& p_uar_msg, TTCN_Buffer p_encoding_buffer);
+
+  int decode_session_id(LibDiameter__Types__Base__AVPs::Session__Id__AVP& p_avp);
+  int decode_auth_session_state(LibDiameter__Types__Base__AVPs::Auth__Session__State__AVP& p_avp);
+  int decode_origin_host(LibDiameter__Types__Base__AVPs::Origin__Host__AVP& p_avp);
+  int decode_destination_host(LibDiameter__Types__Base__AVPs::Destination__Host__AVP& p_avp);
+  int decode_origin_realm(LibDiameter__Types__Base__AVPs::Origin__Realm__AVP& p_avp);
+  int decode_destination_realm(LibDiameter__Types__Base__AVPs::Destination__Realm__AVP& p_avp);
+  
+}; // End of class diameter_uar_codec

ccsrc/Protocols/Diameter/module.mk

+sources := \
+        diameter_layer.cc \
+        diameter_codec.cc \
+        diameter_uar_codec.cc \
+        avp.cc
+
+includes := .

ccsrc/Protocols/Http/http_codec_emtel.cc

+#include "http_codec_emtel.hh"
+
+#include "loggers.hh"
+
+bool http_codec_emtel::encode_body_xml(const LibHttp__XmlMessageBodyTypes::XmlBody &p_xml_body, OCTETSTRING &p_encoding_buffer, const std::string &p_content_type) {
+  loggers::get_instance().log(">>> http_codec_emtel::encode_body_xml");
+
+  std::map<std::string, std::unique_ptr<codec_gen<Record_Type, Record_Type> > >::const_iterator it;
+  bool processed = false;
+  loggers::get_instance().log("http_codec_emtel::encode_body_xml: Content-Type:'%s'", p_content_type.c_str());
+  if (p_content_type.find("held") != std::string::npos) {
+    it = _codecs.find("held"); // TODO Use params
+    if (it != _codecs.cend()) {
+      loggers::get_instance().log("http_codec_emtel::encode_body_xml: Call 'held_codec'");
+      _codecs["held"]->encode((Record_Type&)p_xml_body, p_encoding_buffer); // TODO Use params
+      processed = true;
+    }
+  } else if (p_content_type.find("lost") != std::string::npos) {
+    it = _codecs.find("lost"); // TODO Use params
+    if (it != _codecs.cend()) {
+      loggers::get_instance().log("http_codec_emtel::encode_body_xml: Call 'lost_codec'");
+      _codecs["lost"]->encode((Record_Type&)p_xml_body, p_encoding_buffer); // TODO Use params
+      processed = true;
+    }
+  } // TODO Add new HTTP message codec_gen here
+  if (!processed) {
+    loggers::get_instance().warning("http_codec_emtel::encode_body_xml: Unsupported HTTP codec_gen, use raw field as default");
+    p_encoding_buffer = OCTETSTRING(0, nullptr);
+  }
+
+  return true;
+}
+
+bool http_codec_emtel::decode_body_xml(const OCTETSTRING &p_data, LibHttp__XmlMessageBodyTypes::XmlBody &p_xml_body, const std::string &p_content_type, params* p_params) {
+  loggers::get_instance().log(">>> http_codec_emtel::decode_body_xml");
+
+  if (
+      ((*p_params)["decode_str"].find("=\"urn:ietf:params:xml:ns:geopriv:held\"") != std::string::npos) ||
+      ((*p_params)["decode_str"].find("=\"urn:ietf:params:xml:ns:pidf\"") != std::string::npos)
+      ) {
+    loggers::get_instance().log("http_codec_emtel::decode_body_xml: Find 'urn:ietf:params:xml:ns:geopriv:held'");
+    if (_codecs["held"].get() != nullptr) {
+      loggers::get_instance().log("http_codec_emtel::decode_body_xml: Call 'held_codec'");
+      if (_codecs["held"]->decode(p_data, (Record_Type&)p_xml_body, p_params) == -1) {
+        loggers::get_instance().warning("http_codec_emtel::decode_body_xml: Failed to decode HELD message");
+        p_xml_body.raw() = CHARSTRING(p_data.lengthof(), (char*)static_cast<const unsigned char*>(p_data));
+      } else {
+        loggers::get_instance().log_msg("http_codec_emtel::decode_body_xml: Decoded message:", p_xml_body);
+      }
+    } else {
+      loggers::get_instance().warning("http_codec_emtel::decode_body_xml: No codec_gen for HELD");
+      p_xml_body.raw() = CHARSTRING(p_data.lengthof(), (char*)static_cast<const unsigned char*>(p_data));
+    }
+  } else if ((*p_params)["decode_str"].find("=\"urn:ietf:params:xml:ns:lost1\"") != std::string::npos) {
+    loggers::get_instance().log("http_codec_emtel::decode_body_xml: Find 'urn:ietf:params:xml:ns:lost1'");
+    if (_codecs["lost"].get() != nullptr) {
+      loggers::get_instance().log("http_codec_emtel::decode_body_xml: Call 'lost_codec'");
+      if (_codecs["lost"]->decode(p_data, (Record_Type&)p_xml_body, p_params) == -1) {
+        loggers::get_instance().warning("http_codec_emtel::decode_body_xml: Failed to decode LOST message");
+        p_xml_body.raw() = CHARSTRING(p_data.lengthof(), (char*)static_cast<const unsigned char*>(p_data));
+      } else {
+        loggers::get_instance().log_msg("http_codec_emtel::decode_body_xml: Decoded message:", p_xml_body);
+      }
+    } else {
+      loggers::get_instance().warning("http_codec_emtel::decode_body_xml: No codec_gen for LOST");
+      p_xml_body.raw() = CHARSTRING(p_data.lengthof(), (char*)static_cast<const unsigned char*>(p_data));
+    }
+  } else {
+    loggers::get_instance().warning("http_codec_emtel::decode_body_xml: No XML codec_gen found");
+    p_xml_body.raw() = CHARSTRING(p_data.lengthof(), (char*)static_cast<const unsigned char*>(p_data));
+  }
+  
+  return true;
+}
+
+bool http_codec_emtel::encode_body_json(const LibHttp__JsonMessageBodyTypes::JsonBody &p_json_body, OCTETSTRING &p_encoding_buffer, const std::string &p_content_type) {
+  loggers::get_instance().log(">>> http_codec_emtel::encode_body_json");
+
+  std::map<std::string, std::unique_ptr<codec_gen<Record_Type, Record_Type> > >::const_iterator it;
+  bool processed = false;
+  loggers::get_instance().log("http_codec_emtel::encode_body_json: Content-Type:'%s'", p_content_type.c_str());
+  if (p_content_type.find("json") != std::string::npos) {
+    it = _codecs.find("json"); // TODO Use params
+    if (it != _codecs.cend()) {
+      loggers::get_instance().log("http_codec_emtel::encode_body_json: Call 'json_codec'");
+      _codecs["json"]->encode((Record_Type&)p_json_body, p_encoding_buffer); // TODO Use params
+      processed = true;
+    }
+  } // TODO Add new HTTP message codec_gen here
+  if (!processed) {
+    loggers::get_instance().warning("http_codec_emtel::encode_body_json: Unsupported HTTP codec_gen, use raw field as default");
+    p_encoding_buffer = OCTETSTRING(0, nullptr);
+  }
+
+  return true;  
+}
+bool http_codec_emtel::decode_body_json(const OCTETSTRING &p_data, LibHttp__JsonMessageBodyTypes::JsonBody &p_json_body, const std::string &p_content_type, params* p_params) {
+  loggers::get_instance().log(">>> http_codec_emtel::decode_body_json");
+
+  if (_codecs["json"].get() != nullptr) {
+    loggers::get_instance().log("http_codec_emtel::decode_body_json: Call 'json_codec'");
+    if (_codecs["json"]->decode(p_data, (Record_Type&)p_json_body, p_params) == -1) {
+      loggers::get_instance().warning("http_codec_emtel::decode_body_json: Failed to decode JSON message");
+      p_json_body.raw() = CHARSTRING(p_data.lengthof(), (char*)static_cast<const unsigned char*>(p_data));
+    } else {
+      loggers::get_instance().log_msg("http_codec_emtel::decode_body_json: Decoded message:", p_json_body);
+    }
+  }
+
+  return true;
+}
\ No newline at end of file

ccsrc/Protocols/Http/http_codec_emtel.hh

+#pragma once
+
+#include "http_codec.hh"
+
+#include "LibHttp_MessageBodyTypes.hh"
+
+class http_codec_emtel : public http_codec {
+
+public:
+  explicit http_codec_emtel() : http_codec(){};
+  virtual ~http_codec_emtel(){};
+
+protected: //! \protectedsection
+  bool encode_body_xml(const LibHttp__XmlMessageBodyTypes::XmlBody &p_xml_body, OCTETSTRING &p_encoding_buffer, const std::string &p_content_type);
+  bool decode_body_xml(const OCTETSTRING &p_data, LibHttp__XmlMessageBodyTypes::XmlBody &p_xml_body, const std::string &p_content_type, params* p_params);
+  bool encode_body_json(const LibHttp__JsonMessageBodyTypes::JsonBody &p_json_body, OCTETSTRING &p_encoding_buffer, const std::string &p_content_type);
+  bool decode_body_json(const OCTETSTRING &p_data, LibHttp__JsonMessageBodyTypes::JsonBody &p_json_body, const std::string &p_content_type, params* p_params);
+}; // End of class http_codec_emtel

ccsrc/Protocols/Http/module.mk

+sources := http_codec_emtel.cc
+includes := .
+