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