src/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 "generated-code.h"
  40 #include "common.h"
  41
  42 static gboolean on_sap_connect(TelephonySap *sap, GDBusMethodInvocation *invocation,
  43                 gint arg_req_max_size, gpointer user_data)
  44 {
  45         struct custom_data *ctx = user_data;
  46         UserRequest *ur = NULL;
  47
  48         struct treq_sap_req_connect req_conn;
  49
  50         ur = MAKE_UR(ctx, sap, invocation);
  51         memset(&req_conn, 0, sizeof(struct treq_sap_req_connect));
  52
  53         req_conn.max_msg_size = (unsigned short)arg_req_max_size;
  54
  55         tcore_user_request_set_data(ur, sizeof(struct treq_sap_req_connect), &req_conn);
  56         tcore_user_request_set_command(ur, TREQ_SAP_REQ_CONNECT);
  57         tcore_communicator_dispatch_request(ctx->comm, ur);
  58
  59         return TRUE;
  60 }
  61
  62 static gboolean on_sap_disconnect(TelephonySap *sap, GDBusMethodInvocation *invocation, gpointer user_data)
  63 {
  64         struct custom_data *ctx = user_data;
  65         UserRequest *ur = NULL;
  66
  67         struct treq_sap_req_disconnect req_disconn;
  68
  69         ur = MAKE_UR(ctx, sap, invocation);
  70         memset(&req_disconn, 0, sizeof(struct treq_sap_req_disconnect));
  71
  72         tcore_user_request_set_data(ur, sizeof(struct treq_sap_req_disconnect), &req_disconn);
  73         tcore_user_request_set_command(ur, TREQ_SAP_REQ_DISCONNECT);
  74         tcore_communicator_dispatch_request(ctx->comm, ur);
  75
  76         return TRUE;
  77 }
  78
  79 static gboolean on_sap_get_status(TelephonySap *sap, GDBusMethodInvocation *invocation, gpointer user_data)
  80 {
  81         struct custom_data *ctx = user_data;
  82         UserRequest *ur = NULL;
  83
  84         struct treq_sap_req_status req_status;
  85
  86         ur = MAKE_UR(ctx, sap, invocation);
  87         memset(&req_status, 0, sizeof(struct treq_sap_req_status));
  88
  89         tcore_user_request_set_data(ur, sizeof(struct treq_sap_req_status), &req_status);
  90         tcore_user_request_set_command(ur, TREQ_SAP_REQ_STATUS);
  91         tcore_communicator_dispatch_request(ctx->comm, ur);
  92
  93         return TRUE;
  94 }
  95
  96 static gboolean on_sap_get_atr(TelephonySap *sap, GDBusMethodInvocation *invocation, gpointer user_data)
  97 {
  98         struct custom_data *ctx = user_data;
  99         UserRequest *ur = NULL;
 100
 101         struct treq_sap_req_atr req_atr;
 102
 103         ur = MAKE_UR(ctx, sap, invocation);
 104         memset(&req_atr, 0, sizeof(struct treq_sap_req_atr));
 105
 106         tcore_user_request_set_data(ur, sizeof(struct treq_sap_req_atr), &req_atr);
 107         tcore_user_request_set_command(ur, TREQ_SAP_REQ_ATR);
 108         tcore_communicator_dispatch_request(ctx->comm, ur);
 109
 110         return TRUE;
 111 }
 112
 113 static gboolean on_sap_transfer_apdu(TelephonySap *sap, GDBusMethodInvocation *invocation,
 114                 GVariant *arg_req_apdu, gpointer user_data)
 115 {
 116         struct custom_data *ctx = user_data;
 117         UserRequest *ur = NULL;
 118         struct treq_sap_transfer_apdu t_apdu;
 119
 120         GVariantIter *iter = NULL;
 121         GVariant *inner_gv = NULL;
 122         guchar rt_i;
 123         int i =0;
 124
 125         dbg("Func Entrance");
 126         memset(&t_apdu, 0, sizeof(struct treq_sap_transfer_apdu));
 127
 128         inner_gv = g_variant_get_variant(arg_req_apdu);
 129
 130         g_variant_get(inner_gv, "ay", &iter);
 131         while ( g_variant_iter_loop (iter, "y", &rt_i)) {
 132                 t_apdu.apdu_data[i] = rt_i;
 133                 i++;
 134         }
 135         t_apdu.apdu_length = (unsigned int)i;
 136         g_variant_iter_free(iter);
 137         g_variant_unref(inner_gv);
 138         g_variant_unref(arg_req_apdu);
 139
 140         for(i=0; i < (int)t_apdu.apdu_length; i++)
 141                 dbg("apdu[%d][0x%02x]",i, t_apdu.apdu_data[i]);
 142
 143         ur = MAKE_UR(ctx, sap, invocation);
 144         tcore_user_request_set_data(ur, sizeof(struct treq_sap_transfer_apdu), &t_apdu);
 145         tcore_user_request_set_command(ur, TREQ_SAP_TRANSFER_APDU);
 146         tcore_communicator_dispatch_request(ctx->comm, ur);
 147
 148         return TRUE;
 149 }
 150
 151 static gboolean on_sap_set_protocol(TelephonySap *sap, GDBusMethodInvocation *invocation,
 152                 gint arg_protocol, gpointer user_data)
 153 {
 154         struct custom_data *ctx = user_data;
 155         UserRequest *ur = NULL;
 156
 157         struct treq_sap_set_protocol set_protocol;
 158
 159         ur = MAKE_UR(ctx, sap, invocation);
 160         memset(&set_protocol, 0, sizeof(struct treq_sap_set_protocol));
 161
 162         set_protocol.protocol = arg_protocol;
 163
 164         tcore_user_request_set_data(ur, sizeof(struct treq_sap_set_protocol), &set_protocol);
 165         tcore_user_request_set_command(ur, TREQ_SAP_SET_PROTOCOL);
 166         tcore_communicator_dispatch_request(ctx->comm, ur);
 167
 168         return TRUE;
 169 }
 170
 171 static gboolean on_sap_set_power(TelephonySap *sap, GDBusMethodInvocation *invocation,
 172                 gint arg_mode, gpointer user_data)
 173 {
 174         struct custom_data *ctx = user_data;
 175         UserRequest *ur = NULL;
 176
 177         struct treq_sap_set_power set_power;
 178
 179         ur = MAKE_UR(ctx, sap, invocation);
 180         memset(&set_power, 0, sizeof(struct treq_sap_set_power));
 181
 182         set_power.mode = arg_mode;
 183
 184         tcore_user_request_set_data(ur, sizeof(struct treq_sap_set_power), &set_power);
 185         tcore_user_request_set_command(ur, TREQ_SAP_SET_POWER);
 186         tcore_communicator_dispatch_request(ctx->comm, ur);
 187
 188         return TRUE;
 189 }
 190
 191 static gboolean on_sap_get_card_reader_status(TelephonySap *sap, GDBusMethodInvocation *invocation, gpointer user_data)
 192 {
 193         struct custom_data *ctx = user_data;
 194         UserRequest *ur = NULL;
 195
 196         struct treq_sap_req_cardreaderstatus req_reader;
 197
 198         ur = MAKE_UR(ctx, sap, invocation);
 199         memset(&req_reader, 0, sizeof(struct treq_sap_req_cardreaderstatus));
 200
 201         tcore_user_request_set_data(ur, sizeof(struct treq_sap_req_cardreaderstatus), &req_reader);
 202         tcore_user_request_set_command(ur, TREQ_SAP_REQ_CARDREADERSTATUS);
 203         tcore_communicator_dispatch_request(ctx->comm, ur);
 204
 205         return TRUE;
 206 }
 207
 208 gboolean dbus_plugin_setup_sap_interface(TelephonyObjectSkeleton *object, struct custom_data *ctx)
 209 {
 210         TelephonySap *sap;
 211
 212         sap = telephony_sap_skeleton_new();
 213         telephony_object_skeleton_set_sap(object, sap);
 214         g_object_unref(sap);
 215
 216         dbg("sap = %p", sap);
 217
 218         g_signal_connect (sap,
 219                         "handle-connect",
 220                         G_CALLBACK (on_sap_connect),
 221                         ctx);
 222
 223         g_signal_connect (sap,
 224                         "handle-disconnect",
 225                         G_CALLBACK (on_sap_disconnect),
 226                         ctx);
 227
 228         g_signal_connect (sap,
 229                         "handle-get-status",
 230                         G_CALLBACK (on_sap_get_status),
 231                         ctx);
 232
 233         g_signal_connect (sap,
 234                         "handle-get-atr",
 235                         G_CALLBACK (on_sap_get_atr),
 236                         ctx);
 237
 238         g_signal_connect (sap,
 239                         "handle-transfer-apdu",
 240                         G_CALLBACK (on_sap_transfer_apdu),
 241                         ctx);
 242
 243         g_signal_connect (sap,
 244                         "handle-set-protocol",
 245                         G_CALLBACK (on_sap_set_protocol),
 246                         ctx);
 247
 248         g_signal_connect (sap,
 249                         "handle-set-power",
 250                         G_CALLBACK (on_sap_set_power),
 251                         ctx);
 252
 253         g_signal_connect (sap,
 254                         "handle-get-card-reader-status",
 255                         G_CALLBACK (on_sap_get_card_reader_status),
 256                         ctx);
 257
 258         return TRUE;
 259 }
 260
 261 gboolean dbus_plugin_sap_response(struct custom_data *ctx, UserRequest *ur,
 262                 struct dbus_request_info *dbus_info, enum tcore_response_command command,
 263                 unsigned int data_len, const void *data)
 264 {
 265         const struct tresp_sap_req_connect *sap_conn = data;
 266         const struct tresp_sap_req_disconnect *sap_disconn = data;
 267         const struct tresp_sap_req_status *sap_status = data;
 268         const struct tresp_sap_req_atr *sap_atr = data;
 269         const struct tresp_sap_transfer_apdu *sap_apdu = data;
 270         const struct tresp_sap_set_protocol *sap_protocol = data;
 271         const struct tresp_sap_set_power *sap_power = data;
 272         const struct tresp_sap_req_cardreaderstatus *sap_reader = data;
 273
 274         dbg("application Command = [0x%x], data_len = %d",command, data_len);
 275
 276         switch (command) {
 277                 case TRESP_SAP_REQ_CONNECT:
 278                         dbg("dbus comm - TRESP_SAP_REQ_CONNECT");
 279                         telephony_sap_complete_connect(dbus_info->interface_object, dbus_info->invocation,
 280                                         sap_conn->status, sap_conn->max_msg_size);
 281                         break;
 282
 283                 case TRESP_SAP_REQ_DISCONNECT:
 284                         dbg("dbus comm - TRESP_SAP_REQ_DISCONNECT");
 285                         telephony_sap_complete_disconnect(dbus_info->interface_object, dbus_info->invocation,
 286                                         sap_disconn->result);
 287                         break;
 288
 289                 case TRESP_SAP_REQ_STATUS:
 290                         dbg("dbus comm - TRESP_SAP_REQ_STATUS");
 291                         telephony_sap_complete_get_status(dbus_info->interface_object, dbus_info->invocation,
 292                                         sap_status->status);
 293                         break;
 294
 295                 case TRESP_SAP_REQ_ATR: {
 296                         GVariantBuilder *builder = NULL;
 297                         GVariant * atr_gv = NULL;
 298                         GVariant *inner_gv = NULL;
 299                         int i =0;
 300
 301                         dbg("dbus comm - TRESP_SAP_REQ_ATR");
 302                         builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
 303                         for(i = 0; i < (int)sap_atr->atr_length; i++) {
 304                                 dbg("sap_atr->atr[%d][0x%02x]", i,sap_atr->atr[i]);
 305                                 g_variant_builder_add (builder, "y", sap_atr->atr[i]);
 306                         }
 307                         inner_gv = g_variant_builder_end(builder);
 308 /*                      g_variant_builder_unref (builder);*/
 309                         atr_gv = g_variant_new("v", inner_gv);
 310
 311                         telephony_sap_complete_get_atr(dbus_info->interface_object, dbus_info->invocation,
 312                                         sap_atr->result, atr_gv);
 313                 }
 314                         break;
 315
 316                 case TRESP_SAP_TRANSFER_APDU: {
 317                         GVariantBuilder *builder = NULL;
 318                         GVariant * apdu_gv = NULL;
 319                         GVariant *inner_gv = NULL;
 320                         int i =0;
 321
 322                         dbg("dbus comm - TRESP_SAP_TRANSFER_APDU");
 323                         builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
 324                         for(i = 0; i < (int)sap_apdu->resp_apdu_length; i++) {
 325                                 dbg("sap_apdu->resp_adpdu[%d][0x%02x]", i,sap_apdu->resp_adpdu[i]);
 326                                 g_variant_builder_add (builder, "y", sap_apdu->resp_adpdu[i]);
 327                         }
 328                         inner_gv = g_variant_builder_end(builder);
 329 /*                      g_variant_builder_unref (builder);*/
 330                         apdu_gv = g_variant_new("v", inner_gv);
 331
 332                         telephony_sap_complete_transfer_apdu(dbus_info->interface_object, dbus_info->invocation,
 333                                         sap_apdu->result, apdu_gv);
 334                 }
 335                         break;
 336
 337                 case TRESP_SAP_SET_PROTOCOL:
 338                         dbg("dbus comm - TRESP_SAP_SET_PROTOCOL");
 339                         telephony_sap_complete_set_protocol(dbus_info->interface_object, dbus_info->invocation,
 340                                         sap_protocol->result);
 341                         break;
 342
 343                 case TRESP_SAP_SET_POWER:
 344                         dbg("dbus comm - TRESP_SAP_SET_POWER");
 345                         telephony_sap_complete_set_power(dbus_info->interface_object, dbus_info->invocation,
 346                                         sap_power->result);
 347                         break;
 348
 349                 case TRESP_SAP_REQ_CARDREADERSTATUS:
 350                         dbg("dbus comm - TRESP_SAP_REQ_CARDREADERSTATUS");
 351                         telephony_sap_complete_get_card_reader_status(dbus_info->interface_object, dbus_info->invocation,
 352                                         sap_reader->result, sap_reader->reader_status);
 353                         break;
 354
 355                 default:
 356                         dbg("not handled command[%d]", command);
 357                 break;
 358         }
 359
 360         return TRUE;
 361 }
 362
 363 gboolean dbus_plugin_sap_notification(struct custom_data *ctx, const char *plugin_name,
 364                 TelephonyObjectSkeleton *object, enum tcore_notification_command command,
 365                 unsigned int data_len, const void *data)
 366 {
 367         TelephonySap *sap;
 368         const struct tnoti_sap_status_changed *n_sap_status = data;
 369         const struct tnoti_sap_disconnect *n_sap_disconn = data;
 370
 371         if (!object) {
 372                 dbg("object is NULL");
 373                 return FALSE;
 374         }
 375
 376         sap = telephony_object_peek_sap(TELEPHONY_OBJECT(object));
 377         dbg("sap = %p", sap);
 378
 379         dbg("notification !!! (command = 0x%x, data_len = %d)", command, data_len);
 380
 381         switch (command) {
 382                 case TNOTI_SAP_STATUS:
 383                         dbg("notified sap_status[%d]", n_sap_status->status);
 384                         telephony_sap_emit_status(sap, n_sap_status->status);
 385                         break;
 386                 case TNOTI_SAP_DISCONNECT:
 387                         dbg("notified sap_disconnect type[%d]", n_sap_disconn->type);
 388                         telephony_sap_emit_disconnect(sap, n_sap_disconn->type);
 389                         break;
 390                 default:
 391                         dbg("not handled command[%d]", command);
 392                 break;
 393         }
 394
 395         return TRUE;
 396 }