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