mobile/src/tapi_sim.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 "TelSim.h"
  28
  29 #include "common.h"
  30 #include "tapi_log.h"
  31 #include "ITapiSim.h"
  32
  33 static int _tel_check_tapi_state()
  34 {
  35         return 0;
  36 }
  37
  38 static int _tel_check_sim_state(TapiHandle *handle)
  39 {
  40         GError *gerr = NULL;
  41         GVariant *sync_gv = NULL;
  42         int api_err = TAPI_API_SUCCESS;
  43         TelSimCardStatus_t init_status = 0;
  44         int changed = FALSE;
  45
  46         sync_gv = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
  47                         handle->path, DBUS_TELEPHONY_SIM_INTERFACE, "GetInitStatus", NULL, NULL,
  48                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &gerr);
  49
  50         if (sync_gv) {
  51                 g_variant_get(sync_gv, "(ib)", &init_status, &changed);
  52                 dbg("init_status[%d]",init_status);
  53
  54                 switch(init_status){
  55                         case TAPI_SIM_STATUS_CARD_NOT_PRESENT :
  56                         case TAPI_SIM_STATUS_CARD_REMOVED :
  57                                 api_err = TAPI_API_SIM_NOT_FOUND;
  58                                 break;
  59                         case TAPI_SIM_STATUS_CARD_BLOCKED :
  60                         case TAPI_SIM_STATUS_CARD_ERROR :
  61                                 api_err = TAPI_API_SIM_CARD_ERROR;
  62                                 break;
  63                         case TAPI_SIM_STATUS_SIM_INITIALIZING :
  64                                 api_err = TAPI_API_SIM_NOT_INITIALIZED;
  65                                 break;
  66                         case TAPI_SIM_STATUS_SIM_INIT_COMPLETED :
  67                                 api_err = TAPI_API_SUCCESS;
  68                                 break;
  69                         case TAPI_SIM_STATUS_SIM_PIN_REQUIRED :
  70                         case TAPI_SIM_STATUS_SIM_PUK_REQUIRED :
  71                         case TAPI_SIM_STATUS_SIM_NCK_REQUIRED :
  72                         case TAPI_SIM_STATUS_SIM_NSCK_REQUIRED :
  73                         case TAPI_SIM_STATUS_SIM_SPCK_REQUIRED :
  74                         case TAPI_SIM_STATUS_SIM_CCK_REQUIRED :
  75                         case TAPI_SIM_STATUS_SIM_LOCK_REQUIRED :
  76                                 api_err = TAPI_API_SIM_LOCKED;
  77                                 break;
  78                         case TAPI_SIM_STATUS_UNKNOWN:
  79                                 api_err = TAPI_API_SERVICE_NOT_READY;
  80                                 break;
  81                         default:
  82                                 dbg("not handled status[%d] in here",init_status);
  83                                 break;
  84                 }
  85         } else {
  86                 dbg( "g_dbus_conn failed in _tel_check_sim_state. error (%s)", gerr->message);
  87                 g_error_free(gerr);
  88                 return TAPI_API_OPERATION_FAILED;
  89         }
  90         dbg("api_err[%d]", api_err);
  91         return api_err;
  92 }
  93
  94 static void on_response_get_sim_iccid(GObject *source_object, GAsyncResult *res, gpointer user_data)
  95 {
  96         GError *error = NULL;
  97         GDBusConnection *conn = NULL;
  98         GVariant *dbus_result;
  99
 100         struct tapi_resp_data *evt_cb_data = user_data;
 101         TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
 102         TelSimIccIdInfo_t iccid_info;
 103         gchar *iccid = NULL;
 104
 105         dbg("Func Entrance");
 106         memset(&iccid_info, 0, sizeof(TelSimIccIdInfo_t));
 107
 108         conn = G_DBUS_CONNECTION (source_object);
 109         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 110
 111         CHECK_DEINIT(error);
 112
 113         if (!dbus_result) {
 114                 if (evt_cb_data->cb_fn) {
 115                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 116                 }
 117
 118                 if (error)
 119                         g_error_free(error);
 120
 121                 free(evt_cb_data);
 122                 return;
 123         }
 124
 125         g_variant_get(dbus_result, "(is)", &result, &iccid);
 126         iccid_info.icc_length = strlen((const char*)iccid);
 127         if(iccid_info.icc_length > TAPI_SIM_ICCID_LEN_MAX){
 128                 dbg("current tapi support 20 byte but received length[%d] so changed");
 129                 iccid_info.icc_length = TAPI_SIM_ICCID_LEN_MAX;
 130         }
 131         memcpy(iccid_info.icc_num, iccid, iccid_info.icc_length);
 132
 133         if (evt_cb_data->cb_fn) {
 134                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &iccid_info, evt_cb_data->user_data);
 135         }
 136
 137         free(evt_cb_data);
 138 }
 139
 140 static void on_response_get_sim_language(GObject *source_object, GAsyncResult *res,
 141                 gpointer user_data)
 142 {
 143         GError *error = NULL;
 144         GDBusConnection *conn = NULL;
 145         GVariant *dbus_result;
 146
 147         struct tapi_resp_data *evt_cb_data = user_data;
 148         TelSimLanguagePreferenceCode_t lang = TAPI_SIM_LP_LANG_UNSPECIFIED;
 149         TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
 150
 151         dbg("Func Entrance");
 152         conn = G_DBUS_CONNECTION (source_object);
 153         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 154         CHECK_DEINIT(error);
 155
 156         if (!dbus_result) {
 157                 if (evt_cb_data->cb_fn) {
 158                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 159                 }
 160
 161                 if (error)
 162                         g_error_free(error);
 163
 164                 free(evt_cb_data);
 165                 return;
 166         }
 167
 168         g_variant_get(dbus_result, "(ii)", &result, &lang);
 169
 170         if (evt_cb_data->cb_fn) {
 171                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &lang, evt_cb_data->user_data);
 172         }
 173
 174         free(evt_cb_data);
 175 }
 176
 177 static void on_response_set_sim_language(GObject *source_object, GAsyncResult *res,
 178                 gpointer user_data)
 179 {
 180         GError *error = NULL;
 181         GDBusConnection *conn = NULL;
 182         GVariant *dbus_result;
 183
 184         struct tapi_resp_data *evt_cb_data = user_data;
 185         TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
 186
 187         dbg("Func Entrance");
 188         conn = G_DBUS_CONNECTION (source_object);
 189         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 190         CHECK_DEINIT(error);
 191
 192         if (!dbus_result) {
 193                 if (evt_cb_data->cb_fn) {
 194                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 195                 }
 196
 197                 if (error)
 198                         g_error_free(error);
 199
 200                 free(evt_cb_data);
 201                 return;
 202         }
 203
 204         g_variant_get(dbus_result, "(i)", &result);
 205
 206         if (evt_cb_data->cb_fn) {
 207                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 208         }
 209
 210         free(evt_cb_data);
 211 }
 212
 213 static void on_response_get_sim_callforwarding_info(GObject *source_object, GAsyncResult *res,
 214                 gpointer user_data)
 215 {
 216         GError *error = NULL;
 217         GDBusConnection *conn = NULL;
 218         GVariant *dbus_result;
 219         GVariant *value = NULL;
 220         GVariantIter *cphs_iter = NULL;
 221         GVariantIter *iter = NULL;
 222         GVariantIter *iter_row = NULL;
 223         const gchar *key = NULL;
 224         const gchar *str_value = NULL;
 225         struct tapi_resp_data *evt_cb_data = user_data;
 226         TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
 227         TelSimCallForwardingResp_t cf;
 228         int i =0;
 229
 230         memset(&cf, 0, sizeof(TelSimCallForwardingResp_t));
 231
 232         dbg("Func Entrance");
 233         conn = G_DBUS_CONNECTION (source_object);
 234         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 235         CHECK_DEINIT(error);
 236
 237         if (!dbus_result) {
 238                 if (evt_cb_data->cb_fn) {
 239                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 240                 }
 241
 242                 if (error)
 243                         g_error_free(error);
 244
 245                 free(evt_cb_data);
 246                 return;
 247         }
 248         dbg("dbus_result format(%s)", g_variant_get_type_string(dbus_result));
 249         g_variant_get(dbus_result, "(ibaa{sv}a{sv})", &result, &cf.b_cphs, &iter, &cphs_iter);
 250
 251         if( cf.b_cphs ) {
 252                 while (g_variant_iter_loop(cphs_iter, "{sv}", &key, &value)) {
 253                         if (!g_strcmp0(key, "b_line1")) {
 254                                 cf.cphs_cf.b_line1 = g_variant_get_boolean(value);
 255                         }
 256                         if (!g_strcmp0(key, "b_line2")) {
 257                                 cf.cphs_cf.b_line2 = g_variant_get_boolean(value);
 258                         }
 259                         if (!g_strcmp0(key, "b_fax")) {
 260                                 cf.cphs_cf.b_fax = g_variant_get_boolean(value);
 261                         }
 262                         if (!g_strcmp0(key, "b_data")) {
 263                                 cf.cphs_cf.b_data = g_variant_get_boolean(value);
 264                         }
 265                 }
 266         } else {
 267                 cf.cf_list.profile_count = g_variant_iter_n_children(iter);
 268
 269                 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 270                         while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 271                                 if (!g_strcmp0(key, "rec_index")) {
 272                                         cf.cf_list.cf[i].rec_index = g_variant_get_int32(value);
 273                                 }
 274                                 if (!g_strcmp0(key, "msp_num")) {
 275                                         cf.cf_list.cf[i].msp_num = g_variant_get_byte(value);
 276                                 }
 277                                 if (!g_strcmp0(key, "cfu_status")) {
 278                                         cf.cf_list.cf[i].cfu_status = g_variant_get_byte(value);
 279                                 }
 280                                 if (!g_strcmp0(key, "cfu_num")) {
 281                                         str_value = g_variant_get_string(value, NULL);
 282                                         snprintf(cf.cf_list.cf[i].cfu_num, strlen((const char*) str_value) + 1, "%s", str_value);
 283                                 }
 284                                 if (!g_strcmp0(key, "ton")) {
 285                                         cf.cf_list.cf[i].ton = g_variant_get_int32(value);
 286                                 }
 287                                 if (!g_strcmp0(key, "npi")) {
 288                                         cf.cf_list.cf[i].npi = g_variant_get_int32(value);
 289                                 }
 290                                 if (!g_strcmp0(key, "cc2_id")) {
 291                                         cf.cf_list.cf[i].cc2_id = g_variant_get_byte(value);
 292                                 }
 293                                 if (!g_strcmp0(key, "ext7_id")) {
 294                                         cf.cf_list.cf[i].ext7_id = g_variant_get_byte(value);
 295                                 }
 296                         }
 297                         i++;
 298                         g_variant_iter_free(iter_row);
 299                 }
 300                 g_variant_iter_free(iter);
 301         }
 302
 303         if (evt_cb_data->cb_fn) {
 304                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &cf, evt_cb_data->user_data);
 305         }
 306
 307         free(evt_cb_data);
 308 }
 309
 310 static void on_response_set_sim_callforwarding_info(GObject *source_object, GAsyncResult *res,
 311                 gpointer user_data)
 312 {
 313         GError *error = NULL;
 314         GDBusConnection *conn = NULL;
 315         GVariant *dbus_result;
 316
 317         struct tapi_resp_data *evt_cb_data = user_data;
 318         TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
 319
 320         dbg("Func Entrance");
 321         conn = G_DBUS_CONNECTION (source_object);
 322         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 323         CHECK_DEINIT(error);
 324
 325         if (!dbus_result) {
 326                 if (evt_cb_data->cb_fn) {
 327                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 328                 }
 329
 330                 if (error)
 331                         g_error_free(error);
 332
 333                 free(evt_cb_data);
 334                 return;
 335         }
 336
 337         g_variant_get(dbus_result, "(i)", &result);
 338
 339         if (evt_cb_data->cb_fn) {
 340                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 341         }
 342
 343         free(evt_cb_data);
 344 }
 345
 346
 347 static void on_response_get_sim_messagewaiting_info(GObject *source_object, GAsyncResult *res,
 348                 gpointer user_data)
 349 {
 350         GError *error = NULL;
 351         GDBusConnection *conn = NULL;
 352         GVariant *dbus_result;
 353         GVariant *value = NULL;
 354         GVariantIter *cphs_iter = NULL;
 355         GVariantIter *iter = NULL;
 356         GVariantIter *iter_row = NULL;
 357         const gchar *key = NULL;
 358         struct tapi_resp_data *evt_cb_data = user_data;
 359         TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
 360         TelSimMessageWaitingResp_t mw;
 361         int i =0;
 362
 363         dbg("Func Entrance");
 364         memset(&mw, 0, sizeof(TelSimMessageWaitingResp_t));
 365
 366         conn = G_DBUS_CONNECTION (source_object);
 367         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 368         CHECK_DEINIT(error);
 369
 370         if (!dbus_result) {
 371                 if (evt_cb_data->cb_fn) {
 372                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 373                 }
 374
 375                 if (error)
 376                         g_error_free(error);
 377
 378                 free(evt_cb_data);
 379                 return;
 380         }
 381
 382         dbg("dbus_result format(%s)", g_variant_get_type_string(dbus_result));
 383         g_variant_get(dbus_result, "(ibaa{sv}a{sv})", &result, &mw.b_cphs, &iter, &cphs_iter);
 384
 385         if( mw.b_cphs ) {
 386                 while (g_variant_iter_loop(cphs_iter, "{sv}", &key, &value)) {
 387                         if (!g_strcmp0(key, "b_voice1")) {
 388                                 mw.cphs_mw.b_voice1 = g_variant_get_boolean(value);
 389                         }
 390                         if (!g_strcmp0(key, "b_voice2")) {
 391                                 mw.cphs_mw.b_voice2 = g_variant_get_boolean(value);
 392                         }
 393                         if (!g_strcmp0(key, "b_fax")) {
 394                                 mw.cphs_mw.b_fax = g_variant_get_boolean(value);
 395                         }
 396                         if (!g_strcmp0(key, "b_data")) {
 397                                 mw.cphs_mw.b_data = g_variant_get_boolean(value);
 398                         }
 399                 }
 400
 401         } else {
 402                 mw.mw_list.profile_count = g_variant_iter_n_children(iter);
 403
 404                 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 405                         while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 406                                 if (!g_strcmp0(key, "rec_index")) {
 407                                         mw.mw_list.mw[i].rec_index = g_variant_get_int32(value);
 408                                 }
 409                                 if (!g_strcmp0(key, "indicator_status")) {
 410                                         mw.mw_list.mw[i].indicator_status = g_variant_get_byte(value);
 411                                 }
 412                                 if (!g_strcmp0(key, "voice_count")) {
 413                                         mw.mw_list.mw[i].voice_count = g_variant_get_int32(value);
 414                                 }
 415                                 if (!g_strcmp0(key, "fax_count")) {
 416                                         mw.mw_list.mw[i].fax_count = g_variant_get_int32(value);
 417                                 }
 418                                 if (!g_strcmp0(key, "email_count")) {
 419                                         mw.mw_list.mw[i].email_count = g_variant_get_int32(value);
 420                                 }
 421                                 if (!g_strcmp0(key, "other_count")) {
 422                                         mw.mw_list.mw[i].other_count = g_variant_get_int32(value);
 423                                 }
 424                                 if (!g_strcmp0(key, "video_count")) {
 425                                         mw.mw_list.mw[i].video_count = g_variant_get_int32(value);
 426                                 }
 427                         }
 428                         i++;
 429                         g_variant_iter_free(iter_row);
 430                 }
 431                 g_variant_iter_free(iter);
 432         }
 433
 434         if (evt_cb_data->cb_fn) {
 435                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &mw, evt_cb_data->user_data);
 436         }
 437
 438         free(evt_cb_data);
 439 }
 440
 441 static void on_response_set_sim_messagewaiting_info(GObject *source_object, GAsyncResult *res,
 442                 gpointer user_data)
 443 {
 444         GError *error = NULL;
 445         GDBusConnection *conn = NULL;
 446         GVariant *dbus_result;
 447
 448         struct tapi_resp_data *evt_cb_data = user_data;
 449         TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
 450
 451         dbg("Func Entrance");
 452         conn = G_DBUS_CONNECTION (source_object);
 453         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 454         CHECK_DEINIT(error);
 455
 456         if (!dbus_result) {
 457                 if (evt_cb_data->cb_fn) {
 458                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 459                 }
 460
 461                 if (error)
 462                         g_error_free(error);
 463
 464                 free(evt_cb_data);
 465                 return;
 466         }
 467
 468         g_variant_get(dbus_result, "(i)", &result);
 469
 470         if (evt_cb_data->cb_fn) {
 471                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 472         }
 473
 474         free(evt_cb_data);
 475 }
 476
 477 static void on_response_get_sim_mailbox_info(GObject *source_object, GAsyncResult *res,
 478                 gpointer user_data)
 479 {
 480         GError *error = NULL;
 481         GDBusConnection *conn = NULL;
 482         GVariant *dbus_result;
 483         GVariant *value = NULL;
 484         GVariantIter *iter = NULL;
 485         GVariantIter *iter_row = NULL;
 486         const gchar *key = NULL;
 487         const gchar *str_value = NULL;
 488         struct tapi_resp_data *evt_cb_data = user_data;
 489         TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
 490         TelSimMailboxList_t list;
 491         int i = 0;
 492         gboolean b_cphs = 0;
 493
 494         dbg("Func Entrance");
 495         memset(&list, 0, sizeof(TelSimMailboxList_t));
 496
 497         conn = G_DBUS_CONNECTION (source_object);
 498         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 499         CHECK_DEINIT(error);
 500
 501         if (!dbus_result) {
 502                 if (evt_cb_data->cb_fn) {
 503                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 504                 }
 505
 506                 if (error)
 507                         g_error_free(error);
 508
 509                 free(evt_cb_data);
 510                 return;
 511         }
 512
 513         g_variant_get(dbus_result, "(ibaa{sv})", &result, &b_cphs, &iter);
 514         list.count = g_variant_iter_n_children(iter);
 515
 516         i = 0;
 517         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 518                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 519                         list.list[i].b_cphs = b_cphs;
 520
 521                         if (!g_strcmp0(key, "rec_index")) {
 522                                 list.list[i].rec_index = g_variant_get_int32(value);
 523                         }
 524                         if (!g_strcmp0(key, "profile_num")) {
 525                                 list.list[i].profile_num = g_variant_get_int32(value);
 526                         }
 527                         if (!g_strcmp0(key, "mb_type")) {
 528                                 list.list[i].mb_type = g_variant_get_int32(value);
 529                         }
 530                         if (!g_strcmp0(key, "alpha_id_max_len")) {
 531                                 list.list[i].alpha_id_max_len = g_variant_get_int32(value);
 532                         }
 533                         if (!g_strcmp0(key, "alpha_id")) {
 534                                 str_value = g_variant_get_string(value, NULL);
 535                                 snprintf(list.list[i].alpha_id, strlen((const char*)str_value) + 1, "%s", str_value);
 536                         }
 537                         if (!g_strcmp0(key, "ton")) {
 538                                 list.list[i].ton = g_variant_get_int32(value);
 539                         }
 540                         if (!g_strcmp0(key, "npi")) {
 541                                 list.list[i].npi = g_variant_get_int32(value);
 542                         }
 543                         if (!g_strcmp0(key, "num")) {
 544                                 str_value = g_variant_get_string(value, NULL);
 545                                 snprintf(list.list[i].num, strlen((const char*)str_value) + 1, "%s", str_value);
 546                         }
 547                         if (!g_strcmp0(key, "cc_id")) {
 548                                 list.list[i].cc_id = g_variant_get_byte(value);
 549                         }
 550                         if (!g_strcmp0(key, "ext1_id")) {
 551                                 list.list[i].ext1_id = g_variant_get_byte(value);
 552                         }
 553                 }
 554                 i++;
 555                 g_variant_iter_free(iter_row);
 556         }
 557         g_variant_iter_free(iter);
 558
 559         if (evt_cb_data->cb_fn) {
 560                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 561         }
 562
 563         free(evt_cb_data);
 564 }
 565
 566 static void on_response_set_sim_mailbox_info(GObject *source_object, GAsyncResult *res,
 567                 gpointer user_data)
 568 {
 569         GError *error = NULL;
 570         GDBusConnection *conn = NULL;
 571         GVariant *dbus_result;
 572
 573         struct tapi_resp_data *evt_cb_data = user_data;
 574         TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
 575
 576         dbg("Func Entrance");
 577         conn = G_DBUS_CONNECTION (source_object);
 578         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 579         CHECK_DEINIT(error);
 580
 581         if (!dbus_result) {
 582                 if (evt_cb_data->cb_fn) {
 583                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 584                 }
 585
 586                 if (error)
 587                         g_error_free(error);
 588
 589                 free(evt_cb_data);
 590                 return;
 591         }
 592
 593         g_variant_get(dbus_result, "(i)", &result);
 594
 595         if (evt_cb_data->cb_fn) {
 596                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 597         }
 598
 599         free(evt_cb_data);
 600 }
 601
 602 static void on_response_get_sim_cphs_info(GObject *source_object, GAsyncResult *res,
 603                 gpointer user_data)
 604 {
 605         GError *error = NULL;
 606         GDBusConnection *conn = NULL;
 607         GVariant *dbus_result;
 608
 609         struct tapi_resp_data *evt_cb_data = user_data;
 610         TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
 611         TelSimCphsInfo_t cphs;
 612
 613         dbg("Func Entrance");
 614         memset(&cphs, 0, sizeof(TelSimCphsInfo_t));
 615
 616         conn = G_DBUS_CONNECTION (source_object);
 617         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 618         CHECK_DEINIT(error);
 619
 620         if (!dbus_result) {
 621                 if (evt_cb_data->cb_fn) {
 622                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 623                 }
 624
 625                 if (error)
 626                         g_error_free(error);
 627
 628                 free(evt_cb_data);
 629                 return;
 630         }
 631
 632         g_variant_get(dbus_result, "(iibbbbb)", &result, &cphs.CphsPhase,
 633                         &cphs.CphsServiceTable.bOperatorNameShortForm, &cphs.CphsServiceTable.bMailBoxNumbers,
 634                         &cphs.CphsServiceTable.bServiceStringTable,
 635                         &cphs.CphsServiceTable.bCustomerServiceProfile,
 636                         &cphs.CphsServiceTable.bInformationNumbers);
 637
 638         if (evt_cb_data->cb_fn) {
 639                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &cphs, evt_cb_data->user_data);
 640         }
 641
 642         free(evt_cb_data);
 643 }
 644
 645 static void on_response_get_sim_msisdn(GObject *source_object, GAsyncResult *res,
 646                 gpointer user_data)
 647 {
 648         GError *error = NULL;
 649         GDBusConnection *conn = NULL;
 650         GVariant *dbus_result;
 651         GVariant *value = NULL;
 652         GVariantIter *iter = NULL;
 653         GVariantIter *iter_row = NULL;
 654         const gchar *key = NULL;
 655         const gchar *str_value = NULL;
 656         struct tapi_resp_data *evt_cb_data = user_data;
 657         TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
 658         TelSimMsisdnList_t list;
 659         int i = 0;
 660
 661         dbg("Func Entrance");
 662         memset(&list, 0, sizeof(TelSimMsisdnList_t));
 663
 664         conn = G_DBUS_CONNECTION (source_object);
 665         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 666         CHECK_DEINIT(error);
 667
 668         if (!dbus_result) {
 669                 if (evt_cb_data->cb_fn) {
 670                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 671                 }
 672
 673                 if (error)
 674                         g_error_free(error);
 675
 676                 free(evt_cb_data);
 677                 return;
 678         }
 679
 680         g_variant_get(dbus_result, "(iaa{sv})", &result, &iter);
 681         list.count = g_variant_iter_n_children(iter);
 682
 683         /*this can be changed regarding concept*/
 684         if(list.count > 3){
 685                 dbg("current list.count[%d] but we fixed maximum with 3", list.count);
 686                 list.count = 3;
 687         }
 688         /*this can be changed regarding concept*/
 689
 690         i = 0;
 691         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 692                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 693                         if (!g_strcmp0(key, "name")) {
 694                                 str_value = g_variant_get_string(value, NULL);
 695                                 snprintf(list.list[i].name, strlen((const char*)str_value) + 1, "%s", str_value);
 696                         }
 697                         if (!g_strcmp0(key, "number")) {
 698                                 str_value = g_variant_get_string(value, NULL);
 699                                 snprintf(list.list[i].num, strlen((const char*)str_value) + 1, "%s", str_value);
 700                         }
 701                 }
 702                 i++;
 703                 g_variant_iter_free(iter_row);
 704                 /*this can be changed regarding concept*/
 705                 if (i == 3)
 706                         break;
 707                 /*this can be changed regarding concept*/
 708         }
 709         g_variant_iter_free(iter);
 710
 711         dbg("msisdn count[%d]", list.count);
 712         for(i =0; i < list.count; i++){
 713                 dbg("msisdn[%d]-name[%s]number[%s]",i,list.list[i].name, list.list[i].num);
 714         }
 715
 716         if (evt_cb_data->cb_fn) {
 717                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 718         }
 719
 720         free(evt_cb_data);
 721 }
 722
 723 static void on_response_get_sim_oplmnwact(GObject *source_object, GAsyncResult *res,
 724                 gpointer user_data)
 725 {
 726         GError *error = NULL;
 727         GDBusConnection *conn = NULL;
 728         GVariant *dbus_result;
 729         GVariant *value = NULL;
 730         GVariantIter *iter = NULL;
 731         GVariantIter *iter_row = NULL;
 732         const gchar *key = NULL;
 733         const gchar *str_value = NULL;
 734         struct tapi_resp_data *evt_cb_data = user_data;
 735         TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
 736         TelSimOplmnwactList_t list;
 737         int i = 0;
 738
 739         dbg("Func Entrance");
 740         memset(&list, 0, sizeof(TelSimOplmnwactList_t));
 741
 742         conn = G_DBUS_CONNECTION (source_object);
 743         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 744         CHECK_DEINIT(error);
 745
 746         if (!dbus_result) {
 747                 if (evt_cb_data->cb_fn) {
 748                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 749                 }
 750
 751                 if (error)
 752                         g_error_free(error);
 753
 754                 free(evt_cb_data);
 755                 return;
 756         }
 757
 758         g_variant_get(dbus_result, "(iaa{sv})", &result, &iter);
 759         list.count = g_variant_iter_n_children(iter);
 760
 761         i = 0;
 762         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 763                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 764                         if (!g_strcmp0(key, "plmn")) {
 765                                 str_value = g_variant_get_string(value, NULL);
 766                                 snprintf(list.list[i].plmn, strlen((const char*)str_value) + 1, "%s", str_value);
 767                         }
 768                         if (!g_strcmp0(key, "b_umst")) {
 769                                 list.list[i].b_umts = g_variant_get_boolean(value);
 770                         }
 771                         if (!g_strcmp0(key, "b_gsm")) {
 772                                 list.list[i].b_gsm = g_variant_get_boolean(value);
 773                         }
 774                 }
 775                 i++;
 776                 g_variant_iter_free(iter_row);
 777         }
 778         g_variant_iter_free(iter);
 779
 780         if (evt_cb_data->cb_fn) {
 781                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
 782         }
 783
 784         free(evt_cb_data);
 785 }
 786
 787 static void on_response_get_sim_spn(GObject *source_object, GAsyncResult *res,
 788                 gpointer user_data)
 789 {
 790         GError *error = NULL;
 791         GDBusConnection *conn = NULL;
 792         GVariant *dbus_result;
 793
 794         struct tapi_resp_data *evt_cb_data = user_data;
 795         TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
 796         TelSimSpn_t spn_info;
 797         gchar *spn = NULL;
 798         guchar dc = 0;
 799
 800         memset(&spn_info, 0, sizeof(TelSimSpn_t));
 801
 802         dbg("Func Entrance");
 803         conn = G_DBUS_CONNECTION (source_object);
 804         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 805         CHECK_DEINIT(error);
 806
 807         if (!dbus_result) {
 808                 if (evt_cb_data->cb_fn) {
 809                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 810                 }
 811
 812                 if (error)
 813                         g_error_free(error);
 814
 815                 free(evt_cb_data);
 816                 return;
 817         }
 818
 819         g_variant_get(dbus_result, "(iys)", &result, &dc, &spn);
 820
 821         dbg("result[%d]", result);
 822         if ( result == TAPI_SIM_ACCESS_SUCCESS) {
 823                 dbg("spn[%s], display condition[0x%x]", spn, dc);
 824                 spn_info.display_condition = dc;
 825                 snprintf((char *)spn_info.spn, strlen((const char*)spn)+1, "%s", spn);
 826         }
 827
 828         if (evt_cb_data->cb_fn) {
 829                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &spn_info, evt_cb_data->user_data);
 830         }
 831
 832         free(evt_cb_data);
 833 }
 834
 835 static void on_response_get_sim_cphs_netname(GObject *source_object, GAsyncResult *res,
 836                 gpointer user_data)
 837 {
 838         GError *error = NULL;
 839         GDBusConnection *conn = NULL;
 840         GVariant *dbus_result;
 841
 842         struct tapi_resp_data *evt_cb_data = user_data;
 843         TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
 844         TelSimCphsNetName_t cphs_net;
 845         gchar *full_name = NULL;
 846         gchar *short_name = NULL;
 847
 848         memset(&cphs_net, 0, sizeof(TelSimCphsNetName_t));
 849
 850         dbg("Func Entrance");
 851         conn = G_DBUS_CONNECTION (source_object);
 852         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 853         CHECK_DEINIT(error);
 854
 855         if (!dbus_result) {
 856                 if (evt_cb_data->cb_fn) {
 857                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 858                 }
 859
 860                 if (error)
 861                         g_error_free(error);
 862
 863                 free(evt_cb_data);
 864                 return;
 865         }
 866
 867         g_variant_get(dbus_result, "(iss)", &result, &full_name, &short_name);
 868
 869         dbg("result[%d]", result);
 870         if ( result == TAPI_SIM_ACCESS_SUCCESS) {
 871                 dbg("full name[%s], short name[%s]", full_name, short_name);
 872                 snprintf((char *)cphs_net.full_name, strlen((const char*)full_name)+1, "%s", full_name);
 873                 snprintf((char *)cphs_net.short_name, strlen((const char*)short_name)+1, "%s", short_name);
 874         }
 875
 876         if (evt_cb_data->cb_fn) {
 877                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &cphs_net, evt_cb_data->user_data);
 878         }
 879
 880         free(evt_cb_data);
 881 }
 882
 883 static void on_response_req_sim_authentication(GObject *source_object, GAsyncResult *res,
 884                 gpointer user_data)
 885 {
 886         GError *error = NULL;
 887         GDBusConnection *conn = NULL;
 888         GVariant *dbus_result;
 889
 890         GVariantIter *iter = NULL;
 891         GVariant *ak_gv = NULL;
 892         GVariant *cp_gv = NULL;
 893         GVariant *it_gv = NULL;
 894         GVariant *resp_gv = NULL;
 895         GVariant *ak = NULL;
 896         GVariant *cp = NULL;
 897         GVariant *it = NULL;
 898         GVariant *resp = NULL;
 899         guchar rt_i;
 900         int i = 0;
 901
 902         struct tapi_resp_data *evt_cb_data = user_data;
 903         TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
 904         TelSimAuthenticationResponse_t auth_resp;
 905
 906         dbg("Func Entrance");
 907         memset(&auth_resp, 0, sizeof(TelSimAuthenticationResponse_t));
 908
 909         conn = G_DBUS_CONNECTION (source_object);
 910         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 911         CHECK_DEINIT(error);
 912
 913         if (!dbus_result) {
 914                 if (evt_cb_data->cb_fn) {
 915                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 916                 }
 917
 918                 if (error)
 919                         g_error_free(error);
 920
 921                 free(evt_cb_data);
 922                 return;
 923         }
 924
 925         dbg("dbus_result type_format(%s)", g_variant_get_type_string(dbus_result));
 926         g_variant_get(dbus_result, "(iii@v@v@v@v)", &result, &auth_resp.auth_type,
 927                         &auth_resp.auth_result, &ak_gv, &cp_gv, &it_gv, &resp_gv);
 928
 929         ak = g_variant_get_variant(ak_gv);
 930         g_variant_get(ak, "ay", &iter);
 931         while (g_variant_iter_loop(iter, "y", &rt_i)) {
 932                 auth_resp.authentication_key[i] = rt_i;
 933                 dbg("auth_resp.authentication_key[%d]=[0x%02x]", i, auth_resp.authentication_key[i]);
 934                 i++;
 935         }
 936         auth_resp.authentication_key_length = i;
 937         g_variant_iter_free(iter);
 938         i = 0;
 939
 940         cp = g_variant_get_variant(cp_gv);
 941         g_variant_get(cp, "ay", &iter);
 942         while (g_variant_iter_loop(iter, "y", &rt_i)) {
 943                 auth_resp.cipher_data[i] = rt_i;
 944                 dbg("auth_resp.cipher_data[%d]=[0x%02x]", i, auth_resp.cipher_data[i]);
 945                 i++;
 946         }
 947         auth_resp.cipher_length = i;
 948         g_variant_iter_free(iter);
 949         i = 0;
 950
 951         it = g_variant_get_variant(it_gv);
 952         g_variant_get(it, "ay", &iter);
 953         while (g_variant_iter_loop(iter, "y", &rt_i)) {
 954                 auth_resp.integrity_data[i] = rt_i;
 955                 dbg("auth_resp.integrity_data[%d]=[0x%02x]", i, auth_resp.integrity_data[i]);
 956                 i++;
 957         }
 958         auth_resp.integrity_length = i;
 959         g_variant_iter_free(iter);
 960         i = 0;
 961
 962         resp = g_variant_get_variant(resp_gv);
 963         g_variant_get(resp, "ay", &iter);
 964         while (g_variant_iter_loop(iter, "y", &rt_i)) {
 965                 auth_resp.resp_data[i] = rt_i;
 966                 dbg("auth_resp.resp_data[%d]=[0x%02x]", i, auth_resp.resp_data[i]);
 967                 i++;
 968         }
 969         auth_resp.resp_length = i;
 970         g_variant_iter_free(iter);
 971         i = 0;
 972
 973         if (evt_cb_data->cb_fn) {
 974                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &auth_resp, evt_cb_data->user_data);
 975         }
 976
 977         free(evt_cb_data);
 978 }
 979
 980 static void on_response_verify_sim_pins(GObject *source_object, GAsyncResult *res,
 981                 gpointer user_data)
 982 {
 983         GError *error = NULL;
 984         GDBusConnection *conn = NULL;
 985         GVariant *dbus_result;
 986
 987         struct tapi_resp_data *evt_cb_data = user_data;
 988         TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
 989         TelSimSecResult_t sec_rt;
 990
 991         dbg("Func Entrance");
 992         memset(&sec_rt, 0, sizeof(TelSimSecResult_t));
 993
 994         conn = G_DBUS_CONNECTION (source_object);
 995         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 996         CHECK_DEINIT(error);
 997
 998         if (!dbus_result) {
 999                 if (evt_cb_data->cb_fn) {
1000                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
1001                 }
1002
1003                 if (error)
1004                         g_error_free(error);
1005
1006                 free(evt_cb_data);
1007                 return;
1008         }
1009
1010         g_variant_get(dbus_result, "(iii)", &result, &sec_rt.type, &sec_rt.retry_count);
1011
1012         if (evt_cb_data->cb_fn) {
1013                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &sec_rt, evt_cb_data->user_data);
1014         }
1015
1016         free(evt_cb_data);
1017 }
1018
1019 static void on_response_verify_sim_puks(GObject *source_object, GAsyncResult *res,
1020                 gpointer user_data)
1021 {
1022         GError *error = NULL;
1023         GDBusConnection *conn = NULL;
1024         GVariant *dbus_result;
1025
1026         struct tapi_resp_data *evt_cb_data = user_data;
1027         TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
1028         TelSimSecResult_t sec_rt;
1029
1030         dbg("Func Entrance");
1031         memset(&sec_rt, 0, sizeof(TelSimSecResult_t));
1032
1033         conn = G_DBUS_CONNECTION (source_object);
1034         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1035         CHECK_DEINIT(error);
1036
1037         if (!dbus_result) {
1038                 if (evt_cb_data->cb_fn) {
1039                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
1040                 }
1041
1042                 if (error)
1043                         g_error_free(error);
1044
1045                 free(evt_cb_data);
1046                 return;
1047         }
1048
1049         g_variant_get(dbus_result, "(iii)", &result, &sec_rt.type, &sec_rt.retry_count);
1050
1051         if (evt_cb_data->cb_fn) {
1052                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &sec_rt, evt_cb_data->user_data);
1053         }
1054
1055         free(evt_cb_data);
1056 }
1057
1058 static void on_response_change_sim_pins(GObject *source_object, GAsyncResult *res,
1059                 gpointer user_data)
1060 {
1061         GError *error = NULL;
1062         GDBusConnection *conn = NULL;
1063         GVariant *dbus_result;
1064
1065         struct tapi_resp_data *evt_cb_data = user_data;
1066         TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
1067         TelSimSecResult_t sec_rt;
1068
1069         dbg("Func Entrance");
1070         memset(&sec_rt, 0, sizeof(TelSimSecResult_t));
1071
1072         conn = G_DBUS_CONNECTION (source_object);
1073         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1074         CHECK_DEINIT(error);
1075
1076         if (!dbus_result) {
1077                 if (evt_cb_data->cb_fn) {
1078                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
1079                 }
1080
1081                 if (error)
1082                         g_error_free(error);
1083
1084                 free(evt_cb_data);
1085                 return;
1086         }
1087
1088         g_variant_get(dbus_result, "(iii)", &result, &sec_rt.type, &sec_rt.retry_count);
1089
1090         if (evt_cb_data->cb_fn) {
1091                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &sec_rt, evt_cb_data->user_data);
1092         }
1093
1094         free(evt_cb_data);
1095 }
1096
1097 static void on_response_disable_sim_facility(GObject *source_object, GAsyncResult *res,
1098                 gpointer user_data)
1099 {
1100         GError *error = NULL;
1101         GDBusConnection *conn = NULL;
1102         GVariant *dbus_result;
1103
1104         struct tapi_resp_data *evt_cb_data = user_data;
1105         TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
1106         TelSimFacilityResult_t f_rt;
1107
1108         dbg("Func Entrance");
1109         memset(&f_rt, 0, sizeof(TelSimFacilityResult_t));
1110
1111         conn = G_DBUS_CONNECTION (source_object);
1112         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1113         CHECK_DEINIT(error);
1114
1115         if (!dbus_result) {
1116                 if (evt_cb_data->cb_fn) {
1117                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
1118                 }
1119
1120                 if (error)
1121                         g_error_free(error);
1122
1123                 free(evt_cb_data);
1124                 return;
1125         }
1126
1127         g_variant_get(dbus_result, "(iii)", &result, &f_rt.type, &f_rt.retry_count);
1128
1129         if (evt_cb_data->cb_fn) {
1130                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &f_rt, evt_cb_data->user_data);
1131         }
1132
1133         free(evt_cb_data);
1134 }
1135
1136 static void on_response_enable_sim_facility(GObject *source_object, GAsyncResult *res,
1137                 gpointer user_data)
1138 {
1139         GError *error = NULL;
1140         GDBusConnection *conn = NULL;
1141         GVariant *dbus_result;
1142
1143         struct tapi_resp_data *evt_cb_data = user_data;
1144         TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
1145         TelSimFacilityResult_t f_rt;
1146
1147         dbg("Func Entrance");
1148         memset(&f_rt, 0, sizeof(TelSimFacilityResult_t));
1149
1150         conn = G_DBUS_CONNECTION (source_object);
1151         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1152         CHECK_DEINIT(error);
1153
1154         if (!dbus_result) {
1155                 if (evt_cb_data->cb_fn) {
1156                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
1157                 }
1158
1159                 if (error)
1160                         g_error_free(error);
1161
1162                 free(evt_cb_data);
1163                 return;
1164         }
1165
1166         g_variant_get(dbus_result, "(iii)", &result, &f_rt.type, &f_rt.retry_count);
1167
1168         if (evt_cb_data->cb_fn) {
1169                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &f_rt, evt_cb_data->user_data);
1170         }
1171
1172         free(evt_cb_data);
1173 }
1174
1175 static void on_response_get_sim_facility(GObject *source_object, GAsyncResult *res,
1176                 gpointer user_data)
1177 {
1178         GError *error = NULL;
1179         GDBusConnection *conn = NULL;
1180         GVariant *dbus_result;
1181
1182         struct tapi_resp_data *evt_cb_data = user_data;
1183         TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
1184         TelSimFacilityInfo_t fi;
1185
1186         dbg("Func Entrance");
1187         memset(&fi, 0, sizeof(TelSimFacilityInfo_t));
1188
1189         conn = G_DBUS_CONNECTION (source_object);
1190         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1191         CHECK_DEINIT(error);
1192
1193         if (!dbus_result) {
1194                 if (evt_cb_data->cb_fn) {
1195                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
1196                 }
1197
1198                 if (error)
1199                         g_error_free(error);
1200
1201                 free(evt_cb_data);
1202                 return;
1203         }
1204
1205         g_variant_get(dbus_result, "(iii)", &result, &fi.type, &fi.f_status);
1206
1207         if (evt_cb_data->cb_fn) {
1208                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &fi, evt_cb_data->user_data);
1209         }
1210
1211         free(evt_cb_data);
1212 }
1213
1214 static void on_response_get_sim_lock_info(GObject *source_object, GAsyncResult *res,
1215                 gpointer user_data)
1216 {
1217         GError *error = NULL;
1218         GDBusConnection *conn = NULL;
1219         GVariant *dbus_result;
1220
1221         struct tapi_resp_data *evt_cb_data = user_data;
1222         TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
1223         TelSimLockInfo_t lock;
1224
1225         dbg("Func Entrance");
1226         memset(&lock, 0, sizeof(TelSimLockInfo_t));
1227
1228         conn = G_DBUS_CONNECTION (source_object);
1229         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1230         CHECK_DEINIT(error);
1231
1232         if (!dbus_result) {
1233                 if (evt_cb_data->cb_fn) {
1234                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
1235                 }
1236
1237                 if (error)
1238                         g_error_free(error);
1239
1240                 free(evt_cb_data);
1241                 return;
1242         }
1243
1244         g_variant_get(dbus_result, "(iiii)", &result, &lock.lock_type, &lock.lock_status,
1245                         &lock.retry_count);
1246
1247         if (evt_cb_data->cb_fn) {
1248                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &lock, evt_cb_data->user_data);
1249         }
1250
1251         free(evt_cb_data);
1252 }
1253
1254 static void on_response_req_sim_apdu(GObject *source_object, GAsyncResult *res, gpointer user_data)
1255 {
1256         GError *error = NULL;
1257         GDBusConnection *conn = NULL;
1258         GVariant *dbus_result;
1259
1260         GVariantIter *iter = NULL;
1261         GVariant *param_gv = NULL;
1262         GVariant *inner_gv = NULL;
1263         guchar rt_i;
1264         unsigned short i = 0;
1265
1266         struct tapi_resp_data *evt_cb_data = user_data;
1267         TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
1268         TelSimApduResp_t r_apdu;
1269
1270         dbg("Func Entrance");
1271         memset(&r_apdu, 0, sizeof(TelSimApduResp_t));
1272
1273         conn = G_DBUS_CONNECTION (source_object);
1274         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1275         CHECK_DEINIT(error);
1276
1277         if (!dbus_result) {
1278                 if (evt_cb_data->cb_fn) {
1279                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
1280                 }
1281
1282                 if (error)
1283                         g_error_free(error);
1284
1285                 free(evt_cb_data);
1286                 return;
1287         }
1288
1289         /*      dbg("dbus_result type_format(%s)", g_variant_get_type_string(dbus_result));*/
1290         g_variant_get(dbus_result, "(i@v)", &result, &param_gv);
1291         inner_gv = g_variant_get_variant(param_gv);
1292
1293         g_variant_get(inner_gv, "ay", &iter);
1294         while (g_variant_iter_loop(iter, "y", &rt_i)) {
1295                 r_apdu.apdu_resp[i] = rt_i;
1296                 i++;
1297         }
1298         r_apdu.apdu_resp_len = i;
1299         dbg("r_apdu.apdu_resp_len=[%d]", r_apdu.apdu_resp_len);
1300         g_variant_iter_free(iter);
1301         g_variant_unref(inner_gv);
1302         g_variant_unref(param_gv);
1303
1304         if (evt_cb_data->cb_fn) {
1305                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &r_apdu, evt_cb_data->user_data);
1306         }
1307
1308         free(evt_cb_data);
1309 }
1310
1311 static void on_response_req_sim_atr(GObject *source_object, GAsyncResult *res, gpointer user_data)
1312 {
1313         GError *error = NULL;
1314         GDBusConnection *conn = NULL;
1315         GVariant *dbus_result;
1316
1317         GVariantIter *iter = NULL;
1318         GVariant *param_gv = NULL;
1319         GVariant *inner_gv = NULL;
1320         guchar rt_i;
1321         unsigned short i = 0;
1322
1323         struct tapi_resp_data *evt_cb_data = user_data;
1324         TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
1325         TelSimAtrResp_t r_atr;
1326
1327         dbg("Func Entrance");
1328         memset(&r_atr, 0, sizeof(TelSimAtrResp_t));
1329
1330         conn = G_DBUS_CONNECTION (source_object);
1331         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1332         CHECK_DEINIT(error);
1333
1334         if (!dbus_result) {
1335                 if (evt_cb_data->cb_fn) {
1336                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
1337                 }
1338
1339                 if (error)
1340                         g_error_free(error);
1341
1342                 free(evt_cb_data);
1343                 return;
1344         }
1345
1346         dbg("dbus_result type_format(%s)", g_variant_get_type_string(dbus_result));
1347         g_variant_get(dbus_result, "(i@v)", &result, &param_gv);
1348         inner_gv = g_variant_get_variant(param_gv);
1349
1350         g_variant_get(inner_gv, "ay", &iter);
1351         while (g_variant_iter_loop(iter, "y", &rt_i)) {
1352                 r_atr.atr_resp[i] = rt_i;
1353                 i++;
1354         }
1355         r_atr.atr_resp_len = i;
1356         dbg("r_atr.atr_resp_len=[%d]", r_atr.atr_resp_len);
1357         g_variant_iter_free(iter);
1358         g_variant_unref(inner_gv);
1359         g_variant_unref(param_gv);
1360
1361         if (evt_cb_data->cb_fn) {
1362                 evt_cb_data->cb_fn(evt_cb_data->handle, result, &r_atr, evt_cb_data->user_data);
1363         }
1364
1365         free(evt_cb_data);
1366 }
1367
1368 EXPORT_API int tel_get_sim_init_info(TapiHandle *handle, TelSimCardStatus_t *sim_status,
1369                 int *card_changed)
1370 {
1371         GError *gerr = NULL;
1372         GVariant *sync_gv = NULL;
1373         int api_err = TAPI_API_SUCCESS;
1374         TelSimCardStatus_t init_status = 0;
1375         int changed = FALSE;
1376
1377         dbg("Func Entrance");
1378         if (_tel_check_tapi_state() != 0)
1379                 return TAPI_API_SERVICE_NOT_READY;
1380
1381         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1382         TAPI_RETURN_VAL_IF_FAIL(sim_status, TAPI_API_INVALID_PTR);
1383         TAPI_RETURN_VAL_IF_FAIL(card_changed, TAPI_API_INVALID_PTR);
1384
1385         sync_gv = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
1386                         handle->path, DBUS_TELEPHONY_SIM_INTERFACE, "GetInitStatus", NULL, NULL,
1387                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &gerr);
1388
1389         if (sync_gv) {
1390                 g_variant_get(sync_gv, "(ib)", &init_status, &changed);
1391                 *sim_status = init_status;
1392                 *card_changed = changed;
1393                 dbg("init_status[%d]",init_status);
1394                 dbg("changed[%d]",changed);
1395         } else {
1396                 dbg( "g_dbus_conn failed. error (%s)", gerr->message);
1397                 g_error_free(gerr);
1398                 return TAPI_API_OPERATION_FAILED;
1399         }
1400         g_variant_unref(sync_gv);
1401         return api_err;
1402 }
1403
1404 EXPORT_API int tel_get_sim_type(TapiHandle *handle, TelSimCardType_t *card_type)
1405 {
1406         GError *gerr = NULL;
1407         GVariant *sync_gv = NULL;
1408         int sim_ret =0;
1409
1410         dbg("Func Entrance");
1411
1412         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1413         TAPI_RETURN_VAL_IF_FAIL(card_type, TAPI_API_INVALID_PTR);
1414
1415         if (_tel_check_tapi_state() != 0)
1416                 return TAPI_API_SERVICE_NOT_READY;
1417
1418         sim_ret = _tel_check_sim_state(handle);
1419         if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
1420                 return sim_ret;
1421
1422         sync_gv = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
1423                         handle->path, DBUS_TELEPHONY_SIM_INTERFACE, "GetCardType", NULL, NULL,
1424                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &gerr);
1425
1426         if (sync_gv) {
1427                 g_variant_get(sync_gv, "(i)", card_type);
1428         } else {
1429                 dbg( "g_dbus_conn failed. error (%s)", gerr->message);
1430                 g_error_free(gerr);
1431                 return TAPI_API_OPERATION_FAILED;
1432         }
1433         g_variant_unref(sync_gv);
1434         return TAPI_API_SUCCESS;
1435 }
1436
1437 EXPORT_API int tel_get_sim_imsi(TapiHandle *handle, TelSimImsiInfo_t *imsi)
1438 {
1439         GError *gerr = NULL;
1440         GVariant *sync_gv = NULL;
1441         gchar *gplmn = NULL;
1442         gchar *gmsin = NULL;
1443         int sim_ret = 0;
1444
1445         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1446
1447         dbg("Func Entrance");
1448         if (_tel_check_tapi_state() != 0)
1449                 return TAPI_API_SERVICE_NOT_READY;
1450
1451         sim_ret =_tel_check_sim_state(handle);
1452         if (sim_ret != TAPI_API_SUCCESS)
1453                 return sim_ret;
1454
1455         TAPI_RETURN_VAL_IF_FAIL(imsi, TAPI_API_INVALID_PTR);
1456
1457         sync_gv = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
1458                         handle->path, DBUS_TELEPHONY_SIM_INTERFACE, "GetIMSI", NULL, NULL,
1459                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &gerr);
1460
1461         if (sync_gv) {
1462                 dbg("imsi type_format(%s)", g_variant_get_type_string(sync_gv));
1463                 g_variant_get(sync_gv, "(ss)", &gplmn, &gmsin);
1464
1465                 dbg("gplmn[%s],gmsin[%s]",gplmn,gmsin);
1466                 snprintf(imsi->szMcc, 3 + 1, "%s", gplmn);
1467                 snprintf(imsi->szMnc, strlen((const char*)gplmn) - 3 + 1, "%s", &gplmn[3]);
1468                 snprintf(imsi->szMsin, strlen((const char*)gmsin) + 1, "%s", gmsin);
1469
1470                 dbg("imsi->szMnc[%s]", imsi->szMnc);
1471                 dbg("imsi->szMcc[%s]", imsi->szMcc);
1472                 g_free(gplmn);
1473                 g_free(gmsin);
1474         } else {
1475                 dbg( "g_dbus_conn failed. error (%s)", gerr->message);
1476                 g_error_free(gerr);
1477                 return TAPI_API_OPERATION_FAILED;
1478         }
1479         g_variant_unref(sync_gv);
1480         return TAPI_API_SUCCESS;
1481 }
1482
1483 EXPORT_API int tel_get_sim_ecc(TapiHandle *handle, TelSimEccList_t *ecc)
1484 {
1485         GError *gerr = NULL;
1486         GVariant *sync_gv;
1487         GVariant *value = NULL;
1488         GVariantIter *iter = NULL;
1489         GVariantIter *iter_row = NULL;
1490         const gchar *key = NULL;
1491         const gchar *str_value = NULL;
1492         int i = 0;
1493         int sim_ret = 0;
1494
1495         dbg("Func Entrance");
1496         memset(ecc, 0, sizeof(TelSimEccList_t));
1497         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1498         TAPI_RETURN_VAL_IF_FAIL(ecc, TAPI_API_INVALID_PTR);
1499
1500         sim_ret =_tel_check_sim_state(handle);
1501         if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
1502                 return sim_ret;
1503
1504         sync_gv = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
1505                         handle->path, DBUS_TELEPHONY_SIM_INTERFACE, "GetECC", NULL, NULL,
1506                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &gerr);
1507
1508         if (sync_gv) {
1509 /*              dbg("ecc type_format(%s)", g_variant_get_type_string(sync_gv));*/
1510                 g_variant_get(sync_gv, "(aa{sv})", &iter);
1511                 ecc->ecc_count = g_variant_iter_n_children(iter);
1512                 dbg("ecc->ecc_count[%d]",ecc->ecc_count);
1513                 i = 0;
1514                 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
1515                         while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
1516                                 if (!g_strcmp0(key, "name")) {
1517                                         str_value = g_variant_get_string(value, NULL);
1518                                         snprintf(ecc->list[i].name, strlen((const char*)str_value) + 1, "%s", str_value);
1519                                 }
1520                                 if (!g_strcmp0(key, "number")) {
1521                                         str_value = g_variant_get_string(value, NULL);
1522                                         snprintf(ecc->list[i].number, strlen((const char*)str_value) + 1, "%s", str_value);
1523                                 }
1524                                 if (!g_strcmp0(key, "category")) {
1525                                         ecc->list[i].category = g_variant_get_int32(value);
1526                                 }
1527                         }
1528                         i++;
1529                         g_variant_iter_free(iter_row);
1530                 }
1531                 g_variant_iter_free(iter);
1532         } else {
1533                 dbg( "g_dbus_conn failed. error (%s)", gerr->message);
1534                 g_error_free(gerr);
1535                 return TAPI_API_OPERATION_FAILED;
1536         }
1537         return TAPI_API_SUCCESS;
1538 }
1539
1540 EXPORT_API int tel_get_sim_iccid(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1541 {
1542         struct tapi_resp_data *evt_cb_data = NULL;
1543         int sim_ret = 0;
1544
1545         dbg("Func Entrance ");
1546         if (_tel_check_tapi_state() != 0)
1547                 return TAPI_API_SERVICE_NOT_READY;
1548
1549         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1550
1551         sim_ret =_tel_check_sim_state(handle);
1552         if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
1553                 return sim_ret;
1554
1555         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1556
1557         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1558                         DBUS_TELEPHONY_SIM_INTERFACE, "GetICCID", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
1559                         on_response_get_sim_iccid, evt_cb_data);
1560
1561         return TAPI_API_SUCCESS;
1562 }
1563
1564 EXPORT_API int tel_get_sim_language(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1565 {
1566         struct tapi_resp_data *evt_cb_data = NULL;
1567         int sim_ret = 0;
1568
1569         dbg("Func Entrance ");
1570         if (_tel_check_tapi_state() != 0)
1571                 return TAPI_API_SERVICE_NOT_READY;
1572
1573         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1574
1575         sim_ret =_tel_check_sim_state(handle);
1576         if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
1577                 return sim_ret;
1578
1579         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1580
1581         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1582                         DBUS_TELEPHONY_SIM_INTERFACE, "GetLanguage", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1583                         handle->ca, on_response_get_sim_language, evt_cb_data);
1584
1585         return TAPI_API_SUCCESS;
1586 }
1587
1588 EXPORT_API int tel_set_sim_language(TapiHandle *handle, TelSimLanguagePreferenceCode_t language,
1589                 tapi_response_cb callback, void *user_data)
1590 {
1591         struct tapi_resp_data *evt_cb_data = NULL;
1592         GVariant *param = NULL;
1593         int sim_ret = 0;
1594
1595         dbg("Func Entrance w/ lang[%d]",language);
1596         if (_tel_check_tapi_state() != 0)
1597                 return TAPI_API_SERVICE_NOT_READY;
1598
1599         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1600
1601         sim_ret =_tel_check_sim_state(handle);
1602         if (sim_ret != TAPI_API_SUCCESS)
1603                 return sim_ret;
1604
1605         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1606
1607         param = g_variant_new("(i)", language);
1608
1609         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1610                         DBUS_TELEPHONY_SIM_INTERFACE, "SetLanguage", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1611                         handle->ca, on_response_set_sim_language, evt_cb_data);
1612
1613         return TAPI_API_SUCCESS;
1614 }
1615
1616 EXPORT_API int tel_get_sim_callforwarding_info(TapiHandle *handle, tapi_response_cb callback,
1617                 void *user_data)
1618 {
1619         struct tapi_resp_data *evt_cb_data = NULL;
1620         int sim_ret = 0;
1621
1622         dbg("Func Entrance ");
1623         if (_tel_check_tapi_state() != 0)
1624                 return TAPI_API_SERVICE_NOT_READY;
1625
1626         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1627
1628         sim_ret =_tel_check_sim_state(handle);
1629         if (sim_ret != TAPI_API_SUCCESS)
1630                 return sim_ret;
1631
1632         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1633
1634         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1635                         DBUS_TELEPHONY_SIM_INTERFACE, "GetCallForwarding", NULL, NULL, G_DBUS_CALL_FLAGS_NONE,
1636                         -1, handle->ca, on_response_get_sim_callforwarding_info, evt_cb_data);
1637
1638         return TAPI_API_SUCCESS;
1639 }
1640
1641 EXPORT_API int tel_set_sim_callforwarding_info(TapiHandle *handle, TelSimCallForwardingReq_t *req_cf,
1642                 tapi_response_cb callback, void *user_data)
1643 {
1644         struct tapi_resp_data *evt_cb_data = NULL;
1645         GVariant *param = NULL;
1646         int sim_ret = 0;
1647         gchar *g_number = NULL;
1648
1649         if (_tel_check_tapi_state() != 0)
1650                 return TAPI_API_SERVICE_NOT_READY;
1651
1652         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1653
1654         sim_ret =_tel_check_sim_state(handle);
1655         if (sim_ret != TAPI_API_SUCCESS)
1656                 return sim_ret;
1657
1658         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1659
1660         g_number = calloc(strlen((const char*)&req_cf->cf_data_u.cf.cfu_num)+1, 1);
1661         if (!g_number) {
1662                 g_free(evt_cb_data);
1663                 return TAPI_API_SYSTEM_OUT_OF_MEM;
1664         }
1665
1666         memcpy((void*)g_number, (const void*)&req_cf->cf_data_u.cf.cfu_num, strlen((const char*)&req_cf->cf_data_u.cf.cfu_num));
1667
1668         param = g_variant_new("(biiyiisiibbbb)",
1669                         req_cf->b_cphs,
1670                         req_cf->cf_data_u.cf.rec_index,
1671                         req_cf->cf_data_u.cf.msp_num,
1672                         req_cf->cf_data_u.cf.cfu_status,
1673                         req_cf->cf_data_u.cf.ton,
1674                         req_cf->cf_data_u.cf.npi,
1675                         g_number,
1676                         req_cf->cf_data_u.cf.cc2_id,
1677                         req_cf->cf_data_u.cf.ext7_id,
1678                         req_cf->cf_data_u.cphs_cf.b_line1,
1679                         req_cf->cf_data_u.cphs_cf.b_line2,
1680                         req_cf->cf_data_u.cphs_cf.b_fax,
1681                         req_cf->cf_data_u.cphs_cf.b_data);
1682
1683         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1684                         DBUS_TELEPHONY_SIM_INTERFACE, "SetCallForwarding", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1685                         handle->ca, on_response_set_sim_callforwarding_info, evt_cb_data);
1686
1687         if (g_number)
1688                 free(g_number);
1689
1690         return TAPI_API_SUCCESS;
1691 }
1692
1693 EXPORT_API int tel_get_sim_messagewaiting_info(TapiHandle *handle, tapi_response_cb callback,
1694                 void *user_data)
1695 {
1696         struct tapi_resp_data *evt_cb_data = NULL;
1697         int sim_ret = 0;
1698
1699         dbg("Func Entrance ");
1700         if (_tel_check_tapi_state() != 0)
1701                 return TAPI_API_SERVICE_NOT_READY;
1702
1703         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1704
1705         sim_ret =_tel_check_sim_state(handle);
1706         if (sim_ret != TAPI_API_SUCCESS)
1707                 return sim_ret;
1708
1709         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1710
1711         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1712                         DBUS_TELEPHONY_SIM_INTERFACE, "GetMessageWaiting", NULL, NULL, G_DBUS_CALL_FLAGS_NONE,
1713                         -1, handle->ca, on_response_get_sim_messagewaiting_info, evt_cb_data);
1714
1715         return TAPI_API_SUCCESS;
1716 }
1717
1718 EXPORT_API int tel_set_sim_messagewaiting_info(TapiHandle *handle, TelSimMessageWaitingReq_t *req_mw,
1719                 tapi_response_cb callback, void *user_data)
1720 {
1721         struct tapi_resp_data *evt_cb_data = NULL;
1722         GVariant *param = NULL;
1723         int sim_ret = 0;
1724
1725         if (_tel_check_tapi_state() != 0)
1726                 return TAPI_API_SERVICE_NOT_READY;
1727
1728         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1729
1730         sim_ret =_tel_check_sim_state(handle);
1731         if (sim_ret != TAPI_API_SUCCESS)
1732                 return sim_ret;
1733
1734         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1735
1736         dbg("b_cphs[%d], rec_index[%d], indicator_status[0x%x], voice_count[%d], fax_count[%d], email_count[%d], other_count[%d], video_count[%d], b_voice1[%d],b_voice2[%d],b_fax[%d], b_data[%d]",
1737                         req_mw->b_cphs,
1738                         req_mw->mw_data_u.mw.rec_index,
1739                         req_mw->mw_data_u.mw.indicator_status,
1740                         req_mw->mw_data_u.mw.voice_count,
1741                         req_mw->mw_data_u.mw.fax_count,
1742                         req_mw->mw_data_u.mw.email_count,
1743                         req_mw->mw_data_u.mw.other_count,
1744                         req_mw->mw_data_u.mw.video_count,
1745                         req_mw->mw_data_u.cphs_mw.b_voice1,
1746                         req_mw->mw_data_u.cphs_mw.b_voice2,
1747                         req_mw->mw_data_u.cphs_mw.b_fax,
1748                         req_mw->mw_data_u.cphs_mw.b_data);
1749
1750         param = g_variant_new("(biyiiiiibbbb)",
1751                         req_mw->b_cphs,
1752                         req_mw->mw_data_u.mw.rec_index,
1753                         req_mw->mw_data_u.mw.indicator_status,
1754                         req_mw->mw_data_u.mw.voice_count,
1755                         req_mw->mw_data_u.mw.fax_count,
1756                         req_mw->mw_data_u.mw.email_count,
1757                         req_mw->mw_data_u.mw.other_count,
1758                         req_mw->mw_data_u.mw.video_count,
1759                         req_mw->mw_data_u.cphs_mw.b_voice1,
1760                         req_mw->mw_data_u.cphs_mw.b_voice2,
1761                         req_mw->mw_data_u.cphs_mw.b_fax,
1762                         req_mw->mw_data_u.cphs_mw.b_data);
1763
1764         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1765                         DBUS_TELEPHONY_SIM_INTERFACE, "SetMessageWaiting", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1766                         handle->ca, on_response_set_sim_messagewaiting_info, evt_cb_data);
1767
1768         return TAPI_API_SUCCESS;
1769 }
1770
1771 EXPORT_API int tel_get_sim_mailbox_info(TapiHandle *handle, tapi_response_cb callback,
1772                 void *user_data)
1773 {
1774         struct tapi_resp_data *evt_cb_data = NULL;
1775         int sim_ret = 0;
1776
1777         dbg("Func Entrance ");
1778         if (_tel_check_tapi_state() != 0)
1779                 return TAPI_API_SERVICE_NOT_READY;
1780
1781         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1782
1783         sim_ret =_tel_check_sim_state(handle);
1784         if (sim_ret != TAPI_API_SUCCESS)
1785                 return sim_ret;
1786
1787         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1788
1789         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1790                         DBUS_TELEPHONY_SIM_INTERFACE, "GetMailbox", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1791                         handle->ca, on_response_get_sim_mailbox_info, evt_cb_data);
1792
1793         return TAPI_API_SUCCESS;
1794 }
1795
1796 EXPORT_API int tel_set_sim_mailbox_info(TapiHandle *handle, TelSimMailBoxNumber_t *req_mb,
1797                 tapi_response_cb callback, void *user_data)
1798 {
1799         struct tapi_resp_data *evt_cb_data = NULL;
1800         GVariant *param = NULL;
1801         int sim_ret = 0;
1802         gchar *g_alpha = NULL;
1803         gchar *g_number = NULL;
1804
1805         if (_tel_check_tapi_state() != 0)
1806                 return TAPI_API_SERVICE_NOT_READY;
1807
1808         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1809
1810         sim_ret =_tel_check_sim_state(handle);
1811         if (sim_ret != TAPI_API_SUCCESS)
1812                 return sim_ret;
1813
1814         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1815
1816         g_alpha = calloc(strlen((const char*)&req_mb->alpha_id)+1, 1);
1817         if (!g_alpha) {
1818                 g_free(evt_cb_data);
1819                 return TAPI_API_SYSTEM_OUT_OF_MEM;
1820         }
1821
1822         memcpy((void*)g_alpha, (const void*)&req_mb->alpha_id, strlen((const char*)&req_mb->alpha_id));
1823
1824         g_number = calloc(strlen((const char*)&req_mb->num)+1, 1);
1825         if (!g_number) {
1826                 free(g_alpha);
1827                 g_free(evt_cb_data);
1828                 return TAPI_API_SYSTEM_OUT_OF_MEM;
1829         }
1830
1831         memcpy((void*)g_number, (const void*)&req_mb->num, strlen((const char*)&req_mb->num));
1832
1833         dbg("req_mb->b_cphs[%d], req_mb->rec_index[%d], req_mb->profile_num[%d], req_mb->mb_type[%d], req_mb->alpha_id_max_len[%d],req_mb->alpha_id[%s]",
1834                         req_mb->b_cphs,
1835                         req_mb->rec_index,
1836                         req_mb->profile_num,
1837                         req_mb->mb_type,
1838                         req_mb->alpha_id_max_len,
1839                         g_alpha);
1840
1841         dbg("req_mb->ton[%d],req_mb->npi[%d],g_number[%s],req_mb->cc_id[%d],req_mb->ext1_id[%d]",
1842                         req_mb->ton,
1843                         req_mb->npi,
1844                         g_number,
1845                         req_mb->cc_id,
1846                         req_mb->ext1_id);
1847
1848         param = g_variant_new("(biiiisiisii)",
1849                         req_mb->b_cphs,
1850                         req_mb->mb_type,
1851                         req_mb->rec_index,
1852                         req_mb->profile_num,
1853                         req_mb->alpha_id_max_len,
1854                         g_alpha,
1855                         req_mb->ton,
1856                         req_mb->npi,
1857                         g_number,
1858                         req_mb->cc_id,
1859                         req_mb->ext1_id);
1860
1861         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1862                         DBUS_TELEPHONY_SIM_INTERFACE, "SetMailbox", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1863                         handle->ca, on_response_set_sim_mailbox_info, evt_cb_data);
1864
1865         if (g_alpha)
1866                 free(g_alpha);
1867
1868         if (g_number)
1869                 free(g_number);
1870
1871         return TAPI_API_SUCCESS;
1872 }
1873
1874 EXPORT_API int tel_get_sim_cphs_info(TapiHandle *handle, tapi_response_cb callback,
1875                 void *user_data)
1876 {
1877         struct tapi_resp_data *evt_cb_data = NULL;
1878         int sim_ret = 0;
1879
1880         dbg("Func Entrance ");
1881         if (_tel_check_tapi_state() != 0)
1882                 return TAPI_API_SERVICE_NOT_READY;
1883
1884         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1885
1886         sim_ret =_tel_check_sim_state(handle);
1887         if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
1888                 return sim_ret;
1889
1890         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1891
1892         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1893                         DBUS_TELEPHONY_SIM_INTERFACE, "GetCPHSInfo", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
1894                         on_response_get_sim_cphs_info, evt_cb_data);
1895
1896         return TAPI_API_SUCCESS;
1897 }
1898
1899 EXPORT_API int tel_get_sim_msisdn(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1900 {
1901         struct tapi_resp_data *evt_cb_data = NULL;
1902         int sim_ret = 0;
1903
1904         dbg("Func Entrance ");
1905         if (_tel_check_tapi_state() != 0)
1906                 return TAPI_API_SERVICE_NOT_READY;
1907
1908         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1909
1910         sim_ret =_tel_check_sim_state(handle);
1911         if (sim_ret != TAPI_API_SUCCESS)
1912                 return sim_ret;;
1913
1914         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1915
1916         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1917                         DBUS_TELEPHONY_SIM_INTERFACE, "GetMSISDN", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
1918                         on_response_get_sim_msisdn, evt_cb_data);
1919
1920         return TAPI_API_SUCCESS;
1921 }
1922
1923 EXPORT_API int tel_get_sim_oplmnwact(TapiHandle *handle, tapi_response_cb callback,
1924                 void *user_data)
1925 {
1926         struct tapi_resp_data *evt_cb_data = NULL;
1927         int sim_ret = 0;
1928
1929         dbg("Func Entrance ");
1930         if (_tel_check_tapi_state() != 0)
1931                 return TAPI_API_SERVICE_NOT_READY;
1932
1933         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1934
1935         sim_ret =_tel_check_sim_state(handle);
1936         if (sim_ret != TAPI_API_SUCCESS)
1937                 return sim_ret;
1938
1939         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1940
1941         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1942                         DBUS_TELEPHONY_SIM_INTERFACE, "GetOplmnwact", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1943                         handle->ca, on_response_get_sim_oplmnwact, evt_cb_data);
1944
1945         return TAPI_API_SUCCESS;
1946 }
1947
1948 EXPORT_API int tel_get_sim_spn(TapiHandle *handle, tapi_response_cb callback,
1949                 void *user_data)
1950 {
1951         struct tapi_resp_data *evt_cb_data = NULL;
1952         int sim_ret = 0;
1953
1954         dbg("Func Entrance ");
1955         if (_tel_check_tapi_state() != 0)
1956                 return TAPI_API_SERVICE_NOT_READY;
1957
1958         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1959
1960         sim_ret =_tel_check_sim_state(handle);
1961         if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
1962                 return sim_ret;
1963
1964         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1965
1966         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1967                         DBUS_TELEPHONY_SIM_INTERFACE, "GetSpn", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1968                         handle->ca, on_response_get_sim_spn, evt_cb_data);
1969
1970         return TAPI_API_SUCCESS;
1971 }
1972
1973 EXPORT_API int tel_get_sim_cphs_netname(TapiHandle *handle, tapi_response_cb callback,
1974                 void *user_data)
1975 {
1976         struct tapi_resp_data *evt_cb_data = NULL;
1977         int sim_ret = 0;
1978
1979         dbg("Func Entrance ");
1980         if (_tel_check_tapi_state() != 0)
1981                 return TAPI_API_SERVICE_NOT_READY;
1982
1983         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1984
1985         sim_ret =_tel_check_sim_state(handle);
1986         if (sim_ret != TAPI_API_SUCCESS)
1987                 return sim_ret;
1988
1989         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1990
1991         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1992                         DBUS_TELEPHONY_SIM_INTERFACE, "GetCphsNetName", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1993                         handle->ca, on_response_get_sim_cphs_netname, evt_cb_data);
1994
1995         return TAPI_API_SUCCESS;
1996 }
1997
1998 EXPORT_API int tel_req_sim_authentication(TapiHandle *handle,
1999                 TelSimAuthenticationData_t *authentication_data, tapi_response_cb callback, void *user_data)
2000 {
2001         struct tapi_resp_data *evt_cb_data = NULL;
2002         GVariantBuilder *builder = NULL;
2003         GVariant *param = NULL;
2004         GVariant *rand_gv = NULL;
2005         GVariant *autn_gv = NULL;
2006         int i =0;
2007         int sim_ret = 0;
2008
2009         dbg("Func Entrance ");
2010         if (_tel_check_tapi_state() != 0)
2011                 return TAPI_API_SERVICE_NOT_READY;
2012
2013         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2014
2015         sim_ret =_tel_check_sim_state(handle);
2016         if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
2017                 return sim_ret;
2018
2019         TAPI_RETURN_VAL_IF_FAIL(authentication_data, TAPI_API_INVALID_PTR);
2020
2021         if (authentication_data->auth_type > TAPI_SIM_AUTH_TYPE_3G)
2022                 return TAPI_API_INVALID_INPUT;
2023
2024         if (authentication_data->rand_length == 0)
2025                 return TAPI_API_INVALID_INPUT;
2026
2027         if (authentication_data->auth_type != TAPI_SIM_AUTH_TYPE_GSM
2028                         && authentication_data->autn_length == 0)
2029                 return TAPI_API_INVALID_INPUT;
2030
2031         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2032
2033         builder = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
2034         for (i = 0; i < authentication_data->rand_length; i++) {
2035                 dbg("authentication_data->rand_data[%d][0x%02x]", i,authentication_data->rand_data[i]);
2036                 g_variant_builder_add(builder, "y", authentication_data->rand_data[i]);
2037         }
2038         rand_gv = g_variant_builder_end(builder);
2039
2040         builder = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
2041                 for (i = 0; i < authentication_data->autn_length; i++) {
2042                         dbg("authentication_data->autn_data[%d][0x%02x]", i,authentication_data->autn_data[i]);
2043                         g_variant_builder_add(builder, "y", authentication_data->autn_data[i]);
2044                 }
2045         autn_gv = g_variant_builder_end(builder);
2046
2047         param = g_variant_new("(ivv)", authentication_data->auth_type, rand_gv, autn_gv);
2048         /*g_variant_builder_unref (builder);*/
2049
2050         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2051                         DBUS_TELEPHONY_SIM_INTERFACE, "Authentication", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
2052                         handle->ca, on_response_req_sim_authentication, evt_cb_data);
2053
2054         return TAPI_API_SUCCESS;
2055 }
2056
2057 EXPORT_API int tel_verifiy_sim_pins(TapiHandle *handle, const TelSimSecPw_t *pin_data,
2058                 tapi_response_cb callback, void *user_data)
2059 {
2060         struct tapi_resp_data *evt_cb_data = NULL;
2061         GVariant *param = NULL;
2062         gchar *gpw = NULL;
2063         int sim_ret = 0;
2064
2065         dbg("Func Entrance");
2066         if (_tel_check_tapi_state() != 0)
2067                 return TAPI_API_SERVICE_NOT_READY;
2068
2069         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2070
2071         sim_ret =_tel_check_sim_state(handle);
2072         if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
2073                 return sim_ret;
2074
2075         TAPI_RETURN_VAL_IF_FAIL(pin_data, TAPI_API_INVALID_PTR);
2076         TAPI_RETURN_VAL_IF_FAIL(pin_data->pw, TAPI_API_INVALID_PTR);
2077
2078         dbg("pin type[%d]", pin_data->type);
2079         if (pin_data->type != TAPI_SIM_PTYPE_PIN1 && pin_data->type != TAPI_SIM_PTYPE_PIN2
2080                         && pin_data->type != TAPI_SIM_PTYPE_SIM)
2081                 return TAPI_API_INVALID_INPUT;
2082
2083         if ((pin_data->pw_len < 4) || (pin_data->pw_len > 8))
2084                 return TAPI_API_INVALID_INPUT;
2085
2086         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2087
2088         gpw = calloc(pin_data->pw_len+1, 1);
2089         if (!gpw) {
2090                 g_free(evt_cb_data);
2091                 return TAPI_API_SYSTEM_OUT_OF_MEM;
2092         }
2093
2094         memcpy((void*)gpw, (const void*)pin_data->pw, pin_data->pw_len);
2095
2096         param = g_variant_new("(is)", pin_data->type, gpw);
2097
2098         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2099                         DBUS_TELEPHONY_SIM_INTERFACE, "VerifySec", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
2100                         handle->ca, on_response_verify_sim_pins, evt_cb_data);
2101
2102         if (gpw)
2103                 free(gpw);
2104
2105         return TAPI_API_SUCCESS;
2106 }
2107
2108 EXPORT_API int tel_verify_sim_puks(TapiHandle *handle, const TelSimSecPw_t *puk_data,
2109                 const TelSimSecPw_t *new_pin_data, tapi_response_cb callback, void *user_data)
2110 {
2111         struct tapi_resp_data *evt_cb_data = NULL;
2112         GVariant *param = NULL;
2113         gchar *gpin = NULL;
2114         gchar *gpuk = NULL;
2115         int sim_ret = 0;
2116
2117         dbg("Func Entrance");
2118         if (_tel_check_tapi_state() != 0)
2119                 return TAPI_API_SERVICE_NOT_READY;
2120
2121         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2122
2123         sim_ret =_tel_check_sim_state(handle);
2124         if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
2125                 return sim_ret;
2126
2127         TAPI_RETURN_VAL_IF_FAIL((puk_data != NULL && new_pin_data != NULL), TAPI_API_INVALID_PTR);
2128         TAPI_RETURN_VAL_IF_FAIL((puk_data->pw != NULL && new_pin_data->pw != NULL),     TAPI_API_INVALID_PTR);
2129
2130         dbg("puk type[%d] pin type[%d]", puk_data->type, new_pin_data->type);
2131         if ((puk_data->type != TAPI_SIM_PTYPE_PUK1 && puk_data->type != TAPI_SIM_PTYPE_PUK2)
2132                         || (new_pin_data->type != TAPI_SIM_PTYPE_PIN1 && new_pin_data->type != TAPI_SIM_PTYPE_PIN2))
2133                 return TAPI_API_INVALID_INPUT;
2134
2135         if ((puk_data->type != TAPI_SIM_PTYPE_PUK1 || new_pin_data->type != TAPI_SIM_PTYPE_PIN1)
2136                         && (puk_data->type != TAPI_SIM_PTYPE_PUK2 || new_pin_data->type != TAPI_SIM_PTYPE_PIN2))
2137                 return TAPI_API_INVALID_INPUT;
2138
2139         if ((puk_data->pw_len < 4) || (puk_data->pw_len > 8) || (new_pin_data->pw_len < 4)
2140                         || (new_pin_data->pw_len > 8))
2141                 return TAPI_API_INVALID_INPUT;
2142
2143         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2144
2145         gpin = calloc(new_pin_data->pw_len+1, 1);
2146         if (!gpin) {
2147                 g_free(evt_cb_data);
2148                 return TAPI_API_SYSTEM_OUT_OF_MEM;
2149         }
2150
2151         gpuk = calloc(puk_data->pw_len+1, 1);
2152         if (!gpuk) {
2153                 g_free(evt_cb_data);
2154                 free(gpin);
2155                 return TAPI_API_SYSTEM_OUT_OF_MEM;
2156         }
2157
2158         memcpy((void*)gpin, (const void*)new_pin_data->pw, new_pin_data->pw_len);
2159         memcpy((void*)gpuk, (const void*)puk_data->pw, puk_data->pw_len);
2160
2161         param = g_variant_new("(iss)", puk_data->type, gpuk, gpin);
2162
2163         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2164                         DBUS_TELEPHONY_SIM_INTERFACE, "VerifyPUK", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
2165                         handle->ca, on_response_verify_sim_puks, evt_cb_data);
2166
2167         if (gpin)
2168                 free(gpin);
2169
2170         if (gpuk)
2171                 free(gpuk);
2172
2173         return TAPI_API_SUCCESS;
2174 }
2175
2176 EXPORT_API int tel_change_sim_pins(TapiHandle *handle, const TelSimSecPw_t *old_pin,
2177                 const TelSimSecPw_t *new_pin, tapi_response_cb callback, void *user_data)
2178 {
2179         struct tapi_resp_data *evt_cb_data = NULL;
2180         GVariant *param = NULL;
2181         gchar *gpin_o = NULL;
2182         gchar *gpin_n = NULL;
2183         int sim_ret = 0;
2184
2185         dbg("Func Entrance");
2186         if (_tel_check_tapi_state() != 0)
2187                 return TAPI_API_SERVICE_NOT_READY;
2188
2189         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2190
2191         sim_ret =_tel_check_sim_state(handle);
2192         if (sim_ret != TAPI_API_SUCCESS)
2193                 return sim_ret;
2194
2195         TAPI_RETURN_VAL_IF_FAIL((old_pin != NULL && new_pin != NULL), TAPI_API_INVALID_PTR);
2196         TAPI_RETURN_VAL_IF_FAIL((old_pin->pw != NULL && new_pin->pw != NULL), TAPI_API_INVALID_PTR);
2197
2198         dbg("old_pin type[%d],new_pin type[%d]", old_pin->type, new_pin->type);
2199         if ((old_pin->type != TAPI_SIM_PTYPE_PIN1) && (old_pin->type != TAPI_SIM_PTYPE_PIN2)
2200                         && (new_pin->type != TAPI_SIM_PTYPE_PIN1) && (new_pin->type != TAPI_SIM_PTYPE_PIN2))
2201                 return TAPI_API_INVALID_INPUT;
2202
2203         if (old_pin->type != new_pin->type)
2204                 return TAPI_API_INVALID_INPUT;
2205
2206         if ((old_pin->pw_len < 4) || (old_pin->pw_len > 8))
2207                 return TAPI_API_INVALID_INPUT;
2208
2209         if ((new_pin->pw_len < 4) || (new_pin->pw_len > 8))
2210                 return TAPI_API_INVALID_INPUT;
2211
2212         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2213
2214         gpin_o = calloc(old_pin->pw_len+1, 1);
2215         if (!gpin_o) {
2216                 g_free(evt_cb_data);
2217                 return TAPI_API_SYSTEM_OUT_OF_MEM;
2218         }
2219
2220         gpin_n = calloc(new_pin->pw_len+1, 1);
2221         if (!gpin_n) {
2222                 free(gpin_o);
2223                 g_free(evt_cb_data);
2224                 return TAPI_API_SYSTEM_OUT_OF_MEM;
2225         }
2226
2227         memcpy((void*)gpin_o, (const void*)old_pin->pw, old_pin->pw_len);
2228         memcpy((void*)gpin_n, (const void*)new_pin->pw, new_pin->pw_len);
2229
2230         param = g_variant_new("(iss)", old_pin->type, gpin_o, gpin_n);
2231         dbg("old_pin len[%d],new_pin len[%d]", old_pin->pw_len, new_pin->pw_len);
2232
2233         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2234                         DBUS_TELEPHONY_SIM_INTERFACE, "ChangePIN", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
2235                         handle->ca, on_response_change_sim_pins, evt_cb_data);
2236
2237         if (gpin_o)
2238                 free(gpin_o);
2239
2240         if (gpin_n)
2241                 free(gpin_n);
2242
2243         return TAPI_API_SUCCESS;
2244 }
2245
2246 EXPORT_API int tel_disable_sim_facility(TapiHandle *handle, TelSimFacilityPw_t *pw,
2247                 tapi_response_cb callback, void *user_data)
2248 {
2249         struct tapi_resp_data *evt_cb_data = NULL;
2250         GVariant *param = NULL;
2251         gchar *gpw = NULL;
2252         int sim_ret = 0;
2253
2254         dbg("Func Entrance");
2255         if (_tel_check_tapi_state() != 0)
2256                 return TAPI_API_SERVICE_NOT_READY;
2257
2258         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2259
2260         sim_ret =_tel_check_sim_state(handle);
2261         if (sim_ret != TAPI_API_SUCCESS)
2262                 return sim_ret;
2263
2264         TAPI_RETURN_VAL_IF_FAIL(pw, TAPI_API_INVALID_PTR);
2265         TAPI_RETURN_VAL_IF_FAIL(pw->pw, TAPI_API_INVALID_PTR);
2266
2267         dbg("facility type[%d]", pw->lock_type);
2268         if(pw->lock_type < TAPI_SIM_LOCK_PS || pw->lock_type >TAPI_SIM_LOCK_PC)
2269                 return TAPI_API_INVALID_INPUT;
2270         if ((pw->lock_type < TAPI_SIM_LOCK_PN) && ((pw->pw_len < 4) || (pw->pw_len > 8)) )
2271                 return TAPI_API_INVALID_INPUT;
2272         if ((pw->lock_type > TAPI_SIM_LOCK_FD) && (pw->pw_len < 6) )
2273                 return TAPI_API_INVALID_INPUT;
2274
2275         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2276
2277         gpw = calloc(pw->pw_len+1, 1);
2278         if (!gpw) {
2279                 g_free(evt_cb_data);
2280                 return TAPI_API_SYSTEM_OUT_OF_MEM;
2281         }
2282
2283         memcpy((void*)gpw, (const void*)pw->pw, pw->pw_len);
2284
2285         param = g_variant_new("(is)", pw->lock_type, gpw);
2286
2287         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2288                         DBUS_TELEPHONY_SIM_INTERFACE, "DisableFacility", param, NULL, G_DBUS_CALL_FLAGS_NONE,
2289                         -1, handle->ca, on_response_disable_sim_facility, evt_cb_data);
2290
2291         if (gpw)
2292                 free(gpw);
2293
2294         return TAPI_API_SUCCESS;
2295 }
2296
2297 EXPORT_API int tel_enable_sim_facility(TapiHandle *handle, TelSimFacilityPw_t *pw,
2298                 tapi_response_cb callback, void *user_data)
2299 {
2300         struct tapi_resp_data *evt_cb_data = NULL;
2301         GVariant *param = NULL;
2302         gchar *gpw = NULL;
2303         int sim_ret = 0;
2304
2305         dbg("Func Entrance");
2306         if (_tel_check_tapi_state() != 0)
2307                 return TAPI_API_SERVICE_NOT_READY;
2308
2309         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2310
2311         sim_ret =_tel_check_sim_state(handle);
2312         if (sim_ret != TAPI_API_SUCCESS)
2313                 return sim_ret;
2314
2315         TAPI_RETURN_VAL_IF_FAIL(pw, TAPI_API_INVALID_PTR);
2316         TAPI_RETURN_VAL_IF_FAIL(pw->pw, TAPI_API_INVALID_PTR);
2317
2318         dbg("facility type[%d]", pw->lock_type);
2319         if(pw->lock_type < TAPI_SIM_LOCK_PS || pw->lock_type >TAPI_SIM_LOCK_PC)
2320                 return TAPI_API_INVALID_INPUT;
2321         if ((pw->lock_type < TAPI_SIM_LOCK_PN) && ((pw->pw_len < 4) || (pw->pw_len > 8)) )
2322                 return TAPI_API_INVALID_INPUT;
2323         if ((pw->lock_type > TAPI_SIM_LOCK_FD) && (pw->pw_len < 6) )
2324                 return TAPI_API_INVALID_INPUT;
2325
2326         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2327
2328         gpw = calloc(pw->pw_len+1, 1);
2329         if (!gpw) {
2330                 g_free(evt_cb_data);
2331                 return TAPI_API_SYSTEM_OUT_OF_MEM;
2332         }
2333
2334         memcpy((void*)gpw, (const void*)pw->pw, pw->pw_len);
2335
2336         param = g_variant_new("(is)", pw->lock_type, gpw);
2337
2338         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2339                         DBUS_TELEPHONY_SIM_INTERFACE, "EnableFacility", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
2340                         handle->ca, on_response_enable_sim_facility, evt_cb_data);
2341
2342         if (gpw)
2343                 free(gpw);
2344
2345         return TAPI_API_SUCCESS;
2346 }
2347
2348 EXPORT_API int tel_get_sim_facility(TapiHandle *handle, TelSimLockType_t type,
2349                 tapi_response_cb callback, void *user_data)
2350 {
2351         struct tapi_resp_data *evt_cb_data = NULL;
2352         GVariant *param = NULL;
2353         int sim_ret = 0;
2354
2355         dbg("Func Entrance");
2356         if (_tel_check_tapi_state() != 0)
2357                 return TAPI_API_SERVICE_NOT_READY;
2358
2359         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2360
2361         sim_ret =_tel_check_sim_state(handle);
2362         if (sim_ret != TAPI_API_SUCCESS)
2363                 return sim_ret;
2364
2365         dbg("facility type[%d]", type);
2366         if(type < TAPI_SIM_LOCK_PS || type >TAPI_SIM_LOCK_PC)
2367                 return TAPI_API_INVALID_INPUT;
2368
2369         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2370
2371         param = g_variant_new("(i)", type);
2372
2373         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2374                         DBUS_TELEPHONY_SIM_INTERFACE, "GetFacility", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
2375                         handle->ca, on_response_get_sim_facility, evt_cb_data);
2376
2377         return TAPI_API_SUCCESS;
2378 }
2379
2380 EXPORT_API int tel_get_sim_lock_info(TapiHandle *handle, TelSimLockType_t type,
2381                 tapi_response_cb callback, void *user_data)
2382 {
2383         struct tapi_resp_data *evt_cb_data = NULL;
2384         GVariant *param = NULL;
2385         int sim_ret = 0;
2386
2387         dbg("Func Entrance");
2388         if (_tel_check_tapi_state() != 0)
2389                 return TAPI_API_SERVICE_NOT_READY;
2390
2391         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2392
2393         sim_ret =_tel_check_sim_state(handle);
2394         if (sim_ret != TAPI_API_SUCCESS && sim_ret != TAPI_API_SIM_LOCKED)
2395                 return sim_ret;
2396
2397         dbg("lock type[%d]", type);
2398         if(type < TAPI_SIM_LOCK_PS || type >TAPI_SIM_LOCK_PC)
2399                 return TAPI_API_INVALID_INPUT;
2400
2401         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2402
2403         param = g_variant_new("(i)", type);
2404
2405         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2406                         DBUS_TELEPHONY_SIM_INTERFACE, "GetLockInfo", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
2407                         handle->ca, on_response_get_sim_lock_info, evt_cb_data);
2408
2409         return TAPI_API_SUCCESS;
2410 }
2411
2412 EXPORT_API int tel_req_sim_apdu(TapiHandle *handle, TelSimApdu_t* apdu_data,
2413                 tapi_response_cb callback, void *user_data)
2414 {
2415         struct tapi_resp_data *evt_cb_data = NULL;
2416         GVariantBuilder *builder = NULL;
2417         GVariant *param = NULL;
2418         GVariant *inner_gv = NULL;
2419         int i = 0;
2420         int sim_ret = 0;
2421
2422         dbg("Func Entrance");
2423         if (_tel_check_tapi_state() != 0)
2424                 return TAPI_API_SERVICE_NOT_READY;
2425
2426         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2427
2428         sim_ret =_tel_check_sim_state(handle);
2429         if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
2430                 return sim_ret;
2431
2432         TAPI_RETURN_VAL_IF_FAIL(apdu_data, TAPI_API_INVALID_PTR);
2433         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2434
2435         builder = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
2436         for (i = 0; i < apdu_data->apdu_len; i++) {
2437                 dbg("apdu_data->apdu[%d][0x%02x]", i,apdu_data->apdu[i]);
2438                 g_variant_builder_add(builder, "y", apdu_data->apdu[i]);
2439         }
2440         inner_gv = g_variant_builder_end(builder);
2441         param = g_variant_new("(v)", inner_gv);
2442         /*g_variant_builder_unref (builder);*/
2443
2444         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2445                         DBUS_TELEPHONY_SIM_INTERFACE, "TransferAPDU", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
2446                         handle->ca, on_response_req_sim_apdu, evt_cb_data);
2447
2448         return TAPI_API_SUCCESS;
2449 }
2450
2451 EXPORT_API int tel_req_sim_atr(TapiHandle *handle, tapi_response_cb callback, void *user_data)
2452 {
2453         struct tapi_resp_data *evt_cb_data = NULL;
2454         int sim_ret = 0;
2455
2456         dbg("Func Entrance");
2457         if (_tel_check_tapi_state() != 0)
2458                 return TAPI_API_SERVICE_NOT_READY;
2459
2460         TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2461
2462         sim_ret =_tel_check_sim_state(handle);
2463         if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
2464                 return sim_ret;
2465
2466         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2467
2468         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2469                         DBUS_TELEPHONY_SIM_INTERFACE, "GetATR", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
2470                         on_response_req_sim_atr, evt_cb_data);
2471
2472         return TAPI_API_SUCCESS;
2473 }