alarm-manager-registry.c

   1 /*
   2  *  alarm-manager
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Venkatesha Sarpangala <sarpangala.v@samsung.com>, Jayoun Lee <airjany@samsung.com>,
   7  * Sewook Park <sewook7.park@samsung.com>, Jaeho Lee <jaeho81.lee@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #include<stdio.h>
  24 #include<stdlib.h>
  25 #include<time.h>
  26 #include<signal.h>
  27 #include<string.h>
  28 #include<sys/types.h>
  29
  30 #include<glib.h>
  31 #include <db-util.h>
  32 #if !GLIB_CHECK_VERSION(2, 31, 0)
  33 #include <glib/gmacros.h>
  34 #endif
  35 #include"alarm.h"
  36 #include"alarm-internal.h"
  37
  38 #define SIG_TIMER 0x32
  39
  40 #define MAX_GCONF_PATH_LEN 256
  41 #define MAX_QUERY_LEN 4096
  42
  43 extern __alarm_server_context_t alarm_context;
  44 extern sqlite3 *alarmmgr_db;
  45
  46 bool _save_alarms(__alarm_info_t *__alarm_info);
  47 bool _update_alarms(__alarm_info_t *__alarm_info);
  48 bool _delete_alarms(alarm_id_t alarm_id);
  49 bool _load_alarms_from_registry(void);
  50
  51 bool _save_alarms(__alarm_info_t *__alarm_info)
  52 {
  53         char *error_message = NULL;
  54         alarm_info_t *alarm_info =
  55             (alarm_info_t *) &(__alarm_info->alarm_info);
  56         alarm_date_t *start = &alarm_info->start;
  57         alarm_mode_t *mode = &alarm_info->mode;
  58
  59         char *query = sqlite3_mprintf("insert into alarmmgr( alarm_id, start,\
  60                         end, uid, pid, global, caller_pkgid, callee_pkgid, app_unique_name, app_service_name, app_service_name_mod, bundle, year,\
  61                         month, day, hour, min, sec, day_of_week, repeat,\
  62                         alarm_type, reserved_info, dst_service_name, dst_service_name_mod)\
  63                         values (%d,%d,%d,%d,%d,%d,%Q,%Q,%Q,%Q,%Q,%Q,%d,%d,%d,%d,%d,%d,%d,%d,\
  64                         %d,%d,%Q,%Q)",\
  65                         __alarm_info->alarm_id,
  66                         (int)__alarm_info->start,
  67                         (int)__alarm_info->end,
  68                         __alarm_info->uid,
  69                         __alarm_info->pid,
  70                         __alarm_info->global,
  71                         (char *)g_quark_to_string(__alarm_info->quark_caller_pkgid),
  72                         (char *)g_quark_to_string(__alarm_info->quark_callee_pkgid),
  73                         (char *)g_quark_to_string(
  74                                 __alarm_info->quark_app_unique_name),
  75                         (char *)g_quark_to_string(
  76                                 __alarm_info->quark_app_service_name),
  77                         (char *)g_quark_to_string(
  78                                 __alarm_info->quark_app_service_name_mod),
  79                         (char *)g_quark_to_string(
  80                                 __alarm_info->quark_bundle),
  81                         start->year,
  82                         start->month,
  83                         start->day,
  84                         start->hour,
  85                         start->min,
  86                         start->sec,
  87                         mode->u_interval.day_of_week,
  88                         mode->repeat,
  89                         alarm_info->alarm_type,
  90                         alarm_info->reserved_info,
  91                         (char *)g_quark_to_string(
  92                         __alarm_info->quark_dst_service_name),
  93                         (char *)g_quark_to_string(
  94                         __alarm_info->quark_dst_service_name_mod));
  95
  96         if (SQLITE_OK != sqlite3_exec(alarmmgr_db, query, NULL, NULL, &error_message)) {
  97                 SECURE_LOGE("sqlite3_exec() is failed. query = %s, error message = %s", query, error_message);
  98                 sqlite3_free(query);
  99                 return false;
 100         }
 101
 102         sqlite3_free(query);
 103         return true;
 104 }
 105
 106 bool _update_alarms(__alarm_info_t *__alarm_info)
 107 {
 108         char *error_message = NULL;
 109         alarm_info_t *alarm_info =
 110             (alarm_info_t *) &(__alarm_info->alarm_info);
 111         alarm_date_t *start = &alarm_info->start;
 112         alarm_mode_t *mode = &alarm_info->mode;
 113
 114         char *query = sqlite3_mprintf("update alarmmgr set start=%d, end=%d,\
 115                         uid=%d, pid=%d, global=%d, caller_pkgid=%Q, callee_pkgid=%Q, app_unique_name=%Q, app_service_name=%Q, app_service_name_mod=%Q,\
 116                         bundle=%Q, year=%d, month=%d, day=%d, hour=%d, min=%d, sec=%d,\
 117                         day_of_week=%d, repeat=%d, alarm_type=%d,\
 118                         reserved_info=%d, dst_service_name=%Q, dst_service_name_mod=%Q\
 119                         where alarm_id=%d",\
 120                         (int)__alarm_info->start,
 121                         (int)__alarm_info->end,
 122                         __alarm_info->uid,
 123                         __alarm_info->pid,
 124                         __alarm_info->global,
 125                         (char *)g_quark_to_string(__alarm_info->quark_caller_pkgid),
 126                         (char *)g_quark_to_string(__alarm_info->quark_callee_pkgid),
 127                         (char *)g_quark_to_string(
 128                                 __alarm_info->quark_app_unique_name),
 129                         (char *)g_quark_to_string(
 130                                 __alarm_info->quark_app_service_name),
 131                         (char *)g_quark_to_string(
 132                                 __alarm_info->quark_app_service_name_mod),
 133                         (char *)g_quark_to_string(
 134                                 __alarm_info->quark_bundle),
 135                         start->year,
 136                         start->month,
 137                         start->day,
 138                         start->hour,
 139                         start->min,
 140                         start->sec,
 141                         mode->u_interval.day_of_week,
 142                         mode->repeat,
 143                         alarm_info->alarm_type,
 144                         alarm_info->reserved_info,
 145                         (char *)g_quark_to_string(
 146                                 __alarm_info->quark_dst_service_name),
 147                         (char *)g_quark_to_string(
 148                                 __alarm_info->quark_dst_service_name_mod),
 149                         __alarm_info->alarm_id);
 150
 151         if (SQLITE_OK != sqlite3_exec(alarmmgr_db, query, NULL, NULL, &error_message)) {
 152                 SECURE_LOGE("sqlite3_exec() is failed. query = %s, error message = %s", query, error_message);
 153                 sqlite3_free(query);
 154                 return false;
 155         }
 156
 157         sqlite3_free(query);
 158         return true;
 159 }
 160
 161 bool _delete_alarms(alarm_id_t alarm_id)
 162 {
 163         char *error_message = NULL;
 164         char *query = sqlite3_mprintf("delete from alarmmgr where alarm_id=%d", alarm_id);
 165
 166         if (SQLITE_OK != sqlite3_exec(alarmmgr_db, query, NULL, NULL, &error_message)) {
 167                 SECURE_LOGE("sqlite3_exec() is failed. query = %s, error message = %s", query, error_message);
 168                 sqlite3_free(query);
 169                 return false;
 170         }
 171
 172         sqlite3_free(query);
 173         return true;
 174 }
 175
 176 bool _load_alarms_from_registry()
 177 {
 178         int i = 0;
 179         int col_idx;
 180         char query[MAX_QUERY_LEN] = {0,};
 181         sqlite3_stmt *stmt = NULL;
 182         const char *tail = NULL;
 183         alarm_info_t *alarm_info = NULL;
 184         __alarm_info_t *__alarm_info = NULL;
 185         alarm_date_t *start = NULL;
 186         alarm_mode_t *mode = NULL;
 187         char caller_pkgid[MAX_PKG_ID_LEN] = {0,};
 188         char callee_pkgid[MAX_PKG_ID_LEN] = {0,};
 189         char app_unique_name[MAX_SERVICE_NAME_LEN] = {0,};
 190         char app_service_name[MAX_SERVICE_NAME_LEN] = {0,};
 191         char app_service_name_mod[MAX_SERVICE_NAME_LEN] = {0,};
 192         char dst_service_name[MAX_SERVICE_NAME_LEN] = {0,};
 193         char dst_service_name_mod[MAX_SERVICE_NAME_LEN] = {0,};
 194         char bundle[MAX_BUNDLE_NAME_LEN] = {0,};
 195
 196         snprintf(query, MAX_QUERY_LEN, "select * from alarmmgr");
 197
 198         if (SQLITE_OK != sqlite3_prepare(alarmmgr_db, query, strlen(query), &stmt, &tail)) {
 199                 ALARM_MGR_EXCEPTION_PRINT("sqlite3_prepare() is failed.");
 200                 return false;
 201         }
 202
 203         for (i = 0; SQLITE_ROW == sqlite3_step(stmt); i++) {
 204                 col_idx = 0;
 205                 __alarm_info = malloc(sizeof(__alarm_info_t));
 206
 207                 if (G_UNLIKELY(__alarm_info == NULL)) {
 208                         ALARM_MGR_EXCEPTION_PRINT("Memory allocation failed.");
 209                         return false;
 210                 }
 211                 alarm_info = (alarm_info_t *) &(__alarm_info->alarm_info);
 212                 start = &alarm_info->start;
 213                 mode = &alarm_info->mode;
 214
 215                 __alarm_info->alarm_id = sqlite3_column_int(stmt, col_idx++);
 216                 __alarm_info->start = sqlite3_column_int(stmt, col_idx++);
 217                 __alarm_info->end = sqlite3_column_int(stmt, col_idx++);
 218                 __alarm_info->uid = sqlite3_column_int(stmt, col_idx++);
 219                 __alarm_info->pid = sqlite3_column_int(stmt, col_idx++);
 220                 __alarm_info->global = sqlite3_column_int(stmt, col_idx++);
 221
 222                 strncpy(caller_pkgid, (const char *)sqlite3_column_text(stmt, col_idx++),
 223                         MAX_PKG_ID_LEN - 1);
 224                 strncpy(callee_pkgid, (const char *)sqlite3_column_text(stmt, col_idx++),
 225                         MAX_PKG_ID_LEN - 1);
 226                 strncpy(app_unique_name, (const char *)sqlite3_column_text(stmt, col_idx++),
 227                         MAX_SERVICE_NAME_LEN - 1);
 228                 strncpy(app_service_name, (const char *)sqlite3_column_text(stmt, col_idx++),
 229                         MAX_SERVICE_NAME_LEN - 1);
 230                 strncpy(app_service_name_mod, (const char *)sqlite3_column_text(stmt, col_idx++),
 231                         MAX_SERVICE_NAME_LEN - 1);
 232                 strncpy(bundle, (const char *)sqlite3_column_text(stmt, col_idx++),
 233                         MAX_BUNDLE_NAME_LEN - 1);
 234                 start->year = sqlite3_column_int(stmt, col_idx++);
 235                 start->month = sqlite3_column_int(stmt, col_idx++);
 236                 start->day = sqlite3_column_int(stmt, col_idx++);
 237                 start->hour = sqlite3_column_int(stmt, col_idx++);
 238                 start->min = sqlite3_column_int(stmt, col_idx++);
 239                 start->sec = sqlite3_column_int(stmt, col_idx++);
 240                 mode->u_interval.day_of_week = sqlite3_column_int(stmt, col_idx++);
 241                 mode->repeat = sqlite3_column_int(stmt, col_idx++);
 242                 alarm_info->alarm_type = sqlite3_column_int(stmt, col_idx++);
 243                 alarm_info->reserved_info = sqlite3_column_int(stmt, col_idx++);
 244                 strncpy(dst_service_name, (const char *)sqlite3_column_text(stmt, col_idx++),
 245                         MAX_SERVICE_NAME_LEN - 1);
 246                 strncpy(dst_service_name_mod, (const char *)sqlite3_column_text(stmt, col_idx++),
 247                         MAX_SERVICE_NAME_LEN - 1);
 248
 249                 __alarm_info->quark_caller_pkgid = g_quark_from_string(caller_pkgid);
 250                 __alarm_info->quark_callee_pkgid = g_quark_from_string(callee_pkgid);
 251                 __alarm_info->quark_app_unique_name =
 252                     g_quark_from_string(app_unique_name);
 253                 __alarm_info->quark_app_service_name =
 254                     g_quark_from_string(app_service_name);
 255                 __alarm_info->quark_app_service_name_mod =
 256                     g_quark_from_string(app_service_name_mod);
 257                 __alarm_info->quark_dst_service_name =
 258                     g_quark_from_string(dst_service_name);
 259                 __alarm_info->quark_dst_service_name_mod =
 260                     g_quark_from_string(dst_service_name_mod);
 261                 __alarm_info->quark_bundle = g_quark_from_string(bundle);
 262
 263                 _alarm_next_duetime(__alarm_info);
 264                 alarm_context.alarms = g_slist_append(alarm_context.alarms, __alarm_info);
 265         }
 266
 267
 268         _alarm_schedule();
 269         if (SQLITE_OK != sqlite3_finalize(stmt)) {
 270                 ALARM_MGR_EXCEPTION_PRINT("sqlite3_finalize() is failed.");
 271                 return false;
 272         }
 273
 274         return true;
 275 }