src/tapi_sim.c

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