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