Add CallInfo SIP header - Add SIP message body textplain support (df4d21fc) · Commits · EMTEL - Emergency Communications / NG112 Conformance Test Suites

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 $?