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