Commit 66c5ad91 authored by YannGarcia's avatar YannGarcia
Browse files

Add lower layer information in indication messages (tls, mutual authentication)

parent 2f8bb1d4

ccsrc/Framework/include/params.hh

+1 −0
Original line number Diff line number Diff line
@@ -40,6 +40,7 @@ public: //! \publicsection 
  static const std::string& server;                //! HTTP server address (e.g. www.etsi.org)

  static const std::string& port;                  //! HTTP server port. Default: 80

  static const std::string& use_ssl;               //! Set to 1 to use SSL to communicate with the HTTP server. Default: false

  static const std::string& mutual_tls;            //! Set to 1 to use mutual TLS authentication to communicate with the HTTPS server. Default: false

  static const std::string& server_mode;           //! Does the test sytem acting as a server. Default: 0

  static const std::string& local_port;            //! Local listener port. Default: 80

ccsrc/Framework/src/params.cc

+1 −0
Original line number Diff line number Diff line
@@ -34,6 +34,7 @@ const std::string& params::device_mode = std::string("device_mode"); 
const std::string& params::server = std::string("server");

const std::string& params::port = std::string("port");

const std::string& params::use_ssl = std::string("use_ssl");

const std::string& params::mutual_tls = std::string("mutual_tls");

const std::string& params::server_mode = std::string("server_mode");

const std::string& params::local_port = std::string("local_port");

ccsrc/Protocols/Http/http_codec.cc

+18 −1
Original line number Diff line number Diff line
@@ -88,6 +88,23 @@ int http_codec::decode (const OCTETSTRING& data, LibItsHttp__TypesAndValues::Htt 
      } else {

        response.body() = OPTIONAL<LibItsHttp__MessageBodyTypes::HttpMessageBody>(body);

      }

      // Add lower layers parameters

      loggers::get_instance().log("http_codec::decode: Add lower layers parameters");

      params->log();

      params::const_iterator it = params->find(params::use_ssl);

      if (it != params->cend()) {

        loggers::get_instance().log("http_codec::receive_data: tls=%s", it->second.c_str());

        response.tls() = (it->second.compare("1") == 0) ? true : false;

      } else {

        response.tls().set_to_omit();

      }

      it = params->find(params::mutual_tls);

      if (it != params->cend()) {

        loggers::get_instance().log("http_codec::receive_data: mutual_tls=%s", it->second.c_str());

        response.mutual__tls() = (it->second.compare("1") == 0) ? true : false;

      } else {

        response.mutual__tls().set_to_omit();

      }

      msg.response() = response;

    } else { // HTTP request

      LibItsHttp__TypesAndValues::Request request;

ccsrc/Protocols/Http/http_layer.cc

+1 −1
Original line number Diff line number Diff line
@@ -86,7 +86,7 @@ void http_layer::receive_data(OCTETSTRING& data, params& params) 


  // Decode HTTP message

  LibItsHttp__TypesAndValues::HttpMessage http_message;

  if (_codec.decode(data, http_message) == -1) {

  if (_codec.decode(data, http_message, &params) == -1) {

    loggers::get_instance().warning("http_layer::receive_data: Failed to decode data");

    return;

  }

ccsrc/Protocols/Tcp/tcp_layer.cc

+35 −7
Original line number Diff line number Diff line
@@ -4,6 +4,8 @@ 
#include <errno.h>

#include <chrono>



//#include <experimental/filesystem>



#include "tcp_layer_factory.hh"



#include "loggers.hh"
@@ -21,10 +23,16 @@ tcp_layer::tcp_layer(const std::string & p_type, const std::string & param) : la 
  } else if (it->second.compare("1") == 0) {

    set_socket_debugging(true);

  }

  it = _params.find(std::string("tcp_fragmented"));

  if (it == _params.cend()) {

    _params.insert(std::pair<std::string, std::string>(std::string("tcp_fragmented"), "0"));

  }

  bool server_mode = false;

  it = _params.find(params::server_mode);

  if (it != _params.cend()) {

    server_mode = (1 == std::stoi(it->second));

  } else {

    _params.insert(std::pair<std::string, std::string>(std::string("server_mode"), "0"));

  }

  it = _params.find(params::server);

  if (it == _params.cend()) {
@@ -33,13 +41,15 @@ tcp_layer::tcp_layer(const std::string & p_type, const std::string & param) : la 
  if (!parameter_set(params::server.c_str(), _params[params::server].c_str())) {

    loggers::get_instance().warning("tcp_layer::set_parameter: Unprocessed parameter: %s", params::server.c_str());

  }

  set_ssl_use_ssl(false);

  bool ssl_mode = false;

  it = _params.find(params::use_ssl);

  if (it == _params.cend()) {

    _params.insert(std::pair<std::string, std::string>(std::string("use_ssl"), "0"));

  } else if (it->second.compare("1") == 0) {

    set_ssl_use_ssl(true);

    _params.insert(std::pair<std::string, std::string>(std::string("use_ssl"), "1"));

    ssl_mode = true;

  }

  set_ssl_use_ssl(ssl_mode);

  it = _params.find(params::port);

  if (it == _params.cend()) {

    if (_params[params::use_ssl].compare("0") == 0) { // Use standard HTTP port
@@ -48,7 +58,7 @@ tcp_layer::tcp_layer(const std::string & p_type, const std::string & param) : la 
      _params.insert(std::pair<std::string, std::string>(std::string("port"), "443"));

    }

  }

  if (!parameter_set(params::port.c_str(), _params[params::port].c_str())) {

  if (!parameter_set(remote_port_name(), _params[params::port].c_str())) {

    loggers::get_instance().warning("tcp_layer::set_parameter: Unprocessed parameter: %s", params::port.c_str());

  }

  it = _params.find(params::local_port);
@@ -59,7 +69,7 @@ tcp_layer::tcp_layer(const std::string & p_type, const std::string & param) : la 
      _params.insert(std::pair<std::string, std::string>(std::string("local_port"), "443"));

    }

  }

  if (!parameter_set(params::local_port.c_str(), _params[params::local_port].c_str())) {

  if (!parameter_set(local_port_name(), _params[params::local_port].c_str())) {

    loggers::get_instance().warning("tcp_layer::set_parameter: Unprocessed parameter: %s", params::local_port.c_str());

  }
@@ -70,12 +80,23 @@ tcp_layer::tcp_layer(const std::string & p_type, const std::string & param) : la 
  if (server_mode) {

    parameter_set("serverPort", _params[params::local_port].c_str());

  }

  if (ssl_mode) { // Add certificate bundle

    parameter_set(ssl_verifycertificate_name(), "yes");

    _params.insert(std::pair<std::string, std::string>(std::string("mutual_tls"), "1"));

    //    loggers::get_instance().log("####################### Current path is %s", std::experimental::filesystem::current_path().c_str());

    //parameter_set(ssl_private_key_file_name(), "../certificates/out/privates/e5e11abad8003766e4a7b721afb175a189b5f4cc7046af9b0d8eaebb86f28c40_server_dsa.key.pem");

    //parameter_set(ssl_certificate_file_name(), "../certificates/out/certs/e5e11abad8003766e4a7b721afb175a189b5f4cc7046af9b0d8eaebb86f28c40_server_dsa.cert.pem");

    parameter_set(ssl_trustedCAlist_file_name(), "/usr/share/ca-certificates/mozilla/Amazon_Root_CA_1.crt");//"../certificates/out/certs/CA_dsa.cert.pem"); // FIXME Use a parameter

  }

  set_ttcn_buffer_usercontrol(false);

  set_handle_half_close(true);



  map_user();



  if (!_reconnect_on_send) {

  parameter_set(client_TCP_reconnect_name(), "yes");



  if (!server_mode) {

    loggers::get_instance().log("tcp_layer::tcp_layer: Establish connection: %s/%s", _params[params::server].c_str(), _params[params::port].c_str());

	  open_client_connection(_params[params::server].c_str(), _params[params::port].c_str(), NULL, NULL);

  }

                                                                                                                                                            }
@@ -107,7 +128,14 @@ void tcp_layer::send_data(OCTETSTRING& data, params& params) { 
  loggers::get_instance().log_msg(">>> tcp_layer::send_data: ", data);



  loggers::get_instance().log("tcp_layer::send_data: SSL mode: %x", get_ssl_use_ssl());

  loggers::get_instance().log("tcp_layer::send_data: server_mode: %s", _params[params::server_mode].c_str());

  loggers::get_instance().log("tcp_layer::send_data: peer_list_get_nr_of_peers: %d", peer_list_get_nr_of_peers());



  if ((_params[params::server_mode].compare("0") == 0) && (peer_list_get_nr_of_peers() == 0)) {

    // Reconnect (e.g. HTTP connection lost

    loggers::get_instance().log("tcp_layer::send_data: Re-establish connection: %s/%s", _params[params::server].c_str(), _params[params::port].c_str());

	  open_client_connection(_params[params::server].c_str(), _params[params::port].c_str(), NULL, NULL);

  }

  send_outgoing(static_cast<const unsigned char*>(data), data.lengthof(), _client_id);

}
@@ -125,7 +153,7 @@ void tcp_layer::message_incoming(const unsigned char* message_buffer, int length 
  float duration;

  loggers::get_instance().set_start_time(_time_key);

  OCTETSTRING data(length, message_buffer);

  params params;

  params params(_params);

  this->receive_data(data, params); // TODO Check execution time for decoding operation

  loggers::get_instance().set_stop_time(_time_key, duration);

}