Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • cti-tools/titan-test-system-framework
1 result
Show changes
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 873 additions and 767 deletions
ccsrc/Protocols/ETH/ethernet_layer.hh
View file @ 57565dc1
......@@ -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
*/
......
ccsrc/Protocols/ETH/ethernet_layer_factory.hh
View file @ 57565dc1
......@@ -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
ccsrc/Protocols/Http/http_codec.cc
View file @ 57565dc1
This diff is collapsed.
ccsrc/Protocols/Http/http_codec.hh
View file @ 57565dc1
......@@ -9,6 +9,7 @@ class Base_Type;
class Record_Type;
class TTCN_Typedescriptor_t;
class TTCN_Buffer;
class OCTETSTRING;
namespace LibHttp__TypesAndValues {
class HttpMessage;
......@@ -60,37 +61,40 @@ class http_codec : public codec_gen<LibHttp__TypesAndValues::HttpMessage, LibHtt
protected:
std::map<std::string, std::unique_ptr<codec_gen<Record_Type, Record_Type>>> _codecs;
std::vector<OCTETSTRING> _bufferized_buffers;
unsigned int _initial_content_length;
unsigned int _current_content_length;
public:
explicit http_codec() : codec_gen<LibHttp__TypesAndValues::HttpMessage, LibHttp__TypesAndValues::HttpMessage>(), _ec(), _dc(), _codecs(){};
explicit http_codec() : codec_gen<LibHttp__TypesAndValues::HttpMessage, LibHttp__TypesAndValues::HttpMessage>(), _ec(), _dc(), _codecs(), _bufferized_buffers(), _initial_content_length{0}, _current_content_length{0} {};
virtual ~http_codec(){};
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
ccsrc/Protocols/Http/http_layer.cc
View file @ 57565dc1
......@@ -11,9 +11,9 @@ 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());
loggers::get_instance().log(">>> http_layer::http_layer: '%s', %s", to_string().c_str(), param.c_str());
// Setup parameters
params::convert(_params, param);
......@@ -95,9 +95,14 @@ void http_layer::receive_data(OCTETSTRING &data, params &params) {
// Decode HTTP message
LibHttp__TypesAndValues::HttpMessage http_message;
if (_codec->decode(data, http_message, &params) == -1) {
int ret_code = _codec->decode(data, http_message, &params);
if (ret_code == -1) {
loggers::get_instance().warning("http_layer::receive_data: Failed to decode data");
return;
} else if (ret_code == -2) { // Need to wait for next data
loggers::get_instance().log("http_layer::receive_data: Set Buffurizing to 1");
params.insert(std::make_pair<std::string, std::string>("Buffurizing", "1"));
return;
}
if (_device_mode) {
OCTETSTRING os;
......
ccsrc/Protocols/Http/http_layer_factory.hh
View file @ 57565dc1
......@@ -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
ccsrc/Protocols/Pcap/pcap_cygwin_layer.cc
View file @ 57565dc1
......@@ -52,9 +52,9 @@ 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());
loggers::get_instance().log(">>> pcap_layer::pcap_layer: '%s', %s", p_type.c_str(), param.c_str());
params::convert(_params, param);
char error_buffer[PCAP_ERRBUF_SIZE];
......@@ -128,7 +128,7 @@ pcap_layer::pcap_layer(const std::string &p_type, const std::string &param)
}
// Log final PCAP filter
loggers::get_instance().user("pcap_layer::pcap_layer: Filter: %s", filter.c_str());
loggers::get_instance().user("pcap_layer::pcap_layer: Filter: '%s'", filter.c_str());
// setup filter
{
......@@ -147,7 +147,7 @@ pcap_layer::pcap_layer(const std::string &p_type, const std::string &param)
// create pipe and run thread
if (pipe2(_fd, O_NONBLOCK) == -1) {
loggers::get_instance().error("pcap_layer::pcap_layer: Failed to create a pipe: %s", ::strerror(errno));
loggers::get_instance().error("pcap_layer::pcap_layer: Failed to create a pipe: '%s'", ::strerror(errno));
}
// Pass the pipe handler to the polling procedure
loggers::get_instance().log("pcap_layer::pcap_layer: Call handler with descriptor %d", _fd[0]);
......@@ -238,7 +238,7 @@ void *pcap_layer::thread() {
void pcap_layer::send_data(OCTETSTRING &data, params &params) {
loggers::get_instance().log_msg(">>> pcap_layer::send_data: ", data);
if (pcap_sendpacket(_device, static_cast<const unsigned char *>(data), data.lengthof()) == -1) {
loggers::get_instance().error("pcap_layer::send_data: Failed to send packet: %s", pcap_geterr(_device));
loggers::get_instance().error("pcap_layer::send_data: Failed to send packet: '%s'", pcap_geterr(_device));
}
}
......
ccsrc/Protocols/Pcap/pcap_cygwin_layer.hh
View file @ 57565dc1
......@@ -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
*/
......
ccsrc/Protocols/Pcap/pcap_layer.cc
View file @ 57565dc1
......@@ -16,7 +16,7 @@ typedef struct timeval pcap_o_timeval;
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), _thread(NULL), _running(FALSE), _resume(), _sent_file(NULL), _time_key("pcap_layer::Handle_Fd_Event_Readable") {
bool online = false;
loggers::get_instance().log(">>> pcap_layer::pcap_layer: %s, %s", to_string().c_str(), param.c_str());
loggers::get_instance().log(">>> pcap_layer::pcap_layer: '%s', %s", to_string().c_str(), param.c_str());
_fd[0] = -1; _fd[1] = -1;
// Setup parameters
params::convert(_params, param);
......@@ -42,7 +42,7 @@ pcap_layer::pcap_layer(const std::string& p_type, const std::string& param) : la
} // else, continue
// Set non-blocking flag for the polling procedure
if (pcap_setnonblock(_device, 1, error_buffer) != 0) {
loggers::get_instance().error("pcap_layer::pcap_layer: Failed to set blocking mode: %s", error_buffer);
loggers::get_instance().error("pcap_layer::pcap_layer: Failed to set blocking mode: '%s'", error_buffer);
}
// Retrieve the device file handler
_pcap_h = pcap_get_selectable_fd(_device);
......@@ -70,7 +70,7 @@ pcap_layer::pcap_layer(const std::string& p_type, const std::string& param) : la
int i = _params["file"].find(".pcap");
if (i > 0) {
std::string f(_params["file"].substr(0, i) + ext + ".pcap");
loggers::get_instance().log("pcap_layer::pcap_layer: Save file name: %s", f.c_str());
loggers::get_instance().log("pcap_layer::pcap_layer: Save file name: '%s'", f.c_str());
if ((_sent_file = pcap_dump_open(_device, f.c_str())) == NULL) {
loggers::get_instance().warning("pcap_layer::pcap_layer: Failed to open save file %s", f.c_str());
}
......@@ -105,7 +105,7 @@ pcap_layer::pcap_layer(const std::string& p_type, const std::string& param) : la
} // else nothing to do
}
// Log final PCAP filter
loggers::get_instance().user("pcap_layer::pcap_layer: Filter: %s", filter.c_str());
loggers::get_instance().user("pcap_layer::pcap_layer: Filter: '%s'", filter.c_str());
if (!filter.empty()) {
struct bpf_program f = {0};
if (pcap_compile(_device, &f, filter.c_str(), 1, PCAP_NETMASK_UNKNOWN) != 0) {
......@@ -123,7 +123,7 @@ pcap_layer::pcap_layer(const std::string& p_type, const std::string& param) : la
} else { // Offline capture or cygwin
// Create a pipe
if (pipe2(_fd, O_NONBLOCK) == -1) {
loggers::get_instance().error("pcap_layer::pcap_layer: Failed to create a pipe: %s", ::strerror(errno));
loggers::get_instance().error("pcap_layer::pcap_layer: Failed to create a pipe: '%s'", ::strerror(errno));
}
if(online){
_pcap_h = _fd[0];
......@@ -212,7 +212,7 @@ void pcap_layer::send_data(OCTETSTRING& data, params& params) {
if (_pcap_h != -1) { // Check if offline mode is used
if (pcap_sendpacket(_device, static_cast<const unsigned char *>(data), data.lengthof()) == -1) {
loggers::get_instance().error("pcap_layer::send_data: Failed to send packet: %s", pcap_geterr(_device));
loggers::get_instance().error("pcap_layer::send_data: Failed to send packet: '%s'", pcap_geterr(_device));
}
} else if (_sent_file != NULL) {
struct pcap_pkthdr hdr;
......
ccsrc/Protocols/Pcap/pcap_layer_factory.hh
View file @ 57565dc1
......@@ -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
ccsrc/Protocols/Pcap/pcap_linux_layer.cc
View file @ 57565dc1
......@@ -36,13 +36,13 @@ 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;
std::string nic;
loggers::get_instance().log(">>> pcap_layer::pcap_layer: %s, %s", to_string().c_str(), param.c_str());
loggers::get_instance().log(">>> pcap_layer::pcap_layer: '%s', %s", to_string().c_str(), param.c_str());
// Setup parameters
params::convert(_params, param);
// Prepare capture processing
......@@ -69,7 +69,7 @@ pcap_layer::pcap_layer(const std::string &p_type, const std::string &param)
} // else, continue
// Set non-blocking flag for the polling procedure
if (pcap_setnonblock(_device, 1, error_buffer) != 0) {
loggers::get_instance().error("pcap_layer::pcap_layer: Failed to set blocking mode: %s", error_buffer);
loggers::get_instance().error("pcap_layer::pcap_layer: Failed to set blocking mode: '%s'", error_buffer);
}
// Retrieve the device file handler
_pcap_h = pcap_get_selectable_fd(_device);
......@@ -125,7 +125,7 @@ pcap_layer::pcap_layer(const std::string &p_type, const std::string &param)
filter += std::string(" ") + it->second;
}
// Log final PCAP filter
loggers::get_instance().user("pcap_layer::pcap_layer: Filter: %s", filter.c_str());
loggers::get_instance().user("pcap_layer::pcap_layer: Filter: '%s'", filter.c_str());
{
struct bpf_program f = {0};
......@@ -155,7 +155,7 @@ void pcap_layer::send_data(OCTETSTRING &data, params &params) {
loggers::get_instance().log_msg(">>> pcap_layer::send_data: ", data);
if (pcap_sendpacket(_device, static_cast<const unsigned char *>(data), data.lengthof()) == -1) {
loggers::get_instance().error("pcap_layer::send_data: Failed to send packet: %s", pcap_geterr(_device));
loggers::get_instance().error("pcap_layer::send_data: Failed to send packet: '%s'", pcap_geterr(_device));
}
}
......
ccsrc/Protocols/Pcap/pcap_linux_layer.hh
View file @ 57565dc1
......@@ -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
*/
......
ccsrc/Protocols/Pcap/pcap_offline_layer.cc
View file @ 57565dc1
......@@ -31,9 +31,9 @@ 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());
loggers::get_instance().log(">>> pcap_offline_layer::pcap_offline_layer: '%s', %s", p_type.c_str(), param.c_str());
params::convert(_params, param);
_o_params.insert(std::pair<std::string, std::string>(std::string("timestamp"), std::string()));
......@@ -49,16 +49,16 @@ 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());
loggers::get_instance().user("pcap_offline_layer::pcap_offline_layer: Filter: '%s'", filter.c_str());
struct bpf_program f = {0};
if (pcap_compile(_device, &f, filter.c_str(), 1, PCAP_NETMASK_UNKNOWN) != 0) {
loggers::get_instance().error("pcap_offline_layer::pcap_offline_layer: Failed to compile PCAP filter");
......@@ -72,7 +72,7 @@ pcap_offline_layer::pcap_offline_layer(const std::string &p_type, const std::str
// create pipe and run thread
if (pipe2(_fd, O_NONBLOCK) == -1) {
loggers::get_instance().error("pcap_offline_layer::pcap_offline_layer: Failed to create a pipe: %s", ::strerror(errno));
loggers::get_instance().error("pcap_offline_layer::pcap_offline_layer: Failed to create a pipe: '%s'", ::strerror(errno));
}
// Pass the pipe handler to the polling procedure
loggers::get_instance().log("pcap_offline_layer::pcap_offline_layer: Call handler with descriptor %d", _fd[0]);
......
ccsrc/Protocols/Pcap/pcap_offline_layer.hh
View file @ 57565dc1
......@@ -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
*/
......
ccsrc/Protocols/Pcap/pcap_offline_layer_factory.hh
View file @ 57565dc1
......@@ -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
ccsrc/Protocols/Tcp/tcp_layer.cc
View file @ 57565dc1
......@@ -8,16 +8,16 @@
#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} {
loggers::get_instance().log(">>> tcp_layer::tcp_layer (1): %s, %s", to_string().c_str(), param.c_str());
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);
_params.log();
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} {
loggers::get_instance().log(">>> tcp_layer::tcp_layer (2): %s", to_string().c_str());
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;
......@@ -37,6 +37,8 @@ void tcp_layer::init() {
it = _params.find(std::string("tcp_fragmented"));
if (it == _params.cend()) {
_params.insert(std::pair<std::string, std::string>(std::string("tcp_fragmented"), "0"));
} else {
_params.insert(std::pair<std::string, std::string>(std::string("tcp_fragmented"), "1"));
}
bool server_mode = false;
it = _params.find(params::server_mode);
......@@ -49,8 +51,8 @@ void tcp_layer::init() {
if (it == _params.cend()) {
_params.insert(std::pair<std::string, std::string>(std::string("server"), "127.0.0.1")); // TODO Try using params::server instead of std::string("server")
}
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());
if (!parameter_set(remote_address_name(), _params[params::server].c_str())) {
loggers::get_instance().warning("tcp_layer::set_parameter: Unprocessed parameter: 'remote_address_name()'");
}
bool ssl_mode = false;
it = _params.find(params::use_ssl);
......@@ -70,7 +72,7 @@ void tcp_layer::init() {
}
}
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());
loggers::get_instance().warning("tcp_layer::set_parameter: Unprocessed parameter: '%s'", params::port.c_str());
}
it = _params.find(params::local_port);
if (it == _params.cend()) {
......@@ -81,16 +83,25 @@ void tcp_layer::init() {
}
}
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());
loggers::get_instance().warning("tcp_layer::set_parameter: Unprocessed parameter: '%s'", params::local_port.c_str());
}
it = _params.find(params::local_server);
if (it == _params.cend()) {
_params.insert(std::pair<std::string, std::string>(std::string("local_server"), "0.0.0.0"));
}
if (!parameter_set(local_address_name(), _params[params::local_server].c_str())) {
loggers::get_instance().warning("tcp_layer::set_parameter: Unprocessed parameter: '%s'", params::local_server.c_str());
}
parameter_set(use_connection_ASPs_name(), (!server_mode) ? "yes" : "no");
loggers::get_instance().warning("tcp_layer::set_parameter: Limit to one simultanneous accepted connection (server_backlog == 1");
loggers::get_instance().warning("tcp_layer::set_parameter: Limit to one simultanneous accepted connection (server_backlog == 1)");
parameter_set(server_backlog_name(), "1"); // Limit to one simultanneous accepted connection
loggers::get_instance().log("tcp_layer::init: server_mode=%x", server_mode);
set_server_mode(server_mode);
if (server_mode) {
parameter_set("serverPort", _params[params::local_port].c_str());
if (server_mode) { // Apply default values or specified ones
parameter_set(local_port_name(), _params[params::local_port].c_str());
parameter_set(local_address_name(), _params[params::local_server].c_str());
}
if (ssl_mode) { // Add certificate bundle
// Check mutual authentication param
......@@ -108,20 +119,26 @@ void tcp_layer::init() {
if (it != _params.cend()) {
parameter_set(ssl_trustedCAlist_file_name(), it->second.c_str());
} else {
parameter_set(ssl_trustedCAlist_file_name(), "/home/yann/var/ssl/archive/yanngarcia.ddns.net/fullchain1.pem");
// Use Let's Encrypt to generate your certificates
// https://manpages.ubuntu.com/manpages/impish/en/man1/certbot.1.html
loggers::get_instance().error("tcp_layer::set_parameter: Trusted CA list is required for TLS");
}
// Set additional certificates
it = _params.find(params::privkey);
if (it != _params.cend()) {
parameter_set(ssl_private_key_file_name(), it->second.c_str());
} else {
parameter_set(ssl_private_key_file_name(), "/home/yann/var/ssl/archive/yanngarcia.ddns.net/privkey1.pem");
// Use Let's Encrypt to generate your certificates
// https://manpages.ubuntu.com/manpages/impish/en/man1/certbot.1.html
loggers::get_instance().error("tcp_layer::set_parameter: Certificate private key is required for TLS");
}
it = _params.find(params::certificate);
if (it != _params.cend()) {
parameter_set(ssl_certificate_file_name(), it->second.c_str());
} else {
parameter_set(ssl_certificate_file_name(), "/home/yann/var/ssl/archive/yanngarcia.ddns.net/fullchain1.pem");
// Use Let's Encrypt to generate your certificates
// https://manpages.ubuntu.com/manpages/impish/en/man1/certbot.1.html
loggers::get_instance().error("tcp_layer::set_parameter: Certificate is required for TLS");
}
}
set_ttcn_buffer_usercontrol(false);
......@@ -132,7 +149,7 @@ void tcp_layer::init() {
parameter_set(client_TCP_reconnect_name(), "yes");
if (server_mode == 0) {
loggers::get_instance().log("tcp_layer::init: Establish connection: %s/%s", _params[params::server].c_str(), _params[params::port].c_str());
loggers::get_instance().log("tcp_layer::init: 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);
}
}
......@@ -164,12 +181,12 @@ 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: 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());
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);
......@@ -193,6 +210,10 @@ void tcp_layer::message_incoming(const unsigned char* message_buffer, int length
std::string("timestamp"),
std::to_string(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count())));
this->receive_data(data, params); // TODO Check execution time for decoding operation
params::const_iterator it = params.find(std::string("Buffurizing"));
if (it != params.end()) {
loggers::get_instance().log("tcp_layer::message_incoming: Buffurizing requested");
}
loggers::get_instance().set_stop_time(_time_key, duration);
}
......@@ -251,7 +272,7 @@ 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
sleep(4); // 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);
}
......
ccsrc/Protocols/Tcp/tcp_layer.hh
View file @ 57565dc1
......@@ -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
......
ccsrc/Protocols/Tcp/tcp_layer_factory.hh
View file @ 57565dc1
......@@ -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
ccsrc/Protocols/UDP/udp_layer.cc
View file @ 57565dc1
......@@ -11,10 +11,10 @@
#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);
loggers::get_instance().log(">>> udp_layer::udp_layer (1): '%s', %s, %p", to_string().c_str(), param.c_str(), (void*)this);
// Setup parameters
params::convert(_params, param);
......@@ -22,10 +22,10 @@ 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());
loggers::get_instance().log(">>> udp_layer::udp_layer (2): '%s'", to_string().c_str());
// Setup parameters
_params = param;
......@@ -148,7 +148,7 @@ void udp_layer::Handle_Fd_Event_Readable(int fd) {
std::copy((unsigned char *)buffer, (unsigned char *)((unsigned char *)buffer + result), std::back_inserter(acc));
if (_reuse_incoming_source_adddress) { // Reuse the incoming address/port for sending
memcpy((void *)&_daddr, (const void *)&from, sizeof(struct sockaddr_in));
loggers::get_instance().log("udp_layer::Handle_Fd_Event_Readable: New _daddr: %s:%d", ::inet_ntoa(_daddr.sin_addr), ntohs(_daddr.sin_port));
loggers::get_instance().log("udp_layer::Handle_Fd_Event_Readable: New _daddr: '%s':%d", ::inet_ntoa(_daddr.sin_addr), ntohs(_daddr.sin_port));
}
}
params.insert(std::pair<std::string, std::string>(
......@@ -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()) {
......@@ -182,13 +182,13 @@ unsigned long udp_layer::get_host_id(const std::string &p_host_name) {
struct hostent *hptr;
if ((hptr = ::gethostbyname(p_host_name.c_str())) == 0) {
close();
loggers::get_instance().error("udp_layer::get_host_id: Invalid host name: %s", p_host_name.c_str());
loggers::get_instance().error("udp_layer::get_host_id: Invalid host name: '%s'", p_host_name.c_str());
}
ip_addr = *((unsigned long *)hptr->h_addr_list[0]);
}
}
loggers::get_instance().log("udp_layer::get_host_id: Host name: %s, Host address: %u", p_host_name.c_str(), ip_addr);
loggers::get_instance().log("udp_layer::get_host_id: Host name: '%s', Host address: %u", p_host_name.c_str(), ip_addr);
return htonl(ip_addr);
}
......
ccsrc/Protocols/UDP/udp_layer.hh
View file @ 57565dc1
......@@ -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