src/tapi_network.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include "tapi_common.h"
  26 #include "TapiUtility.h"
  27 #include "TelNetwork.h"
  28
  29 #include "common.h"
  30 #include "tapi_log.h"
  31 #include "ITapiNetwork.h"
  32
  33 static int _convert_act_to_systemtype(int act)
  34 {
  35         switch (act) {
  36                 case 0x1:
  37                         return TAPI_NETWORK_SYSTEM_GSM;
  38                         break;
  39
  40                 case 0x2:
  41                         return TAPI_NETWORK_SYSTEM_GPRS;
  42                         break;
  43
  44                 case 0x3:
  45                         return TAPI_NETWORK_SYSTEM_EGPRS;
  46                         break;
  47
  48                 case 0x4:
  49                         return TAPI_NETWORK_SYSTEM_UMTS;
  50                         break;
  51
  52                 case 0x5:
  53                         return TAPI_NETWORK_SYSTEM_GSM_AND_UMTS;
  54                         break;
  55
  56                 case 0x11:
  57                         return TAPI_NETWORK_SYSTEM_IS95A;
  58                         break;
  59
  60                 case 0x12:
  61                         return TAPI_NETWORK_SYSTEM_IS95B;
  62                         break;
  63
  64                 case 0x13:
  65                         return TAPI_NETWORK_SYSTEM_CDMA_1X;
  66                         break;
  67
  68                 case 0x14:
  69                         return TAPI_NETWORK_SYSTEM_EVDO_REV_0;
  70                         break;
  71
  72                 case 0x15:
  73                         return TAPI_NETWORK_SYSTEM_1X_EVDO_REV_0_HYBRID;
  74                         break;
  75
  76                 case 0x16:
  77                         return TAPI_NETWORK_SYSTEM_EVDO_REV_A;
  78                         break;
  79
  80                 case 0x17:
  81                         return TAPI_NETWORK_SYSTEM_1X_EVDO_REV_A_HYBRID;
  82                         break;
  83
  84                 case 0x18:
  85                         return TAPI_NETWORK_SYSTEM_EVDV;
  86                         break;
  87
  88                 default:
  89                         break;
  90         }
  91
  92         return TAPI_NETWORK_SYSTEM_NO_SRV;
  93 }
  94
  95 static void on_response_search_network(GObject *source_object, GAsyncResult *res, gpointer user_data)
  96 {
  97         GError *error = NULL;
  98         GDBusConnection *conn = NULL;
  99         struct tapi_resp_data *evt_cb_data = user_data;
 100         int result = -1;
 101         int i;
 102
 103         TelNetworkPlmnList_t list;
 104
 105         GVariant *dbus_result = NULL;
 106         GVariant *value = NULL;
 107         GVariantIter *iter = NULL;
 108         GVariantIter *iter_row = NULL;
 109         const gchar *key = NULL;
 110
 111         memset(&list, 0, sizeof(TelNetworkPlmnList_t));
 112
 113         conn = G_DBUS_CONNECTION (source_object);
 114
 115         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 116         if (!dbus_result) {
 117                 if (evt_cb_data->cb_fn) {
 118                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 119                 }
 120                 return;
 121         }
 122
 123         g_variant_get (dbus_result, "(aa{sv}i)", &iter, &result);
 124
 125         list.networks_count = g_variant_iter_n_children(iter);
 126
 127         i = 0;
 128         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 129                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 130                         if (!g_strcmp0(key, "plmn")) {
 131                                 list.network_list[i].plmn_id = atoi(g_variant_get_string(value, NULL));
 132                         }
 133                         if (!g_strcmp0(key, "act")) {
 134                                 list.network_list[i].access_technology = _convert_act_to_systemtype(g_variant_get_int32(value));
 135                         }
 136                         if (!g_strcmp0(key, "type")) {
 137                                 list.network_list[i].type_of_plmn = g_variant_get_int32(value);
 138                         }
 139                         if (!g_strcmp0(key, "name")) {
 140                                 strncpy(list.network_list[i].network_name, g_variant_get_string(value, NULL), 40);
 141                         }
 142                 }
 143                 i++;
 144                 g_variant_iter_free(iter_row);
 145         }
 146         g_variant_iter_free(iter);
 147
 148         if (evt_cb_data->cb_fn) {
 149                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 150         }
 151 }
 152
 153 static void on_response_get_network_selection_mode(GObject *source_object, GAsyncResult *res, gpointer user_data)
 154 {
 155         GError *error = NULL;
 156         GDBusConnection *conn = NULL;
 157         struct tapi_resp_data *evt_cb_data = user_data;
 158         int result = -1;
 159
 160         GVariant *dbus_result;
 161         int mode = 0;
 162
 163         conn = G_DBUS_CONNECTION (source_object);
 164         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 165
 166         g_variant_get (dbus_result, "(ii)", &mode, &result);
 167
 168         if (evt_cb_data->cb_fn) {
 169                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &mode, evt_cb_data->user_data);
 170         }
 171 }
 172
 173 static void on_response_default_set(GObject *source_object, GAsyncResult *res, gpointer user_data)
 174 {
 175         GError *error = NULL;
 176         GDBusConnection *conn = NULL;
 177         struct tapi_resp_data *evt_cb_data = user_data;
 178         int result = -1;
 179
 180         GVariant *dbus_result;
 181
 182         conn = G_DBUS_CONNECTION (source_object);
 183         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 184
 185         g_variant_get (dbus_result, "(i)", &result);
 186
 187         if (evt_cb_data->cb_fn) {
 188                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 189         }
 190 }
 191
 192 static void on_response_get_network_preferred_plmn(GDBusConnection *conn, GAsyncResult *res, gpointer user_data)
 193 {
 194         GError *error = NULL;
 195         struct tapi_resp_data *evt_cb_data = user_data;
 196         int result = -1;
 197         int i;
 198
 199         TelNetworkPreferredPlmnList_t list;
 200
 201         GVariant *dbus_result = NULL;
 202         GVariant *value = NULL;
 203         GVariantIter *iter = NULL;
 204         GVariantIter *iter_row = NULL;
 205         const gchar *key = NULL;
 206
 207         memset(&list, 0, sizeof(TelNetworkPreferredPlmnList_t));
 208
 209         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 210
 211         dbg("dbus_result = %p", dbus_result);
 212         dbg("res = %p", res);
 213         dbg("conn = %p", conn);
 214
 215         if (!dbus_result) {
 216                 dbg("error");
 217                 if (evt_cb_data->cb_fn) {
 218                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 219                 }
 220                 return;
 221         }
 222
 223         g_variant_get (dbus_result, "(aa{sv}i)", &iter, &result);
 224
 225         list.NumOfPrefPlmns = g_variant_iter_n_children(iter);
 226
 227         if (list.NumOfPrefPlmns == 0) {
 228                 dbg("num_of_.. = 0");
 229                 if (evt_cb_data->cb_fn) {
 230                         evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 231                 }
 232                 return;
 233         }
 234
 235         i = 0;
 236         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 237                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 238                         if (!g_strcmp0(key, "plmn")) {
 239                                 strncpy(list.PrefPlmnRecord[i].Plmn, g_variant_get_string(value, NULL), 6);
 240                         }
 241                         if (!g_strcmp0(key, "act")) {
 242                                 list.PrefPlmnRecord[i].SystemType = _convert_act_to_systemtype(g_variant_get_int32(value));
 243                         }
 244                         if (!g_strcmp0(key, "ef_index")) {
 245                                 list.PrefPlmnRecord[i].Index = g_variant_get_int32(value);
 246                         }
 247                         if (!g_strcmp0(key, "name")) {
 248                                 strncpy(list.PrefPlmnRecord[i].network_name, g_variant_get_string(value, NULL), 40);
 249                         }
 250                 }
 251                 i++;
 252                 g_variant_iter_free(iter_row);
 253         }
 254         g_variant_iter_free(iter);
 255
 256         if (evt_cb_data->cb_fn) {
 257                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 258         }
 259 }
 260
 261 static void on_response_get_network_band(GObject *source_object, GAsyncResult *res, gpointer user_data)
 262 {
 263         GError *error = NULL;
 264         GDBusConnection *conn = NULL;
 265         struct tapi_resp_data *evt_cb_data = user_data;
 266         int result = -1;
 267
 268         GVariant *dbus_result;
 269         int band = 0;
 270         int mode = 0;
 271
 272         conn = G_DBUS_CONNECTION (source_object);
 273         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 274
 275         g_variant_get (dbus_result, "(iii)", &band, &mode, &result);
 276
 277         if (evt_cb_data->cb_fn) {
 278                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &band, evt_cb_data->user_data);
 279         }
 280 }
 281
 282 static void on_response_get_network_mode(GObject *source_object, GAsyncResult *res, gpointer user_data)
 283 {
 284         GError *error = NULL;
 285         GDBusConnection *conn = NULL;
 286         struct tapi_resp_data *evt_cb_data = user_data;
 287         int result = -1;
 288
 289         GVariant *dbus_result;
 290         int mode = 0;
 291
 292         conn = G_DBUS_CONNECTION (source_object);
 293         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 294
 295         g_variant_get (dbus_result, "(ii)", &mode, &result);
 296
 297         if (evt_cb_data->cb_fn) {
 298                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &mode, evt_cb_data->user_data);
 299         }
 300 }
 301
 302 static void on_response_get_network_service_domain(GObject *source_object, GAsyncResult *res, gpointer user_data)
 303 {
 304         GError *error = NULL;
 305         GDBusConnection *conn = NULL;
 306         struct tapi_resp_data *evt_cb_data = user_data;
 307         int result = -1;
 308
 309         GVariant *dbus_result;
 310         int domain = 0;
 311
 312         conn = G_DBUS_CONNECTION (source_object);
 313         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 314
 315         g_variant_get (dbus_result, "(ii)", &domain, &result);
 316
 317         if (evt_cb_data->cb_fn) {
 318                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &domain, evt_cb_data->user_data);
 319         }
 320 }
 321
 322 static void on_response_get_network_serving(GObject *source_object, GAsyncResult *res, gpointer user_data)
 323 {
 324         GError *error = NULL;
 325         GDBusConnection *conn = NULL;
 326         struct tapi_resp_data *evt_cb_data = user_data;
 327         int result = -1;
 328
 329         TelNetworkServing_t data;
 330
 331         GVariant *dbus_result;
 332         char *plmn;
 333
 334         memset(&data, 0, sizeof(TelNetworkServing_t));
 335
 336         conn = G_DBUS_CONNECTION (source_object);
 337         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 338
 339         g_variant_get (dbus_result, "(isii)",
 340                         &data.act,
 341                         &plmn,
 342                         &data.lac,
 343                         &result);
 344
 345         if (plmn) {
 346                 snprintf(data.plmn, 7, "%s", plmn);
 347                 free(plmn);
 348         }
 349
 350         if (evt_cb_data->cb_fn) {
 351                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &data, evt_cb_data->user_data);
 352         }
 353 }
 354
 355 EXPORT_API int tel_search_network(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 356 {
 357         struct tapi_resp_data *evt_cb_data = NULL;
 358
 359         dbg("Func Entrance");
 360
 361         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 362
 363         g_dbus_connection_call(handle->dbus_connection,
 364                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 365                         "Search", NULL, NULL,
 366                         G_DBUS_CALL_FLAGS_NONE, 60000, NULL,
 367                         on_response_search_network, evt_cb_data);
 368
 369         return TAPI_API_SUCCESS;
 370 }
 371
 372 EXPORT_API int tel_get_network_selection_mode(struct tapi_handle *handle, tapi_response_cb callback, void *user_data)
 373 {
 374         struct tapi_resp_data *evt_cb_data = NULL;
 375
 376         dbg("Func Entrance");
 377
 378         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 379
 380         g_dbus_connection_call(handle->dbus_connection,
 381                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 382                         "GetSelectionMode", NULL, NULL,
 383                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 384                         on_response_get_network_selection_mode, evt_cb_data);
 385
 386         return TAPI_API_SUCCESS;
 387 }
 388
 389 EXPORT_API int tel_select_network_automatic(struct tapi_handle *handle, tapi_response_cb callback, void *user_data)
 390 {
 391         struct tapi_resp_data *evt_cb_data = NULL;
 392         GVariant *param;
 393
 394         dbg("Func Entrance");
 395
 396         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 397
 398         param = g_variant_new("(isi)",
 399                         0, /* Automatic */
 400                         "",
 401                         0);
 402
 403         g_dbus_connection_call(handle->dbus_connection,
 404                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 405                         "SetSelectionMode", param, NULL,
 406                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 407                         on_response_default_set, evt_cb_data);
 408
 409         return TAPI_API_SUCCESS;
 410 }
 411
 412 EXPORT_API int tel_select_network_manual(struct tapi_handle *handle, const char *plmn, int act, tapi_response_cb callback, void *user_data)
 413 {
 414         struct tapi_resp_data *evt_cb_data = NULL;
 415         GVariant *param;
 416
 417         dbg("Func Entrance");
 418
 419         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 420
 421         param = g_variant_new("(isi)",
 422                         1, /* Manual */
 423                         plmn,
 424                         act);
 425
 426         g_dbus_connection_call(handle->dbus_connection,
 427                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 428                         "SetSelectionMode", param, NULL,
 429                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 430                         on_response_default_set, evt_cb_data);
 431
 432         return TAPI_API_SUCCESS;
 433 }
 434
 435 EXPORT_API int tel_set_network_preferred_plmn(
 436                 TapiHandle *handle,
 437                 TelNetworkPreferredPlmnOp_t operation,
 438                 TelNetworkPreferredPlmnInfo_t *info,
 439                 tapi_response_cb callback,
 440                 void *user_data)
 441 {
 442         struct tapi_resp_data *evt_cb_data = NULL;
 443         GVariant *param;
 444         int act = 0;
 445
 446         dbg("Func Entrance");
 447
 448         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 449
 450         switch (info->SystemType) {
 451                 case TAPI_NETWORK_SYSTEM_GSM:
 452                         act = 1;
 453                         break;
 454
 455                 case TAPI_NETWORK_SYSTEM_UMTS:
 456                         act = 4;
 457                         break;
 458
 459                 case TAPI_NETWORK_SYSTEM_GPRS:
 460                         act = 2;
 461                         break;
 462
 463                 case TAPI_NETWORK_SYSTEM_EGPRS:
 464                         act = 3;
 465                         break;
 466
 467                 case TAPI_NETWORK_SYSTEM_GSM_AND_UMTS:
 468                         act = 4;
 469                         break;
 470
 471                 default:
 472                         act = 4;
 473                         break;
 474         }
 475
 476         param = g_variant_new("(iiis)",
 477                         operation,
 478                         info->Index,
 479                         act,
 480                         info->Plmn);
 481
 482         g_dbus_connection_call(handle->dbus_connection,
 483                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 484                         "SetPreferredPlmn", param, NULL,
 485                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 486                         on_response_default_set, evt_cb_data);
 487
 488         return TAPI_API_SUCCESS;
 489 }
 490
 491 EXPORT_API int tel_get_network_preferred_plmn(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 492 {
 493         struct tapi_resp_data *evt_cb_data = NULL;
 494
 495         dbg("Func Entrance");
 496
 497         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 498
 499         g_dbus_connection_call(handle->dbus_connection,
 500                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 501                         "GetPreferredPlmn", NULL, NULL,
 502                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 503                         (GAsyncReadyCallback) on_response_get_network_preferred_plmn, evt_cb_data);
 504
 505         return TAPI_API_SUCCESS;
 506 }
 507
 508 EXPORT_API int tel_set_network_band(TapiHandle *handle, TelNetworkBandPreferred_t mode, TelNetworkBand_t band, tapi_response_cb callback, void *user_data)
 509 {
 510         struct tapi_resp_data *evt_cb_data = NULL;
 511         GVariant *param;
 512
 513         dbg("Func Entrance");
 514
 515         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 516
 517         param = g_variant_new("(ii)",
 518                         band,
 519                         mode);
 520
 521         g_dbus_connection_call(handle->dbus_connection,
 522                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 523                         "SetBand", param, NULL,
 524                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 525                         on_response_default_set, evt_cb_data);
 526
 527         return TAPI_API_SUCCESS;
 528 }
 529
 530 EXPORT_API int tel_get_network_band(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 531 {
 532         struct tapi_resp_data *evt_cb_data = NULL;
 533
 534         dbg("Func Entrance");
 535
 536         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 537
 538         g_dbus_connection_call(handle->dbus_connection,
 539                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 540                         "GetBand", NULL, NULL,
 541                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 542                         on_response_get_network_band, evt_cb_data);
 543
 544         return TAPI_API_SUCCESS;
 545 }
 546
 547 EXPORT_API int tel_set_network_mode(TapiHandle *handle, int mode, tapi_response_cb callback, void *user_data)
 548 {
 549         struct tapi_resp_data *evt_cb_data = NULL;
 550         GVariant *param;
 551
 552         dbg("Func Entrance");
 553
 554         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 555
 556         param = g_variant_new("(i)",
 557                         mode);
 558
 559         g_dbus_connection_call(handle->dbus_connection,
 560                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 561                         "SetMode", param, NULL,
 562                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 563                         on_response_default_set, evt_cb_data);
 564
 565         return TAPI_API_SUCCESS;
 566 }
 567
 568 EXPORT_API int tel_get_network_mode(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 569 {
 570         struct tapi_resp_data *evt_cb_data = NULL;
 571
 572         dbg("Func Entrance");
 573
 574         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 575
 576         g_dbus_connection_call(handle->dbus_connection,
 577                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 578                         "GetMode", NULL, NULL,
 579                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 580                         on_response_get_network_mode, evt_cb_data);
 581
 582         return TAPI_API_SUCCESS;
 583 }
 584
 585 EXPORT_API int tel_set_network_service_domain(TapiHandle *handle, TelNetworkServiceDomain_t domain, tapi_response_cb callback, void *user_data)
 586 {
 587         struct tapi_resp_data *evt_cb_data = NULL;
 588         GVariant *param;
 589
 590         dbg("Func Entrance");
 591
 592         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 593
 594         param = g_variant_new("(i)", domain);
 595
 596         g_dbus_connection_call(handle->dbus_connection,
 597                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 598                         "SetServiceDomain", param, NULL,
 599                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 600                         on_response_default_set, evt_cb_data);
 601
 602         return TAPI_API_SUCCESS;
 603 }
 604
 605 EXPORT_API int tel_get_network_service_domain(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 606 {
 607         struct tapi_resp_data *evt_cb_data = NULL;
 608
 609         dbg("Func Entrance");
 610
 611         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 612
 613         g_dbus_connection_call(handle->dbus_connection,
 614                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 615                         "GetServiceDomain", NULL, NULL,
 616                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 617                         on_response_get_network_service_domain, evt_cb_data);
 618
 619         return TAPI_API_SUCCESS;
 620 }
 621
 622 EXPORT_API int tel_cancel_network_manual_search(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 623 {
 624         struct tapi_resp_data *evt_cb_data = NULL;
 625
 626         dbg("Func Entrance");
 627
 628         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 629
 630         g_dbus_connection_call(handle->dbus_connection,
 631                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 632                         "SearchCancel", NULL, NULL,
 633                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 634                         on_response_default_set, evt_cb_data);
 635
 636         return TAPI_API_SUCCESS;
 637 }
 638
 639 EXPORT_API int tel_get_network_serving(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 640 {
 641         struct tapi_resp_data *evt_cb_data = NULL;
 642
 643         dbg("Func Entrance");
 644
 645         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 646
 647         g_dbus_connection_call(handle->dbus_connection,
 648                         DBUS_TELEPHONY_SERVICE , handle->path, DBUS_TELEPHONY_NETWORK_INTERFACE,
 649                         "GetServingNetwork", NULL, NULL,
 650                         G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 651                         on_response_get_network_serving, evt_cb_data);
 652
 653         return TAPI_API_SUCCESS;
 654 }