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
  57 #define SIG_TIMER 0x32
  58 #define WAKEUP_ALARM_APP_ID       "com.samsung.alarm.ALARM"
  59         /* alarm ui application's alarm's dbus_service name instead of 21
  60            (alarm application's app_id) value */
  61
  62 __alarm_server_context_t alarm_context;
  63 bool g_dummy_timer_is_set = FALSE;
  64
  65 GSList *g_scheduled_alarm_list = NULL;
  66 GSList *g_expired_alarm_list = NULL;
  67
  68 #ifndef RTC_WKALM_BOOT_SET
  69 #define RTC_WKALM_BOOT_SET _IOW('p', 0x80, struct rtc_wkalrm)
  70 #endif
  71
  72 /*      2008. 6. 3 sewook7.park
  73        When the alarm becoms sleeping mode, alarm timer is not expired.
  74        So using RTC, phone is awaken before alarm rings.
  75 */
  76 #define __WAKEUP_USING_RTC__
  77 #ifdef __WAKEUP_USING_RTC__
  78 #include <errno.h>
  79 #include <linux/rtc.h>
  80 #include <sys/ioctl.h>
  81 #include <fcntl.h>
  82
  83 #define ALARM_RTC_WAKEUP        0
  84
  85 #define ALARM_IOW(c, type, size)            _IOW('a', (c) | ((type) << 4), size)
  86 #define ALARM_SET(type)             ALARM_IOW(2, type, struct timespec)
  87 #define ALARM_SET_RTC               _IOW('a', 5, struct timespec)
  88 #define ALARM_CLEAR(type)           _IO('a', 0 | ((type) << 4))
  89
  90 // For module log
  91 #define ALARMMGR_LOG_BUFFER_SIZE        10000
  92 #define ALARMMGR_LOG_BUFFER_STRING_SIZE 200
  93 #define ALARMMGR_LOG_TAG_SIZE           20
  94 #define ALARMMGR_LOG_MESSAGE_SIZE       120
  95 #define ALARMMGR_LOG_FILE_PATH  "/var/log/alarmmgr.log"
  96 static int log_index = 0;
  97 static int log_fd = 0;
  98
  99 // display lock and unlock
 100 #define DEVICED_BUS_NAME "org.tizen.system.deviced"
 101 #define DEVICED_PATH_DISPLAY            "/Org/Tizen/System/DeviceD/Display"
 102 #define DEVICED_INTERFACE_DISPLAY       "org.tizen.system.deviced.display"
 103 #define DEVICED_LOCK_STATE              "lockstate"
 104 #define DEVICED_UNLOCK_STATE    "unlockstate"
 105 #define DEVICED_DBUS_REPLY_TIMEOUT      (120*1000)
 106 #define DEVICED_LCD_OFF         "lcdoff"
 107 #define DEVICED_STAY_CUR_STATE  "staycurstate"
 108 #define DEVICED_SLEEP_MARGIN            "sleepmargin"
 109
 110 static const char default_rtc[] = "/dev/alarm";
 111
 112 static int gfd = 0;
 113
 114 #endif                          /*__WAKEUP_USING_RTC__*/
 115
 116 /*  GDBus Declaration */
 117 #define ALARM_MGR_DBUS_PATH     "/com/samsung/alarm/manager"
 118 #define ALARM_MGR_DBUS_NAME     "com.samsung.alarm.manager"
 119 GDBusObjectManagerServer *alarmmgr_server = NULL;
 120 static AlarmManager* interface = NULL;
 121
 122 static bool __alarm_add_to_list(__alarm_info_t *__alarm_info);
 123 static void __alarm_generate_alarm_id(__alarm_info_t *__alarm_info, alarm_id_t *alarm_id);
 124 static bool __alarm_update_in_list(int pid, alarm_id_t alarm_id,
 125                                    __alarm_info_t *__alarm_info,
 126                                    int *error_code);
 127 static bool __alarm_remove_from_list(int pid, alarm_id_t alarm_id,
 128                                      int *error_code);
 129 static bool __alarm_set_start_and_end_time(alarm_info_t *alarm_info,
 130                                            __alarm_info_t *__alarm_info);
 131 static bool __alarm_update_due_time_of_all_items_in_list(double diff_time);
 132 static bool __alarm_create(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
 133                            int pid, char *app_service_name, char *app_service_name_mod,
 134                            const char *dst_service_name, const char *dst_service_name_mod, int *error_code);
 135 static bool __alarm_create_appsvc(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
 136                            int pid, char *bundle_data, int *error_code);
 137
 138 static bool __alarm_delete(int pid, alarm_id_t alarm_id, int *error_code);
 139 static bool __alarm_update(int pid, char *app_service_name, alarm_id_t alarm_id,
 140                            alarm_info_t *alarm_info, int *error_code);
 141 static void __alarm_send_noti_to_application(const char *app_service_name, alarm_id_t alarm_id);
 142 static void __alarm_expired();
 143 static gboolean __alarm_handler_idle(gpointer user_data);
 144 static void __clean_registry();
 145 static bool __alarm_manager_reset();
 146 static void __on_system_time_external_changed(keynode_t *node, void *data);
 147 static void __initialize_timer();
 148 static void __initialize_alarm_list();
 149 static void __initialize_scheduled_alarm_list();
 150 static bool __initialize_noti();
 151
 152 static bool __initialize_dbus();
 153 static bool __initialize_db();
 154 static void __initialize();
 155 void on_bus_name_owner_changed(GDBusConnection *connection, const gchar *sender_name, const gchar *object_path,
 156              const gchar *interface_name, const gchar *signal_name, GVariant *parameters, gpointer user_data);
 157 bool __get_caller_unique_name(int pid, char *unique_name);
 158
 159 static void __initialize_module_log(void);
 160 static bool __save_module_log(const char *tag, const char *messgae);
 161
 162 int __display_lock_state(char *state, char *flag, unsigned int timeout);
 163 int __display_unlock_state(char *state, char *flag);
 164
 165 static void __rtc_set()
 166 {
 167 #ifdef __WAKEUP_USING_RTC__
 168         const char *rtc = default_rtc;
 169         struct rtc_wkalrm rtc_wk;
 170         struct tm due_tm;
 171         struct timespec alarm_time;
 172         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
 173 #ifdef _SIMUL                   /*if build is simulator, we don't need to set
 174                                    RTC because RTC does not work in simulator.*/
 175         ALARM_MGR_EXCEPTION_PRINT("because it is simulator's mode, we don't set RTC.");
 176         return;
 177 #endif
 178
 179         if (gfd == 0) {
 180                 gfd = open(rtc, O_RDWR);
 181                 if (gfd == -1) {
 182                         ALARM_MGR_EXCEPTION_PRINT("RTC open failed.");
 183                         return;
 184                 }
 185         }
 186
 187         /* Read the RTC time/date */
 188         int retval = 0;
 189         char *timebuf = ctime(&alarm_context.c_due_time);
 190         timebuf[strlen(timebuf) - 1] = '\0';    // to avoid new line
 191         sprintf(log_message, "wakeup time: %d, %s", alarm_context.c_due_time, timebuf);
 192
 193         ALARM_MGR_LOG_PRINT("alarm_context.c_due_time is %d.", alarm_context.c_due_time);
 194
 195         if (alarm_context.c_due_time != -1) {
 196                 retval = ioctl(gfd, ALARM_CLEAR(ALARM_RTC_WAKEUP));
 197                 if (retval == -1) {
 198                         if (errno == ENOTTY) {
 199                                 ALARM_MGR_EXCEPTION_PRINT("Alarm IRQs is not supported.");
 200                         }
 201                         ALARM_MGR_EXCEPTION_PRINT("ALARM_CLEAR ioctl is failed. errno = %s", strerror(errno));
 202                         return;
 203                 }
 204                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]ALARM_CLEAR ioctl is successfully done.");
 205
 206                 time_t due_time = alarm_context.c_due_time;
 207                 gmtime_r(&due_time, &due_tm);
 208
 209                 ALARM_MGR_EXCEPTION_PRINT("Setted RTC Alarm date/time is %d-%d-%d, %02d:%02d:%02d (UTC).",
 210                         due_tm.tm_mday, due_tm.tm_mon + 1, due_tm.tm_year + 1900,
 211                         due_tm.tm_hour, due_tm.tm_min, due_tm.tm_sec);
 212
 213                 alarm_time.tv_sec = due_time - 1;
 214                 alarm_time.tv_nsec = 500000000; // Wakeup is 500ms faster than expiring time to correct RTC error.
 215                 retval = ioctl(gfd, ALARM_SET(ALARM_RTC_WAKEUP), &alarm_time);
 216                 if (retval == -1) {
 217                         if (errno == ENOTTY) {
 218                                 ALARM_MGR_EXCEPTION_PRINT("Alarm IRQs is not supported.");
 219                         }
 220                         ALARM_MGR_EXCEPTION_PRINT("RTC ALARM_SET ioctl is failed. errno = %s", strerror(errno));
 221                         __save_module_log("FAIL: SET RTC", log_message);
 222                         return;
 223                 }
 224                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]RTC ALARM_SET ioctl is successfully done.");
 225                 __save_module_log("SET RTC", log_message);
 226         }
 227         else {
 228                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]alarm_context.c_due_time is"
 229                         "less than 10 sec. RTC alarm does not need to be set");
 230         }
 231 #endif                          /* __WAKEUP_USING_RTC__ */
 232         return;
 233 }
 234
 235 int _set_rtc_time(time_t _time)
 236 {
 237         int ret = 0;
 238         const char *rtc0 = default_rtc;
 239         struct timespec rtc_time;
 240         char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
 241         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
 242
 243         if (gfd == 0) {
 244                 gfd = open(rtc0, O_RDWR);
 245
 246                 if (gfd == -1) {
 247                         ALARM_MGR_LOG_PRINT("error to open /dev/alarm.");
 248                         perror("\t");
 249                 }
 250         }
 251
 252         rtc_time.tv_sec = _time;
 253         rtc_time.tv_nsec = 0;
 254
 255         strncpy(log_tag, "SET RTC", strlen("SET RTC"));
 256         char *timebuf = ctime(&_time);
 257         timebuf[strlen(timebuf) - 1] = '\0';    // to avoid new line
 258         sprintf(log_message, "rtc time = %d, %s", _time, timebuf);
 259
 260         ret = ioctl(gfd, ALARM_SET_RTC, &rtc_time);
 261         if (ret == -1) {
 262                 ALARM_MGR_LOG_PRINT("ALARM_SET_RTC ioctl is failed. errno = %s", strerror(errno));
 263                 strncpy(log_tag, "FAIL: SET RTC", strlen("FAIL: SET RTC"));
 264
 265                 perror("\t");
 266         }
 267
 268         __save_module_log(log_tag, log_message);
 269
 270         return 1;
 271 }
 272
 273 bool __alarm_clean_list()
 274 {
 275         g_slist_free_full(alarm_context.alarms, g_free);
 276         return true;
 277 }
 278
 279 static void __alarm_generate_alarm_id(__alarm_info_t *__alarm_info, alarm_id_t *alarm_id)
 280 {
 281         bool unique_id = false;
 282         __alarm_info_t *entry = NULL;
 283         GSList *iter = NULL;
 284
 285         srand((unsigned int)time(NULL));
 286         __alarm_info->alarm_id = (rand() % INT_MAX) + 1;
 287         ALARM_MGR_LOG_PRINT("__alarm_info->alarm_id is %d", __alarm_info->alarm_id);
 288
 289         while (unique_id == false) {
 290                 unique_id = true;
 291
 292                 for (iter = alarm_context.alarms; iter != NULL;
 293                      iter = g_slist_next(iter)) {
 294                         entry = iter->data;
 295                         if (entry->alarm_id == __alarm_info->alarm_id) {
 296                                 __alarm_info->alarm_id++;
 297                                 unique_id = false;
 298                         }
 299                 }
 300         }
 301
 302         *alarm_id = __alarm_info->alarm_id;
 303
 304         return;
 305 }
 306
 307 static bool __alarm_add_to_list(__alarm_info_t *__alarm_info)
 308 {
 309         alarm_info_t *alarm_info = &__alarm_info->alarm_info;
 310         __alarm_info_t *entry = NULL;
 311         GSList *iter = NULL;
 312
 313         ALARM_MGR_LOG_PRINT("[alarm-server]: Before add alarm_id(%d)", __alarm_info->alarm_id);
 314
 315         alarm_context.alarms = g_slist_append(alarm_context.alarms, __alarm_info);
 316         ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: After add alarm_id(%d)", __alarm_info->alarm_id);
 317
 318         // alarm list
 319         for (iter = alarm_context.alarms; iter != NULL; iter = g_slist_next(iter)) {
 320                 entry = iter->data;
 321                 ALARM_MGR_LOG_PRINT("[alarm-server]: alarm_id(%d).", entry->alarm_id);
 322         }
 323
 324         if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
 325                 if (!_save_alarms(__alarm_info)) {
 326                         ALARM_MGR_EXCEPTION_PRINT("Saving alarm_id(%d) in DB is failed.", __alarm_info->alarm_id);
 327                 }
 328         }
 329
 330         return true;
 331 }
 332
 333 static bool __alarm_update_in_list(int pid, alarm_id_t alarm_id,
 334                                    __alarm_info_t *__alarm_info,
 335                                    int *error_code)
 336 {
 337         bool found = false;
 338         alarm_info_t *alarm_info = &__alarm_info->alarm_info;
 339         GSList *iter = NULL;
 340         __alarm_info_t *entry = NULL;
 341
 342         for (iter = alarm_context.alarms; iter != NULL;
 343              iter = g_slist_next(iter)) {
 344                 entry = iter->data;
 345                 if (entry->alarm_id == alarm_id) {
 346
 347                         found = true;
 348                         __alarm_info->quark_app_unique_name =
 349                             entry->quark_app_unique_name;
 350                         __alarm_info->quark_dst_service_name =
 351                             entry->quark_dst_service_name;
 352                         memcpy(entry, __alarm_info, sizeof(__alarm_info_t));
 353
 354                         break;
 355                 }
 356         }
 357
 358         if (!found) {
 359                 if (error_code)
 360                         *error_code = ERR_ALARM_INVALID_ID;
 361                 return false;
 362         }
 363
 364         if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
 365                 if (!_update_alarms(__alarm_info)) {
 366                         ALARM_MGR_EXCEPTION_PRINT("Updating alarm_id(%d) in DB is failed.", __alarm_info->alarm_id);
 367                 }
 368         }
 369
 370         return true;
 371 }
 372
 373 static bool __alarm_remove_from_list(int pid, alarm_id_t alarm_id,
 374                                      int *error_code)
 375 {
 376         bool found = false;
 377
 378         alarm_info_t *alarm_info = NULL;
 379
 380         GSList *iter = NULL;
 381         __alarm_info_t *entry = NULL;
 382
 383         /*list alarms */
 384         ALARM_MGR_LOG_PRINT("[alarm-server]: before del : alarm id(%d)", alarm_id);
 385
 386         for (iter = alarm_context.alarms; iter != NULL; iter = g_slist_next(iter)) {
 387                 entry = iter->data;
 388                 if (entry->alarm_id == alarm_id) {
 389                         alarm_info = &entry->alarm_info;
 390
 391                         ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Remove alarm id(%d)", entry->alarm_id);
 392
 393                         if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
 394                                 _delete_alarms(alarm_id);
 395                         }
 396
 397                         alarm_context.alarms = g_slist_remove(alarm_context.alarms, iter->data);
 398                         g_free(entry);
 399                         found = true;
 400                         break;
 401                 }
 402
 403         }
 404
 405         ALARM_MGR_LOG_PRINT("[alarm-server]: after del\n");
 406
 407         if (!found) {
 408                 if (error_code)
 409                         *error_code = ERR_ALARM_INVALID_ID;
 410                 return false;
 411         }
 412
 413         return true;
 414 }
 415
 416 static bool __alarm_set_start_and_end_time(alarm_info_t *alarm_info,
 417                                            __alarm_info_t *__alarm_info)
 418 {
 419         alarm_date_t *start = &alarm_info->start;
 420         alarm_date_t *end = &alarm_info->end;
 421
 422         struct tm alarm_tm = { 0, };
 423
 424         if (start->year != 0) {
 425                 alarm_tm.tm_year = start->year - 1900;
 426                 alarm_tm.tm_mon = start->month - 1;
 427                 alarm_tm.tm_mday = start->day;
 428
 429                 alarm_tm.tm_hour = start->hour;
 430                 alarm_tm.tm_min = start->min;
 431                 alarm_tm.tm_sec = start->sec;
 432                 alarm_tm.tm_isdst = -1;
 433
 434                 __alarm_info->start = mktime(&alarm_tm);
 435         } else {
 436                 __alarm_info->start = 0;
 437         }
 438
 439         if (end->year != 0) {
 440                 alarm_tm.tm_year = end->year - 1900;
 441                 alarm_tm.tm_mon = end->month - 1;
 442                 alarm_tm.tm_mday = end->day;
 443
 444                 alarm_tm.tm_hour = end->hour;
 445                 alarm_tm.tm_min = end->min;
 446                 alarm_tm.tm_sec = end->sec;
 447
 448                 __alarm_info->end = mktime(&alarm_tm);
 449         } else {
 450                 __alarm_info->end = 0;
 451         }
 452
 453         return true;
 454 }
 455
 456 /*
 457 static bool alarm_get_tz_info(int *gmt_idx, int *dst)
 458 {
 459         GConfValue *value1 = NULL;
 460         GConfValue *value2 = NULL;
 461         GConfClient* gConfClient = NULL;
 462         GError* err = NULL;
 463
 464         gConfClient = gconf_client_get_default();
 465
 466         if(gConfClient) {
 467                 value1 = gconf_client_get(gConfClient, SETTINGS_CLOCKTIMEZONE,
 468                                                                         &err);
 469                 if (err) {
 470                         ALARM_MGR_LOG_PRINT("__on_system_time_changed:
 471                         gconf_client_get() failed:
 472                         error:[%s]\n", err->message);
 473                         g_error_free(err);
 474                         err = NULL;
 475                 }
 476                 *gmt_idx = gconf_value_get_int(value1);
 477                 ALARM_MGR_LOG_PRINT("gconf return gmt_idx =%d\n ", *gmt_idx);
 478
 479                 value2 = gconf_client_get(gConfClient,
 480                         SETTINGS_DAYLIGHTSTATUS, &err);
 481                 if (err) {
 482                         ALARM_MGR_LOG_PRINT("__on_system_time_changed:
 483                 gconf_client_get() failed: error:[%s]\n", err->message);
 484                 g_error_free(err);
 485                 err = NULL;
 486         }
 487
 488         *dst = gconf_value_get_int(value2);
 489         ALARM_MGR_LOG_PRINT("gconf return dst =%d\n ", *dst);
 490
 491         if(gConfClient != NULL) {
 492                 g_object_unref(gConfClient);
 493                 gConfClient = NULL;
 494                 }
 495         }
 496         else
 497                 ALARM_MGR_LOG_PRINT("check the gconf setting failed!!!!! \n ");
 498
 499         if(value1) {
 500                 gconf_value_free(value1);
 501                 value1 = NULL;
 502         }
 503         if(value2) {
 504                 gconf_value_free(value2);
 505                 value2 = NULL;
 506         }
 507
 508         return true;
 509 }
 510 */
 511
 512 static bool __alarm_update_due_time_of_all_items_in_list(double diff_time)
 513 {
 514         time_t current_time;
 515         time_t min_time = -1;
 516         time_t due_time = 0;
 517         GSList *iter = NULL;
 518         __alarm_info_t *entry = NULL;
 519         struct tm *p_time = NULL ;
 520         struct tm due_time_result ;
 521         struct tm fixed_time = { 0, };
 522
 523         for (iter = alarm_context.alarms; iter != NULL;
 524              iter = g_slist_next(iter)) {
 525                 entry = iter->data;
 526                 alarm_info_t *alarm_info = &(entry->alarm_info);
 527                 if (alarm_info->alarm_type & ALARM_TYPE_RELATIVE) {
 528                         /*diff_time ó\B8\AE */
 529
 530                         entry->due_time += diff_time;
 531
 532                         alarm_date_t *start = &alarm_info->start; /**< start
 533                                                         time of the alarm */
 534                         alarm_date_t *end = &alarm_info->end;;
 535                                                 /**< end time of the alarm */
 536
 537                         tzset();
 538                         p_time = localtime_r(&entry->due_time, &due_time_result);
 539                         if (p_time != NULL) {
 540                                 start->year = p_time->tm_year + 1900;
 541                                 start->month = p_time->tm_mon + 1;
 542                                 start->day = p_time->tm_mday;
 543                                 start->hour = p_time->tm_hour;
 544                                 start->min = p_time->tm_min;
 545                                 start->sec = p_time->tm_sec;
 546
 547                                 end->year = p_time->tm_year + 1900;
 548                                 end->month = p_time->tm_mon + 1;
 549                                 end->day = p_time->tm_mday;
 550
 551
 552                                 memset(&fixed_time, 0, sizeof(fixed_time));
 553                                 fixed_time.tm_year = p_time->tm_year;
 554                                 fixed_time.tm_mon = p_time->tm_mon;
 555                                 fixed_time.tm_mday = p_time->tm_mday;
 556                                 fixed_time.tm_hour = 0;
 557                                 fixed_time.tm_min = 0;
 558                                 fixed_time.tm_sec = 0;
 559                         }
 560                         entry->start = mktime(&fixed_time);
 561
 562                         fixed_time.tm_hour = 23;
 563                         fixed_time.tm_min = 59;
 564                         fixed_time.tm_sec = 59;
 565
 566                         entry->end = mktime(&fixed_time);
 567
 568                         ALARM_MGR_LOG_PRINT("alarm_info->alarm_type is "
 569                                             "ALARM_TYPE_RELATIVE\n");
 570
 571                         _update_alarms(entry);
 572                 }
 573
 574                 _alarm_next_duetime(entry);
 575                 ALARM_MGR_LOG_PRINT("entry->due_time is %d\n", entry->due_time);
 576         }
 577
 578         time(&current_time);
 579
 580         for (iter = alarm_context.alarms; iter != NULL; iter = g_slist_next(iter)) {
 581                 entry = iter->data;
 582                 due_time = entry->due_time;
 583
 584                 double interval = 0;
 585
 586                 ALARM_MGR_LOG_PRINT("alarm[%d] with duetime(%u) at "
 587                 "current(%u)\n", entry->alarm_id, due_time, current_time);
 588                 if (due_time == 0) {    /* 0 means this alarm has been disabled */
 589                         continue;
 590                 }
 591
 592                 interval = difftime(due_time, current_time);
 593
 594                 if (interval <= 0) {
 595                         ALARM_MGR_EXCEPTION_PRINT("The duetime of alarm(%d) is OVER.", entry->alarm_id);
 596                         continue;
 597                 }
 598
 599                 interval = difftime(due_time, min_time);
 600
 601                 if ((interval < 0) || min_time == -1) {
 602                         min_time = due_time;
 603                 }
 604
 605         }
 606
 607         alarm_context.c_due_time = min_time;
 608
 609         return true;
 610 }
 611
 612 static bool __alarm_create_appsvc(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
 613                            int pid, char *bundle_data, int *error_code)
 614 {
 615         time_t current_time;
 616         time_t due_time;
 617         struct tm ts_ret;
 618         char due_time_r[100] = { 0 };
 619         char app_name[512] = { 0 };
 620         bundle *b;
 621         char caller_appid[256] = { 0 };
 622         char* callee_appid = NULL;
 623         char* caller_pkgid = NULL;
 624         char* callee_pkgid = NULL;
 625         pkgmgrinfo_pkginfo_h caller_handle;
 626         pkgmgrinfo_pkginfo_h callee_handle;
 627         bundle_raw *b_data = NULL;
 628         int datalen = 0;
 629
 630         __alarm_info_t *__alarm_info = NULL;
 631
 632         __alarm_info = malloc(sizeof(__alarm_info_t));
 633         if (__alarm_info == NULL) {
 634                 SECURE_LOGE("Caution!! app_pid=%d, malloc failed. it seems to be OOM.", pid);
 635                 *error_code = ERR_ALARM_SYSTEM_FAIL;
 636                 return false;
 637         }
 638
 639         __alarm_info->pid = pid;
 640         __alarm_info->alarm_id = -1;
 641
 642         if (!__get_caller_unique_name(pid, app_name)) {
 643                 *error_code = ERR_ALARM_SYSTEM_FAIL;
 644                 free(__alarm_info);
 645                 return false;
 646         }
 647         __alarm_info->quark_app_unique_name = g_quark_from_string(app_name);
 648
 649         // Get caller_appid and callee_appid to get each package id
 650         // caller
 651         __alarm_info->quark_caller_pkgid = g_quark_from_string("null");
 652
 653         if (aul_app_get_appid_bypid(pid, caller_appid, 256) == AUL_R_OK) {
 654                 if (pkgmgrinfo_appinfo_get_appinfo(caller_appid, &caller_handle) == PMINFO_R_OK) {
 655                         if (pkgmgrinfo_appinfo_get_pkgid(caller_handle, &caller_pkgid) == PMINFO_R_OK) {
 656                                 if (caller_pkgid) {
 657                                         __alarm_info->quark_caller_pkgid = g_quark_from_string(caller_pkgid);
 658                                 }
 659                         }
 660                         pkgmgrinfo_appinfo_destroy_appinfo(caller_handle);
 661                 }
 662         }
 663
 664         // callee
 665         __alarm_info->quark_callee_pkgid = g_quark_from_string("null");
 666
 667         b = bundle_decode((bundle_raw *)bundle_data, strlen(bundle_data));
 668         callee_appid = appsvc_get_appid(b);
 669         if (pkgmgrinfo_appinfo_get_appinfo(callee_appid, &callee_handle) == PMINFO_R_OK) {
 670                 if (pkgmgrinfo_appinfo_get_pkgid(callee_handle, &callee_pkgid) == PMINFO_R_OK) {
 671                         if (callee_pkgid) {
 672                                 __alarm_info->quark_callee_pkgid = g_quark_from_string(callee_pkgid);
 673                         }
 674                 }
 675                 pkgmgrinfo_appinfo_destroy_appinfo(callee_handle);
 676         }
 677
 678         SECURE_LOGD("caller_pkgid = %s, callee_pkgid = %s",
 679                 g_quark_to_string(__alarm_info->quark_caller_pkgid), g_quark_to_string(__alarm_info->quark_callee_pkgid));
 680
 681         bundle_encode(b, &b_data, &datalen);
 682         __alarm_info->quark_bundle=g_quark_from_string(b_data);
 683         __alarm_info->quark_app_service_name = g_quark_from_string("null");
 684         __alarm_info->quark_dst_service_name = g_quark_from_string("null");
 685         __alarm_info->quark_app_service_name_mod = g_quark_from_string("null");
 686         __alarm_info->quark_dst_service_name_mod = g_quark_from_string("null");
 687
 688         bundle_free(b);
 689         if (b_data) {
 690                 free(b_data);
 691                 b_data = NULL;
 692         }
 693
 694         __alarm_set_start_and_end_time(alarm_info, __alarm_info);
 695         memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
 696         __alarm_generate_alarm_id(__alarm_info, alarm_id);
 697
 698         time(&current_time);
 699
 700         if (alarm_context.c_due_time < current_time) {
 701                 ALARM_MGR_EXCEPTION_PRINT("Caution!! alarm_context.c_due_time "
 702                 "(%d) is less than current time(%d)", alarm_context.c_due_time, current_time);
 703                 alarm_context.c_due_time = -1;
 704         }
 705
 706         due_time = _alarm_next_duetime(__alarm_info);
 707         if (__alarm_add_to_list(__alarm_info) == false) {
 708                 free(__alarm_info);
 709                 *error_code = ERR_ALARM_SYSTEM_FAIL;
 710                 return false;
 711         }
 712
 713         if (due_time == 0) {
 714                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create a new alarm: "
 715                 "due_time is 0, alarm(%d) \n", *alarm_id);
 716                 return true;
 717         } else if (current_time == due_time) {
 718                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create alarm: "
 719                      "current_time(%d) is same as due_time(%d)", current_time,
 720                      due_time);
 721                 return true;
 722         } else if (difftime(due_time, current_time) < 0) {
 723                 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);
 724                 return true;
 725         } else {
 726                 localtime_r(&due_time, &ts_ret);
 727                 strftime(due_time_r, 30, "%c", &ts_ret);
 728                 SECURE_LOGD("[alarm-server]:Create a new alarm: "
 729                                     "alarm(%d) due_time(%s)", *alarm_id,
 730                                     due_time_r);
 731         }
 732
 733         ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:alarm_context.c_due_time(%d), due_time(%d)", alarm_context.c_due_time, due_time);
 734
 735         if (alarm_context.c_due_time == -1 || due_time < alarm_context.c_due_time) {
 736                 _clear_scheduled_alarm_list();
 737                 _add_to_scheduled_alarm_list(__alarm_info);
 738                 _alarm_set_timer(&alarm_context, alarm_context.timer, due_time);
 739                 alarm_context.c_due_time = due_time;
 740         } else if (due_time == alarm_context.c_due_time) {
 741                 _add_to_scheduled_alarm_list(__alarm_info);
 742         }
 743
 744         __rtc_set();
 745
 746         return true;
 747 }
 748
 749 static bool __alarm_create(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
 750                            int pid, char *app_service_name, char *app_service_name_mod,
 751                            const char *dst_service_name,const char *dst_service_name_mod,  int *error_code)
 752 {
 753         time_t current_time;
 754         time_t due_time;
 755         char app_name[512] = { 0 };
 756         char caller_appid[256] = { 0 };
 757         char* caller_pkgid = NULL;
 758         pkgmgrinfo_pkginfo_h caller_handle;
 759
 760         __alarm_info_t *__alarm_info = NULL;
 761
 762         __alarm_info = malloc(sizeof(__alarm_info_t));
 763         if (__alarm_info == NULL) {
 764                 SECURE_LOGE("Caution!! app_pid=%d, malloc "
 765                                           "failed. it seems to be OOM\n", pid);
 766                 *error_code = ERR_ALARM_SYSTEM_FAIL;
 767                 return false;
 768         }
 769         __alarm_info->pid = pid;
 770         __alarm_info->alarm_id = -1;
 771         __alarm_info->quark_caller_pkgid = g_quark_from_string("null");
 772
 773         // Get caller_appid to get caller's package id. There is no callee.
 774         if (aul_app_get_appid_bypid(pid, caller_appid, 256) == AUL_R_OK) {
 775                 if (pkgmgrinfo_appinfo_get_appinfo(caller_appid, &caller_handle) == PMINFO_R_OK) {
 776                         if (pkgmgrinfo_appinfo_get_pkgid(caller_handle, &caller_pkgid) == PMINFO_R_OK) {
 777                                 if (caller_pkgid) {
 778                                         __alarm_info->quark_caller_pkgid = g_quark_from_string(caller_pkgid);
 779                                 }
 780                         }
 781                         pkgmgrinfo_appinfo_destroy_appinfo(caller_handle);
 782                 }
 783         }
 784
 785         __alarm_info->quark_callee_pkgid = g_quark_from_string("null");
 786         SECURE_LOGD("caller_pkgid = %s, callee_pkgid = null", g_quark_to_string(__alarm_info->quark_caller_pkgid));
 787
 788         if (!__get_caller_unique_name(pid, app_name)) {
 789                 *error_code = ERR_ALARM_SYSTEM_FAIL;
 790                 free(__alarm_info);
 791                 return false;
 792         }
 793
 794         __alarm_info->quark_app_unique_name = g_quark_from_string(app_name);
 795         __alarm_info->quark_app_service_name = g_quark_from_string(app_service_name);
 796         __alarm_info->quark_app_service_name_mod = g_quark_from_string(app_service_name_mod);
 797         __alarm_info->quark_dst_service_name = g_quark_from_string(dst_service_name);
 798         __alarm_info->quark_dst_service_name_mod = g_quark_from_string(dst_service_name_mod);
 799         __alarm_info->quark_bundle = g_quark_from_string("null");
 800
 801         __alarm_set_start_and_end_time(alarm_info, __alarm_info);
 802         memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
 803         __alarm_generate_alarm_id(__alarm_info, alarm_id);
 804
 805         time(&current_time);
 806
 807         SECURE_LOGD("[alarm-server]:pid=%d, app_unique_name=%s, "
 808                 "app_service_name=%s,dst_service_name=%s, c_due_time=%d", \
 809                 pid, g_quark_to_string(__alarm_info->quark_app_unique_name), \
 810                 g_quark_to_string(__alarm_info->quark_app_service_name), \
 811                 g_quark_to_string(__alarm_info->quark_dst_service_name), \
 812                             alarm_context.c_due_time);
 813
 814         if (alarm_context.c_due_time < current_time) {
 815                 ALARM_MGR_EXCEPTION_PRINT("Caution!! alarm_context.c_due_time "
 816                 "(%d) is less than current time(%d)", alarm_context.c_due_time, current_time);
 817                 alarm_context.c_due_time = -1;
 818         }
 819
 820         due_time = _alarm_next_duetime(__alarm_info);
 821         if (__alarm_add_to_list(__alarm_info) == false) {
 822                 free(__alarm_info);
 823                 return false;
 824         }
 825
 826         if (due_time == 0) {
 827                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create a new alarm: due_time is 0, alarm(%d).", *alarm_id);
 828                 return true;
 829         } else if (current_time == due_time) {
 830                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create alarm: current_time(%d) is same as due_time(%d).",
 831                         current_time, due_time);
 832                 return true;
 833         } else if (difftime(due_time, current_time) <  0) {
 834                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: Expired Due Time.[Due time=%d, Current Time=%d]!!!Do not add to schedule list.",
 835                         due_time, current_time);
 836                 return true;
 837         } else {
 838                 char due_time_r[100] = { 0 };
 839                 struct tm ts_ret;
 840                 localtime_r(&due_time, &ts_ret);
 841                 strftime(due_time_r, 30, "%c", &ts_ret);
 842                 SECURE_LOGD("[alarm-server]:Create a new alarm: alarm(%d) due_time(%s)", *alarm_id, due_time_r);
 843         }
 844
 845         ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:alarm_context.c_due_time(%d), due_time(%d)", alarm_context.c_due_time, due_time);
 846
 847         if (alarm_context.c_due_time == -1 || due_time < alarm_context.c_due_time) {
 848                 _clear_scheduled_alarm_list();
 849                 _add_to_scheduled_alarm_list(__alarm_info);
 850                 _alarm_set_timer(&alarm_context, alarm_context.timer, due_time);
 851                 alarm_context.c_due_time = due_time;
 852         } else if (due_time == alarm_context.c_due_time) {
 853                 _add_to_scheduled_alarm_list(__alarm_info);
 854         }
 855
 856         __rtc_set();
 857
 858         return true;
 859 }
 860
 861 static bool __alarm_update(int pid, char *app_service_name, alarm_id_t alarm_id,
 862                            alarm_info_t *alarm_info, int *error_code)
 863 {
 864         time_t current_time;
 865         time_t due_time;
 866
 867         __alarm_info_t *__alarm_info = NULL;
 868         bool result = false;
 869
 870         __alarm_info = malloc(sizeof(__alarm_info_t));
 871         if (__alarm_info == NULL) {
 872                 SECURE_LOGE("Caution!! app_pid=%d, malloc failed. it seems to be OOM.", pid);
 873                 *error_code = ERR_ALARM_SYSTEM_FAIL;
 874                 return false;
 875         }
 876
 877         __alarm_info->pid = pid;
 878         __alarm_info->alarm_id = alarm_id;
 879
 880         /* we should consider to check whether  pid is running or Not
 881          */
 882
 883         __alarm_info->quark_app_service_name =
 884             g_quark_from_string(app_service_name);
 885         __alarm_set_start_and_end_time(alarm_info, __alarm_info);
 886         memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
 887
 888         time(&current_time);
 889
 890         if (alarm_context.c_due_time < current_time) {
 891                 ALARM_MGR_EXCEPTION_PRINT("Caution!! alarm_context.c_due_time "
 892                 "(%d) is less than current time(%d)", alarm_context.c_due_time, current_time);
 893                 alarm_context.c_due_time = -1;
 894         }
 895
 896         due_time = _alarm_next_duetime(__alarm_info);
 897         if (!__alarm_update_in_list(pid, alarm_id, __alarm_info, error_code)) {
 898                 free(__alarm_info);
 899                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: requested alarm_id "
 900                 "(%d) does not exist. so this value is invalid id.", alarm_id);
 901                 return false;
 902         }
 903
 904         result = _remove_from_scheduled_alarm_list(pid, alarm_id);
 905
 906         if (result == true && g_slist_length(g_scheduled_alarm_list) == 0) {
 907                 /*there is no scheduled alarm */
 908                 _alarm_disable_timer(alarm_context);
 909                 _alarm_schedule();
 910
 911                 ALARM_MGR_LOG_PRINT("[alarm-server]:Update alarm: alarm(%d).", alarm_id);
 912
 913                 __rtc_set();
 914
 915                 if (due_time == 0) {
 916                         ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Update alarm: due_time is 0.");
 917                 }
 918                 free(__alarm_info);
 919                 return true;
 920         }
 921
 922         if (due_time == 0) {
 923                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Update alarm: "
 924                                 "due_time is 0, alarm(%d)\n", alarm_id);
 925                 free(__alarm_info);
 926                 return true;
 927         } else if (current_time == due_time) {
 928                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Update alarm: "
 929                 "current_time(%d) is same as due_time(%d)", current_time,
 930                 due_time);
 931                 free(__alarm_info);
 932                 return true;
 933         } else if (difftime(due_time, current_time)< 0) {
 934                 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);
 935                 free(__alarm_info);
 936                 return true;
 937         } else {
 938                 char due_time_r[100] = { 0 };
 939                 struct tm ts_ret;
 940                 localtime_r(&due_time, &ts_ret);
 941                 strftime(due_time_r, 30, "%c", &ts_ret);
 942                 SECURE_LOGD("[alarm-server]:Update alarm: alarm(%d) "
 943                                     "due_time(%s)\n", alarm_id, due_time_r);
 944         }
 945
 946         ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:alarm_context.c_due_time(%d), due_time(%d)", alarm_context.c_due_time, due_time);
 947
 948         if (alarm_context.c_due_time == -1 || due_time < alarm_context.c_due_time) {
 949                 _clear_scheduled_alarm_list();
 950                 _add_to_scheduled_alarm_list(__alarm_info);
 951                 _alarm_set_timer(&alarm_context, alarm_context.timer, due_time);
 952                 alarm_context.c_due_time = due_time;
 953                 ALARM_MGR_LOG_PRINT("[alarm-server1]:alarm_context.c_due_time "
 954                      "(%d), due_time(%d)", alarm_context.c_due_time, due_time);
 955         } else if (due_time == alarm_context.c_due_time) {
 956                 _add_to_scheduled_alarm_list(__alarm_info);
 957                 ALARM_MGR_LOG_PRINT("[alarm-server2]:alarm_context.c_due_time "
 958                      "(%d), due_time(%d)", alarm_context.c_due_time, due_time);
 959         }
 960
 961         __rtc_set();
 962
 963         free(__alarm_info);
 964
 965         return true;
 966 }
 967
 968 static bool __alarm_delete(int pid, alarm_id_t alarm_id, int *error_code)
 969 {
 970         bool result = false;
 971
 972         SECURE_LOGD("[alarm-server]:delete alarm: alarm(%d) pid(%d)\n", alarm_id, pid);
 973         result = _remove_from_scheduled_alarm_list(pid, alarm_id);
 974
 975         if (!__alarm_remove_from_list(pid, alarm_id, error_code)) {
 976
 977                 SECURE_LOGE("[alarm-server]:delete alarm: "
 978                                           "alarm(%d) pid(%d) has failed with error_code(%d)\n",
 979                                           alarm_id, pid, *error_code);
 980                 return false;
 981         }
 982
 983         if (result == true && g_slist_length(g_scheduled_alarm_list) == 0) {
 984                 _alarm_disable_timer(alarm_context);
 985                 _alarm_schedule();
 986         }
 987
 988         __rtc_set();
 989
 990         return true;
 991 }
 992
 993 static void __alarm_send_noti_to_application(const char *app_service_name, alarm_id_t alarm_id)
 994 {
 995         char service_name[MAX_SERVICE_NAME_LEN] = {0,};
 996
 997         if (app_service_name == NULL || strlen(app_service_name) == 0) {
 998                 ALARM_MGR_EXCEPTION_PRINT("This alarm destination is invalid.");
 999                 return;
1000         }
1001
1002         memcpy(service_name, app_service_name, strlen(app_service_name));
1003         SECURE_LOGI("[alarm server][send expired_alarm(alarm_id=%d) to app_service_name(%s)]", alarm_id, service_name);
1004
1005         g_dbus_connection_call(alarm_context.connection,
1006                                                 service_name,
1007                                                 "/com/samsung/alarm/client",
1008                                                 "com.samsung.alarm.client",
1009                                                 "alarm_expired",
1010                                                 g_variant_new("(is)", alarm_id, service_name),
1011                                                 NULL,
1012                                                 G_DBUS_CALL_FLAGS_NONE,
1013                                                 -1,
1014                                                 NULL,
1015                                                 NULL,
1016                                                 NULL);
1017 }
1018
1019 static void __alarm_expired()
1020 {
1021         const char *destination_app_service_name = NULL;
1022         alarm_id_t alarm_id = -1;
1023         int app_pid = 0;
1024         __alarm_info_t *__alarm_info = NULL;
1025         char alarm_id_val[32]={0,};
1026         int b_len = 0;
1027         bundle *b = NULL;
1028         char *appid = NULL;
1029         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1030         GError *error = NULL;
1031         GVariant *result = NULL;
1032         gboolean name_has_owner_reply = false;
1033
1034         ALARM_MGR_LOG_PRINT("[alarm-server]: Enter");
1035
1036         time_t current_time;
1037         double interval;
1038
1039         time(&current_time);
1040
1041         interval = difftime(alarm_context.c_due_time, current_time);
1042         ALARM_MGR_LOG_PRINT("[alarm-server]: c_due_time(%d), current_time(%d), interval(%d)",
1043                 alarm_context.c_due_time, current_time, interval);
1044
1045         if (alarm_context.c_due_time > current_time + 1) {
1046                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: False Alarm. due time is (%d) seconds future",
1047                         alarm_context.c_due_time - current_time);
1048                 goto done;
1049         }
1050         // 10 seconds is maximum permitted delay from timer expire to this function
1051         if (alarm_context.c_due_time + 10 < current_time) {
1052                 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: False Alarm. due time is (%d) seconds past\n",
1053                         current_time - alarm_context.c_due_time);
1054                 goto done;
1055         }
1056
1057         GSList *iter = NULL;
1058         __scheduled_alarm_t *alarm = NULL;
1059
1060         for (iter = g_scheduled_alarm_list; iter != NULL; iter = g_slist_next(iter)) {
1061                 alarm = iter->data;
1062                 alarm_id = alarm->alarm_id;
1063
1064                 __alarm_info = alarm->__alarm_info;
1065
1066                 app_pid = __alarm_info->pid;
1067
1068                 if (strncmp(g_quark_to_string(__alarm_info->quark_bundle), "null", 4) != 0) {
1069                                 b_len = strlen(g_quark_to_string(__alarm_info->quark_bundle));
1070
1071                                 b = bundle_decode((bundle_raw *)g_quark_to_string(__alarm_info->quark_bundle), b_len);
1072
1073                                 if (b == NULL)
1074                                 {
1075                                         ALARM_MGR_EXCEPTION_PRINT("Error!!!..Unable to decode the bundle!!\n");
1076                                 }
1077                                 else
1078                                 {
1079                                         snprintf(alarm_id_val,31,"%d",alarm_id);
1080
1081                                         if (bundle_add_str(b,"http://tizen.org/appcontrol/data/alarm_id", alarm_id_val)){
1082                                                 ALARM_MGR_EXCEPTION_PRINT("Unable to add alarm id to the bundle\n");
1083                                         }
1084                                         else
1085                                         {
1086                                                 appid = (char *)appsvc_get_appid(b);
1087                                                 if( (__alarm_info->alarm_info.alarm_type & ALARM_TYPE_NOLAUNCH) && !aul_app_is_running(appid))
1088                                                 {
1089                                                         ALARM_MGR_EXCEPTION_PRINT("This alarm is ignored\n");
1090                                                 }
1091                                                 else
1092                                                 {
1093                                                         if ( appsvc_run_service(b, 0, NULL, NULL) < 0)
1094                                                         {
1095                                                                 ALARM_MGR_EXCEPTION_PRINT("Unable to run app svc\n");
1096                                                         }
1097                                                         else
1098                                                         {
1099                                                                 ALARM_MGR_LOG_PRINT("Successfuly ran app svc\n");
1100                                                         }
1101                                                 }
1102                                         }
1103                                         bundle_free(b);
1104                                 }
1105
1106                 }
1107                 else
1108                 {
1109                         if (strncmp(g_quark_to_string(__alarm_info->quark_dst_service_name), "null", 4) == 0) {
1110                                 SECURE_LOGD("[alarm-server]:destination is null, so we send expired alarm to %s(%u).",
1111                                         g_quark_to_string(__alarm_info->quark_app_service_name), __alarm_info->quark_app_service_name);
1112                                         destination_app_service_name = g_quark_to_string(__alarm_info->quark_app_service_name_mod);
1113                         } else {
1114                                 SECURE_LOGD("[alarm-server]:destination :%s(%u)",
1115                                         g_quark_to_string(__alarm_info->quark_dst_service_name), __alarm_info->quark_dst_service_name);
1116                                         destination_app_service_name = g_quark_to_string(__alarm_info->quark_dst_service_name_mod);
1117                         }
1118
1119                         /*
1120                          * we should consider a situation that
1121                          * destination_app_service_name is owner_name like (:xxxx) and
1122                          * application's pid which registered this alarm was killed.In that case,
1123                          * we don't need to send the expire event because the process was killed.
1124                          * this causes needless message to be sent.
1125                          */
1126                         SECURE_LOGD("[alarm-server]: destination_app_service_name :%s, app_pid=%d", destination_app_service_name, app_pid);
1127
1128                         result = g_dbus_connection_call_sync(alarm_context.connection,
1129                                                                 "org.freedesktop.DBus",
1130                                                                 "/org/freedesktop/DBus",
1131                                                                 "org.freedesktop.DBus",
1132                                                                 "NameHasOwner",
1133                                                                 g_variant_new ("(s)", destination_app_service_name),
1134                                                                 G_VARIANT_TYPE ("(b)"),
1135                                                                 G_DBUS_CALL_FLAGS_NONE,
1136                                                                 -1,
1137                                                                 NULL,
1138                                                                 &error);
1139                         if (result == NULL) {
1140                                 ALARM_MGR_EXCEPTION_PRINT("g_dbus_connection_call_sync() is failed. err: %s", error->message);
1141                                 g_error_free(error);
1142                         } else {
1143                                 g_variant_get (result, "(b)", &name_has_owner_reply);
1144                         }
1145
1146                         if (name_has_owner_reply == false) {
1147                                 __expired_alarm_t *expire_info;
1148                                 char appid[MAX_SERVICE_NAME_LEN] = { 0, };
1149                                 char alarm_id_str[32] = { 0, };
1150
1151                                 if (__alarm_info->alarm_info.alarm_type & ALARM_TYPE_WITHCB) {
1152                                         __alarm_remove_from_list(__alarm_info->pid, alarm_id, NULL);
1153                                         goto done;
1154                                 }
1155
1156                                 expire_info = malloc(sizeof(__expired_alarm_t));
1157                                 if (G_UNLIKELY(NULL == expire_info)) {
1158                                         ALARM_MGR_ASSERT_PRINT("[alarm-server]:Malloc failed!Can't notify alarm expiry info\n");
1159                                         goto done;
1160                                 }
1161                                 memset(expire_info, '\0', sizeof(__expired_alarm_t));
1162                                 strncpy(expire_info->service_name, destination_app_service_name, MAX_SERVICE_NAME_LEN-1);
1163                                 expire_info->alarm_id = alarm_id;
1164                                 g_expired_alarm_list = g_slist_append(g_expired_alarm_list, expire_info);
1165
1166                                 if (strncmp(g_quark_to_string(__alarm_info->quark_dst_service_name), "null",4) == 0) {
1167                                         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);
1168                                 }
1169                                 else {
1170                                         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);
1171                                 }
1172
1173                                 snprintf(alarm_id_str, 31, "%d", alarm_id);
1174
1175                                 SECURE_LOGD("before aul_launch appid(%s) alarm_id_str(%s)", appid, alarm_id_str);
1176
1177                                 bundle *kb;
1178                                 kb = bundle_create();
1179                                 bundle_add_str(kb, "__ALARM_MGR_ID", alarm_id_str);
1180                                 aul_launch_app(appid, kb);
1181                                 bundle_free(kb);
1182                         } else {
1183                                 ALARM_MGR_LOG_PRINT("before alarm_send_noti_to_application");
1184                                 ALARM_MGR_LOG_PRINT("WAKEUP pid: %d", __alarm_info->pid);
1185
1186                                 aul_update_freezer_status(__alarm_info->pid, "wakeup");
1187                                 __alarm_send_noti_to_application(destination_app_service_name, alarm_id);
1188                                 ALARM_MGR_LOG_PRINT("after __alarm_send_noti_to_application");
1189                         }
1190                 }
1191
1192                 ALARM_MGR_EXCEPTION_PRINT("alarm_id[%d] is expired.", alarm_id);
1193
1194                 sprintf(log_message, "alarmID: %d, pid: %d, unique_name: %s, duetime: %d",
1195                         alarm_id, app_pid, g_quark_to_string(__alarm_info->quark_app_unique_name), __alarm_info->due_time);
1196                 __save_module_log("EXPIRED", log_message);
1197                 memset(log_message, '\0', sizeof(log_message));
1198
1199                 if (__alarm_info->alarm_info.mode.repeat == ALARM_REPEAT_MODE_ONCE) {
1200                         __alarm_remove_from_list(__alarm_info->pid, alarm_id, NULL);
1201                 } else {
1202                         _alarm_next_duetime(__alarm_info);
1203                 }
1204         }
1205
1206  done:
1207         _clear_scheduled_alarm_list();
1208         alarm_context.c_due_time = -1;
1209
1210         ALARM_MGR_LOG_PRINT("[alarm-server]: Leave");
1211 }
1212
1213 static gboolean __alarm_handler_idle(gpointer user_data)
1214 {
1215         GPollFD *gpollfd = (GPollFD *) user_data;
1216         uint64_t exp;
1217         if (gpollfd == NULL) {
1218                 ALARM_MGR_EXCEPTION_PRINT("gpollfd is NULL");
1219                 return false;
1220         }
1221         if (read(gpollfd->fd, &exp, sizeof(uint64_t)) < 0) {
1222                 ALARM_MGR_EXCEPTION_PRINT("Reading the fd is failed.");
1223                 return false;
1224         }
1225
1226         ALARM_MGR_EXCEPTION_PRINT("Lock the display not to enter LCD OFF");
1227         if (__display_lock_state(DEVICED_LCD_OFF, DEVICED_STAY_CUR_STATE, 0) != ALARMMGR_RESULT_SUCCESS) {
1228                 ALARM_MGR_EXCEPTION_PRINT("__display_lock_state() is failed");
1229         }
1230
1231         if (g_dummy_timer_is_set == true) {
1232                 ALARM_MGR_LOG_PRINT("dummy alarm timer has expired.");
1233         }
1234         else {
1235                 ALARM_MGR_LOG_PRINT("__alarm_handler_idle");
1236                 __alarm_expired();
1237         }
1238
1239         _alarm_schedule();
1240
1241         __rtc_set();
1242
1243         ALARM_MGR_EXCEPTION_PRINT("Unlock the display from LCD OFF");
1244         if (__display_unlock_state(DEVICED_LCD_OFF, DEVICED_SLEEP_MARGIN) != ALARMMGR_RESULT_SUCCESS) {
1245                 ALARM_MGR_EXCEPTION_PRINT("__display_unlock_state() is failed");
1246         }
1247
1248         return false;
1249 }
1250
1251 static void __clean_registry()
1252 {
1253
1254         /*TODO:remove all db entries */
1255 }
1256
1257 static bool __alarm_manager_reset()
1258 {
1259         _alarm_disable_timer(alarm_context);
1260
1261         __alarm_clean_list();
1262
1263         _clear_scheduled_alarm_list();
1264         __clean_registry();
1265
1266         return true;
1267 }
1268
1269 static void __on_system_time_external_changed(keynode_t *node, void *data)
1270 {
1271         double diff_time = 0.0;
1272         time_t cur_time = 0;
1273
1274         _alarm_disable_timer(alarm_context);
1275
1276         if (node) {
1277                 diff_time = vconf_keynode_get_dbl(node);
1278         } else {
1279                 if (vconf_get_dbl(VCONFKEY_SYSTEM_TIMECHANGE_EXTERNAL, &diff_time) != VCONF_OK) {
1280                         ALARM_MGR_EXCEPTION_PRINT("Failed to get value of VCONFKEY_SYSTEM_TIMECHANGE_EXTERNAL.");
1281                         return;
1282                 }
1283         }
1284
1285         tzset();
1286         time(&cur_time);
1287
1288         ALARM_MGR_EXCEPTION_PRINT("diff_time is %f, New time is %s\n", diff_time, ctime(&cur_time));
1289
1290         ALARM_MGR_LOG_PRINT("[alarm-server] System time has been changed externally\n");
1291         ALARM_MGR_LOG_PRINT("1.alarm_context.c_due_time is %d\n",
1292                             alarm_context.c_due_time);
1293
1294         // set rtc time only because the linux time is set externally
1295         _set_rtc_time(cur_time);
1296
1297         vconf_set_int(VCONFKEY_SYSTEM_TIME_CHANGED,(int)diff_time);
1298
1299         __alarm_update_due_time_of_all_items_in_list(diff_time);
1300
1301         ALARM_MGR_LOG_PRINT("2.alarm_context.c_due_time is %d\n",
1302                             alarm_context.c_due_time);
1303         _clear_scheduled_alarm_list();
1304         _alarm_schedule();
1305         __rtc_set();
1306
1307         return;
1308 }
1309
1310 static void __on_time_zone_changed(keynode_t *node, void *data)
1311 {
1312         double diff_time = 0;
1313
1314         _alarm_disable_timer(alarm_context);
1315
1316         tzset();
1317
1318         ALARM_MGR_LOG_PRINT("[alarm-server] time zone has been changed\n");
1319         ALARM_MGR_LOG_PRINT("1.alarm_context.c_due_time is %d\n", alarm_context.c_due_time);
1320
1321         __alarm_update_due_time_of_all_items_in_list(diff_time);
1322
1323         ALARM_MGR_LOG_PRINT("2.alarm_context.c_due_time is %d\n", alarm_context.c_due_time);
1324         _clear_scheduled_alarm_list();
1325         _alarm_schedule();
1326         __rtc_set();
1327
1328         return;
1329 }
1330
1331 static int __on_app_uninstalled(int req_id, const char *pkg_type,
1332                                 const char *pkgid, const char *key, const char *val,
1333                                 const void *pmsg, void *user_data)
1334 {
1335         GSList* gs_iter = NULL;
1336         __alarm_info_t* entry = NULL;
1337         alarm_info_t* alarm_info = NULL;
1338         bool is_deleted = false;
1339
1340         SECURE_LOGD("pkg_type(%s), pkgid(%s), key(%s), value(%s)", pkg_type, pkgid, key, val);
1341
1342         if (strncmp(key, "end", 3) == 0 && strncmp(val, "ok", 2) == 0)
1343         {
1344                 for (gs_iter = alarm_context.alarms; gs_iter != NULL; )
1345                 {
1346                         bool is_found = false;
1347                         entry = gs_iter->data;
1348
1349                         char* caller_pkgid = g_quark_to_string(entry->quark_caller_pkgid);
1350                         char* callee_pkgid = g_quark_to_string(entry->quark_callee_pkgid);
1351
1352                         if ((caller_pkgid && strncmp(pkgid, caller_pkgid, strlen(pkgid)) == 0) ||
1353                                 (callee_pkgid && strncmp(pkgid, callee_pkgid, strlen(pkgid)) == 0))
1354                         {
1355                                 if (_remove_from_scheduled_alarm_list(pkgid, entry->alarm_id))
1356                                 {
1357                                         is_deleted = true;
1358                                 }
1359
1360                                 alarm_info = &entry->alarm_info;
1361                                 if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE))
1362                                 {
1363                                         if(!_delete_alarms(entry->alarm_id))
1364                                         {
1365                                                 SECURE_LOGE("_delete_alarms() is failed. pkgid[%s], alarm_id[%d]", pkgid, entry->alarm_id);
1366                                         }
1367                                 }
1368                                 is_found = true;
1369                         }
1370
1371                         gs_iter = g_slist_next(gs_iter);
1372
1373                         if (is_found)
1374                         {
1375                                 SECURE_LOGD("Remove pkgid[%s], alarm_id[%d]", pkgid, entry->alarm_id);
1376                                 alarm_context.alarms = g_slist_remove(alarm_context.alarms, entry);
1377                                 g_free(entry);
1378                         }
1379                 }
1380
1381                 if (is_deleted && (g_slist_length(g_scheduled_alarm_list) == 0))
1382                 {
1383                         _alarm_disable_timer(alarm_context);
1384                         _alarm_schedule();
1385                 }
1386         }
1387
1388         __rtc_set();
1389
1390         return ALARMMGR_RESULT_SUCCESS;
1391 }
1392
1393 int __check_privilege_by_cookie(char *e_cookie, const char *label, const char *access, bool check_root, int pid) {
1394         guchar *cookie = NULL;
1395         gsize size = 0;
1396         int retval = 0;
1397         char buf[128] = {0,};
1398         FILE *fp = NULL;
1399         char title[128] = {0,};
1400         int uid = -1;
1401
1402         if (check_root) {
1403                 // Gets the userID from /proc/pid/status to check if the process is the root or not.
1404                 snprintf(buf, sizeof(buf), "/proc/%d/status", pid);
1405                 fp = fopen(buf, "r");
1406                 if(fp) {
1407                         while (fgets(buf, sizeof(buf), fp) != NULL) {
1408                                 if(strncmp(buf, "Uid:", 4) == 0) {
1409                                         sscanf(buf, "%s %d", title, &uid);
1410                                         break;
1411                                 }
1412                         }
1413                         fclose(fp);
1414                 }
1415
1416                 ALARM_MGR_LOG_PRINT("uid : %d", uid);
1417         }
1418
1419         if (uid != 0) { // Checks the cookie only when the process is not the root
1420                 cookie = g_base64_decode(e_cookie, &size);
1421                 if (cookie == NULL) {
1422                         ALARM_MGR_EXCEPTION_PRINT("Unable to decode cookie!!!");
1423                         return ERR_ALARM_SYSTEM_FAIL;
1424                 }
1425
1426                 retval = security_server_check_privilege_by_cookie((const char *)cookie, label, access);
1427                 g_free(cookie);
1428
1429                 if (retval < 0) {
1430                         if (retval == SECURITY_SERVER_API_ERROR_ACCESS_DENIED) {
1431                                 ALARM_MGR_EXCEPTION_PRINT("Access to alarm-server has been denied by smack.");
1432                         }
1433                         ALARM_MGR_EXCEPTION_PRINT("Error has occurred in security_server_check_privilege_by_cookie() : %d.", retval);
1434                         return ERR_ALARM_NO_PERMISSION;
1435                 }
1436         }
1437
1438         ALARM_MGR_LOG_PRINT("The process(%d) was authenticated successfully.", pid);
1439         return ALARMMGR_RESULT_SUCCESS;
1440 }
1441
1442 bool __get_caller_unique_name(int pid, char *unique_name)
1443 {
1444         char caller_appid[256] = {0,};
1445
1446         if (unique_name == NULL)
1447         {
1448                 ALARM_MGR_EXCEPTION_PRINT("unique_name should not be NULL.");
1449                 return false;
1450         }
1451
1452         if (aul_app_get_appid_bypid(pid, caller_appid, sizeof(caller_appid)) == AUL_R_OK)
1453         {
1454                 // When a caller is an application, the unique name is appID.
1455                 strncpy(unique_name, caller_appid, strlen(caller_appid));
1456         }
1457         else
1458         {
1459                 // Otherwise, the unique name is /proc/pid/cmdline.
1460                 char proc_file[512] = {0,};
1461                 char process_name[512] = {0,};
1462                 int fd = 0;
1463                 int i = 0;
1464
1465                 snprintf(proc_file, 512, "/proc/%d/cmdline", pid);
1466
1467                 fd = open(proc_file, O_RDONLY);
1468                 if (fd < 0) {
1469                         SECURE_LOGE("Caution!! pid(%d) seems to be killed, so we failed to get proc file(%s) and do not create alarm_info.", pid, proc_file);
1470                         return false;
1471                 }
1472                 else {
1473                         if (read(fd, process_name, 512) <= 0)
1474                         {
1475                                 ALARM_MGR_EXCEPTION_PRINT("Unable to get the process name.");
1476                                 close(fd);
1477                                 return false;
1478                         }
1479                         close(fd);
1480
1481                         while (process_name[i] != '\0') {
1482                                 if (process_name[i] == ' ') {
1483                                         process_name[i] = '\0';
1484                                         break;
1485                                 }
1486                                 ++i;
1487                         }
1488                         strncpy(unique_name, process_name, strlen(process_name));
1489                 }
1490         }
1491
1492         SECURE_LOGD("unique_name= %s", unique_name);
1493         return true;
1494 }
1495
1496 static void __initialize_module_log(void)
1497 {
1498         log_fd = open(ALARMMGR_LOG_FILE_PATH, O_CREAT | O_WRONLY, 0644);
1499         if (log_fd == -1) {
1500                 ALARM_MGR_EXCEPTION_PRINT("Opening the file for alarmmgr log is failed.");
1501                 return;
1502         }
1503
1504         int offset = lseek(log_fd, 0, SEEK_END);
1505         if (offset != 0) {
1506                 log_index = (int)(offset / ALARMMGR_LOG_BUFFER_STRING_SIZE);
1507                 if (log_index >= ALARMMGR_LOG_BUFFER_SIZE) {
1508                         log_index = 0;
1509                         lseek(log_fd, 0, SEEK_SET);
1510                 }
1511         }
1512         return;
1513 }
1514
1515 static bool __save_module_log(const char *tag, const char *message)
1516 {
1517         char buffer[ALARMMGR_LOG_BUFFER_STRING_SIZE] = {0,};
1518         time_t now;
1519         int offset = 0;
1520
1521         if (log_fd == -1) {
1522                 ALARM_MGR_EXCEPTION_PRINT("The file is not ready.");
1523                 return false;
1524         }
1525
1526         if (log_index != 0) {
1527                 offset = lseek(log_fd, 0, SEEK_CUR);
1528         } else {
1529                 offset = lseek(log_fd, 0, SEEK_SET);
1530         }
1531
1532         time(&now);
1533         snprintf(buffer, ALARMMGR_LOG_BUFFER_STRING_SIZE, "[%-6d] %-20s %-120s %d-%s", log_index, tag, message, (int)now, ctime(&now));
1534
1535         int ret = write(log_fd, buffer, strlen(buffer));
1536         if (ret < 0) {
1537                 ALARM_MGR_EXCEPTION_PRINT("Writing the alarmmgr log is failed.");
1538                 return false;
1539         }
1540
1541         if (++log_index >= ALARMMGR_LOG_BUFFER_SIZE) {
1542                 log_index = 0;
1543         }
1544         return true;
1545 }
1546
1547 int __display_lock_state(char *state, char *flag, unsigned int timeout)
1548 {
1549         GDBusMessage *msg = NULL;
1550         GDBusMessage *reply = NULL;
1551         GVariant *body = NULL;
1552         GError *error = NULL;
1553         int ret = ALARMMGR_RESULT_SUCCESS;
1554         int val = -1;
1555
1556         msg = g_dbus_message_new_method_call(DEVICED_BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, DEVICED_LOCK_STATE);
1557         if (!msg) {
1558                 ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_new_method_call() is failed. (%s:%s-%s)", DEVICED_BUS_NAME, DEVICED_INTERFACE_DISPLAY, DEVICED_LOCK_STATE);
1559                 return ERR_ALARM_SYSTEM_FAIL;
1560         }
1561
1562         g_dbus_message_set_body(msg, g_variant_new("(sssi)", state, flag, "NULL", timeout));
1563
1564         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, &error);
1565         if (!reply) {
1566                 ALARM_MGR_EXCEPTION_PRINT("No reply. error = %s", error->message);
1567                 g_error_free(error);
1568                 ret = ERR_ALARM_SYSTEM_FAIL;
1569         } else {
1570                 body = g_dbus_message_get_body(reply);
1571                 if (!body) {
1572                         ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_get_body() is failed.");
1573                         ret = ERR_ALARM_SYSTEM_FAIL;
1574                 } else {
1575                         g_variant_get(body, "(i)", &val);
1576                         if (val != 0) {
1577                                 ALARM_MGR_EXCEPTION_PRINT("Failed to lock display");
1578                                 ret = ERR_ALARM_SYSTEM_FAIL;
1579                         } else {
1580                                 ALARM_MGR_EXCEPTION_PRINT("Lock LCD OFF is successfully done");
1581                         }
1582                 }
1583         }
1584
1585         g_dbus_connection_flush_sync(alarm_context.connection, NULL, NULL);
1586         g_object_unref(msg);
1587         g_object_unref(reply);
1588
1589         return ret;
1590 }
1591
1592 int __display_unlock_state(char *state, char *flag)
1593 {
1594         GDBusMessage *msg = NULL;
1595         GDBusMessage *reply = NULL;
1596         GVariant *body = NULL;
1597         GError *error = NULL;
1598         int ret = ALARMMGR_RESULT_SUCCESS;
1599         int val = -1;
1600
1601         msg = g_dbus_message_new_method_call(DEVICED_BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, DEVICED_UNLOCK_STATE);
1602         if (!msg) {
1603                 ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_new_method_call() is failed. (%s:%s-%s)", DEVICED_BUS_NAME, DEVICED_INTERFACE_DISPLAY, DEVICED_UNLOCK_STATE);
1604                 return ERR_ALARM_SYSTEM_FAIL;
1605         }
1606
1607         g_dbus_message_set_body(msg, g_variant_new("(ss)", state, flag ));
1608
1609         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, &error);
1610         if (!reply) {
1611                 ALARM_MGR_EXCEPTION_PRINT("No reply. error = %s", error->message);
1612                 g_error_free(error);
1613                 ret = ERR_ALARM_SYSTEM_FAIL;
1614         } else {
1615                 body = g_dbus_message_get_body(reply);
1616                 if (!body) {
1617                         ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_get_body() is failed.");
1618                         ret = ERR_ALARM_SYSTEM_FAIL;
1619                 } else {
1620                         g_variant_get(body, "(i)", &val);
1621                         if (val != 0) {
1622                                 ALARM_MGR_EXCEPTION_PRINT("Failed to unlock display");
1623                                 ret = ERR_ALARM_SYSTEM_FAIL;
1624                         } else {
1625                                 ALARM_MGR_EXCEPTION_PRINT("Unlock LCD OFF is successfully done");
1626                         }
1627                 }
1628         }
1629
1630         g_dbus_connection_flush_sync(alarm_context.connection, NULL, NULL);
1631         g_object_unref(msg);
1632         g_object_unref(reply);
1633
1634         return ret;
1635 }
1636
1637 gboolean alarm_manager_alarm_set_rtc_time(AlarmManager *pObj, GDBusMethodInvocation *invoc, int pid,
1638                                 int year, int mon, int day,
1639                                 int hour, int min, int sec, char *e_cookie,
1640                                 gpointer user_data) {
1641         const char *rtc = default_rtc;
1642         struct timespec alarm_time;
1643         int retval = 0;
1644         int return_code = ALARMMGR_RESULT_SUCCESS;
1645
1646         struct rtc_time rtc_tm = {0,};
1647         struct rtc_wkalrm rtc_wk;
1648         struct tm *alarm_tm = NULL;
1649
1650         char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
1651         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1652
1653         retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "w", false, pid);
1654         if (retval != ALARMMGR_RESULT_SUCCESS) {
1655                 return_code = retval;
1656                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1657                 return true;
1658         }
1659
1660         /*extract day of the week, day in the year & daylight saving time from system*/
1661         time_t current_time;
1662         current_time = time(NULL);
1663         alarm_tm = localtime(&current_time);
1664
1665         alarm_tm->tm_year = year;
1666         alarm_tm->tm_mon = mon;
1667         alarm_tm->tm_mday = day;
1668         alarm_tm->tm_hour = hour;
1669         alarm_tm->tm_min = min;
1670         alarm_tm->tm_sec = sec;
1671
1672         /*convert to calendar time representation*/
1673         time_t rtc_time = mktime(alarm_tm);
1674
1675         if (gfd == 0) {
1676                 gfd = open(rtc, O_RDWR);
1677                 if (gfd == -1) {
1678                         ALARM_MGR_EXCEPTION_PRINT("RTC open failed.");
1679                         return_code = ERR_ALARM_SYSTEM_FAIL;
1680                         g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1681                         return true;
1682                 }
1683         }
1684
1685         alarm_time.tv_sec = rtc_time;
1686         alarm_time.tv_nsec = 0;
1687
1688         retval = ioctl(gfd, ALARM_SET(ALARM_RTC_WAKEUP), &alarm_time);
1689         if (retval == -1) {
1690                 if (errno == ENOTTY) {
1691                         ALARM_MGR_EXCEPTION_PRINT("Alarm IRQs is not supported.");
1692                 }
1693                 ALARM_MGR_EXCEPTION_PRINT("RTC ALARM_SET ioctl is failed. errno = %s", strerror(errno));
1694                 return_code = ERR_ALARM_SYSTEM_FAIL;
1695                 strncpy(log_tag, "FAIL: SET RTC", strlen("FAIL: SET RTC"));
1696         }
1697         else{
1698                 ALARM_MGR_LOG_PRINT("[alarm-server]RTC alarm is setted");
1699                 strncpy(log_tag, "SET RTC", strlen("SET RTC"));
1700         }
1701
1702         sprintf(log_message, "wakeup rtc time: %d, %s", rtc_time, ctime(&rtc_time));
1703         __save_module_log(log_tag, log_message);
1704
1705         g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1706         return true;
1707 }
1708
1709 gboolean alarm_manager_alarm_set_time(AlarmManager *pObj, GDBusMethodInvocation *invoc, int _time, gpointer user_data)
1710 {
1711         static int diff_msec = 0;       // To check a millisecond part of current time at changing the system time
1712         double diff_time = 0.0;
1713         struct timeval before;
1714         int return_code = ALARMMGR_RESULT_SUCCESS;
1715         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1716
1717         _alarm_disable_timer(alarm_context);
1718
1719         gettimeofday(&before, NULL);
1720         diff_msec += (before.tv_usec / 1000);   // Accrue the millisecond to compensate the time
1721         ALARM_MGR_LOG_PRINT("Current time = %s. usec = %ld. diff_msec = %d.\n", ctime(&before.tv_sec), before.tv_usec, diff_msec);
1722
1723         if (diff_msec > 500) {
1724                 diff_time = difftime(_time, before.tv_sec) - 1;
1725                 diff_msec -= 1000;
1726         }
1727         else {
1728                 diff_time = difftime(_time, before.tv_sec);
1729         }
1730
1731         tzset();
1732
1733         char *timebuf = ctime(&_time);
1734         timebuf[strlen(timebuf) - 1] = '\0';    // to avoid newline
1735         sprintf(log_message, "Current: %d, New: %d, %s, diff: %f", before.tv_sec, _time, timebuf, diff_time);
1736         __save_module_log("CHANGE TIME", log_message);
1737
1738         ALARM_MGR_EXCEPTION_PRINT("[TIMESTAMP]Current time(%d), New time(%d)(%s), diff_time(%f)", before.tv_sec, _time, ctime(&_time), diff_time);
1739
1740         ALARM_MGR_LOG_PRINT("[alarm-server] System time has been changed\n");
1741         ALARM_MGR_LOG_PRINT("1.alarm_context.c_due_time is %d\n", alarm_context.c_due_time);
1742
1743         _set_time(_time - 1);
1744         __alarm_update_due_time_of_all_items_in_list(diff_time);
1745
1746         ALARM_MGR_LOG_PRINT("2.alarm_context.c_due_time is %d", alarm_context.c_due_time);
1747         _clear_scheduled_alarm_list();
1748         _alarm_schedule();
1749         __rtc_set();
1750         _set_time(_time);
1751
1752         vconf_set_int(VCONFKEY_SYSTEM_TIME_CHANGED,(int)diff_time);
1753
1754         g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1755         return true;
1756 }
1757
1758 gboolean alarm_manager_alarm_create_appsvc(AlarmManager *pObject, GDBusMethodInvocation *invoc,
1759                                         int pid,
1760                                     int start_year,
1761                                     int start_month, int start_day,
1762                                     int start_hour, int start_min,
1763                                     int start_sec, int end_year, int end_month,
1764                                     int end_day, int mode_day_of_week,
1765                                     int mode_repeat, int alarm_type,
1766                                     int reserved_info,
1767                                     char *bundle_data, char *e_cookie,
1768                                     gpointer user_data)
1769 {
1770         alarm_info_t alarm_info;
1771         int retval = 0;
1772         int return_code = ALARMMGR_RESULT_SUCCESS;
1773         int alarm_id = 0;
1774         char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
1775         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1776         bool ret = true;
1777
1778         retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "w", false, pid);
1779         if (retval != ALARMMGR_RESULT_SUCCESS) {
1780                 return_code = retval;
1781                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
1782                 sprintf(log_message, "pid: %d, Smack denied (alarm-server::alarm, w)", pid);
1783                 __save_module_log("FAIL: CREATE", log_message);
1784                 return true;
1785         }
1786
1787         alarm_info.start.year = start_year;
1788         alarm_info.start.month = start_month;
1789         alarm_info.start.day = start_day;
1790         alarm_info.start.hour = start_hour;
1791         alarm_info.start.min = start_min;
1792         alarm_info.start.sec = start_sec;
1793
1794         alarm_info.end.year = end_year;
1795         alarm_info.end.month = end_month;
1796         alarm_info.end.day = end_day;
1797
1798         alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
1799         alarm_info.mode.repeat = mode_repeat;
1800
1801         alarm_info.alarm_type = alarm_type;
1802         alarm_info.reserved_info = reserved_info;
1803
1804         if (!__alarm_create_appsvc(&alarm_info, &alarm_id, pid, bundle_data, &return_code)) {
1805                 ALARM_MGR_EXCEPTION_PRINT("Unable to create alarm! return_code[%d]", return_code);
1806                 strncpy(log_tag, "FAIL: CREATE", strlen("FAIL: CREATE"));
1807                 ret = false;
1808         } else {
1809                 strncpy(log_tag, "CREATE", strlen("CREATE"));
1810                 ret = true;
1811         }
1812
1813         g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
1814
1815         sprintf(log_message, "alarmID: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
1816                 alarm_id, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
1817         __save_module_log(log_tag, log_message);
1818
1819         return ret;
1820 }
1821
1822 gboolean alarm_manager_alarm_create(AlarmManager *obj, GDBusMethodInvocation *invoc, int pid,
1823                                     char *app_service_name, char *app_service_name_mod,  int start_year,
1824                                     int start_month, int start_day,
1825                                     int start_hour, int start_min,
1826                                     int start_sec, int end_year, int end_month,
1827                                     int end_day, int mode_day_of_week,
1828                                     int mode_repeat, int alarm_type,
1829                                     int reserved_info,
1830                                     char *reserved_service_name, char *reserved_service_name_mod, char *e_cookie,
1831                                     gpointer user_data)
1832 {
1833         alarm_info_t alarm_info;
1834         int retval = 0;
1835         int return_code = ALARMMGR_RESULT_SUCCESS;
1836         int alarm_id = 0;
1837         char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
1838         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1839         bool ret = true;
1840
1841         retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "w", true, pid);
1842         if (retval != ALARMMGR_RESULT_SUCCESS) {
1843                 return_code = retval;
1844                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
1845                 sprintf(log_message, "pid: %d, Smack denied (alarm-server::alarm, w)", pid);
1846                 __save_module_log("FAIL: CREATE", log_message);
1847                 return true;
1848         }
1849
1850         alarm_info.start.year = start_year;
1851         alarm_info.start.month = start_month;
1852         alarm_info.start.day = start_day;
1853         alarm_info.start.hour = start_hour;
1854         alarm_info.start.min = start_min;
1855         alarm_info.start.sec = start_sec;
1856
1857         alarm_info.end.year = end_year;
1858         alarm_info.end.month = end_month;
1859         alarm_info.end.day = end_day;
1860
1861         alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
1862         alarm_info.mode.repeat = mode_repeat;
1863
1864         alarm_info.alarm_type = alarm_type;
1865         alarm_info.reserved_info = reserved_info;
1866
1867         if (!__alarm_create(&alarm_info, &alarm_id, pid, app_service_name,app_service_name_mod,
1868                        reserved_service_name, reserved_service_name_mod, &return_code)) {
1869                 ALARM_MGR_EXCEPTION_PRINT("Unable to create alarm! return_code[%d]", return_code);
1870                 strncpy(log_tag, "FAIL: CREATE", strlen("FAIL: CREATE"));
1871                 ret = false;
1872         } else {
1873                 strncpy(log_tag, "CREATE", strlen("CREATE"));
1874                 ret = true;
1875         }
1876
1877         g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
1878
1879         sprintf(log_message, "alarmID: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
1880                 alarm_id, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
1881         __save_module_log(log_tag, log_message);
1882
1883         return ret;
1884 }
1885
1886 gboolean alarm_manager_alarm_delete(AlarmManager *obj, GDBusMethodInvocation *invoc,
1887                                         int pid, alarm_id_t alarm_id,
1888                                     char *e_cookie, gpointer user_data)
1889 {
1890         int retval = 0;
1891         int return_code = ALARMMGR_RESULT_SUCCESS;
1892         char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
1893         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1894         bool ret = true;
1895
1896         retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "w", true, pid);
1897         if (retval != ALARMMGR_RESULT_SUCCESS) {
1898                 return_code = retval;
1899                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1900                 sprintf(log_message, "alarmID: %d, pid: %d, Smack denied (alarm-server::alarm, w)", alarm_id, pid);
1901                 __save_module_log("FAIL: DELETE", log_message);
1902                 return true;
1903         }
1904
1905         if (!__alarm_delete(pid, alarm_id, &return_code)) {
1906                 ALARM_MGR_EXCEPTION_PRINT("Unable to delete the alarm! alarm_id[%d], return_code[%d]", alarm_id, return_code);
1907                 strncpy(log_tag, "FAIL: DELETE", strlen("FAIL: DELETE"));
1908                 ret = false;
1909         } else {
1910                 ALARM_MGR_EXCEPTION_PRINT("alarm_id[%d] is removed.", alarm_id);
1911                 strncpy(log_tag, "DELETE", strlen("DELETE"));
1912                 ret = true;
1913         }
1914
1915         g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1916
1917         sprintf(log_message, "alarmID: %d, pid: %d", alarm_id, pid);
1918         __save_module_log(log_tag, log_message);
1919
1920         return ret;
1921 }
1922
1923 gboolean alarm_manager_alarm_delete_all(AlarmManager *obj, GDBusMethodInvocation *invoc,
1924                                         int pid, char *e_cookie, gpointer user_data)
1925 {
1926         GSList* gs_iter = NULL;
1927         char app_name[512] = { 0 };
1928         alarm_info_t* alarm_info = NULL;
1929         __alarm_info_t* entry = NULL;
1930         bool is_deleted = false;
1931         int retval = 0;
1932         int return_code = ALARMMGR_RESULT_SUCCESS;
1933         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1934
1935         retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "w", true, pid);
1936         if (retval != ALARMMGR_RESULT_SUCCESS) {
1937                 return_code = retval;
1938                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1939                 sprintf(log_message, "pid: %d, Smack denied (alarm-server::alarm, w)", pid);
1940                 __save_module_log("FAIL: DELETE ALL", log_message);
1941                 return true;
1942         }
1943
1944         if (!__get_caller_unique_name(pid, app_name)) {
1945                 return_code = ERR_ALARM_SYSTEM_FAIL;
1946                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1947                 sprintf(log_message, "pid: %d. Can not get the unique_name.", pid);
1948                 __save_module_log("FAIL: DELETE ALL", log_message);
1949                 return true;
1950         }
1951
1952         SECURE_LOGD("Called by process (pid:%d, unique_name=%s)", pid, app_name);
1953
1954         for (gs_iter = alarm_context.alarms; gs_iter != NULL; )
1955         {
1956                 bool is_found = false;
1957                 entry = gs_iter->data;
1958                 char* tmp_appname = g_quark_to_string(entry->quark_app_unique_name);
1959                 SECURE_LOGD("Try to remove app_name[%s], alarm_id[%d]\n", tmp_appname, entry->alarm_id);
1960                 if (tmp_appname && strncmp(app_name, tmp_appname, strlen(tmp_appname)) == 0)
1961                 {
1962                         if (_remove_from_scheduled_alarm_list(pid, entry->alarm_id))
1963                         {
1964                                 is_deleted = true;
1965                         }
1966
1967                         alarm_info = &entry->alarm_info;
1968                         if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE))
1969                         {
1970                                 if(!_delete_alarms(entry->alarm_id))
1971                                 {
1972                                         SECURE_LOGE("_delete_alarms() is failed. pid[%d], alarm_id[%d]", pid, entry->alarm_id);
1973                                 }
1974                         }
1975                         is_found = true;
1976                 }
1977
1978                 gs_iter = g_slist_next(gs_iter);
1979
1980                 if (is_found)
1981                 {
1982                         ALARM_MGR_EXCEPTION_PRINT("alarm_id[%d] is removed.", entry->alarm_id);
1983                         SECURE_LOGD("Removing is done. app_name[%s], alarm_id [%d]\n", tmp_appname, entry->alarm_id);
1984                         alarm_context.alarms = g_slist_remove(alarm_context.alarms, entry);
1985                         g_free(entry);
1986                 }
1987         }
1988
1989         if (is_deleted && (g_slist_length(g_scheduled_alarm_list) == 0))
1990         {
1991                 _alarm_disable_timer(alarm_context);
1992                 _alarm_schedule();
1993         }
1994
1995         __rtc_set();
1996         g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1997         return true;
1998 }
1999
2000 gboolean alarm_manager_alarm_update(AlarmManager *pObj, GDBusMethodInvocation *invoc, int pid,
2001                                     char *app_service_name, alarm_id_t alarm_id,
2002                                     int start_year, int start_month,
2003                                     int start_day, int start_hour,
2004                                     int start_min, int start_sec, int end_year,
2005                                     int end_month, int end_day,
2006                                     int mode_day_of_week, int mode_repeat,
2007                                     int alarm_type, int reserved_info,
2008                                     gpointer user_data)
2009 {
2010         int return_code = ALARMMGR_RESULT_SUCCESS;
2011         alarm_info_t alarm_info;
2012         bool ret = true;
2013         char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
2014         char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
2015
2016         alarm_info.start.year = start_year;
2017         alarm_info.start.month = start_month;
2018         alarm_info.start.day = start_day;
2019         alarm_info.start.hour = start_hour;
2020         alarm_info.start.min = start_min;
2021         alarm_info.start.sec = start_sec;
2022
2023         alarm_info.end.year = end_year;
2024         alarm_info.end.month = end_month;
2025         alarm_info.end.day = end_day;
2026
2027         alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
2028         alarm_info.mode.repeat = mode_repeat;
2029
2030         alarm_info.alarm_type = alarm_type;
2031         alarm_info.reserved_info = reserved_info;
2032
2033         if (!__alarm_update(pid, app_service_name, alarm_id, &alarm_info, &return_code)) {
2034                 ALARM_MGR_EXCEPTION_PRINT("Unable to update the alarm! alarm_id[%d], return_code[%d]", alarm_id, return_code);
2035                 strncpy(log_tag, "FAIL: UPDATE", strlen("FAIL: UPDATE"));
2036                 ret = false;
2037         } else {
2038                 strncpy(log_tag, "UPDATE", strlen("UPDATE"));
2039                 ret = true;
2040         }
2041
2042         g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2043
2044         sprintf(log_message, "alarmID: %d, appname: %s, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
2045                 alarm_id, app_service_name, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
2046         __save_module_log(log_tag, log_message);
2047
2048         return ret;
2049 }
2050
2051 gboolean alarm_manager_alarm_get_number_of_ids(AlarmManager *pObject, GDBusMethodInvocation *invoc, int pid, char *e_cookie,
2052                                                gpointer user_data)
2053 {
2054         GSList *gs_iter = NULL;
2055         char app_name[256] = { 0 };
2056         __alarm_info_t *entry = NULL;
2057         int retval = 0;
2058         int num_of_ids = 0;
2059         int return_code = ALARMMGR_RESULT_SUCCESS;
2060
2061         retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "r", true, pid);
2062         if (retval != ALARMMGR_RESULT_SUCCESS) {
2063                 return_code = retval;
2064                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", num_of_ids, return_code));
2065                 return true;
2066         }
2067
2068         if (!__get_caller_unique_name(pid, app_name)) {
2069                 return_code = ERR_ALARM_SYSTEM_FAIL;
2070                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", num_of_ids, return_code));
2071                 return true;
2072         }
2073
2074         SECURE_LOGD("Called by process (pid:%d, unique_name:%s)", pid, app_name);
2075
2076         for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
2077                 entry = gs_iter->data;
2078                 SECURE_LOGD("app_name=%s, quark_app_unique_name=%s", app_name, g_quark_to_string(entry->quark_app_unique_name));
2079                 if (strncmp(app_name, g_quark_to_string(entry->quark_app_unique_name), strlen(app_name)) == 0) {
2080                         (num_of_ids)++;
2081                         SECURE_LOGD("inc number of alarms of app (pid:%d, unique_name:%s) is %d.", pid, app_name, num_of_ids);
2082                 }
2083         }
2084
2085         SECURE_LOGD("number of alarms of the process (pid:%d, unique_name:%s) is %d.", pid, app_name, num_of_ids);
2086         g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", num_of_ids, return_code));
2087         return true;
2088 }
2089
2090 gboolean alarm_manager_alarm_get_list_of_ids(AlarmManager *pObject, GDBusMethodInvocation *invoc, int pid,
2091                                              int max_number_of_ids, gpointer user_data)
2092 {
2093         GSList *gs_iter = NULL;
2094         char app_name[512] = { 0 };
2095         __alarm_info_t *entry = NULL;
2096         int index = 0;
2097         GVariant* arr = NULL;
2098         GVariantBuilder* builder = NULL;
2099         int num_of_ids = 0;
2100         int return_code = ALARMMGR_RESULT_SUCCESS;
2101
2102         if (max_number_of_ids <= 0) {
2103                 SECURE_LOGE("called for pid(%d), but max_number_of_ids(%d) is less than 0.", pid, max_number_of_ids);
2104                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(@aiii)", g_variant_new("ai", NULL), num_of_ids, return_code));
2105                 return true;
2106         }
2107
2108         if (!__get_caller_unique_name(pid, app_name)) {
2109                 return_code = ERR_ALARM_SYSTEM_FAIL;
2110                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(@aiii)", g_variant_new("ai", NULL), num_of_ids, return_code));
2111                 return true;
2112         }
2113
2114         SECURE_LOGD("Called by process (pid:%d, unique_name=%s).", pid, app_name);
2115
2116         builder = g_variant_builder_new(G_VARIANT_TYPE ("ai"));
2117         for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
2118                 entry = gs_iter->data;
2119                 if (strncmp(app_name, g_quark_to_string(entry->quark_app_unique_name), strlen(app_name)) == 0) {
2120                         g_variant_builder_add (builder, "i", entry->alarm_id);
2121                         index ++;
2122                         SECURE_LOGE("called for alarmid(%d), but max_number_of_ids(%d) index %d.", entry->alarm_id, max_number_of_ids, index);
2123                 }
2124         }
2125
2126         arr = g_variant_new("ai", builder);
2127         num_of_ids = index;
2128
2129         SECURE_LOGE("Called by pid (%d), but max_number_of_ids(%d) return code %d.", pid, num_of_ids, return_code);
2130         g_dbus_method_invocation_return_value(invoc, g_variant_new("(@aiii)", arr, num_of_ids, return_code));
2131
2132         g_variant_builder_unref(builder);
2133         return true;
2134 }
2135
2136 gboolean alarm_manager_alarm_get_appsvc_info(AlarmManager *pObject, GDBusMethodInvocation *invoc ,
2137                                 int pid, alarm_id_t alarm_id,
2138                                 char *e_cookie, gpointer user_data)
2139 {
2140         bool found = false;
2141         GSList *gs_iter = NULL;
2142         __alarm_info_t *entry = NULL;
2143         int retval = 0;
2144         int return_code = ALARMMGR_RESULT_SUCCESS;
2145         gchar *b_data = NULL;
2146
2147         SECURE_LOGD("called for pid(%d) and alarm_id(%d)\n", pid, alarm_id);
2148
2149         retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "r", false, pid);
2150         if (retval != ALARMMGR_RESULT_SUCCESS) {
2151                 return_code = retval;
2152                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", b_data, return_code));
2153                 return true;
2154         }
2155
2156         for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
2157                 entry = gs_iter->data;
2158                 if (entry->alarm_id == alarm_id) {
2159                         found = true;
2160                         b_data = g_strdup(g_quark_to_string(entry->quark_bundle));
2161                         break;
2162                 }
2163         }
2164
2165         if (found) {
2166                 if (b_data && strlen(b_data) == 4 && strncmp(b_data, "null", 4) == 0) {
2167                         ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is an regular alarm, not svc alarm.", alarm_id);
2168                         return_code = ERR_ALARM_INVALID_TYPE;
2169                 }
2170         } else {
2171                 ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is not found.", alarm_id);
2172                 return_code = ERR_ALARM_INVALID_ID;
2173         }
2174
2175         g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", b_data, return_code));
2176         g_free(b_data);
2177         return true;
2178 }
2179
2180 gboolean alarm_manager_alarm_get_info(AlarmManager *pObject, GDBusMethodInvocation *invoc, int pid,
2181                                       alarm_id_t alarm_id, char *e_cookie, gpointer user_data)
2182 {
2183         SECURE_LOGD("called for pid(%d) and alarm_id(%d)\n", pid, alarm_id);
2184
2185         GSList *gs_iter = NULL;
2186         __alarm_info_t *entry = NULL;
2187         alarm_info_t *alarm_info = NULL;
2188         int retval = 0;
2189         int return_code = ALARMMGR_RESULT_SUCCESS;
2190
2191         retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "r", true, pid);
2192         if (retval != ALARMMGR_RESULT_SUCCESS) {
2193                 return_code = retval;
2194                 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));
2195                 return true;
2196         }
2197
2198         for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
2199                 entry = gs_iter->data;
2200                 if (entry->alarm_id == alarm_id) {
2201                         alarm_info = &(entry->alarm_info);
2202                         break;
2203                 }
2204         }
2205
2206         if (alarm_info == NULL) {
2207                 ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is not found.", alarm_id);
2208                 return_code = ERR_ALARM_INVALID_ID;
2209                 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));
2210         } else {
2211                 ALARM_MGR_LOG_PRINT("The alarm(%d) is found.", alarm_id);
2212                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(iiiiiiiiiiiiii)", alarm_info->start.year, alarm_info->start.month,
2213                                                         alarm_info->start.day, alarm_info->start.hour, alarm_info->start.min, alarm_info->start.sec, alarm_info->end.year, alarm_info->end.month,
2214                                                         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));
2215         }
2216
2217         return true;
2218 }
2219
2220 gboolean alarm_manager_alarm_get_next_duetime(AlarmManager *pObject, GDBusMethodInvocation *invoc, int pid,
2221                                       alarm_id_t alarm_id, char *e_cookie, gpointer user_data)
2222 {
2223         SECURE_LOGD("called for pid(%d) and alarm_id(%d)\n", pid, alarm_id);
2224
2225         GSList *gs_iter = NULL;
2226         __alarm_info_t *entry = NULL;
2227         __alarm_info_t *find_item = NULL;
2228         int retval = 0;
2229         int return_code = ALARMMGR_RESULT_SUCCESS;
2230         time_t duetime = 0;
2231
2232         retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "r", true, pid);
2233         if (retval != ALARMMGR_RESULT_SUCCESS) {
2234                 return_code = retval;
2235                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", duetime, return_code));
2236                 return true;
2237         }
2238
2239         for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
2240                 entry = gs_iter->data;
2241                 if (entry->alarm_id == alarm_id) {
2242                         find_item = entry;
2243                         break;
2244                 }
2245         }
2246
2247         if (find_item == NULL) {
2248                 ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is not found.", alarm_id);
2249                 return_code = ERR_ALARM_INVALID_ID;
2250                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", duetime, return_code));
2251                 return true;
2252         }
2253
2254         duetime = _alarm_next_duetime(find_item);
2255         ALARM_MGR_LOG_PRINT("Next duetime : %s", ctime(&duetime));
2256
2257         g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", duetime, return_code));
2258         return true;
2259 }
2260
2261 gboolean alarm_manager_alarm_get_all_info(AlarmManager *pObject, GDBusMethodInvocation *invoc, int pid, char *e_cookie, gpointer user_data)
2262 {
2263         sqlite3 *alarmmgr_tool_db;
2264         char *db_path = NULL;
2265         char db_path_tmp[50] = {0,};
2266         time_t current_time = 0;
2267         struct tm current_tm;
2268         const char *query_for_creating_table =  "create table alarmmgr_tool \
2269                                         (alarm_id integer primary key,\
2270                                                         duetime_epoch integer,\
2271                                                         duetime text,\
2272                                                         start_epoch integer,\
2273                                                         end_epoch integer,\
2274                                                         pid integer,\
2275                                                         caller_pkgid text,\
2276                                                         callee_pkgid text,\
2277                                                         app_unique_name text,\
2278                                                         app_service_name text,\
2279                                                         dst_service_name text,\
2280                                                         day_of_week integer,\
2281                                                         repeat integer,\
2282                                                         alarm_type integer)";
2283         const char *query_for_deleting_table = "drop table alarmmgr_tool";
2284         int return_code = ALARMMGR_RESULT_SUCCESS;
2285         GSList *gs_iter = NULL;
2286         __alarm_info_t *entry = NULL;
2287         char *error_message = NULL;
2288
2289         return_code = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "r", true, pid);
2290         if (return_code != ALARMMGR_RESULT_SUCCESS) {
2291                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", db_path, return_code));
2292                 return true;
2293         }
2294
2295         // Open a DB
2296         time(&current_time);
2297         localtime_r(&current_time, &current_tm);
2298         sprintf(db_path_tmp, "/tmp/alarmmgr_%d%d%d_%02d%02d%02d.db",
2299                 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);
2300         db_path = strdup(db_path_tmp);
2301
2302         if (db_util_open(db_path, &alarmmgr_tool_db, DB_UTIL_REGISTER_HOOK_METHOD) != SQLITE_OK) {
2303                 ALARM_MGR_EXCEPTION_PRINT("Opening [%s] failed", db_path);
2304                 return_code = ERR_ALARM_SYSTEM_FAIL;
2305                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", db_path, return_code));
2306                 free(db_path);
2307                 return true;
2308         }
2309
2310         // Drop a table
2311         if (sqlite3_exec(alarmmgr_tool_db, query_for_deleting_table, NULL, NULL, &error_message) != SQLITE_OK) {
2312                 ALARM_MGR_EXCEPTION_PRINT("Deleting the table is failed. error message = %s", error_message);
2313         }
2314
2315         // Create a table if it does not exist
2316         if (sqlite3_exec(alarmmgr_tool_db, query_for_creating_table, NULL, NULL, &error_message) != SQLITE_OK) {
2317                 ALARM_MGR_EXCEPTION_PRINT("Creating the table is failed. error message = %s", error_message);
2318                 sqlite3_close(alarmmgr_tool_db);
2319                 return_code = ERR_ALARM_SYSTEM_FAIL;
2320                 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", db_path, return_code));
2321                 free(db_path);
2322                 return true;
2323         }
2324
2325         // Get information of all alarms and save those into the DB.
2326         int index = 0;
2327         for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
2328                 entry = gs_iter->data;
2329                 ++index;
2330                 SECURE_LOGD("#%d alarm id[%d] app_name[%s] duetime[%d]",
2331                         index, entry->alarm_id, g_quark_to_string(entry->quark_app_unique_name), entry->start);
2332
2333                 alarm_info_t *alarm_info = (alarm_info_t *) &(entry->alarm_info);
2334                 alarm_mode_t *mode = &alarm_info->mode;
2335
2336                 char *query = sqlite3_mprintf("insert into alarmmgr_tool( alarm_id, duetime_epoch, duetime, start_epoch,\
2337                                 end_epoch, pid, caller_pkgid, callee_pkgid, app_unique_name, app_service_name, dst_service_name, day_of_week, repeat, alarm_type)\
2338                                 values (%d,%d,%Q,%d,%d,%d,%Q,%Q,%Q,%Q,%Q,%d,%d,%d)",
2339                                 entry->alarm_id,
2340                                 (int)entry->due_time,
2341                                 ctime(&(entry->due_time)),
2342                                 (int)entry->start,
2343                                 (int)entry->end,
2344                                 (int)entry->pid,
2345                                 (char *)g_quark_to_string(entry->quark_caller_pkgid),
2346                                 (char *)g_quark_to_string(entry->quark_callee_pkgid),
2347                                 (char *)g_quark_to_string(entry->quark_app_unique_name),
2348                                 (char *)g_quark_to_string(entry->quark_app_service_name),
2349                                 (char *)g_quark_to_string(entry->quark_dst_service_name),
2350                                 mode->u_interval.day_of_week,
2351                                 mode->repeat,
2352                                 entry->alarm_info.alarm_type);
2353
2354                 if (sqlite3_exec(alarmmgr_tool_db, query, NULL, NULL, &error_message) != SQLITE_OK) {
2355                         SECURE_LOGE("sqlite3_exec() is failed. error message = %s", error_message);
2356                 }
2357
2358                 sqlite3_free(query);
2359         }
2360
2361         sqlite3_close(alarmmgr_tool_db);
2362
2363         return_code = ALARMMGR_RESULT_SUCCESS;
2364         g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", db_path, return_code));
2365         free(db_path);
2366         return true;
2367 }
2368
2369 static void __timer_glib_finalize(GSource *src)
2370 {
2371         GSList *fd_list;
2372         GPollFD *tmp;
2373
2374         fd_list = src->poll_fds;
2375         do {
2376                 tmp = (GPollFD *) fd_list->data;
2377                 g_free(tmp);
2378
2379                 fd_list = fd_list->next;
2380         } while (fd_list);
2381
2382         return;
2383 }
2384
2385 static gboolean __timer_glib_check(GSource *src)
2386 {
2387         GSList *fd_list;
2388         GPollFD *tmp;
2389
2390         fd_list = src->poll_fds;
2391         do {
2392                 tmp = (GPollFD *) fd_list->data;
2393                 if (tmp->revents & (POLLIN | POLLPRI)) {
2394                         return TRUE;
2395                 }
2396                 fd_list = fd_list->next;
2397         } while (fd_list);
2398
2399         return FALSE;
2400 }
2401
2402 static gboolean __timer_glib_dispatch(GSource *src, GSourceFunc callback,
2403                                   gpointer data)
2404 {
2405         callback(data);
2406         return TRUE;
2407 }
2408
2409 static gboolean __timer_glib_prepare(GSource *src, gint *timeout)
2410 {
2411         return FALSE;
2412 }
2413
2414 GSourceFuncs funcs = {
2415         .prepare = __timer_glib_prepare,
2416         .check = __timer_glib_check,
2417         .dispatch = __timer_glib_dispatch,
2418         .finalize = __timer_glib_finalize
2419 };
2420
2421 static void __initialize_timer()
2422 {
2423         int fd;
2424         GSource *src;
2425         GPollFD *gpollfd;
2426         int ret;
2427
2428         fd = timerfd_create(CLOCK_REALTIME, 0);
2429         if (fd == -1) {
2430                 ALARM_MGR_EXCEPTION_PRINT("timerfd_create() is failed.\n");
2431                 exit(1);
2432         }
2433         src = g_source_new(&funcs, sizeof(GSource));
2434
2435         gpollfd = (GPollFD *) g_malloc(sizeof(GPollFD));
2436         gpollfd->events = POLLIN;
2437         gpollfd->fd = fd;
2438
2439         g_source_add_poll(src, gpollfd);
2440         g_source_set_callback(src, (GSourceFunc) __alarm_handler_idle,
2441                               (gpointer) gpollfd, NULL);
2442         g_source_set_priority(src, G_PRIORITY_HIGH);
2443
2444         ret = g_source_attach(src, NULL);
2445         if (ret == 0) {
2446                 ALARM_MGR_EXCEPTION_PRINT("g_source_attach() is failed.\n");
2447                 return;
2448         }
2449
2450         g_source_unref(src);
2451
2452         alarm_context.timer = fd;
2453 }
2454
2455 static void __initialize_alarm_list()
2456 {
2457         alarm_context.alarms = NULL;
2458         alarm_context.c_due_time = -1;
2459
2460         _load_alarms_from_registry();
2461
2462         __rtc_set();    /*Set RTC1 Alarm with alarm due time for alarm-manager initialization*/
2463 }
2464
2465 static void __initialize_scheduled_alarm_list()
2466 {
2467         _init_scheduled_alarm_list();
2468 }
2469
2470 static bool __initialize_noti()
2471 {
2472         // system state change noti
2473         if (vconf_notify_key_changed
2474             (VCONFKEY_SETAPPL_TIMEZONE_ID, __on_time_zone_changed, NULL) < 0) {
2475                 ALARM_MGR_LOG_PRINT(
2476                         "Failed to add callback for time zone changing event\n");
2477         }
2478
2479         if (vconf_notify_key_changed
2480             (VCONFKEY_SYSTEM_TIMECHANGE_EXTERNAL, __on_system_time_external_changed, NULL) < 0) {
2481                 ALARM_MGR_LOG_PRINT(
2482                         "Failed to add callback for time external changing event\n");
2483         }
2484
2485         // If the caller or callee app is uninstalled, all registered alarms will be canceled.
2486         int event_type = PMINFO_CLIENT_STATUS_UNINSTALL;
2487         pkgmgrinfo_client* pc = pkgmgrinfo_client_new(PMINFO_LISTENING);
2488         pkgmgrinfo_client_set_status_type(pc, event_type);
2489         pkgmgrinfo_client_listen_status(pc, __on_app_uninstalled, NULL);
2490
2491         return true;
2492 }
2493
2494 void on_bus_name_owner_changed(GDBusConnection  *connection,
2495                                                                                 const gchar             *sender_name,
2496                                                                                 const gchar             *object_path,
2497                                                                                 const gchar             *interface_name,
2498                                                                                 const gchar             *signal_name,
2499                                                                                 GVariant                        *parameters,
2500                                                                                 gpointer                        user_data)
2501 {
2502         // 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.
2503         // In this case, "NameOwnerChange" signal is broadcasted.
2504         if (signal_name && strcmp(signal_name , "NameOwnerChanged") == 0) {
2505                 GSList *entry = NULL;
2506                 __expired_alarm_t *expire_info = NULL;
2507                 char *service_name = NULL;
2508                 g_variant_get(parameters, "(sss)", &service_name, NULL, NULL);
2509
2510                 for (entry = g_expired_alarm_list; entry; entry = entry->next) {
2511                         if (entry->data) {
2512                                 expire_info = (__expired_alarm_t *) entry->data;
2513                                 SECURE_LOGD("expired service(%s), owner changed service(%s)", expire_info->service_name, service_name);
2514
2515                                 if (strcmp(expire_info->service_name, service_name) == 0) {
2516                                         SECURE_LOGE("expired service name(%s) alarm_id (%d)", expire_info->service_name, expire_info->alarm_id);
2517                                         __alarm_send_noti_to_application(expire_info->service_name, expire_info->alarm_id);
2518                                         g_expired_alarm_list = g_slist_remove(g_expired_alarm_list, entry->data);
2519                                         g_free(expire_info);
2520                                 }
2521                         }
2522                 }
2523                 g_free(service_name);
2524         }
2525 }
2526
2527 static void on_bus_acquired(GDBusConnection *connection, const gchar *name, gpointer user_data)
2528 {
2529         ALARM_MGR_EXCEPTION_PRINT("on_bus_acquired");
2530
2531         interface = alarm_manager_skeleton_new();
2532         if (interface == NULL) {
2533                 ALARM_MGR_EXCEPTION_PRINT("Creating a skeleton object is failed.");
2534                 return;
2535         }
2536
2537         g_signal_connect(interface, "handle_alarm_create", G_CALLBACK(alarm_manager_alarm_create), NULL);
2538         g_signal_connect(interface, "handle_alarm_create_appsvc", G_CALLBACK(alarm_manager_alarm_create_appsvc), NULL);
2539         g_signal_connect(interface, "handle_alarm_delete", G_CALLBACK(alarm_manager_alarm_delete), NULL);
2540         g_signal_connect(interface, "handle_alarm_delete_all", G_CALLBACK(alarm_manager_alarm_delete_all), NULL);
2541         g_signal_connect(interface, "handle_alarm_get_appsvc_info", G_CALLBACK(alarm_manager_alarm_get_appsvc_info), NULL);
2542         g_signal_connect(interface, "handle_alarm_get_info", G_CALLBACK(alarm_manager_alarm_get_info), NULL);
2543         g_signal_connect(interface, "handle_alarm_get_list_of_ids", G_CALLBACK(alarm_manager_alarm_get_list_of_ids), NULL);
2544         g_signal_connect(interface, "handle_alarm_get_next_duetime", G_CALLBACK(alarm_manager_alarm_get_next_duetime), NULL);
2545         g_signal_connect(interface, "handle_alarm_get_number_of_ids", G_CALLBACK(alarm_manager_alarm_get_number_of_ids), NULL);
2546         g_signal_connect(interface, "handle_alarm_set_rtc_time", G_CALLBACK(alarm_manager_alarm_set_rtc_time), NULL);
2547         g_signal_connect(interface, "handle_alarm_set_time", G_CALLBACK(alarm_manager_alarm_set_time), NULL);
2548         g_signal_connect(interface, "handle_alarm_update", G_CALLBACK(alarm_manager_alarm_update), NULL);
2549         g_signal_connect(interface, "handle_alarm_get_all_info", G_CALLBACK(alarm_manager_alarm_get_all_info), NULL);
2550
2551         guint subsc_id = g_dbus_connection_signal_subscribe(connection, "org.freedesktop.DBus", "org.freedesktop.DBus",
2552                                                         "NameOwnerChanged", "/org/freedesktop/DBus", NULL, G_DBUS_SIGNAL_FLAGS_NONE,
2553                                                         on_bus_name_owner_changed, NULL, NULL);
2554         if (subsc_id == 0) {
2555                 ALARM_MGR_EXCEPTION_PRINT("Subscribing to signal for invoking callback is failed.");
2556                 g_object_unref(interface);
2557                 interface = NULL;
2558                 return;
2559         }
2560
2561         if (!g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(interface), connection, ALARM_MGR_DBUS_PATH, NULL)) {
2562                 ALARM_MGR_EXCEPTION_PRINT("Exporting the interface is failed.");
2563                 g_object_unref(interface);
2564                 interface = NULL;
2565                 return;
2566         }
2567
2568         alarm_context.connection = connection;
2569         g_dbus_object_manager_server_set_connection(alarmmgr_server, alarm_context.connection);
2570 }
2571
2572 static bool __initialize_dbus()
2573 {
2574         ALARM_MGR_LOG_PRINT("__initialize_dbus Enter");
2575
2576         alarmmgr_server = g_dbus_object_manager_server_new(ALARM_MGR_DBUS_PATH);
2577         if (alarmmgr_server == NULL) {
2578                 ALARM_MGR_EXCEPTION_PRINT("Creating a new server object is failed.");
2579                 return false;
2580         }
2581
2582         guint owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM, ALARM_MGR_DBUS_NAME,
2583                                 G_BUS_NAME_OWNER_FLAGS_NONE, on_bus_acquired, NULL, NULL, NULL, NULL);
2584
2585         if (owner_id == 0) {
2586                 ALARM_MGR_EXCEPTION_PRINT("Acquiring the own name is failed.");
2587                 g_object_unref(alarmmgr_server);
2588                 return false;
2589         }
2590
2591         return true;
2592 }
2593
2594 #define ALARMMGR_DB_FILE "/opt/dbspace/.alarmmgr.db"
2595 sqlite3 *alarmmgr_db;
2596 #define QUERY_CREATE_TABLE_ALARMMGR "create table alarmmgr \
2597                                 (alarm_id integer primary key,\
2598                                                 start integer,\
2599                                                 end integer,\
2600                                                 pid integer,\
2601                                                 caller_pkgid text,\
2602                                                 callee_pkgid text,\
2603                                                 app_unique_name text,\
2604                                                 app_service_name text,\
2605                                                 app_service_name_mod text,\
2606                                                 bundle text, \
2607                                                 year integer,\
2608                                                 month integer,\
2609                                                 day integer,\
2610                                                 hour integer,\
2611                                                 min integer,\
2612                                                 sec integer,\
2613                                                 day_of_week integer,\
2614                                                 repeat integer,\
2615                                                 alarm_type integer,\
2616                                                 reserved_info integer,\
2617                                                 dst_service_name text, \
2618                                                 dst_service_name_mod text \
2619                                                 )"
2620
2621 static bool __initialize_db()
2622 {
2623         char *error_message = NULL;
2624         int ret;
2625
2626         if (access("/opt/dbspace/.alarmmgr.db", F_OK) == 0) {
2627                 ret = db_util_open(ALARMMGR_DB_FILE, &alarmmgr_db, DB_UTIL_REGISTER_HOOK_METHOD);
2628
2629                 if (ret != SQLITE_OK) {
2630                         ALARM_MGR_EXCEPTION_PRINT("====>>>> connect menu_db [%s] failed", ALARMMGR_DB_FILE);
2631                         return false;
2632                 }
2633
2634                 return true;
2635         }
2636
2637         ret = db_util_open(ALARMMGR_DB_FILE, &alarmmgr_db, DB_UTIL_REGISTER_HOOK_METHOD);
2638
2639         if (ret != SQLITE_OK) {
2640                 ALARM_MGR_EXCEPTION_PRINT("====>>>> connect menu_db [%s] failed", ALARMMGR_DB_FILE);
2641                 return false;
2642         }
2643
2644         if (SQLITE_OK != sqlite3_exec(alarmmgr_db, QUERY_CREATE_TABLE_ALARMMGR, NULL, NULL, &error_message)) {
2645                 ALARM_MGR_EXCEPTION_PRINT("Don't execute query = %s, error message = %s", QUERY_CREATE_TABLE_ALARMMGR, error_message);
2646                 return false;
2647         }
2648
2649         return true;
2650 }
2651
2652 static void __initialize()
2653 {
2654         g_type_init();
2655
2656         __initialize_timer();
2657         if (__initialize_dbus() == false) {     /* because dbus's initialize
2658                                         failed, we cannot continue any more. */
2659                 ALARM_MGR_EXCEPTION_PRINT("because __initialize_dbus failed, "
2660                                           "alarm-server cannot be runned.\n");
2661                 exit(1);
2662         }
2663         __initialize_scheduled_alarm_list();
2664         __initialize_db();
2665         __initialize_alarm_list();
2666         __initialize_noti();
2667
2668         __initialize_module_log();      // for module log
2669
2670 }
2671
2672 int main()
2673 {
2674         GMainLoop *mainloop = NULL;
2675
2676         ALARM_MGR_LOG_PRINT("Enter main loop\n");
2677
2678         mainloop = g_main_loop_new(NULL, FALSE);
2679
2680         __initialize();
2681
2682         g_main_loop_run(mainloop);
2683
2684         return 0;
2685 }