server/alarm-manager.c

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