Merge remote-tracking branch 'origin/ttf_t009' into ttf_t009 (43b3473f) · Commits · EMTEL - Emergency Communications / NG112 Conformance Test Suites

ccsrc/Framework/include/params.hh

+2 −0

Original line number	Diff line number	Diff line
		@@ -40,6 +40,8 @@ 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_auth; //! Set to 1 to use mutual TLS authentication to communicate with the HTTPS server. Default: false
		static const std::string& trusted_ca_list; //! List of trusted CA certificates
		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

+2 −0

Original line number	Diff line number	Diff line
		@@ -34,6 +34,8 @@ 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_auth = std::string("mutual_auth");
		const std::string& params::trusted_ca_list = std::string("trusted_ca_list");
		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_auth);
		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

+59 −17

Original line number	Diff line number	Diff line
		@@ -21,10 +21,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 +39,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 +56,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 +67,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 +78,38 @@ 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
		// Check mutual authentication param
		_params.insert(std::pair<std::string, std::string>(std::string("mutual_tls"), "0"));
		parameter_set(ssl_verifycertificate_name(), "no");
		it = _params.find(params::mutual_auth);
		if (it == _params.cend()) {
		if (_params[params::mutual_auth].compare("1") == 0) { // Use mutual authentication
		parameter_set(ssl_verifycertificate_name(), "yes");
		_params.insert(std::pair<std::string, std::string>(std::string("mutual_tls"), "1"));
		}
		}
		// Set trusted CA file
		it = _params.find(params::mutual_auth);
		if (it == _params.cend()) {
		parameter_set(ssl_trustedCAlist_file_name(), it->second.c_str());
		_params.insert(std::pair<std::string, std::string>(std::string("mutual_tls"), it->second));
		} else {
		parameter_set(ssl_trustedCAlist_file_name(), "/usr/share/ca-certificates/mozilla/Amazon_Root_CA_1.crt");
		}
		// Set additional certificates
		//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");
		}
		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 == 0) {
		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 +141,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);
		}

		@@ -151,8 +192,7 @@ int tcp_layer::send_message_on_fd(int p_client_id, const unsigned char * message
		{
		loggers::get_instance().log(">>> tcp_layer::send_message_on_fd: %d", p_client_id);

		if(get_user_data(p_client_id))
		{
		if(get_user_data(p_client_id)) {
		loggers::get_instance().log("tcp_layer::send_message_on_fd: SSL mode");
		return SSL_Socket::send_message_on_fd(p_client_id, message_buffer, length_of_message);
		}
		@@ -165,8 +205,7 @@ int tcp_layer::send_message_on_nonblocking_fd(int p_client_id, const unsigned ch
		{
		loggers::get_instance().log(">>> tcp_layer::send_message_on_nonblocking_fd: %d", p_client_id);

		if(get_user_data(p_client_id))
		{
		if(get_user_data(p_client_id)) {
		loggers::get_instance().log("tcp_layer::send_message_on_nonblocking_fd: SSL mode");
		return SSL_Socket::send_message_on_nonblocking_fd(p_client_id, message_buffer, length_of_message);
		}
		@@ -186,6 +225,9 @@ int tcp_layer::receive_message_on_fd(int p_client_id)
		}

		loggers::get_instance().log("tcp_layer::receive_message_on_fd: Non secured mode");
		if (_params[std::string("tcp_fragmented")].compare("1") == 0) {
		sleep(5); // FIXME When HTTP paquet is fragmented into several TCP packets, a timer is required. This is a Q&D solution
		}
		return Abstract_Socket::receive_message_on_fd(p_client_id);
		}