Commit 5f71d2b3 authored by Yann Garcia's avatar Yann Garcia
Browse files

Start PSAP testing

parent 034daf3d

ccsrc/EncDec/LibSip/LibSip_Encdec.cc

+29 −3
Original line number Diff line number Diff line
@@ -4,7 +4,7 @@ 


#include "sip_codec_register_request.hh"

#include "sip_codec_invite_request.hh"



#include "sip_codec_message_body.hh"

#include "sip_codec_response.hh"



#include "loggers.hh"
@@ -98,7 +98,24 @@ namespace LibSip__EncdecDeclarations { 
  

  BITSTRING fx__enc__Raw(const CHARSTRING& p) { return BITSTRING(); }

  BITSTRING fx__enc__SMS(const LibSip__SimpleMsgSummaryTypes::SimpleMsgSummary& pdu) { return BITSTRING(); }

  BITSTRING fx__enc__MessageBody(const LibSip__MessageBodyTypes::MessageBody& pdu) { return BITSTRING(); }



  BITSTRING fx__enc__MessageBody(const LibSip__MessageBodyTypes::MessageBody& pdu) {

    loggers::get_instance().log_msg(">>> fx__enc__MessageBody: ", pdu);



    float duration;

    std::string tag("fx__enc__MessageBody");

    loggers::get_instance().set_start_time(tag);



    OCTETSTRING os;

    sip_codec_message_body codec;

    if (codec.encode(pdu, os) == -1) {

      loggers::get_instance().warning("fx__enc__MessageBody: -1 result code was returned");

      return int2bit(0, 1);

    }

    loggers::get_instance().set_stop_time(tag, duration);



    return oct2bit(os);

  }

  

  INTEGER fx__dec__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::Request& p) {

    loggers::get_instance().log_msg(">>> fx__dec__Request: ", pdu);
@@ -154,5 +171,14 @@ namespace LibSip__EncdecDeclarations { 
  }

  

  INTEGER fx__dec__SMS(BITSTRING& pdu, LibSip__SimpleMsgSummaryTypes::SimpleMsgSummary& p) { return INTEGER(0); }

  INTEGER fx__dec__MessageBody(BITSTRING& pdu, LibSip__MessageBodyTypes::MessageBody& p) { return INTEGER(0); }



  INTEGER fx__dec__MessageBody(BITSTRING& pdu, LibSip__MessageBodyTypes::MessageBody& p) {

    loggers::get_instance().log_msg(">>> fx__dec__MessageBody: ", pdu);



    OCTETSTRING os = bit2oct(pdu);

    sip_codec_message_body codec;

    codec.decode(os, p);



    return 0;

  }

} // End of namespace LibSip__EncdecDeclarations

ccsrc/EncDec/LibSip/LibSip_Steps_Encdec.cc

+17 −2
Original line number Diff line number Diff line 
#include <algorithm>

#include <string>



#include "LibSip_Steps.hh"



#include "loggers.hh"



namespace LibSip__Steps {



  CHARSTRING fx__rndStr() { return CHARSTRING(""); };

  CHARSTRING fx__putInLowercase(const CHARSTRING& p__string) { return CHARSTRING(""); };

  CHARSTRING fx__rndStr() {

    static const char alphanum[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

    char s[10] = { 0 };

    for (int i = 0; i < 10; ++i) {

      s[i] = alphanum[rand() % (sizeof(alphanum) - 10)];

    } // End of 'for' statement

    return CHARSTRING(s);

  };



  CHARSTRING fx__putInLowercase(const CHARSTRING& p__string) {

    std::string s(static_cast<const char*>(p__string));

    std::transform(s.begin(), s.end(), s.begin(), ::tolower);

    return CHARSTRING(s.c_str());

  };

  CHARSTRING fx__getIpAddr(const CHARSTRING& p__host__name) { return CHARSTRING(""); };

  CHARSTRING fx__calculateDigestResponse(const CHARSTRING& p__nonce, const CHARSTRING& p__cnonce, const CHARSTRING& p__user, const CHARSTRING& p__realm, const CHARSTRING& p__passwd, const CHARSTRING& p__alg, const CHARSTRING& p__nonceCount, const CHARSTRING& p__method, const CHARSTRING& p__qop, const CHARSTRING& p__URI, const CHARSTRING& p__HEntity) { return CHARSTRING(""); };

ccsrc/Protocols/Sip/sip_codec_message_body.cc

+162 −117
Original line number Diff line number Diff line
@@ -6,28 +6,85 @@ 


#include "converter.hh"



int sip_codec_message_body::encode (const LibSip__MessageBodyTypes::MessageBody& msg, OCTETSTRING& data)

{

  loggers::get_instance().log_msg(">>> sip_codec_message_body::encode: ", msg);



  //  TRACE_INITIALIZE(TRACE_LEVEL7, NULL);

  //  OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL, ">>> sip_codec_request::decode\n"));



  if (msg.ischosen(LibSip__MessageBodyTypes::MessageBody::ALT_sdpMessageBody)) {

    const LibSip__SDPTypes::SDP__Message& sdp = msg.sdpMessageBody();

    sdp_message_t* sdp_body = nullptr;

    if (encode_message_body_sdp(sdp, &sdp_body) == -1) {

      loggers::get_instance().warning("sip_codec_message_body::encode: Failed to encode SDP message");

      return -1;

    }

    char* buff = nullptr;

    ::sdp_message_to_str(sdp_body, &buff);

    if (buff != nullptr) {

      data = char2oct(CHARSTRING(buff));

      osip_free(buff);

      sdp_message_free(sdp_body);

    }

  } else {

    loggers::get_instance().warning("sip_codec_message_body::encode: Unsupported variant");

    return -1;

  }



  loggers::get_instance().log_msg("<<< sip_codec_message_body::encode: Failed to encode SDP message: ", data);

  return 0;

}



int sip_codec_message_body::decode (const OCTETSTRING& data, LibSip__MessageBodyTypes::MessageBody& msg, params* p_params)

{

  loggers::get_instance().log(">>> sip_codec_message_body::decode");



  //  TRACE_INITIALIZE(TRACE_LEVEL7, NULL);

  //  OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL, ">>> sip_codec_request::decode\n"));

  loggers::get_instance().error("sip_codec_message_body::decode: Not implemented yet");

  return -1;

}



int sip_codec_message_body::encode_message_body(const LibSip__MessageBodyTypes::MessageBody& p_message_body, osip_message_t* p_sip_message)

{ // TODO Rename into encode_message_body

{ // TODO Rename into encode_message

  loggers::get_instance().log(">>> sip_codec_message_body::encode_message_body");



  osip_content_length* content_length = ::osip_message_get_content_length(p_sip_message);

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

  if (p_message_body.ischosen(LibSip__MessageBodyTypes::MessageBody::ALT_sdpMessageBody)) {

    const LibSip__SDPTypes::SDP__Message& sdp = p_message_body.sdpMessageBody();

    loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: sdp: ", sdp);

    sdp_message_t* sdp_body = nullptr;

    if (encode_message_body_sdp(sdp, &sdp_body) == -1) {

      loggers::get_instance().warning("sip_codec_message_body::encode_message_body: Failed to decode SDP message");

      return -1;

    }

    char* buff = nullptr;

    ::sdp_message_to_str(sdp_body, &buff);

    if (buff != nullptr) {

      ::osip_message_set_body(p_sip_message, buff, strlen(buff));

      osip_free(buff);

      sdp_message_free(sdp_body);

    }

  }

  

  return 0;

} // End of method encode_message_body



    sdp_message_t* sdp_body;

    ::sdp_message_init(&sdp_body);

int sip_codec_message_body::encode_message_body_sdp(const LibSip__SDPTypes::SDP__Message& p_sdp_message, sdp_message_t** p_sdp_body) {

  loggers::get_instance().log_msg(">>> sip_codec_message_body::encode_message_body_sdp: ", p_sdp_message);



  ::sdp_message_init(p_sdp_body);



  // Encode mandatory fields

  // Version

    INTEGER version = sdp.protocol__version();

    ::sdp_message_v_version_set(sdp_body, (char*)::strdup(std::to_string(static_cast<const int>(version)).c_str()));

    LibSip__SDPTypes::SDP__Origin origin = sdp.origin();

  INTEGER version = p_sdp_message.protocol__version();

  ::sdp_message_v_version_set(*p_sdp_body, (char*)::strdup(std::to_string(static_cast<const int>(version)).c_str()));

  LibSip__SDPTypes::SDP__Origin origin = p_sdp_message.origin();

  // Origin

    loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: origin: ", origin);

  loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body_sdp: origin: ", origin);

  ::sdp_message_o_origin_set(

                               sdp_body,

                             *p_sdp_body,

                             (char*)::strdup(static_cast<const char*>(origin.user__name())),

                             (char*)::strdup(static_cast<const char*>(origin.session__id())),

                             (char*)::strdup(static_cast<const char*>(origin.session__version())),
@@ -36,35 +93,35 @@ int sip_codec_message_body::encode_message_body(const LibSip__MessageBodyTypes:: 
                             (char*)::strdup(static_cast<const char*>(origin.addr()))

                             );

  // Session name

    ::sdp_message_s_name_set(sdp_body, (char*)::strdup(static_cast<const char*>(sdp.session__name())));

  ::sdp_message_s_name_set(*p_sdp_body, (char*)::strdup(static_cast<const char*>(p_sdp_message.session__name())));

  // Time, t

    ::sdp_message_s_name_set(sdp_body, (char*)::strdup(static_cast<const char*>(sdp.session__name())));

    loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: times: ", sdp.times());

    for (int i = 0; i < sdp.times().lengthof(); i++) {

      const LibSip__SDPTypes::SDP__time& time = sdp.times()[i];

      loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: time: ", time);

      ::sdp_message_t_time_descr_add(sdp_body, (char*)::strdup(static_cast<const char*>(time.time__field().start__time())), (char*)::strdup(static_cast<const char*>(time.time__field().stop__time())));

  ::sdp_message_s_name_set(*p_sdp_body, (char*)::strdup(static_cast<const char*>(p_sdp_message.session__name())));

  loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body_sdp: times: ", p_sdp_message.times());

  for (int i = 0; i < p_sdp_message.times().lengthof(); i++) {

    const LibSip__SDPTypes::SDP__time& time = p_sdp_message.times()[i];

    loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body_sdp: time: ", time);

    ::sdp_message_t_time_descr_add(*p_sdp_body, (char*)::strdup(static_cast<const char*>(time.time__field().start__time())), (char*)::strdup(static_cast<const char*>(time.time__field().stop__time())));

    if (time.time__repeat().is_present()) {

      const LibSip__SDPTypes::SDP__repeat__list& l = static_cast<const OPTIONAL<LibSip__SDPTypes::SDP__repeat__list>&>(*time.time__repeat().get_opt_value());

        loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: l: ", l);

      loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body_sdp: l: ", l);

      for (int j = 0; j < l.lengthof(); j++) {

        const LibSip__SDPTypes::SDP__repeat& r = l[j];

        // TODO            r.repeat__interval();

        // TODO            r.active();

        for (int k = 0; k < r.offsets().lengthof(); k++) {

      	const LibSip__SDPTypes::SDP__typed__time& s = r.offsets()[k];

            // TODO              ::sdp_message_r_repeat_add(sdp_body, k, char *value);

          }

          // TODO        ::sdp_message_r_repeat_add(sdp_body, int pos_time_descr, char *value)

      	// TODO              ::sdp_message_r_repeat_add(p_sdp_body, k, char *value);

        } // End of 'for' statement

        // TODO        ::sdp_message_r_repeat_add(p_sdp_body, int pos_time_descr, char *value)

      } // End of 'for' statement

    }

  } // End of 'for' statement



  // Encode optional fields

  // email, e

    loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: emails: ", sdp.emails());

    if (sdp.emails().is_present()) {

      const LibSip__SDPTypes::SDP__email__list& l = static_cast<const LibSip__SDPTypes::SDP__email__list&>(*sdp.emails().get_opt_value());

  loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body_sdp: emails: ", p_sdp_message.emails());

  if (p_sdp_message.emails().is_present()) {

    const LibSip__SDPTypes::SDP__email__list& l = static_cast<const LibSip__SDPTypes::SDP__email__list&>(*p_sdp_message.emails().get_opt_value());

    for (int i = 0; i < l.lengthof(); i++) {

      const LibSip__SDPTypes::SDP__contact& e = l[i];

      std::string str;
@@ -73,40 +130,39 @@ int sip_codec_message_body::encode_message_body(const LibSip__MessageBodyTypes:: 
        str += " ";

      }

      str += static_cast<const char*>(e.addr__or__phone());

        ::sdp_message_e_email_add (sdp_body, ::strdup(str.c_str()));

      ::sdp_message_e_email_add(*p_sdp_body, ::strdup(str.c_str()));

    } // End of 'for' statement

  }

  // Information, i

    loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: information: ", sdp.information());

    if (sdp.information().is_present()) {

      ::sdp_message_i_info_set(sdp_body, 0, ::strdup(static_cast<const CHARSTRING&>(*sdp.information().get_opt_value())));

  loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body_sdp: information: ", p_sdp_message.information());

  if (p_sdp_message.information().is_present()) {

    ::sdp_message_i_info_set(*p_sdp_body, 0, ::strdup(static_cast<const CHARSTRING&>(*p_sdp_message.information().get_opt_value())));

  }

  // Media list, m

    loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: medias: ", sdp.media__list());

    if (sdp.media__list().is_present()) {

      const LibSip__SDPTypes::SDP__media__desc__list& l = static_cast<const LibSip__SDPTypes::SDP__media__desc__list&>(*sdp.media__list().get_opt_value());

  loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body_sdp: medias: ", p_sdp_message.media__list());

  if (p_sdp_message.media__list().is_present()) {

    const LibSip__SDPTypes::SDP__media__desc__list& l = static_cast<const LibSip__SDPTypes::SDP__media__desc__list&>(*p_sdp_message.media__list().get_opt_value());

    int i = 0;

    for ( ; i < l.lengthof(); i++) {

      const LibSip__SDPTypes::SDP__media__desc m = l[i];

        loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: media: ", m);

      loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body_sdp: media: ", m);

      if (m.media__field().ports().num__of__ports().is_present()) {

        int i = static_cast<const INTEGER&>(*m.media__field().ports().num__of__ports().get_opt_value());

          ::sdp_message_m_media_add(sdp_body, (char*)::strdup(static_cast<const char*>(m.media__field().media())), (char*)::strdup(std::to_string(m.media__field().ports().port__number()).c_str()), (char*)::strdup(std::to_string(i).c_str()), (char*)::strdup(static_cast<const char*>(m.media__field().transport())));

        ::sdp_message_m_media_add(*p_sdp_body, (char*)::strdup(static_cast<const char*>(m.media__field().media())), (char*)::strdup(std::to_string(m.media__field().ports().port__number()).c_str()), (char*)::strdup(std::to_string(i).c_str()), (char*)::strdup(static_cast<const char*>(m.media__field().transport())));

      } else {

          ::sdp_message_m_media_add(sdp_body, (char*)::strdup(static_cast<const char*>(m.media__field().media())), (char*)::strdup(std::to_string(m.media__field().ports().port__number()).c_str()), NULL, (char*)::strdup(static_cast<const char*>(m.media__field().transport())));

        ::sdp_message_m_media_add(*p_sdp_body, (char*)::strdup(static_cast<const char*>(m.media__field().media())), (char*)::strdup(std::to_string(m.media__field().ports().port__number()).c_str()), NULL, (char*)::strdup(static_cast<const char*>(m.media__field().transport())));

      }

        

    } // End of 'for' statement

      ::sdp_message_endof_media(sdp_body, i);

    ::sdp_message_endof_media(*p_sdp_body, i);

  }

  // Attribute list, a

    loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: attributes: ", sdp.attributes());

    if (sdp.attributes().is_present()) {

      const LibSip__SDPTypes::SDP__attribute__list& l = static_cast<const LibSip__SDPTypes::SDP__attribute__list&>(*sdp.attributes().get_opt_value());

  loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body_sdp: attributes: ", p_sdp_message.attributes());

  if (p_sdp_message.attributes().is_present()) {

    const LibSip__SDPTypes::SDP__attribute__list& l = static_cast<const LibSip__SDPTypes::SDP__attribute__list&>(*p_sdp_message.attributes().get_opt_value());

    int i = 0;

    for ( ; i < l.lengthof(); i++) {

      const LibSip__SDPTypes::SDP__attribute a = l[i];

        loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: attribute: ", a);

      loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body_sdp: attribute: ", a);

      if (a.ischosen(LibSip__SDPTypes::SDP__attribute::ALT_rtpmap)) {

        std::string str("rtpmap:");

        str += static_cast<const char*>(a.rtpmap().codec().encoding());
@@ -115,35 +171,24 @@ int sip_codec_message_body::encode_message_body(const LibSip__MessageBodyTypes:: 
          str += "/";

          str += static_cast<const char*>(static_cast<const CHARSTRING&>(*a.rtpmap().codec().parameters().get_opt_value()));

        }

          ::sdp_message_a_attribute_add(sdp_body, 0, (char*)::strdup(static_cast<const char*>(a.rtpmap().payload__type())), (char*)::strdup(str.c_str()));

        ::sdp_message_a_attribute_add(*p_sdp_body, 0, (char*)::strdup(static_cast<const char*>(a.rtpmap().payload__type())), (char*)::strdup(str.c_str()));

      } else if (a.ischosen(LibSip__SDPTypes::SDP__attribute::ALT_maxptime)) {

        std::string str("maxptime:");

        str += static_cast<const char*>(a.maxptime().attr__value());

          ::sdp_message_a_attribute_add(sdp_body, 0, (char*)::strdup(str.c_str()), NULL);

        ::sdp_message_a_attribute_add(*p_sdp_body, 0, (char*)::strdup(str.c_str()), NULL);

      } else {

          loggers::get_instance().warning("sip_codec_message_body::encode_message_body: attribute not processed");

        loggers::get_instance().warning("sip_codec_message_body::encode_message_body_sdp: attribute not processed");

      }

    } // End of 'for' statement

  }

    

  // TODO To be continued



    loggers::get_instance().log("sip_codec_message_body::encode_message_body: SDP encoded");

    

    char* buff = nullptr;

    ::sdp_message_to_str(sdp_body, &buff);

    if (buff != nullptr) {

      ::osip_message_set_body(p_sip_message, buff, strlen(buff));

      osip_free(buff);

      sdp_message_free(sdp_body);

    }

  }

  

  loggers::get_instance().log("<<< sip_codec_message_body::encode_message_body_sdp");

  return 0;

} // End of method encode_message_body

}



void sip_codec_message_body::decode_message_body(const osip_message_t* p_sip_message, OPTIONAL<LibSip__MessageBodyTypes::MessageBody>& p_message_body)

{

{ // TODO Rename into decode_message

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



  osip_content_length* content_length = ::osip_message_get_content_length(p_sip_message);

ccsrc/Protocols/Sip/sip_codec_message_body.hh

+9 −1
Original line number Diff line number Diff line
@@ -10,13 +10,21 @@ namespace LibSip__MessageBodyTypes { 
  class MessageBody;

}



class sip_codec_message_body

class sip_codec_message_body: public codec <

LibSip__MessageBodyTypes::MessageBody,

LibSip__MessageBodyTypes::MessageBody>

{

public:

  explicit sip_codec_message_body() { };

  virtual ~sip_codec_message_body() { };



  virtual int encode (const LibSip__MessageBodyTypes::MessageBody& msg, OCTETSTRING& data);

  virtual int decode (const OCTETSTRING& data, LibSip__MessageBodyTypes::MessageBody& msg, params* p_params = NULL);



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

  virtual void decode_message_body(const osip_message_t* p_sip_message, OPTIONAL<LibSip__MessageBodyTypes::MessageBody>& p_message_body);



private:

  int encode_message_body_sdp(const LibSip__SDPTypes::SDP__Message& p_message_body, sdp_message_t** p_sdp_body);



}; // End of class sip_codec_message_body

ccsrc/Protocols/Sip/sip_codec_request.cc

+4 −4
Original line number Diff line number Diff line
@@ -10,8 +10,8 @@ int sip_codec_request::encode (const LibSip__SIPTypesAndValues::Request& msg, OC 
{

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

  

  TRACE_INITIALIZE(TRACE_LEVEL7, NULL);

  OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL, ">>> sip_codec_request::encode\n"));

//  TRACE_INITIALIZE(TRACE_LEVEL7, NULL);

//  OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL, ">>> sip_codec_request::encode\n"));

  

  osip_message_t* sip_message = nullptr; // TODO Use smart pointer

  ::parser_init();
@@ -49,8 +49,8 @@ int sip_codec_request::decode (const OCTETSTRING& data, LibSip__SIPTypesAndValue 
{

  loggers::get_instance().log_msg(">>> sip_codec_request::decode: data=", data);



  TRACE_INITIALIZE(TRACE_LEVEL7, NULL);

  OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL, ">>> sip_codec_request::decode\n"));

//  TRACE_INITIALIZE(TRACE_LEVEL7, NULL);

//  OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL, ">>> sip_codec_request::decode\n"));

  

  // Sanity checks

  if (data.lengthof() == 0) {