src/sim.c

   1 /*
   2  * tel-plugin-dbus-tapi
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <stdlib.h>
  24 #include <errno.h>
  25 #include <glib.h>
  26 #include <gio/gio.h>
  27
  28 #include <tcore.h>
  29 #include <server.h>
  30 #include <plugin.h>
  31 #include <hal.h>
  32 #include <communicator.h>
  33 #include <core_object.h>
  34 #include <queue.h>
  35 #include <user_request.h>
  36 #include <util.h>
  37 #include <co_sim.h>
  38
  39 #include "generated-code.h"
  40 #include "common.h"
  41
  42 #define DBUS_SIM_STATUS_ERROR "SIM STATUS ERROR"
  43 #define DBUS_SIM_NOT_FOUND "SIM NOT FOUND"
  44 #define DBUS_SIM_PERM_BLOCKED "SIM PERM BLOCKED"
  45 #define DBUS_SIM_CARD_ERROR "SIM CARD ERROR"
  46 #define DBUS_SIM_NOT_INITIALIZED "SIM NOT INITIALIZED"
  47 #define DBUS_SIM_INIT_COMPLETED "SIM INIT COMPLETED"
  48 #define DBUS_SIM_LOCKED "SIM LOCKED"
  49 #define DBUS_SIM_NOT_READY "SIM NOT READY"
  50 #define DBUS_SIM_RESPONSE_DATA_ERROR "SIM RESPONSE DATA ERROR"
  51 #define DBUS_SIM_SERVICE_IS_DISABLED "SIM SERVICE IS DISABLED"
  52
  53 #define DBUS_SIM_GET_COSIM(invocation, co_sim, server) { \
  54         co_sim = __get_sim_co_by_cp_name(server, GET_CP_NAME(invocation)); \
  55         if (!co_sim) { \
  56                 err("SIM Core object is NULL"); \
  57                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED); \
  58                 return TRUE; \
  59         } \
  60 }
  61
  62 #define DBUS_SIM_CHECK_SIM_STATUS(op_type, co_sim) {\
  63         if (__check_sim_state(op_type, tcore_sim_get_status(co_sim)) == FALSE) { \
  64                 err("Invalid SIM status"); \
  65                 __return_fail_response(invocation, tcore_sim_get_status(co_sim)); \
  66                 return TRUE; \
  67         } \
  68 }
  69
  70 #define DBUS_SIM_CHECK_SIM_SERVICE_TABLE(op_type, co_sim) {\
  71         gboolean b_cphs = FALSE; \
  72         b_cphs = tcore_sim_get_cphs_status(co_sim); \
  73         if (b_cphs && op_type != GET_MSISDN) { \
  74                 dbg("CPHS SIM... Do not check SST"); \
  75         } else { \
  76                 struct tel_sim_service_table* svct = tcore_sim_get_service_table(co_sim); \
  77                 if (svct != NULL) { \
  78                         if (__check_sim_service_table(op_type, svct) == FALSE) { \
  79                                 err("'Service' is disabled in SST"); \
  80                                 FAIL_RESPONSE(invocation, DBUS_SIM_SERVICE_IS_DISABLED); \
  81                                 free(svct); \
  82                                 return TRUE; \
  83                         } else { \
  84                                 dbg("Request to modem"); \
  85                                 free(svct); \
  86                         } \
  87                 } \
  88         } \
  89 }
  90
  91 #define DBUS_SIM_CHECK_DISPATCH_RET(ret, invocation, ur) {\
  92         if (ret != TCORE_RETURN_SUCCESS) { \
  93                 if (ret == TCORE_RETURN_SIM_DISABLED_IN_SST) { \
  94                         err("'Service' is disabled in SST"); \
  95                         FAIL_RESPONSE (invocation, DBUS_SIM_SERVICE_IS_DISABLED); \
  96                 } else { \
  97                         err("Dispatch request failed: [0x%x]", ret); \
  98                         FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED); \
  99                 } \
 100                 tcore_user_request_unref(ur); \
 101         } \
 102 }
 103
 104 enum dbus_tapi_sim_gdbus_method_name {
 105         GET_INIT_STATUS = 1,
 106         GET_CARD_TYPE,
 107         GET_IMSI,
 108         GET_ECC,
 109         GET_ICCID = 5,
 110         GET_LANGUAGE,
 111         SET_LANGUAGE,
 112         GET_CALL_FORWARDING,
 113         SET_CALL_FORWARDING,
 114         GET_MESSAGE_WAITING = 10,
 115         SET_MESSAGE_WAITING,
 116         GET_MAILBOX,
 117         SET_MAILBOX,
 118         GET_CPHS_INFO,
 119         GET_SVCT = 15,
 120         GET_MSISDN,
 121         GET_OPLMWACT,
 122         GET_SPN,
 123         GET_CPHS_NET_NAME,
 124         AUTHENTICATION = 20,
 125         VERIFY_SEC,
 126         VERIFY_PUK,
 127         CHANGE_PIN,
 128         DISABLE_FACILITY,
 129         ENABLE_FACILITY = 25,
 130         GET_FACILITY,
 131         GET_LOCK_INFO,
 132         TRANSFER_APDU,
 133         GET_ATR,
 134         GET_FIELDS = 30,        //for get various data at once
 135         GET_GID,
 136         SET_POWERSTATE,
 137
 138         //for notification
 139         STATUS = 100,
 140         REFRESHED,
 141 };
 142
 143 #if 0
 144 static gboolean __is_valid_sim_status(enum tel_sim_status sim_status)
 145 {
 146         switch(sim_status) {
 147         case SIM_STATUS_INIT_COMPLETED:
 148         case SIM_STATUS_INITIALIZING:
 149         case SIM_STATUS_PIN_REQUIRED:
 150         case SIM_STATUS_PUK_REQUIRED:
 151         case SIM_STATUS_LOCK_REQUIRED:
 152         case SIM_STATUS_CARD_BLOCKED:
 153         case SIM_STATUS_NCK_REQUIRED:
 154         case SIM_STATUS_NSCK_REQUIRED:
 155         case SIM_STATUS_SPCK_REQUIRED:
 156         case SIM_STATUS_CCK_REQUIRED:
 157                 return TRUE;
 158         default:
 159                 return FALSE;
 160         }
 161 }
 162 #endif
 163
 164 static CoreObject *__get_sim_co_by_cp_name(Server *server, char *cp_name)
 165 {
 166         TcorePlugin *plugin = NULL;
 167
 168         if (!server) {
 169                 err("server is NULL");
 170                 return NULL;
 171         }
 172
 173         plugin = tcore_server_find_plugin(server, cp_name);
 174         return tcore_plugin_ref_core_object(plugin, CORE_OBJECT_TYPE_SIM);
 175 }
 176
 177 static CoreObject* __get_sim_co_from_ur(Server *server, UserRequest *ur)
 178 {
 179         CoreObject *co_sim = NULL;
 180         char *modem_name = NULL;
 181
 182         modem_name = tcore_user_request_get_modem_name(ur);
 183         if (!modem_name) {
 184                 err("Modem name is NULL");
 185                 return co_sim;
 186         }
 187
 188         co_sim = __get_sim_co_by_cp_name(server, modem_name);
 189         free(modem_name);
 190
 191         return co_sim;
 192 }
 193
 194 static gboolean __check_sim_state(enum dbus_tapi_sim_gdbus_method_name method, enum tel_sim_status sim_status)
 195 {
 196         gboolean ret = TRUE;
 197
 198         if ((int)sim_status < SIM_STATUS_CARD_ERROR) {
 199                 err("SIM status is NOT valid");
 200                 return FALSE;
 201         }
 202
 203         switch (method) {
 204         case GET_CARD_TYPE:
 205         case GET_ECC:
 206         case GET_ICCID:
 207         case GET_LANGUAGE:
 208         case GET_CPHS_INFO:
 209         case GET_SPN:
 210         case AUTHENTICATION:
 211         case TRANSFER_APDU:
 212         case GET_ATR:
 213         // Regarding Lock facilities
 214         case CHANGE_PIN:
 215         case ENABLE_FACILITY:
 216         case DISABLE_FACILITY:
 217         case GET_FACILITY:
 218         case GET_LOCK_INFO:
 219         case VERIFY_SEC:
 220         case VERIFY_PUK:
 221                 if (sim_status == SIM_STATUS_CARD_ERROR
 222                                 || sim_status == SIM_STATUS_CARD_BLOCKED
 223                                 || sim_status == SIM_STATUS_CARD_NOT_PRESENT
 224                                 || sim_status == SIM_STATUS_CARD_REMOVED
 225                                 || sim_status == SIM_STATUS_UNKNOWN
 226                                 || sim_status == SIM_STATUS_CARD_POWEROFF) {
 227                         ret = FALSE;
 228                 }
 229         break;
 230         case GET_IMSI:
 231         case GET_SVCT:
 232         case GET_MSISDN:
 233         case GET_OPLMWACT:
 234         case GET_CPHS_NET_NAME:
 235         case GET_CALL_FORWARDING:
 236         case SET_CALL_FORWARDING:
 237         case GET_MESSAGE_WAITING:
 238         case SET_MESSAGE_WAITING:
 239         case GET_MAILBOX:
 240         case SET_MAILBOX:
 241         case SET_LANGUAGE:
 242         case GET_FIELDS:
 243         case GET_GID:
 244                 if (sim_status != SIM_STATUS_INIT_COMPLETED) {
 245                         ret = FALSE;
 246                 }
 247         break;
 248         case SET_POWERSTATE:
 249                 if (sim_status != SIM_STATUS_INIT_COMPLETED
 250                                 && sim_status != SIM_STATUS_INITIALIZING
 251                                 && sim_status != SIM_STATUS_PIN_REQUIRED
 252                                 && sim_status != SIM_STATUS_CARD_BLOCKED
 253                                 && sim_status != SIM_STATUS_CARD_POWEROFF) {
 254                         ret = FALSE;
 255                 }
 256         break;
 257         case GET_INIT_STATUS:
 258         case STATUS:
 259         case REFRESHED:
 260         default:
 261                 err("Unhandled/Unknown operation: [%d]", method);
 262         break;
 263         }
 264         return ret;
 265 }
 266
 267 static gboolean __check_sim_service_table(enum dbus_tapi_sim_gdbus_method_name method, struct tel_sim_service_table *svct)
 268 {
 269         gboolean ret = TRUE;
 270
 271         switch (method) {
 272         case GET_MSISDN:
 273                 if ( !(svct->sim_type == SIM_TYPE_GSM && svct->table.sst.service[SIM_SST_MSISDN]) &&
 274                                 !(svct->sim_type == SIM_TYPE_USIM && svct->table.ust.service[SIM_UST_MSISDN]) ) {
 275                         ret = FALSE;
 276                 }
 277         break;
 278         case GET_CALL_FORWARDING:
 279         case SET_CALL_FORWARDING:
 280                 if ( !(svct->sim_type == SIM_TYPE_GSM && svct->table.sst.service[SIM_SST_CFIS]) &&
 281                                 !(svct->sim_type == SIM_TYPE_USIM && svct->table.ust.service[SIM_UST_CFIS]) ) {
 282                         ret = FALSE;
 283                 }
 284         break;
 285         case GET_MESSAGE_WAITING:
 286         case SET_MESSAGE_WAITING:
 287                 if ( !(svct->sim_type == SIM_TYPE_GSM && svct->table.sst.service[SIM_SST_MWIS]) &&
 288                                 !(svct->sim_type == SIM_TYPE_USIM && svct->table.ust.service[SIM_UST_MWIS]) ) {
 289                         ret = FALSE;
 290                 }
 291         break;
 292         case GET_MAILBOX:
 293         case SET_MAILBOX:
 294                 if ( !(svct->sim_type == SIM_TYPE_GSM && svct->table.sst.service[SIM_SST_MBDN]) &&
 295                                 !(svct->sim_type == SIM_TYPE_USIM && svct->table.ust.service[SIM_UST_MBDN]) ) {
 296                         ret = FALSE;
 297                 }
 298         break;
 299         default:
 300                 err("Unhandled/Unknown operation: [%d]", method);
 301         break;
 302         }
 303
 304         return ret;
 305 }
 306
 307 static void __return_fail_response(GDBusMethodInvocation *invocation, enum tel_sim_status sim_status)
 308 {
 309         dbg("SIM Status: [%d]", sim_status);
 310
 311         switch (sim_status) {
 312         case SIM_STATUS_CARD_NOT_PRESENT:
 313         case SIM_STATUS_CARD_REMOVED:
 314                 FAIL_RESPONSE(invocation, DBUS_SIM_NOT_FOUND);
 315         break;
 316         case SIM_STATUS_CARD_BLOCKED:
 317                 FAIL_RESPONSE(invocation, DBUS_SIM_PERM_BLOCKED);
 318         break;
 319         case SIM_STATUS_CARD_ERROR:
 320         case SIM_STATUS_CARD_CRASHED:
 321                 FAIL_RESPONSE(invocation, DBUS_SIM_CARD_ERROR);
 322         break;
 323         case SIM_STATUS_INITIALIZING:
 324                 FAIL_RESPONSE(invocation, DBUS_SIM_NOT_INITIALIZED);
 325         break;
 326         case SIM_STATUS_INIT_COMPLETED:
 327                 FAIL_RESPONSE(invocation, DBUS_SIM_INIT_COMPLETED);
 328         break;
 329         case SIM_STATUS_PIN_REQUIRED:
 330         case SIM_STATUS_PUK_REQUIRED:
 331         case SIM_STATUS_NCK_REQUIRED:
 332         case SIM_STATUS_NSCK_REQUIRED:
 333         case SIM_STATUS_SPCK_REQUIRED:
 334         case SIM_STATUS_CCK_REQUIRED:
 335         case SIM_STATUS_LOCK_REQUIRED:
 336                 FAIL_RESPONSE(invocation, DBUS_SIM_LOCKED);
 337         break;
 338         case SIM_STATUS_UNKNOWN:
 339                 FAIL_RESPONSE(invocation, DBUS_SIM_NOT_READY);
 340         break;
 341         default:
 342                 dbg("Unhandled/Unknown status: [%d]", sim_status);
 343                 FAIL_RESPONSE(invocation, DBUS_SIM_STATUS_ERROR);
 344         break;
 345         }
 346 }
 347
 348 static gboolean on_sim_get_init_status(TelephonySim *sim, GDBusMethodInvocation *invocation,
 349         gpointer user_data)
 350 {
 351         struct custom_data *ctx = user_data;
 352         enum tel_sim_status sim_status = SIM_STATUS_UNKNOWN;
 353         gboolean sim_changed = FALSE;
 354         CoreObject *co_sim = NULL;
 355
 356         if (!check_access_control (invocation, AC_SIM, "r"))
 357                 return TRUE;
 358
 359         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
 360
 361         sim_status = tcore_sim_get_status(co_sim);
 362         sim_changed = tcore_sim_get_identification(co_sim);
 363         dbg("SIM - Status: [%d] Changed: [%s]",
 364                 sim_status, (sim_changed ? "Yes" : "No"));
 365
 366         telephony_sim_complete_get_init_status(sim, invocation, sim_status, sim_changed);
 367
 368         return TRUE;
 369 }
 370
 371 static gboolean on_sim_get_card_type(TelephonySim *sim, GDBusMethodInvocation *invocation,
 372         gpointer user_data)
 373 {
 374         struct custom_data *ctx = user_data;
 375         enum tel_sim_type sim_type = SIM_TYPE_UNKNOWN;
 376         CoreObject *co_sim = NULL;
 377
 378         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
 379         DBUS_SIM_CHECK_SIM_STATUS(GET_CARD_TYPE, co_sim);
 380
 381         sim_type = tcore_sim_get_type(co_sim);
 382
 383         telephony_sim_complete_get_card_type(sim, invocation, sim_type);
 384
 385         return TRUE;
 386 }
 387
 388 static gboolean on_sim_get_imsi(TelephonySim *sim, GDBusMethodInvocation *invocation,
 389                 gpointer user_data)
 390 {
 391         struct custom_data *ctx = user_data;
 392         struct tel_sim_imsi *n_imsi;
 393         CoreObject *co_sim = NULL;
 394
 395         if (!check_access_control (invocation, AC_SIM, "r"))
 396                 return TRUE;
 397
 398         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
 399         DBUS_SIM_CHECK_SIM_STATUS(GET_IMSI, co_sim);
 400
 401         n_imsi = tcore_sim_get_imsi(co_sim);
 402         if (!n_imsi) {
 403                 FAIL_RESPONSE (invocation, DBUS_SIM_RESPONSE_DATA_ERROR);
 404                 return TRUE;
 405         } else {
 406                 telephony_sim_complete_get_imsi(sim, invocation, n_imsi->plmn, n_imsi->msin);
 407                 free(n_imsi);
 408         }
 409
 410         return TRUE;
 411 }
 412
 413 static gboolean on_sim_get_ecc(TelephonySim *sim, GDBusMethodInvocation *invocation,
 414                 gpointer user_data)
 415 {
 416         struct custom_data *ctx = user_data;
 417         CoreObject *co_sim = NULL;
 418         struct tel_sim_ecc_list *ecc_list = NULL;
 419
 420         if (!check_access_control (invocation, AC_SIM, "r"))
 421                 return TRUE;
 422
 423         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
 424         DBUS_SIM_CHECK_SIM_STATUS(GET_ECC, co_sim);
 425
 426         ecc_list = tcore_sim_get_ecc_list(co_sim);
 427         if (!ecc_list) {
 428                 UserRequest *ur = NULL;
 429                 TReturn ret;
 430                 dbg("po->ecc_list is NULL. Request to Modem.");
 431                 ur = MAKE_UR(ctx, sim, invocation);
 432                 tcore_user_request_set_command(ur, TREQ_SIM_GET_ECC);
 433                 ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 434                 if (ret != TCORE_RETURN_SUCCESS) {
 435                         FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 436                         dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 437                         tcore_user_request_unref(ur);
 438                 }
 439         } else {
 440                 GVariant *gv = NULL;
 441                 GVariantBuilder b;
 442                 int i;
 443                 g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 444                 for (i = 0; i<ecc_list->ecc_count; i++) {
 445                         dbg("ecc[%d] : ecc_category=[0x%x], ecc_num=[%s], ecc_string=[%s]",
 446                                         i, ecc_list->ecc[i].ecc_category, ecc_list->ecc[i].ecc_num, ecc_list->ecc[i].ecc_string);
 447                         g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 448                         g_variant_builder_add(&b, "{sv}", "category", g_variant_new_int32(ecc_list->ecc[i].ecc_category));
 449                         g_variant_builder_add(&b, "{sv}", "number", g_variant_new_string(ecc_list->ecc[i].ecc_num));
 450                         g_variant_builder_add(&b, "{sv}", "name", g_variant_new_string(ecc_list->ecc[i].ecc_string));
 451                         g_variant_builder_close(&b);
 452                 }
 453                 gv = g_variant_builder_end(&b);
 454                 if (!gv)
 455                         dbg("error - ecc gv is NULL");
 456
 457                 telephony_sim_complete_get_ecc(sim, invocation, gv);
 458
 459                 free(ecc_list);
 460         }
 461
 462         return TRUE;
 463 }
 464
 465 static gboolean on_sim_get_iccid(TelephonySim *sim, GDBusMethodInvocation *invocation,
 466                 gpointer user_data)
 467 {
 468         struct custom_data *ctx = user_data;
 469         UserRequest *ur = NULL;
 470         TReturn ret;
 471         CoreObject *co_sim = NULL;
 472         struct tel_sim_iccid* iccid = NULL;
 473
 474         dbg("Func Entrance");
 475
 476         if (!check_access_control (invocation, AC_SIM, "r"))
 477                 return TRUE;
 478
 479         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
 480         DBUS_SIM_CHECK_SIM_STATUS(GET_ICCID, co_sim);
 481
 482         iccid = tcore_sim_get_iccid(co_sim);
 483
 484         if (!iccid) {
 485                 ur = MAKE_UR(ctx, sim, invocation);
 486
 487                 tcore_user_request_set_command(ur, TREQ_SIM_GET_ICCID);
 488                 ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 489
 490                 if (ret != TCORE_RETURN_SUCCESS) {
 491                         FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 492                         dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 493                         tcore_user_request_unref(ur);
 494                 }
 495         } else {
 496                 telephony_sim_complete_get_iccid(sim, invocation, SIM_ACCESS_SUCCESS,
 497                                                                                 iccid->iccid);
 498                 free(iccid);
 499         }
 500
 501         return TRUE;
 502 }
 503
 504 static gboolean on_sim_get_language(TelephonySim *sim, GDBusMethodInvocation *invocation,
 505                 gpointer user_data)
 506 {
 507         struct custom_data *ctx = user_data;
 508         UserRequest *ur = NULL;
 509         TReturn ret;
 510         CoreObject *co_sim = NULL;
 511
 512         if (!check_access_control (invocation, AC_SIM, "r"))
 513                 return TRUE;
 514
 515         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
 516         DBUS_SIM_CHECK_SIM_STATUS(GET_LANGUAGE, co_sim);
 517
 518         ur = MAKE_UR(ctx, sim, invocation);
 519
 520         tcore_user_request_set_command(ur, TREQ_SIM_GET_LANGUAGE);
 521         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 522         if (ret != TCORE_RETURN_SUCCESS) {
 523                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 524                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 525                 tcore_user_request_unref(ur);
 526         }
 527
 528         return TRUE;
 529 }
 530
 531 static gboolean on_sim_set_language(TelephonySim *sim, GDBusMethodInvocation *invocation,
 532                 gint arg_language, gpointer user_data)
 533 {
 534         struct custom_data *ctx = user_data;
 535         UserRequest *ur = NULL;
 536         TReturn ret;
 537         CoreObject *co_sim = NULL;
 538         struct treq_sim_set_language set_language;
 539
 540         if (!check_access_control (invocation, AC_SIM, "w"))
 541                 return TRUE;
 542
 543         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
 544         DBUS_SIM_CHECK_SIM_STATUS(SET_LANGUAGE, co_sim);
 545
 546         memset(&set_language, 0, sizeof(struct treq_sim_set_language));
 547         set_language.language = arg_language;
 548
 549         dbg("set_language.language[%d]", set_language.language);
 550         ur = MAKE_UR(ctx, sim, invocation);
 551
 552         tcore_user_request_set_data(ur, sizeof(struct treq_sim_set_language), &set_language);
 553         tcore_user_request_set_command(ur, TREQ_SIM_SET_LANGUAGE);
 554         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 555         if (ret != TCORE_RETURN_SUCCESS) {
 556                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 557                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 558                 tcore_user_request_unref(ur);
 559         }
 560
 561         return TRUE;
 562 }
 563
 564 static gboolean on_sim_get_call_forwarding(TelephonySim *sim, GDBusMethodInvocation *invocation,
 565                 gpointer user_data)
 566 {
 567         struct custom_data *ctx = user_data;
 568         UserRequest *ur = NULL;
 569         TReturn ret;
 570         CoreObject *co_sim = NULL;
 571
 572         if (!check_access_control (invocation, AC_SIM, "r"))
 573                 return TRUE;
 574
 575         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
 576         DBUS_SIM_CHECK_SIM_STATUS(GET_CALL_FORWARDING, co_sim);
 577         DBUS_SIM_CHECK_SIM_SERVICE_TABLE(GET_CALL_FORWARDING, co_sim);
 578
 579         ur = MAKE_UR(ctx, sim, invocation);
 580         tcore_user_request_set_command(ur, TREQ_SIM_GET_CALLFORWARDING);
 581
 582         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 583         DBUS_SIM_CHECK_DISPATCH_RET(ret, invocation, ur);
 584
 585         return TRUE;
 586 }
 587
 588 static gboolean on_sim_set_call_forwarding(TelephonySim *sim, GDBusMethodInvocation *invocation,
 589                 gboolean  arg_cphs,
 590                 gint arg_rec_index,
 591                 gint arg_msp_num,
 592                 guchar arg_cfu_status,
 593                 gint arg_ton,
 594                 gint arg_npi,
 595                 const gchar *arg_number,
 596                 gint arg_cc2_id,
 597                 gint arg_ext7_id,
 598                 gboolean arg_cphs_line1,
 599                 gboolean arg_cphs_line2,
 600                 gboolean arg_cphs_fax,
 601                 gboolean arg_cphs_data,
 602                 gpointer user_data)
 603 {
 604         struct custom_data *ctx = user_data;
 605         UserRequest *ur = NULL;
 606         TReturn ret;
 607         CoreObject *co_sim = NULL;
 608         struct treq_sim_set_callforwarding req_cf;
 609
 610         if (!check_access_control (invocation, AC_SIM, "w"))
 611                 return TRUE;
 612
 613         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
 614         DBUS_SIM_CHECK_SIM_STATUS(SET_CALL_FORWARDING, co_sim);
 615         DBUS_SIM_CHECK_SIM_SERVICE_TABLE(SET_CALL_FORWARDING, co_sim);
 616
 617         ur = MAKE_UR(ctx, sim, invocation);
 618
 619         memset(&req_cf, 0, sizeof(struct treq_sim_set_callforwarding));
 620
 621         req_cf.b_cphs = arg_cphs;
 622
 623         if (req_cf.b_cphs) {
 624                 req_cf.cphs_cf.b_line1 = arg_cphs_line1;
 625                 req_cf.cphs_cf.b_line2 = arg_cphs_line2;
 626                 req_cf.cphs_cf.b_fax = arg_cphs_fax;
 627                 req_cf.cphs_cf.b_data = arg_cphs_data;
 628                 dbg("b_line1[%d], b_line2[%d], b_fax[%d], b_data[%d]",
 629                                 req_cf.cphs_cf.b_line1, req_cf.cphs_cf.b_line2,
 630                                 req_cf.cphs_cf.b_fax, req_cf.cphs_cf.b_data);
 631         } else {
 632                 req_cf.cf.rec_index = arg_rec_index;
 633                 req_cf.cf.msp_num = arg_msp_num;
 634                 req_cf.cf.cfu_status = arg_cfu_status;
 635                 req_cf.cf.ton = arg_ton;
 636                 req_cf.cf.npi = arg_npi;
 637                 memcpy(&req_cf.cf.cfu_num, arg_number, strlen(arg_number));
 638                 req_cf.cf.cc2_id = arg_cc2_id;
 639                 req_cf.cf.ext7_id = arg_ext7_id;
 640                 dbg("rec_index[%d], msp_num[%d], cfu_status[0x%x], ton[%d], "
 641                                 "npi[%d], cfu_num[%s], cc2_id[%d], ext7_id[%d]",
 642                                 req_cf.cf.rec_index, req_cf.cf.msp_num, req_cf.cf.cfu_status, req_cf.cf.ton,
 643                                 req_cf.cf.npi, req_cf.cf.cfu_num, req_cf.cf.cc2_id, req_cf.cf.ext7_id);
 644         }
 645
 646         tcore_user_request_set_data(ur, sizeof(struct treq_sim_set_callforwarding), &req_cf);
 647         tcore_user_request_set_command(ur, TREQ_SIM_SET_CALLFORWARDING);
 648
 649         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 650         DBUS_SIM_CHECK_DISPATCH_RET(ret, invocation, ur);
 651
 652         return TRUE;
 653 }
 654
 655 static gboolean on_sim_get_message_waiting(TelephonySim *sim, GDBusMethodInvocation *invocation,
 656                 gpointer user_data)
 657 {
 658         struct custom_data *ctx = user_data;
 659         UserRequest *ur = NULL;
 660         TReturn ret;
 661         CoreObject *co_sim = NULL;
 662
 663         if (!check_access_control (invocation, AC_SIM, "r"))
 664                 return TRUE;
 665
 666         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
 667         DBUS_SIM_CHECK_SIM_STATUS(GET_MESSAGE_WAITING, co_sim);
 668         DBUS_SIM_CHECK_SIM_SERVICE_TABLE(GET_MESSAGE_WAITING, co_sim);
 669
 670         ur = MAKE_UR(ctx, sim, invocation);
 671         tcore_user_request_set_command(ur, TREQ_SIM_GET_MESSAGEWAITING);
 672
 673         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 674         DBUS_SIM_CHECK_DISPATCH_RET(ret, invocation, ur);
 675
 676         return TRUE;
 677 }
 678
 679 static gboolean on_sim_set_message_waiting(TelephonySim *sim, GDBusMethodInvocation *invocation,
 680                 gboolean  arg_cphs,
 681                 gint arg_rec_index,
 682                 guchar arg_indicator_status,
 683                 gint arg_voice_cnt,
 684                 gint arg_fax_cnt,
 685                 gint arg_email_cnt,
 686                 gint arg_other_cnt,
 687                 gint arg_video_cnt,
 688                 gboolean arg_cphs_voice1,
 689                 gboolean arg_cphs_voice2,
 690                 gboolean arg_cphs_fax,
 691                 gboolean arg_cphs_data,
 692                 gpointer user_data)
 693 {
 694         struct custom_data *ctx = user_data;
 695         UserRequest *ur = NULL;
 696         TReturn ret;
 697         CoreObject *co_sim = NULL;
 698         struct treq_sim_set_messagewaiting req_mw;
 699
 700         if (!check_access_control (invocation, AC_SIM, "w"))
 701                 return TRUE;
 702
 703         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
 704         DBUS_SIM_CHECK_SIM_STATUS(SET_MESSAGE_WAITING, co_sim);
 705         DBUS_SIM_CHECK_SIM_SERVICE_TABLE(SET_MESSAGE_WAITING, co_sim);
 706
 707         ur = MAKE_UR(ctx, sim, invocation);
 708
 709         memset(&req_mw, 0, sizeof(struct treq_sim_set_messagewaiting));
 710
 711         req_mw.b_cphs = arg_cphs;
 712
 713         if (req_mw.b_cphs) {
 714                 req_mw.cphs_mw.b_voice1 = arg_cphs_voice1;
 715                 req_mw.cphs_mw.b_voice2 = arg_cphs_voice2;
 716                 req_mw.cphs_mw.b_fax = arg_cphs_fax;
 717                 req_mw.cphs_mw.b_data = arg_cphs_data;
 718                 dbg("b_voice1[%d],b_voice2[%d],b_fax[%d], b_data[%d]",
 719                                 req_mw.cphs_mw.b_voice1,
 720                                 req_mw.cphs_mw.b_voice2,
 721                                 req_mw.cphs_mw.b_fax,
 722                                 req_mw.cphs_mw.b_data);
 723         } else {
 724                 req_mw.mw.rec_index = arg_rec_index;
 725                 req_mw.mw.indicator_status = arg_indicator_status;
 726                 req_mw.mw.voice_count = arg_voice_cnt;
 727                 req_mw.mw.fax_count = arg_fax_cnt;
 728                 req_mw.mw.email_count = arg_email_cnt;
 729                 req_mw.mw.other_count = arg_other_cnt;
 730                 req_mw.mw.video_count = arg_video_cnt;
 731                 dbg("rec_index[%d], indicator_status[0x%x],     voice_count[%d], fax_count[%d], email_count[%d], other_count[%d], video_count[%d]",
 732                                 req_mw.mw.rec_index,
 733                                 req_mw.mw.indicator_status,
 734                                 req_mw.mw.voice_count,
 735                                 req_mw.mw.fax_count,
 736                                 req_mw.mw.email_count,
 737                                 req_mw.mw.other_count,
 738                                 req_mw.mw.video_count);
 739         }
 740
 741         tcore_user_request_set_data(ur, sizeof(struct treq_sim_set_messagewaiting), &req_mw);
 742         tcore_user_request_set_command(ur, TREQ_SIM_SET_MESSAGEWAITING);
 743
 744         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 745         DBUS_SIM_CHECK_DISPATCH_RET(ret, invocation, ur);
 746
 747         return TRUE;
 748 }
 749
 750 static gboolean on_sim_get_mailbox(TelephonySim *sim, GDBusMethodInvocation *invocation,
 751                 gpointer user_data)
 752 {
 753         struct custom_data *ctx = user_data;
 754         UserRequest *ur = NULL;
 755         TReturn ret;
 756         CoreObject *co_sim = NULL;
 757
 758         if (!check_access_control (invocation, AC_SIM, "r"))
 759                 return TRUE;
 760
 761         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
 762         DBUS_SIM_CHECK_SIM_STATUS(GET_MAILBOX, co_sim);
 763         DBUS_SIM_CHECK_SIM_SERVICE_TABLE(GET_MAILBOX, co_sim);
 764
 765         ur = MAKE_UR(ctx, sim, invocation);
 766         tcore_user_request_set_command(ur, TREQ_SIM_GET_MAILBOX);
 767
 768         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 769         DBUS_SIM_CHECK_DISPATCH_RET(ret, invocation, ur);
 770
 771         return TRUE;
 772 }
 773
 774 static gboolean on_sim_set_mailbox(TelephonySim *sim, GDBusMethodInvocation *invocation,
 775                 gboolean arg_cphs,
 776                 gint arg_type,
 777                 gint arg_rec_index,
 778                 gint arg_profile_number,
 779                 gint arg_alpha_id_max_len,
 780                 const gchar *arg_alpha_id,
 781                 gint arg_ton,
 782                 gint arg_npi,
 783                 const gchar *arg_number,
 784                 gint arg_cc_id,
 785                 gint arg_ext1_id,
 786                 gpointer user_data)
 787 {
 788         struct custom_data *ctx = user_data;
 789         UserRequest *ur = NULL;
 790         TReturn ret;
 791         CoreObject *co_sim = NULL;
 792         struct treq_sim_set_mailbox req_mb;
 793
 794         if (!check_access_control (invocation, AC_SIM, "w"))
 795                 return TRUE;
 796
 797         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
 798         DBUS_SIM_CHECK_SIM_STATUS(SET_MAILBOX, co_sim);
 799         DBUS_SIM_CHECK_SIM_SERVICE_TABLE(SET_MAILBOX, co_sim);
 800
 801         ur = MAKE_UR(ctx, sim, invocation);
 802
 803         memset(&req_mb, 0, sizeof(struct treq_sim_set_mailbox));
 804
 805         req_mb.b_cphs = arg_cphs;
 806
 807         req_mb.mb_info.mb_type = arg_type;
 808         req_mb.mb_info.rec_index = arg_rec_index;
 809         req_mb.mb_info.profile_number = arg_profile_number;
 810         req_mb.mb_info.number_info.alpha_id_max_len = arg_alpha_id_max_len;
 811         if (strlen(arg_alpha_id))
 812                 memcpy(&req_mb.mb_info.number_info.alpha_id, arg_alpha_id, strlen(arg_alpha_id));
 813         req_mb.mb_info.number_info.ton = arg_npi;
 814         req_mb.mb_info.number_info.npi = arg_npi;
 815         if (strlen(arg_number))
 816                 memcpy(&req_mb.mb_info.number_info.num, arg_number, strlen(arg_number));
 817         req_mb.mb_info.number_info.cc_id = arg_ext1_id;
 818         req_mb.mb_info.number_info.ext1_id = arg_ext1_id;
 819
 820         dbg("b_cphs[%d] mb_type[%d], rec_index[%d], profile_number[%d], alpha_id_max_len[%d], "
 821                         "alpha_id[%s], ton[%d], npi[%d], num[%s], cc_id[%d], ext1_id[%d]",
 822                         req_mb.b_cphs,
 823                         req_mb.mb_info.mb_type,
 824                         req_mb.mb_info.rec_index,
 825                         req_mb.mb_info.profile_number,
 826                         req_mb.mb_info.number_info.alpha_id_max_len,
 827                         req_mb.mb_info.number_info.alpha_id,
 828                         req_mb.mb_info.number_info.ton,
 829                         req_mb.mb_info.number_info.npi,
 830                         req_mb.mb_info.number_info.num,
 831                         req_mb.mb_info.number_info.cc_id,
 832                         req_mb.mb_info.number_info.ext1_id)
 833
 834         tcore_user_request_set_data(ur, sizeof(struct treq_sim_set_mailbox), &req_mb);
 835         tcore_user_request_set_command(ur, TREQ_SIM_SET_MAILBOX);
 836
 837         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 838         DBUS_SIM_CHECK_DISPATCH_RET(ret, invocation, ur);
 839
 840         return TRUE;
 841 }
 842
 843 static gboolean on_sim_get_cphsinfo(TelephonySim *sim, GDBusMethodInvocation *invocation,
 844                 gpointer user_data)
 845 {
 846         struct custom_data *ctx = user_data;
 847         UserRequest *ur = NULL;
 848         TReturn ret;
 849         CoreObject *co_sim = NULL;
 850
 851         if (!check_access_control (invocation, AC_SIM, "r"))
 852                 return TRUE;
 853
 854         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
 855         DBUS_SIM_CHECK_SIM_STATUS(GET_CPHS_INFO, co_sim);
 856
 857         ur = MAKE_UR(ctx, sim, invocation);
 858
 859         tcore_user_request_set_command(ur, TREQ_SIM_GET_CPHS_INFO);
 860         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 861         if (ret != TCORE_RETURN_SUCCESS) {
 862                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 863                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 864                 tcore_user_request_unref(ur);
 865         }
 866
 867         return TRUE;
 868 }
 869
 870 static gboolean on_sim_get_service_table(TelephonySim *sim, GDBusMethodInvocation *invocation,
 871                 gpointer user_data)
 872 {
 873         struct custom_data *ctx = user_data;
 874         CoreObject *co_sim = NULL;
 875         struct tel_sim_service_table *svct = NULL;
 876
 877         if (!check_access_control (invocation, AC_SIM, "r"))
 878                 return TRUE;
 879
 880         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
 881         DBUS_SIM_CHECK_SIM_STATUS(GET_SVCT, co_sim);
 882
 883         svct = tcore_sim_get_service_table(co_sim);
 884         if (!svct) {
 885                 UserRequest *ur = NULL;
 886                 TReturn ret;
 887                 ur = MAKE_UR(ctx, sim, invocation);
 888
 889                 dbg("Not cached. Request to modem");
 890                 tcore_user_request_set_command(ur, TREQ_SIM_GET_SERVICE_TABLE);
 891                 ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 892                 if (ret != TCORE_RETURN_SUCCESS) {
 893                         FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 894                         dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 895                         tcore_user_request_unref(ur);
 896                 }
 897         } else {
 898                 GVariantBuilder builder;
 899                 GVariant * inner_gv = NULL;
 900                 GVariant *svct_gv = NULL;
 901                 int i =0;
 902                 dbg("TRESP_SIM_GET_SERVICE_TABLE");
 903
 904                 g_variant_builder_init (&builder, G_VARIANT_TYPE ("ay"));
 905                 if (svct->sim_type == SIM_TYPE_GSM) {
 906                         for (i = 0; i < SIM_SST_SERVICE_CNT_MAX; i++) {
 907                                 g_variant_builder_add (&builder, "y", svct->table.sst.service[i]);
 908                         }
 909                 } else if (svct->sim_type == SIM_TYPE_USIM) {
 910                         for (i = 0; i < SIM_UST_SERVICE_CNT_MAX; i++) {
 911                                 g_variant_builder_add (&builder, "y", svct->table.ust.service[i]);
 912                         }
 913                 } else if(svct->sim_type == SIM_TYPE_RUIM) {
 914                         if(SIM_CDMA_SVC_TABLE == svct->table.cst.cdma_svc_table) {
 915                                 for(i = 0; i < SIM_CDMA_ST_SERVICE_CNT_MAX; i++) {
 916                                         g_variant_builder_add (&builder, "iy", svct->table.cst.cdma_svc_table,
 917                                                                                         svct->table.cst.service.cdma_service[i]);
 918                                 }
 919                         } else if(SIM_CSIM_SVC_TABLE == svct->table.cst.cdma_svc_table) {
 920                                 for(i = 0; i < SIM_CSIM_ST_SERVICE_CNT_MAX; i++) {
 921                                         g_variant_builder_add (&builder, "iy", svct->table.cst.cdma_svc_table,
 922                                                                                         svct->table.cst.service.csim_service[i]);
 923                                 }
 924                         } else {
 925                                 err("Invalid cdma_svc_table:[%d]", svct->table.cst.cdma_svc_table);
 926                         }
 927                 } else {
 928                         err("Unknown SIM type: [%d]", svct->sim_type);
 929                 }
 930                 inner_gv = g_variant_builder_end(&builder);
 931                 svct_gv = g_variant_new("v", inner_gv);
 932
 933                 telephony_sim_complete_get_service_table (sim, invocation,
 934                                 SIM_ACCESS_SUCCESS,
 935                                 svct->sim_type,
 936                                 svct_gv);
 937
 938                 free(svct);
 939         }
 940         return TRUE;
 941 }
 942
 943 static gboolean on_sim_get_msisdn(TelephonySim *sim, GDBusMethodInvocation *invocation,
 944                 gpointer user_data)
 945 {
 946         struct custom_data *ctx = user_data;
 947         TReturn ret;
 948         CoreObject *co_sim = NULL;
 949         struct tel_sim_msisdn_list *msisdn_list = NULL;
 950         gboolean read_from_modem = FALSE;
 951
 952         if (!check_access_control (invocation, AC_SIM, "r"))
 953                 return TRUE;
 954
 955         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
 956         DBUS_SIM_CHECK_SIM_STATUS(GET_MSISDN, co_sim);
 957         DBUS_SIM_CHECK_SIM_SERVICE_TABLE(GET_MSISDN, co_sim);
 958
 959         if(SIM_TYPE_NVSIM == tcore_sim_get_type(co_sim)) {
 960                 dbg("In NV SIM, don't use MSISDN cached");
 961                 read_from_modem = TRUE;
 962         } else {
 963                 msisdn_list = tcore_sim_get_msisdn_list(co_sim);
 964                 if (msisdn_list)
 965                         read_from_modem = FALSE;
 966                 else
 967                         read_from_modem = TRUE;
 968         }
 969
 970         if(read_from_modem) {
 971                 UserRequest *ur = NULL;
 972
 973                 ur = MAKE_UR(ctx, sim, invocation);
 974                 dbg("Not cached. Request to modem");
 975                 tcore_user_request_set_command(ur, TREQ_SIM_GET_MSISDN);
 976
 977                 ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 978                 DBUS_SIM_CHECK_DISPATCH_RET(ret, invocation, ur);
 979         } else {
 980                 GVariant *gv = NULL;
 981                 int i;
 982                 GVariantBuilder b;
 983                 dbg("TRESP_SIM_GET_MSISDN");
 984                 g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 985
 986                 dbg("msisdn_list->count = %d", msisdn_list->count);
 987                 for (i = 0;i < msisdn_list->count; i++) {
 988                         g_variant_builder_open(&b,G_VARIANT_TYPE("a{sv}"));
 989                         g_variant_builder_add(&b, "{sv}", "name", g_variant_new_string((const gchar *)msisdn_list->msisdn[i].name));
 990                         if (msisdn_list->msisdn[i].ton == SIM_TON_INTERNATIONAL) {
 991                                 unsigned char *tmp = (unsigned char *)calloc(SIM_MSISDN_NUMBER_LEN_MAX + 1, 1);
 992                                 if (tmp!=NULL) {
 993                                         tmp[0] = '+';
 994                                         strncpy((char *)tmp+1, (const char*)msisdn_list->msisdn[i].num, SIM_MSISDN_NUMBER_LEN_MAX - 1);
 995                                         tmp[SIM_MSISDN_NUMBER_LEN_MAX] = '\0';
 996                                         g_variant_builder_add(&b, "{sv}", "number", g_variant_new_string((const gchar *)tmp));
 997                                         free(tmp);
 998                                 } else {
 999                                         dbg("calloc failed.");
1000                                         g_variant_builder_add(&b, "{sv}", "number", g_variant_new_string((const gchar *)msisdn_list->msisdn[i].num));
1001                                 }
1002                         } else {
1003                                 g_variant_builder_add(&b, "{sv}", "number", g_variant_new_string((const gchar *)msisdn_list->msisdn[i].num));
1004                         }
1005                         g_variant_builder_close(&b);
1006                 }
1007                 gv = g_variant_builder_end(&b);
1008
1009                 telephony_sim_complete_get_msisdn (sim, invocation,     SIM_ACCESS_SUCCESS, gv);
1010                 free(msisdn_list);
1011         }
1012
1013         return TRUE;
1014 }
1015
1016 static gboolean on_sim_get_oplmnwact(TelephonySim *sim, GDBusMethodInvocation *invocation,
1017                 gpointer user_data)
1018 {
1019         struct custom_data *ctx = user_data;
1020         UserRequest *ur = NULL;
1021         TReturn ret;
1022         CoreObject *co_sim = NULL;
1023
1024         if (!check_access_control (invocation, AC_SIM, "r"))
1025                 return TRUE;
1026
1027         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
1028         DBUS_SIM_CHECK_SIM_STATUS(GET_OPLMWACT, co_sim);
1029
1030         ur = MAKE_UR(ctx, sim, invocation);
1031
1032         tcore_user_request_set_command(ur, TREQ_SIM_GET_OPLMNWACT);
1033         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
1034         if (ret != TCORE_RETURN_SUCCESS) {
1035                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
1036                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
1037                 tcore_user_request_unref(ur);
1038         }
1039
1040         return TRUE;
1041 }
1042
1043 static gboolean on_sim_get_spn(TelephonySim *sim, GDBusMethodInvocation *invocation,
1044                 gpointer user_data)
1045 {
1046         struct custom_data *ctx = user_data;
1047         UserRequest *ur = NULL;
1048         TReturn ret;
1049         CoreObject *co_sim = NULL;
1050         struct tel_sim_spn* spn = NULL;
1051
1052         if (!check_access_control (invocation, AC_SIM, "r"))
1053                 return TRUE;
1054
1055         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
1056         DBUS_SIM_CHECK_SIM_STATUS(GET_SPN, co_sim);
1057
1058         spn = tcore_sim_get_spn(co_sim);
1059
1060         if (!spn) {
1061                 ur = MAKE_UR(ctx, sim, invocation);
1062
1063                 tcore_user_request_set_command(ur, TREQ_SIM_GET_SPN);
1064                 ret = tcore_communicator_dispatch_request(ctx->comm, ur);
1065
1066                 if (ret != TCORE_RETURN_SUCCESS) {
1067                         FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
1068                         dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
1069                         tcore_user_request_unref(ur);
1070                 }
1071         } else {
1072                 telephony_sim_complete_get_spn (sim, invocation, SIM_ACCESS_SUCCESS,
1073                                                                 spn->display_condition, (const gchar *)spn->spn);
1074                 free(spn);
1075         }
1076         return TRUE;
1077 }
1078
1079 static gboolean on_sim_get_cphs_netname(TelephonySim *sim, GDBusMethodInvocation *invocation,
1080                 gpointer user_data)
1081 {
1082         struct custom_data *ctx = user_data;
1083         UserRequest *ur = NULL;
1084         TReturn ret;
1085         CoreObject *co_sim = NULL;
1086         struct tel_sim_cphs_netname *cphs_netname = NULL;
1087
1088         if (!check_access_control (invocation, AC_SIM, "r"))
1089                 return TRUE;
1090
1091         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
1092         DBUS_SIM_CHECK_SIM_STATUS(GET_CPHS_NET_NAME, co_sim);
1093
1094         cphs_netname = tcore_sim_get_cphs_netname(co_sim);
1095
1096         if (!cphs_netname) {
1097                 ur = MAKE_UR(ctx, sim, invocation);
1098
1099                 tcore_user_request_set_command(ur, TREQ_SIM_GET_CPHS_NETNAME);
1100                 ret = tcore_communicator_dispatch_request(ctx->comm, ur);
1101                 if (ret != TCORE_RETURN_SUCCESS) {
1102                         FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
1103                         dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
1104                         tcore_user_request_unref(ur);
1105                 }
1106         } else {
1107                 telephony_sim_complete_get_cphs_net_name (sim, invocation, SIM_ACCESS_SUCCESS,
1108                                                                                         (const gchar *)cphs_netname->full_name,
1109                                                                                         (const gchar *)cphs_netname->short_name);
1110                 free(cphs_netname);
1111         }
1112
1113         return TRUE;
1114 }
1115
1116 static gboolean on_sim_get_gid(TelephonySim *sim, GDBusMethodInvocation *invocation,
1117                 gpointer user_data)
1118 {
1119         struct custom_data *ctx = user_data;
1120         UserRequest *ur = NULL;
1121         TReturn ret;
1122         CoreObject *co_sim = NULL;
1123
1124         if (!check_access_control (invocation, AC_SIM, "r"))
1125                 return TRUE;
1126
1127         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
1128         DBUS_SIM_CHECK_SIM_STATUS(GET_GID, co_sim);
1129
1130         ur = MAKE_UR(ctx, sim, invocation);
1131
1132         tcore_user_request_set_command(ur, TREQ_SIM_GET_GID);
1133         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
1134         if (ret != TCORE_RETURN_SUCCESS) {
1135                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
1136                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
1137                 tcore_user_request_unref(ur);
1138         }
1139
1140         return TRUE;
1141 }
1142
1143 static gboolean on_sim_authentication(TelephonySim *sim, GDBusMethodInvocation *invocation,
1144                 gint arg_type,
1145             GVariant *arg_rand,
1146             GVariant *arg_autn,
1147             gpointer user_data)
1148 {
1149         struct custom_data *ctx = user_data;
1150         UserRequest *ur = NULL;
1151         GVariantIter *iter = NULL;
1152         GVariant *rand_gv = NULL;
1153         GVariant *autn_gv = NULL;
1154         guchar rt_i;
1155         int i =0;
1156         TReturn ret;
1157         CoreObject *co_sim = NULL;
1158         struct treq_sim_req_authentication req_auth;
1159
1160         if (!check_access_control (invocation, AC_SIM, "x"))
1161                 return TRUE;
1162
1163         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
1164         DBUS_SIM_CHECK_SIM_STATUS(AUTHENTICATION, co_sim);
1165
1166         memset(&req_auth, 0, sizeof(struct treq_sim_req_authentication));
1167
1168         req_auth.auth_type = arg_type;
1169
1170         rand_gv = g_variant_get_variant(arg_rand);
1171         g_variant_get(rand_gv, "ay", &iter);
1172         while ( g_variant_iter_loop (iter, "y", &rt_i)) {
1173                 req_auth.rand_data[i] = rt_i;
1174                 i++;
1175         }
1176         req_auth.rand_length = (unsigned int)i;
1177
1178         i = 0;
1179         autn_gv = g_variant_get_variant(arg_autn);
1180         g_variant_get(autn_gv, "ay", &iter);
1181         while ( g_variant_iter_loop (iter, "y", &rt_i)) {
1182                 req_auth.autn_data[i] = rt_i;
1183                 i++;
1184         }
1185         req_auth.autn_length = (unsigned int)i;
1186
1187         ur = MAKE_UR(ctx, sim, invocation);
1188         tcore_user_request_set_data(ur, sizeof(struct treq_sim_req_authentication), &req_auth);
1189         tcore_user_request_set_command(ur, TREQ_SIM_REQ_AUTHENTICATION);
1190         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
1191         if (ret != TCORE_RETURN_SUCCESS) {
1192                 GVariantBuilder builder;
1193                 GVariant *ak = NULL;
1194                 GVariant *cp = NULL;
1195                 GVariant *it = NULL;
1196                 GVariant *resp = NULL;
1197                 GVariant *ak_gv = NULL;
1198                 GVariant *cp_gv = NULL;
1199                 GVariant *it_gv = NULL;
1200                 GVariant *resp_gv = NULL;
1201
1202                 g_variant_builder_init (&builder, G_VARIANT_TYPE ("ay"));
1203                 ak = g_variant_builder_end(&builder);
1204                 ak_gv = g_variant_new("v", ak);
1205
1206                 g_variant_builder_init (&builder, G_VARIANT_TYPE ("ay"));
1207                 cp = g_variant_builder_end(&builder);
1208                 cp_gv = g_variant_new("v", cp);
1209
1210                 g_variant_builder_init (&builder, G_VARIANT_TYPE ("ay"));
1211                 it = g_variant_builder_end(&builder);
1212                 it_gv = g_variant_new("v", it);
1213
1214                 g_variant_builder_init (&builder, G_VARIANT_TYPE ("ay"));
1215                 resp = g_variant_builder_end(&builder);
1216                 resp_gv = g_variant_new("v", resp);
1217
1218                 telephony_sim_complete_authentication (sim, invocation, SIM_ACCESS_FAILED, 0, 0,        ak_gv,  cp_gv, it_gv, resp_gv);
1219                 tcore_user_request_unref(ur);
1220         }
1221
1222         return TRUE;
1223 }
1224
1225 static gboolean on_sim_verify_sec(TelephonySim *sim, GDBusMethodInvocation *invocation,
1226             gint arg_type,
1227             const gchar *arg_password,
1228                 gpointer user_data)
1229 {
1230         struct custom_data *ctx = user_data;
1231         UserRequest *ur = NULL;
1232         TReturn ret;
1233         CoreObject *co_sim = NULL;
1234         struct treq_sim_verify_pins verify_pins;
1235
1236         if (!check_access_control (invocation, AC_SIM, "x"))
1237                 return TRUE;
1238
1239         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
1240         DBUS_SIM_CHECK_SIM_STATUS(VERIFY_SEC, co_sim);
1241
1242         memset(&verify_pins, 0, sizeof(struct treq_sim_verify_pins));
1243
1244         verify_pins.pin_type = arg_type;
1245         verify_pins.pin_length = strlen(arg_password);
1246         memcpy(verify_pins.pin, arg_password, verify_pins.pin_length);
1247
1248         ur = MAKE_UR(ctx, sim, invocation);
1249         tcore_user_request_set_data(ur, sizeof(struct treq_sim_verify_pins), &verify_pins);
1250         tcore_user_request_set_command(ur, TREQ_SIM_VERIFY_PINS);
1251         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
1252         if (ret != TCORE_RETURN_SUCCESS) {
1253                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
1254                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
1255                 tcore_user_request_unref(ur);
1256         }
1257
1258         return TRUE;
1259 }
1260
1261 static gboolean on_sim_verify_puk(TelephonySim *sim, GDBusMethodInvocation *invocation,
1262             gint arg_type,
1263             const gchar *arg_puk,
1264             const gchar *arg_new_pin,
1265                 gpointer user_data)
1266 {
1267         struct custom_data *ctx = user_data;
1268         UserRequest *ur = NULL;
1269         TReturn ret;
1270         CoreObject *co_sim = NULL;
1271         struct treq_sim_verify_puks verify_puks;
1272
1273         if (!check_access_control (invocation, AC_SIM, "x"))
1274                 return TRUE;
1275
1276         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
1277         DBUS_SIM_CHECK_SIM_STATUS(VERIFY_PUK, co_sim);
1278
1279         memset(&verify_puks, 0, sizeof(struct treq_sim_verify_puks));
1280
1281         verify_puks.puk_type = arg_type;
1282         verify_puks.puk_length = strlen(arg_puk);
1283         memcpy(verify_puks.puk, arg_puk, verify_puks.puk_length);
1284         verify_puks.pin_length = strlen(arg_new_pin);
1285         memcpy(verify_puks.pin, arg_new_pin, verify_puks.pin_length);
1286
1287         ur = MAKE_UR(ctx, sim, invocation);
1288         tcore_user_request_set_data(ur, sizeof(struct treq_sim_verify_puks), &verify_puks);
1289         tcore_user_request_set_command(ur, TREQ_SIM_VERIFY_PUKS);
1290         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
1291         if (ret != TCORE_RETURN_SUCCESS) {
1292                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
1293                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
1294                 tcore_user_request_unref(ur);
1295         }
1296
1297         return TRUE;
1298 }
1299
1300 static gboolean on_sim_change_pin(TelephonySim *sim, GDBusMethodInvocation *invocation,
1301             gint arg_type,
1302             const gchar *arg_old_password,
1303             const gchar *arg_new_password,
1304                 gpointer user_data)
1305 {
1306         struct custom_data *ctx = user_data;
1307         UserRequest *ur = NULL;
1308         TReturn ret;
1309         CoreObject *co_sim = NULL;
1310         struct treq_sim_change_pins change_pins;
1311
1312         if (!check_access_control (invocation, AC_SIM, "x"))
1313                 return TRUE;
1314
1315         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
1316         DBUS_SIM_CHECK_SIM_STATUS(CHANGE_PIN, co_sim);
1317
1318         memset(&change_pins, 0, sizeof(struct treq_sim_change_pins));
1319
1320         change_pins.type = arg_type;
1321         change_pins.old_pin_length = strlen(arg_old_password);
1322         memcpy(change_pins.old_pin, arg_old_password, change_pins.old_pin_length);
1323         change_pins.new_pin_length = strlen(arg_new_password);
1324         memcpy(change_pins.new_pin, arg_new_password, change_pins.new_pin_length);
1325
1326         ur = MAKE_UR(ctx, sim, invocation);
1327         tcore_user_request_set_data(ur, sizeof(struct treq_sim_change_pins), &change_pins);
1328         tcore_user_request_set_command(ur, TREQ_SIM_CHANGE_PINS);
1329         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
1330         if (ret != TCORE_RETURN_SUCCESS) {
1331                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
1332                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
1333                 tcore_user_request_unref(ur);
1334         }
1335
1336         return TRUE;
1337 }
1338
1339 static gboolean on_sim_disable_facility(TelephonySim *sim, GDBusMethodInvocation *invocation,
1340             gint arg_type,
1341             const gchar *arg_password,
1342                 gpointer user_data)
1343 {
1344         struct custom_data *ctx = user_data;
1345         UserRequest *ur = NULL;
1346         TReturn ret;
1347         struct treq_sim_disable_facility dis_facility;
1348         CoreObject *co_sim = NULL;
1349
1350         if (!check_access_control (invocation, AC_SIM, "x"))
1351                 return TRUE;
1352
1353         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
1354         DBUS_SIM_CHECK_SIM_STATUS(DISABLE_FACILITY, co_sim);
1355
1356         memset(&dis_facility, 0, sizeof(struct treq_sim_disable_facility));
1357
1358         dbg("arg_type[%d]", arg_type);
1359         switch (arg_type) {
1360                 case 1:
1361                         dis_facility.type = SIM_FACILITY_PS;
1362                         break;
1363                 case 3:
1364                         dis_facility.type = SIM_FACILITY_SC;
1365                         break;
1366                 case 4:
1367                         dis_facility.type = SIM_FACILITY_FD;
1368                         break;
1369                 case 5:
1370                         dis_facility.type = SIM_FACILITY_PN;
1371                         break;
1372                 case 6:
1373                         dis_facility.type = SIM_FACILITY_PU;
1374                         break;
1375                 case 7:
1376                         dis_facility.type = SIM_FACILITY_PP;
1377                         break;
1378                 case 8:
1379                         dis_facility.type = SIM_FACILITY_PC;
1380                         break;
1381                 default:
1382                         err("Unhandled/Unknown type[0x%x]", arg_type);
1383                         break;
1384         }
1385         dis_facility.password_length = strlen(arg_password);
1386         memcpy(dis_facility.password, arg_password, dis_facility.password_length);
1387
1388         ur = MAKE_UR(ctx, sim, invocation);
1389         tcore_user_request_set_data(ur, sizeof(struct treq_sim_disable_facility), &dis_facility);
1390         tcore_user_request_set_command(ur, TREQ_SIM_DISABLE_FACILITY);
1391         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
1392         if (ret != TCORE_RETURN_SUCCESS) {
1393                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
1394                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
1395                 tcore_user_request_unref(ur);
1396         }
1397
1398         return TRUE;
1399 }
1400
1401 static gboolean on_sim_enable_facility(TelephonySim *sim, GDBusMethodInvocation *invocation,
1402             gint arg_type,
1403             const gchar *arg_password,
1404                 gpointer user_data)
1405 {
1406         struct custom_data *ctx = user_data;
1407         UserRequest *ur = NULL;
1408         TReturn ret;
1409         struct treq_sim_enable_facility en_facility;
1410         CoreObject *co_sim = NULL;
1411
1412         if (!check_access_control (invocation, AC_SIM, "x"))
1413                 return TRUE;
1414
1415         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
1416         DBUS_SIM_CHECK_SIM_STATUS(ENABLE_FACILITY, co_sim);
1417
1418         memset(&en_facility, 0, sizeof(struct treq_sim_enable_facility));
1419
1420         dbg("arg_type[%d]", arg_type);
1421         switch (arg_type) {
1422                 case 1:
1423                         en_facility.type = SIM_FACILITY_PS;
1424                         break;
1425                 case 3:
1426                         en_facility.type = SIM_FACILITY_SC;
1427                         break;
1428                 case 4:
1429                         en_facility.type = SIM_FACILITY_FD;
1430                         break;
1431                 case 5:
1432                         en_facility.type = SIM_FACILITY_PN;
1433                         break;
1434                 case 6:
1435                         en_facility.type = SIM_FACILITY_PU;
1436                         break;
1437                 case 7:
1438                         en_facility.type = SIM_FACILITY_PP;
1439                         break;
1440                 case 8:
1441                         en_facility.type = SIM_FACILITY_PC;
1442                         break;
1443                 default:
1444                         err("Unhandled/Unknown type[0x%x]", arg_type);
1445                         break;
1446         }
1447         en_facility.password_length = strlen(arg_password);
1448         memcpy(en_facility.password, arg_password, en_facility.password_length);
1449
1450         ur = MAKE_UR(ctx, sim, invocation);
1451         tcore_user_request_set_data(ur, sizeof(struct treq_sim_enable_facility), &en_facility);
1452         tcore_user_request_set_command(ur, TREQ_SIM_ENABLE_FACILITY);
1453         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
1454         if (ret != TCORE_RETURN_SUCCESS) {
1455                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
1456                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
1457                 tcore_user_request_unref(ur);
1458         }
1459
1460         return TRUE;
1461 }
1462
1463 static gboolean on_sim_get_facility(TelephonySim *sim, GDBusMethodInvocation *invocation,
1464             gint arg_type,
1465                 gpointer user_data)
1466 {
1467         struct custom_data *ctx = user_data;
1468         UserRequest *ur = NULL;
1469         TReturn ret;
1470         struct treq_sim_get_facility_status facility;
1471         CoreObject *co_sim = NULL;
1472
1473         if (!check_access_control (invocation, AC_SIM, "r"))
1474                 return TRUE;
1475
1476         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
1477         DBUS_SIM_CHECK_SIM_STATUS(GET_FACILITY, co_sim);
1478
1479         memset(&facility, 0, sizeof(struct treq_sim_get_facility_status));
1480
1481         dbg("arg_type[%d]", arg_type);
1482
1483         switch (arg_type) {
1484                 case 1:
1485                         facility.type = SIM_FACILITY_PS;
1486                         break;
1487                 case 3:
1488                         facility.type = SIM_FACILITY_SC;
1489                         break;
1490                 case 4:
1491                         facility.type = SIM_FACILITY_FD;
1492                         break;
1493                 case 5:
1494                         facility.type = SIM_FACILITY_PN;
1495                         break;
1496                 case 6:
1497                         facility.type = SIM_FACILITY_PU;
1498                         break;
1499                 case 7:
1500                         facility.type = SIM_FACILITY_PP;
1501                         break;
1502                 case 8:
1503                         facility.type = SIM_FACILITY_PC;
1504                         break;
1505                 default:
1506                         err("Unhandled/Unknown type[0x%x]", arg_type);
1507                         break;
1508         }
1509
1510         ur = MAKE_UR(ctx, sim, invocation);
1511         tcore_user_request_set_data(ur, sizeof(struct treq_sim_get_facility_status), &facility);
1512         tcore_user_request_set_command(ur, TREQ_SIM_GET_FACILITY_STATUS);
1513         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
1514         if (ret != TCORE_RETURN_SUCCESS) {
1515                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
1516                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
1517                 tcore_user_request_unref(ur);
1518         }
1519
1520         return TRUE;
1521 }
1522
1523 static gboolean on_sim_get_lock_info(TelephonySim *sim, GDBusMethodInvocation *invocation,
1524             gint arg_type,
1525                 gpointer user_data)
1526 {
1527         struct custom_data *ctx = user_data;
1528         UserRequest *ur = NULL;
1529         TReturn ret;
1530         CoreObject *co_sim = NULL;
1531         struct treq_sim_get_lock_info lock_info;
1532
1533         if (!check_access_control (invocation, AC_SIM, "r"))
1534                 return TRUE;
1535
1536         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
1537         DBUS_SIM_CHECK_SIM_STATUS(GET_LOCK_INFO, co_sim);
1538
1539         memset(&lock_info, 0, sizeof(struct treq_sim_get_lock_info));
1540
1541         dbg("arg_type[%d]", arg_type);
1542         switch (arg_type) {
1543                 case 1:
1544                         lock_info.type = SIM_FACILITY_PS;
1545                         break;
1546                 case 3:
1547                         lock_info.type = SIM_FACILITY_SC;
1548                         break;
1549                 case 4:
1550                         lock_info.type = SIM_FACILITY_FD;
1551                         break;
1552                 case 5:
1553                         lock_info.type = SIM_FACILITY_PN;
1554                         break;
1555                 case 6:
1556                         lock_info.type = SIM_FACILITY_PU;
1557                         break;
1558                 case 7:
1559                         lock_info.type = SIM_FACILITY_PP;
1560                         break;
1561                 case 8:
1562                         lock_info.type = SIM_FACILITY_PC;
1563                         break;
1564                 default:
1565                         err("Unhandled/Unknown type[0x%x]", arg_type);
1566                         break;
1567         }
1568
1569         ur = MAKE_UR(ctx, sim, invocation);
1570         tcore_user_request_set_data(ur, sizeof(struct treq_sim_get_lock_info), &lock_info);
1571         tcore_user_request_set_command(ur, TREQ_SIM_GET_LOCK_INFO);
1572         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
1573         if (ret != TCORE_RETURN_SUCCESS) {
1574                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
1575                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
1576                 tcore_user_request_unref(ur);
1577         }
1578
1579         return TRUE;
1580 }
1581
1582 static gboolean on_sim_transfer_apdu(TelephonySim *sim, GDBusMethodInvocation *invocation,
1583                 GVariant *arg_apdu,
1584                 gpointer user_data)
1585 {
1586         struct custom_data *ctx = user_data;
1587         UserRequest *ur = NULL;
1588         struct treq_sim_transmit_apdu send_apdu;
1589         GVariantIter *iter = NULL;
1590         GVariant *inner_gv = NULL;
1591         guchar rt_i;
1592         TReturn ret;
1593         CoreObject *co_sim = NULL;
1594         int i =0;
1595
1596         if (!check_access_control (invocation, AC_SIM, "x"))
1597                 return TRUE;
1598
1599         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
1600         DBUS_SIM_CHECK_SIM_STATUS(TRANSFER_APDU, co_sim);
1601
1602         memset(&send_apdu, 0, sizeof(struct treq_sim_transmit_apdu));
1603
1604         inner_gv = g_variant_get_variant(arg_apdu);
1605
1606         g_variant_get(inner_gv, "ay", &iter);
1607         while ( g_variant_iter_loop (iter, "y", &rt_i)) {
1608                 send_apdu.apdu[i] = rt_i;
1609                 i++;
1610         }
1611         send_apdu.apdu_length = (unsigned int)i;
1612         g_variant_iter_free(iter);
1613         g_variant_unref(inner_gv);
1614         g_variant_unref(arg_apdu);
1615
1616         tcore_util_hex_dump("[APDU_REQ] ", send_apdu.apdu_length, send_apdu.apdu);
1617
1618         ur = MAKE_UR(ctx, sim, invocation);
1619         tcore_user_request_set_data(ur, sizeof(struct treq_sim_transmit_apdu), &send_apdu);
1620         tcore_user_request_set_command(ur, TREQ_SIM_TRANSMIT_APDU);
1621         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
1622         if (ret != TCORE_RETURN_SUCCESS) {
1623                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
1624                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
1625                 tcore_user_request_unref(ur);
1626         }
1627
1628         return TRUE;
1629 }
1630
1631 static gboolean on_sim_get_atr(TelephonySim *sim, GDBusMethodInvocation *invocation,
1632                 gpointer user_data)
1633 {
1634         struct custom_data *ctx = user_data;
1635         UserRequest *ur = NULL;
1636         TReturn ret;
1637         CoreObject *co_sim = NULL;
1638
1639         if (!check_access_control (invocation, AC_SIM, "r"))
1640                 return TRUE;
1641
1642         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
1643         DBUS_SIM_CHECK_SIM_STATUS(GET_ATR, co_sim);
1644
1645         ur = MAKE_UR(ctx, sim, invocation);
1646
1647         tcore_user_request_set_command(ur, TREQ_SIM_GET_ATR);
1648         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
1649         if (ret != TCORE_RETURN_SUCCESS) {
1650                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
1651                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
1652                 tcore_user_request_unref(ur);
1653         }
1654
1655         return TRUE;
1656 }
1657
1658 static gboolean on_sim_get_fields(TelephonySim *sim, GDBusMethodInvocation *invocation,
1659                 gpointer user_data)
1660 {
1661         struct custom_data *ctx = user_data;
1662         struct tel_sim_imsi *n_imsi = NULL;
1663         //struct tel_sim_msisdn_list *msisdn_list = NULL;
1664         //struct tel_sim_iccid *iccid = NULL;
1665         //struct tel_sim_spn *spn= NULL;
1666         CoreObject *co_sim = NULL;
1667         GVariantBuilder b;
1668         GVariant *gv_fields = NULL;
1669
1670         dbg("Func Entrance");
1671
1672         if (!check_access_control (invocation, AC_SIM, "r"))
1673                 return TRUE;
1674
1675         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
1676
1677         g_variant_builder_init(&b, G_VARIANT_TYPE("a{svv}}"));
1678
1679         DBUS_SIM_CHECK_SIM_STATUS(GET_IMSI, co_sim);
1680
1681         n_imsi = tcore_sim_get_imsi(co_sim);
1682         if (n_imsi != NULL) {
1683                 g_variant_builder_add(&b, "{svv}", "imsi", g_variant_new_string("plmn"), g_variant_new_string(n_imsi->plmn));
1684                 g_variant_builder_add(&b, "{svv}", "imsi", g_variant_new_string("msin"), g_variant_new_string(n_imsi->msin));
1685                 free(n_imsi);
1686         }
1687
1688         DBUS_SIM_CHECK_SIM_STATUS(GET_ICCID, co_sim);
1689         //n_imsi = tcore_sim_get_imsi(co_sim);
1690         //if (n_imsi != NULL) {
1691                 g_variant_builder_add(&b, "{svv}", "iccid", g_variant_new_string(""), g_variant_new_string(""));
1692                 //free(n_imsi);
1693         //}
1694
1695         DBUS_SIM_CHECK_SIM_STATUS(GET_MSISDN, co_sim);
1696         g_variant_builder_add(&b, "{svv}", "msisdn", g_variant_new_string("name"), g_variant_new_string("number"));
1697
1698         DBUS_SIM_CHECK_SIM_STATUS(GET_SPN, co_sim);
1699         g_variant_builder_add(&b, "{svv}", "spn", g_variant_new_uint16(255), g_variant_new_string("network name"));
1700
1701         DBUS_SIM_CHECK_SIM_STATUS(GET_INIT_STATUS, co_sim);
1702         g_variant_builder_add(&b, "{svv}", "init_status", g_variant_new_uint16(0), g_variant_new_boolean(TRUE));
1703
1704         gv_fields = g_variant_builder_end(&b);
1705
1706         telephony_sim_complete_get_fields(sim, invocation, 0, gv_fields);
1707
1708         return TRUE;
1709 }
1710
1711 static gboolean on_sim_set_power_state(TelephonySim *sim, GDBusMethodInvocation *invocation,
1712                 gint arg_state, gpointer user_data)
1713 {
1714         struct custom_data *ctx = user_data;
1715         UserRequest *ur = NULL;
1716         TReturn ret;
1717         CoreObject *co_sim = NULL;
1718         struct treq_sim_set_powerstate set_powerstate;
1719
1720         if (!check_access_control (invocation, AC_SIM, "w"))
1721                 return TRUE;
1722
1723         DBUS_SIM_GET_COSIM(invocation, co_sim, ctx->server);
1724         DBUS_SIM_CHECK_SIM_STATUS(SET_POWERSTATE, co_sim);
1725
1726         memset(&set_powerstate, 0, sizeof(struct treq_sim_set_powerstate));
1727         set_powerstate.state = arg_state;
1728
1729         dbg("set_powerstate.state[%d]", set_powerstate.state);
1730         ur = MAKE_UR(ctx, sim, invocation);
1731
1732         tcore_user_request_set_data(ur, sizeof(struct treq_sim_set_powerstate), &set_powerstate);
1733         tcore_user_request_set_command(ur, TREQ_SIM_SET_POWERSTATE);
1734         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
1735         if (ret != TCORE_RETURN_SUCCESS) {
1736                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
1737                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
1738                 tcore_user_request_unref(ur);
1739         }
1740
1741         return TRUE;
1742 }
1743
1744 gboolean dbus_plugin_setup_sim_interface(TelephonyObjectSkeleton *object, struct custom_data *ctx)
1745 {
1746         TelephonySim *sim;
1747
1748         sim = telephony_sim_skeleton_new();
1749         telephony_object_skeleton_set_sim(object, sim);
1750         g_object_unref(sim);
1751
1752         dbg("sim: [%p]", sim);
1753
1754         telephony_sim_set_cf_state(sim, FALSE);
1755
1756         g_signal_connect (sim,
1757                         "handle-get-init-status",
1758                         G_CALLBACK (on_sim_get_init_status),
1759                         ctx);
1760
1761         g_signal_connect (sim,
1762                         "handle-get-card-type",
1763                         G_CALLBACK (on_sim_get_card_type),
1764                         ctx);
1765
1766         g_signal_connect (sim,
1767                         "handle-get-imsi",
1768                         G_CALLBACK (on_sim_get_imsi),
1769                         ctx);
1770
1771         g_signal_connect (sim,
1772                         "handle-get-ecc",
1773                         G_CALLBACK (on_sim_get_ecc),
1774                         ctx);
1775
1776         g_signal_connect (sim,
1777                         "handle-get-iccid",
1778                         G_CALLBACK (on_sim_get_iccid),
1779                         ctx);
1780
1781         g_signal_connect (sim,
1782                         "handle-get-language",
1783                         G_CALLBACK (on_sim_get_language),
1784                         ctx);
1785
1786         g_signal_connect (sim,
1787                         "handle-set-language",
1788                         G_CALLBACK (on_sim_set_language),
1789                         ctx);
1790
1791         g_signal_connect (sim,
1792                         "handle-get-call-forwarding",
1793                         G_CALLBACK (on_sim_get_call_forwarding),
1794                         ctx);
1795
1796         g_signal_connect (sim,
1797                         "handle-set-call-forwarding",
1798                         G_CALLBACK (on_sim_set_call_forwarding),
1799                         ctx);
1800
1801         g_signal_connect (sim,
1802                         "handle-get-message-waiting",
1803                         G_CALLBACK (on_sim_get_message_waiting),
1804                         ctx);
1805
1806         g_signal_connect (sim,
1807                         "handle-set-message-waiting",
1808                         G_CALLBACK (on_sim_set_message_waiting),
1809                         ctx);
1810
1811         g_signal_connect (sim,
1812                         "handle-get-mailbox",
1813                         G_CALLBACK (on_sim_get_mailbox),
1814                         ctx);
1815
1816         g_signal_connect (sim,
1817                         "handle-set-mailbox",
1818                         G_CALLBACK (on_sim_set_mailbox),
1819                         ctx);
1820
1821         g_signal_connect (sim,
1822                         "handle-get-cphsinfo",
1823                         G_CALLBACK (on_sim_get_cphsinfo),
1824                         ctx);
1825
1826         g_signal_connect (sim,
1827                         "handle-get-service-table",
1828                         G_CALLBACK (on_sim_get_service_table),
1829                         ctx);
1830
1831         g_signal_connect (sim,
1832                         "handle-get-msisdn",
1833                         G_CALLBACK (on_sim_get_msisdn),
1834                         ctx);
1835
1836         g_signal_connect (sim,
1837                         "handle-get-oplmnwact",
1838                         G_CALLBACK (on_sim_get_oplmnwact),
1839                         ctx);
1840
1841         g_signal_connect (sim,
1842                         "handle-get-spn",
1843                         G_CALLBACK (on_sim_get_spn),
1844                         ctx);
1845
1846         g_signal_connect (sim,
1847                         "handle-get-cphs-net-name",
1848                         G_CALLBACK (on_sim_get_cphs_netname),
1849                         ctx);
1850
1851         g_signal_connect (sim,
1852                         "handle-get-gid",
1853                         G_CALLBACK (on_sim_get_gid),
1854                         ctx);
1855
1856         g_signal_connect (sim,
1857                         "handle-authentication",
1858                         G_CALLBACK (on_sim_authentication),
1859                         ctx);
1860
1861         g_signal_connect (sim,
1862                         "handle-verify-sec",
1863                         G_CALLBACK (on_sim_verify_sec),
1864                         ctx);
1865
1866         g_signal_connect (sim,
1867                         "handle-verify-puk",
1868                         G_CALLBACK (on_sim_verify_puk),
1869                         ctx);
1870
1871         g_signal_connect (sim,
1872                         "handle-change-pin",
1873                         G_CALLBACK (on_sim_change_pin),
1874                         ctx);
1875
1876         g_signal_connect (sim,
1877                         "handle-disable-facility",
1878                         G_CALLBACK (on_sim_disable_facility),
1879                         ctx);
1880
1881         g_signal_connect (sim,
1882                         "handle-enable-facility",
1883                         G_CALLBACK (on_sim_enable_facility),
1884                         ctx);
1885
1886         g_signal_connect (sim,
1887                         "handle-get-facility",
1888                         G_CALLBACK (on_sim_get_facility),
1889                         ctx);
1890
1891         g_signal_connect (sim,
1892                         "handle-get-lock-info",
1893                         G_CALLBACK (on_sim_get_lock_info),
1894                         ctx);
1895
1896         g_signal_connect (sim,
1897                         "handle-transfer-apdu",
1898                         G_CALLBACK (on_sim_transfer_apdu),
1899                         ctx);
1900
1901         g_signal_connect (sim,
1902                         "handle-get-atr",
1903                         G_CALLBACK (on_sim_get_atr),
1904                         ctx);
1905
1906         g_signal_connect (sim,
1907                         "handle-get-fields",
1908                         G_CALLBACK (on_sim_get_fields),
1909                         ctx);
1910
1911         g_signal_connect (sim,
1912                         "handle-set-powerstate",
1913                         G_CALLBACK (on_sim_set_power_state),
1914                         ctx);
1915
1916         return TRUE;
1917 }
1918
1919 gboolean dbus_plugin_sim_response(struct custom_data *ctx, UserRequest *ur,
1920         struct dbus_request_info *dbus_info, enum tcore_response_command command,
1921         unsigned int data_len, const void *data)
1922 {
1923         dbg("Response!!! Command: [0x%x] CP Name: [%s]",
1924                 command, GET_CP_NAME(dbus_info->invocation));
1925
1926         switch (command) {
1927         case TRESP_SIM_GET_ECC: {
1928                 const struct tresp_sim_read *resp_read = data;
1929                 CoreObject *co_sim = NULL;
1930                 GVariant *gv = NULL;
1931                 GVariantBuilder b;
1932                 int i = 0;
1933
1934                 dbg("TRESP_SIM_GET_ECC - Result: [%s])",
1935                         (resp_read->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"));
1936
1937                 co_sim = __get_sim_co_from_ur(ctx->server, ur);
1938                 if (!co_sim) {
1939                         err("SIM Core object is NULL");
1940                         return FALSE;
1941                 }
1942
1943                 if (resp_read->result == SIM_ACCESS_SUCCESS) {
1944                         tcore_sim_set_ecc_list(co_sim, &resp_read->data.ecc);
1945                 } else if (resp_read->result == SIM_ACCESS_FILE_NOT_FOUND) {
1946                         tcore_sim_set_ecc_list(co_sim, NULL);
1947                 }
1948
1949                 g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
1950                 for (i = 0; i < resp_read->data.ecc.ecc_count; i++) {
1951                         dbg("ecc[%d] : ecc_category=[0x%x], ecc_num=[%s], ecc_string=[%s]", i,
1952                                 resp_read->data.ecc.ecc[i].ecc_category,
1953                                 resp_read->data.ecc.ecc[i].ecc_num,
1954                                 resp_read->data.ecc.ecc[i].ecc_string);
1955
1956                         g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
1957                         g_variant_builder_add(&b, "{sv}", "category", g_variant_new_int32(resp_read->data.ecc.ecc[i].ecc_category));
1958                         g_variant_builder_add(&b, "{sv}", "number", g_variant_new_string(resp_read->data.ecc.ecc[i].ecc_num));
1959                         g_variant_builder_add(&b, "{sv}", "name", g_variant_new_string(resp_read->data.ecc.ecc[i].ecc_string));
1960                         g_variant_builder_close(&b);
1961                 }
1962                 gv = g_variant_builder_end(&b);
1963
1964                 telephony_sim_complete_get_ecc (dbus_info->interface_object, dbus_info->invocation, gv);
1965         }
1966         break;
1967
1968         case TRESP_SIM_GET_ICCID: {
1969                 const struct tresp_sim_read *resp_read = data;
1970                 CoreObject *co_sim = NULL;
1971
1972                 dbg("TRESP_SIM_GET_ICCID - Result: [%s] ICCID: [%s])",
1973                          (resp_read->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"),
1974                          resp_read->data.iccid.iccid);
1975
1976                 co_sim = __get_sim_co_from_ur(ctx->server, ur);
1977                 if (!co_sim) {
1978                         err("SIM Core object is NULL");
1979                         return FALSE;
1980                 }
1981
1982                 if (resp_read->result == SIM_ACCESS_SUCCESS) {
1983                         tcore_sim_set_iccid(co_sim, &resp_read->data.iccid);
1984                 } else if (resp_read->result == SIM_ACCESS_FILE_NOT_FOUND) {
1985                         tcore_sim_set_iccid(co_sim, NULL);
1986                 }
1987
1988                 telephony_sim_complete_get_iccid(dbus_info->interface_object, dbus_info->invocation,
1989                                 resp_read->result,
1990                                 resp_read->data.iccid.iccid);
1991         }
1992         break;
1993
1994         case TRESP_SIM_GET_LANGUAGE: {
1995                 const struct tresp_sim_read *resp_read = data;
1996
1997                 dbg("TRESP_SIM_GET_LANGUAGE - Result: [%s] Language: [0x%2x]",
1998                         (resp_read->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"),
1999                         resp_read->data.language.language[0]);
2000
2001                 telephony_sim_complete_get_language(dbus_info->interface_object, dbus_info->invocation,
2002                                 resp_read->result,
2003                                 resp_read->data.language.language[0]);
2004         }
2005         break;
2006
2007         case TRESP_SIM_SET_LANGUAGE: {
2008                 const struct tresp_sim_set_data *resp_set_data = data;
2009
2010                 dbg("TRESP_SIM_SET_LANGUAGE - Result: [%s]",
2011                         (resp_set_data->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"));
2012
2013                 telephony_sim_complete_set_language(dbus_info->interface_object, dbus_info->invocation,
2014                                 resp_set_data->result);
2015         }
2016         break;
2017
2018         case TRESP_SIM_GET_CALLFORWARDING: {
2019                 const struct tresp_sim_read *resp_read = data;
2020                 GVariant *gv_cf = NULL;
2021                 GVariant *gv_cphs_cf = NULL;
2022                 GVariantBuilder b;
2023
2024                 dbg("TRESP_SIM_GET_CALLFORWARDING - Result: [%s] CPHS: [%s]",
2025                         (resp_read->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"),
2026                         (resp_read->data.cf.b_cphs ? "Yes" : "No"));
2027
2028                 if (resp_read->data.cf.b_cphs) {
2029                         dbg("b_line1[%d], b_line2[%d], b_fax[%d], b_data[%d]",
2030                                 resp_read->data.cf.cphs_cf.b_line1, resp_read->data.cf.cphs_cf.b_line2,
2031                                 resp_read->data.cf.cphs_cf.b_fax, resp_read->data.cf.cphs_cf.b_data);
2032
2033                         g_variant_builder_init(&b, G_VARIANT_TYPE("a{sv}"));
2034                         g_variant_builder_add(&b, "{sv}", "b_line1", g_variant_new_boolean(resp_read->data.cf.cphs_cf.b_line1));
2035                         g_variant_builder_add(&b, "{sv}", "b_line2", g_variant_new_boolean(resp_read->data.cf.cphs_cf.b_line2));
2036                         g_variant_builder_add(&b, "{sv}", "b_fax", g_variant_new_boolean(resp_read->data.cf.cphs_cf.b_fax));
2037                         g_variant_builder_add(&b, "{sv}", "b_data", g_variant_new_boolean(resp_read->data.cf.cphs_cf.b_data));
2038                         gv_cphs_cf = g_variant_builder_end(&b);
2039
2040                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
2041                         gv_cf = g_variant_builder_end(&b);
2042
2043                 } else {
2044                         int i =0;
2045
2046                         dbg("profile_count[%d]",resp_read->data.cf.cf_list.profile_count);
2047
2048                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
2049                         for (i = 0; i < resp_read->data.cf.cf_list.profile_count; i++) {
2050                                 dbg("[%d] : rec_index[0x%x], msp_num[0x%x], cfu_status[0x%x], "
2051                                         "cfu_num[%s], ton[0x%x], npi[0x%x], cc2_id[0x%x], ext7_id[0x%x]",
2052                                         i, resp_read->data.cf.cf_list.cf[i].rec_index, resp_read->data.cf.cf_list.cf[i].msp_num,
2053                                         resp_read->data.cf.cf_list.cf[i].cfu_status, resp_read->data.cf.cf_list.cf[i].cfu_num,
2054                                         resp_read->data.cf.cf_list.cf[i].ton, resp_read->data.cf.cf_list.cf[i].npi,
2055                                         resp_read->data.cf.cf_list.cf[i].cc2_id, resp_read->data.cf.cf_list.cf[i].ext7_id);
2056
2057                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
2058                                 g_variant_builder_add(&b, "{sv}", "rec_index", g_variant_new_int32(resp_read->data.cf.cf_list.cf[i].rec_index));
2059                                 g_variant_builder_add(&b, "{sv}", "msp_num", g_variant_new_byte(resp_read->data.cf.cf_list.cf[i].msp_num));
2060                                 g_variant_builder_add(&b, "{sv}", "cfu_status", g_variant_new_byte(resp_read->data.cf.cf_list.cf[i].cfu_status));
2061                                 g_variant_builder_add(&b, "{sv}", "cfu_num", g_variant_new_string(resp_read->data.cf.cf_list.cf[i].cfu_num));
2062                                 g_variant_builder_add(&b, "{sv}", "ton", g_variant_new_int32(resp_read->data.cf.cf_list.cf[i].ton));
2063                                 g_variant_builder_add(&b, "{sv}", "npi", g_variant_new_int32(resp_read->data.cf.cf_list.cf[i].npi));
2064                                 g_variant_builder_add(&b, "{sv}", "cc2_id", g_variant_new_byte(resp_read->data.cf.cf_list.cf[i].cc2_id));
2065                                 g_variant_builder_add(&b, "{sv}", "ext7_id", g_variant_new_byte(resp_read->data.cf.cf_list.cf[i].ext7_id));
2066                                 g_variant_builder_close(&b);
2067                         }
2068                         gv_cf = g_variant_builder_end(&b);
2069
2070                         g_variant_builder_init(&b, G_VARIANT_TYPE("a{sv}"));
2071                         gv_cphs_cf = g_variant_builder_end(&b);
2072                 }
2073
2074                 telephony_sim_complete_get_call_forwarding (dbus_info->interface_object, dbus_info->invocation,
2075                                 resp_read->result,
2076                                 resp_read->data.cf.b_cphs,
2077                                 gv_cf,
2078                                 gv_cphs_cf);
2079         }
2080         break;
2081
2082         case TRESP_SIM_SET_CALLFORWARDING: {
2083                 const struct tresp_sim_set_data *resp_set_data = data;
2084
2085                 dbg("TRESP_SIM_SET_CALLFORWARDING - Result: [%s]",
2086                         (resp_set_data->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"));
2087
2088                 telephony_sim_complete_set_call_forwarding(dbus_info->interface_object, dbus_info->invocation,
2089                                 resp_set_data->result);
2090         }
2091         break;
2092
2093         case TRESP_SIM_GET_MESSAGEWAITING: {
2094                 const struct tresp_sim_read *resp_read = data;
2095                 GVariant *gv_mw = NULL;
2096                 GVariant *gv_cphs_mw = NULL;
2097                 GVariantBuilder b;
2098
2099                 dbg("TRESP_SIM_GET_MESSAGEWAITING - Result: [%s] CPHS: [%s]",
2100                         (resp_read->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"),
2101                         (resp_read->data.mw.b_cphs ? "Yes" : "No"));
2102
2103                 if (resp_read->data.mw.b_cphs) {
2104                         dbg("b_voice1[%d], b_voice2[%d], b_fax[%d], b_data[%d]",
2105                                 resp_read->data.mw.cphs_mw.b_voice1, resp_read->data.mw.cphs_mw.b_voice2,
2106                                 resp_read->data.mw.cphs_mw.b_fax, resp_read->data.mw.cphs_mw.b_data);
2107
2108                         g_variant_builder_init(&b, G_VARIANT_TYPE("a{sv}"));
2109                         g_variant_builder_add(&b, "{sv}", "b_voice1",   g_variant_new_boolean(resp_read->data.mw.cphs_mw.b_voice1));
2110                         g_variant_builder_add(&b, "{sv}", "b_voice2",   g_variant_new_boolean(resp_read->data.mw.cphs_mw.b_voice2));
2111                         g_variant_builder_add(&b, "{sv}", "b_fax",      g_variant_new_boolean(resp_read->data.mw.cphs_mw.b_fax));
2112                         g_variant_builder_add(&b, "{sv}", "b_data",     g_variant_new_boolean(resp_read->data.mw.cphs_mw.b_data));
2113                         gv_cphs_mw = g_variant_builder_end(&b);
2114
2115                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
2116                         gv_mw = g_variant_builder_end(&b);
2117
2118                 } else {
2119                         int i =0;
2120
2121                         dbg("profile_count[%d]", resp_read->data.mw.mw_list.profile_count);
2122
2123                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
2124                         for (i = 0; i <resp_read->data.mw.mw_list.profile_count; i++) {
2125                                 dbg("[%d] : rec_index[0x%x], indicator_status[0x%x], voice_count[0x%x], "
2126                                         "fax_count[0x%x] email_count[0x%x], other_count[0x%x], video_count[0x%x]",
2127                                         i, resp_read->data.mw.mw_list.mw[i].rec_index, resp_read->data.mw.mw_list.mw[i].indicator_status,
2128                                         resp_read->data.mw.mw_list.mw[i].voice_count, resp_read->data.mw.mw_list.mw[i].fax_count,
2129                                         resp_read->data.mw.mw_list.mw[i].email_count, resp_read->data.mw.mw_list.mw[i].other_count,
2130                                         resp_read->data.mw.mw_list.mw[i].video_count);
2131
2132                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
2133                                 g_variant_builder_add(&b,"{sv}",        "rec_index", g_variant_new_int32(       resp_read->data.mw.mw_list.mw[i].rec_index));
2134                                 g_variant_builder_add(&b, "{sv}", "indicator_status", g_variant_new_byte(resp_read->data.mw.mw_list.mw[i].indicator_status));
2135                                 g_variant_builder_add(&b,"{sv}",        "voice_count", g_variant_new_int32(resp_read->data.mw.mw_list.mw[i].voice_count));
2136                                 g_variant_builder_add(&b,"{sv}",        "fax_count", g_variant_new_int32(resp_read->data.mw.mw_list.mw[i].fax_count));
2137                                 g_variant_builder_add(&b, "{sv}", "email_count", g_variant_new_int32(resp_read->data.mw.mw_list.mw[i].email_count));
2138                                 g_variant_builder_add(&b, "{sv}", "other_count", g_variant_new_int32(resp_read->data.mw.mw_list.mw[i].other_count));
2139                                 g_variant_builder_add(&b, "{sv}", "video_count", g_variant_new_int32(resp_read->data.mw.mw_list.mw[i].video_count));
2140                                 g_variant_builder_close(&b);
2141                         }
2142                         gv_mw = g_variant_builder_end(&b);
2143                         g_variant_builder_init(&b, G_VARIANT_TYPE("a{sv}"));
2144                         gv_cphs_mw = g_variant_builder_end(&b);
2145                 }
2146
2147                 telephony_sim_complete_get_message_waiting(dbus_info->interface_object, dbus_info->invocation,
2148                                                                         resp_read->result,
2149                                                                         resp_read->data.mw.b_cphs,
2150                                                                         gv_mw,
2151                                                                         gv_cphs_mw);
2152         }
2153         break;
2154
2155         case TRESP_SIM_SET_MESSAGEWAITING: {
2156                 const struct tresp_sim_set_data *resp_set_data = data;
2157
2158                 dbg("TRESP_SIM_SET_MESSAGEWAITING - Result: [%s]",
2159                         (resp_set_data->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"));
2160
2161                 telephony_sim_complete_set_message_waiting(dbus_info->interface_object, dbus_info->invocation,
2162                                 resp_set_data->result);
2163         }
2164         break;
2165
2166         case TRESP_SIM_GET_MAILBOX: {
2167                 const struct tresp_sim_read *resp_read = data;
2168                 GVariant *gv = NULL;
2169                 GVariantBuilder b;
2170                 int i =0;
2171
2172                 dbg("TRESP_SIM_GET_MAILBOX - Result: [%s] CPHS: [%s] Count: [%d])",
2173                         (resp_read->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"),
2174                         (resp_read->data.mb.b_cphs ? "Yes" : "No"),
2175                         resp_read->data.mb.count);
2176
2177                 g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
2178                 for (i =0; i < resp_read->data.mb.count; i++) {
2179                                 dbg("resp_read->data.mb.mb[%d] : "
2180                                                 "rec_index[%d], profile_number[%d], mb_type[%d], alpha_id_max_len[%d]"
2181                                                 "alpha_id[%s], ton[%d], npi[%d], num[%s], cc_id[%d], ext1_id[%d]",
2182                                                 i, resp_read->data.mb.mb[i].rec_index, resp_read->data.mb.mb[i].profile_number,
2183                                                 resp_read->data.mb.mb[i].mb_type, resp_read->data.mb.mb[i].number_info.alpha_id_max_len,
2184                                                 resp_read->data.mb.mb[i].number_info.alpha_id, resp_read->data.mb.mb[i].number_info.ton,
2185                                                 resp_read->data.mb.mb[i].number_info.npi, resp_read->data.mb.mb[i].number_info.num,
2186                                                 resp_read->data.mb.mb[i].number_info.cc_id, resp_read->data.mb.mb[i].number_info.ext1_id);
2187
2188                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
2189                                 g_variant_builder_add(&b, "{sv}", "rec_index", g_variant_new_int32(resp_read->data.mb.mb[i].rec_index));
2190                                 g_variant_builder_add(&b, "{sv}", "profile_num", g_variant_new_int32(resp_read->data.mb.mb[i].profile_number));
2191                                 g_variant_builder_add(&b, "{sv}", "mb_type", g_variant_new_int32(resp_read->data.mb.mb[i].mb_type));
2192                                 g_variant_builder_add(&b, "{sv}", "alpha_id_max_len", g_variant_new_int32(resp_read->data.mb.mb[i].number_info.alpha_id_max_len));
2193                                 g_variant_builder_add(&b, "{sv}", "alpha_id", g_variant_new_string(resp_read->data.mb.mb[i].number_info.alpha_id));
2194                                 g_variant_builder_add(&b, "{sv}", "ton", g_variant_new_int32(resp_read->data.mb.mb[i].number_info.ton));
2195                                 g_variant_builder_add(&b, "{sv}", "npi", g_variant_new_int32(resp_read->data.mb.mb[i].number_info.npi));
2196                                 g_variant_builder_add(&b, "{sv}", "num", g_variant_new_string(resp_read->data.mb.mb[i].number_info.num));
2197                                 g_variant_builder_add(&b, "{sv}", "cc_id", g_variant_new_byte(resp_read->data.mb.mb[i].number_info.cc_id));
2198                                 g_variant_builder_add(&b, "{sv}", "ext1_id", g_variant_new_byte(resp_read->data.mb.mb[i].number_info.ext1_id));
2199                                 g_variant_builder_close(&b);
2200                 }
2201
2202                 gv = g_variant_builder_end(&b);
2203
2204                 telephony_sim_complete_get_mailbox (dbus_info->interface_object, dbus_info->invocation,
2205                                 resp_read->result,
2206                                 resp_read->data.mb.b_cphs,
2207                                 gv);
2208         }
2209         break;
2210
2211         case TRESP_SIM_SET_MAILBOX: {
2212                 const struct tresp_sim_set_data *resp_set_data = data;
2213
2214                 dbg("TRESP_SIM_SET_MAILBOX - Result: [%s]",
2215                         (resp_set_data->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"));
2216
2217                 telephony_sim_complete_set_mailbox(dbus_info->interface_object, dbus_info->invocation,
2218                                 resp_set_data->result);
2219         }
2220         break;
2221
2222         case TRESP_SIM_GET_CPHS_INFO: {
2223                 const struct tresp_sim_read *resp_read = data;
2224
2225                 dbg("TRESP_SIM_GET_CPHS_INFO - Result: [%s]",
2226                         (resp_read->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"));
2227
2228                 telephony_sim_complete_get_cphsinfo (dbus_info->interface_object, dbus_info->invocation,
2229                                 resp_read->result,
2230                                 resp_read->data.cphs.CphsPhase,
2231                                 resp_read->data.cphs.CphsServiceTable.bOperatorNameShortForm,
2232                                 resp_read->data.cphs.CphsServiceTable.bMailBoxNumbers,
2233                                 resp_read->data.cphs.CphsServiceTable.bServiceStringTable,
2234                                 resp_read->data.cphs.CphsServiceTable.bCustomerServiceProfile,
2235                                 resp_read->data.cphs.CphsServiceTable.bInformationNumbers);
2236         }
2237         break;
2238
2239         case TRESP_SIM_GET_SERVICE_TABLE: {
2240                 const struct tresp_sim_read *resp_read = data;
2241                 CoreObject *co_sim = NULL;
2242                 GVariantBuilder builder;
2243                 GVariant * inner_gv = NULL;
2244                 GVariant *svct_gv = NULL;
2245                 int i =0;
2246
2247                 dbg("TRESP_SIM_GET_SERVICE_TABLE - Result: [%s]",
2248                         (resp_read->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"));
2249
2250                 co_sim = __get_sim_co_from_ur(ctx->server, ur);
2251                 if (!co_sim) {
2252                         err("SIM Core object is NULL");
2253                         return FALSE;
2254                 }
2255
2256                 if (resp_read->result == SIM_ACCESS_SUCCESS) {
2257                         tcore_sim_set_service_table(co_sim, &resp_read->data.svct);
2258                 } else if (resp_read->result == SIM_ACCESS_FILE_NOT_FOUND) {
2259                         tcore_sim_set_service_table(co_sim, NULL);
2260                 }
2261
2262                 g_variant_builder_init (&builder, G_VARIANT_TYPE ("ay"));
2263
2264                 if (resp_read->data.svct.sim_type == SIM_TYPE_GSM) {
2265                         for (i = 0; i < SIM_SST_SERVICE_CNT_MAX; i++) {
2266                                 g_variant_builder_add (&builder, "y", resp_read->data.svct.table.sst.service[i]);
2267                         }
2268                 } else if (resp_read->data.svct.sim_type == SIM_TYPE_USIM) {
2269                         for (i = 0; i < SIM_UST_SERVICE_CNT_MAX; i++) {
2270                                 g_variant_builder_add (&builder, "y", resp_read->data.svct.table.ust.service[i]);
2271                         }
2272                 } else if(resp_read->data.svct.sim_type == SIM_TYPE_RUIM) {
2273                         if(SIM_CDMA_SVC_TABLE == resp_read->data.svct.table.cst.cdma_svc_table) {
2274                                 for(i = 0; i < SIM_CDMA_ST_SERVICE_CNT_MAX; i++) {
2275                                         g_variant_builder_add (&builder, "iy", resp_read->data.svct.table.cst.cdma_svc_table,
2276                                                                                         resp_read->data.svct.table.cst.service.cdma_service[i]);
2277                                 }
2278                         } else if(SIM_CSIM_SVC_TABLE == resp_read->data.svct.table.cst.cdma_svc_table) {
2279                                 for(i = 0; i < SIM_CSIM_ST_SERVICE_CNT_MAX; i++) {
2280                                         g_variant_builder_add (&builder, "iy", resp_read->data.svct.table.cst.cdma_svc_table,
2281                                                                                         resp_read->data.svct.table.cst.service.csim_service[i]);
2282                                 }
2283                         } else {
2284                                 err("Invalid cdma_svc_table:[%d]", resp_read->data.svct.table.cst.cdma_svc_table);
2285                         }
2286                 } else {
2287                         dbg("unknown sim type.");
2288                 }
2289                 inner_gv = g_variant_builder_end(&builder);
2290                 svct_gv = g_variant_new("v", inner_gv);
2291
2292                 telephony_sim_complete_get_service_table (dbus_info->interface_object, dbus_info->invocation,
2293                                 resp_read->result,
2294                                 resp_read->data.svct.sim_type,
2295                                 svct_gv);
2296         }       break;
2297
2298         case TRESP_SIM_GET_SPN: {
2299                 const struct tresp_sim_read *resp_read = data;
2300                 CoreObject *co_sim = NULL;
2301
2302                 dbg("TRESP_SIM_GET_SPN - Result: [%s] Display condition: [%d] SPN: [%s]",
2303                         (resp_read->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"),
2304                         resp_read->data.spn.display_condition, (const gchar *)resp_read->data.spn.spn);
2305
2306                 co_sim = __get_sim_co_from_ur(ctx->server, ur);
2307                 if (!co_sim) {
2308                         err("SIM Core object is NULL");
2309                         return FALSE;
2310                 }
2311
2312                 if (resp_read->result == SIM_ACCESS_SUCCESS) {
2313                         tcore_sim_set_spn(co_sim, &resp_read->data.spn);
2314                 } else if (resp_read->result == SIM_ACCESS_FILE_NOT_FOUND) {
2315                         tcore_sim_set_spn(co_sim, NULL);
2316                 }
2317
2318                 telephony_sim_complete_get_spn (dbus_info->interface_object, dbus_info->invocation,
2319                                 resp_read->result,
2320                                 resp_read->data.spn.display_condition, (const gchar *)resp_read->data.spn.spn);
2321         }
2322         break;
2323
2324         case TRESP_SIM_GET_CPHS_NETNAME: {
2325                 const struct tresp_sim_read *resp_read = data;
2326                 CoreObject *co_sim = NULL;
2327
2328                 dbg("TRESP_SIM_GET_CPHS_NETNAME - Result: [%s]",
2329                         (resp_read->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"));
2330
2331                 co_sim = __get_sim_co_from_ur(ctx->server, ur);
2332                 if (!co_sim) {
2333                         err("SIM Core object is NULL");
2334                         return FALSE;
2335                 }
2336
2337                 if (resp_read->result == SIM_ACCESS_SUCCESS) {
2338                         tcore_sim_set_cphs_netname(co_sim, &resp_read->data.cphs_net);
2339                 } else if (resp_read->result == SIM_ACCESS_FILE_NOT_FOUND) {
2340                         tcore_sim_set_cphs_netname(co_sim, NULL);
2341                 }
2342
2343                 telephony_sim_complete_get_cphs_net_name (dbus_info->interface_object, dbus_info->invocation,
2344                                 resp_read->result,
2345                                 (const gchar *)resp_read->data.cphs_net.full_name, (const gchar *)resp_read->data.cphs_net.short_name);
2346         }
2347         break;
2348
2349         case TRESP_SIM_GET_GID: {
2350                 const struct tresp_sim_read *resp_read = data;
2351                 GVariantBuilder *builder = NULL;
2352                 GVariant * inner_gv = NULL;
2353                 GVariant *gid_gv = NULL;
2354                 int i =0;
2355
2356                 dbg("TRESP_SIM_GET_GID - Result: [%s]",
2357                         (resp_read->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"));
2358
2359                 builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
2360
2361                 for(i = 0; i < resp_read->data.gid.GroupIdentifierLen; i++) {
2362                         g_variant_builder_add (builder, "y", resp_read->data.gid.szGroupIdentifier[i]);
2363                 }
2364                 inner_gv = g_variant_builder_end(builder);
2365                 gid_gv = g_variant_new("v", inner_gv);
2366
2367                 telephony_sim_complete_get_gid (dbus_info->interface_object, dbus_info->invocation,
2368                                                 resp_read->result,
2369                                                 resp_read->data.gid.GroupIdentifierLen,
2370                                                 gid_gv);
2371         }
2372         break;
2373
2374         case TRESP_SIM_GET_MSISDN:{
2375                 const struct tresp_sim_read *resp_read = data;
2376                 CoreObject *co_sim = NULL;
2377                 GVariant *gv = NULL;
2378                 GVariantBuilder b;
2379                 int i =0;
2380
2381                 dbg("TRESP_SIM_GET_MSISDN - Result: [%s]",
2382                         (resp_read->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"));
2383
2384                 co_sim = __get_sim_co_from_ur(ctx->server, ur);
2385                 if (!co_sim) {
2386                         err("SIM Core object is NULL");
2387                         return FALSE;
2388                 }
2389
2390                 g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
2391                 if (resp_read->result == SIM_ACCESS_SUCCESS) {
2392                         tcore_sim_set_msisdn_list(co_sim, &resp_read->data.msisdn_list);
2393                 } else if (resp_read->result == SIM_ACCESS_FILE_NOT_FOUND) {
2394                         tcore_sim_set_msisdn_list(co_sim, NULL);
2395                 }
2396
2397                 for (i = 0; i < resp_read->data.msisdn_list.count; i++) {
2398                         g_variant_builder_open(&b,G_VARIANT_TYPE("a{sv}"));
2399                         g_variant_builder_add(&b, "{sv}", "name", g_variant_new_string((const gchar *)resp_read->data.msisdn_list.msisdn[i].name));
2400                         if (resp_read->data.msisdn_list.msisdn[i].ton == SIM_TON_INTERNATIONAL) {
2401                                 unsigned char *tmp = (unsigned char *)calloc(SIM_MSISDN_NUMBER_LEN_MAX + 1, 1);
2402                                 if (tmp!=NULL) {
2403                                         tmp[0] = '+';
2404                                         strncpy((char *)tmp+1, (const char*)resp_read->data.msisdn_list.msisdn[i].num, SIM_MSISDN_NUMBER_LEN_MAX - 1);
2405                                         tmp[SIM_MSISDN_NUMBER_LEN_MAX] = '\0';
2406                                         g_variant_builder_add(&b, "{sv}", "number", g_variant_new_string((const gchar *)tmp));
2407                                         free(tmp);
2408                                 } else {
2409                                         dbg("calloc failed.");
2410                                         g_variant_builder_add(&b, "{sv}", "number", g_variant_new_string((const gchar *)resp_read->data.msisdn_list.msisdn[i].num));
2411                                 }
2412                         } else {
2413                                 g_variant_builder_add(&b, "{sv}", "number", g_variant_new_string((const gchar *)resp_read->data.msisdn_list.msisdn[i].num));
2414                         }
2415                         g_variant_builder_close(&b);
2416                 }
2417                 gv = g_variant_builder_end(&b);
2418
2419                 telephony_sim_complete_get_msisdn (dbus_info->interface_object, dbus_info->invocation,
2420                                 resp_read->result,
2421                                 gv);
2422         }
2423         break;
2424
2425         case TRESP_SIM_GET_OPLMNWACT: {
2426                 const struct tresp_sim_read *resp_read = data;
2427                 GVariant *gv = NULL;
2428                 GVariantBuilder b;
2429                 int i =0;
2430
2431                 dbg("TRESP_SIM_GET_OPLMNWACT - Result: [%s]",
2432                         (resp_read->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"));
2433
2434                 g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
2435                 for (i = 0;i < resp_read->data.opwa.opwa_count; i++) {
2436                         g_variant_builder_open(&b,G_VARIANT_TYPE("a{sv}"));
2437                         g_variant_builder_add(&b, "{sv}", "plmn", g_variant_new_string((const gchar *)resp_read->data.opwa.opwa[i].plmn));
2438                         g_variant_builder_add(&b, "{sv}", "b_umts", g_variant_new_boolean(resp_read->data.opwa.opwa[i].b_umts));
2439                         g_variant_builder_add(&b, "{sv}", "b_gsm", g_variant_new_boolean(resp_read->data.opwa.opwa[i].b_gsm));
2440                         g_variant_builder_close(&b);
2441                 }
2442                 gv = g_variant_builder_end(&b);
2443
2444                 telephony_sim_complete_get_oplmnwact (dbus_info->interface_object, dbus_info->invocation,
2445                                 resp_read->result,
2446                                 gv);
2447         }
2448         break;
2449
2450         case TRESP_SIM_REQ_AUTHENTICATION: {
2451                 const struct tresp_sim_req_authentication *resp_auth = data;
2452                 GVariantBuilder builder;
2453                 GVariant *ak = NULL;
2454                 GVariant *cp = NULL;
2455                 GVariant *it = NULL;
2456                 GVariant *resp = NULL;
2457                 GVariant *ak_gv = NULL;
2458                 GVariant *cp_gv = NULL;
2459                 GVariant *it_gv = NULL;
2460                 GVariant *resp_gv = NULL;
2461                 int i =0;
2462
2463                 dbg("TRESP_SIM_REQ_AUTHENTICATION - Result: [%s]",
2464                         (resp_auth->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"));
2465
2466                 tcore_util_hex_dump("[AUTH_KEY] ", resp_auth->authentication_key_length, resp_auth->authentication_key);
2467                 g_variant_builder_init (&builder, G_VARIANT_TYPE ("ay"));
2468                 for (i = 0; i < (int)resp_auth->authentication_key_length; i++) {
2469                         g_variant_builder_add (&builder, "y", resp_auth->authentication_key[i]);
2470                 }
2471                 ak = g_variant_builder_end(&builder);
2472                 ak_gv = g_variant_new("v", ak);
2473
2474                 tcore_util_hex_dump("[CIPHER_DATA] ", resp_auth->cipher_length, resp_auth->cipher_data);
2475                 g_variant_builder_init (&builder, G_VARIANT_TYPE ("ay"));
2476                 for (i = 0; i < (int)resp_auth->cipher_length; i++) {
2477                         g_variant_builder_add (&builder, "y", resp_auth->cipher_data[i]);
2478                 }
2479                 cp = g_variant_builder_end(&builder);
2480                 cp_gv = g_variant_new("v", cp);
2481
2482                 tcore_util_hex_dump("[INTEGRITY_DATA] ", resp_auth->integrity_length, resp_auth->integrity_data);
2483                 g_variant_builder_init (&builder, G_VARIANT_TYPE ("ay"));
2484                 for (i = 0; i < (int)resp_auth->integrity_length; i++) {
2485                         g_variant_builder_add (&builder, "y", resp_auth->integrity_data[i]);
2486                 }
2487                 it = g_variant_builder_end(&builder);
2488                 it_gv = g_variant_new("v", it);
2489
2490                 tcore_util_hex_dump("[RESP_DATA] ", resp_auth->resp_length, resp_auth->resp_data);
2491                 g_variant_builder_init (&builder, G_VARIANT_TYPE ("ay"));
2492                 for (i = 0; i < (int)resp_auth->resp_length; i++) {
2493                         g_variant_builder_add (&builder, "y", resp_auth->resp_data[i]);
2494                 }
2495                 resp = g_variant_builder_end(&builder);
2496                 resp_gv = g_variant_new("v", resp);
2497
2498                 telephony_sim_complete_authentication (dbus_info->interface_object, dbus_info->invocation,
2499                                 resp_auth->result,
2500                                 resp_auth->auth_type,
2501                                 resp_auth->auth_result,
2502                                 ak_gv,
2503                                 cp_gv,
2504                                 it_gv,
2505                                 resp_gv);
2506         }
2507         break;
2508
2509         case TRESP_SIM_VERIFY_PINS: {
2510                 const struct tresp_sim_verify_pins *resp_verify_pins = data;
2511
2512                 dbg("TRESP_SIM_VERIFY_PINS - Result: [%s] PIN Type: [%d] Re-try count: [%d]",
2513                         (resp_verify_pins->result == SIM_PIN_OPERATION_SUCCESS ? "Success" : "Fail"),
2514                         resp_verify_pins->pin_type, resp_verify_pins->retry_count);
2515
2516                 telephony_sim_complete_verify_sec(dbus_info->interface_object, dbus_info->invocation,
2517                                 resp_verify_pins->result,
2518                                 resp_verify_pins->pin_type,
2519                                 resp_verify_pins->retry_count);
2520         }
2521         break;
2522
2523         case TRESP_SIM_VERIFY_PUKS: {
2524                 const struct tresp_sim_verify_puks *resp_verify_puks = data;
2525
2526                 dbg("TRESP_SIM_VERIFY_PUKS - Result: [%s] PIN Type: [%d] Re-try count: [%d]",
2527                         (resp_verify_puks->result == SIM_PIN_OPERATION_SUCCESS ? "Success" : "Fail"),
2528                         resp_verify_puks->pin_type, resp_verify_puks->retry_count);
2529
2530                 telephony_sim_complete_verify_puk (dbus_info->interface_object, dbus_info->invocation,
2531                                 resp_verify_puks->result,
2532                                 resp_verify_puks->pin_type,
2533                                 resp_verify_puks->retry_count);
2534         }
2535         break;
2536
2537         case TRESP_SIM_CHANGE_PINS: {
2538                 const struct tresp_sim_change_pins *resp_change_pins = data;
2539
2540                 dbg("TRESP_SIM_CHANGE_PINS - Result: [%s] PIN Type: [%d] Re-try count: [%d]",
2541                         (resp_change_pins->result == SIM_PIN_OPERATION_SUCCESS ? "Success" : "Fail"),
2542                         resp_change_pins->pin_type, resp_change_pins->retry_count);
2543
2544                 telephony_sim_complete_change_pin(dbus_info->interface_object, dbus_info->invocation,
2545                                 resp_change_pins->result,
2546                                 resp_change_pins->pin_type,
2547                                 resp_change_pins->retry_count);
2548         }
2549         break;
2550
2551         case TRESP_SIM_DISABLE_FACILITY: {
2552                 const struct tresp_sim_disable_facility *resp_dis_facility = data;
2553                 gint f_type =0;
2554
2555                 dbg("TRESP_SIM_DISABLE_FACILITY - Result: [%s] Type: [%d] Re-try count: [%d]",
2556                         (resp_dis_facility->result == SIM_PIN_OPERATION_SUCCESS ? "Success" : "Fail"),
2557                         resp_dis_facility->type, resp_dis_facility->retry_count);
2558
2559                 switch (resp_dis_facility->type) {
2560                 case SIM_FACILITY_PS:
2561                         f_type = 1;
2562                 break;
2563                 case SIM_FACILITY_SC:
2564                         f_type = 3;
2565                 break;
2566                 case SIM_FACILITY_FD:
2567                         f_type = 4;
2568                 break;
2569                 case SIM_FACILITY_PN:
2570                         f_type = 5;
2571                 break;
2572                 case SIM_FACILITY_PU:
2573                         f_type = 6;
2574                 break;
2575                 case SIM_FACILITY_PP:
2576                         f_type = 7;
2577                 break;
2578                 case SIM_FACILITY_PC:
2579                         f_type = 8;
2580                 break;
2581                 default:
2582                         err("Unhandled/Unknown type[0x%x]", resp_dis_facility->type);
2583                 break;
2584                 }
2585
2586                 telephony_sim_complete_disable_facility(dbus_info->interface_object, dbus_info->invocation,
2587                                 resp_dis_facility->result,
2588                                 f_type,
2589                                 resp_dis_facility->retry_count);
2590         }
2591         break;
2592
2593         case TRESP_SIM_ENABLE_FACILITY: {
2594                 const struct tresp_sim_enable_facility *resp_en_facility = data;
2595                 gint f_type =0;
2596
2597                 dbg("TRESP_SIM_ENABLE_FACILITY - Result: [%s] Type: [%d] Re-try count: [%d]",
2598                         (resp_en_facility->result == SIM_PIN_OPERATION_SUCCESS ? "Success" : "Fail"),
2599                         resp_en_facility->type, resp_en_facility->retry_count);
2600
2601                 switch (resp_en_facility->type) {
2602                 case SIM_FACILITY_PS:
2603                         f_type = 1;
2604                 break;
2605                 case SIM_FACILITY_SC:
2606                         f_type = 3;
2607                 break;
2608                 case SIM_FACILITY_FD:
2609                         f_type = 4;
2610                 break;
2611                 case SIM_FACILITY_PN:
2612                         f_type = 5;
2613                 break;
2614                 case SIM_FACILITY_PU:
2615                         f_type = 6;
2616                 break;
2617                 case SIM_FACILITY_PP:
2618                         f_type = 7;
2619                 break;
2620                 case SIM_FACILITY_PC:
2621                         f_type = 8;
2622                 break;
2623                 default:
2624                         err("Unhandled/Unknown type[0x%x]", resp_en_facility->type);
2625                 break;
2626                 }
2627
2628                 telephony_sim_complete_enable_facility(dbus_info->interface_object, dbus_info->invocation,
2629                                 resp_en_facility->result,
2630                                 f_type,
2631                                 resp_en_facility->retry_count);
2632         }
2633         break;
2634
2635         case TRESP_SIM_GET_FACILITY_STATUS: {
2636                 const struct tresp_sim_get_facility_status *resp_get_facility = data;
2637                 gint f_type =0;
2638
2639                 dbg("TRESP_SIM_GET_FACILITY_STATUS - Result: [%s] Type: [%d] Enable: [%s]",
2640                         (resp_get_facility->result == SIM_PIN_OPERATION_SUCCESS ? "Success" : "Fail"),
2641                         resp_get_facility->type,
2642                         (resp_get_facility->b_enable ? "Yes" : "No"));
2643
2644                 switch (resp_get_facility->type) {
2645                 case SIM_FACILITY_PS:
2646                         f_type = 1;
2647                 break;
2648                 case SIM_FACILITY_SC:
2649                         f_type = 3;
2650                 break;
2651                 case SIM_FACILITY_FD:
2652                         f_type = 4;
2653                 break;
2654                 case SIM_FACILITY_PN:
2655                         f_type = 5;
2656                 break;
2657                 case SIM_FACILITY_PU:
2658                         f_type = 6;
2659                 break;
2660                 case SIM_FACILITY_PP:
2661                         f_type = 7;
2662                 break;
2663                 case SIM_FACILITY_PC:
2664                         f_type = 8;
2665                 break;
2666                 default:
2667                         err("Unhandled/Unknown type[0x%x]", resp_get_facility->type);
2668                 break;
2669                 }
2670
2671                 telephony_sim_complete_get_facility(dbus_info->interface_object, dbus_info->invocation,
2672                                 resp_get_facility->result,
2673                                 f_type,
2674                                 resp_get_facility->b_enable);
2675         }
2676         break;
2677
2678         case TRESP_SIM_GET_LOCK_INFO: {
2679                 const struct tresp_sim_get_lock_info *resp_lock = data;
2680                 gint f_type =0;
2681
2682                 dbg("TRESP_SIM_GET_LOCK_INFO - Result: [%s] Type: [%d] Re-try count: [%d]",
2683                         (resp_lock->result == SIM_PIN_OPERATION_SUCCESS ? "Success" : "Fail"),
2684                         resp_lock->type, resp_lock->retry_count);
2685
2686                 switch (resp_lock->type) {
2687                 case SIM_FACILITY_PS:
2688                         f_type = 1;
2689                 break;
2690                 case SIM_FACILITY_SC:
2691                         f_type = 3;
2692                 break;
2693                 case SIM_FACILITY_FD:
2694                         f_type = 4;
2695                 break;
2696                 case SIM_FACILITY_PN:
2697                         f_type = 5;
2698                 break;
2699                 case SIM_FACILITY_PU:
2700                         f_type = 6;
2701                 break;
2702                 case SIM_FACILITY_PP:
2703                         f_type = 7;
2704                 break;
2705                 case SIM_FACILITY_PC:
2706                         f_type = 8;
2707                 break;
2708                 default:
2709                         err("Unhandled/Unknown type[0x%x]", resp_lock->type);
2710                 break;
2711                 }
2712
2713                 telephony_sim_complete_get_lock_info(dbus_info->interface_object, dbus_info->invocation,
2714                                 resp_lock->result,
2715                                 f_type,
2716                                 resp_lock->lock_status,
2717                                 resp_lock->retry_count);
2718         }
2719         break;
2720
2721         case TRESP_SIM_TRANSMIT_APDU: {
2722                 const struct tresp_sim_transmit_apdu *resp_apdu = data;
2723                 GVariantBuilder builder;
2724                 GVariant * apdu_gv = NULL;
2725                 GVariant *inner_gv = NULL;
2726                 int i =0;
2727
2728                 dbg("TRESP_SIM_TRANSMIT_APDU - Result: [%s]",
2729                         (resp_apdu->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"));
2730                 tcore_util_hex_dump("[APDU_RESP] ",
2731                         resp_apdu->apdu_resp_length, resp_apdu->apdu_resp);
2732
2733                 g_variant_builder_init (&builder, G_VARIANT_TYPE ("ay"));
2734                 for (i = 0; i < (int)resp_apdu->apdu_resp_length; i++) {
2735                         g_variant_builder_add (&builder, "y", resp_apdu->apdu_resp[i]);
2736                 }
2737                 inner_gv = g_variant_builder_end(&builder);
2738                 apdu_gv = g_variant_new("v", inner_gv);
2739
2740                 telephony_sim_complete_transfer_apdu(dbus_info->interface_object, dbus_info->invocation,
2741                                 resp_apdu->result,
2742                                 apdu_gv);
2743         }
2744         break;
2745
2746         case TRESP_SIM_GET_ATR:{
2747                 const struct tresp_sim_get_atr *resp_get_atr = data;
2748                 GVariantBuilder builder;
2749                 GVariant * atr_gv = NULL;
2750                 GVariant *inner_gv = NULL;
2751                 int i =0;
2752
2753                 dbg("TRESP_SIM_GET_ATR - Result: [%s]",
2754                         (resp_get_atr->result == SIM_ACCESS_SUCCESS ? "Success" : "Fail"));
2755                 tcore_util_hex_dump("[ATR_RESP] ",
2756                         resp_get_atr->atr_length, resp_get_atr->atr);
2757
2758                 g_variant_builder_init (&builder, G_VARIANT_TYPE ("ay"));
2759                 for (i = 0; i < (int)resp_get_atr->atr_length; i++) {
2760                         g_variant_builder_add (&builder, "y", resp_get_atr->atr[i]);
2761                 }
2762                 inner_gv = g_variant_builder_end(&builder);
2763                 atr_gv = g_variant_new("v", inner_gv);
2764
2765                 telephony_sim_complete_get_atr(dbus_info->interface_object, dbus_info->invocation,
2766                                 resp_get_atr->result,
2767                                 atr_gv);
2768         }
2769         break;
2770
2771         case TRESP_SIM_SET_POWERSTATE: {
2772                 const struct tresp_sim_set_powerstate *resp_power = data;
2773
2774                 dbg("TRESP_SIM_SET_POWERSTATE - Result: [%s]",
2775                         (resp_power->result == SIM_POWER_SET_SUCCESS ? "Success" : "Fail"));
2776
2777                 telephony_sim_complete_set_powerstate(dbus_info->interface_object, dbus_info->invocation,
2778                                 resp_power->result);
2779         }
2780         break;
2781
2782         default:
2783                 err("Unhandled/Unknown Response!!!");
2784         break;
2785         }
2786
2787         return TRUE;
2788 }
2789
2790 gboolean dbus_plugin_sim_notification(struct custom_data *ctx, CoreObject *source,
2791         TelephonyObjectSkeleton *object, enum tcore_notification_command command,
2792         unsigned int data_len, const void *data)
2793 {
2794         TelephonySim *sim;
2795         const char *cp_name;
2796
2797         cp_name = tcore_server_get_cp_name_by_plugin(tcore_object_ref_plugin(source));
2798
2799         sim = telephony_object_peek_sim(TELEPHONY_OBJECT(object));
2800         dbg("sim: [%p]", sim);
2801
2802         switch (command) {
2803         case TNOTI_SIM_STATUS: {
2804                 const struct tnoti_sim_status *n_sim_status = data;
2805
2806                 info("[DBUSINFO][%s] SIM_STATUS : [%d]", cp_name, n_sim_status->sim_status);
2807
2808 #ifdef ENABLE_KPI_LOGS
2809                 if (n_sim_status->sim_status == SIM_STATUS_INIT_COMPLETED)
2810                         TIME_CHECK("[%s] SIM Initialized", cp_name);
2811 #endif
2812
2813                 telephony_sim_emit_status(sim, n_sim_status->sim_status);
2814         }
2815         break;
2816
2817         case TNOTI_SIM_REFRESHED: {
2818                 const struct tnoti_sim_refreshed *n_sim_refreshed = data;
2819                 info("[DBUSINFO][%s] SIM_REFRESHED : b_full_file_changed: [%s] changed_file_count: [%d]",
2820                         cp_name, (n_sim_refreshed->b_full_file_changed ? "Yes" : "No"), n_sim_refreshed->file_list.file_count);
2821
2822                 telephony_sim_emit_refreshed(sim, n_sim_refreshed->cmd_type);
2823         }
2824         break;
2825
2826         case TNOTI_SIM_CALL_FORWARD_STATE: {
2827                 const struct tnoti_sim_call_forward_state *info = data;
2828                 info("[DBUSINFO][%s] SIM_CALL_FORWARD_STATE : [%s]",
2829                         cp_name, info->b_forward ? "ON" : "OFF");
2830
2831                 telephony_sim_set_cf_state(sim, info->b_forward);
2832         }
2833         break;
2834
2835         default:
2836                 err("Unhandled/Unknown Notification!!!");
2837         break;
2838         }
2839
2840         return TRUE;
2841 }
2842