Organize the return code into hal_security_auth_error_e type.

Change-Id: I1b47ab5d6b5f8bed3cf4ff89251ed50cfba62f0b

diff --git a/haltest/security-auth.cpp b/haltest/security-auth.cpp
index 8f34f2efc95920a221e4c449485e1de9b04b2a20..5a176a792d5b95dd39bd168400dff8cfa7279422 100644 (file)
--- a/haltest/security-auth.cpp
+++ b/haltest/security-auth.cpp
@@ -21,7 +21,6 @@
 #include <tzplatform_config.h>
 
 #include "hal-security-auth.h"
-#include "hal-security-auth-error.h"
 
 const char *normal_password = "normal-password";
 const char *admin_password = "admin-password";
@@ -59,43 +58,43 @@ TEST_F(SECURITY_AUTH, WriteMemoryToFile)
     hal_security_auth_password_type_e password_type;
 
     ret = hal_security_auth_create_password_file(user_id, hal_security_auth_password_type_e::HAL_SECURITY_AUTH_PASSWORD_PIN);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to create password file for client (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to create password file for client (" << ret << ")";
 
     ret = hal_security_auth_write_memory_to_file(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to write memory to file (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to write memory to file (" << ret << ")";
 
     ret = hal_security_auth_write_memory_to_file(wrong_user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to write to memory to file  (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to write to memory to file  (" << ret << ")";
 
     ret = hal_security_auth_write_attempt_to_file(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to write attempt to file (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to write attempt to file (" << ret << ")";
 
     ret = hal_security_auth_write_attempt_to_file(wrong_user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to write attempt to file  (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to write attempt to file  (" << ret << ")";
 
     ret = hal_security_auth_get_password_type(user_id, &password_type);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to get password type (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to get password type (" << ret << ")";
     EXPECT_EQ(password_type, hal_security_auth_password_type_e::HAL_SECURITY_AUTH_PASSWORD_PIN) << "Failed : Wrong password type (" << password_type << ")";
 
     user_id = root_user;
 
     ret = hal_security_auth_create_password_file(user_id, hal_security_auth_password_type_e::HAL_SECURITY_AUTH_PASSWORD_PIN);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to create password file for client (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to create password file for client (" << ret << ")";
 
     ret = hal_security_auth_write_memory_to_file(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to write memory to file (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to write memory to file (" << ret << ")";
 
     ret = hal_security_auth_write_memory_to_file(wrong_user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to write to memory to file  (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to write to memory to file  (" << ret << ")";
 
     ret = hal_security_auth_write_attempt_to_file(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to write attempt to file (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to write attempt to file (" << ret << ")";
 
     ret = hal_security_auth_write_attempt_to_file(wrong_user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to write attempt to file  (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to write attempt to file  (" << ret << ")";
 
     ret = hal_security_auth_get_password_type(user_id, &password_type);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to get password type (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to get password type (" << ret << ")";
     EXPECT_EQ(password_type, HAL_SECURITY_AUTH_PASSWORD_PIN) << "Failed : Wrong password type (" << password_type << ")";
 }
 
@@ -106,36 +105,36 @@ TEST_F(SECURITY_AUTH, SetAndCheckPassword)
     uid_t user_id = tzplatform_getuid(TZ_SYS_DEFAULT_USER);
 
     ret = hal_security_auth_create_password_file(user_id, hal_security_auth_password_type_e::HAL_SECURITY_AUTH_PASSWORD_NORMAL);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to create password file for client (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to create password file for client (" << ret << ")";
 
     ret = hal_security_auth_set_password(user_id, normal_password);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to set password (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to set password (" << ret << ")";
 
     ret = hal_security_auth_set_password(wrong_user_id, normal_password);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to set password (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to set password (" << ret << ")";
 
     ret = hal_security_auth_check_password(user_id, normal_password);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to check password (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to check password (" << ret << ")";
 
     ret = hal_security_auth_check_password(user_id, wrong_password);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_PASSWORD_MISMATCH) << "Wrong password to check password (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_PASSWORD_MISMATCH) << "Wrong password to check password (" << ret << ")";
 
     user_id = root_user;
 
     ret = hal_security_auth_create_password_file(user_id, hal_security_auth_password_type_e::HAL_SECURITY_AUTH_PASSWORD_NORMAL);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to create password file for client (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to create password file for client (" << ret << ")";
 
     ret = hal_security_auth_set_password(user_id, normal_password);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to set password (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to set password (" << ret << ")";
 
     ret = hal_security_auth_set_password(wrong_user_id, normal_password);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to set password (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to set password (" << ret << ")";
 
     ret = hal_security_auth_check_password(user_id, normal_password);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to check password (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to check password (" << ret << ")";
 
     ret = hal_security_auth_check_password(user_id, wrong_password);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_PASSWORD_MISMATCH) << "Wrong password to check password (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_PASSWORD_MISMATCH) << "Wrong password to check password (" << ret << ")";
 }
 
 TEST_F(SECURITY_AUTH, HistoryParams)
@@ -145,38 +144,38 @@ TEST_F(SECURITY_AUTH, HistoryParams)
     uid_t user_id = tzplatform_getuid(TZ_SYS_DEFAULT_USER);
 
     ret = hal_security_auth_create_password_file(user_id, hal_security_auth_password_type_e::HAL_SECURITY_AUTH_PASSWORD_PIN);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to create password file for client (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to create password file for client (" << ret << ")";
 
     ret = hal_security_auth_set_max_history_size(user_id, max_history_size);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to set max history size (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to set max history size (" << ret << ")";
 
     ret = hal_security_auth_set_max_history_size(wrong_user_id, max_history_size);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to set max history size (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to set max history size (" << ret << ")";
 
     ret = hal_security_auth_get_max_history_size(user_id, &history_size);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to get max history size (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to get max history size (" << ret << ")";
     EXPECT_EQ(history_size, max_history_size) << "Failed : Wrong max history size (" << history_size << ")";
 
     ret = hal_security_auth_get_max_history_size(wrong_user_id, &history_size);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to get max history size (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to get max history size (" << ret << ")";
 
     user_id = root_user;
 
     ret = hal_security_auth_create_password_file(user_id, hal_security_auth_password_type_e::HAL_SECURITY_AUTH_PASSWORD_PIN);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to create password file for client (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to create password file for client (" << ret << ")";
 
     ret = hal_security_auth_set_max_history_size(user_id, max_history_size);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to set max history size (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to set max history size (" << ret << ")";
 
     ret = hal_security_auth_set_max_history_size(wrong_user_id, max_history_size);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to set max history size (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to set max history size (" << ret << ")";
 
     ret = hal_security_auth_get_max_history_size(user_id, &history_size);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to get max history size (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to get max history size (" << ret << ")";
     EXPECT_EQ(history_size, max_history_size) << "Failed : Wrong max history size (" << history_size << ")";
 
     ret = hal_security_auth_get_max_history_size(wrong_user_id, &history_size);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to get max history size (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to get max history size (" << ret << ")";
 }
 
 TEST_F(SECURITY_AUTH, ExpireParams)
@@ -186,38 +185,38 @@ TEST_F(SECURITY_AUTH, ExpireParams)
     uid_t user_id = tzplatform_getuid(TZ_SYS_DEFAULT_USER);
 
     ret = hal_security_auth_create_password_file(user_id, hal_security_auth_password_type_e::HAL_SECURITY_AUTH_PASSWORD_PATTERN);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to create password file for client (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to create password file for client (" << ret << ")";
 
     ret = hal_security_auth_set_expire_time(user_id, expire_time_days);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to set expire time (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to set expire time (" << ret << ")";
 
     ret = hal_security_auth_set_expire_time(wrong_user_id, expire_time_days);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to set expire time (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to set expire time (" << ret << ")";
 
     ret = hal_security_auth_get_expire_time(user_id, &expire_time);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to get expire time (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to get expire time (" << ret << ")";
     EXPECT_EQ(expire_time, expire_time_days) << "Wrong expire time (" << expire_time << ")";
 
     ret = hal_security_auth_get_expire_time(wrong_user_id, &expire_time);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to get expire time (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to get expire time (" << ret << ")";
 
     user_id = root_user;
 
     ret = hal_security_auth_create_password_file(user_id, hal_security_auth_password_type_e::HAL_SECURITY_AUTH_PASSWORD_PATTERN);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to create password file for client (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to create password file for client (" << ret << ")";
 
     ret = hal_security_auth_set_expire_time(user_id, expire_time_days);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to set expire time (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to set expire time (" << ret << ")";
 
     ret = hal_security_auth_set_expire_time(wrong_user_id, expire_time_days);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to set expire time (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to set expire time (" << ret << ")";
 
     ret = hal_security_auth_get_expire_time(user_id, &expire_time);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to get expire time (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to get expire time (" << ret << ")";
     EXPECT_EQ(expire_time, expire_time_days) << "Wrong expire time (" << expire_time << ")";
 
     ret = hal_security_auth_get_expire_time(wrong_user_id, &expire_time);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to get expire time (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to get expire time (" << ret << ")";
 }
 
 TEST_F(SECURITY_AUTH, AttemptParams)
@@ -228,76 +227,76 @@ TEST_F(SECURITY_AUTH, AttemptParams)
     uid_t user_id = tzplatform_getuid(TZ_SYS_DEFAULT_USER);
 
     ret = hal_security_auth_create_password_file(user_id, hal_security_auth_password_type_e::HAL_SECURITY_AUTH_PASSWORD_NORMAL);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to create password file for client (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to create password file for client (" << ret << ")";
 
     ret = hal_security_auth_reset_attempt(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to reset attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to reset attempt (" << ret << ")";
 
     ret = hal_security_auth_reset_attempt(wrong_user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to reset attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to reset attempt (" << ret << ")";
 
     ret = hal_security_auth_increment_attempt(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to increment attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to increment attempt (" << ret << ")";
 
     ret = hal_security_auth_increment_attempt(wrong_user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to increment attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to increment attempt (" << ret << ")";
 
     ret = hal_security_auth_get_attempt(user_id, &attempt);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to get attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to get attempt (" << ret << ")";
     EXPECT_EQ(attempt, increment_unit) << "Wrong attempt (" << attempt << ")";
 
     ret = hal_security_auth_get_attempt(wrong_user_id, &attempt);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to get attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to get attempt (" << ret << ")";
 
     ret = hal_security_auth_set_max_attempt(user_id, max_attempt_size);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to set max attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to set max attempt (" << ret << ")";
 
     ret = hal_security_auth_set_max_attempt(wrong_user_id, max_attempt_size);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to set max attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to set max attempt (" << ret << ")";
 
     ret = hal_security_auth_get_max_attempt(user_id, &max_attempt);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to get max attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to get max attempt (" << ret << ")";
     EXPECT_EQ(max_attempt, max_attempt_size) << "Wrong max attempt (" << max_attempt << ")";
 
     ret = hal_security_auth_get_max_attempt(wrong_user_id, &max_attempt);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to get max attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to get max attempt (" << ret << ")";
 
     user_id = root_user;
 
     ret = hal_security_auth_create_password_file(user_id, hal_security_auth_password_type_e::HAL_SECURITY_AUTH_PASSWORD_NORMAL);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to create password file for client (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to create password file for client (" << ret << ")";
 
     ret = hal_security_auth_reset_attempt(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to reset attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to reset attempt (" << ret << ")";
 
     ret = hal_security_auth_reset_attempt(wrong_user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to reset attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to reset attempt (" << ret << ")";
 
     ret = hal_security_auth_increment_attempt(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to increment attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to increment attempt (" << ret << ")";
 
     ret = hal_security_auth_increment_attempt(wrong_user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to increment attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to increment attempt (" << ret << ")";
 
     ret = hal_security_auth_get_attempt(user_id, &attempt);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to get attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to get attempt (" << ret << ")";
     EXPECT_EQ(attempt, increment_unit) << "Wrong attempt (" << attempt << ")";
 
     ret = hal_security_auth_get_attempt(wrong_user_id, &attempt);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to get attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to get attempt (" << ret << ")";
 
     ret = hal_security_auth_set_max_attempt(user_id, max_attempt_size);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to set max attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to set max attempt (" << ret << ")";
 
     ret = hal_security_auth_set_max_attempt(wrong_user_id, max_attempt_size);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to set max attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to set max attempt (" << ret << ")";
 
     ret = hal_security_auth_get_max_attempt(user_id, &max_attempt);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to get max attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to get max attempt (" << ret << ")";
     EXPECT_EQ(max_attempt, max_attempt_size) << "Wrong max attempt (" << max_attempt << ")";
 
     ret = hal_security_auth_get_max_attempt(wrong_user_id, &max_attempt);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id to get max attempt (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id to get max attempt (" << ret << ")";
 }
 
 TEST_F(SECURITY_AUTH, StatusParams)
@@ -306,66 +305,66 @@ TEST_F(SECURITY_AUTH, StatusParams)
     uid_t user_id = tzplatform_getuid(TZ_SYS_DEFAULT_USER);
 
     ret = hal_security_auth_create_password_file(user_id, hal_security_auth_password_type_e::HAL_SECURITY_AUTH_PASSWORD_PIN);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to create password file for client (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to create password file for client (" << ret << ")";
 
     ret = hal_security_auth_set_max_history_size(user_id, max_history_size);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to set max history size (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to set max history size (" << ret << ")";
 
     ret = hal_security_auth_set_password(user_id, normal_password);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to set password (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to set password (" << ret << ")";
 
     ret = hal_security_auth_is_password_active(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Wrong password active status (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Wrong password active status (" << ret << ")";
 
     ret = hal_security_auth_is_history_active(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Wrong history active status (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Wrong history active status (" << ret << ")";
 
     ret = hal_security_auth_is_history_active(wrong_user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id for history active status (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id for history active status (" << ret << ")";
 
     ret = hal_security_auth_is_password_reused(user_id, reused_normal);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Wrong to check password reused status for a previously-used one (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Wrong to check password reused status for a previously-used one (" << ret << ")";
 
     ret = hal_security_auth_is_password_reused(user_id, new_password);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_STATUS) << "Wrong password reused status for a new one (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_STATUS) << "Wrong password reused status for a new one (" << ret << ")";
 
     ret = hal_security_auth_set_password(user_id,"");//null password is for inactive password status
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to set password (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to set password (" << ret << ")";
 
     ret = hal_security_auth_is_password_active(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_STATUS) << "Wrong status for active password (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_STATUS) << "Wrong status for active password (" << ret << ")";
 
     user_id = root_user;
 
     ret = hal_security_auth_create_password_file(user_id, hal_security_auth_password_type_e::HAL_SECURITY_AUTH_PASSWORD_PIN);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to create password file for client (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to create password file for client (" << ret << ")";
 
     ret = hal_security_auth_set_max_history_size(user_id, max_history_size);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to set max history size (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to set max history size (" << ret << ")";
 
     ret = hal_security_auth_set_password(user_id, normal_password);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to set password (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to set password (" << ret << ")";
 
     ret = hal_security_auth_is_password_active(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Wrong password active status (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Wrong password active status (" << ret << ")";
 
     ret = hal_security_auth_is_history_active(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Wrong history active status (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Wrong history active status (" << ret << ")";
 
     ret = hal_security_auth_is_history_active(wrong_user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_INPUT_PARAM) << "Wrong user id for history active status (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_INPUT_PARAM) << "Wrong user id for history active status (" << ret << ")";
 
     ret = hal_security_auth_is_password_reused(user_id, reused_normal);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Wrong to check password reused status for a previously-used one (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Wrong to check password reused status for a previously-used one (" << ret << ")";
 
     ret = hal_security_auth_is_password_reused(user_id, new_password);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_STATUS) << "Wrong password reused status for a new one (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_STATUS) << "Wrong password reused status for a new one (" << ret << ")";
 
     ret = hal_security_auth_set_password(user_id,"");//null password is for inactive password status
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to set password (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to set password (" << ret << ")";
 
     ret = hal_security_auth_is_password_active(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_STATUS) << "Wrong status for active password (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_STATUS) << "Wrong status for active password (" << ret << ")";
 }
 
 TEST_F(SECURITY_AUTH, LimitationParams)
@@ -378,66 +377,66 @@ TEST_F(SECURITY_AUTH, LimitationParams)
     hal_security_auth_password_type_e password_type;
 
     ret = hal_security_auth_create_password_file(user_id, hal_security_auth_password_type_e::HAL_SECURITY_AUTH_PASSWORD_PATTERN);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to create password file for client (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to create password file for client (" << ret << ")";
 
     time_t curTime = time(NULL);
        unsigned int validSecs = (curTime + (expire_time_left_days * 86400));
 
     ret = hal_security_auth_set_expire_time_left(user_id,validSecs);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed : set expire_time_left (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed : set expire_time_left (" << ret << ")";
 
     unsigned int validLeftSecs = validSecs;
     ret = hal_security_auth_get_expire_time_left(user_id,&expire_time_left_secs);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed : get expire_time_left (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed : get expire_time_left (" << ret << ")";
     EXPECT_EQ((validLeftSecs <= (expire_time_left_secs+curTime)) && (validLeftSecs <= (expire_time_left_secs+curTime+1)),true) << "Failed : get expire time left (" << expire_time_left_secs << "),"
                                                                                                             << "(" << validLeftSecs << ")";
 
     ret = hal_security_auth_check_expiration(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed : check expiration status (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed : check expiration status (" << ret << ")";
 
     ret = hal_security_auth_check_attempt_exceeded(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed : check to attempt exceeded status (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed : check to attempt exceeded status (" << ret << ")";
     sleep(1);
     ret = hal_security_auth_is_ignore_period(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_PASSWORD_RETRY_TIMER) << "Failed : ignore period status (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_PASSWORD_RETRY_TIMER) << "Failed : ignore period status (" << ret << ")";
 
     ret = hal_security_auth_get_password_type(user_id, &password_type);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to get password type (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to get password type (" << ret << ")";
     EXPECT_EQ(password_type, HAL_SECURITY_AUTH_PASSWORD_PATTERN) << "Failed : Wrong password type (" << password_type << ")";
 
     ret = hal_security_auth_set_max_history_size(user_id, 0);//0 is for inactive history
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to set max history size (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to set max history size (" << ret << ")";
 
     user_id = root_user;
 
     ret = hal_security_auth_create_password_file(user_id, hal_security_auth_password_type_e::HAL_SECURITY_AUTH_PASSWORD_PATTERN);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to create password file for client (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to create password file for client (" << ret << ")";
 
     curTime = time(NULL);
        validSecs = (curTime + (expire_time_left_days * 86400));
 
     ret = hal_security_auth_set_expire_time_left(user_id,validSecs);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed : set expire_time_left (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed : set expire_time_left (" << ret << ")";
 
     validLeftSecs = validSecs;
     ret = hal_security_auth_get_expire_time_left(user_id,&expire_time_left_secs);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed : get expire_time_left (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed : get expire_time_left (" << ret << ")";
     EXPECT_EQ((validLeftSecs <= (expire_time_left_secs+curTime)) && (validLeftSecs <= (expire_time_left_secs+curTime+1)),true) << "Failed : get expire time left (" << expire_time_left_secs << "),"
                                                                                                         << "(" << validLeftSecs << ")";
 
     ret = hal_security_auth_check_expiration(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed : check expiration status (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed : check expiration status (" << ret << ")";
 
     ret = hal_security_auth_check_attempt_exceeded(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed : check to attempt exceeded status (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed : check to attempt exceeded status (" << ret << ")";
     sleep(1);
     ret = hal_security_auth_is_ignore_period(user_id);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_ERROR_PASSWORD_RETRY_TIMER) << "Failed : ignore period status (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_PASSWORD_RETRY_TIMER) << "Failed : ignore period status (" << ret << ")";
 
     ret = hal_security_auth_get_password_type(user_id, &password_type);
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to get password type (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to get password type (" << ret << ")";
     EXPECT_EQ(password_type, HAL_SECURITY_AUTH_PASSWORD_PATTERN) << "Failed : Wrong password type (" << password_type << ")";
 
     ret = hal_security_auth_set_max_history_size(user_id, 0);//0 is for inactive history
-    EXPECT_EQ(ret, AUTH_PASSWD_API_SUCCESS) << "Failed to set max history size (" << ret << ")";
+    EXPECT_EQ(ret, HAL_SECURITY_AUTH_ERROR_NONE) << "Failed to set max history size (" << ret << ")";
 }
\ No newline at end of file

diff --git a/include/hal-security-auth-error.h b/include/hal-security-auth-error.h
deleted file mode 100644 (file)
index f32e711..0000000
--- a/include/hal-security-auth-error.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- *  Authentication password
- *
- *  Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd All Rights Reserved
- *
- *  Contact: Jooseong Lee <jooseong.lee@samsung.com>
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License
- *
- */
-
-#ifndef AUTH_PASSWD_ERROR_H
-#define AUTH_PASSWD_ERROR_H
-
-/**
- * \name Return Codes
- * exported by the foundation API.
- * result codes begin with the start error code and extend into negative direction.
- * @{
-*/
-#define AUTH_PASSWD_API_SUCCESS 0
-
-/*! \brief   indicating the result of the one specific API is successful */
-#define AUTH_PASSWD_API_ERROR_SOCKET -1
-
-/*! \brief   indicating the API's input parameter is malformed */
-#define AUTH_PASSWD_API_ERROR_INPUT_PARAM -2
-
-/*! \brief   indicating system  is running out of memory state */
-#define AUTH_PASSWD_API_ERROR_OUT_OF_MEMORY -3
-
-/*! \brief   indicating the output buffer size which is passed as parameter is too small */
-#define AUTH_PASSWD_API_ERROR_BUFFER_TOO_SMALL -4
-
-/*! \brief   indicating Authenticaton Server has been failed for some reason */
-#define AUTH_PASSWD_API_ERROR_SERVER_ERROR -5
-
-/*! \brief   indicating the access has been denied by Authetnication Server */
-#define AUTH_PASSWD_API_ERROR_ACCESS_DENIED -6
-
-/*! \brief   indicating there is no user */
-#define AUTH_PASSWD_API_ERROR_NO_USER -8
-
-/*! \brief   indicating there is no password set */
-#define AUTH_PASSWD_API_ERROR_NO_PASSWORD -9
-
-/*! \brief   indicating password exists in system */
-#define AUTH_PASSWD_API_ERROR_PASSWORD_EXIST -11
-
-/*! \brief   indicating password mismatch */
-#define AUTH_PASSWD_API_ERROR_PASSWORD_MISMATCH -12
-
-/*! \brief   indicating password retry timeout has not yet occurred */
-#define AUTH_PASSWD_API_ERROR_PASSWORD_RETRY_TIMER -13
-
-/*! \brief   indicating no more attempts are possible */
-#define AUTH_PASSWD_API_ERROR_PASSWORD_MAX_ATTEMPTS_EXCEEDED -14
-
-/*! \brief   indicating password is expired */
-#define AUTH_PASSWD_API_ERROR_PASSWORD_EXPIRED -15
-
-/*! \brief   indicating password is reused */
-#define AUTH_PASSWD_API_ERROR_PASSWORD_REUSED -16
-
-/*! \brief   indicating password does not meet password min length policy */
-#define AUTH_PASSWD_API_ERROR_INVALID_MIN_LENGTH -18
-
-/*! \brief   indicating password does not meet min complex character number policy */
-#define AUTH_PASSWD_API_ERROR_INVALID_MIN_COMPLEX_CHAR_NUM -19
-
-/*! \brief   indicating password does not meet max character occurences policy */
-#define AUTH_PASSWD_API_ERROR_INVALID_MAX_CHAR_OCCURENCES -20
-
-/*! \brief   indicating password does not meet max number sequence length policy */
-#define AUTH_PASSWD_API_ERROR_INVALID_MAX_NUM_SEQ_LENGTH -21
-
-/*! \brief   indicating password does not meet forbidden passwords policy */
-#define AUTH_PASSWD_API_ERROR_INVALID_FORBIDDEN_PASSWORDS -22
-
-/*! \brief   indicating password does not meet quality type policy */
-#define AUTH_PASSWD_API_ERROR_INVALID_QUALITY_TYPE -23
-
-/*! \brief   indicating password does not meet pattern policy */
-#define AUTH_PASSWD_API_ERROR_INVALID_PATTERN -24
-
-/*! \brief   indicating status does not meet the required condition or threshold */
-#define AUTH_PASSWD_API_ERROR_STATUS -25
-
-/*! \brief   indicating the error with unknown reason */
-#define AUTH_PASSWD_API_ERROR_UNKNOWN -255
-/** @}*/
-
-#endif

diff --git a/include/hal-security-auth-types.h b/include/hal-security-auth-types.h
index fe9b7fd1e63ca6f6b74c5daf90b26c377eb1af52..9eebd1b57011c482aaa0d9b99863f10421e47221 100644 (file)
--- a/include/hal-security-auth-types.h
+++ b/include/hal-security-auth-types.h
@@ -36,6 +36,28 @@ typedef enum {
     HAL_SECURITY_AUTH_PASSWORD_PATTERN = 2,         /**< Numeric character string for pattern match */
 } hal_security_auth_password_type_e;
 
+/**
+ * @brief Return Codes exported by the hal-security-auth functions.
+ * @since HAL_MODULE_SECURITY_AUTH 1.0
+ */
+typedef enum {
+    HAL_SECURITY_AUTH_ERROR_NONE = 0, /**< Indicate the result of the one specific API is successful*/
+    HAL_SECURITY_AUTH_ERROR_INPUT_PARAM = -2, /**< Indicate the API's input parameter is malformed*/
+    HAL_SECURITY_AUTH_ERROR_OUT_OF_MEMORY = -3, /**< Indicate system is running out of memory state*/
+    HAL_SECURITY_AUTH_ERROR_BUFFER_TOO_SMALL = -4, /**< Indicate the output buffer size which is passed as parameter is too small*/
+    HAL_SECURITY_AUTH_ERROR_NO_USER = -8, /**< Indicate there is no user*/
+    HAL_SECURITY_AUTH_ERROR_NO_PASSWORD = -9, /**< Indicate there is no password set*/
+    HAL_SECURITY_AUTH_ERROR_PASSWORD_EXIST = -11, /**< Indicate password exists in system*/
+    HAL_SECURITY_AUTH_ERROR_PASSWORD_MISMATCH = -12, /**< Indicate password mismatch*/
+    HAL_SECURITY_AUTH_ERROR_PASSWORD_RETRY_TIMER = -13, /**< Indicate password retry timeout has not yet occurred*/
+    HAL_SECURITY_AUTH_ERROR_PASSWORD_MAX_ATTEMPTS_EXCEEDED = -14, /**< Indicate no more attempts are possible*/
+    HAL_SECURITY_AUTH_ERROR_PASSWORD_EXPIRED = -15, /**< Indicate password is expired*/
+    HAL_SECURITY_AUTH_ERROR_PASSWORD_REUSED = -16, /**< Indicate password is reused*/
+    HAL_SECURITY_AUTH_ERROR_STATUS = -25, /**< Indicate status does not meet the required condition or threshold*/
+    HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL = -26, /**< Indicate there is a failure during HAL initialization*/
+    HAL_SECURITY_AUTH_ERROR_UNKNOWN = -255, /**< Indicate the error with unknown reason*/
+} hal_security_auth_error_e;
+
 /**
  * @}
  */

diff --git a/src/hal-api-security-auth.c b/src/hal-api-security-auth.c
index ed1da3472656be9d723fdfd4a0f7c116aaac252c..dcdf6f9c8fd97dbf801caa80cf4a49275c574d8b 100644 (file)
--- a/src/hal-api-security-auth.c
+++ b/src/hal-api-security-auth.c
@@ -37,14 +37,14 @@ EXPORT int hal_security_auth_get_backend(void)
         return 0;
     g_security_auth_funcs = calloc(1, sizeof(hal_backend_security_auth_funcs));
     if (!g_security_auth_funcs)
-        return -ENOMEM;
+        return HAL_SECURITY_AUTH_ERROR_OUT_OF_MEMORY;
 
     ret = hal_common_get_backend(HAL_MODULE_SECURITY_AUTH, (void **)&g_security_auth_funcs);
 
     if (ret < 0) {
         free(g_security_auth_funcs);
         g_security_auth_funcs = NULL;
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     }
 
     return 0;
@@ -53,7 +53,7 @@ EXPORT int hal_security_auth_get_backend(void)
 EXPORT int hal_security_auth_put_backend(void)
 {
     if (!g_security_auth_funcs)
-        return -EINVAL;
+        return HAL_SECURITY_AUTH_ERROR_INPUT_PARAM;
 
     hal_common_put_backend(HAL_MODULE_SECURITY_AUTH, (void *)g_security_auth_funcs);
 
@@ -66,160 +66,160 @@ EXPORT int hal_security_auth_put_backend(void)
 EXPORT int hal_security_auth_create_password_file(uid_t user_id, hal_security_auth_password_type_e password_type)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->create_password_file(user_id, password_type);
 }
 
 EXPORT int hal_security_auth_write_memory_to_file(uid_t user_id)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->write_memory_to_file(user_id);
 }
 
 EXPORT int hal_security_auth_write_attempt_to_file(uid_t user_id)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->write_attempt_to_file(user_id);
 }
 
 EXPORT int hal_security_auth_set_password(uid_t user_id, const char* password)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->set_password(user_id, password);
 }
 
 EXPORT int hal_security_auth_check_password(uid_t user_id, const char* password)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->check_password(user_id, password);
 }
 
 EXPORT int hal_security_auth_set_max_history_size(uid_t user_id, unsigned int history_size)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->set_max_history_size(user_id, history_size);
 }
 
 EXPORT int hal_security_auth_get_max_history_size(uid_t user_id, unsigned int *history_size)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->get_max_history_size(user_id, history_size);
 }
 
 EXPORT int hal_security_auth_get_expire_time(uid_t user_id, unsigned int *expire_time)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->get_expire_time(user_id, expire_time);
 }
 
 EXPORT int hal_security_auth_set_expire_time(uid_t user_id, unsigned int expire_time)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->set_expire_time(user_id, expire_time);
 }
 
 EXPORT int hal_security_auth_get_expire_time_left(uid_t user_id, unsigned int *expire_time_left)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->get_expire_time_left(user_id, expire_time_left);
 }
 
 EXPORT int hal_security_auth_set_expire_time_left(uid_t user_id, unsigned int expire_time_left)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->set_expire_time_left(user_id, expire_time_left);
 }
 
 EXPORT int hal_security_auth_get_attempt(uid_t user_id, unsigned int *attempt)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->get_attempt(user_id, attempt);
 }
 
 EXPORT int hal_security_auth_reset_attempt(uid_t user_id)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->reset_attempt(user_id);
 }
 
 EXPORT int hal_security_auth_increment_attempt(uid_t user_id)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->increment_attempt(user_id);
 }
 
 EXPORT int hal_security_auth_get_max_attempt(uid_t user_id, unsigned int *max_attempt)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->get_max_attempt(user_id, max_attempt);
 }
 
 EXPORT int hal_security_auth_set_max_attempt(uid_t user_id, unsigned int max_attempt)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->set_max_attempt(user_id, max_attempt);
 }
 
 EXPORT int hal_security_auth_is_password_active(uid_t user_id)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->is_password_active(user_id);
 }
 
 EXPORT int hal_security_auth_is_password_reused(uid_t user_id, const char* password)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->is_password_reused(user_id, password);
 }
 
 EXPORT int hal_security_auth_check_expiration(uid_t user_id)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->check_expiration(user_id);
 }
 
 EXPORT int hal_security_auth_check_attempt_exceeded(uid_t user_id)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->check_attempt_exceeded(user_id);
 }
 
 EXPORT int hal_security_auth_is_ignore_period(uid_t user_id)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->is_ignore_period(user_id);
 }
 
 EXPORT int hal_security_auth_is_history_active(uid_t user_id)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->is_history_active(user_id);
 }
 
 EXPORT int hal_security_auth_get_password_type(uid_t user_id, hal_security_auth_password_type_e *password_type)
 {
     if (!g_security_auth_funcs)
-        return -ENOTSUP;
+        return HAL_SECURITY_AUTH_ERROR_HAL_INIT_FAIL;
     return g_security_auth_funcs->get_password_type(user_id, password_type);
 }
\ No newline at end of file