Commit cd187523 authored by garciay's avatar garciay
Browse files

Enhance SIP codec

parent d7351289

ccsrc/Protocols/Sip/sip_codec_request.cc

+243 −45
Original line number Diff line number Diff line
@@ -177,21 +177,33 @@ int sip_codec_request::encode_request_headers(const LibSip__SIPTypesAndValues::M 
    loggers::get_instance().warning("sip_codec_request::encode_request_headers: Faile to encode Authorization header");

    return -1;

  }

  ::osip_authorization_to_str(authorization_header, &hvalue);

  loggers::get_instance().log("sip_codec_request::encode_request_headers: Authorization:%s", hvalue);

  int result = ::osip_message_set_authorization(p_sip_message, hvalue);

  int result = ::osip_authorization_to_str(authorization_header, &hvalue);

  loggers::get_instance().log("sip_codec_request::encode_request_headers: Authorization: %s - %d", hvalue, result);

  result = ::osip_message_set_authorization(p_sip_message, hvalue);

  loggers::get_instance().log("sip_codec_request::encode_request_headers: SIP Authorization: %p - %d", p_sip_message->authorizations, result);

  ::osip_authorization_free(authorization_header);

  osip_free(hvalue);



  osip_contact_t* contact_header = nullptr;

  osip_call_id_t* call_id_header;

  if (encode_call_id_header(p_msg_header.callId(), &call_id_header) == -1) {

    loggers::get_instance().warning("sip_codec_request::encode_request_headers: Faile to encode Call_Id header");

    return -1;

  }

  ::osip_call_id_to_str(call_id_header, &hvalue);

  loggers::get_instance().log("sip_codec_request::encode_request_headers: Call_Id:%s", hvalue);

  result = ::osip_message_set_call_id(p_sip_message, hvalue);

  loggers::get_instance().log("sip_codec_request::encode_request_headers: SIP Call_Id: %p - %d", p_sip_message->call_id, result);

  ::osip_call_id_free(call_id_header);

  osip_free(hvalue);

  

  osip_contact_t* contact_header;

  if (encode_contact_header(p_msg_header.contact(), &contact_header) == -1) {

    loggers::get_instance().warning("sip_codec_request::encode_request_headers: Faile to encode Contact header");

    return -1;

  }

  ::osip_contact_to_str(contact_header, &hvalue);

  loggers::get_instance().log("sip_codec_request::encode_request_headers: Contact: %s", hvalue);

  int result = ::osip_message_set_contact(p_sip_message, hvalue);

  result = ::osip_message_set_contact(p_sip_message, hvalue);

  loggers::get_instance().log("sip_codec_request::encode_request_headers: SIP Contact: %p - %d", p_sip_message->contacts, result);

  ::osip_contact_free(contact_header);

  osip_free(hvalue);
@@ -311,10 +323,10 @@ void sip_codec_request::encode_host_port(const LibSip__SIPTypesAndValues::HostPo 
  loggers::get_instance().log("sip_codec_request::encode_port_port: port:'%s'", p_port.c_str());

} // End of method encode_host_port



int sip_codec_request::encode_accept_header(const LibSip__SIPTypesAndValues::Accept& p_accept, osip_accept_t* p_sip_accept_header) {

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

  loggers::get_instance().log(">>> sip_codec_request::encode_accept_header");

  

  ::osip_accept_init(p_accept_header);

  ::accept_init(p_accept_header);

  

  return -1; // TODO

} // End of method encode_accept_header
@@ -339,7 +351,6 @@ int sip_codec_request::encode_authorization_header(const LibSip__SIPTypesAndValu 
        do {

          const LibSip__Common::GenericParam& g = p[j++];

          std::string str(static_cast<const char*>(g.id()));

          ::osip_authorization_set_digest(*p_authorization_header, (char*)::strdup("Digest"));

          if (str.compare("realm") == 0) {

            loggers::get_instance().log("sip_codec_request::encode_authorization_header: realm found");

            if (g.paramValue().is_present()) {
@@ -348,7 +359,6 @@ int sip_codec_request::encode_authorization_header(const LibSip__SIPTypesAndValu 
              if (v.ischosen(LibSip__Common::GenValue::ALT_tokenOrHost)) {

                loggers::get_instance().log_msg("sip_codec_request::encode_authorization_header: tokenOrHost: ", v.tokenOrHost());

                ::osip_authorization_set_realm(*p_authorization_header, (char*)::strdup(static_cast<const char*>(v.tokenOrHost())));

                //                ::osip_authorization_set_auth_type(*p_authorization_header, ::strdup("")); // Required by osip even if useless!

              } else {

                loggers::get_instance().error("sip_codec_request::encode_authorization_header: Not implemented (3)");

              }
@@ -363,7 +373,6 @@ int sip_codec_request::encode_authorization_header(const LibSip__SIPTypesAndValu 
              if (v.ischosen(LibSip__Common::GenValue::ALT_tokenOrHost)) {

                loggers::get_instance().log_msg("sip_codec_request::encode_authorization_header: tokenOrHost: ", v.tokenOrHost());

                ::osip_authorization_set_username(*p_authorization_header, (char*)::strdup(static_cast<const char*>(v.tokenOrHost())));

                //                ::osip_authorization_set_auth_type(*p_authorization_header, ::strdup("")); // Required by osip even if useless!

              } else {

                loggers::get_instance().error("sip_codec_request::encode_authorization_header: Not implemented (5)");

              }
@@ -378,7 +387,6 @@ int sip_codec_request::encode_authorization_header(const LibSip__SIPTypesAndValu 
              if (v.ischosen(LibSip__Common::GenValue::ALT_tokenOrHost)) {

                loggers::get_instance().log_msg("sip_codec_request::encode_authorization_header: tokenOrHost: ", v.tokenOrHost());

                ::osip_authorization_set_uri(*p_authorization_header, (char*)::strdup(static_cast<const char*>(v.tokenOrHost())));

                //                ::osip_authorization_set_auth_type(*p_authorization_header, ::strdup("")); // Required by osip even if useless!

              } else {

                loggers::get_instance().error("sip_codec_request::encode_authorization_header: Not implemented (7)");

              }
@@ -393,7 +401,6 @@ int sip_codec_request::encode_authorization_header(const LibSip__SIPTypesAndValu 
              if (v.ischosen(LibSip__Common::GenValue::ALT_tokenOrHost)) {

                loggers::get_instance().log_msg("sip_codec_request::encode_authorization_header: tokenOrHost: ", v.tokenOrHost());

                ::osip_authorization_set_nonce(*p_authorization_header, (char*)::strdup(static_cast<const char*>(v.tokenOrHost())));

                //                ::osip_authorization_set_auth_type(*p_authorization_header, ::strdup("")); // Required by osip even if useless!

              } else {

                loggers::get_instance().error("sip_codec_request::encode_authorization_header: Not implemented (9)");

              }
@@ -408,7 +415,6 @@ int sip_codec_request::encode_authorization_header(const LibSip__SIPTypesAndValu 
              if (v.ischosen(LibSip__Common::GenValue::ALT_tokenOrHost)) {

                loggers::get_instance().log_msg("sip_codec_request::encode_authorization_header: tokenOrHost: ", v.tokenOrHost());

                ::osip_authorization_set_response(*p_authorization_header, (char*)::strdup(static_cast<const char*>(v.tokenOrHost())));

                //                ::osip_authorization_set_auth_type(*p_authorization_header, ::strdup("")); // Required by osip even if useless!

              } else {

                loggers::get_instance().error("sip_codec_request::encode_authorization_header: Not implemented (11)");

              }
@@ -423,7 +429,7 @@ int sip_codec_request::encode_authorization_header(const LibSip__SIPTypesAndValu 
      }

      loggers::get_instance().log("sip_codec_request::encode_authorization_header: processed: %x", processed);

      if (processed) {

        ::osip_authorization_set_auth_type(*p_authorization_header, ::strdup("")); // Required by osip even if useless!

        ::osip_authorization_set_auth_type(*p_authorization_header, (char*)::strdup("Digest"));

      }

    } else {

      const LibSip__SIPTypesAndValues::OtherAuth& o = c.otherResponse();
@@ -434,12 +440,79 @@ int sip_codec_request::encode_authorization_header(const LibSip__SIPTypesAndValu 
  return 0;

} // End of method encode_authorization_header



int sip_codec_request::encode_contact_header(const LibSip__SIPTypesAndValues::Contact& p_contact, osip_contact_t* p_sip_contact_header) {

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

  loggers::get_instance().log_msg(">>> sip_codec_request::encode_call_id_header", p_call_id.callid());

  

  ::osip_call_id_init(p_call_id_header);

  ::osip_call_id_parse(*p_call_id_header, static_cast<const char*>(p_call_id.callid()));

  

  loggers::get_instance().log("<<< sip_codec_request::encode_call_id_header");

  return 0;

} // End of method encode_call_id_header



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

  loggers::get_instance().log(">>> sip_codec_request::encode_contact_header");



  ::osip_accept_init(p_contact_header);

  ::osip_contact_init(p_contact_header);

  const LibSip__SIPTypesAndValues::ContactBody& body = p_contact.contactBody();

  if (body.ischosen(LibSip__SIPTypesAndValues::ContactBody::ALT_wildcard)) {

    const CHARSTRING& wildcard = body.wildcard();

    loggers::get_instance().warning("sip_codec_request::encode_contact_header: wildcard not implemented yet");

    *p_contact_header = nullptr;

    return -1;

  } else if (body.ischosen(LibSip__SIPTypesAndValues::ContactBody::ALT_contactAddresses)) {

    const LibSip__SIPTypesAndValues::ContactAddress__List& l = body.contactAddresses();

    // Encode AddressField

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

      osip_uri_t* uri = nullptr;

      const LibSip__SIPTypesAndValues::ContactAddress c = l[i];

      if (c.addressField().ischosen(LibSip__SIPTypesAndValues::Addr__Union::ALT_nameAddr)) {

        const LibSip__SIPTypesAndValues::NameAddr& addr = c.addressField().nameAddr();

        if (encode_sip_url(addr.addrSpec(), &uri) == -1) {

          loggers::get_instance().warning("sip_codec_request::encode_contact_header: Failed to encode SipUrl");

          ::osip_contact_free(*p_contact_header);

          *p_contact_header = nullptr;

          return -1;

        }

        ::osip_contact_set_url(*p_contact_header, uri);

        if (addr.displayName().is_present()) {

          const LibSip__SIPTypesAndValues::DisplayName& n = static_cast<const LibSip__SIPTypesAndValues::DisplayName&>(addr.displayName());

          if (n.ischosen(LibSip__SIPTypesAndValues::DisplayName::ALT_token)) {

            ::osip_contact_set_displayname(*p_contact_header, (char*)::strdup(static_cast<const char*>(static_cast<CHARSTRING>(n.token()))));

          } else if (n.ischosen(LibSip__SIPTypesAndValues::DisplayName::ALT_quotedString)) {

            ::osip_contact_set_displayname(*p_contact_header, (char*)::strdup(static_cast<const char*>(static_cast<CHARSTRING>(n.quotedString()))));

          } else {

            loggers::get_instance().warning("sip_codec_request::encode_contact_header: Failed to encode DisplayName");

            ::osip_contact_free(*p_contact_header);

            *p_contact_header = nullptr;

            return -1;

          }

        }

      } else if (c.addressField().ischosen(LibSip__SIPTypesAndValues::Addr__Union::ALT_addrSpecUnion)) {

        if (encode_sip_url(c.addressField().addrSpecUnion(), &uri) == -1) {

          loggers::get_instance().warning("sip_codec_request::encode_contact_header: Failed to encode SipUrl");

          ::osip_contact_free(*p_contact_header);

          *p_contact_header = nullptr;

          return -1;

        }

        ::osip_contact_set_url(*p_contact_header, uri);

      } else {

        loggers::get_instance().warning("sip_codec_request::encode_contact_header: Failed to encode Addr__Union");

        ::osip_contact_free(*p_contact_header);

        *p_contact_header = nullptr;

        return -1;

      }

      // Encode contactParams

      if (c.contactParams().is_present()) {

        encode_semi_colon_params(static_cast<const LibSip__Common::SemicolonParam__List>(c.contactParams()), &(*p_contact_header)->gen_params);

      }



    } // End of 'for' statement

  } else {

    return -1;

  }

  

  return -1; // TODO

  return 0;

} // End of method encode_contact_header



int sip_codec_request::encode_c_seq_header(const LibSip__SIPTypesAndValues::CSeq& p_c_seq, osip_cseq_t** p_c_seq_header)
@@ -457,6 +530,7 @@ int sip_codec_request::encode_from_header(const LibSip__SIPTypesAndValues::From& 
  loggers::get_instance().log(">>> sip_codec_request::encode_from_header");

  

  ::osip_from_init(p_from_header);

  // Endode addressField

  osip_uri_t* uri = nullptr;

  const LibSip__SIPTypesAndValues::Addr__Union& a = p_from.addressField();

  if (a.ischosen(LibSip__SIPTypesAndValues::Addr__Union::ALT_nameAddr)) {
@@ -495,6 +569,7 @@ int sip_codec_request::encode_from_header(const LibSip__SIPTypesAndValues::From& 
    *p_from_header = nullptr;

    return -1;

  }

  // Encode fromParams

  if (p_from.fromParams().is_present()) {

    encode_semi_colon_params(static_cast<const LibSip__Common::SemicolonParam__List>(p_from.fromParams()), &(*p_from_header)->gen_params);

  }
@@ -731,7 +806,15 @@ void sip_codec_request::decode_headers(const osip_message_t* p_sip_message, LibS 
  }

  

  headers.callInfo().set_to_omit();



  LibSip__SIPTypesAndValues::Contact contact_header;

  decode_contact_header(p_sip_message, contact_header);

  if (contact_header.is_value()) {

    headers.contact() = contact_header;

  } else {

    headers.contact().set_to_omit();

  }

  

  headers.contentDisposition().set_to_omit();

  headers.contentEncoding().set_to_omit();

  headers.contentLanguage().set_to_omit();
@@ -850,14 +933,101 @@ void sip_codec_request::decode_headers(const osip_message_t* p_sip_message, LibS 
  

  p_request.msgHeader() = headers;



  loggers::get_instance().log_msg("sip_codec_request::decode_headers: ", p_request);

  // List unprocessed headers

  int i = 0;

  char *hvalue;

  while (::osip_message_get_unsupported(p_sip_message, i, &hvalue) == 0) {

    loggers::get_instance().warning("sip_codec_request::decode_header: '%s' was not processed", hvalue);

    osip_free(hvalue);

  } // End of 'while' statement

  

  loggers::get_instance().log_msg("<<< sip_codec_request::decode_headers: ", p_request);

} // End of method decode_headers



void sip_codec_request::decode_message_body(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::Request& p_request)

{

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



  osip_body_t* body;

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

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

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

  loggers::get_instance().log("sip_codec_request::decode_message_body: content-type=%p", body->content_type);

  loggers::get_instance().log("sip_codec_request::decode_message_body: body headers size=%d", ::osip_list_size(body->headers));

  osip_content_type_t* content_type = ::osip_message_get_content_type(p_sip_message);

  if (content_type != nullptr) {

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

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

    LibSip__MessageBodyTypes::MessageBody m;

    if (std::string(content_type->subtype).compare("sdp") == 0) {

      LibSip__SDPTypes::SDP__Message sdp_header;

      sdp_message_t* sdp;

      ::sdp_message_init(&sdp);

      if (::sdp_message_parse(sdp, body->body) == 0) {

        char *hvalue = sdp_message_v_version_get(sdp);

        if (hvalue != nullptr) {

          sdp_header.protocol__version() = std::stoi(hvalue);

        }

        sdp_header.origin() = LibSip__SDPTypes::SDP__Origin(

                                                            sdp_message_o_username_get(sdp),

                                                            sdp_message_o_sess_version_get(sdp),

                                                            sdp_message_o_sess_version_get(sdp),

                                                            sdp_message_o_nettype_get(sdp),

                                                            sdp_message_o_addrtype_get(sdp),

                                                            sdp_message_o_addr_get(sdp)

                                                            );

        if ((hvalue = sdp_message_s_name_get(sdp)) != nullptr) {

          sdp_header.session__name() = CHARSTRING(hvalue);

        }

        int i = 0;

        if ((hvalue = sdp_message_t_start_time_get(sdp, i)) != nullptr) {

          LibSip__SDPTypes::SDP__time__list l;

          do {

            LibSip__SDPTypes::SDP__time t;

            LibSip__SDPTypes::SDP__time__field tf;

            tf.start__time() = CHARSTRING(hvalue);

            tf.stop__time() = CHARSTRING(sdp_message_t_stop_time_get(sdp, i));

            t.time__field() = tf;

            t.time__repeat().set_to_omit(); // TODO

            l[i] = t;

            sdp_header.times() = l;

            i += 1;

          } while ((hvalue = sdp_message_t_start_time_get(sdp, i)) != nullptr);

        } else {

          loggers::get_instance().warning("sip_codec_request::decode_message_body: Not start time in sdp");

        }

        // TODO

        loggers::get_instance().warning("sip_codec_request::decode_message_body: Optional SDP not supported yet");

        sdp_header.information().set_to_omit();

        sdp_header.uri().set_to_omit();

        sdp_header.emails().set_to_omit();

        sdp_header.phone__numbers().set_to_omit();

        sdp_header.connection().set_to_omit();

        sdp_header.bandwidth().set_to_omit();

        sdp_header.timezone__adjustments().set_to_omit();

        sdp_header.key().set_to_omit();

        sdp_header.attributes().set_to_omit();

        sdp_header.media__list().set_to_omit();

        m.sdpMessageBody() = sdp_header;

        loggers::get_instance().log_msg("sip_codec_request::decode_message_body: sdp:", m.sdpMessageBody());

      } else {

        loggers::get_instance().warning("sip_codec_request::decode_message_body: sdp_message_parse failed, fallback to textplain");

        m.textplain() = CHARSTRING(body->body);

      }

    } else {

      loggers::get_instance().warning("sip_codec_request::decode_message_body: Unsuported content-type, fallback to textplain");

      m.textplain() = CHARSTRING(body->body);

    }

    p_request.messageBody() = OPTIONAL<LibSip__MessageBodyTypes::MessageBody>(m);

  } else if (body->body != nullptr) {

    LibSip__MessageBodyTypes::MessageBody m;

    m.textplain() = CHARSTRING(body->body);

    p_request.messageBody() = OPTIONAL<LibSip__MessageBodyTypes::MessageBody>(m);

  } else {

    p_request.messageBody().set_to_omit();

  }

  

  loggers::get_instance().log_msg("<<< sip_codec_request::decode_message_body", p_request);

} // End of method decode_message_body



void sip_codec_request::decode_payload(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::Request& p_request)
@@ -1298,6 +1468,7 @@ void sip_codec_request::decode_authorization_header(const osip_message_t* p_sip_ 
                                            );

    }

    if (::osip_authorization_get_nonce(sip_authorization) != nullptr) {

      loggers::get_instance().log("sip_codec_request::decode_authorization_header: Decode nonce");

      LibSip__Common::GenValue v;

      v.tokenOrHost() = CHARSTRING(::osip_authorization_get_nonce(sip_authorization));

      cl[j++] = LibSip__Common::GenericParam(
@@ -1306,6 +1477,7 @@ void sip_codec_request::decode_authorization_header(const osip_message_t* p_sip_ 
                                            );

    }

    if (::osip_authorization_get_response(sip_authorization) != nullptr) {

      loggers::get_instance().log("sip_codec_request::decode_authorization_header: Decode response");

      LibSip__Common::GenValue v;

      v.tokenOrHost() = CHARSTRING(::osip_authorization_get_response(sip_authorization));

      cl[j++] = LibSip__Common::GenericParam(
@@ -1315,7 +1487,7 @@ void sip_codec_request::decode_authorization_header(const osip_message_t* p_sip_ 
    }

    loggers::get_instance().log_msg("sip_codec_request::decode_authorization_header: New GenValue:", cl);

    v.digestResponse() = cl;

    loggers::get_instance().log_msg("sip_codec_request::decode_authorization_header: New GenValue:", cl);

    loggers::get_instance().log_msg("sip_codec_request::decode_authorization_header: New GenValue list:", cl);

    l[i++] = v;

    loggers::get_instance().log_msg("sip_codec_request::decode_authorization_header: New CredentialsList:", l);

  } while(::osip_message_get_authorization(p_sip_message, i, &sip_authorization) == 0); // End of 'do-while' statement
@@ -1346,7 +1518,7 @@ void sip_codec_request::decode_call_id_header(const osip_message_t* p_sip_messag 


void sip_codec_request::decode_c_seq_header(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::CSeq& p_c_seq_header)

{

  loggers::get_instance().log(">>> sip_codec_request::decode_c_seq_header: %p", p_sip_message->cseq);

  loggers::get_instance().log(">>> sip_codec_request::decode_c_seq_header");

  

  // Sanity check

  if (p_sip_message->cseq == nullptr) {
@@ -1354,7 +1526,7 @@ void sip_codec_request::decode_c_seq_header(const osip_message_t* p_sip_message, 
  }



  // FieldName

  p_c_seq_header.fieldName() = LibSip__SIPTypesAndValues::FieldName(LibSip__SIPTypesAndValues::FieldName::str_to_enum("C_SEQ_E"));

  p_c_seq_header.fieldName() = LibSip__SIPTypesAndValues::FieldName(LibSip__SIPTypesAndValues::FieldName::str_to_enum("CSEQ_E"));

  // Sequence number

  p_c_seq_header.seqNumber() = INTEGER(std::stoi(osip_cseq_get_number(p_sip_message->cseq)));

  // Method
@@ -1363,7 +1535,7 @@ void sip_codec_request::decode_c_seq_header(const osip_message_t* p_sip_message, 


void sip_codec_request::decode_content_length_header(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::ContentLength& p_content_length_header)

{

  loggers::get_instance().log(">>> sip_codec_request::decode_content_length_header: %p", p_sip_message->content_length);

  loggers::get_instance().log(">>> sip_codec_request::decode_content_length_header");

  

  // Sanity check

  if (p_sip_message->content_length == nullptr) {
@@ -1383,7 +1555,7 @@ void sip_codec_request::decode_content_length_header(const osip_message_t* p_sip 


void sip_codec_request::decode_content_type_header(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::ContentType& p_content_type_header)

{

  loggers::get_instance().log(">>> sip_codec_request::decode_content_type_header: %p", p_sip_message->content_type);

  loggers::get_instance().log(">>> sip_codec_request::decode_content_type_header");

  

  // Sanity check

  if (p_sip_message->content_type == nullptr) {
@@ -1402,22 +1574,48 @@ void sip_codec_request::decode_content_type_header(const osip_message_t* p_sip_m 
  p_content_type_header.mParams() = params;

} // End of method decode_content_type_header



void sip_codec_request::decode_contact_header(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::Contact& p_contact_header) {

  loggers::get_instance().log("sip_codec_request::decode_contact_header");

  

  // Sanity check

  if (p_sip_message == nullptr) {

    return;

  }

  

  // FieldName

  p_contact_header.fieldName() = LibSip__SIPTypesAndValues::FieldName(LibSip__SIPTypesAndValues::FieldName::str_to_enum("CONTACT_E"));

  // ContactBody

  LibSip__SIPTypesAndValues::ContactAddress__List c;

  int i = 0;

  osip_contact_t* contact = nullptr;

  while (::osip_message_get_contact(p_sip_message, i, &contact) == 0) {

    LibSip__SIPTypesAndValues::ContactAddress contact_addr;

    LibSip__SIPTypesAndValues::SipUrl uri;

    decode_uri(uri, ::osip_contact_get_url((osip_contact_t*)contact));

    LibSip__SIPTypesAndValues::Addr__Union addr;

    OPTIONAL<LibSip__SIPTypesAndValues::DisplayName> display_name;

    if (::osip_contact_get_displayname((osip_contact_t*)contact) != nullptr) {

      LibSip__SIPTypesAndValues::DisplayName n;

      n.token() = CHARSTRING(::osip_contact_get_displayname((osip_contact_t*)contact));

      display_name = OPTIONAL<LibSip__SIPTypesAndValues::DisplayName>(n);

      LibSip__SIPTypesAndValues::NameAddr name_addr(display_name, uri);

      addr.nameAddr() = name_addr;

    } else {

      display_name.set_to_omit();

      addr.addrSpecUnion() = uri;

    }

    contact_addr.addressField() = addr;

    // Params

    OPTIONAL<LibSip__Common::SemicolonParam__List> params;

    decode_semi_colon_params(contact->gen_params, params);

    contact_addr.contactParams() = params;

    

    c[i++] = contact_addr;

  } // End of 'while' statement

  p_contact_header.contactBody().contactAddresses() = c;

  

























  loggers::get_instance().log_msg("<<< sip_codec_request::decode_from_header: ", p_contact_header);

} // End of method decode_contact_header



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

{
@@ -1456,7 +1654,7 @@ void sip_codec_request::decode_from_header(const osip_from_t* p_sip_from, LibSip 


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

{

  loggers::get_instance().log("sip_codec_request::decode_max_forwards_header: %p", p_sip_message->headers);

  loggers::get_instance().log("sip_codec_request::decode_max_forwards_header");



  // Sanity checks

  osip_header_t *dest = nullptr;
@@ -1474,7 +1672,7 @@ void sip_codec_request::decode_max_forwards_header(const osip_message_t* p_sip_m 


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

{

  loggers::get_instance().log("sip_codec_request::decode_supported_header: %p", p_sip_message->headers);

  loggers::get_instance().log("sip_codec_request::decode_supported_header");



  // Sanity checks

  osip_header_t *dest = nullptr;

ccsrc/Protocols/Sip/sip_codec_request.hh

+5 −3

File changed.

Preview size limit exceeded, changes collapsed.

etc/TestCodec/TestCodec.cfg

+2 −2
Original line number Diff line number Diff line
@@ -53,9 +53,9 @@ system.httpPort.params := "HTTP(codecs=held:held_codec;html:html_codec;json:json 


[EXECUTE]

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

TestCodec_Register.tc_register_request_1

#TestCodec_Register.tc_register_request_1

#TestCodec_Register.tc_register_request_2

#TestCodec_Register.tc_invite_request_2

TestCodec_Invite.tc_invite_request_1

#TestCodec_Register.tc_invite_request_2

#TestCodec_HttpRequest.tc_http_get_1

#TestCodec_HttpResponse.tc_http_200_ok_1

ttcn/TestCodec/TestCodec_Register.ttcn

+4 −4

File changed.

Preview size limit exceeded, changes collapsed.

workspace_stf549/.metadata/.plugins/org.eclipse.ui.workbench/workingsets.xml

+1 −0
Original line number Diff line number Diff line 
<?xml version="1.0" encoding="UTF-8"?>

<workingSetManager>

<workingSet aggregate="true" factoryID="org.eclipse.ui.internal.WorkingSetFactory" id="1531374044304_0" label="Window Working Set" name="Aggregate for window 1531374044293"/>

<workingSet aggregate="true" factoryID="org.eclipse.ui.internal.WorkingSetFactory" id="1537705239597_1" label="Window Working Set" name="Aggregate for window 1537705239597"/>

</workingSetManager>
 
 No newline at end of file