Commit b3f563f5 authored by Yann Garcia's avatar Yann Garcia
Browse files

Add SIP headers codec

parent 857a9134

ccsrc/Framework/include/converter.hh

+17 −1
Original line number Diff line number Diff line
@@ -338,6 +338,22 @@ public: 
   */

  std::string trim(const std::string& p_value, const std::string& p_trim_chars = " \t");

    

  /*!

   * \brief Convert the provided string into a list of arguments

   * \param[in] p_value The string value

   * \param[in] p_separator The separator sequence to use for the spliting process

   * \return The item list

   * \code{.cc}

   *     std::string str = "This is a test for spliting a string with a white spave";

   *     std::vector<std::string> tokens = converter::get_instance().split(str, " ");

   *     std::clog << "Tokens: " << std::endl;

   *     for (auto it = tokens.begin(); it != tokens.end(); ++it) {

   *       std::clog << "   " << *it << std::endl;

   *     }

   * \endcode

   */

  std::vector<std::string> split(const std::string & p_value, const std::string& p_separator);

  

  /*!

   * \brief Convert the provided string into a list of arguments

   * \param[in] p_value The string value

ccsrc/Framework/src/converter.cc

+15 −1
Original line number Diff line number Diff line
@@ -98,6 +98,20 @@ std::string converter::trim(const std::string& str, const std::string& whitespac 
  return str.substr(strBegin, strRange);

}



std::vector<std::string> converter::split(const std::string & p_value, const std::string& p_separator) {

  std::vector<std::string> output;

  std::size_t current, previous = 0;

  current = p_value.find(p_separator);

  while (current != std::string::npos) {

    output.push_back(p_value.substr(previous, current - previous));

    previous = current + 1;

    current = p_value.find(p_separator, previous);

  }

  output.push_back(p_value.substr(previous, current - previous));



  return output;

}



std::vector<std::string> converter::split_arguments_line(const std::string & p_value) {

  std::vector<std::string> output;

  std::string line = trim(p_value);

ccsrc/Protocols/Sip/sip_codec_request.cc

+600 −29

File changed.

Preview size limit exceeded, changes collapsed.

ccsrc/Protocols/Sip/sip_codec_request.hh

+12 −2
Original line number Diff line number Diff line
@@ -56,13 +56,19 @@ 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_accept_header(const LibSip__SIPTypesAndValues::Accept& p_accept, osip_message_t** p_sip_message);

  int encode_accept_contact_header(const LibSip__SIPTypesAndValues::AcceptContact& p_accept_contact, osip_message_t** p_sip_message);

  int encode_allow_header(const OPTIONAL<LibSip__SIPTypesAndValues::Allow>& p_allow, osip_message_t** p_sip_message);

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

  int encode_call_id_header(const LibSip__SIPTypesAndValues::CallId& p_call_id, osip_call_id_t** p_call_id_header);

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

  int encode_content_length_header(const LibSip__SIPTypesAndValues::ContentLength& p_contact, osip_content_length_t** p_content_length_header);

  int encode_content_type_header(const LibSip__SIPTypesAndValues::ContentType& p_contact, osip_content_type_t** p_content_type_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);

  int encode_min_se_header(const OPTIONAL<LibSip__SIPTypesAndValues::MinSE>& p_min_se, osip_message_t** p_sip_message);

  int encode_session_expires_header(const OPTIONAL<LibSip__SIPTypesAndValues::SessionExpires>& p_session_expires, osip_message_t** p_sip_message);

  int encode_supported_header(const OPTIONAL<LibSip__SIPTypesAndValues::Supported>& p_supported, osip_message_t** p_sip_message);

  int encode_to_header(const LibSip__SIPTypesAndValues::To& p_to, osip_to_t** p_to_header);

  int encode_via_header(const LibSip__SIPTypesAndValues::Via& p_via, osip_via_t** p_via_header);
@@ -93,6 +99,9 @@ private: //! \todo Move this section into a sip_codec_helper class, need to deco 
  void decode_contact_header(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::Contact& p_contact_header);

  void decode_from_header(const osip_from_t* p_sip_from, LibSip__SIPTypesAndValues::From& p_from_header);

  void decode_max_forwards_header(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::MaxForwards& p_max_forwards_header);

  void decode_min_se_header(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::MinSE& p_min_se_header);

  void decode_route_header(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::Route& p_route_header);

  void decode_session_expires_header(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::SessionExpires& p_session_expires_header);

  void decode_supported_header(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::Supported& p_supported_header);

  void decode_to_header(const osip_to_t* p_sip_to, LibSip__SIPTypesAndValues::To& p_to_header);

  void decode_via_header(const osip_message_t* p_sip_via_list, LibSip__SIPTypesAndValues::Via& p_via_header);
@@ -100,6 +109,7 @@ private: //! \todo Move this section into a sip_codec_helper class, need to deco 
  void encode_host_port(const LibSip__SIPTypesAndValues::HostPort& p_host_port, std::string& p_host, std::string& p_port);

  void decode_host_port(const char* p_host, const char* p_port, LibSip__SIPTypesAndValues::HostPort& p_host_port);

  int encode_semi_colon_params(const LibSip__Common::SemicolonParam__List& p_list, osip_list_t* p_sip_list);

  void decode_semi_colon_params(const std::string& p_params, std::string& p_first_param, LibSip__Common::SemicolonParam__List& p_others_params);

  void decode_semi_colon_params(const osip_list_t& p_sip_list, OPTIONAL<LibSip__Common::SemicolonParam__List>& p_list);

  int encode_ampersand_params(const LibSip__Common::AmpersandParam__List& p_list, osip_list_t** p_sip_list);

  void decode_ampersand_params(const osip_list_t& p_sip_list, OPTIONAL<LibSip__Common::AmpersandParam__List>& p_list);

ccsrc/Protocols/Sip/sip_codec_response.cc

+32 −5
Original line number Diff line number Diff line
@@ -4,6 +4,8 @@ 
#include "sip_codec_response.hh"

#include "loggers.hh"



#include "converter.hh"



int sip_codec_response::encode (const LibSip__SIPTypesAndValues::Response& msg, OCTETSTRING& data)

{

  loggers::get_instance().log_msg(">>> sip_codec_response::encode: ", (const Base_Type&)msg);
@@ -1009,11 +1011,21 @@ void sip_codec_response::decode_message_body(const osip_message_t* p_sip_message 
{

  loggers::get_instance().log(">>> sip_codec_response::decode_message_body");



  osip_content_length* content_length = ::osip_message_get_content_length(p_sip_message);

  loggers::get_instance().log("sip_codec_request::decode_message_body: content_length= %s", content_length->value);

  if (strcmp((const char*)content_length->value, "0") == 0) {

    p_response.messageBody().set_to_omit();

    return;

  }

  osip_content_type_t* content_type = ::osip_message_get_content_type(p_sip_message);

  osip_body_t* body;

  int result = ::osip_message_get_body(p_sip_message, 0, &body);

  if (content_type != nullptr) {

  loggers::get_instance().log("sip_codec_response::decode_message_body: result=%d", result);

  if (result != 0) {

    p_response.messageBody().set_to_omit();

    return;

  }

  if (content_type != nullptr) {

    loggers::get_instance().log("sip_codec_response::decode_message_body: content-type.type: %s", content_type->type);

    loggers::get_instance().log("sip_codec_response::decode_message_body: content-type.subtype: %s", content_type->subtype);

    LibSip__MessageBodyTypes::MessageBody m;
@@ -1301,11 +1313,26 @@ void sip_codec_response::decode_uri(LibSip__SIPTypesAndValues::SipUrl& p_sip_url 
      loggers::get_instance().log_msg("sip_codec_response::decode_uri: host_port: ", host_port);

      uri_components.sip() = LibSip__SIPTypesAndValues::SipUriComponents(user_info, host_port);

    } else if (strcmp(::osip_uri_get_scheme((osip_uri_t*)p_uri), "tel") == 0) {

      // FIXME uri_components.tel() = LibSip__SIPTypesAndValues::TelUriComponents(user_info, host_port);

      const LibSip__SIPTypesAndValues::TelUriComponents t;

      uri_components.tel() = t; // TODO To be done

      loggers::get_instance().error("sip_codec_response::decode_sip_uri: Unsupported LibSip__SIPTypesAndValues::UriComponents::ALT_tel");

    } else if (strcmp(::osip_uri_get_scheme((osip_uri_t*)p_uri), "urn") == 0) {

      CHARSTRING namespace_id("Todo");

      CHARSTRING namespace_spec("Todo");

      uri_components.urn() = LibSip__SIPTypesAndValues::UrnUriComponents(namespace_id, namespace_spec);

      char *buf = nullptr;

      if (::osip_uri_to_str_canonical((osip_uri_t*)p_uri, &buf) == 0) {

        std::string str(buf);

        loggers::get_instance().log("sip_codec_response::decode_uri: str: %s", str.c_str());

        std::vector<std::string> output = converter::get_instance().split(str, ":");

        loggers::get_instance().log("sip_codec_response::decode_uri: split size: %d", output.size());

        LibSip__SIPTypesAndValues::UrnUriComponents urn;

        urn.namespaceId() = output[1].c_str();

        std::string s(output[2]);

        for (size_t i = 3; i < output.size(); i++) {

          s += ":" + output[i];

        }

        urn.namespaceSpecificString() = s.c_str();

        uri_components.urn() = urn;

        osip_free(buf); // Macro

      } // TODO Check what to do in this case

    } else {

      char *buffer = nullptr;

      ::osip_uri_to_str_canonical((osip_uri_t*)p_uri, &buffer);