Commit efce1fbd authored by YannGarcia's avatar YannGarcia
Browse files

Add submodule for common TITAN framework; Re-organize ATSs

parent 13e13a57

ccsrc/Helpers/helpers_externals.cc

0 → 100644
+46 −0
Original line number Diff line number Diff line 
#include "LibHelpers_Functions.hh"

#include <math.h>



#include "base_time.hh"

#include "loggers.hh"



#ifndef M_PI

#define M_PI 3.14159265358979323846

#endif

#define earthRadius 6378137.0L

#define rbis = ((double)(earthRadius * M_PI / 180))



namespace LibHelpers__Functions {



  /**

   * @desc    This external function gets the current time since 01/01/1970 in UTC format

   * @return  The current time since 01/01/1970 in UTC format in milliseconds

   * @see     fx_getCurrentTimeUtc() return UInt64

   */

  INTEGER fx__getCurrentTimeUtc() {

    INTEGER i;

    i.set_long_long_val(base_time::get_instance().get_current_time_ms());

    loggers::get_instance().log_msg("<<< fx__getCurrentTimeUtc: ", i);

    return i;

  }

  /**

   * @desc    Gets the Minute of current UTC year

   * @return  MinuteOfTheYear - tenths of a second in the current or next hour in units of 1/10th second from UTC time

   * @see     function f_getMinuteOfTheYear() return MinuteOfTheYear

   */

  INTEGER fx__getMinuteOfTheYear() {

    //	TODO: this is just a sceleton. fill in the function

    return 0;

  }



  /**

   * @desc    Gets the milliseconds point in the current UTC minute

   * @return  DSecond - The milliseconds point in the current UTC minute (0..60000)

   * @see     function f_getDSecond() return DSecond

   */

  INTEGER fx__getDSecond() {

    //	TODO: this is just a sceleton. fill in the function

    return 0;

  }



} // namespace LibHelpers__Functions

ccsrc/Helpers/module.mk

+2 −0
Original line number Diff line number Diff line 
sources := helpers_externals.cc

includes := .

ccsrc/Protocols/Http/http_codec.cc

+28 −132
Original line number Diff line number Diff line
@@ -8,11 +8,10 @@ 


#include "loggers.hh"



#include "LibHttp_MessageBodyTypes.hh"

#include "LibHttp_TypesAndValues.hh"

#include "LibHttp_MessageBodyTypes.hh"

#include "LibHttp_XmlMessageBodyTypes.hh"



#include "http_etsi_ieee1609dot2_codec.hh"

#include "LibHttp_JsonMessageBodyTypes.hh"



int http_codec::encode(const LibHttp__TypesAndValues::HttpMessage &msg, OCTETSTRING &data) {

  loggers::get_instance().log_msg(">>> http_codec::encode: ", (const Base_Type &)msg);
@@ -422,61 +421,26 @@ int http_codec::encode_body(const LibHttp__MessageBodyTypes::HttpMessageBody &p_ 
    if (binary_body.ischosen(LibHttp__BinaryMessageBodyTypes::BinaryBody::ALT_raw)) {

      p_encoding_buffer = OCTETSTRING(binary_body.raw().lengthof(), (unsigned char *)static_cast<const unsigned char *>(binary_body.raw()));

    } else {

      std::map<std::string, std::unique_ptr<codec_gen<Record_Type, Record_Type>>>::const_iterator it;

      bool                                                                                    processed = false;

      if (p_content_type.find("x-its") != std::string::npos) {

        loggers::get_instance().log("http_codec::encode_body: Find x-its");

        it = _codecs.find("http_its"); // TODO Use params

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

          loggers::get_instance().log("http_codec::encode_body: Call '%s'", it->first.c_str());

          if (binary_body.ischosen(LibHttp__BinaryMessageBodyTypes::BinaryBody::ALT_ieee1609dot2__data)) {

            _codecs["http_its"]->encode((Record_Type &)binary_body.ieee1609dot2__data(), p_encoding_buffer); // TODO Use params

            processed = true;

          } else if (binary_body.ischosen(LibHttp__BinaryMessageBodyTypes::BinaryBody::ALT_ieee1609dot2__certificate)) {

            _codecs["http_its"]->encode((Record_Type &)binary_body.ieee1609dot2__certificate(), p_encoding_buffer); // TODO Use params

            processed = true;

          } else {

            loggers::get_instance().warning("http_codec::encode_body: Unsupported variant");

          }

        }

      } // TODO Add new HTTP message codec here

      if (!processed) {

        loggers::get_instance().warning("http_codec::encode_body: Unsupported HTTP codec, use raw field as default");

        p_encoding_buffer = OCTETSTRING(0, nullptr);

      encode_body_binary(binary_body, p_encoding_buffer, p_content_type);

    }

  } else if (p_message_body.ischosen(LibHttp__MessageBodyTypes::HttpMessageBody::ALT_json__body)) {

    const LibHttp__JsonMessageBodyTypes::JsonBody& json_body = p_message_body.json__body();

    if (json_body.ischosen(LibHttp__JsonMessageBodyTypes::JsonBody::ALT_raw)) {

      p_encoding_buffer = unichar2oct(json_body.raw());

    } else {

      encode_body_json(json_body, p_encoding_buffer, p_content_type);

    }

  } else if (p_message_body.ischosen(LibHttp__MessageBodyTypes::HttpMessageBody::ALT_html__body)) {

    p_encoding_buffer = OCTETSTRING(p_message_body.html__body().lengthof(), (unsigned char *)static_cast<const char *>(p_message_body.html__body()));

  } else if (p_message_body.ischosen(LibHttp__MessageBodyTypes::HttpMessageBody::ALT_text__body)) {

    p_encoding_buffer = OCTETSTRING(p_message_body.text__body().lengthof(), (unsigned char *)static_cast<const char *>(p_message_body.text__body()));

  } else if (p_message_body.ischosen(LibHttp__MessageBodyTypes::HttpMessageBody::ALT_xml__body)) {

    const LibHttp__XmlMessageBodyTypes::XmlBody &xml_body = p_message_body.xml__body();

    if (xml_body.ischosen(LibHttp__XmlMessageBodyTypes::XmlBody::ALT_raw)) {

      p_encoding_buffer = OCTETSTRING(xml_body.raw().lengthof(), (unsigned char *)static_cast<const char *>(xml_body.raw()));

    } else {

      std::map<std::string, std::unique_ptr<codec_gen<Record_Type, Record_Type>>>::const_iterator it;

      bool                                                                                    processed = false;

      loggers::get_instance().log("http_codec::encode_body: Content-Type:'%s'", p_content_type.c_str());

      if (p_content_type.find("held") != std::string::npos) {

        it = _codecs.find("held"); // TODO Use params

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

          loggers::get_instance().log("http_codec::encode_body: Call 'held_codec'");

          _codecs["held"]->encode((Record_Type &)xml_body, p_encoding_buffer); // TODO Use params

          processed = true;

        }

      } else if (p_content_type.find("lost") != std::string::npos) {

        it = _codecs.find("lost"); // TODO Use params

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

          loggers::get_instance().log("http_codec::encode_body: Call 'lost_codec'");

          _codecs["lost"]->encode((Record_Type &)xml_body, p_encoding_buffer); // TODO Use params

          processed = true;

        }

      } // TODO Add new HTTP message codec here

      if (!processed) {

        loggers::get_instance().warning("http_codec::encode_body: Unsupported HTTP codec, use raw field as default");

        p_encoding_buffer = OCTETSTRING(0, nullptr);

      }

      encode_body_xml(xml_body, p_encoding_buffer, p_content_type);

    }

  } else if (p_message_body.ischosen(LibHttp__MessageBodyTypes::HttpMessageBody::ALT_html__body)) {

    p_encoding_buffer = OCTETSTRING(p_message_body.html__body().lengthof(), (unsigned char *)static_cast<const char *>(p_message_body.html__body()));

  } else if (p_message_body.ischosen(LibHttp__MessageBodyTypes::HttpMessageBody::ALT_text__body)) {

    p_encoding_buffer = OCTETSTRING(p_message_body.text__body().lengthof(), (unsigned char *)static_cast<const char *>(p_message_body.text__body()));

  } else {

    loggers::get_instance().warning("http_codec::encode_body: Failed to encode HTTP message body");

    return -1;
@@ -589,45 +553,8 @@ int http_codec::decode_body(TTCN_Buffer &decoding_buffer, LibHttp__MessageBodyTy 
  LibHttp__MessageBodyTypes::HttpMessageBody v;

  if (_dc.is_binary == 0x01) {

    LibHttp__BinaryMessageBodyTypes::BinaryBody                                          binary_body;

    std::map<std::string, std::unique_ptr<codec_gen<Record_Type, Record_Type>>>::const_iterator it;

    bool                                                                                    processed = false;

    // TODO To be refined adding a string identifier to check which codec to use. E.g. held_code.id() returns "xmlns=\"urn:ietf:params:xml:ns:geopriv:held\">"

    if ((p_content_type.find("x-its") != std::string::npos) || (p_content_type.find("application/octet-stream") != std::string::npos)) {

      loggers::get_instance().log("http_codec::decode_body: Find 'x-its'");

      it = _codecs.cbegin(); //_codecs.find("http_its");

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

        /***

            FIXME:

            This code generate a codedump, I don't undertsand the reason.

            The same code works file for Ng112 HELD & LOST codec. Ununderstandable!!!!

            ==> Use a patch

            if (_codecs["http_its"].get() != nullptr) {

            loggers::get_instance().log("http_codec::decode_body: Call 'http_etsi_ieee1609dot2_codec'");

            if (_codecs["http_its"]->decode(body, (Record_Type&)binary_body) == 0) {

            processed = true;

            }

            }*/

        loggers::get_instance().log("http_codec::decode_body: Call '%s'", it->first.c_str());

        http_etsi_ieee1609dot2_codec *codec = new http_etsi_ieee1609dot2_codec();

        if (body[0].get_octet() != 0x80) {

          if (codec->decode(body, binary_body.ieee1609dot2__data()) == 0) {

            message_body.binary__body() = binary_body;

            processed                   = true;

          }

        } else {

          if (codec->decode(body, binary_body.ieee1609dot2__certificate()) == 0) {

            message_body.binary__body() = binary_body;

            processed                   = true;

          }

        }

        delete codec;

      }

    } // TODO Add new HTTP message codec here

    if (!processed) {

      loggers::get_instance().warning("http_codec::decode_body: Unsupported HTTP codec, use raw field as default");

      binary_body.raw()           = body;

    decode_body_binary(body, binary_body, p_content_type);

    message_body.binary__body() = binary_body;

    }

  } else {

    // Convert into string

    params p;
@@ -637,51 +564,20 @@ int http_codec::decode_body(TTCN_Buffer &decoding_buffer, LibHttp__MessageBodyTy 
    if (p["decode_str"].find("<?xml version=") != std::string::npos) {

      loggers::get_instance().log("http_codec::decode_body: Find xml message");

      LibHttp__XmlMessageBodyTypes::XmlBody xml_body;

      // TODO To be refined adding a string identifier to check which codec to use. E.g. held_code.id() returns "xmlns=\"urn:ietf:params:xml:ns:geopriv:held\">"

      if ((p["decode_str"].find("=\"urn:ietf:params:xml:ns:geopriv:held\"") != std::string::npos) ||

          (p["decode_str"].find("=\"urn:ietf:params:xml:ns:pidf\"") != std::string::npos)) {

        loggers::get_instance().log("http_codec::decode_body: Find 'urn:ietf:params:xml:ns:geopriv:held'");

        if (_codecs["held"].get() != nullptr) {

          loggers::get_instance().log("http_codec::decode_body: Call 'held_codec'");

          if (_codecs["held"]->decode(body, (Record_Type &)xml_body, &p) == -1) {

            loggers::get_instance().warning("http_codec::decode_body: Failed to decode HELD message");

            xml_body.raw() = CHARSTRING(body.lengthof(), (char *)static_cast<const unsigned char *>(body));

          } else {

            loggers::get_instance().log_msg("http_codec::decode_body: Decoded message:", xml_body);

            message_body.xml__body() = xml_body;

          }

        } else {

          loggers::get_instance().warning("http_codec::decode_body: No codec for HELD");

          xml_body.raw() = CHARSTRING(body.lengthof(), (char *)static_cast<const unsigned char *>(body));

        }

        message_body.xml__body() = xml_body;

      } else if (p["decode_str"].find("=\"urn:ietf:params:xml:ns:lost1\"") != std::string::npos) {

        loggers::get_instance().log("http_codec::decode_body: Find 'urn:ietf:params:xml:ns:lost1'");

        if (_codecs["lost"].get() != nullptr) {

          loggers::get_instance().log("http_codec::decode_body: Call 'lost_codec'");

          if (_codecs["lost"]->decode(body, (Record_Type &)xml_body, &p) == -1) {

            loggers::get_instance().warning("http_codec::decode_body: Failed to decode LOST message");

            xml_body.raw() = CHARSTRING(body.lengthof(), (char *)static_cast<const unsigned char *>(body));

          } else {

            loggers::get_instance().log_msg("http_codec::decode_body: Decoded message:", xml_body);

            message_body.xml__body() = xml_body;

          }

        } else {

          loggers::get_instance().warning("http_codec::decode_body: No codec for LOST");

          xml_body.raw() = CHARSTRING(body.lengthof(), (char *)static_cast<const unsigned char *>(body));

        }

      decode_body_xml(body, xml_body, p_content_type, &p);

      message_body.xml__body() = xml_body;

      } else {

        loggers::get_instance().warning("http_codec::decode_body: No XML codec found");

        xml_body.raw()           = CHARSTRING(body.lengthof(), (char *)static_cast<const unsigned char *>(body));

        message_body.xml__body() = xml_body;

      }

    } else if (p["decode_str"].find("<html>") != std::string::npos) { // Try to identify HTML

      loggers::get_instance().log("http_codec::decode_body: Find html message");

      LibHttp__MessageBodyTypes::HtmlBody html_body;

      message_body.html__body() = CHARSTRING(body.lengthof(), (char *)static_cast<const unsigned char *>(body));

      decode_body_html(body, html_body, p_content_type, &p);

      message_body.html__body() = html_body;

    } else if (p_content_type.find("json") != std::string::npos) { // Try to identify JSON

      loggers::get_instance().log("http_codec::decode_body: Find json message");

      LibHttp__JsonMessageBodyTypes::JsonBody json_body;

      decode_body_json(body, json_body, p_content_type, &p);

      message_body.json__body() = json_body;

    } else {

      loggers::get_instance().log("http_codec::decode_body: Use textBdy as default");

      loggers::get_instance().log("http_codec::decode_body: Use textBody as default");

      LibHttp__MessageBodyTypes::TextBody text_body;

      message_body.text__body() = CHARSTRING(body.lengthof(), (char *)static_cast<const unsigned char *>(body));

    }

ccsrc/Protocols/Http/http_codec.hh

+25 −1
Original line number Diff line number Diff line
@@ -19,7 +19,16 @@ namespace LibHttp__TypesAndValues { 
} // namespace LibHttp__TypesAndValues

namespace LibHttp__MessageBodyTypes {

  class HttpMessageBody;

}

} // namespace LibHttp__MessageBodyTypes

namespace LibHttp__BinaryMessageBodyTypes {

  class BinaryBody;

} // namespace LibHttp__BinaryMessageBodyTypes

namespace LibHttp__XmlMessageBodyTypes {

  class XmlBody;

} // namespace LibHttp__XmlMessageBodyTypes

namespace LibHttp__JsonMessageBodyTypes {

  class JsonBody;

} // namespace LibHttp__JsonMessageBodyTypes



struct encoding_context {

  unsigned int  length;
@@ -48,6 +57,8 @@ struct decoding_context { 
class http_codec : public codec_gen<LibHttp__TypesAndValues::HttpMessage, LibHttp__TypesAndValues::HttpMessage> {

  encoding_context                                                        _ec;

  decoding_context                                                        _dc;



protected:

  std::map<std::string, std::unique_ptr<codec_gen<Record_Type, Record_Type>>> _codecs;



public:
@@ -59,6 +70,19 @@ public: 


  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_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) {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);

ccsrc/Protocols/Http/http_layer.cc

+22 −12
Original line number Diff line number Diff line
@@ -12,20 +12,12 @@ using namespace std; // Required for isnan() 
#include "LibHttp_TypesAndValues.hh"



http_layer::http_layer(const std::string &p_type, const std::string &param)

  : t_layer<LibHttp__TestSystem::HttpPort>(p_type), _params(), _device_mode{false} {

  : 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

  params::convert(_params, param);



  params::const_iterator it = _params.find(params::codecs);

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

    _codec.set_payload_codecs(it->second);

  }

  // it = _params.find(params::device_mode);

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

  //   _device_mode = (1 == converter::get_instance().string_to_int(it->second));

  // }

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

  params::const_iterator it = _params.find(params::method);

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

    _params[params::method] = "POST";

  }
@@ -43,12 +35,30 @@ http_layer::http_layer(const std::string &p_type, const std::string &param) 
  }

}



bool http_layer::set_codec(http_codec *p_codec) { 

  loggers::get_instance().log(">>> http_layer::set_codec: %p", (void*)p_codec);



  // Sanity check that

  if (p_codec == nullptr) { 

    loggers::get_instance().error("http_layer::set_codec: Wrong parameter");

    return false;

  }



  _codec = p_codec;

  params::const_iterator it = _params.find(params::codecs);

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

    _codec->set_payload_codecs(it->second);

  }



  return true;

}



void http_layer::sendMsg(const LibHttp__TypesAndValues::HttpMessage &p_http_message, params &p_param) {

  loggers::get_instance().log_msg(">>> http_layer::sendMsg: ", p_http_message);



  // Encode HttpMessage

  OCTETSTRING data;

  _codec.encode(p_http_message, data);

  _codec->encode(p_http_message, data);

  send_data(data, _params);

}
@@ -85,7 +95,7 @@ void http_layer::receive_data(OCTETSTRING &data, params &params) { 


  // Decode HTTP message

  LibHttp__TypesAndValues::HttpMessage http_message;

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

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

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

    return;

  }