src/tapi_sap.c

   1 /*
   2  * libtapi
   3  *
   4  * Copyright (c) 2013 Samsung Electronics Co. Ltd. All rights reserved.
   5  * Copyright (c) 2013 Intel Corporation. All rights reserved.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23
  24 #include "tapi_log.h"
  25 #include "tapi.h"
  26 #include "tapi_private.h"
  27
  28 #include "tel_sap.h"
  29 #include "tapi_sap.h"
  30
  31 void on_sap_signal_emit_handler(TelephonySap *sap, gchar *sender_name,
  32                                                         gchar *signal_name, GVariant *parameters,
  33                                                         gpointer user_data)
  34 {
  35         TapiEvtCbData *evt_cb_data = NULL;
  36         TelHandle *handle = user_data;
  37         char *evt_id = NULL;
  38
  39         dbg("Entry");
  40
  41         if (handle == NULL) {
  42                 err("handle is null");
  43                 return;
  44         }
  45
  46         evt_id = g_strdup_printf("%s:%s", TELEPHONY_SAP_INTERFACE,
  47                                         signal_name);
  48
  49         evt_cb_data = g_hash_table_lookup(handle->evt_table, evt_id);
  50         if (evt_cb_data == NULL) {
  51                 warn("evt_cb_data is null for the signal[%s]", signal_name);
  52                 g_free(evt_id);
  53                 return;
  54         }
  55
  56         if (!g_strcmp0(signal_name, "Status")) {
  57                 TelSapCardStatus status;
  58
  59                 g_variant_get(parameters, "(i)", &status);
  60                 dbg("signal[%s] status[%d]", signal_name, status);
  61
  62                 EVT_CALLBACK_CALL(handle, evt_cb_data, evt_id, &status);
  63         } else {
  64                 err("Unsupported signal %s", signal_name);
  65         }
  66         g_free(evt_id);
  67 }
  68
  69 static void on_response_sap_req_connect(GObject *source_object,
  70                         GAsyncResult *res, gpointer user_data)
  71 {
  72         TapiRespCbData *rsp_cb_data = user_data;
  73         TelHandle *handle = GET_TAPI_HANDLE(rsp_cb_data);
  74         TelSapResult result = TEL_SAP_RESULT_FAILURE_NO_REASON;
  75         unsigned int max_msg_size;
  76         GError *error = NULL;
  77
  78         dbg("Entry");
  79
  80         telephony_sap_call_req_connect_finish(handle->sap_proxy,
  81                         (int *)&result, &max_msg_size, res, &error);
  82
  83         CHECK_DEINIT(error, rsp_cb_data, result);
  84
  85         RESP_CALLBACK_CALL(rsp_cb_data, result, &max_msg_size);
  86 }
  87
  88 EXPORT_API TelReturn tapi_sap_req_connect(TelHandle *handle,
  89                         unsigned int max_msg_size,
  90                         TapiResponseCb callback, void *user_data)
  91 {
  92         TapiRespCbData *rsp_cb_data;
  93
  94         dbg("Entry");
  95
  96         g_return_val_if_fail(handle != NULL && callback != NULL,
  97                         TEL_RETURN_INVALID_PARAMETER);
  98
  99         MAKE_RESP_CB_DATA(rsp_cb_data, handle, callback, user_data);
 100
 101         telephony_sap_call_req_connect(handle->sap_proxy, max_msg_size, NULL,
 102                         on_response_sap_req_connect, rsp_cb_data);
 103
 104         return TEL_RETURN_SUCCESS;
 105 }
 106
 107 static void on_response_sap_req_disconnect(GObject *source_object,
 108                         GAsyncResult *res, gpointer user_data)
 109 {
 110         TapiRespCbData *rsp_cb_data = user_data;
 111         TelHandle *handle = GET_TAPI_HANDLE(rsp_cb_data);
 112         TelSapResult result = TEL_SAP_RESULT_FAILURE_NO_REASON;
 113         GError *error = NULL;
 114
 115         dbg("Entry");
 116
 117         telephony_sap_call_req_disconnect_finish(handle->sap_proxy,
 118                         (int *)&result, res, &error);
 119
 120         CHECK_DEINIT(error, rsp_cb_data, result);
 121
 122         RESP_CALLBACK_CALL(rsp_cb_data, result, NULL);
 123 }
 124
 125 EXPORT_API TelReturn tapi_sap_req_disconnect(TelHandle *handle,
 126                         TapiResponseCb callback, void *user_data)
 127 {
 128         TapiRespCbData *rsp_cb_data;
 129
 130         dbg("Entry");
 131
 132         g_return_val_if_fail(handle != NULL && callback != NULL,
 133                         TEL_RETURN_INVALID_PARAMETER);
 134
 135         MAKE_RESP_CB_DATA(rsp_cb_data, handle, callback, user_data);
 136
 137         telephony_sap_call_req_disconnect(handle->sap_proxy, NULL,
 138                         on_response_sap_req_disconnect, rsp_cb_data);
 139
 140         return TEL_RETURN_SUCCESS;
 141 }
 142
 143 static void on_response_sap_get_atr(GObject *source_object,
 144                         GAsyncResult *res, gpointer user_data)
 145 {
 146         TapiRespCbData *rsp_cb_data = user_data;
 147         TelHandle *handle = GET_TAPI_HANDLE(rsp_cb_data);
 148         TelSapResult result = TEL_SAP_RESULT_FAILURE_NO_REASON;
 149         TelSapAtr atr;
 150         char *content = NULL;
 151         GError *error = NULL;
 152
 153         guchar *binary_content;
 154
 155         dbg("Entry");
 156
 157         telephony_sap_call_get_atr_finish(handle->sap_proxy,
 158                         (int *)&result, &content, res, &error);
 159
 160         CHECK_DEINIT(error, rsp_cb_data, result);
 161
 162         if (result != TEL_SAP_RESULT_SUCCESS) {
 163                 RESP_CALLBACK_CALL(rsp_cb_data, result, NULL);
 164                 g_free(content);
 165                 return;
 166         }
 167
 168         binary_content = g_base64_decode(content, &atr.atr_len);
 169
 170         if (atr.atr_len > TEL_SAP_ATR_LEN_MAX) {
 171                 err("ATR length is too long");
 172                 RESP_CALLBACK_CALL(rsp_cb_data,
 173                                 TEL_SAP_RESULT_FAILURE_NO_REASON, NULL);
 174                 g_free(content);
 175                 g_free(binary_content);
 176                 return;
 177         }
 178
 179         memcpy(atr.atr, binary_content, atr.atr_len);
 180
 181         RESP_CALLBACK_CALL(rsp_cb_data, result, &atr);
 182         g_free(content);
 183         g_free(binary_content);
 184 }
 185
 186 EXPORT_API TelReturn tapi_sap_get_atr(TelHandle *handle,
 187                         TapiResponseCb callback, void *user_data)
 188 {
 189         TapiRespCbData *rsp_cb_data;
 190
 191         dbg("Entry");
 192
 193         g_return_val_if_fail(handle != NULL && callback != NULL,
 194                         TEL_RETURN_INVALID_PARAMETER);
 195
 196         MAKE_RESP_CB_DATA(rsp_cb_data, handle, callback, user_data);
 197
 198         telephony_sap_call_get_atr(handle->sap_proxy, NULL,
 199                         on_response_sap_get_atr, rsp_cb_data);
 200
 201         return TEL_RETURN_SUCCESS;
 202 }
 203
 204 static void on_response_sap_req_transfer_apdu(GObject *source_object,
 205                         GAsyncResult *res, gpointer user_data)
 206 {
 207         TapiRespCbData *rsp_cb_data = user_data;
 208         TelHandle *handle = GET_TAPI_HANDLE(rsp_cb_data);
 209         TelSapResult result = TEL_SAP_RESULT_FAILURE_NO_REASON;
 210         TelSapApduResp rsp;
 211         char *pdu = NULL;
 212         GError *error = NULL;
 213
 214         guchar *binary_pdu;
 215
 216         dbg("Entry");
 217
 218         telephony_sap_call_req_transfer_apdu_finish(handle->sap_proxy,
 219                         (int *)&result, &pdu, res, &error);
 220
 221         CHECK_DEINIT(error, rsp_cb_data, result);
 222
 223         if (result != TEL_SAP_RESULT_SUCCESS) {
 224                 RESP_CALLBACK_CALL(rsp_cb_data, result, NULL);
 225                 g_free(pdu);
 226                 return;
 227         }
 228
 229         binary_pdu = g_base64_decode(pdu, &rsp.apdu_resp_len);
 230
 231         if (rsp.apdu_resp_len > TEL_SAP_APDU_RESP_LEN_MAX) {
 232                 err("Req Transfer APDU response pdu length is too long");
 233                 RESP_CALLBACK_CALL(rsp_cb_data,
 234                                 TEL_SAP_RESULT_FAILURE_NO_REASON, NULL);
 235                 g_free(pdu);
 236                 g_free(binary_pdu);
 237                 return;
 238         }
 239
 240         memcpy(rsp.apdu_resp, binary_pdu, rsp.apdu_resp_len);
 241
 242         RESP_CALLBACK_CALL(rsp_cb_data, result, &rsp);
 243         g_free(pdu);
 244         g_free(binary_pdu);
 245 }
 246
 247 EXPORT_API TelReturn tapi_sap_req_transfer_apdu(TelHandle *handle,
 248                         TelSapApdu *apdu, TapiResponseCb callback,
 249                         void *user_data)
 250 {
 251         TapiRespCbData *rsp_cb_data;
 252         char *encoded_apdu;
 253
 254         dbg("Entry");
 255
 256         g_return_val_if_fail(handle != NULL && apdu != NULL &&
 257                         apdu->apdu_len < TEL_SAP_APDU_LEN_MAX &&
 258                         callback != NULL, TEL_RETURN_INVALID_PARAMETER);
 259
 260         MAKE_RESP_CB_DATA(rsp_cb_data, handle, callback, user_data);
 261
 262         encoded_apdu = g_base64_encode(apdu->apdu, apdu->apdu_len);
 263         telephony_sap_call_req_transfer_apdu(handle->sap_proxy,
 264                         encoded_apdu, NULL,
 265                         on_response_sap_req_transfer_apdu, rsp_cb_data);
 266
 267         g_free(encoded_apdu);
 268         return TEL_RETURN_SUCCESS;
 269 }
 270
 271 static void on_response_sap_req_transport_protocol(GObject *source_object,
 272                         GAsyncResult *res, gpointer user_data)
 273 {
 274         TapiRespCbData *rsp_cb_data = user_data;
 275         TelHandle *handle = GET_TAPI_HANDLE(rsp_cb_data);
 276         TelSapResult result = TEL_SAP_RESULT_FAILURE_NO_REASON;
 277         GError *error = NULL;
 278
 279         dbg("Entry");
 280
 281         telephony_sap_call_req_transport_protocol_finish(handle->sap_proxy,
 282                         (int *)&result, res, &error);
 283
 284         CHECK_DEINIT(error, rsp_cb_data, result);
 285
 286         RESP_CALLBACK_CALL(rsp_cb_data, result, NULL);
 287 }
 288
 289 EXPORT_API TelReturn tapi_sap_req_transport_protocol(TelHandle *handle,
 290                         TelSimSapProtocol protocol,
 291                         TapiResponseCb callback, void *user_data)
 292 {
 293         TapiRespCbData *rsp_cb_data;
 294
 295         dbg("Entry");
 296
 297         g_return_val_if_fail(handle != NULL &&
 298                         protocol <= TEL_SIM_SAP_PROTOCOL_T1 && callback != NULL,
 299                         TEL_RETURN_INVALID_PARAMETER);
 300
 301         MAKE_RESP_CB_DATA(rsp_cb_data, handle, callback, user_data);
 302
 303         telephony_sap_call_req_transport_protocol(handle->sap_proxy, protocol,
 304                         NULL, on_response_sap_req_transport_protocol, rsp_cb_data);
 305
 306         return TEL_RETURN_SUCCESS;
 307 }
 308
 309 static void on_response_sap_req_power_operation(GObject *source_object,
 310                         GAsyncResult *res, gpointer user_data)
 311 {
 312         TapiRespCbData *rsp_cb_data = user_data;
 313         TelHandle *handle = GET_TAPI_HANDLE(rsp_cb_data);
 314         TelSapResult result = TEL_SAP_RESULT_FAILURE_NO_REASON;
 315         GError *error = NULL;
 316
 317         dbg("Entry");
 318
 319         telephony_sap_call_req_power_operation_finish(handle->sap_proxy,
 320                         (int *)&result, res, &error);
 321
 322         CHECK_DEINIT(error, rsp_cb_data, result);
 323
 324         RESP_CALLBACK_CALL(rsp_cb_data, result, NULL);
 325 }
 326
 327 EXPORT_API TelReturn tapi_sap_req_power_operation(TelHandle *handle,
 328                         TelSapPowerMode mode,
 329                         TapiResponseCb callback, void *user_data)
 330 {
 331         TapiRespCbData *rsp_cb_data;
 332
 333         dbg("Entry");
 334
 335         g_return_val_if_fail(handle != NULL && mode <= TEL_SAP_SIM_RESET_REQ &&
 336                         callback != NULL,
 337                         TEL_RETURN_INVALID_PARAMETER);
 338
 339         MAKE_RESP_CB_DATA(rsp_cb_data, handle, callback, user_data);
 340
 341         telephony_sap_call_req_power_operation(handle->sap_proxy, mode,
 342                         NULL, on_response_sap_req_power_operation, rsp_cb_data);
 343
 344         return TEL_RETURN_SUCCESS;
 345 }
 346
 347 static void on_response_sap_get_card_reader_status(GObject *source_object,
 348                         GAsyncResult *res, gpointer user_data)
 349 {
 350         TapiRespCbData *rsp_cb_data = user_data;
 351         TelHandle *handle = GET_TAPI_HANDLE(rsp_cb_data);
 352         TelSapResult result = TEL_SAP_RESULT_FAILURE_NO_REASON;
 353         int status;
 354         GError *error = NULL;
 355
 356         dbg("Entry");
 357
 358         telephony_sap_call_get_card_reader_status_finish(handle->sap_proxy,
 359                         (int *)&result, (int *)&status, res, &error);
 360
 361         CHECK_DEINIT(error, rsp_cb_data, result);
 362
 363         RESP_CALLBACK_CALL(rsp_cb_data, result, &status);
 364 }
 365
 366 EXPORT_API TelReturn tapi_sap_get_cardreader_status(TelHandle *handle,
 367                         TapiResponseCb callback, void *user_data)
 368 {
 369         TapiRespCbData *rsp_cb_data;
 370
 371         dbg("Entry");
 372
 373         g_return_val_if_fail(handle != NULL && callback != NULL,
 374                         TEL_RETURN_INVALID_PARAMETER);
 375
 376         MAKE_RESP_CB_DATA(rsp_cb_data, handle, callback, user_data);
 377
 378         telephony_sap_call_get_card_reader_status(handle->sap_proxy, NULL,
 379                         on_response_sap_get_card_reader_status, rsp_cb_data);
 380
 381         return TEL_RETURN_SUCCESS;
 382 }