Fix memory leak

[platform/core/api/package-manager.git] / src / package_manager.c

diff --git a/src/package_manager.c b/src/package_manager.c
index dec09cd..1791d28 100644 (file)
--- a/src/package_manager.c
+++ b/src/package_manager.c
@@ -1063,11 +1063,15 @@ static int internal_callback(uid_t target_uid, int req_id, const char *pkg_type,
                                const char *pkg_name, const char *key,
                                const char *val, const void *pmsg, void *data)
 {
-       int ret = -1;
-       package_manager_event_type_e event_type = -1;
        struct package_manager_event_info *info = NULL;
+       int ret = -1;
        package_manager_h manager = data;
        uid_t uid = target_uid;
+       bool invoke_callback = false;
+       package_manager_event_type_e event_type = -1;
+       package_manager_event_state_e event_state;
+       int progress = 0;
+       package_manager_error_e error = PACKAGE_MANAGER_ERROR_NONE;
 
        _LOGD("req_id(%d), pkg_name(%s), type(%s), key(%s), val(%s)",
                        req_id, pkg_name, pkg_type, key, val);
@@ -1105,60 +1109,55 @@ static int internal_callback(uid_t target_uid, int req_id, const char *pkg_type,
                        __insert_event_info(manager, pkg_name, event_type,
                                        PACKAGE_MANAGER_EVENT_STATE_STARTED);
 
-                       if (manager->event_cb && getuid() == uid)
-                               manager->event_cb(pkg_type, pkg_name,
-                                               event_type,
-                                               PACKAGE_MANAGER_EVENT_STATE_STARTED,
-                                               0,
-                                               PACKAGE_MANAGER_ERROR_NONE,
-                                               manager->user_data);
+                       event_state = PACKAGE_MANAGER_EVENT_STATE_STARTED;
+                       progress = 0;
+                       error = PACKAGE_MANAGER_ERROR_NONE;
+                       invoke_callback = true;
                } else {
                        _LOGE("unexpected start event");
                }
        } else if (strcasecmp(key, "install_percent") == 0
                   || strcasecmp(key, "progress_percent") == 0) {
                info->event_state = PACKAGE_MANAGER_EVENT_STATE_PROCESSING;
-               if (manager->event_cb && getuid() == uid)
-                       manager->event_cb(pkg_type, pkg_name,
-                                       info->event_type,
-                                       info->event_state,
-                                       atoi(val),
-                                       PACKAGE_MANAGER_ERROR_NONE,
-                                       manager->user_data);
+               event_type = info->event_type;
+               event_state = info->event_state;
+               progress = atoi(val);
+               error = PACKAGE_MANAGER_ERROR_NONE;
+               invoke_callback = true;
        } else if (strcasecmp(key, "error") == 0) {
                info->event_state = PACKAGE_MANAGER_EVENT_STATE_FAILED;
-               if (manager->event_cb && getuid() == uid)
-                       manager->event_cb(pkg_type, pkg_name,
-                                       info->event_type,
-                                       info->event_state,
-                                       0,
-                                       __convert_to_error(val),
-                                       manager->user_data);
+               event_type = info->event_type;
+               event_state = info->event_state;
+               progress = 0;
+               error = __convert_to_error(val);
+               invoke_callback = true;
        } else if (strcasecmp(key, "end") == 0) {
                if (info->event_state != PACKAGE_MANAGER_EVENT_STATE_FAILED) {
-                       if (manager->event_cb && getuid() == uid) {
-                               if (strcasecmp(val, "ok") == 0) {
-                                       manager->event_cb(pkg_type, pkg_name,
-                                               info->event_type,
-                                               PACKAGE_MANAGER_EVENT_STATE_COMPLETED,
-                                               100,
-                                               PACKAGE_MANAGER_ERROR_NONE,
-                                               manager->user_data);
-                               } else {
-                                       manager->event_cb(pkg_type, pkg_name,
-                                               info->event_type,
-                                               PACKAGE_MANAGER_EVENT_STATE_FAILED,
-                                               0,
-                                               PACKAGE_MANAGER_ERROR_SYSTEM_ERROR,
-                                               manager->user_data);
-                               }
+                       if (strcasecmp(val, "ok") == 0) {
+                               event_type = info->event_type;
+                               event_state =
+                                       PACKAGE_MANAGER_EVENT_STATE_COMPLETED;
+                               progress = 100;
+                               error = PACKAGE_MANAGER_ERROR_NONE;
+                               invoke_callback = true;
+                       } else {
+                               event_type = info->event_type;
+                               event_state =
+                                       PACKAGE_MANAGER_EVENT_STATE_FAILED;
+                               progress = 0;
+                               error = PACKAGE_MANAGER_ERROR_SYSTEM_ERROR;
+                               invoke_callback = true;
                        }
                }
                g_hash_table_remove(manager->event_info_table, info->pkg_name);
        }
-
        g_mutex_unlock(&manager->mutex);
 
+       if (invoke_callback && manager->event_cb && getuid() == uid) {
+               manager->event_cb(pkg_type, pkg_name, event_type, event_state,
+                               progress, error, manager->user_data);
+       }
+
        return PACKAGE_MANAGER_ERROR_NONE;
 }
 
@@ -1571,7 +1570,7 @@ static void __result_cb(pkgmgr_client *pc, const char *pkgid, const pkg_size_inf
        size_info.external_cache_size = result->ext_cache_size;
        size_info.external_app_size   = result->ext_app_size;
 
-       callback(pkgid, (package_size_info_h)&size_info, user_data);
+       callback(pkgid, (package_size_info_h)&size_info, cbdata->user_data);
 
        __free_getsize_cbdata(cbdata);
 }
@@ -1594,7 +1593,7 @@ static void __total_result_cb(pkgmgr_client *pc, const pkg_size_info_t *result,
        size_info.external_cache_size = result->ext_cache_size;
        size_info.external_app_size   = result->ext_app_size;
 
-       callback((package_size_info_h)&size_info, user_data);
+       callback((package_size_info_h)&size_info, cbdata->user_data);
 
        __free_getsize_cbdata(cbdata);
 }
@@ -1626,28 +1625,24 @@ static int _get_pkg_size_info(const char *package_id, void *callback, void *user
        else
                res = pkgmgr_client_get_total_package_size_info(pc, __total_result_cb, cbdata);
 
-       if (res == PKGMGR_R_EINVAL) {
-               pkgmgr_client_free(pc);
-               return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
-       } else if (res == PKGMGR_R_ENOPKG) {
-               pkgmgr_client_free(pc);
-               return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
-       } else if (res == PKGMGR_R_ENOMEM) {
-               pkgmgr_client_free(pc);
-               return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
-       } else if (res == PKGMGR_R_EIO) {
-               pkgmgr_client_free(pc);
-               return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
-       } else if (res == PKGMGR_R_EPRIV) {
-               pkgmgr_client_free(pc);
-               return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
-       } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
-               pkgmgr_client_free(pc);
-               return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
-       } else if (res != PKGMGR_R_OK) {
-               _LOGE("Unexpected error");
+       if (res != PKGMGR_R_OK) {
                __free_getsize_cbdata(cbdata);
-               return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
+               if (res == PKGMGR_R_EINVAL) {
+                       return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
+               } else if (res == PKGMGR_R_ENOPKG) {
+                       return package_manager_error(PACKAGE_MANAGER_ERROR_NO_SUCH_PACKAGE, __FUNCTION__, NULL);
+               } else if (res == PKGMGR_R_ENOMEM) {
+                       return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
+               } else if (res == PKGMGR_R_EIO) {
+                       return package_manager_error(PACKAGE_MANAGER_ERROR_IO_ERROR, __FUNCTION__, NULL);
+               } else if (res == PKGMGR_R_EPRIV) {
+                       return package_manager_error(PACKAGE_MANAGER_ERROR_PERMISSION_DENIED, __FUNCTION__, NULL);
+               } else if (res == PKGMGR_R_ESYSTEM || res == PKGMGR_R_ECOMM || res == PKGMGR_R_ERROR) {
+                       return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
+               } else {
+                       _LOGE("Unexpected error");
+                       return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
+               }
        }
 
        return PACKAGE_MANAGER_ERROR_NONE;