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 GSList *alarmmgr_db_list;
  45 bool _save_alarms(__alarm_info_t *__alarm_info);
  46 bool _update_alarms(__alarm_info_t *__alarm_info);
  47 bool _delete_alarms(alarm_id_t alarm_id, const char *zone);
  48 bool _load_alarms_from_registry(void);
  49
  50 static gint _find_zone_alarmmgr_db(void *db_info, void *data)
  51 {
  52         _zone_alarm_db_list_t *db_struct = (_zone_alarm_db_list_t *)db_info;
  53         return strcmp(db_struct->zone, (char *)data);
  54 }
  55
  56 static sqlite3 *_find_db(const char *zone)
  57 {
  58         sqlite3 *alarmmgr_db = NULL;
  59         GSList *iter = g_slist_find_custom(alarmmgr_db_list, zone, (GCompareFunc)_find_zone_alarmmgr_db);
  60         if (iter == NULL) {
  61                 SECURE_LOGE("failed to find db for zone[%s]", zone);
  62                 return NULL;
  63         }
  64         alarmmgr_db = ((_zone_alarm_db_list_t *)iter->data)->alarmmgr_db;
  65
  66         return alarmmgr_db;
  67 }
  68
  69 bool _save_alarms(__alarm_info_t *__alarm_info)
  70 {
  71         char *error_message = NULL;
  72         alarm_info_t *alarm_info =
  73             (alarm_info_t *) &(__alarm_info->alarm_info);
  74         alarm_date_t *start = &alarm_info->start;
  75         alarm_mode_t *mode = &alarm_info->mode;
  76
  77         SECURE_LOGE("__zone %s", g_quark_to_string(__alarm_info->zone));
  78         sqlite3 *alarmmgr_db = _find_db((const char *)g_quark_to_string(__alarm_info->zone));
  79         if (alarmmgr_db == NULL) {
  80                 SECURE_LOGE("failed to retrieve db");
  81                 return false;
  82         }
  83
  84         char *query = sqlite3_mprintf("insert into alarmmgr( alarm_id, start,\
  85                         end, pid, caller_pkgid, callee_pkgid, app_unique_name, app_service_name, app_service_name_mod, bundle, year,\
  86                         month, day, hour, min, sec, day_of_week, repeat,\
  87                         alarm_type, reserved_info, dst_service_name, dst_service_name_mod)\
  88                         values (%d,%d,%d,%d,%Q,%Q,%Q,%Q,%Q,%Q,%d,%d,%d,%d,%d,%d,%d,%d,\
  89                         %d,%d,%Q,%Q)",\
  90                         __alarm_info->alarm_id,
  91                         (int)__alarm_info->start,
  92                         (int)__alarm_info->end,
  93                         __alarm_info->pid,
  94                         (char *)g_quark_to_string(__alarm_info->quark_caller_pkgid),
  95                         (char *)g_quark_to_string(__alarm_info->quark_callee_pkgid),
  96                         (char *)g_quark_to_string(
  97                                 __alarm_info->quark_app_unique_name),
  98                         (char *)g_quark_to_string(
  99                                 __alarm_info->quark_app_service_name),
 100                         (char *)g_quark_to_string(
 101                                 __alarm_info->quark_app_service_name_mod),
 102                         (char *)g_quark_to_string(
 103                                 __alarm_info->quark_bundle),
 104                         start->year,
 105                         start->month,
 106                         start->day,
 107                         start->hour,
 108                         start->min,
 109                         start->sec,
 110                         mode->u_interval.day_of_week,
 111                         mode->repeat,
 112                         alarm_info->alarm_type,
 113                         alarm_info->reserved_info,
 114                         (char *)g_quark_to_string(
 115                         __alarm_info->quark_dst_service_name),
 116                         (char *)g_quark_to_string(
 117                         __alarm_info->quark_dst_service_name_mod));
 118
 119         if (SQLITE_OK != sqlite3_exec(alarmmgr_db, query, NULL, NULL, &error_message)) {
 120                 SECURE_LOGE("sqlite3_exec() is failed. query = %s, error message = %s", query, error_message);
 121                 sqlite3_free(query);
 122                 return false;
 123         }
 124
 125         sqlite3_free(query);
 126         return true;
 127 }
 128
 129 bool _update_alarms(__alarm_info_t *__alarm_info)
 130 {
 131         char *error_message = NULL;
 132         alarm_info_t *alarm_info =
 133             (alarm_info_t *) &(__alarm_info->alarm_info);
 134         alarm_date_t *start = &alarm_info->start;
 135         alarm_mode_t *mode = &alarm_info->mode;
 136
 137         sqlite3 *alarmmgr_db = _find_db((const char *)g_quark_to_string(__alarm_info->zone));
 138         if (alarmmgr_db == NULL) {
 139                 SECURE_LOGE("failed to retrieve db");
 140                 return false;
 141         }
 142
 143         char *query = sqlite3_mprintf("update alarmmgr set start=%d, end=%d,\
 144                         pid=%d, caller_pkgid=%Q, callee_pkgid=%Q, app_unique_name=%Q, app_service_name=%Q, app_service_name_mod=%Q,\
 145                         bundle=%Q, year=%d, month=%d, day=%d, hour=%d, min=%d, sec=%d,\
 146                         day_of_week=%d, repeat=%d, alarm_type=%d,\
 147                         reserved_info=%d, dst_service_name=%Q, dst_service_name_mod=%Q\
 148                         where alarm_id=%d",\
 149                         (int)__alarm_info->start,
 150                         (int)__alarm_info->end,
 151                         __alarm_info->pid,
 152                         (char *)g_quark_to_string(__alarm_info->quark_caller_pkgid),
 153                         (char *)g_quark_to_string(__alarm_info->quark_callee_pkgid),
 154                         (char *)g_quark_to_string(
 155                                 __alarm_info->quark_app_unique_name),
 156                         (char *)g_quark_to_string(
 157                                 __alarm_info->quark_app_service_name),
 158                         (char *)g_quark_to_string(
 159                                 __alarm_info->quark_app_service_name_mod),
 160                         (char *)g_quark_to_string(
 161                                 __alarm_info->quark_bundle),
 162                         start->year,
 163                         start->month,
 164                         start->day,
 165                         start->hour,
 166                         start->min,
 167                         start->sec,
 168                         mode->u_interval.day_of_week,
 169                         mode->repeat,
 170                         alarm_info->alarm_type,
 171                         alarm_info->reserved_info,
 172                         (char *)g_quark_to_string(
 173                                 __alarm_info->quark_dst_service_name),
 174                         (char *)g_quark_to_string(
 175                                 __alarm_info->quark_dst_service_name_mod),
 176                         __alarm_info->alarm_id);
 177
 178         if (SQLITE_OK != sqlite3_exec(alarmmgr_db, query, NULL, NULL, &error_message)) {
 179                 SECURE_LOGE("sqlite3_exec() is failed. query = %s, error message = %s", query, error_message);
 180                 sqlite3_free(query);
 181                 return false;
 182         }
 183
 184         sqlite3_free(query);
 185         return true;
 186 }
 187
 188 bool _delete_alarms(alarm_id_t alarm_id, const char *zone)
 189 {
 190         char *error_message = NULL;
 191         char *query = sqlite3_mprintf("delete from alarmmgr where alarm_id=%d", alarm_id);
 192
 193         sqlite3 *alarmmgr_db = _find_db(zone);
 194         if (alarmmgr_db == NULL) {
 195                 SECURE_LOGE("failed to retrieve db");
 196                 return false;
 197         }
 198
 199         if (SQLITE_OK != sqlite3_exec(alarmmgr_db, query, NULL, NULL, &error_message)) {
 200                 SECURE_LOGE("sqlite3_exec() is failed. query = %s, error message = %s", query, error_message);
 201                 sqlite3_free(query);
 202                 return false;
 203         }
 204
 205         sqlite3_free(query);
 206         return true;
 207 }
 208
 209 bool _load_alarms_from_registry()
 210 {
 211         int i = 0;
 212         char query[MAX_QUERY_LEN] = {0,};
 213         sqlite3_stmt *stmt = NULL;
 214         const char *tail = NULL;
 215         alarm_info_t *alarm_info = NULL;
 216         __alarm_info_t *__alarm_info = NULL;
 217         alarm_date_t *start = NULL;
 218         alarm_mode_t *mode = NULL;
 219         char caller_pkgid[MAX_PKG_ID_LEN] = {0,};
 220         char callee_pkgid[MAX_PKG_ID_LEN] = {0,};
 221         char app_unique_name[MAX_SERVICE_NAME_LEN] = {0,};
 222         char app_service_name[MAX_SERVICE_NAME_LEN] = {0,};
 223         char app_service_name_mod[MAX_SERVICE_NAME_LEN] = {0,};
 224         char dst_service_name[MAX_SERVICE_NAME_LEN] = {0,};
 225         char dst_service_name_mod[MAX_SERVICE_NAME_LEN] = {0,};
 226         char bundle[MAX_BUNDLE_NAME_LEN] = {0,};
 227
 228         snprintf(query, MAX_QUERY_LEN, "select * from alarmmgr");
 229
 230         GSList *iter;
 231         sqlite3 *alarmmgr_db = NULL;
 232         char *zone = NULL;
 233         for (iter = alarmmgr_db_list; iter != NULL; iter = g_slist_next(iter)) {
 234                 alarmmgr_db = ((_zone_alarm_db_list_t *)iter->data)->alarmmgr_db;
 235                 zone = ((_zone_alarm_db_list_t *)iter->data)->zone;
 236
 237                 if (SQLITE_OK != sqlite3_prepare(alarmmgr_db, query, strlen(query), &stmt, &tail)) {
 238                         ALARM_MGR_EXCEPTION_PRINT("sqlite3_prepare() is failed.");
 239                         return false;
 240                 }
 241                 for (i = 0; SQLITE_ROW == sqlite3_step(stmt); i++) {
 242                         __alarm_info = malloc(sizeof(__alarm_info_t));
 243
 244                         if (G_UNLIKELY(__alarm_info == NULL)) {
 245                                 ALARM_MGR_EXCEPTION_PRINT("Memory allocation failed.");
 246                                 return false;
 247                         }
 248                         alarm_info = (alarm_info_t *) &(__alarm_info->alarm_info);
 249                         start = &alarm_info->start;
 250                         mode = &alarm_info->mode;
 251
 252                         __alarm_info->alarm_id = sqlite3_column_int(stmt, 0);
 253                         __alarm_info->start = sqlite3_column_int(stmt, 1);
 254                         __alarm_info->end = sqlite3_column_int(stmt, 2);
 255                         __alarm_info->pid = sqlite3_column_int(stmt, 3);
 256
 257                         strncpy(caller_pkgid, (const char *)sqlite3_column_text(stmt, 4),
 258                                         MAX_PKG_ID_LEN - 1);
 259                         strncpy(callee_pkgid, (const char *)sqlite3_column_text(stmt, 5),
 260                                         MAX_PKG_ID_LEN - 1);
 261                         strncpy(app_unique_name, (const char *)sqlite3_column_text(stmt, 6),
 262                                         MAX_SERVICE_NAME_LEN - 1);
 263                         strncpy(app_service_name, (const char *)sqlite3_column_text(stmt, 7),
 264                                         MAX_SERVICE_NAME_LEN - 1);
 265                         strncpy(app_service_name_mod, (const char *)sqlite3_column_text(stmt, 8),
 266                                         MAX_SERVICE_NAME_LEN - 1);
 267                         strncpy(bundle, (const char *)sqlite3_column_text(stmt, 9),
 268                                         MAX_BUNDLE_NAME_LEN - 1);
 269                         start->year = sqlite3_column_int(stmt, 10);
 270                         start->month = sqlite3_column_int(stmt, 11);
 271                         start->day = sqlite3_column_int(stmt, 12);
 272                         start->hour = sqlite3_column_int(stmt, 13);
 273                         start->min = sqlite3_column_int(stmt, 14);
 274                         start->sec = sqlite3_column_int(stmt, 15);
 275                         mode->u_interval.day_of_week = sqlite3_column_int(stmt, 16);
 276                         mode->repeat = sqlite3_column_int(stmt, 17);
 277                         alarm_info->alarm_type = sqlite3_column_int(stmt, 18);
 278                         alarm_info->reserved_info = sqlite3_column_int(stmt, 19);
 279                         strncpy(dst_service_name, (const char *)sqlite3_column_text(stmt, 20),
 280                                         MAX_SERVICE_NAME_LEN - 1);
 281                         strncpy(dst_service_name_mod, (const char *)sqlite3_column_text(stmt, 21),
 282                                         MAX_SERVICE_NAME_LEN - 1);
 283
 284                         __alarm_info->quark_caller_pkgid = g_quark_from_string(caller_pkgid);
 285                         __alarm_info->quark_callee_pkgid = g_quark_from_string(callee_pkgid);
 286                         __alarm_info->quark_app_unique_name =
 287                                 g_quark_from_string(app_unique_name);
 288                         __alarm_info->quark_app_service_name =
 289                                 g_quark_from_string(app_service_name);
 290                         __alarm_info->quark_app_service_name_mod=
 291                                 g_quark_from_string(app_service_name_mod);
 292                         __alarm_info->quark_dst_service_name =
 293                                 g_quark_from_string(dst_service_name);
 294                         __alarm_info->quark_dst_service_name_mod=
 295                                 g_quark_from_string(dst_service_name_mod);
 296                         __alarm_info->quark_bundle = g_quark_from_string(bundle);
 297                         __alarm_info->zone = g_quark_from_string(zone);
 298
 299                         _alarm_next_duetime(__alarm_info);
 300                         alarm_context.alarms = g_slist_append(alarm_context.alarms, __alarm_info);
 301                 }
 302
 303                 if (SQLITE_OK != sqlite3_finalize(stmt)) {
 304                         ALARM_MGR_EXCEPTION_PRINT("sqlite3_finalize() is failed.");
 305                         return false;
 306                 }
 307                 stmt = NULL;
 308         }
 309
 310         _alarm_schedule();
 311         if (SQLITE_OK != sqlite3_finalize(stmt)) {
 312                 ALARM_MGR_EXCEPTION_PRINT("sqlite3_finalize() is failed.");
 313                 return false;
 314         }
 315         stmt = NULL;
 316
 317         return true;
 318 }