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