Fix to print proper error message from the sqlite database handle in error case

Change-Id: Ic08a3e880931dba225decbd757b456a303b2bb76
Signed-off-by: Abhay Agarwal <ay.agarwal@samsung.com>

diff --git a/ua-daemon/src/ua-manager-adv-db.c b/ua-daemon/src/ua-manager-adv-db.c
index 17d99f9..d9272a8 100644 (file)
--- a/ua-daemon/src/ua-manager-adv-db.c
+++ b/ua-daemon/src/ua-manager-adv-db.c
@@ -169,12 +169,12 @@ int _uam_db_get_max_ibeacon_id(void)
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = select_max_ibeacon_id;
-       int rc;
+       int sql_ret = SQLITE_OK;
 
        do {
-               rc = sqlite3_step(stmt);
+               sql_ret = sqlite3_step(stmt);
 
-               switch (rc) {
+               switch (sql_ret) {
                case SQLITE_DONE:
                        break;
                case SQLITE_ROW:
@@ -183,9 +183,10 @@ int _uam_db_get_max_ibeacon_id(void)
                        break;
                case SQLITE_ERROR:
                default:
-                       UAM_ERR("Failed to select max ibeacon adv");
+                       UAM_ERR("Failed to select max ibeacon adv [%d:%s]",
+                               sql_ret, sqlite3_errmsg(database));
                }
-       } while (rc == SQLITE_ROW);
+       } while (sql_ret == SQLITE_ROW);
 
        sqlite3_reset(stmt);
        FUNC_EXIT;
@@ -227,6 +228,7 @@ int _uam_db_insert_adv_info(unsigned int adv_len, const char *iadv)
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = insert_ibeacon_adv;
+       int sql_ret = SQLITE_OK;
 
        retv_if(NULL == iadv, UAM_ERROR_INVALID_PARAMETER);
 
@@ -239,8 +241,10 @@ int _uam_db_insert_adv_info(unsigned int adv_len, const char *iadv)
        DB_ACTION(sqlite3_bind_int(stmt, 3, adv_len),
                error_code, handle_error);
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to insert ibeacon adv info");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to insert ibeacon adv info [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
                error_code = UAM_ERROR_DB_FAILED;
                goto handle_error;
        }
@@ -257,15 +261,15 @@ handle_error:
 GSList *_uam_db_get_all_advs(void)
 {
        FUNC_ENTRY;
-       int rc;
        sqlite3_stmt *stmt = select_all_advs;
        GSList *adv_list = NULL;
        db_adv_info_t *info = NULL;
+       int sql_ret = SQLITE_OK;
 
        do {
-               rc = sqlite3_step(stmt);
+               sql_ret = sqlite3_step(stmt);
 
-               switch (rc) {
+               switch (sql_ret) {
                case SQLITE_DONE:
                        break;
                case SQLITE_ROW:
@@ -282,9 +286,10 @@ GSList *_uam_db_get_all_advs(void)
                        break;
                case SQLITE_ERROR:
                default:
-                       UAM_ERR("Failed to enumerate ibeacon adv info ");
+                       UAM_ERR("Failed to enumerate ibeacon adv info [%d:%s]",
+                               sql_ret, sqlite3_errmsg(database));
                }
-       } while (rc == SQLITE_ROW);
+       } while (sql_ret == SQLITE_ROW);
 
        sqlite3_reset(stmt);
        FUNC_EXIT;
@@ -295,9 +300,12 @@ int _uam_adv_db_clear(void)
 {
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = delete_all_adv_data;
+       int sql_ret = SQLITE_OK;
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to delete adv data ");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to delete adv data [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
                error_code = UAM_ERROR_DB_FAILED;
                goto handle_error;
        }

diff --git a/ua-daemon/src/ua-manager-db.c b/ua-daemon/src/ua-manager-db.c
index 0df6757..b4c1ab5 100644 (file)
--- a/ua-daemon/src/ua-manager-db.c
+++ b/ua-daemon/src/ua-manager-db.c
@@ -156,24 +156,24 @@ static int __uam_db_get_version(unsigned int *ver)
 {
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
-       int rc;
+       int sql_ret;
        char *sql = NULL;
        sql = sqlite3_mprintf("PRAGMA user_version");
        sqlite3_stmt *stmt = select_version;
 
-       rc = sqlite3_prepare_v2(database, sql, -1, &stmt, NULL);
-       if (rc != SQLITE_OK) {
+       sql_ret = sqlite3_prepare_v2(database, sql, -1, &stmt, NULL);
+       if (sql_ret != SQLITE_OK) {
                stmt = NULL;
                FINALIZE(select_version);
                UAM_ERR("Failed to prepare \"%s\" query", sql);
                sqlite3_free(sql);
-               return rc;
+               return sql_ret;
        }
 
        do {
-               rc = sqlite3_step(stmt);
+               sql_ret = sqlite3_step(stmt);
 
-               switch (rc) {
+               switch (sql_ret) {
                case SQLITE_DONE:
                        break;
                case SQLITE_ROW:
@@ -182,9 +182,10 @@ static int __uam_db_get_version(unsigned int *ver)
                        break;
                case SQLITE_ERROR:
                default:
-                       UAM_ERR("Failed to select database version info");
+                       UAM_ERR("Failed to select database version info [%d:%s]",
+                               sql_ret, sqlite3_errmsg(database));
                }
-       } while (rc == SQLITE_ROW);
+       } while (sql_ret == SQLITE_ROW);
 
        FINALIZE(select_version);
        sqlite3_reset(stmt);
@@ -271,10 +272,10 @@ int _uam_db_check_version(void)
 
 static bool __uam_db_is_table_existing(const char *table)
 {
-       int ret;
        char *sql;
        int count;
        bool result = false;
+       int sql_ret = SQLITE_OK;
 
        sql = sqlite3_mprintf(
                "SELECT count(*) FROM sqlite_master WHERE type='table' AND name ='%s';", table);
@@ -284,16 +285,16 @@ static bool __uam_db_is_table_existing(const char *table)
        }
        sqlite3_stmt *stmt = NULL;
 
-       ret = sqlite3_prepare_v2(database, sql, strlen(sql), &stmt, NULL);
-       if (SQLITE_OK != ret) {
-               UAM_ERR("sqlite3_prepare_v2 failed, [%d:%s]", ret, sqlite3_errmsg(database));
+       sql_ret = sqlite3_prepare_v2(database, sql, strlen(sql), &stmt, NULL);
+       if (SQLITE_OK != sql_ret) {
+               UAM_ERR("sqlite3_prepare_v2 failed, [%d:%s]", sql_ret, sqlite3_errmsg(database));
                result = false;
                goto is_table_existing_done;
        }
 
-       ret = sqlite3_step(stmt);
-       if (SQLITE_ROW != ret) {
-               UAM_ERR("sqlite3_step failed, [%d:%s]", ret, sqlite3_errmsg(database));
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_ROW) {
+               UAM_ERR("sqlite3_step failed, [%d:%s]", sql_ret, sqlite3_errmsg(database));
                result = false;
                goto is_table_existing_done;
        }
@@ -369,7 +370,7 @@ static int __uam_db_create_table(const char *table_name)
        if (UAM_ERROR_NONE != ret)
                UAM_ERR("Faild to __uam_db_exec_sql()");
        else
-               UAM_DBG("Successfully verified database integrity");
+               UAM_DBG("Successfully created table %s", table_name);
 
        sqlite3_free(sql);
 

diff --git a/ua-daemon/src/ua-manager-device-db.c b/ua-daemon/src/ua-manager-device-db.c
index 70531b7..d671781 100644 (file)
--- a/ua-daemon/src/ua-manager-device-db.c
+++ b/ua-daemon/src/ua-manager-device-db.c
@@ -254,13 +254,13 @@ int _uam_db_get_max_device_number(void)
 {
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
-       int rc;
        sqlite3_stmt *stmt = select_max_device_number;
+       int sql_ret = SQLITE_OK;
 
        do {
-               rc = sqlite3_step(stmt);
+               sql_ret = sqlite3_step(stmt);
 
-               switch (rc) {
+               switch (sql_ret) {
                case SQLITE_DONE:
                        break;
                case SQLITE_ROW:
@@ -269,9 +269,10 @@ int _uam_db_get_max_device_number(void)
                        break;
                case SQLITE_ERROR:
                default:
-                       UAM_ERR("Failed to enumerate device info ");
+                       UAM_ERR("Failed to enumerate device info [%d:%s]",
+                               sql_ret, sqlite3_errmsg(database));
                }
-       } while (rc == SQLITE_ROW);
+       } while (sql_ret == SQLITE_ROW);
 
        sqlite3_reset(stmt);
        FUNC_EXIT;
@@ -314,6 +315,7 @@ int _uam_device_db_update_device_ip_address(char *device_id, int tech_type,
 {
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = update_ip_address;
+       int sql_ret = SQLITE_OK;
 
        retv_if(NULL == device_id, UAM_ERROR_INVALID_PARAMETER);
        retv_if(NULL == address, UAM_ERROR_INVALID_PARAMETER);
@@ -328,8 +330,10 @@ int _uam_device_db_update_device_ip_address(char *device_id, int tech_type,
        DB_ACTION(sqlite3_bind_text(stmt, 4, address, -1, SQLITE_TRANSIENT),
                error_code, handle_error);
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to update ip address ");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to update ip address [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
 
                error_code = UAM_ERROR_DB_FAILED;
                goto handle_error;
@@ -347,6 +351,7 @@ int _uam_device_db_update_device_presence(char *device_id, int tech_type,
 {
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = update_presence;
+       int sql_ret = SQLITE_OK;
 
        retv_if(NULL == device_id, UAM_ERROR_INVALID_PARAMETER);
        retv_if(NULL == address, UAM_ERROR_INVALID_PARAMETER);
@@ -360,8 +365,10 @@ int _uam_device_db_update_device_presence(char *device_id, int tech_type,
        DB_ACTION(sqlite3_bind_text(stmt, 4, address, -1, SQLITE_TRANSIENT),
                error_code, handle_error);
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to update presence ");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to update presence [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
 
                error_code = UAM_ERROR_DB_FAILED;
                goto handle_error;
@@ -379,6 +386,7 @@ int _uam_device_db_update_device_timestamp(char *device_id, int tech_type,
 {
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = update_timestamp;
+       int sql_ret = SQLITE_OK;
 
        retv_if(NULL == device_id, UAM_ERROR_INVALID_PARAMETER);
        retv_if(NULL == address, UAM_ERROR_INVALID_PARAMETER);
@@ -392,8 +400,10 @@ int _uam_device_db_update_device_timestamp(char *device_id, int tech_type,
        DB_ACTION(sqlite3_bind_text(stmt, 4, address, -1, SQLITE_TRANSIENT),
                error_code, handle_error);
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to update device timestamp ");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to update device timestamp [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
 
                error_code = UAM_ERROR_DB_FAILED;
                goto handle_error;
@@ -411,6 +421,7 @@ int _uam_device_db_update_device_device(char *device_id, int tech_type,
 {
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = update_device;
+       int sql_ret = SQLITE_OK;
 
        retv_if(NULL == device_id, UAM_ERROR_INVALID_PARAMETER);
        retv_if(NULL == address, UAM_ERROR_INVALID_PARAMETER);
@@ -436,8 +447,10 @@ int _uam_device_db_update_device_device(char *device_id, int tech_type,
        DB_ACTION(sqlite3_bind_text(stmt, 10, address, -1, SQLITE_TRANSIENT),
                error_code, handle_error);
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to update device discriminant ");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to update device discriminant [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
 
                error_code = UAM_ERROR_DB_FAILED;
                goto handle_error;
@@ -456,6 +469,7 @@ int _uam_device_db_insert_device_info(int user_id,
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = insert_device_info;
+       int sql_ret = SQLITE_OK;
 
        retv_if(NULL == dev_info, UAM_ERROR_INVALID_PARAMETER);
 
@@ -493,8 +507,10 @@ int _uam_device_db_insert_device_info(int user_id,
        DB_ACTION(sqlite3_bind_int(stmt, 14, max_device_number + 1),
                error_code, handle_error);
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to insert device info ");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to insert device info [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
                error_code = UAM_ERROR_DB_FAILED;
                goto handle_error;
        }
@@ -515,6 +531,7 @@ int _uam_device_db_delete_device_info(const char *device_id, int tech_type,
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = delete_device_info;
+       int sql_ret = SQLITE_OK;
 
        UAM_INFO("DeviceId: %s", device_id);
 
@@ -531,8 +548,10 @@ int _uam_device_db_delete_device_info(const char *device_id, int tech_type,
                goto handle_error;
        }
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to delete device info ");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to delete device info [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
                error_code = UAM_ERROR_DB_FAILED;
        } else
                UAM_DBG("Device info deleted");
@@ -549,6 +568,7 @@ int _uam_device_db_get_device(char *device_id, int tech_type, char *address,
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = select_device;
+       int sql_ret = SQLITE_OK;
 
        retv_if(NULL == info, UAM_ERROR_INVALID_PARAMETER);
 
@@ -561,8 +581,10 @@ int _uam_device_db_get_device(char *device_id, int tech_type, char *address,
        DB_ACTION(sqlite3_bind_text(stmt, 3, address, -1, SQLITE_STATIC),
                error_code, handle_error);
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to select device info ");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to select device info [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
                error_code = UAM_ERROR_DB_FAILED;
        } else {
                UAM_DBG("Device info found");
@@ -610,9 +632,9 @@ int _uam_db_get_device_number(const char *device_id, int tech_type,
        const char *address, int *device_number)
 {
        FUNC_ENTRY;
-       int rc;
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = select_device_number;
+       int sql_ret = SQLITE_OK;
 
        retv_if(NULL == device_id, UAM_ERROR_INVALID_PARAMETER);
        retv_if(NULL == address, UAM_ERROR_INVALID_PARAMETER);
@@ -627,9 +649,9 @@ int _uam_db_get_device_number(const char *device_id, int tech_type,
                error_code, handle_error);
 
        do {
-               rc = sqlite3_step(stmt);
+               sql_ret = sqlite3_step(stmt);
 
-               switch (rc) {
+               switch (sql_ret) {
                case SQLITE_DONE:
                        break;
                case SQLITE_ROW:
@@ -639,9 +661,10 @@ int _uam_db_get_device_number(const char *device_id, int tech_type,
                        break;
                case SQLITE_ERROR:
                default:
-                       UAM_ERR("Failed to enumerate device info ");
+                       UAM_ERR("Failed to enumerate device info [%d:%s]",
+                               sql_ret, sqlite3_errmsg(database));
                }
-       } while (rc == SQLITE_ROW);
+       } while (sql_ret == SQLITE_ROW);
 
 handle_error:
        sqlite3_reset(stmt);
@@ -652,15 +675,15 @@ handle_error:
 GSList *_uam_device_db_get_all_devices(void)
 {
        FUNC_ENTRY;
-       int rc;
        sqlite3_stmt *stmt = select_all_devices;
        GSList *device_list = NULL;
        db_device_info_t *info = NULL;
+       int sql_ret = SQLITE_OK;
 
        do {
-               rc = sqlite3_step(stmt);
+               sql_ret = sqlite3_step(stmt);
 
-               switch (rc) {
+               switch (sql_ret) {
                case SQLITE_DONE:
                        break;
                case SQLITE_ROW:
@@ -701,9 +724,10 @@ GSList *_uam_device_db_get_all_devices(void)
                        break;
                case SQLITE_ERROR:
                default:
-                       UAM_ERR("Failed to enumerate device info ");
+                       UAM_ERR("Failed to enumerate device info [%d:%s]",
+                               sql_ret, sqlite3_errmsg(database));
                }
-       } while (rc == SQLITE_ROW);
+       } while (sql_ret == SQLITE_ROW);
 
        sqlite3_reset(stmt);
        FUNC_EXIT;
@@ -714,9 +738,12 @@ int _uam_device_db_clear(void)
 {
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = delete_all_devices;
+       int sql_ret = SQLITE_OK;
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to delete device data ");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to delete device data [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
                error_code = UAM_ERROR_DB_FAILED;
                goto handle_error;
        }

diff --git a/ua-daemon/src/ua-manager-device-service-db.c b/ua-daemon/src/ua-manager-device-service-db.c
index 5f44241..819bb4f 100644 (file)
--- a/ua-daemon/src/ua-manager-device-service-db.c
+++ b/ua-daemon/src/ua-manager-device-service-db.c
@@ -263,6 +263,7 @@ int _uam_db_insert_service(int device_number, int service_number, gboolean discr
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = insert_device_service;
+       int sql_ret = SQLITE_OK;
 
        UAM_INFO("%d-%d", device_number, service_number);
 
@@ -270,8 +271,10 @@ int _uam_db_insert_service(int device_number, int service_number, gboolean discr
        DB_ACTION(sqlite3_bind_int(stmt, 2, service_number), error_code, handle_error);
        DB_ACTION(sqlite3_bind_int(stmt, 3, discriminant), error_code, handle_error);
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to insert device-service info");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to insert device-service info [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
                error_code = UAM_ERROR_DB_FAILED;
                goto handle_error;
        }
@@ -291,6 +294,7 @@ int _uam_db_update_device_service(int device_number, int service_number,
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = update_device_service;
+       int sql_ret = SQLITE_OK;
 
        UAM_INFO("%d-%d", device_number, service_number);
 
@@ -298,8 +302,10 @@ int _uam_db_update_device_service(int device_number, int service_number,
        DB_ACTION(sqlite3_bind_int(stmt, 2, device_number), error_code, handle_error);
        DB_ACTION(sqlite3_bind_int(stmt, 3, service_number), error_code, handle_error);
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to insert device-service info");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to insert device-service info [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
                error_code = UAM_ERROR_DB_FAILED;
                goto handle_error;
        }
@@ -384,9 +390,12 @@ int _uam_device_service_db_clear(void)
 {
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = delete_all_device_services;
+       int sql_ret = SQLITE_OK;
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to delete device data");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to delete device data [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
                error_code = UAM_ERROR_DB_FAILED;
                goto handle_error;
        }
@@ -404,13 +413,16 @@ int _uam_db_delete_service_number(int service_number)
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = delete_service;
+       int sql_ret = SQLITE_OK;
 
        UAM_INFO("Service Number: %d", service_number);
 
        DB_ACTION(sqlite3_bind_int(stmt, 1, service_number), error_code, handle_error);
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to delete device-service info");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to delete device-service info [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
                error_code = UAM_ERROR_DB_FAILED;
        } else
                UAM_DBG("Device-service info deleted");
@@ -426,14 +438,17 @@ int _uam_db_delete_device_service_number(int device_number, int service_number)
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = delete_device_service;
+       int sql_ret = SQLITE_OK;
 
        UAM_INFO("Device Number: %d Service Number: %d", device_number, service_number);
 
        DB_ACTION(sqlite3_bind_int(stmt, 1, device_number), error_code, handle_error);
        DB_ACTION(sqlite3_bind_int(stmt, 2, service_number), error_code, handle_error);
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to delete device-service info");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to delete device-service info [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
                error_code = UAM_ERROR_DB_FAILED;
        } else
                UAM_DBG("Device-service info deleted");
@@ -449,13 +464,16 @@ int _uam_db_delete_device_number(int device_number)
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = delete_device;
+       int sql_ret = SQLITE_OK;
 
        UAM_INFO("Device Number: %d", device_number);
 
        DB_ACTION(sqlite3_bind_int(stmt, 1, device_number), error_code, handle_error);
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to delete device info");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to delete device info [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
                error_code = UAM_ERROR_DB_FAILED;
        } else
                UAM_DBG("Device info deleted");
@@ -557,18 +575,17 @@ handle_error:
 GSList *_uam_db_get_service(int device_number)
 {
        FUNC_ENTRY;
-       int rc;
        sqlite3_stmt *stmt = select_service;
        GSList *service_list = NULL;
        db_service_info_t *info = NULL;
+       int sql_ret = SQLITE_OK;
 
        if (sqlite3_bind_int(stmt, 1, device_number) != SQLITE_OK)
                goto handle_error;
 
        do {
-               rc = sqlite3_step(stmt);
-
-               switch (rc) {
+               sql_ret = sqlite3_step(stmt);
+               switch (sql_ret) {
                case SQLITE_DONE:
                        break;
                case SQLITE_ROW:
@@ -583,9 +600,10 @@ GSList *_uam_db_get_service(int device_number)
                        break;
                case SQLITE_ERROR:
                default:
-                       UAM_ERR("Failed to enumerate device info");
+                       UAM_ERR("Failed to enumerate device info [%d:%s]",
+                               sql_ret, sqlite3_errmsg(database));
                }
-       } while (rc == SQLITE_ROW);
+       } while (sql_ret == SQLITE_ROW);
 
 handle_error:
        sqlite3_reset(stmt);
@@ -617,10 +635,10 @@ int _uam_db_get_device_services_count(const char *device_id, int tech_type,
        const char *address, int *svc_count)
 {
        FUNC_ENTRY;
-       int rc;
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = select_device_services_count;
        int device_number = 0;
+       int sql_ret = SQLITE_OK;
 
        retv_if(NULL == device_id, UAM_ERROR_INVALID_PARAMETER);
        retv_if(NULL == address, UAM_ERROR_INVALID_PARAMETER);
@@ -634,9 +652,9 @@ int _uam_db_get_device_services_count(const char *device_id, int tech_type,
                error_code, handle_error);
 
        do {
-               rc = sqlite3_step(stmt);
+               sql_ret = sqlite3_step(stmt);
 
-               switch (rc) {
+               switch (sql_ret) {
                case SQLITE_DONE:
                        break;
                case SQLITE_ROW:
@@ -646,9 +664,10 @@ int _uam_db_get_device_services_count(const char *device_id, int tech_type,
                        break;
                case SQLITE_ERROR:
                default:
-                       UAM_ERR("Failed to enumerate device info ");
+                       UAM_ERR("Failed to enumerate device info [%d:%s]",
+                               sql_ret, sqlite3_errmsg(database));
                }
-       } while (rc == SQLITE_ROW);
+       } while (sql_ret == SQLITE_ROW);
 
 handle_error:
        sqlite3_reset(stmt);
@@ -659,15 +678,15 @@ handle_error:
 GSList *_uam_db_get_service_devices_info()
 {
        FUNC_ENTRY;
-       int rc;
        sqlite3_stmt *stmt = select_device_services;
        GSList *svc_dev_list = NULL;
        db_svc_dev_info_t *info = NULL;
+       int sql_ret = SQLITE_OK;
 
        do {
-               rc = sqlite3_step(stmt);
+               sql_ret = sqlite3_step(stmt);
 
-               switch (rc) {
+               switch (sql_ret) {
                case SQLITE_DONE:
                        break;
                case SQLITE_ROW:
@@ -690,9 +709,10 @@ GSList *_uam_db_get_service_devices_info()
                        break;
                case SQLITE_ERROR:
                default:
-                       UAM_ERR("Failed to enumerate device info ");
+                       UAM_ERR("Failed to enumerate device info [%d:%s]",
+                               sql_ret, sqlite3_errmsg(database));
                }
-       } while (rc == SQLITE_ROW);
+       } while (sql_ret == SQLITE_ROW);
 
        sqlite3_reset(stmt);
        FUNC_EXIT;

diff --git a/ua-daemon/src/ua-manager-service-db.c b/ua-daemon/src/ua-manager-service-db.c
index 2f33314..58262fd 100644 (file)
--- a/ua-daemon/src/ua-manager-service-db.c
+++ b/ua-daemon/src/ua-manager-service-db.c
@@ -218,12 +218,12 @@ int _uam_db_get_max_service_number(void)
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = select_max_service_number;
-       int rc;
+       int sql_ret = SQLITE_OK;
 
        do {
-               rc = sqlite3_step(stmt);
+               sql_ret = sqlite3_step(stmt);
 
-               switch (rc) {
+               switch (sql_ret) {
                case SQLITE_DONE:
                        break;
                case SQLITE_ROW:
@@ -232,9 +232,10 @@ int _uam_db_get_max_service_number(void)
                        break;
                case SQLITE_ERROR:
                default:
-                       UAM_ERR("Failed to select max service number");
+                       UAM_ERR("Failed to select max service number [%d:%s]",
+                               sql_ret, sqlite3_errmsg(database));
                }
-       } while (rc == SQLITE_ROW);
+       } while (sql_ret == SQLITE_ROW);
 
        sqlite3_reset(stmt);
        FUNC_EXIT;
@@ -277,6 +278,7 @@ int _uam_db_insert_service_info(
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = insert_service_info;
+       int sql_ret = SQLITE_OK;
 
        retv_if(NULL == svc->name, UAM_ERROR_INVALID_PARAMETER);
 
@@ -294,8 +296,10 @@ int _uam_db_insert_service_info(
        DB_ACTION(sqlite3_bind_int(stmt, 5, svc->absence_threshold),
                error_code, handle_error);
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to insert service info");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to insert service info [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
                error_code = UAM_ERROR_DB_FAILED;
                goto handle_error;
        }
@@ -315,8 +319,7 @@ int _uam_db_delete_service_info(const char *service_name)
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = delete_service_info;
-
-       UAM_INFO("Service name: %s", service_name);
+       int sql_ret = SQLITE_OK;
 
        error_code = _uam_db_delete_device_service(service_name);
        if (UAM_ERROR_NONE != error_code) {
@@ -327,8 +330,10 @@ int _uam_db_delete_service_info(const char *service_name)
        DB_ACTION(sqlite3_bind_text(stmt, 1, service_name, -1, SQLITE_STATIC),
                error_code, handle_error);
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to delete service info");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to delete service info [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
                error_code = UAM_ERROR_DB_FAILED;
        } else
                UAM_DBG("Service info deleted");
@@ -343,9 +348,12 @@ int _uam_service_db_clear(void)
 {
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = delete_all_services;
+       int sql_ret = SQLITE_OK;
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to delete service data");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to delete service data [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
                error_code = UAM_ERROR_DB_FAILED;
                goto handle_error;
        }
@@ -362,6 +370,7 @@ int _uam_db_update_service_cycle(const char *service_name, int cycle)
 {
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = update_cycle;
+       int sql_ret = SQLITE_OK;
 
        retv_if(NULL == service_name, UAM_ERROR_INVALID_PARAMETER);
 
@@ -370,8 +379,10 @@ int _uam_db_update_service_cycle(const char *service_name, int cycle)
        DB_ACTION(sqlite3_bind_text(stmt, 2, service_name, -1, SQLITE_TRANSIENT),
                error_code, handle_error);
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to update service timestamp");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to update service timestamp [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
 
                error_code = UAM_ERROR_DB_FAILED;
                goto handle_error;
@@ -389,7 +400,7 @@ int _uam_db_get_service_info(const char *service_name, db_service_info_t *info)
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NOT_FOUND;
        sqlite3_stmt *stmt = select_service;
-       int rc;
+       int sql_ret = SQLITE_OK;
 
        retv_if(!service_name, UAM_ERROR_INVALID_PARAMETER);
        retv_if(!info, UAM_ERROR_INVALID_PARAMETER);
@@ -400,9 +411,8 @@ int _uam_db_get_service_info(const char *service_name, db_service_info_t *info)
                error_code, handle_error);
 
        do {
-               rc = sqlite3_step(stmt);
-
-               switch (rc) {
+               sql_ret = sqlite3_step(stmt);
+               switch (sql_ret) {
                case SQLITE_DONE:
                        break;
                case SQLITE_ROW:
@@ -419,10 +429,11 @@ int _uam_db_get_service_info(const char *service_name, db_service_info_t *info)
                        break;
                case SQLITE_ERROR:
                default:
-                       UAM_ERR("Failed to enumerate device info");
+                       UAM_ERR("Failed to enumerate device info [%d:%s]",
+                               sql_ret, sqlite3_errmsg(database));
                        error_code = UAM_ERROR_DB_FAILED;
                }
-       } while (rc == SQLITE_ROW);
+       } while (sql_ret == SQLITE_ROW);
 
 handle_error:
        sqlite3_reset(stmt);
@@ -433,15 +444,14 @@ handle_error:
 GSList *_uam_service_db_get_all_services(void)
 {
        FUNC_ENTRY;
-       int rc;
        sqlite3_stmt *stmt = select_all_services;
        GSList *service_list = NULL;
        db_service_info_t *info = NULL;
+       int sql_ret = SQLITE_OK;
 
        do {
-               rc = sqlite3_step(stmt);
-
-               switch (rc) {
+               sql_ret = sqlite3_step(stmt);
+               switch (sql_ret) {
                case SQLITE_DONE:
                        break;
                case SQLITE_ROW:
@@ -460,9 +470,10 @@ GSList *_uam_service_db_get_all_services(void)
                        break;
                case SQLITE_ERROR:
                default:
-                       UAM_ERR("Failed to enumerate service info");
+                       UAM_ERR("Failed to enumerate service info [%d:%s]",
+                               sql_ret, sqlite3_errmsg(database));
                }
-       } while (rc == SQLITE_ROW);
+       } while (sql_ret == SQLITE_ROW);
 
        sqlite3_reset(stmt);
        FUNC_EXIT;

diff --git a/ua-daemon/src/ua-manager-user-db.c b/ua-daemon/src/ua-manager-user-db.c
index 7158c90..796becc 100644 (file)
--- a/ua-daemon/src/ua-manager-user-db.c
+++ b/ua-daemon/src/ua-manager-user-db.c
@@ -193,12 +193,12 @@ int _uam_db_get_max_user_id(void)
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = select_max_user_id;
-       int rc;
+       int sql_ret = SQLITE_OK;
 
        do {
-               rc = sqlite3_step(stmt);
+               sql_ret = sqlite3_step(stmt);
 
-               switch (rc) {
+               switch (sql_ret) {
                case SQLITE_DONE:
                        break;
                case SQLITE_ROW:
@@ -207,9 +207,10 @@ int _uam_db_get_max_user_id(void)
                        break;
                case SQLITE_ERROR:
                default:
-                       UAM_ERR("Failed to select max user id");
+                       UAM_ERR("Failed to select max user id [%d:%s]",
+                               sql_ret, sqlite3_errmsg(database));
                }
-       } while (rc == SQLITE_ROW);
+       } while (sql_ret == SQLITE_ROW);
 
        sqlite3_reset(stmt);
        FUNC_EXIT;
@@ -252,6 +253,7 @@ int _uam_db_insert_user_info(int *user_id, const char *name, const char *account
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = insert_user_info;
+       int sql_ret = SQLITE_OK;
 
        retv_if(NULL == account, UAM_ERROR_INVALID_PARAMETER);
 
@@ -264,8 +266,10 @@ int _uam_db_insert_user_info(int *user_id, const char *name, const char *account
        DB_ACTION(sqlite3_bind_text(stmt, 3, account, -1, SQLITE_TRANSIENT),
                error_code, handle_error);
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to insert user info");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to insert user info [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
                error_code = UAM_ERROR_DB_FAILED;
                goto handle_error;
        }
@@ -285,6 +289,7 @@ int _uam_db_delete_by_user_id(int user_id)
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = delete_user_info;
+       int sql_ret = SQLITE_OK;
 
        retv_if(0 > user_id, UAM_ERROR_INVALID_PARAMETER);
 
@@ -292,8 +297,10 @@ int _uam_db_delete_by_user_id(int user_id)
 
        DB_ACTION(sqlite3_bind_int(stmt, 1, user_id), error_code, handle_error);
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to delete user info");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to delete user info [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
                error_code = UAM_ERROR_DB_FAILED;
        } else
                UAM_DBG("User info deleted");
@@ -309,6 +316,7 @@ int _uam_db_get_user(int user_id, db_user_info_t *info)
        FUNC_ENTRY;
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = select_user_data;
+       int sql_ret = SQLITE_OK;
 
        retv_if(0 > user_id, UAM_ERROR_INVALID_PARAMETER);
        retv_if(!info, UAM_ERROR_INVALID_PARAMETER);
@@ -317,8 +325,10 @@ int _uam_db_get_user(int user_id, db_user_info_t *info)
 
        DB_ACTION(sqlite3_bind_int(stmt, 1, user_id), error_code, handle_error);
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to select user info");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to select user info [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
                error_code = UAM_ERROR_DB_FAILED;
        } else {
                info = g_new0(db_user_info_t, 1);
@@ -343,15 +353,15 @@ handle_error:
 GSList *_uam_db_get_all_users(void)
 {
        FUNC_ENTRY;
-       int rc;
        sqlite3_stmt *stmt = select_all_users_data;
        GSList *user_list = NULL;
        db_user_info_t *info = NULL;
+       int sql_ret = SQLITE_OK;
 
        do {
-               rc = sqlite3_step(stmt);
+               sql_ret = sqlite3_step(stmt);
 
-               switch (rc) {
+               switch (sql_ret) {
                case SQLITE_DONE:
                        break;
                case SQLITE_ROW:
@@ -368,9 +378,10 @@ GSList *_uam_db_get_all_users(void)
                        break;
                case SQLITE_ERROR:
                default:
-                       UAM_ERR("Failed to enumerate user info");
+                       UAM_ERR("Failed to enumerate user info [%d:%s]",
+                               sql_ret, sqlite3_errmsg(database));
                }
-       } while (rc == SQLITE_ROW);
+       } while (sql_ret == SQLITE_ROW);
 
        sqlite3_reset(stmt);
        FUNC_EXIT;
@@ -381,9 +392,12 @@ int _uam_user_db_clear(void)
 {
        int error_code = UAM_ERROR_NONE;
        sqlite3_stmt *stmt = delete_all_users_data;
+       int sql_ret = SQLITE_OK;
 
-       if (sqlite3_step(stmt) != SQLITE_DONE) {
-               UAM_ERR("Failed to delete user data");
+       sql_ret = sqlite3_step(stmt);
+       if (sql_ret != SQLITE_DONE) {
+               UAM_ERR("Failed to delete user data [%d:%s]",
+                       sql_ret, sqlite3_errmsg(database));
                error_code = UAM_ERROR_DB_FAILED;
                goto handle_error;
        }