Organize SIP codec (130c67b5) · Commits · EMTEL - Emergency Communications / NG112 Conformance Test Suites

ccsrc/EncDec/LibSip/LibSip_Encdec.cc

+42 −3

Original line number	Original line	Diff line number	Diff line
	@@ -5,6 +5,8 @@
	#include "sip_codec_register_request.hh"		#include "sip_codec_register_request.hh"
	#include "sip_codec_invite_request.hh"		#include "sip_codec_invite_request.hh"

			#include "sip_codec_response.hh"

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

	namespace LibSip__EncdecDeclarations {		namespace LibSip__EncdecDeclarations {
	@@ -75,11 +77,38 @@ namespace LibSip__EncdecDeclarations {
	BITSTRING fx__enc__REFER__Request(const LibSip__SIPTypesAndValues::REFER__Request& p) { return BITSTRING(); }		BITSTRING fx__enc__REFER__Request(const LibSip__SIPTypesAndValues::REFER__Request& p) { return BITSTRING(); }
	BITSTRING fx__enc__MESSAGE__Request(const LibSip__SIPTypesAndValues::MESSAGE__Request& p) { return BITSTRING(); }		BITSTRING fx__enc__MESSAGE__Request(const LibSip__SIPTypesAndValues::MESSAGE__Request& p) { return BITSTRING(); }
	BITSTRING fx__enc__INFO__Request(const LibSip__SIPTypesAndValues::INFO__Request& p) { return BITSTRING(); }		BITSTRING fx__enc__INFO__Request(const LibSip__SIPTypesAndValues::INFO__Request& p) { return BITSTRING(); }
	BITSTRING fx__enc__Response(const LibSip__SIPTypesAndValues::Response& p) { return BITSTRING(); }
			BITSTRING fx__enc__Response(const LibSip__SIPTypesAndValues::Response& p) {
			loggers::get_instance().log_msg(">>> fx__enc__Response: ", p);

			float duration;
			std::string tag("fx__enc__Response");
			loggers::get_instance().set_start_time(tag);

			OCTETSTRING os;
			sip_codec_response codec;
			if (codec.encode(p, os) == -1) {
			loggers::get_instance().warning("fx__enc__Response: -1 result code was returned");
			return int2bit(0, 1);
			}
			loggers::get_instance().set_stop_time(tag, duration);

			return oct2bit(os);
			}

	BITSTRING fx__enc__Raw(const CHARSTRING& p) { return BITSTRING(); }		BITSTRING fx__enc__Raw(const CHARSTRING& p) { return BITSTRING(); }
	BITSTRING fx__enc__SMS(const LibSip__SimpleMsgSummaryTypes::SimpleMsgSummary& pdu) { return BITSTRING(); }		BITSTRING fx__enc__SMS(const LibSip__SimpleMsgSummaryTypes::SimpleMsgSummary& pdu) { return BITSTRING(); }
	BITSTRING fx__enc__MessageBody(const LibSip__MessageBodyTypes::MessageBody& pdu) { return BITSTRING(); }		BITSTRING fx__enc__MessageBody(const LibSip__MessageBodyTypes::MessageBody& pdu) { return BITSTRING(); }
	INTEGER fx__dec__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::Request& p) { return INTEGER(0); }
			INTEGER fx__dec__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::Request& p) {
			loggers::get_instance().log_msg(">>> fx__dec__Request: ", pdu);

			OCTETSTRING os = bit2oct(pdu);
			sip_codec_request codec;
			codec.decode(os, p);

			return 0;
			}

	INTEGER fx__dec__REGISTER__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::REGISTER__Request& p) {		INTEGER fx__dec__REGISTER__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::REGISTER__Request& p) {
	loggers::get_instance().log_msg(">>> fx__dec__REGISTER__Request: ", pdu);		loggers::get_instance().log_msg(">>> fx__dec__REGISTER__Request: ", pdu);
	@@ -113,7 +142,17 @@ namespace LibSip__EncdecDeclarations {
	INTEGER fx__dec__REFER__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::REFER__Request& p) { return INTEGER(0); }		INTEGER fx__dec__REFER__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::REFER__Request& p) { return INTEGER(0); }
	INTEGER fx__dec__MESSAGE__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::MESSAGE__Request& p) { return INTEGER(0); }		INTEGER fx__dec__MESSAGE__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::MESSAGE__Request& p) { return INTEGER(0); }
	INTEGER fx__dec__INFO__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::INFO__Request& p) { return INTEGER(0); }		INTEGER fx__dec__INFO__Request(BITSTRING& pdu, LibSip__SIPTypesAndValues::INFO__Request& p) { return INTEGER(0); }
	INTEGER fx__dec__Response(BITSTRING& pdu, LibSip__SIPTypesAndValues::Response& p) { return INTEGER(0); }
			INTEGER fx__dec__Response(BITSTRING& pdu, LibSip__SIPTypesAndValues::Response& p) {
			loggers::get_instance().log_msg(">>> fx__dec__Response: ", pdu);

			OCTETSTRING os = bit2oct(pdu);
			sip_codec_response codec;
			codec.decode(os, p);

			return 0;
			}

	INTEGER fx__dec__SMS(BITSTRING& pdu, LibSip__SimpleMsgSummaryTypes::SimpleMsgSummary& p) { return INTEGER(0); }		INTEGER fx__dec__SMS(BITSTRING& pdu, LibSip__SimpleMsgSummaryTypes::SimpleMsgSummary& p) { return INTEGER(0); }
	INTEGER fx__dec__MessageBody(BITSTRING& pdu, LibSip__MessageBodyTypes::MessageBody& p) { return INTEGER(0); }		INTEGER fx__dec__MessageBody(BITSTRING& pdu, LibSip__MessageBodyTypes::MessageBody& p) { return INTEGER(0); }
	} // End of namespace LibSip__EncdecDeclarations		} // End of namespace LibSip__EncdecDeclarations

ccsrc/Protocols/Sip/sip_codec_headers.cc

+39 −9

Original line number	Original line	Diff line number	Diff line
	@@ -820,7 +820,7 @@ int sip_codec_headers::encode_option_tag_list(const LibSip__SIPTypesAndValues::O

	void sip_codec_headers::decode_option_tag_list(const char* p_list, OPTIONAL<LibSip__SIPTypesAndValues::OptionTag__List>& p_options_tags)		void sip_codec_headers::decode_option_tag_list(const char* p_list, OPTIONAL<LibSip__SIPTypesAndValues::OptionTag__List>& p_options_tags)
	{		{
	loggers::get_instance().log(">>> sip_codec_headers::decode_option_tag_list");		loggers::get_instance().log(">>> sip_codec_headers::decode_option_tag_list: %s", p_list);

	if (p_list != nullptr) {		if (p_list != nullptr) {
	LibSip__SIPTypesAndValues::OptionTag__List l;		LibSip__SIPTypesAndValues::OptionTag__List l;
	@@ -832,9 +832,12 @@ void sip_codec_headers::decode_option_tag_list(const char* p_list, OPTIONAL<LibS
	int idx = 0;		int idx = 0;
	while(i != std::string::npos) {		while(i != std::string::npos) {
	l[idx++] = CHARSTRING(str.substr(0, i - 1).c_str());		l[idx++] = CHARSTRING(str.substr(0, i - 1).c_str());
	str = str.substr(i);		str = str.substr(i + 1);
			loggers::get_instance().log("sip_codec_headers::decode_option_tag_list: New str: %s", str.c_str());
	i = str.find(",");		i = str.find(",");
			loggers::get_instance().log("sip_codec_headers::decode_option_tag_list: New i: %d /%d", i, std::string::npos);
	} // End of 'while' statement		} // End of 'while' statement
			l[idx] = CHARSTRING(str.c_str());
	}		}
	p_options_tags = OPTIONAL<LibSip__SIPTypesAndValues::OptionTag__List>(l);		p_options_tags = OPTIONAL<LibSip__SIPTypesAndValues::OptionTag__List>(l);
	} else {		} else {
	@@ -956,10 +959,14 @@ void sip_codec_headers::decode_accept_header(const osip_message_t* p_sip_message
	p_accept_header.acceptArgs().set_to_omit();		p_accept_header.acceptArgs().set_to_omit();
	} else {		} else {
	LibSip__SIPTypesAndValues::AcceptBody__List bl;		LibSip__SIPTypesAndValues::AcceptBody__List bl;
			int x = 0;
	for (int i = 0; i < ::osip_list_size(&p_sip_message->accepts); i++) {		for (int i = 0; i < ::osip_list_size(&p_sip_message->accepts); i++) {
	const osip_accept_t* l = (const osip_accept_t*)::osip_list_get(&p_sip_message->accepts, i);		const osip_accept_t* l = (const osip_accept_t*)::osip_list_get(&p_sip_message->accepts, i);
	if (l != nullptr) {		if (l != nullptr) {
	loggers::get_instance().log("sip_codec_headers::decode_accept_header: %s=%s, %p", l->type, l->subtype, l->gen_params);		loggers::get_instance().log("sip_codec_headers::decode_accept_header: %s=%s", l->type, l->subtype); // application=sdp,application/3gpp-ims+xml
			std::string str(l->subtype);
			std::size_t idx = str.find(",");
			if (idx == std::string::npos) {
	LibSip__SIPTypesAndValues::AcceptBody b;		LibSip__SIPTypesAndValues::AcceptBody b;
	b.mediaRange() = CHARSTRING(l->type) + CHARSTRING("/") + CHARSTRING(l->subtype); // FIXME CHARSTRING(l->type \|\| "=" \|\| l->subtype)???		b.mediaRange() = CHARSTRING(l->type) + CHARSTRING("/") + CHARSTRING(l->subtype); // FIXME CHARSTRING(l->type \|\| "=" \|\| l->subtype)???
	if (osip_list_size(&(l->gen_params)) != 0) {		if (osip_list_size(&(l->gen_params)) != 0) {
	@@ -967,7 +974,30 @@ void sip_codec_headers::decode_accept_header(const osip_message_t* p_sip_message
	} else {		} else {
	b.acceptParam().set_to_omit();		b.acceptParam().set_to_omit();
	}		}
	bl[i] = b;		bl[x++] = b;
			} else {
			std::vector<std::string> output = converter::get_instance().split(str, ",");
			LibSip__SIPTypesAndValues::AcceptBody b;
			loggers::get_instance().log("sip_codec_headers::decode_accept_header: Processing %s=%s", l->type, output[0].c_str());
			b.mediaRange() = CHARSTRING(l->type) + CHARSTRING("/") + CHARSTRING(output[0].c_str()); // FIXME CHARSTRING(l->type \|\| "=" \|\| l->subtype)???
			if (osip_list_size(&(l->gen_params)) != 0) {
			// TODO
			} else {
			b.acceptParam().set_to_omit();
			}
			bl[x++] = b;
			for (unsigned int k = 1; k < output.size(); k++) {
			loggers::get_instance().log("sip_codec_headers::decode_accept_header: In loop, processing %s=%s", output[k].c_str());
			LibSip__SIPTypesAndValues::AcceptBody b;
			b.mediaRange() = CHARSTRING(output[k].c_str()); // FIXME CHARSTRING(l->type \|\| "=" \|\| l->subtype)???
			if (osip_list_size(&(l->gen_params)) != 0) {
			// TODO
			} else {
			b.acceptParam().set_to_omit();
			}
			bl[x++] = b;
			}
			}
	}		}
	} // End of 'for' statement		} // End of 'for' statement
	p_accept_header.acceptArgs() = OPTIONAL<LibSip__SIPTypesAndValues::AcceptBody__List>(bl);		p_accept_header.acceptArgs() = OPTIONAL<LibSip__SIPTypesAndValues::AcceptBody__List>(bl);

ccsrc/Protocols/Sip/sip_codec_headers.hh

+0 −8

Original line number	Original line	Diff line number	Diff line
	@@ -6,10 +6,6 @@
	#include "osipparser2/osip_parser.h"		#include "osipparser2/osip_parser.h"
	#include "osipparser2/sdp_message.h"		#include "osipparser2/sdp_message.h"

	class Base_Type;
	class TTCN_Typedescriptor_t;
	class TTCN_Buffer;

	namespace LibSip__SIPTypesAndValues {		namespace LibSip__SIPTypesAndValues {
	class HostPort;		class HostPort;
	class Authorization;		class Authorization;
	@@ -24,10 +20,6 @@ namespace LibSip__SIPTypesAndValues {
	class PAccessNetworkInfo;		class PAccessNetworkInfo;
	}		}

	namespace LibSip__MessageBodyTypes {
	class MessageBody;
	}

	namespace LibSip__Common {		namespace LibSip__Common {
	class SemicolonParam__List;		class SemicolonParam__List;
	class AmpersandParam__List;		class AmpersandParam__List;

ccsrc/Protocols/Sip/sip_codec_message_body.cc

0 → 100644

+282 −0

Original line number	Original line	Diff line number	Diff line
			#include "LibSip_SIPTypesAndValues.hh"
			#include "LibSip_Common.hh"

			#include "sip_codec_message_body.hh"
			#include "loggers.hh"

			#include "converter.hh"

			int sip_codec_message_body::encode_message_body(const LibSip__MessageBodyTypes::MessageBody& p_message_body, osip_message_t* p_sip_message)
			{ // TODO Rename into encode_message_body
			loggers::get_instance().log(">>> sip_codec_message_body::encode_message_body");

			osip_content_length* content_length = ::osip_message_get_content_length(p_sip_message);
			loggers::get_instance().log("sip_codec_message_body::encode_message_body: content_length= %s", content_length->value);
			if (p_message_body.ischosen(LibSip__MessageBodyTypes::MessageBody::ALT_sdpMessageBody)) {
			const LibSip__SDPTypes::SDP__Message& sdp = p_message_body.sdpMessageBody();
			loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: sdp: ", sdp);

			sdp_message_t* sdp_body;
			::sdp_message_init(&sdp_body);

			// Encode mandatory fields
			// Version
			INTEGER version = sdp.protocol__version();
			::sdp_message_v_version_set(sdp_body, (char*)::strdup(std::to_string(static_cast<const int>(version)).c_str()));
			LibSip__SDPTypes::SDP__Origin origin = sdp.origin();
			// Origin
			loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: origin: ", origin);
			::sdp_message_o_origin_set(
			sdp_body,
			(char)::strdup(static_cast<const char>(origin.user__name())),
			(char)::strdup(static_cast<const char>(origin.session__id())),
			(char)::strdup(static_cast<const char>(origin.session__version())),
			(char)::strdup(static_cast<const char>(origin.net__type())),
			(char)::strdup(static_cast<const char>(origin.addr__type())),
			(char)::strdup(static_cast<const char>(origin.addr()))
			);
			// Session name
			::sdp_message_s_name_set(sdp_body, (char)::strdup(static_cast<const char>(sdp.session__name())));
			// Time, t
			::sdp_message_s_name_set(sdp_body, (char)::strdup(static_cast<const char>(sdp.session__name())));
			loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: times: ", sdp.times());
			for (int i = 0; i < sdp.times().lengthof(); i++) {
			const LibSip__SDPTypes::SDP__time& time = sdp.times()[i];
			loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: time: ", time);
			::sdp_message_t_time_descr_add(sdp_body, (char)::strdup(static_cast<const char>(time.time__field().start__time())), (char)::strdup(static_cast<const char>(time.time__field().stop__time())));
			if (time.time__repeat().is_present()) {
			const LibSip__SDPTypes::SDP__repeat__list& l = static_cast<const OPTIONAL<LibSip__SDPTypes::SDP__repeat__list>&>(*time.time__repeat().get_opt_value());
			loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: l: ", l);
			for (int j = 0; j < l.lengthof(); j++) {
			const LibSip__SDPTypes::SDP__repeat& r = l[j];
			// TODO r.repeat__interval();
			// TODO r.active();
			for (int k = 0; k < r.offsets().lengthof(); k++) {
			const LibSip__SDPTypes::SDP__typed__time& s = r.offsets()[k];
			// TODO ::sdp_message_r_repeat_add(sdp_body, k, char *value);
			}
			// TODO ::sdp_message_r_repeat_add(sdp_body, int pos_time_descr, char *value)
			} // End of 'for' statement
			}
			} // End of 'for' statement

			// Encode optional fields
			// email, e
			loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: emails: ", sdp.emails());
			if (sdp.emails().is_present()) {
			const LibSip__SDPTypes::SDP__email__list& l = static_cast<const LibSip__SDPTypes::SDP__email__list&>(*sdp.emails().get_opt_value());
			for (int i = 0; i < l.lengthof(); i++) {
			const LibSip__SDPTypes::SDP__contact& e = l[i];
			std::string str;
			if (e.disp__name().is_present()) {
			str = static_cast<const char>(static_cast<const CHARSTRING&>(e.disp__name().get_opt_value()));
			str += " ";
			}
			str += static_cast<const char*>(e.addr__or__phone());
			::sdp_message_e_email_add (sdp_body, ::strdup(str.c_str()));
			} // End of 'for' statement
			}
			// Information, i
			loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: information: ", sdp.information());
			if (sdp.information().is_present()) {
			::sdp_message_i_info_set(sdp_body, 0, ::strdup(static_cast<const CHARSTRING&>(*sdp.information().get_opt_value())));
			}
			// Media list, m
			loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: medias: ", sdp.media__list());
			if (sdp.media__list().is_present()) {
			const LibSip__SDPTypes::SDP__media__desc__list& l = static_cast<const LibSip__SDPTypes::SDP__media__desc__list&>(*sdp.media__list().get_opt_value());
			int i = 0;
			for ( ; i < l.lengthof(); i++) {
			const LibSip__SDPTypes::SDP__media__desc m = l[i];
			loggers::get_instance().log_msg("sip_codec_message_body::encode_message_body: media: ", m);
			//::sdp_message_m_media_add(sdp_body, char media, char port, char number_of_port, char proto);
			} // End of 'for' statement
			::sdp_message_endof_media(sdp_body, i);
			}
			// TODO To be continued

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

			char* buff = nullptr;
			::sdp_message_to_str(sdp_body, &buff);
			if (buff != nullptr) {
			::osip_message_set_body(p_sip_message, buff, strlen(buff));
			osip_free(buff);
			sdp_message_free(sdp_body);
			}
			}

			return 0;
			} // End of method encode_message_body

			void sip_codec_message_body::decode_message_body(const osip_message_t* p_sip_message, OPTIONAL<LibSip__MessageBodyTypes::MessageBody>& p_message_body)
			{
			loggers::get_instance().log(">>> sip_codec_message_body::decode_message_body");

			osip_content_length* content_length = ::osip_message_get_content_length(p_sip_message);
			loggers::get_instance().log("sip_codec_message_body::decode_message_body: content_length= %s", content_length->value);
			if (strcmp((const char*)content_length->value, "0") == 0) {
			p_message_body.set_to_omit();
			return;
			}
			// TODO Align the body the content_length

			osip_content_type_t* content_type = ::osip_message_get_content_type(p_sip_message);
			osip_body_t* body;
			int result = ::osip_message_get_body(p_sip_message, 0, &body);
			loggers::get_instance().log("sip_codec_message_body::decode_message_body: result=%d", result);
			if (result != 0) {
			p_message_body.set_to_omit();
			return;
			}
			if (content_type != nullptr) {
			loggers::get_instance().log("sip_codec_message_body::decode_message_body: content-type.type: %s", content_type->type);
			loggers::get_instance().log("sip_codec_message_body::decode_message_body: content-type.subtype: %s", content_type->subtype);
			LibSip__MessageBodyTypes::MessageBody msg_body;
			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) {
			// Mandatroy fields
			// Version, v
			char *hvalue = ::sdp_message_v_version_get(sdp);
			if (hvalue != nullptr) {
			sdp_header.protocol__version() = std::stoi(hvalue);
			}
			// Origin, o
			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)
			);
			// Session name, s
			if ((hvalue = ::sdp_message_s_name_get(sdp)) != nullptr) {
			sdp_header.session__name() = CHARSTRING(hvalue);
			}
			// Time, t
			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;
			i += 1;
			} while ((hvalue = ::sdp_message_t_start_time_get(sdp, i)) != nullptr);
			sdp_header.times() = l;
			} else {
			loggers::get_instance().warning("sip_codec_message_body::decode_message_body: No start time in sdp");
			}
			// Optional fields
			// Emails, e
			i = 0;
			if ((hvalue = ::sdp_message_e_email_get(sdp, i)) != nullptr) {
			LibSip__SDPTypes::SDP__email__list l;
			do {
			LibSip__SDPTypes::SDP__contact e;
			e.addr__or__phone() = CHARSTRING(hvalue);
			e.disp__name().set_to_omit(); // TODO To be refined
			l[i] = e;
			i += 1;
			} while ((hvalue = ::sdp_message_e_email_get(sdp, i)) != nullptr);
			sdp_header.emails() = OPTIONAL<LibSip__SDPTypes::SDP__email__list>(l);
			} else {
			loggers::get_instance().warning("sip_codec_message_body::decode_message_body: No emails in sdp");
			sdp_header.emails().set_to_omit();
			}
			// Information, i
			i = 0;
			if ((hvalue = ::sdp_message_i_info_get(sdp, i)) != nullptr) {
			sdp_header.information() = OPTIONAL<CHARSTRING>(CHARSTRING(hvalue));
			} else {
			loggers::get_instance().warning("sip_codec_message_body::decode_message_body: No information in sdp");
			sdp_header.information().set_to_omit();
			}
			// Media, m
			i = 0;
			if ((hvalue = ::sdp_message_m_media_get(sdp, i)) != nullptr) {
			LibSip__SDPTypes::SDP__media__desc__list l;
			do {
			// Media description
			LibSip__SDPTypes::SDP__media__field f;
			f.media() = CHARSTRING(hvalue);
			LibSip__SDPTypes::SDP__media__port p;
			hvalue = ::sdp_message_m_port_get(sdp, i);
			p.port__number() = std::stoi(hvalue);
			if ((hvalue = ::sdp_message_m_number_of_port_get(sdp, i)) == nullptr) {
			p.num__of__ports().set_to_omit();
			} else {
			p.num__of__ports() = OPTIONAL<INTEGER>(std::stoi(hvalue));
			}
			f.ports() = p;
			f.transport() = CHARSTRING(::sdp_message_m_proto_get(sdp, i));
			LibSip__SDPTypes::SDP__fmt__list fl;
			int j = 0;
			while ((hvalue = ::sdp_message_m_payload_get(sdp, i, j)) != nullptr) {
			fl[j++] = CHARSTRING(hvalue);
			} // End of 'for' statement
			f.fmts() = fl;
			LibSip__SDPTypes::SDP__media__desc m;
			m.media__field() = f;
			// TODO
			// Media attributes
			m.attributes().set_to_omit();
			m.bandwidth().set_to_omit();
			m.information().set_to_omit();
			m.connections().set_to_omit();
			m.key().set_to_omit();
			l[i] = m;
			i += 1;
			} while ((hvalue = ::sdp_message_m_media_get(sdp, i)) != nullptr);
			sdp_header.media__list() = OPTIONAL<LibSip__SDPTypes::SDP__media__desc__list>(l);
			} else {
			loggers::get_instance().warning("sip_codec_message_body::decode_message_body: No media in sdp");
			sdp_header.media__list().set_to_omit();
			}

			// TODO
			loggers::get_instance().warning("sip_codec_message_body::decode_message_body: Optional SDP not supported yet");
			sdp_header.uri().set_to_omit();
			sdp_header.phone__numbers().set_to_omit();
			sdp_header.connection().set_to_omit();
			// Bandwidth
			// sdp_bandwidth_t* b = ::sdp_message_bandwidth_get(sdp, i, j);
			sdp_header.bandwidth().set_to_omit();

			sdp_header.timezone__adjustments().set_to_omit();
			sdp_header.key().set_to_omit();

			// Attribute
			// sdp_attribute_t* a = ::sdp_message_attribute_get(sdp, i, j);
			sdp_header.attributes().set_to_omit();

			// Set message body
			msg_body.sdpMessageBody() = sdp_header;
			loggers::get_instance().log_msg("sip_codec_message_body::decode_message_body: sdp:", msg_body);
			} else {
			loggers::get_instance().warning("sip_codec_message_body::decode_message_body: sdp_message_parse failed, fallback to textplain");
			msg_body.textplain() = CHARSTRING(body->body);
			}
			} else {
			loggers::get_instance().warning("sip_codec_message_body::decode_message_body: Unsuported content-type, fallback to textplain");
			msg_body.textplain() = CHARSTRING(body->body);
			}
			p_message_body = OPTIONAL<LibSip__MessageBodyTypes::MessageBody>(msg_body);
			} else if ((body != nullptr) && (body->body != nullptr)) {
			LibSip__MessageBodyTypes::MessageBody msg_body;
			msg_body.textplain() = CHARSTRING(body->body);
			p_message_body = OPTIONAL<LibSip__MessageBodyTypes::MessageBody>(msg_body);
			} else {
			p_message_body.set_to_omit();
			}

			loggers::get_instance().log_msg("<<< sip_codec_message_body::decode_message_body: ", p_message_body);
			} // End of method decode_message_body

ccsrc/Protocols/Sip/sip_codec_message_body.hh

0 → 100644

+22 −0

Original line number	Original line	Diff line number	Diff line
			#pragma once

			#include "codec.hh"
			#include "params.hh"

			#include "osipparser2/osip_parser.h"
			#include "osipparser2/sdp_message.h"

			namespace LibSip__MessageBodyTypes {
			class MessageBody;
			}

			class sip_codec_message_body
			{
			public:
			explicit sip_codec_message_body() { };
			virtual ~sip_codec_message_body() { };

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

			}; // End of class sip_codec_message_body