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 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_ERROR(error);
  49
  50         g_variant_get(dbus_result, "(ii)", &result, &max_msg_size);
  51
  52         if (evt_cb_data->cb_fn) {
  53                 evt_cb_data->cb_fn(evt_cb_data->handle, result, (void*)&max_msg_size, evt_cb_data->user_data);
  54         }
  55
  56         g_free(evt_cb_data);
  57         g_variant_unref(dbus_result);
  58 }
  59
  60 EXPORT_API int tel_req_sap_connect(TapiHandle *handle, int max_msg_size, tapi_response_cb callback, void *user_data)
  61 {
  62         struct tapi_resp_data *evt_cb_data = NULL;
  63         GVariant *param = NULL;
  64
  65         dbg("Func Entrance w/ max_msg_size[%d]",max_msg_size);
  66
  67         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
  68
  69         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
  70
  71         param = g_variant_new("(i)", max_msg_size);
  72         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
  73                         DBUS_TELEPHONY_SAP_INTERFACE, "Connect", param, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
  74                         handle->ca, on_response_sap_connect, evt_cb_data);
  75
  76         return TAPI_API_SUCCESS;
  77 }
  78
  79 static void on_response_sap_disconnect(GObject *source_object, GAsyncResult *res, gpointer user_data)
  80 {
  81         GError *error = NULL;
  82         GDBusConnection *conn = NULL;
  83         GVariant *dbus_result;
  84
  85         struct tapi_resp_data *evt_cb_data = user_data;
  86         TelSimSapResultCode_t result = TAPI_SIM_SAP_RESULT_CODE_OK;
  87
  88         dbg("Func Entrance");
  89
  90         conn = G_DBUS_CONNECTION (source_object);
  91         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
  92         CHECK_ERROR(error);
  93
  94         g_variant_get(dbus_result, "(i)", &result);
  95
  96         if (evt_cb_data->cb_fn) {
  97                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
  98         }
  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         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 113
 114                 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
 115                         DBUS_TELEPHONY_SAP_INTERFACE, "Disconnect", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
 116                         handle->ca, on_response_sap_disconnect, evt_cb_data);
 117
 118         return TAPI_API_SUCCESS;
 119 }
 120
 121 static void on_response_sap_connection_status(GObject *source_object, GAsyncResult *res, gpointer user_data)
 122 {
 123         GError *error = NULL;
 124         GDBusConnection *conn = NULL;
 125         GVariant *dbus_result;
 126
 127         struct tapi_resp_data *evt_cb_data = user_data;
 128         TelSimSapStatusInfo_t result = TAPI_SIM_SAP_STATUS_UNKNOWN;
 129
 130         dbg("Func Entrance");
 131
 132         conn = G_DBUS_CONNECTION (source_object);
 133         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 134         CHECK_ERROR(error);
 135
 136         g_variant_get(dbus_result, "(i)", &result);
 137
 138         if (evt_cb_data->cb_fn) {
 139                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 140         }
 141
 142         g_free(evt_cb_data);
 143         g_variant_unref(dbus_result);
 144 }
 145
 146 EXPORT_API int tel_req_sap_connection_status(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 147 {
 148         struct tapi_resp_data *evt_cb_data = NULL;
 149
 150         dbg("Func Entrance");
 151
 152         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 153
 154         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 155
 156         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
 157                         DBUS_TELEPHONY_SAP_INTERFACE, "GetStatus", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
 158                         handle->ca, on_response_sap_connection_status, evt_cb_data);
 159
 160         return TAPI_API_SUCCESS;
 161 }
 162
 163 static void on_response_sap_transfer_atr(GObject *source_object, GAsyncResult *res, gpointer user_data)
 164 {
 165         GError *error = NULL;
 166         GDBusConnection *conn = NULL;
 167         GVariant *dbus_result;
 168
 169         GVariantIter *iter = NULL;
 170         GVariant *param_gv = NULL;
 171         GVariant *inner_gv = NULL;
 172         guchar rt_i;
 173         int i = 0;
 174
 175         struct tapi_resp_data *evt_cb_data = user_data;
 176         TelSimSapResultCode_t result = TAPI_SIM_SAP_RESULT_CODE_OK;
 177         TelSapAtrInfo_t r_atr;
 178
 179         dbg("Func Entrance");
 180         memset(&r_atr, 0, sizeof(TelSapAtrInfo_t));
 181
 182         conn = G_DBUS_CONNECTION (source_object);
 183         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 184         CHECK_ERROR(error);
 185
 186         /*      dbg("dbus_result type_format(%s)", g_variant_get_type_string(dbus_result));*/
 187         g_variant_get(dbus_result, "(i@v)", &result, &param_gv);
 188         inner_gv = g_variant_get_variant(param_gv);
 189
 190         g_variant_get(inner_gv, "ay", &iter);
 191         while (g_variant_iter_loop(iter, "y", &rt_i)) {
 192                 r_atr.atr_data[i] = rt_i;
 193                 i++;
 194         }
 195         r_atr.atr_len = (int) i;
 196         g_variant_iter_free(iter);
 197         g_variant_unref(inner_gv);
 198         g_variant_unref(param_gv);
 199         /*              for(i=0; i < (int)r_atr.atr_len; i++)
 200          dbg("r_atr[%d][0x%02x]",i, r_atr.atr_data[i]);*/
 201
 202         if (evt_cb_data->cb_fn) {
 203                 evt_cb_data->cb_fn(evt_cb_data->handle, result, (void*)&r_atr, evt_cb_data->user_data);
 204         }
 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         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 219
 220         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
 221                         DBUS_TELEPHONY_SAP_INTERFACE, "GetATR", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
 222                         handle->ca, on_response_sap_transfer_atr, evt_cb_data);
 223
 224         return TAPI_API_SUCCESS;
 225 }
 226
 227 static void on_response_sap_transfer_apdu(GObject *source_object, GAsyncResult *res, gpointer user_data)
 228 {
 229         GError *error = NULL;
 230         GDBusConnection *conn = NULL;
 231         GVariant *dbus_result;
 232
 233         GVariantIter *iter = NULL;
 234         GVariant *param_gv = NULL;
 235         GVariant *inner_gv = NULL;
 236         guchar rt_i;
 237         int i = 0;
 238
 239         struct tapi_resp_data *evt_cb_data = user_data;
 240         TelSimSapResultCode_t result = TAPI_SIM_SAP_RESULT_CODE_OK;
 241         TelSapApduData_t r_apdu;
 242
 243         dbg("Func Entrance");
 244         memset(&r_apdu, 0, sizeof(TelSapApduData_t));
 245
 246         conn = G_DBUS_CONNECTION (source_object);
 247         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 248         CHECK_ERROR(error);
 249
 250         /*      dbg("dbus_result type_format(%s)", g_variant_get_type_string(dbus_result));*/
 251         g_variant_get(dbus_result, "(i@v)", &result, &param_gv);
 252         inner_gv = g_variant_get_variant(param_gv);
 253
 254         g_variant_get(inner_gv, "ay", &iter);
 255         while (g_variant_iter_loop(iter, "y", &rt_i)) {
 256                 r_apdu.apdu_data[i] = rt_i;
 257                 i++;
 258         }
 259         r_apdu.apdu_len = (int) i;
 260         g_variant_iter_free(iter);
 261         g_variant_unref(inner_gv);
 262         g_variant_unref(param_gv);
 263         /*              for(i=0; i < (int)r_apdu.apdu_len; i++)
 264          dbg("apdu[%d][0x%02x]",i, r_apdu.apdu_data[i]);*/
 265
 266         if (evt_cb_data->cb_fn) {
 267                 evt_cb_data->cb_fn(evt_cb_data->handle, result, (void*)&r_apdu, evt_cb_data->user_data);
 268         }
 269
 270         g_free(evt_cb_data);
 271         g_variant_unref(dbus_result);
 272 }
 273
 274 EXPORT_API int tel_req_sap_transfer_apdu(TapiHandle *handle, TelSapApduData_t *apdu_data, tapi_response_cb callback, void *user_data)
 275 {
 276         struct tapi_resp_data *evt_cb_data = NULL;
 277         GVariantBuilder builder;
 278         GVariant *param = NULL;
 279         GVariant *inner_gv = NULL;
 280         int i = 0;
 281
 282         dbg("Func Entrance");
 283
 284         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 285         TAPI_RET_ERR_NUM_IF_FAIL(apdu_data, TAPI_API_INVALID_PTR);
 286
 287         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 288
 289         g_variant_builder_init(&builder, G_VARIANT_TYPE ("ay"));
 290         for (i = 0; i < apdu_data->apdu_len; i++) {
 291                 dbg("apdu_data->apdu_data[%d][0x%02x]", i,apdu_data->apdu_data[i]);
 292                 g_variant_builder_add(&builder, "y", apdu_data->apdu_data[i]);
 293         }
 294         inner_gv = g_variant_builder_end(&builder);
 295         param = g_variant_new("(v)", inner_gv);
 296         /*g_variant_builder_unref (builder);*/
 297
 298         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
 299                         DBUS_TELEPHONY_SAP_INTERFACE, "TransferAPDU", 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         CHECK_ERROR(error);
 319
 320         g_variant_get(dbus_result, "(i)", &result);
 321
 322         if (evt_cb_data->cb_fn) {
 323                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 324         }
 325
 326         g_free(evt_cb_data);
 327         g_variant_unref(dbus_result);
 328 }
 329
 330 EXPORT_API int tel_req_sap_transport_protocol(TapiHandle *handle, TelSimSapProtocol_t protocol, tapi_response_cb callback, void *user_data)
 331 {
 332         struct tapi_resp_data *evt_cb_data = NULL;
 333         GVariant *param = NULL;
 334
 335         dbg("Func Entrance w/ protocol[%d]", protocol);
 336
 337         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 338
 339         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 340
 341         param = g_variant_new("(i)", protocol);
 342         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
 343                         DBUS_TELEPHONY_SAP_INTERFACE, "SetProtocol", param, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
 344                         handle->ca, on_response_sap_transport_protocol, evt_cb_data);
 345
 346         return TAPI_API_SUCCESS;
 347 }
 348
 349 static void on_response_sap_power_operation(GObject *source_object, GAsyncResult *res, gpointer user_data)
 350 {
 351         GError *error = NULL;
 352         GDBusConnection *conn = NULL;
 353         GVariant *dbus_result;
 354
 355         struct tapi_resp_data *evt_cb_data = user_data;
 356         TelSimSapResultCode_t result = TAPI_SIM_SAP_RESULT_CODE_OK;
 357
 358         dbg("Func Entrance");
 359
 360         conn = G_DBUS_CONNECTION (source_object);
 361         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 362         CHECK_ERROR(error);
 363
 364         g_variant_get(dbus_result, "(i)", &result);
 365
 366         if (evt_cb_data->cb_fn) {
 367                 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
 368         }
 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, TelSimSapPowerMode_t power_mode, tapi_response_cb callback, void *user_data)
 375 {
 376         struct tapi_resp_data *evt_cb_data = NULL;
 377         GVariant *param = NULL;
 378         gint mode = 0;
 379         dbg("Func Entrance w/ power_mode[%d]", power_mode);
 380
 381         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 382
 383         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 384
 385         switch (power_mode) {
 386                 case TAPI_SIM_SAP_POWER_SIM_ON_REQ:
 387                         mode = 0;
 388                         break;
 389                 case TAPI_SIM_SAP_POWER_SIM_OFF_REQ:
 390                         mode =1;
 391                         break;
 392                 case TAPI_SIM_SAP_RESET_SIM_REQ:
 393                         mode = 2;
 394                         break;
 395                 default:
 396                         dbg("not handed value[%d]", power_mode);
 397                         break;
 398         }
 399
 400         param = g_variant_new("(i)", mode);
 401         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
 402                         DBUS_TELEPHONY_SAP_INTERFACE, "SetPower", param, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
 403                         handle->ca, on_response_sap_power_operation, evt_cb_data);
 404
 405         return TAPI_API_SUCCESS;
 406 }
 407
 408 static void on_response_sap_cardreader_status(GObject *source_object, GAsyncResult *res, gpointer user_data)
 409 {
 410         GError *error = NULL;
 411         GDBusConnection *conn = NULL;
 412         GVariant *dbus_result;
 413
 414         struct tapi_resp_data *evt_cb_data = user_data;
 415         TelSimSapResultCode_t result = TAPI_SIM_SAP_RESULT_CODE_OK;
 416         TelSimSapCardStatus_t reader_status = TAPI_SIM_SAP_CARD_STATUS_UNKNOWN;
 417
 418         dbg("Func Entrance");
 419
 420         conn = G_DBUS_CONNECTION (source_object);
 421         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 422         CHECK_ERROR(error);
 423
 424         g_variant_get(dbus_result, "(ii)", &result, &reader_status);
 425
 426         if (evt_cb_data->cb_fn) {
 427                 evt_cb_data->cb_fn(evt_cb_data->handle, result, (void*)&reader_status, evt_cb_data->user_data);
 428         }
 429
 430         g_free(evt_cb_data);
 431         g_variant_unref(dbus_result);
 432 }
 433
 434 EXPORT_API int tel_req_sap_cardreader_status(TapiHandle *handle, tapi_response_cb callback, void *user_data)
 435 {
 436         struct tapi_resp_data *evt_cb_data = NULL;
 437
 438         dbg("Func Entrance ");
 439
 440         TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
 441
 442         MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
 443
 444         g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
 445                         DBUS_TELEPHONY_SAP_INTERFACE, "GetCardReaderStatus", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
 446                         handle->ca, on_response_sap_cardreader_status, evt_cb_data);
 447
 448         return TAPI_API_SUCCESS;
 449 }