Fix bug for caching appid and fix unittest

- Pid can be recycled, that's why it is not appropriate to use it as a hash key
- Adds code for limit of cache size
- Fix trivial unittest issue

Change-Id: I02ab3ce9c86c8c60f0e717307b8afed53b9b15c4
Signed-off-by: Inkyun Kil <inkyun.kil@samsung.com>

diff --git a/include/alarm-internal.h b/include/alarm-internal.h
index de5d5d5..eca3ae4 100644 (file)
--- a/include/alarm-internal.h
+++ b/include/alarm-internal.h
@@ -40,6 +40,7 @@ extern "C" {
 #define MAX_APP_ID_LEN 256
 #define MIN_INEXACT_INTERVAL 900
 #define REGULAR_UID_MIN 5000
+#define MAX_APPID_CACHE_SIZE 100
 
 #define BILLION 1000000000 /* for calculating nano seconds */
 #define MILLION 1000000 /* for calculating micro seconds */
@@ -178,15 +179,15 @@ bool _can_skip_expired_cb(alarm_id_t alarm_id);
 void _alarm_expired();
 void _rtc_set();
 
-int alarm_manager_alarm_create(GVariant *parameters, uid_t uid, pid_t pid, int *alarm_id);
-int alarm_manager_alarm_create_appsvc(GVariant *parameters, uid_t uid, pid_t pid, int *alarm_id);
-int alarm_manager_alarm_create_periodic(GVariant *parameters, uid_t uid, pid_t pid, int *alarm_id);
-int alarm_manager_alarm_create_noti(GVariant *parameters, uid_t uid, pid_t pid, int *alarm_id);
-int alarm_manager_alarm_delete(GVariant *parameters, uid_t uid, pid_t pid);
-int alarm_manager_alarm_delete_all(GVariant *parameters, uid_t uid, pid_t pid);
-int alarm_manager_alarm_update(GVariant *parameters, uid_t uid, pid_t pid);
-int alarm_manager_alarm_get_number_of_ids(uid_t uid, pid_t pid, int *num_of_ids);
-int alarm_manager_alarm_get_list_of_ids(GVariant *parameters, uid_t uid, pid_t pid,
+int alarm_manager_alarm_create(GVariant *parameters, uid_t uid, pid_t pid, const gchar *sender, int *alarm_id);
+int alarm_manager_alarm_create_appsvc(GVariant *parameters, uid_t uid, pid_t pid, const gchar *sender, int *alarm_id);
+int alarm_manager_alarm_create_periodic(GVariant *parameters, uid_t uid, pid_t pid, const gchar *sender, int *alarm_id);
+int alarm_manager_alarm_create_noti(GVariant *parameters, uid_t uid, pid_t pid, const gchar *sender, int *alarm_id);
+int alarm_manager_alarm_delete(GVariant *parameters, uid_t uid, pid_t pid, const gchar *sender);
+int alarm_manager_alarm_delete_all(GVariant *parameters, uid_t uid, pid_t pid, const gchar *sender);
+int alarm_manager_alarm_update(GVariant *parameters, uid_t uid, pid_t pid, const gchar *sender);
+int alarm_manager_alarm_get_number_of_ids(uid_t uid, pid_t pid, const gchar *sender, int *num_of_ids);
+int alarm_manager_alarm_get_list_of_ids(GVariant *parameters, uid_t uid, pid_t pid, const gchar *sender,
                GVariantBuilder *alarm_array, int *num_of_alarm);
 int alarm_manager_alarm_get_appsvc_info(GVariant *parameters, uid_t uid, gchar **b_data);
 int alarm_manager_alarm_get_noti_info(GVariant *parameters, uid_t uid, gchar **noti_data);
@@ -194,8 +195,8 @@ int alarm_manager_alarm_get_info(GVariant *parameters, uid_t uid, base_info_t *b
 int alarm_manager_alarm_get_next_duetime(GVariant *parameters, uid_t uid, time_t *duetime);
 int alarm_manager_alarm_get_all_info(uid_t uid, char **db_path);
 int alarm_manager_alarm_set_rtc_time(GVariant *parameters);
-int alarm_manager_alarm_set_time(GVariant* parameters, pid_t pid);
-int alarm_manager_alarm_set_time_with_propagation_delay(GVariant* parameters, pid_t pid);
+int alarm_manager_alarm_set_time(GVariant* parameters, pid_t pid, const gchar *sender);
+int alarm_manager_alarm_set_time_with_propagation_delay(GVariant* parameters, pid_t pid, const gchar *sender);
 int alarm_manager_alarm_set_timezone(GVariant* parameters);
 int alarm_manager_alarm_set_global(GVariant *parameters, uid_t uid);
 int alarm_manager_alarm_get_global(GVariant *parameters, gboolean *global);

diff --git a/lib/alarm-lib.c b/lib/alarm-lib.c
index c2be7f2..bcd3d65 100644 (file)
--- a/lib/alarm-lib.c
+++ b/lib/alarm-lib.c
@@ -678,11 +678,15 @@ EXPORT_API void alarmmgr_fini()
                alarm_context.session_conn = NULL;
        }
 
-       if (alarm_context.app_service_name)
+       if (alarm_context.app_service_name) {
                free(alarm_context.app_service_name);
-       if (alarm_context.app_service_name_mod)
-               free(alarm_context.app_service_name_mod);
+               alarm_context.app_service_name = NULL;
+       }
 
+       if (alarm_context.app_service_name_mod) {
+               free(alarm_context.app_service_name_mod);
+               alarm_context.app_service_name_mod = NULL;
+       }
 
        b_initialized = false;
        sub_initialized = false;

diff --git a/mock/glib_fake.h b/mock/glib_fake.h
index a46077a..ccc80b0 100755 (executable)
--- a/mock/glib_fake.h
+++ b/mock/glib_fake.h
@@ -26,6 +26,7 @@ DECLARE_FAKE_VALUE_FUNC3_VARARG(gboolean, g_variant_iter_loop, GVariantIter*,
     const gchar*, ...);
 DECLARE_FAKE_VOID_FUNC(g_variant_iter_free, GVariantIter*);
 DECLARE_FAKE_VOID_FUNC(g_variant_unref, GVariant*);
+DECLARE_FAKE_VOID_FUNC(g_variant_store, GVariant*, gpointer);
 DECLARE_FAKE_VALUE_FUNC(gpointer, g_hash_table_lookup, GHashTable*, gconstpointer);
 DECLARE_FAKE_VALUE_FUNC(guint, g_hash_table_foreach_remove, GHashTable*,
     GHRFunc, gpointer);

diff --git a/mock/mock.cc b/mock/mock.cc
index 11aa6d1..eea387c 100644 (file)
--- a/mock/mock.cc
+++ b/mock/mock.cc
@@ -65,6 +65,7 @@ DEFINE_FAKE_VALUE_FUNC(gsize, g_variant_get_size, GVariant*);
 DEFINE_FAKE_VALUE_FUNC3_VARARG(gboolean, g_variant_iter_loop, GVariantIter*, const gchar*, ...);
 DEFINE_FAKE_VOID_FUNC(g_variant_iter_free, GVariantIter*);
 DEFINE_FAKE_VOID_FUNC(g_variant_unref, GVariant*);
+DEFINE_FAKE_VOID_FUNC(g_variant_store, GVariant*, gpointer);
 DEFINE_FAKE_VALUE_FUNC(gpointer, g_hash_table_lookup, GHashTable*, gconstpointer);
 DEFINE_FAKE_VALUE_FUNC(guint, g_hash_table_foreach_remove, GHashTable*,
     GHRFunc, gpointer);

diff --git a/server/alarm-manager-dbus.c b/server/alarm-manager-dbus.c
index 5224f39..c7cef8d 100644 (file)
--- a/server/alarm-manager-dbus.c
+++ b/server/alarm-manager-dbus.c
@@ -634,37 +634,37 @@ static void handle_method_call(GDBusConnection *connection,
        pid_t pid = __get_caller_pid(name);
 
        if (g_strcmp0(method_name, "alarm_create_periodic") == 0) {
-               ret = alarm_manager_alarm_create_periodic(parameters, uid, pid, &alarm_id);
+               ret = alarm_manager_alarm_create_periodic(parameters, uid, pid, sender, &alarm_id);
                g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, ret));
        } else if (g_strcmp0(method_name, "alarm_create") == 0) {
-               ret = alarm_manager_alarm_create(parameters, uid, pid, &alarm_id);
+               ret = alarm_manager_alarm_create(parameters, uid, pid, sender, &alarm_id);
                g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, ret));
        } else if (g_strcmp0(method_name, "alarm_create_appsvc") == 0) {
-               ret = alarm_manager_alarm_create_appsvc(parameters, uid, pid, &alarm_id);
+               ret = alarm_manager_alarm_create_appsvc(parameters, uid, pid, sender, &alarm_id);
                g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, ret));
        } else if (g_strcmp0(method_name, "alarm_create_noti") == 0) {
                const char *notification_priv = "http://tizen.org/privilege/notification";
                ret = _cynara_check(invoc, notification_priv, pid);
                if (ret == ALARMMGR_RESULT_SUCCESS) {
-                       ret = alarm_manager_alarm_create_noti(parameters, uid, pid, &alarm_id);
+                       ret = alarm_manager_alarm_create_noti(parameters, uid, pid, sender, &alarm_id);
                }
                g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, ret));
        } else if (g_strcmp0(method_name, "alarm_delete") == 0) {
-               ret = alarm_manager_alarm_delete(parameters, uid, pid);
+               ret = alarm_manager_alarm_delete(parameters, uid, pid, sender);
                g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ret));
        } else if (g_strcmp0(method_name, "alarm_delete_all") == 0) {
-               ret = alarm_manager_alarm_delete_all(parameters, uid, pid);
+               ret = alarm_manager_alarm_delete_all(parameters, uid, pid, sender);
                g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ret));
        } else if (g_strcmp0(method_name, "alarm_update") == 0) {
-               ret = alarm_manager_alarm_update(parameters, uid, pid);
+               ret = alarm_manager_alarm_update(parameters, uid, pid, sender);
                g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ret));
        } else if (g_strcmp0(method_name, "alarm_get_number_of_ids") == 0) {
-               ret = alarm_manager_alarm_get_number_of_ids(uid, pid, &num_of_alarm);
+               ret = alarm_manager_alarm_get_number_of_ids(uid, pid, sender, &num_of_alarm);
                g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", num_of_alarm, ret));
        } else if (g_strcmp0(method_name, "alarm_get_list_of_ids") == 0) {
                GVariantBuilder *arr = g_variant_builder_new(G_VARIANT_TYPE("a(i)"));
 
-               ret = alarm_manager_alarm_get_list_of_ids(parameters, uid, pid, arr, &num_of_alarm);
+               ret = alarm_manager_alarm_get_list_of_ids(parameters, uid, pid, sender, arr, &num_of_alarm);
                g_dbus_method_invocation_return_value(invoc, g_variant_new("(a(i)ii)", arr, num_of_alarm, ret));
 
                g_variant_builder_unref(arr);
@@ -717,12 +717,12 @@ static void handle_method_call(GDBusConnection *connection,
                _display_unlock_state(DEVICED_LCD_OFF, DEVICED_SLEEP_MARGIN);
        } else if (g_strcmp0(method_name, "alarm_set_time") == 0) {
                _display_lock_state(DEVICED_LCD_OFF, DEVICED_STAY_CUR_STATE, 0);
-               ret = alarm_manager_alarm_set_time(parameters, pid);
+               ret = alarm_manager_alarm_set_time(parameters, pid, sender);
                g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ret));
                _display_unlock_state(DEVICED_LCD_OFF, DEVICED_SLEEP_MARGIN);
        } else if (g_strcmp0(method_name, "alarm_set_time_with_propagation_delay") == 0) {
                _display_lock_state(DEVICED_LCD_OFF, DEVICED_STAY_CUR_STATE, 0);
-               ret = alarm_manager_alarm_set_time_with_propagation_delay(parameters, pid);
+               ret = alarm_manager_alarm_set_time_with_propagation_delay(parameters, pid, sender);
                g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ret));
                _display_unlock_state(DEVICED_LCD_OFF, DEVICED_SLEEP_MARGIN);
        } else if (g_strcmp0(method_name, "alarm_set_timezone") == 0) {

diff --git a/server/alarm-manager.c b/server/alarm-manager.c
index 3fefde7..f32cd4d 100644 (file)
--- a/server/alarm-manager.c
+++ b/server/alarm-manager.c
@@ -96,6 +96,7 @@ struct running_info_t {
 typedef struct {
        int pid;
        bool is_app;
+       char *sender;
        char *unique_name;
 } appid_cache_t;
 
@@ -110,12 +111,13 @@ static void __alarm_set_start_and_end_time(base_info_t *base_info,
                __alarm_info_t *__alarm_info);
 static void __alarm_update_due_time_of_all_items_in_list(time_t new_time,double diff_time);
 static bool __alarm_create(base_info_t *base_info, alarm_id_t *alarm_id, uid_t uid,
-                       int pid, periodic_method_e method, long requested_interval, int is_ref,
-                       char *app_service_name, char *app_service_name_mod,
-                       const char *dst_service_name, const char *dst_service_name_mod,
-                       int *error_code);
+               int pid, const gchar *sender, periodic_method_e method,
+               long requested_interval, int is_ref, char *app_service_name,
+               char *app_service_name_mod, const char *dst_service_name,
+               const char *dst_service_name_mod, int *error_code);
 static bool __alarm_create_appsvc(base_info_t *base_info, alarm_id_t *alarm_id,
-                          long requested_interval, uid_t uid, int pid, char *bundle_data, int *error_code);
+               long requested_interval, uid_t uid, int pid, const gchar *sender,
+               char *bundle_data, int *error_code);
 
 static bool __alarm_delete(uid_t uid, alarm_id_t alarm_id, int *error_code);
 static bool __alarm_update(uid_t uid, alarm_id_t alarm_id,
@@ -175,13 +177,14 @@ gboolean __hash_table_remove_cb(gpointer key, gpointer value, gpointer user_data
        return false;
 }
 
-static bool __get_cached_unique_name(int pid, char *unique_name, int size, bool *is_app, uid_t uid)
+static bool __get_cached_unique_name(int pid, const gchar *sender,
+               char *unique_name, int size, bool *is_app, uid_t uid)
 {
        appid_cache_t *data;
        bool ret = false;
        bool _is_app;
 
-       data = (appid_cache_t *)g_hash_table_lookup(caller_appid_cache_table, GINT_TO_POINTER(pid));
+       data = (appid_cache_t *)g_hash_table_lookup(caller_appid_cache_table, (gpointer)sender);
        if (data) {
                snprintf(unique_name, size, "%s", data->unique_name);
                if (is_app)
@@ -198,9 +201,19 @@ static bool __get_cached_unique_name(int pid, char *unique_name, int size, bool
                data = (appid_cache_t *)calloc(1, sizeof(appid_cache_t));
                if (data) {
                        data->unique_name = strdup(unique_name);
+                       data->sender = strdup(sender);
                        data->is_app = _is_app;
                        data->pid = pid;
-                       g_hash_table_insert(caller_appid_cache_table, GINT_TO_POINTER(data->pid), (gpointer)data);
+
+                       if (data->unique_name && data->sender) {
+                               if (g_hash_table_size(caller_appid_cache_table) > MAX_APPID_CACHE_SIZE) {
+                                       g_hash_table_remove_all(caller_appid_cache_table);
+                               }
+                               g_hash_table_insert(caller_appid_cache_table, (gpointer)data->sender, (gpointer)data);
+                       } else {
+                               LOGE("Out of memory");
+                               __free_cached_value(data);
+                       }
                }
 
                if (is_app)
@@ -226,6 +239,8 @@ void __free_cached_value(gpointer data)
        if (value) {
                if (value->unique_name)
                        free(value->unique_name);
+               if (value->sender)
+                       free(value->sender);
                free(value);
        }
 }
@@ -838,7 +853,8 @@ static bool __alarm_add_and_set(__alarm_info_t *alarm_info, pid_t pid)
 }
 
 static bool __alarm_create_appsvc(base_info_t *base_info, alarm_id_t *alarm_id,
-                          long requested_interval, uid_t uid, int pid, char *bundle_data, int *error_code)
+               long requested_interval, uid_t uid, int pid, const gchar *sender,
+               char *bundle_data, int *error_code)
 {
        char app_name[MAX_APP_ID_LEN] = { 0 };
        bundle *b;
@@ -863,7 +879,8 @@ static bool __alarm_create_appsvc(base_info_t *base_info, alarm_id_t *alarm_id,
        __alarm_info->global = false;
        __alarm_info->method = CUT_OFF;
 
-       if (__get_cached_unique_name(pid, app_name, sizeof(app_name), &caller_is_app, uid) == false) {
+       if (__get_cached_unique_name(pid, sender, app_name, sizeof(app_name),
+                       &caller_is_app, uid) == false) {
                *error_code = ERR_ALARM_SYSTEM_FAIL;
                _release_alarm_info_t(__alarm_info);
                return false;
@@ -913,11 +930,11 @@ static bool __alarm_create_appsvc(base_info_t *base_info, alarm_id_t *alarm_id,
        return true;
 }
 
-static bool __alarm_create(base_info_t *base_info, alarm_id_t *alarm_id, uid_t uid,
-                       int pid, periodic_method_e method, long requested_interval, int is_ref,
-                       char *app_service_name, char *app_service_name_mod,
-                       const char *dst_service_name, const char *dst_service_name_mod,
-                       int *error_code)
+static bool __alarm_create(base_info_t *base_info, alarm_id_t *alarm_id,
+               uid_t uid, int pid, const gchar *sender, periodic_method_e method,
+               long requested_interval, int is_ref, char *app_service_name,
+               char *app_service_name_mod, const char *dst_service_name,
+               const char *dst_service_name_mod, int *error_code)
 {
        char unique_name[MAX_APP_ID_LEN] = { 0 };
        bool caller_is_app = false;
@@ -939,7 +956,7 @@ static bool __alarm_create(base_info_t *base_info, alarm_id_t *alarm_id, uid_t u
        __alarm_info->is_ref = is_ref;
        __alarm_info->global = false;
 
-       if (__get_cached_unique_name(pid, unique_name, sizeof(unique_name),
+       if (__get_cached_unique_name(pid, sender, unique_name, sizeof(unique_name),
                        &caller_is_app, uid) == false) {
                *error_code = ERR_ALARM_SYSTEM_FAIL;
                _release_alarm_info_t(__alarm_info);
@@ -1024,7 +1041,8 @@ end:
 }
 
 static bool __alarm_create_noti(base_info_t *base_info, alarm_id_t *alarm_id,
-                          long requested_interval, uid_t uid, int pid, char *noti_data, int *error_code)
+               long requested_interval, uid_t uid, int pid, const gchar *sender,
+               char *noti_data, int *error_code)
 {
        char app_name[MAX_APP_ID_LEN] = { 0 };
        bool caller_is_app = false;
@@ -1046,7 +1064,8 @@ static bool __alarm_create_noti(base_info_t *base_info, alarm_id_t *alarm_id,
        __alarm_info->global = false;
        __alarm_info->method = CUT_OFF;
 
-       if (__get_cached_unique_name(pid, app_name, sizeof(app_name), &caller_is_app, uid) == false) {
+       if (__get_cached_unique_name(pid, sender, app_name, sizeof(app_name),
+                       &caller_is_app, uid) == false) {
                *error_code = ERR_ALARM_SYSTEM_FAIL;
                _release_alarm_info_t(__alarm_info);
                return false;
@@ -1839,7 +1858,6 @@ static int __on_app_uninstalled(uid_t target_uid, int req_id, const char *pkg_ty
 
                const char *caller_pkgid = entry->caller_pkgid;
                const char *callee_pkgid = entry->callee_pkgid;
-               int pid = _get_pid_from_appid(entry->app_unique_name, entry->uid);
 
                gs_iter = g_slist_next(gs_iter);
                if ((caller_pkgid && strncmp(pkgid, caller_pkgid, strlen(pkgid)) == 0) ||
@@ -1860,9 +1878,6 @@ static int __on_app_uninstalled(uid_t target_uid, int req_id, const char *pkg_ty
                                g_disabled_alarm_list = g_slist_append(g_disabled_alarm_list, entry);
                                alarm_context.alarms = g_slist_remove(alarm_context.alarms, entry);
                        } else {
-                               if (g_hash_table_remove(caller_appid_cache_table, GINT_TO_POINTER(pid)) == true)
-                                       LOGD("Remove cachd data of pid[%d]", pid);
-
                                LOGD("Remove pkgid[%s], alarm_id[%d]", pkgid, entry->alarm_id);
                                alarm_context.alarms = g_slist_remove(alarm_context.alarms, entry);
                                _release_alarm_info_t(entry);
@@ -1970,7 +1985,7 @@ void __reschedule_alarms_with_newtime(time_t cur_time, time_t new_time, double d
        return;
 }
 
-static int __check_modifiable(uid_t uid, pid_t pid, int alarm_id)
+static int __check_modifiable(uid_t uid, pid_t pid, const gchar *sender, int alarm_id)
 {
        bool caller_is_app = false;
        char app_name[MAX_APP_ID_LEN] = { 0 };
@@ -1978,7 +1993,7 @@ static int __check_modifiable(uid_t uid, pid_t pid, int alarm_id)
        __alarm_info_t *entry = NULL;
        char *caller_pkgid = NULL;
 
-       if (__get_cached_unique_name(pid, app_name, sizeof(app_name),
+       if (__get_cached_unique_name(pid, sender, app_name, sizeof(app_name),
                                &caller_is_app, uid) == false)
                return ERR_ALARM_SYSTEM_FAIL;
 
@@ -2070,7 +2085,7 @@ int alarm_manager_alarm_set_rtc_time(GVariant *parameters)
 
 static int accrue_nsec = 0; /* To check a millisecond part of current time at changing the system time(sec) */
 
-int alarm_manager_alarm_set_time(GVariant* parameters, pid_t pid)
+int alarm_manager_alarm_set_time(GVariant* parameters, pid_t pid, const gchar *sender)
 {
        double diff_time = 0.0;
        struct timespec cur_time;
@@ -2109,14 +2124,15 @@ int alarm_manager_alarm_set_time(GVariant* parameters, pid_t pid)
 
        __reschedule_alarms_with_newtime(cur_time.tv_sec, new_time, diff_time);
 
-       __get_cached_unique_name(pid, sender_id, MAX_APP_ID_LEN, NULL, 5001);
+       __get_cached_unique_name(pid, sender, sender_id, MAX_APP_ID_LEN, NULL, 5001);
        snprintf(log_message, sizeof(log_message), "requested by %s (pid %d)", sender_id, pid);
        _save_module_log("SET TIME END", log_message);
 
        return ALARMMGR_RESULT_SUCCESS;;
 }
 
-int alarm_manager_alarm_set_time_with_propagation_delay(GVariant* parameters, pid_t pid)
+int alarm_manager_alarm_set_time_with_propagation_delay(GVariant* parameters,
+               pid_t pid, const gchar *sender)
 {
        double diff_time = 0.0;
        struct timespec cur_time = {0,};
@@ -2181,7 +2197,7 @@ int alarm_manager_alarm_set_time_with_propagation_delay(GVariant* parameters, pi
        LOGD("Requested(%ld.%09ld) Delay(%ld.%09ld) Sleep(%09ld)", req_sec, req_nsec, delay.tv_sec, delay.tv_nsec, sleep_time.tv_nsec);
        __reschedule_alarms_with_newtime(cur_time.tv_sec, real_newtime, diff_time);
 
-       __get_cached_unique_name(pid, sender_id, MAX_APP_ID_LEN, NULL, 5001);
+       __get_cached_unique_name(pid, sender, sender_id, MAX_APP_ID_LEN, NULL, 5001);
        snprintf(log_message, sizeof(log_message), "requested by %s (pid %d)", sender_id, pid);
        _save_module_log("SET TIME PROPAGATION END", log_message);
 
@@ -2264,7 +2280,8 @@ done:
        return return_code;
 }
 
-int alarm_manager_alarm_create_appsvc(GVariant *parameters, uid_t uid, pid_t pid, int *alarm_id)
+int alarm_manager_alarm_create_appsvc(GVariant *parameters, uid_t uid, pid_t pid,
+               const gchar *sender, int *alarm_id)
 {
        base_info_t base_info;
        int return_code = ALARMMGR_RESULT_SUCCESS;
@@ -2344,7 +2361,8 @@ int alarm_manager_alarm_create_appsvc(GVariant *parameters, uid_t uid, pid_t pid
                base_info.mode.u_interval.interval = 0;
        }
 
-       if (!__alarm_create_appsvc(&base_info, &_alarm_id, mode_interval, uid, pid, bundle_data, &return_code)) {
+       if (!__alarm_create_appsvc(&base_info, &_alarm_id, mode_interval, uid, pid,
+                       sender, bundle_data, &return_code)) {
                LOGE("Unable to create alarm! return_code[%d]", return_code);
                strncpy(log_tag, "FAIL: CREATE SVC", sizeof(log_tag) - 1);
                snprintf(log_message, sizeof(log_message),
@@ -2361,7 +2379,7 @@ int alarm_manager_alarm_create_appsvc(GVariant *parameters, uid_t uid, pid_t pid
 }
 
 int alarm_manager_alarm_create_noti(GVariant *parameters, uid_t uid, pid_t pid,
-               int *alarm_id)
+               const gchar *sender, int *alarm_id)
 {
        base_info_t base_info;
        int return_code = ALARMMGR_RESULT_SUCCESS;
@@ -2410,7 +2428,8 @@ int alarm_manager_alarm_create_noti(GVariant *parameters, uid_t uid, pid_t pid,
                base_info.mode.u_interval.interval = 0;
        }
 
-       if (!__alarm_create_noti(&base_info, &_alarm_id, mode_interval, uid, pid, noti_data, &return_code)) {
+       if (!__alarm_create_noti(&base_info, &_alarm_id, mode_interval, uid, pid,
+                       sender, noti_data, &return_code)) {
                LOGE("Unable to create alarm! return_code[%d]", return_code);
                strncpy(log_tag, "FAIL: CREATE NOTI", sizeof(log_tag) - 1);
                snprintf(log_message, sizeof(log_message), "alarmID: %d, uid: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
@@ -2425,7 +2444,8 @@ int alarm_manager_alarm_create_noti(GVariant *parameters, uid_t uid, pid_t pid,
        return return_code;
 }
 
-int alarm_manager_alarm_create(GVariant *parameters, uid_t uid, pid_t pid, int *alarm_id)
+int alarm_manager_alarm_create(GVariant *parameters, uid_t uid, pid_t pid,
+               const gchar *sender, int *alarm_id)
 {
        base_info_t base_info;
        int return_code = ALARMMGR_RESULT_SUCCESS;
@@ -2480,7 +2500,7 @@ int alarm_manager_alarm_create(GVariant *parameters, uid_t uid, pid_t pid, int *
        if (strcmp(reserved_service_name_mod, "null") == 0)
                _reserved_service_name_mod = NULL;
 
-       if (!__alarm_create(&base_info, &_alarm_id, uid, pid, QUANTUMIZE, 0, 0, app_service_name, app_service_name_mod,
+       if (!__alarm_create(&base_info, &_alarm_id, uid, pid, sender, QUANTUMIZE, 0, 0, app_service_name, app_service_name_mod,
                                _reserved_service_name, _reserved_service_name_mod, &return_code)) {
                LOGE("Unable to create alarm! return_code[%d]", return_code);
                strncpy(log_tag, "FAIL: CREATE", sizeof(log_tag) - 1);
@@ -2507,7 +2527,7 @@ time_t _get_periodic_alarm_standard_time(void)
 }
 
 int alarm_manager_alarm_create_periodic(GVariant *parameters, uid_t uid,
-               pid_t pid, int *alarm_id)
+               pid_t pid, const gchar *sender, int *alarm_id)
 {
        base_info_t base_info;
        int return_code = ALARMMGR_RESULT_SUCCESS;
@@ -2559,9 +2579,9 @@ int alarm_manager_alarm_create_periodic(GVariant *parameters, uid_t uid,
                        base_info.mode.u_interval.interval = __get_proper_interval(interval * 60);
        }
 
-       if (!__alarm_create(&base_info, &_alarm_id, uid, pid, (periodic_method_e)method, interval * 60, is_ref,
-                               app_service_name, app_service_name_mod,
-                               NULL, NULL, &return_code)) {
+       if (!__alarm_create(&base_info, &_alarm_id, uid, pid, sender,
+                       (periodic_method_e)method, interval * 60, is_ref, app_service_name,
+                       app_service_name_mod, NULL, NULL, &return_code)) {
                LOGE("Unable to create alarm! return_code[%d]", return_code);
                strncpy(log_tag, "FAIL: CREAT PERIOD", sizeof(log_tag) - 1);
                snprintf(log_message, sizeof(log_message), "alarmID: %d, uid: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
@@ -2578,7 +2598,8 @@ int alarm_manager_alarm_create_periodic(GVariant *parameters, uid_t uid,
        return return_code;
 }
 
-int alarm_manager_alarm_delete(GVariant *parameters, uid_t uid, pid_t pid)
+int alarm_manager_alarm_delete(GVariant *parameters, uid_t uid, pid_t pid,
+               const gchar *sender)
 {
        int return_code = ALARMMGR_RESULT_SUCCESS;
        char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
@@ -2587,7 +2608,7 @@ int alarm_manager_alarm_delete(GVariant *parameters, uid_t uid, pid_t pid)
 
        g_variant_get(parameters, "(i)", &alarm_id);
 
-       return_code = __check_modifiable(uid, pid, alarm_id);
+       return_code = __check_modifiable(uid, pid, sender, alarm_id);
        if (return_code != ALARMMGR_RESULT_SUCCESS)
                return return_code;
 
@@ -2606,7 +2627,8 @@ int alarm_manager_alarm_delete(GVariant *parameters, uid_t uid, pid_t pid)
        return return_code;
 }
 
-int alarm_manager_alarm_delete_all(GVariant *parameters, uid_t uid, pid_t pid)
+int alarm_manager_alarm_delete_all(GVariant *parameters, uid_t uid, pid_t pid,
+               const gchar *sender)
 {
        GSList *gs_iter = NULL;
        char app_name[MAX_APP_ID_LEN] = { 0 };
@@ -2615,7 +2637,7 @@ int alarm_manager_alarm_delete_all(GVariant *parameters, uid_t uid, pid_t pid)
        bool is_deleted = false;
        char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
 
-       if (__get_cached_unique_name(pid, app_name, sizeof(app_name), NULL, uid) == false) {
+       if (__get_cached_unique_name(pid, sender, app_name, sizeof(app_name), NULL, uid) == false) {
                snprintf(log_message, sizeof(log_message), "pid: %d. Can not get the unique_name.", pid);
                _save_module_log("FAIL: DELETE ALL", log_message);
                return ERR_ALARM_SYSTEM_FAIL;
@@ -2662,7 +2684,7 @@ int alarm_manager_alarm_delete_all(GVariant *parameters, uid_t uid, pid_t pid)
        return ALARMMGR_RESULT_SUCCESS;
 }
 
-int alarm_manager_alarm_update(GVariant *parameters, uid_t uid, pid_t pid)
+int alarm_manager_alarm_update(GVariant *parameters, uid_t uid, pid_t pid, const gchar *sender)
 {
        int return_code = ALARMMGR_RESULT_SUCCESS;
        base_info_t base_info;
@@ -2684,7 +2706,7 @@ int alarm_manager_alarm_update(GVariant *parameters, uid_t uid, pid_t pid)
        mode_interval = (time_t)tmp_mode_interval;
        reserved_info = (time_t)tmp_reserved_info;
 
-       return_code = __check_modifiable(uid, pid, alarm_id);
+       return_code = __check_modifiable(uid, pid, sender, alarm_id);
        if (return_code != ALARMMGR_RESULT_SUCCESS)
                return return_code;
 
@@ -2717,7 +2739,8 @@ int alarm_manager_alarm_update(GVariant *parameters, uid_t uid, pid_t pid)
        return return_code;
 }
 
-int alarm_manager_alarm_get_number_of_ids(uid_t uid, pid_t pid, int *num_of_ids)
+int alarm_manager_alarm_get_number_of_ids(uid_t uid, pid_t pid,
+               const gchar *sender, int *num_of_ids)
 {
        GSList *gs_iter = NULL;
        char app_name[MAX_APP_ID_LEN] = { 0 };
@@ -2726,7 +2749,7 @@ int alarm_manager_alarm_get_number_of_ids(uid_t uid, pid_t pid, int *num_of_ids)
 
        *num_of_ids = _num_of_ids;
 
-       if (__get_cached_unique_name(pid, app_name, sizeof(app_name), NULL, uid) == false)
+       if (__get_cached_unique_name(pid, sender, app_name, sizeof(app_name), NULL, uid) == false)
                return ERR_ALARM_SYSTEM_FAIL;
 
        SECURE_LOGD("Called by process (uid:%d, pid:%d, unique_name:%s)", uid, pid, app_name);
@@ -2747,7 +2770,7 @@ int alarm_manager_alarm_get_number_of_ids(uid_t uid, pid_t pid, int *num_of_ids)
 }
 
 int alarm_manager_alarm_get_list_of_ids(GVariant *parameters, uid_t uid,
-               pid_t pid, GVariantBuilder *alarm_array, int *num_of_alarm)
+               pid_t pid, const gchar *sender, GVariantBuilder *alarm_array, int *num_of_alarm)
 {
        GSList *gs_iter = NULL;
        char app_name[MAX_APP_ID_LEN] = { 0 };
@@ -2763,7 +2786,7 @@ int alarm_manager_alarm_get_list_of_ids(GVariant *parameters, uid_t uid,
                return ALARMMGR_RESULT_SUCCESS;
        }
 
-       if (__get_cached_unique_name(pid, app_name, sizeof(app_name), NULL, uid) == false)
+       if (__get_cached_unique_name(pid, sender, app_name, sizeof(app_name), NULL, uid) == false)
                return ERR_ALARM_SYSTEM_FAIL;
 
        SECURE_LOGD("Called by process (uid: %d, pid:%d, unique_name=%s).", uid, pid, app_name);
@@ -3195,8 +3218,8 @@ void _alarm_initialize()
        __initialize_noti();
 
        if (!caller_appid_cache_table) {
-               caller_appid_cache_table = g_hash_table_new_full(g_direct_hash,
-                               g_direct_equal, NULL, __free_cached_value);
+               caller_appid_cache_table = g_hash_table_new_full(g_str_hash,
+                               g_str_equal, NULL, __free_cached_value);
        }
 
        if (using_rtc) {

diff --git a/unittest/alarm_manager_unittest.cpp b/unittest/alarm_manager_unittest.cpp
index 67be189..e410510 100644 (file)
--- a/unittest/alarm_manager_unittest.cpp
+++ b/unittest/alarm_manager_unittest.cpp
@@ -118,9 +118,11 @@ static int __pkgmgrinfo_pkginfo_get_usr_pkginfo_fake(const char *pkgid, uid_t ui
   return 0;
 }
 
+static char *ver = "2.0";
 static int __pkgmgrinfo_pkginfo_get_api_version_fake(
     pkgmgrinfo_pkginfo_h handle, char **version)
 {
+  *version = ver;
   return 0;
 }
 
@@ -183,7 +185,7 @@ TEST_F(AlarmServerTest, alarm_manager_alarm_create_p)
       2019, 11, 1, 12, 59, 59, 400, 2020, 12, 29, 3, 1, 1, reserved,
       "reserved_service_name", "reserved_service_name_mod");
 
-  ret = alarm_manager_alarm_create(param, 5001, 1, &alarm_id);
+  ret = alarm_manager_alarm_create(param, 5001, 1, "sender", &alarm_id);
   EXPECT_EQ(ALARMMGR_RESULT_SUCCESS, ret);
 }
 
@@ -224,7 +226,7 @@ TEST_F(AlarmServerTest, alarm_manager_alarm_create_appsvc_p)
       2020, 12, 29,
       1, reserved, 1, 0, reserved,
       (char *)b_data);
-  ret = alarm_manager_alarm_create_appsvc(param, 5001, 1, &alarm_id);
+  ret = alarm_manager_alarm_create_appsvc(param, 5001, 1, "sender", &alarm_id);
   bundle_free(b);
   if (b_data)
     free(b_data);
@@ -240,7 +242,7 @@ TEST_F(AlarmServerTest, alarm_manager_alarm_create_periodic_p)
   param = g_variant_new("(ssiii)",
       "app_service_name", "app_service_name_mod", 1, 0, 1);
 
-  ret = alarm_manager_alarm_create_periodic(param, 5001, 1, &alarm_id);
+  ret = alarm_manager_alarm_create_periodic(param, 5001, 1, "sender", &alarm_id);
   EXPECT_EQ(ALARMMGR_RESULT_SUCCESS, ret);
 }
 
@@ -258,7 +260,7 @@ TEST_F(AlarmServerTest, alarm_manager_alarm_create_noti_p)
       "bundle");
 
 
-  ret = alarm_manager_alarm_create_noti(param, 5001, 1, &alarm_id);
+  ret = alarm_manager_alarm_create_noti(param, 5001, 1, "sender", &alarm_id);
   EXPECT_EQ(ALARMMGR_RESULT_SUCCESS, ret);
 }
 
@@ -269,7 +271,7 @@ TEST_F(AlarmServerTest, alarm_manager_alarm_delete_p)
 
   param = g_variant_new("(i)", 1);
 
-  ret = alarm_manager_alarm_delete(param, 5001, 1);
+  ret = alarm_manager_alarm_delete(param, 5001, 1, "sender");
   EXPECT_EQ(ERR_ALARM_INVALID_ID, ret);
 }
 
@@ -278,7 +280,7 @@ TEST_F(AlarmServerTest, alarm_manager_alarm_delete_all_p)
   int ret;
   GVariant *param = NULL;
 
-  ret = alarm_manager_alarm_delete_all(param, 5001, 1);
+  ret = alarm_manager_alarm_delete_all(param, 5001, 1, "sender");
   EXPECT_EQ(ALARMMGR_RESULT_SUCCESS, ret);
 }
 
@@ -295,7 +297,7 @@ TEST_F(AlarmServerTest, alarm_manager_alarm_update_n)
       2020, 12, 29, 0,
       reserved, 0, 0, reserved, 0);
 
-  ret = alarm_manager_alarm_update(param, 5001, 1);
+  ret = alarm_manager_alarm_update(param, 5001, 1, "sender");
   EXPECT_EQ(ERR_ALARM_INVALID_ID, ret);
 }
 
@@ -304,7 +306,7 @@ TEST_F(AlarmServerTest, alarm_manager_alarm_get_number_of_ids_p)
   int ret;
   int num_of_ids;
 
-  ret = alarm_manager_alarm_get_number_of_ids(5001, 1, &num_of_ids);
+  ret = alarm_manager_alarm_get_number_of_ids(5001, 1, "sender", &num_of_ids);
   EXPECT_EQ(ALARMMGR_RESULT_SUCCESS, ret);
 }
 
@@ -317,7 +319,7 @@ TEST_F(AlarmServerTest, alarm_manager_alarm_get_list_of_ids_p)
 
   param = g_variant_new("(i)", 10);
 
-  ret = alarm_manager_alarm_get_list_of_ids(param, 5001, 1, &alarm_array,
+  ret = alarm_manager_alarm_get_list_of_ids(param, 5001, 1, "sender", &alarm_array,
       &num_of_alarm);
   EXPECT_EQ(ALARMMGR_RESULT_SUCCESS, ret);
 }
@@ -403,7 +405,7 @@ TEST_F(AlarmServerTest, alarm_manager_alarm_set_time_n)
 
   param = g_variant_new("(x)", 20190012);
 
-  ret = alarm_manager_alarm_set_time(param, 1);
+  ret = alarm_manager_alarm_set_time(param, 1, "sender");
   EXPECT_EQ(ERR_ALARM_SYSTEM_FAIL, ret);
 }
 
@@ -414,7 +416,7 @@ TEST_F(AlarmServerTest, alarm_manager_alarm_set_time_with_propagation_delay_n)
 
   param = g_variant_new("(xxxx)", 20190012, 2949294, 292929, 29299292);
 
-  ret = alarm_manager_alarm_set_time_with_propagation_delay(param, 1);
+  ret = alarm_manager_alarm_set_time_with_propagation_delay(param, 1, "sender");
   EXPECT_EQ(ERR_ALARM_SYSTEM_FAIL, ret);
 }
 
@@ -450,7 +452,7 @@ TEST_F(AlarmServerTest, alarm_manager_alarm_set_global_n)
       2019, 11, 1, 12, 59, 59, 400, 2020, 12, 29, 3, 1, 1, reserved,
       "reserved_service_name", "reserved_service_name_mod");
 
-  ret = alarm_manager_alarm_create(param, 5001, 1, &alarm_id);
+  ret = alarm_manager_alarm_create(param, 5001, 1, "sender", &alarm_id);
   param2 = g_variant_new("(ib)", alarm_id, true);
 
   ret = alarm_manager_alarm_set_global(param2, 5001);

diff --git a/unittest/alarmlib_unittest.cpp b/unittest/alarmlib_unittest.cpp
index a9a852a..51dcfa3 100755 (executable)
--- a/unittest/alarmlib_unittest.cpp
+++ b/unittest/alarmlib_unittest.cpp
@@ -123,6 +123,11 @@ gsize __g_variant_get_size_fake(GVariant *var)
   return (gsize)size;
 }
 
+void __g_variant_store_fake(GVariant *var, gpointer data)
+{
+  return;
+}
+
 GVariant* __notification_ipc_make_gvariant_from_noti_fake(notification_h,
     bool translate)
 {
@@ -307,6 +312,7 @@ TEST_F(AlarmLibTest, alarmmgr_add_alarm_noti_n)
   alarm_id_t alarm_id;
   notification_h noti = nullptr;
 
+  g_variant_store_fake.custom_fake = __g_variant_store_fake;
   g_variant_get_size_fake.custom_fake = __g_variant_get_size_fake;
   g_dbus_proxy_call_sync_fake.custom_fake = __g_dbus_proxy_call_sync_fake_negative;
   notification_ipc_make_gvariant_from_noti_fake.custom_fake = __notification_ipc_make_gvariant_from_noti_fake;
@@ -316,7 +322,6 @@ TEST_F(AlarmLibTest, alarmmgr_add_alarm_noti_n)
   EXPECT_EQ(ERR_ALARM_NO_PERMISSION, ret);
 }
 
-
 TEST_F(AlarmLibTest, alarmmgr_get_alarm_noti_n)
 {
   int ret;
@@ -356,6 +361,7 @@ TEST_F(AlarmLibTest, alarmmgr_add_alarm_with_localtime_n)
   test_time.min = 1;
   test_time.sec = 5;
 
+  alarmmgr_fini();
   ret = alarmmgr_init(testapp);
   EXPECT_EQ(ALARMMGR_RESULT_SUCCESS, ret);
 
@@ -475,9 +481,11 @@ TEST_F(AlarmLibTest, alarmmgr_add_get_alarm_withcb_n)
 
   g_dbus_proxy_call_sync_fake.custom_fake = __g_dbus_proxy_call_sync_fake_negative;
 
+  alarmmgr_fini();
   ret = alarmmgr_add_alarm_withcb(ALARM_TYPE_VOLATILE, 100, 1000,
       __handler, NULL, &alarm_id);
   EXPECT_EQ(ERR_ALARM_NO_PERMISSION, ret);
+  alarmmgr_fini();
 }
 
 TEST_F(AlarmLibTest, alarmmgr_add_get_alarm_withcb_precision_n)
@@ -490,6 +498,7 @@ TEST_F(AlarmLibTest, alarmmgr_add_get_alarm_withcb_precision_n)
   ret = alarmmgr_add_alarm_withcb_precision(ALARM_TYPE_VOLATILE, 100, 1000,
       __handler, NULL, &alarm_id);
   EXPECT_EQ(ERR_ALARM_NO_PERMISSION, ret);
+  alarmmgr_fini();
 }
 
 TEST_F(AlarmLibTest, alarmmgr_remove_alarm_n)
@@ -552,6 +561,7 @@ TEST_F(AlarmLibTest, alarmmgr_add_periodic_alarm_withcb_n)
   ret = alarmmgr_add_periodic_alarm_withcb(1000, CUT_OFF, handler, NULL,
       &alarm_id);
   EXPECT_EQ(ERR_ALARM_NO_PERMISSION, ret);
+  alarmmgr_fini();
 }
 
 TEST_F(AlarmLibTest, alarmmgr_add_reference_periodic_alarm_withcb_n)
@@ -564,6 +574,7 @@ TEST_F(AlarmLibTest, alarmmgr_add_reference_periodic_alarm_withcb_n)
   ret = alarmmgr_add_reference_periodic_alarm_withcb(1000, handler, NULL,
       &alarm_id);
   EXPECT_EQ(ERR_ALARM_NO_PERMISSION, ret);
+  alarmmgr_fini();
 }
 
 TEST_F(AlarmLibTest, alarmmgr_set_systime_n)