mobile/src/tapi_sap.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25
  26 #include "tapi_common.h"
  27 #include "TapiUtility.h"
  28 #include "TelSim.h"
  29
  30 #include "common.h"
  31 #include "tapi_log.h"
  32 #include "ITapiSap.h"
  33
  34 static void on_response_sap_connect(GObject *source_object, GAsyncResult *res, gpointer user_data)
  35 {
  36         GError *error = NULL;
  37         GDBusConnection *conn = NULL;
  38         GVariant *dbus_result;
  39
  40         struct tapi_resp_data *evt_cb_data = user_data;
  41         TelSimSapConnectionStatus_t result = TAPI_SIM_SAP_CONNECTION_STATUS_OK;
  42         gint max_msg_size = 0;
  43
  44         dbg("Func Entrance");
  45
  46         conn = G_DBUS_CONNECTION (source_object);
  47         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
  48         CHECK_DEINIT(error);
  49
  50         if (!dbus_result) {
  51                 if (evt_cb_data->cb_fn) {
  52                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
  53                 }
  54
  55                 if (error)
  56                         g_error_free(error);
  57
  58                 free(evt_cb_data);
  59                 return;
  60         }
  61
  62         g_variant_get(dbus_result, "(ii)", &result, &max_msg_size);
  63
  64         if (evt_cb_data->cb_fn) {
  65                 evt_cb_data->cb_fn(evt_cb_data->handle, result, (void*)&max_msg_size, evt_cb_data->user_data);
  66         }
  67
  68         free(evt_cb_data);
  69 }
  70
  71 EXPORT_API int tel_req_sap_connect(TapiHandle *handle, int max_msg_size, tapi_response_cb callback, void *user_data)
  72 {
  73         struct tapi_resp_data *evt_cb_data = NULL;
  74         GVariant *param = NULL;
  75
  76         dbg("Func Entrance w/ max_msg_size[%d]",max_msg_size);
  77
  78         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
  79
  80         param = g_variant_new("(i)", max_msg_size);
  81         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
  82                         DBUS_TELEPHONY_SAP_INTERFACE, "Connect", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
  83                         handle->ca, on_response_sap_connect, evt_cb_data);
  84
  85         return TAPI_API_SUCCESS;
  86 }
  87
  88 static void on_response_sap_disconnect(GObject *source_object, GAsyncResult *res, gpointer user_data)
  89 {
  90         GError *error = NULL;
  91         GDBusConnection *conn = NULL;
  92         GVariant *dbus_result;
  93
  94         struct tapi_resp_data *evt_cb_data = user_data;
  95         TelSimSapResultCode_t result = TAPI_SIM_SAP_RESULT_CODE_OK;
  96
  97         dbg("Func Entrance");
  98
  99         conn = G_DBUS_CONNECTION (source_object);
 100         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 101         CHECK_DEINIT(error);
 102
 103         if (!dbus_result) {
 104                 if (evt_cb_data->cb_fn) {
 105                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 106                 }
 107
 108                 if (error)
 109                         g_error_free(error);
 110
 111                 free(evt_cb_data);
 112                 return;
 113         }
 114
 115         g_variant_get(dbus_result, "(i)", &result);
 116
 117         if (evt_cb_data->cb_fn) {
 118                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 119         }
 120
 121         free(evt_cb_data);
 122 }
 123
 124 EXPORT_API int tel_req_sap_disconnect(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 125 {
 126         struct tapi_resp_data *evt_cb_data = NULL;
 127
 128         dbg("Func Entrance ");
 129
 130         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 131
 132                 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
 133                         DBUS_TELEPHONY_SAP_INTERFACE, "Disconnect", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
 134                         handle->ca, on_response_sap_disconnect, evt_cb_data);
 135
 136         return TAPI_API_SUCCESS;
 137 }
 138
 139 static void on_response_sap_connection_status(GObject *source_object, GAsyncResult *res, gpointer user_data)
 140 {
 141         GError *error = NULL;
 142         GDBusConnection *conn = NULL;
 143         GVariant *dbus_result;
 144
 145         struct tapi_resp_data *evt_cb_data = user_data;
 146         TelSimSapStatusInfo_t result = TAPI_SIM_SAP_STATUS_UNKNOWN;
 147
 148         dbg("Func Entrance");
 149
 150         conn = G_DBUS_CONNECTION (source_object);
 151         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 152         CHECK_DEINIT(error);
 153
 154         if (!dbus_result) {
 155                 if (evt_cb_data->cb_fn) {
 156                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 157                 }
 158
 159                 if (error)
 160                         g_error_free(error);
 161
 162                 free(evt_cb_data);
 163                 return;
 164         }
 165
 166         g_variant_get(dbus_result, "(i)", &result);
 167
 168         if (evt_cb_data->cb_fn) {
 169                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 170         }
 171
 172         free(evt_cb_data);
 173 }
 174
 175 EXPORT_API int tel_req_sap_connection_status(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 176 {
 177         struct tapi_resp_data *evt_cb_data = NULL;
 178
 179         dbg("Func Entrance");
 180
 181         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 182
 183         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
 184                         DBUS_TELEPHONY_SAP_INTERFACE, "GetStatus", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
 185                         handle->ca, on_response_sap_connection_status, evt_cb_data);
 186
 187         return TAPI_API_SUCCESS;
 188 }
 189
 190 static void on_response_sap_transfer_atr(GObject *source_object, GAsyncResult *res, gpointer user_data)
 191 {
 192         GError *error = NULL;
 193         GDBusConnection *conn = NULL;
 194         GVariant *dbus_result;
 195
 196         GVariantIter *iter = NULL;
 197         GVariant *param_gv = NULL;
 198         GVariant *inner_gv = NULL;
 199         guchar rt_i;
 200         int i = 0;
 201
 202         struct tapi_resp_data *evt_cb_data = user_data;
 203         TelSimSapResultCode_t result = TAPI_SIM_SAP_RESULT_CODE_OK;
 204         TelSapAtrInfo_t r_atr;
 205
 206         dbg("Func Entrance");
 207         memset(&r_atr, 0, sizeof(TelSapAtrInfo_t));
 208
 209         conn = G_DBUS_CONNECTION (source_object);
 210         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 211         CHECK_DEINIT(error);
 212
 213         if (!dbus_result) {
 214                 if (evt_cb_data->cb_fn) {
 215                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 216                 }
 217
 218                 if (error)
 219                         g_error_free(error);
 220
 221                 free(evt_cb_data);
 222                 return;
 223         }
 224
 225         /*      dbg("dbus_result type_format(%s)", g_variant_get_type_string(dbus_result));*/
 226         g_variant_get(dbus_result, "(i@v)", &result, &param_gv);
 227         inner_gv = g_variant_get_variant(param_gv);
 228
 229         g_variant_get(inner_gv, "ay", &iter);
 230         while (g_variant_iter_loop(iter, "y", &rt_i)) {
 231                 r_atr.atr_data[i] = rt_i;
 232                 i++;
 233         }
 234         r_atr.atr_len = (int) i;
 235         g_variant_iter_free(iter);
 236         g_variant_unref(inner_gv);
 237         g_variant_unref(param_gv);
 238         /*              for(i=0; i < (int)r_atr.atr_len; i++)
 239          dbg("r_atr[%d][0x%02x]",i, r_atr.atr_data[i]);*/
 240
 241         if (evt_cb_data->cb_fn) {
 242                 evt_cb_data->cb_fn(evt_cb_data->handle, result, (void*)&r_atr, evt_cb_data->user_data);
 243         }
 244
 245         free(evt_cb_data);
 246 }
 247
 248 EXPORT_API int tel_req_sap_transfer_atr(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 249 {
 250         struct tapi_resp_data *evt_cb_data = NULL;
 251
 252         dbg("Func Entrance");
 253
 254         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 255
 256         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
 257                         DBUS_TELEPHONY_SAP_INTERFACE, "GetATR", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
 258                         handle->ca, on_response_sap_transfer_atr, evt_cb_data);
 259
 260         return TAPI_API_SUCCESS;
 261 }
 262
 263 static void on_response_sap_transfer_apdu(GObject *source_object, GAsyncResult *res, gpointer user_data)
 264 {
 265         GError *error = NULL;
 266         GDBusConnection *conn = NULL;
 267         GVariant *dbus_result;
 268
 269         GVariantIter *iter = NULL;
 270         GVariant *param_gv = NULL;
 271         GVariant *inner_gv = NULL;
 272         guchar rt_i;
 273         int i = 0;
 274
 275         struct tapi_resp_data *evt_cb_data = user_data;
 276         TelSimSapResultCode_t result = TAPI_SIM_SAP_RESULT_CODE_OK;
 277         TelSapApduData_t r_apdu;
 278
 279         dbg("Func Entrance");
 280         memset(&r_apdu, 0, sizeof(TelSapApduData_t));
 281
 282         conn = G_DBUS_CONNECTION (source_object);
 283         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 284         CHECK_DEINIT(error);
 285
 286         if (!dbus_result) {
 287                 if (evt_cb_data->cb_fn) {
 288                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 289                 }
 290
 291                 if (error)
 292                         g_error_free(error);
 293
 294                 free(evt_cb_data);
 295                 return;
 296         }
 297
 298         /*      dbg("dbus_result type_format(%s)", g_variant_get_type_string(dbus_result));*/
 299         g_variant_get(dbus_result, "(i@v)", &result, &param_gv);
 300         inner_gv = g_variant_get_variant(param_gv);
 301
 302         g_variant_get(inner_gv, "ay", &iter);
 303         while (g_variant_iter_loop(iter, "y", &rt_i)) {
 304                 r_apdu.apdu_data[i] = rt_i;
 305                 i++;
 306         }
 307         r_apdu.apdu_len = (int) i;
 308         g_variant_iter_free(iter);
 309         g_variant_unref(inner_gv);
 310         g_variant_unref(param_gv);
 311         /*              for(i=0; i < (int)r_apdu.apdu_len; i++)
 312          dbg("apdu[%d][0x%02x]",i, r_apdu.apdu_data[i]);*/
 313
 314         if (evt_cb_data->cb_fn) {
 315                 evt_cb_data->cb_fn(evt_cb_data->handle, result, (void*)&r_apdu, evt_cb_data->user_data);
 316         }
 317
 318         free(evt_cb_data);
 319 }
 320
 321 EXPORT_API int tel_req_sap_transfer_apdu(TapiHandle *handle, TelSapApduData_t *apdu_data, tapi_response_cb callback, void *user_data)
 322 {
 323         struct tapi_resp_data *evt_cb_data = NULL;
 324         GVariantBuilder *builder = NULL;
 325         GVariant *param = NULL;
 326         GVariant *inner_gv = NULL;
 327         int i = 0;
 328
 329         dbg("Func Entrance");
 330         TAPI_RETURN_VAL_IF_FAIL(apdu_data, TAPI_API_INVALID_PTR);
 331
 332         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 333
 334         builder = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
 335         for (i = 0; i < apdu_data->apdu_len; i++) {
 336                 dbg("apdu_data->apdu_data[%d][0x%02x]", i,apdu_data->apdu_data[i]);
 337                 g_variant_builder_add(builder, "y", apdu_data->apdu_data[i]);
 338         }
 339         inner_gv = g_variant_builder_end(builder);
 340         param = g_variant_new("(v)", inner_gv);
 341         /*g_variant_builder_unref (builder);*/
 342
 343         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
 344                         DBUS_TELEPHONY_SAP_INTERFACE, "TransferAPDU", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
 345                         handle->ca, on_response_sap_transfer_apdu, evt_cb_data);
 346
 347         return TAPI_API_SUCCESS;
 348 }
 349
 350 static void on_response_sap_transport_protocol(GObject *source_object, GAsyncResult *res, gpointer user_data)
 351 {
 352         GError *error = NULL;
 353         GDBusConnection *conn = NULL;
 354         GVariant *dbus_result;
 355
 356         struct tapi_resp_data *evt_cb_data = user_data;
 357         TelSimSapResultCode_t result = TAPI_SIM_SAP_RESULT_CODE_OK;
 358
 359         dbg("Func Entrance");
 360
 361         conn = G_DBUS_CONNECTION (source_object);
 362         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 363         CHECK_DEINIT(error);
 364
 365         if (!dbus_result) {
 366                 if (evt_cb_data->cb_fn) {
 367                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 368                 }
 369
 370                 if (error)
 371                         g_error_free(error);
 372
 373                 free(evt_cb_data);
 374                 return;
 375         }
 376
 377         g_variant_get(dbus_result, "(i)", &result);
 378
 379         if (evt_cb_data->cb_fn) {
 380                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 381         }
 382
 383         free(evt_cb_data);
 384 }
 385
 386 EXPORT_API int tel_req_sap_transport_protocol(TapiHandle *handle, TelSimSapProtocol_t protocol, tapi_response_cb callback, void *user_data)
 387 {
 388         struct tapi_resp_data *evt_cb_data = NULL;
 389         GVariant *param = NULL;
 390
 391         dbg("Func Entrance w/ protocol[%d]", protocol);
 392
 393         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 394
 395         param = g_variant_new("(i)", protocol);
 396         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
 397                         DBUS_TELEPHONY_SAP_INTERFACE, "SetProtocol", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
 398                         handle->ca, on_response_sap_transport_protocol, evt_cb_data);
 399
 400         return TAPI_API_SUCCESS;
 401 }
 402
 403 static void on_response_sap_power_operation(GObject *source_object, GAsyncResult *res, gpointer user_data)
 404 {
 405         GError *error = NULL;
 406         GDBusConnection *conn = NULL;
 407         GVariant *dbus_result;
 408
 409         struct tapi_resp_data *evt_cb_data = user_data;
 410         TelSimSapResultCode_t result = TAPI_SIM_SAP_RESULT_CODE_OK;
 411
 412         dbg("Func Entrance");
 413
 414         conn = G_DBUS_CONNECTION (source_object);
 415         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 416         CHECK_DEINIT(error);
 417
 418         if (!dbus_result) {
 419                 if (evt_cb_data->cb_fn) {
 420                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 421                 }
 422
 423                 if (error)
 424                         g_error_free(error);
 425
 426                 free(evt_cb_data);
 427                 return;
 428         }
 429
 430         g_variant_get(dbus_result, "(i)", &result);
 431
 432         if (evt_cb_data->cb_fn) {
 433                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 434         }
 435
 436         free(evt_cb_data);
 437 }
 438
 439 EXPORT_API int tel_req_sap_power_operation(TapiHandle *handle, TelSimSapPowerMode_t power_mode, tapi_response_cb callback, void *user_data)
 440 {
 441         struct tapi_resp_data *evt_cb_data = NULL;
 442         GVariant *param = NULL;
 443         gint mode = 0;
 444         dbg("Func Entrance w/ power_mode[%d]", power_mode);
 445
 446         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 447
 448         switch (power_mode) {
 449                 case TAPI_SIM_SAP_POWER_SIM_ON_REQ:
 450                         mode = 0;
 451                         break;
 452                 case TAPI_SIM_SAP_POWER_SIM_OFF_REQ:
 453                         mode =1;
 454                         break;
 455                 case TAPI_SIM_SAP_RESET_SIM_REQ:
 456                         mode = 2;
 457                         break;
 458                 default:
 459                         dbg("not handed value[%d]", power_mode);
 460                         break;
 461         }
 462
 463         param = g_variant_new("(i)", mode);
 464         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
 465                         DBUS_TELEPHONY_SAP_INTERFACE, "SetPower", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
 466                         handle->ca, on_response_sap_power_operation, evt_cb_data);
 467
 468         return TAPI_API_SUCCESS;
 469 }
 470
 471 static void on_response_sap_cardreader_status(GObject *source_object, GAsyncResult *res, gpointer user_data)
 472 {
 473         GError *error = NULL;
 474         GDBusConnection *conn = NULL;
 475         GVariant *dbus_result;
 476
 477         struct tapi_resp_data *evt_cb_data = user_data;
 478         TelSimSapResultCode_t result = TAPI_SIM_SAP_RESULT_CODE_OK;
 479         TelSimSapCardStatus_t reader_status = TAPI_SIM_SAP_CARD_STATUS_UNKNOWN;
 480
 481         dbg("Func Entrance");
 482
 483         conn = G_DBUS_CONNECTION (source_object);
 484         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 485         CHECK_DEINIT(error);
 486
 487         if (!dbus_result) {
 488                 if (evt_cb_data->cb_fn) {
 489                         evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
 490                 }
 491
 492                 if (error)
 493                         g_error_free(error);
 494
 495                 free(evt_cb_data);
 496                 return;
 497         }
 498
 499         g_variant_get(dbus_result, "(ii)", &result, &reader_status);
 500
 501         if (evt_cb_data->cb_fn) {
 502                 evt_cb_data->cb_fn(evt_cb_data->handle, result, (void*)&reader_status, evt_cb_data->user_data);
 503         }
 504
 505         free(evt_cb_data);
 506 }
 507
 508 EXPORT_API int tel_req_sap_cardreader_status(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 509 {
 510         struct tapi_resp_data *evt_cb_data = NULL;
 511
 512         dbg("Func Entrance ");
 513
 514         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 515
 516         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
 517                         DBUS_TELEPHONY_SAP_INTERFACE, "GetCardReaderStatus", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
 518                         handle->ca, on_response_sap_cardreader_status, evt_cb_data);
 519
 520         return TAPI_API_SUCCESS;
 521 }