src/net_nfc_client_hce.c

   1 /*
   2  * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Flora License, Version 1.1 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "vconf.h"
  18
  19 #include "net_nfc_typedef_internal.h"
  20 #include "net_nfc_debug_internal.h"
  21 #include "net_nfc_util_internal.h"
  22 #include "net_nfc_util_ndef_message.h"
  23 #include "net_nfc_util_gdbus_internal.h"
  24 #include "net_nfc_gdbus.h"
  25 #include "net_nfc_client.h"
  26 #include "net_nfc_client_util_internal.h"
  27 #include "net_nfc_client_manager.h"
  28 #include "net_nfc_client_hce_ipc.h"
  29 #include "net_nfc_client_hce.h"
  30
  31 /* LCOV_EXCL_START */
  32
  33
  34 #ifndef NET_NFC_EXPORT_API
  35 #define NET_NFC_EXPORT_API __attribute__((visibility("default")))
  36 #endif
  37
  38 typedef struct _HceHandler HceHandler;
  39
  40 struct _HceHandler {
  41         net_nfc_client_hce_event_cb hce_event_cb;
  42         gpointer hce_data;
  43 };
  44
  45 static NetNfcGDbusHce *hce_proxy = NULL;
  46
  47 static HceHandler hce_handler;
  48 static char package_name[1024];
  49
  50 static void __load_package_name()
  51 {
  52         if (net_nfc_util_get_pkgid_by_pid(getpid(),
  53                 package_name, sizeof(package_name)) == false) {
  54                 DEBUG_ERR_MSG("failed to get package name, pid [%d]", getpid());
  55         }
  56 }
  57
  58 static void hce_event_received(GObject *source_object, guint arg_handle,
  59         guint arg_event, GVariant *arg_apdu, gchar *arg_package)
  60 {
  61         INFO_MSG(">>> SIGNAL arrived");
  62
  63         if (hce_handler.hce_event_cb != NULL) {
  64
  65                 data_s apdu = { NULL, 0 };
  66
  67                 net_nfc_util_gdbus_variant_to_data_s(arg_apdu, &apdu);
  68
  69                 hce_handler.hce_event_cb((net_nfc_target_handle_h)GUINT_TO_POINTER(arg_handle),
  70                         (net_nfc_hce_event_t)arg_event, &apdu,
  71                         hce_handler.hce_data);
  72
  73                 net_nfc_util_clear_data(&apdu);
  74         }
  75 }
  76
  77 void net_nfc_client_hce_process_received_event(int event,
  78         net_nfc_target_handle_h handle, data_h data)
  79 {
  80         INFO_MSG(">>> SIGNAL arrived");
  81
  82         if (hce_handler.hce_event_cb != NULL) {
  83                 hce_handler.hce_event_cb(handle,
  84                         (net_nfc_hce_event_t)event, data,
  85                         hce_handler.hce_data);
  86         }
  87 }
  88
  89
  90
  91 NET_NFC_EXPORT_API
  92 net_nfc_error_e net_nfc_client_hce_set_event_received_cb(
  93         net_nfc_client_hce_event_cb callback, void *user_data)
  94 {
  95         net_nfc_error_e result = NET_NFC_OK;
  96         GError *error = NULL;
  97
  98         if (callback == NULL)
  99                 return net_nfc_client_hce_unset_event_received_cb();
 100
 101         if (hce_proxy == NULL) {
 102                 result = net_nfc_client_hce_init();
 103                 if (result != NET_NFC_OK) {
 104                         DEBUG_ERR_MSG("net_nfc_client_hce_init failed, [%d]", result);
 105
 106                         return result;
 107                 }
 108         }
 109
 110         if (net_nfc_gdbus_hce_call_start_hce_handler_sync(hce_proxy,
 111                 &result, NULL, &error) == true) {
 112                 hce_handler.hce_event_cb = callback;
 113                 hce_handler.hce_data = user_data;
 114
 115                 if (net_nfc_client_hce_ipc_is_initialized() == false) {
 116                         result = net_nfc_client_hce_ipc_init();
 117                         if (result != NET_NFC_OK) {
 118                                 DEBUG_ERR_MSG("net_nfc_client_hce_ipc_init failed");
 119
 120                                 result = NET_NFC_IPC_FAIL;
 121                         }
 122                 }
 123         } else {
 124                 if (error != NULL) {
 125                         DEBUG_ERR_MSG("net_nfc_gdbus_hce_call_start_hce_handler_sync failed: %s", error->message);
 126                         g_error_free(error);
 127                 }
 128
 129                 result = NET_NFC_IPC_FAIL;
 130         }
 131
 132         return result;
 133 }
 134
 135 NET_NFC_EXPORT_API
 136 net_nfc_error_e net_nfc_client_hce_unset_event_received_cb(void)
 137 {
 138         net_nfc_error_e result = NET_NFC_OK;
 139         GError *error = NULL;
 140
 141         if (hce_proxy == NULL) {
 142                 DEBUG_ERR_MSG("not initialized!!!");
 143
 144                 return NET_NFC_NOT_INITIALIZED;
 145         }
 146
 147         if (net_nfc_gdbus_hce_call_stop_hce_handler_sync(hce_proxy,
 148                 &result, NULL, &error) == true) {
 149                 hce_handler.hce_event_cb = NULL;
 150                 hce_handler.hce_data = NULL;
 151
 152                 net_nfc_client_hce_ipc_deinit();
 153         } else {
 154                 if (error != NULL) {
 155                         DEBUG_ERR_MSG("net_nfc_gdbus_hce_call_stop_hce_handler_sync failed: %s", error->message);
 156                         g_error_free(error);
 157                 }
 158
 159                 result = NET_NFC_IPC_FAIL;
 160         }
 161
 162         return result;
 163 }
 164 #if 0
 165 NET_NFC_EXPORT_API
 166 net_nfc_error_e net_nfc_client_hce_response_apdu_sync(
 167                                 net_nfc_target_handle_h handle,
 168                                 data_h resp_apdu_data)
 169 {
 170         net_nfc_error_e result = NET_NFC_OK;
 171         GError *error = NULL;
 172         GVariant *arg_data = NULL;
 173
 174         INFO_MSG(">>> net_nfc_client_hce_response_apdu_sync!!");
 175
 176         if (hce_proxy == NULL) {
 177                 result = net_nfc_client_hce_init();
 178                 if (result != NET_NFC_OK) {
 179                         DEBUG_ERR_MSG("net_nfc_client_hce_init failed, [%d]", result);
 180
 181                         return result;
 182                 }
 183         }
 184
 185         arg_data = net_nfc_util_gdbus_data_to_variant((data_s *)resp_apdu_data);
 186         if (arg_data == NULL) {
 187
 188                 INFO_MSG(">>> resp_apdu_data is null !!");
 189                 return NET_NFC_INVALID_PARAM;
 190         }
 191
 192         if (net_nfc_gdbus_hce_call_response_apdu_sync(
 193                 hce_proxy,
 194                 GPOINTER_TO_UINT(handle),
 195                 arg_data,
 196                 &result,
 197                 NULL,
 198                 &error) == true) {
 199         } else {
 200                 DEBUG_ERR_MSG("Response APDU failed: %s", error->message);
 201                 result = NET_NFC_IPC_FAIL;
 202
 203                 g_error_free(error);
 204         }
 205
 206         return result;
 207 }
 208 #else
 209 NET_NFC_EXPORT_API
 210 net_nfc_error_e net_nfc_client_hce_response_apdu_sync(
 211                                 net_nfc_target_handle_h handle,
 212                                 data_h resp_apdu_data)
 213 {
 214         net_nfc_error_e result;
 215
 216         DEBUG_CLIENT_MSG(">>> net_nfc_client_hce_response_apdu_sync!!");
 217
 218         if (hce_proxy == NULL) {
 219                 result = net_nfc_client_hce_init();
 220                 if (result != NET_NFC_OK) {
 221                         DEBUG_ERR_MSG("net_nfc_client_hce_init failed, [%d]", result);
 222
 223                         return result;
 224                 }
 225         }
 226
 227         if (net_nfc_client_hce_ipc_is_initialized() == false) {
 228                 if (net_nfc_client_hce_ipc_init() == false) {
 229                         DEBUG_ERR_MSG("net_nfc_client_hce_ipc_init failed");
 230
 231                         return NET_NFC_NOT_INITIALIZED;
 232                 }
 233         }
 234
 235         if (net_nfc_server_hce_ipc_send_to_server(0, handle, resp_apdu_data) == true) {
 236                 result = NET_NFC_OK;
 237         } else {
 238                 DEBUG_ERR_MSG("net_nfc_server_hce_ipc_send_to_server failed");
 239
 240                 result = NET_NFC_IPC_FAIL;
 241         }
 242
 243         return result;
 244 }
 245 #endif
 246 net_nfc_error_e net_nfc_client_hce_init(void)
 247 {
 248         GError *error = NULL;
 249
 250         DEBUG_CLIENT_MSG("net_nfc_client_hce_init call");
 251
 252         if (hce_proxy) {
 253                 DEBUG_CLIENT_MSG("Already initialized");
 254
 255                 return NET_NFC_OK;
 256         }
 257
 258         hce_proxy = net_nfc_gdbus_hce_proxy_new_for_bus_sync(
 259                                 G_BUS_TYPE_SYSTEM,
 260                                 G_DBUS_PROXY_FLAGS_NONE,
 261                                 "org.tizen.NetNfcService",
 262                                 "/org/tizen/NetNfcService/Hce",
 263                                 NULL,
 264                                 &error);
 265
 266         if (hce_proxy == NULL) {
 267                 if (error != NULL) {
 268                         DEBUG_ERR_MSG("Can not create proxy : %s", error->message);
 269                         g_error_free(error);
 270                 }
 271
 272                 return NET_NFC_UNKNOWN_ERROR;
 273         }
 274
 275         g_signal_connect(hce_proxy, "event-received",
 276                 G_CALLBACK(hce_event_received), NULL);
 277
 278         /* get package name */
 279         __load_package_name();
 280
 281         return NET_NFC_OK;
 282 }
 283
 284 void net_nfc_client_hce_deinit(void)
 285 {
 286         if (hce_proxy != NULL) {
 287                 net_nfc_client_hce_ipc_deinit();
 288
 289                 g_object_unref(hce_proxy);
 290                 hce_proxy = NULL;
 291         }
 292 }
 293
 294 /* LCOV_EXCL_STOP */
 295