Add multiuser feature

Signed-off-by: seungha.son <seungha.son@samsung.com>
Change-Id: I4e22f9930f770c92fe60ae623f047754e2c575c6

diff --git a/include/badge_db.h b/include/badge_db.h
index 2216f40..b0dd63f 100755 (executable)
--- a/include/badge_db.h
+++ b/include/badge_db.h
@@ -26,21 +26,22 @@
 
 #include <stdbool.h>
 #include <sqlite3.h>
+#include <sys/types.h>
 #include <badge_error.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-int badge_db_insert(const char *pkgname, const char *writable_pkg, const char *caller);
-int badge_db_delete(const char *pkgname, const char *caller_pkg);
-int badge_db_set_count(const char *pkgname, const char *caller_pkg, unsigned int count);
-int badge_db_get_count(const char *pkgname, unsigned int *count);
-int badge_db_set_display_option(const char *pkgname, const char *caller_pkg, unsigned int is_display);
-int badge_db_get_display_option(const char *pkgname, unsigned int *is_display);
+int badge_db_insert(const char *pkgname, const char *writable_pkg, const char *caller, uid_t uid);
+int badge_db_delete(const char *pkgname, const char *caller_pkg, uid_t uid);
+int badge_db_set_count(const char *pkgname, const char *caller_pkg, unsigned int count, uid_t uid);
+int badge_db_get_count(const char *pkgname, unsigned int *count, uid_t uid);
+int badge_db_set_display_option(const char *pkgname, unsigned int is_display, uid_t uid);
+int badge_db_get_display_option(const char *pkgname, unsigned int *is_display, uid_t uid);
 int badge_db_exec(sqlite3 *db, const char *query, int *num_changes);
-int badge_db_get_list(GList **badge_list);
-int badge_db_is_existing(const char *pkgname, bool *existing);
+int badge_db_get_list(GList **badge_list, uid_t uid);
+int badge_db_is_existing(const char *pkgname, bool *existing, uid_t uid);
 int badge_db_init();
 
 #ifdef __cplusplus

diff --git a/include/badge_internal.h b/include/badge_internal.h
index ad4b00b..c007cb0 100755 (executable)
--- a/include/badge_internal.h
+++ b/include/badge_internal.h
@@ -26,6 +26,7 @@
 #include <stdbool.h>
 #include <stdarg.h>
 #include <glib.h>
+#include <sys/types.h>
 
 #include "badge_error.h"
 #include "badge.h"
@@ -139,29 +140,28 @@ int badge_is_existing(const char *app_id, bool *existing);
 
 char *_badge_get_pkgname_by_pid(void);
 
-int _badge_is_existing(const char *pkgname, bool *existing);
+int _badge_is_existing(const char *pkgname, bool *existing, uid_t uid);
 
-int _badge_foreach_existed(badge_foreach_cb callback, void *data);
+int _badge_foreach_existed(badge_foreach_cb callback, void *data, uid_t uid);
 
-int _badge_get_list(GList **badge_list);
+int _badge_get_list(GList **badge_list, uid_t uid);
 
-int _badge_insert(badge_h *badge);
+int _badge_insert(badge_h *badge, uid_t uid);
 
-int _badge_remove(const char *caller, const char *pkgname);
+int _badge_remove(const char *caller, const char *pkgname, uid_t uid);
 
 int _badge_set_count(const char *caller, const char *pkgname,
-                       unsigned int count);
+                       unsigned int count, uid_t uid);
 
-int _badge_get_count(const char *pkgname, unsigned int *count);
+int _badge_get_count(const char *pkgname, unsigned int *count, uid_t uid);
 
-int _badge_set_display(const char *pkgname,
-                       unsigned int is_display);
+int _badge_set_display(const char *pkgname, unsigned int is_display, uid_t uid);
 
-int _badge_get_display(const char *pkgname, unsigned int *is_display);
+int _badge_get_display(const char *pkgname, unsigned int *is_display, uid_t uid);
 
-int _badge_register_changed_cb(badge_change_cb callback, void *data);
+int _badge_register_changed_cb(badge_change_cb callback, void *data, uid_t uid);
 
-int _badge_unregister_changed_cb(badge_change_cb callback);
+int _badge_unregister_changed_cb(badge_change_cb callback, uid_t uid);
 
 int _badge_free(badge_h *badge);
 
@@ -174,7 +174,7 @@ char *_badge_pkgs_new_valist(int *err,
                        const char *pkg1, va_list args);
 
 void badge_changed_cb_call(unsigned int action, const char *pkgname,
-                       unsigned int count);
+                       unsigned int count, uid_t uid);
 
 /**
  * @internal
@@ -204,6 +204,31 @@ void badge_changed_cb_call(unsigned int action, const char *pkgname,
  */
 int badge_create(const char *pkgname, const char *writable_pkg);
 
+int badge_create_for_uid(const char *pkgname, const char *writable_pkg, uid_t uid);
+
+int badge_new_for_uid(const char *writable_app_id, uid_t uid);
+
+int badge_add_for_uid(const char *badge_app_id, uid_t uid);
+
+int badge_remove_for_uid(const char *app_id, uid_t uid);
+
+int badge_is_existing_for_uid(const char *app_id, bool *existing, uid_t uid);
+
+int badge_foreach_for_uid(badge_foreach_cb callback, void *user_data, uid_t uid);
+
+int badge_set_count_for_uid(const char *app_id, unsigned int count, uid_t uid);
+
+int badge_get_count_for_uid(const char *app_id, unsigned int *count, uid_t uid);
+
+int badge_set_display_for_uid(const char *app_id, unsigned int is_display, uid_t uid);
+
+int badge_get_display_for_uid(const char *app_id, unsigned int *is_display, uid_t uid);
+
+int badge_register_changed_cb_for_uid(badge_change_cb callback, void *data, uid_t uid);
+
+int badge_unregister_changed_cb_for_uid(badge_change_cb callback, uid_t uid);
+
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */

diff --git a/include/badge_ipc.h b/include/badge_ipc.h
index 2e785ef..ffcfb99 100755 (executable)
--- a/include/badge_ipc.h
+++ b/include/badge_ipc.h
@@ -24,6 +24,7 @@
 #define __BADGE_IPC_H__
 
 #include <badge.h>
+#include <sys/types.h>
 
 #define BADGE_ADDR "/tmp/.badge.service"
 
@@ -33,25 +34,25 @@ extern "C" {
 
 struct packet;
 
-int badge_ipc_monitor_init(void);
+int badge_ipc_monitor_init(uid_t uid);
 int badge_ipc_monitor_fini(void);
 
-int badge_ipc_request_insert(const char *pkgname, const char *writable_pkg, const char *caller);
-int badge_ipc_request_delete(const char *pkgname, const char *caller);
-int badge_ipc_request_set_count(const char *pkgname, const char *caller, int count);
-int badge_ipc_request_get_count(const char *pkgname, unsigned int *count);
-int badge_ipc_request_set_display(const char *pkgname, const char *caller, unsigned int display_option);
-int badge_ipc_request_get_display(const char *pkgname, unsigned int *is_display);
+int badge_ipc_request_insert(const char *pkgname, const char *writable_pkg, const char *caller, uid_t uid);
+int badge_ipc_request_delete(const char *pkgname, const char *caller, uid_t uid);
+int badge_ipc_request_set_count(const char *pkgname, const char *caller, int count, uid_t uid);
+int badge_ipc_request_get_count(const char *pkgname, unsigned int *count, uid_t uid);
+int badge_ipc_request_set_display(const char *pkgname, const char *caller, unsigned int display_option, uid_t uid);
+int badge_ipc_request_get_display(const char *pkgname, unsigned int *is_display, uid_t uid);
 
 int badge_ipc_is_master_ready(void);
 int badge_ipc_add_deferred_task(void (*badge_add_deferred_task)(void *data), void *user_data);
 int badge_ipc_del_deferred_task(void (*badge_add_deferred_task)(void *data));
 
-int badge_ipc_setting_property_set(const char *pkgname, const char *property, const char *value);
-int badge_ipc_setting_property_get(const char *pkgname, const char *property, char **value);
+int badge_ipc_setting_property_set(const char *pkgname, const char *property, const char *value, uid_t uid);
+int badge_ipc_setting_property_get(const char *pkgname, const char *property, char **value, uid_t uid);
 
-int badge_ipc_request_get_list(badge_foreach_cb callback, void *data);
-int badge_ipc_request_is_existing(const char *pkgname, bool *existing);
+int badge_ipc_request_get_list(badge_foreach_cb callback, void *data, uid_t uid);
+int badge_ipc_request_is_existing(const char *pkgname, bool *existing, uid_t uid);
 
 #ifdef __cplusplus
 }

diff --git a/include/badge_setting.h b/include/badge_setting.h
index 7a037ed..3da78d0 100755 (executable)
--- a/include/badge_setting.h
+++ b/include/badge_setting.h
@@ -24,6 +24,7 @@
 #define __BADGE_SETTING_H__
 
 #include <stdbool.h>
+#include <sys/types.h>
 #include <badge_error.h>
 
 #ifdef __cplusplus
@@ -40,6 +41,8 @@ extern "C" {
  */
 int badge_setting_property_set(const char *pkgname, const char *property, const char *value);
 
+int badge_setting_property_set_for_uid(const char *pkgname, const char *property, const char *value, uid_t uid);
+
 /**
  * @brief This function gets badge property for designated package.
  * @param[in] pkgname The name of designated package
@@ -50,6 +53,7 @@ int badge_setting_property_set(const char *pkgname, const char *property, const
  */
 int badge_setting_property_get(const char *pkgname, const char *property, char **value);
 
+int badge_setting_property_get_for_uid(const char *pkgname, const char *property, char **value, uid_t uid);
 
 #ifdef __cplusplus
 }

diff --git a/include/badge_setting_service.h b/include/badge_setting_service.h
index 9ee0266..8d8ce57 100755 (executable)
--- a/include/badge_setting_service.h
+++ b/include/badge_setting_service.h
@@ -24,14 +24,15 @@
 #define __BADGE_SETTING_SERVICE_H__
 
 #include <stdbool.h>
+#include <sys/types.h>
 #include <badge_error.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-int badge_setting_db_set(const char *pkgname, const char *property, const char *value);
-int badge_setting_db_get(const char *pkgname, const char *property, char **value);
+int badge_setting_db_set(const char *pkgname, const char *property, const char *value, uid_t uid);
+int badge_setting_db_get(const char *pkgname, const char *property, char **value, uid_t uid);
 
 #ifdef __cplusplus
 }

diff --git a/src/badge.c b/src/badge.c
index 8c2a422..67b4df3 100755 (executable)
--- a/src/badge.c
+++ b/src/badge.c
@@ -22,6 +22,7 @@
 
 #include <stdlib.h>
 #include <stdarg.h>
+#include <unistd.h>
 #include <package_manager.h>
 
 #include "badge.h"
@@ -33,210 +34,73 @@
 EXPORT_API
 int badge_create(const char *pkgname, const char *writable_pkg)
 {
-       char *caller = NULL;
-       int err = BADGE_ERROR_NONE;
-
-       if (pkgname == NULL)
-               return BADGE_ERROR_INVALID_PARAMETER;
-
-
-       caller = _badge_get_pkgname_by_pid();
-       if (!caller) {
-               ERR("fail to get caller pkgname");
-               return BADGE_ERROR_PERMISSION_DENIED;
-       }
-
-       err = badge_ipc_request_insert(pkgname, writable_pkg, caller);
-
-       free(caller);
-       return err;
+       return badge_create_for_uid(pkgname, writable_pkg, getuid());
 }
 
 EXPORT_API
 int badge_new(const char *writable_app_id)
 {
-       char *caller = NULL;
-       int err = BADGE_ERROR_NONE;
-
-       caller = _badge_get_pkgname_by_pid();
-       if (!caller) {
-               ERR("fail to get caller pkgname");
-               return BADGE_ERROR_PERMISSION_DENIED;
-       }
-
-       err = badge_ipc_request_insert(caller, writable_app_id, caller);
-
-       free(caller);
-       return err;
+       return badge_new_for_uid(writable_app_id, getuid());
 }
 
 EXPORT_API
 int badge_add(const char *badge_app_id)
 {
-       char *caller = NULL;
-       int err = BADGE_ERROR_NONE;
-
-       caller = _badge_get_pkgname_by_pid();
-       if (!caller) {
-               ERR("fail to get caller pkgname");
-               return BADGE_ERROR_PERMISSION_DENIED;
-       }
-
-       if (badge_app_id == NULL) {
-               badge_app_id = caller;
-       } else {
-               int pkgmgr_ret  = PACKAGE_MANAGER_ERROR_NONE;
-               package_manager_compare_result_type_e compare_result = PACKAGE_MANAGER_COMPARE_MISMATCH;
-
-               pkgmgr_ret = package_manager_compare_app_cert_info(badge_app_id, caller, &compare_result);
-
-               if (pkgmgr_ret != PACKAGE_MANAGER_ERROR_NONE || compare_result != PACKAGE_MANAGER_COMPARE_MATCH) {
-                       err = BADGE_ERROR_INVALID_PACKAGE;
-                       goto out;
-               }
-       }
-
-       err = badge_ipc_request_insert(badge_app_id, caller, caller);
-
-out:
-       if (caller)
-               free(caller);
-       return err;
+       return badge_add_for_uid(badge_app_id, getuid());
 }
 
 EXPORT_API
 int badge_remove(const char *app_id)
 {
-       char *caller = NULL;
-       int result = BADGE_ERROR_NONE;
-
-       if (app_id == NULL)
-               return BADGE_ERROR_INVALID_PARAMETER;
-
-       caller = _badge_get_pkgname_by_pid();
-       if (!caller) {
-               ERR("fail to get caller pkgname");
-               result = BADGE_ERROR_PERMISSION_DENIED;
-               goto out;
-       }
-
-       result = badge_ipc_request_delete(app_id, caller);
-
-out:
-       if (caller)
-               free(caller);
-       return result;
+       return badge_remove_for_uid(app_id, getuid());
 }
 
 EXPORT_API
 int badge_is_existing(const char *app_id, bool *existing)
 {
-       return badge_ipc_request_is_existing(app_id, existing);
+       return badge_is_existing_for_uid(app_id, existing, getuid());
 }
 
 EXPORT_API
 int badge_foreach(badge_foreach_cb callback, void *user_data)
 {
-       int result = BADGE_ERROR_NONE;
-       result = badge_ipc_request_get_list(callback, user_data);
-       if (result == BADGE_ERROR_IO_ERROR)
-               result = BADGE_ERROR_FROM_DB;
-       return result;
+       return badge_foreach_for_uid(callback, user_data, getuid());
 }
 
 EXPORT_API
 int badge_set_count(const char *app_id, unsigned int count)
 {
-       char *caller = NULL;
-       int result = BADGE_ERROR_NONE;
-
-       if (app_id == NULL)
-               return BADGE_ERROR_INVALID_PARAMETER;
-
-       DBG("app_id %s, count %d", app_id, count);
-
-       caller = _badge_get_pkgname_by_pid();
-       if (!caller) {
-               ERR("fail to get caller pkgname");
-               result = BADGE_ERROR_PERMISSION_DENIED;
-               goto out;
-       }
-
-       result = badge_ipc_request_set_count(app_id, caller, count);
-out:
-       if (caller)
-               free(caller);
-       return result;
+       return badge_set_count_for_uid(app_id, count, getuid());
 }
 
 EXPORT_API
 int badge_get_count(const char *app_id, unsigned int *count)
 {
-       int result = BADGE_ERROR_NONE;
-       if (app_id == NULL || count == NULL)
-               return BADGE_ERROR_INVALID_PARAMETER;
-
-       result = badge_ipc_request_get_count(app_id, count);
-       if (result == BADGE_ERROR_IO_ERROR)
-               result = BADGE_ERROR_FROM_DB;
-
-       return result;
+       return badge_get_count_for_uid(app_id, count, getuid());
 }
 
 EXPORT_API
 int badge_set_display(const char *app_id, unsigned int is_display)
 {
-       char *caller = NULL;
-       int result = BADGE_ERROR_NONE;
-
-       if (app_id == NULL)
-               return BADGE_ERROR_INVALID_PARAMETER;
-
-       caller = _badge_get_pkgname_by_pid();
-       if (!caller) {
-               ERR("fail to get caller pkgname");
-               result = BADGE_ERROR_PERMISSION_DENIED;
-               goto out;
-       }
-
-       result = badge_ipc_request_set_display(app_id, caller, is_display);
-
-out:
-       if (caller)
-               free(caller);
-       return result;
+       return badge_set_display_for_uid(app_id, is_display, getuid());
 }
 
 EXPORT_API
 int badge_get_display(const char *app_id, unsigned int *is_display)
 {
-       int result = BADGE_ERROR_NONE;
-       if (app_id == NULL || is_display == NULL)
-               return BADGE_ERROR_INVALID_PARAMETER;
-
-       result = badge_ipc_request_get_display(app_id, is_display);
-       if (result == BADGE_ERROR_IO_ERROR)
-               result = BADGE_ERROR_FROM_DB;
-
-       return result;
+       return badge_get_display_for_uid(app_id, is_display, getuid());
 }
 
 EXPORT_API
 int badge_register_changed_cb(badge_change_cb callback, void *data)
 {
-       if (callback == NULL)
-               return BADGE_ERROR_INVALID_PARAMETER;
-
-       return _badge_register_changed_cb(callback, data);
+       return badge_register_changed_cb_for_uid(callback, data, getuid());
 }
 
 EXPORT_API
 int badge_unregister_changed_cb(badge_change_cb callback)
 {
-       if (callback == NULL)
-               return BADGE_ERROR_INVALID_PARAMETER;
-
-       return _badge_unregister_changed_cb(callback);
+       return badge_unregister_changed_cb_for_uid(callback, getuid());
 }
 
 EXPORT_API

diff --git a/src/badge_db.c b/src/badge_db.c
index 82d75f7..0f969ff 100755 (executable)
--- a/src/badge_db.c
+++ b/src/badge_db.c
@@ -35,17 +35,20 @@
 #define BADGE_DB_NAME ".badge.db"
 #define CREATE_BADGE_TABLE " \
 PRAGMA journal_mode = PERSIST; \
+PRAGMA synchronous = FULL; \
 create table if not exists badge_data ( \
+       uid INTEGER, \
        pkgname TEXT NOT NULL, \
        writable_pkgs TEXT, \
        badge INTEGER default 0, \
        rowid INTEGER PRIMARY KEY AUTOINCREMENT, \
-       UNIQUE (pkgname) \
+       UNIQUE (uid, pkgname) \
 ); \
 create table if not exists badge_option ( \
+       uid INTEGER, \
        pkgname TEXT NOT NULL, \
        display INTEGER default 1, \
-       UNIQUE (pkgname) \
+       UNIQUE (uid, pkgname) \
 ); "
 
 EXPORT_API
@@ -71,6 +74,7 @@ int badge_db_init()
        }
 
        r = sqlite3_exec(db, CREATE_BADGE_TABLE, NULL, NULL, &errmsg);
+
        if (r != SQLITE_OK) {
                ERR("query error(%d)(%s)", r, errmsg);
                sqlite3_free(errmsg);
@@ -83,23 +87,23 @@ int badge_db_init()
 }
 
 EXPORT_API
-int badge_db_is_existing(const char *pkgname, bool *existing)
+int badge_db_is_existing(const char *pkgname, bool *existing, uid_t uid)
 {
        int result = BADGE_ERROR_NONE;
-       result = _badge_is_existing(pkgname, existing);
+       result = _badge_is_existing(pkgname, existing, uid);
        return result;
 }
 
 EXPORT_API
-int badge_db_get_list(GList **badge_list)
+int badge_db_get_list(GList **badge_list, uid_t uid)
 {
        int result = BADGE_ERROR_NONE;
-       result = _badge_get_list(badge_list);
+       result = _badge_get_list(badge_list, uid);
        return result;
 }
 
 EXPORT_API
-int badge_db_insert(const char *pkgname, const char *writable_pkg, const char *caller)
+int badge_db_insert(const char *pkgname, const char *writable_pkg, const char *caller, uid_t uid)
 {
        int err = BADGE_ERROR_NONE;
        badge_h *badge = NULL;
@@ -126,7 +130,7 @@ int badge_db_insert(const char *pkgname, const char *writable_pkg, const char *c
        }
        free(pkgs);
 
-       err = _badge_insert(badge);
+       err = _badge_insert(badge, uid);
        if (err != BADGE_ERROR_NONE) {
                ERR("fail to _badge_insert : %d", err);
                _badge_free(badge);
@@ -139,51 +143,51 @@ int badge_db_insert(const char *pkgname, const char *writable_pkg, const char *c
 }
 
 EXPORT_API
-int badge_db_delete(const char *pkgname, const char *caller)
+int badge_db_delete(const char *pkgname, const char *caller, uid_t uid)
 {
        int result = BADGE_ERROR_NONE;
 
-       result = _badge_remove(caller, pkgname);
+       result = _badge_remove(caller, pkgname, uid);
 
        return result;
 }
 
 EXPORT_API
-int badge_db_set_count(const char *pkgname, const char *caller, unsigned int count)
+int badge_db_set_count(const char *pkgname, const char *caller, unsigned int count, uid_t uid)
 {
        int result = BADGE_ERROR_NONE;
 
-       result = _badge_set_count(caller, pkgname, count);
+       result = _badge_set_count(caller, pkgname, count, uid);
 
        return result;
 }
 
 EXPORT_API
-int badge_db_get_count(const char *pkgname, unsigned int *count)
+int badge_db_get_count(const char *pkgname, unsigned int *count, uid_t uid)
 {
        int result = BADGE_ERROR_NONE;
 
-       result = _badge_get_count(pkgname, count);
+       result = _badge_get_count(pkgname, count, uid);
 
        return result;
 }
 
 EXPORT_API
-int badge_db_set_display_option(const char *pkgname, const char *caller, unsigned int is_display)
+int badge_db_set_display_option(const char *pkgname, unsigned int is_display, uid_t uid)
 {
        int result = BADGE_ERROR_NONE;
 
-       result = _badge_set_display(pkgname, is_display);
+       result = _badge_set_display(pkgname, is_display, uid);
 
        return result;
 }
 
 EXPORT_API
-int badge_db_get_display_option(const char *pkgname, unsigned int *is_display)
+int badge_db_get_display_option(const char *pkgname, unsigned int *is_display, uid_t uid)
 {
        int result = BADGE_ERROR_NONE;
 
-       result = _badge_get_display(pkgname, is_display);
+       result = _badge_get_display(pkgname, is_display, uid);
 
        return result;
 }

diff --git a/src/badge_internal.c b/src/badge_internal.c
index f576886..e85fe0f 100755 (executable)
--- a/src/badge_internal.c
+++ b/src/badge_internal.c
@@ -26,6 +26,7 @@
 #include <fcntl.h>
 #include <unistd.h>
 #include <glib.h>
+#include <gio/gio.h>
 #include <dbus/dbus.h>
 #include <dbus/dbus-glib-lowlevel.h>
 #include <aul.h>
@@ -58,7 +59,7 @@ struct _badge_cb_data {
        void *data;
 };
 
-static GList *g_badge_cb_list;
+static GHashTable *_badge_cb_hash = NULL;
 
 static inline long _get_max_len(void)
 {
@@ -126,7 +127,7 @@ char *_badge_get_pkgname_by_pid(void)
 }
 
 static int _badge_check_data_inserted(const char *pkgname,
-                                       sqlite3 *db)
+                                       sqlite3 *db, uid_t uid)
 {
        sqlite3_stmt *stmt = NULL;
        int count = 0;
@@ -141,8 +142,8 @@ static int _badge_check_data_inserted(const char *pkgname,
                return BADGE_ERROR_INVALID_PARAMETER;
 
        sqlbuf = sqlite3_mprintf("SELECT count(*) FROM %q WHERE " \
-                        "pkgname = %Q",
-                        BADGE_TABLE_NAME, pkgname);
+                        "pkgname = %Q AND uid = %d",
+                        BADGE_TABLE_NAME, pkgname, uid);
 
        if (!sqlbuf) {
                /* LCOV_EXCL_START */
@@ -185,7 +186,7 @@ free_and_return:
 }
 
 static int _badge_check_option_inserted(const char *pkgname,
-                                       sqlite3 *db)
+                                       sqlite3 *db, uid_t uid)
 {
        sqlite3_stmt *stmt = NULL;
        int count = 0;
@@ -200,8 +201,8 @@ static int _badge_check_option_inserted(const char *pkgname,
                return BADGE_ERROR_INVALID_PARAMETER;
 
        sqlbuf = sqlite3_mprintf("SELECT count(*) FROM %q WHERE " \
-                        "pkgname = %Q",
-                        BADGE_OPTION_TABLE_NAME, pkgname);
+                        "pkgname = %Q AND uid = %d",
+                        BADGE_OPTION_TABLE_NAME, pkgname, uid);
 
        if (!sqlbuf) {
                /* LCOV_EXCL_START */
@@ -263,7 +264,7 @@ static int _is_same_certinfo(const char *caller, const char *pkgname)
 }
 
 static int _badge_check_writable(const char *caller,
-                       const char *pkgname, sqlite3 *db)
+                       const char *pkgname, sqlite3 *db, uid_t uid)
 {
        sqlite3_stmt *stmt = NULL;
        int count = 0;
@@ -288,9 +289,10 @@ static int _badge_check_writable(const char *caller,
                return BADGE_ERROR_NONE;
 
        sqlbuf = sqlite3_mprintf("SELECT COUNT(*) FROM %q WHERE " \
-                        "pkgname = %Q AND writable_pkgs LIKE '%%%q%%'",
+                        "pkgname = %Q AND writable_pkgs LIKE '%%%q%%'" \
+                        "AND uid = %d",
                         BADGE_TABLE_NAME,
-                        pkgname, caller);
+                        pkgname, caller, uid);
        if (!sqlbuf) {
                ERR("fail to alloc sql query");
                return BADGE_ERROR_OUT_OF_MEMORY;
@@ -326,7 +328,7 @@ free_and_return:
        /* LCOV_EXCL_STOP */
 }
 
-int _badge_is_existing(const char *pkgname, bool *existing)
+int _badge_is_existing(const char *pkgname, bool *existing, uid_t uid)
 {
        sqlite3 *db = NULL;
        int sqlret;
@@ -349,7 +351,7 @@ int _badge_is_existing(const char *pkgname, bool *existing)
                /* LCOV_EXCL_STOP */
        }
 
-       result = _badge_check_data_inserted(pkgname, db);
+       result = _badge_check_data_inserted(pkgname, db, uid);
        if (result == BADGE_ERROR_ALREADY_EXIST) {
                *existing = TRUE;
                result = BADGE_ERROR_NONE;
@@ -365,7 +367,7 @@ int _badge_is_existing(const char *pkgname, bool *existing)
        return result;
 }
 
-int _badge_get_list(GList **badge_list)
+int _badge_get_list(GList **badge_list, uid_t uid)
 {
        sqlite3 *db = NULL;
        int result = BADGE_ERROR_NONE;
@@ -384,8 +386,8 @@ int _badge_get_list(GList **badge_list)
                /* LCOV_EXCL_STOP */
        }
 
-       sqlbuf = sqlite3_mprintf("SELECT pkgname, badge FROM %q",
-                               BADGE_TABLE_NAME);
+       sqlbuf = sqlite3_mprintf("SELECT pkgname, badge FROM %q WHERE uid = %d",
+                               BADGE_TABLE_NAME, uid);
        if (!sqlbuf) {
                /* LCOV_EXCL_START */
                ERR("fail to alloc sql query");
@@ -453,7 +455,7 @@ free_and_return:
 }
 
 /* LCOV_EXCL_START */
-int _badge_foreach_existed(badge_foreach_cb callback, void *data)
+int _badge_foreach_existed(badge_foreach_cb callback, void *data, uid_t uid)
 {
        sqlite3 *db = NULL;
        int result = BADGE_ERROR_NONE;
@@ -472,8 +474,8 @@ int _badge_foreach_existed(badge_foreach_cb callback, void *data)
                return BADGE_ERROR_FROM_DB;
        }
 
-       sqlbuf = sqlite3_mprintf("SELECT pkgname, badge FROM %q",
-                               BADGE_TABLE_NAME);
+       sqlbuf = sqlite3_mprintf("SELECT pkgname, badge FROM %q WHERE uid = %d",
+                               BADGE_TABLE_NAME, uid);
        if (!sqlbuf) {
                ERR("fail to alloc sql query");
                result = BADGE_ERROR_OUT_OF_MEMORY;
@@ -532,7 +534,7 @@ free_and_return:
 }
 /* LCOV_EXCL_STOP */
 
-int _badge_insert(badge_h *badge)
+int _badge_insert(badge_h *badge, uid_t uid)
 {
        sqlite3 *db = NULL;
        int sqlret;
@@ -552,7 +554,7 @@ int _badge_insert(badge_h *badge)
        }
 
        /* Check pkgname & id */
-       ret = _badge_check_data_inserted(badge->pkgname, db);
+       ret = _badge_check_data_inserted(badge->pkgname, db, uid);
        if (ret != BADGE_ERROR_NOT_EXIST) {
                /* LCOV_EXCL_START */
                result = ret;
@@ -562,11 +564,12 @@ int _badge_insert(badge_h *badge)
 
        sqlbuf = sqlite3_mprintf("INSERT INTO %q " \
                        "(pkgname, " \
-                       "writable_pkgs) " \
-                       "VALUES "
-                       "(%Q, %Q);",
+                       "writable_pkgs, " \
+                       "uid) "\
+                       "VALUES " \
+                       "(%Q, %Q, %d);",
                         BADGE_TABLE_NAME,
-                        badge->pkgname, badge->writable_pkgs);
+                        badge->pkgname, badge->writable_pkgs, uid);
        if (!sqlbuf) {
                /* LCOV_EXCL_START */
                ERR("fail to alloc query");
@@ -586,18 +589,19 @@ int _badge_insert(badge_h *badge)
        }
 
        /* inserting badge options */
-       ret = _badge_check_option_inserted(badge->pkgname, db);
+       ret = _badge_check_option_inserted(badge->pkgname, db, uid);
        if (ret != BADGE_ERROR_NOT_EXIST) {
                result = ret;
                goto return_close_db;
        }
 
        sqlbuf = sqlite3_mprintf("INSERT INTO %q " \
-                       "(pkgname) " \
+                       "(pkgname, " \
+                       "uid) " \
                        "VALUES "
-                       "(%Q);",
+                       "(%Q, %d);",
                        BADGE_OPTION_TABLE_NAME,
-                        badge->pkgname);
+                        badge->pkgname, uid);
        if (!sqlbuf) {
                /* LCOV_EXCL_START */
                ERR("fail to alloc query");
@@ -627,7 +631,7 @@ return_close_db:
        return result;
 }
 
-int _badge_remove(const char *caller, const char *pkgname)
+int _badge_remove(const char *caller, const char *pkgname, uid_t uid)
 {
        int ret = BADGE_ERROR_NONE;
        int result = BADGE_ERROR_NONE;
@@ -649,20 +653,20 @@ int _badge_remove(const char *caller, const char *pkgname)
                /* LCOV_EXCL_STOP */
        }
 
-       ret = _badge_check_data_inserted(pkgname, db);
+       ret = _badge_check_data_inserted(pkgname, db, uid);
        if (ret != BADGE_ERROR_ALREADY_EXIST) {
                result = ret;
                goto return_close_db;
        }
 
-       ret = _badge_check_writable(caller, pkgname, db);
+       ret = _badge_check_writable(caller, pkgname, db, uid);
        if (ret != BADGE_ERROR_NONE) {
                result = ret;
                goto return_close_db;
        }
 
-       sqlbuf = sqlite3_mprintf("DELETE FROM %q WHERE pkgname = %Q",
-                        BADGE_TABLE_NAME, pkgname);
+       sqlbuf = sqlite3_mprintf("DELETE FROM %q WHERE pkgname = %Q AND uid = %d",
+                        BADGE_TABLE_NAME, pkgname, uid);
        if (!sqlbuf) {
                /* LCOV_EXCL_START */
                ERR("fail to alloc query");
@@ -680,14 +684,14 @@ int _badge_remove(const char *caller, const char *pkgname)
        }
 
        /* treating option table */
-       ret = _badge_check_option_inserted(pkgname, db);
+       ret = _badge_check_option_inserted(pkgname, db, uid);
        if (ret != BADGE_ERROR_ALREADY_EXIST) {
                result = ret;
                goto return_close_db;
        }
 
-       sqlbuf = sqlite3_mprintf("DELETE FROM %q WHERE pkgname = %Q",
-                       BADGE_OPTION_TABLE_NAME, pkgname);
+       sqlbuf = sqlite3_mprintf("DELETE FROM %q WHERE pkgname = %Q AND uid = %d",
+                       BADGE_OPTION_TABLE_NAME, pkgname, uid);
        if (!sqlbuf) {
                /* LCOV_EXCL_START */
                ERR("fail to alloc query");
@@ -718,7 +722,7 @@ return_close_db:
 }
 
 int _badge_set_count(const char *caller, const char *pkgname,
-                       unsigned int count)
+                       unsigned int count, uid_t uid)
 {
        int ret = BADGE_ERROR_NONE;
        int result = BADGE_ERROR_NONE;
@@ -740,21 +744,21 @@ int _badge_set_count(const char *caller, const char *pkgname,
                /* LCOV_EXCL_STOP */
        }
 
-       ret = _badge_check_data_inserted(pkgname, db);
+       ret = _badge_check_data_inserted(pkgname, db, uid);
        if (ret != BADGE_ERROR_ALREADY_EXIST) {
                result = ret;
                goto return_close_db;
        }
 
-       ret = _badge_check_writable(caller, pkgname, db);
+       ret = _badge_check_writable(caller, pkgname, db, uid);
        if (ret != BADGE_ERROR_NONE) {
                result = ret;
                goto return_close_db;
        }
 
        sqlbuf = sqlite3_mprintf("UPDATE %q SET badge = %d " \
-                       "WHERE pkgname = %Q",
-                        BADGE_TABLE_NAME, count, pkgname);
+                       "WHERE pkgname = %Q AND uid = %d",
+                        BADGE_TABLE_NAME, count, pkgname, uid);
        if (!sqlbuf) {
                /* LCOV_EXCL_START */
                ERR("fail to alloc query");
@@ -784,7 +788,7 @@ return_close_db:
        return result;
 }
 
-int _badge_get_count(const char *pkgname, unsigned int *count)
+int _badge_get_count(const char *pkgname, unsigned int *count, uid_t uid)
 {
        int ret = BADGE_ERROR_NONE;
        int result = BADGE_ERROR_NONE;
@@ -810,15 +814,15 @@ int _badge_get_count(const char *pkgname, unsigned int *count)
                /* LCOV_EXCL_STOP */
        }
 
-       ret = _badge_check_data_inserted(pkgname, db);
+       ret = _badge_check_data_inserted(pkgname, db, uid);
        if (ret != BADGE_ERROR_ALREADY_EXIST) {
                result = ret;
                goto return_close_db;
        }
 
        sqlbuf = sqlite3_mprintf("SELECT badge FROM %q " \
-                       "WHERE pkgname = %Q",
-                        BADGE_TABLE_NAME, pkgname);
+                       "WHERE pkgname = %Q AND uid = %d",
+                        BADGE_TABLE_NAME, pkgname, uid);
        if (!sqlbuf) {
                /* LCOV_EXCL_START */
                ERR("fail to alloc query");
@@ -857,8 +861,7 @@ return_close_db:
        return result;
 }
 
-int _badge_set_display(const char *pkgname,
-                       unsigned int is_display)
+int _badge_set_display(const char *pkgname, unsigned int is_display, uid_t uid)
 {
        int ret = BADGE_ERROR_NONE;
        int result = BADGE_ERROR_NONE;
@@ -880,17 +883,17 @@ int _badge_set_display(const char *pkgname,
                /* LCOV_EXCL_STOP */
        }
 
-       ret = _badge_check_data_inserted(pkgname, db);
+       ret = _badge_check_data_inserted(pkgname, db, uid);
        if (ret != BADGE_ERROR_ALREADY_EXIST) {
                result = ret;
                goto return_close_db;
        }
 
-       ret = _badge_check_option_inserted(pkgname, db);
+       ret = _badge_check_option_inserted(pkgname, db, uid);
        if (ret == BADGE_ERROR_ALREADY_EXIST) {
                sqlbuf = sqlite3_mprintf("UPDATE %q SET display = %d " \
-                               "WHERE pkgname = %Q",
-                               BADGE_OPTION_TABLE_NAME, is_display, pkgname);
+                               "WHERE pkgname = %Q AND uid = %d",
+                               BADGE_OPTION_TABLE_NAME, is_display, pkgname, uid);
                if (!sqlbuf) {
                        /* LCOV_EXCL_START */
                        ERR("fail to alloc query");
@@ -912,11 +915,12 @@ int _badge_set_display(const char *pkgname,
        } else if (ret == BADGE_ERROR_NOT_EXIST) {
                sqlbuf = sqlite3_mprintf("INSERT INTO %q " \
                                "(pkgname, " \
-                               "display) " \
+                               "display, " \
+                               "uid) " \
                                "VALUES "
-                               "(%Q, %d);",
+                               "(%Q, %d, %d);",
                                BADGE_OPTION_TABLE_NAME,
-                               pkgname, is_display);
+                               pkgname, is_display, uid);
                if (!sqlbuf) {
                        /* LCOV_EXCL_START */
                        ERR("fail to alloc query");
@@ -950,7 +954,7 @@ return_close_db:
        return result;
 }
 
-int _badge_get_display(const char *pkgname, unsigned int *is_display)
+int _badge_get_display(const char *pkgname, unsigned int *is_display, uid_t uid)
 {
        int ret = BADGE_ERROR_NONE;
        int result = BADGE_ERROR_NONE;
@@ -976,7 +980,7 @@ int _badge_get_display(const char *pkgname, unsigned int *is_display)
                /* LCOV_EXCL_STOP */
        }
 
-       ret = _badge_check_option_inserted(pkgname, db);
+       ret = _badge_check_option_inserted(pkgname, db, uid);
        if (ret != BADGE_ERROR_ALREADY_EXIST) {
                if (ret == BADGE_ERROR_NOT_EXIST)
                        *is_display = 1;
@@ -986,8 +990,8 @@ int _badge_get_display(const char *pkgname, unsigned int *is_display)
        }
 
        sqlbuf = sqlite3_mprintf("SELECT display FROM %q " \
-                       "WHERE pkgname = %Q",
-                       BADGE_OPTION_TABLE_NAME, pkgname);
+                       "WHERE pkgname = %Q AND uid = %d",
+                       BADGE_OPTION_TABLE_NAME, pkgname, uid);
        if (!sqlbuf) {
                /* LCOV_EXCL_START */
                ERR("fail to alloc query");
@@ -1027,30 +1031,40 @@ return_close_db:
 }
 
 void badge_changed_cb_call(unsigned int action, const char *pkgname,
-                       unsigned int count)
+                       unsigned int count, uid_t uid)
 {
-       DBG("call badge_change_cb");
-       GList *list = g_badge_cb_list;
+       GList *badge_cb_list = NULL;
        struct _badge_cb_data *bd = NULL;
 
-       while (list) {
-               bd = g_list_nth_data(list, 0);
-               if (!bd)
-                       continue;
 
-               if (bd->callback) {
+       DBG("call badge_change_cb");
+
+       if (_badge_cb_hash == NULL)
+               return;
+
+       badge_cb_list = (GList *)g_hash_table_lookup(_badge_cb_hash, GUINT_TO_POINTER(uid));
+
+       if (badge_cb_list == NULL) {
+               ERR("invalid data");
+               return;
+       }
+
+       badge_cb_list = g_list_first(badge_cb_list);
+
+       for (; badge_cb_list != NULL; badge_cb_list = badge_cb_list->next) {
+               bd = badge_cb_list->data;
+
+               if (bd != NULL && bd->callback != NULL) {
                        DBG("call badge_change_cb : action %d, pkgname %s, count %d",
-                                       action, pkgname, count);
+                           action, pkgname, count);
                        bd->callback(action, pkgname, count, bd->data);
                }
-
-               list = g_list_next(list);
        }
 }
 
-static int _badge_changed_monitor_init()
+static int _badge_changed_monitor_init(uid_t uid)
 {
-       return badge_ipc_monitor_init();
+       return badge_ipc_monitor_init(uid);
 }
 
 static void _badge_chanaged_monitor_fini()
@@ -1072,70 +1086,90 @@ static gint _badge_data_compare(gconstpointer a, gconstpointer b)
        return 1;
 }
 
-int _badge_register_changed_cb(badge_change_cb callback, void *data)
+int _badge_register_changed_cb(badge_change_cb callback, void *data, uid_t uid)
 {
        struct _badge_cb_data *bd = NULL;
-       GList *found = NULL;
+       GList *badge_cb_list = NULL;
+       GList *badge_found_list = NULL;
        int ret;
 
-       if (!callback)
+       if (callback == NULL)
                return BADGE_ERROR_INVALID_PARAMETER;
 
-       found = g_list_find_custom(g_badge_cb_list, (gconstpointer)callback,
-                       _badge_data_compare);
+       if (_badge_cb_hash == NULL)
+               _badge_cb_hash = g_hash_table_new(g_direct_hash, g_direct_equal);
 
-       if (found) {
-               bd = g_list_nth_data(found, 0);
-               bd->data = data;
-       } else {
-
-               bd = malloc(sizeof(struct _badge_cb_data));
-               if (!bd)
-                       return BADGE_ERROR_OUT_OF_MEMORY;
+       bd = (struct _badge_cb_data *)malloc(sizeof(struct _badge_cb_data));
+       if (bd == NULL)
+               return BADGE_ERROR_OUT_OF_MEMORY;
 
+       bd->callback = callback;
+       bd->data = data;
 
-               bd->callback = callback;
-               bd->data = data;
+       badge_cb_list = (GList *)g_hash_table_lookup(_badge_cb_hash, GUINT_TO_POINTER(uid));
 
-               g_badge_cb_list = g_list_append(g_badge_cb_list, bd);
+       if (badge_cb_list == NULL) {
+               badge_cb_list = g_list_append(badge_cb_list, bd);
+               g_hash_table_insert(_badge_cb_hash, GUINT_TO_POINTER(uid), badge_cb_list);
+       } else {
+               badge_found_list = g_list_find_custom(badge_cb_list, (gconstpointer)callback,
+                                                    _badge_data_compare);
+               if (badge_found_list) {
+                       bd = g_list_nth_data(badge_found_list, 0);
+                       bd->data = data;
+               } else {
+                       badge_cb_list = g_list_append(badge_cb_list, bd);
+               }
        }
 
-       ret = _badge_changed_monitor_init();
+       ret = _badge_changed_monitor_init(uid);
        if (ret != BADGE_ERROR_NONE) {
                /* LCOV_EXCL_START */
                ERR("badge_ipc_monitor_init err : %d", ret);
-               _badge_unregister_changed_cb(callback);
+               _badge_unregister_changed_cb(callback, uid);
                return ret;
                /* LCOV_EXCL_STOP */
        }
        return BADGE_ERROR_NONE;
 }
 
-int _badge_unregister_changed_cb(badge_change_cb callback)
+int _badge_unregister_changed_cb(badge_change_cb callback, uid_t uid)
 {
-       GList *found = NULL;
+       GList *badge_cb_list = NULL;
+       GList *badge_delete_list = NULL;
        struct _badge_cb_data *bd = NULL;
 
-       if (!callback)
+       if (callback == NULL)
                return BADGE_ERROR_INVALID_PARAMETER;
 
-       found = g_list_find_custom(g_badge_cb_list, (gconstpointer)callback,
+       if (_badge_cb_hash == NULL)
+               return BADGE_ERROR_INVALID_PARAMETER;
+
+       badge_cb_list = (GList *)g_hash_table_lookup(_badge_cb_hash, GUINT_TO_POINTER(uid));
+
+       if (badge_cb_list == NULL)
+               return BADGE_ERROR_INVALID_PARAMETER;
+
+       badge_delete_list = g_list_find_custom(badge_cb_list, (gconstpointer)callback,
                                _badge_data_compare);
 
-       if (found) {
-               bd = g_list_nth_data(found, 0);
-               g_badge_cb_list = g_list_delete_link(g_badge_cb_list, found);
+       if (badge_delete_list) {
+               bd = g_list_nth_data(badge_delete_list, 0);
+               badge_cb_list = g_list_delete_link(badge_cb_list, badge_delete_list);
                free(bd);
+       } else {
+               return BADGE_ERROR_INVALID_PARAMETER;
        }
 
-       if (!g_badge_cb_list)
-               _badge_chanaged_monitor_fini();
-
-       if (found != NULL)
-               return BADGE_ERROR_NONE;
+       if (badge_cb_list == NULL)
+               g_hash_table_steal(_badge_cb_hash, GUINT_TO_POINTER(uid));
        else
-               return BADGE_ERROR_INVALID_PARAMETER;
+               g_hash_table_replace(_badge_cb_hash, GUINT_TO_POINTER(uid), badge_cb_list);
 
+       if (g_hash_table_size(_badge_cb_hash) == 0)
+               _badge_chanaged_monitor_fini();
+
+       return BADGE_ERROR_NONE;
 }
 
 int _badge_free(badge_h *badge)
@@ -1353,3 +1387,213 @@ char *_badge_pkgs_new_valist(int *err, const char *pkg1, va_list args)
        return result;
 }
 /* LCOV_EXCL_STOP */
+
+
+EXPORT_API
+int badge_create_for_uid(const char *pkgname, const char *writable_pkg, uid_t uid)
+{
+       char *caller = NULL;
+       int err = BADGE_ERROR_NONE;
+
+       if (pkgname == NULL)
+               return BADGE_ERROR_INVALID_PARAMETER;
+
+
+       caller = _badge_get_pkgname_by_pid();
+       if (!caller) {
+               ERR("fail to get caller pkgname");
+               return BADGE_ERROR_PERMISSION_DENIED;
+       }
+
+       err = badge_ipc_request_insert(pkgname, writable_pkg, caller, uid);
+
+       free(caller);
+       return err;
+}
+
+EXPORT_API
+int badge_new_for_uid(const char *writable_app_id, uid_t uid)
+{
+       char *caller = NULL;
+       int err = BADGE_ERROR_NONE;
+
+       caller = _badge_get_pkgname_by_pid();
+       if (!caller) {
+               ERR("fail to get caller pkgname");
+               return BADGE_ERROR_PERMISSION_DENIED;
+       }
+
+       err = badge_ipc_request_insert(caller, writable_app_id, caller, uid);
+
+       free(caller);
+       return err;
+}
+
+EXPORT_API
+int badge_add_for_uid(const char *badge_app_id, uid_t uid)
+{
+       char *caller = NULL;
+       int err = BADGE_ERROR_NONE;
+
+       caller = _badge_get_pkgname_by_pid();
+       if (!caller) {
+               ERR("fail to get caller pkgname");
+               return BADGE_ERROR_PERMISSION_DENIED;
+       }
+
+       if (badge_app_id == NULL) {
+               badge_app_id = caller;
+       } else {
+               int pkgmgr_ret  = PACKAGE_MANAGER_ERROR_NONE;
+               package_manager_compare_result_type_e compare_result = PACKAGE_MANAGER_COMPARE_MISMATCH;
+
+               pkgmgr_ret = package_manager_compare_app_cert_info(badge_app_id, caller, &compare_result);
+
+               if (pkgmgr_ret != PACKAGE_MANAGER_ERROR_NONE || compare_result != PACKAGE_MANAGER_COMPARE_MATCH) {
+                       err = BADGE_ERROR_INVALID_PACKAGE;
+                       goto out;
+               }
+       }
+
+       err = badge_ipc_request_insert(badge_app_id, caller, caller, uid);
+
+out:
+       if (caller)
+               free(caller);
+       return err;
+}
+
+EXPORT_API
+int badge_remove_for_uid(const char *app_id, uid_t uid)
+{
+       char *caller = NULL;
+       int result = BADGE_ERROR_NONE;
+
+       if (app_id == NULL)
+               return BADGE_ERROR_INVALID_PARAMETER;
+
+       caller = _badge_get_pkgname_by_pid();
+       if (!caller) {
+               ERR("fail to get caller pkgname");
+               result = BADGE_ERROR_PERMISSION_DENIED;
+               goto out;
+       }
+
+       result = badge_ipc_request_delete(app_id, caller, uid);
+
+out:
+       if (caller)
+               free(caller);
+       return result;
+}
+
+EXPORT_API
+int badge_is_existing_for_uid(const char *app_id, bool *existing, uid_t uid)
+{
+       return badge_ipc_request_is_existing(app_id, existing, uid);
+}
+
+EXPORT_API
+int badge_foreach_for_uid(badge_foreach_cb callback, void *user_data, uid_t uid)
+{
+       int result = BADGE_ERROR_NONE;
+       result = badge_ipc_request_get_list(callback, user_data, uid);
+       if (result == BADGE_ERROR_IO_ERROR)
+               result = BADGE_ERROR_FROM_DB;
+       return result;
+}
+
+EXPORT_API
+int badge_set_count_for_uid(const char *app_id, unsigned int count, uid_t uid)
+{
+       char *caller = NULL;
+       int result = BADGE_ERROR_NONE;
+
+       if (app_id == NULL)
+               return BADGE_ERROR_INVALID_PARAMETER;
+
+       DBG("app_id %s, count %d", app_id, count);
+
+       caller = _badge_get_pkgname_by_pid();
+       if (!caller) {
+               ERR("fail to get caller pkgname");
+               result = BADGE_ERROR_PERMISSION_DENIED;
+               goto out;
+       }
+
+       result = badge_ipc_request_set_count(app_id, caller, count, uid);
+out:
+       if (caller)
+               free(caller);
+       return result;
+}
+
+EXPORT_API
+int badge_get_count_for_uid(const char *app_id, unsigned int *count, uid_t uid)
+{
+       int result = BADGE_ERROR_NONE;
+       if (app_id == NULL || count == NULL)
+               return BADGE_ERROR_INVALID_PARAMETER;
+
+       result = badge_ipc_request_get_count(app_id, count, uid);
+       if (result == BADGE_ERROR_IO_ERROR)
+               result = BADGE_ERROR_FROM_DB;
+
+       return result;
+}
+
+EXPORT_API
+int badge_set_display_for_uid(const char *app_id, unsigned int is_display, uid_t uid)
+{
+       char *caller = NULL;
+       int result = BADGE_ERROR_NONE;
+
+       if (app_id == NULL)
+               return BADGE_ERROR_INVALID_PARAMETER;
+
+       caller = _badge_get_pkgname_by_pid();
+       if (!caller) {
+               ERR("fail to get caller pkgname");
+               result = BADGE_ERROR_PERMISSION_DENIED;
+               goto out;
+       }
+
+       result = badge_ipc_request_set_display(app_id, caller, is_display, uid);
+
+out:
+       if (caller)
+               free(caller);
+       return result;
+}
+
+EXPORT_API
+int badge_get_display_for_uid(const char *app_id, unsigned int *is_display, uid_t uid)
+{
+       int result = BADGE_ERROR_NONE;
+       if (app_id == NULL || is_display == NULL)
+               return BADGE_ERROR_INVALID_PARAMETER;
+
+       result = badge_ipc_request_get_display(app_id, is_display, uid);
+       if (result == BADGE_ERROR_IO_ERROR)
+               result = BADGE_ERROR_FROM_DB;
+
+       return result;
+}
+
+EXPORT_API
+int badge_register_changed_cb_for_uid(badge_change_cb callback, void *data, uid_t uid)
+{
+       if (callback == NULL)
+               return BADGE_ERROR_INVALID_PARAMETER;
+
+       return _badge_register_changed_cb(callback, data, uid);
+}
+
+EXPORT_API
+int badge_unregister_changed_cb_for_uid(badge_change_cb callback, uid_t uid)
+{
+       if (callback == NULL)
+               return BADGE_ERROR_INVALID_PARAMETER;
+
+       return _badge_unregister_changed_cb(callback, uid);
+}

diff --git a/src/badge_ipc.c b/src/badge_ipc.c
index 551aa91..1e1da76 100755 (executable)
--- a/src/badge_ipc.c
+++ b/src/badge_ipc.c
@@ -23,6 +23,7 @@
 #include <stdlib.h>
 #include <stdarg.h>
 #include <gio/gio.h>
+#include <unistd.h>
 
 #include <vconf.h>
 
@@ -216,9 +217,10 @@ static void _do_deferred_task(void)
 static void _insert_badge_notify(GVariant *parameters)
 {
        char *pkgname = NULL;
+       uid_t uid;
 
-       g_variant_get(parameters, "(&s)", &pkgname);
-       badge_changed_cb_call(BADGE_ACTION_CREATE, pkgname, 0);
+       g_variant_get(parameters, "(&si)", &pkgname, &uid);
+       badge_changed_cb_call(BADGE_ACTION_CREATE, pkgname, 0, uid);
 }
 /* LCOV_EXCL_STOP */
 
@@ -226,9 +228,10 @@ static void _insert_badge_notify(GVariant *parameters)
 static void _delete_badge_notify(GVariant *parameters)
 {
        char *pkgname = NULL;
+       uid_t uid;
 
-       g_variant_get(parameters, "(&s)", &pkgname);
-       badge_changed_cb_call(BADGE_ACTION_REMOVE, pkgname, 0);
+       g_variant_get(parameters, "(&si)", &pkgname, &uid);
+       badge_changed_cb_call(BADGE_ACTION_REMOVE, pkgname, 0, uid);
 }
 /* LCOV_EXCL_STOP */
 
@@ -237,9 +240,10 @@ static void _set_badge_count_notify(GVariant *parameters)
 {
        char *pkgname = NULL;
        int count = 0;
+       uid_t uid;
 
-       g_variant_get(parameters, "(&si)", &pkgname, &count);
-       badge_changed_cb_call(BADGE_ACTION_UPDATE, pkgname, count);
+       g_variant_get(parameters, "(&sii)", &pkgname, &count, &uid);
+       badge_changed_cb_call(BADGE_ACTION_UPDATE, pkgname, count, uid);
 }
 /* LCOV_EXCL_STOP */
 
@@ -248,9 +252,10 @@ static void _set_disp_option_notify(GVariant *parameters)
 {
        char *pkgname = NULL;
        int is_display = 0;
+       uid_t uid;
 
-       g_variant_get(parameters, "(&si)", &pkgname, &is_display);
-       badge_changed_cb_call(BADGE_ACTION_CHANGED_DISPLAY, pkgname, is_display);
+       g_variant_get(parameters, "(&sii)", &pkgname, &is_display, &uid);
+       badge_changed_cb_call(BADGE_ACTION_CHANGED_DISPLAY, pkgname, is_display, uid);
 }
 /* LCOV_EXCL_STOP */
 
@@ -391,26 +396,26 @@ static int _send_sync_badge(GVariant *body, GDBusMessage **reply, char *cmd)
 
 }
 
-static int _send_service_register()
+static int _send_service_register(uid_t uid)
 {
        GDBusMessage *reply = NULL;
        int result;
 
-       result = _send_sync_badge(g_variant_new("(i)", getuid()), &reply, "badge_service_register");
+       result = _send_sync_badge(g_variant_new("(i)", uid), &reply, "badge_service_register");
 
        if (reply)
                g_object_unref(reply);
 
-       badge_changed_cb_call(BADGE_ACTION_SERVICE_READY, NULL, 0);
+       badge_changed_cb_call(BADGE_ACTION_SERVICE_READY, NULL, 0, uid);
        DBG("_send_service_register dones");
        return result;
 }
 
-static int _ipc_monitor_register(void)
+static int _ipc_monitor_register(uid_t uid)
 {
        DBG("register a service\n");
 
-       return  _send_service_register();
+       return  _send_service_register(uid);
 }
 
 /* LCOV_EXCL_START */
@@ -421,7 +426,7 @@ static void _on_name_appeared(GDBusConnection *connection,
 {
        DBG("name appeared : %s", name);
        is_master_started = 1;
-       _ipc_monitor_register();
+       _ipc_monitor_register(GPOINTER_TO_INT(user_data));
 
        _do_deferred_task();
 }
@@ -437,7 +442,7 @@ static void _on_name_vanished(GDBusConnection *connection,
 }
 /* LCOV_EXCL_STOP */
 
-int badge_ipc_monitor_init(void)
+int badge_ipc_monitor_init(uid_t uid)
 {
        DBG("register a service\n");
        int ret = BADGE_ERROR_NONE;
@@ -458,7 +463,7 @@ int badge_ipc_monitor_init(void)
                /* LCOV_EXCL_STOP */
        }
 
-       ret = _ipc_monitor_register();
+       ret = _ipc_monitor_register(uid);
        if (ret != BADGE_ERROR_NONE) {
                /* LCOV_EXCL_START */
                ERR("Can't init ipc_monitor_register %d", ret);
@@ -473,7 +478,7 @@ int badge_ipc_monitor_init(void)
                                G_BUS_NAME_WATCHER_FLAGS_NONE,
                                _on_name_appeared,
                                _on_name_vanished,
-                               NULL,
+                               GINT_TO_POINTER((int)uid),
                                NULL);
 
                if (provider_monitor_id == 0) {
@@ -503,7 +508,7 @@ int badge_ipc_monitor_fini(void)
        return BADGE_ERROR_NONE;
 }
 
-int badge_ipc_request_is_existing(const char *pkgname, bool *existing)
+int badge_ipc_request_is_existing(const char *pkgname, bool *existing, uid_t uid)
 {
        int result;
        GDBusMessage *reply = NULL;
@@ -516,7 +521,7 @@ int badge_ipc_request_is_existing(const char *pkgname, bool *existing)
                ERR("Can't init dbus %d", result);
                return result;
        }
-       body = g_variant_new("(s)", pkgname);
+       body = g_variant_new("(si)", pkgname, uid);
 
        result = _send_sync_badge(body, &reply, "get_badge_existing");
        if (result == BADGE_ERROR_NONE) {
@@ -532,12 +537,13 @@ int badge_ipc_request_is_existing(const char *pkgname, bool *existing)
        return result;
 }
 
-int badge_ipc_request_get_list(badge_foreach_cb callback, void *data)
+int badge_ipc_request_get_list(badge_foreach_cb callback, void *data, uid_t uid)
 {
        GDBusMessage *reply = NULL;
        int result;
        GVariant *reply_body;
        GVariant *iter_body;
+       GVariant *body;
        GVariantIter *iter;
        badge_info_s badge;
 
@@ -549,7 +555,14 @@ int badge_ipc_request_get_list(badge_foreach_cb callback, void *data)
                ERR("Can't init dbus %d", result);
                return result;
        }
-       result = _send_sync_badge(NULL, &reply, "get_list");
+
+       body = g_variant_new("(i)", uid);
+       if (!body) {
+               ERR("Cannot create gvariant. Out of memory.");
+               return BADGE_ERROR_OUT_OF_MEMORY;
+       }
+
+       result = _send_sync_badge(body, &reply, "get_list");
        if (result == BADGE_ERROR_NONE) {
                reply_body = g_dbus_message_get_body(reply);
                g_variant_get(reply_body, "(a(v))", &iter);
@@ -567,7 +580,7 @@ int badge_ipc_request_get_list(badge_foreach_cb callback, void *data)
        return result;
 }
 
-int badge_ipc_request_insert(const char *pkgname, const char *writable_pkg, const char *caller)
+int badge_ipc_request_insert(const char *pkgname, const char *writable_pkg, const char *caller, uid_t uid)
 {
        int result;
        GDBusMessage *reply = NULL;
@@ -579,7 +592,7 @@ int badge_ipc_request_insert(const char *pkgname, const char *writable_pkg, cons
                return result;
        }
 
-       body = g_variant_new("(sss)", pkgname, writable_pkg, caller);
+       body = g_variant_new("(sssi)", pkgname, writable_pkg, caller, uid);
        if (!body) {
                ERR("Cannot create gvariant. Out of memory.");
                return BADGE_ERROR_OUT_OF_MEMORY;
@@ -594,7 +607,7 @@ int badge_ipc_request_insert(const char *pkgname, const char *writable_pkg, cons
        return result;
 }
 
-int badge_ipc_request_delete(const char *pkgname, const char *caller)
+int badge_ipc_request_delete(const char *pkgname, const char *caller, uid_t uid)
 {
        int result;
        GDBusMessage *reply = NULL;
@@ -605,7 +618,12 @@ int badge_ipc_request_delete(const char *pkgname, const char *caller)
                ERR("Can't init dbus %d", result);
                return result;
        }
-       body = g_variant_new("(ss)", pkgname, caller);
+
+       body = g_variant_new("(ssi)", pkgname, caller, uid);
+       if (!body) {
+               ERR("Cannot create gvariant. Out of memory.");
+               return BADGE_ERROR_OUT_OF_MEMORY;
+       }
 
        result = _send_sync_badge(body, &reply, "delete_badge");
 
@@ -616,7 +634,7 @@ int badge_ipc_request_delete(const char *pkgname, const char *caller)
        return result;
 }
 
-int badge_ipc_request_set_count(const char *pkgname, const char *caller, int count)
+int badge_ipc_request_set_count(const char *pkgname, const char *caller, int count, uid_t uid)
 {
        int result;
        GDBusMessage *reply = NULL;
@@ -627,7 +645,12 @@ int badge_ipc_request_set_count(const char *pkgname, const char *caller, int cou
                ERR("Can't init dbus %d", result);
                return result;
        }
-       body = g_variant_new("(ssi)", pkgname, caller, count);
+
+       body = g_variant_new("(ssii)", pkgname, caller, count, uid);
+       if (!body) {
+               ERR("Cannot create gvariant. Out of memory.");
+               return BADGE_ERROR_OUT_OF_MEMORY;
+       }
 
        result = _send_sync_badge(body, &reply, "set_badge_count");
 
@@ -638,7 +661,7 @@ int badge_ipc_request_set_count(const char *pkgname, const char *caller, int cou
        return result;
 }
 
-int badge_ipc_request_get_count(const char *pkgname, unsigned int *count)
+int badge_ipc_request_get_count(const char *pkgname, unsigned int *count, uid_t uid)
 {
        int result;
        GDBusMessage *reply = NULL;
@@ -651,7 +674,12 @@ int badge_ipc_request_get_count(const char *pkgname, unsigned int *count)
                ERR("Can't init dbus %d", result);
                return result;
        }
-       body = g_variant_new("(s)", pkgname);
+
+       body = g_variant_new("(si)", pkgname, uid);
+       if (!body) {
+               ERR("Cannot create gvariant. Out of memory.");
+               return BADGE_ERROR_OUT_OF_MEMORY;
+       }
 
        result = _send_sync_badge(body, &reply, "get_badge_count");
        if (result == BADGE_ERROR_NONE) {
@@ -667,7 +695,8 @@ int badge_ipc_request_get_count(const char *pkgname, unsigned int *count)
        return result;
 }
 
-int badge_ipc_request_set_display(const char *pkgname, const char *caller, unsigned int display_option)
+int badge_ipc_request_set_display(const char *pkgname, const char *caller,
+                                 unsigned int display_option, uid_t uid)
 {
        int result;
        GDBusMessage *reply = NULL;
@@ -678,7 +707,11 @@ int badge_ipc_request_set_display(const char *pkgname, const char *caller, unsig
                ERR("Can't init dbus %d", result);
                return result;
        }
-       body = g_variant_new("(ssi)", pkgname, caller, display_option);
+       body = g_variant_new("(ssii)", pkgname, caller, display_option, uid);
+       if (!body) {
+               ERR("Cannot create gvariant. Out of memory.");
+               return BADGE_ERROR_OUT_OF_MEMORY;
+       }
 
        result = _send_sync_badge(body, &reply, "set_disp_option");
        if (reply)
@@ -688,7 +721,7 @@ int badge_ipc_request_set_display(const char *pkgname, const char *caller, unsig
        return result;
 }
 
-int badge_ipc_request_get_display(const char *pkgname, unsigned int *is_display)
+int badge_ipc_request_get_display(const char *pkgname, unsigned int *is_display, uid_t uid)
 {
        int result ;
        GDBusMessage *reply = NULL;
@@ -701,7 +734,12 @@ int badge_ipc_request_get_display(const char *pkgname, unsigned int *is_display)
                ERR("Can't init dbus %d", result);
                return result;
        }
-       body = g_variant_new("(s)", pkgname);
+
+       body = g_variant_new("(si)", pkgname, uid);
+       if (!body) {
+               ERR("Cannot create gvariant. Out of memory.");
+               return BADGE_ERROR_OUT_OF_MEMORY;
+       }
 
        result = _send_sync_badge(body, &reply, "get_disp_option");
        if (result == BADGE_ERROR_NONE) {
@@ -717,7 +755,7 @@ int badge_ipc_request_get_display(const char *pkgname, unsigned int *is_display)
        return result;
 }
 
-int badge_ipc_setting_property_set(const char *pkgname, const char *property, const char *value)
+int badge_ipc_setting_property_set(const char *pkgname, const char *property, const char *value, uid_t uid)
 {
        int result;
        GDBusMessage *reply = NULL;
@@ -728,7 +766,7 @@ int badge_ipc_setting_property_set(const char *pkgname, const char *property, co
                ERR("Can't init dbus %d", result);
                return result;
        }
-       body = g_variant_new("(sss)", pkgname, property, value);
+       body = g_variant_new("(sssi)", pkgname, property, value, uid);
 
        result = _send_sync_badge(body, &reply, "set_noti_property");
        if (reply)
@@ -738,7 +776,7 @@ int badge_ipc_setting_property_set(const char *pkgname, const char *property, co
        return result;
 }
 
-int badge_ipc_setting_property_get(const char *pkgname, const char *property, char **value)
+int badge_ipc_setting_property_get(const char *pkgname, const char *property, char **value, uid_t uid)
 {
        int result;
        GDBusMessage *reply = NULL;
@@ -751,7 +789,7 @@ int badge_ipc_setting_property_get(const char *pkgname, const char *property, ch
                ERR("Can't init dbus %d", result);
                return result;
        }
-       body = g_variant_new("(ss)", pkgname, property);
+       body = g_variant_new("(ssi)", pkgname, property, uid);
 
        result = _send_sync_badge(body, &reply, "get_noti_property");
        if (result == BADGE_ERROR_NONE) {

diff --git a/src/badge_setting.c b/src/badge_setting.c
index 992c9fa..d8aba7e 100755 (executable)
--- a/src/badge_setting.c
+++ b/src/badge_setting.c
@@ -22,6 +22,7 @@
 
 #include <stdlib.h>
 #include <stdarg.h>
+#include <unistd.h>
 #include <sqlite3.h>
 #include <db-util.h>
 #include <tzplatform_config.h>
@@ -139,7 +140,7 @@ free_and_return:
        return result;
 }
 
-EXPORT_API int badge_setting_db_set(const char *pkgname, const char *property, const char *value)
+EXPORT_API int badge_setting_db_set(const char *pkgname, const char *property, const char *value, uid_t uid)
 {
        int ret = BADGE_ERROR_NONE;
        int result = BADGE_ERROR_NONE;
@@ -201,7 +202,7 @@ return_close_db:
        return result;
 }
 
-EXPORT_API int badge_setting_db_get(const char *pkgname, const char *property, char **value)
+EXPORT_API int badge_setting_db_get(const char *pkgname, const char *property, char **value, uid_t uid)
 {
        int ret = BADGE_ERROR_NONE;
        int result = BADGE_ERROR_NONE;
@@ -287,7 +288,7 @@ return_close_db:
        return result;
 }
 
-EXPORT_API int badge_setting_property_set(const char *pkgname, const char *property, const char *value)
+EXPORT_API int badge_setting_property_set_for_uid(const char *pkgname, const char *property, const char *value, uid_t uid)
 {
        int ret = 0;
 
@@ -300,14 +301,19 @@ EXPORT_API int badge_setting_property_set(const char *pkgname, const char *prope
        if (!value)
                return BADGE_ERROR_INVALID_PARAMETER;
 
-       ret = badge_ipc_setting_property_set(pkgname, property, value);
+       ret = badge_ipc_setting_property_set(pkgname, property, value, uid);
        if (ret != BADGE_ERROR_NONE)
                return ret;
 
        return BADGE_ERROR_NONE;
 }
 
-EXPORT_API int badge_setting_property_get(const char *pkgname, const char *property, char **value)
+EXPORT_API int badge_setting_property_set(const char *pkgname, const char *property, const char *value)
+{
+       return badge_setting_property_set_for_uid(pkgname, property, value, getuid());
+}
+
+EXPORT_API int badge_setting_property_get_for_uid(const char *pkgname, const char *property, char **value, uid_t uid)
 {
        int ret = 0;
 
@@ -320,9 +326,14 @@ EXPORT_API int badge_setting_property_get(const char *pkgname, const char *prope
        if (!value)
                return BADGE_ERROR_INVALID_PARAMETER;
 
-       ret = badge_ipc_setting_property_get(pkgname, property, value);
+       ret = badge_ipc_setting_property_get(pkgname, property, value, uid);
        if (ret != BADGE_ERROR_NONE)
                return ret;
 
        return BADGE_ERROR_NONE;
 }
+
+EXPORT_API int badge_setting_property_get(const char *pkgname, const char *property, char **value)
+{
+       return badge_setting_property_get_for_uid(pkgname, property, value, getuid());
+}