Commit f24967ee authored by juvancic's avatar juvancic
Browse files

Merge branch 'devel' of https://forge.etsi.org/rep/int/5g-core/ngap into devel

parents 9ebc88b8 fc84d434

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

}