Commit df4d21fc authored by YannGarcia's avatar YannGarcia
Browse files

Add CallInfo SIP header - Add SIP message body textplain support

parent 70453eab

ccsrc/EncDec/LibEmtel/LibNg112_EncDec.cc

+96 −12
Original line number Diff line number Diff line 
#include "LibNg112_EncdecDeclarations.hh"



namespace LibNg112__EncdecDeclarations {

#include "json_codec.hh"



  BITSTRING enc__DequeueRegistrationRequest(const LibNg112__DequeueRegistration::DequeueRegistrationRequest& p) {

    return BITSTRING(); // TODO

#include "loggers.hh"



namespace LibNg112__EncdecDeclarations { // TODO File to be removed



/*  BITSTRING enc__DequeueRegistrationRequest(const LibNg112__DequeueRegistration::DequeueRegistrationRequest& p) {

    loggers::get_instance().log_msg(">>> enc__DequeueRegistrationRequest: ", (const Base_Type&)p);



    OCTETSTRING os;

    json_codec codec;

    codec.encode(p, os);



    return oct2bit(os);

  }



  INTEGER dec__DequeueRegistrationRequest(BITSTRING& pdu, LibNg112__DequeueRegistration::DequeueRegistrationRequest& p) {

    return 0; // TODO

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



    OCTETSTRING os = bit2oct(pdu);

    json_codec codec;

    codec.decode(os, p);



    return 0;

  }



  BITSTRING enc__DequeueRegistrationResponse(const LibNg112__DequeueRegistration::DequeueRegistrationResponse& p) {

    return BITSTRING(); // TODO

    loggers::get_instance().log_msg(">>> enc__DequeueRegistrationResponse: ", (const Base_Type&)p);



    OCTETSTRING os;

    json_codec codec;

    codec.encode(p, os);



    return oct2bit(os);

  }



  INTEGER dec__DequeueRegistrationResponse(BITSTRING& pdu, LibNg112__DequeueRegistration::DequeueRegistrationResponse& p) {

    return 0; // TODO

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



    OCTETSTRING os = bit2oct(pdu);

    json_codec codec;

    codec.decode(os, p);



    return 0;

  }



  BITSTRING enc__ServiceStatePayload(const LibNg112__SubscriptionPayloads::ServiceStatePayload& p) {

    return BITSTRING(); // TODO

    loggers::get_instance().log_msg(">>> enc__ServiceStatePayload: ", (const Base_Type&)p);



    OCTETSTRING os;

    json_codec codec;

    codec.encode(p, os);



    return oct2bit(os);

  }



  INTEGER dec__ServiceStatePayload(BITSTRING& pdu, LibNg112__SubscriptionPayloads::ServiceStatePayload& p) {

    return 0; // TODO

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



    OCTETSTRING os = bit2oct(pdu);

    json_codec codec;

    codec.decode(os, p);



    return 0;

  }



  BITSTRING enc__ElementStatePayload(const LibNg112__SubscriptionPayloads::ElementStatePayload& p) {

    return BITSTRING(); // TODO

    loggers::get_instance().log_msg(">>> enc__ElementStatePayload: ", (const Base_Type&)p);



    OCTETSTRING os;

    json_codec codec;

    codec.encode(p, os);



    return oct2bit(os);

  }



  INTEGER dec__ElementStatePayload(BITSTRING& pdu, LibNg112__SubscriptionPayloads::ElementStatePayload& p) {

    return 0; // TODO

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



    OCTETSTRING os = bit2oct(pdu);

    json_codec codec;

    codec.decode(os, p);



    return 0;

  }



  BITSTRING enc__SecurityPosturePayload(const LibNg112__SubscriptionPayloads::SecurityPosturePayload& p) {

    return BITSTRING(); // TODO

    loggers::get_instance().log_msg(">>> enc__SecurityPosturePayload: ", (const Base_Type&)p);



    OCTETSTRING os;

    json_codec codec;

    codec.encode(p, os);



    return oct2bit(os);

  }



  INTEGER dec__SecurityPosturePayload(BITSTRING& pdu, LibNg112__SubscriptionPayloads::SecurityPosturePayload& p) {

    return 0; // TODO

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



    OCTETSTRING os = bit2oct(pdu);

    json_codec codec;

    codec.decode(os, p);



    return 0;

  }



  BITSTRING enc__QueueStatePayload(const LibNg112__SubscriptionPayloads::QueueStatePayload& p) {

    loggers::get_instance().log_msg(">>> enc__QueueStatePayload: ", (const Base_Type&)p);



    OCTETSTRING os;

    json_codec codec;

    codec.encode(p, os);



    return oct2bit(os);

  }



  INTEGER dec__QueueStatePayload(BITSTRING& pdu, LibNg112__SubscriptionPayloads::QueueStatePayload& p) {

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



    OCTETSTRING os = bit2oct(pdu);

    json_codec codec;

    codec.decode(os, p);



    return 0;

  }

*/

} // End of namespace LibNg112__EncdecDeclarations

ccsrc/Protocols/Sip/sip_codec_headers.cc

+86 −1
Original line number Diff line number Diff line
@@ -113,6 +113,14 @@ int sip_codec_headers::encode_headers(const LibSip__SIPTypesAndValues::MessageHe 
    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;
@@ -423,7 +431,13 @@ void sip_codec_headers::decode_headers(const osip_message_t* p_sip_message, LibS 
    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);
@@ -979,6 +993,43 @@ int sip_codec_headers::encode_call_id_header(const LibSip__SIPTypesAndValues::Ca 
  return 0;

} // End of method encode_call_id_header



int sip_codec_headers::encode_call_info_header(const OPTIONAL<LibSip__SIPTypesAndValues::CallInfo>& p_call_info, osip_message_t** p_sip_message) {

  loggers::get_instance().log_msg(">>> sip_codec_headers::encode_call_info_header", p_call_info);

  

  const LibSip__SIPTypesAndValues::CallInfo& call_info = static_cast<const LibSip__SIPTypesAndValues::CallInfo&>(*p_call_info.get_opt_value());



  if (!call_info.callInfoBody().is_present()) {

    return 0;

  }

  

  const LibSip__SIPTypesAndValues::CallInfoBody__List& c = static_cast<const LibSip__SIPTypesAndValues::CallInfoBody__List&>(*call_info.callInfoBody().get_opt_value());

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

    return 0;

  }

  

  int pos = 0;

  std::string value;

  do {

    const LibSip__SIPTypesAndValues::CallInfoBody& call_info_body = c[pos++];

    loggers::get_instance().log_msg("sip_codec_headers::encode_call_info_header: Processing ", call_info_body);

    osip_call_info_t *header;

    ::osip_call_info_init(&header);

    ::osip_call_info_set_uri(header, (char*)static_cast<const char*>(call_info_body.url()));

    if (call_info_body.infoParams().is_present()) {

      encode_semi_colon_params(static_cast<const LibSip__Common::SemicolonParam__List>(call_info_body.infoParams()), &(header)->gen_params);

    }

    char *buffer;

    ::osip_call_info_to_str(header, &buffer);

    value += buffer;

    osip_free(buffer);

    osip_free(header);

    loggers::get_instance().log("sip_codec_headers::encode_call_info_header: value=%s", value.c_str());

  } while (pos < c.lengthof());

  ::osip_message_set_header((osip_message_t *)*p_sip_message, (const char *)"callInfo", value.c_str()); 

  loggers::get_instance().log("<<< sip_codec_headers::encode_call_info_header");

  return 0;

} // End of method encode_call_info_header



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

  loggers::get_instance().log(">>> sip_codec_headers::encode_contact_header");
@@ -2432,6 +2483,40 @@ void sip_codec_headers::decode_call_id_header(const osip_message_t* p_sip_messag 
  }

} // End of method decode_call_id_header



void sip_codec_headers::decode_call_info_header(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::CallInfo& p_call_info_header)

{

  loggers::get_instance().log(">>> sip_codec_headers::decode_call_info_header: %p", p_sip_message->call_infos);

  

  osip_call_info_t *call_info = nullptr;

  ::osip_message_get_call_info(p_sip_message, 0, &call_info);

  if (call_info == nullptr) {

    return;

  }



  // FieldName

  p_call_info_header.fieldName() = LibSip__SIPTypesAndValues::FieldName(LibSip__SIPTypesAndValues::FieldName::str_to_enum("CALL_INFO_E"));

  // CallInfoBody_List

  loggers::get_instance().log("sip_codec_headers::decode_call_info_header: value: %s", call_info->element);

  if ((call_info->element == nullptr) || (strlen(call_info->element) == 0)) {

    p_call_info_header.callInfoBody().set_to_omit();

  } else if (osip_list_size(&(p_sip_message->call_infos)) == 0) {

    p_call_info_header.callInfoBody().set_to_omit();

  } else {

    LibSip__SIPTypesAndValues::CallInfoBody__List l;

    int pos = 0;

    while (pos < osip_list_size(&(p_sip_message->call_infos))) {

      ::osip_message_get_call_info(p_sip_message, pos, &call_info);	

      loggers::get_instance().log("sip_codec_headers::decode_call_info_header: call_info.element=%s", call_info->element);

      OPTIONAL<LibSip__Common::SemicolonParam__List> params;

      decode_semi_colon_params(call_info->gen_params, params);

      l[pos++] = LibSip__SIPTypesAndValues::CallInfoBody(call_info->element, params);

    } // End of 'while' statement

    p_call_info_header.callInfoBody() = OPTIONAL<LibSip__SIPTypesAndValues::CallInfoBody__List>(l);

  }



  loggers::get_instance().log_msg("<<< sip_codec_headers::decode_call_info_header: ", p_call_info_header);

} // End of method decode_call_info_header



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

{

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

ccsrc/Protocols/Sip/sip_codec_headers.hh

+3 −0
Original line number Diff line number Diff line
@@ -9,6 +9,7 @@ 
namespace LibSip__SIPTypesAndValues {

  class Authorization;

  class CallId;

  class CallInfo;

  class ContentLength;

  class ContentType;

  class CSeq;
@@ -50,6 +51,7 @@ public: 
  virtual int encode_allow_header(const OPTIONAL<LibSip__SIPTypesAndValues::Allow>& p_allow, osip_message_t** p_sip_message);

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

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

  virtual int encode_call_info_header(const OPTIONAL<LibSip__SIPTypesAndValues::CallInfo>& p_call_info, osip_message_t** p_sip_message);

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

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

  virtual int encode_content_type_header(const LibSip__SIPTypesAndValues::ContentType& p_contact, osip_content_type_t** p_content_type_header);
@@ -87,6 +89,7 @@ public: 
  virtual void decode_allow_events_header(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::AllowEvents& p_allow_events_header);

  virtual void decode_authorization_header(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::Authorization& p_authorization_header);

  virtual void decode_call_id_header(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::CallId& p_call_id_header);

  virtual void decode_call_info_header(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::CallInfo& p_call_info_header);

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

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

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

ccsrc/Protocols/Sip/sip_codec_message_body.cc

+5 −1
Original line number Diff line number Diff line
@@ -39,6 +39,8 @@ int sip_codec_message_body::encode (const LibSip__MessageBodyTypes::MessageBody& 
      osip_free(buff);

      sdp_message_free(sdp_body);

    }

  } else if (msg.ischosen(LibSip__MessageBodyTypes::MessageBody::ALT_textplain)) {

    data = char2oct(msg.textplain());

  } else {

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

    return -1;
@@ -78,6 +80,9 @@ int sip_codec_message_body::encode_message_body(const LibSip__MessageBodyTypes:: 
      osip_free(buff);

      sdp_message_free(sdp_body);

    }

  } else if (p_message_body.ischosen(LibSip__MessageBodyTypes::MessageBody::ALT_textplain)) {

    const CHARSTRING& text = p_message_body.textplain();

    ::osip_message_set_body(p_sip_message, static_cast<const char*>(text), text.lengthof());

  } else if (p_message_body.ischosen(LibSip__MessageBodyTypes::MessageBody::ALT_mimeMessageBody)) {

    ::osip_message_set_mime_version(p_sip_message, "2.0");

    const LibSip__MessageBodyTypes::MIME__Message& mime = p_message_body.mimeMessageBody();
@@ -147,7 +152,6 @@ int sip_codec_message_body::encode_message_body(const LibSip__MessageBodyTypes:: 
      }

      pos += 1;

    } // End of 'while' statement

    

  } else {

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

    return -1;

mocks/AtsESRP/QUEUE_STATE_BV_02/run.sh

0 → 100755
+7 −0
Original line number Diff line number Diff line 
#!/bin/bash

set -e

#set -vx



sipp -t t1 -trace_msg -m 1 -sf Scenario.xml 127.0.0.1:5080



exit $?