Merge branch 'devel' of https://forge.etsi.org/rep/int/5g-core/ngap into devel (f24967ee) · Commits · INT - Core Network and Interoperability Testing / 5G Core / NGAP

ccsrc/Asn1c/oer_codec.hh

deleted100644 → 0

+0 −42

Original line number	Diff line number	Diff line
		#pragma once

		#include "params.hh"
		#include "asn1_recoder.hh"

		class OCTETSTRING;
		class CHARSTRING;
		class BITSTRING;

		struct asn_TYPE_descriptor_s;

		template<typename TPDU> class oer_codec : public asn1_recoder
		{
		public:
		virtual int encode(const TPDU& msg, BITSTRING& bits) = 0;
		virtual int decode(const BITSTRING& bits, TPDU& msg) = 0;

		protected:
		inline int _decode (const TTCN_Typedescriptor_t& ttcn, const asn_TYPE_descriptor_s & td, const BITSTRING& p_data, TPDU& msg) {
		TTCN_Buffer buf(bit2oct(p_data));
		TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL, TTCN_EncDec::EB_WARNING);
		int rc = oer2xer (td, buf);
		if (rc > 0) {
		msg.decode(ttcn, buf, TTCN_EncDec::CT_BER, BER_ACCEPT_ALL);
		rc = buf.get_len();
		}
		return rc;
		}
		inline int _encode (const TTCN_Typedescriptor_t& ttcn, const asn_TYPE_descriptor_s & td, const TPDU& msg, BITSTRING& p_data) {
		int rc = -1;
		TTCN_Buffer buf;
		TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL, TTCN_EncDec::EB_WARNING);
		msg.encode(ttcn, buf, TTCN_EncDec::CT_BER, BER_ENCODE_DER);
		if (buf.get_len() > 0) {
		rc = xer2oer (td, buf);
		if (rc > 0) {
		p_data = oct2bit(OCTETSTRING(buf.get_len(), buf.get_data()));
		}
		}
		return rc;
		}
		};

ccsrc/EncDec/LibNGAP_Encdec.cc

+10 −0

Original line number	Diff line number	Diff line
		@@ -114,6 +114,16 @@ namespace LibNGAP__EncdecDeclarations {
		return -1;
		}

		BITSTRING fx__enc__PDUSessionResourceModifyRequestTransfer(const NGAP__IEs::PDUSessionResourceModifyRequestTransfer& p) {
		loggers::get_instance().log_msg(">>> fx__enc__PDUSessionResourceSetupUnsuccessfulTransfer ", p);
		return int2bit(0, 1);
		}

		INTEGER fx__dec__PDUSessionResourceModifyRequestTransfer(BITSTRING& pdu, NGAP__IEs::PDUSessionResourceModifyRequestTransfer& p) {
		loggers::get_instance().log(">>> fx__dec__PDUSessionResourceSetupUnsuccessfulTransfer");
		return -1;
		}


		/****************************************************
		* @desc External function to encode a .... type

ccsrc/Protocols/NGAP/ngap_codec.cc

+3 −141

Original line number	Diff line number	Diff line
		@@ -2,165 +2,27 @@
		#include "LibNGAP_TypesAndValues.hh"
		#include "asn1/asn_application.h" // from asn1c
		#include "loggers.hh"
		#include "NGAP_PDU_Descriptions.hh"

		template <typename T_type> class OPTIONAL;
		class TTCN_EncDec;


		//int ngap_codec::encode(const NGAP__PDU__Descriptions::NGAP__PDU , OCTETSTRING &data) {return 0;}
		int ngap_codec::encode(const NGAP__PDU__Descriptions::NGAP__PDU& ngap, OCTETSTRING &data) {
		loggers::get_instance().log(">>> ngap_codec::encode");

		BITSTRING b;
		int rc = asn_codec.encode(ngap, b);
		loggers::get_instance().log("ngap_codec::encode: ASN.1 codec returned %d", rc);
		if (rc>0) {
		//loggers::get_instance().log_msg("ngap_codec::encode: ", b);
		//loggers::get_instance().log_msg("ngap_codec::encode: ", data);
		if (rc) {
		data = bit2oct(b);
		loggers::get_instance().log_msg("ngap_codec::encode: ", data);
		}else{
		loggers::get_instance().log(">>> ngap_codec::encode: errcode %d", rc);

		}
		return rc;


		/*TTCN_EncDec::clear_error();
		TTCN_Buffer encoding_buffer;
		encode_(ngap, *ngap.get_descriptor(), encoding_buffer);
		data = OCTETSTRING(encoding_buffer.get_len(), encoding_buffer.get_data());
		return 0;*/
		}

		int ngap_codec::encode_(const Base_Type &type, const TTCN_Typedescriptor_t &field_descriptor, TTCN_Buffer &encoding_buffer) {
		loggers::get_instance().log(">>> ngap_codec::encode_: processing %s/%s", type.get_descriptor()->name, field_descriptor.name);
		loggers::get_instance().log_msg(">>> ngap_codec::encode_: ", type);

		/if (dynamic_cast<const Record_Type >(&type) != NULL) {
		const Record_Type &r = (const Record_Type &)type;
		// loggers::get_instance().log("btp_codec::encode_: processing Record_Type %s", r.get_descriptor()->name);
		for (int i = 0; i < r.get_count(); i++) {
		// loggers::get_instance().log("btp_codec::encode_: processing %s/%s/%s - %d (1 ==> use dynamic_cast<const OPTIONAL<...>) - %d", r.fld_name(i),
		// r.fld_descr(i)->name, r.get_at(i)->get_descriptor()->name, r.get_at(i)->is_optional(), r.get_at(i)->is_present());
		if (r.get_at(i)->is_present()) {
		if (encode_(r.get_at(i), r.fld_descr(i), encoding_buffer) == -1) {
		// loggers::get_instance().warning("btp_codec::encode_: -1 result code returned");
		return -1;
		}
		}
		} // End of 'for' statement
		} else if (std::string(field_descriptor.name).compare("@LibItsBtp_TypesAndValues.BtpPacket.payload") == 0) {
		const OPTIONAL<LibItsBtp__TypesAndValues::BtpRawPayload> &v = dynamic_cast<const OPTIONAL<LibItsBtp__TypesAndValues::BtpRawPayload> &>(type);
		// loggers::get_instance().log("btp_codec::encode_: BtpRawPayload present: %d", v.is_present());
		if (v.is_present()) {
		if (encode_(static_cast<const LibItsBtp__TypesAndValues::BtpRawPayload &>(*v.get_opt_value()), LibItsBtp__TypesAndValues::BtpRawPayload_descr_,
		encoding_buffer) == -1) {
		// loggers::get_instance().warning("btp_codec::encode_: -1 result code returned");
		return -1;
		}
		}
		} else {
		// loggers::get_instance().log("btp_codec::encode_ (else): processing type %s/%s", type.get_descriptor()->name, field_descriptor.name);
		type.encode(field_descriptor, encoding_buffer, TTCN_EncDec::CT_RAW);
		}
		*/
		loggers::get_instance().log_to_hexa("<<<btp_codec::encode_: encoding_buffer=", encoding_buffer);
		return 0;
		}



		//int ngap_codec::decode(const OCTETSTRING &data, NGAP__PDU__Descriptions::NGAP__PDU &ngap, params_ *params) {return 0;}
		int ngap_codec::decode(const OCTETSTRING &data, NGAP__PDU__Descriptions::NGAP__PDU &ngap, params *params) {
		int ngap_codec::decode(const OCTETSTRING &data, NGAP__PDU__Descriptions::NGAP__PDU &ngap, params_ngap *params) {
		loggers::get_instance().log_msg(">>> ngap_codec::decode: ", data);

		int rc = asn_codec.decode(oct2bit(data), ngap);
		loggers::get_instance().log("ngap_codec::decode: ASN.1 codec returned %d", rc);
		if (rc>0) {
		if (rc) {
		loggers::get_instance().log_msg("ngap_codec::decode: ", ngap);
		}else{
		loggers::get_instance().log(">>> ngap_codec::decode: errcode %d", rc);
		}
		return rc;


		/* TTCN_EncDec::clear_error();
		TTCN_Buffer decoding_buffer(data);
		//_params = params;

		loggers::get_instance().log_to_hexa(">>> ngap_codec::decode: decoding_buffer=", decoding_buffer);
		decode_(ngap, *ngap.get_descriptor(), decoding_buffer);

		loggers::get_instance().log_msg("<<< ngap_codec::decode: ", (const Base_Type&)ngap);

		return 0;*/
		}

		int ngap_codec::decode_(Base_Type &type, const TTCN_Typedescriptor_t &field_descriptor, TTCN_Buffer &decoding_buffer) {
		loggers::get_instance().log(">>> ngap_codec::decode_: processing %s/%s (%d,%d,%p)", type.get_descriptor()->name, field_descriptor.name,
		decoding_buffer.get_len(), decoding_buffer.get_pos(), decoding_buffer.get_read_data());

		/if (dynamic_cast<Record_Type >(&type) != NULL) {
		Record_Type &r = (Record_Type &)type;
		// loggers::get_instance().log("btp_codec::decode_: processing Record_Type %s", r.get_descriptor()->name);
		for (int i = 0; i < r.get_count(); i++) {
		// loggers::get_instance().log("btp_codec::decode_: processing %s/%s/%s", r.fld_name(i), r.fld_descr(i)->name, r.get_at(i)->get_descriptor()->name);
		if (decode_(dynamic_cast<Base_Type >(r.get_at(i)), *(r.fld_descr(i)), decoding_buffer) == -1) {
		return -1;
		}
		} // End of 'for' statement
		} else {
		// loggers::get_instance().log("btp_codec::decode_ (else): processing type %s/%s - optional:%d", type.get_descriptor()->name, field_descriptor.name,
		// type.is_optional());
		if (std::string(field_descriptor.name).compare("@LibItsBtp_TypesAndValues.BtpPacket.header") == 0) {
		// loggers::get_instance().log("btp_codec::decode_: _type = %d", _type);
		LibItsBtp__TypesAndValues::BtpHeader &b = static_cast<LibItsBtp__TypesAndValues::BtpHeader &>(type);
		if (_type == btp_codec::btpA) {
		decode_(b.btpAHeader(), *b.btpAHeader().get_descriptor(), decoding_buffer);
		if (_params != NULL) {
		(*_params)[params_its::btp_type] = std::string("btpA");
		(*_params)[params_its::btp_destination_port] = std::to_string(static_cast<int>(b.btpAHeader().destinationPort()));
		}
		} else if (_type == btp_codec::btpB) {
		decode_(b.btpBHeader(), *b.btpBHeader().get_descriptor(), decoding_buffer);
		if (_params != NULL) {
		(*_params)[params_its::btp_type] = std::string("btpB");
		(*_params)[params_its::btp_destination_port] = std::to_string(static_cast<int>(b.btpBHeader().destinationPort()));
		(*_params)[params_its::btp_info] = std::to_string(static_cast<int>(b.btpBHeader().destinationPortInfo()));
		}
		} else {
		// loggers::get_instance().error("btp_codec::decode_: Invalid BTP type"); // Cannot be reached
		}
		// loggers::get_instance().log_msg("btp_codec::decode_: BtpHeader: ", type);
		} else if (std::string(field_descriptor.name).compare("@LibItsBtp_TypesAndValues.BtpPacket.payload") == 0) {
		if (decoding_buffer.get_len() == decoding_buffer.get_pos()) { // No payload, set it to omit
		// loggers::get_instance().log("btp_codec::decode_: Set OPTIONAL<BtpRawPayload> to omit");
		dynamic_cast<OPTIONAL<LibItsBtp__TypesAndValues::BtpRawPayload> &>(type).set_to_omit();
		} else {
		// Decode BtpRawPayload data structure
		OCTETSTRING os(decoding_buffer.get_len() - decoding_buffer.get_pos(), decoding_buffer.get_data() + decoding_buffer.get_pos());
		// loggers::get_instance().log_msg("btp_codec::decode_: s=", os);
		if (_params != NULL) {
		(_params)[params_its::btp_payload] = std::string(static_cast<const char >(oct2str(os)));
		}
		if (os.lengthof() != 0) {
		dynamic_cast<OPTIONAL<LibItsBtp__TypesAndValues::BtpRawPayload> &>(type) = OPTIONAL<LibItsBtp__TypesAndValues::BtpRawPayload>(os);
		// loggers::get_instance().log_msg("btp_codec::decode_: Set OPTIONAL to ", type);
		} else {
		// loggers::get_instance().log("btp_codec::decode_: Set OPTIONAL to omit");
		dynamic_cast<OPTIONAL<LibItsBtp__TypesAndValues::BtpRawPayload> &>(type).set_to_omit();
		}
		}
		} else {
		type.decode(field_descriptor, decoding_buffer, TTCN_EncDec::CT_RAW);
		}
		}
		*/
		loggers::get_instance().log_msg("<<< ngap_codec::decode_: ", type);
		loggers::get_instance().log_to_hexa("<<< ngap_codec::decode_: decoding_buffer=", decoding_buffer);

		return 0;
		}

ccsrc/Protocols/NGAP/ngap_codec.hh

+8 −31

Original line number	Diff line number	Diff line
		#pragma once

		#include "LibNGAP_TypesAndValues.hh"
		#include "ngap_pdu_codec.hh"
		//#include "codec.hh"
		#include "NGAP_PDU_Descriptions.hh"
		#include "codec.hh"

		class BITSTRING; //! Forward declaration of TITAN class
		class OCTETSTRING; //! Forward declaration of TITAN class
		//class params_;

		class Base_Type;
		class TTCN_Typedescriptor_t;
		class TTCN_Buffer;
		namespace NGAP__PDU__Descriptions { //! Forward declaration of asn1c NGAP class
		class NGAP__PDU;
		}


		//namespace NGAP__PDU__Descriptions { //! Forward declaration of asn1c NGAP class
		// class NGAP__PDU;
		//}

		//class ngap_codec : public codec<NGAP__PDU__Descriptions::NGAP__PDU, NGAP__PDU__Descriptions::NGAP__PDU> {
		class ngap_codec {
		class ngap_codec : public codec<NGAP__PDU__Descriptions::NGAP__PDU, NGAP__PDU__Descriptions::NGAP__PDU> {
		ngap_pdu_codec asn_codec;

		int encode_(const Base_Type &type, const TTCN_Typedescriptor_t &field_descriptor, TTCN_Buffer &encoding_buffer);

		int decode_(Base_Type &type, const TTCN_Typedescriptor_t &field_descriptor, TTCN_Buffer &decoding_buffer);


		public:
		//explicit ngap_codec() : codec<NGAP__PDU__Descriptions::NGAP__PDU, NGAP__PDU__Descriptions::NGAP__PDU>(), asn_codec(){};
		/explicit/ ngap_codec() : asn_codec(){};
		explicit ngap_codec() : codec<NGAP__PDU__Descriptions::NGAP__PDU, NGAP__PDU__Descriptions::NGAP__PDU>(), asn_codec(){};
		virtual ~ngap_codec(){};

		/virtual/ int encode(const NGAP__PDU__Descriptions::NGAP__PDU& ngap, OCTETSTRING &data);
		/virtual/ int decode(const OCTETSTRING &data, NGAP__PDU__Descriptions::NGAP__PDU &, params *params = NULL);
		virtual int encode(const NGAP__PDU__Descriptions::NGAP__PDU& ngap, OCTETSTRING &data);
		virtual int decode(const OCTETSTRING &data, NGAP__PDU__Descriptions::NGAP__PDU &ngap, params_ngap *params = NULL);
		};

		//void NGAP__PDU::encode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int p_coding, ...) const
		//{
		// va_list pvar;
		// va_start(pvar, p_coding);
		// switch(p_coding) {
		// case TTCN_EncDec::CT_BER: {

ccsrc/Protocols/NGAP/ngap_pdu_codec.cc

+5 −59

Original line number	Diff line number	Diff line
		@@ -2,67 +2,13 @@
		#include "LibNGAP_TypesAndValues.hh"
		#include "asn1/asn_application.h" // from asn1c
		#include "loggers.hh"
		#include "NGAP_PDU_Descriptions.hh"
		#include "TTCN3.hh"
		#include <errno.h>

		extern "C" {
		extern asn_TYPE_descriptor_t asn_DEF_NGAP_PDU;
		}
		/*extern "C" {
		static int asn1c_collect_encoded_data(const void buffer, size_t size, void application_specific_key) {
		TTCN_Buffer tb = (TTCN_Buffer )application_specific_key;
		tb->put_s(size, (unsigned char *)buffer);
		return 0;
		}
		}*/

		int ngap_pdu_codec::encode(const NGAP__PDU__Descriptions::NGAP__PDU &p_ngap, BITSTRING &p_data) {
		loggers::get_instance().log("ngap_pdu_codec::encode: ");
		/*loggers::get_instance().log_msg("ngap_pdu_codec::encodemsg: ",p_ngap);
		TTCN_Buffer buf;
		TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL, TTCN_EncDec::WARNING);
		p_ngap.encode(NGAP__PDU__Descriptions::NGAP__PDU_descr_, buf, TTCN_EncDec::CT_BER, BER_ENCODE_DER);
		p_data = oct2bit(OCTETSTRING(buf.get_len(), buf.get_data()));

		loggers::get_instance().log_msg("ngap_pdu_codec::encodemsg: ",OCTETSTRING(buf.get_len(), buf.get_data()));

		void * ptr = NULL;
		asn_dec_rval_t rc_d;

		rc_d = asn_decode(NULL, ATS_BER, (asn_TYPE_descriptor_s *)&asn_DEF_NGAP_PDU, &ptr, buf.get_data(), buf.get_len());
		if (rc_d.code == RC_OK) {
		// rc = rc_e.encoded;

		loggers::get_instance().log("ngap_pdu_codec::ASN1C decoded BER OK: ");
		// Encode as PER
		asn_enc_rval_t rc_e;
		buf.clear();
		rc_e = asn_encode(NULL,ATS_ALIGNED_BASIC_PER, (asn_TYPE_descriptor_s *)&asn_DEF_NGAP_PDU, ptr, asn1c_collect_encoded_data, &buf);
		//rc_e = asn_encode(NULL,ATS_UNALIGNED_BASIC_PER, (asn_TYPE_descriptor_s *)&asn_DEF_NGAP_PDU, ptr, asn1c_collect_encoded_data, &buf);
		//rc_e = asn_encode(NULL,ATS_ALIGNED_CANONICAL_PER, (asn_TYPE_descriptor_s *)&asn_DEF_NGAP_PDU, ptr, asn1c_collect_encoded_data, &buf);
		//rc_e = asn_encode(NULL,ATS_UNALIGNED_CANONICAL_PER, (asn_TYPE_descriptor_s *)&asn_DEF_NGAP_PDU, ptr, asn1c_collect_encoded_data, &buf);


		if (rc_e.encoded > 0) {
		loggers::get_instance().log("ngap_pdu_codec::ASN1C encoded PER OK: ");
		loggers::get_instance().log_msg("ngap_pdu_codec::encodemsg PER: ",OCTETSTRING(buf.get_len(), buf.get_data()));
		}else{

		//loggers::get_instance().log("ngap_pdu_codec::ASN1C encoded PER NOK:%d %d",rc_e.encoded,errno);
		switch (errno){
		case EINVAL: {loggers::get_instance().log("Incorrect parameters to the function, such as NULLs.");break;}
		case ENOENT: {loggers::get_instance().log("Encoding transfer syntax is not defined (for this type)");break;}
		case EBADF: {loggers::get_instance().log("The structure has invalid form or content constraint failed.");break;}
		case EIO: {loggers::get_instance().log("The (callback) has returned negative value during encoding.");break;}
		}
		loggers::get_instance().log("ngap_pdu_codec::ASN1C encoded PER NOK:end switch errno %d",errno);
		}

		}
		if (ptr) {
		ASN_STRUCT_FREE(asn_DEF_NGAP_PDU, ptr);
		}*/

		return _encode(NGAP__PDU__Descriptions::NGAP__PDU_descr_, asn_DEF_NGAP_PDU, p_ngap, p_data);
		}