Merge branch 'STF525' of https://forge.etsi.org/gitlab/ITS/ITS into STF525

.TITAN_properties

@@ -3,7 +3,6 @@
   <ActiveConfiguration>Default</ActiveConfiguration>
   <ProjectProperties>
     <MakefileSettings>
-      <incrementalDependencyRefresh>false</incrementalDependencyRefresh>
       <functiontestRuntime>true</functiontestRuntime>
       <targetExecutable>bin/TSITS</targetExecutable>
       <TTCN3preprocessorDefines>
@@ -86,6 +85,13 @@
         <ExcludeFromBuild>true</ExcludeFromBuild>
       </FolderProperties>
     </FolderResource>
+    <FolderResource>
+      <FolderPath>html</FolderPath>
+      <FolderProperties>
+        <CentralStorage>false</CentralStorage>
+        <ExcludeFromBuild>true</ExcludeFromBuild>
+      </FolderProperties>
+    </FolderResource>
     <FolderResource>
       <FolderPath>javasrc</FolderPath>
       <FolderProperties>
@@ -318,13 +324,25 @@
       </FileProperties>
     </FileResource>
     <FileResource>
-      <FilePath>ccsrc/Ports/LibIts_ports/Pki_ports/AdapterControlPort_Pki.partC</FilePath>
+      <FilePath>ccsrc/Ports/LibIts_ports/Pki_ports/AdapterControlPkiPort.cc</FilePath>
+      <FileProperties>
+        <ExcludeFromBuild>true</ExcludeFromBuild>
+      </FileProperties>
+    </FileResource>
+    <FileResource>
+      <FilePath>ccsrc/Ports/LibIts_ports/Pki_ports/AdapterControlPkiPort.hh</FilePath>
+      <FileProperties>
+        <ExcludeFromBuild>true</ExcludeFromBuild>
+      </FileProperties>
+    </FileResource>
+    <FileResource>
+      <FilePath>ccsrc/Ports/LibIts_ports/Pki_ports/UpperTesterPort_Pki.partC</FilePath>
       <FileProperties>
         <ExcludeFromBuild>true</ExcludeFromBuild>
       </FileProperties>
     </FileResource>
     <FileResource>
-      <FilePath>ccsrc/Ports/LibIts_ports/Pki_ports/AdapterControlPort_Pki.partH</FilePath>
+      <FilePath>ccsrc/Ports/LibIts_ports/Pki_ports/UpperTesterPort_Pki.partH</FilePath>
       <FileProperties>
         <ExcludeFromBuild>true</ExcludeFromBuild>
       </FileProperties>
@@ -336,7 +354,7 @@
       </FileProperties>
     </FileResource>
     <FileResource>
-      <FilePath>ttcn/LibIts/asn1/Security/TS102921/EtsiTs102941MessagesCA.asn</FilePath>
+      <FilePath>ttcn/LibIts/asn1/Security/TS102921/EtsiTs102941MessagesItss.asn</FilePath>
       <FileProperties>
         <ExcludeFromBuild>true</ExcludeFromBuild>
       </FileProperties>

ccsrc/EncDec/LibItsPki_Encdec.cc

@@ -3,12 +3,16 @@
 #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 "etsi_ts102941_types_authorization_shared_at_request.hh"
+#include "etsi_ts102941_types_authorization_validation_request.hh"
 
 #include "loggers.hh"
 
 namespace LibItsPki__EncdecDeclarations {
 
-  BITSTRING fx__enc__EtsiTs102941Data(const EtsiTs102941MessagesItss::EtsiTs102941Data& p_etsi_ts_102941_data) {
+  BITSTRING fx__enc__EtsiTs102941Data(const EtsiTs102941MessagesCa::EtsiTs102941Data& p_etsi_ts_102941_data) {
     loggers::get_instance().log_msg(">>> fx__enc__EtsiTs102941Data: ", p_etsi_ts_102941_data);
 
     etsi_ts102941_data codec;
@@ -21,7 +25,7 @@ namespace LibItsPki__EncdecDeclarations {
     return oct2bit(os);
   }
 
-  INTEGER fx__dec__EtsiTs102941Data(BITSTRING& b, EtsiTs102941MessagesItss::EtsiTs102941Data& p_etsi_ts_102941_data) {
+  INTEGER fx__dec__EtsiTs102941Data(BITSTRING& b, EtsiTs102941MessagesCa::EtsiTs102941Data& p_etsi_ts_102941_data) {
     loggers::get_instance().log_msg(">>> fx__dec__EtsiTs102941Data: ", b);
 
     etsi_ts102941_data codec;
@@ -87,5 +91,113 @@ namespace LibItsPki__EncdecDeclarations {
     loggers::get_instance().log_msg("<<< fx__dec__InnerEcResponse: ", p_inner_response);
     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;
+  }
+
+  BITSTRING fx__enc__SharedAtRequest(EtsiTs102941TypesAuthorization::SharedAtRequest const& p_shared_at) {
+    loggers::get_instance().log_msg(">>> fx__enc__SharedAtRequest: ", p_shared_at);
+
+    etsi_ts102941_types_authorization_shared_at_request codec;
+    OCTETSTRING os;
+    if (codec.encode(p_shared_at, os) == -1) {
+      loggers::get_instance().warning("fx__enc__SharedAtRequest: -1 result code was returned");
+      return int2bit(0, 1);
+    }
+
+    return oct2bit(os);
+  }
+  
+  INTEGER fx__dec__SharedAtRequest(BITSTRING& b, EtsiTs102941TypesAuthorization::SharedAtRequest& p_shared_at) {
+    loggers::get_instance().log_msg(">>> fx__dec__SharedAtRequest: ", b);
+
+    etsi_ts102941_types_authorization_shared_at_request codec;
+    OCTETSTRING is = bit2oct(b);
+    if (codec.decode(is, p_shared_at) == -1) {
+      loggers::get_instance().warning("fx__dec__SharedAtRequest: -1 result code was returned");
+      return -1;
+    }
+
+    loggers::get_instance().log_msg("<<< fx__dec__SharedAtRequest: ", p_shared_at);
+    return 0;
+  }
+  
+  BITSTRING fx__enc__AuthorizationValidationRequest(EtsiTs102941TypesAuthorizationValidation::AuthorizationValidationRequest const& p_shared_at) {
+    loggers::get_instance().log_msg(">>> fx__enc__AuthorizationValidationRequest: ", p_shared_at);
 
+    etsi_ts102941_types_authorization_validation_request codec;
+    OCTETSTRING os;
+    if (codec.encode(p_shared_at, os) == -1) {
+      loggers::get_instance().warning("fx__enc__AuthorizationValidationRequest: -1 result code was returned");
+      return int2bit(0, 1);
+    }
+
+    return oct2bit(os);
+  }
+  
+  INTEGER fx__dec__AuthorizationValidationRequest(BITSTRING& b, EtsiTs102941TypesAuthorizationValidation::AuthorizationValidationRequest& p_shared_at) {
+    loggers::get_instance().log_msg(">>> fx__dec__AuthorizationValidationRequest: ", b);
+
+    etsi_ts102941_types_authorization_validation_request codec;
+    OCTETSTRING is = bit2oct(b);
+    if (codec.decode(is, p_shared_at) == -1) {
+      loggers::get_instance().warning("fx__dec__AuthorizationValidationRequest: -1 result code was returned");
+      return -1;
+    }
+
+    loggers::get_instance().log_msg("<<< fx__dec__AuthorizationValidationRequest: ", p_shared_at);
+    return 0;
+  }
+  
 } // End of namespace LibItsPki__EncdecDeclarations

ccsrc/Externals/LibItsSecurity_externals.cc

@@ -595,7 +595,7 @@ namespace LibItsSecurity__Functions
   // TODO Use common function for both fx__encryptWithEciesxxx and fx__decryptWithEciesxxx function
   OCTETSTRING fx__encryptWithEciesNistp256WithSha256(const OCTETSTRING& p__toBeEncryptedSecuredMessage, const OCTETSTRING& p__recipientsPublicKeyCompressed, const INTEGER& p__compressedMode, OCTETSTRING& p__publicEphemeralKeyCompressed, INTEGER& p__ephemeralCompressedMode, OCTETSTRING& p__encrypted__sym__key, OCTETSTRING& p__authentication__vector, OCTETSTRING& p__nonce) {
     loggers::get_instance().log_msg(">>> fx__encryptWithEciesNistp256WithSha256: p__toBeEncryptedSecuredMessage: ", p__toBeEncryptedSecuredMessage);
-    loggers::get_instance().log_msg(">>> fx__encryptWithEciesNistp256WithSha256: p__recipientsPublicKeyX: ", p__recipientsPublicKeyCompressed);
+    loggers::get_instance().log_msg(">>> fx__encryptWithEciesNistp256WithSha256: p__recipientsPublicKeyCompressed", p__recipientsPublicKeyCompressed);
     loggers::get_instance().log(">>> fx__encryptWithEciesNistp256WithSha256: p__compressedMode: %d", static_cast<int>(p__compressedMode));
     
     // 1. Generate new Private/Public key

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/CAM_ports/AdapterControlPort_CAM.partC

@@ -98,7 +98,7 @@ void AdapterControlPort::outgoing_send(const LibItsCommon__TypesAndValues::AcSec
       loggers::get_instance().log_msg("AdapterControlPort::outgoing_send: Send response: ", response);
       incoming_message(response);
     } else {
-      loggers::get_instance().error("AdapterControlPort::outgoing_send: %s not registered", "geoNetworkingPort");
+      loggers::get_instance().error("AdapterControlPort::outgoing_send: CAM not registered");
     }
 }
 

ccsrc/Ports/LibIts_ports/Pki_ports/AdapterControlPkiPort.hh

@@ -38,3 +38,4 @@ protected:
 };
 
 } /* end of namespace */
+

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/PkiPort.cc

@@ -113,6 +113,19 @@ namespace LibItsPki__TestSystem {
 
   }
 
+  void PkiPort::outgoing_send(const EtsiTs102941TypesAuthorizationValidation::AuthorizationValidationRequest& send_par) {
+    loggers::get_instance().log_msg(">>> PkiPort::outgoing_send: payload=", send_par);
+    
+    float duration;
+    loggers::get_instance().set_start_time(_time_key);
+    params params;
+    static_cast<pki_layer *>(_layer)->sendMsg(send_par, params);
+    loggers::get_instance().set_stop_time(_time_key, duration);
+  }
+  
+  void PkiPort::outgoing_send(const EtsiTs102941TypesAuthorizationValidation::AuthorizationValidationResponse& send_par) {
+  }
+  
   void PkiPort::receiveMsg (const EtsiTs102941TypesEnrolment::InnerEcRequest& p_ind, const params& p_params) {
     loggers::get_instance().log_msg(">>> PkiPort::receive_msg: ", p_ind);
     // Sanity check
@@ -132,6 +145,26 @@ namespace LibItsPki__TestSystem {
 
     incoming_message(p_ind);
   }
+  
+  void PkiPort::receiveMsg (const EtsiTs102941TypesAuthorizationValidation::AuthorizationValidationRequest& p_ind, const params& p_params) {
+    loggers::get_instance().log_msg(">>> PkiPort::receive_msg: ", p_ind);
+    // Sanity check
+    if (!p_ind.is_bound()) {
+      return;
+    }
+
+    incoming_message(p_ind);
+  }
+
+  void PkiPort::receiveMsg (const EtsiTs102941TypesAuthorizationValidation::AuthorizationValidationResponse& p_ind, const params& p_params) {
+    loggers::get_instance().log_msg(">>> PkiPort::receive_msg: ", p_ind);
+    // Sanity check
+    if (!p_ind.is_bound()) {
+      return;
+    }
 
+    incoming_message(p_ind);
+  }
+  
 } /* end of namespace */
 

ccsrc/Ports/LibIts_ports/Pki_ports/PkiPort.hh

@@ -29,6 +29,8 @@ public:
 	void set_parameter(const char *parameter_name, const char *parameter_value);
 	void receiveMsg (const EtsiTs102941TypesEnrolment::InnerEcRequest& p_ind, const params& p_params);
 	void receiveMsg (const EtsiTs102941TypesEnrolment::InnerEcResponse& p_ind, const params& p_params);
+	void receiveMsg (const EtsiTs102941TypesAuthorizationValidation::AuthorizationValidationRequest& p_ind, const params& p_params);
+	void receiveMsg (const EtsiTs102941TypesAuthorizationValidation::AuthorizationValidationResponse& p_ind, const params& p_params);
 
 private:
 	/* void Handle_Fd_Event(int fd, boolean is_readable,
@@ -46,6 +48,8 @@ protected:
 
 	void outgoing_send(const EtsiTs102941TypesEnrolment::InnerEcRequest& send_par);