src/net_nfc_client_snep.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 "net_nfc_typedef_internal.h"
  18 #include "net_nfc_debug_internal.h"
  19 #include "net_nfc_util_internal.h"
  20 #include "net_nfc_util_ndef_message.h"
  21 #include "net_nfc_util_gdbus_internal.h"
  22 #include "net_nfc_gdbus.h"
  23 #include "net_nfc_data.h"
  24 #include "net_nfc_ndef_message.h"
  25 #include "net_nfc_client.h"
  26 #include "net_nfc_client_manager.h"
  27 #include "net_nfc_client_snep.h"
  28
  29 #ifndef NET_NFC_EXPORT_API
  30 #define NET_NFC_EXPORT_API __attribute__((visibility("default")))
  31 #endif
  32
  33 /* LCOV_EXCL_START */
  34
  35 static NetNfcGDbusSnep *snep_proxy = NULL;
  36
  37 /*******************************************************************/
  38
  39 static void snep_send_client_request(GObject *source_object,
  40         GAsyncResult *res,
  41         gpointer user_data);
  42
  43 /*********************************************************************/
  44
  45 static void snep_send_client_request(GObject *source_object,
  46         GAsyncResult *res,
  47         gpointer user_data)
  48 {
  49         GVariant *parameter = (GVariant *)user_data;
  50         net_nfc_error_e out_result;
  51         net_nfc_snep_type_t out_type = NET_NFC_SNEP_GET;
  52         GVariant *out_data = NULL;
  53         GError *error = NULL;
  54         net_nfc_client_snep_event_cb callback;
  55         void *user_param;
  56         net_nfc_snep_handle_h handle;
  57
  58         g_assert(parameter != NULL);
  59
  60         if (net_nfc_gdbus_snep_call_client_request_finish(
  61                 NET_NFC_GDBUS_SNEP(source_object),
  62                 (gint *)&out_result,
  63                 (guint *)&out_type,
  64                 &out_data,
  65                 res,
  66                 &error) == FALSE) {
  67                 DEBUG_ERR_MSG("Can not finish send client request %s",
  68                         error->message);
  69                 out_result = NET_NFC_IPC_FAIL;
  70
  71                 g_error_free(error);
  72         }
  73
  74         g_variant_get(parameter, "(ttt)",
  75                 &callback,
  76                 &user_param,
  77                 &handle);
  78
  79         if (callback != NULL) {
  80                 ndef_message_h message;
  81
  82                 message = net_nfc_util_gdbus_variant_to_ndef_message(out_data);
  83
  84                 callback(handle, out_type, out_result,
  85                         message, user_param);
  86
  87                 net_nfc_free_ndef_message(message);
  88         }
  89
  90         g_variant_unref(parameter);
  91 }
  92
  93 NET_NFC_EXPORT_API
  94 net_nfc_error_e net_nfc_client_snep_start_server(
  95         net_nfc_target_handle_h target,
  96         const char *san,
  97         sap_t sap,
  98         net_nfc_client_snep_event_cb callback,
  99         void *user_data)
 100 {
 101         net_nfc_error_e result = NET_NFC_OK;
 102         GError *error = NULL;
 103         GVariant *parameter;
 104
 105         if (snep_proxy == NULL) {
 106                 DEBUG_ERR_MSG("Can not get Snep Proxy");
 107
 108                 return NET_NFC_NOT_INITIALIZED;
 109         }
 110
 111         /* prevent executing daemon when nfc is off */
 112         if (net_nfc_client_manager_is_activated() == false)
 113                 return NET_NFC_NOT_ACTIVATED;
 114
 115         parameter = g_variant_new("(tt)",
 116                 callback,
 117                 user_data);
 118
 119         if (net_nfc_gdbus_snep_call_server_start_sync(snep_proxy,
 120                 GPOINTER_TO_UINT(target),
 121                 sap,
 122                 san,
 123                 GPOINTER_TO_UINT(parameter),
 124                 (gint *)&result,
 125                 NULL,
 126                 &error) == FALSE) {
 127                 DEBUG_ERR_MSG("snep server(sync call) failed: %s",
 128                         error->message);
 129                 result = NET_NFC_IPC_FAIL;
 130
 131                 g_error_free(error);
 132
 133                 g_variant_unref(parameter);
 134         }
 135
 136         return result;
 137 }
 138
 139 NET_NFC_EXPORT_API
 140 net_nfc_error_e net_nfc_client_snep_start_client(
 141         net_nfc_target_handle_h target,
 142         const char *san,
 143         sap_t sap,
 144         net_nfc_client_snep_event_cb callback,
 145         void *user_data)
 146 {
 147         net_nfc_error_e result = NET_NFC_OK;
 148         GError *error = NULL;
 149         GVariant *parameter;
 150
 151         if (snep_proxy == NULL) {
 152                 DEBUG_ERR_MSG("Can not get Snep Proxy");
 153
 154                 return NET_NFC_NOT_INITIALIZED;
 155         }
 156
 157         /* prevent executing daemon when nfc is off */
 158         if (net_nfc_client_manager_is_activated() == false)
 159                 return NET_NFC_NOT_ACTIVATED;
 160
 161         parameter = g_variant_new("(tt)",
 162                 callback,
 163                 user_data);
 164
 165         if (net_nfc_gdbus_snep_call_client_start_sync(snep_proxy,
 166                 GPOINTER_TO_UINT(target),
 167                 sap,
 168                 san,
 169                 GPOINTER_TO_UINT(parameter),
 170                 (gint *)&result,
 171                 NULL,
 172                 &error) == FALSE) {
 173                 DEBUG_ERR_MSG("snep client(sync call) failed: %s",
 174                         error->message);
 175                 result = NET_NFC_IPC_FAIL;
 176
 177                 g_error_free(error);
 178
 179                 g_variant_unref(parameter);
 180         }
 181
 182         return result;
 183 }
 184
 185 NET_NFC_EXPORT_API
 186 net_nfc_error_e net_nfc_client_snep_send_client_request(
 187         net_nfc_snep_handle_h target,
 188         net_nfc_snep_type_t snep_type,
 189         ndef_message_h msg,
 190         net_nfc_client_snep_event_cb callback,
 191         void *user_data)
 192 {
 193         GVariant *ndef_msg = NULL;
 194         GVariant *parameter;
 195
 196         if (target == NULL || msg == NULL)
 197                 return NET_NFC_NULL_PARAMETER;
 198
 199         if (snep_proxy == NULL) {
 200                 DEBUG_ERR_MSG("Can not get Snep Proxy");
 201
 202                 return NET_NFC_NOT_INITIALIZED;
 203         }
 204
 205         /* prevent executing daemon when nfc is off */
 206         if (net_nfc_client_manager_is_activated() == false)
 207                 return NET_NFC_NOT_ACTIVATED;
 208
 209         parameter = g_variant_new("(ttt)",
 210                 callback,
 211                 user_data,
 212                 target);
 213
 214         ndef_msg = net_nfc_util_gdbus_ndef_message_to_variant(msg);
 215
 216         net_nfc_gdbus_snep_call_client_request(snep_proxy,
 217                 GPOINTER_TO_UINT(target),
 218                 snep_type,
 219                 ndef_msg,
 220                 NULL,
 221                 snep_send_client_request,
 222                 parameter);
 223
 224         return NET_NFC_OK;
 225 }
 226 #if 0
 227 NET_NFC_EXPORT_API
 228 net_nfc_error_e net_nfc_client_snep_send_client_request_sync(
 229         net_nfc_target_handle_h target,
 230         net_nfc_snep_type_t snep_type,
 231         ndef_message_h msg,
 232         net_nfc_snep_type_t *resp_type,
 233         ndef_message_h *response)
 234 {
 235         GVariant *resp_msg = NULL;
 236         GVariant *arg_msg = NULL;
 237         GError *error = NULL;
 238         net_nfc_error_e result;
 239         guint type;
 240
 241         if (target == NULL || msg == NULL ||
 242                 resp_type == NULL || response == NULL)
 243                 return NET_NFC_NULL_PARAMETER;
 244
 245         *response = NULL;
 246
 247         if (snep_proxy == NULL) {
 248                 DEBUG_ERR_MSG("Can not get Snep Proxy");
 249
 250                 return NET_NFC_NOT_INITIALIZED;
 251         }
 252
 253         arg_msg = net_nfc_util_gdbus_ndef_message_to_variant(msg);
 254
 255         if (net_nfc_gdbus_snep_call_client_request_sync(snep_proxy,
 256                 GPOINTER_TO_UINT(target),
 257                 snep_type,
 258                 arg_msg,
 259                 &result,
 260                 resp_type,
 261                 &resp_msg,
 262                 NULL,
 263                 &error) == TRUE) {
 264                 data_s ndef_data = { NULL, };
 265
 266                 net_nfc_util_gdbus_variant_to_data_s(resp_msg, &ndef_data);
 267
 268                 if (ndef_data.buffer != NULL && ndef_data.length > 0) {
 269                         result = net_nfc_create_ndef_message_from_rawdata(
 270                                 response,
 271                                 &ndef_data);
 272
 273                         net_nfc_util_free_data(&ndef_data);
 274                 }
 275         } else {
 276                 DEBUG_ERR_MSG(" send client request (sync call) failed: %s",
 277                         error->message);
 278                 g_error_free(error);
 279
 280                 return NET_NFC_IPC_FAIL;
 281         }
 282
 283
 284         return result;
 285 }
 286 #endif
 287 NET_NFC_EXPORT_API
 288 net_nfc_error_e net_nfc_client_snep_stop_service_sync(
 289         net_nfc_target_handle_h target,
 290         net_nfc_snep_handle_h service)
 291 {
 292         net_nfc_error_e result = NET_NFC_OK;
 293         GError *error = NULL;
 294
 295         if (target == NULL || service == NULL)
 296                 return NET_NFC_NULL_PARAMETER;
 297
 298         if (snep_proxy == NULL) {
 299                 DEBUG_ERR_MSG("Can not get Snep Proxy");
 300
 301                 return NET_NFC_NOT_INITIALIZED;
 302         }
 303
 304         /* prevent executing daemon when nfc is off */
 305         if (net_nfc_client_manager_is_activated() == false)
 306                 return NET_NFC_NOT_ACTIVATED;
 307
 308         if (net_nfc_gdbus_snep_call_stop_snep_sync(
 309                 snep_proxy,
 310                 GPOINTER_TO_UINT(target),
 311                 GPOINTER_TO_UINT(service),
 312                 (gint *)&result,
 313                 NULL,
 314                 &error) == FALSE) {
 315                 DEBUG_ERR_MSG("snep stop service(sync call) failed: %s",
 316                         error->message);
 317                 result = NET_NFC_IPC_FAIL;
 318
 319                 g_error_free(error);
 320         }
 321
 322         return result;
 323 }
 324
 325 static void _snep_event_cb(NetNfcGDbusSnep *object,
 326         guint arg_handle,
 327         guint arg_event,
 328         gint arg_result,
 329         GVariant *arg_ndef_msg,
 330         guint arg_user_data)
 331 {
 332         GVariant *parameter = (GVariant *)GUINT_TO_POINTER(arg_user_data);
 333
 334         INFO_MSG(">>> SIGNAL arrived");
 335
 336         DEBUG_CLIENT_MSG("handle [%p], event [%d], result [%d], user_data [%p]",
 337                 GUINT_TO_POINTER(arg_handle),
 338                 arg_event,
 339                 arg_result,
 340                 parameter);
 341
 342         if (parameter != NULL) {
 343                 net_nfc_client_snep_event_cb callback;
 344                 void *user_data;
 345
 346                 g_variant_get(parameter,
 347                         "(tt)",
 348                         &callback,
 349                         &user_data);
 350
 351                 if (callback != NULL) {
 352                         ndef_message_h message;
 353
 354                         message = net_nfc_util_gdbus_variant_to_ndef_message(
 355                                         arg_ndef_msg);
 356
 357                         callback(GUINT_TO_POINTER(arg_handle),
 358                                 arg_event,
 359                                 arg_result,
 360                                 message,
 361                                 user_data);
 362
 363                         net_nfc_free_ndef_message(message);
 364                 }
 365 #if 0 /* remove temporary... */
 366                 if (arg_event == NET_NFC_LLCP_UNREGISTERED)
 367                         g_variant_unref(parameter);
 368 #endif
 369         }
 370 }
 371
 372 NET_NFC_EXPORT_API
 373 net_nfc_error_e net_nfc_client_snep_register_server(const char *san,
 374         sap_t sap,
 375         net_nfc_client_snep_event_cb callback,
 376         void *user_data)
 377 {
 378         net_nfc_error_e result = NET_NFC_OK;
 379         GError *error = NULL;
 380         GVariant *parameter;
 381
 382         if (snep_proxy == NULL) {
 383                 if (net_nfc_client_snep_init() != NET_NFC_OK) {
 384                         DEBUG_ERR_MSG("Snep Proxy fail");
 385                         return NET_NFC_NOT_INITIALIZED;
 386                 }
 387         }
 388
 389         /* prevent executing daemon when nfc is off */
 390         if (net_nfc_client_manager_is_activated() == false)
 391                 return NET_NFC_NOT_ACTIVATED;
 392
 393         parameter = g_variant_new("(tt)",
 394                 callback,
 395                 user_data);
 396
 397         if (net_nfc_gdbus_snep_call_server_register_sync(snep_proxy,
 398                 sap,
 399                 san,
 400                 GPOINTER_TO_UINT(parameter),
 401                 (gint *)&result,
 402                 NULL,
 403                 &error) == FALSE) {
 404                 DEBUG_ERR_MSG("snep register server(sync call) failed: %s",
 405                         error->message);
 406                 result = NET_NFC_IPC_FAIL;
 407
 408                 g_error_free(error);
 409
 410                 g_variant_unref(parameter);
 411         }
 412
 413         return result;
 414 }
 415
 416 NET_NFC_EXPORT_API
 417 net_nfc_error_e net_nfc_client_snep_unregister_server(const char *san,
 418         sap_t sap)
 419 {
 420         net_nfc_error_e result = NET_NFC_OK;
 421         GError *error = NULL;
 422
 423         if (snep_proxy == NULL) {
 424                 DEBUG_ERR_MSG("Can not get Snep Proxy");
 425
 426                 return NET_NFC_NOT_INITIALIZED;
 427         }
 428
 429         /* prevent executing daemon when nfc is off */
 430         if (net_nfc_client_manager_is_activated() == false)
 431                 return NET_NFC_NOT_ACTIVATED;
 432
 433         if (net_nfc_gdbus_snep_call_server_unregister_sync(snep_proxy,
 434                 sap,
 435                 san,
 436                 (gint *)&result,
 437                 NULL,
 438                 &error) == FALSE) {
 439                 DEBUG_ERR_MSG("snep unregister server(sync call) failed: %s",
 440                         error->message);
 441                 result = NET_NFC_IPC_FAIL;
 442
 443                 g_error_free(error);
 444         }
 445
 446         return result;
 447 }
 448
 449 net_nfc_error_e net_nfc_client_snep_init(void)
 450 {
 451         GError *error = NULL;
 452
 453         if (snep_proxy) {
 454                 DEBUG_CLIENT_MSG("Already initialized");
 455
 456                 return NET_NFC_OK;
 457         }
 458
 459         snep_proxy = net_nfc_gdbus_snep_proxy_new_for_bus_sync(
 460                 G_BUS_TYPE_SYSTEM,
 461                 G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
 462                 "org.tizen.NetNfcService",
 463                 "/org/tizen/NetNfcService/Snep",
 464                 NULL,
 465                 &error);
 466         if (snep_proxy == NULL) {
 467                 DEBUG_ERR_MSG("Can not create proxy : %s", error->message);
 468                 g_error_free(error);
 469
 470                 return NET_NFC_UNKNOWN_ERROR;
 471         }
 472
 473         g_signal_connect(snep_proxy, "snep-event",
 474                         G_CALLBACK(_snep_event_cb), NULL);
 475
 476         return NET_NFC_OK;
 477 }
 478
 479 void net_nfc_client_snep_deinit(void)
 480 {
 481         if (snep_proxy) {
 482                 g_object_unref(snep_proxy);
 483                 snep_proxy = NULL;
 484         }
 485 }
 486
 487 /* LCOV_EXCL_STOP */
 488