alarm-manager.c

   1 /*
   2  * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #define _GNU_SOURCE
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <time.h>
  21 #include <signal.h>
  22 #include <string.h>
  23 #include <sys/socket.h>
  24 #include <sys/un.h>
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <sys/time.h>
  28 #include <unistd.h>
  29 #include <sys/timerfd.h>
  30 #include <poll.h>
  31 #include <stdint.h>
  32
  33 #include <tzplatform_config.h>
  34 #include <aul.h>
  35 #include <bundle.h>
  36 #include <db-util.h>
  37 #include <vconf.h>
  38 #include <vconf-keys.h>
  39 #include <dlfcn.h>
  40 #include <pkgmgr-info.h>
  41 #include <package-manager.h>
  42 #include <device/display.h>
  43 #include <systemd/sd-login.h>
  44 #include <eventsystem.h>
  45 #include <notification.h>
  46 #include <notification_ipc.h>
  47 #include <notification_internal.h>
  48
  49 #include <glib.h>
  50 #if !GLIB_CHECK_VERSION(2, 31, 0)
  51 #include <glib/gmacros.h>
  52 #endif
  53
  54 #include "gio/gio.h"
  55 #include "alarm.h"
  56 #include "alarm-internal.h"
  57 #include "alarm-mgr-stub.h"
  58
  59
  60 #define SIG_TIMER 0x32
  61 #define WAKEUP_ALARM_APP_ID       "org.tizen.alarm.ALARM"
  62 /* alarm ui application's alarm's dbus_service name instead of 21
  63  * (alarm application's app_id) value */
  64
  65 __alarm_server_context_t alarm_context;
  66 bool g_dummy_timer_is_set = FALSE;
  67
  68 GSList *g_scheduled_alarm_list = NULL;
  69 GSList *g_expired_alarm_list = NULL;
  70
  71 #ifndef RTC_WKALM_BOOT_SET
  72 #define RTC_WKALM_BOOT_SET _IOW('p', 0x80, struct rtc_wkalrm)
  73 #endif
  74
  75 /*
  76  * 2008. 6. 3 sewook7.park
  77  * When the alarm becoms sleeping mode, alarm timer is not expired.
  78  * So using RTC, phone is awaken before alarm rings.
  79  */
  80 #include <errno.h>
  81 #include <linux/rtc.h>
  82 #include <sys/ioctl.h>
  83 #include <fcntl.h>
  84
  85 #ifdef _APPFW_FEATURE_WAKEUP_USING_RTC
  86 static const char default_rtc[] = "/dev/rtc";
  87 static int gfd = -1;
  88 #endif /*__APPFW_FEATURE_WAKEUP_USING_RTC*/
  89
  90 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
  91 #define ALARMMGR_LOG_BUFFER_SIZE        10000
  92 #define ALARMMGR_LOG_BUFFER_STRING_SIZE 200
  93 #define ALARMMGR_LOG_TAG_SIZE           20
  94 #define ALARMMGR_LOG_MESSAGE_SIZE       120
  95 #define ALARMMGR_LOG_FILE_PATH  "/var/log/alarmmgr.log"
  96 static int log_index = 0;
  97 static int log_fd = 0;
  98 #endif
  99
 100 /* display lock and unlock */
 101 #define DEVICED_BUS_NAME "org.tizen.system.deviced"
 102 #define DEVICED_PATH_DISPLAY            "/Org/Tizen/System/DeviceD/Display"
 103 #define DEVICED_INTERFACE_DISPLAY       "org.tizen.system.deviced.display"
 104 #define DEVICED_LOCK_STATE              "lockstate"
 105 #define DEVICED_UNLOCK_STATE    "unlockstate"
 106 #define DEVICED_DBUS_REPLY_TIMEOUT      (120*1000)
 107 #define DEVICED_LCD_OFF         "lcdoff"
 108 #define DEVICED_STAY_CUR_STATE  "staycurstate"
 109 #define DEVICED_SLEEP_MARGIN            "sleepmargin"
 110
 111 /* link path for timezone info */
 112 #define TIMEZONE_INFO_LINK_PATH tzplatform_mkpath(TZ_SYS_ETC, "localtime")
 113
 114 /*  GDBus Declaration */
 115 #define ALARM_MGR_DBUS_PATH     "/org/tizen/alarm/manager"
 116 #define ALARM_MGR_DBUS_NAME     "org.tizen.alarm.manager"
 117 static AlarmManager* interface = NULL;
 118
 119 sqlite3 *alarmmgr_db;
 120 bool is_time_changed = false; /* for calculating next duetime */
 121
 122 #define BILLION 1000000000 /* for calculating nano seconds */
 123 static time_t periodic_alarm_standard_time = 0;
 124
 125 static bool __alarm_add_to_list(__alarm_info_t *__alarm_info);
 126 static void __alarm_generate_alarm_id(__alarm_info_t *__alarm_info, alarm_id_t *alarm_id);
 127 static bool __alarm_update_in_list(__alarm_info_t *__alarm_info,
 128                                    int *error_code);
 129 static bool __alarm_remove_from_list(uid_t uid, alarm_id_t alarm_id,
 130                                      int *error_code);
 131 static bool __alarm_set_start_and_end_time(alarm_info_t *alarm_info,
 132                                            __alarm_info_t *__alarm_info);
 133 static bool __alarm_update_due_time_of_all_items_in_list(double diff_time);
 134 static bool __alarm_create(alarm_info_t *alarm_info, alarm_id_t *alarm_id, uid_t uid,
 135                         int pid, periodic_method_e method, long requested_interval, int is_ref,
 136                         char *app_service_name, char *app_service_name_mod,
 137                         const char *dst_service_name, const char *dst_service_name_mod,
 138                         int *error_code);
 139 static bool __alarm_create_appsvc(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
 140                            long requested_interval, uid_t uid, int pid, char *bundle_data, int *error_code);
 141
 142 static bool __alarm_delete(uid_t uid, alarm_id_t alarm_id, int *error_code);
 143 static bool __alarm_update(uid_t uid, int pid, char *app_service_name, alarm_id_t alarm_id,
 144                            alarm_info_t *alarm_info, int *error_code);
 145 static void __alarm_send_noti_to_application(const char *app_service_name, alarm_id_t alarm_id, uid_t uid);
 146 static void __alarm_expired();
 147 static gboolean __alarm_handler_idle(gpointer user_data);
 148 static void __on_system_time_external_changed(keynode_t *node, void *data);
 149 static void __initialize_timer();
 150 static void __initialize_alarm_list();
 151 static void __initialize_scheduled_alarm_list();
 152 static bool __initialize_noti();
 153
 154 static bool __initialize_dbus();
 155 static bool __initialize_db();
 156 static void __initialize();
 157 void on_bus_name_owner_changed(GDBusConnection *connection, const gchar *sender_name, const gchar *object_path,
 158                 const gchar *interface_name, const gchar *signal_name, GVariant *parameters, gpointer user_data);
 159 bool __get_caller_unique_name(int pid, char *unique_name, bool *is_app, uid_t uid);
 160
 161 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
 162 static void __initialize_module_log(void);
 163 static bool __save_module_log(const char *tag, const char *messgae);
 164 #endif
 165
 166 int __display_lock_state(char *state, char *flag, unsigned int timeout);
 167 int __display_unlock_state(char *state, char *flag);
 168
 169 int __set_time(time_t _time);
 170
 171 struct filtered_alarm_app_s {
 172         int is_ui_app;
 173         uid_t uid;
 174 };
 175
 176 GHashTable* appid_cache_table = NULL;
 177
 178 typedef struct {
 179         int pid;
 180         bool is_app;
 181         char *unique_name;
 182 } appid_cache_t;
 183
 184 static bool __get_cached_unique_name(int pid, char *unique_name, bool *is_app, uid_t uid)
 185 {
 186         appid_cache_t *data = NULL;
 187         data = (appid_cache_t *)g_hash_table_lookup(appid_cache_table, &pid);
 188         if (data) {
 189                 snprintf(unique_name, MAX_APP_ID, "%s", data->unique_name);
 190                 if (is_app)
 191                         *is_app = data->is_app;
 192                 ALARM_MGR_LOG_PRINT("Get cached unique_name: %s, pid:%d", unique_name, pid);
 193                 return true;
 194         }
 195
 196         ALARM_MGR_LOG_PRINT("There is no cached unique_name for pid(%d)", pid);
 197         return __get_caller_unique_name(pid, unique_name, is_app, uid);
 198 }
 199
 200 gboolean __hash_table_remove_cb(gpointer key, gpointer value, gpointer user_data)
 201 {
 202         char *target_name = user_data;
 203         appid_cache_t *data = value;
 204         if (target_name && data && strcmp(target_name, data->unique_name) == 0) {
 205                 ALARM_MGR_LOG_PRINT("Remove cached data of [%s]", target_name);
 206                 return true;
 207         }
 208         return false;
 209 }
 210
 211 void __hashtable_foreach_cb(gpointer key, gpointer value, gpointer user_data)
 212 {
 213         appid_cache_t *data = value;
 214         if (data)
 215                 ALARM_MGR_LOG_PRINT("# %s(%d) - %s - %d", data->unique_name, data->pid, data->is_app);
 216 }
 217
 218 void __free_cached_value(gpointer data)
 219 {
 220         appid_cache_t* value = data;
 221
 222         if (value) {
 223                 if (value->unique_name)
 224                         free(value->unique_name);
 225                 free(value);
 226         }
 227 }
 228
 229 static void __rtc_set()
 230 {
 231 #ifdef _APPFW_FEATURE_WAKEUP_USING_RTC
 232         const char *rtc = default_rtc;
 233         struct tm due_tm;
 234 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
 235         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
 236 #endif
 237 #ifdef _SIMUL /* RTC does not work in simulator. */
 238         ALARM_MGR_EXCEPTION_PRINT("because it is simulator's mode, we don't set RTC.");
 239         return;
 240 #endif
 241
 242         if (gfd < 0) {
 243                 gfd = open(rtc, O_RDWR);
 244                 if (gfd < 0) {
 245                         ALARM_MGR_EXCEPTION_PRINT("RTC open failed.");
 246                         return;
 247                 }
 248         }
 249
 250         /* Read the RTC time/date */
 251         int retval = 0;
 252         char buf[1024];
 253 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
 254         char *timebuf = ctime(&alarm_context.c_due_time);
 255         if (timebuf) {
 256                 timebuf[strlen(timebuf) - 1] = '\0'; /* to avoid new line */
 257                 snprintf(log_message, sizeof(log_message), "wakeup time: %d, %s", (int)alarm_context.c_due_time, timebuf);
 258         }
 259 #endif
 260
 261         ALARM_MGR_LOG_PRINT("alarm_context.c_due_time is %d.", (int)alarm_context.c_due_time);
 262
 263         if (alarm_context.c_due_time != -1) {
 264                 struct rtc_wkalrm rtc_wkalarm = { 0, };
 265                 rtc_wkalarm.enabled = 0;
 266                 rtc_wkalarm.time.tm_year = 1900;
 267                 rtc_wkalarm.time.tm_mon = 0;
 268                 rtc_wkalarm.time.tm_mday = 1;
 269                 rtc_wkalarm.time.tm_hour = 0;
 270                 rtc_wkalarm.time.tm_min = 0;
 271                 rtc_wkalarm.time.tm_sec = 0;
 272
 273                 retval = ioctl(gfd, RTC_WKALM_SET, &rtc_wkalarm);
 274                 if (retval == -1) {
 275                         if (errno == ENOTTY)
 276                                 ALARM_MGR_EXCEPTION_PRINT("Alarm IRQs is not supported.");
 277
 278                         ALARM_MGR_EXCEPTION_PRINT("RTC_WKALM_SET disabled ioctl is failed. errno = %s", strerror_r(errno, buf, sizeof(buf)));
 279                         return;
 280                 }
 281                 ALARM_MGR_LOG_PRINT("[alarm-server]RTC_WKALM_SET disabled ioctl is successfully done.");
 282
 283                 time_t due_time = alarm_context.c_due_time;
 284                 localtime_r(&due_time, &due_tm);
 285
 286                 ALARM_MGR_LOG_PRINT("Setted RTC Alarm date/time is %d-%d-%d, %02d:%02d:%02d (UTC).",
 287                         due_tm.tm_mday, due_tm.tm_mon + 1, due_tm.tm_year + 1900,
 288                         due_tm.tm_hour, due_tm.tm_min, due_tm.tm_sec);
 289
 290                 rtc_wkalarm.enabled = 1;
 291                 rtc_wkalarm.time.tm_year = due_tm.tm_year;
 292                 rtc_wkalarm.time.tm_mon = due_tm.tm_mon;
 293                 rtc_wkalarm.time.tm_mday = due_tm.tm_mday;
 294                 rtc_wkalarm.time.tm_hour = due_tm.tm_hour;
 295                 rtc_wkalarm.time.tm_min = due_tm.tm_min;
 296                 rtc_wkalarm.time.tm_sec = due_tm.tm_sec - 1; /* Wakeup is 1000ms faster than expiring time to correct RTC error. */
 297                 retval = ioctl(gfd, RTC_WKALM_SET, &rtc_wkalarm);
 298                 if (retval == -1) {
 299                         if (errno == ENOTTY)
 300                                 ALARM_MGR_EXCEPTION_PRINT("Alarm IRQs is not supported.");
 301
 302                         ALARM_MGR_EXCEPTION_PRINT("RTC ALARM_SET ioctl is failed. errno = %s", strerror_r(errno, buf, sizeof(buf)));
 303 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
 304                         __save_module_log("FAIL: SET RTC", log_message);
 305 #endif
 306                         return;
 307                 }
 308                 ALARM_MGR_LOG_PRINT("[alarm-server]RTC ALARM_SET ioctl is successfully done.");
 309 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
 310                 __save_module_log("SET RTC", log_message);
 311 #endif
 312         } else {
 313                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]alarm_context.c_due_time is"
 314                         "less than 10 sec. RTC alarm does not need to be set");
 315         }
 316 #else
 317         ALARM_MGR_LOG_PRINT("[alarm-server] RTC does not work.");
 318 #endif /* _APPFW_FEATURE_WAKEUP_USING_RTC */
 319         return;
 320 }
 321
 322 int __set_time(time_t _time)
 323 {
 324         int ret = 0;
 325         struct timeval tv;
 326         struct tm tm, *gmtime_res;
 327
 328         tv.tv_sec = _time;
 329         tv.tv_usec = 0;
 330
 331         gmtime_res = gmtime_r(&(tv.tv_sec), &tm);
 332         if (!gmtime_res)
 333                 ALARM_MGR_EXCEPTION_PRINT("gmtime_r is failed. [%d]", errno);
 334
 335         ret = settimeofday(&tv, NULL);
 336         if (ret < 0)
 337                 ALARM_MGR_EXCEPTION_PRINT("settimeofday is failed.[%d]", errno);
 338
 339 #ifdef _APPFW_FEATURE_WAKEUP_USING_RTC
 340         /* Using /dev/alarm, this function changes both OS time and RTC. */
 341         const char *rtc0 = default_rtc;
 342         struct rtc_time _rtc_time;
 343 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
 344         char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
 345         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
 346 #endif
 347         char buf[1024];
 348
 349         if (gfd < 0) {
 350                 gfd = open(rtc0, O_RDWR);
 351                 if (gfd < 0) {
 352                         ALARM_MGR_EXCEPTION_PRINT("Opening the /dev/alarm is failed.");
 353                         perror("\t");
 354                         return 1;
 355                 }
 356         }
 357
 358         memset(&_rtc_time, 0, sizeof(_rtc_time));
 359         _rtc_time.tm_sec = tm.tm_sec;
 360         _rtc_time.tm_min = tm.tm_min;
 361         _rtc_time.tm_hour = tm.tm_hour;
 362         _rtc_time.tm_mday = tm.tm_mday;
 363         _rtc_time.tm_mon = tm.tm_mon;
 364         _rtc_time.tm_year = tm.tm_year;
 365         _rtc_time.tm_wday = tm.tm_wday;
 366         _rtc_time.tm_yday = tm.tm_yday;
 367         _rtc_time.tm_isdst = tm.tm_isdst;
 368
 369         ret = ioctl(gfd, RTC_SET_TIME, &_rtc_time);
 370         if (ret == -1) {
 371                 ALARM_MGR_EXCEPTION_PRINT("ALARM_SET_RTC ioctl is failed. errno = %s", strerror_r(errno, buf, sizeof(buf)));
 372 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
 373                 strncpy(log_tag, "FAIL: SET RTC", strlen("FAIL: SET RTC"));
 374 #endif
 375                 perror("\t");
 376         }
 377 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
 378         else
 379                 strncpy(log_tag, "SET RTC", strlen("SET RTC"));
 380
 381         char *timebuf = ctime(&_time);
 382         if (timebuf) {
 383                 timebuf[strlen(timebuf) - 1] = '\0'; /* to avoid new line */
 384                 snprintf(log_message, sizeof(log_message), "RTC & OS =%d, %s", (int)_time, timebuf);
 385         }
 386
 387         __save_module_log(log_tag, log_message);
 388 #endif
 389 #else
 390         ALARM_MGR_LOG_PRINT("[alarm-server] RTC does not work.");
 391 #endif /* _APPFW_FEATURE_WAKEUP_USING_RTC */
 392
 393         return 1;
 394 }
 395
 396 bool __alarm_clean_list()
 397 {
 398         g_slist_free_full(alarm_context.alarms, g_free);
 399         return true;
 400 }
 401
 402 static void __alarm_generate_alarm_id(__alarm_info_t *__alarm_info, alarm_id_t *alarm_id)
 403 {
 404         bool unique_id = false;
 405         __alarm_info_t *entry = NULL;
 406         GSList *iter = NULL;
 407
 408         srand((unsigned int)time(NULL));
 409         __alarm_info->alarm_id = (rand() % INT_MAX) + 1;
 410         ALARM_MGR_LOG_PRINT("__alarm_info->alarm_id is %d", __alarm_info->alarm_id);
 411
 412         while (unique_id == false) {
 413                 unique_id = true;
 414
 415                 for (iter = alarm_context.alarms; iter != NULL;
 416                      iter = g_slist_next(iter)) {
 417                         entry = iter->data;
 418                         if (entry->alarm_id == __alarm_info->alarm_id) {
 419                                 __alarm_info->alarm_id++;
 420                                 unique_id = false;
 421                         }
 422                 }
 423         }
 424
 425         *alarm_id = __alarm_info->alarm_id;
 426
 427         return;
 428 }
 429
 430 static bool __alarm_add_to_list(__alarm_info_t *__alarm_info)
 431 {
 432         alarm_info_t *alarm_info = &__alarm_info->alarm_info;
 433         __alarm_info_t *entry = NULL;
 434         GSList *iter = NULL;
 435
 436         ALARM_MGR_LOG_PRINT("[alarm-server]: Before add alarm_id(%d)", __alarm_info->alarm_id);
 437
 438         alarm_context.alarms = g_slist_append(alarm_context.alarms, __alarm_info);
 439         ALARM_MGR_LOG_PRINT("[alarm-server]: After add alarm_id(%d)", __alarm_info->alarm_id);
 440
 441         /* alarm list */
 442         for (iter = alarm_context.alarms; iter != NULL; iter = g_slist_next(iter)) {
 443                 entry = iter->data;
 444                 ALARM_MGR_LOG_PRINT("[alarm-server]: alarm_id(%d).", entry->alarm_id);
 445         }
 446
 447         if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
 448                 if (!_save_alarms(__alarm_info))
 449                         ALARM_MGR_EXCEPTION_PRINT("Saving alarm_id(%d) in DB is failed.", __alarm_info->alarm_id);
 450         }
 451
 452         return true;
 453 }
 454
 455 static bool __alarm_update_in_list(__alarm_info_t *__alarm_info,
 456                                    int *error_code)
 457 {
 458         bool found = false;
 459         alarm_info_t *alarm_info = &__alarm_info->alarm_info;
 460         GSList *iter = NULL;
 461         __alarm_info_t *entry = NULL;
 462
 463         for (iter = alarm_context.alarms; iter != NULL;
 464              iter = g_slist_next(iter)) {
 465                 entry = iter->data;
 466                 if (entry->uid == __alarm_info->uid &&
 467                                 entry->alarm_id == __alarm_info->alarm_id) {
 468                         found = true;
 469                         __alarm_info->quark_app_unique_name =
 470                             entry->quark_app_unique_name;
 471                         __alarm_info->quark_dst_service_name =
 472                             entry->quark_dst_service_name;
 473                         memcpy(entry, __alarm_info, sizeof(__alarm_info_t));
 474
 475                         break;
 476                 }
 477         }
 478
 479         if (!found) {
 480                 if (error_code)
 481                         *error_code = ERR_ALARM_INVALID_ID;
 482                 return false;
 483         }
 484
 485         if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
 486                 if (!_update_alarms(__alarm_info))
 487                         ALARM_MGR_EXCEPTION_PRINT("Updating alarm_id(%d) in DB is failed.", __alarm_info->alarm_id);
 488         }
 489
 490         return true;
 491 }
 492
 493 static bool __alarm_remove_from_list(uid_t uid, alarm_id_t alarm_id,
 494                                      int *error_code)
 495 {
 496         bool found = false;
 497
 498         alarm_info_t *alarm_info = NULL;
 499
 500         GSList *iter = NULL;
 501         __alarm_info_t *entry = NULL;
 502
 503         /*list alarms */
 504         ALARM_MGR_LOG_PRINT("[alarm-server]: before del : alarm id(%d)", alarm_id);
 505
 506         for (iter = alarm_context.alarms; iter != NULL; iter = g_slist_next(iter)) {
 507                 entry = iter->data;
 508                 if (entry->uid == uid && entry->alarm_id == alarm_id) {
 509                         alarm_info = &entry->alarm_info;
 510
 511                         ALARM_MGR_LOG_PRINT("[alarm-server]:Remove alarm id(%d)", entry->alarm_id);
 512
 513                         if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE))
 514                                 _delete_alarms(alarm_id);
 515
 516                         alarm_context.alarms = g_slist_remove(alarm_context.alarms, iter->data);
 517                         g_free(entry);
 518                         found = true;
 519                         break;
 520                 }
 521
 522         }
 523
 524         ALARM_MGR_LOG_PRINT("[alarm-server]: after del\n");
 525
 526         if (!found) {
 527                 if (error_code)
 528                         *error_code = ERR_ALARM_INVALID_ID;
 529                 return false;
 530         }
 531
 532         return true;
 533 }
 534
 535 static bool __alarm_set_start_and_end_time(alarm_info_t *alarm_info,
 536                                            __alarm_info_t *__alarm_info)
 537 {
 538         alarm_date_t *start = &alarm_info->start;
 539         alarm_date_t *end = &alarm_info->end;
 540
 541         struct tm alarm_tm = { 0, };
 542
 543         if (start->year != 0) {
 544                 if ((alarm_info->alarm_type & ALARM_TYPE_RELATIVE) &&  alarm_info->reserved_info != 0) {
 545                         __alarm_info->start = alarm_info->reserved_info;
 546                 } else {
 547                         alarm_tm.tm_year = start->year - 1900;
 548                         alarm_tm.tm_mon = start->month - 1;
 549                         alarm_tm.tm_mday = start->day;
 550
 551                         alarm_tm.tm_hour = start->hour;
 552                         alarm_tm.tm_min = start->min;
 553                         alarm_tm.tm_sec = start->sec;
 554                         alarm_tm.tm_isdst = -1;
 555
 556                         __alarm_info->start = mktime(&alarm_tm);
 557                 }
 558         } else {
 559                 __alarm_info->start = 0;
 560         }
 561
 562         if (end->year != 0) {
 563                 alarm_tm.tm_year = end->year - 1900;
 564                 alarm_tm.tm_mon = end->month - 1;
 565                 alarm_tm.tm_mday = end->day;
 566
 567                 alarm_tm.tm_hour = end->hour;
 568                 alarm_tm.tm_min = end->min;
 569                 alarm_tm.tm_sec = end->sec;
 570
 571                 __alarm_info->end = mktime(&alarm_tm);
 572         } else {
 573                 __alarm_info->end = 0;
 574         }
 575
 576         return true;
 577 }
 578
 579 /*
 580 static bool alarm_get_tz_info(int *gmt_idx, int *dst)
 581 {
 582         GConfValue *value1 = NULL;
 583         GConfValue *value2 = NULL;
 584         GConfClient* gConfClient = NULL;
 585         GError* err = NULL;
 586
 587         gConfClient = gconf_client_get_default();
 588
 589         if(gConfClient) {
 590                 value1 = gconf_client_get(gConfClient, SETTINGS_CLOCKTIMEZONE,
 591                                                                         &err);
 592                 if (err) {
 593                         ALARM_MGR_LOG_PRINT("__on_system_time_changed:
 594                         gconf_client_get() failed:
 595                         error:[%s]\n", err->message);
 596                         g_error_free(err);
 597                         err = NULL;
 598                 }
 599                 *gmt_idx = gconf_value_get_int(value1);
 600                 ALARM_MGR_LOG_PRINT("gconf return gmt_idx =%d\n ", *gmt_idx);
 601
 602                 value2 = gconf_client_get(gConfClient,
 603                         SETTINGS_DAYLIGHTSTATUS, &err);
 604                 if (err) {
 605                         ALARM_MGR_LOG_PRINT("__on_system_time_changed:
 606                 gconf_client_get() failed: error:[%s]\n", err->message);
 607                 g_error_free(err);
 608                 err = NULL;
 609         }
 610
 611         *dst = gconf_value_get_int(value2);
 612         ALARM_MGR_LOG_PRINT("gconf return dst =%d\n ", *dst);
 613
 614         if(gConfClient != NULL) {
 615                 g_object_unref(gConfClient);
 616                 gConfClient = NULL;
 617                 }
 618         }
 619         else
 620                 ALARM_MGR_LOG_PRINT("check the gconf setting failed!!!!! \n ");
 621
 622         if(value1) {
 623                 gconf_value_free(value1);
 624                 value1 = NULL;
 625         }
 626         if(value2) {
 627                 gconf_value_free(value2);
 628                 value2 = NULL;
 629         }
 630
 631         return true;
 632 }
 633 */
 634
 635 gboolean __update_relative_alarms(gpointer user_data)
 636 {
 637         GSList *iter = NULL;
 638         __alarm_info_t *entry = NULL;
 639         char *error_message = NULL;
 640
 641         if (sqlite3_exec(alarmmgr_db, "BEGIN EXCLUSIVE", NULL, NULL, &error_message) != SQLITE_OK) {
 642                 SECURE_LOGE("sqlite3_exec() is failed. error message = %s", error_message);
 643                 return false;
 644         }
 645
 646         for (iter = alarm_context.alarms; iter != NULL; iter = g_slist_next(iter)) {
 647                 entry = iter->data;
 648                 alarm_info_t *alarm_info = &(entry->alarm_info);
 649                 if (alarm_info->alarm_type & ALARM_TYPE_RELATIVE)
 650                         _update_alarms(entry);
 651         }
 652
 653         if (sqlite3_exec(alarmmgr_db, "COMMIT", NULL, NULL, &error_message) != SQLITE_OK) {
 654                 SECURE_LOGE("sqlite3_exec() is failed. error message = %s", error_message);
 655                 return false;
 656         }
 657
 658         return false;
 659 }
 660
 661 static bool __alarm_update_due_time_of_all_items_in_list(double diff_time)
 662 {
 663         time_t current_time;
 664         time_t min_time = -1;
 665         time_t due_time = 0;
 666         GSList *iter = NULL;
 667         __alarm_info_t *entry = NULL;
 668         struct tm *p_time = NULL ;
 669         struct tm due_time_result ;
 670         is_time_changed = true;
 671
 672         tzset();
 673         for (iter = alarm_context.alarms; iter != NULL; iter = g_slist_next(iter)) {
 674                 entry = iter->data;
 675                 alarm_info_t *alarm_info = &(entry->alarm_info);
 676                 if (alarm_info->alarm_type & ALARM_TYPE_RELATIVE) {
 677                         entry->due_time += diff_time;
 678
 679                         alarm_date_t *start = &alarm_info->start;       /**< start time of the alarm */
 680                         alarm_date_t *end = &alarm_info->end;   /**< end time of the alarm */
 681
 682                         p_time = localtime_r(&entry->due_time, &due_time_result);
 683                         if (p_time != NULL) {
 684                                 start->year = p_time->tm_year + 1900;
 685                                 start->month = p_time->tm_mon + 1;
 686                                 start->day = p_time->tm_mday;
 687                                 start->hour = p_time->tm_hour;
 688                                 start->min = p_time->tm_min;
 689                                 start->sec = p_time->tm_sec;
 690                         }
 691                         if (entry->start != 0) {
 692                                 entry->start = entry->due_time;
 693                         }
 694
 695                         if (entry->end != 0) {
 696                                 entry->end += diff_time;
 697                                 p_time = localtime_r(&entry->end, &due_time_result);
 698                                 if (p_time != NULL) {
 699                                         end->year = p_time->tm_year + 1900;
 700                                         end->month = p_time->tm_mon + 1;
 701                                         end->day = p_time->tm_mday;
 702                                         end->hour = p_time->tm_hour;
 703                                         end->min = p_time->tm_min;
 704                                         end->sec = p_time->tm_sec;
 705                                 }
 706                         }
 707                 }
 708                 _alarm_next_duetime(entry);
 709         }
 710
 711         time(&current_time);
 712
 713         for (iter = alarm_context.alarms; iter != NULL; iter = g_slist_next(iter)) {
 714                 entry = iter->data;
 715                 due_time = entry->due_time;
 716
 717                 double interval = 0;
 718
 719                 ALARM_MGR_LOG_PRINT("alarm[%d] with duetime(%u) at current(%u)", entry->alarm_id, due_time, current_time);
 720                 if (due_time == 0) {    /* 0 means this alarm has been disabled */
 721                         continue;
 722                 }
 723
 724                 interval = difftime(due_time, current_time);
 725
 726                 if (interval < 0) {
 727                         ALARM_MGR_EXCEPTION_PRINT("The duetime of alarm(%d) is OVER.", entry->alarm_id);
 728                         continue;
 729                 }
 730
 731                 interval = difftime(due_time, min_time);
 732
 733                 if ((interval < 0) || min_time == -1)
 734                         min_time = due_time;
 735         }
 736
 737         is_time_changed = false;
 738         alarm_context.c_due_time = min_time;
 739
 740         g_idle_add(__update_relative_alarms, NULL);
 741         return true;
 742 }
 743
 744 static bool __alarm_create_appsvc(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
 745                            long requested_interval, uid_t uid, int pid, char *bundle_data, int *error_code)
 746 {
 747         time_t current_time;
 748         time_t due_time;
 749         struct tm ts_ret;
 750         char due_time_r[100] = { 0 };
 751         char app_name[512] = { 0 };
 752         bundle *b;
 753         const char* callee_appid = NULL;
 754         char* caller_pkgid = NULL;
 755         char* callee_pkgid = NULL;
 756         pkgmgrinfo_pkginfo_h caller_handle;
 757         pkgmgrinfo_pkginfo_h callee_handle;
 758         bundle_raw *b_data = NULL;
 759         int datalen = 0;
 760         bool caller_is_app = false;
 761
 762         __alarm_info_t *__alarm_info = NULL;
 763
 764         __alarm_info = malloc(sizeof(__alarm_info_t));
 765         if (__alarm_info == NULL) {
 766                 SECURE_LOGE("Caution!! app_pid=%d, malloc failed. it seems to be OOM.", pid);
 767                 *error_code = ERR_ALARM_SYSTEM_FAIL;
 768                 return false;
 769         }
 770
 771         __alarm_info->uid = uid;
 772         __alarm_info->pid = pid;
 773         __alarm_info->alarm_id = -1;
 774         __alarm_info->requested_interval = requested_interval;
 775         __alarm_info->global = false;
 776
 777         if (__get_cached_unique_name(pid, app_name, &caller_is_app, uid) == false) {
 778                 *error_code = ERR_ALARM_SYSTEM_FAIL;
 779                 free(__alarm_info);
 780                 return false;
 781         }
 782         __alarm_info->quark_app_unique_name = g_quark_from_string(app_name);
 783
 784         /* caller */
 785         __alarm_info->quark_caller_pkgid = g_quark_from_string("null");
 786
 787         if (caller_is_app) {
 788                 if (pkgmgrinfo_appinfo_get_usr_appinfo(app_name, uid, &caller_handle) == PMINFO_R_OK) {
 789                         if (pkgmgrinfo_appinfo_get_pkgid(caller_handle, &caller_pkgid) == PMINFO_R_OK) {
 790                                 if (caller_pkgid)
 791                                         __alarm_info->quark_caller_pkgid = g_quark_from_string(caller_pkgid);
 792                         }
 793                         pkgmgrinfo_appinfo_destroy_appinfo(caller_handle);
 794                 }
 795         }
 796
 797         /* callee */
 798         __alarm_info->quark_callee_pkgid = g_quark_from_string("null");
 799
 800         b = bundle_decode((bundle_raw *)bundle_data, strlen(bundle_data));
 801         callee_appid = appsvc_get_appid(b);
 802         if (pkgmgrinfo_appinfo_get_usr_appinfo(callee_appid, uid, &callee_handle) == PMINFO_R_OK) {
 803                 if (pkgmgrinfo_appinfo_get_pkgid(callee_handle, &callee_pkgid) == PMINFO_R_OK) {
 804                         if (callee_pkgid)
 805                                 __alarm_info->quark_callee_pkgid = g_quark_from_string(callee_pkgid);
 806                 }
 807                 pkgmgrinfo_appinfo_destroy_appinfo(callee_handle);
 808         }
 809
 810         SECURE_LOGD("caller_pkgid = %s, callee_pkgid = %s",
 811                 g_quark_to_string(__alarm_info->quark_caller_pkgid), g_quark_to_string(__alarm_info->quark_callee_pkgid));
 812
 813         bundle_encode(b, &b_data, &datalen);
 814         __alarm_info->quark_bundle = g_quark_from_string((const gchar *)b_data);
 815         __alarm_info->quark_noti = g_quark_from_string("null");
 816         __alarm_info->quark_app_service_name = g_quark_from_string("null");
 817         __alarm_info->quark_dst_service_name = g_quark_from_string("null");
 818         __alarm_info->quark_app_service_name_mod = g_quark_from_string("null");
 819         __alarm_info->quark_dst_service_name_mod = g_quark_from_string("null");
 820
 821         bundle_free(b);
 822         if (b_data) {
 823                 free(b_data);
 824                 b_data = NULL;
 825         }
 826
 827         __alarm_set_start_and_end_time(alarm_info, __alarm_info);
 828         memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
 829         __alarm_generate_alarm_id(__alarm_info, alarm_id);
 830
 831         time(&current_time);
 832
 833         if (alarm_context.c_due_time < current_time) {
 834                 ALARM_MGR_EXCEPTION_PRINT("Caution!! alarm_context.c_due_time "
 835                 "(%d) is less than current time(%d)", alarm_context.c_due_time, current_time);
 836                 alarm_context.c_due_time = -1;
 837         }
 838
 839         due_time = _alarm_next_duetime(__alarm_info);
 840         if (__alarm_add_to_list(__alarm_info) == false) {
 841                 free(__alarm_info);
 842                 *error_code = ERR_ALARM_SYSTEM_FAIL;
 843                 return false;
 844         }
 845
 846         if (due_time == 0) {
 847                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create a new alarm: "
 848                 "due_time is 0, alarm(%d) \n", *alarm_id);
 849                 return true;
 850         } else if (current_time == due_time) {
 851                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create alarm: "
 852                      "current_time(%d) is same as due_time(%d)", current_time,
 853                      due_time);
 854                 return true;
 855         } else if (difftime(due_time, current_time) < 0) {
 856                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: Expired Due Time.[Due time=%d, Current Time=%d]!!!Do not add to schedule list\n", due_time, current_time);
 857                 return true;
 858         } else {
 859                 localtime_r(&due_time, &ts_ret);
 860                 strftime(due_time_r, 30, "%c", &ts_ret);
 861                 SECURE_LOGD("[alarm-server]:Create a new alarm: "
 862                                     "alarm(%d) due_time(%s)", *alarm_id,
 863                                     due_time_r);
 864         }
 865
 866         ALARM_MGR_LOG_PRINT("[alarm-server]:alarm_context.c_due_time(%d), due_time(%d)", alarm_context.c_due_time, due_time);
 867
 868         if (alarm_context.c_due_time == -1 || due_time < alarm_context.c_due_time) {
 869                 _clear_scheduled_alarm_list();
 870                 _add_to_scheduled_alarm_list(__alarm_info);
 871                 _alarm_set_timer(&alarm_context, alarm_context.timer, due_time);
 872                 alarm_context.c_due_time = due_time;
 873         } else if (due_time == alarm_context.c_due_time) {
 874                 _add_to_scheduled_alarm_list(__alarm_info);
 875         }
 876
 877         __rtc_set();
 878
 879         return true;
 880 }
 881
 882 static bool __alarm_create(alarm_info_t *alarm_info, alarm_id_t *alarm_id, uid_t uid,
 883                         int pid, periodic_method_e method, long requested_interval, int is_ref,
 884                         char *app_service_name, char *app_service_name_mod,
 885                         const char *dst_service_name, const char *dst_service_name_mod,
 886                         int *error_code)
 887 {
 888         time_t current_time;
 889         time_t due_time;
 890         char unique_name[MAX_APP_ID] = { 0 };
 891         char* caller_pkgid = NULL;
 892         pkgmgrinfo_pkginfo_h caller_handle;
 893         bool caller_is_app = false;
 894
 895         __alarm_info_t *__alarm_info = NULL;
 896
 897         __alarm_info = malloc(sizeof(__alarm_info_t));
 898         if (__alarm_info == NULL) {
 899                 SECURE_LOGE("Caution!! app_pid=%d, malloc "
 900                                           "failed. it seems to be OOM\n", pid);
 901                 *error_code = ERR_ALARM_SYSTEM_FAIL;
 902                 return false;
 903         }
 904         __alarm_info->uid = uid;
 905         __alarm_info->pid = pid;
 906         __alarm_info->alarm_id = -1;
 907         __alarm_info->quark_caller_pkgid = g_quark_from_string("null");
 908         __alarm_info->method = method;
 909         __alarm_info->requested_interval = requested_interval;
 910         __alarm_info->is_ref = is_ref;
 911         __alarm_info->global = false;
 912
 913         if (__get_cached_unique_name(pid, unique_name, &caller_is_app, uid) == false) {
 914                 *error_code = ERR_ALARM_SYSTEM_FAIL;
 915                 free(__alarm_info);
 916                 return false;
 917         }
 918
 919         /* Get caller_appid to get caller's package id. There is no callee. */
 920         if (caller_is_app) {
 921                 if (pkgmgrinfo_appinfo_get_usr_appinfo(unique_name, uid, &caller_handle) == PMINFO_R_OK) {
 922                         if (pkgmgrinfo_appinfo_get_pkgid(caller_handle, &caller_pkgid) == PMINFO_R_OK) {
 923                                 if (caller_pkgid)
 924                                         __alarm_info->quark_caller_pkgid = g_quark_from_string(caller_pkgid);
 925                         }
 926                         pkgmgrinfo_appinfo_destroy_appinfo(caller_handle);
 927                 }
 928         }
 929
 930         __alarm_info->quark_callee_pkgid = g_quark_from_string("null");
 931         SECURE_LOGD("caller_pkgid = %s, callee_pkgid = null", g_quark_to_string(__alarm_info->quark_caller_pkgid));
 932
 933         __alarm_info->quark_app_unique_name = g_quark_from_string(unique_name);
 934         __alarm_info->quark_app_service_name = g_quark_from_string(app_service_name);
 935         __alarm_info->quark_app_service_name_mod = g_quark_from_string(app_service_name_mod);
 936         __alarm_info->quark_dst_service_name = g_quark_from_string(dst_service_name);
 937         __alarm_info->quark_dst_service_name_mod = g_quark_from_string(dst_service_name_mod);
 938         __alarm_info->quark_bundle = g_quark_from_string("null");
 939         __alarm_info->quark_noti = g_quark_from_string("null");
 940
 941         __alarm_set_start_and_end_time(alarm_info, __alarm_info);
 942         memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
 943         __alarm_generate_alarm_id(__alarm_info, alarm_id);
 944
 945         time(&current_time);
 946
 947         SECURE_LOGD("[alarm-server]:pid=%d, app_unique_name=%s, "
 948                 "app_service_name=%s,dst_service_name=%s, c_due_time=%d", \
 949                 pid, g_quark_to_string(__alarm_info->quark_app_unique_name), \
 950                 g_quark_to_string(__alarm_info->quark_app_service_name), \
 951                 g_quark_to_string(__alarm_info->quark_dst_service_name), \
 952                             alarm_context.c_due_time);
 953
 954         if (alarm_context.c_due_time < current_time) {
 955                 ALARM_MGR_EXCEPTION_PRINT("Caution!! alarm_context.c_due_time "
 956                 "(%d) is less than current time(%d)", alarm_context.c_due_time, current_time);
 957                 alarm_context.c_due_time = -1;
 958         }
 959
 960         due_time = _alarm_next_duetime(__alarm_info);
 961         if (__alarm_add_to_list(__alarm_info) == false) {
 962                 free(__alarm_info);
 963                 return false;
 964         }
 965
 966         if (due_time == 0) {
 967                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create a new alarm: due_time is 0, alarm(%d).", *alarm_id);
 968                 return true;
 969         } else if (current_time == due_time) {
 970                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create alarm: current_time(%d) is same as due_time(%d).",
 971                         current_time, due_time);
 972                 return true;
 973         } else if (difftime(due_time, current_time) <  0) {
 974                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: Expired Due Time.[Due time=%d, Current Time=%d]!!!Do not add to schedule list.",
 975                         due_time, current_time);
 976                 return true;
 977         } else {
 978                 char due_time_r[100] = { 0 };
 979                 struct tm ts_ret;
 980                 localtime_r(&due_time, &ts_ret);
 981                 strftime(due_time_r, 30, "%c", &ts_ret);
 982                 SECURE_LOGD("[alarm-server]:Create a new alarm: alarm(%d) due_time(%s)", *alarm_id, due_time_r);
 983         }
 984
 985         ALARM_MGR_LOG_PRINT("[alarm-server]:alarm_context.c_due_time(%d), due_time(%d)", alarm_context.c_due_time, due_time);
 986
 987         if (alarm_context.c_due_time == -1 || due_time < alarm_context.c_due_time) {
 988                 _clear_scheduled_alarm_list();
 989                 _add_to_scheduled_alarm_list(__alarm_info);
 990                 _alarm_set_timer(&alarm_context, alarm_context.timer, due_time);
 991                 alarm_context.c_due_time = due_time;
 992         } else if (due_time == alarm_context.c_due_time) {
 993                 _add_to_scheduled_alarm_list(__alarm_info);
 994         }
 995
 996         __rtc_set();
 997
 998         return true;
 999 }
1000
1001 static bool __alarm_create_noti(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
1002                            long requested_interval, uid_t uid, int pid, char *noti_data, int *error_code)
1003 {
1004         time_t current_time;
1005         time_t due_time;
1006         struct tm ts_ret;
1007         char due_time_r[100] = { 0 };
1008         char app_name[512] = { 0 };
1009         char* caller_pkgid = NULL;
1010         pkgmgrinfo_pkginfo_h caller_handle;
1011         bool caller_is_app = false;
1012
1013         __alarm_info_t *__alarm_info = NULL;
1014
1015         __alarm_info = malloc(sizeof(__alarm_info_t));
1016         if (__alarm_info == NULL) {
1017                 SECURE_LOGE("Caution!! app_pid=%d, malloc "
1018                                           "failed. it seems to be OOM\n", pid);
1019                 *error_code = ERR_ALARM_SYSTEM_FAIL;
1020                 return false;
1021         }
1022         __alarm_info->uid = uid;
1023         __alarm_info->pid = pid;
1024         __alarm_info->alarm_id = -1;
1025         __alarm_info->requested_interval = requested_interval;
1026         __alarm_info->global = false;
1027
1028         if (__get_cached_unique_name(pid, app_name, &caller_is_app, uid) == false) {
1029                 *error_code = ERR_ALARM_SYSTEM_FAIL;
1030                 free(__alarm_info);
1031                 return false;
1032         }
1033         __alarm_info->quark_app_unique_name = g_quark_from_string(app_name);
1034
1035         __alarm_info->quark_caller_pkgid = g_quark_from_string("null");
1036
1037         if (caller_is_app) {
1038                 if (pkgmgrinfo_appinfo_get_usr_appinfo(app_name, uid, &caller_handle) == PMINFO_R_OK) {
1039                         if (pkgmgrinfo_appinfo_get_pkgid(caller_handle, &caller_pkgid) == PMINFO_R_OK) {
1040                                 if (caller_pkgid)
1041                                         __alarm_info->quark_caller_pkgid = g_quark_from_string(caller_pkgid);
1042                         }
1043                         pkgmgrinfo_appinfo_destroy_appinfo(caller_handle);
1044                 }
1045         }
1046
1047         __alarm_info->quark_callee_pkgid = g_quark_from_string("null");
1048         SECURE_LOGD("caller_pkgid = %s, callee_pkgid = null",
1049                 g_quark_to_string(__alarm_info->quark_caller_pkgid));
1050
1051         __alarm_info->quark_bundle = g_quark_from_string("null");
1052         __alarm_info->quark_noti = g_quark_from_string(noti_data);
1053         __alarm_info->quark_app_service_name = g_quark_from_string("null");
1054         __alarm_info->quark_dst_service_name = g_quark_from_string("null");
1055         __alarm_info->quark_app_service_name_mod = g_quark_from_string("null");
1056         __alarm_info->quark_dst_service_name_mod = g_quark_from_string("null");
1057
1058         __alarm_set_start_and_end_time(alarm_info, __alarm_info);
1059         memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
1060         __alarm_generate_alarm_id(__alarm_info, alarm_id);
1061
1062         time(&current_time);
1063
1064         SECURE_LOGD("[alarm-server]:pid=%d, app_unique_name=%s, "
1065                 "app_service_name=%s,dst_service_name=%s, c_due_time=%d", \
1066                 pid, g_quark_to_string(__alarm_info->quark_app_unique_name), \
1067                 g_quark_to_string(__alarm_info->quark_app_service_name), \
1068                 g_quark_to_string(__alarm_info->quark_dst_service_name), \
1069                             alarm_context.c_due_time);
1070
1071         if (alarm_context.c_due_time < current_time) {
1072                 ALARM_MGR_EXCEPTION_PRINT("Caution!! alarm_context.c_due_time "
1073                 "(%d) is less than current time(%d)", alarm_context.c_due_time, current_time);
1074                 alarm_context.c_due_time = -1;
1075         }
1076
1077         due_time = _alarm_next_duetime(__alarm_info);
1078         if (__alarm_add_to_list(__alarm_info) == false) {
1079                 free(__alarm_info);
1080                 return false;
1081         }
1082
1083         if (due_time == 0) {
1084                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create a new alarm: due_time is 0, alarm(%d).", *alarm_id);
1085                 return true;
1086         } else if (current_time == due_time) {
1087                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create alarm: current_time(%d) is same as due_time(%d).",
1088                         current_time, due_time);
1089                 return true;
1090         } else if (difftime(due_time, current_time) <  0) {
1091                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: Expired Due Time.[Due time=%d, Current Time=%d]!!!Do not add to schedule list.",
1092                         due_time, current_time);
1093                 return true;
1094         } else {
1095                 localtime_r(&due_time, &ts_ret);
1096                 strftime(due_time_r, 30, "%c", &ts_ret);
1097                 SECURE_LOGD("[alarm-server]:Create a new alarm: alarm(%d) due_time(%s)", *alarm_id, due_time_r);
1098         }
1099
1100         ALARM_MGR_LOG_PRINT("[alarm-server]:alarm_context.c_due_time(%d), due_time(%d)", alarm_context.c_due_time, due_time);
1101
1102         if (alarm_context.c_due_time == -1 || due_time < alarm_context.c_due_time) {
1103                 _clear_scheduled_alarm_list();
1104                 _add_to_scheduled_alarm_list(__alarm_info);
1105                 _alarm_set_timer(&alarm_context, alarm_context.timer, due_time);
1106                 alarm_context.c_due_time = due_time;
1107         } else if (due_time == alarm_context.c_due_time) {
1108                 _add_to_scheduled_alarm_list(__alarm_info);
1109         }
1110
1111         __rtc_set();
1112
1113         return true;
1114 }
1115
1116 static bool __alarm_update(uid_t uid, int pid, char *app_service_name, alarm_id_t alarm_id,
1117                            alarm_info_t *alarm_info, int *error_code)
1118 {
1119         time_t current_time;
1120         time_t due_time;
1121
1122         __alarm_info_t *__alarm_info = NULL;
1123         bool result = false;
1124
1125         __alarm_info = malloc(sizeof(__alarm_info_t));
1126         if (__alarm_info == NULL) {
1127                 SECURE_LOGE("Caution!! app_pid=%d, malloc failed. it seems to be OOM.", pid);
1128                 *error_code = ERR_ALARM_SYSTEM_FAIL;
1129                 return false;
1130         }
1131
1132         __alarm_info->uid = uid;
1133         __alarm_info->pid = pid;
1134         __alarm_info->alarm_id = alarm_id;
1135
1136         /* we should consider to check whether  pid is running or Not
1137          */
1138
1139         __alarm_info->quark_app_service_name =
1140             g_quark_from_string(app_service_name);
1141         __alarm_set_start_and_end_time(alarm_info, __alarm_info);
1142         memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
1143
1144         time(&current_time);
1145
1146         if (alarm_context.c_due_time < current_time) {
1147                 ALARM_MGR_EXCEPTION_PRINT("Caution!! alarm_context.c_due_time "
1148                 "(%d) is less than current time(%d)", alarm_context.c_due_time, current_time);
1149                 alarm_context.c_due_time = -1;
1150         }
1151
1152         due_time = _alarm_next_duetime(__alarm_info);
1153         if (!__alarm_update_in_list(__alarm_info, error_code)) {
1154                 free(__alarm_info);
1155                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: requested alarm_id "
1156                 "(%d) does not exist. so this value is invalid id.", alarm_id);
1157                 return false;
1158         }
1159
1160         result = _remove_from_scheduled_alarm_list(uid, alarm_id);
1161
1162         if (result == true && g_slist_length(g_scheduled_alarm_list) == 0) {
1163                 /*there is no scheduled alarm */
1164                 _alarm_disable_timer(alarm_context);
1165                 _alarm_schedule();
1166
1167                 ALARM_MGR_LOG_PRINT("[alarm-server]:Update alarm: alarm(%d).", alarm_id);
1168
1169                 __rtc_set();
1170
1171                 if (due_time == 0)
1172                         ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Update alarm: due_time is 0.");
1173
1174                 free(__alarm_info);
1175                 return true;
1176         }
1177
1178         if (due_time == 0) {
1179                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Update alarm: "
1180                                 "due_time is 0, alarm(%d)\n", alarm_id);
1181                 free(__alarm_info);
1182                 return true;
1183         } else if (current_time == due_time) {
1184                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Update alarm: "
1185                 "current_time(%d) is same as due_time(%d)", current_time,
1186                 due_time);
1187                 free(__alarm_info);
1188                 return true;
1189         } else if (difftime(due_time, current_time) < 0) {
1190                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: Expired Due Time.[Due time=%d, Current Time=%d]!!!Do not add to schedule list\n", due_time, current_time);
1191                 free(__alarm_info);
1192                 return true;
1193         } else {
1194                 char due_time_r[100] = { 0 };
1195                 struct tm ts_ret;
1196                 localtime_r(&due_time, &ts_ret);
1197                 strftime(due_time_r, 30, "%c", &ts_ret);
1198                 SECURE_LOGD("[alarm-server]:Update alarm: alarm(%d) "
1199                                     "due_time(%s)\n", alarm_id, due_time_r);
1200         }
1201
1202         ALARM_MGR_LOG_PRINT("[alarm-server]:alarm_context.c_due_time(%d), due_time(%d)", alarm_context.c_due_time, due_time);
1203
1204         if (alarm_context.c_due_time == -1 || due_time < alarm_context.c_due_time) {
1205                 _clear_scheduled_alarm_list();
1206                 _add_to_scheduled_alarm_list(__alarm_info);
1207                 _alarm_set_timer(&alarm_context, alarm_context.timer, due_time);
1208                 alarm_context.c_due_time = due_time;
1209                 ALARM_MGR_LOG_PRINT("[alarm-server1]:alarm_context.c_due_time "
1210                      "(%d), due_time(%d)", alarm_context.c_due_time, due_time);
1211         } else if (due_time == alarm_context.c_due_time) {
1212                 _add_to_scheduled_alarm_list(__alarm_info);
1213                 ALARM_MGR_LOG_PRINT("[alarm-server2]:alarm_context.c_due_time "
1214                      "(%d), due_time(%d)", alarm_context.c_due_time, due_time);
1215         }
1216
1217         __rtc_set();
1218
1219         free(__alarm_info);
1220
1221         return true;
1222 }
1223
1224 static bool __alarm_set_global_to_db(__alarm_info_t *alarm_info, bool global)
1225 {
1226
1227         char *error_message = NULL;
1228         char *query = sqlite3_mprintf("update alarmmgr set global=%d where alarm_id=%d",
1229                         alarm_info->global, alarm_info->alarm_id);
1230
1231         if (SQLITE_OK != sqlite3_exec(alarmmgr_db, query, NULL, NULL, &error_message)) {
1232                 SECURE_LOGE("sqlite3_exec() is failed. query = %s, error message = %s", query, error_message);
1233                 sqlite3_free(query);
1234                 return false;
1235         }
1236
1237         sqlite3_free(query);
1238         return true;
1239 }
1240
1241
1242 static bool __alarm_delete(uid_t uid, alarm_id_t alarm_id, int *error_code)
1243 {
1244         bool result = false;
1245
1246         SECURE_LOGD("[alarm-server]:delete alarm: alarm(%d) uid(%d)\n", alarm_id, uid);
1247         result = _remove_from_scheduled_alarm_list(uid, alarm_id);
1248
1249         if (!__alarm_remove_from_list(uid, alarm_id, error_code)) {
1250
1251                 SECURE_LOGE("[alarm-server]:delete alarm: "
1252                                           "alarm(%d) uid(%d) has failed with error_code(%d)\n",
1253                                           alarm_id, uid, *error_code);
1254                 return false;
1255         }
1256
1257         if (result == true && g_slist_length(g_scheduled_alarm_list) == 0) {
1258                 _alarm_disable_timer(alarm_context);
1259                 _alarm_schedule();
1260         }
1261
1262         __rtc_set();
1263
1264         return true;
1265 }
1266
1267 static bool __can_skip_expired_cb(alarm_id_t alarm_id)
1268 {
1269         GSList *gs_iter = NULL;
1270         __alarm_info_t *entry = NULL;
1271         alarm_info_t *alarm = NULL;
1272
1273         for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
1274                 entry = gs_iter->data;
1275                 if (entry->alarm_id == alarm_id) {
1276                         alarm = &(entry->alarm_info);
1277                         time_t ts = 0;
1278                         struct tm ts_tm;
1279                         int dur = entry->requested_interval;
1280                         int from, to;
1281
1282                         if (dur == 0 || !(alarm->alarm_type & ALARM_TYPE_PERIOD) || entry->method == CUT_OFF)
1283                                 return false;
1284
1285                         ts_tm.tm_hour = alarm->start.hour;
1286                         ts_tm.tm_min = alarm->start.min;
1287                         ts_tm.tm_sec = alarm->start.sec;
1288
1289                         ts_tm.tm_year = alarm->start.year - 1900;
1290                         ts_tm.tm_mon = alarm->start.month - 1;
1291                         ts_tm.tm_mday = alarm->start.day;
1292                         ts_tm.tm_isdst = -1;
1293
1294                         ts = mktime(&ts_tm);
1295
1296                         from = (ts / dur) * dur;
1297                         to = from + dur;
1298
1299                         if (ts >= from && ts < to && from > ts - alarm->mode.u_interval.interval)
1300                                 return false;
1301
1302                         return true;
1303                 }
1304         }
1305
1306         return false;
1307 }
1308
1309 static gboolean __send_noti_to_session_bus(char *service_name,
1310                 alarm_id_t alarm_id, uid_t uid)
1311 {
1312         int fd;
1313         int ret;
1314         int len;
1315         struct sockaddr_un saddr;
1316         uint8_t *data;
1317         GVariant *gv;
1318         uint8_t *gv_data;
1319
1320         fd = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
1321         if (fd < 0)
1322                 return FALSE;
1323
1324         saddr.sun_family = AF_UNIX;
1325         snprintf(saddr.sun_path, sizeof(saddr.sun_path),
1326                         "/run/alarm_agent/%d", uid);
1327
1328         ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
1329         if (ret < 0) {
1330                 ALARM_MGR_EXCEPTION_PRINT("connect failed - (errno %d)", errno);
1331                 close(fd);
1332                 return FALSE;
1333         }
1334
1335         gv = g_variant_new("(is)", alarm_id, service_name);
1336         if (!gv) {
1337                 close(fd);
1338                 return FALSE;
1339         }
1340
1341         len = g_variant_get_size(gv);
1342
1343         gv_data = NULL;
1344         if (len > 0)
1345                 gv_data = malloc(len);
1346
1347         if (!gv_data) {
1348                 g_variant_unref(gv);
1349                 close(fd);
1350                 return FALSE;
1351         }
1352
1353         g_variant_store(gv, gv_data);
1354         g_variant_unref(gv);
1355
1356         data = malloc(len + 4);
1357         if (!data) {
1358                 close(fd);
1359                 return FALSE;
1360         }
1361
1362         memcpy(data, &len, 4);
1363         memcpy(data + 4, gv_data, len);
1364         free(gv_data);
1365
1366         if (send(fd, data, len + 4, 0) == -1) {
1367                 ALARM_MGR_EXCEPTION_PRINT("sendto() failed (errno %d)", errno);
1368                 free(data);
1369                 close(fd);
1370                 return FALSE;
1371         }
1372
1373         free(data);
1374         close(fd);
1375         return TRUE;
1376 }
1377
1378 static void __alarm_send_noti_to_application(const char *app_service_name, alarm_id_t alarm_id, uid_t uid)
1379 {
1380         char service_name[MAX_SERVICE_NAME_LEN] = {0,};
1381         gboolean ret;
1382
1383         if (app_service_name == NULL || strlen(app_service_name) == 0) {
1384                 ALARM_MGR_EXCEPTION_PRINT("This alarm destination is invalid.");
1385                 return;
1386         }
1387
1388         if (__can_skip_expired_cb(alarm_id))
1389                 return;
1390
1391         memcpy(service_name, app_service_name, strlen(app_service_name));
1392         SECURE_LOGI("[alarm server][send expired_alarm(alarm_id=%d) to app_service_name(%s)]", alarm_id, service_name);
1393
1394         if (uid >= REGULAR_UID_MIN) {
1395                 ret = __send_noti_to_session_bus(service_name, alarm_id, uid);
1396                 if (ret != TRUE)
1397                         ALARM_MGR_EXCEPTION_PRINT("failed to send alarm expired noti for %d, %s",
1398                                         alarm_id, service_name);
1399         } else {
1400                 g_dbus_connection_call(alarm_context.connection,
1401                                 service_name,
1402                                 "/org/tizen/alarm/client",
1403                                 "org.tizen.alarm.client",
1404                                 "alarm_expired",
1405                                 g_variant_new("(is)", alarm_id, service_name),
1406                                 NULL,
1407                                 G_DBUS_CALL_FLAGS_NONE,
1408                                 -1,
1409                                 NULL,
1410                                 NULL,
1411                                 NULL);
1412         }
1413 }
1414
1415 static int __get_caller_uid(const char *name)
1416 {
1417         guint uid;
1418         GVariant *ret;
1419         GError *error = NULL;
1420
1421         ret = g_dbus_connection_call_sync(
1422                         alarm_context.connection,
1423                         "org.freedesktop.DBus",
1424                         "/org/freedesktop/DBus",
1425                         "org.freedesktop.DBus",
1426                         "GetConnectionUnixUser",
1427                         g_variant_new("(s)", name),
1428                         NULL,
1429                         G_DBUS_CALL_FLAGS_NONE,
1430                         -1,
1431                         NULL,
1432                         &error);
1433         if (!ret) {
1434                 ALARM_MGR_EXCEPTION_PRINT("failed to get caller uid");
1435                 if (error) {
1436                         ALARM_MGR_EXCEPTION_PRINT("dbus error message :  %s", error->message);
1437                         g_error_free(error);
1438                 }
1439                 return -1;
1440         }
1441         g_variant_get(ret, "(u)", &uid);
1442         g_variant_unref(ret);
1443
1444         return uid;
1445 }
1446
1447 static int __get_caller_pid(const char *name)
1448 {
1449         guint pid;
1450         GVariant *ret;
1451         GError *error = NULL;
1452
1453         ret = g_dbus_connection_call_sync(alarm_context.connection,
1454                                         "org.freedesktop.DBus",
1455                                         "/org/freedesktop/DBus",
1456                                         "org.freedesktop.DBus",
1457                                         "GetConnectionUnixProcessID",
1458                                         g_variant_new("(s)", name),
1459                                         NULL,
1460                                         G_DBUS_CALL_FLAGS_NONE,
1461                                         -1,
1462                                         NULL,
1463                                         &error);
1464         if (!ret) {
1465                 ALARM_MGR_EXCEPTION_PRINT("failed to get caller pid");
1466                 if (error) {
1467                         ALARM_MGR_EXCEPTION_PRINT("dbus error message :  %s", error->message);
1468                         g_error_free(error);
1469                 }
1470                 return -1;
1471         }
1472         g_variant_get(ret, "(u)", &pid);
1473         g_variant_unref(ret);
1474
1475         return pid;
1476 }
1477
1478 static int __is_ui_app(const char *appid, uid_t uid)
1479 {
1480         if (appid == NULL)
1481                 return 0;
1482
1483         int ret = 0;
1484         pkgmgrinfo_appinfo_h appinfo_h = NULL;
1485
1486         ret = pkgmgrinfo_appinfo_get_usr_appinfo(appid, uid, &appinfo_h);
1487
1488         if (ret < 0)
1489                 return 0;
1490
1491         char *component = NULL;
1492         int found = 0;
1493
1494         ret = pkgmgrinfo_appinfo_get_component_type(appinfo_h, &component);
1495         if (ret == 0 && component != NULL && strncmp(component, "uiapp", 5) == 0)
1496                 found = 1;
1497
1498         if (appinfo_h)
1499                 pkgmgrinfo_appinfo_destroy_appinfo(appinfo_h);
1500
1501         return found;
1502 }
1503
1504 static int __compare_api_version(int *result, int pid, uid_t uid)
1505 {
1506         int ret = 0;
1507         pkgmgrinfo_pkginfo_h pkginfo = NULL;
1508         char pkgid[512] = {0, };
1509         char *pkg_version;
1510
1511         if (aul_app_get_pkgid_bypid_for_uid(pid, pkgid, sizeof(pkgid), uid) != AUL_R_OK) {
1512                 ALARM_MGR_EXCEPTION_PRINT("aul_app_get_pkgid_bypid() is failed. PID %d may not be app.", getpid());
1513         } else {
1514                 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &pkginfo);
1515                 if (ret != PMINFO_R_OK) {
1516                         ALARM_MGR_EXCEPTION_PRINT("Failed to get pkginfo\n");
1517                 } else {
1518                         ret = pkgmgrinfo_pkginfo_get_api_version(pkginfo, &pkg_version);
1519                         if (ret != PMINFO_R_OK)
1520                                 ALARM_MGR_EXCEPTION_PRINT("Failed to check api version [%d]\n", ret);
1521                         *result = strverscmp(pkg_version, "2.4");
1522                         pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
1523                 }
1524         }
1525         return ret;
1526 }
1527
1528 static int __find_login_user(uid_t *uid)
1529 {
1530         uid_t *uids;
1531         int ret, i;
1532         char *state;
1533
1534         ret = sd_get_uids(&uids);
1535         if (ret <= 0)
1536                 return -1;
1537
1538         for (i = 0; i < ret ; i++) {
1539                 if (sd_uid_get_state(uids[i], &state) < 0) {
1540                         free(uids);
1541                         return -1;
1542                 } else {
1543                         if (!strncmp(state, "online", 6)) {
1544                                 *uid = uids[i];
1545                                 free(uids);
1546                                 free(state);
1547                                 return 0;
1548                         }
1549                 }
1550         }
1551         free(uids);
1552         free(state);
1553         return -1;
1554 }
1555
1556 static void __alarm_expired()
1557 {
1558         int ret;
1559         const char *destination_app_service_name = NULL;
1560         alarm_id_t alarm_id = -1;
1561         int app_pid = 0;
1562         __alarm_info_t *__alarm_info = NULL;
1563         char alarm_id_val[32];
1564         int b_len = 0;
1565         bundle *b = NULL;
1566         char *appid = NULL;
1567         uid_t target_uid;
1568 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
1569         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1570 #endif
1571
1572         ALARM_MGR_LOG_PRINT("[alarm-server]: Enter");
1573
1574         time_t current_time;
1575         double interval;
1576
1577         time(&current_time);
1578
1579         interval = difftime(alarm_context.c_due_time, current_time);
1580         ALARM_MGR_LOG_PRINT("[alarm-server]: c_due_time(%d), current_time(%d), interval(%d)",
1581                 alarm_context.c_due_time, current_time, interval);
1582
1583         if (alarm_context.c_due_time > current_time + 1) {
1584                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: False Alarm. due time is (%d) seconds future",
1585                         alarm_context.c_due_time - current_time);
1586                 goto done;
1587         }
1588         /* 10 seconds is maximum permitted delay from timer expire to this function */
1589         if (alarm_context.c_due_time + 10 < current_time) {
1590                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: False Alarm. due time is (%d) seconds past.",
1591                         current_time - alarm_context.c_due_time);
1592                 goto done;
1593         }
1594
1595         GSList *iter = NULL;
1596         __scheduled_alarm_t *alarm = NULL;
1597
1598         for (iter = g_scheduled_alarm_list; iter != NULL; iter = g_slist_next(iter)) {
1599                 alarm = iter->data;
1600                 alarm_id = alarm->alarm_id;
1601                 __alarm_info = alarm->__alarm_info;
1602                 app_pid = __alarm_info->pid;
1603
1604                 /* Case #1. The process is an application launched by app_control.
1605                  * It registered an alarm using launch-based APIs like alarm_schedule_xxx, alarmmgr_xxx_appsvc. */
1606                 if (strncmp(g_quark_to_string(__alarm_info->quark_bundle), "null", 4) != 0) {
1607                         b_len = strlen(g_quark_to_string(__alarm_info->quark_bundle));
1608
1609                         b = bundle_decode((bundle_raw *)g_quark_to_string(__alarm_info->quark_bundle), b_len);
1610
1611                         if (b == NULL) {
1612                                 ALARM_MGR_EXCEPTION_PRINT("Error!!!..Unable to decode the bundle!!\n");
1613                         } else {
1614                                 snprintf(alarm_id_val, sizeof(alarm_id_val), "%d", alarm_id);
1615
1616                                 if (bundle_add_str(b, "http://tizen.org/appcontrol/data/alarm_id", alarm_id_val)) {
1617                                         ALARM_MGR_EXCEPTION_PRINT("Unable to add alarm id to the bundle\n");
1618                                 } else {
1619                                         int result = 0;
1620
1621                                         if (__compare_api_version(&result, app_pid, __alarm_info->uid) < 0) {
1622                                                 ALARM_MGR_EXCEPTION_PRINT("Unable to check api version\n");
1623                                                 result = -1;
1624                                         }
1625
1626                                         if (result < 0) {
1627                                                 /* before 2.4 */
1628                                                 if (appsvc_usr_run_service(b, 0, NULL, NULL, __alarm_info->uid) < 0)
1629                                                         ALARM_MGR_EXCEPTION_PRINT("Unable to run app svc\n");
1630                                                 else
1631                                                         ALARM_MGR_LOG_PRINT("Successfuly run app svc\n");
1632                                         } else {
1633                                                 /* since 2.4 */
1634                                                 appid = (char *)appsvc_get_appid(b);
1635                                                 if ((__alarm_info->alarm_info.alarm_type & ALARM_TYPE_NOLAUNCH) && !aul_app_is_running(appid)) {
1636                                                         ALARM_MGR_EXCEPTION_PRINT("This alarm is ignored\n");
1637                                                 } else if (!(__alarm_info->alarm_info.alarm_type & ALARM_TYPE_INEXACT) ||
1638                                                                 !__can_skip_expired_cb(__alarm_info->alarm_id)) {
1639                                                         if (__alarm_info->global) {
1640                                                                 if (__find_login_user(&target_uid) < 0) {
1641                                                                         ALARM_MGR_EXCEPTION_PRINT("Fail to get login user\n");
1642                                                                         ret = -1;
1643                                                                 } else {
1644                                                                         ret = appsvc_usr_run_service(b, 0, NULL, NULL, target_uid);
1645                                                                 }
1646                                                         } else {
1647                                                                 ret = appsvc_usr_run_service(b, 0, NULL, NULL, __alarm_info->uid);
1648                                                         }
1649
1650                                                         if (ret < 0) {
1651                                                                 ALARM_MGR_EXCEPTION_PRINT("Unable to launch app [%s] \n", appid);
1652                                                         } else {
1653                                                                 ALARM_MGR_LOG_PRINT("Successfuly ran app svc\n");
1654                                                                 if (__is_ui_app(appid, __alarm_info->uid))
1655                                                                         device_display_change_state(DISPLAY_STATE_NORMAL);
1656                                                         }
1657                                                 }
1658                                         }
1659                                 }
1660                                 bundle_free(b);
1661                         }
1662                 } else if (strncmp(g_quark_to_string(__alarm_info->quark_noti), "null", 4) != 0) {
1663                         GVariant *noti_gv = NULL;
1664                         GVariant *body = NULL;
1665                         guchar *data;
1666                         notification_h noti;
1667                         int datalen;
1668
1669                         data = g_base64_decode(g_quark_to_string(__alarm_info->quark_noti),
1670                                         (gsize *)&datalen);
1671
1672                         noti_gv = g_variant_new_from_data(G_VARIANT_TYPE("(v)"),
1673                                         data, datalen,
1674                                         TRUE, NULL, NULL);
1675
1676                         g_variant_get(noti_gv, "(v)", &body);
1677
1678                         noti = notification_create(NOTIFICATION_TYPE_NOTI);
1679                         notification_ipc_make_noti_from_gvariant(noti, body);
1680                         notification_post_for_uid(noti, __alarm_info->uid);
1681                 } else {
1682                         char appid[MAX_SERVICE_NAME_LEN] = { 0, };
1683                         pkgmgrinfo_appinfo_h appinfo_handle = NULL;
1684
1685                         if (g_quark_to_string(__alarm_info->quark_bundle) != NULL && strncmp(g_quark_to_string(__alarm_info->quark_dst_service_name), "null", 4) == 0) {
1686                                 SECURE_LOGD("[alarm-server]:destination is null, so we send expired alarm to %s(%u).",
1687                                                 g_quark_to_string(__alarm_info->quark_app_service_name), __alarm_info->quark_app_service_name);
1688                                 destination_app_service_name = g_quark_to_string(__alarm_info->quark_app_service_name_mod);
1689                         } else {
1690                                 SECURE_LOGD("[alarm-server]:destination :%s(%u)",
1691                                                 g_quark_to_string(__alarm_info->quark_dst_service_name), __alarm_info->quark_dst_service_name);
1692                                 destination_app_service_name = g_quark_to_string(__alarm_info->quark_dst_service_name_mod);
1693                         }
1694
1695                         /*
1696                          * we should consider a situation that
1697                          * destination_app_service_name is owner_name like (:xxxx) and
1698                          * application's pid which registered this alarm was killed.In that case,
1699                          * we don't need to send the expire event because the process was killed.
1700                          * this causes needless message to be sent.
1701                          */
1702                         SECURE_LOGD("[alarm-server]: destination_app_service_name :%s, app_pid=%d", destination_app_service_name, app_pid);
1703
1704                         if (g_quark_to_string(__alarm_info->quark_dst_service_name) != NULL && strncmp(g_quark_to_string(__alarm_info->quark_dst_service_name), "null", 4) == 0) {
1705                                 if (g_quark_to_string(__alarm_info->quark_app_service_name) != NULL && strlen(g_quark_to_string(__alarm_info->quark_app_service_name)) > 6)
1706                                         strncpy(appid, g_quark_to_string(__alarm_info->quark_app_service_name) + 6, strlen(g_quark_to_string(__alarm_info->quark_app_service_name)) - 6);
1707                         } else {
1708                                 if (g_quark_to_string(__alarm_info->quark_dst_service_name)  != NULL && strlen(g_quark_to_string(__alarm_info->quark_dst_service_name)) > 6)
1709                                         strncpy(appid,  g_quark_to_string(__alarm_info->quark_dst_service_name) + 6, strlen(g_quark_to_string(__alarm_info->quark_dst_service_name)) - 6);
1710                         }
1711
1712                         ret = pkgmgrinfo_appinfo_get_usr_appinfo(appid, __alarm_info->uid, &appinfo_handle);
1713                         ALARM_MGR_LOG_PRINT("appid : %s (%x)", appid, appinfo_handle);
1714
1715                         /* Case #2. The process was killed && App type
1716                          * This app is launched and owner of DBus connection is changed. and then, expiration noti is sent by DBus. */
1717                         if (ret == PMINFO_R_OK && !aul_app_is_running_for_uid(appid, __alarm_info->uid)) {
1718                                 __expired_alarm_t *expire_info;
1719                                 char alarm_id_str[32] = { 0, };
1720
1721                                 if (__alarm_info->alarm_info.alarm_type & ALARM_TYPE_WITHCB) {
1722                                         __alarm_remove_from_list(__alarm_info->uid, alarm_id, NULL);
1723                                         goto done;
1724                                 }
1725
1726                                 expire_info = malloc(sizeof(__expired_alarm_t));
1727                                 if (G_UNLIKELY(NULL == expire_info)) {
1728                                         ALARM_MGR_ASSERT_PRINT("[alarm-server]:Malloc failed!Can't notify alarm expiry info\n");
1729                                         goto done;
1730                                 }
1731                                 memset(expire_info, '\0', sizeof(__expired_alarm_t));
1732                                 strncpy(expire_info->service_name, destination_app_service_name, MAX_SERVICE_NAME_LEN-1);
1733                                 expire_info->alarm_id = alarm_id;
1734                                 expire_info->uid = __alarm_info->uid;
1735                                 g_expired_alarm_list = g_slist_append(g_expired_alarm_list, expire_info);
1736
1737                                 snprintf(alarm_id_str, 31, "%d", alarm_id);
1738
1739                                 SECURE_LOGD("before aul_launch appid(%s) alarm_id_str(%s)", appid, alarm_id_str);
1740
1741                                 bundle *kb;
1742                                 kb = bundle_create();
1743                                 bundle_add_str(kb, "__ALARM_MGR_ID", alarm_id_str);
1744
1745                                 if (__alarm_info->global) {
1746                                         if (__find_login_user(&target_uid) < 0)
1747                                                 ALARM_MGR_EXCEPTION_PRINT("Fail to get login user\n");
1748                                         else
1749                                                 aul_launch_app_for_uid(appid, kb, target_uid); /* on_bus_name_owner_changed will be called. */
1750                                 } else {
1751                                         aul_launch_app_for_uid(appid, kb, __alarm_info->uid); /* on_bus_name_owner_changed will be called. */
1752                                 }
1753
1754                                 bundle_free(kb);
1755                         } else {
1756                                 /* Case #3. The process is alive or was killed && non-app type(daemon)
1757                                  * Expiration noti is sent by DBus. it makes the process alive. (dbus auto activation) */
1758                                 ALARM_MGR_LOG_PRINT("before alarm_send_noti_to_application");
1759                                 ALARM_MGR_LOG_PRINT("WAKEUP pid: %d", __alarm_info->pid);
1760
1761                                 /* TODO: implement aul_update_freezer_status */
1762                                 /* aul_update_freezer_status(__alarm_info->pid, "wakeup"); */
1763                                 __alarm_send_noti_to_application(destination_app_service_name,
1764                                                 alarm_id, __alarm_info->uid); /* dbus auto activation */
1765                                 ALARM_MGR_LOG_PRINT("after __alarm_send_noti_to_application");
1766                         }
1767                 }
1768
1769                 ALARM_MGR_LOG_PRINT("alarm_id[%d] is expired.", alarm_id);
1770
1771 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
1772                 snprintf(log_message, sizeof(log_message), "alarmID: %d, pid: %d, duetime: %d", alarm_id, app_pid, (int)__alarm_info->due_time);
1773                 __save_module_log("EXPIRED", log_message);
1774 #endif
1775
1776                 if (__alarm_info->alarm_info.mode.repeat == ALARM_REPEAT_MODE_ONCE)
1777                         __alarm_remove_from_list(__alarm_info->uid, alarm_id, NULL);
1778                 else
1779                         _alarm_next_duetime(__alarm_info);
1780         }
1781
1782 done:
1783         _clear_scheduled_alarm_list();
1784         alarm_context.c_due_time = -1;
1785
1786         ALARM_MGR_LOG_PRINT("[alarm-server]: Leave");
1787 }
1788
1789 static gboolean __alarm_handler_idle(gpointer user_data)
1790 {
1791         GPollFD *gpollfd = (GPollFD *) user_data;
1792         uint64_t exp;
1793         time_t current_time;
1794
1795         if (gpollfd == NULL) {
1796                 ALARM_MGR_EXCEPTION_PRINT("gpollfd is NULL");
1797                 return false;
1798         }
1799
1800         if (read(gpollfd->fd, &exp, sizeof(uint64_t)) < 0) {
1801                 ALARM_MGR_EXCEPTION_PRINT("Reading the fd is failed.");
1802                 return false;
1803         }
1804
1805         ALARM_MGR_LOG_PRINT("Lock the display not to enter LCD OFF");
1806         if (__display_lock_state(DEVICED_LCD_OFF, DEVICED_STAY_CUR_STATE, 0) != ALARMMGR_RESULT_SUCCESS)
1807                 ALARM_MGR_EXCEPTION_PRINT("__display_lock_state() is failed");
1808
1809         if (g_dummy_timer_is_set == true) {
1810                 ALARM_MGR_LOG_PRINT("dummy alarm timer has expired.");
1811         } else {
1812                 ALARM_MGR_LOG_PRINT("__alarm_handler_idle");
1813                 __alarm_expired();
1814         }
1815
1816         _alarm_schedule();
1817
1818         /*
1819          * Previous alarm can be expired late as tolerance of RTC.
1820          * In this case, Expire alarms forcibly if real duetime is same to current time.
1821          */
1822         time(&current_time);
1823         if (alarm_context.c_due_time == current_time) {
1824                 ALARM_MGR_LOG_PRINT("Expire alarms forcibly when duetime is same to current time(%d).", current_time);
1825                 __alarm_expired();
1826                 _alarm_schedule();
1827         }
1828
1829         __rtc_set();
1830
1831         ALARM_MGR_LOG_PRINT("Unlock the display from LCD OFF");
1832         if (__display_unlock_state(DEVICED_LCD_OFF, DEVICED_SLEEP_MARGIN) != ALARMMGR_RESULT_SUCCESS)
1833                 ALARM_MGR_EXCEPTION_PRINT("__display_unlock_state() is failed");
1834
1835         return false;
1836 }
1837
1838 static void __on_system_time_external_changed(keynode_t *node, void *data)
1839 {
1840         double diff_time = 0.0;
1841         time_t cur_time = 0;
1842
1843         _alarm_disable_timer(alarm_context);
1844
1845         if (node) {
1846                 diff_time = vconf_keynode_get_dbl(node);
1847         } else {
1848                 if (vconf_get_dbl(VCONFKEY_SYSTEM_TIMECHANGE_EXTERNAL, &diff_time) != 0) {
1849                         ALARM_MGR_EXCEPTION_PRINT("Failed to get value of VCONFKEY_SYSTEM_TIMECHANGE_EXTERNAL.");
1850                         return;
1851                 }
1852         }
1853
1854         tzset();
1855         time(&cur_time);
1856
1857         ALARM_MGR_LOG_PRINT("diff_time is %f, New time is %s\n", diff_time, ctime(&cur_time));
1858
1859         ALARM_MGR_LOG_PRINT("[alarm-server] System time has been changed externally\n");
1860         ALARM_MGR_LOG_PRINT("1.alarm_context.c_due_time is %d\n",
1861                             alarm_context.c_due_time);
1862
1863         __set_time(cur_time);
1864
1865         vconf_set_int(VCONFKEY_SYSTEM_TIME_CHANGED, (int)diff_time);
1866         bundle *b = NULL;
1867         b = bundle_create();
1868         bundle_add_str(b, EVT_KEY_TIME_CHANGED, EVT_VAL_TIME_CHANGED_TRUE);
1869         eventsystem_send_system_event(SYS_EVENT_TIME_CHANGED, b);
1870         bundle_free(b);
1871
1872         __alarm_update_due_time_of_all_items_in_list(diff_time);
1873
1874         ALARM_MGR_LOG_PRINT("2.alarm_context.c_due_time is %d\n",
1875                             alarm_context.c_due_time);
1876         _clear_scheduled_alarm_list();
1877         _alarm_schedule();
1878         __rtc_set();
1879
1880         return;
1881 }
1882
1883 static int __on_app_uninstalled(uid_t target_uid, int req_id, const char *pkg_type,
1884                                 const char *pkgid, const char *key, const char *val,
1885                                 const void *pmsg, void *user_data)
1886 {
1887         GSList* gs_iter = NULL;
1888         __alarm_info_t* entry = NULL;
1889         alarm_info_t* alarm_info = NULL;
1890         bool is_deleted = false;
1891
1892         SECURE_LOGD("pkg_type(%s), pkgid(%s), key(%s), value(%s)", pkg_type, pkgid, key, val);
1893
1894         if (strncmp(key, "end", 3) == 0 && strncmp(val, "ok", 2) == 0) {
1895                 for (gs_iter = alarm_context.alarms; gs_iter != NULL;) {
1896                         entry = gs_iter->data;
1897
1898                         const char* caller_pkgid = g_quark_to_string(entry->quark_caller_pkgid);
1899                         const char* callee_pkgid = g_quark_to_string(entry->quark_callee_pkgid);
1900
1901                         gs_iter = g_slist_next(gs_iter);
1902                         if ((caller_pkgid && strncmp(pkgid, caller_pkgid, strlen(pkgid)) == 0) ||
1903                                         (callee_pkgid && strncmp(pkgid, callee_pkgid, strlen(pkgid)) == 0)) {
1904                                 if (_remove_from_scheduled_alarm_list(entry->uid, entry->alarm_id))
1905                                         is_deleted = true;
1906
1907                                 alarm_info = &entry->alarm_info;
1908                                 if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
1909                                         if (!_delete_alarms(entry->alarm_id))
1910                                                 SECURE_LOGE("_delete_alarms() is failed. pkgid[%s], alarm_id[%d]", pkgid, entry->alarm_id);
1911                                 }
1912
1913                                 if (g_hash_table_remove(appid_cache_table, &entry->pid) == true)
1914                                         ALARM_MGR_LOG_PRINT("Remove cachd data of pid[%d]", entry->pid);
1915
1916                                 SECURE_LOGD("Remove pkgid[%s], alarm_id[%d]", pkgid, entry->alarm_id);
1917                                 alarm_context.alarms = g_slist_remove(alarm_context.alarms, entry);
1918                                 g_free(entry);
1919
1920                         }
1921                 }
1922
1923                 if (is_deleted && (g_slist_length(g_scheduled_alarm_list) == 0)) {
1924                         _alarm_disable_timer(alarm_context);
1925                         _alarm_schedule();
1926                         __rtc_set();
1927                 }
1928         }
1929
1930         return ALARMMGR_RESULT_SUCCESS;
1931 }
1932
1933 bool __get_caller_unique_name(int pid, char *unique_name, bool *is_app, uid_t uid)
1934 {
1935         char caller_appid[256] = {0,};
1936
1937         if (unique_name == NULL) {
1938                 ALARM_MGR_EXCEPTION_PRINT("unique_name should not be NULL.");
1939                 return false;
1940         }
1941
1942         if (aul_app_get_appid_bypid_for_uid(pid, caller_appid,
1943                                 sizeof(caller_appid), uid) == AUL_R_OK) {
1944                 /* When a caller is an application, the unique name is appID. */
1945                 if (is_app)
1946                         *is_app = true;
1947                 strncpy(unique_name, caller_appid, strlen(caller_appid));
1948         } else {
1949                 /* Otherwise, the unique name is /proc/pid/cmdline. */
1950                 char proc_file[512] = {0,};
1951                 char process_name[512] = {0,};
1952                 int fd = 0;
1953                 int i = 0;
1954
1955                 if (is_app)
1956                         *is_app = false;
1957
1958                 snprintf(proc_file, 512, "/proc/%d/cmdline", pid);
1959
1960                 fd = open(proc_file, O_RDONLY);
1961                 if (fd < 0) {
1962                         SECURE_LOGE("Caution!! pid(%d) seems to be killed.",
1963                                         pid, proc_file);
1964                         return false;
1965                 } else {
1966                         if (read(fd, process_name, sizeof(process_name) - 1) <= 0) {
1967                                 ALARM_MGR_EXCEPTION_PRINT("Unable to get the process name.");
1968                                 close(fd);
1969                                 return false;
1970                         }
1971                         close(fd);
1972
1973                         while (process_name[i] != '\0') {
1974                                 if (process_name[i] == ' ') {
1975                                         process_name[i] = '\0';
1976                                         break;
1977                                 }
1978                                 ++i;
1979                         }
1980                         strncpy(unique_name, process_name, strlen(process_name));
1981                 }
1982         }
1983         appid_cache_t* entry = (appid_cache_t*)calloc(1, sizeof(appid_cache_t));
1984
1985         entry->unique_name = strdup(unique_name);
1986         entry->is_app = is_app;
1987         entry->pid = pid;
1988         g_hash_table_foreach_remove(appid_cache_table, __hash_table_remove_cb, (gpointer)unique_name);
1989         g_hash_table_insert(appid_cache_table, &entry->pid, (gpointer)entry);
1990
1991         SECURE_LOGD("unique_name= %s", unique_name);
1992         return true;
1993 }
1994
1995 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
1996 static void __initialize_module_log(void)
1997 {
1998         char buf[1024];
1999
2000         log_fd = open(ALARMMGR_LOG_FILE_PATH, O_CREAT | O_WRONLY, 0644);
2001         if (log_fd == -1) {
2002                 ALARM_MGR_EXCEPTION_PRINT("Opening the file for alarmmgr log is failed. err: %s", strerror_r(errno, buf, sizeof(buf)));
2003                 return;
2004         }
2005
2006         int offset = lseek(log_fd, 0, SEEK_END);
2007         if (offset != 0) {
2008                 log_index = (int)(offset / ALARMMGR_LOG_BUFFER_STRING_SIZE);
2009                 if (log_index >= ALARMMGR_LOG_BUFFER_SIZE) {
2010                         log_index = 0;
2011                         lseek(log_fd, 0, SEEK_SET);
2012                 }
2013         }
2014         return;
2015 }
2016
2017 static bool __save_module_log(const char *tag, const char *message)
2018 {
2019         char buffer[ALARMMGR_LOG_BUFFER_STRING_SIZE] = {0,};
2020         time_t now;
2021         char buf[1024];
2022
2023         if (log_fd == -1) {
2024                 ALARM_MGR_EXCEPTION_PRINT("The file is not ready.");
2025                 return false;
2026         }
2027
2028         if (log_index != 0)
2029                 lseek(log_fd, 0, SEEK_CUR);
2030         else
2031                 lseek(log_fd, 0, SEEK_SET);
2032
2033         time(&now);
2034         snprintf(buffer, ALARMMGR_LOG_BUFFER_STRING_SIZE, "[%-6d] %-20s %-120s %d-%s", log_index, tag, message, (int)now, ctime(&now));
2035
2036         int ret = write(log_fd, buffer, strlen(buffer));
2037         if (ret < 0) {
2038                 ALARM_MGR_EXCEPTION_PRINT("Writing the alarmmgr log is failed. err: %s", strerror_r(errno, buf, sizeof(buf)));
2039                 return false;
2040         }
2041
2042         if (++log_index >= ALARMMGR_LOG_BUFFER_SIZE)
2043                 log_index = 0;
2044
2045         return true;
2046 }
2047 #endif /* _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG */
2048
2049 int __display_lock_state(char *state, char *flag, unsigned int timeout)
2050 {
2051         GDBusMessage *msg = NULL;
2052         GDBusMessage *reply = NULL;
2053         GVariant *body = NULL;
2054         int ret = ALARMMGR_RESULT_SUCCESS;
2055         int val = -1;
2056
2057         msg = g_dbus_message_new_method_call(DEVICED_BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, DEVICED_LOCK_STATE);
2058         if (!msg) {
2059                 ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_new_method_call() is failed. (%s:%s-%s)", DEVICED_BUS_NAME, DEVICED_INTERFACE_DISPLAY, DEVICED_LOCK_STATE);
2060                 return ERR_ALARM_SYSTEM_FAIL;
2061         }
2062
2063         g_dbus_message_set_body(msg, g_variant_new("(sssi)", state, flag, "NULL", timeout));
2064
2065         reply =  g_dbus_connection_send_message_with_reply_sync(alarm_context.connection, msg, G_DBUS_SEND_MESSAGE_FLAGS_NONE, DEVICED_DBUS_REPLY_TIMEOUT, NULL, NULL, NULL);
2066         if (!reply) {
2067                 ALARM_MGR_EXCEPTION_PRINT("No reply. g_dbus_connection_send_message_with_reply_sync() is failed.");
2068                 ret = ERR_ALARM_SYSTEM_FAIL;
2069         } else {
2070                 body = g_dbus_message_get_body(reply);
2071                 if (!body) {
2072                         ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_get_body() is failed.");
2073                         ret = ERR_ALARM_SYSTEM_FAIL;
2074                 } else {
2075                         g_variant_get(body, "(i)", &val);
2076                         if (val != 0) {
2077                                 ALARM_MGR_EXCEPTION_PRINT("Failed to lock display");
2078                                 ret = ERR_ALARM_SYSTEM_FAIL;
2079                         } else {
2080                                 ALARM_MGR_LOG_PRINT("Lock LCD OFF is successfully done");
2081                         }
2082                 }
2083         }
2084
2085         g_dbus_connection_flush_sync(alarm_context.connection, NULL, NULL);
2086         g_object_unref(msg);
2087         if (reply)
2088                 g_object_unref(reply);
2089
2090         return ret;
2091 }
2092
2093 int __display_unlock_state(char *state, char *flag)
2094 {
2095         GDBusMessage *msg = NULL;
2096         GDBusMessage *reply = NULL;
2097         GVariant *body = NULL;
2098         int ret = ALARMMGR_RESULT_SUCCESS;
2099         int val = -1;
2100
2101         msg = g_dbus_message_new_method_call(DEVICED_BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, DEVICED_UNLOCK_STATE);
2102         if (!msg) {
2103                 ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_new_method_call() is failed. (%s:%s-%s)", DEVICED_BUS_NAME, DEVICED_INTERFACE_DISPLAY, DEVICED_UNLOCK_STATE);
2104                 return ERR_ALARM_SYSTEM_FAIL;
2105         }
2106
2107         g_dbus_message_set_body(msg, g_variant_new("(ss)", state, flag));
2108
2109         reply =  g_dbus_connection_send_message_with_reply_sync(alarm_context.connection, msg, G_DBUS_SEND_MESSAGE_FLAGS_NONE, DEVICED_DBUS_REPLY_TIMEOUT, NULL, NULL, NULL);
2110         if (!reply) {
2111                 ALARM_MGR_EXCEPTION_PRINT("No reply. g_dbus_connection_send_message_with_reply_sync() is failed.");
2112                 ret = ERR_ALARM_SYSTEM_FAIL;
2113         } else {
2114                 body = g_dbus_message_get_body(reply);
2115                 if (!body) {
2116                         ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_get_body() is failed.");
2117                         ret = ERR_ALARM_SYSTEM_FAIL;
2118                 } else {
2119                         g_variant_get(body, "(i)", &val);
2120                         if (val != 0) {
2121                                 ALARM_MGR_EXCEPTION_PRINT("Failed to unlock display");
2122                                 ret = ERR_ALARM_SYSTEM_FAIL;
2123                         } else {
2124                                 ALARM_MGR_LOG_PRINT("Unlock LCD OFF is successfully done");
2125                         }
2126                 }
2127         }
2128
2129         g_dbus_connection_flush_sync(alarm_context.connection, NULL, NULL);
2130         g_object_unref(msg);
2131         if (reply)
2132                 g_object_unref(reply);
2133
2134         return ret;
2135 }
2136
2137 static long __get_proper_interval(long interval, int alarm_type)
2138 {
2139         GSList *gs_iter = NULL;
2140         __alarm_info_t *entry = NULL;
2141         long maxInterval = 60;
2142
2143         for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
2144                 entry = gs_iter->data;
2145                 if (entry->alarm_info.alarm_type & ALARM_TYPE_PERIOD) {
2146                         if (entry->alarm_info.mode.u_interval.interval <= interval &&
2147                                         entry->alarm_info.mode.u_interval.interval > maxInterval)
2148                                 maxInterval = entry->alarm_info.mode.u_interval.interval;
2149                 }
2150         }
2151
2152         while (maxInterval * 2 <= interval ||
2153                         (alarm_type & ALARM_TYPE_INEXACT && maxInterval < MIN_INEXACT_INTERVAL))
2154                 maxInterval *= 2;
2155
2156         return maxInterval;
2157 }
2158
2159 gboolean __alarm_expired_directly(gpointer user_data)
2160 {
2161         if (g_scheduled_alarm_list == NULL || g_scheduled_alarm_list->data == NULL)
2162                 return false;
2163
2164         int time_sec = (int)(intptr_t)user_data;
2165         __scheduled_alarm_t *alarm = g_scheduled_alarm_list->data;
2166         __alarm_info_t *alarm_info = alarm->__alarm_info;
2167
2168         /* Expire alarms with duetime equal to newtime by force */
2169         if (alarm_info->due_time == time_sec) {
2170                 if (__display_lock_state(DEVICED_LCD_OFF, DEVICED_STAY_CUR_STATE, 0) != ALARMMGR_RESULT_SUCCESS)
2171                         ALARM_MGR_EXCEPTION_PRINT("__display_lock_state() is failed");
2172
2173                 if (g_dummy_timer_is_set == true) {
2174                         ALARM_MGR_LOG_PRINT("dummy alarm timer has expired.");
2175                 } else {
2176                         ALARM_MGR_LOG_PRINT("due_time=%d is expired.", alarm_info->due_time);
2177                         __alarm_expired();
2178                 }
2179
2180                 _alarm_schedule();
2181                 __rtc_set();
2182
2183                 if (__display_unlock_state(DEVICED_LCD_OFF, DEVICED_SLEEP_MARGIN) != ALARMMGR_RESULT_SUCCESS)
2184                         ALARM_MGR_EXCEPTION_PRINT("__display_unlock_state() is failed");
2185         }
2186
2187         return false;
2188 }
2189
2190 void __reschedule_alarms_with_newtime(int cur_time, int new_time, double diff_time)
2191 {
2192 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2193         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
2194 #endif
2195
2196         vconf_set_int(VCONFKEY_SYSTEM_TIME_CHANGED, (int)diff_time);
2197         bundle *b = NULL;
2198         b = bundle_create();
2199         bundle_add_str(b, EVT_KEY_TIME_CHANGED, EVT_VAL_TIME_CHANGED_TRUE);
2200         eventsystem_send_system_event(SYS_EVENT_TIME_CHANGED, b);
2201         bundle_free(b);
2202
2203         __alarm_update_due_time_of_all_items_in_list(diff_time); /* Rescheduling alarms with ALARM_TYPE_RELATIVE */
2204         ALARM_MGR_LOG_PRINT("Next duetime is %d", alarm_context.c_due_time);
2205
2206         _clear_scheduled_alarm_list();
2207         _alarm_schedule();
2208         __rtc_set();
2209
2210 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2211         char *timebuf = ctime((const time_t *)&new_time);
2212         if (timebuf) {
2213                 timebuf[strlen(timebuf) - 1] = '\0'; /* to avoid newline */
2214                 snprintf(log_message, sizeof(log_message), "Current: %d, New: %d, %s, diff: %f", cur_time, new_time, timebuf, diff_time);
2215         }
2216         __save_module_log("CHANGE TIME", log_message);
2217 #endif
2218
2219         g_idle_add(__alarm_expired_directly, (gpointer)(intptr_t)new_time); /* Expire alarms with duetime equal to newtime directly */
2220         return;
2221 }
2222
2223 gboolean alarm_manager_alarm_set_rtc_time(AlarmManager *pObj, GDBusMethodInvocation *invoc,
2224                                 int year, int mon, int day,
2225                                 int hour, int min, int sec,
2226                                 gpointer user_data) {
2227         int return_code = ALARMMGR_RESULT_SUCCESS;
2228 #ifdef _APPFW_FEATURE_WAKEUP_USING_RTC
2229         const char *rtc = default_rtc;
2230         struct rtc_wkalrm rtc_wkalarm;
2231         int retval = 0;
2232         struct tm tm, *alarm_tm = NULL;
2233 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2234         char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
2235         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
2236 #endif
2237         /*extract day of the week, day in the year & daylight saving time from system*/
2238         time_t current_time;
2239         char buf[1024];
2240
2241         current_time = time(NULL);
2242         alarm_tm = gmtime_r(&current_time, &tm);
2243         if (alarm_tm == NULL) {
2244                 ALARM_MGR_EXCEPTION_PRINT("alarm_tm is NULL");
2245                 return_code = ERR_ALARM_SYSTEM_FAIL;
2246                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2247                 return true;
2248         }
2249
2250
2251         alarm_tm->tm_year = year;
2252         alarm_tm->tm_mon = mon;
2253         alarm_tm->tm_mday = day;
2254         alarm_tm->tm_hour = hour;
2255         alarm_tm->tm_min = min;
2256         alarm_tm->tm_sec = sec;
2257
2258         /*convert to calendar time representation*/
2259         time_t rtc_time = mktime(alarm_tm);
2260
2261         if (gfd < 0) {
2262                 gfd = open(rtc, O_RDWR);
2263                 if (gfd < 0) {
2264                         ALARM_MGR_EXCEPTION_PRINT("RTC open failed.");
2265                         return_code = ERR_ALARM_SYSTEM_FAIL;
2266                         g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2267                         return true;
2268                 }
2269         }
2270
2271         rtc_wkalarm.enabled = 1;
2272         rtc_wkalarm.time.tm_year = year;
2273         rtc_wkalarm.time.tm_mon = mon;
2274         rtc_wkalarm.time.tm_mday = day;
2275         rtc_wkalarm.time.tm_hour = hour;
2276         rtc_wkalarm.time.tm_min = min;
2277         rtc_wkalarm.time.tm_sec = sec;
2278
2279         retval = ioctl(gfd, RTC_WKALM_SET, &rtc_wkalarm);
2280         if (retval == -1) {
2281                 if (errno == ENOTTY)
2282                         ALARM_MGR_EXCEPTION_PRINT("Alarm IRQs is not supported.");
2283
2284                 ALARM_MGR_EXCEPTION_PRINT("RTC ALARM_SET ioctl is failed. errno = %s", strerror_r(errno, buf, sizeof(buf)));
2285                 return_code = ERR_ALARM_SYSTEM_FAIL;
2286 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2287                 strncpy(log_tag, "FAIL: SET RTC", strlen("FAIL: SET RTC"));
2288 #endif
2289         } else {
2290                 ALARM_MGR_LOG_PRINT("[alarm-server]RTC alarm is setted");
2291 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2292                 strncpy(log_tag, "SET RTC", strlen("SET RTC"));
2293 #endif
2294         }
2295
2296 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2297         snprintf(log_message, sizeof(log_message), "wakeup rtc time: %d, %s", (int)rtc_time, ctime(&rtc_time));
2298         __save_module_log(log_tag, log_message);
2299 #endif
2300 #else
2301         ALARM_MGR_LOG_PRINT("[alarm-server] RTC does not work.");
2302         return_code = ERR_ALARM_SYSTEM_FAIL;
2303 #endif /* _APPFW_FEATURE_WAKEUP_USING_RTC */
2304
2305         g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2306         return true;
2307 }
2308
2309 static int accrue_msec = 0; /* To check a millisecond part of current time at changing the system time(sec) */
2310
2311 gboolean alarm_manager_alarm_set_time(AlarmManager *pObj, GDBusMethodInvocation *invoc, int time_sec, gpointer user_data)
2312 {
2313         double diff_time = 0.0;
2314         struct timeval cur_time = {0,};
2315         int return_code = ALARMMGR_RESULT_SUCCESS;
2316
2317         _alarm_disable_timer(alarm_context); /* Disable the timer to reschedule the alarm before the time is changed. */
2318
2319         tzset();
2320         gettimeofday(&cur_time, NULL);
2321
2322         accrue_msec += (cur_time.tv_usec / 1000); /* Accrue the millisecond to compensate the time */
2323         if (accrue_msec > 500) {
2324                 diff_time = difftime(time_sec, cur_time.tv_sec) - 1;
2325                 accrue_msec -= 1000;
2326         } else {
2327                 diff_time = difftime(time_sec, cur_time.tv_sec);
2328         }
2329
2330         __set_time(time_sec); /* Change both OS time and RTC */
2331         ALARM_MGR_LOG_PRINT("[TIMESTAMP]Current time(%d), New time(%d)(%s), diff_time(%f)",
2332                                                                         cur_time.tv_sec, time_sec, ctime((const time_t *)&time_sec), diff_time);
2333
2334         __reschedule_alarms_with_newtime(cur_time.tv_sec, time_sec, diff_time);
2335         g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2336         return true;
2337 }
2338
2339 gboolean alarm_manager_alarm_set_time_with_propagation_delay(AlarmManager *pObj, GDBusMethodInvocation *invoc,
2340         guint new_sec, guint new_nsec, guint req_sec, guint req_nsec, gpointer user_data)
2341 {
2342         double diff_time = 0.0;
2343         struct timespec cur_time = {0,};
2344         struct timespec delay = {0,};
2345         struct timespec sleep_time = {0,};
2346         guint real_newtime = 0;
2347         accrue_msec = 0; /* reset accrued msec */
2348
2349         _alarm_disable_timer(alarm_context); /* Disable the timer to reschedule the alarm before the time is changed. */
2350
2351         tzset();
2352         clock_gettime(CLOCK_REALTIME, &cur_time);
2353
2354         /* Check validation of requested time */
2355         if (req_sec > cur_time.tv_sec || (req_sec == cur_time.tv_sec && req_nsec > cur_time.tv_nsec)) {
2356                 ALARM_MGR_EXCEPTION_PRINT("The requeted time(%d.%09d) must be equal to or less than current time(%d.%09d).",
2357                         req_sec, req_nsec, cur_time.tv_sec, cur_time.tv_nsec);
2358                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ERR_ALARM_INVALID_PARAM));
2359                 return true;
2360         }
2361
2362         /* Compensate propagation delay */
2363         if (req_nsec > cur_time.tv_nsec) {
2364                 delay.tv_sec = cur_time.tv_sec - 1 - req_sec;
2365                 delay.tv_nsec = cur_time.tv_nsec + BILLION - req_nsec;
2366         } else {
2367                 delay.tv_sec = cur_time.tv_sec - req_sec;
2368                 delay.tv_nsec = cur_time.tv_nsec - req_nsec;
2369         }
2370
2371         if (new_nsec + delay.tv_nsec >= BILLION) {
2372                 real_newtime = new_sec + delay.tv_sec + 2;
2373                 sleep_time.tv_nsec = BILLION - ((delay.tv_nsec + new_nsec) - BILLION);
2374         } else {
2375                 real_newtime = new_sec + delay.tv_sec + 1;
2376                 sleep_time.tv_nsec = BILLION - (delay.tv_nsec + new_nsec);
2377         }
2378
2379         nanosleep(&sleep_time, NULL); /* Wait until 0 nsec to match both OS time and RTC(sec) */
2380
2381         __set_time(real_newtime); /* Change both OS time and RTC */
2382
2383         diff_time = difftime(real_newtime, cur_time.tv_sec);
2384         ALARM_MGR_LOG_PRINT("[TIMESTAMP]Current time(%d.%09d), New time(%d.%09d), Real Newtime(%d), diff_time(%f)",
2385                 cur_time.tv_sec, cur_time.tv_nsec, new_sec, new_nsec, real_newtime, diff_time);
2386         ALARM_MGR_LOG_PRINT("Requested(%d.%09d) Delay(%d.%09d) Sleep(%09d)", req_sec, req_nsec, delay.tv_sec, delay.tv_nsec, sleep_time.tv_nsec);
2387         __reschedule_alarms_with_newtime(cur_time.tv_sec, real_newtime, diff_time);
2388         g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ALARMMGR_RESULT_SUCCESS));
2389         return true;
2390 }
2391
2392 gboolean alarm_manager_alarm_set_timezone(AlarmManager *pObject, GDBusMethodInvocation *invoc, char *tzpath_str, gpointer user_data)
2393 {
2394         int retval = 0;
2395         int return_code = ALARMMGR_RESULT_SUCCESS;
2396         struct stat statbuf;
2397 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2398         char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
2399         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
2400 #endif
2401
2402         ALARM_MGR_LOG_PRINT("[TIMESTAMP]Set the timezone to %s.", tzpath_str);
2403
2404         if (stat(tzpath_str, &statbuf) == -1 && errno == ENOENT) {
2405                 ALARM_MGR_EXCEPTION_PRINT("Invalid tzpath, %s", tzpath_str);
2406                 return_code = ERR_ALARM_INVALID_PARAM;
2407                 goto done;
2408         }
2409
2410         retval = stat(TIMEZONE_INFO_LINK_PATH, &statbuf);
2411         if (retval == 0 || (retval == -1 && errno != ENOENT)) {
2412                 /* unlink the current link */
2413                 if (unlink(TIMEZONE_INFO_LINK_PATH) < 0) {
2414                         ALARM_MGR_EXCEPTION_PRINT("unlink() is failed.");
2415                         return_code = ERR_ALARM_SYSTEM_FAIL;
2416                         goto done;
2417                 }
2418         }
2419
2420         /* create a new symlink when the /opt/etc/localtime is empty. */
2421         if (symlink(tzpath_str, TIMEZONE_INFO_LINK_PATH) < 0) {
2422                 ALARM_MGR_EXCEPTION_PRINT("Failed to create an symlink of %s.", tzpath_str);
2423                 return_code = ERR_ALARM_SYSTEM_FAIL;
2424                 goto done;
2425         }
2426
2427         tzset();
2428
2429         /* Rescheduling alarms */
2430         _alarm_disable_timer(alarm_context);
2431         __alarm_update_due_time_of_all_items_in_list(0);
2432         ALARM_MGR_LOG_PRINT("next expiring due_time is %d", alarm_context.c_due_time);
2433
2434         _clear_scheduled_alarm_list();
2435         _alarm_schedule();
2436         __rtc_set();
2437
2438         vconf_set_int(VCONFKEY_SYSTEM_TIME_CHANGED, 0);
2439         bundle *b = NULL;
2440         b = bundle_create();
2441         bundle_add_str(b, EVT_KEY_TIME_CHANGED, EVT_VAL_TIME_CHANGED_TRUE);
2442         eventsystem_send_system_event(SYS_EVENT_TIME_CHANGED, b);
2443         bundle_free(b);
2444
2445         b = bundle_create();
2446         bundle_add_str(b, EVT_KEY_TIME_ZONE, tzpath_str);
2447         eventsystem_send_system_event(SYS_EVENT_TIME_ZONE, b);
2448         bundle_free(b);
2449
2450 done:
2451         g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2452 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2453         if (return_code == ALARMMGR_RESULT_SUCCESS)
2454                 strncpy(log_tag, "SET TIMEZONE", strlen("SET TIMEZONE"));
2455         else
2456                 strncpy(log_tag, "FAIL: SET TIMEZONE", strlen("FAIL: SET TIMEZONE"));
2457
2458         snprintf(log_message, sizeof(log_message), "Set the timezone to %s.", tzpath_str);
2459         __save_module_log(log_tag, log_message);
2460 #endif
2461
2462         return true;
2463 }
2464
2465 gboolean alarm_manager_alarm_create_appsvc(AlarmManager *pObject, GDBusMethodInvocation *invoc,
2466                                     int start_year,
2467                                     int start_month, int start_day,
2468                                     int start_hour, int start_min,
2469                                     int start_sec, int end_year, int end_month,
2470                                     int end_day, int mode_day_of_week,
2471                                     unsigned int mode_interval,
2472                                     int mode_repeat, int alarm_type,
2473                                     int reserved_info,
2474                                     char *bundle_data,
2475                                     gpointer user_data)
2476 {
2477         alarm_info_t alarm_info;
2478         int return_code = ALARMMGR_RESULT_SUCCESS;
2479         int alarm_id = 0;
2480 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2481         char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
2482         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
2483 #endif
2484         bool ret = true;
2485         int uid;
2486         int pid;
2487         const char *name = g_dbus_method_invocation_get_sender(invoc);
2488
2489         uid = __get_caller_uid(name);
2490         pid = __get_caller_pid(name);
2491         if (uid < 0 || pid < 0) {
2492                 return_code = ERR_ALARM_SYSTEM_FAIL;
2493                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
2494                 return true;
2495         }
2496
2497         alarm_info.start.year = start_year;
2498         alarm_info.start.month = start_month;
2499         alarm_info.start.day = start_day;
2500         alarm_info.start.hour = start_hour;
2501         alarm_info.start.min = start_min;
2502         alarm_info.start.sec = start_sec;
2503
2504         alarm_info.end.year = end_year;
2505         alarm_info.end.month = end_month;
2506         alarm_info.end.day = end_day;
2507
2508         alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
2509         alarm_info.mode.repeat = mode_repeat;
2510
2511         alarm_info.alarm_type = alarm_type;
2512         alarm_info.reserved_info = reserved_info;
2513
2514         if ((alarm_info.alarm_type & ALARM_TYPE_INEXACT)) {
2515                 alarm_info.alarm_type |= ALARM_TYPE_PERIOD;
2516                 alarm_info.mode.u_interval.interval =
2517                         __get_proper_interval(mode_interval, alarm_info.alarm_type);
2518         } else if (mode_interval <= 0) {
2519                 alarm_info.mode.u_interval.interval = 0;
2520         }
2521
2522         if (!__alarm_create_appsvc(&alarm_info, &alarm_id, mode_interval, uid, pid, bundle_data, &return_code)) {
2523                 ALARM_MGR_EXCEPTION_PRINT("Unable to create alarm! return_code[%d]", return_code);
2524 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2525                 strncpy(log_tag, "FAIL: CREATE", strlen("FAIL: CREATE"));
2526 #endif
2527                 ret = false;
2528         } else {
2529 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2530                 strncpy(log_tag, "CREATE", strlen("CREATE"));
2531 #endif
2532         }
2533
2534         g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
2535
2536 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2537         snprintf(log_message, sizeof(log_message), "alarmID: %d, uid: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
2538                 alarm_id, uid, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
2539         __save_module_log(log_tag, log_message);
2540 #endif
2541
2542         return ret;
2543 }
2544
2545 gboolean alarm_manager_alarm_create_noti(AlarmManager *pObject, GDBusMethodInvocation *invoc,
2546                                     int start_year,
2547                                     int start_month, int start_day,
2548                                     int start_hour, int start_min,
2549                                     int start_sec, int end_year, int end_month,
2550                                     int end_day, int mode_day_of_week,
2551                                     unsigned int mode_interval,
2552                                     int mode_repeat, int alarm_type,
2553                                     int reserved_info,
2554                                     char *noti_data,
2555                                     gpointer user_data)
2556 {
2557         alarm_info_t alarm_info;
2558         int return_code = ALARMMGR_RESULT_SUCCESS;
2559         int alarm_id = 0;
2560 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2561         char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
2562         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
2563 #endif
2564         bool ret = true;
2565         int uid;
2566         int pid;
2567         const char *name = g_dbus_method_invocation_get_sender(invoc);
2568
2569         uid = __get_caller_uid(name);
2570         pid = __get_caller_pid(name);
2571         if (uid < 0 || pid < 0) {
2572                 return_code = ERR_ALARM_SYSTEM_FAIL;
2573                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
2574                 return true;
2575         }
2576
2577         alarm_info.start.year = start_year;
2578         alarm_info.start.month = start_month;
2579         alarm_info.start.day = start_day;
2580         alarm_info.start.hour = start_hour;
2581         alarm_info.start.min = start_min;
2582         alarm_info.start.sec = start_sec;
2583
2584         alarm_info.end.year = end_year;
2585         alarm_info.end.month = end_month;
2586         alarm_info.end.day = end_day;
2587
2588         alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
2589         alarm_info.mode.repeat = mode_repeat;
2590
2591         alarm_info.alarm_type = alarm_type;
2592         alarm_info.reserved_info = reserved_info;
2593
2594         if ((alarm_info.alarm_type & ALARM_TYPE_INEXACT)) {
2595                 alarm_info.alarm_type |= ALARM_TYPE_PERIOD;
2596                 alarm_info.mode.u_interval.interval =
2597                         __get_proper_interval(mode_interval, alarm_info.alarm_type);
2598         } else if (mode_interval <= 0) {
2599                 alarm_info.mode.u_interval.interval = 0;
2600         }
2601
2602         if (!__alarm_create_noti(&alarm_info, &alarm_id, mode_interval, uid, pid, noti_data, &return_code)) {
2603                 ALARM_MGR_EXCEPTION_PRINT("Unable to create alarm! return_code[%d]", return_code);
2604 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2605                 strncpy(log_tag, "FAIL: CREATE", strlen("FAIL: CREATE"));
2606 #endif
2607                 ret = false;
2608         } else {
2609 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2610                 strncpy(log_tag, "CREATE", strlen("CREATE"));
2611 #endif
2612         }
2613
2614         g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
2615
2616 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2617         snprintf(log_message, sizeof(log_message), "alarmID: %d, uid: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
2618                 alarm_id, uid, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
2619         __save_module_log(log_tag, log_message);
2620 #endif
2621
2622         return ret;
2623 }
2624
2625 gboolean alarm_manager_alarm_create(AlarmManager *obj, GDBusMethodInvocation *invoc,
2626                                     char *app_service_name, char *app_service_name_mod,  int start_year,
2627                                     int start_month, int start_day,
2628                                     int start_hour, int start_min,
2629                                     int start_sec, int end_year, int end_month,
2630                                     int end_day, int mode_day_of_week,
2631                                     int mode_repeat, int alarm_type,
2632                                     int reserved_info,
2633                                     char *reserved_service_name, char *reserved_service_name_mod,
2634                                     gpointer user_data)
2635 {
2636         alarm_info_t alarm_info;
2637         int return_code = ALARMMGR_RESULT_SUCCESS;
2638         int alarm_id = 0;
2639 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2640         char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
2641         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
2642 #endif
2643         bool ret = true;
2644         int uid;
2645         int pid;
2646         const char *name = g_dbus_method_invocation_get_sender(invoc);
2647
2648         pid = __get_caller_pid(name);
2649         uid = __get_caller_uid(name);
2650         if (uid < 0 || pid < 0) {
2651                 return_code = ERR_ALARM_SYSTEM_FAIL;
2652                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
2653                 return true;
2654         }
2655
2656         alarm_info.start.year = start_year;
2657         alarm_info.start.month = start_month;
2658         alarm_info.start.day = start_day;
2659         alarm_info.start.hour = start_hour;
2660         alarm_info.start.min = start_min;
2661         alarm_info.start.sec = start_sec;
2662
2663         alarm_info.end.year = end_year;
2664         alarm_info.end.month = end_month;
2665         alarm_info.end.day = end_day;
2666
2667         alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
2668         alarm_info.mode.repeat = mode_repeat;
2669
2670         alarm_info.alarm_type = alarm_type;
2671         alarm_info.reserved_info = reserved_info;
2672
2673         if (!__alarm_create(&alarm_info, &alarm_id, uid, pid, 0, 0, 0, app_service_name, app_service_name_mod,
2674                                 reserved_service_name, reserved_service_name_mod, &return_code)) {
2675                 ALARM_MGR_EXCEPTION_PRINT("Unable to create alarm! return_code[%d]", return_code);
2676 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2677                 strncpy(log_tag, "FAIL: CREATE", strlen("FAIL: CREATE"));
2678 #endif
2679                 ret = false;
2680         } else {
2681 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2682                 strncpy(log_tag, "CREATE", strlen("CREATE"));
2683 #endif
2684         }
2685
2686         g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
2687
2688 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2689         snprintf(log_message, sizeof(log_message), "alarmID: %d, uid: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
2690                 alarm_id, uid, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
2691         __save_module_log(log_tag, log_message);
2692 #endif
2693
2694         return ret;
2695 }
2696
2697 time_t _get_periodic_alarm_standard_time(void)
2698 {
2699         /* To avoid start time of all devices are same. */
2700         if (periodic_alarm_standard_time == 0) {
2701                 srand((unsigned int)time(NULL));
2702                 periodic_alarm_standard_time = rand() % BILLION + 1; /* 1 ~ 1000000000 */
2703         }
2704
2705         ALARM_MGR_LOG_PRINT("periodic_standard_time : [%d]", periodic_alarm_standard_time);
2706         return periodic_alarm_standard_time;
2707 }
2708
2709 gboolean alarm_manager_alarm_create_periodic(AlarmManager *obj, GDBusMethodInvocation *invoc,
2710                 char *app_service_name, char *app_service_name_mod, int interval,
2711                 int is_ref, int method, gpointer user_data)
2712 {
2713         alarm_info_t alarm_info;
2714         int return_code = ALARMMGR_RESULT_SUCCESS;
2715         int alarm_id = 0;
2716 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2717         char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
2718         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
2719 #endif
2720         bool ret = true;
2721         int uid;
2722         int pid;
2723         const char *name = g_dbus_method_invocation_get_sender(invoc);
2724
2725         uid = __get_caller_uid(name);
2726         pid = __get_caller_pid(name);
2727         if (uid < 0 || pid < 0) {
2728                 return_code = ERR_ALARM_SYSTEM_FAIL;
2729                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
2730                 return true;
2731         }
2732
2733         struct tm standard_tm;
2734         time_t standard_time = _get_periodic_alarm_standard_time();
2735         localtime_r(&standard_time, &standard_tm);
2736
2737         alarm_info.reserved_info = standard_time;
2738
2739         alarm_info.start.year = standard_tm.tm_year + 1900;
2740         alarm_info.start.month = standard_tm.tm_mon + 1;
2741         alarm_info.start.day = standard_tm.tm_mday;
2742         alarm_info.start.hour = standard_tm.tm_hour;
2743         alarm_info.start.min = standard_tm.tm_min;
2744         alarm_info.start.sec = standard_tm.tm_sec;
2745
2746         alarm_info.end.year = 0;
2747         alarm_info.end.month = 0;
2748         alarm_info.end.day = 0;
2749
2750         alarm_info.alarm_type = ALARM_TYPE_VOLATILE;
2751         alarm_info.alarm_type |= ALARM_TYPE_RELATIVE;
2752         alarm_info.alarm_type |= ALARM_TYPE_WITHCB;
2753         alarm_info.alarm_type |= ALARM_TYPE_PERIOD;
2754
2755         if (interval <= 0) {
2756                 alarm_info.mode.repeat = ALARM_REPEAT_MODE_ONCE;
2757                 alarm_info.mode.u_interval.interval = 0;
2758         } else {
2759                 alarm_info.mode.repeat = ALARM_REPEAT_MODE_REPEAT;
2760                 if (is_ref)
2761                         alarm_info.mode.u_interval.interval = interval * 60;
2762                 else
2763                         alarm_info.mode.u_interval.interval = __get_proper_interval(interval * 60, alarm_info.alarm_type);
2764         }
2765
2766         if (!__alarm_create(&alarm_info, &alarm_id, uid, pid, method, interval * 60, is_ref,
2767                                 app_service_name, app_service_name_mod,
2768                                 "null", "null", &return_code)) {
2769                 ALARM_MGR_EXCEPTION_PRINT("Unable to create alarm! return_code[%d]", return_code);
2770 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2771                 strncpy(log_tag, "FAIL: CREATE", strlen("FAIL: CREATE"));
2772 #endif
2773                 ret = false;
2774         } else {
2775 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2776                 strncpy(log_tag, "CREATE", strlen("CREATE"));
2777 #endif
2778                 ret = true;
2779         }
2780
2781         g_dbus_method_invocation_return_value(invoc,
2782                         g_variant_new("(ii)", alarm_id, return_code));
2783 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2784         snprintf(log_message, sizeof(log_message), "alarmID: %d, uid: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
2785                         alarm_id, uid, pid, alarm_info.start.year, alarm_info.start.month,
2786                         alarm_info.start.day, alarm_info.start.hour,
2787                         alarm_info.start.min, alarm_info.start.sec);
2788         __save_module_log(log_tag, log_message);
2789 #endif
2790         return ret;
2791 }
2792
2793 gboolean alarm_manager_alarm_delete(AlarmManager *obj, GDBusMethodInvocation *invoc,
2794                 alarm_id_t alarm_id, gpointer user_data)
2795 {
2796         int return_code = ALARMMGR_RESULT_SUCCESS;
2797 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2798         char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
2799         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
2800 #endif
2801         bool ret = true;
2802         int uid;
2803         int pid;
2804         const char *name = g_dbus_method_invocation_get_sender(invoc);
2805
2806         uid = __get_caller_uid(name);
2807         pid = __get_caller_pid(name);
2808         if (uid < 0 || pid < 0) {
2809                 return_code = ERR_ALARM_SYSTEM_FAIL;
2810                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2811                 return true;
2812         }
2813
2814
2815         if (!__alarm_delete(uid, alarm_id, &return_code)) {
2816                 ALARM_MGR_EXCEPTION_PRINT("Unable to delete the alarm! alarm_id[%d], return_code[%d]", alarm_id, return_code);
2817 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2818                 strncpy(log_tag, "FAIL: DELETE", strlen("FAIL: DELETE"));
2819 #endif
2820                 ret = false;
2821         } else {
2822                 ALARM_MGR_LOG_PRINT("alarm_id[%d] is removed.", alarm_id);
2823 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2824                 strncpy(log_tag, "DELETE", strlen("DELETE"));
2825 #endif
2826         }
2827
2828         g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2829
2830 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2831         snprintf(log_message, sizeof(log_message), "alarmID: %d, uid: %d, pid: %d", alarm_id, uid, pid);
2832         __save_module_log(log_tag, log_message);
2833 #endif
2834
2835         return ret;
2836 }
2837
2838 gboolean alarm_manager_alarm_delete_all(AlarmManager *obj, GDBusMethodInvocation *invoc,
2839                                         gpointer user_data)
2840 {
2841         GSList* gs_iter = NULL;
2842         char app_name[512] = { 0 };
2843         alarm_info_t* alarm_info = NULL;
2844         __alarm_info_t* entry = NULL;
2845         bool is_deleted = false;
2846         int return_code = ALARMMGR_RESULT_SUCCESS;
2847 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2848         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
2849 #endif
2850         int uid;
2851         int pid;
2852         const char *name = g_dbus_method_invocation_get_sender(invoc);
2853
2854         uid = __get_caller_uid(name);
2855         pid = __get_caller_pid(name);
2856         if (uid < 0 || pid < 0) {
2857                 return_code = ERR_ALARM_SYSTEM_FAIL;
2858                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2859                 return true;
2860         }
2861
2862         if (__get_cached_unique_name(pid, app_name, NULL, uid) == false) {
2863                 return_code = ERR_ALARM_SYSTEM_FAIL;
2864                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2865 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2866                 snprintf(log_message, sizeof(log_message), "pid: %d. Can not get the unique_name.", pid);
2867                 __save_module_log("FAIL: DELETE ALL", log_message);
2868 #endif
2869                 return true;
2870         }
2871
2872         SECURE_LOGD("Called by process (pid:%d, unique_name=%s)", pid, app_name);
2873
2874         for (gs_iter = alarm_context.alarms; gs_iter != NULL;) {
2875                 bool is_found = false;
2876                 entry = gs_iter->data;
2877                 const char* tmp_appname = g_quark_to_string(entry->quark_app_unique_name);
2878                 SECURE_LOGD("Try to remove app_name[%s], alarm_id[%d]\n", tmp_appname, entry->alarm_id);
2879                 if (tmp_appname && strncmp(app_name, tmp_appname, strlen(tmp_appname)) == 0) {
2880                         if (_remove_from_scheduled_alarm_list(uid, entry->alarm_id))
2881                                 is_deleted = true;
2882
2883                         alarm_info = &entry->alarm_info;
2884                         if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
2885                                 if (!_delete_alarms(entry->alarm_id))
2886                                         SECURE_LOGE("_delete_alarms() is failed. pid[%d], alarm_id[%d]", pid, entry->alarm_id);
2887                         }
2888                         is_found = true;
2889                 }
2890
2891                 gs_iter = g_slist_next(gs_iter);
2892
2893                 if (is_found) {
2894                         ALARM_MGR_LOG_PRINT("alarm_id[%d] is removed.", entry->alarm_id);
2895                         SECURE_LOGD("Removing is done. app_name[%s], alarm_id [%d]\n", tmp_appname, entry->alarm_id);
2896                         alarm_context.alarms = g_slist_remove(alarm_context.alarms, entry);
2897                         g_free(entry);
2898                 }
2899         }
2900
2901         if (is_deleted && (g_slist_length(g_scheduled_alarm_list) == 0)) {
2902                 _alarm_disable_timer(alarm_context);
2903                 _alarm_schedule();
2904         }
2905
2906 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2907         snprintf(log_message, sizeof(log_message), "uid: %d, pid: %d, unique_name: %s", uid, pid, app_name);
2908         __save_module_log("DELETE ALL", log_message);
2909 #endif
2910
2911         __rtc_set();
2912         g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2913         return true;
2914 }
2915
2916 gboolean alarm_manager_alarm_update(AlarmManager *pObj, GDBusMethodInvocation *invoc,
2917                                     char *app_service_name, alarm_id_t alarm_id,
2918                                     int start_year, int start_month,
2919                                     int start_day, int start_hour,
2920                                     int start_min, int start_sec, int end_year,
2921                                     int end_month, int end_day,
2922                                     int mode_day_of_week, int mode_repeat,
2923                                     int alarm_type, int reserved_info,
2924                                     gpointer user_data)
2925 {
2926         int return_code = ALARMMGR_RESULT_SUCCESS;
2927         alarm_info_t alarm_info;
2928         bool ret = true;
2929 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2930         char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
2931         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
2932 #endif
2933         int uid;
2934         int pid;
2935         const char *name = g_dbus_method_invocation_get_sender(invoc);
2936
2937         uid = __get_caller_uid(name);
2938         pid = __get_caller_pid(name);
2939         if (uid < 0 || pid < 0) {
2940                 return_code = ERR_ALARM_SYSTEM_FAIL;
2941                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2942                 return true;
2943         }
2944
2945         alarm_info.start.year = start_year;
2946         alarm_info.start.month = start_month;
2947         alarm_info.start.day = start_day;
2948         alarm_info.start.hour = start_hour;
2949         alarm_info.start.min = start_min;
2950         alarm_info.start.sec = start_sec;
2951
2952         alarm_info.end.year = end_year;
2953         alarm_info.end.month = end_month;
2954         alarm_info.end.day = end_day;
2955
2956         alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
2957         alarm_info.mode.repeat = mode_repeat;
2958
2959         alarm_info.alarm_type = alarm_type;
2960         alarm_info.reserved_info = reserved_info;
2961
2962         if (!__alarm_update(uid, pid, app_service_name, alarm_id, &alarm_info, &return_code)) {
2963                 ALARM_MGR_EXCEPTION_PRINT("Unable to update the alarm! alarm_id[%d], return_code[%d]", alarm_id, return_code);
2964 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2965                 strncpy(log_tag, "FAIL: UPDATE", strlen("FAIL: UPDATE"));
2966 #endif
2967                 ret = false;
2968         } else {
2969 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2970                 strncpy(log_tag, "UPDATE", strlen("UPDATE"));
2971 #endif
2972         }
2973
2974         g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2975
2976 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
2977         snprintf(log_message, sizeof(log_message), "alarmID: %d, appname: %s, uid: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
2978                 alarm_id, app_service_name, uid, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
2979         __save_module_log(log_tag, log_message);
2980 #endif
2981
2982         return ret;
2983 }
2984
2985 gboolean alarm_manager_alarm_get_number_of_ids(AlarmManager *pObject, GDBusMethodInvocation *invoc,
2986                                                gpointer user_data)
2987 {
2988         GSList *gs_iter = NULL;
2989         char app_name[256] = { 0 };
2990         __alarm_info_t *entry = NULL;
2991         int num_of_ids = 0;
2992         int return_code = ALARMMGR_RESULT_SUCCESS;
2993         int uid;
2994         int pid;
2995         const char *name = g_dbus_method_invocation_get_sender(invoc);
2996
2997         uid = __get_caller_uid(name);
2998         pid = __get_caller_pid(name);
2999         if (uid < 0 || pid < 0) {
3000                 return_code = ERR_ALARM_SYSTEM_FAIL;
3001                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", num_of_ids, return_code));
3002                 return true;
3003         }
3004
3005         if (__get_cached_unique_name(pid, app_name, NULL, uid) == false) {
3006                 return_code = ERR_ALARM_SYSTEM_FAIL;
3007                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", num_of_ids, return_code));
3008                 return true;
3009         }
3010
3011         SECURE_LOGD("Called by process (uid:%d, pid:%d, unique_name:%s)", uid, pid, app_name);
3012
3013         for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
3014                 entry = gs_iter->data;
3015                 SECURE_LOGD("app_name=%s, quark_app_unique_name=%s", app_name, g_quark_to_string(entry->quark_app_unique_name));
3016                 if (entry->uid == uid &&
3017                                 strncmp(app_name, g_quark_to_string(entry->quark_app_unique_name), strlen(app_name)) == 0) {
3018                         (num_of_ids)++;
3019                         SECURE_LOGD("inc number of alarms of app (uid:%d, pid:%d, unique_name:%s) is %d.", uid, pid, app_name, num_of_ids);
3020                 }
3021         }
3022
3023         SECURE_LOGD("number of alarms of the process (uid:%d, pid:%d, unique_name:%s) is %d.", uid, pid, app_name, num_of_ids);
3024         g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", num_of_ids, return_code));
3025         return true;
3026 }
3027
3028 gboolean alarm_manager_alarm_get_list_of_ids(AlarmManager *pObject, GDBusMethodInvocation *invoc,
3029                                              int max_number_of_ids, gpointer user_data)
3030 {
3031         GSList *gs_iter = NULL;
3032         char app_name[512] = { 0 };
3033         __alarm_info_t *entry = NULL;
3034         int index = 0;
3035         GVariant* arr = NULL;
3036         GVariantBuilder* builder = NULL;
3037         int num_of_ids = 0;
3038         int return_code = ALARMMGR_RESULT_SUCCESS;
3039         int uid;
3040         int pid;
3041         const char *name = g_dbus_method_invocation_get_sender(invoc);
3042
3043         uid = __get_caller_uid(name);
3044         pid = __get_caller_pid(name);
3045         if (uid < 0 || pid < 0) {
3046                 return_code = ERR_ALARM_SYSTEM_FAIL;
3047                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(@aiii)", g_variant_new("ai", NULL), num_of_ids, return_code));
3048                 return true;
3049         }
3050
3051         if (max_number_of_ids <= 0) {
3052                 SECURE_LOGE("called for uid(%d) pid(%d), but max_number_of_ids(%d) is less than 0.", uid, pid, max_number_of_ids);
3053                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(@aiii)", g_variant_new("ai", NULL), num_of_ids, return_code));
3054                 return true;
3055         }
3056
3057         if (__get_cached_unique_name(pid, app_name, NULL, uid) == false) {
3058                 return_code = ERR_ALARM_SYSTEM_FAIL;
3059                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(@aiii)", g_variant_new("ai", NULL), num_of_ids, return_code));
3060                 return true;
3061         }
3062
3063         SECURE_LOGD("Called by process (uid: %d, pid:%d, unique_name=%s).", uid, pid, app_name);
3064
3065         builder = g_variant_builder_new(G_VARIANT_TYPE("ai"));
3066         for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
3067                 entry = gs_iter->data;
3068                 if (entry->uid == uid &&
3069                                 strncmp(app_name, g_quark_to_string(entry->quark_app_unique_name), strlen(app_name)) == 0) {
3070                         g_variant_builder_add(builder, "i", entry->alarm_id);
3071                         index++;
3072                         SECURE_LOGE("called for alarmid(%d), but max_number_of_ids(%d) index %d.", entry->alarm_id, max_number_of_ids, index);
3073                 }
3074         }
3075
3076         arr = g_variant_new("ai", builder);
3077         num_of_ids = index;
3078
3079         SECURE_LOGE("Called by uid (%d), pid (%d), but max_number_of_ids(%d) return code %d.", uid, pid, num_of_ids, return_code);
3080         g_dbus_method_invocation_return_value(invoc, g_variant_new("(@aiii)", arr, num_of_ids, return_code));
3081
3082         g_variant_builder_unref(builder);
3083         return true;
3084 }
3085
3086 gboolean alarm_manager_alarm_get_appsvc_info(AlarmManager *pObject, GDBusMethodInvocation *invoc,
3087                                 alarm_id_t alarm_id, gpointer user_data)
3088 {
3089         bool found = false;
3090         GSList *gs_iter = NULL;
3091         __alarm_info_t *entry = NULL;
3092         int return_code = ALARMMGR_RESULT_SUCCESS;
3093         gchar *b_data = NULL;
3094         int uid;
3095         const char *name = g_dbus_method_invocation_get_sender(invoc);
3096
3097         uid = __get_caller_uid(name);
3098         if (uid < 0) {
3099                 return_code = ERR_ALARM_SYSTEM_FAIL;
3100                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", b_data, return_code));
3101                 return true;
3102         }
3103
3104         SECURE_LOGD("called for uid(%d), alarm_id(%d)\n", uid, alarm_id);
3105
3106         for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
3107                 entry = gs_iter->data;
3108                 if (entry->uid == uid && entry->alarm_id == alarm_id) {
3109                         found = true;
3110                         b_data = g_strdup(g_quark_to_string(entry->quark_bundle));
3111                         break;
3112                 }
3113         }
3114
3115         if (found) {
3116                 if (b_data && strlen(b_data) == 4 && strncmp(b_data, "null", 4) == 0) {
3117                         ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is an regular alarm, not svc alarm.", alarm_id);
3118                         return_code = ERR_ALARM_INVALID_TYPE;
3119                 }
3120         } else {
3121                 ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is not found.", alarm_id);
3122                 return_code = ERR_ALARM_INVALID_ID;
3123         }
3124
3125         g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", b_data, return_code));
3126         g_free(b_data);
3127         return true;
3128 }
3129
3130 gboolean alarm_manager_alarm_get_noti_info(AlarmManager *pObject, GDBusMethodInvocation *invoc,
3131                                 alarm_id_t alarm_id, gpointer user_data)
3132 {
3133         bool found = false;
3134         GSList *gs_iter = NULL;
3135         __alarm_info_t *entry = NULL;
3136         int return_code = ALARMMGR_RESULT_SUCCESS;
3137         gchar *noti_data = NULL;
3138         int uid;
3139         const char *name = g_dbus_method_invocation_get_sender(invoc);
3140
3141         uid = __get_caller_uid(name);
3142         if (uid < 0) {
3143                 return_code = ERR_ALARM_SYSTEM_FAIL;
3144                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", noti_data, return_code));
3145                 return true;
3146         }
3147
3148         SECURE_LOGD("called for uid(%d), alarm_id(%d)\n", uid, alarm_id);
3149
3150         for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
3151                 entry = gs_iter->data;
3152                 if (entry->uid == uid && entry->alarm_id == alarm_id) {
3153                         found = true;
3154                         noti_data = strdup(g_quark_to_string(entry->quark_noti));
3155                         break;
3156                 }
3157         }
3158
3159         if (found) {
3160                 if (noti_data && strlen(noti_data) == 4 && strncmp(noti_data, "null", 4) == 0) {
3161                         ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is an regular alarm, not svc alarm.", alarm_id);
3162                         return_code = ERR_ALARM_INVALID_TYPE;
3163                 }
3164         } else {
3165                 ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is not found.", alarm_id);
3166                 return_code = ERR_ALARM_INVALID_ID;
3167         }
3168
3169         g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", noti_data, return_code));
3170         g_free(noti_data);
3171         return true;
3172 }
3173
3174 gboolean alarm_manager_alarm_get_info(AlarmManager *pObject, GDBusMethodInvocation *invoc,
3175                                       alarm_id_t alarm_id, gpointer user_data)
3176 {
3177         GSList *gs_iter = NULL;
3178         __alarm_info_t *entry = NULL;
3179         alarm_info_t *alarm_info = NULL;
3180         int return_code = ALARMMGR_RESULT_SUCCESS;
3181         int uid;
3182         const char *name = g_dbus_method_invocation_get_sender(invoc);
3183
3184         uid = __get_caller_uid(name);
3185         if (uid < 0) {
3186                 return_code = ERR_ALARM_SYSTEM_FAIL;
3187                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(iiiiiiiiiiiiii)", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, return_code));
3188                 return true;
3189         }
3190
3191         SECURE_LOGD("called for uid(%d), alarm_id(%d)\n", uid, alarm_id);
3192         for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
3193                 entry = gs_iter->data;
3194                 if (entry->uid == uid && entry->alarm_id == alarm_id) {
3195                         alarm_info = &(entry->alarm_info);
3196                         break;
3197                 }
3198         }
3199
3200         if (alarm_info == NULL) {
3201                 ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is not found.", alarm_id);
3202                 return_code = ERR_ALARM_INVALID_ID;
3203                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(iiiiiiiiiiiiii)", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, return_code));
3204         } else {
3205                 ALARM_MGR_LOG_PRINT("The alarm(%d) is found.", alarm_id);
3206                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(iiiiiiiiiiiiii)", alarm_info->start.year, alarm_info->start.month,
3207                                                         alarm_info->start.day, alarm_info->start.hour, alarm_info->start.min, alarm_info->start.sec, alarm_info->end.year, alarm_info->end.month,
3208                                                         alarm_info->end.day, alarm_info->mode.u_interval.day_of_week, alarm_info->mode.repeat, alarm_info->alarm_type, alarm_info->reserved_info, return_code));
3209         }
3210
3211         return true;
3212 }
3213
3214 gboolean alarm_manager_alarm_get_next_duetime(AlarmManager *pObject, GDBusMethodInvocation *invoc,
3215                                       alarm_id_t alarm_id, gpointer user_data)
3216 {
3217         GSList *gs_iter = NULL;
3218         __alarm_info_t *entry = NULL;
3219         __alarm_info_t *find_item = NULL;
3220         int return_code = ALARMMGR_RESULT_SUCCESS;
3221         time_t duetime = 0;
3222         int uid;
3223         const char *name = g_dbus_method_invocation_get_sender(invoc);
3224
3225         uid = __get_caller_uid(name);
3226         if (uid < 0) {
3227                 return_code = ERR_ALARM_SYSTEM_FAIL;
3228                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", duetime, return_code));
3229                 return true;
3230         }
3231
3232         SECURE_LOGD("called for alarm_id(%d)\n", alarm_id);
3233         for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
3234                 entry = gs_iter->data;
3235                 if (entry->uid == uid && entry->alarm_id == alarm_id) {
3236                         find_item = entry;
3237                         break;
3238                 }
3239         }
3240
3241         if (find_item == NULL) {
3242                 ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is not found.", alarm_id);
3243                 return_code = ERR_ALARM_INVALID_ID;
3244                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", duetime, return_code));
3245                 return true;
3246         }
3247
3248         duetime = _alarm_next_duetime(find_item);
3249         ALARM_MGR_LOG_PRINT("Next duetime : %s", ctime(&duetime));
3250
3251         g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", duetime, return_code));
3252         return true;
3253 }
3254
3255 gboolean alarm_manager_alarm_get_all_info(AlarmManager *pObject, GDBusMethodInvocation *invoc, gpointer user_data)
3256 {
3257         sqlite3 *alarmmgr_tool_db;
3258         char *db_path = NULL;
3259         char db_path_tmp[50] = {0,};
3260         time_t current_time = 0;
3261         struct tm current_tm;
3262         const char *query_for_creating_table =  "create table alarmmgr_tool \
3263                                         (alarm_id integer primary key,\
3264                                                         duetime_epoch integer,\
3265                                                         duetime text,\
3266                                                         start_epoch integer,\
3267                                                         end_epoch integer,\
3268                                                         pid integer,\
3269                                                         global integer,\
3270                                                         caller_pkgid text,\
3271                                                         callee_pkgid text,\
3272                                                         app_unique_name text,\
3273                                                         app_service_name text,\
3274                                                         dst_service_name text,\
3275                                                         day_of_week integer,\
3276                                                         repeat integer,\
3277                                                         alarm_type integer)";
3278         const char *query_for_deleting_table = "drop table alarmmgr_tool";
3279         int return_code = ALARMMGR_RESULT_SUCCESS;
3280         GSList *gs_iter = NULL;
3281         __alarm_info_t *entry = NULL;
3282         char *error_message = NULL;
3283         int uid;
3284         const char *name = g_dbus_method_invocation_get_sender(invoc);
3285
3286         uid = __get_caller_uid(name);
3287         if (uid < 0) {
3288                 return_code = ERR_ALARM_SYSTEM_FAIL;
3289                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", db_path, return_code));
3290                 return true;
3291         }
3292
3293         /* Open a DB */
3294         time(&current_time);
3295         localtime_r(&current_time, &current_tm);
3296         snprintf(db_path_tmp, sizeof(db_path_tmp), "/tmp/alarmmgr_%d%d%d_%02d%02d%02d.db",
3297                 current_tm.tm_year + 1900, current_tm.tm_mon + 1, current_tm.tm_mday, current_tm.tm_hour, current_tm.tm_min, current_tm.tm_sec);
3298         db_path = strdup(db_path_tmp);
3299
3300         if (db_util_open(db_path, &alarmmgr_tool_db, DB_UTIL_REGISTER_HOOK_METHOD) != SQLITE_OK) {
3301                 ALARM_MGR_EXCEPTION_PRINT("Opening [%s] failed", db_path);
3302                 return_code = ERR_ALARM_SYSTEM_FAIL;
3303                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", db_path, return_code));
3304                 free(db_path);
3305                 return true;
3306         }
3307
3308         /* Drop a table */
3309         if (sqlite3_exec(alarmmgr_tool_db, query_for_deleting_table, NULL, NULL, &error_message) != SQLITE_OK)
3310                 ALARM_MGR_EXCEPTION_PRINT("Deleting the table is failed. error message = %s", error_message);
3311
3312         /* Create a table if it does not exist */
3313         if (sqlite3_exec(alarmmgr_tool_db, query_for_creating_table, NULL, NULL, &error_message) != SQLITE_OK) {
3314                 ALARM_MGR_EXCEPTION_PRINT("Creating the table is failed. error message = %s", error_message);
3315                 sqlite3_close(alarmmgr_tool_db);
3316                 return_code = ERR_ALARM_SYSTEM_FAIL;
3317                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", db_path, return_code));
3318                 free(db_path);
3319                 return true;
3320         }
3321
3322         /* Get information of all alarms and save those into the DB. */
3323         int index = 0;
3324         for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
3325                 entry = gs_iter->data;
3326                 if (entry->uid != uid)
3327                         continue;
3328                 ++index;
3329                 SECURE_LOGD("#%d alarm id[%d] app_name[%s] duetime[%d]",
3330                         index, entry->alarm_id, g_quark_to_string(entry->quark_app_unique_name), entry->start);
3331
3332                 alarm_info_t *alarm_info = (alarm_info_t *) &(entry->alarm_info);
3333                 alarm_mode_t *mode = &alarm_info->mode;
3334
3335                 char *query = sqlite3_mprintf("insert into alarmmgr_tool( alarm_id, duetime_epoch, duetime, start_epoch,\
3336                                 end_epoch, pid, global, caller_pkgid, callee_pkgid, app_unique_name, app_service_name, dst_service_name, day_of_week, repeat, alarm_type)\
3337                                 values (%d,%d,%Q,%d,%d,%d,%d,%Q,%Q,%Q,%Q,%Q,%d,%d,%d)",
3338                                 entry->alarm_id,
3339                                 (int)entry->due_time,
3340                                 ctime(&(entry->due_time)),
3341                                 (int)entry->start,
3342                                 (int)entry->end,
3343                                 (int)entry->pid,
3344                                 (bool)entry->global,
3345                                 (char *)g_quark_to_string(entry->quark_caller_pkgid),
3346                                 (char *)g_quark_to_string(entry->quark_callee_pkgid),
3347                                 (char *)g_quark_to_string(entry->quark_app_unique_name),
3348                                 (char *)g_quark_to_string(entry->quark_app_service_name),
3349                                 (char *)g_quark_to_string(entry->quark_dst_service_name),
3350                                 mode->u_interval.day_of_week,
3351                                 mode->repeat,
3352                                 entry->alarm_info.alarm_type);
3353
3354                 if (sqlite3_exec(alarmmgr_tool_db, query, NULL, NULL, &error_message) != SQLITE_OK)
3355                         SECURE_LOGE("sqlite3_exec() is failed. error message = %s", error_message);
3356
3357                 sqlite3_free(query);
3358         }
3359
3360         sqlite3_close(alarmmgr_tool_db);
3361
3362         return_code = ALARMMGR_RESULT_SUCCESS;
3363         g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", db_path, return_code));
3364         free(db_path);
3365         return true;
3366 }
3367
3368 gboolean alarm_manager_alarm_set_global(AlarmManager *pObject, GDBusMethodInvocation *invoc,
3369                                       alarm_id_t alarm_id, bool global, gpointer user_data)
3370 {
3371         GSList *gs_iter = NULL;
3372         __alarm_info_t *entry = NULL;
3373         alarm_info_t *alarm_info = NULL;
3374         int retval = 0;
3375         int return_code = ALARMMGR_RESULT_SUCCESS;
3376         int uid;
3377         const char *name = g_dbus_method_invocation_get_sender(invoc);
3378         char *callee_pkgid;
3379
3380         uid = __get_caller_uid(name);
3381         if (uid < 0) {
3382                 return_code = ERR_ALARM_SYSTEM_FAIL;
3383                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
3384                 return true;
3385         }
3386
3387         SECURE_LOGD("called for uid(%d), alarm_id(%d)\n", uid, alarm_id);
3388         for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
3389                 entry = gs_iter->data;
3390                 if (entry->uid == uid && entry->alarm_id == alarm_id) {
3391                         alarm_info = &(entry->alarm_info);
3392                         break;
3393                 }
3394         }
3395
3396         if (alarm_info == NULL) {
3397                 ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is not found.", alarm_id);
3398                 return_code = ERR_ALARM_INVALID_ID;
3399                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
3400         } else {
3401                 ALARM_MGR_LOG_PRINT("The alarm(%d) is found.", alarm_id);
3402
3403                 callee_pkgid = (char *)g_quark_to_string(entry->quark_callee_pkgid);
3404                 if (strncmp(callee_pkgid, "null", strlen(callee_pkgid)) == 0)
3405                         callee_pkgid = (char *)g_quark_to_string(entry->quark_app_service_name)+6;
3406
3407                 ALARM_MGR_LOG_PRINT("The alarm pkgid : %s.", callee_pkgid);
3408
3409                 pkgmgrinfo_pkginfo_h handle;
3410                 retval = pkgmgrinfo_pkginfo_get_usr_pkginfo(callee_pkgid, uid, &handle);
3411                 if (retval != PMINFO_R_OK) {
3412                         ALARM_MGR_EXCEPTION_PRINT("Failed to get pkginfo\n");
3413                         return_code = ERR_ALARM_INVALID_ID;
3414                 } else {
3415                         bool is_global = 0;
3416                         retval = pkgmgrinfo_pkginfo_is_global(handle, &is_global);
3417                         if (retval == PMINFO_R_OK && is_global) {
3418                                 entry->global = global;
3419                                 if (!__alarm_set_global_to_db(entry, global))
3420                                         return_code = ERR_ALARM_SYSTEM_FAIL;
3421                         } else if (retval == PMINFO_R_OK && !is_global) {
3422                                 return_code = ERR_ALARM_NOT_PERMITTED_APP;
3423                         }
3424
3425                 }
3426                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
3427         }
3428
3429         return true;
3430 }
3431
3432 gboolean alarm_manager_alarm_get_global(AlarmManager *pObject, GDBusMethodInvocation *invoc,
3433                                       alarm_id_t alarm_id, gpointer user_data)
3434 {
3435         GSList *gs_iter = NULL;
3436         __alarm_info_t *entry = NULL;
3437         __alarm_info_t *find_item = NULL;
3438         int return_code = ALARMMGR_RESULT_SUCCESS;
3439         bool global = false;
3440
3441         SECURE_LOGD("called for alarm_id(%d)\n", alarm_id);
3442         for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
3443                 entry = gs_iter->data;
3444                 if (entry->alarm_id == alarm_id) {
3445                         find_item = entry;
3446                         break;
3447                 }
3448         }
3449
3450         if (find_item == NULL) {
3451                 ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is not found.", alarm_id);
3452                 return_code = ERR_ALARM_INVALID_ID;
3453                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(bi)", global, return_code));
3454                 return true;
3455         }
3456
3457         global = find_item->global;
3458         ALARM_MGR_LOG_PRINT("Is global : %d", global);
3459
3460         g_dbus_method_invocation_return_value(invoc, g_variant_new("(bi)", global, return_code));
3461         return true;
3462 }
3463
3464
3465 static void __timer_glib_finalize(GSource *src)
3466 {
3467         GSList *fd_list;
3468         GPollFD *tmp;
3469
3470         fd_list = src->poll_fds;
3471         do {
3472                 tmp = (GPollFD *) fd_list->data;
3473                 g_free(tmp);
3474
3475                 fd_list = fd_list->next;
3476         } while (fd_list);
3477
3478         return;
3479 }
3480
3481 static gboolean __timer_glib_check(GSource *src)
3482 {
3483         GSList *fd_list;
3484         GPollFD *tmp;
3485
3486         fd_list = src->poll_fds;
3487         do {
3488                 tmp = (GPollFD *) fd_list->data;
3489                 if (tmp->revents & (POLLIN | POLLPRI))
3490                         return TRUE;
3491
3492                 fd_list = fd_list->next;
3493         } while (fd_list);
3494
3495         return FALSE;
3496 }
3497
3498 static gboolean __timer_glib_dispatch(GSource *src, GSourceFunc callback,
3499                                   gpointer data)
3500 {
3501         callback(data);
3502         return TRUE;
3503 }
3504
3505 static gboolean __timer_glib_prepare(GSource *src, gint *timeout)
3506 {
3507         return FALSE;
3508 }
3509
3510 GSourceFuncs funcs = {
3511         .prepare = __timer_glib_prepare,
3512         .check = __timer_glib_check,
3513         .dispatch = __timer_glib_dispatch,
3514         .finalize = __timer_glib_finalize
3515 };
3516
3517 static void __initialize_timer()
3518 {
3519         int fd;
3520         GSource *src;
3521         GPollFD *gpollfd;
3522         int ret;
3523
3524         fd = timerfd_create(CLOCK_REALTIME, 0);
3525         if (fd == -1) {
3526                 ALARM_MGR_EXCEPTION_PRINT("timerfd_create() is failed.\n");
3527                 exit(1);
3528         }
3529         src = g_source_new(&funcs, sizeof(GSource));
3530
3531         gpollfd = (GPollFD *) g_malloc(sizeof(GPollFD));
3532         if (gpollfd == NULL) {
3533                 ALARM_MGR_EXCEPTION_PRINT("Out of memory\n");
3534                 exit(1);
3535         }
3536         gpollfd->events = POLLIN;
3537         gpollfd->fd = fd;
3538
3539         g_source_add_poll(src, gpollfd);
3540         g_source_set_callback(src, (GSourceFunc) __alarm_handler_idle,
3541                               (gpointer) gpollfd, NULL);
3542         g_source_set_priority(src, G_PRIORITY_HIGH);
3543
3544         ret = g_source_attach(src, NULL);
3545         if (ret == 0) {
3546                 ALARM_MGR_EXCEPTION_PRINT("g_source_attach() is failed.\n");
3547                 return;
3548         }
3549
3550         g_source_unref(src);
3551
3552         alarm_context.timer = fd;
3553 }
3554
3555 static void __initialize_alarm_list()
3556 {
3557         alarm_context.alarms = NULL;
3558         alarm_context.c_due_time = -1;
3559
3560         _load_alarms_from_registry();
3561
3562         __rtc_set();    /*Set RTC1 Alarm with alarm due time for alarm-manager initialization*/
3563 }
3564
3565 static void __initialize_scheduled_alarm_list()
3566 {
3567         _init_scheduled_alarm_list();
3568 }
3569
3570 static bool __initialize_noti()
3571 {
3572         /* VCONFKEY_SYSTEM_TIMECHANGE_EXTERNAL is set by OSP app-service. */
3573         if (vconf_notify_key_changed
3574             (VCONFKEY_SYSTEM_TIMECHANGE_EXTERNAL, __on_system_time_external_changed, NULL) < 0) {
3575                 ALARM_MGR_LOG_PRINT("Failed to add callback for time external changing event.");
3576         }
3577
3578         /* If the caller or callee app is uninstalled, all registered alarms will be canceled. */
3579         int event_type = PKGMGR_CLIENT_STATUS_UNINSTALL;
3580         pkgmgr_client *pc = pkgmgr_client_new(PC_LISTENING);
3581         pkgmgr_client_set_status_type(pc, event_type);
3582         pkgmgr_client_listen_status(pc, __on_app_uninstalled, NULL);
3583
3584         return true;
3585 }
3586
3587 void on_bus_name_owner_changed(GDBusConnection  *connection,
3588                                 const gchar *sender_name,
3589                                 const gchar *object_path,
3590                                 const gchar *interface_name,
3591                                 const gchar *signal_name,
3592                                 GVariant *parameters,
3593                                 gpointer user_data)
3594 {
3595         GSList *entry = NULL;
3596         __expired_alarm_t *expire_info = NULL;
3597         char *service_name = NULL;
3598
3599         /* On expiry, the killed app can be launched by aul. Then, the owner of the bus name which was registered by the app is changed.
3600          * In this case, "NameOwnerChange" signal is broadcasted. */
3601         if (signal_name && strcmp(signal_name , "NameOwnerChanged") == 0) {
3602                 g_variant_get(parameters, "(sss)", &service_name, NULL, NULL);
3603
3604                 for (entry = g_expired_alarm_list; entry; entry = entry->next) {
3605                         if (entry->data) {
3606                                 expire_info = (__expired_alarm_t *) entry->data;
3607                                 SECURE_LOGD("expired service(%s), owner changed service(%s)", expire_info->service_name, service_name);
3608
3609                                 if (strcmp(expire_info->service_name, service_name) == 0) {
3610                                         SECURE_LOGE("expired service name(%s) alarm_id (%d)", expire_info->service_name, expire_info->alarm_id);
3611                                         __alarm_send_noti_to_application(expire_info->service_name, expire_info->alarm_id, expire_info->uid);
3612                                         g_expired_alarm_list = g_slist_remove(g_expired_alarm_list, entry->data);
3613                                         g_free(expire_info);
3614                                 }
3615                         }
3616                 }
3617                 g_free(service_name);
3618         }
3619 }
3620
3621 static bool __initialize_dbus()
3622 {
3623         GDBusConnection *connection = NULL;
3624         GError *error = NULL;
3625         guint subsc_id;
3626         ALARM_MGR_LOG_PRINT("__initialize_dbus Enter");
3627
3628         connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
3629         if (connection == NULL) {
3630                 ALARM_MGR_EXCEPTION_PRINT("g_bus_get_sync() is failed");
3631                 if (error) {
3632                         ALARM_MGR_EXCEPTION_PRINT("dbus error message : %s", error->message);
3633                         g_error_free(error);
3634                 }
3635                 return false;
3636         }
3637
3638         interface = alarm_manager_skeleton_new();
3639         if (interface == NULL) {
3640                 ALARM_MGR_EXCEPTION_PRINT("Creating a skeleton object is failed.");
3641                 g_object_unref(connection);
3642                 return false;
3643         }
3644
3645         g_signal_connect(interface, "handle_alarm_create", G_CALLBACK(alarm_manager_alarm_create), NULL);
3646         g_signal_connect(interface, "handle_alarm_create_periodic", G_CALLBACK(alarm_manager_alarm_create_periodic), NULL);
3647         g_signal_connect(interface, "handle_alarm_create_appsvc", G_CALLBACK(alarm_manager_alarm_create_appsvc), NULL);
3648         g_signal_connect(interface, "handle_alarm_create_noti", G_CALLBACK(alarm_manager_alarm_create_noti), NULL);
3649         g_signal_connect(interface, "handle_alarm_delete", G_CALLBACK(alarm_manager_alarm_delete), NULL);
3650         g_signal_connect(interface, "handle_alarm_delete_all", G_CALLBACK(alarm_manager_alarm_delete_all), NULL);
3651         g_signal_connect(interface, "handle_alarm_get_appsvc_info", G_CALLBACK(alarm_manager_alarm_get_appsvc_info), NULL);
3652         g_signal_connect(interface, "handle_alarm_get_info", G_CALLBACK(alarm_manager_alarm_get_info), NULL);
3653         g_signal_connect(interface, "handle_alarm_get_noti_info", G_CALLBACK(alarm_manager_alarm_get_noti_info), NULL);
3654         g_signal_connect(interface, "handle_alarm_get_list_of_ids", G_CALLBACK(alarm_manager_alarm_get_list_of_ids), NULL);
3655         g_signal_connect(interface, "handle_alarm_get_next_duetime", G_CALLBACK(alarm_manager_alarm_get_next_duetime), NULL);
3656         g_signal_connect(interface, "handle_alarm_get_number_of_ids", G_CALLBACK(alarm_manager_alarm_get_number_of_ids), NULL);
3657         g_signal_connect(interface, "handle_alarm_set_rtc_time", G_CALLBACK(alarm_manager_alarm_set_rtc_time), NULL);
3658         g_signal_connect(interface, "handle_alarm_set_time", G_CALLBACK(alarm_manager_alarm_set_time), NULL);
3659         g_signal_connect(interface, "handle_alarm_set_timezone", G_CALLBACK(alarm_manager_alarm_set_timezone), NULL);
3660         g_signal_connect(interface, "handle_alarm_update", G_CALLBACK(alarm_manager_alarm_update), NULL);
3661         g_signal_connect(interface, "handle_alarm_get_all_info", G_CALLBACK(alarm_manager_alarm_get_all_info), NULL);
3662         g_signal_connect(interface, "handle_alarm_set_time_with_propagation_delay", G_CALLBACK(alarm_manager_alarm_set_time_with_propagation_delay), NULL);
3663         g_signal_connect(interface, "handle_alarm_set_global", G_CALLBACK(alarm_manager_alarm_set_global), NULL);
3664         g_signal_connect(interface, "handle_alarm_get_global", G_CALLBACK(alarm_manager_alarm_get_global), NULL);
3665
3666         subsc_id = g_dbus_connection_signal_subscribe(connection,
3667                         "org.freedesktop.DBus", "org.freedesktop.DBus",
3668                         "NameOwnerChanged", "/org/freedesktop/DBus", NULL,
3669                         G_DBUS_SIGNAL_FLAGS_NONE, on_bus_name_owner_changed, NULL, NULL);
3670         if (subsc_id == 0) {
3671                 ALARM_MGR_EXCEPTION_PRINT("Subscribing to signal for invoking callback is failed.");
3672                 g_object_unref(interface);
3673                 interface = NULL;
3674                 g_object_unref(connection);
3675                 return false;
3676         }
3677
3678         if (!g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(interface), connection, ALARM_MGR_DBUS_PATH, NULL)) {
3679                 ALARM_MGR_EXCEPTION_PRINT("Exporting the interface is failed.");
3680                 g_object_unref(interface);
3681                 interface = NULL;
3682                 g_object_unref(connection);
3683                 return false;
3684         }
3685
3686         guint owner_id = g_bus_own_name_on_connection(connection,
3687                         ALARM_MGR_DBUS_NAME, G_BUS_NAME_OWNER_FLAGS_NONE,
3688                         NULL, NULL, NULL, NULL);
3689
3690         if (owner_id == 0) {
3691                 ALARM_MGR_EXCEPTION_PRINT("Acquiring the own name is failed.");
3692                 g_object_unref(interface);
3693                 interface = NULL;
3694                 g_object_unref(connection);
3695                 return false;
3696         }
3697
3698         alarm_context.connection = connection;
3699
3700         return true;
3701 }
3702
3703 #define ALARMMGR_DB_FILE tzplatform_mkpath(TZ_SYS_DB, ".alarmmgr.db")
3704 #define QUERY_CREATE_TABLE_ALARMMGR "create table alarmmgr \
3705                                 (alarm_id integer primary key,\
3706                                                 start integer,\
3707                                                 end integer,\
3708                                                 uid integer,\
3709                                                 pid integer,\
3710                                                 global integer,\
3711                                                 caller_pkgid text,\
3712                                                 callee_pkgid text,\
3713                                                 app_unique_name text,\
3714                                                 app_service_name text,\
3715                                                 app_service_name_mod text,\
3716                                                 bundle text, \
3717                                                 noti_len integer,\
3718                                                 noti text, \
3719                                                 year integer,\
3720                                                 month integer,\
3721                                                 day integer,\
3722                                                 hour integer,\
3723                                                 min integer,\
3724                                                 sec integer,\
3725                                                 day_of_week integer,\
3726                                                 repeat integer,\
3727                                                 alarm_type integer,\
3728                                                 reserved_info integer,\
3729                                                 dst_service_name text, \
3730                                                 dst_service_name_mod text \
3731                                                 )"
3732
3733 static bool __initialize_db()
3734 {
3735         char *error_message = NULL;
3736         int ret;
3737
3738         if (access(ALARMMGR_DB_FILE, F_OK) == 0) {
3739                 ret = db_util_open(ALARMMGR_DB_FILE, &alarmmgr_db, DB_UTIL_REGISTER_HOOK_METHOD);
3740
3741                 if (ret != SQLITE_OK) {
3742                         ALARM_MGR_EXCEPTION_PRINT("====>>>> connect menu_db [%s] failed", ALARMMGR_DB_FILE);
3743                         return false;
3744                 }
3745
3746                 return true;
3747         }
3748
3749         ret = db_util_open(ALARMMGR_DB_FILE, &alarmmgr_db, DB_UTIL_REGISTER_HOOK_METHOD);
3750
3751         if (ret != SQLITE_OK) {
3752                 ALARM_MGR_EXCEPTION_PRINT("====>>>> connect menu_db [%s] failed", ALARMMGR_DB_FILE);
3753                 return false;
3754         }
3755
3756         if (SQLITE_OK != sqlite3_exec(alarmmgr_db, QUERY_CREATE_TABLE_ALARMMGR, NULL, NULL, &error_message)) {
3757                 ALARM_MGR_EXCEPTION_PRINT("Don't execute query = %s, error message = %s", QUERY_CREATE_TABLE_ALARMMGR, error_message);
3758                 return false;
3759         }
3760
3761         return true;
3762 }
3763
3764 static void __initialize()
3765 {
3766 #if !(GLIB_CHECK_VERSION(2, 36, 0))
3767         g_type_init();
3768 #endif
3769
3770         __initialize_timer();
3771         if (__initialize_dbus() == false) {
3772                 /* because dbus's initialize
3773                  * failed, we cannot continue any more. */
3774                 ALARM_MGR_EXCEPTION_PRINT("because __initialize_dbus failed, "
3775                                           "alarm-server cannot be runned.\n");
3776                 exit(1);
3777         }
3778
3779 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
3780         __initialize_module_log(); /* for module log */
3781 #endif
3782
3783         __initialize_scheduled_alarm_list();
3784         __initialize_db();
3785         __initialize_alarm_list();
3786         __initialize_noti();
3787
3788         if (!appid_cache_table) {
3789                 appid_cache_table = g_hash_table_new_full(g_int_hash, g_int_equal,
3790                                 NULL, __free_cached_value);
3791         }
3792 }
3793
3794 int main()
3795 {
3796         GMainLoop *mainloop = NULL;
3797
3798         ALARM_MGR_LOG_PRINT("Enter main loop\n");
3799
3800         mainloop = g_main_loop_new(NULL, FALSE);
3801
3802         __initialize();
3803
3804         g_main_loop_run(mainloop);
3805
3806         return 0;
3807 }