Fix memory leak

Change-Id: I6ec3ee020a742aeffae127383134f575ecf704f0
Signed-off-by: Suyeon Hwang <stom.hwang@samsung.com>
(cherry picked from commit 3fcede4baff208089bc91dae037bc8f048a7854a)

diff --git a/common/vc_cmd_db.c b/common/vc_cmd_db.c
index 01ae1e9..3cf4094 100644 (file)
--- a/common/vc_cmd_db.c
+++ b/common/vc_cmd_db.c
@@ -133,11 +133,16 @@ static int __vc_db_delete_commands(int pid, vc_cmd_type_e type, const char* appi
        ret = sqlite3_prepare_v2(db_handle, sql, -1, &stmt, NULL);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "[ERROR] sqlite3_prepare_v2: %s", sqlite3_errmsg(db_handle));
+               free(sql);
+               sql = NULL;
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_bind_int(stmt, 1, (int)type);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: %s", sqlite3_errmsg(db_handle));
+               sqlite3_finalize(stmt);
+               free(sql);
+               sql = NULL;
                return VC_DB_ERROR_OPERATION_FAILED;
        }
 
@@ -147,6 +152,10 @@ static int __vc_db_delete_commands(int pid, vc_cmd_type_e type, const char* appi
                ret = sqlite3_bind_text(stmt, 2, appid, -1, SQLITE_TRANSIENT);
                if (ret != SQLITE_OK) {
                        SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: %s", sqlite3_errmsg(db_handle));
+                       sqlite3_clear_bindings(stmt);
+                       sqlite3_finalize(stmt);
+                       free(sql);
+                       sql = NULL;
                        return VC_DB_ERROR_OPERATION_FAILED;
                }
                SLOG(LOG_DEBUG, vc_db_tag(), "[SQL] DELETE FROM vc_info WHERE type = %d AND appid = %s", type, appid);
@@ -154,6 +163,10 @@ static int __vc_db_delete_commands(int pid, vc_cmd_type_e type, const char* appi
                ret = sqlite3_bind_int(stmt, 2, pid);
                if (ret != SQLITE_OK) {
                        SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: %s", sqlite3_errmsg(db_handle));
+                       sqlite3_clear_bindings(stmt);
+                       sqlite3_finalize(stmt);
+                       free(sql);
+                       sql = NULL;
                        return VC_DB_ERROR_OPERATION_FAILED;
                }
                SLOG(LOG_DEBUG, vc_db_tag(), "[SQL] DELETE FROM vc_info WHERE type = %d AND pid = %d", type, pid);
@@ -162,6 +175,10 @@ static int __vc_db_delete_commands(int pid, vc_cmd_type_e type, const char* appi
        ret = sqlite3_step(stmt);
        if (ret != SQLITE_DONE) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_step: fail returned, sql(%s), ret(%d), err(%s)", sql, ret, sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
+               free(sql);
+               sql = NULL;
                return VC_DB_ERROR_OPERATION_FAILED;
        }
 
@@ -189,26 +206,35 @@ static int __vc_db_insert_commands(int pid, vc_cmd_type_e type, vc_cmd_s* cmd)
        ret = sqlite3_bind_int(stmt, 2, pid);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: err(%s)", sqlite3_errmsg(db_handle));
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_bind_int(stmt, 3, cmd->type);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: err(%s)", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_bind_int(stmt, 4, cmd->format);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: err(%s)", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_bind_int(stmt, 5, cmd->domain);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: err(%s)", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_bind_text(stmt, 6, cmd->command, -1, SQLITE_TRANSIENT);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_text: err(%s)", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
 
@@ -227,23 +253,31 @@ static int __vc_db_insert_commands(int pid, vc_cmd_type_e type, vc_cmd_s* cmd)
        ret = sqlite3_bind_text(stmt, 8, cmd->appid, -1, SQLITE_TRANSIENT);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_text: err(%s)", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        if (VC_COMMAND_TYPE_BACKGROUND == type && NULL != cmd->invocation_name) {
                ret = sqlite3_bind_text(stmt, 9, cmd->invocation_name, -1, SQLITE_TRANSIENT);
                if (ret != SQLITE_OK) {
                        SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_text: err(%s)", sqlite3_errmsg(db_handle));
+                       sqlite3_clear_bindings(stmt);
+                       sqlite3_finalize(stmt);
                        return VC_DB_ERROR_OPERATION_FAILED;
                }
        }
        ret = sqlite3_bind_text(stmt, 10, cmd->fixed, -1, SQLITE_TRANSIENT);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_text: err(%s)", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_step(stmt);
        if (ret != SQLITE_DONE) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_step: fail returned %d, %s", ret, sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
 
@@ -287,12 +321,19 @@ static int __vc_db_get_commands(int pid, vc_cmd_type_e type, GSList** cmd_list)
        ret = sqlite3_bind_int(stmt, 1, (int)type);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: %s", sqlite3_errmsg(db_handle));
+               sqlite3_finalize(stmt);
+               free(sql);
+               sql = NULL;
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        if (VC_COMMAND_TYPE_BACKGROUND != type) {
                ret = sqlite3_bind_int(stmt, 2, pid);
                if (ret != SQLITE_OK) {
                        SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: %s", sqlite3_errmsg(db_handle));
+                       sqlite3_clear_bindings(stmt);
+                       sqlite3_finalize(stmt);
+                       free(sql);
+                       sql = NULL;
                        return VC_DB_ERROR_OPERATION_FAILED;
                }
        }
@@ -305,6 +346,10 @@ static int __vc_db_get_commands(int pid, vc_cmd_type_e type, GSList** cmd_list)
        ret = sqlite3_step(stmt);
        if (ret == SQLITE_DONE) {
                SLOG(LOG_DEBUG, vc_db_tag(), "No matched commands");
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
+               free(sql);
+               sql = NULL;
                return VC_DB_ERROR_NONE;
        }
 
@@ -325,6 +370,11 @@ static int __vc_db_get_commands(int pid, vc_cmd_type_e type, GSList** cmd_list)
                                free(appid);
                                appid = NULL;
                        }
+                       sqlite3_reset(stmt);
+                       sqlite3_clear_bindings(stmt);
+                       sqlite3_finalize(stmt);
+                       free(sql);
+                       sql = NULL;
                        return VC_DB_ERROR_OUT_OF_MEMORY;
                }
 
@@ -447,21 +497,28 @@ static int __vc_db_insert_result(const char* result_text, int event, const char*
        ret = sqlite3_bind_text(stmt, 2, result_text, -1, SQLITE_TRANSIENT);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_text: %s", sqlite3_errmsg(db_handle));
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_bind_int(stmt, 3, event);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: %s", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_bind_text(stmt, 4, msg, -1, SQLITE_TRANSIENT);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_text: %s", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_bind_int(stmt, 5, exclusive);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: %s", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
 
@@ -471,6 +528,8 @@ static int __vc_db_insert_result(const char* result_text, int event, const char*
                ret = sqlite3_step(stmt);
                if (ret != SQLITE_DONE) {
                        SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_step: fail returned %d, %s", ret, sqlite3_errmsg(db_handle));
+                       sqlite3_clear_bindings(stmt);
+                       sqlite3_finalize(stmt);
                        return VC_DB_ERROR_OPERATION_FAILED;
                }
                sqlite3_reset(stmt);
@@ -493,51 +552,71 @@ static int __vc_db_insert_result(const char* result_text, int event, const char*
        ret = sqlite3_bind_int(stmt, 6, cmd->pid);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: %s", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_bind_int(stmt, 7, cmd->type);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: %s", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_bind_int(stmt, 8, cmd->format);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: %s", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_bind_int(stmt, 9, cmd->domain);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: %s", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_bind_text(stmt, 10, cmd->command, -1, SQLITE_TRANSIENT);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_text: %s", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_bind_text(stmt, 11, cmd->parameter, -1, SQLITE_TRANSIENT);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_text: %s", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_bind_text(stmt, 12, cmd->appid, -1, SQLITE_TRANSIENT);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_text: %s", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_bind_text(stmt, 13, cmd->invocation_name, -1, SQLITE_TRANSIENT);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_text: %s", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_bind_text(stmt, 14, cmd->fixed, -1, SQLITE_TRANSIENT);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_text: %s", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_step(stmt);
        if (ret != SQLITE_DONE) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_step: fail returned %d, %s", ret, sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
 
@@ -630,24 +709,36 @@ static int __vc_db_get_result(char** result_text, int* event, char** msg, int pi
        ret = sqlite3_prepare_v2(db_handle, sql, -1, &stmt, NULL);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "[ERROR] sqlite3_prepare_v2: %s", sqlite3_errmsg(db_handle));
+               free(sql);
+               sql = NULL;
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        if (NULL != appid) {
                ret = sqlite3_bind_text(stmt, 1, appid, -1, SQLITE_TRANSIENT);
                if (ret != SQLITE_OK) {
                        SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: %s", sqlite3_errmsg(db_handle));
+                       sqlite3_finalize(stmt);
+                       free(sql);
+                       sql = NULL;
                        return VC_DB_ERROR_OPERATION_FAILED;
                }
        } else if (-1 != pid) {
                ret = sqlite3_bind_int(stmt, 1, pid);
                if (ret != SQLITE_OK) {
                        SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: %s", sqlite3_errmsg(db_handle));
+                       sqlite3_finalize(stmt);
+                       free(sql);
+                       sql = NULL;
                        return VC_DB_ERROR_OPERATION_FAILED;
                }
        }
        ret = sqlite3_step(stmt);
        if (ret == SQLITE_DONE) {
                SLOG(LOG_DEBUG, vc_db_tag(), "No matched commands");
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
+               free(sql);
+               sql = NULL;
                return VC_DB_ERROR_NONE;
        }
 
@@ -689,6 +780,12 @@ static int __vc_db_get_result(char** result_text, int* event, char** msg, int pi
                                free(*msg);
                                *msg = NULL;
                        }
+
+                       sqlite3_reset(stmt);
+                       sqlite3_clear_bindings(stmt);
+                       sqlite3_finalize(stmt);
+                       free(sql);
+                       sql = NULL;
                        return -1;
                }
 
@@ -778,6 +875,11 @@ static int __vc_db_get_result(char** result_text, int* event, char** msg, int pi
                                *msg = NULL;
                        }
 
+                       sqlite3_reset(stmt);
+                       sqlite3_clear_bindings(stmt);
+                       sqlite3_finalize(stmt);
+                       free(sql);
+                       sql = NULL;
                        return VC_DB_ERROR_OPERATION_FAILED;
                }
 
@@ -811,17 +913,22 @@ static int __vc_db_get_appid(const char* result, GSList** app_list)
        ret = sqlite3_bind_int(stmt, 1, VC_COMMAND_TYPE_BACKGROUND);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: %s", sqlite3_errmsg(db_handle));
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_bind_text(stmt, 2, result, -1, SQLITE_TRANSIENT);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: %s", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        SLOG(LOG_DEBUG, vc_db_tag(), "[SQL] SELECT * FROM vc_result WHERE type = 2 and result = %s", result);
        ret = sqlite3_step(stmt);
        if (ret == SQLITE_DONE) {
                SLOG(LOG_DEBUG, vc_db_tag(), "No matched commands");
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_NONE;
        }
 
@@ -831,6 +938,15 @@ static int __vc_db_get_appid(const char* result, GSList** app_list)
                temp_app = (vc_deactivated_app_s*)calloc(1, sizeof(vc_deactivated_app_s));
                if (NULL == temp_app) {
                        SLOG(LOG_ERROR, vc_db_tag(), "[ERROR] memory allcation fail");
+
+                       if (NULL != temp_app_list) {
+                               g_slist_free_full(temp_app_list, free);
+                               temp_app_list = NULL;
+                       }
+
+                       sqlite3_reset(stmt);
+                       sqlite3_clear_bindings(stmt);
+                       sqlite3_finalize(stmt);
                        return VC_DB_ERROR_OUT_OF_MEMORY;
                }
 
@@ -869,11 +985,14 @@ int __vc_db_get_result_pid_list(const char* result, GSList** pid_list)
        ret = sqlite3_bind_text(stmt, 1, result, -1, SQLITE_TRANSIENT);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: %s", sqlite3_errmsg(db_handle));
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_step(stmt);
        if (ret == SQLITE_DONE) {
                SLOG(LOG_DEBUG, vc_db_tag(), "No matched commands");
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_NONE;
        }
 
@@ -885,6 +1004,15 @@ int __vc_db_get_result_pid_list(const char* result, GSList** pid_list)
                temp_cmd = (vc_cmd_s*)calloc(1, sizeof(vc_cmd_s));
                if (NULL == temp_cmd) {
                        SLOG(LOG_ERROR, vc_db_tag(), "[ERROR] memory allcation fail");
+
+                       if (NULL != temp_pid_list) {
+                               g_slist_free_full(temp_pid_list, free);
+                               temp_pid_list = NULL;
+                       }
+
+                       sqlite3_reset(stmt);
+                       sqlite3_clear_bindings(stmt);
+                       sqlite3_finalize(stmt);
                        return VC_DB_ERROR_OUT_OF_MEMORY;
                }
 
@@ -928,16 +1056,21 @@ static int __vc_db_append_commands(int pid, int type, vc_cmd_list_h vc_cmd_list)
        ret = sqlite3_bind_int(stmt, 1, pid);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: %s", sqlite3_errmsg(db_handle));
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_bind_int(stmt, 2, type);
        if (ret != SQLITE_OK) {
                SLOG(LOG_ERROR, vc_db_tag(), "sqlite3_bind_int: %s", sqlite3_errmsg(db_handle));
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_OPERATION_FAILED;
        }
        ret = sqlite3_step(stmt);
        if (ret == SQLITE_DONE) {
                SLOG(LOG_DEBUG, vc_db_tag(), "No matched commands");
+               sqlite3_clear_bindings(stmt);
+               sqlite3_finalize(stmt);
                return VC_DB_ERROR_NONE;
        }
 
@@ -951,6 +1084,9 @@ static int __vc_db_append_commands(int pid, int type, vc_cmd_list_h vc_cmd_list)
 
                if (0 != vc_cmd_create(&temp_cmd)) {
                        SLOG(LOG_ERROR, vc_db_tag(), "[ERROR] Fail to create command!!");
+                       sqlite3_reset(stmt);
+                       sqlite3_clear_bindings(stmt);
+                       sqlite3_finalize(stmt);
                        return -1;
                }
                temp = sqlite3_column_int(stmt, 0);
@@ -992,6 +1128,9 @@ static int __vc_db_append_commands(int pid, int type, vc_cmd_list_h vc_cmd_list)
                        SLOG(LOG_DEBUG, vc_db_tag(), "Fail to add command to list");
                        vc_cmd_destroy(temp_cmd);
                        vc_cmd_list_destroy(vc_cmd_list, true);
+                       sqlite3_reset(stmt);
+                       sqlite3_clear_bindings(stmt);
+                       sqlite3_finalize(stmt);
                        return VC_DB_ERROR_OPERATION_FAILED;
                }
 

diff --git a/common/vc_info_parser.c b/common/vc_info_parser.c
index 08db797..770ca29 100644 (file)
--- a/common/vc_info_parser.c
+++ b/common/vc_info_parser.c
@@ -191,6 +191,12 @@ int vc_info_parser_get_demandable_clients(GSList** client_list)
 
                                if (NULL == temp_client) {
                                        SLOG(LOG_ERROR, vc_info_tag(), "[ERROR] Memory alloc error!!");
+
+                                       if (NULL != temp_client_list) {
+                                               g_slist_free_full(temp_client_list, free);
+                                               temp_client_list = NULL;
+                                       }
+                                       xmlFree(key);
                                        xmlFreeDoc(doc);
                                        return -1;
                                }
@@ -589,6 +595,11 @@ int vc_info_parser_get_client_info(GSList** client_info_list)
 
                if (NULL == client) {
                        SLOG(LOG_ERROR, vc_info_tag(), "[ERROR] Memory alloc error!!");
+
+                       if (NULL != temp_client_list) {
+                               g_slist_free_full(temp_client_list, free);
+                               temp_client_list = NULL;
+                       }
                        xmlFreeDoc(doc);
                        return -1;
                }