Commit 538e2713 authored by garciay's avatar garciay
Browse files

Enhance SIP codec

parent f010f4cf

ccsrc/Protocols/Http/http_codec.cc

+623 −560
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@ 
int http_codec::encode (const LibItsHttp__TypesAndValues::HttpMessage& msg, OCTETSTRING& data)

{

  loggers::get_instance().log_msg(">>> http_codec::encode: ", (const Base_Type&)msg);

  loggers::get_instance().log(">>> http_codec::encode: %p", this);



  TTCN_EncDec::clear_error();

  TTCN_Buffer encoding_buffer;
@@ -125,26 +126,6 @@ int http_codec::encode_request(const LibItsHttp__TypesAndValues::Request& p_requ 
{

  loggers::get_instance().log_msg(">>> http_codec::encode_request: ", (const Base_Type&)p_request);

  

  const OPTIONAL<LibItsHttp__MessageBodyTypes::HttpMessageBody>& v = p_request.body();

  OCTETSTRING os;

  if (v.ispresent()) {

    const LibItsHttp__MessageBodyTypes::HttpMessageBody& body = static_cast<const LibItsHttp__MessageBodyTypes::HttpMessageBody&>(*v.get_opt_value());

    loggers::get_instance().log_msg("http_codec::encode_request: body: ", body);

    if (encode_body(body, os) == -1) {

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

      _ec.length = 0;

      _ec.is_content_length_present = 0x00;

    } else {

      _ec.length = os.lengthof();

      _ec.is_content_length_present = 0x01;

    }

    loggers::get_instance().log("http_codec::encode_request: length=%d", _ec.length);

  } else {

    loggers::get_instance().log("http_codec::encode_request: HTTP body field not present");

    _ec.length = 0;

    _ec.is_content_length_present = 0x00;

  }



  // Encode generic part

  p_encoding_buffer.put_cs(p_request.method());

  p_encoding_buffer.put_c(' ');
@@ -154,35 +135,36 @@ int http_codec::encode_request(const LibItsHttp__TypesAndValues::Request& p_requ 
  p_encoding_buffer.put_c('.');

  p_encoding_buffer.put_cs(int2str(p_request.version__minor()));

  p_encoding_buffer.put_cs("\r\n");

  // Encode headers

  

  // Encode headers excepeted the Content-length

  const LibItsHttp__TypesAndValues::HeaderLines& headers = p_request.header();

  std::string content_type;

  for (int i = 0; i < headers.size_of(); i++) {

    const LibItsHttp__TypesAndValues::HeaderLine& header = headers[i];

    loggers::get_instance().log_msg("http_codec::encode_request: Processing header ", header.header__name());

    p_encoding_buffer.put_cs(header.header__name());

    p_encoding_buffer.put_cs(": ");

    if (std::string(static_cast<const char*>(header.header__name())).compare("Content-length") == 0) {

      if (_ec.length != 0) {

        p_encoding_buffer.put_cs(int2str(_ec.length + 2/*Stand for the last CRLF*/));

        _ec.is_content_length_present = 0x01;

      } else {

        p_encoding_buffer.put_cs("0");

        _ec.is_content_length_present = 0x00;

      }

      loggers::get_instance().log("http_codec::encode_request: Content-length: %d - %x", _ec.length, _ec.is_content_length_present);

    if (std::string(static_cast<const char*>(header.header__name())).compare("Content-length") == 0) { // Skip it, processed later

      continue;

    } else {

      const OPTIONAL<LibItsHttp__TypesAndValues::charstring__list>& o = header.header__value();

      if (o.ispresent()) {

        const LibItsHttp__TypesAndValues::charstring__list& v = dynamic_cast<const OPTIONAL<LibItsHttp__TypesAndValues::charstring__list> &>(o);

        if (v.size_of() > 0) {

          loggers::get_instance().log_msg("http_codec::encode_request: Processing value ", v[0]);

          if (std::string(static_cast<const char*>(header.header__name())).compare("Content-type") == 0) { // Store it for HTTP body payload encoding

            loggers::get_instance().log("http_codec::encode_request: Storing Content-type");

            int j = 0;

            while (j < v.size_of()) {

              content_type += v[j++];

            } // End of 'while' statement

          }

          p_encoding_buffer.put_cs(v[0]);

          int j = 1;

          while (j < v.size_of()) {

            p_encoding_buffer.put_cs(", ");

            loggers::get_instance().log_msg("http_codec::encode_request: Processing value ", v[j]);

                p_encoding_buffer.put_cs(v[j]);

                j += 1;

            p_encoding_buffer.put_cs(v[j++]);

          } // End of 'while' statement

        }

      } // else, do not include it
@@ -190,6 +172,38 @@ int http_codec::encode_request(const LibItsHttp__TypesAndValues::Request& p_requ 
    p_encoding_buffer.put_cs("\r\n");

  } // End of 'for' statement

  

  // Encode message body

  const OPTIONAL<LibItsHttp__MessageBodyTypes::HttpMessageBody>& v = p_request.body();

  OCTETSTRING os;

  if (v.ispresent()) {

    const LibItsHttp__MessageBodyTypes::HttpMessageBody& body = static_cast<const LibItsHttp__MessageBodyTypes::HttpMessageBody&>(*v.get_opt_value());

    loggers::get_instance().log_msg("http_codec::encode_request: body: ", body);

    if (encode_body(body, os, content_type) == -1) {

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

      _ec.length = 0;

      _ec.is_content_length_present = 0x00;

    } else {

      _ec.length = os.lengthof();

      _ec.is_content_length_present = 0x01;

    }

    loggers::get_instance().log("http_codec::encode_request: length=%d", _ec.length);

  } else {

    loggers::get_instance().log("http_codec::encode_request: HTTP body field not present");

    _ec.length = 0;

    _ec.is_content_length_present = 0x00;

  }



  // Encode Content-length header

  if (_ec.length != 0) {

    p_encoding_buffer.put_cs(int2str(_ec.length + 2/*Stand for the last CRLF*/));

    _ec.is_content_length_present = 0x01;

  } else {

    p_encoding_buffer.put_cs("0");

    _ec.is_content_length_present = 0x00;

  }

  loggers::get_instance().log("http_codec::encode_request: Content-length: %d - %x", _ec.length, _ec.is_content_length_present);

  p_encoding_buffer.put_cs("\r\n");



  p_encoding_buffer.put_cs("\r\n");

  if (_ec.is_content_length_present == 0x01) {

    loggers::get_instance().log_msg("http_codec::encode_request: Add body ", os);
@@ -203,16 +217,6 @@ int http_codec::encode_request(const LibItsHttp__TypesAndValues::Request& p_requ 
int http_codec::encode_response (const LibItsHttp__TypesAndValues::Response& p_response, TTCN_Buffer& p_encoding_buffer) {

  loggers::get_instance().log_msg(">>> http_codec::encode_response: ", (const Base_Type&)p_response);



  const OPTIONAL<LibItsHttp__MessageBodyTypes::HttpMessageBody>& v = p_response.body();

  OCTETSTRING os;

  if (v.ispresent()) {

    const LibItsHttp__MessageBodyTypes::HttpMessageBody& body = static_cast<const LibItsHttp__MessageBodyTypes::HttpMessageBody&>(*v.get_opt_value());

    loggers::get_instance().log_msg("http_codec::encode_response: body: ", body);

    if (encode_body(body, os) == -1) {

      _ec.length = 0;

    }

  }



  // Encode generic part

  p_encoding_buffer.put_cs("HTTP/");

  p_encoding_buffer.put_cs(int2str(p_response.version__major()));
@@ -225,26 +229,29 @@ int http_codec::encode_response (const LibItsHttp__TypesAndValues::Response& p_r 
    p_encoding_buffer.put_cs(p_response.statustext());

  }

  p_encoding_buffer.put_cs("\r\n");

  // Encode headers

  

  // Encode headers excepeted the Content-length

  const LibItsHttp__TypesAndValues::HeaderLines& headers = p_response.header();

  std::string content_type;

  for (int i = 0; i < headers.size_of(); i++) {

    const LibItsHttp__TypesAndValues::HeaderLine& header = headers[i];

    loggers::get_instance().log_msg("http_codec::encode_response: Processing header ", header.header__name());

    p_encoding_buffer.put_cs(header.header__name());

    p_encoding_buffer.put_cs(": ");

    if (std::string(static_cast<const char*>(header.header__name())).compare("Content-Length") == 0) {

      if (_ec.length != 0) {

        p_encoding_buffer.put_cs(int2str(_ec.length + 2/*Stand for the last CRLF*/));

      } else {

        p_encoding_buffer.put_cs("0");

      }

      _ec.is_content_length_present = 0x01;

      continue;

    } else {

      const OPTIONAL<LibItsHttp__TypesAndValues::charstring__list>& o = header.header__value();

      if (o.ispresent()) {

        const LibItsHttp__TypesAndValues::charstring__list& v = dynamic_cast<const OPTIONAL<LibItsHttp__TypesAndValues::charstring__list> &>(o);

        if (v.size_of() > 0) {

          loggers::get_instance().log_msg("http_codec::encode_response: Processing value ", v[0]);

          if (std::string(static_cast<const char*>(header.header__name())).compare("Content-type") == 0) { // Store it for HTTP body payload encoding

            int j = 1;

            while (j < v.size_of()) {

              content_type += v[j++];

            } // End of 'while' statement

          }

          p_encoding_buffer.put_cs(v[0]);

          int j = 1;

          while (j < v.size_of()) {
@@ -259,6 +266,37 @@ int http_codec::encode_response (const LibItsHttp__TypesAndValues::Response& p_r 
    p_encoding_buffer.put_cs("\r\n");

  } // End of 'for' statement



  // Encode message body

  const OPTIONAL<LibItsHttp__MessageBodyTypes::HttpMessageBody>& v = p_response.body();

  OCTETSTRING os;

  if (v.ispresent()) {

    const LibItsHttp__MessageBodyTypes::HttpMessageBody& body = static_cast<const LibItsHttp__MessageBodyTypes::HttpMessageBody&>(*v.get_opt_value());

    loggers::get_instance().log_msg("http_codec::encode_response: body: ", body);

    if (encode_body(body, os, content_type) == -1) {

      _ec.length = 0;

      _ec.is_content_length_present = 0x00;

    } else {

      _ec.length = os.lengthof();

      _ec.is_content_length_present = 0x01;

    }

    loggers::get_instance().log("http_codec::encode_request: length=%d", _ec.length);

  } else {

    loggers::get_instance().log("http_codec::encode_request: HTTP body field not present");

    _ec.length = 0;

    _ec.is_content_length_present = 0x00;

  }



  // Encode Content-length header

  if (_ec.length != 0) {

    p_encoding_buffer.put_cs(int2str(_ec.length + 2/*Stand for the last CRLF*/));

    _ec.is_content_length_present = 0x01;

  } else {

    p_encoding_buffer.put_cs("0");

    _ec.is_content_length_present = 0x00;

  }

  loggers::get_instance().log("http_codec::encode_response: Content-length: %d - %x", _ec.length, _ec.is_content_length_present);

  p_encoding_buffer.put_cs("\r\n");

  

  p_encoding_buffer.put_cs("\r\n");

  if (_ec.length != 0) {

    p_encoding_buffer.put_os(os);
@@ -331,12 +369,37 @@ int http_codec::decode_header(CHARSTRING& header_line, LibItsHttp__TypesAndValue 
  }

}



int http_codec::encode_body(const LibItsHttp__MessageBodyTypes::HttpMessageBody& p_message_body, OCTETSTRING& p_encoding_buffer) {

int http_codec::encode_body(const LibItsHttp__MessageBodyTypes::HttpMessageBody& p_message_body, OCTETSTRING& p_encoding_buffer, const std::string& p_content_type) {

  loggers::get_instance().log_msg(">>> http_codec::encode_body: ", (const Base_Type&)p_message_body);

  loggers::get_instance().log("http_codec::encode_body: # of codecs=%d", _codecs.size());

  loggers::get_instance().log("http_codec::encode_body: # of codecs=%d - %p", _codecs.size(), this);

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



  // Sanity check

  if (p_content_type.empty()) {

    loggers::get_instance().warning("http_codec::encode_body: Failed to select a codec for  HTTP body payload");

    return -1;

  }



  if (p_message_body.ischosen(LibItsHttp__MessageBodyTypes::HttpMessageBody::ALT_binary__body)) {

    p_encoding_buffer = p_message_body.binary__body().raw();

    const LibItsHttp__BinaryMessageBodyTypes::BinaryBody& binary_body = p_message_body.binary__body();

    if (binary_body.ischosen(LibItsHttp__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<Record_Type, Record_Type> > >::const_iterator it;

      bool processed = false;

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

        it = _codecs.find("etsi_ieee1609dot2");

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

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

          _codecs["etsi_ieee1609dot2"]->encode((Record_Type&)binary_body, p_encoding_buffer);

          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(binary_body.raw().lengthof(), (unsigned char*)static_cast<const unsigned char*>(binary_body.raw()));

      }

    }

  } else if (p_message_body.ischosen(LibItsHttp__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(LibItsHttp__MessageBodyTypes::HttpMessageBody::ALT_text__body)) {
@@ -345,25 +408,27 @@ int http_codec::encode_body(const LibItsHttp__MessageBodyTypes::HttpMessageBody& 
    const LibItsHttp__XmlMessageBodyTypes::XmlBody& xml_body = p_message_body.xml__body();

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

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

    } else if (xml_body.ischosen(LibItsHttp__XmlMessageBodyTypes::XmlBody::ALT_findServiceRequest)) {

      std::map<std::string, std::unique_ptr<codec<Record_Type, Record_Type> > >::const_iterator it = _codecs.find("lost");

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

      } else {

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

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

        // TODO Add new HTTP message codec here

      }

    } else {

      std::map<std::string, std::unique_ptr<codec<Record_Type, Record_Type> > >::const_iterator it = _codecs.find("held");

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

      bool processed = false;

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

        it = _codecs.find("held");

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

      } else {

          processed = true;

        }

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

        it = _codecs.find("lost");

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

          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(xml_body.raw().lengthof(), (unsigned char*)static_cast<const char*>(xml_body.raw()));

        // TODO Add new HTTP message codec here

      }

    }

  } else {
@@ -439,11 +504,8 @@ int http_codec::decode_body(TTCN_Buffer& decoding_buffer, LibItsHttp__MessageBod 
       loggers::get_instance().log("http_codec::decode_body: Find xml message");

       LibItsHttp__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("xmlns=\"urn:ietf:params:xml:ns:geopriv:held\"") != std::string::npos) ||

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

           ) {

         loggers::get_instance().log("http_codec::decode_body: Identified Held'");

       if (p["decode_str"].find("xmlns=\"urn:ietf:params:xml:ns:geopriv:held\">") != 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) {
@@ -457,8 +519,9 @@ int http_codec::decode_body(TTCN_Buffer& decoding_buffer, LibItsHttp__MessageBod 
           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));

         }

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

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

         message_body.xml__body() = xml_body;

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

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

         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) {
@@ -472,11 +535,8 @@ int http_codec::decode_body(TTCN_Buffer& decoding_buffer, LibItsHttp__MessageBod 
           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));

         }

       } else {

         loggers::get_instance().warning("http_codec::decode_body: No 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");

      LibItsHttp__MessageBodyTypes::TextBody txt_body;
@@ -547,11 +607,14 @@ void http_codec::set_payload_codecs(const std::string& p_codecs) { 
      loggers::get_instance().log("http_codec::set_payload_codecs: %d - %s - %s - %s - %s - %s - %s - %s - %s", m.size(), m[1].str().c_str(), m[2].str().c_str(), m[3].str().c_str(), m[4].str().c_str(), m[5].str().c_str(), m[6].str().c_str(), m[7].str().c_str(), m[8].str().c_str());

      for (unsigned int j = 1; j < m.size() - 1; j += 3) { // Exclude m[0]

        loggers::get_instance().log("http_codec::set_payload_codecs: insert (%s, %s), j = %d", m[j].str().c_str(), m[j + 1].str().c_str(), j);

        if (m[j].str().empty()) {

          break;

        }

        std::string key(m[j].str());

        _codecs.insert(std::make_pair(key, std::unique_ptr<codec<Record_Type, Record_Type> >(codec_stack_builder::get_instance()->get_codec(m[j + 1].str().c_str()))));

      } // End of 'for' statement

    } // End of 'for' statement

    //loggers::get_instance().log("http_codec::set_payload_codecs: _codecs length=%d", _codecs.size());

    loggers::get_instance().log("http_codec::set_payload_codecs: _codecs length=%d - %p", _codecs.size(), this);

  }

  catch(const std::logic_error& e){

    loggers::get_instance().warning("http_codec::set_payload_codecs: std::logic_error: %s", e.what());

ccsrc/Protocols/Http/http_codec.hh

+66 −66
Original line number Diff line number Diff line
@@ -56,7 +56,7 @@ public: 
private:

  int encode_request (const LibItsHttp__TypesAndValues::Request& p_request, TTCN_Buffer& p_encoding_buffer);

  int encode_response (const LibItsHttp__TypesAndValues::Response& p_response, TTCN_Buffer& p_encoding_buffer);

  int encode_body(const LibItsHttp__MessageBodyTypes::HttpMessageBody& p_message_body, OCTETSTRING& p_encoding_buffer);

  int encode_body(const LibItsHttp__MessageBodyTypes::HttpMessageBody& p_message_body, OCTETSTRING& p_encoding_buffer, const std::string& p_content_type);



  int decode_headers(TTCN_Buffer& decoding_buffer, LibItsHttp__TypesAndValues::HeaderLines& headers);

  int decode_header(CHARSTRING& header_line, LibItsHttp__TypesAndValues::HeaderLine& header);

ccsrc/Protocols/Sip/sip_codec_request.cc

+142 −11

File changed.

Preview size limit exceeded, changes collapsed.

ccsrc/Protocols/Sip/sip_codec_request.hh

+2 −0
Original line number Diff line number Diff line
@@ -54,7 +54,9 @@ private: //! \todo Move this section into a sip_codec_helper class, need to deco 
  int encode_request_headers(const LibSip__SIPTypesAndValues::MessageHeader& p_msg_header, osip_message_t* p_sip_message);

  int encode_request_message_body(const LibSip__MessageBodyTypes::MessageBody& p_message_body, osip_message_t* p_sip_message);

  int encode_request_payload(const LibSip__SIPTypesAndValues::Payload& p_payload, osip_message_t* p_sip_message);

  int encode_accept_header(const LibSip__SIPTypesAndValues::Accept& p_accept, osip_accept_t* p_accept_header);

  int encode_authorization_header(const LibSip__SIPTypesAndValues::Authorization& p_authorization, osip_authorization_t** p_authorization_header);

  int encode_contact_header(const LibSip__SIPTypesAndValues::Contact& p_contact, osip_contact_t* p_contact_header);

  int encode_c_seq_header(const LibSip__SIPTypesAndValues::CSeq& p_c_seq, osip_cseq_t** p_c_seq_header);

  int encode_from_header(const LibSip__SIPTypesAndValues::From& p_from, osip_from_t** p_from_header);

  int encode_max_forwards_header(const  OPTIONAL<LibSip__SIPTypesAndValues::MaxForwards>& p_max_forwards, osip_message_t** p_sip_message);

etc/AtsNg112/AtsNg112.cfg

+12 −12
Original line number Diff line number Diff line
@@ -3,20 +3,20 @@ 


LibCommon_Time.PX_TAC := 30.0



#LibItsHttp_Pics.PICS_HEADER_HOST := "e4iutdpic5.execute-api.eu-central-1.amazonaws.com" # Used for LIS

LibItsHttp_Pics.PICS_HEADER_HOST := "6fsrcxrqm1.execute-api.eu-central-1.amazonaws.com" # Used for ECRF

LibItsHttp_Pics.PICS_HEADER_HOST := "e4iutdpic5.execute-api.eu-central-1.amazonaws.com" # Used for LIS

#LibItsHttp_Pics.PICS_HEADER_HOST := "6fsrcxrqm1.execute-api.eu-central-1.amazonaws.com" # Used for ECRF

#LibItsHttp_Pics.PICS_HEADER_HOST := "ptsv2.com"



#LibNg112_Pics.PICS_LIS_URI := "/Prod";

LibNg112_Pics.PICS_ECRF_URI := "/Prod";

LibNg112_Pics.PICS_LIS_URI := "/Prod";

#LibNg112_Pics.PICS_ECRF_URI := "/Prod";



#LibItsHttp_Pics.PICS_HEADER_CONTENT_TYPE := "application/held+xml;charset=utf-8";

LibItsHttp_Pics.PICS_HEADER_CONTENT_TYPE := "application/lost+xml;charset=utf-8";

LibItsHttp_Pics.PICS_HEADER_CONTENT_TYPE := "application/held+xml;charset=utf-8";

#LibItsHttp_Pics.PICS_HEADER_CONTENT_TYPE := "application/lost+xml;charset=utf-8";



#LibNg112_Pics.PICS_HTTP_GET_REQUEST := false



#LibNg112_Pixits.PX_DEVICE_URI_TEL := "<uri>+331234567890</uri>" # Position location

LibNg112_Pixits.PX_DEVICE_URI_TEL := "<uri>+331234567891</uri>" # Circle location

LibNg112_Pixits.PX_DEVICE_URI_TEL := "<uri>+331234567890</uri>" # Position location

#LibNg112_Pixits.PX_DEVICE_URI_TEL := "<uri>+331234567891</uri>" # Circle location

#LibNg112_Pixits.PX_DEVICE_URI_TEL := "<uri>+331234567892</uri>" # Civic location

LibNg112_Pixits.PX_DEVICE_NUMBER_POINT := { 43.616891, 7.053179 }

LibNg112_Pixits.PX_CIRCLE_POS := { 43.617174, 7.05275 }
@@ -40,9 +40,9 @@ LogEventTypes:= Yes 
# In this section you can specify parameters that are passed to Test Ports.



# LIS

#system.httpPort.params := "HTTP(codecs=lost:lost_codec;held:held_codec)/TCP(debug=1,server=e4iutdpic5.execute-api.eu-central-1.amazonaws.com,use_ssl=1)"

system.httpPort.params := "HTTP(codecs=lost:lost_codec;held:held_codec)/TCP(debug=1,server=e4iutdpic5.execute-api.eu-central-1.amazonaws.com,use_ssl=1)"

# ECRF

system.httpPort.params := "HTTP(codecs=lost:lost_codec;held:held_codec)/TCP(debug=1,server=6fsrcxrqm1.execute-api.eu-central-1.amazonaws.com,use_ssl=1)"

#system.httpPort.params := "HTTP(codecs=lost:lost_codec;held:held_codec)/TCP(debug=1,server=6fsrcxrqm1.execute-api.eu-central-1.amazonaws.com,use_ssl=1)"

# Test

#system.httpPort.params := "HTTP(codecs=lost:lost_codec;held:held_codec)/TCP(debug=1,server=ptsv2.com,port=80,use_ssl=0)"
@@ -71,7 +71,7 @@ system.httpPort.params := "HTTP(codecs=lost:lost_codec;held:held_codec)/TCP(debu 


[EXECUTE]

# In this section you can specify what parts of your test suite you want to execute.

#AtsNg112_TestCases.TC_LIS_HTTP_POST_BV_01

AtsNg112_TestCases.TC_LIS_HTTP_POST_BV_01

#AtsNg112_TestCases.TC_LIS_HTTP_POST_BV_02

#AtsNg112_TestCases.TC_LIS_HTTP_POST_BV_03

#AtsNg112_TestCases.TC_LIS_HTTP_POST_BV_04
@@ -79,7 +79,7 @@ system.httpPort.params := "HTTP(codecs=lost:lost_codec;held:held_codec)/TCP(debu 
#AtsNg112_TestCases.TC_LIS_HTTP_POST_BV_06

#AtsNg112_TestCases.TC_LIS_HTTP_GET_BV_01

#AtsNg112_TestCases.TC_LIS_HTTP_GET_BV_02

AtsNg112_TestCases.TC_ECRF_HTTP_POST_BV_01

#AtsNg112_TestCases.TC_ECRF_HTTP_POST_BV_01



[GROUPS]

# In this section you can specify groups of hosts. These groups can be used inside the