alarm-manager.c

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