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
  24
  25
  26 #include<stdio.h>
  27 #include<stdlib.h>
  28 #include<time.h>
  29 #include<signal.h>
  30 #include<string.h>
  31 #include<sys/types.h>
  32
  33 #include<dbus/dbus.h>
  34 #include<glib.h>
  35 #include <db-util.h>
  36 #if !GLIB_CHECK_VERSION (2, 31, 0)
  37 #include <glib/gmacros.h>
  38 #else
  39 #endif
  40
  41 #include"alarm.h"
  42 #include"alarm-internal.h"
  43
  44 #define SIG_TIMER 0x32
  45
  46 #define MAX_GCONF_PATH_LEN 256
  47 #define MAX_QUERY_LEN 4096
  48
  49 extern __alarm_server_context_t alarm_context;
  50 extern sqlite3 *alarmmgr_db;
  51
  52 #ifdef __ALARM_BOOT
  53 extern bool enable_power_on_alarm;
  54 #endif
  55
  56 bool _save_alarms(__alarm_info_t *__alarm_info);
  57 bool _update_alarms(__alarm_info_t *__alarm_info);
  58 bool _delete_alarms(alarm_id_t alarm_id);
  59 #ifdef __ALARM_BOOT
  60 bool _update_power_on(bool on_off);
  61 #endif
  62 bool _load_alarms_from_registry(void);
  63
  64 bool _save_alarms(__alarm_info_t *__alarm_info)
  65 {
  66         char *error_message = NULL;
  67         alarm_info_t *alarm_info =
  68             (alarm_info_t *) &(__alarm_info->alarm_info);
  69         alarm_date_t *start = &alarm_info->start;
  70         alarm_mode_t *mode = &alarm_info->mode;
  71
  72         char *query = sqlite3_mprintf("insert into alarmmgr( alarm_id, start,\
  73                         end, pid, app_unique_name, app_service_name, app_service_name_mod, bundle, year,\
  74                         month, day, hour, min, sec, day_of_week, repeat,\
  75                         alarm_type, reserved_info, dst_service_name, dst_service_name_mod)\
  76                         values (%d,%d,%d,%d,%Q,%Q,%Q,%Q,%d,%d,%d,%d,%d,%d,%d,%d,\
  77                         %d,%d,%Q,%Q)",\
  78                         __alarm_info->alarm_id,
  79                         (int)__alarm_info->start,
  80                         (int)__alarm_info->end,
  81                         __alarm_info->pid,
  82                         (char *)g_quark_to_string(
  83                                 __alarm_info->quark_app_unique_name),
  84                         (char *)g_quark_to_string(
  85                                 __alarm_info->quark_app_service_name),
  86                         (char *)g_quark_to_string(
  87                                 __alarm_info->quark_app_service_name_mod),
  88                         (char *)g_quark_to_string(
  89                                 __alarm_info->quark_bundle),
  90                         start->year,
  91                         start->month,
  92                         start->day,
  93                         start->hour,
  94                         start->min,
  95                         start->sec,
  96                         mode->u_interval.day_of_week,
  97                         mode->repeat,
  98                         alarm_info->alarm_type,
  99                         alarm_info->reserved_info,
 100                         (char *)g_quark_to_string(
 101                         __alarm_info->quark_dst_service_name),
 102                         (char *)g_quark_to_string(
 103                         __alarm_info->quark_dst_service_name_mod));
 104
 105         if (SQLITE_OK !=
 106             sqlite3_exec(alarmmgr_db, query, NULL, NULL, &error_message)) {
 107                 SECURE_LOGE(
 108                     "Don't execute query = %s, error message = %s\n", query,
 109                      error_message);
 110                 sqlite3_free(query);
 111                 return false;
 112         }
 113
 114         sqlite3_free(query);
 115         return true;
 116 }
 117
 118 bool _update_alarms(__alarm_info_t *__alarm_info)
 119 {
 120         char *error_message = NULL;
 121         alarm_info_t *alarm_info =
 122             (alarm_info_t *) &(__alarm_info->alarm_info);
 123         alarm_date_t *start = &alarm_info->start;
 124         alarm_mode_t *mode = &alarm_info->mode;
 125
 126         char *query = sqlite3_mprintf("update alarmmgr set start=%d, end=%d,\
 127                         pid=%d, app_unique_name=%Q, app_service_name=%Q, app_service_name_mod=%Q,\
 128                         bundle=%Q, year=%d, month=%d, day=%d, hour=%d, min=%d, sec=%d,\
 129                         day_of_week=%d, repeat=%d, alarm_type=%d,\
 130                         reserved_info=%d, dst_service_name=%Q, dst_service_name_mod=%Q\
 131                         where alarm_id=%d",\
 132                         (int)__alarm_info->start,
 133                         (int)__alarm_info->end,
 134                         __alarm_info->pid,
 135                         (char *)g_quark_to_string(
 136                                 __alarm_info->quark_app_unique_name),
 137                         (char *)g_quark_to_string(
 138                                 __alarm_info->quark_app_service_name),
 139                         (char *)g_quark_to_string(
 140                                 __alarm_info->quark_app_service_name_mod),
 141                         (char *)g_quark_to_string(
 142                                 __alarm_info->quark_bundle),
 143                         start->year,
 144                         start->month,
 145                         start->day,
 146                         start->hour,
 147                         start->min,
 148                         start->sec,
 149                         mode->u_interval.day_of_week,
 150                         mode->repeat,
 151                         alarm_info->alarm_type,
 152                         alarm_info->reserved_info,
 153                         (char *)g_quark_to_string(
 154                                 __alarm_info->quark_dst_service_name),
 155                         (char *)g_quark_to_string(
 156                                 __alarm_info->quark_dst_service_name_mod),
 157                         __alarm_info->alarm_id);
 158
 159         if (SQLITE_OK !=
 160             sqlite3_exec(alarmmgr_db, query, NULL, NULL, &error_message)) {
 161                 SECURE_LOGE(
 162                     "Don't execute query = %s, error message = %s\n", query,
 163                      error_message);
 164                 sqlite3_free(query);
 165                 return false;
 166         }
 167
 168         sqlite3_free(query);
 169         return true;
 170 }
 171
 172 bool _delete_alarms(alarm_id_t alarm_id)
 173 {
 174         char *error_message = NULL;
 175         char *query = sqlite3_mprintf("delete from alarmmgr where alarm_id=%d", alarm_id);
 176
 177         if (SQLITE_OK !=
 178             sqlite3_exec(alarmmgr_db, query, NULL, NULL, &error_message)) {
 179                 SECURE_LOGE(
 180                     "Don't execute query = %s, error message = %s\n", query,
 181                      error_message);
 182                 sqlite3_free(query);
 183                 return false;
 184         }
 185
 186         sqlite3_free(query);
 187         return true;
 188 }
 189
 190 #ifdef __ALARM_BOOT
 191 bool _update_power_on(bool on_off)
 192 {
 193 /*      GConfClient* pGCC;
 194         char key[MAX_GCONF_PATH_LEN];
 195         GError* error = NULL;
 196
 197         g_type_init();
 198         pGCC = gconf_client_get_default();
 199
 200         if(!pGCC)
 201         {
 202                 ALARM_MGR_EXCEPTION_PRINT(" gconf get failed.. \n");
 203                 return false;
 204         }
 205
 206         sprintf(key,"/Services/AlarmMgr/Auto_poweron");
 207
 208
 209         if(!gconf_client_set_bool(pGCC, key, on_off, &error))
 210         {
 211                 ALARM_MGR_EXCEPTION_PRINT("set string has failed...\n");
 212                 return false;
 213         }
 214
 215         gconf_client_suggest_sync(pGCC, NULL);
 216         g_object_unref(pGCC);
 217 */
 218         return false;
 219 }
 220 #endif
 221
 222 bool _load_alarms_from_registry()
 223 {
 224         int i = 0;
 225         char query[MAX_QUERY_LEN] = {0,};
 226         sqlite3_stmt *stmt = NULL;
 227         const char *tail = NULL;
 228         alarm_info_t *alarm_info = NULL;
 229         __alarm_info_t *__alarm_info = NULL;
 230         alarm_date_t *start = NULL;
 231         alarm_mode_t *mode = NULL;
 232         char app_unique_name[MAX_SERVICE_NAME_LEN] = {0,};
 233         char app_service_name[MAX_SERVICE_NAME_LEN] = {0,};
 234         char app_service_name_mod[MAX_SERVICE_NAME_LEN] = {0,};
 235         char dst_service_name[MAX_SERVICE_NAME_LEN] = {0,};
 236         char dst_service_name_mod[MAX_SERVICE_NAME_LEN] = {0,};
 237         char bundle[MAX_BUNDLE_NAME_LEN] = {0,};
 238
 239 #ifdef __ALARM_BOOT
 240         /*sprintf(path, "/Services/AlarmMgr/Auto_poweron"); */
 241
 242         enable_power_on_alarm = 0;
 243         /*gconf_client_get_bool(pGCC, path, NULL); */
 244 #endif
 245
 246         snprintf(query, MAX_QUERY_LEN, "select * from alarmmgr");
 247
 248         if (SQLITE_OK !=
 249             sqlite3_prepare(alarmmgr_db, query, strlen(query), &stmt, &tail)) {
 250                 ALARM_MGR_EXCEPTION_PRINT("sqlite3_prepare error\n");
 251                 return false;
 252         }
 253
 254         for (i = 0; SQLITE_ROW == sqlite3_step(stmt); i++) {
 255                 __alarm_info = malloc(sizeof(__alarm_info_t));
 256
 257                 if (G_UNLIKELY(__alarm_info == NULL)){
 258                         ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Malloc failed\n");
 259                         return false;
 260                 }
 261                 alarm_info = (alarm_info_t *) &(__alarm_info->alarm_info);
 262                 start = &alarm_info->start;
 263                 mode = &alarm_info->mode;
 264
 265                 memset(app_service_name, 0, MAX_SERVICE_NAME_LEN);
 266                 memset(app_service_name_mod, 0, MAX_SERVICE_NAME_LEN);
 267                 memset(dst_service_name, 0, MAX_SERVICE_NAME_LEN);
 268                 memset(dst_service_name_mod, 0, MAX_SERVICE_NAME_LEN);
 269
 270                 __alarm_info->alarm_id = sqlite3_column_int(stmt, 0);
 271                 __alarm_info->start = sqlite3_column_int(stmt, 1);
 272                 __alarm_info->end = sqlite3_column_int(stmt, 2);
 273                 __alarm_info->pid = sqlite3_column_int(stmt, 3);
 274                 strncpy(app_unique_name, (const char *)sqlite3_column_text(stmt, 4),
 275                         MAX_SERVICE_NAME_LEN - 1);
 276                 strncpy(app_service_name, (const char *)sqlite3_column_text(stmt, 5),
 277                         MAX_SERVICE_NAME_LEN - 1);
 278                 strncpy(app_service_name_mod, (const char *)sqlite3_column_text(stmt, 6),
 279                         MAX_SERVICE_NAME_LEN - 1);
 280                 strncpy(bundle, (const char *)sqlite3_column_text(stmt, 7),
 281                         MAX_BUNDLE_NAME_LEN - 1);
 282                 start->year = sqlite3_column_int(stmt, 8);
 283                 start->month = sqlite3_column_int(stmt, 9);
 284                 start->day = sqlite3_column_int(stmt, 10);
 285                 start->hour = sqlite3_column_int(stmt, 11);
 286                 start->min = sqlite3_column_int(stmt, 12);
 287                 start->sec = sqlite3_column_int(stmt, 13);
 288                 mode->u_interval.day_of_week = sqlite3_column_int(stmt, 14);
 289                 mode->repeat = sqlite3_column_int(stmt, 15);
 290                 alarm_info->alarm_type = sqlite3_column_int(stmt, 16);
 291                 alarm_info->reserved_info = sqlite3_column_int(stmt, 17);
 292                 strncpy(dst_service_name, (const char *)sqlite3_column_text(stmt, 18),
 293                         MAX_SERVICE_NAME_LEN - 1);
 294                 strncpy(dst_service_name_mod, (const char *)sqlite3_column_text(stmt, 19),
 295                         MAX_SERVICE_NAME_LEN - 1);
 296
 297                 __alarm_info->quark_app_unique_name =
 298                     g_quark_from_string(app_unique_name);
 299                 __alarm_info->quark_app_service_name =
 300                     g_quark_from_string(app_service_name);
 301                 __alarm_info->quark_app_service_name_mod=
 302                     g_quark_from_string(app_service_name_mod);
 303                 __alarm_info->quark_dst_service_name =
 304                     g_quark_from_string(dst_service_name);
 305                 __alarm_info->quark_dst_service_name_mod=
 306                     g_quark_from_string(dst_service_name_mod);
 307                 __alarm_info->quark_bundle = g_quark_from_string(bundle);
 308
 309                 _alarm_next_duetime(__alarm_info);
 310                 alarm_context.alarms =
 311                     g_slist_append(alarm_context.alarms, __alarm_info);
 312         }
 313
 314         if (SQLITE_OK != sqlite3_finalize(stmt)) {
 315                 ALARM_MGR_EXCEPTION_PRINT("error : sqlite3_finalize\n");
 316                 return false;
 317         }
 318
 319         _alarm_schedule();
 320
 321         return true;
 322 }