Remove symbol : ckmc_label_shared_owner

[platform/core/security/key-manager.git] / src / manager / client-capi / ckmc-type.cpp

diff --git a/src/manager/client-capi/ckmc-type.cpp b/src/manager/client-capi/ckmc-type.cpp
index 6f1ddd2..57071f0 100644 (file)
--- a/src/manager/client-capi/ckmc-type.cpp
+++ b/src/manager/client-capi/ckmc-type.cpp
@@ -67,7 +67,6 @@ int _ckmc_load_cert_from_x509(X509 *xCert, ckmc_cert_s **cert)
 
 
 const char * const ckmc_label_name_separator    = CKM::LABEL_NAME_SEPARATOR;
-const char * const ckmc_label_shared_owner      = CKM::OWNER_ID_SYSTEM;
 const char * const ckmc_owner_id_separator      = CKM::LABEL_NAME_SEPARATOR;
 const char * const ckmc_owner_id_system         = CKM::OWNER_ID_SYSTEM;
 
@@ -572,19 +571,19 @@ void ckmc_cert_list_all_free(ckmc_cert_list_s *first)
 }
 
 KEY_MANAGER_CAPI
-int ckmc_param_list_new(ckmc_param_list_s **ppparams)
+int ckmc_param_list_new(ckmc_param_list_h *pparams)
 {
-    if (!ppparams)
+    if (!pparams || *pparams)
         return CKMC_ERROR_INVALID_PARAMETER;
 
-    *ppparams = reinterpret_cast<ckmc_param_list_s*>(new(std::nothrow)(CKM::CryptoAlgorithm));
-    if (!*ppparams)
+    *pparams = reinterpret_cast<ckmc_param_list_h>(new(std::nothrow)(CKM::CryptoAlgorithm));
+    if (!*pparams)
         return CKMC_ERROR_OUT_OF_MEMORY;
     return CKMC_ERROR_NONE;
 }
 
 KEY_MANAGER_CAPI
-int ckmc_param_list_add_integer(ckmc_param_list_s *params,
+int ckmc_param_list_set_integer(ckmc_param_list_h params,
                                 ckmc_param_name_e name,
                                 uint64_t value)
 {
@@ -597,7 +596,7 @@ int ckmc_param_list_add_integer(ckmc_param_list_s *params,
 }
 
 KEY_MANAGER_CAPI
-int ckmc_param_list_add_buffer(ckmc_param_list_s *params,
+int ckmc_param_list_set_buffer(ckmc_param_list_h params,
                                ckmc_param_name_e name,
                                const ckmc_raw_buffer_s *buffer)
 {
@@ -611,26 +610,26 @@ int ckmc_param_list_add_buffer(ckmc_param_list_s *params,
 }
 
 KEY_MANAGER_CAPI
-int ckmc_param_list_get_integer(const ckmc_param_list_s *params,
+int ckmc_param_list_get_integer(ckmc_param_list_h params,
                                 ckmc_param_name_e name,
-                                uint64_t* value)
+                                uint64_t *pvalue)
 {
-    if (!params || !value)
+    if (!params || !pvalue)
         return CKMC_ERROR_INVALID_PARAMETER;
 
     const CKM::CryptoAlgorithm* algo = reinterpret_cast<const CKM::CryptoAlgorithm*>(params);
-    if (!algo->getParam(static_cast<CKM::ParamName>(name),*value))
+    if (!algo->getParam(static_cast<CKM::ParamName>(name), *pvalue))
         return CKMC_ERROR_INVALID_PARAMETER;
 
     return CKMC_ERROR_NONE;
 }
 
 KEY_MANAGER_CAPI
-int ckmc_param_list_get_buffer(const ckmc_param_list_s *params,
+int ckmc_param_list_get_buffer(ckmc_param_list_h params,
                                ckmc_param_name_e name,
-                               ckmc_raw_buffer_s **buffer)
+                               ckmc_raw_buffer_s **ppbuffer)
 {
-    if (!params || !buffer)
+    if (!params || !ppbuffer || *ppbuffer)
         return CKMC_ERROR_INVALID_PARAMETER;
 
     const CKM::CryptoAlgorithm* algo = reinterpret_cast<const CKM::CryptoAlgorithm*>(params);
@@ -638,28 +637,30 @@ int ckmc_param_list_get_buffer(const ckmc_param_list_s *params,
     if (!algo->getParam(static_cast<CKM::ParamName>(name),value))
         return CKMC_ERROR_INVALID_PARAMETER;
 
-    return ckmc_buffer_new(value.data(), value.size(), buffer);
+    return ckmc_buffer_new(value.data(), value.size(), ppbuffer);
 }
 
 KEY_MANAGER_CAPI
-void ckmc_param_list_free(ckmc_param_list_s *params)
+void ckmc_param_list_free(ckmc_param_list_h params)
 {
     CKM::CryptoAlgorithm* algo = reinterpret_cast<CKM::CryptoAlgorithm*>(params);
     delete algo;
 }
 
 KEY_MANAGER_CAPI
-int ckmc_generate_params(ckmc_algo_type_e type, ckmc_param_list_s *params)
+int ckmc_generate_new_params(ckmc_algo_type_e type, ckmc_param_list_h *pparams)
 {
-    // return error if params are NULL
-    if(params == NULL)
+    if (!pparams || *pparams)
         return CKMC_ERROR_INVALID_PARAMETER;
 
-    int ret = CKMC_ERROR_NONE;
-    switch(type)
-    {
+    ckmc_param_list_h params = NULL;
+    int ret = ckmc_param_list_new(&params);
+    if (ret != CKMC_ERROR_NONE)
+        return ret;
+
+    switch (type) {
     case CKMC_ALGO_AES_CTR:
-        ret = ckmc_param_list_add_integer(params, CKMC_PARAM_ED_CTR_LEN, DEFAULT_IV_LEN_BITS);
+        ret = ckmc_param_list_set_integer(params, CKMC_PARAM_ED_CTR_LEN, DEFAULT_IV_LEN_BITS);
         break;
     case CKMC_ALGO_AES_CBC:
     case CKMC_ALGO_AES_GCM:
@@ -667,22 +668,23 @@ int ckmc_generate_params(ckmc_algo_type_e type, ckmc_param_list_s *params)
     case CKMC_ALGO_RSA_OAEP:
         // no iv by default
         break;
-    case CKMC_ALGO_RSA_SV:
-    case CKMC_ALGO_DSA_SV:
-    case CKMC_ALGO_ECDSA_SV:
-        // no hash, no padding by default
-        break;
-    case CKMC_ALGO_RSA_GEN:
-    case CKMC_ALGO_DSA_GEN:
-        ret = ckmc_param_list_add_integer(params, CKMC_PARAM_GEN_KEY_LEN, DEFAULT_KEY_LEN_BITS);
-        break;
-    case CKMC_ALGO_ECDSA_GEN:
-        ret = ckmc_param_list_add_integer(params, CKMC_PARAM_GEN_EC, CKMC_EC_PRIME192V1);
-        break;
     default:
-        return CKMC_ERROR_INVALID_PARAMETER;
+        ret = CKMC_ERROR_INVALID_PARAMETER;
+        break;
     }
-    if (ret == CKMC_ERROR_NONE)
-        return ckmc_param_list_add_integer(params, CKMC_PARAM_ALGO_TYPE, type);
-    return ret;
+
+    if (ret != CKMC_ERROR_NONE) {
+        ckmc_param_list_free(params);
+        return ret;
+    }
+
+    ret = ckmc_param_list_set_integer(params, CKMC_PARAM_ALGO_TYPE, type);
+    if (ret != CKMC_ERROR_NONE) {
+        ckmc_param_list_free(params);
+        return ret;
+    }
+
+    *pparams = params;
+
+    return CKMC_ERROR_NONE;
 }