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 gboolean alarm_manager_alarm_set_rtc_time(void *pObject, int pid,
1656                                 int year, int mon, int day,
1657                                 int hour, int min, int sec, char *e_cookie,
1658                                 int *return_code){
1659         guchar *cookie = NULL;
1660         gsize size;
1661         int retval = 0;
1662         gboolean result = true;
1663         gid_t call_gid;
1664
1665         const char *rtc = power_rtc;
1666         int fd = 0;
1667         struct rtc_time rtc_tm = {0,};
1668         struct rtc_wkalrm rtc_wk;
1669         struct tm *alarm_tm = NULL;
1670         struct tm due_tm = {0,};
1671
1672
1673         if (return_code){
1674                 *return_code = ALARMMGR_RESULT_SUCCESS;
1675         }
1676
1677         cookie = g_base64_decode(e_cookie, &size);
1678         if (NULL == cookie)
1679         {
1680                 if (return_code)
1681                         *return_code = ERR_ALARM_NO_PERMISSION;
1682                 ALARM_MGR_EXCEPTION_PRINT("Unable to decode cookie!!!\n");
1683                 return true;
1684         }
1685
1686         call_gid = security_server_get_gid("alarm");
1687
1688         ALARM_MGR_LOG_PRINT("call_gid : %d\n", call_gid);
1689
1690         retval = security_server_check_privilege((const char *)cookie, call_gid);
1691         if (retval < 0) {
1692                 if (retval == SECURITY_SERVER_API_ERROR_ACCESS_DENIED) {
1693                         ALARM_MGR_EXCEPTION_PRINT(
1694                                 "%s", "access has been denied\n");
1695                 }
1696                 ALARM_MGR_EXCEPTION_PRINT("Error has occurred in security_server_check_privilege()\n");
1697                 if (return_code)
1698                         *return_code = ERR_ALARM_NO_PERMISSION;
1699         }
1700         else {
1701
1702                 /*extract day of the week, day in the year &
1703                 daylight saving time from system*/
1704                 time_t ctime;
1705                 ctime = time(NULL);
1706                 alarm_tm = localtime(&ctime);
1707
1708                 alarm_tm->tm_year = year;
1709                 alarm_tm->tm_mon = mon;
1710                 alarm_tm->tm_mday = day;
1711                 alarm_tm->tm_hour = hour;
1712                 alarm_tm->tm_min = min;
1713                 alarm_tm->tm_sec = sec;
1714
1715                 /*convert to calendar time representation*/
1716                 time_t rtc_time = mktime(alarm_tm);
1717
1718                 /*convert to Coordinated Universal Time (UTC)*/
1719                 gmtime_r(&rtc_time, &due_tm);
1720
1721                 fd = open(rtc, O_RDONLY);
1722                 if (fd == -1) {
1723                         ALARM_MGR_EXCEPTION_PRINT("RTC open failed.\n");
1724                         if (return_code)
1725                                 *return_code = ERR_ALARM_SYSTEM_FAIL;
1726                         return result;
1727                 }
1728
1729                 /* Read the RTC time/date */
1730                 retval = ioctl(fd, RTC_RD_TIME, &rtc_tm);
1731                 if (retval == -1) {
1732                         ALARM_MGR_EXCEPTION_PRINT("RTC_RD_TIME ioctl failed");
1733                         close(fd);
1734                         if (return_code)
1735                                 *return_code = ERR_ALARM_SYSTEM_FAIL;
1736                         return result;
1737                 }
1738
1739                 rtc_tm.tm_mday = due_tm.tm_mday;
1740                 rtc_tm.tm_mon = due_tm.tm_mon;
1741                 rtc_tm.tm_year = due_tm.tm_year;
1742                 rtc_tm.tm_hour = due_tm.tm_hour;
1743                 rtc_tm.tm_min = due_tm.tm_min;
1744                 rtc_tm.tm_sec = due_tm.tm_sec;
1745
1746                 memcpy(&rtc_wk.time, &rtc_tm, sizeof(rtc_tm));
1747
1748                 rtc_wk.enabled = 1;
1749                 rtc_wk.pending = 0;
1750
1751                 retval = ioctl(fd, RTC_WKALM_BOOT_SET, &rtc_wk);
1752                 if (retval == -1) {
1753                         if (errno == ENOTTY) {
1754                                 ALARM_MGR_EXCEPTION_PRINT("\nAlarm IRQs not"
1755                                                           "supported.\n");
1756                         }
1757                         ALARM_MGR_EXCEPTION_PRINT("RTC_ALM_SET ioctl");
1758                         close(fd);
1759                         if (return_code)
1760                                 *return_code = ERR_ALARM_SYSTEM_FAIL;
1761                 }
1762                 else{
1763                         ALARM_MGR_LOG_PRINT("[alarm-server]RTC alarm is setted");
1764                         /* Enable alarm interrupts */
1765                         retval = ioctl(fd, RTC_AIE_ON, 0);
1766                         if (retval == -1) {
1767                                 ALARM_MGR_EXCEPTION_PRINT("RTC_AIE_ON ioctl failed");
1768                                 if (return_code)
1769                                         *return_code = ERR_ALARM_SYSTEM_FAIL;
1770                         }
1771                         close(fd);
1772                 }
1773         }
1774
1775         if (cookie){
1776                 g_free(cookie);
1777                 cookie = NULL;
1778         }
1779
1780         return result;
1781
1782 }
1783
1784 gboolean alarm_manager_alarm_create_appsvc(void *pObject, int pid,
1785                                     int start_year,
1786                                     int start_month, int start_day,
1787                                     int start_hour, int start_min,
1788                                     int start_sec, int end_year, int end_month,
1789                                     int end_day, int mode_day_of_week,
1790                                     int mode_repeat, int alarm_type,
1791                                     int reserved_info,
1792                                     char *bundle_data, char *e_cookie,
1793                                     int *alarm_id, int *return_code)
1794 {
1795         alarm_info_t alarm_info;
1796         guchar *cookie = NULL;
1797         gsize size;
1798         int retval = 0;
1799         gid_t call_gid;
1800         gboolean result = true;
1801
1802         alarm_info.start.year = start_year;
1803         alarm_info.start.month = start_month;
1804         alarm_info.start.day = start_day;
1805         alarm_info.start.hour = start_hour;
1806         alarm_info.start.min = start_min;
1807         alarm_info.start.sec = start_sec;
1808
1809         alarm_info.end.year = end_year;
1810         alarm_info.end.month = end_month;
1811         alarm_info.end.day = end_day;
1812
1813         alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
1814         alarm_info.mode.repeat = mode_repeat;
1815
1816         alarm_info.alarm_type = alarm_type;
1817         alarm_info.reserved_info = reserved_info;
1818
1819         *return_code = 0;
1820
1821         cookie = g_base64_decode(e_cookie, &size);
1822         if (NULL == cookie)
1823         {
1824                 *return_code = -1;
1825                 ALARM_MGR_EXCEPTION_PRINT("Unable to decode cookie!!!\n");
1826                 return false;
1827         }
1828
1829         call_gid = security_server_get_gid("alarm");
1830
1831         ALARM_MGR_LOG_PRINT("call_gid : %d\n", call_gid);
1832
1833         retval = security_server_check_privilege((const char *)cookie, call_gid);
1834         if (retval < 0) {
1835                 if (retval == SECURITY_SERVER_API_ERROR_ACCESS_DENIED) {
1836                         ALARM_MGR_EXCEPTION_PRINT(
1837                                 "%s", "access has been denied\n");
1838                 }
1839                 ALARM_MGR_EXCEPTION_PRINT("Error has occurred in security_server_check_privilege()\n");
1840                 *return_code = -1;
1841                 result = false;
1842         }
1843         else {
1844                 result = __alarm_create_appsvc(&alarm_info, alarm_id, pid,
1845                                bundle_data, return_code);
1846                 if (false == result)
1847                 {
1848                         ALARM_MGR_EXCEPTION_PRINT("Unable to create alarm!\n");
1849                 }
1850         }
1851
1852         if (cookie){
1853                 g_free(cookie);
1854                 cookie = NULL;
1855         }
1856
1857         return result;
1858 }
1859
1860 gboolean alarm_manager_alarm_create(void *pObject, int pid,
1861                                     char *app_service_name, char *app_service_name_mod,  int start_year,
1862                                     int start_month, int start_day,
1863                                     int start_hour, int start_min,
1864                                     int start_sec, int end_year, int end_month,
1865                                     int end_day, int mode_day_of_week,
1866                                     int mode_repeat, int alarm_type,
1867                                     int reserved_info,
1868                                     char *reserved_service_name, char *reserved_service_name_mod, char *e_cookie,
1869                                     int *alarm_id, int *return_code)
1870 {
1871         alarm_info_t alarm_info;
1872         guchar *cookie;
1873         gsize size;
1874         int retval;
1875         gid_t call_gid;
1876
1877         alarm_info.start.year = start_year;
1878         alarm_info.start.month = start_month;
1879         alarm_info.start.day = start_day;
1880         alarm_info.start.hour = start_hour;
1881         alarm_info.start.min = start_min;
1882         alarm_info.start.sec = start_sec;
1883
1884         alarm_info.end.year = end_year;
1885         alarm_info.end.month = end_month;
1886         alarm_info.end.day = end_day;
1887
1888         alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
1889         alarm_info.mode.repeat = mode_repeat;
1890
1891         alarm_info.alarm_type = alarm_type;
1892         alarm_info.reserved_info = reserved_info;
1893
1894         *return_code = 0;
1895
1896         cookie = g_base64_decode(e_cookie, &size);
1897         call_gid = security_server_get_gid("alarm");
1898
1899         ALARM_MGR_LOG_PRINT("call_gid : %d\n", call_gid);
1900
1901         retval = security_server_check_privilege((const char *)cookie, call_gid);
1902         if (retval < 0) {
1903                 if (retval == SECURITY_SERVER_API_ERROR_ACCESS_DENIED) {
1904                         ALARM_MGR_EXCEPTION_PRINT(
1905                                 "%s", "access has been denied\n");
1906                 }
1907                 ALARM_MGR_EXCEPTION_PRINT("%s", "Error has occurred\n");
1908
1909                 *return_code = -1;
1910         }
1911
1912         else {
1913                 /* return valule and return_code should be checked */
1914                 __alarm_create(&alarm_info, alarm_id, pid, app_service_name,app_service_name_mod,
1915                                reserved_service_name, reserved_service_name_mod, return_code);
1916         }
1917
1918         g_free(cookie);
1919
1920         return true;
1921 }
1922
1923 gboolean alarm_manager_alarm_delete(void *pObject, int pid, alarm_id_t alarm_id,
1924                                     char *e_cookie, int *return_code)
1925 {
1926         guchar *cookie;
1927         gsize size;
1928         int retval;
1929         gid_t call_gid;
1930
1931         cookie = g_base64_decode(e_cookie, &size);
1932         call_gid = security_server_get_gid("alarm");
1933
1934         ALARM_MGR_LOG_PRINT("call_gid : %d\n", call_gid);
1935
1936         retval = security_server_check_privilege((const char *)cookie, call_gid);
1937         if (retval < 0) {
1938                 if (retval == SECURITY_SERVER_API_ERROR_ACCESS_DENIED) {
1939                         ALARM_MGR_EXCEPTION_PRINT("%s",
1940                                                   "access has been denied\n");
1941                 }
1942                 ALARM_MGR_EXCEPTION_PRINT("%s", "Error has occurred\n");
1943
1944                 *return_code = -1;
1945         }
1946
1947         else {
1948                 __alarm_delete(pid, alarm_id, return_code);
1949         }
1950
1951         g_free(cookie);
1952
1953         return true;
1954 }
1955
1956 gboolean alarm_manager_alarm_power_on(void *pObject, int pid, bool on_off,
1957                                       int *return_code)
1958 {
1959
1960         return __alarm_power_on(pid, on_off, return_code);
1961 }
1962
1963 gboolean alarm_manager_alarm_power_off(void *pObject, int pid, int *return_code)
1964 {
1965
1966         return __alarm_power_off(pid, return_code);
1967 }
1968
1969 bool alarm_manager_alarm_check_next_duetime(void *pObject, int pid,
1970                                             int *return_code)
1971 {
1972         return __alarm_check_next_duetime(pid, return_code);
1973 }
1974
1975 gboolean alarm_manager_alarm_update(void *pObject, int pid,
1976                                     char *app_service_name, alarm_id_t alarm_id,
1977                                     int start_year, int start_month,
1978                                     int start_day, int start_hour,
1979                                     int start_min, int start_sec, int end_year,
1980                                     int end_month, int end_day,
1981                                     int mode_day_of_week, int mode_repeat,
1982                                     int alarm_type, int reserved_info,
1983                                     int *return_code)
1984 {
1985         alarm_info_t alarm_info;
1986         alarm_info.start.year = start_year;
1987         alarm_info.start.month = start_month;
1988         alarm_info.start.day = start_day;
1989         alarm_info.start.hour = start_hour;
1990         alarm_info.start.min = start_min;
1991         alarm_info.start.sec = start_sec;
1992
1993         alarm_info.end.year = end_year;
1994         alarm_info.end.month = end_month;
1995         alarm_info.end.day = end_day;
1996
1997         alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
1998         alarm_info.mode.repeat = mode_repeat;
1999
2000         alarm_info.alarm_type = alarm_type;
2001         alarm_info.reserved_info = reserved_info;
2002
2003         *return_code = 0;
2004
2005         __alarm_update(pid, app_service_name, alarm_id, &alarm_info,
2006                        return_code);
2007
2008         return true;
2009 }
2010
2011 gboolean alarm_manager_alarm_get_number_of_ids(void *pObject, int pid,
2012                                                int *num_of_ids,
2013                                                int *return_code)
2014 {
2015         GSList *gs_iter = NULL;
2016         GQuark quark_app_unique_name;   /* the fullpath of pid(pid) is
2017                                            converted  to quark value. */
2018         char proc_file[256] = { 0 };
2019         char process_name[512] = { 0 };
2020         char app_name[256] = { 0 };
2021         char *word = NULL;
2022         __alarm_info_t *entry = NULL;
2023         char *proc_name_ptr = NULL;
2024
2025         *num_of_ids = 0;
2026         *return_code = 0;
2027
2028         /* we should consider to check whether  pid is running or Not
2029          */
2030         memset(process_name, '\0', 512);
2031         memset(proc_file, '\0', 256);
2032         snprintf(proc_file, 256, "/proc/%d/cmdline", pid);
2033
2034         int fd;
2035         int ret;
2036         int i = 0;
2037         fd = open(proc_file, O_RDONLY);
2038         if (fd < 0) {           /* failure */
2039                 quark_app_unique_name = g_quark_from_string("unknown");
2040                 memcpy(app_name, "unknown", strlen("unknown") + 1);
2041
2042                 ALARM_MGR_EXCEPTION_PRINT("Caution!! app_pid(%d) seems to be "
2043                                           "killed, so we failed to get proc file(%s) \n",
2044                                           pid, proc_file);
2045                 *return_code = -1;      /* -1 means that system
2046                                            failed internally. */
2047                 return true;
2048         } else {
2049                 ret = read(fd, process_name, 512);
2050                 close(fd);
2051                 while (process_name[i] != '\0') {
2052                         if (process_name[i] == ' ') {
2053                                 process_name[i] = '\0';
2054                                 break;
2055                         }
2056                         i++;
2057                 }
2058                 /*if (readlink(proc_file, process_name, 256)!=-1) */
2059                 /*success */
2060
2061                 word = strtok_r(process_name, "/", &proc_name_ptr);
2062                 while (word != NULL) {
2063                         memset(app_name, 0, 256);
2064                         snprintf(app_name, 256, "%s", word);
2065                         word = strtok_r(NULL, "/", &proc_name_ptr);
2066                 }
2067                 quark_app_unique_name = g_quark_from_string(app_name);
2068         }
2069
2070         ALARM_MGR_LOG_PRINT("called for  app(pid:%d, name=%s)\n",
2071                             pid, app_name);
2072
2073         for (gs_iter = alarm_context.alarms; gs_iter != NULL;
2074              gs_iter = g_slist_next(gs_iter)) {
2075                 entry = gs_iter->data;
2076                 ALARM_MGR_LOG_PRINT("alarm_manager_alarm_get_number_of_ids(): "
2077                                     "app_name=%s,quark_app_unique_name=%s\n",
2078                 app_name, g_quark_to_string(entry->quark_app_unique_name));
2079                 if (strcmp
2080                     (app_name,
2081                      g_quark_to_string(entry->quark_app_unique_name)) == 0
2082                     && strcmp(app_name, "unknown") != 0) {
2083                         (*num_of_ids)++;
2084                         ALARM_MGR_LOG_PRINT("inc number of alarms of app "
2085                                             "(pid:%d, name:%s) is %d\n",
2086                                             pid, app_name, *num_of_ids);
2087                 }
2088         }
2089         *return_code = 0;
2090         ALARM_MGR_LOG_PRINT("number of alarms of app(pid:%d, name:%s) is %d\n",
2091                             pid, app_name, *num_of_ids);
2092         return true;
2093 }
2094
2095 gboolean alarm_manager_alarm_get_list_of_ids(void *pObject, int pid,
2096                                              int max_number_of_ids,
2097                                              GArray **arr, int *num_of_ids,
2098                                              int *return_code)
2099 {
2100         GSList *gs_iter = NULL;
2101         GQuark quark_app_unique_name;   /* the fullpath of pid(pid) is converted
2102                                            to quark value. */
2103         char proc_file[256] = { 0 };
2104         char process_name[512] = { 0 };
2105         char app_name[256] = { 0 };
2106         char *word = NULL;
2107         __alarm_info_t *entry = NULL;
2108         int index = 0;
2109         char *proc_name_ptr = NULL;
2110         int fd;
2111         int ret;
2112         int i = 0;
2113         GArray *garray = NULL;
2114
2115         *return_code = 0;
2116
2117         garray = g_array_new(false, true, sizeof(alarm_id_t));
2118
2119         /* we should check that there is a resource leak.
2120          * Now we don't have free code for g_array_new().
2121          */
2122         if (max_number_of_ids <= 0) {
2123                 *arr = garray;
2124                 ALARM_MGR_EXCEPTION_PRINT("called for  pid(%d), but "
2125                                           "max_number_of_ids(%d) is less than 0.\n",
2126                                           pid, max_number_of_ids);
2127                 return true;
2128         }
2129
2130         /* we should consider to check whether  pid is running or Not
2131          */
2132         memset(process_name, '\0', 512);
2133         memset(proc_file, '\0', 256);
2134         snprintf(proc_file, 256, "/proc/%d/cmdline", pid);
2135
2136         fd = open(proc_file, O_RDONLY);
2137         if (fd < 0) {           /* failure */
2138                 quark_app_unique_name = g_quark_from_string("unknown");
2139                 memcpy(app_name, "unknown", strlen("unknown") + 1);
2140
2141                 ALARM_MGR_EXCEPTION_PRINT("Caution!! app_pid(%d) seems to be "
2142                 "killed, so we failed to get proc file(%s)\n", pid, proc_file);
2143                 *return_code = -1;
2144                 /* -1 means that system failed internally. */
2145                 return true;
2146         } else {
2147                 ret = read(fd, process_name, 512);
2148                 close(fd);
2149                 while (process_name[i] != '\0') {
2150                         if (process_name[i] == ' ') {
2151                                 process_name[i] = '\0';
2152                                 break;
2153                         }
2154                         i++;
2155                 }
2156                 /* if (readlink(proc_file, process_name, 256)!=-1) */
2157                 /*success */
2158
2159                 word = strtok_r(process_name, "/", &proc_name_ptr);
2160                 while (word != NULL) {
2161                         memset(app_name, 0, 256);
2162                         snprintf(app_name, 256, "%s", word);
2163                         word = strtok_r(NULL, "/", &proc_name_ptr);
2164                 }
2165                 quark_app_unique_name = g_quark_from_string(app_name);
2166         }
2167
2168         ALARM_MGR_LOG_PRINT("called for  app(pid:%d, name=%s)\n",
2169                             pid, app_name);
2170
2171         for (gs_iter = alarm_context.alarms; gs_iter != NULL;
2172              gs_iter = g_slist_next(gs_iter)) {
2173                 entry = gs_iter->data;
2174                 if (strcmp
2175                     (app_name,
2176                      g_quark_to_string(entry->quark_app_unique_name)) == 0
2177                     && strcmp(app_name, "unknown") != 0) {
2178                         g_array_append_val(garray, entry->alarm_id);
2179                 }
2180         }
2181
2182         *num_of_ids = index;
2183
2184         *arr = garray;
2185
2186         return true;
2187 }
2188
2189 gboolean alarm_manager_alarm_get_appsvc_info(void *pObject, int pid, alarm_id_t alarm_id,
2190                                 char *e_cookie, gchar **b_data, int *return_code)
2191 {
2192         bool found = false;
2193
2194         GSList *gs_iter = NULL;
2195         __alarm_info_t *entry = NULL;
2196
2197         guchar *cookie = NULL;
2198         gsize size;
2199         int retval = 0;
2200         gid_t call_gid;
2201
2202         ALARM_MGR_LOG_PRINT("called for  pid(%d) and alarm_id(%d)\n", pid,
2203                             alarm_id);
2204
2205         cookie = g_base64_decode(e_cookie, &size);
2206         if (NULL == cookie)
2207         {
2208                 if (return_code)
2209                         *return_code = ERR_ALARM_SYSTEM_FAIL;
2210                 ALARM_MGR_EXCEPTION_PRINT("Unable to decode cookie!!!\n");
2211                 return true;
2212         }
2213         call_gid = security_server_get_gid("alarm");
2214
2215         ALARM_MGR_LOG_PRINT("call_gid : %d\n", call_gid);
2216
2217         retval = security_server_check_privilege((const char *)cookie, call_gid);
2218         if (retval < 0) {
2219                 if (retval == SECURITY_SERVER_API_ERROR_ACCESS_DENIED) {
2220                         ALARM_MGR_EXCEPTION_PRINT(
2221                                 "%s", "access has been denied\n");
2222                 }
2223                 ALARM_MGR_EXCEPTION_PRINT("%s", "Error has occurred\n");
2224
2225                 if (return_code)
2226                         *return_code = ERR_ALARM_NO_PERMISSION;
2227
2228                 if (cookie)
2229                         g_free(cookie);
2230
2231                 return true;
2232         }
2233
2234         if (return_code)
2235                 *return_code = 0;
2236
2237         for (gs_iter = alarm_context.alarms; gs_iter != NULL;
2238              gs_iter = g_slist_next(gs_iter)) {
2239                 entry = gs_iter->data;
2240                 if (entry->alarm_id == alarm_id) {
2241                         found = true;
2242                         *b_data = g_strdup(g_quark_to_string(entry->quark_bundle));
2243                         break;
2244                 }
2245         }
2246
2247         if (found) {
2248                 if ( *b_data && strlen(*b_data) == 4 && strncmp(*b_data,"null",4) == 0){
2249                         ALARM_MGR_EXCEPTION_PRINT("Regular alarm,not svc alarm");
2250                         if (return_code)
2251                                 *return_code = ERR_ALARM_INVALID_TYPE;
2252                 }
2253         } else {
2254                 if (return_code)
2255                         *return_code = ERR_ALARM_INVALID_ID;
2256         }
2257
2258         if (cookie)
2259                 g_free(cookie);
2260
2261         return true;
2262 }
2263
2264 gboolean alarm_manager_alarm_get_info(void *pObject, int pid,
2265                                       alarm_id_t alarm_id, int *start_year,
2266                                       int *start_month, int *start_day,
2267                                       int *start_hour, int *start_min,
2268                                       int *start_sec, int *end_year,
2269                                       int *end_month, int *end_day,
2270                                       int *mode_day_of_week, int *mode_repeat,
2271                                       int *alarm_type, int *reserved_info,
2272                                       int *return_code)
2273 {
2274         ALARM_MGR_LOG_PRINT("called for  pid(%d) and alarm_id(%d)\n", pid,
2275                             alarm_id);
2276
2277         GSList *gs_iter = NULL;
2278         __alarm_info_t *entry = NULL;
2279
2280         alarm_info_t *alarm_info = NULL;
2281         *return_code = 0;
2282
2283         for (gs_iter = alarm_context.alarms; gs_iter != NULL;
2284              gs_iter = g_slist_next(gs_iter)) {
2285                 entry = gs_iter->data;
2286                 if (entry->alarm_id == alarm_id) {
2287                         alarm_info = &(entry->alarm_info);
2288                         break;
2289                 }
2290         }
2291
2292         if (alarm_info == NULL)
2293         {
2294                 ALARM_MGR_EXCEPTION_PRINT("alarm id(%d) was not found\n",
2295                                           alarm_id);
2296                 *return_code = ERR_ALARM_INVALID_ID;
2297         } else {
2298                 ALARM_MGR_LOG_PRINT("alarm was found\n");
2299                 *start_year = alarm_info->start.year;
2300                 *start_month = alarm_info->start.month;
2301                 *start_day = alarm_info->start.day;
2302                 *start_hour = alarm_info->start.hour;
2303                 *start_min = alarm_info->start.min;
2304                 *start_sec = alarm_info->start.sec;
2305
2306                 *end_year = alarm_info->end.year;
2307                 *end_year = alarm_info->end.month;
2308                 *end_year = alarm_info->end.day;
2309
2310                 *mode_day_of_week = alarm_info->mode.u_interval.day_of_week;
2311                 *mode_repeat = alarm_info->mode.repeat;
2312
2313                 *alarm_type = alarm_info->alarm_type;
2314                 *reserved_info = alarm_info->reserved_info;
2315
2316                 *return_code = 0;
2317         }
2318         return true;
2319 }
2320
2321 #include "alarm-skeleton.h"
2322
2323 typedef struct AlarmManagerObject AlarmManagerObject;
2324 typedef struct AlarmManagerObjectClass AlarmManagerObjectClass;
2325 GType Server_Object_get_type(void);
2326 struct AlarmManagerObject {
2327         GObject parent;
2328 };
2329 struct AlarmManagerObjectClass {
2330         GObjectClass parent;
2331 };
2332
2333 #define DBUS_NAME_FLAG_PROHIBIT_REPLACEMENT 0
2334
2335 #define ALARM_MANAGER_TYPE_OBJECT              (Server_Object_get_type())
2336 #define ALARM_MANAGER_OBJECT(object)           (G_TYPE_CHECK_INSTANCE_CAST \
2337 ((object), ALARM_MANAGER_TYPE_OBJECT, AlarmManagerObject))
2338 #define ALARM_MANAGER_OBJECT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST \
2339 ((klass), ALARM_MANAGER_TYPE_OBJECT, AlarmManagerObjectClass))
2340 #define ALARM_MANAGER_IS_OBJECT(object)        (G_TYPE_CHECK_INSTANCE_TYPE \
2341 ((object), ALARM_MANAGER_TYPE_OBJECT))
2342 #define ALARM_MANAGER_IS_OBJECT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE \
2343 ((klass), ALARM_MANAGER_TYPE_OBJECT))
2344 #define ALARM_MANAGER_OBJECT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS \
2345 ((obj), ALARM_MANAGER_TYPE_OBJECT, AlarmManagerObjectClass))
2346 G_DEFINE_TYPE(AlarmManagerObject, Server_Object, G_TYPE_OBJECT)
2347 static void Server_Object_init(AlarmManagerObject * obj)
2348 {
2349         ;
2350 }
2351
2352 static void Server_Object_class_init(AlarmManagerObjectClass *klass)
2353 {
2354         ;
2355 }
2356
2357 static void __initialize_timer()
2358 {
2359         struct sigaction sig_timer;
2360         sigemptyset(&sig_timer.sa_mask);
2361         sig_timer.sa_flags = SA_SIGINFO;
2362         sig_timer.sa_sigaction = (void *)__alarm_handler;
2363         sigaction(SIG_TIMER, &sig_timer, NULL);
2364
2365         alarm_context.timer = _alarm_create_timer();
2366
2367 }
2368
2369 static void __initialize_alarm_list()
2370 {
2371
2372         alarm_context.alarms = NULL;
2373         alarm_context.c_due_time = -1;
2374
2375         _load_alarms_from_registry();
2376
2377         __rtc_set();    /*Set RTC1 Alarm with alarm due time for alarm-manager initialization*/
2378
2379         /*alarm boot */
2380 #ifdef __ALARM_BOOT
2381         /*alarm boot */
2382         if (enable_power_on_alarm) {
2383                 /* orginally first arg's value was 21(app_id, WAKEUP_ALARM_APP_ID) in a
2384                  * platform with app-server. because __alarm_power_on(..) fuction don't
2385                  * use first parameter internally, we set this value to 0(zero)
2386                  */
2387                 __alarm_power_on(0, enable_power_on_alarm, NULL);
2388         }
2389 #endif
2390 }
2391
2392 static void __initialize_scheduled_alarm_lsit()
2393 {
2394         _init_scheduled_alarm_list();
2395 }
2396
2397
2398 static void __hibernation_leave_callback()
2399 {
2400
2401         __initialize_scheduled_alarm_lsit();
2402
2403         __alarm_clean_list();
2404
2405         __initialize_alarm_list();
2406 }
2407
2408 static bool __initialize_noti()
2409 {
2410         int ret = -1;
2411         int fd = heynoti_init();
2412         if (fd < 0) {
2413                 ALARM_MGR_EXCEPTION_PRINT("fail to heynoti_init\n");
2414                 return false;
2415         }
2416         heynoti_subscribe(fd, "HIBERNATION_LEAVE", __hibernation_leave_callback,
2417                           NULL);
2418         ret = heynoti_attach_handler(fd);
2419         if(ret<0) {
2420                 ALARM_MGR_EXCEPTION_PRINT("heynoti_attach_handler fail");
2421         }
2422
2423         if (vconf_notify_key_changed
2424             (VCONFKEY_SYSTEM_TIMECHANGE, __on_system_time_changed, NULL) < 0) {
2425                 ALARM_MGR_LOG_PRINT(
2426                         "Failed to add callback for time changing event\n");
2427         }
2428         /*system state change noti Ã³¸® */
2429
2430         return true;
2431 }
2432
2433
2434 static DBusHandlerResult __alarm_server_filter(DBusConnection *connection,
2435                                                DBusMessage *message,
2436                                                void *user_data)
2437 {
2438
2439         if (dbus_message_is_signal
2440             (message, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) {
2441                 char *service;
2442                 char *old_owner;
2443                 char *new_owner;
2444                 GSList *entry;
2445                 __expired_alarm_t *expire_info;
2446
2447                 dbus_message_get_args(message,
2448                                       NULL,
2449                                       DBUS_TYPE_STRING, &service,
2450                                       DBUS_TYPE_STRING, &old_owner,
2451                                       DBUS_TYPE_STRING, &new_owner,
2452                                       DBUS_TYPE_INVALID);
2453
2454                 for (entry = g_expired_alarm_list; entry; entry = entry->next) {
2455                         if (entry->data) {
2456                                 expire_info = (__expired_alarm_t *) entry->data;
2457
2458                                 if (strcmp(expire_info->service_name, service)
2459                                     == 0) {
2460                                         ALARM_MGR_EXCEPTION_PRINT(
2461                                         "__alarm_server_filter : "
2462                                              "service name(%s) alarm_id (%d)\n",
2463                                              expire_info->service_name,\
2464                                              expire_info->alarm_id);
2465
2466                                         __alarm_send_noti_to_application(
2467                                              expire_info->service_name,
2468                                              expire_info->alarm_id);
2469                                         g_expired_alarm_list =
2470                                             g_slist_remove(g_expired_alarm_list,
2471                                                            entry->data);
2472                                         free(expire_info);
2473                                 }
2474                         }
2475                 }
2476
2477                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2478         }
2479
2480         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2481 }
2482
2483 static bool __initialize_dbus()
2484 {
2485         GError *error = NULL;
2486         GObject *obj = NULL;
2487         DBusGConnection *connection = NULL;
2488         DBusError derror;
2489         int request_name_result = 0;
2490
2491         dbus_g_object_type_install_info(ALARM_MANAGER_TYPE_OBJECT,
2492                                         &dbus_glib_alarm_manager_object_info);
2493
2494         connection = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
2495         if (!connection) {
2496
2497                 ALARM_MGR_EXCEPTION_PRINT("dbus_g_bus_get failed\n");
2498                 return false;
2499         }
2500
2501         dbus_error_init(&derror);
2502
2503         request_name_result =
2504             dbus_bus_request_name(dbus_g_connection_get_connection(connection),
2505                                   "org.tizen.alarm.manager",
2506                                   DBUS_NAME_FLAG_PROHIBIT_REPLACEMENT, &derror);
2507         if (dbus_error_is_set(&derror)) {       /* failure */
2508                 ALARM_MGR_EXCEPTION_PRINT("Failed to dbus_bus_request_name "
2509                 "(org.tizen.alarm.manager): %s\n", derror.message);
2510                 dbus_error_free(&derror);
2511                 return false;
2512         }
2513
2514         if (!(obj = g_object_new(ALARM_MANAGER_TYPE_OBJECT, NULL))) {
2515                 ALARM_MGR_EXCEPTION_PRINT("Could not allocate new object\n");
2516                 return false;
2517         }
2518
2519         dbus_g_connection_register_g_object(connection,
2520                                             "/org/tizen/alarm/manager",
2521                                             G_OBJECT(obj));
2522
2523         /*dbus_bus_add_match (dbus_g_connection_get_connection(connection),
2524            "type='signal',member='NameOwnerChanged'",NULL); */
2525
2526         dbus_bus_add_match(dbus_g_connection_get_connection(connection),
2527                            "type='signal',sender='" DBUS_SERVICE_DBUS
2528                            "',path='" DBUS_PATH_DBUS
2529                            "',interface='" DBUS_INTERFACE_DBUS
2530                            "',member='NameOwnerChanged'", NULL);
2531
2532         if (!dbus_connection_add_filter
2533             (dbus_g_connection_get_connection(connection),
2534              __alarm_server_filter, NULL, NULL)) {
2535                 ALARM_MGR_EXCEPTION_PRINT("add __expire_alarm_filter failed\n");
2536
2537                 return false;
2538         }
2539
2540         alarm_context.bus = connection;
2541         return true;
2542 }
2543
2544 #define ALARMMGR_DB_FILE "/opt/dbspace/.alarmmgr.db"
2545 sqlite3 *alarmmgr_db;
2546 #define QUERY_CREATE_TABLE_ALARMMGR "create table alarmmgr \
2547                                 (alarm_id integer primary key,\
2548                                                 start integer,\
2549                                                 end integer,\
2550                                                 pid integer,\
2551                                                 app_unique_name text,\
2552                                                 app_service_name text,\
2553                                                 app_service_name_mod text,\
2554                                                 bundle text, \
2555                                                 year integer,\
2556                                                 month integer,\
2557                                                 day integer,\
2558                                                 hour integer,\
2559                                                 min integer,\
2560                                                 sec integer,\
2561                                                 day_of_week integer,\
2562                                                 repeat integer,\
2563                                                 alarm_type integer,\
2564                                                 reserved_info integer,\
2565                                                 dst_service_name text, \
2566                                                 dst_service_name_mod text \
2567                                                 )"
2568
2569 static bool __initialize_db()
2570 {
2571         char *error_message = NULL;
2572         int ret;
2573
2574         if (access("/opt/dbspace/.alarmmgr.db", F_OK) == 0) {
2575                 ret =
2576                     db_util_open(ALARMMGR_DB_FILE, &alarmmgr_db,
2577                                  DB_UTIL_REGISTER_HOOK_METHOD);
2578
2579                 if (ret != SQLITE_OK) {
2580                         ALARM_MGR_EXCEPTION_PRINT(
2581                             "====>>>> connect menu_db [%s] failed!\n",
2582                              ALARMMGR_DB_FILE);
2583                         return false;
2584                 }
2585
2586                 return true;
2587         }
2588
2589         ret =
2590             db_util_open(ALARMMGR_DB_FILE, &alarmmgr_db,
2591                          DB_UTIL_REGISTER_HOOK_METHOD);
2592
2593         if (ret != SQLITE_OK) {
2594                 ALARM_MGR_EXCEPTION_PRINT(
2595                     "====>>>> connect menu_db [%s] failed!\n",
2596                      ALARMMGR_DB_FILE);
2597                 return false;
2598         }
2599
2600         if (SQLITE_OK !=
2601             sqlite3_exec(alarmmgr_db, QUERY_CREATE_TABLE_ALARMMGR, NULL, NULL,\
2602                          &error_message)) {
2603                 ALARM_MGR_EXCEPTION_PRINT("Don't execute query = %s, "
2604                 "error message = %s\n", QUERY_CREATE_TABLE_ALARMMGR,
2605                                           error_message);
2606                 return false;
2607         }
2608
2609         return true;
2610 }
2611
2612 static void __initialize()
2613 {
2614
2615         g_type_init();
2616 #ifdef __ALARM_BOOT
2617         FILE *fp;
2618         char temp[2];
2619         int size;
2620
2621         fp = fopen("/proc/alarm_boot", "r");
2622         if (fp == NULL)
2623                 alarm_boot = 0;
2624         else {
2625
2626                 size = fread(&temp, 1, 1, fp);
2627                 if (size != 1)
2628                         alarm_boot = 0;
2629                 else {
2630                         temp[1] = 0;
2631                         alarm_boot = atoi(temp);
2632                 }
2633                 fclose(fp);
2634         }
2635 #endif
2636
2637         int fd;
2638         int fd2;
2639         struct rtc_time rtc_tm;
2640         int retval;
2641
2642         fd = open(power_rtc, O_RDONLY);
2643         if (fd < 0) {
2644                 ALARM_MGR_EXCEPTION_PRINT("cannot open /dev/rtc0\n");
2645                 return;
2646         }
2647         retval = ioctl(fd, RTC_RD_TIME, &rtc_tm);
2648         close(fd);
2649
2650         fd2 = open(default_rtc, O_RDWR);
2651         if (fd2 < 0) {
2652                 ALARM_MGR_EXCEPTION_PRINT("cannot open /dev/rtc1\n");
2653                 return;
2654         }
2655         retval = ioctl(fd2, RTC_SET_TIME, &rtc_tm);
2656         close(fd2);
2657
2658         __initialize_timer();
2659         if (__initialize_dbus() == false) {     /* because dbus's initialize
2660                                         failed, we cannot continue any more. */
2661                 ALARM_MGR_EXCEPTION_PRINT("because __initialize_dbus failed, "
2662                                           "alarm-server cannot be runned.\n");
2663                 exit(1);
2664         }
2665         __initialize_scheduled_alarm_lsit();
2666         __initialize_db();
2667         __initialize_alarm_list();
2668         __initialize_noti();
2669
2670 }
2671
2672 #ifdef __ALARM_BOOT
2673 static bool __check_false_alarm()
2674 {
2675         time_t current_time;
2676         time_t interval;
2677
2678         time(&current_time);
2679
2680         interval = ab_due_time - current_time;
2681
2682         ALARM_MGR_LOG_PRINT("due_time : %d / current_time %d\n", \
2683                             alarm_context.c_due_time, current_time);
2684
2685         if (interval > 0 && interval <= 30) {
2686                 return true;
2687         } else if (!poweron_alarm_expired) {
2688                 /* originally, first arguement's value was 121(app_id) which means
2689                  * alarm_booting ui application.and this application's dbus-service
2690                  * name had a org.tizen.alarmboot.ui in a platform with app-server.
2691                  * so we set "org.tizen.alarmboot.ui.ALARM" instead of 121.
2692                  */
2693                 __alarm_send_noti_to_application(
2694                         WAKEUP_ALARMBOOTING_APP_ID, -1);
2695                 return false;
2696         }
2697
2698         return true;
2699 }
2700 #endif
2701
2702 int main()
2703 {
2704         GMainLoop *mainloop = NULL;
2705
2706         ALARM_MGR_LOG_PRINT("Enter main loop\n");
2707
2708         mainloop = g_main_loop_new(NULL, FALSE);
2709
2710         __initialize();
2711
2712 #ifdef __ALARM_BOOT
2713         if (alarm_boot){
2714                 __check_false_alarm();
2715         }
2716 #endif
2717
2718         g_main_loop_run(mainloop);
2719
2720         return 0;
2721 }