Use GMutex for portability

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

diff --git a/src/package_manager.c b/src/package_manager.c
index 83b789e..dec09cd 100644 (file)
--- a/src/package_manager.c
+++ b/src/package_manager.c
@@ -28,8 +28,6 @@
 #include "package_manager.h"
 #include "package_manager_internal.h"
 
-static GHashTable *__cb_table = NULL;
-
 #define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
 typedef struct _request_event_info {
        int req_id;
@@ -52,6 +50,7 @@ struct package_manager_s {
        GHashTable *event_info_table;
        package_manager_event_cb event_cb;
        void *user_data;
+       GMutex mutex;
 };
 
 struct package_manager_request_s {
@@ -1003,6 +1002,7 @@ API int package_manager_create(package_manager_h *manager)
        }
 
        package_manager->handle_id = package_manager_new_id();
+       g_mutex_init(&package_manager->mutex);
 
        *manager = package_manager;
 
@@ -1026,6 +1026,7 @@ API int package_manager_destroy(package_manager_h manager)
                     NULL);
        }
 
+       g_mutex_clear(&manager->mutex);
        pkgmgr_client_free(manager->pc);
        g_hash_table_destroy(manager->event_info_table);
        free(manager);
@@ -1078,6 +1079,7 @@ static int internal_callback(uid_t target_uid, int req_id, const char *pkg_type,
                return PACKAGE_MANAGER_ERROR_NONE;
 
        if (manager && manager->event_info_table) {
+               g_mutex_lock(&manager->mutex);
                info = g_hash_table_lookup(manager->event_info_table, pkg_name);
        } else {
                _LOGE("invalid handle");
@@ -1087,14 +1089,17 @@ static int internal_callback(uid_t target_uid, int req_id, const char *pkg_type,
        if (!info) {
                if (strcasecmp(key, "start") != 0) {
                        _LOGD("unexpected signal or no info(removed)");
+                       g_mutex_unlock(&manager->mutex);
                        return PACKAGE_MANAGER_ERROR_NONE;
                }
        }
 
        if (strcasecmp(key, "start") == 0) {
                ret = package_manager_get_event_type(val, &event_type);
-               if (ret != PACKAGE_MANAGER_ERROR_NONE)
+               if (ret != PACKAGE_MANAGER_ERROR_NONE) {
+                       g_mutex_unlock(&manager->mutex);
                        return PACKAGE_MANAGER_ERROR_INVALID_PARAMETER;
+               }
 
                if (!info) {
                        __insert_event_info(manager, pkg_name, event_type,
@@ -1152,6 +1157,8 @@ static int internal_callback(uid_t target_uid, int req_id, const char *pkg_type,
                g_hash_table_remove(manager->event_info_table, info->pkg_name);
        }
 
+       g_mutex_unlock(&manager->mutex);
+
        return PACKAGE_MANAGER_ERROR_NONE;
 }
 
@@ -1255,7 +1262,9 @@ API int package_manager_unset_event_cb(package_manager_h manager)
        manager->event_cb = NULL;
        manager->user_data = NULL;
 
+       g_mutex_lock(&manager->mutex);
        g_hash_table_remove_all(manager->event_info_table);
+       g_mutex_unlock(&manager->mutex);
 
        retval = pkgmgr_client_remove_listen_status(manager->pc);
        if (retval == PKGMGR_R_EINVAL)
@@ -1532,23 +1541,25 @@ API int package_manager_clear_all_cache_dir(void)
        return package_manager_clear_cache_dir(PKG_CLEAR_ALL_CACHE);
 }
 
-static void __free_client(gpointer data)
-{
-       pkgmgr_client *pc = (pkgmgr_client *)data;
-       pkgmgr_client_free(pc);
-}
+struct getsize_cbdata {
+       pkgmgr_client *pc;
+       void *cb;
+       void *user_data;
+};
 
-static void __initialize_cb_table(void)
+static void __free_getsize_cbdata(struct getsize_cbdata *cbdata)
 {
-       __cb_table = g_hash_table_new_full(g_direct_hash, g_direct_equal, __free_client, NULL);
+       pkgmgr_client_free(cbdata->pc);
+       free(cbdata);
 }
 
 static void __result_cb(pkgmgr_client *pc, const char *pkgid, const pkg_size_info_t *result, void *user_data)
 {
-       package_manager_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
+       struct getsize_cbdata *cbdata = (struct getsize_cbdata *)user_data;
+       package_manager_size_info_receive_cb callback = cbdata->cb;
        if (callback == NULL) {
                _LOGE("callback is null.");
-               g_hash_table_remove(__cb_table, pc);
+               __free_getsize_cbdata(cbdata);
                return;
        }
 
@@ -1562,15 +1573,16 @@ static void __result_cb(pkgmgr_client *pc, const char *pkgid, const pkg_size_inf
 
        callback(pkgid, (package_size_info_h)&size_info, user_data);
 
-       g_hash_table_remove(__cb_table, pc);
+       __free_getsize_cbdata(cbdata);
 }
 
 static void __total_result_cb(pkgmgr_client *pc, const pkg_size_info_t *result, void *user_data)
 {
-       package_manager_total_size_info_receive_cb callback = g_hash_table_lookup(__cb_table, pc);
+       struct getsize_cbdata *cbdata = (struct getsize_cbdata *)user_data;
+       package_manager_total_size_info_receive_cb callback = cbdata->cb;
        if (callback == NULL) {
                _LOGE("callback is null.");
-               g_hash_table_remove(__cb_table, pc);
+               __free_getsize_cbdata(cbdata);
                return;
        }
 
@@ -1584,26 +1596,35 @@ static void __total_result_cb(pkgmgr_client *pc, const pkg_size_info_t *result,
 
        callback((package_size_info_h)&size_info, user_data);
 
-       g_hash_table_remove(__cb_table, pc);
+       __free_getsize_cbdata(cbdata);
 }
 
 static int _get_pkg_size_info(const char *package_id, void *callback, void *user_data)
 {
+       struct getsize_cbdata *cbdata;
+
        if (package_id == NULL || callback == NULL)
                return package_manager_error(PACKAGE_MANAGER_ERROR_INVALID_PARAMETER, __FUNCTION__, NULL);
 
-       if (__cb_table == NULL)
-               __initialize_cb_table();
+       cbdata = malloc(sizeof(struct getsize_cbdata));
+       if (cbdata == NULL)
+               return package_manager_error(PACKAGE_MANAGER_ERROR_OUT_OF_MEMORY, __FUNCTION__, NULL);
 
        pkgmgr_client *pc = pkgmgr_client_new(PC_REQUEST);
-       if (pc == NULL)
+       if (pc == NULL) {
+               free(cbdata);
                return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
+       }
+
+       cbdata->pc = pc;
+       cbdata->cb = callback;
+       cbdata->user_data = user_data;
 
        int res = 0;
        if (strcmp(package_id, PKG_SIZE_INFO_TOTAL) != 0)
-               res = pkgmgr_client_get_package_size_info(pc, package_id, __result_cb, user_data);
+               res = pkgmgr_client_get_package_size_info(pc, package_id, __result_cb, cbdata);
        else
-               res = pkgmgr_client_get_total_package_size_info(pc, __total_result_cb, user_data);
+               res = pkgmgr_client_get_total_package_size_info(pc, __total_result_cb, cbdata);
 
        if (res == PKGMGR_R_EINVAL) {
                pkgmgr_client_free(pc);
@@ -1625,12 +1646,10 @@ static int _get_pkg_size_info(const char *package_id, void *callback, void *user
                return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
        } else if (res != PKGMGR_R_OK) {
                _LOGE("Unexpected error");
-               pkgmgr_client_free(pc);
+               __free_getsize_cbdata(cbdata);
                return package_manager_error(PACKAGE_MANAGER_ERROR_SYSTEM_ERROR, __FUNCTION__, NULL);
        }
 
-       g_hash_table_insert(__cb_table, pc, callback);
-
        return PACKAGE_MANAGER_ERROR_NONE;
 }