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 #include "ps_common.h"
  23
  24 #include <tzplatform_config.h>
  25 #include <server.h>
  26 #include <plugin.h>
  27 #include <user_request.h>
  28 #include <core_object.h>
  29 #include <co_context.h>
  30 #include <co_ps.h>
  31 #include <co_network.h>
  32 #include "ps_log.h"
  33
  34 #include "ps_context.h"
  35 #include "ps_master.h"
  36 #include "ps_modem.h"
  37 #include "ps_service.h"
  38 #include "ps_tcore_interface.h"
  39 #include "ps_hook.h"
  40 #include "ps_modem_interface.h"
  41
  42
  43 static void __ps_modem_processing_modem_event(ps_modem_t *modem);
  44
  45
  46 void __remove_modem_handler(gpointer data)
  47 {
  48         ps_modem_t *modem = data;
  49
  50         if (!modem) {
  51                 warn("Modem is NULL");
  52                 return;
  53         }
  54
  55         ps_info_ex_modem(modem, "Entered");
  56
  57 #ifdef TIZEN_SUPPORT_REQUEST_HOOK_PDP_CONTROL
  58         _ps_hook_cp_reset_send_pending_request_response(modem);
  59 #endif
  60         /*Need to remove the compelete hash table*/
  61         g_hash_table_remove_all(modem->services);
  62
  63         /*Need to UNexport and Unref the master Object */
  64         g_dbus_interface_skeleton_unexport(G_DBUS_INTERFACE_SKELETON(modem->if_obj));
  65
  66         g_object_unref(modem->if_obj);
  67
  68         /*Need to free memory allocated for the internal structure*/
  69 #ifdef TIZEN_SUPPORT_REQUEST_HOOK_PDP_CONTROL
  70         g_queue_free(modem->work_queue);
  71
  72         if (modem->deact_timer_src > 0) {
  73                 ps_info_ex_modem(modem, "remove connection retry timer (%d)", modem->deact_timer_src);
  74                 alarmmgr_remove_alarm(modem->deact_timer_src);
  75                 modem->deact_timer_src = -1;
  76         }
  77 #endif
  78         g_free(modem->path);
  79         g_free(modem->operator);
  80         g_free(modem->cp_name);
  81
  82         _ps_modem_remove_profile_reset_gsource(modem);
  83
  84         g_free(modem);
  85
  86         dbg("Exiting");
  87 }
  88
  89 static void __ps_modem_create_service(GDBusConnection *conn, TcorePlugin *p,
  90                                       ps_modem_t *modem, CoreObject *co_modem)
  91 {
  92         gchar *t_path = NULL;
  93         ps_service_t *service = NULL;
  94         CoreObject *co_ps = NULL;
  95         CoreObject *co_network = NULL;
  96         TcorePlugin *target_plg = NULL;
  97
  98         target_plg = tcore_object_ref_plugin(co_modem);
  99         co_ps = tcore_plugin_ref_core_object(target_plg, CORE_OBJECT_TYPE_PS);
 100         co_network = tcore_plugin_ref_core_object(target_plg, CORE_OBJECT_TYPE_NETWORK);
 101         if (!co_ps || !co_network)
 102                 return;
 103
 104         t_path = g_strdup_printf("%s/%s", _ps_modem_ref_path(modem), "umts_ps");
 105         if (NULL != g_hash_table_lookup(modem->services, t_path)) {
 106                 ps_dbg_ex_modem(modem, "service (%s) already exist!!!", t_path);
 107                 g_free(t_path);
 108                 return;
 109         }
 110         ps_info_ex_modem(modem, "service path (%s)", t_path);
 111         service = _ps_service_create_service(conn, p, modem, co_network, co_ps, t_path);
 112         if (G_UNLIKELY(!service)) {
 113                 ps_err_ex_modem(modem, "Failed to create service ");
 114                 g_free(t_path);
 115                 return;
 116         }
 117
 118         g_hash_table_insert(modem->services, g_strdup(t_path), service);
 119         ps_dbg_ex_modem(modem, "service (%p) insert to hash", service);
 120         ps_modem_emit_service_added_signal(modem, service);
 121
 122         g_free(t_path);
 123 }
 124
 125 static void __ps_modem_remove_service(ps_modem_t *modem, ps_service_t *service)
 126 {
 127         ps_dbg_ex_modem(modem, "Entered");
 128
 129         /*Unexporting the interface for the modem*/
 130         if (service->if_obj) {
 131                 g_dbus_interface_skeleton_unexport(G_DBUS_INTERFACE_SKELETON(service->if_obj));
 132                 g_object_unref(service->if_obj);
 133                 service->if_obj = NULL;
 134         }
 135
 136         g_hash_table_remove(modem->services, _ps_service_ref_path(service));
 137         ps_info_ex_modem(modem, "Successfully removed the service from the modem");
 138 }
 139
 140 static gboolean __ps_modem_set_powered(ps_modem_t *modem, gboolean value)
 141 {
 142         g_return_val_if_fail(modem != NULL, FALSE);
 143
 144         if (modem->powered != value) {
 145                 modem->powered = value;
 146                 ps_info_ex_modem(modem, "modem(%p) powered(%d)", modem, modem->powered);
 147                 ps_modem_emit_property_changed_signal(modem);
 148         }
 149         return TRUE;
 150 }
 151
 152 static gboolean __ps_modem_set_sim_complete(ps_modem_t *modem, gboolean value, gchar *operator)
 153 {
 154         g_return_val_if_fail(modem != NULL, FALSE);
 155
 156         if (modem->sim_init != value) {
 157                 /* Update SIM init status */
 158                 modem->sim_init = value;
 159                 if (value && operator != NULL && !modem->operator)
 160                         modem->operator = g_strdup(operator);
 161                 ps_info_ex_modem(modem, "modem [%p] SIM-Init [%s]", modem, (modem->sim_init ? "INITIALIZED" : "UNINITIALIZED"));
 162
 163                 ps_modem_emit_property_changed_signal(modem);
 164         }
 165
 166         return TRUE;
 167 }
 168
 169 static gboolean __ps_modem_set_flght_mode(ps_modem_t *modem, gboolean value)
 170 {
 171         g_return_val_if_fail(modem != NULL, FALSE);
 172
 173         if (modem->flight_mode != value) {
 174                 modem->flight_mode = value;
 175                 ps_info_ex_modem(modem, "modem(%p) flight_mode(%d)", modem, modem->flight_mode);
 176                 ps_modem_emit_property_changed_signal(modem);
 177                 __ps_modem_processing_modem_event(modem);
 178         }
 179
 180         return TRUE;
 181 }
 182
 183 static void __ps_modem_get_ps_setting_from_storage(ps_modem_t *modem)
 184 {
 185         gboolean key_3g_enable = FALSE, key_roaming_allowed = FALSE;
 186         gint key_ps_mode = 0, key_roaming_apn = 0;
 187
 188         key_3g_enable = _ps_master_get_storage_value_bool(modem->p_master, KEY_3G_ENABLE);
 189         key_roaming_allowed = _ps_master_get_storage_value_bool(modem->p_master, KEY_DATA_ROAMING_SETTING);
 190         key_ps_mode = _ps_master_get_storage_value_int(modem->p_master, KEY_POWER_SAVING_MODE);
 191
 192         _ps_modem_set_data_allowed(modem, key_3g_enable);
 193         _ps_modem_set_data_roaming_allowed(modem, key_roaming_allowed);
 194         _ps_modem_set_data_roaming_apn(modem, key_roaming_apn);
 195
 196 #if defined(TIZEN_UPS_ENABLED)
 197         _ps_modem_set_psmode(modem, key_ps_mode);
 198 #endif
 199         ps_dbg_ex_modem(modem, "data allowed(%d) roaming allowed(%d) power saving mode(%d)",
 200                         key_3g_enable, key_roaming_allowed, key_ps_mode);
 201 }
 202
 203 static void __ps_modem_processing_modem_event(ps_modem_t *modem)
 204 {
 205         GHashTableIter iter;
 206         gpointer key, value;
 207 #ifdef PREPAID_SIM_APN_SUPPORT
 208         gboolean ret;
 209 #endif
 210
 211         g_return_if_fail(modem != NULL);
 212
 213         if (!modem->services)
 214                 return;
 215
 216         g_hash_table_iter_init(&iter, modem->services);
 217         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 218                 gboolean s_roaming = FALSE;
 219                 ps_service_t *service = value;
 220
 221                 s_roaming = _ps_service_get_roaming(service);
 222                 _ps_update_cellular_state_key(service);
 223
 224                 if (modem->powered == PS_MODEM_STATE_OFFLINE) {
 225                         _ps_service_remove_contexts(service);
 226                         _ps_free_co_ps_event(service);
 227                         _ps_free_co_network_event(service);
 228                         __ps_modem_remove_service(modem, service);
 229                         continue;
 230                 }
 231
 232                 if (modem->flight_mode) {
 233                         _ps_service_disconnect_contexts(service);
 234                         continue;
 235                 } else if (!modem->data_allowed || (s_roaming && !modem->roaming_allowed)) {
 236                         _ps_service_disconnect_internet_mms_tethering_contexts(service);
 237                         continue;
 238                 }
 239
 240                 /* only available case */
 241 #ifdef PREPAID_SIM_APN_SUPPORT
 242                 ret = _ps_service_connect_last_connected_context(service);
 243                 ps_dbg_ex_modem(modem, "ret[%d]", ret);
 244                 if (ret == TRUE)
 245                         return;  /* No need to activate default context */
 246 #endif
 247                 _ps_service_connect_default_context(service);
 248         }
 249 }
 250
 251 ps_modem_t *_ps_modem_create_modem(GDBusConnection *conn, TcorePlugin *p, ps_master_t *master,
 252                                    char *modem_name, CoreObject *co_modem, gchar *cp_name)
 253 {
 254         ps_modem_t *new_modem;
 255
 256         g_return_val_if_fail(conn != NULL, NULL);
 257         g_return_val_if_fail(master != NULL, NULL);
 258
 259         /*Initializing the modem list for internal referencing*/
 260         new_modem = g_try_malloc0(sizeof(ps_modem_t));
 261         if (G_UNLIKELY(!new_modem)) {
 262                 err("Unable to allocate memory for modem");
 263                 return NULL;
 264         }
 265
 266 #ifdef TIZEN_SUPPORT_REQUEST_HOOK_PDP_CONTROL
 267         /*Add work queue to keep user request in case of handling active PDP context*/
 268         new_modem->hook_flag = 0x00;
 269         new_modem->work_queue = g_queue_new();
 270         if (G_UNLIKELY(!new_modem->work_queue)) {
 271                 err("Unable to get work queue for modem");
 272                 g_free(new_modem);
 273                 return NULL;
 274         }
 275 #endif
 276         new_modem->conn = conn;
 277         new_modem->p_master = master;
 278         new_modem->plg = p;
 279         new_modem->co_modem = co_modem;
 280         new_modem->path = g_strdup(modem_name);
 281         new_modem->cp_name = g_strdup(cp_name);
 282         if (g_str_has_suffix(cp_name, "0"))
 283                 new_modem->subs_type = PS_SUBS_PRIMARY;
 284         else
 285                 new_modem->subs_type = PS_SUBS_SECONDARY;
 286         new_modem->services = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, __remove_service_handler);
 287
 288         __ps_modem_get_ps_setting_from_storage(new_modem);
 289         _ps_add_co_modem_event(new_modem);
 290         _ps_get_co_modem_values(new_modem);
 291
 292         /*Setting the interface call backs functions*/
 293         if (!ps_modem_setup_interface(new_modem)) {
 294                 g_free(new_modem);
 295                 return NULL;
 296         }
 297
 298         ps_info_ex_modem(new_modem, "Successfully created the modem");
 299         return new_modem;
 300 }
 301
 302 void _ps_modem_destroy_modem(GDBusConnection *conn, ps_modem_t *modem)
 303 {
 304         GHashTableIter iter;
 305         gpointer key, value;
 306         GSList *list = NULL;
 307         GSList *list_iter = NULL;
 308
 309         g_return_if_fail(modem != NULL);
 310
 311         if (modem->services == NULL)
 312                 return;
 313
 314         ps_dbg_ex_modem(modem, "Clearing all services");
 315         g_hash_table_iter_init(&iter, modem->services);
 316         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 317                 ps_service_t *service = value;
 318
 319                 /* Update Cellular state */
 320                 _ps_service_set_ps_attached(service, FALSE);
 321                 _ps_update_cellular_state_key(service);
 322
 323                 /* Remove contexts */
 324                 _ps_service_remove_contexts(service);
 325
 326                 /* Clear hooks */
 327                 _ps_free_co_ps_event(service);
 328                 _ps_free_co_network_event(service);
 329
 330                 /* To avoid hashtable assertion */
 331                 list = g_slist_append(list, service);
 332         }
 333
 334         for (list_iter = list; list_iter; list_iter = g_slist_next(list_iter)) {
 335                 /* Remove services */
 336                 __ps_modem_remove_service(modem, list_iter->data);
 337         }
 338         g_slist_free(list);
 339         g_slist_free(modem->contexts);
 340
 341         /* Clear modem hooks */
 342         _ps_free_co_modem_event(modem);
 343 }
 344 gboolean _ps_modem_processing_flight_mode(ps_modem_t *modem, gboolean enable)
 345 {
 346         g_return_val_if_fail(modem != NULL, FALSE);
 347
 348         if (modem->flight_mode == enable)
 349                 return TRUE;
 350
 351         __ps_modem_set_flght_mode(modem, enable);
 352         return TRUE;
 353 }
 354
 355 gboolean _ps_modem_processing_power_enable(ps_modem_t *modem, int modem_state)
 356 {
 357         g_return_val_if_fail(modem != NULL, FALSE);
 358
 359         ps_info_ex_modem(modem, "modem->powered [%d], Modem->sim_init [%d], modem_state [%d]",
 360                          modem->powered, modem->sim_init, modem_state);
 361
 362         if (modem->powered == modem_state)
 363                 return TRUE;
 364
 365         __ps_modem_set_powered(modem, modem_state);
 366
 367         if (modem_state == PS_MODEM_STATE_ONLINE) {
 368                 __ps_modem_create_service(modem->conn, modem->plg, modem, modem->co_modem);
 369                 if (modem->sim_init == TRUE && modem->operator != NULL) {
 370                         GSList *contexts = (GSList *)_ps_modem_ref_contexts(modem);
 371
 372                         if (contexts != NULL) {
 373                                 GHashTableIter iter;
 374                                 gpointer key, value;
 375                                 ps_warn_ex_modem(modem, "contexts exist, SIM init complete before Modem Power On event.");
 376                                 g_hash_table_iter_init(&iter, modem->services);
 377                                 while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 378                                         ps_service_t *service = value;
 379                                         _ps_service_set_number_of_pdn_cnt(service, modem->operator);
 380                                         _ps_service_ref_contexts(service, contexts, modem->operator);
 381 //                                      _ps_service_set_attach_apn(service);
 382                                 }
 383                         }
 384                 }
 385         } else if (modem_state == PS_MODEM_STATE_OFFLINE) {
 386                 __ps_modem_processing_modem_event(modem);
 387                 /* SIM init should be set to FALSE during CP silent reset.
 388                  * and will be updated when SIM initialized complete notification is received.
 389                  */
 390         }
 391         return TRUE;
 392 }
 393
 394 gboolean _ps_modem_processing_no_sim(ps_modem_t *modem)
 395 {
 396 #ifdef TIZEN_SUPPORT_VOLTE
 397         GSList *contexts = _ps_modem_ref_contexts(modem);
 398         g_return_val_if_fail(modem != NULL, FALSE);
 399
 400         if (contexts) {
 401                 ps_dbg_ex_modem(modem, "Contexts exits");
 402                 return FALSE;
 403         }
 404
 405         ps_dbg_ex_modem(modem, "Entered");
 406
 407         if (!modem->operator)
 408                 modem->operator = g_strdup(PS_IMS_EMERGENCY_PROFILE_PLMN);
 409
 410         ps_dbg_ex_modem(modem, "Creating Hash table...");
 411         contexts = _ps_context_create_hashtable(modem, modem->roaming);
 412         if (contexts != NULL) {
 413                 GHashTableIter iter;
 414                 gpointer key, value;
 415
 416                 g_hash_table_iter_init(&iter, modem->services);
 417                 while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 418                         ps_service_t *service = value;
 419                         _ps_service_set_number_of_pdn_cnt(service, modem->operator);
 420                         _ps_service_ref_contexts(service, contexts, modem->operator);
 421                         _ps_service_set_attach_apn(service);
 422                 }
 423         } else {
 424                 ps_err_ex_modem(modem, "Failed to create HASH table");
 425                 return FALSE;
 426         }
 427
 428         ps_dbg_ex_modem(modem, "Exiting");
 429 #endif
 430         return TRUE;
 431 }
 432
 433 gboolean _ps_modem_processing_sim_complete(ps_modem_t *modem, gboolean complete, gchar *operator)
 434 {
 435         g_return_val_if_fail(modem != NULL, FALSE);
 436
 437         ps_dbg_ex_modem(modem, "Entered: sim_init[%d]", modem->sim_init);
 438
 439         if (modem->sim_init == complete && !modem->reset_profile) {
 440 #ifdef TIZEN_SUPPORT_VOLTE
 441                 GSList *contexts = (GSList *)_ps_modem_ref_contexts(modem);
 442
 443                 ps_dbg_ex_modem(modem, "No change in SIM state");
 444
 445                 if (contexts != NULL) {
 446                         GHashTableIter iter;
 447                         gpointer key, value;
 448                         ps_warn_ex_modem(modem, "contexts exist, SIM init complete before Modem Power On event.");
 449                         g_hash_table_iter_init(&iter, modem->services);
 450                         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 451                                 ps_service_t *service = value;
 452                                 _ps_service_set_number_of_pdn_cnt(service, modem->operator);
 453                                 _ps_service_ref_contexts(service, contexts, modem->operator);
 454                                 _ps_service_set_attach_apn(service);
 455                         }
 456                 }
 457                 return TRUE;
 458 #else
 459                 ps_dbg_ex_modem(modem, "No change in SIM state");
 460                 return TRUE;
 461 #endif
 462         } else {
 463                 gboolean different_sim = FALSE;
 464
 465                 if (operator && (g_strcmp0(modem->operator, operator) != 0)) {
 466                         ps_info_ex_modem(modem, "Previous operator: [%s] Present operator: [%s]", modem->operator, operator);
 467                         g_free(modem->operator);
 468
 469                         modem->operator = g_strdup(operator);
 470                         different_sim = TRUE;
 471                 }
 472
 473
 474                 /* free modem operator */
 475                 if (FALSE == complete) {
 476                         g_free(modem->operator);
 477                         modem->operator = NULL;
 478                 }
 479
 480                 /* Update SIM state */
 481                 __ps_modem_set_sim_complete(modem, complete, operator);
 482                 /* Tizen Telephony makes dummy profile for CDMA by default */
 483                 _ps_context_create_cdma_profile(modem->operator, modem->cp_name);
 484
 485                 /* Modem power off notification coming due to which profile are removed */
 486                 /* and needed to be re inserted in db with sim off notification  */
 487                 /*
 488                  * Context table creation
 489                  *
 490                  * Create context if -
 491                  *      SIM is initiatized
 492                  * Initialzed SIM is different (if same SIM is re-initialized then need not create context)
 493                  * Delete context if sim_init = FALSE;
 494                  * This will be coming when SIM power off or CARD error is received.
 495                  */
 496                 if (modem->sim_init == TRUE) {
 497                         if ((different_sim || modem->reset_profile) && (modem->operator != NULL)) {
 498
 499                                 GSList *contexts = (GSList *)_ps_modem_ref_contexts(modem);
 500                                 if (contexts) {
 501                                         ps_dbg_ex_modem(modem, "Contexts exits");
 502                                         return FALSE;
 503                                 }
 504
 505                                 ps_dbg_ex_modem(modem, "Creating Hash table...");
 506                                 contexts = _ps_context_create_hashtable(modem, modem->roaming);
 507                                 if (contexts != NULL) {
 508                                         GHashTableIter iter;
 509                                         gpointer key, value;
 510
 511                                         g_hash_table_iter_init(&iter, modem->services);
 512                                         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 513                                                 ps_service_t *service = value;
 514                                                 ps_master_t *master = _ps_modem_ref_master(modem);
 515                                                 _ps_service_set_number_of_pdn_cnt(service, modem->operator);
 516                                                 _ps_service_ref_contexts(service, contexts, modem->operator);
 517                                                 if (master && master->b_lte_supported)
 518                                                         _ps_service_set_attach_apn(service);
 519                                         }
 520                                 } else {
 521                                         ps_err_ex_modem(modem, "Failed to create HASH table");
 522                                         return FALSE;
 523                                 }
 524                         }
 525                 } else {
 526                         GHashTableIter iter;
 527                         gpointer key, value;
 528
 529                         if (!modem->services)
 530                                 goto EXIT;
 531
 532                         g_hash_table_iter_init(&iter, modem->services);
 533                         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 534                                 ps_service_t *service = value;
 535                                 ps_info_ex_modem(modem, "Remove contexts on service(%p)", service);
 536                                 _ps_service_remove_contexts(service);
 537                         }
 538                 }
 539         }
 540  EXIT:
 541         ps_dbg_ex_modem(modem, "Exiting");
 542         return TRUE;
 543 }
 544
 545 gboolean _ps_modem_processing_sim_refresh(ps_modem_t *modem)
 546 {
 547 #ifdef TIZEN_SUPPORT_VOLTE
 548         GHashTableIter iter;
 549         gpointer key, value;
 550         unsigned int index;
 551
 552         ps_dbg_ex_modem(modem, "Entered");
 553         g_return_val_if_fail(modem != NULL, FALSE);
 554
 555         if (!modem->services)
 556                 goto EXIT;
 557
 558         g_hash_table_iter_init(&iter, modem->services);
 559         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 560                 ps_service_t *service = value;
 561                 for (index = 0; index < g_slist_length(service->contexts); index++) {
 562                         ps_context_t *context = g_slist_nth_data(service->contexts, index);
 563                         CoreObject *co_context = _ps_context_ref_co_context(context);
 564
 565                         if (tcore_context_get_role(co_context) == CONTEXT_ROLE_IMS) {
 566                                 gboolean ims_registered = FALSE, ims_deregistering = FALSE;
 567                                 struct tel_network_ims_registration_info ims_reg_info = { 0, };
 568
 569                                 tcore_network_get_ims_reg_info(_ps_service_ref_co_network(service), &ims_reg_info);
 570                                 if (ims_reg_info.feature_mask & NET_IMS_MASK_REGI)
 571                                         ims_registered = TRUE;
 572                                 ims_deregistering = tcore_network_get_ims_on_deregistering(_ps_service_ref_co_network(service));
 573
 574                                 ps_dbg_ex_svc(service, "ims_registered(%d), ims_deregistering(%d), context_state(%d), flight_mode(%d)",
 575                                               ims_registered, ims_deregistering, tcore_context_get_state(co_context), modem->flight_mode);
 576
 577                                 if (!modem->flight_mode) {
 578                                         if (ims_registered && !ims_deregistering) {
 579                                                 if (_ps_context_deregister_ims(context) == TCORE_RETURN_SUCCESS)
 580                                                         return TRUE;
 581                                         }
 582                                 }
 583                         }
 584                 }
 585         }
 586  EXIT:
 587 #endif
 588         ps_dbg_ex_modem(modem, "Exiting");
 589         return TRUE;
 590 }
 591
 592 gboolean _ps_modem_set_attach_apn(ps_modem_t *modem)
 593 {
 594         unsigned int index;
 595         GSList *contexts = NULL;
 596
 597         g_return_val_if_fail(modem != NULL, FALSE);
 598         contexts = (GSList *)_ps_modem_ref_contexts(modem);
 599         ps_dbg_ex_modem(modem, "Entered");
 600
 601         for (index = 0; index < g_slist_length(modem->contexts); index++) {
 602                 ps_context_t *context = g_slist_nth_data(modem->contexts, index);
 603                 ps_service_t *service = _ps_context_ref_service(context);
 604                 CoreObject *co_context = _ps_context_ref_co_context(context);
 605                 if (service == NULL)
 606                         continue;
 607                 tcore_ps_clear_context_id(_ps_service_ref_co_ps(service), co_context);
 608         }
 609
 610         if (contexts != NULL) {
 611                 GHashTableIter iter;
 612                 gpointer key, value;
 613                 ps_warn_ex_modem(modem, "contexts exist, Set attach apn");
 614                 g_hash_table_iter_init(&iter, modem->services);
 615                 while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 616                         ps_service_t *service = value;
 617                         _ps_service_set_number_of_pdn_cnt(service, modem->operator);
 618                         _ps_service_ref_contexts(service, contexts, modem->operator);
 619                         _ps_service_set_attach_apn(service);
 620                 }
 621         }
 622
 623         ps_dbg_ex_modem(modem, "Exiting");
 624         return TRUE;
 625
 626 }
 627
 628 int _ps_modem_get_data_roaming_apn(ps_modem_t *modem)
 629 {
 630         g_return_val_if_fail(modem != NULL, FALSE);
 631         return modem->roaming_apn;
 632 }
 633
 634 gboolean _ps_modem_set_data_roaming_apn(ps_modem_t *modem, int value)
 635 {
 636         g_return_val_if_fail(modem != NULL, FALSE);
 637
 638         if (modem->roaming_apn != value) {
 639                 modem->roaming_apn = value;
 640                 ps_info_ex_modem(modem, "modem(%p) roaming_apn(%d)", modem, modem->roaming_apn);
 641         }
 642
 643         return TRUE;
 644 }
 645
 646 gboolean _ps_modem_get_reset_profile(ps_modem_t *modem)
 647 {
 648         g_return_val_if_fail(modem != NULL, FALSE);
 649
 650         ps_info_ex_modem(modem, "modem(%p) reset_profile(%d)", modem, modem->reset_profile);
 651
 652         return modem->reset_profile;
 653 }
 654
 655 GSource *_ps_modem_get_profile_reset_gsource(ps_modem_t *modem)
 656 {
 657         g_return_val_if_fail(modem != NULL, NULL);
 658         return modem->reset_profile_gsource;
 659 }
 660
 661 gboolean _ps_modem_set_profile_reset_gsource(ps_modem_t *modem, GSource *source)
 662 {
 663         g_return_val_if_fail(modem != NULL, FALSE);
 664         modem->reset_profile_gsource = source;
 665         return TRUE;
 666 }
 667
 668 gboolean _ps_modem_remove_profile_reset_gsource(ps_modem_t *modem)
 669 {
 670         g_return_val_if_fail(modem != NULL, FALSE);
 671
 672         if (NULL != modem->reset_profile_gsource) {
 673                 g_source_unref(modem->reset_profile_gsource);
 674                 modem->reset_profile_gsource = NULL;
 675         }
 676
 677         return TRUE;
 678 }
 679
 680 gboolean _ps_modem_set_sim_enabled(ps_modem_t *modem, gboolean value)
 681 {
 682         g_return_val_if_fail(modem != NULL, FALSE);
 683
 684         if (modem->sim_init != value) {
 685                 modem->sim_init = value;
 686                 ps_info_ex_modem(modem, "modem(%p) sim_enabled(%d)", modem, modem->sim_init);
 687         }
 688         return TRUE;
 689 }
 690
 691 gboolean _ps_modem_connect_default_context(ps_modem_t *modem)
 692 {
 693         GHashTableIter iter;
 694         gpointer key, value;
 695
 696         g_return_val_if_fail(modem != NULL, FALSE);
 697
 698         g_hash_table_iter_init(&iter, modem->services);
 699         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
 700                 ps_service_t *service = value;
 701                 _ps_service_connect_default_context(service);
 702         }
 703
 704         return TRUE;
 705 }
 706
 707 gboolean _ps_modem_set_data_allowed(ps_modem_t *modem, gboolean value)
 708 {
 709         g_return_val_if_fail(modem != NULL, FALSE);
 710
 711         if (modem->data_allowed != value) {
 712                 modem->data_allowed = value;
 713                 ps_info_ex_modem(modem, "modem(%p) data allowed(%d)", modem, modem->data_allowed);
 714                 ps_modem_emit_property_changed_signal(modem);
 715                 __ps_modem_processing_modem_event(modem);
 716
 717                 if (modem->data_allowed) {
 718                         GHashTableIter iter;
 719                         gpointer key, service;
 720                         ps_context_t *def_context = NULL, *ims_context = NULL;
 721
 722                         g_hash_table_iter_init(&iter, modem->services);
 723                         while (g_hash_table_iter_next(&iter, &key, &service) == TRUE) {
 724                                 def_context = _ps_service_return_default_context(service, CONTEXT_ROLE_INTERNET);
 725                                 if (def_context)
 726                                         _ps_context_set_alwayson_enable(def_context, TRUE);
 727                                 ims_context = _ps_service_return_default_context(service, CONTEXT_ROLE_IMS);
 728                                 if (ims_context)
 729                                         _ps_context_set_alwayson_enable(ims_context, TRUE);
 730
 731                         }
 732                         __ps_modem_processing_modem_event(modem);
 733                 }
 734         }
 735
 736         return TRUE;
 737 }
 738
 739 gboolean _ps_modem_get_data_allowed(ps_modem_t *modem)
 740 {
 741         g_return_val_if_fail(modem != NULL, FALSE);
 742         return modem->data_allowed;
 743 }
 744
 745 gboolean _ps_modem_set_data_roaming_allowed(ps_modem_t *modem, gboolean roaming_allowed)
 746 {
 747         g_return_val_if_fail(modem != NULL, FALSE);
 748
 749         if (modem->roaming_allowed != roaming_allowed) {
 750                 modem->roaming_allowed = roaming_allowed;
 751                 ps_info_ex_modem(modem, "modem(%p) roaming allowed(%d)", modem, modem->roaming_allowed);
 752                 ps_modem_emit_property_changed_signal(modem);
 753
 754                 if (!modem->services)
 755                         return TRUE;
 756
 757                 if (modem->roaming) {
 758                         GHashTableIter iter;
 759                         gpointer key, service;
 760                         ps_context_t *def_context = NULL, *ims_context = NULL;
 761
 762                         g_hash_table_iter_init(&iter, modem->services);
 763                         while (g_hash_table_iter_next(&iter, &key, &service) == TRUE) {
 764                                 def_context = _ps_service_return_default_context(service, CONTEXT_ROLE_INTERNET);
 765                                 if (def_context)
 766                                         _ps_context_set_alwayson_enable(def_context, TRUE);
 767
 768                                 ims_context = _ps_service_return_default_context(service, CONTEXT_ROLE_IMS);
 769                                 if (ims_context)
 770                                         _ps_context_set_alwayson_enable(ims_context, TRUE);
 771                         }
 772                         __ps_modem_processing_modem_event(modem);
 773                 }
 774         }
 775
 776         return TRUE;
 777 }
 778
 779 gboolean _ps_modem_set_pm_state(ps_modem_t *modem, gint pm_state)
 780 {
 781         g_return_val_if_fail(modem != NULL, FALSE);
 782
 783         if (modem->pm_state != pm_state) {
 784                 modem->pm_state = pm_state;
 785                 ps_info_ex_modem(modem, "modem(%p) pm_state(%d)", modem, modem->pm_state);
 786
 787                 if (!modem->services)
 788                         return TRUE;
 789
 790                 if (modem->pm_state == 1) {
 791                         GHashTableIter iter;
 792                         gpointer key, service;
 793                         ps_context_t *def_context = NULL, *ims_context = NULL;
 794
 795                         g_hash_table_iter_init(&iter, modem->services);
 796                         while (g_hash_table_iter_next(&iter, &key, &service) == TRUE) {
 797                                 def_context = _ps_service_return_default_context(service, CONTEXT_ROLE_INTERNET);
 798                                 if (def_context && def_context->timer_src > 0) {
 799                                         ps_info_ex_modem(modem, "reset pdp retry timer (%d)", def_context->timer_src);
 800                                         _ps_service_set_retry_timeout_value(def_context, PDP_RETRY_TIME_OUT_DEFAULT);
 801                                         _ps_service_connection_timer(service, def_context);
 802                                 }
 803
 804                                 ims_context = _ps_service_return_default_context(service, CONTEXT_ROLE_IMS);
 805                                 if (ims_context && ims_context->timer_src > 0) {
 806                                         ps_info_ex_modem(modem, "reset pdp retry timer (%d)", ims_context->timer_src);
 807                                         _ps_service_set_retry_timeout_value(ims_context, PDP_RETRY_TIME_OUT_DEFAULT);
 808                                         _ps_service_connection_timer(service, ims_context);
 809                                 }
 810                         }
 811                 }
 812         }
 813
 814         return TRUE;
 815
 816 }
 817
 818 gboolean _ps_modem_set_psmode(ps_modem_t *modem, gint value)
 819 {
 820         g_return_val_if_fail(modem != NULL, FALSE);
 821
 822         if (modem->ps_mode != value) {
 823                 modem->ps_mode = value;
 824                 ps_info_ex_modem(modem, "modem(%p) power saving mode(%d)", modem, modem->ps_mode);
 825         }
 826
 827         return TRUE;
 828 }
 829
 830 gboolean _ps_modem_get_roaming(ps_modem_t *modem)
 831 {
 832         g_return_val_if_fail(modem != NULL, FALSE);
 833         return modem->roaming;
 834 }
 835
 836 void _ps_modem_set_roaming(ps_modem_t *modem, gboolean value)
 837 {
 838         g_return_if_fail(modem != NULL);
 839
 840         if (modem->roaming != value) {
 841                 modem->roaming = value;
 842                 ps_info_ex_modem(modem, "modem(%p) roaming(%d)", modem, modem->roaming);
 843         }
 844 }
 845
 846 gint _ps_modem_get_roaming_apn_support(ps_modem_t *modem)
 847 {
 848         g_return_val_if_fail(modem != NULL, FALSE);
 849         return modem->roaming_apn_support;
 850 }
 851
 852 void _ps_modem_set_roaming_apn_support(ps_modem_t *modem, gboolean value)
 853 {
 854         g_return_if_fail(modem != NULL);
 855         if (modem->roaming_apn_support != value) {
 856                 modem->roaming_apn_support = value;
 857                 ps_info_ex_modem(modem, "modem(%p) roaming_apn_support(%d)", modem, modem->roaming_apn_support);
 858         }
 859 }
 860
 861 gint _ps_modem_get_psmode(ps_modem_t *modem)
 862 {
 863         g_return_val_if_fail(modem != NULL, FALSE);
 864         return modem->ps_mode;
 865 }
 866
 867 gboolean _ps_modem_get_data_roaming_allowed(ps_modem_t *modem)
 868 {
 869         g_return_val_if_fail(modem != NULL, FALSE);
 870         return modem->roaming_allowed;
 871 }
 872
 873 gboolean _ps_modem_get_flght_mode(ps_modem_t *modem)
 874 {
 875         g_return_val_if_fail(modem != NULL, FALSE);
 876         return modem->flight_mode;
 877 }
 878
 879 gboolean _ps_modem_get_sim_init(ps_modem_t *modem)
 880 {
 881         g_return_val_if_fail(modem != NULL, FALSE);
 882         return modem->sim_init;
 883 }
 884
 885 gboolean _ps_modem_get_power(ps_modem_t *modem)
 886 {
 887         g_return_val_if_fail(modem != NULL, FALSE);
 888         return modem->powered;
 889 }
 890
 891 char *_ps_modem_ref_operator(ps_modem_t *modem)
 892 {
 893         g_return_val_if_fail(modem != NULL, FALSE);
 894         return modem->operator;
 895 }
 896
 897 ps_subs_type _ps_modem_get_subs_type(ps_modem_t *modem)
 898 {
 899         g_return_val_if_fail(modem != NULL, FALSE);
 900         return modem->subs_type;
 901 }
 902
 903 gboolean _ps_modem_get_properties_handler(ps_modem_t *modem, GVariantBuilder *properties)
 904 {
 905         g_return_val_if_fail(modem != NULL, FALSE);
 906         g_return_val_if_fail(properties != NULL, FALSE);
 907
 908         ps_info_ex_modem(modem, "get modem properties");
 909
 910         g_variant_builder_open(properties, G_VARIANT_TYPE("a{ss}"));
 911         g_variant_builder_add(properties, "{ss}", "path", modem->path);
 912
 913         if (modem->operator)
 914                 g_variant_builder_add(properties, "{ss}", "operator", modem->operator);
 915         g_variant_builder_add(properties, "{ss}", "powered", BOOL2STRING(modem->powered));
 916         g_variant_builder_add(properties, "{ss}", "sim_init", BOOL2STRING(modem->sim_init));
 917         g_variant_builder_add(properties, "{ss}", "flight_mode", BOOL2STRING(modem->flight_mode));
 918         g_variant_builder_add(properties, "{ss}", "roaming_allowed", BOOL2STRING(modem->roaming_allowed));
 919         g_variant_builder_add(properties, "{ss}", "data_allowed", BOOL2STRING(modem->data_allowed));
 920         g_variant_builder_close(properties);
 921
 922         return TRUE;
 923 }
 924
 925 GVariant *_ps_modem_get_properties(ps_modem_t *modem, GVariantBuilder *properties)
 926 {
 927         g_return_val_if_fail(modem != NULL, FALSE);
 928         g_return_val_if_fail(properties != NULL, FALSE);
 929
 930         ps_info_ex_modem(modem, "get modem properties");
 931
 932         g_variant_builder_init(properties, G_VARIANT_TYPE("a{ss}"));
 933         g_variant_builder_add(properties, "{ss}", "path", modem->path);
 934
 935         if (modem->operator)
 936                 g_variant_builder_add(properties, "{ss}", "operator", modem->operator);
 937         g_variant_builder_add(properties, "{ss}", "powered", BOOL2STRING(modem->powered));
 938         g_variant_builder_add(properties, "{ss}", "sim_init", BOOL2STRING(modem->sim_init));
 939         g_variant_builder_add(properties, "{ss}", "flight_mode", BOOL2STRING(modem->flight_mode));
 940         g_variant_builder_add(properties, "{ss}", "roaming_allowed", BOOL2STRING(modem->roaming_allowed));
 941         g_variant_builder_add(properties, "{ss}", "data_allowed", BOOL2STRING(modem->data_allowed));
 942
 943         return g_variant_builder_end(properties);
 944 }
 945
 946 ps_master_t *_ps_modem_ref_master(ps_modem_t *modem)
 947 {
 948         g_return_val_if_fail(modem != NULL, NULL);
 949         return modem->p_master;
 950 }
 951
 952 GHashTable *_ps_modem_ref_services(ps_modem_t *modem)
 953 {
 954         g_return_val_if_fail(modem != NULL, NULL);
 955         return modem->services;
 956 }
 957
 958 char *_ps_modem_ref_path(ps_modem_t *modem)
 959 {
 960         g_return_val_if_fail(modem != NULL, NULL);
 961         return modem->path;
 962 }
 963
 964 TcorePlugin *_ps_modem_ref_plugin(ps_modem_t *modem)
 965 {
 966         g_return_val_if_fail(modem != NULL, NULL);
 967         return modem->plg;
 968 }
 969
 970 GDBusConnection *_ps_modem_ref_dbusconn(ps_modem_t *modem)
 971 {
 972         g_return_val_if_fail(modem != NULL, NULL);
 973         return modem->conn;
 974 }
 975
 976 CoreObject *_ps_modem_ref_co_modem(ps_modem_t *modem)
 977 {
 978         g_return_val_if_fail(modem != NULL, NULL);
 979         return modem->co_modem;
 980 }
 981
 982 gchar *_ps_modem_ref_cp_name(ps_modem_t *modem)
 983 {
 984         g_return_val_if_fail(modem != NULL, NULL);
 985         return modem->cp_name;
 986 }
 987
 988 GSList *_ps_modem_ref_contexts(ps_modem_t *modem)
 989 {
 990         g_return_val_if_fail(modem != NULL, NULL);
 991         return modem->contexts;
 992 }