sip_codec_headers.cc

#include <iomanip>

#include "LibSip_SIPTypesAndValues.hh"
#include "LibSip_Common.hh"

#include "sip_codec_headers.hh"
#include "loggers.hh"

#include "converter.hh"

#ifdef WIN32
#undef osip_malloc
#undef osip_free
#define osip_malloc(S) malloc(S)
#define osip_free(P) { if (P!=NULL) { free(P);} }
#endif

int sip_codec_headers::encode_headers(const LibSip__SIPTypesAndValues::MessageHeader& p_msg_header, osip_message_t* p_sip_message)
{
  loggers::get_instance().log_msg(">>> sip_codec_headers::encode_headers: ", p_msg_header);
  
  // Encode mandatory fields
  // From
  osip_from_t* from_header = nullptr;
  if (encode_from_header(p_msg_header.fromField(), &from_header) == -1) {
    loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode From header");
    return -1;
  }
  char* hvalue;
  ::osip_from_to_str(from_header, &hvalue);
  loggers::get_instance().log("sip_codec_headers::encode_headers: From:%s", hvalue);
  if (::osip_message_set_from(p_sip_message, hvalue) != OSIP_SUCCESS) {
    loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to set From header in sip_message");
    return -1;
  }

  ::osip_from_free(from_header);
  osip_free(hvalue);
  
  // To
  osip_to_t* to_header = nullptr;
  if (encode_to_header(p_msg_header.toField(), &to_header) == -1) {
    loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode To header");
    return -1;
  }
  int r = ::osip_to_to_str(to_header, &hvalue);
  loggers::get_instance().log("sip_codec_headers::encode_headers: To:'%s'- result:%d", hvalue, r);
  if (::osip_message_set_to(p_sip_message, hvalue) != OSIP_SUCCESS) {
    loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to set To header in sip_message");
    return -1;
  }
  ::osip_to_free(to_header);
  osip_free(hvalue);

  // Via
  osip_via_t* via_header = nullptr;
  if (encode_via_header(p_msg_header.via(), &via_header) == -1) {
    loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode Via header");
    return -1;
  }
  ::osip_via_to_str(via_header, &hvalue);
  loggers::get_instance().log("sip_codec_headers::encode_headers: Via:%s", hvalue);
  std::string str(hvalue);
  std::size_t idx = str.find(" ("); // FIXME Horrible work-around for osip_via_to_str issue (' ()' added sometimes
  if (idx != std::string::npos) {
    str = str.substr(0, idx);
  }
  loggers::get_instance().log("sip_codec_headers::encode_headers: Via (final):%s", str.c_str());
  if (::osip_message_set_via(p_sip_message, str.c_str()) != OSIP_SUCCESS) {
    loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to set Via header in sip_message");
    return -1;
  }
  ::osip_via_free(via_header);
  osip_free(hvalue);

  // Encode Optional fields
  loggers::get_instance().log("sip_codec_headers::encode_headers: Encode Optional fields");
  
  // Accept
  if (p_msg_header.accept().is_present()) {
    if (encode_accept_header(p_msg_header.accept(), &p_sip_message) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode Accept header");
      return -1;
    }
  }
  
  // AcceptContact
  if (p_msg_header.acceptContact().is_present()) {
    if (encode_accept_contact_header(p_msg_header.acceptContact(), &p_sip_message) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode AcceptContact header");
      return -1;
    }
  }
  
  // Allow
  if (p_msg_header.allow().is_present()) {
    if (encode_allow_header(p_msg_header.allow(), &p_sip_message) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode Allow header");
      return -1;
    }
  }
  
  // Authorization
  if (p_msg_header.authorization().is_present()) {
    osip_authorization_t* authorization_header = nullptr;
    if (encode_authorization_header(p_msg_header.authorization(), &authorization_header) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode Authorization header");
      return -1;
    }
    int result = ::osip_authorization_to_str(authorization_header, &hvalue);
    loggers::get_instance().log("sip_codec_headers::encode_headers: Authorization: %s - %d", hvalue, result);
    result = ::osip_message_set_authorization(p_sip_message, hvalue);
    loggers::get_instance().log("sip_codec_headers::encode_headers: SIP Authorization: %p - %d", p_sip_message->authorizations, result);
    ::osip_authorization_free(authorization_header);
    osip_free(hvalue);
  }
  
  // CallInfo
  if (p_msg_header.callInfo().is_present()) {
    if (encode_call_info_header(p_msg_header.callInfo(), &p_sip_message) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode CallInfo header");
      return -1;
    }
  }
  
  // CallId
  if (p_msg_header.callId().is_present()) {
    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_headers::encode_headers: Failed to encode Call_Id header");
      return -1;
    }
    ::osip_call_id_to_str(call_id_header, &hvalue);
    loggers::get_instance().log("sip_codec_headers::encode_headers: Call_Id:%s", hvalue);
    int result = ::osip_message_set_call_id(p_sip_message, hvalue);
    loggers::get_instance().log("sip_codec_headers::encode_headers: SIP Call_Id: %p - %d", p_sip_message->call_id, result);
    ::osip_call_id_free(call_id_header);
    osip_free(hvalue);
  }
  
  // Contact
  if (p_msg_header.contact().is_present()) {
    osip_contact_t* contact_header;
    if (encode_contact_header(p_msg_header.contact(), &contact_header) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode Contact header");
      return -1;
    }
    ::osip_contact_to_str(contact_header, &hvalue);
    loggers::get_instance().log("sip_codec_headers::encode_headers: Contact: %s", hvalue);
    int result = ::osip_message_set_contact(p_sip_message, hvalue);
    loggers::get_instance().log("sip_codec_headers::encode_headers: SIP Contact: %p - %d", p_sip_message->contacts, result);
    ::osip_contact_free(contact_header);
    osip_free(hvalue);
  }
  
  // ContentLength
  osip_content_length_t* content_length_header = nullptr;
  if (encode_content_length_header(p_msg_header.contentLength(), &content_length_header) == -1) {
    loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode ContentLength header");
    return -1;
  }
  ::osip_content_length_to_str(content_length_header, &hvalue);
  loggers::get_instance().log("sip_codec_headers::encode_headers: ContentLength:%s", hvalue);
  ::osip_message_set_content_length(p_sip_message, hvalue);
  ::osip_content_length_free(content_length_header);
  osip_free(hvalue);
  
  // ContentType
  if (p_msg_header.contentType().is_present()) {
    osip_content_type_t* content_type_header = nullptr;
    if (encode_content_type_header(p_msg_header.contentType(), &content_type_header) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode ContentType header");
      return -1;
    }
    ::osip_content_type_to_str(content_type_header, &hvalue);
    loggers::get_instance().log("sip_codec_headers::encode_headers: ContentType:%s", hvalue);
    ::osip_message_set_content_type(p_sip_message, hvalue);
    ::osip_content_type_free(content_type_header);
    osip_free(hvalue);
  }
  
  // CSeq
  osip_cseq_t* cseq_header = nullptr;
  if (encode_c_seq_header(p_msg_header.cSeq(), &cseq_header) == -1) {
    loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode CSeq header");
    return -1;
  }
  ::osip_cseq_to_str(cseq_header, &hvalue);
  loggers::get_instance().log("sip_codec_headers::encode_headers: Cseq:%s", hvalue);
  ::osip_message_set_cseq(p_sip_message, hvalue);
  ::osip_cseq_free(cseq_header);
  osip_free(hvalue);

  // Event
  if (p_msg_header.event().is_present()) {
    if (encode_event_header(p_msg_header.event(), &p_sip_message) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode Event header");
      return -1;
    }
  }

  // Expires
  if (p_msg_header.expires().is_present()) {
    if (encode_expires_header(p_msg_header.expires(), &p_sip_message) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode Expires header");
      return -1;
    }
  }

  // Geolocation
  if (p_msg_header.geolocation().is_present()) {
    if (encode_geolocation_header(p_msg_header.geolocation(), &p_sip_message) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode Geolocation header");
      return -1;
    }
  }

  // GeolocationRouting
  if (p_msg_header.geolocationRouting().is_present()) {
    if (encode_geolocation_routing_header(p_msg_header.geolocationRouting(), &p_sip_message) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode GeolocationRouting header");
      return -1;
    }
  }

  // MaxForwards
  if (p_msg_header.maxForwards().is_present()) {
    if (encode_max_forwards_header(p_msg_header.maxForwards(), &p_sip_message) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode MaxForwards header");
      return -1;
    }
  }
  
  // MinSE
  if (p_msg_header.minSE().is_present()) {
    if (encode_min_se_header(p_msg_header.minSE(), &p_sip_message) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode MinSE header");
      return -1;
    }
  }
  
  // PAccessNetworkInfo
  if (p_msg_header.pAccessNetworkInfo().is_present()) {
    if (encode_p_access_network_info_header(p_msg_header.pAccessNetworkInfo(), &p_sip_message) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode PAccessNetworkInfo header");
      return -1;
    }
  }
  
  // Privacy
  if (p_msg_header.privacy().is_present()) {
    if (encode_privacy_header(p_msg_header.privacy(), &p_sip_message) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode Privacy header");
      return -1;
    }
  }
  
  // Route
  if (p_msg_header.route().is_present()) {
    if (encode_route_header(p_msg_header.route(), &p_sip_message) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode Route header");
      return -1;
    }
  }
  
  // RecordRoute
  if (p_msg_header.recordRoute().is_present()) {
    if (encode_record_route_header(p_msg_header.recordRoute(), &p_sip_message) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode RecordRoute header");
      return -1;
    }
  }
  
  // RSeq
  if (p_msg_header.rSeq().is_present()) {
    if (encode_r_seq_header(p_msg_header.rSeq(), &p_sip_message) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode RSeq header");
      return -1;
    }
  }

  // Supported
  if (p_msg_header.supported().is_present()) {
    if (encode_supported_header(p_msg_header.supported(), &p_sip_message) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode Supported header");
      return -1;
    }
  }
  
  if (p_msg_header.userAgent().is_present()) {
    if (encode_user_agent_header(p_msg_header.userAgent(), &p_sip_message) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode UserAgent header");
      return -1;
    }
  }
  
  // WwwAuthenticate
  if (p_msg_header.wwwAuthenticate().is_present()) {
    osip_www_authenticate_t* www_authenticate_header = nullptr;
    if (encode_www_authenticate_header(p_msg_header.wwwAuthenticate(), &www_authenticate_header) == -1) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to encode WwwAuthenticate header");
      return -1;
    }
    //std::string s("Digest realm=\"testrealm@host.com\", nonce=\"dcd98b7102dd2f0e8b11d0f600bfb0c093\", opaque=\"5ccc069c403ebaf9f0171e9517f40e41\"");
    ::osip_www_authenticate_to_str(www_authenticate_header, &hvalue);
    loggers::get_instance().log("sip_codec_headers::encode_headers: WwwAuthenticate:%s", hvalue);
    if (::osip_message_set_www_authenticate(p_sip_message, hvalue) != OSIP_SUCCESS) {
      loggers::get_instance().warning("sip_codec_headers::encode_headers: Failed to set WwwAuthenticate header in sip_message");
      return -1;
    }
    //int result = ::osip_message_set_www_authenticate(p_sip_message, s.c_str());//hvalue);
    //loggers::get_instance().log("sip_codec_headers::encode_headers: osip_message_set_www_authenticate return code:%d", result);
    osip_free(hvalue);
  }
  
  // TODO continue
  const osip_list_t* p = &(p_sip_message->headers);
  unsigned int pos = 0;
  unsigned int size = ::osip_list_size(p);
  loggers::get_instance().log("Unknown headers count: %d\n", size);
  while (pos < size) {
    const osip_header_t* header = (const osip_header_t*)osip_list_get(p, pos++);
    loggers::get_instance().log("sip_codec_headers::encode_headers: %p: hname='%s' : hvalue='%s'\n", header, header->hname, header->hvalue);
  } // End of 'while' statement

  loggers::get_instance().log("<<< sip_codec_headers::encode_headers");
  return 0;
} // End of method encode_headers

void sip_codec_headers::decode_headers(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::MessageHeader& p_headers)
{
  loggers::get_instance().log(">>> sip_codec_headers::decode_headers");
  
  LibSip__SIPTypesAndValues::MessageHeader headers;
  // Decode mandatory fields
  // From
  loggers::get_instance().log("sip_codec_headers::decode_headers: From");
  LibSip__SIPTypesAndValues::From from_header;
  decode_from_header(::osip_message_get_from(p_sip_message), from_header);
  if (from_header.is_value()) {
    p_headers.fromField() = from_header;
  } else {
    p_headers.fromField().set_to_omit();
  }
  // To
  loggers::get_instance().log("sip_codec_headers::decode_headers: To");
  LibSip__SIPTypesAndValues::To to_header;
  decode_to_header(::osip_message_get_to(p_sip_message), to_header);
  if (to_header.is_value()) {
    p_headers.toField() = to_header;
  } else {
    p_headers.toField().set_to_omit();
  }
  // Via
  loggers::get_instance().log("sip_codec_headers::decode_headers: Via");
  LibSip__SIPTypesAndValues::Via via_header;
  decode_via_header(p_sip_message, via_header);
  if (via_header.is_value()) {
    p_headers.via() = via_header;
  } else {
    p_headers.via().set_to_omit();
  }

  // Decode Optional fields
  LibSip__SIPTypesAndValues::Accept accept_header;
  decode_accept_header(p_sip_message, accept_header);
  if (accept_header.is_value()) {
    p_headers.accept() = accept_header;
  } else {
    p_headers.accept().set_to_omit();
  }

  LibSip__SIPTypesAndValues::AcceptContact accept_contact_header;
  decode_accept_contact_header(p_sip_message, accept_contact_header);
  if (accept_contact_header.is_value()) {
    p_headers.acceptContact() = accept_contact_header;
  } else {
    p_headers.acceptContact().set_to_omit();
  }
  
  LibSip__SIPTypesAndValues::AcceptEncoding accept_encoding_header;
  decode_accept_encoding_header(p_sip_message, accept_encoding_header);
  if (accept_encoding_header.is_value()) {
    p_headers.acceptEncoding() = accept_encoding_header;
  } else {
    p_headers.acceptEncoding().set_to_omit();
  }

  LibSip__SIPTypesAndValues::AcceptLanguage accept_language_header;
  decode_accept_language_header(p_sip_message, accept_language_header);
  if (accept_language_header.is_value()) {
    p_headers.acceptLanguage() = accept_language_header;
  } else {
    p_headers.acceptLanguage().set_to_omit();
  }

  LibSip__SIPTypesAndValues::AlertInfo alert_info_header;
  decode_alert_info_header(p_sip_message, alert_info_header);
  if (alert_info_header.is_value()) {
    p_headers.alertInfo() = alert_info_header;
  } else {
    p_headers.alertInfo().set_to_omit();
  }

  LibSip__SIPTypesAndValues::Allow allow_header;
  decode_allow_header(p_sip_message, allow_header);
  if (allow_header.is_value()) {
    p_headers.allow() = allow_header;
  } else {
    p_headers.allow().set_to_omit();
  }

  LibSip__SIPTypesAndValues::AllowEvents allow_events_header;
  decode_allow_events_header(p_sip_message, allow_events_header);
  if (allow_events_header.is_value()) {
    p_headers.allowEvents() = allow_events_header;
  } else {
    p_headers.allowEvents().set_to_omit();
  }

  LibSip__SIPTypesAndValues::Authorization authorization_header;
  decode_authorization_header(p_sip_message, authorization_header);
  if (authorization_header.is_value()) {
    p_headers.authorization() = authorization_header;
  } else {
    p_headers.authorization().set_to_omit();
  }
  
  p_headers.authenticationInfo().set_to_omit();

  LibSip__SIPTypesAndValues::CallId call_id_header;
  decode_call_id_header(p_sip_message, call_id_header);
  if (call_id_header.is_value()) {
    p_headers.callId() = call_id_header;
  } else {
    p_headers.callId().set_to_omit();
  }
  
  LibSip__SIPTypesAndValues::CallInfo call_info_header;
  decode_call_info_header(p_sip_message, call_info_header);
  if (call_info_header.is_value()) {
    p_headers.callInfo() = call_info_header;
  } else {
    p_headers.callInfo().set_to_omit();
  }

  LibSip__SIPTypesAndValues::Contact contact_header;
  decode_contact_header(p_sip_message, contact_header);
  if (contact_header.is_value()) {
    p_headers.contact() = contact_header;
  } else {
    p_headers.contact().set_to_omit();
  }
  
  p_headers.contentDisposition().set_to_omit();
  p_headers.contentEncoding().set_to_omit();
  p_headers.contentLanguage().set_to_omit();
  
  LibSip__SIPTypesAndValues::ContentLength content_length_header;
  decode_content_length_header(p_sip_message, content_length_header);
  if (content_length_header.is_value()) {
    p_headers.contentLength() = content_length_header;
  } else {
    p_headers.contentLength().set_to_omit();
  }

  LibSip__SIPTypesAndValues::ContentType content_type_header;
  decode_content_type_header(p_sip_message, content_type_header);
  if (content_type_header.is_value()) {
    p_headers.contentType() = content_type_header;
  } else {
    p_headers.contentType().set_to_omit();
  }

  LibSip__SIPTypesAndValues::CSeq c_seq_header;
  decode_c_seq_header(p_sip_message, c_seq_header);
  if (c_seq_header.is_value()) {
    p_headers.cSeq() = c_seq_header;
  } else {
    p_headers.cSeq().set_to_omit();
  }
  
  p_headers.date().set_to_omit();
  p_headers.errorInfo().set_to_omit();
  p_headers.event().set_to_omit();
  p_headers.expires().set_to_omit();
  p_headers.featureCaps().set_to_omit();

  LibSip__SIPTypesAndValues::Geolocation geolocation_header;
  decode_geolocation_header(p_sip_message, geolocation_header);
  if (geolocation_header.is_value()) {
    p_headers.geolocation() = geolocation_header;
  } else {
    p_headers.geolocation().set_to_omit();
  }

  LibSip__SIPTypesAndValues::GeolocationRouting geolocation_routing_header;
  decode_geolocation_routing_header(p_sip_message, geolocation_routing_header);
  if (geolocation_routing_header.is_value()) {
    p_headers.geolocationRouting() = geolocation_routing_header;
  } else {
    p_headers.geolocationRouting().set_to_omit();
  }

  p_headers.historyInfo().set_to_omit();
  p_headers.infoPackage().set_to_omit();
  p_headers.inReplyTo().set_to_omit();

  LibSip__SIPTypesAndValues::Event event_header;
  decode_event_header(p_sip_message, event_header);
  if (event_header.is_value()) {
    p_headers.event() = event_header;
  } else {
    p_headers.event().set_to_omit();
  }

  LibSip__SIPTypesAndValues::Expires expires_header;
  decode_expires_header(p_sip_message, expires_header);
  if (expires_header.is_value()) {
    p_headers.expires() = expires_header;
  } else {
    p_headers.expires().set_to_omit();
  }

  LibSip__SIPTypesAndValues::MaxForwards max_forwards_header;
  decode_max_forwards_header(p_sip_message, max_forwards_header);
  if (max_forwards_header.is_value()) {
    p_headers.maxForwards() = max_forwards_header;
  } else {
    p_headers.maxForwards().set_to_omit();
  }

  p_headers.mimeVersion().set_to_omit();
  p_headers.minExpires().set_to_omit();
  
  LibSip__SIPTypesAndValues::MinSE min_se_header;
  decode_min_se_header(p_sip_message, min_se_header);
  if (min_se_header.is_value()) {
    p_headers.minSE() = min_se_header;
  } else {
    p_headers.minSE().set_to_omit();
  }
  
  p_headers.organization().set_to_omit();
  
  LibSip__SIPTypesAndValues::PAccessNetworkInfo p_access_network_info_header;
  decode_p_access_network_info_header(p_sip_message, p_access_network_info_header);
  if (p_access_network_info_header.is_value()) {
    p_headers.pAccessNetworkInfo() = p_access_network_info_header;
  } else {
    p_headers.pAccessNetworkInfo().set_to_omit();
  }

  p_headers.pAssertedID().set_to_omit();
  p_headers.pAssertedService().set_to_omit();
  p_headers.pAssociatedURI().set_to_omit();
  p_headers.path().set_to_omit();
  p_headers.pCalledPartyID().set_to_omit();
  p_headers.pChargingFunctionAddresses().set_to_omit();
  p_headers.pChargingVector().set_to_omit();
  p_headers.pEarlyMedia().set_to_omit();
  p_headers.pMediaAuthorization().set_to_omit();
  p_headers.pPreferredID().set_to_omit();
  p_headers.pPreferredService().set_to_omit();
  p_headers.priority().set_to_omit();
  
  LibSip__SIPTypesAndValues::Privacy privacy_header;
  decode_privacy_header(p_sip_message, privacy_header);
  if (privacy_header.is_value()) {
    p_headers.privacy() = privacy_header;
  } else {
    p_headers.privacy().set_to_omit();
  }
  
  p_headers.proxyAuthenticate().set_to_omit();
  p_headers.proxyAuthorization().set_to_omit();
  p_headers.proxyRequire().set_to_omit();
  p_headers.pVisitedNetworkID().set_to_omit();
  p_headers.rAck().set_to_omit();
  p_headers.reason().set_to_omit();
  p_headers.recvInfo().set_to_omit();
  p_headers.requestDisposition().set_to_omit();
  p_headers.referredBy().set_to_omit();
  p_headers.referTo().set_to_omit();
  p_headers.referSub().set_to_omit();
  p_headers.replaces().set_to_omit();
  p_headers.replyTo().set_to_omit();
  p_headers.require().set_to_omit();
  
  LibSip__SIPTypesAndValues::RSeq r_seq_header;
  decode_r_seq_header(p_sip_message, r_seq_header);
  if (r_seq_header.is_value()) {
    p_headers.rSeq() = r_seq_header;
  } else {
    p_headers.rSeq().set_to_omit();
  }
  p_headers.retryAfter().set_to_omit();
  
  LibSip__SIPTypesAndValues::Route route_header;
  decode_route_header(p_sip_message, route_header);
  if (route_header.is_value()) {
    p_headers.route() = route_header;
  } else {
    p_headers.route().set_to_omit();
  }
  
  LibSip__SIPTypesAndValues::RecordRoute record_route_header;
  decode_record_route_header(p_sip_message, record_route_header);
  if (record_route_header.is_value()) {
    p_headers.recordRoute() = record_route_header;
  } else {
    p_headers.recordRoute().set_to_omit();
  }
  
  p_headers.securityClient().set_to_omit();
  p_headers.securityServer().set_to_omit();
  p_headers.securityVerify().set_to_omit();
  p_headers.server().set_to_omit();
  p_headers.serviceRoute().set_to_omit();
  
  LibSip__SIPTypesAndValues::SessionExpires session_expires;
  decode_session_expires_header(p_sip_message, session_expires);
  if (session_expires.is_value()) {
    p_headers.sessionExpires() = session_expires;
  } else {
    p_headers.sessionExpires().set_to_omit();
  }
  
  p_headers.sessionId().set_to_omit();
  p_headers.sipETag().set_to_omit();
  p_headers.sipIfMatch().set_to_omit();
  p_headers.subject().set_to_omit();
  p_headers.subscriptionState().set_to_omit();
  
  LibSip__SIPTypesAndValues::Supported supported_header;
  decode_supported_header(p_sip_message, supported_header);
  if (supported_header.is_value()) {
    p_headers.supported() = supported_header;
  } else {
    p_headers.supported().set_to_omit();
  }
  
  p_headers.timestamp__().set_to_omit();
  p_headers.unsupported().set_to_omit();
  p_headers.userToUser().set_to_omit();
  
  LibSip__SIPTypesAndValues::UserAgent user_agent_header;
  decode_user_agent_header(p_sip_message, user_agent_header);
  if (user_agent_header.is_value()) {
    p_headers.userAgent() = user_agent_header;
  } else {
    p_headers.userAgent().set_to_omit();
  }
  p_headers.warning().set_to_omit();

  LibSip__SIPTypesAndValues::WwwAuthenticate www_authenticate_header;
  osip_www_authenticate_t* www_authenticate = nullptr;
  ::osip_message_get_www_authenticate(p_sip_message, 0, &www_authenticate);
  decode_www_authenticate_header(www_authenticate, www_authenticate_header);
  if (www_authenticate_header.is_value()) {
    p_headers.wwwAuthenticate() = www_authenticate_header;
  } else {
    p_headers.wwwAuthenticate().set_to_omit();
  }

  p_headers.resourcePriority().set_to_omit();
  p_headers.answerMode().set_to_omit();
  p_headers.privAnswerMode().set_to_omit();
  p_headers.targetDialog().set_to_omit();
  p_headers.pAnswerState().set_to_omit();
  p_headers.undefinedHeader__List().set_to_omit();
  
  // List unprocessed headers
  const osip_list_t* p = &(p_sip_message->headers);
  unsigned int pos = 0;
  unsigned int size = ::osip_list_size(p);
  loggers::get_instance().log("Unknown headers count: %d\n", size);
  while (pos < size) {
    const osip_header_t* header = (const osip_header_t*)osip_list_get(p, pos++);
    loggers::get_instance().log("sip_codec_headers::decode_headers: %p: hname='%s' : hvalue='%s'\n", header, header->hname, header->hvalue);
  } // End of 'while' statement
  
  loggers::get_instance().log_msg("<<< sip_codec_headers::decode_headers: ", p_headers);
} // End of method decode_headers

int sip_codec_headers::encode_sip_url(const LibSip__SIPTypesAndValues::SipUrl& p_sip_uri, osip_uri_t** p_uri)
{ // TODO To be renamed into encode_uri
  loggers::get_instance().log_msg(">>> sip_codec_headers::encode_sip_uri: ", p_sip_uri);

  std::string host;
  std::string port;
  osip_uri_t *uri = nullptr;
  ::osip_uri_init(&uri);
  const LibSip__SIPTypesAndValues::UriComponents& components = p_sip_uri.components();
  if (components.ischosen(LibSip__SIPTypesAndValues::UriComponents::ALT_sip)) {
    ::osip_uri_set_scheme(uri, (char*)static_cast<const char*>(p_sip_uri.scheme()));
    const LibSip__SIPTypesAndValues::SipUriComponents& s = p_sip_uri.components().sip();
    if (s.userInfo().is_present()) {
      const LibSip__SIPTypesAndValues::UserInfo& u = static_cast<const LibSip__SIPTypesAndValues::UserInfo>(s.userInfo());
      ::osip_uri_set_username(uri, (char*)static_cast<const char*>(static_cast<CHARSTRING>(u.userOrTelephoneSubscriber())));
      if (u.password().is_present()) {
        const CHARSTRING& c = static_cast<CHARSTRING>(u.password());
        ::osip_uri_set_password(uri, (char*)static_cast<const char*>(c));
      }
    }
    encode_host_port(s.hostPort(), host, port);
    if (!host.empty()) {
      ::osip_uri_set_host(uri, (char*)host.c_str());
    }
    if (!port.empty()) {
     ::osip_uri_set_port(uri, (char*)port.c_str());
    }
  } else if (components.ischosen(LibSip__SIPTypesAndValues::UriComponents::ALT_tel)) {
    const LibSip__SIPTypesAndValues::TelUriComponents& t = p_sip_uri.components().tel();
    loggers::get_instance().error("sip_codec_headers::encode_sip_uri: Unsupported LibSip__SIPTypesAndValues::UriComponents::ALT_tel");
  } else if (components.ischosen(LibSip__SIPTypesAndValues::UriComponents::ALT_urn)) {
    const LibSip__SIPTypesAndValues::UrnUriComponents& u = p_sip_uri.components().urn();
    loggers::get_instance().log("sip_codec_headers::encode_sip_uri: Decode Urn");
    std::string str(static_cast<const char*>(p_sip_uri.scheme()));
    str += ":";
    str += static_cast<const char*>(u.namespaceId());
    str += ":";
    str += static_cast<const char*>(u.namespaceSpecificString());
    ::osip_uri_parse(uri, str.c_str());
  } else if (components.ischosen(LibSip__SIPTypesAndValues::UriComponents::ALT_other)) {
    std::string str(static_cast<const char*>(p_sip_uri.scheme()));
    str += ":";
    str += static_cast<const char*>(p_sip_uri.components().other());
    ::osip_uri_parse(uri, str.c_str());
  } // else, noting to do
  
  if (uri != nullptr) {
    ::osip_uri_clone(uri, p_uri);
  } else {
    *p_uri = nullptr;
  }
  
  char* buffer = nullptr;
  std::size_t length = 0;
  int result = ::osip_uri_to_str(*p_uri, &buffer);
  if (result != 0) {
    loggers::get_instance().warning("sip_codec_headers::encode_sip_uri: Failed to encode data structures");
  } else {
    loggers::get_instance().log("sip_codec_headers::encode_sip_uri: URI:%s", buffer);
  }
  
  return 0;
} // End of method encode_sip_url

void sip_codec_headers::encode_host_port(const LibSip__SIPTypesAndValues::HostPort& p_host_port, std::string& p_host, std::string& p_port)
{
  loggers::get_instance().log(">>> sip_codec_headers::encode_host_port");
  
  if (p_host_port.host().is_present()) {
    p_host.assign(static_cast<const char*>(static_cast<CHARSTRING>(p_host_port.host())));
  } else {
    p_host.clear();
  }
  loggers::get_instance().log("sip_codec_headers::encode_host_port: host:'%s'", p_host.c_str());
  if (p_host_port.portField().is_present()) {
    p_port.assign(std::to_string(static_cast<int>(static_cast<INTEGER>(p_host_port.portField()))));
  } else {
    p_port.clear();
  }
  loggers::get_instance().log("sip_codec_headers::encode_port_port: port:'%s'", p_port.c_str());
} // End of method encode_host_port

int sip_codec_headers::encode_accept_header(const LibSip__SIPTypesAndValues::Accept& p_accept, osip_message_t** p_sip_message) {
  loggers::get_instance().log(">>> sip_codec_headers::encode_accept_header");
  
  if (!p_accept.acceptArgs().is_present()) {
    return 0;
  }
  
  const LibSip__SIPTypesAndValues::AcceptBody__List& al = static_cast<const LibSip__SIPTypesAndValues::AcceptBody__List&>(*p_accept.acceptArgs().get_opt_value());
  if (al.lengthof() == 0) {
    return 0;
  }
  std::string accepts;
  for (int i = 0; i < al.lengthof(); i++) {
    const LibSip__SIPTypesAndValues::AcceptBody& b = al[i];
    loggers::get_instance().log_msg("sip_codec_headers::encode_accept_header: b: ", b);
    osip_accept_t *accept;
    accept_init(&accept);
    // Split it using '/' as separator
    std::vector<std::string> output = converter::get_instance().split(static_cast<const char*>(b.mediaRange()), "/");
    accept->type = ::strdup(output[0].c_str());
    if (output.size() > 1) {
      accept->subtype = ::strdup(output[1].c_str());
    }
    if (b.acceptParam().is_present()) {
      encode_semi_colon_params(static_cast<const LibSip__Common::SemicolonParam__List>(b.acceptParam()), &(accept->gen_params));
    }
    char *buff;
    ::osip_accept_to_str(accept, &buff);
    accepts += (const char*)buff;
    accepts += ",";
    osip_free(buff);
    ::osip_accept_free(accept);
    loggers::get_instance().log("sip_codec_headers::encode_accept_header: accepts: %s", accepts.c_str());
  } // End of 'for' statement
  accepts.resize(accepts.length() - 1); // Remove the last ','
  ::osip_message_set_accept(*p_sip_message, ::strdup(accepts.c_str()));
  
  return 0;
} // End of method encode_accept_header

int sip_codec_headers::encode_accept_contact_header(const LibSip__SIPTypesAndValues::AcceptContact& p_accept_contact, osip_message_t** p_sip_message) {
  loggers::get_instance().log(">>> sip_codec_headers::encode_accept_contact_header");

  const LibSip__SIPTypesAndValues::AcRcValue__List& al = p_accept_contact.acValues();
  if (al.lengthof() == 0) {
    return 0;
  }

  std::string accepts;
  for (int i = 0; i < al.lengthof(); i++) {
    const LibSip__SIPTypesAndValues::AcRcValue& a = al[i];
    loggers::get_instance().log_msg("sip_codec_headers::encode_accept_contact_header: a: ", a);
    accepts += static_cast<const char*>(a.wildcard());
    if (a.acRcParams().is_present()) {
      const LibSip__Common::SemicolonParam__List& l = static_cast<const LibSip__Common::SemicolonParam__List&>(*a.acRcParams().get_opt_value());
      for (int j = 0; j < l.lengthof(); j++) {
        accepts += ";";
        const LibSip__Common::GenericParam& p = l[j];
        accepts += static_cast<const char*>(p.id());
        if (p.paramValue().is_present()) {
          const LibSip__Common::GenValue& g = static_cast<const LibSip__Common::GenValue&>(*p.paramValue().get_opt_value());;
          accepts += "=";
          if (g.ischosen(LibSip__Common::GenValue::ALT_tokenOrHost)) {
            accepts += static_cast<const char*>(g.tokenOrHost());
          } else {
            accepts += static_cast<const char*>(g.quotedString());
          }
        }
      } // End of 'for' statement
    }
    accepts += ",";
    loggers::get_instance().log("sip_codec_headers::encode_accept_header: accepts: %s", accepts.c_str());
  } // End of 'for' statement
  accepts.resize(accepts.length() - 1); // Remove the last ','
  ::osip_message_set_header(*p_sip_message, (const char *)"Accept-Contact", ::strdup(accepts.c_str()));

  loggers::get_instance().log("<<< sip_codec_headers::encode_accept_contact_header");
  return 0;
} // End of method encode_accept_contact_header

int sip_codec_headers::encode_allow_header(const OPTIONAL<LibSip__SIPTypesAndValues::Allow>& p_allow, osip_message_t** p_sip_message)
{
  loggers::get_instance().log_msg(">>> sip_codec_headers::encode_allow_header", p_allow);

  const LibSip__SIPTypesAndValues::Allow& allow = static_cast<const LibSip__SIPTypesAndValues::Allow&>(*p_allow.get_opt_value());

  if (!allow.methods().is_present()) {
    return 0;
  }
  
  const LibSip__SIPTypesAndValues::Method__List& m = static_cast<const LibSip__SIPTypesAndValues::Method__List&>(*allow.methods().get_opt_value());
  if (m.lengthof() == 0) {
    return 0;
  }
  
  std::string str(static_cast<const char*>(m[0]));
  if (m.lengthof() > 1) {
    int i = 1;
    do {
      str += ",";
      str += static_cast<const char*>(m[i++]);
    } while (i < m.lengthof());
  }
  ::osip_message_set_header((osip_message_t *)*p_sip_message,(const char *)"Allow", str.c_str());
  
  loggers::get_instance().log("<<< sip_codec_headers::encode_allow_header");
  return 0;
} // End of method encode_allow_header

int sip_codec_headers::encode_authorization_header(const LibSip__SIPTypesAndValues::Authorization& p_authorization, osip_authorization_t** p_authorization_header)
{
  loggers::get_instance().log(">>> sip_codec_headers::encode_authorization_header");
  
  ::osip_authorization_init(p_authorization_header);

  const LibSip__SIPTypesAndValues::CredentialsList& l = p_authorization.body();
  int i = 0;
  do {
    loggers::get_instance().log("sip_codec_headers::encode_authorization_header: Processing item #%d", i);
    const LibSip__SIPTypesAndValues::Credentials& c = l[i++];
    if (c.ischosen(LibSip__SIPTypesAndValues::Credentials::ALT_digestResponse)) {
      bool processed = true;
      const LibSip__Common::CommaParam__List& p = c.digestResponse();
      if (p.lengthof() > 0) {
        loggers::get_instance().log_msg("sip_codec_headers::encode_authorization_header: Processing param ", p);
        int j = 0;
        do {
          const LibSip__Common::GenericParam& g = p[j++];
          std::string str(static_cast<const char*>(g.id()));
          if (str.compare("realm") == 0) {
            loggers::get_instance().log("sip_codec_headers::encode_authorization_header: realm found");
            if (g.paramValue().is_present()) {
              const LibSip__Common::GenValue& v = static_cast<const LibSip__Common::GenValue&>(*g.paramValue().get_opt_value());
              loggers::get_instance().log_msg("sip_codec_headers::encode_authorization_header: GenValue: ", v);
              if (v.ischosen(LibSip__Common::GenValue::ALT_tokenOrHost)) {
                loggers::get_instance().log_msg("sip_codec_headers::encode_authorization_header: tokenOrHost: ", v.tokenOrHost());
                ::osip_authorization_set_realm(*p_authorization_header, (char*)::strdup(static_cast<const char*>(v.tokenOrHost())));
              } else {
                loggers::get_instance().log_msg("sip_codec_headers::encode_authorization_header: quotedString: ", v.quotedString());
                ::osip_authorization_set_realm(*p_authorization_header, (char*)::strdup(static_cast<const char*>(v.quotedString())));
              }
            } else {
              loggers::get_instance().error("sip_codec_headers::encode_authorization_header: Not implemented(4)");
            }
          } else if (str.compare("username") == 0) {
            loggers::get_instance().log("sip_codec_headers::encode_authorization_header: username found");
            if (g.paramValue().is_present()) {
              const LibSip__Common::GenValue& v = static_cast<const LibSip__Common::GenValue&>(*g.paramValue().get_opt_value());
              loggers::get_instance().log_msg("sip_codec_headers::encode_authorization_header: GenValue: ", v);
              if (v.ischosen(LibSip__Common::GenValue::ALT_tokenOrHost)) {
                loggers::get_instance().log_msg("sip_codec_headers::encode_authorization_header: tokenOrHost: ", v.tokenOrHost());
                ::osip_authorization_set_username(*p_authorization_header, (char*)::strdup(static_cast<const char*>(v.tokenOrHost())));
              } else {
                loggers::get_instance().log_msg("sip_codec_headers::encode_authorization_header: quotedString: ", v.quotedString());
                ::osip_authorization_set_username(*p_authorization_header, (char*)::strdup(static_cast<const char*>(v.quotedString())));
              }
            } else {
              loggers::get_instance().error("sip_codec_headers::encode_authorization_header: Not implemented(6)");
            }
          } else if (str.compare("uri") == 0) {
            loggers::get_instance().log("sip_codec_headers::encode_authorization_header: uri found");
            if (g.paramValue().is_present()) {
              const LibSip__Common::GenValue& v = static_cast<const LibSip__Common::GenValue&>(*g.paramValue().get_opt_value());
              loggers::get_instance().log_msg("sip_codec_headers::encode_authorization_header: GenValue: ", v);
              if (v.ischosen(LibSip__Common::GenValue::ALT_tokenOrHost)) {
                loggers::get_instance().log_msg("sip_codec_headers::encode_authorization_header: tokenOrHost: ", v.tokenOrHost());
                ::osip_authorization_set_uri(*p_authorization_header, (char*)::strdup(static_cast<const char*>(v.tokenOrHost())));
              } else {
                loggers::get_instance().log_msg("sip_codec_headers::encode_authorization_header: quotedString: ", v.quotedString());
                ::osip_authorization_set_uri(*p_authorization_header, (char*)::strdup(static_cast<const char*>(v.quotedString())));
              }
            } else {
              loggers::get_instance().error("sip_codec_headers::encode_authorization_header: Not implemented(7)");
            }
          } else if (str.compare("nonce") == 0) {
            loggers::get_instance().log("sip_codec_headers::encode_authorization_header: nonce found");
            if (g.paramValue().is_present()) {
              const LibSip__Common::GenValue& v = static_cast<const LibSip__Common::GenValue&>(*g.paramValue().get_opt_value());
              loggers::get_instance().log_msg("sip_codec_headers::encode_authorization_header: GenValue: ", v);
              if (v.ischosen(LibSip__Common::GenValue::ALT_tokenOrHost)) {
                loggers::get_instance().log_msg("sip_codec_headers::encode_authorization_header: tokenOrHost: ", v.tokenOrHost());
                ::osip_authorization_set_nonce(*p_authorization_header, (char*)::strdup(static_cast<const char*>(v.tokenOrHost())));
              } else {
                loggers::get_instance().log_msg("sip_codec_headers::encode_authorization_header: quotedString: ", v.quotedString());
                ::osip_authorization_set_nonce(*p_authorization_header, (char*)::strdup(static_cast<const char*>(v.quotedString())));
              }
            } else {
              loggers::get_instance().error("sip_codec_headers::encode_authorization_header: Not implemented(10)");
            }
          } else if (str.compare("response") == 0) {
            loggers::get_instance().log("sip_codec_headers::encode_authorization_header: response found");
            if (g.paramValue().is_present()) {
              const LibSip__Common::GenValue& v = static_cast<const LibSip__Common::GenValue&>(*g.paramValue().get_opt_value());
              loggers::get_instance().log_msg("sip_codec_headers::encode_authorization_header: GenValue: ", v);
              if (v.ischosen(LibSip__Common::GenValue::ALT_tokenOrHost)) {
                loggers::get_instance().log_msg("sip_codec_headers::encode_authorization_header: tokenOrHost: ", v.tokenOrHost());
                ::osip_authorization_set_response(*p_authorization_header, (char*)::strdup(static_cast<const char*>(v.tokenOrHost())));
              } else {
                loggers::get_instance().log_msg("sip_codec_headers::encode_authorization_header: quotedString: ", v.quotedString());
                ::osip_authorization_set_response(*p_authorization_header, (char*)::strdup(static_cast<const char*>(v.quotedString())));
              }
            } else {
              loggers::get_instance().error("sip_codec_headers::encode_authorization_header: Not implemented(12)");
            }
          } else {
            loggers::get_instance().log("sip_codec_headers::encode_authorization_header: Set processed to false for %s", str.c_str());
            processed = false;
          }
        } while (j < p.lengthof());
      }
      loggers::get_instance().log("sip_codec_headers::encode_authorization_header: processed: %x", processed);
      if (processed) {
        ::osip_authorization_set_auth_type(*p_authorization_header, (char*)::strdup("Digest"));
      }
    } else {
      const LibSip__SIPTypesAndValues::OtherAuth& o = c.otherResponse();
      loggers::get_instance().error("sip_codec_headers::encode_authorization_header: Not implemented");
    }
  } while (i < l.lengthof());
  
  return 0;
} // End of method encode_authorization_header

int sip_codec_headers::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_headers::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_headers::encode_call_id_header");
  return 0;
} // End of method encode_call_id_header