Commit 3dbd01f2 authored by Yann Garcia's avatar Yann Garcia
Browse files

Add missing enc/dec function & review codecs

parent b13cce64

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/codec.hh

deleted100644 → 0
+0 −62
Original line number Diff line number Diff line 
/*!

 * \file      codec.hh

 * \brief     Header file for ITS abstract codec definition.

 * \author    ETSI STF525

 * \copyright ETSI Copyright Notification

 *            No part may be reproduced except as authorized by written permission.

 *            The copyright and the foregoing restriction extend to reproduction in all media.

 *            All rights reserved.

 * \version   0.1

 */

#pragma once



///#include "params_its.hh"

#include "t_layer.hh"



class OCTETSTRING; //! Declare TITAN class

class CHARSTRING;  //! Declare TITAN class

class BITSTRING;   //! Declare TITAN class



/*!

 * \class codec

 * \brief  This class provides the interface for all ITS codecs, include UT and AC codecs

 * \abstract

 */

template <typename TPDUEnc, typename TPDUDec> class codec {

protected:

  params *_params; //! Reference to params stack

                       // \todo Use smart pointer std::unique_ptr<params>



public: //! \publicsection

  /*!

   * \fn codec();

   * \brief  Default constructor

   * \todo Remove logs

   */

  explicit codec() : _params(nullptr){};

  /*!

   * \fn ~codec();

   * \brief  Default destructor

   * \virtual

   * \todo Remove logs

   */

  virtual ~codec(){};

  /*!

   * \fn int encode(const TPDUEnc& msg, OCTETSTRING& data);

   * \brief  Encode typed message into an octet string

   * \param[in] p_message The typed message to be encoded

   * \param[out] p_data The encoding result

   * \return 0 on success, -1 otherwise

   * \pure

   */

  virtual int encode(const TPDUEnc &p_message, OCTETSTRING &p_data) ;//= 0;

  /*!

   * \fn int decode(const OCTETSTRING& p_, TPDUDec& p_message, params_its* p_params = NULL);

   * \brief  Encode typed message into an octet string format

   * \param[in] p_data The message in its octet string

   * \param[out] p_message The decoded typed message

   * \return 0 on success, -1 otherwise

   * \pure

   */

  virtual int decode(const OCTETSTRING &p_, TPDUDec &p_message, params *p_params = NULL) ;//= 0;

}; // End of class codec

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: {