src/tapi_sap.c

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