alarm-manager.c

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