plugin/src/socket_sap.c

   1 /*
   2  * tel-plugin-socket-communicator
   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-object.h>
  26
  27 #include <tcore.h>
  28 #include <server.h>
  29 #include <plugin.h>
  30 #include <hal.h>
  31 #include <communicator.h>
  32 #include <core_object.h>
  33 #include <queue.h>
  34 #include <user_request.h>
  35 #include <util.h>
  36 #include <co_sap.h>
  37 #include <co_sim.h>
  38
  39 #include "sipc.h"
  40 #include "tapi_common.h"
  41 #include "module_req.h"
  42
  43 gboolean scomm_service_reqeust_sap(unsigned int ch_id, Communicator *c, TcorePlugin *plugin, tapi_service_command_e cmd, gchar *data, void **outparam)
  44 {
  45         GSList *co_list = NULL;
  46         CoreObject *co_sap = NULL;
  47         UserRequest *ur = NULL;
  48         struct tcore_user_info ui = { 0, 0, 0, NULL,0,0, NULL };
  49         int ret = 0;
  50
  51         gchar *tmp = NULL;
  52         int tmp_len = 0;
  53         struct _sipc_marshal_object *in_o;
  54
  55         co_list = tcore_plugin_get_core_objects_bytype(plugin, CORE_OBJECT_TYPE_SAP);
  56         if (!co_list) {
  57                 dbg("err-no sap core object list in current plugin");
  58                 return FALSE;
  59         }
  60
  61         co_sap = (CoreObject *)co_list->data;
  62         if (!co_sap) {
  63                 dbg("err-no sap core object in current plugin");
  64                 return FALSE;
  65         }
  66
  67         g_slist_free(co_list);
  68
  69         ur = tcore_user_request_new(c, tcore_plugin_get_description(plugin)->name);
  70         if (!ur) {
  71                 dbg("err - ur creation failed");
  72                 return FALSE;
  73         }
  74
  75         ui.channel_id = ch_id;
  76         ui.client_cmd = cmd;
  77         tcore_user_request_set_user_info(ur, &ui);
  78
  79         in_o = sipc_util_marshal_object_deserializer(data);
  80         if(in_o){
  81                 dbg("err - data deserializer failed");
  82                 return FALSE;
  83         }
  84
  85         switch (cmd) {
  86                 case TAPI_SERVICE_SAP_CONNECT :{
  87                         struct treq_sap_req_connect req_conn = {0, };
  88                         gint g_max_size;
  89                         g_max_size = sipc_util_marshal_object_get_int(in_o, "max_size");
  90                         req_conn.max_msg_size = (unsigned short)g_max_size;
  91                         tcore_user_request_set_data(ur, sizeof(struct treq_sap_req_connect), &req_conn);
  92                         tcore_user_request_set_command(ur, TREQ_SIM_SET_LANGUAGE);
  93                 }
  94                         break;
  95
  96                 case TAPI_SERVICE_SAP_DISCONNECT: {
  97                         struct treq_sap_req_disconnect req_disconn;
  98                         tcore_user_request_set_data(ur, sizeof(struct treq_sap_req_disconnect), &req_disconn);
  99                         tcore_user_request_set_command(ur, TREQ_SAP_REQ_DISCONNECT);
 100                 }
 101                         break;
 102
 103                 case TAPI_SERVICE_SAP_GET_CONNECTSTATUS: {
 104                         struct treq_sap_req_status req_status;
 105                         tcore_user_request_set_data(ur, sizeof(struct treq_sap_req_status), &req_status);
 106                         tcore_user_request_set_command(ur, TREQ_SAP_REQ_STATUS);
 107                 }
 108                         break;
 109
 110                 case TAPI_SERVICE_SAP_GET_ATR : {
 111                         struct treq_sap_req_atr req_atr;
 112                         tcore_user_request_set_data(ur, sizeof(struct treq_sap_req_atr), &req_atr);
 113                         tcore_user_request_set_command(ur, TREQ_SAP_REQ_ATR);
 114                 }
 115                         break;
 116
 117                 case TAPI_SERVICE_SAP_TRANSFER_APDU : {
 118                         struct treq_sap_transfer_apdu t_apdu = {0, };
 119                         gchar *apdu_data = NULL;
 120                         apdu_data = sipc_util_marshal_object_get_string(in_o, "apdu");
 121                         t_apdu.apdu_length = strlen(apdu_data);
 122                         memcpy(t_apdu.apdu_data, apdu_data, t_apdu.apdu_length);
 123
 124                         tcore_user_request_set_data(ur, sizeof(struct treq_sap_transfer_apdu), &t_apdu);
 125                         tcore_user_request_set_command(ur, TREQ_SAP_TRANSFER_APDU);
 126                 }
 127                         break;
 128
 129                 case TAPI_SERVICE_SAP_SET_PROTOCOL : {
 130                         struct treq_sap_set_protocol set_protocol;
 131                         enum tel_sap_protocol_type g_protocol = 0;
 132                         g_protocol = sipc_util_marshal_object_get_int(in_o, "protocol");
 133                         set_protocol.protocol = g_protocol;
 134
 135                         tcore_user_request_set_data(ur, sizeof(struct treq_sap_set_protocol), &set_protocol);
 136                         tcore_user_request_set_command(ur, TREQ_SAP_SET_PROTOCOL);
 137                 }
 138                         break;
 139
 140                 case TAPI_SERVICE_SAP_SET_POWER : {
 141                         struct treq_sap_set_power set_power;
 142                         enum tel_sap_power_mode g_mode = SAP_POWER_ON;
 143                         g_mode = sipc_util_marshal_object_get_int(in_o, "mode");
 144                         set_power.mode = g_mode;
 145
 146                         tcore_user_request_set_data(ur, sizeof(struct treq_sap_set_power), &set_power);
 147                         tcore_user_request_set_command(ur, TREQ_SAP_SET_POWER);
 148                 }
 149                         break;
 150
 151                 case TAPI_SERVICE_SAP_GET_READERSTATUS : {
 152                         struct treq_sap_req_cardreaderstatus req_reader;
 153                         tcore_user_request_set_data(ur, sizeof(struct treq_sap_req_cardreaderstatus), &req_reader);
 154                         tcore_user_request_set_command(ur, TREQ_SAP_REQ_CARDREADERSTATUS);
 155                 }
 156                         break;
 157
 158                 default :
 159                         dbg("not handled command[%d] here",cmd);
 160                         break;
 161         }
 162
 163         ret = tcore_communicator_dispatch_request(c, ur);
 164         if (ret != TCORE_RETURN_SUCCESS) {
 165                 return FALSE;
 166         }
 167         return TRUE;
 168 }
 169
 170 gboolean scomm_service_response_sap(Communicator *comm, UserRequest *ur, enum tcore_response_command command,
 171                 unsigned int data_len, const void *data)
 172 {
 173         const struct tresp_sap_req_connect *sap_conn = data;
 174         const struct tresp_sap_req_disconnect *sap_disconn = data;
 175         const struct tresp_sap_req_status *sap_status = data;
 176         const struct tresp_sap_req_atr *sap_atr = data;
 177         const struct tresp_sap_transfer_apdu *sap_apdu = data;
 178         const struct tresp_sap_set_protocol *sap_protocol = data;
 179         const struct tresp_sap_set_power *sap_power = data;
 180         const struct tresp_sap_req_cardreaderstatus *sap_reader = data;
 181         int ret = 0;
 182         gchar *out_d= NULL, *serial_d = NULL;
 183         struct custom_data *ctx = NULL;
 184         const struct tcore_user_info *ui;
 185         sipc_server_t *s = NULL;
 186         struct _tapi_header hdr;
 187         struct _sipc_marshal_object* out_o = NULL;
 188
 189         memset(&hdr, 0, sizeof(struct _tapi_header));
 190
 191         ctx = tcore_communicator_ref_user_data(comm);
 192         if (!ctx) {
 193                 dbg("user_data is NULL");
 194                 return FALSE;
 195         }
 196
 197         ui = tcore_user_request_ref_user_info(ur);
 198         s = ctx->sk_server;
 199
 200         dbg("application channel id(%d), Command = [0x%x], data_len = %d", ui->channel_id, command, data_len);
 201         hdr.cmd = (tapi_service_command_e)ui->client_cmd;
 202
 203         out_o = sipc_util_marshal_object_create();
 204
 205         switch (command) {
 206                 case TRESP_SAP_REQ_CONNECT:
 207                         sipc_util_marshal_object_add_data(out_o, "result", (void*)&sap_conn->status, SIPC_MARSHAL_DATA_INT_TYPE);
 208                         sipc_util_marshal_object_add_data(out_o, "max_size", (void*)&sap_conn->max_msg_size , SIPC_MARSHAL_DATA_INT_TYPE);
 209                         break;
 210
 211                 case TRESP_SAP_REQ_DISCONNECT:
 212                         sipc_util_marshal_object_add_data(out_o, "result", (void*)&sap_disconn->result, SIPC_MARSHAL_DATA_INT_TYPE);
 213                         break;
 214
 215                 case TRESP_SAP_REQ_STATUS:
 216                         sipc_util_marshal_object_add_data(out_o, "status", (void*)&sap_status->status, SIPC_MARSHAL_DATA_INT_TYPE);
 217                         break;
 218
 219                 case TRESP_SAP_REQ_ATR:
 220                         sipc_util_marshal_object_add_data(out_o, "result", (void*)&sap_atr->result, SIPC_MARSHAL_DATA_INT_TYPE);
 221                         sipc_util_marshal_object_add_data(out_o, "atr", (void*)&sap_atr->atr, SIPC_MARSHAL_DATA_STRING_TYPE);
 222                         break;
 223
 224                 case TRESP_SAP_TRANSFER_APDU:
 225                         sipc_util_marshal_object_add_data(out_o, "result", (void*)&sap_apdu->result, SIPC_MARSHAL_DATA_INT_TYPE);
 226                         sipc_util_marshal_object_add_data(out_o, "apdu", (void*)&sap_apdu->resp_adpdu, SIPC_MARSHAL_DATA_STRING_TYPE);
 227                         break;
 228
 229                 case TRESP_SAP_SET_PROTOCOL:
 230                         sipc_util_marshal_object_add_data(out_o, "result", (void*)&sap_protocol->result, SIPC_MARSHAL_DATA_INT_TYPE);
 231                         break;
 232
 233                 case TRESP_SAP_SET_POWER:
 234                         sipc_util_marshal_object_add_data(out_o, "result", (void*)&sap_power->result, SIPC_MARSHAL_DATA_INT_TYPE);
 235                         break;
 236
 237                 case TRESP_SAP_REQ_CARDREADERSTATUS:
 238                         sipc_util_marshal_object_add_data(out_o, "result", (void*)&sap_reader->result, SIPC_MARSHAL_DATA_INT_TYPE);
 239                         sipc_util_marshal_object_add_data(out_o, "status", (void*)&sap_reader->reader_status, SIPC_MARSHAL_DATA_INT_TYPE);
 240                         break;
 241         }
 242
 243
 244         if(out_o){
 245                 serial_d = sipc_util_marshal_object_serializer(out_o);
 246                 hdr.data_len = strlen(serial_d);
 247                 sipc_util_marshal_object_destory(out_o);
 248         }
 249
 250         out_d = g_new0(char, sizeof(struct _tapi_header)+hdr.data_len);
 251         memcpy(out_d, &hdr, sizeof(struct _tapi_header));
 252         if(serial_d){
 253                 memcpy(out_d+sizeof(struct _tapi_header), serial_d, hdr.data_len);
 254                 g_free(serial_d);
 255         }
 256
 257         ret = sipc_server_send(s, ui->channel_id, out_d, sizeof(struct _tapi_header)+hdr.data_len, SIPC_SEND_DATA_ASYNC);
 258         g_free(out_d);
 259
 260         if(ret < 0){
 261                 return FALSE;
 262         }
 263
 264         return TRUE;
 265 }
 266
 267
 268 gboolean scomm_service_notification_sap(Communicator *comm, CoreObject *source, enum tcore_notification_command command,
 269                 unsigned int data_len, const void *data)
 270 {
 271         const struct tnoti_sap_status_changed *n_sap_status = data;
 272         const struct tnoti_sap_disconnect *n_sap_disconn = data;
 273         int ret = 0;
 274         gchar *out_d = NULL, *serial_d = NULL;
 275         struct custom_data *ctx = NULL;
 276         sipc_server_t *s = NULL;
 277
 278         struct _tapi_header hdr;
 279         struct _sipc_marshal_object* out_o = NULL;
 280
 281         memset(&hdr, 0, sizeof(struct _tapi_header));
 282
 283         ctx = tcore_communicator_ref_user_data(comm);
 284         if (!ctx) {
 285                 dbg("user_data is NULL");
 286                 return FALSE;
 287         }
 288
 289         s = ctx->sk_server;
 290         dbg("notification !!! (command = 0x%x, data_len = %d)", command, data_len);
 291
 292         out_o = sipc_util_marshal_object_create();
 293
 294         switch (command) {
 295                 case TNOTI_SAP_STATUS :
 296                         dbg("notified sap_status[%d]", n_sap_status->status);
 297                         sipc_util_marshal_object_add_data(out_o, "status", (void*)&n_sap_status->status, SIPC_MARSHAL_DATA_INT_TYPE);
 298                         break;
 299
 300                 case TNOTI_SAP_DISCONNECT :
 301                         dbg("notified sap_disconnect type[%d]", n_sap_disconn->type);
 302                         sipc_util_marshal_object_add_data(out_o, "type", (void*)&n_sap_disconn->type, SIPC_MARSHAL_DATA_INT_TYPE);
 303                         break;
 304
 305                 default :
 306                         dbg("not handled command [%d] here",command);
 307                         break;
 308         }
 309
 310         if(out_o){
 311                 serial_d = sipc_util_marshal_object_serializer(out_o);
 312                 hdr.data_len = strlen(serial_d);
 313                 sipc_util_marshal_object_destory(out_o);
 314         }
 315
 316         out_d = g_new0(char, sizeof(struct _tapi_header)+hdr.data_len);
 317         memcpy(out_d, &hdr, sizeof(struct _tapi_header));
 318         if(serial_d){
 319                 memcpy(out_d+sizeof(struct _tapi_header), serial_d, hdr.data_len);
 320                 g_free(serial_d);
 321         }
 322
 323         ret = sipc_server_broadcast(s, out_d, sizeof(struct _tapi_header)+hdr.data_len);
 324         g_free(out_d);
 325
 326         if(ret < 0){
 327                 return FALSE;
 328         }
 329         return TRUE;
 330 }