Change error code names.

Old prefix was "KEY_MANAGER_API_"
New prefix is "CKM_API_"

Change-Id: I9bce2da2c08d6768ff0fd8ff160ea3dcafb559a7

diff --git a/src/include/ckm/ckm-error.h b/src/include/ckm/ckm-error.h
index 63bd285..891e528 100644 (file)
--- a/src/include/ckm/ckm-error.h
+++ b/src/include/ckm/ckm-error.h
@@ -51,56 +51,56 @@
  * result codes begin with the start error code and extend into negative direction.
  * @{
 */
-#define KEY_MANAGER_API_SUCCESS 0
+#define CKM_API_SUCCESS 0
 /*! \brief   indicating the result of the one specific API is successful */
-#define KEY_MANAGER_API_ERROR_SOCKET -1
+#define CKM_API_ERROR_SOCKET -1
 
 /*! \brief   indicating the socket between client and Central Key Manager failed  */
-#define KEY_MANAGER_API_ERROR_BAD_REQUEST -2
+#define CKM_API_ERROR_BAD_REQUEST -2
 
 /*! \brief   indicating the response from Central Key Manager is malformed */
-#define KEY_MANAGER_API_ERROR_BAD_RESPONSE -3
+#define CKM_API_ERROR_BAD_RESPONSE -3
 
 /*! \brief   indicating the transmitting request failed */
 /* deprecated unused */
-#define KEY_MANAGER_API_ERROR_SEND_FAILED -4
+#define CKM_API_ERROR_SEND_FAILED -4
 
 /*! \brief   indicating the receiving response failed */
 /* deprecated unused */
-#define KEY_MANAGER_API_ERROR_RECV_FAILED -5
+#define CKM_API_ERROR_RECV_FAILED -5
 
 /*! \brief   indicating the authentication between client and manager failed */
-#define KEY_MANAGER_API_ERROR_AUTHENTICATION_FAILED -6
+#define CKM_API_ERROR_AUTHENTICATION_FAILED -6
 
 /*! \brief   indicating the API's input parameter is malformed */
-#define KEY_MANAGER_API_ERROR_INPUT_PARAM -7
+#define CKM_API_ERROR_INPUT_PARAM -7
 
 /*! \brief   indicating the output buffer size which is passed as parameter is too small */
-#define KEY_MANAGER_API_ERROR_BUFFER_TOO_SMALL -8
+#define CKM_API_ERROR_BUFFER_TOO_SMALL -8
 
 /*! \brief   indicating system  is running out of memory state */
-#define KEY_MANAGER_API_ERROR_OUT_OF_MEMORY -9
+#define CKM_API_ERROR_OUT_OF_MEMORY -9
 
 /*! \brief   indicating the access has been denied by Central Key Manager */
-#define KEY_MANAGER_API_ERROR_ACCESS_DENIED -10
+#define CKM_API_ERROR_ACCESS_DENIED -10
 
 /*! \brief   indicating Central Key Manager has been failed for some reason */
-#define KEY_MANAGER_API_ERROR_SERVER_ERROR -11
+#define CKM_API_ERROR_SERVER_ERROR -11
 
 /*! \brief   indicating the database was not unlocked - user did not login */
-#define KEY_MANAGER_API_ERROR_DB_LOCKED -12
+#define CKM_API_ERROR_DB_LOCKED -12
 
 /*! \brief   indicating an internal error inside the database */
-#define KEY_MANAGER_API_ERROR_DB_ERROR -13
+#define CKM_API_ERROR_DB_ERROR -13
 
 /*! \brief   indicating that provided alias already exists in the database */
-#define KEY_MANAGER_API_ERROR_DB_ALIAS_EXISTS -14
+#define CKM_API_ERROR_DB_ALIAS_EXISTS -14
 
 /*! \brief   indicating that request give to database returned no result */
-#define KEY_MANAGER_API_ERROR_DB_ALIAS_UNKNOWN -15
+#define CKM_API_ERROR_DB_ALIAS_UNKNOWN -15
 
 /*! \brief   indicating the error with unknown reason */
-#define KEY_MANAGER_API_ERROR_UNKNOWN -255
+#define CKM_API_ERROR_UNKNOWN -255
 /** @}*/
 
 namespace CKM {
@@ -120,8 +120,8 @@ extern "C" {
  * \param[in] Message for service
  * \param[out] Response from service
  *
- * \return KEY_MANAGER_API_ERROR_INPUT_PARAM when trying to pass NULL message
- * \return KEY_MANAGER_API_SUCCESS on success
+ * \return CKM_API_ERROR_INPUT_PARAM when trying to pass NULL message
+ * \return CKM_API_SUCCESS on success
  */
 
 int key_manager_echo(const char* echo, char** oche);

diff --git a/src/manager/client/client-common.cpp b/src/manager/client/client-common.cpp
index 8564d79..97c2cc9 100644 (file)
--- a/src/manager/client/client-common.cpp
+++ b/src/manager/client/client-common.cpp
@@ -89,7 +89,7 @@ public:
         if (m_sock < 0) {
             int err = errno;
             LogError("Error creating socket: " << strerror(err));
-            return KEY_MANAGER_API_ERROR_SOCKET;
+            return CKM_API_ERROR_SOCKET;
         }
 
         if ((flags = fcntl(m_sock, F_GETFL, 0)) < 0 ||
@@ -97,7 +97,7 @@ public:
         {
             int err = errno;
             LogError("Error in fcntl: " << strerror(err));
-            return KEY_MANAGER_API_ERROR_SOCKET;
+            return CKM_API_ERROR_SOCKET;
         }
 
         memset(&clientAddr, 0, sizeof(clientAddr));
@@ -106,7 +106,7 @@ public:
 
         if (strlen(interface) >= sizeof(clientAddr.sun_path)) {
             LogError("Error: interface name " << interface << "is too long. Max len is:" << sizeof(clientAddr.sun_path));
-            return KEY_MANAGER_API_ERROR_SOCKET;
+            return CKM_API_ERROR_SOCKET;
         }
 
         strcpy(clientAddr.sun_path, interface);
@@ -117,7 +117,7 @@ public:
         if ((retval == -1) && (errno == EINPROGRESS)) {
             if (0 >= waitForSocket(m_sock, POLLIN, POLL_TIMEOUT)) {
                 LogError("Error in waitForSocket.");
-                return KEY_MANAGER_API_ERROR_SOCKET;
+                return CKM_API_ERROR_SOCKET;
             }
             int error = 0;
             size_t len = sizeof(error);
@@ -126,31 +126,31 @@ public:
             if (-1 == retval) {
                 int err = errno;
                 LogError("Error in getsockopt: " << strerror(err));
-                return KEY_MANAGER_API_ERROR_SOCKET;
+                return CKM_API_ERROR_SOCKET;
             }
 
             if (error == EACCES) {
                 LogError("Access denied");
-                return KEY_MANAGER_API_ERROR_ACCESS_DENIED;
+                return CKM_API_ERROR_ACCESS_DENIED;
             }
 
             if (error != 0) {
                 LogError("Error in connect: " << strerror(error));
-                return KEY_MANAGER_API_ERROR_SOCKET;
+                return CKM_API_ERROR_SOCKET;
             }
 
-            return KEY_MANAGER_API_SUCCESS;
+            return CKM_API_SUCCESS;
         }
 
         if (-1 == retval) {
             int err = errno;
             LogError("Error connecting socket: " << strerror(err));
             if (err == EACCES)
-                return KEY_MANAGER_API_ERROR_ACCESS_DENIED;
-            return KEY_MANAGER_API_ERROR_SOCKET;
+                return CKM_API_ERROR_ACCESS_DENIED;
+            return CKM_API_ERROR_SOCKET;
         }
 
-        return KEY_MANAGER_API_SUCCESS;
+        return CKM_API_SUCCESS;
     }
 
     int Get() {
@@ -172,7 +172,7 @@ int sendToServer(char const * const interface, const RawBuffer &send, MessageBuf
     ssize_t done = 0;
     char buffer[2048];
 
-    if (KEY_MANAGER_API_SUCCESS != (ret = sock.Connect(interface))) {
+    if (CKM_API_SUCCESS != (ret = sock.Connect(interface))) {
         LogError("Error in SockRAII");
         return ret;
     }
@@ -180,13 +180,13 @@ int sendToServer(char const * const interface, const RawBuffer &send, MessageBuf
     while ((send.size() - done) > 0) {
         if (0 >= waitForSocket(sock.Get(), POLLOUT, POLL_TIMEOUT)) {
             LogError("Error in poll(POLLOUT)");
-            return KEY_MANAGER_API_ERROR_SOCKET;
+            return CKM_API_ERROR_SOCKET;
         }
         ssize_t temp = TEMP_FAILURE_RETRY(write(sock.Get(), &send[done], send.size() - done));
         if (-1 == temp) {
             int err = errno;
             LogError("Error in write: " << strerror(err));
-            return KEY_MANAGER_API_ERROR_SOCKET;
+            return CKM_API_ERROR_SOCKET;
         }
         done += temp;
     }
@@ -194,24 +194,24 @@ int sendToServer(char const * const interface, const RawBuffer &send, MessageBuf
     do {
         if (0 >= waitForSocket(sock.Get(), POLLIN, POLL_TIMEOUT)) {
             LogError("Error in poll(POLLIN)");
-            return KEY_MANAGER_API_ERROR_SOCKET;
+            return CKM_API_ERROR_SOCKET;
         }
         ssize_t temp = TEMP_FAILURE_RETRY(read(sock.Get(), buffer, 2048));
         if (-1 == temp) {
             int err = errno;
             LogError("Error in read: " << strerror(err));
-            return KEY_MANAGER_API_ERROR_SOCKET;
+            return CKM_API_ERROR_SOCKET;
         }
 
         if (0 == temp) {
             LogError("Read return 0/Connection closed by server(?)");
-            return KEY_MANAGER_API_ERROR_SOCKET;
+            return CKM_API_ERROR_SOCKET;
         }
 
         RawBuffer raw(buffer, buffer+temp);
         recv.Push(raw);
     } while(!recv.Ready());
-    return KEY_MANAGER_API_SUCCESS;
+    return CKM_API_SUCCESS;
 }
 
 int try_catch(const std::function<int()>& func)
@@ -225,7 +225,7 @@ int try_catch(const std::function<int()>& func)
     } catch (...) {
         LogError("Unknown exception occured");
     }
-    return KEY_MANAGER_API_ERROR_UNKNOWN;
+    return CKM_API_ERROR_UNKNOWN;
 }
 
 } // namespace CKM

diff --git a/src/manager/client/client-control.cpp b/src/manager/client/client-control.cpp
index 4819369..03eecd4 100644 (file)
--- a/src/manager/client/client-control.cpp
+++ b/src/manager/client/client-control.cpp
@@ -48,7 +48,7 @@ public:
                 send.Pop(),
                 recv);
 
-            if (KEY_MANAGER_API_SUCCESS != retCode) {
+            if (CKM_API_SUCCESS != retCode) {
                 return retCode;
             }
 
@@ -69,7 +69,7 @@ public:
                 send.Pop(),
                 recv);
 
-            if (KEY_MANAGER_API_SUCCESS != retCode) {
+            if (CKM_API_SUCCESS != retCode) {
                 return retCode;
             }
 
@@ -90,7 +90,7 @@ public:
                 send.Pop(),
                 recv);
 
-            if (KEY_MANAGER_API_SUCCESS != retCode) {
+            if (CKM_API_SUCCESS != retCode) {
                 return retCode;
             }
 
@@ -113,7 +113,7 @@ public:
                 send.Pop(),
                 recv);
 
-            if (KEY_MANAGER_API_SUCCESS != retCode) {
+            if (CKM_API_SUCCESS != retCode) {
                 return retCode;
             }
 
@@ -135,7 +135,7 @@ public:
                 send.Pop(),
                 recv);
 
-            if (KEY_MANAGER_API_SUCCESS != retCode) {
+            if (CKM_API_SUCCESS != retCode) {
                 return retCode;
             }
 

diff --git a/src/manager/client/client-echo.cpp b/src/manager/client/client-echo.cpp
index d836042..584ebaa 100644 (file)
--- a/src/manager/client/client-echo.cpp
+++ b/src/manager/client/client-echo.cpp
@@ -34,7 +34,7 @@ int key_manager_echo(const char *echo, char** oche) {
 
     if(echo == NULL){
         LogDebug("Echo message is null");
-        return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+        return CKM_API_ERROR_INPUT_PARAM;
     }
 
     MessageBuffer send, recv;
@@ -42,7 +42,7 @@ int key_manager_echo(const char *echo, char** oche) {
 
     int retCode = sendToServer(SERVICE_SOCKET_ECHO, send.Pop(), recv);
 
-    if(retCode != KEY_MANAGER_API_SUCCESS)
+    if(retCode != CKM_API_SUCCESS)
         return retCode;
 
     std::string response;
@@ -50,5 +50,5 @@ int key_manager_echo(const char *echo, char** oche) {
 
     *oche = strdup(response.c_str());
 
-    return KEY_MANAGER_API_SUCCESS;
+    return CKM_API_SUCCESS;
 }

diff --git a/src/manager/client/client-error.cpp b/src/manager/client/client-error.cpp
index 3f846ed..663ac6b 100644 (file)
--- a/src/manager/client/client-error.cpp
+++ b/src/manager/client/client-error.cpp
@@ -26,23 +26,23 @@ namespace CKM {
 __attribute__ ((visibility ("default")))
 const char * ErrorToString(int error) {
     switch(error) {
-        ERRORDESCRIBE(KEY_MANAGER_API_SUCCESS);
-        ERRORDESCRIBE(KEY_MANAGER_API_ERROR_SOCKET);
-        ERRORDESCRIBE(KEY_MANAGER_API_ERROR_BAD_REQUEST);
-        ERRORDESCRIBE(KEY_MANAGER_API_ERROR_BAD_RESPONSE);
-        ERRORDESCRIBE(KEY_MANAGER_API_ERROR_SEND_FAILED);
-        ERRORDESCRIBE(KEY_MANAGER_API_ERROR_RECV_FAILED);
-        ERRORDESCRIBE(KEY_MANAGER_API_ERROR_AUTHENTICATION_FAILED);
-        ERRORDESCRIBE(KEY_MANAGER_API_ERROR_INPUT_PARAM);
-        ERRORDESCRIBE(KEY_MANAGER_API_ERROR_BUFFER_TOO_SMALL);
-        ERRORDESCRIBE(KEY_MANAGER_API_ERROR_OUT_OF_MEMORY);
-        ERRORDESCRIBE(KEY_MANAGER_API_ERROR_ACCESS_DENIED);
-        ERRORDESCRIBE(KEY_MANAGER_API_ERROR_SERVER_ERROR);
-        ERRORDESCRIBE(KEY_MANAGER_API_ERROR_DB_LOCKED);
-        ERRORDESCRIBE(KEY_MANAGER_API_ERROR_DB_ERROR);
-        ERRORDESCRIBE(KEY_MANAGER_API_ERROR_DB_ALIAS_EXISTS);
-        ERRORDESCRIBE(KEY_MANAGER_API_ERROR_DB_ALIAS_UNKNOWN);
-        ERRORDESCRIBE(KEY_MANAGER_API_ERROR_UNKNOWN);
+        ERRORDESCRIBE(CKM_API_SUCCESS);
+        ERRORDESCRIBE(CKM_API_ERROR_SOCKET);
+        ERRORDESCRIBE(CKM_API_ERROR_BAD_REQUEST);
+        ERRORDESCRIBE(CKM_API_ERROR_BAD_RESPONSE);
+        ERRORDESCRIBE(CKM_API_ERROR_SEND_FAILED);
+        ERRORDESCRIBE(CKM_API_ERROR_RECV_FAILED);
+        ERRORDESCRIBE(CKM_API_ERROR_AUTHENTICATION_FAILED);
+        ERRORDESCRIBE(CKM_API_ERROR_INPUT_PARAM);
+        ERRORDESCRIBE(CKM_API_ERROR_BUFFER_TOO_SMALL);
+        ERRORDESCRIBE(CKM_API_ERROR_OUT_OF_MEMORY);
+        ERRORDESCRIBE(CKM_API_ERROR_ACCESS_DENIED);
+        ERRORDESCRIBE(CKM_API_ERROR_SERVER_ERROR);
+        ERRORDESCRIBE(CKM_API_ERROR_DB_LOCKED);
+        ERRORDESCRIBE(CKM_API_ERROR_DB_ERROR);
+        ERRORDESCRIBE(CKM_API_ERROR_DB_ALIAS_EXISTS);
+        ERRORDESCRIBE(CKM_API_ERROR_DB_ALIAS_UNKNOWN);
+        ERRORDESCRIBE(CKM_API_ERROR_UNKNOWN);
     default:
         return "Error not defined";
     }

diff --git a/src/manager/client/client-manager-impl.cpp b/src/manager/client/client-manager-impl.cpp
index d5bf19a..d2848b7 100644 (file)
--- a/src/manager/client/client-manager-impl.cpp
+++ b/src/manager/client/client-manager-impl.cpp
@@ -38,7 +38,7 @@ int Manager::ManagerImpl::saveBinaryData(
 
     return try_catch([&] {
         if (alias.empty() || rawData.empty())
-            return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+            return CKM_API_ERROR_INPUT_PARAM;
 
         MessageBuffer send, recv;
         Serialization::Serialize(send, static_cast<int>(LogicCommand::SAVE));
@@ -53,7 +53,7 @@ int Manager::ManagerImpl::saveBinaryData(
             send.Pop(),
             recv);
 
-        if (KEY_MANAGER_API_SUCCESS != retCode) {
+        if (CKM_API_SUCCESS != retCode) {
             return retCode;
         }
 
@@ -66,7 +66,7 @@ int Manager::ManagerImpl::saveBinaryData(
         Deserialization::Deserialize(recv, opType);
 
         if (counter != m_counter) {
-            return KEY_MANAGER_API_ERROR_UNKNOWN;
+            return CKM_API_ERROR_UNKNOWN;
         }
 
         return retCode;
@@ -75,7 +75,7 @@ int Manager::ManagerImpl::saveBinaryData(
 
 int Manager::ManagerImpl::saveKey(const Alias &alias, const Key &key, const Policy &policy) {
     if (key.empty())
-        return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+        return CKM_API_ERROR_INPUT_PARAM;
     return saveBinaryData(alias, toDBDataType(key.getType()), key.getDER(), policy);
 }
 
@@ -89,7 +89,7 @@ int Manager::ManagerImpl::saveCertificate(
 
 int Manager::ManagerImpl::saveData(const Alias &alias, const RawBuffer &rawData, const Policy &policy) {
     if (!policy.extractable)
-        return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+        return CKM_API_ERROR_INPUT_PARAM;
     return saveBinaryData(alias, DBDataType::BINARY_DATA, rawData, policy);
 }
 
@@ -97,7 +97,7 @@ int Manager::ManagerImpl::removeBinaryData(const Alias &alias, DBDataType dataTy
 {
     return try_catch([&] {
         if (alias.empty())
-            return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+            return CKM_API_ERROR_INPUT_PARAM;
 
         MessageBuffer send, recv;
         Serialization::Serialize(send, static_cast<int>(LogicCommand::REMOVE));
@@ -110,7 +110,7 @@ int Manager::ManagerImpl::removeBinaryData(const Alias &alias, DBDataType dataTy
             send.Pop(),
             recv);
 
-        if (KEY_MANAGER_API_SUCCESS != retCode) {
+        if (CKM_API_SUCCESS != retCode) {
             return retCode;
         }
 
@@ -123,7 +123,7 @@ int Manager::ManagerImpl::removeBinaryData(const Alias &alias, DBDataType dataTy
         Deserialization::Deserialize(recv, opType);
 
         if (counter != m_counter) {
-            return KEY_MANAGER_API_ERROR_UNKNOWN;
+            return CKM_API_ERROR_UNKNOWN;
         }
 
         return retCode;
@@ -151,7 +151,7 @@ int Manager::ManagerImpl::getBinaryData(
 {
     return try_catch([&] {
         if (alias.empty())
-            return KEY_MANAGER_API_ERROR_INPUT_PARAM;
+            return CKM_API_ERROR_INPUT_PARAM;
 
         MessageBuffer send, recv;
         Serialization::Serialize(send, static_cast<int>(LogicCommand::GET));
@@ -165,7 +165,7 @@ int Manager::ManagerImpl::getBinaryData(
             send.Pop(),
             recv);
 
-        if (KEY_MANAGER_API_SUCCESS != retCode) {
+        if (CKM_API_SUCCESS != retCode) {
             return retCode;
         }
 
@@ -180,7 +180,7 @@ int Manager::ManagerImpl::getBinaryData(
         recvDataType = static_cast<DBDataType>(tmpDataType);
 
         if (counter != m_counter) {
-            return KEY_MANAGER_API_ERROR_UNKNOWN;
+            return CKM_API_ERROR_UNKNOWN;
         }
 
         return retCode;
@@ -198,19 +198,19 @@ int Manager::ManagerImpl::getKey(const Alias &alias, const std::string &password
         recvDataType,
         rawData);
 
-    if (retCode != KEY_MANAGER_API_SUCCESS)
+    if (retCode != CKM_API_SUCCESS)
         return retCode;
 
     Key keyParsed(rawData);
 
     if (keyParsed.empty()) {
         LogDebug("Key empty - failed to parse!");
-        return KEY_MANAGER_API_ERROR_BAD_RESPONSE;
+        return CKM_API_ERROR_BAD_RESPONSE;
     }
 
     key = keyParsed;
 
-    return KEY_MANAGER_API_SUCCESS;
+    return CKM_API_SUCCESS;
 }
 
 int Manager::ManagerImpl::getCertificate(const Alias &alias, const std::string &password, Certificate &cert)
@@ -225,20 +225,20 @@ int Manager::ManagerImpl::getCertificate(const Alias &alias, const std::string &
         recvDataType,
         rawData);
 
-    if (retCode != KEY_MANAGER_API_SUCCESS)
+    if (retCode != CKM_API_SUCCESS)
         return retCode;
 
     if (recvDataType != DBDataType::CERTIFICATE)
-        return KEY_MANAGER_API_ERROR_BAD_RESPONSE;
+        return CKM_API_ERROR_BAD_RESPONSE;
 
     Certificate certParsed(rawData, DataFormat::FORM_DER);
 
     if (certParsed.empty())
-        return KEY_MANAGER_API_ERROR_BAD_RESPONSE;
+        return CKM_API_ERROR_BAD_RESPONSE;
 
     cert = certParsed;
 
-    return KEY_MANAGER_API_SUCCESS;
+    return CKM_API_SUCCESS;
 }
 
 int Manager::ManagerImpl::getData(const Alias &alias, const std::string &password, RawBuffer &rawData)
@@ -252,13 +252,13 @@ int Manager::ManagerImpl::getData(const Alias &alias, const std::string &passwor
         recvDataType,
         rawData);
 
-    if (retCode != KEY_MANAGER_API_SUCCESS)
+    if (retCode != CKM_API_SUCCESS)
         return retCode;
 
     if (recvDataType != DBDataType::BINARY_DATA)
-        return KEY_MANAGER_API_ERROR_BAD_RESPONSE;
+        return CKM_API_ERROR_BAD_RESPONSE;
 
-    return KEY_MANAGER_API_SUCCESS;
+    return CKM_API_SUCCESS;
 }
 
 int Manager::ManagerImpl::getBinaryDataAliasVector(DBDataType dataType, AliasVector &aliasVector)
@@ -275,7 +275,7 @@ int Manager::ManagerImpl::getBinaryDataAliasVector(DBDataType dataType, AliasVec
             send.Pop(),
             recv);
 
-        if (KEY_MANAGER_API_SUCCESS != retCode) {
+        if (CKM_API_SUCCESS != retCode) {
             return retCode;
         }
 
@@ -290,7 +290,7 @@ int Manager::ManagerImpl::getBinaryDataAliasVector(DBDataType dataType, AliasVec
         Deserialization::Deserialize(recv, aliasVector);
 
         if (counter != m_counter) {
-            return KEY_MANAGER_API_ERROR_UNKNOWN;
+            return CKM_API_ERROR_UNKNOWN;
         }
 
         return retCode;
@@ -336,7 +336,7 @@ int Manager::ManagerImpl::createKeyPairRSA(
             send.Pop(),
             recv);
 
-        if (KEY_MANAGER_API_SUCCESS != retCode) {
+        if (CKM_API_SUCCESS != retCode) {
             return retCode;
         }
 
@@ -349,7 +349,7 @@ int Manager::ManagerImpl::createKeyPairRSA(
         Deserialization::Deserialize(recv, retCode);
         
         if (counter != my_counter) {
-            return KEY_MANAGER_API_ERROR_UNKNOWN;
+            return CKM_API_ERROR_UNKNOWN;
         }
 
         return retCode;
@@ -382,7 +382,7 @@ int Manager::ManagerImpl::createKeyPairECDSA(
             send.Pop(),
             recv);
 
-        if (KEY_MANAGER_API_SUCCESS != retCode) {
+        if (CKM_API_SUCCESS != retCode) {
             return retCode;
         }
 
@@ -394,7 +394,7 @@ int Manager::ManagerImpl::createKeyPairECDSA(
         Deserialization::Deserialize(recv, retCode);
         
         if (counter != my_counter) {
-            return KEY_MANAGER_API_ERROR_UNKNOWN;
+            return CKM_API_ERROR_UNKNOWN;
         }
 
         return retCode;

diff --git a/src/manager/service/DBCryptoModule.cpp b/src/manager/service/DBCryptoModule.cpp
index 1139e5a..c3433f2 100644 (file)
--- a/src/manager/service/DBCryptoModule.cpp
+++ b/src/manager/service/DBCryptoModule.cpp
@@ -59,7 +59,7 @@ int DBCryptoModule::pushKey(const std::string &smackLabel,
                  << "label already exists.");
     }
     m_keyMap[smackLabel] = applicationKey;
-    return KEY_MANAGER_API_SUCCESS;
+    return CKM_API_SUCCESS;
 }
 
 std::size_t DBCryptoModule::insertDigest(RawBuffer &data, const int dataSize)
@@ -132,7 +132,7 @@ int DBCryptoModule::encryptRow(const std::string &password, DBRow &row)
     crow.algorithmType = DBCMAlgType::AES_CBC_256;
     row = crow;
 
-    return KEY_MANAGER_API_SUCCESS;
+    return CKM_API_SUCCESS;
 }
 
 int DBCryptoModule::decryptRow(const std::string &password, DBRow &row)
@@ -193,7 +193,7 @@ int DBCryptoModule::decryptRow(const std::string &password, DBRow &row)
     }
     row = crow;
 
-    return KEY_MANAGER_API_SUCCESS;
+    return CKM_API_SUCCESS;
 }
 
 RawBuffer DBCryptoModule::generateRandIV(void)

diff --git a/src/manager/service/ckm-logic.cpp b/src/manager/service/ckm-logic.cpp
index d40e972..83e8a19 100644 (file)
--- a/src/manager/service/ckm-logic.cpp
+++ b/src/manager/service/ckm-logic.cpp
@@ -44,7 +44,7 @@ CKMLogic::~CKMLogic(){}
 
 RawBuffer CKMLogic::unlockUserKey(uid_t user, const std::string &password) {
     // TODO try catch for all errors that should be supported by error code
-    int retCode = KEY_MANAGER_API_SUCCESS;
+    int retCode = CKM_API_SUCCESS;
 
     try {
         if (0 == m_userDataMap.count(user) || !(m_userDataMap[user].keyProvider.isInitialized())) {
@@ -66,7 +66,7 @@ RawBuffer CKMLogic::unlockUserKey(uid_t user, const std::string &password) {
         }
     } catch (const KeyProvider::Exception::Base &e) {
         LogError("Error in KeyProvider " << e.GetMessage());
-        retCode = KEY_MANAGER_API_ERROR_SERVER_ERROR;
+        retCode = CKM_API_ERROR_SERVER_ERROR;
     }
 
     MessageBuffer response;
@@ -75,7 +75,7 @@ RawBuffer CKMLogic::unlockUserKey(uid_t user, const std::string &password) {
 }
 
 RawBuffer CKMLogic::lockUserKey(uid_t user) {
-    int retCode = KEY_MANAGER_API_SUCCESS;
+    int retCode = CKM_API_SUCCESS;
     // TODO try catch for all errors that should be supported by error code
     m_userDataMap.erase(user);
 
@@ -85,7 +85,7 @@ RawBuffer CKMLogic::lockUserKey(uid_t user) {
 }
 
 RawBuffer CKMLogic::removeUserData(uid_t user) {
-    int retCode = KEY_MANAGER_API_SUCCESS;
+    int retCode = CKM_API_SUCCESS;
     // TODO try catch for all errors that should be supported by error code
     m_userDataMap.erase(user);
 
@@ -102,12 +102,12 @@ RawBuffer CKMLogic::changeUserPassword(
     const std::string &oldPassword,
     const std::string &newPassword)
 {
-    int retCode = KEY_MANAGER_API_SUCCESS;
+    int retCode = CKM_API_SUCCESS;
     // TODO try-catch
     FileSystem fs(user);
     auto wrappedDomainKEK = fs.getDomainKEK();
     if (wrappedDomainKEK.empty()) {
-        retCode = KEY_MANAGER_API_ERROR_BAD_REQUEST;
+        retCode = CKM_API_ERROR_BAD_REQUEST;
     } else {
         wrappedDomainKEK = KeyProvider::reencrypt(wrappedDomainKEK, oldPassword, newPassword);
         fs.saveDomainKEK(wrappedDomainKEK);
@@ -121,10 +121,10 @@ RawBuffer CKMLogic::resetUserPassword(
     uid_t user,
     const std::string &newPassword)
 {
-    int retCode = KEY_MANAGER_API_SUCCESS;
+    int retCode = CKM_API_SUCCESS;
     // TODO try-catch
     if (0 == m_userDataMap.count(user)) {
-        retCode = KEY_MANAGER_API_ERROR_BAD_REQUEST;
+        retCode = CKM_API_ERROR_BAD_REQUEST;
     } else {
         auto &handler = m_userDataMap[user];
         FileSystem fs(user);
@@ -144,7 +144,7 @@ int CKMLogic::saveDataHelper(
     const PolicySerializable &policy)
 {
     if (0 == m_userDataMap.count(cred.uid))
-        return KEY_MANAGER_API_ERROR_DB_LOCKED;
+        return CKM_API_ERROR_DB_LOCKED;
 
     DBRow row = { alias, cred.smackLabel, policy.restricted,
          policy.extractable, dataType, DBCMAlgType::NONE,
@@ -170,7 +170,7 @@ int CKMLogic::saveDataHelper(
     handler.crypto.encryptRow(policy.password, row);
     handler.database.saveDBRow(row);
     transaction.commit();
-    return KEY_MANAGER_API_SUCCESS;
+    return CKM_API_SUCCESS;
 }
 
 RawBuffer CKMLogic::saveData(
@@ -181,25 +181,25 @@ RawBuffer CKMLogic::saveData(
     const RawBuffer &key,
     const PolicySerializable &policy)
 {
-    int retCode = KEY_MANAGER_API_SUCCESS;
+    int retCode = CKM_API_SUCCESS;
     try {
         retCode = saveDataHelper(cred, dataType, alias, key, policy);
         LogDebug("SaveDataHelper returned: " << retCode);
     } catch (const KeyProvider::Exception::Base &e) {
         LogError("KeyProvider failed with message: " << e.GetMessage());
-        retCode = KEY_MANAGER_API_ERROR_SERVER_ERROR;
+        retCode = CKM_API_ERROR_SERVER_ERROR;
     } catch (const DBCryptoModule::Exception::Base &e) {
         LogError("DBCryptoModule failed with message: " << e.GetMessage());
-        retCode = KEY_MANAGER_API_ERROR_SERVER_ERROR;
+        retCode = CKM_API_ERROR_SERVER_ERROR;
     } catch (const DBCrypto::Exception::InternalError &e) {
         LogError("DBCrypto failed with message: " << e.GetMessage());
-        retCode = KEY_MANAGER_API_ERROR_DB_ERROR;
+        retCode = CKM_API_ERROR_DB_ERROR;
     } catch (const DBCrypto::Exception::AliasExists &e) {
         LogError("DBCrypto couldn't save duplicate alias");
-        retCode = KEY_MANAGER_API_ERROR_DB_ALIAS_EXISTS;
+        retCode = CKM_API_ERROR_DB_ALIAS_EXISTS;
     } catch (const DBCrypto::Exception::TransactionError &e) {
         LogError("DBCrypto transaction failed with message " << e.GetMessage());
-        retCode = KEY_MANAGER_API_ERROR_DB_ERROR;
+        retCode = CKM_API_ERROR_DB_ERROR;
     }
 
     MessageBuffer response;
@@ -217,17 +217,17 @@ RawBuffer CKMLogic::removeData(
     DBDataType dataType,
     const Alias &alias)
 {
-    int retCode = KEY_MANAGER_API_SUCCESS;
+    int retCode = CKM_API_SUCCESS;
 
     if (0 < m_userDataMap.count(cred.uid)) {
         Try {
             m_userDataMap[cred.uid].database.deleteDBRow(alias, cred.smackLabel);
         } Catch (CKM::Exception) {
             LogError("Error in deleting row!");
-            retCode = KEY_MANAGER_API_ERROR_DB_ERROR;
+            retCode = CKM_API_ERROR_DB_ERROR;
         }
     } else {
-        retCode = KEY_MANAGER_API_ERROR_DB_LOCKED;
+        retCode = CKM_API_ERROR_DB_LOCKED;
     }
 
     MessageBuffer response;
@@ -248,7 +248,7 @@ int CKMLogic::getDataHelper(
 {
 
     if (0 == m_userDataMap.count(cred.uid))
-        return KEY_MANAGER_API_ERROR_DB_LOCKED;
+        return CKM_API_ERROR_DB_LOCKED;
 
     auto &handler = m_userDataMap[cred.uid];
 
@@ -261,11 +261,11 @@ int CKMLogic::getDataHelper(
         row_optional = handler.database.getKeyDBRow(alias, cred.smackLabel);
     } else {
         LogError("Unknown type of requested data" << (int)dataType);
-        return KEY_MANAGER_API_ERROR_BAD_REQUEST;
+        return CKM_API_ERROR_BAD_REQUEST;
     }
     if(!row_optional) {
         LogError("No row for given alias, label and type");
-        return KEY_MANAGER_API_ERROR_DB_ALIAS_UNKNOWN;
+        return CKM_API_ERROR_DB_ALIAS_UNKNOWN;
     } else {
         row = *row_optional;
     }
@@ -275,7 +275,7 @@ int CKMLogic::getDataHelper(
         auto key_optional = handler.database.getKey(row.smackLabel);
         if(!key_optional) {
             LogError("No key for given label in database");
-            return KEY_MANAGER_API_ERROR_DB_ERROR;
+            return CKM_API_ERROR_DB_ERROR;
         }
         key = *key_optional;
         key = handler.keyProvider.getPureDEK(key);
@@ -285,7 +285,7 @@ int CKMLogic::getDataHelper(
 
     LogError("Datatype: " << (int) row.dataType);
 
-    return KEY_MANAGER_API_SUCCESS;
+    return CKM_API_SUCCESS;
 }
 
 RawBuffer CKMLogic::getData(
@@ -295,23 +295,23 @@ RawBuffer CKMLogic::getData(
     const Alias &alias,
     const std::string &password)
 {
-    int retCode = KEY_MANAGER_API_SUCCESS;
+    int retCode = CKM_API_SUCCESS;
     DBRow row;
 
     try {
         retCode = getDataHelper(cred, dataType, alias, password, row);
     } catch (const KeyProvider::Exception::Base &e) {
         LogError("KeyProvider failed with error: " << e.GetMessage());
-        retCode = KEY_MANAGER_API_ERROR_SERVER_ERROR;
+        retCode = CKM_API_ERROR_SERVER_ERROR;
     } catch (const DBCryptoModule::Exception::Base &e) {
         LogError("DBCryptoModule failed with message: " << e.GetMessage());
-        retCode = KEY_MANAGER_API_ERROR_SERVER_ERROR;
+        retCode = CKM_API_ERROR_SERVER_ERROR;
     } catch (const DBCrypto::Exception::Base &e) {
         LogError("DBCrypto failed with message: " << e.GetMessage());
-        retCode = KEY_MANAGER_API_ERROR_DB_ERROR;
+        retCode = CKM_API_ERROR_DB_ERROR;
     }
 
-    if (KEY_MANAGER_API_SUCCESS != retCode) {
+    if (CKM_API_SUCCESS != retCode) {
         row.data.clear();
         row.dataType = dataType;
     }
@@ -332,7 +332,7 @@ RawBuffer CKMLogic::getDataList(
     int commandId,
     DBDataType dataType)
 {
-    int retCode = KEY_MANAGER_API_SUCCESS;
+    int retCode = CKM_API_SUCCESS;
     AliasVector aliasVector;
 
     if (0 < m_userDataMap.count(cred.uid)) {
@@ -345,10 +345,10 @@ RawBuffer CKMLogic::getDataList(
             }
         } Catch (CKM::Exception) {
             LogError("Failed to get aliases");
-            retCode = KEY_MANAGER_API_ERROR_DB_ERROR;
+            retCode = CKM_API_ERROR_DB_ERROR;
         }
     } else {
-        retCode = KEY_MANAGER_API_ERROR_DB_LOCKED;
+        retCode = CKM_API_ERROR_DB_LOCKED;
     }
 
     MessageBuffer response;
@@ -369,7 +369,7 @@ int CKMLogic::createKeyPairRSAHelper(
     const PolicySerializable &policyPublic)
 {
     if (0 >= m_userDataMap.count(cred.uid))
-        return KEY_MANAGER_API_ERROR_DB_LOCKED;
+        return CKM_API_ERROR_DB_LOCKED;
 
     auto &handler = m_userDataMap[cred.uid];
     GenericKey prv, pub;
@@ -379,7 +379,7 @@ int CKMLogic::createKeyPairRSAHelper(
         (retCode = CryptoService::createKeyPairRSA(size, prv, pub)))
     {
         LogDebug("CryptoService error with code: " << retCode);
-        return KEY_MANAGER_API_ERROR_SERVER_ERROR; // TODO error code
+        return CKM_API_ERROR_SERVER_ERROR; // TODO error code
     }
 
     DBCrypto::Transaction transaction(&handler.database);
@@ -389,7 +389,7 @@ int CKMLogic::createKeyPairRSAHelper(
                             prv.getDER(),
                             policyPrivate);
 
-    if (KEY_MANAGER_API_SUCCESS != retCode)
+    if (CKM_API_SUCCESS != retCode)
         return retCode;
 
     retCode = saveDataHelper(cred,
@@ -398,7 +398,7 @@ int CKMLogic::createKeyPairRSAHelper(
                             pub.getDER(),
                             policyPublic);
 
-    if (KEY_MANAGER_API_SUCCESS != retCode)
+    if (CKM_API_SUCCESS != retCode)
         return retCode;
 
     transaction.commit();
@@ -415,7 +415,7 @@ RawBuffer CKMLogic::createKeyPairRSA(
     const PolicySerializable &policyPrivate,
     const PolicySerializable &policyPublic)
 {
-    int retCode = KEY_MANAGER_API_SUCCESS;
+    int retCode = CKM_API_SUCCESS;
 
     try {
         retCode = createKeyPairRSAHelper(
@@ -434,7 +434,7 @@ RawBuffer CKMLogic::createKeyPairRSA(
         retCode = CKM_API_ERROR_DB_ERROR;
     } catch (DBCrypto::Exception::InternalError &e) {
         LogDebug("DBCrypto internal error: " << e.GetMessage());
-        retCode = KEY_MANAGER_API_ERROR_DB_ERROR;
+        retCode = CKM_API_ERROR_DB_ERROR;
     }
 
     MessageBuffer response;
@@ -454,7 +454,7 @@ int CKMLogic::createKeyPairECDSAHelper(
     const PolicySerializable &policyPublic)
 {
     if (0 >= m_userDataMap.count(cred.uid))
-        return KEY_MANAGER_API_ERROR_DB_LOCKED;
+        return CKM_API_ERROR_DB_LOCKED;
 
     auto &handler = m_userDataMap[cred.uid];
     GenericKey prv, pub;
@@ -464,7 +464,7 @@ int CKMLogic::createKeyPairECDSAHelper(
         (retCode = CryptoService::createKeyPairECDSA(static_cast<ElipticCurve>(type), prv, pub)))
     {
         LogError("CryptoService failed with code: " << retCode);
-        return KEY_MANAGER_API_ERROR_SERVER_ERROR; // TODO error code
+        return CKM_API_ERROR_SERVER_ERROR; // TODO error code
     }
 
     DBCrypto::Transaction transaction(&handler.database);
@@ -475,7 +475,7 @@ int CKMLogic::createKeyPairECDSAHelper(
                             prv.getDER(),
                             policyPrivate);
 
-    if (KEY_MANAGER_API_SUCCESS != retCode)
+    if (CKM_API_SUCCESS != retCode)
         return retCode;
 
     retCode = saveDataHelper(cred,
@@ -484,7 +484,7 @@ int CKMLogic::createKeyPairECDSAHelper(
                             pub.getDER(),
                             policyPublic);
 
-    if (KEY_MANAGER_API_SUCCESS != retCode)
+    if (CKM_API_SUCCESS != retCode)
         return retCode;
 
     transaction.commit();
@@ -501,7 +501,7 @@ RawBuffer CKMLogic::createKeyPairECDSA(
     const PolicySerializable &policyPrivate,
     const PolicySerializable &policyPublic)
 {
-    int retCode = KEY_MANAGER_API_SUCCESS;
+    int retCode = CKM_API_SUCCESS;
     
     try {
         retCode = createKeyPairECDSAHelper(
@@ -519,7 +519,7 @@ RawBuffer CKMLogic::createKeyPairECDSA(
         retCode = CKM_API_ERROR_DB_ERROR;
     } catch (const DBCrypto::Exception::InternalError &e) {
         LogDebug("DBCrypto internal error: " << e.GetMessage());
-        retCode = KEY_MANAGER_API_ERROR_DB_ERROR;
+        retCode = CKM_API_ERROR_DB_ERROR;
     }
 
     MessageBuffer response;