src/ps_modem.c

   1 /*
   2  * tel-plugin-packetservice
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: DongHoo Park <donghoo.park@samsung.com>
   7  *          Arun Shukla <arun.shukla@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 "ps_common.h"
  24 #include "generated-code.h"
  25
  26 #include <tzplatform_config.h>
  27 #include <server.h>
  28 #include <plugin.h>
  29 #include <user_request.h>
  30 #include <core_object.h>
  31 #include <co_context.h>
  32 #include <co_ps.h>
  33
  34 #define PROP_DEFAULT    FALSE
  35 #define PROP_DEFAULT_STR   NULL
  36 #define DATABASE_PATH_0 tzplatform_mkpath(TZ_SYS_DB, ".dnet.db")
  37 #define DATABASE_PATH_1 tzplatform_mkpath(TZ_SYS_DB, ".dnet2.db")
  38
  39 struct ps_thread_data {
  40         ps_modem_t *modem;
  41         GThread *selfi;
  42 };
  43
  44 static void __ps_modem_emit_property_changed_signal(ps_modem_t *modem);
  45 static void __ps_modem_emit_service_added_signal(ps_modem_t *modem, gpointer service);
  46 /*static void __ps_modem_emit_service_removed_signal(ps_modem_t *modem, gpointer service);*/
  47 static void _ps_modem_setup_interface(PacketServiceModem *modem, ps_modem_t *modem_data);
  48
  49 static void __ps_modem_create_service(GDBusConnection *conn, TcorePlugin *p,
  50         gpointer modem, CoreObject *co_modem);
  51 static void __ps_modem_remove_service(ps_modem_t *modem, gpointer service);
  52 static void __ps_modem_get_ps_setting_from_storage(ps_modem_t *object);
  53 static void __ps_modem_processing_modem_event(gpointer object);
  54
  55 static gboolean __ps_modem_set_powered(ps_modem_t *modem, int value);
  56 static gboolean __ps_modem_set_sim_complete(ps_modem_t *modem, gboolean value, gchar *operator);
  57
  58 static gboolean __ps_modem_thread_finish_cb(gpointer data)
  59 {
  60         struct ps_thread_data *thread_data = data;
  61         ps_modem_t *modem;
  62         GHashTableIter iter;
  63         gpointer key, value;
  64
  65         if (!thread_data) {
  66                 err("thread_data is NULL !!");
  67                 return FALSE;
  68         }
  69
  70         modem = thread_data->modem;
  71
  72         dbg("Thread %p return is complete", thread_data->selfi);
  73
  74         _ps_get_co_modem_values(thread_data->modem);
  75         _ps_modem_set_reset_profile(thread_data->modem, FALSE);
  76         packet_service_modem_complete_reset_profile(thread_data->modem->if_obj, thread_data->modem->invocation, TRUE);
  77
  78         g_thread_join(thread_data->selfi);
  79         dbg("Clean up of thread %p is complete", thread_data->selfi);
  80         thread_data->modem->invocation = NULL;
  81         _ps_modem_remove_profile_reset_gsource(thread_data->modem);
  82         thread_data->modem = NULL;
  83         thread_data->selfi = NULL;
  84         g_free(thread_data);
  85
  86         /* Try to re-connect default contexts after reset profile is complete */
  87         g_hash_table_iter_init(&iter, modem->services);
  88         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE)
  89                 _ps_service_connect_default_context(value);
  90
  91         return FALSE;
  92 }
  93
  94 static gpointer __ps_modem_regenerate_database(gpointer data)
  95 {
  96         gboolean rv = FALSE;
  97         ps_modem_t *modem = data;
  98         struct ps_thread_data *thread_data = NULL;
  99         gchar *command = NULL;
 100
 101         thread_data = g_try_malloc0(sizeof(*thread_data));
 102         if (!thread_data) {
 103                 err("mamory alloc is fail !!!");
 104                 return NULL;
 105         }
 106         thread_data->modem = modem;
 107         thread_data->selfi = g_thread_self();
 108
 109         _ps_context_reset_profile_table(modem->cp_name);
 110         /* Re-generate global APN database */
 111         if (g_str_has_suffix(modem->cp_name, "1"))
 112                 command = g_strdup_printf("/usr/bin/sqlite3 %s < /usr/share/ps-plugin/dnet_db_init.sql", DATABASE_PATH_1);
 113         else
 114                 command = g_strdup_printf("/usr/bin/sqlite3 %s < /usr/share/ps-plugin/dnet_db_init.sql", DATABASE_PATH_0);
 115         rv = ps_util_system_command(command);
 116         ps_dbg_ex_co(modem->co_modem, "system command sent, rv(%d)", rv);
 117         rv = _ps_context_fill_profile_table_from_ini_file(modem->cp_name);
 118
 119         if (TRUE == ps_util_thread_dispatch(g_main_context_default(), G_PRIORITY_LOW, (GSourceFunc)__ps_modem_thread_finish_cb, thread_data))
 120                 dbg("Thread %p processing is complete", thread_data->selfi);
 121
 122         g_free(command);
 123
 124         return NULL;
 125 }
 126
 127 void __remove_modem_handler(gpointer data)
 128 {
 129         ps_modem_t *modem = data;
 130
 131         ps_dbg_ex_co(_ps_modem_ref_co_modem(modem), "Entered");
 132         if (!modem) {
 133                 dbg("Modem is NULL");
 134                 return;
 135         }
 136
 137         __ps_modem_cp_reset_send_pending_request_response(modem);
 138
 139         /*Need to remove the compelete hash table*/
 140         g_hash_table_remove_all(modem->services);
 141
 142         /*Need to UNexport and Unref the master Object */
 143         g_dbus_interface_skeleton_unexport(G_DBUS_INTERFACE_SKELETON(modem->if_obj));
 144
 145         g_object_unref(modem->if_obj);
 146
 147         /*Need to free memory allocated for the internal structure*/
 148         g_queue_free(modem->work_queue);
 149         g_free(modem->path);
 150         g_free(modem->operator);
 151         g_free(modem->cp_name);
 152
 153         _ps_modem_remove_profile_reset_gsource(modem);
 154
 155         g_free(modem);
 156
 157         dbg("Exiting");
 158         return;
 159 }
 160
 161 static void __ps_modem_emit_property_changed_signal(ps_modem_t *modem)
 162 {
 163         GVariant *gv = NULL;
 164         GVariantBuilder properties;
 165
 166         ps_dbg_ex_co(_ps_modem_ref_co_modem(modem), "get modem properties");
 167
 168         gv = _ps_modem_get_properties(modem, &properties);
 169         packet_service_modem_emit_property_changed(modem->if_obj, gv);
 170
 171         return;
 172 }
 173
 174 static void __ps_modem_emit_service_added_signal(ps_modem_t *modem, gpointer service)
 175 {
 176         GVariant *gv = NULL;
 177         GVariantBuilder property;
 178
 179         ps_dbg_ex_co(_ps_modem_ref_co_modem(modem), "get service properties");
 180
 181         gv = _ps_service_get_properties(service, &property);
 182         packet_service_modem_emit_service_added(modem->if_obj, gv);
 183         return;
 184 }
 185 /* blocked may be used later
 186 static void __ps_modem_emit_service_removed_signal(ps_modem_t *modem, gpointer service)
 187 {
 188         ps_service_t *psservice = service;
 189         packet_service_modem_emit_service_removed(modem->if_obj, psservice->path);
 190         return;
 191 }
 192 */
 193
 194 static void __ps_modem_create_service(GDBusConnection *conn, TcorePlugin *p,
 195                 gpointer modem, CoreObject *co_modem)
 196 {
 197         gchar *t_path = NULL;
 198         GObject *object = NULL;
 199
 200         CoreObject *co_ps = NULL;
 201         CoreObject *co_network = NULL;
 202         TcorePlugin *target_plg = NULL;
 203
 204         target_plg = tcore_object_ref_plugin(co_modem);
 205         co_ps = tcore_plugin_ref_core_object(target_plg, CORE_OBJECT_TYPE_PS);
 206         co_network = tcore_plugin_ref_core_object(target_plg, CORE_OBJECT_TYPE_NETWORK);
 207         if (!co_ps || !co_network)
 208                 return;
 209
 210         t_path = g_strdup_printf("%s/%s", _ps_modem_ref_path(modem), "umts_ps");
 211         if (NULL != g_hash_table_lookup(((ps_modem_t *) modem)->services, t_path)) {
 212                 ps_dbg_ex_co(co_modem, "service (%s) already exist!!!", t_path);
 213                 g_free(t_path);
 214                 return;
 215         }
 216         ps_dbg_ex_co(co_modem, "service path (%s)", t_path);
 217         object = _ps_service_create_service(conn, p, modem, co_network, co_ps, t_path);
 218         if (object == NULL) {
 219                 ps_err_ex_co(co_modem, "Failed to create service ");
 220                 g_free(t_path);
 221                 return;
 222         }
 223
 224         g_hash_table_insert(((ps_modem_t *) modem)->services, g_strdup(t_path), object);
 225         ps_dbg_ex_co(co_modem, "service (%p) insert to hash", object);
 226         __ps_modem_emit_service_added_signal((ps_modem_t *) modem, object);
 227
 228         g_free(t_path);
 229         return;
 230 }
 231
 232 static void __ps_modem_remove_service(ps_modem_t *modem, gpointer service)
 233 {
 234         ps_service_t *psservice = service;
 235
 236         ps_dbg_ex_co(_ps_modem_ref_co_modem(modem), "Entered");
 237
 238         /*Unexporting the interface for the modem*/
 239         if (psservice->if_obj) {
 240                 g_dbus_interface_skeleton_unexport(G_DBUS_INTERFACE_SKELETON(psservice->if_obj));
 241                 g_object_unref(psservice->if_obj);
 242                 psservice->if_obj = NULL;
 243         }
 244
 245         g_hash_table_remove(modem->services, _ps_service_ref_path(service));
 246
 247         dbg("Successfully removed the service from the modem");
 248         return;
 249 }
 250
 251 static gboolean __ps_modem_set_powered(ps_modem_t *modem, gboolean value)
 252 {
 253         g_return_val_if_fail(modem != NULL, FALSE);
 254
 255         modem->powered = value;
 256         ps_dbg_ex_co(_ps_modem_ref_co_modem(modem), "modem(%p) powered(%d)", modem, modem->powered);
 257         __ps_modem_emit_property_changed_signal(modem);
 258         return TRUE;
 259 }
 260
 261 static gboolean __ps_modem_set_sim_complete(ps_modem_t *modem, gboolean value, gchar *operator)
 262 {
 263         g_return_val_if_fail(modem != NULL, FALSE);
 264
 265         /* Update SIM init status */
 266         modem->sim_init = value;
 267         if (value && operator != NULL && !modem->operator)
 268                 modem->operator = g_strdup(operator);
 269         ps_dbg_ex_co(_ps_modem_ref_co_modem(modem), "modem [%p] SIM-Init [%s]", modem, (modem->sim_init ? "INITIALIZED" : "UNINITIALIZED"));
 270
 271         __ps_modem_emit_property_changed_signal(modem);
 272
 273         return TRUE;
 274 }
 275
 276 static gboolean __ps_modem_set_flght_mode(ps_modem_t *modem, gboolean value)
 277 {
 278         g_return_val_if_fail(modem != NULL, FALSE);
 279
 280         modem->flight_mode = value;
 281         ps_dbg_ex_co(_ps_modem_ref_co_modem(modem), "modem(%p) flight_mode(%d)", modem, modem->flight_mode);
 282         __ps_modem_emit_property_changed_signal(modem);
 283         __ps_modem_processing_modem_event(modem);
 284
 285         return TRUE;
 286 }
 287
 288 static void __ps_modem_get_ps_setting_from_storage(ps_modem_t *object)
 289 {
 290         gboolean key_3g_enable = FALSE, key_roaming_allowed = FALSE;
 291         gboolean key_nw_restrict_mode = FALSE;
 292         gint key_ps_mode = 0;
 293         ps_modem_t *modem = NULL;
 294         CoreObject *co_modem;
 295 #if defined(TIZEN_UPS_ENABLED)
 296         struct treq_modem_set_flightmode data = {0};
 297 #endif
 298
 299         modem = (ps_modem_t *) object;
 300         co_modem = _ps_modem_ref_co_modem(modem);
 301         key_3g_enable = _ps_master_get_storage_value_bool(modem->p_master, KEY_3G_ENABLE);
 302         key_roaming_allowed = _ps_master_get_storage_value_bool(modem->p_master, KEY_DATA_ROAMING_SETTING);
 303         key_ps_mode = _ps_master_get_storage_value_int(modem->p_master, KEY_POWER_SAVING_MODE);
 304         key_nw_restrict_mode = _ps_master_get_storage_value_bool(modem->p_master, KEY_NETWORK_RESTRICT_MODE);
 305
 306         _ps_modem_set_data_allowed(modem, key_3g_enable);
 307         _ps_modem_set_data_roaming_allowed(modem, key_roaming_allowed);
 308
 309 #if defined(TIZEN_UPS_ENABLED)
 310         _ps_modem_set_psmode(modem, key_ps_mode);
 311         if (key_ps_mode == POWER_SAVING_MODE_NORMAL) {
 312                 dbg("set flight mode off");
 313                 data.enable = FALSE;
 314         } else if (key_ps_mode == POWER_SAVING_MODE_WEARABLE) {
 315                 dbg("set flight mode on");
 316                 data.enable = TRUE;
 317         } else {
 318                 err("Not supported");
 319                 goto OUT;
 320         }
 321         _ps_modem_send_filght_mode_request(modem, &data);
 322 OUT:
 323 #endif
 324         ps_dbg_ex_co(co_modem, "data allowed(%d) roaming allowed(%d) power saving mode(%d), network restrict mode (%d)",
 325                 key_3g_enable, key_roaming_allowed, key_ps_mode, key_nw_restrict_mode);
 326         return;
 327 }
 328
 329 static void __ps_modem_processing_modem_event(gpointer object)
 330 {
 331         ps_modem_t *modem = object;
 332         GHashTableIter iter;
 333         gpointer key, value;
 334 #ifdef PREPAID_SIM_APN_SUPPORT
 335         gboolean ret;
 336 #endif
 337
 338         g_return_if_fail(modem != NULL);
 339
 340         if (!modem->services)
 341                 return;
 342
 343         g_hash_table_iter_init(&iter, modem->services);
 344         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 345                 gboolean s_roaming = FALSE;
 346
 347                 s_roaming = _ps_service_get_roaming(value);
 348                 _ps_update_cellular_state_key(value);
 349
 350                 if (modem->powered == PS_MODEM_STATE_OFFLINE) {
 351                         _ps_service_remove_contexts(value);
 352                         _ps_free_co_ps_event(value);
 353                         _ps_free_co_network_event(value);
 354                         __ps_modem_remove_service(modem, value);
 355                         continue;
 356                 }
 357
 358                 if (modem->flight_mode || (s_roaming && !modem->roaming_allowed)) {
 359                         _ps_service_disconnect_contexts(value);
 360                         continue;
 361                 } else if (!modem->data_allowed) {
 362                         _ps_service_disconnect_internet_mms_contexts(value);
 363                         continue;
 364                 }
 365
 366                 /* only available case */
 367 #ifdef PREPAID_SIM_APN_SUPPORT
 368                 ret = _ps_service_connect_last_connected_context(value);
 369                 dbg("ret[%d]", ret);
 370                 if (ret == TRUE)
 371                         return; /* No need to activate default context */
 372 #endif
 373                 _ps_service_connect_default_context(value);
 374         }
 375
 376         return;
 377 }
 378
 379 gpointer _ps_modem_create_modem(GDBusConnection *conn, TcorePlugin *p, gpointer master,
 380         char *modem_name, gpointer co_modem , gchar *cp_name)
 381 {
 382         PacketServiceModem *modem;
 383         ps_modem_t *new_modem;
 384         GError *error = NULL;
 385
 386         ps_dbg_ex_co(co_modem, "modem object create");
 387         g_return_val_if_fail(conn != NULL, NULL);
 388         g_return_val_if_fail(master != NULL, NULL);
 389
 390         /*creating the master object for the interface com.tcore.ps.modem*/
 391         modem = packet_service_modem_skeleton_new();
 392
 393         /*Initializing the modem list for internal referencing*/
 394         new_modem = g_try_malloc0(sizeof(ps_modem_t));
 395         if (NULL == new_modem) {
 396                 ps_err_ex_co(co_modem, "Unable to allocate memory for modem");
 397                 return NULL;
 398         }
 399
 400         /*Add work queue to keep user request in case of handling active PDP context*/
 401         new_modem->hook_flag = 0x00;
 402         new_modem->work_queue = g_queue_new();
 403         if (NULL == new_modem->work_queue) {
 404                 ps_err_ex_co(co_modem, "Unable to get work queue for modem");
 405                 g_free(new_modem);
 406                 return NULL;
 407         }
 408
 409         new_modem->conn = conn;
 410         new_modem->p_master = master;
 411         new_modem->plg = p;
 412         new_modem->co_modem = co_modem;
 413         new_modem->path = g_strdup(modem_name);
 414         new_modem->cp_name = g_strdup(cp_name);
 415         new_modem->if_obj = modem;
 416         new_modem->services = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, __remove_service_handler);
 417
 418         __ps_modem_get_ps_setting_from_storage(new_modem);
 419         _ps_hook_co_modem_event(new_modem);
 420         _ps_get_co_modem_values(new_modem);
 421
 422         /*Setting the interface call backs functions*/
 423         _ps_modem_setup_interface(modem, new_modem);
 424
 425         /*exporting the interface object to the path mention for modem*/
 426         g_dbus_interface_skeleton_export((G_DBUS_INTERFACE_SKELETON(modem)),
 427                         conn,
 428                         modem_name,
 429                         &error);
 430
 431         g_assert_no_error(error);
 432
 433         /* Adding hooks for special Network Requests */
 434         tcore_server_add_request_hook(tcore_plugin_ref_server(p),
 435                         TREQ_NETWORK_SEARCH,
 436                         ps_handle_hook, new_modem);
 437         tcore_server_add_request_hook(tcore_plugin_ref_server(p),
 438                         TREQ_NETWORK_SET_PLMN_SELECTION_MODE,
 439                         ps_handle_hook, new_modem);
 440         tcore_server_add_request_hook(tcore_plugin_ref_server(p),
 441                         TREQ_NETWORK_SET_MODE,
 442                         ps_handle_hook, new_modem);
 443         tcore_server_add_request_hook(tcore_plugin_ref_server(p),
 444                         TREQ_NETWORK_SET_CANCEL_MANUAL_SEARCH,
 445                         ps_handle_hook, new_modem);
 446         tcore_server_add_request_hook(tcore_plugin_ref_server(p),
 447                         TREQ_NETWORK_SET_DEFAULT_DATA_SUBSCRIPTION,
 448                         ps_handle_hook, new_modem);
 449         tcore_server_add_request_hook(tcore_plugin_ref_server(p),
 450                         TREQ_SIM_SET_POWERSTATE,
 451                         ps_handle_hook, new_modem);
 452         tcore_server_add_request_hook(tcore_plugin_ref_server(p),
 453                         TREQ_MODEM_SET_FLIGHTMODE,
 454                         ps_handle_hook, new_modem);
 455         tcore_server_add_request_hook(tcore_plugin_ref_server(p),
 456                         TREQ_MODEM_POWER_OFF,
 457                         ps_handle_hook, new_modem);
 458         tcore_server_add_request_hook(tcore_plugin_ref_server(p),
 459                         TREQ_MODEM_POWER_LOW,
 460                         ps_handle_hook, new_modem);
 461         tcore_server_add_request_hook(tcore_plugin_ref_server(p),
 462                         TREQ_MODEM_POWER_ON,
 463                         ps_handle_hook, new_modem);
 464
 465         ps_err_ex_co(co_modem, "Successfully created the modem");
 466         return new_modem;
 467 }
 468
 469 void _ps_modem_destroy_modem(GDBusConnection *conn, gpointer object)
 470 {
 471         ps_modem_t *modem = object;
 472         GHashTableIter iter;
 473         gpointer key, value;
 474         GSList *list = NULL;
 475         GSList *list_iter = NULL;
 476
 477         g_return_if_fail(modem != NULL);
 478
 479         if (modem->services == NULL)
 480                 return;
 481
 482         dbg("Clearing all services");
 483         g_hash_table_iter_init(&iter, modem->services);
 484         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 485                 /* Update Cellular state */
 486                 _ps_service_set_ps_attached(value, FALSE);
 487                 _ps_update_cellular_state_key(value);
 488
 489                 /* Remove contexts */
 490                 _ps_service_remove_contexts(value);
 491
 492                 /* Clear hooks */
 493                 _ps_free_co_ps_event(value);
 494                 _ps_free_co_network_event(value);
 495
 496                 /* To avoid hashtable assertion */
 497                 list = g_slist_append(list, value);
 498         }
 499
 500         for (list_iter = list; list_iter; list_iter = g_slist_next(list_iter)) {
 501                 /* Remove services */
 502                 __ps_modem_remove_service(modem, list_iter->data);
 503         }
 504         g_slist_free(list);
 505         g_slist_free(modem->contexts);
 506
 507         /* Clear modem hooks */
 508         _ps_free_co_modem_event(modem);
 509 }
 510
 511 gboolean _ps_modem_send_filght_mode_request(gpointer value, void *data)
 512 {
 513         CoreObject *co_modem = NULL, *co_ps = NULL;
 514         UserRequest *ur = NULL;
 515         ps_modem_t *modem = value;
 516         TReturn rv;
 517
 518         co_modem = _ps_modem_ref_co_modem(modem);
 519         co_ps = tcore_plugin_ref_core_object(tcore_object_ref_plugin(co_modem), CORE_OBJECT_TYPE_PS);
 520         /* deactivate contexts first. */
 521         rv = tcore_ps_deactivate_contexts(co_ps);
 522         if (rv != TCORE_RETURN_SUCCESS)
 523                 ps_dbg_ex_co(co_ps, "fail to deactivation");
 524
 525         tcore_ps_set_online(co_ps, FALSE);
 526
 527         ur = tcore_user_request_new(NULL, NULL);
 528         tcore_user_request_set_data(ur, sizeof(struct treq_modem_set_flightmode), data);
 529         tcore_user_request_set_command(ur, TREQ_MODEM_SET_FLIGHTMODE);
 530         if (TCORE_RETURN_SUCCESS != tcore_object_dispatch_request(co_modem, ur)) {
 531                 err("fail to send user request");
 532                 tcore_user_request_unref(ur);
 533                 return FALSE;
 534         }
 535         return TRUE;
 536 }
 537
 538 gboolean _ps_modem_processing_flight_mode(gpointer object, gboolean enable)
 539 {
 540         ps_modem_t *modem = object;
 541
 542         g_return_val_if_fail(modem != NULL, FALSE);
 543
 544         if (modem->flight_mode == enable)
 545                 return TRUE;
 546
 547         __ps_modem_set_flght_mode(modem, enable);
 548         return TRUE;
 549 }
 550
 551 gboolean _ps_modem_processing_power_enable(gpointer object, int modem_state)
 552 {
 553         ps_modem_t *modem = object;
 554
 555         g_return_val_if_fail(modem != NULL, FALSE);
 556
 557         dbg("modem->powered [%d], Modem->sim_init [%d], modem_state [%d]",
 558                 modem->powered, modem->sim_init, modem_state);
 559
 560         if (modem->powered == modem_state)
 561                 return TRUE;
 562
 563         __ps_modem_set_powered(modem, modem_state);
 564
 565         if (modem_state == PS_MODEM_STATE_ONLINE) {
 566                 __ps_modem_create_service(modem->conn, modem->plg, modem, modem->co_modem);
 567                 if (modem->sim_init == TRUE && modem->operator != NULL) {
 568                         GSList *contexts = (GSList*)_ps_modem_ref_contexts(modem);
 569
 570                         if (contexts != NULL) {
 571                                 GHashTableIter iter;
 572                                 gpointer key, value;
 573                                 warn("[WARN] contexts exist, SIM init complete before Modem Power On event.");
 574                                 g_hash_table_iter_init(&iter, modem->services);
 575                                 while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 576                                         _ps_service_set_number_of_pdn_cnt(value, modem->operator);
 577                                         _ps_service_ref_contexts(value, contexts, modem->operator);
 578                                         _ps_service_set_attach_apn(value);
 579                                 }
 580                         }
 581                 }
 582         } else if (modem_state == PS_MODEM_STATE_OFFLINE) {
 583                 __ps_modem_processing_modem_event(modem);
 584                 /* SIM init should be set to FALSE during CP silent reset.
 585                  * and will be updated when SIM initialized complete notification is received.
 586                  */
 587         }
 588         return TRUE;
 589 }
 590
 591 gboolean _ps_modem_processing_sim_complete(gpointer object, gboolean complete, gchar *operator)
 592 {
 593         ps_modem_t *modem = object;
 594         CoreObject *co_modem;
 595         g_return_val_if_fail(modem != NULL, FALSE);
 596
 597         co_modem = _ps_modem_ref_co_modem(modem);
 598         ps_dbg_ex_co(co_modem, "Entered: sim_init[%d]", modem->sim_init);
 599
 600         if (modem->sim_init == complete && !modem->reset_profile) {
 601                 ps_dbg_ex_co(co_modem, "No change in SIM state");
 602                 return TRUE;
 603         } else {
 604                 gboolean different_sim = FALSE;
 605
 606                 if (operator && (g_strcmp0(modem->operator, operator) != 0)) {
 607                         ps_dbg_ex_co(co_modem, "Previous operator: [%s] Present operator: [%s]", modem->operator, operator);
 608                         g_free(modem->operator);
 609
 610                         modem->operator = g_strdup(operator);
 611                         different_sim = TRUE;
 612                 }
 613
 614
 615                 /* free modem operator */
 616                 if (FALSE == complete) {
 617                         g_free(modem->operator);
 618                         modem->operator = NULL;
 619                 }
 620
 621                 /* Update SIM state */
 622                 __ps_modem_set_sim_complete(modem, complete, operator);
 623                 /* Tizen Telephony makes dummy profile for CDMA by default */
 624                 _ps_context_create_cdma_profile(modem->operator, modem->cp_name);
 625
 626                 /* Modem power off notification coming due to which profile are removed */
 627                 /* and needed to be re inserted in db with sim off notification  */
 628                 /*
 629                  * Context table creation
 630                  *
 631                  * Create context if -
 632                  *      SIM is initiatized
 633                  * Initialzed SIM is different (if same SIM is re-initialized then need not create context)
 634                  * Delete context if sim_init = FALSE;
 635                  * This will be coming when SIM power off or CARD error is received.
 636                  */
 637                 if (modem->sim_init == TRUE) {
 638                         if ((different_sim || modem->reset_profile) && (modem->operator != NULL)) {
 639                                 GSList *contexts;
 640
 641                                 ps_dbg_ex_co(co_modem, "Creating Hash table...");
 642                                 contexts = _ps_context_create_hashtable(object, modem->roaming);
 643                                 if (contexts != NULL) {
 644                                         GHashTableIter iter;
 645                                         gpointer key, value;
 646
 647                                         g_hash_table_iter_init(&iter, modem->services);
 648                                         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 649                                                 _ps_service_set_number_of_pdn_cnt(value, modem->operator);
 650                                                 _ps_service_ref_contexts(value, contexts, modem->operator);
 651                                                 _ps_service_set_attach_apn(value);
 652                                         }
 653                                 } else {
 654                                         ps_dbg_ex_co(co_modem, "Failed to create HASH table");
 655                                         return FALSE;
 656                                 }
 657                         }
 658                 } else {
 659                         GHashTableIter iter;
 660                         gpointer key, value;
 661
 662                         if (!modem->services)
 663                                 goto EXIT;
 664
 665                         g_hash_table_iter_init(&iter, modem->services);
 666                         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 667                                 ps_dbg_ex_co(co_modem, "Remove contexts on service(%p)", value);
 668                                 _ps_service_remove_contexts(value);
 669                         }
 670                 }
 671         }
 672 EXIT:
 673         dbg("Exiting");
 674         return TRUE;
 675 }
 676
 677 gboolean _ps_modem_set_reset_profile(gpointer object, gboolean value)
 678 {
 679         ps_modem_t *modem = object;
 680
 681         g_return_val_if_fail(modem != NULL, FALSE);
 682
 683         modem->reset_profile = value;
 684         dbg("modem(%p) reset_profile(%d)", modem, modem->reset_profile);
 685         return TRUE;
 686 }
 687
 688 gboolean _ps_modem_get_reset_profile(gpointer object)
 689 {
 690         ps_modem_t *modem = object;
 691
 692         g_return_val_if_fail(modem != NULL, FALSE);
 693
 694         dbg("modem(%p) reset_profile(%d)", modem, modem->reset_profile);
 695
 696         return modem->reset_profile;
 697 }
 698
 699 GSource *_ps_modem_get_profile_reset_gsource(gpointer object)
 700 {
 701         ps_modem_t *modem = object;
 702
 703         g_return_val_if_fail(modem != NULL, NULL);
 704
 705         return modem->reset_profile_gsource;
 706 }
 707
 708 gboolean _ps_modem_set_profile_reset_gsource(gpointer object, GSource *source)
 709 {
 710         ps_modem_t *modem = object;
 711
 712         g_return_val_if_fail(modem != NULL, FALSE);
 713
 714         modem->reset_profile_gsource = source;
 715
 716         return TRUE;
 717 }
 718
 719 gboolean  _ps_modem_remove_profile_reset_gsource(gpointer object)
 720 {
 721         ps_modem_t *modem = object;
 722
 723         g_return_val_if_fail(modem != NULL, FALSE);
 724
 725         if (NULL != modem->reset_profile_gsource) {
 726                 g_source_unref(modem->reset_profile_gsource);
 727                 modem->reset_profile_gsource = NULL;
 728         }
 729
 730         return TRUE;
 731 }
 732
 733 gboolean _ps_modem_set_sim_enabled(gpointer object, gboolean value)
 734 {
 735         ps_modem_t *modem = object;
 736
 737         g_return_val_if_fail(modem != NULL, FALSE);
 738
 739         modem->sim_init = value;
 740         ps_dbg_ex_co(_ps_modem_ref_co_modem(modem), "modem(%p) sim_enabled(%d)", modem, modem->sim_init);
 741         return TRUE;
 742 }
 743
 744 gboolean _ps_modem_set_data_allowed(gpointer object, gboolean value)
 745 {
 746         ps_modem_t *modem = object;
 747
 748         g_return_val_if_fail(modem != NULL, FALSE);
 749
 750         modem->data_allowed = value;
 751         ps_dbg_ex_co(_ps_modem_ref_co_modem(modem), "modem(%p) data allowed(%d)", modem, modem->data_allowed);
 752         __ps_modem_emit_property_changed_signal(modem);
 753         __ps_modem_processing_modem_event(modem);
 754
 755         return TRUE;
 756 }
 757
 758 gboolean _ps_modem_get_data_allowed(gpointer object)
 759 {
 760         ps_modem_t *modem = object;
 761         g_return_val_if_fail(modem != NULL, FALSE);
 762
 763         return modem->data_allowed;
 764 }
 765
 766 gboolean _ps_modem_set_data_roaming_allowed(gpointer object, gboolean roaming_allowed)
 767 {
 768         ps_modem_t *modem = object;
 769
 770         g_return_val_if_fail(modem != NULL, FALSE);
 771
 772         modem->roaming_allowed = roaming_allowed;
 773         ps_dbg_ex_co(_ps_modem_ref_co_modem(modem), "modem(%p) roaming allowed(%d)", modem, modem->roaming_allowed);
 774         __ps_modem_emit_property_changed_signal(modem);
 775
 776         if (!modem->services)
 777                 return TRUE;
 778
 779         if (modem->roaming)
 780                 __ps_modem_processing_modem_event(modem);
 781
 782         return TRUE;
 783 }
 784
 785 gboolean _ps_modem_set_psmode(gpointer object, gint value)
 786 {
 787         ps_modem_t *modem = object;
 788
 789         g_return_val_if_fail(modem != NULL, FALSE);
 790
 791         modem->ps_mode = value;
 792         ps_dbg_ex_co(_ps_modem_ref_co_modem(modem), "modem(%p) power saving mode(%d)", modem, modem->ps_mode);
 793
 794         return TRUE;
 795 }
 796
 797 gboolean _ps_modem_get_roaming(gpointer object)
 798 {
 799         ps_modem_t *modem = object;
 800         g_return_val_if_fail(modem != NULL, FALSE);
 801
 802         return modem->roaming;
 803 }
 804
 805 void _ps_modem_set_roaming(gpointer object, gboolean value)
 806 {
 807         ps_modem_t *modem = object;
 808         g_return_if_fail(modem != NULL);
 809
 810         modem->roaming = value;
 811         ps_dbg_ex_co(_ps_modem_ref_co_modem(modem), "modem(%p) roaming(%d)", modem, modem->roaming);
 812
 813         return;
 814 }
 815
 816 gint _ps_modem_get_roaming_apn_support(gpointer object)
 817 {
 818         ps_modem_t *modem = object;
 819
 820         g_return_val_if_fail(modem != NULL, FALSE);
 821
 822         return modem->roaming_apn_support;
 823 }
 824
 825 void _ps_modem_set_roaming_apn_support(gpointer object, gboolean value)
 826 {
 827         ps_modem_t *modem = object;
 828         g_return_if_fail(modem != NULL);
 829
 830         modem->roaming_apn_support = value;
 831         ps_dbg_ex_co(_ps_modem_ref_co_modem(modem), "modem(%p) roaming_apn_support(%d)", modem, modem->roaming);
 832 }
 833
 834 gint _ps_modem_get_psmode(gpointer object)
 835 {
 836         ps_modem_t *modem = object;
 837
 838         g_return_val_if_fail(modem != NULL, FALSE);
 839
 840         return modem->ps_mode;
 841 }
 842
 843 guchar _ps_modem_get_hook_flag(gpointer object)
 844 {
 845         ps_modem_t *modem = object;
 846
 847         g_return_val_if_fail(modem != NULL, FALSE);
 848
 849         return modem->hook_flag;
 850 }
 851
 852 gboolean _ps_modem_get_data_roaming_allowed(gpointer object)
 853 {
 854         ps_modem_t *modem = object;
 855         g_return_val_if_fail(modem != NULL, FALSE);
 856
 857         return modem->roaming_allowed;
 858 }
 859
 860 gboolean _ps_modem_get_flght_mode(gpointer object)
 861 {
 862         ps_modem_t *modem = object;
 863         g_return_val_if_fail(modem != NULL, FALSE);
 864
 865         return modem->flight_mode;
 866 }
 867
 868 void _ps_modem_set_flght_mode_ups(gpointer object, gboolean value)
 869 {
 870         ps_modem_t *modem = object;
 871         g_return_if_fail(modem != NULL);
 872
 873         modem->flight_mode_ups = value;
 874         dbg("modem(%p) flight_mode_ups(%d)", modem, modem->flight_mode_ups);
 875
 876         return;
 877 }
 878
 879 gboolean _ps_modem_get_flght_mode_ups(gpointer object)
 880 {
 881         ps_modem_t *modem = object;
 882         g_return_val_if_fail(modem != NULL, FALSE);
 883
 884         return modem->flight_mode_ups;
 885 }
 886
 887 gboolean _ps_modem_get_sim_init(gpointer object)
 888 {
 889         ps_modem_t *modem = object;
 890         g_return_val_if_fail(modem != NULL, FALSE);
 891
 892         return modem->sim_init;
 893 }
 894
 895 gboolean _ps_modem_get_power(gpointer object)
 896 {
 897         ps_modem_t *modem = object;
 898         g_return_val_if_fail(modem != NULL, FALSE);
 899
 900         return modem->powered;
 901 }
 902
 903 char *_ps_modem_ref_operator(gpointer object)
 904 {
 905         ps_modem_t *modem = object;
 906         g_return_val_if_fail(modem != NULL, FALSE);
 907
 908         return modem->operator;
 909 }
 910
 911 ps_subs_type _ps_modem_get_subs_type(gpointer object)
 912 {
 913         ps_modem_t *modem = object;
 914         const gchar *cp_name;
 915
 916         g_return_val_if_fail(modem != NULL, FALSE);
 917
 918         cp_name = modem->cp_name;
 919         if (g_str_has_suffix(cp_name, "0"))
 920                 return PS_SUBS_PRIMARY;
 921         else if (g_str_has_suffix(cp_name, "1"))
 922                 return PS_SUBS_SECONDARY;
 923         else if (g_str_has_suffix(cp_name, "2"))
 924                 return PS_SUBS_TERTIARY;
 925
 926         return PS_SUBS_MAX;
 927 }
 928
 929 gboolean _ps_modem_get_properties_handler(gpointer object, GVariantBuilder *properties)
 930 {
 931         ps_modem_t *modem = object;
 932
 933         ps_dbg_ex_co(_ps_modem_ref_co_modem(modem), "get modem properties");
 934         g_return_val_if_fail(modem != NULL, FALSE);
 935         g_return_val_if_fail(properties != NULL, FALSE);
 936
 937         g_variant_builder_open(properties, G_VARIANT_TYPE("a{ss}"));
 938         g_variant_builder_add(properties, "{ss}", "path", modem->path);
 939
 940         if (modem->operator)
 941                 g_variant_builder_add(properties, "{ss}", "operator", modem->operator);
 942         g_variant_builder_add(properties, "{ss}", "powered", BOOL2STRING(modem->powered));
 943         g_variant_builder_add(properties, "{ss}", "sim_init", BOOL2STRING(modem->sim_init));
 944         g_variant_builder_add(properties, "{ss}", "flight_mode", BOOL2STRING(modem->flight_mode));
 945         g_variant_builder_add(properties, "{ss}", "roaming_allowed", BOOL2STRING(modem->roaming_allowed));
 946         g_variant_builder_add(properties, "{ss}", "data_allowed", BOOL2STRING(modem->data_allowed));
 947         g_variant_builder_close(properties);
 948
 949         dbg("Exiting");
 950         return TRUE;
 951 }
 952
 953 GVariant *_ps_modem_get_properties(gpointer object, GVariantBuilder *properties)
 954 {
 955         ps_modem_t *modem = object;
 956
 957         ps_dbg_ex_co(_ps_modem_ref_co_modem(modem), "get modem properties");
 958         g_return_val_if_fail(modem != NULL, FALSE);
 959         g_return_val_if_fail(properties != NULL, FALSE);
 960
 961         g_variant_builder_init(properties, G_VARIANT_TYPE("a{ss}"));
 962
 963         g_variant_builder_add(properties, "{ss}", "path", modem->path);
 964
 965         if (modem->operator)
 966                 g_variant_builder_add(properties, "{ss}", "operator", modem->operator);
 967         g_variant_builder_add(properties, "{ss}", "powered", BOOL2STRING(modem->powered));
 968         g_variant_builder_add(properties, "{ss}", "sim_init", BOOL2STRING(modem->sim_init));
 969         g_variant_builder_add(properties, "{ss}", "flight_mode", BOOL2STRING(modem->flight_mode));
 970         g_variant_builder_add(properties, "{ss}", "roaming_allowed", BOOL2STRING(modem->roaming_allowed));
 971         g_variant_builder_add(properties, "{ss}", "data_allowed", BOOL2STRING(modem->data_allowed));
 972
 973         dbg("Exiting");
 974         return g_variant_builder_end(properties);
 975 }
 976
 977 GHashTable *_ps_modem_ref_services(gpointer object)
 978 {
 979         ps_modem_t *modem = object;
 980         g_return_val_if_fail(modem != NULL, NULL);
 981
 982         return modem->services;
 983 }
 984
 985 char *_ps_modem_ref_path(gpointer object)
 986 {
 987         ps_modem_t *modem = object;
 988         g_return_val_if_fail(modem != NULL, NULL);
 989
 990         return modem->path;
 991 }
 992
 993 gpointer _ps_modem_ref_plugin(gpointer object)
 994 {
 995         ps_modem_t *modem = object;
 996         g_return_val_if_fail(modem != NULL, NULL);
 997
 998         return modem->plg;
 999 }
1000
1001 gpointer _ps_modem_ref_dbusconn(gpointer object)
1002 {
1003         ps_modem_t *modem = object;
1004         g_return_val_if_fail(modem != NULL, NULL);
1005
1006         return modem->conn;
1007 }
1008
1009 gpointer _ps_modem_ref_co_modem(gpointer object)
1010 {
1011         ps_modem_t *modem = object;
1012         g_return_val_if_fail(modem != NULL, NULL);
1013
1014         return modem->co_modem;
1015 }
1016
1017 gpointer _ps_modem_ref_work_queue(gpointer object)
1018 {
1019         ps_modem_t *modem = object;
1020         g_return_val_if_fail(modem != NULL, NULL);
1021
1022         return modem->work_queue;
1023 }
1024
1025 gchar *_ps_modem_ref_cp_name(gpointer object)
1026 {
1027         ps_modem_t *modem = object;
1028         g_return_val_if_fail(modem != NULL, NULL);
1029
1030         return modem->cp_name;
1031 }
1032
1033 gpointer _ps_modem_ref_contexts(gpointer object)
1034 {
1035         ps_modem_t *modem = object;
1036         g_return_val_if_fail(modem != NULL, NULL);
1037         return modem->contexts;
1038 }
1039
1040 static gboolean on_modem_get_properties(PacketServiceModem *obj_modem,
1041                 GDBusMethodInvocation *invocation,
1042                 gpointer user_data)
1043 {
1044         GVariant *gv = NULL;
1045         GVariantBuilder properties;
1046
1047         dbg("get modem properties");
1048
1049         gv = _ps_modem_get_properties(user_data, &properties);
1050         packet_service_modem_complete_get_properties(obj_modem, invocation, gv);
1051         return TRUE;
1052 }
1053
1054 static gboolean on_modem_get_services(PacketServiceModem *obj_modem,
1055                 GDBusMethodInvocation *invocation,
1056                 gpointer user_data)
1057 {
1058         GVariantBuilder b_service;
1059         GVariant *services;
1060
1061         GHashTableIter iter;
1062         gpointer key, value;
1063         ps_modem_t *modem = user_data;
1064         CoreObject *co_modem = _ps_modem_ref_co_modem(modem);
1065
1066         ps_dbg_ex_co(co_modem, "modem get service interface");
1067
1068         if (modem->services == NULL) {
1069                 FAIL_RESPONSE(invocation, PS_ERR_INTERNAL);
1070                 return TRUE;
1071         }
1072
1073         g_variant_builder_init(&b_service, G_VARIANT_TYPE("a{sa{ss}}"));
1074         g_hash_table_iter_init(&iter, modem->services);
1075         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1076                 gchar *path = NULL;
1077
1078                 g_variant_builder_open(&b_service, G_VARIANT_TYPE("{sa{ss}}"));
1079                 path = _ps_service_ref_path(value);
1080                 ps_dbg_ex_co(co_modem, "path added [%s]", path);
1081                 g_variant_builder_add(&b_service, "s", g_strdup(path));
1082                 if (FALSE == _ps_service_get_properties_handler(value, &b_service)) {
1083                         g_variant_builder_close(&b_service);
1084                         FAIL_RESPONSE(invocation, PS_ERR_INTERNAL);
1085                         return TRUE;
1086                 }
1087                 g_variant_builder_close(&b_service);
1088         }
1089
1090         services = g_variant_builder_end(&b_service);
1091         packet_service_modem_complete_get_services(obj_modem, invocation, services);
1092         return TRUE;
1093 }
1094
1095 static gboolean on_modem_go_dormant_all(PacketServiceModem *obj_modem,
1096                 GDBusMethodInvocation *invocation,
1097                 gpointer user_data)
1098 {
1099         int result = -1;
1100
1101         GHashTableIter iter;
1102         gpointer key, value;
1103         ps_modem_t *modem = user_data;
1104
1105         dbg("modem go dormant all interface");
1106
1107         if (modem->services == NULL) {
1108                 FAIL_RESPONSE(invocation, PS_ERR_INTERNAL);
1109                 return TRUE;
1110         }
1111
1112         g_hash_table_iter_init(&iter, modem->services);
1113         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1114                 ps_service_t *service = value;
1115                 dbg("service (%p), send dormant request, ", service);
1116                 result = tcore_ps_send_dormant_request(service->co_ps, NULL);
1117         }
1118
1119         packet_service_modem_complete_go_dormant_all(obj_modem, invocation, result);
1120         return TRUE;
1121 }
1122
1123 static gboolean on_modem_get_profile_list(PacketServiceModem *obj_modem,
1124                 GDBusMethodInvocation *invocation,
1125                 gpointer user_data)
1126 {
1127         int profile_index = 0;
1128
1129         guint len = 0, index;
1130         gchar **strv = NULL;
1131         GSList *profiles = NULL;
1132         ps_modem_t *modem = user_data;
1133         CoreObject *co_modem = _ps_modem_ref_co_modem(modem);
1134
1135         ps_dbg_ex_co(co_modem, "master get the profile list");
1136
1137         if (modem->contexts == NULL) {
1138                 ps_err_ex_co(co_modem, "no profiles");
1139                 FAIL_RESPONSE(invocation, PS_ERR_NO_PROFILE);
1140                 return TRUE;
1141         }
1142
1143         for (index = 0; index < g_slist_length(modem->contexts); index++) {
1144                 gchar *s_path = NULL;
1145                 gpointer value = g_slist_nth_data(modem->contexts, index);
1146
1147                 s_path = _ps_context_ref_path(value);
1148                 ps_dbg_ex_co(co_modem, "value(%p), path(%s)", value, s_path);
1149                 if (s_path)
1150                         profiles = g_slist_append(profiles, g_strdup((const char *)s_path));
1151         }
1152
1153         if (profiles == NULL) {
1154                 ps_dbg_ex_co(co_modem, "no profiles");
1155                 FAIL_RESPONSE(invocation, PS_ERR_NO_PROFILE);
1156                 return TRUE;
1157         }
1158
1159         len = g_slist_length(profiles);
1160         strv = g_new(gchar *, len+1);
1161
1162         while (profiles) {
1163                 strv[profile_index] = g_strdup(profiles->data);
1164                 profile_index++;
1165
1166                 profiles = profiles->next;
1167         }
1168         strv[profile_index] = NULL;
1169
1170         packet_service_modem_complete_get_profile_list(obj_modem,
1171                                 invocation, (const gchar *const *)strv);
1172
1173         g_strfreev(strv);
1174         profiles = g_slist_nth(profiles, 0);
1175         g_slist_free_full(profiles, g_free);
1176         dbg("Exiting");
1177         return TRUE;
1178 }
1179
1180 static gboolean on_modem_add_profile(PacketServiceModem *obj_modem,
1181                 GDBusMethodInvocation *invocation,
1182                 GVariant *property,
1183                 gpointer user_data)
1184 {
1185         GVariantIter g_iter;
1186         gchar *g_value;
1187         gchar *g_key;
1188
1189         gboolean rv = FALSE;
1190         gchar *operator = NULL;
1191         ps_modem_t *modem = user_data;
1192         CoreObject *co_modem = _ps_modem_ref_co_modem(modem);
1193         GHashTable *profile_property = NULL;
1194
1195         ps_dbg_ex_co(co_modem, "add profile request");
1196
1197         operator = _ps_modem_ref_operator(modem);
1198
1199         if (!operator) {
1200                 ps_dbg_ex_co(co_modem, "there is no active modem");
1201                 FAIL_RESPONSE(invocation, PS_ERR_INTERNAL);
1202                 return TRUE;
1203         }
1204
1205         /*Create a hash table for the profile property as all fucntion already use ghash table */
1206         profile_property = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
1207         g_variant_iter_init(&g_iter, property);
1208         while (g_variant_iter_next(&g_iter, "{ss}", &g_key, &g_value)) {
1209
1210                 ps_dbg_ex_co(co_modem, " '%s' value '%s'", g_key, g_value);
1211                 g_hash_table_insert(profile_property, g_strdup(g_key), g_strdup(g_value));
1212                 /* must free data for ourselves */
1213                 g_free(g_value);
1214                 g_free(g_key);
1215         }
1216
1217         rv = _ps_context_add_context(modem, operator, profile_property);
1218         if (rv != TRUE) {
1219                 ps_err_ex_co(co_modem, "Failed to add the Profile");
1220                 FAIL_RESPONSE(invocation, PS_ERR_INTERNAL);
1221                 g_hash_table_destroy(profile_property);
1222                 return TRUE;
1223         }
1224
1225         packet_service_modem_complete_add_profile(obj_modem, invocation, TRUE);
1226
1227         g_hash_table_destroy(profile_property);
1228         dbg("Exiting");
1229         return TRUE;
1230 }
1231
1232 gboolean _ps_modem_initiate_reset_profile(gpointer value)
1233 {
1234         CoreObject *co_modem;
1235         ps_modem_t *modem = value;
1236         GHashTableIter iter;
1237         gpointer key, key_value;
1238
1239         g_return_val_if_fail(modem != NULL, FALSE);
1240
1241         co_modem = _ps_modem_ref_co_modem(modem);
1242
1243         ps_dbg_ex_co(co_modem, "Reseting the hash table");
1244         /* Remove contexts through only service. */
1245         g_hash_table_iter_init(&iter, modem->services);
1246         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
1247                 ps_dbg_ex_co(co_modem, "Remove contexts on service(%p)", value);
1248                 _ps_service_remove_contexts(value);
1249         }
1250
1251         if (modem->type == 0) {
1252                 GThread *thread;
1253                 gchar *name = g_strdup_printf("REGEN-DB-%s", modem->cp_name);
1254
1255                 thread = g_thread_new(name, __ps_modem_regenerate_database, modem);
1256                 g_free(name);
1257                 if (thread == NULL) {
1258                         dbg("Thread is not created");
1259                         FAIL_RESPONSE(modem->invocation , PS_ERR_INTERNAL);
1260                         _ps_modem_remove_profile_reset_gsource(modem);
1261                 } else {
1262                         dbg("Thread(%p) is created", thread);
1263                 }
1264
1265                 return FALSE;
1266         }
1267         /* Create contexts again. */
1268         _ps_get_co_modem_values(modem);
1269         _ps_modem_set_reset_profile(modem, FALSE);
1270         packet_service_modem_complete_reset_profile(modem->if_obj, modem->invocation, TRUE);
1271         modem->invocation = NULL;
1272
1273         _ps_modem_remove_profile_reset_gsource(modem);
1274
1275         /* Try to re-connect default contexts after reset profile is complete */
1276         g_hash_table_iter_init(&iter, modem->services);
1277         while (g_hash_table_iter_next(&iter, &key, &key_value) == TRUE) {
1278                 /* only available case */
1279                 _ps_service_connect_default_context(key_value);
1280         }
1281
1282         ps_dbg_ex_co(co_modem, "Exiting");
1283         return FALSE;
1284 }
1285
1286 static gboolean on_modem_reset_profile(PacketServiceModem *obj_modem,
1287                 GDBusMethodInvocation *invocation,
1288                 gint type,
1289                 gpointer user_data)
1290 {
1291         TReturn rv;
1292         gboolean contexts_active;
1293         ps_modem_t *modem = user_data;
1294         CoreObject *co_modem = _ps_modem_ref_co_modem(modem);
1295         CoreObject *co_ps;
1296         int state;
1297
1298         ps_dbg_ex_co(co_modem, "reset profile request type(%d)", type);
1299
1300         if (_ps_modem_get_reset_profile(modem) == TRUE) {
1301                 ps_err_ex_co(co_modem, "Reset Profile is already in Progress");
1302                 packet_service_modem_complete_reset_profile(obj_modem, invocation, FALSE);
1303                 ps_dbg_ex_co(co_modem, "Exiting");
1304                 return FALSE;
1305         }
1306
1307         _ps_modem_set_reset_profile(modem, TRUE);
1308
1309         co_ps = tcore_plugin_ref_core_object(tcore_object_ref_plugin(_ps_modem_ref_co_modem(modem)),
1310                                                                                 CORE_OBJECT_TYPE_PS);
1311
1312         modem->invocation = invocation;
1313         modem->type = type;
1314
1315         contexts_active = tcore_ps_any_context_activating_activated(co_ps, &state);
1316
1317         if (contexts_active == TRUE) {
1318                 ps_dbg_ex_co(co_modem, "Contexts are in [%d] state", state);
1319                 if (state == CONTEXT_STATE_ACTIVATED) {
1320                         ps_dbg_ex_co(co_modem, "Contexts are in Actived state. Sending Diconnect Notification to all connected contexts");
1321                         rv = tcore_ps_deactivate_contexts(co_ps);
1322                         if (rv != TCORE_RETURN_SUCCESS)
1323                                 ps_dbg_ex_co(co_modem, "fail to deactivation");
1324                 } else if (state == CONTEXT_STATE_ACTIVATING) {
1325                         ps_dbg_ex_co(co_modem, "Contexts are in Activating state. Wait for them to connect");
1326                 }
1327         } else {
1328                 ps_dbg_ex_co(co_modem, "No contexts are in activating or activated state");
1329                 ps_dbg_ex_co(co_modem, "Profiles reset is being initiated");
1330                 _ps_modem_initiate_reset_profile(modem);
1331         }
1332
1333         return TRUE;
1334 }
1335
1336
1337 static void _ps_modem_setup_interface(PacketServiceModem *modem, ps_modem_t *modem_data)
1338 {
1339         ps_dbg_ex_co(_ps_modem_ref_co_modem(modem_data), "Entered");
1340
1341         g_signal_connect(modem,
1342                         "handle-get-properties",
1343                         G_CALLBACK(on_modem_get_properties),
1344                         modem_data);
1345
1346         g_signal_connect(modem,
1347                         "handle-get-services",
1348                         G_CALLBACK(on_modem_get_services),
1349                         modem_data);
1350
1351         g_signal_connect(modem,
1352                         "handle-go-dormant-all",
1353                         G_CALLBACK(on_modem_go_dormant_all),
1354                         modem_data);
1355
1356         g_signal_connect(modem,
1357                         "handle-get-profile-list",
1358                         G_CALLBACK(on_modem_get_profile_list),
1359                         modem_data);
1360
1361         g_signal_connect(modem,
1362                         "handle-add-profile",
1363                         G_CALLBACK(on_modem_add_profile),
1364                         modem_data);
1365
1366         g_signal_connect(modem,
1367                         "handle-reset-profile",
1368                         G_CALLBACK(on_modem_reset_profile),
1369                         modem_data);
1370
1371         return;
1372 }
1373