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

ccsrc/Protocols/Sip/sip_codec_headers.cc

+490 −5

Original line number	Diff line number	Diff line
		@@ -6,6 +6,491 @@

		#include "converter.hh"

		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: Faile 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: Faile 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: Faile 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: Faile 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: Faile 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: Faile 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: Faile 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: Faile 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: Faile 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);
		}

		// 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: Faile 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: Faile 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: Faile 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: Faile 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: Faile 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);

		// 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: Faile 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: Faile to encode MinSE 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: Faile to encode Supported 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: Faile to encode PAccessNetworkInfo header");
		return -1;
		}
		}

		// 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("%p: hname=%s : hvalue=%s\n", header, header->hname, header->hvalue);
		} // End of 'while' statement

		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
		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
		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
		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();
		}

		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();
		p_headers.geolocation().set_to_omit();
		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::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();


		// TODO
		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();
		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.rSeq().set_to_omit();
		p_headers.reason().set_to_omit();
		p_headers.recordRoute().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();
		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();
		}

		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();
		p_headers.userAgent().set_to_omit();
		p_headers.warning().set_to_omit();
		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
		int i = 0;
		osip_header_t* h_;
		while (::osip_message_get_header(p_sip_message, i++, &h_) == 0) {
		loggers::get_instance().warning("sip_codec_headers::decode_headers: '%s'/'%s' was not processed", h_->hname, h_->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);
		@@ -56,7 +541,7 @@ int sip_codec_headers::encode_sip_url(const LibSip__SIPTypesAndValues::SipUrl& p
		}

		char* buffer = nullptr;
		size_t length = 0;
		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");
		@@ -909,7 +1394,7 @@ void sip_codec_headers::decode_uri(LibSip__SIPTypesAndValues::SipUrl& p_sip_url,
		LibSip__SIPTypesAndValues::UrnUriComponents urn;
		urn.namespaceId() = output[1].c_str();
		std::string s(output[2]);
		for (size_t i = 3; i < output.size(); i++) {
		for (std::size_t i = 3; i < output.size(); i++) {
		s += ":" + output[i];
		}
		urn.namespaceSpecificString() = s.c_str();
		@@ -1061,7 +1546,7 @@ void sip_codec_headers::decode_accept_contact_header(const osip_message_t* p_sip
		} else {
		// Split the list of values using , as separator
		std::vector<std::string> lop = converter::get_instance().split(str, ",");
		for (size_t s = 0; s < lop.size(); s++) {
		for (std::size_t s = 0; s < lop.size(); s++) {
		str = lop[s];
		// Extract parameters separated by ; into SemiColumn__List
		std::vector<std::string> output = converter::get_instance().split(str, ";");
		@@ -1375,7 +1860,7 @@ void sip_codec_headers::decode_contact_header(const osip_message_t* p_sip_messag
		loggers::get_instance().log("sip_codec_headers::decode_contact_header");

		// Sanity check
		if (p_sip_message == nullptr) {
		if (::osip_list_size(&p_sip_message->contacts) == 0) {
		return;
		}

		@@ -1495,7 +1980,7 @@ void sip_codec_headers::decode_min_se_header(const osip_message_t* p_sip_message
		void sip_codec_headers::decode_route_header(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::Route& p_route_header) {
		loggers::get_instance().log("sip_codec_headers::decode_route_header");
		// Sanity check
		if (p_sip_message == nullptr) {
		if (::osip_list_size(&p_sip_message->routes) == 0) {
		return;
		}

ccsrc/Protocols/Sip/sip_codec_headers.hh

+3 −0

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

		namespace LibSip__SIPTypesAndValues {
		class MessageHeader;
		class HostPort;
		class Authorization;
		class From;
		@@ -32,6 +33,7 @@ public:
		virtual ~sip_codec_headers() { };

		public:
		virtual int encode_headers(const LibSip__SIPTypesAndValues::MessageHeader& p_msg_header, osip_message_t* p_sip_message);
		virtual int encode_sip_url(const LibSip__SIPTypesAndValues::SipUrl& p_sip_uri, osip_uri_t** p_uri);
		virtual int encode_accept_header(const LibSip__SIPTypesAndValues::Accept& p_accept, osip_message_t** p_sip_message);
		virtual int encode_accept_contact_header(const LibSip__SIPTypesAndValues::AcceptContact& p_accept_contact, osip_message_t** p_sip_message);
		@@ -53,6 +55,7 @@ public:

		public:
		// TODO Replace const osip_message_t* p_sip_message by header specific type using osip_parser.h/macros such as osip_message_get_accept/osip_accept_t
		virtual void decode_headers(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::MessageHeader& p_headers);
		virtual void decode_uri(LibSip__SIPTypesAndValues::SipUrl& p_sip_url, const osip_uri_t* p_uri);
		virtual void decode_accept_header(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::Accept& p_accept_header);
		virtual void decode_accept_contact_header(const osip_message_t* p_sip_message, LibSip__SIPTypesAndValues::AcceptContact& p_accept_contact_header);

ccsrc/Protocols/Sip/sip_codec_request.cc

+10 −453

File changed.

Preview size limit exceeded, changes collapsed.

ccsrc/Protocols/Sip/sip_codec_response.cc

+14 −375

File changed.

Preview size limit exceeded, changes collapsed.

etc/TestCodec/TestCodec.cfg

+1 −0

Original line number	Diff line number	Diff line
		@@ -58,6 +58,7 @@ system.httpPort.params := "HTTP(codecs=held:held_codec;html:html_codec;json:json
		#TestCodec_Invite.tc_invite_request_1
		#TestCodec_Invite.tc_invite_request_2
		TestCodec_Invite.tc_invite_request_3
		TestCodec_Responses.tc_100_trying_1
		#TestCodec_Responses.tc_100_trying_1
		#TestCodec_HttpRequest.tc_http_get_1
		#TestCodec_HttpResponse.tc_http_200_ok_1