diff --git a/ccsrc/Framework/include/codec_factory.hh b/ccsrc/Framework/include/codec_factory.hh
index 9d09b73a1020be923e5a818d4c1e34da80d45bd6..ca93662ea36f8d12c763677a0824f637ff934565 100644
--- a/ccsrc/Framework/include/codec_factory.hh
+++ b/ccsrc/Framework/include/codec_factory.hh
@@ -32,7 +32,7 @@ public: //! \publicsection
    */
   codec_factory(){};
   /*!
-   * \fn codec* create_codec(const std::string & type, const std::string & param);
+   * \fn codec* create_codec(const std::string&  type, const std::string&  param);
    * \brief  Create the codecs stack based on the provided codecs stack description (cf. remark)
    * \param[in] p_type The provided codecs stack description
    * \param[in] p_params Optional parameters
diff --git a/ccsrc/Framework/include/codec_stack_builder.hh b/ccsrc/Framework/include/codec_stack_builder.hh
index ca1be9f655c8ab0fa1757fedb9702e7bd7054f6b..9e81d6b9bb45aacc3733edc6b36d870305167d29 100644
--- a/ccsrc/Framework/include/codec_stack_builder.hh
+++ b/ccsrc/Framework/include/codec_stack_builder.hh
@@ -38,24 +38,24 @@ public:                    //! \publicsection
   static codec_stack_builder *get_instance() { return _instance ? _instance : _instance = new codec_stack_builder(); };
 
   /*!
-   * \fn void register_codec_factory(const std::string & p_type, codec_factory<TPDUEnc, TPDUDec>* p_codec_factory);
+   * \fn void register_codec_factory(const std::string&  p_type, codec_factory<TPDUEnc, TPDUDec>* p_codec_factory);
    * \brief Add a new codec factory
    * \param[in] p_type          The codec identifier (e.g. GN for the GeoNetworking codec...)
    * \param[in] p_codec_factory A reference to the \see codec_factory
    * \static
    */
-  static void register_codec_factory(const std::string &p_type, codec_factory *p_codec_factory) {
+  static void register_codec_factory(const std::string& p_type, codec_factory *p_codec_factory) {
     codec_stack_builder::get_instance()->_register_codec_factory(p_type, p_codec_factory);
   };
 
 private: //! \privatesection
   /*!
-   * \fn void _register_codec_factory(const std::string & p_type, codec_factory<TPDUEnc, TPDUDec>* p_codec_factory);
+   * \fn void _register_codec_factory(const std::string&  p_type, codec_factory<TPDUEnc, TPDUDec>* p_codec_factory);
    * \brief Add a new codec factory
    * \param[in] p_type          The codec identifier (e.g. GN for the GeoNetworking codec...)
    * \param[in] p_codec_factory A reference to the \see codec_factory
    */
-  void _register_codec_factory(const std::string &p_type, codec_factory *p_codec_factory) { _codecs[p_type] = p_codec_factory; };
+  void _register_codec_factory(const std::string& p_type, codec_factory *p_codec_factory) { _codecs[p_type] = p_codec_factory; };
 
 public: //! \publicsection
   /*!
diff --git a/ccsrc/Framework/include/converter.hh b/ccsrc/Framework/include/converter.hh
index 6070f2d80e6bdf0ec4cb089b102fc9e9177c43f0..844b43c393e052b1c15b8c58d37a6e3e48b58823 100644
--- a/ccsrc/Framework/include/converter.hh
+++ b/ccsrc/Framework/include/converter.hh
@@ -104,7 +104,7 @@ public:
    * \param[in] p_value The string value
    * \return The hexadecimal value
    */
-  std::string string_to_hexa(const std::string &p_value, const bool p_uppercase = false);
+  std::string string_to_hexa(const std::string& p_value, const bool p_uppercase = false);
   /*!
    * \brief Convert a bytes array int32_t an hexadecimal string
    * \param[in] p_value The bytes array value
@@ -116,7 +116,7 @@ public:
    * \param[in] p_value The hexadecimal value
    * \return The bytes array value
    */
-  std::vector<uint8_t> hexa_to_bytes(const std::string &p_value);
+  std::vector<uint8_t> hexa_to_bytes(const std::string& p_value);
 
   /*!
    * \brief Convert a time in time_t format into a string formated according to RFC 822, 1036, 1123, 2822
@@ -279,7 +279,7 @@ public:
    * \param[in] p_value The string value
    * \return The bytes array value
    */
-  inline std::vector<uint8_t> string_to_bytes(const std::string &p_value) const {
+  inline std::vector<uint8_t> string_to_bytes(const std::string& p_value) const {
     return std::vector<uint8_t>(p_value.begin(), p_value.end());
   }; // End of string_to_bytes
 
@@ -298,7 +298,7 @@ public:
    * \param[in] p_value The string value
    * \return The integer value
    */
-  inline int32_t string_to_int(const std::string &p_value) const {
+  inline int32_t string_to_int(const std::string& p_value) const {
     return std::stoi(p_value);
     // return atoi(p_value.c_str());
   }; // End of string_to_int
@@ -318,13 +318,13 @@ public:
    * \brief Convert a string in to lower case
    * \param[in/out] p_value The string value to convert
    */
-  inline void to_lower(std::string &p_value) { std::transform(p_value.begin(), p_value.end(), p_value.begin(), ::tolower); }
+  inline void to_lower(std::string& p_value) { std::transform(p_value.begin(), p_value.end(), p_value.begin(), ::tolower); }
 
   /*!
    * \brief Convert a string in to upper case
    * \param[in/out] p_value The string value to convert
    */
-  inline void to_upper(std::string &p_value) { std::transform(p_value.begin(), p_value.end(), p_value.begin(), ::toupper); }
+  inline void to_upper(std::string& p_value) { std::transform(p_value.begin(), p_value.end(), p_value.begin(), ::toupper); }
 
 public:
   /*!
@@ -333,7 +333,7 @@ public:
    * \param[in] p_trim_chars The special characters to be omitted. Default: ' ' and TAB
    * \return The new string value
    */
-  std::string trim(const std::string &p_value, const std::string &p_trim_chars = " \t");
+  std::string trim(const std::string& p_value, const std::string& p_trim_chars = " \t");
 
   /*!
    * \brief Convert the provided string into a list of arguments
@@ -349,7 +349,7 @@ public:
    *     }
    * \endcode
    */
-  std::vector<std::string> split(const std::string &p_value, const std::string &p_separator);
+  std::vector<std::string> split(const std::string& p_value, const std::string& p_separator);
 
   /*!
    * \brief Convert the provided string into a list of arguments
@@ -364,7 +364,7 @@ public:
    *     }
    * \endcode
    */
-  std::vector<std::string> split_arguments_line(const std::string &p_value);
+  std::vector<std::string> split_arguments_line(const std::string& p_value);
 
   /*!
    * \brief Convert the provided buffer into a Base64
diff --git a/ccsrc/Framework/include/layer.hh b/ccsrc/Framework/include/layer.hh
index b42e68d8c1706e79a0aff8e55deb079caa4f9cd5..8a2183f141126f82bd1f9113fe7e5f822643d691 100644
--- a/ccsrc/Framework/include/layer.hh
+++ b/ccsrc/Framework/include/layer.hh
@@ -47,7 +47,7 @@ public: //! \publicsection
    * \remark This constructor is called by the layer factory
    * \see layer_factory
    */
-  explicit layer(const std::string &p_type) : upperLayers(), lowerLayers(), type(std::string(p_type.begin(), p_type.end())){};
+  explicit layer(const std::string& p_type) : upperLayers(), lowerLayers(), type(std::string(p_type.begin(), p_type.end())){};
 
   /*!
    * \brief Default destructor
@@ -117,7 +117,7 @@ public: //! \publicsection
    * \brief Remove the specified upper layer protocol from the list of the upper layer
    * \param[in] The layer protocol to be removed
    */
-  inline const std::string &to_string() const { return type; };
+  inline const std::string& to_string() const { return type; };
 
 protected: //! \protectedsection
   inline void to_all_layers(std::vector<layer *> &layers, OCTETSTRING &data, params &params) {
diff --git a/ccsrc/Framework/include/layer_factory.hh b/ccsrc/Framework/include/layer_factory.hh
index 68e99c587b624a475139cc7dc2e3c9f94fbcd120..e3c1429d65ddad2a5bc7a3625349c015b15a5435 100644
--- a/ccsrc/Framework/include/layer_factory.hh
+++ b/ccsrc/Framework/include/layer_factory.hh
@@ -30,7 +30,7 @@ public: //! \publicsection
    */
   layer_factory(){};
   /*!
-   * \fn layer* create_layer(const std::string & type, const std::string & param);
+   * \fn layer* create_layer(const std::string&  type, const std::string&  param);
    * \brief  Create the layers stack based on the provided layers stack description (cf. remark)
    * \param[in] p_type The provided layers stack description
    * \param[in] p_params Optional parameters
@@ -59,5 +59,5 @@ public: //! \publicsection
    *         save_mode   : 1 to save sent packet, 0 otherwise
    * \pure
    */
-  virtual layer *create_layer(const std::string &p_type, const std::string &p_params) = 0;
+  virtual layer *create_layer(const std::string& p_type, const std::string& p_params) = 0;
 }; // End of class layer_factory
diff --git a/ccsrc/Framework/include/layer_stack_builder.hh b/ccsrc/Framework/include/layer_stack_builder.hh
index 2d1b25a59eac4e0dfeb395256945a4659b5535f6..83ad20b394379cc371ad0f7e43ec7fe0f60528c4 100644
--- a/ccsrc/Framework/include/layer_stack_builder.hh
+++ b/ccsrc/Framework/include/layer_stack_builder.hh
@@ -38,22 +38,22 @@ public:                  //! \publicsection
   static layer_stack_builder *get_instance();
 
   /*!
-   * \fn void register_layer_factory(const std::string & p_type, layer_factory* p_layer_factory);
+   * \fn void register_layer_factory(const std::string&  p_type, layer_factory* p_layer_factory);
    * \brief Add a new layer factory
    * \param[in] p_type          The layer identifier (e.g. GN for the GeoNetworking layer...)
    * \param[in] p_layer_factory A reference to the \see layer_factory
    * \static
    */
-  static void register_layer_factory(const std::string &p_type, layer_factory *p_layer_factory);
+  static void register_layer_factory(const std::string& p_type, layer_factory *p_layer_factory);
 
 private: //! \privatesection
   /*!
-   * \fn void _register_layer_factory(const std::string & p_type, layer_factory* p_layer_factory);
+   * \fn void _register_layer_factory(const std::string&  p_type, layer_factory* p_layer_factory);
    * \brief Add a new layer factory
    * \param[in] p_type          The layer identifier (e.g. GN for the GeoNetworking layer...)
    * \param[in] p_layer_factory A reference to the \see layer_factory
    */
-  void _register_layer_factory(const std::string &p_type, layer_factory *p_layer_factory);
+  void _register_layer_factory(const std::string& p_type, layer_factory *p_layer_factory);
 
 public: //! \publicsection
   /*!
diff --git a/ccsrc/Framework/include/registration.hh b/ccsrc/Framework/include/registration.hh
index df24ea1cfdd3b14c171de8a6f375b80d5e689c15..0b2dbfeb87aafe141153af8a5e755d9cf0db59be 100644
--- a/ccsrc/Framework/include/registration.hh
+++ b/ccsrc/Framework/include/registration.hh
@@ -35,8 +35,8 @@ public:
   };
 
 public:
-  void   add_item(const std::string &type, TItem *f);
-  TItem *get_item(const std::string &type);
+  void   add_item(const std::string& type, TItem *f);
+  TItem *get_item(const std::string& type);
 }; // End of class registration
 
 template <typename TItem> registration<TItem> *registration<TItem>::_instance = nullptr;
@@ -46,9 +46,9 @@ template <typename TItem> registration<TItem> &registration<TItem>::get_instance
   return (_instance != nullptr) ? *_instance : *(_instance = new registration());
 }
 
-template <typename TItem> void registration<TItem>::add_item(const std::string &type, TItem *f) { _items[type] = f; }
+template <typename TItem> void registration<TItem>::add_item(const std::string& type, TItem *f) { _items[type] = f; }
 
-template <typename TItem> TItem *registration<TItem>::get_item(const std::string &type) {
+template <typename TItem> TItem *registration<TItem>::get_item(const std::string& type) {
   typename std::map<std::string, TItem *>::const_iterator it = _items.find(type);
   if (it == _items.cend()) {
     return nullptr;
diff --git a/ccsrc/Framework/include/t_layer.hh b/ccsrc/Framework/include/t_layer.hh
index 286bd3169b92258ec085b0ab5425ea22c23097d5..cbb5edf34d7b4b920741384830549fbac2b08e76 100644
--- a/ccsrc/Framework/include/t_layer.hh
+++ b/ccsrc/Framework/include/t_layer.hh
@@ -39,7 +39,7 @@ public: //! \publicsection
    * \remark This constructor is called by the layer factory
    * \see layer_factory
    */
-  explicit t_layer(const std::string &p_type) : layer(p_type), upperPorts(){};
+  explicit t_layer(const std::string& p_type) : layer(p_type), upperPorts(){};
   /*!
    * \inline
    * \fn void add_upper_port(TPort * p_port);
diff --git a/ccsrc/Framework/src/converter.cc b/ccsrc/Framework/src/converter.cc
index e9ad4d1476ff8563e79a712ac1e9eeae18787636..7a9a0cc1102ab5ff65cbf54da6e44182b4028096 100644
--- a/ccsrc/Framework/src/converter.cc
+++ b/ccsrc/Framework/src/converter.cc
@@ -14,7 +14,7 @@ uint32_t converter::swap(const uint32_t p_value) {
 
 const std::string converter::lut_u = "0123456789ABCDEF";
 const std::string converter::lut_l = "0123456789abcdef";
-std::string       converter::string_to_hexa(const std::string &p_value, const bool p_uppercase) {
+std::string       converter::string_to_hexa(const std::string& p_value, const bool p_uppercase) {
 
   std::string input(p_value);
   std::for_each(input.begin(), input.end(), [](char &c) { c = std::toupper(c); });
@@ -68,7 +68,7 @@ inline uint8_t char2byte(const char p_ch) {
   return s;
 }
 
-std::vector<uint8_t> converter::hexa_to_bytes(const std::string &p_value) {
+std::vector<uint8_t> converter::hexa_to_bytes(const std::string& p_value) {
   // Sanity check
   std::vector<uint8_t> output;
   size_t               i = 0, idx = 0, outlen = (p_value.length() + 1) / 2;
@@ -100,7 +100,7 @@ std::string converter::time_to_string(const struct tm &p_time) {
   return std::string(buffer);
 }
 
-std::string converter::trim(const std::string &str, const std::string &whitespace) {
+std::string converter::trim(const std::string& str, const std::string& whitespace) {
   size_t strBegin = str.find_first_not_of(whitespace);
   if (strBegin == std::string::npos)
     return ""; // no content
@@ -111,7 +111,7 @@ std::string converter::trim(const std::string &str, const std::string &whitespac
   return str.substr(strBegin, strRange);
 }
 
-std::vector<std::string> converter::split(const std::string &p_value, const std::string &p_separator) {
+std::vector<std::string> converter::split(const std::string& p_value, const std::string& p_separator) {
   std::vector<std::string> output;
   std::size_t              current, previous = 0;
   current = p_value.find(p_separator);
@@ -125,7 +125,7 @@ std::vector<std::string> converter::split(const std::string &p_value, const std:
   return output;
 }
 
-std::vector<std::string> converter::split_arguments_line(const std::string &p_value) {
+std::vector<std::string> converter::split_arguments_line(const std::string& p_value) {
   std::vector<std::string> output;
   std::string              line = trim(p_value);
   if (!line.empty() && (line[0] == '-')) { // Valid command line
diff --git a/ccsrc/Framework/src/layer_factory.cc b/ccsrc/Framework/src/layer_factory.cc
index a28e2dc9a265a761ee255b793d7d12aa265cde43..e812ac70a3f01e46b9cd3bd82da0ef6dd59d8268 100644
--- a/ccsrc/Framework/src/layer_factory.cc
+++ b/ccsrc/Framework/src/layer_factory.cc
@@ -10,14 +10,14 @@ layer_stack_builder *layer_stack_builder::_instance = NULL;
 // static functions
 layer_stack_builder *layer_stack_builder::get_instance() { return _instance ? _instance : _instance = new layer_stack_builder(); }
 
-void layer_stack_builder::register_layer_factory(const std::string &p_type, layer_factory *p_layer_factory) {
+void layer_stack_builder::register_layer_factory(const std::string& p_type, layer_factory *p_layer_factory) {
   layer_stack_builder::get_instance()->_register_layer_factory(p_type, p_layer_factory);
 }
 
 // member functions
 layer_stack_builder::layer_stack_builder() {}
 
-void layer_stack_builder::_register_layer_factory(const std::string &p_type, layer_factory *p_layer_factory) { _layer_factories[p_type] = p_layer_factory; }
+void layer_stack_builder::_register_layer_factory(const std::string& p_type, layer_factory *p_layer_factory) { _layer_factories[p_type] = p_layer_factory; }
 
 layer *layer_stack_builder::create_layer_stack(const char *p_layer_stack_description) {
   loggers::get_instance().log(">>> layer_stack_builder::create_layer_stack: '%s'", p_layer_stack_description);
diff --git a/ccsrc/Protocols/ETH/ethernet_layer.cc b/ccsrc/Protocols/ETH/ethernet_layer.cc
index 6405a96e2ec330fce344c5a22f6e7fc54b0b5e3c..0b6bff730f4ffb7a8aea986f5be4727a50d6a1a0 100644
--- a/ccsrc/Protocols/ETH/ethernet_layer.cc
+++ b/ccsrc/Protocols/ETH/ethernet_layer.cc
@@ -2,7 +2,7 @@
 
 #include "loggers.hh"
 
-ethernet_layer::ethernet_layer(const std::string & p_type, const std::string & p_param) : layer(p_type), _params() {
+ethernet_layer::ethernet_layer(const std::string&  p_type, const std::string&  p_param) : layer(p_type), _params() {
   loggers::get_instance().log(">>> ethernet_layer::ethernet_layer: '%s', %s", to_string().c_str(), p_param.c_str());
   // Setup parameters
   params::convert(_params, p_param);
diff --git a/ccsrc/Protocols/ETH/ethernet_layer.hh b/ccsrc/Protocols/ETH/ethernet_layer.hh
index f510350bc21528b8da602a59d8eccebf2c155d48..57ae7c2e203d3dcab61aa2887afb041ef1a2cfab 100644
--- a/ccsrc/Protocols/ETH/ethernet_layer.hh
+++ b/ccsrc/Protocols/ETH/ethernet_layer.hh
@@ -23,7 +23,7 @@ public: //! \publicsection
    * \param[in] p_type \todo
    * \param[in] p_param \todo
    */
-  ethernet_layer(const std::string &p_type, const std::string &p_param);
+  ethernet_layer(const std::string& p_type, const std::string& p_param);
   /*!
    * \brief Default destructor
    */
diff --git a/ccsrc/Protocols/ETH/ethernet_layer_factory.hh b/ccsrc/Protocols/ETH/ethernet_layer_factory.hh
index 7adf9f4c242fcb60c532a04e7c2b08d9ed2ab51b..091b68d4ab4c876b3424f045f92381521a454eb4 100644
--- a/ccsrc/Protocols/ETH/ethernet_layer_factory.hh
+++ b/ccsrc/Protocols/ETH/ethernet_layer_factory.hh
@@ -31,12 +31,12 @@ public:                             //! \publicsection
     layer_stack_builder::register_layer_factory("ETH", this);
   };
   /*!
-   * \fn layer* create_layer(const std::string & type, const std::string & param);
+   * \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 ethernet_layer(p_type, p_param); };
+  inline virtual layer *create_layer(const std::string& p_type, const std::string& p_param) { return new ethernet_layer(p_type, p_param); };
 }; // End of class ethernet_layer_factory
diff --git a/ccsrc/Protocols/Http/http_codec.cc b/ccsrc/Protocols/Http/http_codec.cc
index f0763bbbb7a3d37fea0bfb702f1889c8cfd9c819..9240129ff9232034ad107dffd43bfb78286473df 100644
--- a/ccsrc/Protocols/Http/http_codec.cc
+++ b/ccsrc/Protocols/Http/http_codec.cc
@@ -342,7 +342,7 @@ int http_codec::encode_response(const LibHttp__TypesAndValues::Response &p_respo
   return 0;
 }
 
-int http_codec::decode_headers(TTCN_Buffer &decoding_buffer, LibHttp__TypesAndValues::Headers &headers, std::string &p_content_type) {
+int http_codec::decode_headers(TTCN_Buffer &decoding_buffer, LibHttp__TypesAndValues::Headers &headers, std::string& p_content_type) {
   loggers::get_instance().log(">>> http_codec::decode_headers");
   loggers::get_instance().log_to_hexa("http_codec::decode_headers: ", decoding_buffer);
 
@@ -424,7 +424,7 @@ int http_codec::decode_header(CHARSTRING &header_line, LibHttp__TypesAndValues::
 }
 
 int http_codec::encode_body(const LibHttp__MessageBodyTypes::HttpMessageBody &p_message_body, OCTETSTRING &p_encoding_buffer,
-                            const std::string &p_content_type) {
+                            const std::string& p_content_type) {
   loggers::get_instance().log_msg(">>> http_codec::encode_body: ", (const Base_Type &)p_message_body);
 
   // Sanity check
@@ -469,7 +469,7 @@ int http_codec::encode_body(const LibHttp__MessageBodyTypes::HttpMessageBody &p_
   return 0;
 }
 
-int http_codec::decode_body(TTCN_Buffer &decoding_buffer, LibHttp__MessageBodyTypes::HttpMessageBody &message_body, const std::string &p_content_type) {
+int http_codec::decode_body(TTCN_Buffer &decoding_buffer, LibHttp__MessageBodyTypes::HttpMessageBody &message_body, const std::string& p_content_type) {
   loggers::get_instance().log(">>> http_codec::decode_body");
   loggers::get_instance().log_to_hexa("http_codec::decode_body", decoding_buffer);
   loggers::get_instance().log("http_codec::decode_body: # of codecs=%d - %p", _codecs.size(), this);
@@ -641,7 +641,7 @@ int http_codec::get_line(TTCN_Buffer &buffer, CHARSTRING &to, const bool concate
   } // End of 'while' statement
 }
 
-void http_codec::set_payload_codecs(const std::string &p_codecs) {
+void http_codec::set_payload_codecs(const std::string& p_codecs) {
   loggers::get_instance().log(">>> http_codec::set_payload_codecs: '%s'", p_codecs.c_str());
 
   // Sanity check
@@ -678,7 +678,7 @@ void http_codec::set_payload_codecs(const std::string &p_codecs) {
   }
 }
 
-bool http_codec::decode_body_html(const OCTETSTRING &p_data, CHARSTRING &p_html_body, const std::string &p_content_type, params* p_params) {
+bool http_codec::decode_body_html(const OCTETSTRING &p_data, CHARSTRING &p_html_body, const std::string& p_content_type, params* p_params) {
   p_html_body = CHARSTRING(p_data.lengthof(), (char*)static_cast<const unsigned char*>(p_data));
   return true;
 }
diff --git a/ccsrc/Protocols/Http/http_codec.hh b/ccsrc/Protocols/Http/http_codec.hh
index efcebe2ab78c5f981221ea9d9592f0372e4acb00..04079e616934887046926aa07454902db70ac05e 100644
--- a/ccsrc/Protocols/Http/http_codec.hh
+++ b/ccsrc/Protocols/Http/http_codec.hh
@@ -68,29 +68,29 @@ public:
   virtual int encode(const LibHttp__TypesAndValues::HttpMessage &, OCTETSTRING &data);
   virtual int decode(const OCTETSTRING &data, LibHttp__TypesAndValues::HttpMessage &, params *params = NULL);
 
-  void set_payload_codecs(const std::string &p_codecs);
+  void set_payload_codecs(const std::string& p_codecs);
 
 protected: //! \protectedsection
-  virtual bool encode_body_binary(const LibHttp__BinaryMessageBodyTypes::BinaryBody &p_binary_body, OCTETSTRING &p_encoding_buffer, const std::string &p_content_type) {return false;};
-  virtual bool decode_body_binary(const OCTETSTRING &p_data, LibHttp__BinaryMessageBodyTypes::BinaryBody &p_binary_body, const std::string &p_content_type) {return false;};
+  virtual bool encode_body_binary(const LibHttp__BinaryMessageBodyTypes::BinaryBody &p_binary_body, OCTETSTRING &p_encoding_buffer, const std::string& p_content_type) {return false;};
+  virtual bool decode_body_binary(const OCTETSTRING &p_data, LibHttp__BinaryMessageBodyTypes::BinaryBody &p_binary_body, const std::string& p_content_type) {return false;};
 
-  virtual bool encode_body_xml(const LibHttp__XmlMessageBodyTypes::XmlBody &p_xml_body, OCTETSTRING &p_encoding_buffer, const std::string &p_content_type) {return false;};
-  virtual bool decode_body_xml(const OCTETSTRING &p_data, LibHttp__XmlMessageBodyTypes::XmlBody &p_body, const std::string &p_content_type, params* p_params) {return false;};
+  virtual bool encode_body_xml(const LibHttp__XmlMessageBodyTypes::XmlBody &p_xml_body, OCTETSTRING &p_encoding_buffer, const std::string& p_content_type) {return false;};
+  virtual bool decode_body_xml(const OCTETSTRING &p_data, LibHttp__XmlMessageBodyTypes::XmlBody &p_body, const std::string& p_content_type, params* p_params) {return false;};
 
-  virtual bool encode_body_html(const CHARSTRING &p_html_body, OCTETSTRING &p_encoding_buffer, const std::string &p_content_type) {return false;};
-  virtual bool decode_body_html(const OCTETSTRING &p_data, CHARSTRING &p_html_body, const std::string &p_content_type, params* p_params);
+  virtual bool encode_body_html(const CHARSTRING &p_html_body, OCTETSTRING &p_encoding_buffer, const std::string& p_content_type) {return false;};
+  virtual bool decode_body_html(const OCTETSTRING &p_data, CHARSTRING &p_html_body, const std::string& p_content_type, params* p_params);
 
-  virtual bool encode_body_json(const LibHttp__JsonMessageBodyTypes::JsonBody &p_json_body, OCTETSTRING &p_encoding_buffer, const std::string &p_content_type) {return false;};
-  virtual bool decode_body_json(const OCTETSTRING &p_data, LibHttp__JsonMessageBodyTypes::JsonBody &p_json_body, const std::string &p_content_type, params* p_params) {return false;};
+  virtual bool encode_body_json(const LibHttp__JsonMessageBodyTypes::JsonBody &p_json_body, OCTETSTRING &p_encoding_buffer, const std::string& p_content_type) {return false;};
+  virtual bool decode_body_json(const OCTETSTRING &p_data, LibHttp__JsonMessageBodyTypes::JsonBody &p_json_body, const std::string& p_content_type, params* p_params) {return false;};
 
 private:
   int encode_request(const LibHttp__TypesAndValues::Request &p_request, TTCN_Buffer &p_encoding_buffer);
   int encode_response(const LibHttp__TypesAndValues::Response &p_response, TTCN_Buffer &p_encoding_buffer);
-  int encode_body(const LibHttp__MessageBodyTypes::HttpMessageBody &p_message_body, OCTETSTRING &p_encoding_buffer, const std::string &p_content_type);
+  int encode_body(const LibHttp__MessageBodyTypes::HttpMessageBody &p_message_body, OCTETSTRING &p_encoding_buffer, const std::string& p_content_type);
 
-  int decode_headers(TTCN_Buffer &decoding_buffer, LibHttp__TypesAndValues::Headers &headers, std::string &p_content_type);
+  int decode_headers(TTCN_Buffer &decoding_buffer, LibHttp__TypesAndValues::Headers &headers, std::string& p_content_type);
   int decode_header(CHARSTRING &header_line, LibHttp__TypesAndValues::Header &header);
-  int decode_body(TTCN_Buffer &decoding_buffer, LibHttp__MessageBodyTypes::HttpMessageBody &message_body, const std::string &p_content_type);
+  int decode_body(TTCN_Buffer &decoding_buffer, LibHttp__MessageBodyTypes::HttpMessageBody &message_body, const std::string& p_content_type);
   int get_line(TTCN_Buffer &buffer, CHARSTRING &to, const bool concatenate_header_lines = false);
 
 }; // End of class http_codec
diff --git a/ccsrc/Protocols/Http/http_layer.cc b/ccsrc/Protocols/Http/http_layer.cc
index 23f911c51d48489ec2c7646a01b807547119d246..bf4da9f92d5c7edb135b1cd2aae8f0daab9929c9 100644
--- a/ccsrc/Protocols/Http/http_layer.cc
+++ b/ccsrc/Protocols/Http/http_layer.cc
@@ -11,7 +11,7 @@ using namespace std; // Required for isnan()
 #include "LibHttp_TestSystem.hh"
 #include "LibHttp_TypesAndValues.hh"
 
-http_layer::http_layer(const std::string &p_type, const std::string &param)
+http_layer::http_layer(const std::string& p_type, const std::string& param)
   : t_layer<LibHttp__TestSystem::HttpPort>(p_type), _params(), _codec(nullptr), _device_mode{false} {
   loggers::get_instance().log(">>> http_layer::http_layer: '%s', %s", to_string().c_str(), param.c_str());
   // Setup parameters
diff --git a/ccsrc/Protocols/Http/http_layer_factory.hh b/ccsrc/Protocols/Http/http_layer_factory.hh
index 5e4e71abbc84e6265a19065017126e5f6b997a32..5668e87c8205a3d7ba5c20b97f5a21c13d573e0e 100644
--- a/ccsrc/Protocols/Http/http_layer_factory.hh
+++ b/ccsrc/Protocols/Http/http_layer_factory.hh
@@ -31,12 +31,12 @@ public:                         //! \publicsection
     layer_stack_builder::register_layer_factory("HTTP", this);
   };
   /*!
-   * \fn layer* create_layer(const std::string & type, const std::string & param);
+   * \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 http_layer(p_type, p_param); };
+  inline virtual layer *create_layer(const std::string& p_type, const std::string& p_param) { return new http_layer(p_type, p_param); };
 }; // End of class http_layer_factory
diff --git a/ccsrc/Protocols/Pcap/pcap_cygwin_layer.cc b/ccsrc/Protocols/Pcap/pcap_cygwin_layer.cc
index f45d70e8bb0fabf0cc99094f052ed3617bbf930a..dca0cfab7cf07580dbd4ff3c0f9f8b02dcb213f6 100644
--- a/ccsrc/Protocols/Pcap/pcap_cygwin_layer.cc
+++ b/ccsrc/Protocols/Pcap/pcap_cygwin_layer.cc
@@ -52,7 +52,7 @@ static char *      _bin2hex(char *hex, size_t hlen, const char *bin, size_t blen
   return hex + blen * 2;
 }
 
-pcap_layer::pcap_layer(const std::string &p_type, const std::string &param)
+pcap_layer::pcap_layer(const std::string& p_type, const std::string& param)
   : layer(p_type), PORT(p_type.c_str()), _params(), _device(NULL), _running(FALSE), _time_key("pcap_layer::Handle_Fd_Event_Readable") {
   loggers::get_instance().log(">>> pcap_layer::pcap_layer: '%s', %s", p_type.c_str(), param.c_str());
   params::convert(_params, param);
diff --git a/ccsrc/Protocols/Pcap/pcap_cygwin_layer.hh b/ccsrc/Protocols/Pcap/pcap_cygwin_layer.hh
index d7d477a871c179fba588758188722f63e8bf1712..b54cedabd95c23e0675723d353cd44235bfd0bb3 100644
--- a/ccsrc/Protocols/Pcap/pcap_cygwin_layer.hh
+++ b/ccsrc/Protocols/Pcap/pcap_cygwin_layer.hh
@@ -52,7 +52,7 @@ public: //! \publicsection
    * \param[in] p_type \todo
    * \param[in] p_param \todo
    */
-  pcap_layer(const std::string &p_type, const std::string &param);
+  pcap_layer(const std::string& p_type, const std::string& param);
   /*!
    * \brief Default destructor
    */
diff --git a/ccsrc/Protocols/Pcap/pcap_layer_factory.hh b/ccsrc/Protocols/Pcap/pcap_layer_factory.hh
index 0125e1946cb3359295bac349039fef518c70ce52..79f2b6d1a5792b6401448c0448803b446f41e709 100644
--- a/ccsrc/Protocols/Pcap/pcap_layer_factory.hh
+++ b/ccsrc/Protocols/Pcap/pcap_layer_factory.hh
@@ -31,12 +31,12 @@ public:                         //! \publicsection
     layer_stack_builder::register_layer_factory("PCAP", this);
   };
   /*!
-   * \fn layer* create_layer(const std::string & type, const std::string & param);
+   * \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 pcap_layer(p_type, p_param); };
+  inline virtual layer *create_layer(const std::string& p_type, const std::string& p_param) { return new pcap_layer(p_type, p_param); };
 }; // End of class pcap_layer_factory
diff --git a/ccsrc/Protocols/Pcap/pcap_linux_layer.cc b/ccsrc/Protocols/Pcap/pcap_linux_layer.cc
index ab9b5b87e20d3f636b5e1653696eadf9213014ed..27ce633d9d040a21730d4855b48338de7205a042 100644
--- a/ccsrc/Protocols/Pcap/pcap_linux_layer.cc
+++ b/ccsrc/Protocols/Pcap/pcap_linux_layer.cc
@@ -36,7 +36,7 @@ static char *      _bin2hex(char *hex, size_t hlen, const char *bin, size_t blen
   return hex + blen * 2;
 }
 
-pcap_layer::pcap_layer(const std::string &p_type, const std::string &param)
+pcap_layer::pcap_layer(const std::string& p_type, const std::string& param)
   : layer(p_type), PORT(p_type.c_str()), _params(), _device(NULL), _pcap_h(-1), _time_key("pcap_layer::Handle_Fd_Event_Readable") {
   char                   error_buffer[PCAP_ERRBUF_SIZE];
   params::const_iterator it;
diff --git a/ccsrc/Protocols/Pcap/pcap_linux_layer.hh b/ccsrc/Protocols/Pcap/pcap_linux_layer.hh
index 82efc4b5857fd29cb944cdbcc775f98719ec3570..90c45dd7c8b32b32d2554755001002175093cb80 100644
--- a/ccsrc/Protocols/Pcap/pcap_linux_layer.hh
+++ b/ccsrc/Protocols/Pcap/pcap_linux_layer.hh
@@ -35,7 +35,7 @@ public: //! \publicsection
    * \param[in] p_type \todo
    * \param[in] p_param \todo
    */
-  pcap_layer(const std::string &p_type, const std::string &param);
+  pcap_layer(const std::string& p_type, const std::string& param);
   /*!
    * \brief Default destructor
    */
diff --git a/ccsrc/Protocols/Pcap/pcap_offline_layer.cc b/ccsrc/Protocols/Pcap/pcap_offline_layer.cc
index b84cfc2e5fb19ae4137034fa2c972d09e61db934..0f8808c5ad138fa6fe8a509752c81f37e0ba92d2 100644
--- a/ccsrc/Protocols/Pcap/pcap_offline_layer.cc
+++ b/ccsrc/Protocols/Pcap/pcap_offline_layer.cc
@@ -31,7 +31,7 @@ typedef struct pcap_pkthdr pcap_o_pkthdr;
 typedef struct timeval     pcap_o_timeval;
 #endif
 
-pcap_offline_layer::pcap_offline_layer(const std::string &p_type, const std::string &param)
+pcap_offline_layer::pcap_offline_layer(const std::string& p_type, const std::string& param)
   : layer(p_type), PORT(p_type.c_str()), _params(), _device(NULL), _running(FALSE), _time_key("pcap_offline_layer::Handle_Fd_Event_Readable") {
   loggers::get_instance().log(">>> pcap_offline_layer::pcap_offline_layer: '%s', %s", p_type.c_str(), param.c_str());
   params::convert(_params, param);
@@ -49,14 +49,14 @@ pcap_offline_layer::pcap_offline_layer(const std::string &p_type, const std::str
 
   it = _params.find(std::string("file"));
   if ((it != _params.end()) && !it->second.empty()) {
-    const std::string &file = it->second;
+    const std::string& file = it->second;
     _device                 = pcap_open_offline(file.c_str(), error_buffer);
     if (_device) {
 
       // Add user defined filter
       it = _params.find(params::filter);
       if ((it != _params.end()) && !it->second.empty()) {
-        const std::string &filter = it->second;
+        const std::string& filter = it->second;
         // Log final PCAP filter
         loggers::get_instance().user("pcap_offline_layer::pcap_offline_layer: Filter: '%s'", filter.c_str());
         struct bpf_program f = {0};
diff --git a/ccsrc/Protocols/Pcap/pcap_offline_layer.hh b/ccsrc/Protocols/Pcap/pcap_offline_layer.hh
index 0c1993e4118aef4c6977bcde7896f2d1efdfaa63..f4abd9485e468e2c05d1f957eaabd9904fb94a5f 100644
--- a/ccsrc/Protocols/Pcap/pcap_offline_layer.hh
+++ b/ccsrc/Protocols/Pcap/pcap_offline_layer.hh
@@ -53,7 +53,7 @@ public: //! \publicsection
    * \param[in] p_type \todo
    * \param[in] p_param \todo
    */
-  pcap_offline_layer(const std::string &p_type, const std::string &param);
+  pcap_offline_layer(const std::string& p_type, const std::string& param);
   /*!
    * \brief Default destructor
    */
diff --git a/ccsrc/Protocols/Pcap/pcap_offline_layer_factory.hh b/ccsrc/Protocols/Pcap/pcap_offline_layer_factory.hh
index 23cd1d0d28f84386a20a1bdb2b35a0716f010fc9..3c3d6659d1f72da2d1d0312d6a1c6f7d63f3ecd0 100644
--- a/ccsrc/Protocols/Pcap/pcap_offline_layer_factory.hh
+++ b/ccsrc/Protocols/Pcap/pcap_offline_layer_factory.hh
@@ -31,12 +31,12 @@ public:                                 //! \publicsection
     layer_stack_builder::register_layer_factory("PCAP_FILE", this);
   };
   /*!
-   * \fn layer* create_layer(const std::string & type, const std::string & param);
+   * \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 pcap_offline_layer(p_type, p_param); };
+  inline virtual layer *create_layer(const std::string& p_type, const std::string& p_param) { return new pcap_offline_layer(p_type, p_param); };
 }; // End of class pcap_offline_layer_factory
diff --git a/ccsrc/Protocols/Tcp/tcp_layer.cc b/ccsrc/Protocols/Tcp/tcp_layer.cc
index 945a1487a1cb1de5326afc98b9e63b98c1e8cc11..c077355c5e9b6994d60803e4c1a10cc9b40d3227 100644
--- a/ccsrc/Protocols/Tcp/tcp_layer.cc
+++ b/ccsrc/Protocols/Tcp/tcp_layer.cc
@@ -8,7 +8,7 @@
 
 #include "loggers.hh"
 
-tcp_layer::tcp_layer(const std::string & p_type, const std::string & param) : layer(p_type), SSL_Socket(), PORT(p_type.c_str()), _params(), _client_id{-1}, _time_key("tcp_layer::Handle_Fd_Event_Readable"), _reconnect_on_send{false} {
+tcp_layer::tcp_layer(const std::string&  p_type, const std::string&  param) : layer(p_type), SSL_Socket(), PORT(p_type.c_str()), _params(), _client_id{-1}, _time_key("tcp_layer::Handle_Fd_Event_Readable"), _reconnect_on_send{false} {
   loggers::get_instance().log(">>> tcp_layer::tcp_layer (1): '%s', %s", to_string().c_str(), param.c_str());
   // Setup parameters
   params::convert(_params, param);
@@ -16,7 +16,7 @@ tcp_layer::tcp_layer(const std::string & p_type, const std::string & param) : la
 
   init();                                                                                                                                                   }
 
-tcp_layer::tcp_layer(const std::string & p_type, const params & param) : layer(p_type), SSL_Socket(), PORT(p_type.c_str()), _params(), _client_id{-1}, _time_key("tcp_layer::Handle_Fd_Event_Readable"), _reconnect_on_send{false} {
+tcp_layer::tcp_layer(const std::string&  p_type, const params & param) : layer(p_type), SSL_Socket(), PORT(p_type.c_str()), _params(), _client_id{-1}, _time_key("tcp_layer::Handle_Fd_Event_Readable"), _reconnect_on_send{false} {
   loggers::get_instance().log(">>> tcp_layer::tcp_layer (2): '%s'", to_string().c_str());
   // Setup parameters
   _params = param;
diff --git a/ccsrc/Protocols/Tcp/tcp_layer.hh b/ccsrc/Protocols/Tcp/tcp_layer.hh
index 3dbcba7a6c13b824a3f8683b383eaabec5c8c3fd..8db788c5b003f15665dbcc19cbc8400f368991fe 100644
--- a/ccsrc/Protocols/Tcp/tcp_layer.hh
+++ b/ccsrc/Protocols/Tcp/tcp_layer.hh
@@ -35,14 +35,14 @@ public: //! \publicsection
    * \param[in] p_type \todo
    * \param[in] p_param \todo
    */
-  tcp_layer(const std::string &p_type, const std::string &p_param);
+  tcp_layer(const std::string& p_type, const std::string& p_param);
   /*!
    * \brief Specialised constructor
    *        Create a new instance of the tcp_layer class
    * \param[in] p_type \todo
    * \param[in] p_param \todo
    */
-  tcp_layer(const std::string &p_type, const params &p_param);
+  tcp_layer(const std::string& p_type, const params &p_param);
   /*!
    * \brief Default destructor
    * \remark If \see _reconnect_on_send is set to false, the disconnection is done by the destructor
diff --git a/ccsrc/Protocols/Tcp/tcp_layer_factory.hh b/ccsrc/Protocols/Tcp/tcp_layer_factory.hh
index 4fe20098388966ef95bf6a77288a5b97974be92b..017f3ec8ac331886cb40c015e192abdf9456782e 100644
--- a/ccsrc/Protocols/Tcp/tcp_layer_factory.hh
+++ b/ccsrc/Protocols/Tcp/tcp_layer_factory.hh
@@ -31,11 +31,11 @@ public:                        //! \publicsection
     layer_stack_builder::register_layer_factory("TCP", this);
   };
   /*!
-   * \fn layer* create_layer(const std::string & type, const std::string & param);
+   * \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 virtual layer *create_layer(const std::string &p_type, const std::string &p_param) { return new tcp_layer(p_type, p_param); };
+  inline virtual layer *create_layer(const std::string& p_type, const std::string& p_param) { return new tcp_layer(p_type, p_param); };
 }; // End of class tcp_layer_factory
diff --git a/ccsrc/Protocols/UDP/udp_layer.cc b/ccsrc/Protocols/UDP/udp_layer.cc
index b44d38268262ff73f89ed1c0efedf3010ee22f00..e17c530dfe6f87ee18dc4f7396d12de144a27537 100644
--- a/ccsrc/Protocols/UDP/udp_layer.cc
+++ b/ccsrc/Protocols/UDP/udp_layer.cc
@@ -11,7 +11,7 @@
 #include <net/if.h>
 #include <sys/ioctl.h>
 
-udp_layer::udp_layer(const std::string &p_type, const std::string &param)
+udp_layer::udp_layer(const std::string& p_type, const std::string& param)
   : layer(p_type), PORT(p_type.c_str()), _params(), _saddr{0}, _daddr{0}, _reuse_incoming_source_adddress(false), _fd(-1),
     _time_key("udp_layer::Handle_Fd_Event_Readable") {
   loggers::get_instance().log(">>> udp_layer::udp_layer (1): '%s', %s, %p", to_string().c_str(), param.c_str(), (void*)this);
@@ -22,7 +22,7 @@ udp_layer::udp_layer(const std::string &p_type, const std::string &param)
   init();
 }
 
-udp_layer::udp_layer(const std::string &p_type, const params &param)
+udp_layer::udp_layer(const std::string& p_type, const params &param)
   : layer(p_type), PORT(p_type.c_str()), _params(), _saddr{0}, _daddr{0}, _reuse_incoming_source_adddress(false), _fd(-1),
     _time_key("udp_layer::Handle_Fd_Event_Readable") {
   loggers::get_instance().log(">>> udp_layer::udp_layer (2): '%s'", to_string().c_str());
@@ -162,7 +162,7 @@ void udp_layer::Handle_Fd_Event_Readable(int fd) {
   loggers::get_instance().set_stop_time(_time_key, duration);
 }
 
-unsigned long udp_layer::get_host_id(const std::string &p_host_name) {
+unsigned long udp_layer::get_host_id(const std::string& p_host_name) {
   loggers::get_instance().log(">>> udp_layer::get_host_id");
 
   if (p_host_name.empty()) {
diff --git a/ccsrc/Protocols/UDP/udp_layer.hh b/ccsrc/Protocols/UDP/udp_layer.hh
index c24d833568cb364c6b01bed39de5e42d52bfe0f2..4a212e8a231de5ca143dcd75585ba6bb30a1f1be 100644
--- a/ccsrc/Protocols/UDP/udp_layer.hh
+++ b/ccsrc/Protocols/UDP/udp_layer.hh
@@ -43,14 +43,14 @@ public: //! \publicsection
    * \param[in] p_type \todo
    * \param[in] p_param \todo
    */
-  udp_layer(const std::string &p_type, const std::string &p_param);
+  udp_layer(const std::string& p_type, const std::string& p_param);
   /*!
    * \brief Specialised constructor
    *        Create a new instance of the udp_layer class
    * \param[in] p_type \todo
    * \param[in] p_param \todo
    */
-  udp_layer(const std::string &p_type, const params &p_param);
+  udp_layer(const std::string& p_type, const params &p_param);
   /*!
    * \brief Default destructor
    */
@@ -79,6 +79,6 @@ protected:
   void init();
 
 private:
-  unsigned long get_host_id(const std::string &p_host_name);
+  unsigned long get_host_id(const std::string& p_host_name);
   void          close();
 }; // End of class udp_layer
diff --git a/ccsrc/Protocols/UDP/udp_layer_factory.hh b/ccsrc/Protocols/UDP/udp_layer_factory.hh
index d08c50332e6b8fbc9a80d2f0153efaa8223292f9..2c6f7abdbb763ccf07351546abbefa94b780a43f 100644
--- a/ccsrc/Protocols/UDP/udp_layer_factory.hh
+++ b/ccsrc/Protocols/UDP/udp_layer_factory.hh
@@ -31,12 +31,12 @@ public:                        //! \publicsection
     layer_stack_builder::register_layer_factory("UDP", this);
   };
   /*!
-   * \fn layer* create_layer(const std::string & type, const std::string & param);
+   * \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 udp_layer(p_type, p_param); };
+  inline virtual layer *create_layer(const std::string& p_type, const std::string& p_param) { return new udp_layer(p_type, p_param); };
 }; // End of class udp_layer_factory
diff --git a/ccsrc/Protocols/Xml/src/xml_converters.cc b/ccsrc/Protocols/Xml/src/xml_converters.cc
index 014504de8924a74f3bca58ae484bf306a9b6d5c0..aebace2db03217b991cf6e3fbedcda11eba4c557 100644
--- a/ccsrc/Protocols/Xml/src/xml_converters.cc
+++ b/ccsrc/Protocols/Xml/src/xml_converters.cc
@@ -57,6 +57,6 @@ int xml_converters::xml_canonicalization(const std::string& p_to_canonical, std:
 }
 
 int xml_converters::xml_node_set_contains_callback(void* p_user_data, xmlNodePtr p_node, xmlNodePtr p_parent) {
-  loggers::get_instance().log("xml_converters::xml_node_set_contains_callback");
+  //loggers::get_instance().log("xml_converters::xml_node_set_contains_callback");
   return 1;
 }
diff --git a/ccsrc/loggers/loggers.hh b/ccsrc/loggers/loggers.hh
index 36f73449dee9fa01d1b96b3f5cc18ffa1119c557..035f2d12d5d4244748cf99b962e397e92a7bff2f 100644
--- a/ccsrc/loggers/loggers.hh
+++ b/ccsrc/loggers/loggers.hh
@@ -157,7 +157,7 @@ public: //! \publicsection
    * \param[in] p_time_key A timer identifier (any string)
    * \inline
    */
-  inline void set_start_time(std::string &p_time_key);
+  inline void set_start_time(std::string& p_time_key);
   /*!
    * \fn void set_stop_time(std::string& p_time_key, float& p_time);
    * \brief Stop execution time measurement
@@ -165,7 +165,7 @@ public: //! \publicsection
    * \param[out] p_time    The execution time measured in milliseconds
    * \inline
    */
-  inline void set_stop_time(std::string &p_time_key, float &p_time);
+  inline void set_stop_time(std::string& p_time_key, float &p_time);
 }; // End of class loggers
 
 void loggers::log_to_hexa(const char *p_prompt, const TTCN_Buffer &buffer) {
@@ -252,9 +252,9 @@ void loggers::error(const char *p_fmt, ...) {
   va_end(args);
 }
 
-void loggers::set_start_time(std::string &p_time_key) { _times[p_time_key] = std::clock(); }
+void loggers::set_start_time(std::string& p_time_key) { _times[p_time_key] = std::clock(); }
 
-void loggers::set_stop_time(std::string &p_time_key, float &p_time) {
+void loggers::set_stop_time(std::string& p_time_key, float &p_time) {
   std::map<std::string, std::clock_t>::iterator it = _times.find(p_time_key);
   if (it != loggers::_times.end()) {
     p_time = (std::clock() - _times[p_time_key]) * 1000.0 / CLOCKS_PER_SEC; // in milliseconds
diff --git a/ccsrc/security/include/certs_cache.hh b/ccsrc/security/include/certs_cache.hh
index e51f5e6633557124132148ba131d3dda469aa9d3..7d33e4ffc9b9161f7ebb63078bb275e4638de0d0 100644
--- a/ccsrc/security/include/certs_cache.hh
+++ b/ccsrc/security/include/certs_cache.hh
@@ -52,21 +52,23 @@ public: /*! \publicsection */
    */
   int get_certificate(const std::string& p_certificate_id, const X509** p_certificate);
   /*!
-   * \fn int get_private_key(const std::string &p_certificate_id, const EVP_PKEY** p_private_key);
+   * \fn int get_private_key(const std::string& p_certificate_id, const EVP_PKEY** p_private_key);
    * \brief Retrive the private key of the specified certificate
    * \param[in] p_certificate_id The certificate name
    * \param[out] p_private_key The private key
    * \return 0 on success, -1 otherwise
    */
-  int get_private_key(const std::string &p_certificate_id, const EVP_PKEY** p_private_key);
+  int get_private_key(const std::string& p_certificate_id, const EVP_PKEY** p_private_key);
   /*!
-   * \fn int get_public_keys(const std::string &p_certificate_id, const EVP_PKEY** p_public_key);
+   * \fn int get_public_keys(const std::string& p_certificate_id, const EVP_PKEY** p_public_key);
    * \brief Retrive the public keys (in uncompressed format) of the specified certificate
    * \param[in] p_certificate_id The certificate name
    * \param[out] p_public_key The public key
    * \return 0 on success, -1 otherwise
    */
-  int get_public_keys(const std::string &p_certificate_id, const EVP_PKEY** p_public_key);
+  int get_public_keys(const std::string& p_certificate_id, const EVP_PKEY** p_public_key);
+
+  int get_certificate_pem(const std::string& p_certificate_id, std::string& p_certificate_pem);
 
   virtual int store_certificate(const std::string& p_certificate_name, const std::string& p_certificate, const EVP_PKEY* p_private_key);
 
@@ -82,14 +84,14 @@ public: /*! \publicsection */
 
 private: /*! \privatesection */
   /*!
-   * \fn int load_certificate(const std::string &p_certificate_name, const std::string &p_private_key_name, const certs_db_record** p_record);
+   * \fn int load_certificate(const std::string& p_certificate_name, const std::string& p_private_key_name, const certs_db_record** p_record);
    * \brief Retrive the specified certificate either from memory of from storage location
    * \param[in] p_certificate_name The certificate name
    * \param[in] p_private_key_name The certificate's private key name
    * \param[out] p_record A reference to the certificate record
    * \return 0 on success, -1 otherwise
    */
-  int load_certificate(const std::string &p_certificate_name, const std::string &p_private_key_name, const certs_db_record** p_record);
+  int load_certificate(const std::string& p_certificate_name, const std::string& p_private_key_name, const certs_db_record** p_record);
   /*!
    * \fn int load_certificate(const std::string& p_certificate_id, const certs_db_record** p_record);
    * \brief Retrive the specified certificate either from memory of from storage location
@@ -97,6 +99,6 @@ private: /*! \privatesection */
    * \param[out] p_record A reference to the certificate record
    * \return 0 on success, -1 otherwise
    */
-  int load_certificate(const std::string &p_certificate_id, const certs_db_record** p_record);
+  int load_certificate(const std::string& p_certificate_id, const certs_db_record** p_record);
 
 }; // End of class certs_cache
diff --git a/ccsrc/security/include/certs_db.hh b/ccsrc/security/include/certs_db.hh
index 0f08fa44e0ad84aacde32642539fbc0db98a8c43..adb4e141ab4e280b4b441453b8116fe679bd0e51 100644
--- a/ccsrc/security/include/certs_db.hh
+++ b/ccsrc/security/include/certs_db.hh
@@ -24,7 +24,7 @@ public: /*! \publicsection */
    * \brief Ctor with full path to the certificates storage
    * \param[in] p_db_path The full path to the certificates storage
    */
-  certs_db(const std::string &p_db_path);
+  certs_db(const std::string& p_db_path);
   /*!
    * \brief Default dtor
    */
@@ -45,5 +45,5 @@ private: /*! \privatesection */
    * \param[in] p_db_path The full path to the certificates storage
    * \return 0 on success, -1 otherwise
    */
-  int initialize_cache(const std::string &p_db_path);
+  int initialize_cache(const std::string& p_db_path);
 }; // End of class certs_db
diff --git a/ccsrc/security/include/certs_db_record.hh b/ccsrc/security/include/certs_db_record.hh
index f98f82a903d8255c8266e5fb1cab95a91e9832fc..17de815833866285292d5992366e6e2aef8b1a9e 100644
--- a/ccsrc/security/include/certs_db_record.hh
+++ b/ccsrc/security/include/certs_db_record.hh
@@ -23,20 +23,22 @@ class certs_db_record {
   std::string _certificate_id;   /*!< Certificate name */
   X509*       _certificate;      /*!< X509 Certificate */
   EVP_PKEY*   _private_key;      /*!< Private key */
+  std::string _pem;              /*!< Certificate PEM format */
 
 public: /*! \publicsection */
   /*!
    * \brief Default ctor
    */
   explicit certs_db_record()
-    : _certificate_id(nullptr), _certificate(nullptr), _private_key(nullptr) {};
+    : _certificate_id(nullptr), _certificate(nullptr), _private_key(nullptr), _pem{} {};
   /*!
    * \brief Specialised ctor
    * \param[in] p_certificate_id The certificate identifier
    * \param[in] p_certificate The X509 certificate in openssl format
    * \param[in] p_private_key The certificate's private key in openssl format
+   * \param[in] p_certificate_pem The certificate's PEM format
    */
-  certs_db_record(const std::string &p_certificate_id, X509* p_certificate, EVP_PKEY* p_private_key);
+  certs_db_record(const std::string& p_certificate_id, X509* p_certificate, EVP_PKEY* p_private_key, const std::string& p_certificate_pem);
 
   /*!
    * \brief Default dtor
@@ -49,7 +51,7 @@ public: /*! \publicsection */
    * \brief Retrieve the certificate identifier value
    * \return The certificate identifier
    */
-  inline const std::string &certificate_id() const { return _certificate_id; };
+  inline const std::string& certificate_id() const { return _certificate_id; };
   /*!
    * \inline
    * \fn const X509* certificate() const;
@@ -59,4 +61,5 @@ public: /*! \publicsection */
   inline const X509* certificate() const { return _certificate; };
   inline const EVP_PKEY* private_key() const { return _private_key; };
   inline const EVP_PKEY* public_key() const { return ::X509_get_pubkey(_certificate); };
+  inline const std::string& pem() const { return _pem; };
 }; // End of class certs_db_record
diff --git a/ccsrc/security/include/certs_loader.hh b/ccsrc/security/include/certs_loader.hh
index 42fd16296a5e807e1a2c1aa6958bff6f78be5651..3f408c6617c83b51cd626e6b8620a2da5ec03c70 100644
--- a/ccsrc/security/include/certs_loader.hh
+++ b/ccsrc/security/include/certs_loader.hh
@@ -62,7 +62,7 @@ public: /*! \publicsection */
   };
 
   /*!
-   * \fn int build_path(const std::string &p_root_directory);
+   * \fn int build_path(const std::string& p_root_directory);
    * \brief Set the pass of the certificate storage
    * \param[in] p_db_path The pass of the certificate storage
    */
diff --git a/ccsrc/security/include/security_services.hh b/ccsrc/security/include/security_services.hh
index 99bfb5f8631a7e817addb929f8ef8da86944bc1a..07b43eca8ecd6678c31596f29c48267989dd36e9 100644
--- a/ccsrc/security/include/security_services.hh
+++ b/ccsrc/security/include/security_services.hh
@@ -32,7 +32,7 @@ public: /*! \publicsection */
   int initialize(const std::string& p_certs_db_path);
   int load_certificate(const std::string& p_certificate_name, const std::string& p_private_key_name, const X509** p_certificate);
   /*!
-   * \fn int build_path(const std::string &p_root_directory);
+   * \fn int build_path(const std::string& p_root_directory);
    * \brief Set the pass of the certificate storage
    * \param[in] p_db_path The pass of the certificate storage
    */
diff --git a/ccsrc/security/src/certs_cache.cc b/ccsrc/security/src/certs_cache.cc
index b0b413a38995b99dd1ccfcc85f50b9645133ee3f..2aa7a5c7488d1ed06b5362133cb28f725c915d6c 100644
--- a/ccsrc/security/src/certs_cache.cc
+++ b/ccsrc/security/src/certs_cache.cc
@@ -34,7 +34,7 @@ int certs_cache::clear() {
   return 0;
 } // End of clear method
 
-int certs_cache::load_certificate(const std::string &p_certificate_id, const certs_db_record** p_record) {
+int certs_cache::load_certificate(const std::string& p_certificate_id, const certs_db_record** p_record) {
   loggers::get_instance().log(">>> certs_cache::load_certificate (1): '%s'", p_certificate_id.c_str());
 
   // Sanity check
@@ -49,7 +49,7 @@ int certs_cache::load_certificate(const std::string &p_certificate_id, const cer
   return 0;
 }
 
-int certs_cache::load_certificate(const std::string &p_certificate_name, const std::string &p_private_key_name, const certs_db_record** p_record) {
+int certs_cache::load_certificate(const std::string& p_certificate_name, const std::string& p_private_key_name, const certs_db_record** p_record) {
   loggers::get_instance().log(">>> certs_cache::load_certificate (2): '%s'", p_certificate_name.c_str());
 
   std::string certificate_id;
@@ -77,7 +77,7 @@ int certs_cache::load_certificate(const std::string &p_certificate_name, const s
   return 0;
 }
 
-int certs_cache::get_certificate(const std::string& p_certificate_name, const std::string &p_private_key_name, const X509** p_certificate) {
+int certs_cache::get_certificate(const std::string& p_certificate_name, const std::string& p_private_key_name, const X509** p_certificate) {
   loggers::get_instance().log(">>> certs_cache::get_certificate (1): '%s'", p_certificate_name.c_str());
 
   const certs_db_record* record;
@@ -92,7 +92,7 @@ int certs_cache::get_certificate(const std::string& p_certificate_name, const st
   return 0;
 }
 
-int certs_cache::get_certificate(const std::string &p_certificate_id, const X509** p_certificate) {
+int certs_cache::get_certificate(const std::string& p_certificate_id, const X509** p_certificate) {
   loggers::get_instance().log(">>> certs_cache::get_certificate (2): '%s'", p_certificate_id.c_str());
 
   const certs_db_record* record;
@@ -107,7 +107,7 @@ int certs_cache::get_certificate(const std::string &p_certificate_id, const X509
   return 0;
 }
 
-int certs_cache::get_private_key(const std::string &p_certificate_id, const EVP_PKEY** p_private_key) {
+int certs_cache::get_private_key(const std::string& p_certificate_id, const EVP_PKEY** p_private_key) {
   loggers::get_instance().log(">>> certs_cache::get_private_key: '%s'", p_certificate_id.c_str());
 
   const certs_db_record *record;
@@ -122,7 +122,7 @@ int certs_cache::get_private_key(const std::string &p_certificate_id, const EVP_
   return 0;
 }
 
-int certs_cache::get_public_keys(const std::string &p_certificate_id, const EVP_PKEY** p_public_key) {
+int certs_cache::get_public_keys(const std::string& p_certificate_id, const EVP_PKEY** p_public_key) {
   loggers::get_instance().log(">>> certs_cache::get_public_keys: '%s'", p_certificate_id.c_str());
 
   const certs_db_record* record;
@@ -137,6 +137,21 @@ int certs_cache::get_public_keys(const std::string &p_certificate_id, const EVP_
   return 0;
 }
 
+int certs_cache::get_certificate_pem(const std::string& p_certificate_id, std::string& p_certificate_pem) {
+  loggers::get_instance().log(">>> certs_cache::get_certificate_pem: '%s'", p_certificate_id.c_str());
+
+  const certs_db_record* record;
+  if (load_certificate(p_certificate_id, &record) == -1) {
+    loggers::get_instance().warning("certs_cache::get_certificate_pem: Failed to load certificate");
+    return -1;
+  }
+
+  p_certificate_pem = record->pem();
+  loggers::get_instance().log("certs_cache::get_certificate_pem: p_certificate_pem: '%s'", p_certificate_pem);
+
+  return 0;
+}
+
 int certs_cache::store_certificate(const std::string& p_certificate_name, const std::string& p_certificate, const EVP_PKEY* p_private_key) {
   loggers::get_instance().log(">>> certs_cache::store_certificate: '%s'", p_certificate_name.c_str());
 
diff --git a/ccsrc/security/src/certs_db.cc b/ccsrc/security/src/certs_db.cc
index 055551999437434e64597c8ae935d7bb6b1f26d7..b4cfc430818ad2fc76459704dcd2b4224beb010c 100644
--- a/ccsrc/security/src/certs_db.cc
+++ b/ccsrc/security/src/certs_db.cc
@@ -7,7 +7,7 @@
 using namespace std; // Required for isnan()
 #include "certs_loader.hh"
 
-certs_db::certs_db(const std::string &p_db_path) {
+certs_db::certs_db(const std::string& p_db_path) {
   loggers::get_instance().log(">>> certs_db::certs_db: '%s'", p_db_path.c_str());
 
   initialize_cache(p_db_path);
@@ -16,7 +16,7 @@ certs_db::certs_db(const std::string &p_db_path) {
 
 certs_db::~certs_db() { loggers::get_instance().log(">>> certs_db::~certs_db"); } // End of dtor
 
-int certs_db::initialize_cache(const std::string &p_db_path) {
+int certs_db::initialize_cache(const std::string& p_db_path) {
   loggers::get_instance().log(">>> certs_db::initialize_cache: '%s'", p_db_path.c_str());
 
   certs_loader::get_instance().build_path(p_db_path);
diff --git a/ccsrc/security/src/certs_db_record.cc b/ccsrc/security/src/certs_db_record.cc
index 59a0bd14c9d5c9e7068da31447a1e1a3e7728f22..a5c34ba0f3bbf7e630e927b9e301c2fdd316ac78 100644
--- a/ccsrc/security/src/certs_db_record.cc
+++ b/ccsrc/security/src/certs_db_record.cc
@@ -15,10 +15,11 @@
 
 #include "certs_db_record.hh"
 
-certs_db_record::certs_db_record(const std::string &p_certificate_id, X509* p_certificate, EVP_PKEY* p_private_key) : _certificate_id(p_certificate_id), _certificate(p_certificate), _private_key(p_private_key) {
-  loggers::get_instance().log(">>> certs_db_record::certs_db_record: p_certificate_id: '%s'", p_certificate_id.c_str());
-  loggers::get_instance().log(">>> certs_db_record::certs_db_record: p_certificate: '%p'", p_certificate);
-  loggers::get_instance().log(">>> certs_db_record::certs_db_record: p_private_key: '%p'", p_private_key);
+certs_db_record::certs_db_record(const std::string& p_certificate_id, X509* p_certificate, EVP_PKEY* p_private_key, const std::string& p_certificate_pem) : _certificate_id(p_certificate_id), _certificate(p_certificate), _private_key(p_private_key), _pem(p_certificate_pem) {
+  loggers::get_instance().log(">>> certs_db_record::certs_db_record: p_certificate_id: '%s'", _certificate_id.c_str());
+  loggers::get_instance().log(">>> certs_db_record::certs_db_record: p_certificate: '%p'", _certificate_id);
+  loggers::get_instance().log(">>> certs_db_record::certs_db_record: p_private_key: '%p'", _private_key);
+  loggers::get_instance().log(">>> certs_db_record::certs_db_record: p_private_key: '%s'", _pem);
 }
 
 certs_db_record::~certs_db_record() {
diff --git a/ccsrc/security/src/certs_loader.cc b/ccsrc/security/src/certs_loader.cc
index dcb4b77677395747dfcec7c1a64143f5180b4e20..0fa3eb738a3d7f71d8cf311b41c2866d8a63aeed 100644
--- a/ccsrc/security/src/certs_loader.cc
+++ b/ccsrc/security/src/certs_loader.cc
@@ -88,12 +88,41 @@ int certs_loader::load_certificate(const std::string& p_certificate_name, const
   }
   std::experimental::filesystem::path p = _db_path.string() + "/" + p_certificate_name;
   int ret = BIO_read_filename(certbio, p.string().c_str());
+
   X509* cert = ::PEM_read_bio_X509(certbio, NULL, 0, NULL);
   if (cert == nullptr) {
     loggers::get_instance().warning("certs_loader::load_certificate: Error loading cert into memory");
     ::BIO_free_all(certbio);
     return -1;
   }
+
+  std::unique_ptr<BIO, decltype(&::BIO_free)> bio(BIO_new(BIO_s_mem()), ::BIO_free);
+  ret = ::PEM_write_bio_X509(bio.get(), cert);
+  if (ret != 1) {
+    loggers::get_instance().warning("certs_loader::load_certificate: PEM_write_bio_X509 failed, error %s", ::ERR_get_error());
+    ::X509_free(cert);
+    ::BIO_free_all(certbio);
+    return -1;
+  }
+  BUF_MEM *mem = NULL;
+  ::BIO_get_mem_ptr(bio.get(), &mem);
+  if (!mem || !mem->data || !mem->length) {
+    loggers::get_instance().warning("certs_loader::load_certificate: BIO_get_mem_ptr failed, error %s", ::ERR_get_error());
+    ::X509_free(cert);
+    ::BIO_free_all(certbio);
+    return -1;
+  }
+  std::string pem(mem->data, mem->length);
+  // Remove labels
+  loggers::get_instance().log("certs_loader::load_certificate: certificate pem (1): '%s'", pem.c_str());
+  std::string s("-----BEGIN CERTIFICATE-----\n");
+  std::string::size_type idx = pem.find_first_of(s);
+  pem = pem.substr(s.length());
+  s = "\n-----END CERTIFICATE-----\n";
+  idx = pem.rfind(s);
+  pem = pem.substr(0, pem.length() - s.length());
+  loggers::get_instance().log("certs_loader::load_certificate: certificate pem (2): '%s'", pem.c_str());
+
   ::BIO_free_all(certbio);
 
   // Load private key file
@@ -123,9 +152,10 @@ int certs_loader::load_certificate(const std::string& p_certificate_name, const
   loggers::get_instance().log("certs_loader::load_certificate: p_certificate_id: '%s'", p_certificate_id.c_str());
   loggers::get_instance().log("certs_loader::load_certificate: cert: '%p'", cert);
   loggers::get_instance().log("certs_loader::load_certificate: private_key: '%p'", private_key);
+  loggers::get_instance().log("certs_loader::load_certificate: certificate pem: '%s'", pem.c_str());
 
   // Create new record
-  certs_db_record *r = new certs_db_record(p_certificate_name, cert, private_key);
+  certs_db_record *r = new certs_db_record(p_certificate_name, cert, private_key, pem);
   std::pair<std::map<std::string, std::unique_ptr<const certs_db_record>>::iterator, bool> result = p_certificates.insert(std::pair<std::string, std::unique_ptr<const certs_db_record>>(p_certificate_id, std::unique_ptr<const certs_db_record>(r)));
   if (result.second == false) {
     loggers::get_instance().warning("certs_loader::build_certificates_cache: Failed to insert new record '%s'", p_certificate_name.c_str());
diff --git a/ccsrc/security/src/securty_services.cc b/ccsrc/security/src/securty_services.cc
index 455df75146b1f027e13099bbe832e13a25424f5a..0103af52678383cf1343435be68519c86a39f0fd 100644
--- a/ccsrc/security/src/securty_services.cc
+++ b/ccsrc/security/src/securty_services.cc
@@ -41,7 +41,7 @@ int security_services::do_sign(const OCTETSTRING& p_encoded_message, const CHARS
 
   // Canonicalization
   std::string canonicalized;
-  xml_converters::get_instance().xml_canonicalization(std::string((const char*)(static_cast<const unsigned char*>(p_encoded_message))), canonicalized);
+  xml_converters::get_instance().xml_canonicalization(std::string((const char*)(static_cast<const unsigned char*>(p_encoded_message)), p_encoded_message.lengthof()), canonicalized);
   OCTETSTRING encoded_message(char2oct(CHARSTRING(canonicalized.c_str())));
   loggers::get_instance().log("security_services::do_sign: canonicalized: '%s", canonicalized.c_str());
 
@@ -64,7 +64,12 @@ int security_services::do_sign(const OCTETSTRING& p_encoded_message, const CHARS
   p_x509_certificate_subject = CHARSTRING(subject.c_str());
   X509_free((X509*)certificate);
 
-  p_x509_certificate_pem = ""; // TODO
+  std::string str;
+  if (_certs_db->get_certificate_pem(certificate_id, str) != 0) {
+    loggers::get_instance().warning("fx__sign: Failed to retrieve certificate PEM");
+    return -1;  
+  }
+  p_x509_certificate_pem = CHARSTRING(str.c_str());
 
   // Compute the digest
   sha256 digest;