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_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/module.mk

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

ccsrc/Protocols/Http/module.mk

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