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