STF545: Add InnerAcRequest/Response support, UpperTester port for ITS-S

ccsrc/EncDec/LibItsPki_Encdec.cc

@@ -3,6 +3,8 @@
 #include "etsi_ts102941_data.hh"
 #include "etsi_ts102941_types_enrolment_inner_request.hh"
 #include "etsi_ts102941_types_enrolment_inner_response.hh"
+#include "etsi_ts102941_types_authorization_inner_request.hh"
+#include "etsi_ts102941_types_authorization_inner_response.hh"
 
 #include "loggers.hh"
 
@@ -88,4 +90,58 @@ namespace LibItsPki__EncdecDeclarations {
     return 0;
   }
   
+  BITSTRING fx__enc__InnerAtRequest(const EtsiTs102941TypesAuthorization::InnerAtRequest& p_inner_request) {
+    loggers::get_instance().log_msg(">>> fx_enc_InnerAtRequest: ", p_inner_request);
+
+    etsi_ts102941_types_authorization_inner_request codec;
+    OCTETSTRING os;
+    if (codec.encode(p_inner_request, os) == -1) {
+      loggers::get_instance().warning("fx_enc_InnerAtRequest: -1 result code was returned");
+      return int2bit(0, 1);
+    }
+    
+    return oct2bit(os);
+  }
+
+  INTEGER fx__dec__InnerAtRequest(BITSTRING& b, EtsiTs102941TypesAuthorization::InnerAtRequest& p_inner_request) {
+    loggers::get_instance().log_msg(">>> fx__dec__InnerAtRequest: ", b);
+
+    etsi_ts102941_types_authorization_inner_request codec;
+    OCTETSTRING is = bit2oct(b);
+    if (codec.decode(is, p_inner_request) == -1) {
+      loggers::get_instance().warning("fx__dec__InnerAtRequest: -1 result code was returned");
+      return -1;
+    }
+    
+    loggers::get_instance().log_msg("<<< fx__dec__InnerAtRequest: ", p_inner_request);
+    return 0;
+  }
+  
+  BITSTRING fx__enc__InnerAtResponse(const EtsiTs102941TypesAuthorization::InnerAtResponse& p_inner_response) {
+    loggers::get_instance().log_msg(">>> fx__enc__InnerAtResponse: ", p_inner_response);
+
+    etsi_ts102941_types_authorization_inner_response codec;
+    OCTETSTRING os;
+    if (codec.encode(p_inner_response, os) == -1) {
+      loggers::get_instance().warning("fx__enc__InnerAtResponse: -1 result code was returned");
+      return int2bit(0, 1);
+    }
+
+    return oct2bit(os);
+  }
+
+  INTEGER fx__dec__InnerAtResponse(BITSTRING& b, EtsiTs102941TypesAuthorization::InnerAtResponse& p_inner_response) {
+    loggers::get_instance().log_msg(">>> fx__dec__InnerAtResponse: ", b);
+
+    etsi_ts102941_types_authorization_inner_response codec;
+    OCTETSTRING is = bit2oct(b);
+    if (codec.decode(is, p_inner_response) == -1) {
+      loggers::get_instance().warning("fx__dec__InnerAtResponse: -1 result code was returned");
+      return -1;
+    }
+
+    loggers::get_instance().log_msg("<<< fx__dec__InnerAtResponse: ", p_inner_response);
+    return 0;
+  }
+  
 } // End of namespace LibItsPki__EncdecDeclarations

ccsrc/Ports/LibIts_ports/AdapterControlPort.cc

@@ -9,7 +9,7 @@
 #include "IVIM_ports/AdapterControlPort_IVIM.partC"
 #include "MapemSpatem_ports/AdapterControlPort_MapemSpatem.partC"
 #include "SremSsem_ports/AdapterControlPort_SremSsem.partC"
-//#include "Pki_ports/AdapterControlPort_Pki.partC"
+#include "Pki_ports/AdapterControlPort_Pki.partC"
 //#include "V2G_ports/AdapterControlPort_V2G.partC"
 
 #else //_NO_SOFTLINKS_
@@ -20,7 +20,7 @@
 #include "AdapterControlPort_MapemSpatem.partC"
 #include "AdapterControlPort_SremSsem.partC"
 #include "AdapterControlPort_GN.partC"
-//#include "AdapterControlPort_Pki.partC"
+#include "AdapterControlPort_Pki.partC"
 /*
 #include "AdapterControlPort_IVIM.partC"
 #include "AdapterControlPort_MapemSpatem.partC"

ccsrc/Ports/LibIts_ports/AdapterControlPort.hh

@@ -12,7 +12,7 @@
 #include "IVIM_ports/AdapterControlPort_IVIM.partH"
 #include "MapemSpatem_ports/AdapterControlPort_MapemSpatem.partH"
 #include "SremSsem_ports/AdapterControlPort_SremSsem.partH"
-//#include "Pki_ports/AdapterControlPort_Pki.partH"
+#include "Pki_ports/AdapterControlPort_Pki.partH"
 //#include "V2G_ports/AdapterControlPort_V2G.partH"
 
 #else //_NO_SOFTLINKS_
@@ -23,7 +23,7 @@
 #include "AdapterControlPort_MapemSpatem.partH"
 #include "AdapterControlPort_SremSsem.partH"
 #include "AdapterControlPort_GN.partH"
-//#include "AdapterControlPort_Pki.partH"
+#include "AdapterControlPort_Pki.partH"
 /*
 #include "AdapterControlPort_IVIM.partH"
 #include "AdapterControlPort_MapemSpatem.partH"

ccsrc/Ports/LibIts_ports/Pki_ports/AdapterControlPort_Pki.partC

 #include <TTCN3.hh>
 
-#include "LibItsPki_TestSystem.hh"
-
 #include "loggers.hh"
 #include "registration.hh"
 
@@ -10,87 +8,87 @@
 //=============================================================================
 namespace LibItsPki__TestSystem {
 
-  AdapterControlPkiPort::AdapterControlPkiPort(const char *par_port_name)
-    : AdapterControlPkiPort_BASE(par_port_name), _params()
+  AdapterControlPort::AdapterControlPort(const char *par_port_name)
+    : AdapterControlPort_BASE(par_port_name), _params()
   {
-    loggers::get_instance().log("AdapterControlPkiPort::AdapterControlPkiPort");
+    loggers::get_instance().log("AdapterControlPort::AdapterControlPort");
 
 
   }
 
-  AdapterControlPkiPort::~AdapterControlPkiPort()
+  AdapterControlPort::~AdapterControlPort()
   {
 
   }
 
-  void AdapterControlPkiPort::set_parameter(const char * parameter_name, const char * parameter_value)
+  void AdapterControlPort::set_parameter(const char * parameter_name, const char * parameter_value)
   {
-    loggers::get_instance().log("AdapterControlPkiPort::set_parameter: %s=%s", parameter_name, parameter_value);
+    loggers::get_instance().log("AdapterControlPort::set_parameter: %s=%s", parameter_name, parameter_value);
 
   }
 
-  /*void AdapterControlPkiPort::Handle_Fd_Event(int fd, boolean is_readable,
+  /*void AdapterControlPort::Handle_Fd_Event(int fd, boolean is_readable,
     boolean is_writable, boolean is_error) {}*/
 
-  void AdapterControlPkiPort::Handle_Fd_Event_Error(int /*fd*/)
+  void AdapterControlPort::Handle_Fd_Event_Error(int /*fd*/)
   {
 
   }
 
-  void AdapterControlPkiPort::Handle_Fd_Event_Writable(int /*fd*/)
+  void AdapterControlPort::Handle_Fd_Event_Writable(int /*fd*/)
   {
 
   }
 
-  void AdapterControlPkiPort::Handle_Fd_Event_Readable(int /*fd*/)
+  void AdapterControlPort::Handle_Fd_Event_Readable(int /*fd*/)
   {
 
   }
 
-  /*void AdapterControlPkiPort::Handle_Timeout(double time_since_last_call) {}*/
+  /*void AdapterControlPort::Handle_Timeout(double time_since_last_call) {}*/
 
-  void AdapterControlPkiPort::user_map(const char * system_port)
+  void AdapterControlPort::user_map(const char * system_port)
   {
-    loggers::get_instance().log(">>> AdapterControlPkiPort::user_map: %s", system_port);
+    loggers::get_instance().log(">>> AdapterControlPort::user_map: %s", system_port);
 
   }
 
-  void AdapterControlPkiPort::user_unmap(const char * system_port)
+  void AdapterControlPort::user_unmap(const char * system_port)
   {
-    loggers::get_instance().log(">>> AdapterControlPkiPort::user_unmap: %s", system_port);
+    loggers::get_instance().log(">>> AdapterControlPort::user_unmap: %s", system_port);
 
   }
 
-  void AdapterControlPkiPort::user_start()
+  void AdapterControlPort::user_start()
   {
 
   }
 
-  void AdapterControlPkiPort::user_stop()
+  void AdapterControlPort::user_stop()
   {
 
   }
 
-  void AdapterControlPkiPort::outgoing_send(const LibItsPki__TypesAndValues::AcPkiPrimitive& send_par)
+  void AdapterControlPort::outgoing_send(const LibItsPki__TypesAndValues::AcPkiPrimitive& send_par)
   {
-    loggers::get_instance().log_msg(">>> AdapterControlPkiPort::outgoing_send: ", send_par);
+    loggers::get_instance().log_msg(">>> AdapterControlPort::outgoing_send: ", send_par);
     
-    // Register this object for AdapterControlPkiPort
+    // Register this object for AdapterControlPort
     pki_layer* p = registration<pki_layer>::get_instance().get_item(std::string("PKI"));
     if (p != NULL) {
-      loggers::get_instance().log("AdapterControlPkiPort::outgoing_send: Got PKI layer %p", p);
+      loggers::get_instance().log("AdapterControlPort::outgoing_send: Got PKI layer %p", p);
       LibItsPki__TypesAndValues::AcPkiResponse response;
       response.result() = BOOLEAN(false);
       if (send_par.ischosen(LibItsPki__TypesAndValues::AcPkiPrimitive::ALT_acSetSecurityData)) {
-        loggers::get_instance().log("AdapterControlPkiPort::outgoing_send: AcSetSecurityData");
+        loggers::get_instance().log("AdapterControlPort::outgoing_send: AcSetSecurityData");
         p->set_pki_keys(send_par.acSetSecurityData());
         response.result() = BOOLEAN(true);
       }
       // Send response
-      loggers::get_instance().log_msg("AdapterControlPkiPort::outgoing_send: Send response: ", response);
+      loggers::get_instance().log_msg("AdapterControlPort::outgoing_send: Send response: ", response);
       incoming_message(response);
     } else {
-      loggers::get_instance().error("AdapterControlPkiPort::outgoing_send: pkiPort not registered");
+      loggers::get_instance().error("AdapterControlPort::outgoing_send: pkiPort not registered");
     }
   }
 

ccsrc/Ports/LibIts_ports/Pki_ports/AdapterControlPort_Pki.partH

@@ -3,18 +3,14 @@
 
 #include "params.hh"
 
-namespace LibItsPki__TypesAndValues {
-  class AcPkiPrimitive;
-}
-
 namespace LibItsPki__TestSystem {
 
-class AdapterControlPkiPort : public AdapterControlPkiPort_BASE {
+class AdapterControlPort : public AdapterControlPort_BASE {
   params _params;
 	
 public:
-	AdapterControlPkiPort(const char *par_port_name = NULL);
-	~AdapterControlPkiPort();
+	AdapterControlPort(const char *par_port_name = NULL);
+	~AdapterControlPort();
 
 	void set_parameter(const char *parameter_name,
 		const char *parameter_value);

ccsrc/Ports/LibIts_ports/Pki_ports/UpperTesterPort_Pki.partC

+#include "uppertester_pki_layer_factory.hh"
+
+#include "loggers.hh"
+
+//=============================================================================
+namespace LibItsPki__TestSystem {
+
+  UpperTesterPort::UpperTesterPort(const char *par_port_name)
+    : UpperTesterPort_BASE(par_port_name), _cfg_params(), _layer_params(), _layer(NULL), _time_key("UpperTesterPort_Pki::outgoing_send")
+  {
+    loggers::get_instance().log("UpperTesterPort_Pki::UpperTesterPort_Pki");
+  }
+
+  UpperTesterPort::~UpperTesterPort()
+  {
+    if (_layer != NULL) {
+      delete _layer;
+    }
+  }
+
+  void UpperTesterPort::set_parameter(const char * parameter_name, const char * parameter_value)
+  {
+    loggers::get_instance().log("UpperTesterPort_Pki::set_parameter: %s=%s", parameter_name, parameter_value);
+    _cfg_params.insert(std::pair<std::string, std::string>(std::string(parameter_name), std::string(parameter_value)));
+    _cfg_params.log();
+  }
+
+  /*void UpperTesterPort::Handle_Fd_Event(int fd, boolean is_readable,
+    boolean is_writable, boolean is_error) {}*/
+
+  void UpperTesterPort::Handle_Fd_Event_Error(int /*fd*/)
+  {
+
+  }
+
+  void UpperTesterPort::Handle_Fd_Event_Writable(int /*fd*/)
+  {
+
+  }
+
+  void UpperTesterPort::Handle_Fd_Event_Readable(int /*fd*/)
+  {
+
+  }
+
+  /*void UpperTesterPort::Handle_Timeout(double time_since_last_call) {}*/
+
+  void UpperTesterPort::user_map(const char * system_port)
+  {
+    loggers::get_instance().log(">>> UpperTesterPort_Pki::user_map: %s", system_port);
+    // Build layer stack
+    params::iterator it = _cfg_params.find(std::string("params"));
+    if (it != _cfg_params.end()) {
+      loggers::get_instance().log("UpperTesterPort_Pki::user_map: %s", it->second.c_str());
+      _layer = layer_stack_builder::get_instance()->create_layer_stack(it->second.c_str());
+      if (static_cast<uppertester_pki_layer *>(_layer) == NULL) {
+        loggers::get_instance().error("UpperTesterPort_Pki::user_map: Invalid stack configuration: %s", it->second.c_str());
+      }
+      static_cast<uppertester_pki_layer *>(_layer)->add_upper_port(this);
+    } else {
+      loggers::get_instance().error("UpperTesterPort_Pki::user_map: No layers defined in configuration file");
+    }
+  }
+
+  void UpperTesterPort::user_unmap(const char * system_port)
+  {
+    loggers::get_instance().log(">>> UpperTesterPort_Pki::user_unmap: %s", system_port);
+    if (_layer != NULL) {
+      delete _layer;
+      _layer = NULL;
+    }
+
+  }
+
+  void UpperTesterPort::user_start()
+  {
+
+  }
+
+  void UpperTesterPort::user_stop()
+  {
+
+  }
+
+  void UpperTesterPort::outgoing_send(const LibItsPki__TypesAndValues::UtPkiInitialize& send_par)
+  {
+    loggers::get_instance().log_msg(">>> UppertesterPort::outgoing_send: ", send_par);
+    
+    float duration;
+    loggers::get_instance().set_start_time(_time_key);
+    static_cast<uppertester_pki_layer *>(_layer)->sendMsg(send_par, _layer_params);
+    loggers::get_instance().set_stop_time(_time_key, duration);
+  }
+
+  void UpperTesterPort::outgoing_send(const LibItsPki__TypesAndValues::UtPkiTrigger& send_par)
+  {
+    loggers::get_instance().log_msg(">>> UppertesterPort::outgoing_send: ", send_par);
+    
+    float duration;
+    loggers::get_instance().set_start_time(_time_key);
+    static_cast<uppertester_pki_layer *>(_layer)->sendMsg(send_par, _layer_params);
+    loggers::get_instance().set_stop_time(_time_key, duration);
+  }
+
+  void UpperTesterPort::receiveMsg (const Base_Type& p_ind, const params& p_params) {
+    loggers::get_instance().log_msg(">>> UpperTesterPort_Pki::receive_msg: ", p_ind);
+    // Sanity check
+    if (!p_ind.is_bound()) {
+      return;
+    }
+
+    if (std::string(p_ind.get_descriptor()->name).compare("@LibItsPki_TypesAndValues.UtPkiResults") == 0) { // TODO To be refined
+      incoming_message(static_cast<const LibItsPki__TypesAndValues::UtPkiResults&>(p_ind));
+    } else {
+      loggers::get_instance().warning("UpperTesterPort_Pki::receive_msg: Message not processed: %s", p_ind.get_descriptor()->name);
+    }
+  }
+
+} /* end of namespace */

ccsrc/Ports/LibIts_ports/Pki_ports/UpperTesterPort_Pki.partH

+#include "layer.hh"
+#include "params.hh"
+
+//=============================================================================
+#include "LibItsPki_TestSystem.hh"
+namespace LibItsPki__TestSystem {
+
+  class UpperTesterPort : public UpperTesterPort_BASE {
+    params _cfg_params;
+    params _layer_params;
+    layer* _layer;
+    std::string _time_key;
+    
+  public:
+    UpperTesterPort(const char *par_port_name = NULL);
+    ~UpperTesterPort();
+
+    void set_parameter(const char *parameter_name,
+                       const char *parameter_value);
+
+    void receiveMsg (const Base_Type&, const params&);
+
+  private:
+    /* void Handle_Fd_Event(int fd, boolean is_readable,
+       boolean is_writable, boolean is_error); */
+    void Handle_Fd_Event_Error(int fd);
+    void Handle_Fd_Event_Writable(int fd);
+    void Handle_Fd_Event_Readable(int fd);
+    /* void Handle_Timeout(double time_since_last_call); */
+  protected:
+    void user_map(const char *system_port);
+    void user_unmap(const char *system_port);
+
+    void user_start();
+    void user_stop();
+
+    void outgoing_send(const LibItsPki__TypesAndValues::UtPkiInitialize& send_par);
+	
+    void outgoing_send(const LibItsPki__TypesAndValues::UtPkiTrigger& send_par);
+	
+  };
+
+} /* end of namespace */

ccsrc/Ports/LibIts_ports/UpperTesterPort.cc

@@ -13,6 +13,7 @@
 //#include "MapSpat_ports/UpperTesterPort_MapSpat.partC"
 #include "MapemSpatem_ports/UpperTesterPort_MapemSpatem.partC"
 #include "SremSsem_ports/UpperTesterPort_SremSsem.partC"
+#include "V2G_ports/UpperTesterPort_Pki.partC"
 //#include "V2G_ports/UpperTesterPort_V2G.partC"
 
 #else //_NO_SOFTLINKS_
@@ -25,6 +26,7 @@
 #include "UpperTesterPort_MapemSpatem.partC"
 #include "UpperTesterPort_SremSsem.partC"
 #include "UpperTesterPort_GN.partC"
+#include "UpperTesterPort_Pki.partC"
 /*
 #include "UpperTesterPort_IVIM.partC"
 //#include "UpperTesterPort_MapSpat.partC"

ccsrc/Ports/LibIts_ports/UpperTesterPort.hh

@@ -12,9 +12,9 @@
 #include "DENM_ports/UpperTesterPort_DENM.partH"
 #include "GN_ports/UpperTesterPort_GN.partH"
 #include "IVIM_ports/UpperTesterPort_IVIM.partH"
-//#include "MapSpat_ports/UpperTesterPort_MapSpat.partH"
 #include "MapemSpatem_ports/UpperTesterPort_MapemSpatem.partH"
 #include "SremSsem_ports/UpperTesterPort_SremSsem.partH"
+#include "V2G_ports/UpperTesterPort_Pki.partH"
 //#include "V2G_ports/UpperTesterPort_V2G.partH"
 
 #else //_NO_SOFTLINKS_
@@ -27,6 +27,7 @@
 #include "UpperTesterPort_MapemSpatem.partH"
 #include "UpperTesterPort_SremSsem.partH"
 #include "UpperTesterPort_GN.partH"
+#include "UpperTesterPort_Pki.partH"
 /*
 #include "UpperTesterPort_IVIM.partH"
 //#include "UpperTesterPort_MapSpat.partH"

ccsrc/Protocols/Pki/pki_layer.cc

@@ -55,11 +55,19 @@ void pki_layer::sendMsg(const EtsiTs102941TypesEnrolment::InnerEcRequest& p_inne
   OCTETSTRING inner_ec_request;
   _etsi_ts102941_types_enrolment_inner_request.encode(p_inner_ec_request, inner_ec_request);
   // Build the EtsiTs103097Data-Encrypted
-  OCTETSTRING etsi_ts_102941_data;
-  if (generate_inner_ec_request_signed_for_pop(inner_ec_request, etsi_ts_102941_data, _params) == -1) {
+  OCTETSTRING etsi_ts_103097_data;
+  if (generate_inner_ec_request_signed_for_pop(inner_ec_request, etsi_ts_103097_data, _params) == -1) {
     loggers::get_instance().warning("pki_layer::sendMsg: Failed to generate InnerExRequestSignedForPop");
     return;
   }
+  // Secured the EtsiTs102941Data layer
+  OCTETSTRING etsi_ts_102941_data;
+  if (sign_and_encrypt_payload(etsi_ts_103097_data, etsi_ts_102941_data, _params) == -1) {
+    loggers::get_instance().warning("pki_layer::sendMsg: Failed to secure Pki message");
+    return;
+  }
+  
+  loggers::get_instance().log_msg("<<< pki_layer::generate_inner_ec_request_signed_for_pop: ", etsi_ts_102941_data);
   
   send_data(etsi_ts_102941_data, _params);
 }
@@ -133,7 +141,7 @@ void pki_layer::set_pki_keys(const LibItsPki__TypesAndValues::AcSetSecurityData&
   _params[params::peer_certificate] = p_ac_set_security_data.peer__certificateId();
 }
 
-int pki_layer::generate_inner_ec_request_signed_for_pop(const OCTETSTRING& p_inner_ec_request, OCTETSTRING& p_etsi_ts_102941_data, params& p_params) {
+int pki_layer::generate_inner_ec_request_signed_for_pop(const OCTETSTRING& p_inner_ec_request, OCTETSTRING& p_etsi_ts_103097_data, params& p_params) {
   loggers::get_instance().log_msg(">>> pki_layer::generate_inner_ec_request_signed_for_pop: ", p_inner_ec_request);
 
   // Re-configure default parameters
@@ -191,20 +199,13 @@ int pki_layer::generate_inner_ec_request_signed_for_pop(const OCTETSTRING& p_inn
   EtsiTs102941MessagesItss::EtsiTs102941Data etsi_ts_102941_data;
   etsi_ts_102941_data.content().enrolmentRequest() = ieee_1609dot2_data;
   loggers::get_instance().log_msg("pki_layer::generate_inner_ec_request_signed_for_pop: InnerEcRequestSignedForPop: ", etsi_ts_102941_data);
-  OCTETSTRING os;
-  _codec.encode(ieee_1609dot2_data, os);
-  if (!os.is_bound()) {
+  _codec.encode(ieee_1609dot2_data, p_etsi_ts_103097_data);
+  if (!p_etsi_ts_103097_data.is_bound()) {
     loggers::get_instance().warning("pki_layer::generate_inner_ec_request_signed_for_pop: Failed to encode InnerEcRequestSignedForPop");
     return -1;
   }
-  loggers::get_instance().log_msg("pki_layer::generate_inner_ec_request_signed_for_pop: ", os);
-  // Secured the EtsiTs102941Data layer
-  if (sign_and_encrypt_payload(os, p_etsi_ts_102941_data, p) == -1) {
-    loggers::get_instance().warning("pki_layer::generate_inner_ec_request_signed_for_pop: Failed to secure Pki message");
-    return -1;
-  }
   
-  loggers::get_instance().log_msg("<<< pki_layer::generate_inner_ec_request_signed_for_pop: ", p_etsi_ts_102941_data);
+  loggers::get_instance().log_msg("<<< pki_layer::generate_inner_ec_request_signed_for_pop: ", p_etsi_ts_103097_data);
   return 0;
 }
 

ccsrc/Protocols/Security/etsi_ts102941_types_authorization_inner_request.cc

+#include "etsi_ts102941_types_authorization_inner_request.hh"
+
+#include "loggers.hh"
+
+int etsi_ts102941_types_authorization_inner_request::encode (const EtsiTs102941TypesAuthorization::InnerAtRequest& p_inner_request, OCTETSTRING& p_data)
+{
+  loggers::get_instance().log(">>> etsi_ts102941_types_authorization_inner_request::encode: %s", p_inner_request.get_descriptor()->name);
+
+  BITSTRING b;
+  TTCN_EncDec::clear_error();
+  TTCN_Buffer buffer;
+  p_inner_request.encode(*p_inner_request.get_descriptor(), buffer, TTCN_EncDec::CT_OER);
+  p_data = OCTETSTRING(buffer.get_len(), buffer.get_data());
+  loggers::get_instance().log_msg("etsi_ts102941_types_authorization_inner_request::encode: ", p_data);
+
+  return 0;
+}
+
+int etsi_ts102941_types_authorization_inner_request::decode (const OCTETSTRING& p_data, EtsiTs102941TypesAuthorization::InnerAtRequest& p_inner_request, params* p_params)
+{
+  loggers::get_instance().log_msg(">>> etsi_ts102941_types_authorization_inner_request::decode: ", p_data);
+
+  TTCN_EncDec::clear_error();
+  TTCN_Buffer decoding_buffer(p_data);
+  //  _params = params;
+  p_inner_request.decode(*p_inner_request.get_descriptor(), decoding_buffer, TTCN_EncDec::CT_OER);
+
+  loggers::get_instance().log_msg("<<< etsi_ts102941_types_authorization_inner_request::decode: ", (const Base_Type&)p_inner_request);
+  return 0;
+}

ccsrc/Protocols/Security/etsi_ts102941_types_authorization_inner_request.hh

+#pragma once
+
+#include "codec.hh"
+#include "params.hh"
+
+#include "EtsiTs102941TypesAuthorization.hh"
+
+class etsi_ts102941_types_authorization_inner_request : public codec<EtsiTs102941TypesAuthorization::InnerAtRequest, EtsiTs102941TypesAuthorization::InnerAtRequest>
+{
+public:
+  explicit etsi_ts102941_types_authorization_inner_request() : codec<EtsiTs102941TypesAuthorization::InnerAtRequest, EtsiTs102941TypesAuthorization::InnerAtRequest>() { };
+  virtual ~etsi_ts102941_types_authorization_inner_request() { };
+
+  virtual int encode (const EtsiTs102941TypesAuthorization::InnerAtRequest& p_inner_request, OCTETSTRING& p_data);
+  virtual int decode (const OCTETSTRING& p_data, EtsiTs102941TypesAuthorization::InnerAtRequest& p_inner_request, params* p_params = NULL);
+}; // End of class etsi_ts102941_types_authorization_inner_request
+

ccsrc/Protocols/Security/etsi_ts102941_types_authorization_inner_response.cc

+#include "etsi_ts102941_types_authorization_inner_response.hh"
+
+#include "loggers.hh"
+
+int etsi_ts102941_types_authorization_inner_response::encode (const EtsiTs102941TypesAuthorization::InnerAtResponse& p_inner_response, OCTETSTRING& p_data)
+{
+  loggers::get_instance().log(">>> etsi_ts102941_types_authorization_inner_response::encode: %s", p_inner_response.get_descriptor()->name);
+
+  BITSTRING b;
+  TTCN_EncDec::clear_error();
+  TTCN_Buffer buffer;
+  p_inner_response.encode(*p_inner_response.get_descriptor(), buffer, TTCN_EncDec::CT_OER);
+  p_data = OCTETSTRING(buffer.get_len(), buffer.get_data());
+  loggers::get_instance().log_msg("etsi_ts102941_types_authorization_inner_response::encode: ", p_data);
+
+  return 0;
+}
+
+int etsi_ts102941_types_authorization_inner_response::decode (const OCTETSTRING& p_data, EtsiTs102941TypesAuthorization::InnerAtResponse& p_inner_response, params* p_params)
+{
+  loggers::get_instance().log_msg(">>> etsi_ts102941_types_authorization_inner_response::decode: ", p_data);
+
+  TTCN_EncDec::clear_error();
+  TTCN_Buffer decoding_buffer(p_data);
+  //  _params = params;
+  p_inner_response.decode(*p_inner_response.get_descriptor(), decoding_buffer, TTCN_EncDec::CT_OER);
+
+  loggers::get_instance().log_msg("<<< etsi_ts102941_types_authorization_inner_response::decode: ", (const Base_Type&)p_inner_response);
+  return 0;
+}

ccsrc/Protocols/Security/etsi_ts102941_types_authorization_inner_response.hh

+#pragma once
+
+#include "codec.hh"
+#include "params.hh"
+
+#include "EtsiTs102941TypesAuthorization.hh"
+
+class etsi_ts102941_types_authorization_inner_response : public codec<EtsiTs102941TypesAuthorization::InnerAtResponse, EtsiTs102941TypesAuthorization::InnerAtResponse>
+{
+public:
+  explicit etsi_ts102941_types_authorization_inner_response() : codec<EtsiTs102941TypesAuthorization::InnerAtResponse, EtsiTs102941TypesAuthorization::InnerAtResponse>() { };
+  virtual ~etsi_ts102941_types_authorization_inner_response() { };
+
+  virtual int encode (const EtsiTs102941TypesAuthorization::InnerAtResponse& p_inner_response, OCTETSTRING& p_data);
+  virtual int decode (const OCTETSTRING& p_data, EtsiTs102941TypesAuthorization::InnerAtResponse& p_inner_response, params* p_params = NULL);
+}; // End of class etsi_ts102941_types_authorization_inner_response
+