daemon/net_nfc_server_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 <glib.h>
  18
  19 #include "net_nfc_debug_internal.h"
  20 #include "net_nfc_util_defines.h"
  21 #include "net_nfc_util_internal.h"
  22 #include "net_nfc_server_controller.h"
  23 #include "net_nfc_server_common.h"
  24 #include "net_nfc_server_llcp.h"
  25 #include "net_nfc_server_snep.h"
  26 #include "net_nfc_server_process_snep.h"
  27 #include "net_nfc_util_gdbus_internal.h"
  28 #include "net_nfc_server_context.h"
  29
  30 /* declaration */
  31 static gboolean _handle_start_server(
  32                 NetNfcGDbusSnep *object,
  33                 GDBusMethodInvocation *invocation,
  34                 guint arg_handle,
  35                 guint arg_sap,
  36                 const gchar *arg_san,
  37                 guint arg_user_data,
  38                 GVariant *arg_privilege);
  39
  40 static gboolean _handle_start_client(
  41                 NetNfcGDbusSnep *object,
  42                 GDBusMethodInvocation *invocation,
  43                 guint arg_handle,
  44                 guint arg_sap,
  45                 const gchar *arg_san,
  46                 guint arg_user_data,
  47                 GVariant *arg_privilege);
  48
  49 static gboolean _handle_client_send_request(
  50                 NetNfcGDbusSnep *object,
  51                 GDBusMethodInvocation *invocation,
  52                 guint arg_snep_handle,
  53                 guint arg_type,
  54                 GVariant *arg_ndef_msg,
  55                 GVariant *arg_privilege);
  56
  57 static gboolean _handle_stop_snep(
  58                 NetNfcGDbusSnep *object,
  59                 GDBusMethodInvocation *invocation,
  60                 guint arg_handle,
  61                 guint arg_snep_handle,
  62                 GVariant *arg_privilege);
  63
  64 static void snep_server_start_thread_func(gpointer user_data);
  65
  66 static void snep_client_start_thread_func(gpointer user_data);
  67
  68 static void snep_client_send_request_thread_func(gpointer user_data);
  69
  70 static void snep_stop_service_thread_func(gpointer user_data);
  71
  72 /* definition */
  73 static NetNfcGDbusSnep *snep_skeleton =  NULL;
  74
  75 static void _emit_snep_event_signal(GVariant *parameter,
  76                 net_nfc_snep_handle_h handle,
  77                 net_nfc_error_e result,
  78                 uint32_t type,
  79                 data_s *data)
  80 {
  81         GDBusConnection *connection;
  82         char *client_id;
  83         void *user_data;
  84         GVariant *arg_data;
  85         GError *error = NULL;
  86
  87         g_variant_get(parameter, "(usu)",
  88                         (guint *)&connection,
  89                         &client_id,
  90                         (guint *)&user_data);
  91
  92         arg_data = net_nfc_util_gdbus_data_to_variant(data);
  93
  94         if (g_dbus_connection_emit_signal(
  95                                 connection,
  96                                 client_id,
  97                                 "/org/tizen/NetNfcService/Snep",
  98                                 "org.tizen.NetNfcService.Snep",
  99                                 "SnepEvent",
 100                                 g_variant_new("(uui@a(y)u)", GPOINTER_TO_UINT(handle), type, (gint)result,
 101                                         arg_data, GPOINTER_TO_UINT(user_data)),
 102                                 &error) == false)
 103         {
 104                 if (error != NULL && error->message != NULL) {
 105                         NFC_ERR("g_dbus_connection_emit_signal failed : %s", error->message);
 106                 } else {
 107                         NFC_ERR("g_dbus_connection_emit_signal failed");
 108                 }
 109         }
 110
 111         g_free(client_id);
 112 }
 113
 114 static net_nfc_error_e _snep_server_cb(net_nfc_snep_handle_h handle,
 115                 net_nfc_error_e result,
 116                 uint32_t type,
 117                 data_s *data,
 118                 void *user_param)
 119 {
 120         GVariant *parameter = (GVariant *)user_param;
 121
 122         data_s *temp = data;
 123
 124         NFC_DBG("type [%d], result [%d], data [%p], user_param [%p]",
 125                         type, result, data, user_param);
 126
 127         switch (type)
 128         {
 129         case SNEP_REQ_GET :
 130                 {
 131                         uint32_t max_len = 0;
 132
 133                         net_nfc_server_snep_parse_get_request(data, &max_len,
 134                                         temp);
 135                 }
 136                 break;
 137
 138         case SNEP_REQ_PUT :
 139                 break;
 140
 141         default :
 142                 NFC_ERR("error [%d]", result);
 143                 break;
 144         }
 145
 146         if (result < NET_NFC_OK) {
 147                 type = NET_NFC_LLCP_STOP;
 148         }
 149
 150         _emit_snep_event_signal(parameter, handle,
 151                         result, type, data);
 152
 153         if (type == NET_NFC_LLCP_STOP) {
 154                 g_object_unref(parameter);
 155         }
 156
 157         return result;
 158 }
 159
 160 static void snep_server_start_thread_func(gpointer user_data)
 161 {
 162         NetNfcGDbusSnep *object;
 163         GDBusMethodInvocation *invocation;
 164         net_nfc_target_handle_s *arg_handle;
 165         guint arg_sap;
 166         gchar *arg_san;
 167         void *arg_user_data;
 168         net_nfc_error_e result;
 169
 170         GVariant *parameter;
 171         GDBusConnection *connection;
 172
 173         if (user_data == NULL)
 174         {
 175                 NFC_ERR("cannot get SNEP client data");
 176
 177                 return;
 178         }
 179
 180         g_variant_get((GVariant *)user_data,
 181                         "(uuuusu)",
 182                         (guint *)&object,
 183                         (guint *)&invocation,
 184                         (guint *)&arg_handle,
 185                         &arg_sap,
 186                         &arg_san,
 187                         (guint *)&arg_user_data);
 188
 189         g_assert(object != NULL);
 190         g_assert(invocation != NULL);
 191
 192         connection = g_dbus_method_invocation_get_connection(invocation);
 193
 194         parameter = g_variant_new("(usu)",
 195                         GPOINTER_TO_UINT(g_object_ref(connection)),
 196                         g_dbus_method_invocation_get_sender(invocation),
 197                         GPOINTER_TO_UINT(arg_user_data));
 198         if (parameter != NULL) {
 199                 result = net_nfc_server_snep_server(arg_handle,
 200                                 arg_san,
 201                                 arg_sap,
 202                                 _snep_server_cb,
 203                                 parameter);
 204                 if (result != NET_NFC_OK) {
 205                         NFC_ERR("net_nfc_server_snep_server failed, [%d]",
 206                                         result);
 207                         g_object_unref(connection);
 208
 209                         g_variant_unref(parameter);
 210                 }
 211         } else {
 212                 NFC_ERR("g_variant_new failed");
 213
 214                 g_object_unref(connection);
 215
 216                 result = NET_NFC_ALLOC_FAIL;
 217         }
 218
 219         net_nfc_gdbus_snep_complete_server_start(object, invocation, result);
 220
 221         g_free(arg_san);
 222
 223         g_variant_unref(user_data);
 224 }
 225
 226 static gboolean _handle_start_server(
 227                 NetNfcGDbusSnep *object,
 228                 GDBusMethodInvocation *invocation,
 229                 guint arg_handle,
 230                 guint arg_sap,
 231                 const gchar *arg_san,
 232                 guint arg_user_data,
 233                 GVariant *arg_privilege)
 234 {
 235         GVariant *parameter;
 236         gboolean result;
 237
 238         NFC_INFO(">>> REQUEST from [%s]",
 239                         g_dbus_method_invocation_get_sender(invocation));
 240
 241         /* check privilege and update client context */
 242         if (net_nfc_server_gdbus_check_privilege(invocation,
 243                                 arg_privilege,
 244                                 "nfc-manager::p2p",
 245                                 "rw") == false) {
 246                 NFC_ERR("permission denied, and finished request");
 247
 248                 return FALSE;
 249         }
 250
 251         parameter = g_variant_new("(uuuusu)",
 252                         GPOINTER_TO_UINT(g_object_ref(object)),
 253                         GPOINTER_TO_UINT(g_object_ref(invocation)),
 254                         arg_handle,
 255                         arg_sap,
 256                         arg_san,
 257                         arg_user_data);
 258
 259         if (parameter != NULL)
 260         {
 261                 if ((result = net_nfc_server_controller_async_queue_push(
 262                                                 snep_server_start_thread_func, parameter)) == FALSE)
 263                 {
 264                         NFC_ERR("net_nfc_server_controller_async_queue_push failed");
 265
 266                         g_dbus_method_invocation_return_dbus_error(invocation,
 267                                         "org.tizen.NetNfcService.Snep.ThreadError",
 268                                         "can not push to controller thread");
 269
 270                         g_object_unref(invocation);
 271                         g_object_unref(object);
 272
 273                         g_variant_unref(parameter);
 274                 }
 275         }
 276         else
 277         {
 278                 NFC_ERR("g_variant_new failed");
 279
 280                 g_dbus_method_invocation_return_dbus_error(invocation,
 281                                 "org.tizen.NetNfcService.Snep.MemoryError",
 282                                 "Out of memory");
 283
 284                 result = FALSE;
 285         }
 286
 287         return result;
 288 }
 289
 290 static net_nfc_error_e _snep_start_client_cb(
 291                 net_nfc_snep_handle_h handle,
 292                 net_nfc_error_e result,
 293                 uint32_t type,
 294                 data_s *data,
 295                 void *user_param)
 296 {
 297         GVariant *parameter = (GVariant *)user_param;
 298
 299         NFC_DBG("type [%d], result [%d], data [%p], user_param [%p]",
 300                         type, result, data, user_param);
 301
 302         _emit_snep_event_signal(parameter, handle, result, type, data);
 303
 304         if (type == NET_NFC_LLCP_STOP) {
 305                 g_variant_unref(parameter);
 306         }
 307
 308         return result;
 309 }
 310
 311 static void snep_client_start_thread_func(gpointer user_data)
 312 {
 313         NetNfcGDbusSnep *object;
 314         GDBusMethodInvocation *invocation;
 315         net_nfc_target_handle_s *arg_handle;
 316         guint arg_sap;
 317         gchar *arg_san;
 318         void *arg_user_data;
 319         net_nfc_error_e result;
 320
 321         GVariant *parameter;
 322         GDBusConnection *connection;
 323
 324         if (user_data == NULL)
 325         {
 326                 NFC_ERR("cannot get SNEP client data");
 327
 328                 return;
 329         }
 330
 331         g_variant_get((GVariant *)user_data,
 332                         "(uuuusu)",
 333                         (guint *)&object,
 334                         (guint *)&invocation,
 335                         (guint *)&arg_handle,
 336                         &arg_sap,
 337                         &arg_san,
 338                         (guint *)&arg_user_data);
 339
 340         g_assert(object != NULL);
 341         g_assert(invocation != NULL);
 342
 343         connection = g_dbus_method_invocation_get_connection(invocation);
 344
 345         parameter = g_variant_new("(usu)",
 346                         GPOINTER_TO_UINT(g_object_ref(connection)),
 347                         g_dbus_method_invocation_get_sender(invocation),
 348                         GPOINTER_TO_UINT(arg_user_data));
 349         if (parameter != NULL) {
 350                 result = net_nfc_server_snep_client(arg_handle,
 351                                 arg_san,
 352                                 arg_sap,
 353                                 _snep_start_client_cb,
 354                                 parameter);
 355                 if (result != NET_NFC_OK) {
 356                         NFC_ERR("net_nfc_server_snep_client failed, [%d]",
 357                                         result);
 358                         g_object_unref(connection);
 359
 360                         g_variant_unref(parameter);
 361                 }
 362         } else {
 363                 NFC_ERR("g_variant_new failed");
 364
 365                 g_object_unref(connection);
 366
 367                 result = NET_NFC_ALLOC_FAIL;
 368         }
 369
 370         net_nfc_gdbus_snep_complete_client_start(object, invocation, result);
 371
 372         g_free(arg_san);
 373
 374         g_variant_unref(user_data);
 375 }
 376
 377 static gboolean _handle_start_client(
 378                 NetNfcGDbusSnep *object,
 379                 GDBusMethodInvocation *invocation,
 380                 guint arg_handle,
 381                 guint arg_sap,
 382                 const gchar *arg_san,
 383                 guint arg_user_data,
 384                 GVariant *arg_privilege)
 385 {
 386         GVariant *parameter;
 387         gboolean result;
 388
 389         NFC_INFO(">>> REQUEST from [%s]",
 390                         g_dbus_method_invocation_get_sender(invocation));
 391
 392         /* check privilege and update client context */
 393         if (net_nfc_server_gdbus_check_privilege(invocation,
 394                                 arg_privilege,
 395                                 "nfc-manager::p2p",
 396                                 "rw") == false) {
 397                 NFC_ERR("permission denied, and finished request");
 398
 399                 return FALSE;
 400         }
 401
 402         parameter = g_variant_new("(uuuusu)",
 403                         GPOINTER_TO_UINT(g_object_ref(object)),
 404                         GPOINTER_TO_UINT(g_object_ref(invocation)),
 405                         arg_handle,
 406                         arg_sap,
 407                         arg_san,
 408                         arg_user_data);
 409
 410         if (parameter != NULL)
 411         {
 412                 if ((result = net_nfc_server_controller_async_queue_push(
 413                                                 snep_client_start_thread_func, parameter)) == FALSE)
 414                 {
 415                         NFC_ERR("net_nfc_server_controller_async_queue_push failed");
 416
 417                         g_dbus_method_invocation_return_dbus_error(invocation,
 418                                         "org.tizen.NetNfcService.Snep.ThreadError",
 419                                         "can not push to controller thread");
 420
 421                         g_object_unref(invocation);
 422                         g_object_unref(object);
 423
 424                         g_object_unref(g_variant_unref);
 425                 }
 426         }
 427         else
 428         {
 429                 NFC_ERR("g_variant_new failed");
 430
 431                 g_dbus_method_invocation_return_dbus_error(invocation,
 432                                 "org.tizen.NetNfcService.Snep.MemoryError",
 433                                 "Out of memory");
 434
 435                 result = FALSE;
 436         }
 437
 438         return result;
 439 }
 440
 441 static net_nfc_error_e _snep_client_request_cb(
 442                 net_nfc_snep_handle_h handle,
 443                 net_nfc_error_e result,
 444                 net_nfc_snep_type_t type,
 445                 data_s *data,
 446                 void *user_param)
 447 {
 448         GVariant *parameter = (GVariant *)user_param;
 449
 450         NFC_DBG("type [%d], result [%d], data [%p], user_param [%p]",
 451                         type, result, data, user_param);
 452
 453         if (parameter != NULL) {
 454                 NetNfcGDbusSnep *object;
 455                 GDBusMethodInvocation *invocation;
 456                 net_nfc_snep_handle_h arg_snep_handle;
 457                 net_nfc_snep_type_t arg_type;
 458                 GVariant *arg_ndef_msg;
 459                 GVariant *arg_data = NULL;
 460
 461                 g_variant_get(parameter,
 462                                 "(uuuu@a(y))",
 463                                 (guint *)&object,
 464                                 (guint *)&invocation,
 465                                 (guint *)&arg_snep_handle,
 466                                 (guint *)&arg_type,
 467                                 &arg_ndef_msg);
 468
 469                 if (data != NULL && data->buffer != NULL && data->length > 0) {
 470                         arg_data = net_nfc_util_gdbus_data_to_variant(data);
 471                 } else {
 472                         arg_data = net_nfc_util_gdbus_buffer_to_variant(NULL, 0);
 473                 }
 474
 475                 net_nfc_gdbus_snep_complete_client_request(object,
 476                                 invocation,
 477                                 result,
 478                                 type,
 479                                 arg_data);
 480
 481                 g_variant_unref(arg_ndef_msg);
 482
 483                 g_object_unref(invocation);
 484                 g_object_unref(object);
 485
 486                 g_variant_unref(parameter);
 487
 488                 result = NET_NFC_OK;
 489         } else {
 490                 result = NET_NFC_NULL_PARAMETER;
 491         }
 492
 493         return result;
 494 }
 495
 496 static void snep_client_send_request_thread_func(gpointer user_data)
 497 {
 498         NetNfcGDbusSnep *object;
 499         GDBusMethodInvocation *invocation;
 500         net_nfc_snep_handle_h arg_snep_handle;
 501         net_nfc_snep_type_t arg_type;
 502         GVariant *arg_ndef_msg;
 503         data_s data = { NULL, };
 504         net_nfc_error_e result;
 505
 506         if (user_data == NULL)
 507         {
 508                 NFC_ERR("cannot get SNEP client data");
 509
 510                 return;
 511         }
 512
 513         g_variant_get((GVariant *)user_data,
 514                         "(uuuu@a(y))",
 515                         (guint *)&object,
 516                         (guint *)&invocation,
 517                         (guint *)&arg_snep_handle,
 518                         (guint *)&arg_type,
 519                         &arg_ndef_msg);
 520
 521         g_assert(object != NULL);
 522         g_assert(invocation != NULL);
 523
 524         net_nfc_util_gdbus_variant_to_data_s(arg_ndef_msg, &data);
 525
 526         result = net_nfc_server_snep_client_request(arg_snep_handle,
 527                         arg_type,
 528                         &data,
 529                         _snep_client_request_cb,
 530                         user_data);
 531         if (result != NET_NFC_OK)
 532         {
 533                 GVariant *resp;
 534
 535                 NFC_ERR("net_nfc_server_snep_client_request  "
 536                                 "failed, [%d]",result);
 537
 538                 resp = net_nfc_util_gdbus_buffer_to_variant(NULL, 0);
 539
 540                 net_nfc_gdbus_snep_complete_client_request(object,
 541                                 invocation, result, NET_NFC_LLCP_STOP, resp);
 542
 543                 g_object_unref(invocation);
 544                 g_object_unref(object);
 545
 546                 g_variant_unref(user_data);
 547         }
 548
 549         net_nfc_util_free_data(&data);
 550
 551         g_variant_unref(arg_ndef_msg);
 552 }
 553
 554 static gboolean _handle_client_send_request(
 555                 NetNfcGDbusSnep *object,
 556                 GDBusMethodInvocation *invocation,
 557                 guint arg_snep_handle,
 558                 guint arg_type,
 559                 GVariant *arg_ndef_msg,
 560                 GVariant *arg_privilege)
 561 {
 562         GVariant *parameter;
 563         gboolean result;
 564
 565         NFC_INFO(">>> REQUEST from [%s]",
 566                         g_dbus_method_invocation_get_sender(invocation));
 567
 568         /* check privilege and update client context */
 569         if (net_nfc_server_gdbus_check_privilege(invocation,
 570                                 arg_privilege,
 571                                 "nfc-manager::p2p",
 572                                 "rw") == false) {
 573                 NFC_ERR("permission denied, and finished request");
 574
 575                 return FALSE;
 576         }
 577
 578         parameter = g_variant_new("(uuuu@a(y))",
 579                         GPOINTER_TO_UINT(g_object_ref(object)),
 580                         GPOINTER_TO_UINT(g_object_ref(invocation)),
 581                         arg_snep_handle,
 582                         arg_type,
 583                         arg_ndef_msg);
 584
 585         if (parameter != NULL)
 586         {
 587                 if ((result = net_nfc_server_controller_async_queue_push(
 588                                                 snep_client_send_request_thread_func, parameter)) == FALSE)
 589                 {
 590                         NFC_ERR("net_nfc_server_controller_async_queue_push failed");
 591
 592                         g_dbus_method_invocation_return_dbus_error(invocation,
 593                                         "org.tizen.NetNfcService.Snep.ThreadError",
 594                                         "can not push to controller thread");
 595
 596                         g_object_unref(invocation);
 597                         g_object_unref(object);
 598
 599                         g_variant_unref(parameter);
 600                 }
 601         }
 602         else
 603         {
 604                 NFC_ERR("g_variant_new failed");
 605
 606                 g_dbus_method_invocation_return_dbus_error(invocation,
 607                                 "org.tizen.NetNfcService.Snep.MemoryError",
 608                                 "Out of memory");
 609
 610                 result = FALSE;
 611         }
 612
 613         return result;
 614 }
 615
 616 static void snep_stop_service_thread_func(gpointer user_data)
 617 {
 618         NetNfcGDbusSnep *object;
 619         GDBusMethodInvocation *invocation;
 620         net_nfc_target_handle_s *handle;
 621         net_nfc_snep_handle_h snep_handle;
 622
 623         if (user_data == NULL)
 624         {
 625                 NFC_ERR("cannot get SNEP client data");
 626
 627                 return;
 628         }
 629
 630         g_variant_get((GVariant *)user_data,
 631                         "(uuuu)",
 632                         (guint *)&object,
 633                         (guint *)&invocation,
 634                         (guint *)&handle,
 635                         (guint *)&snep_handle);
 636
 637         g_assert(object != NULL);
 638         g_assert(invocation != NULL);
 639
 640         /* TODO :
 641                 g_dbus_method_invocation_return_dbus_error(
 642                 invocation,
 643                 "org.tizen.NetNfcService.Snep.DataError",
 644                 "Cannot stop SNEP service");
 645                 */
 646
 647         net_nfc_gdbus_snep_complete_stop_snep(object,
 648                         invocation,
 649                         NET_NFC_OK);
 650
 651         g_object_unref(invocation);
 652         g_object_unref(object);
 653
 654         g_variant_unref(user_data);
 655 }
 656
 657 static gboolean _handle_stop_snep(
 658                 NetNfcGDbusSnep *object,
 659                 GDBusMethodInvocation *invocation,
 660                 guint arg_handle,
 661                 guint arg_snep_handle,
 662                 GVariant *arg_privilege)
 663 {
 664         GVariant *parameter;
 665         gboolean result;
 666
 667         NFC_INFO(">>> REQUEST from [%s]",
 668                         g_dbus_method_invocation_get_sender(invocation));
 669
 670         /* check privilege and update client context */
 671         if (net_nfc_server_gdbus_check_privilege(invocation,
 672                                 arg_privilege,
 673                                 "nfc-manager::p2p",
 674                                 "rw") == false) {
 675                 NFC_ERR("permission denied, and finished request");
 676
 677                 return FALSE;
 678         }
 679
 680         parameter = g_variant_new("(uuuu)",
 681                         GPOINTER_TO_UINT(g_object_ref(object)),
 682                         GPOINTER_TO_UINT(g_object_ref(invocation)),
 683                         arg_handle,
 684                         arg_snep_handle);
 685
 686         if (parameter != NULL)
 687         {
 688                 if ((result = net_nfc_server_controller_async_queue_push(
 689                                                 snep_stop_service_thread_func, parameter)) == FALSE)
 690                 {
 691                         NFC_ERR("net_nfc_server_controller_async_queue_push failed");
 692
 693                         g_dbus_method_invocation_return_dbus_error(invocation,
 694                                         "org.tizen.NetNfcService.Snep.ThreadError",
 695                                         "can not push to controller thread");
 696
 697                         g_object_unref(invocation);
 698                         g_object_unref(object);
 699
 700                         g_variant_unref(parameter);
 701                 }
 702         }
 703         else
 704         {
 705                 NFC_ERR("g_variant_new failed");
 706
 707                 g_dbus_method_invocation_return_dbus_error(invocation,
 708                                 "org.tizen.NetNfcService.Snep.MemoryError",
 709                                 "Out of memory");
 710
 711                 result = FALSE;
 712         }
 713
 714         return result;
 715 }
 716
 717 static void _snep_activate_cb(int event, net_nfc_target_handle_s *handle,
 718                 uint32_t sap, const char *san, void *user_param)
 719 {
 720         GVariant *parameter = (GVariant *)user_param;
 721         net_nfc_error_e result = NET_NFC_OK;
 722
 723         NFC_DBG("event [%d], handle [%p], sap [%d], san [%s]",
 724                         event, handle, sap, san);
 725
 726         if (event == NET_NFC_LLCP_START) {
 727                 GDBusConnection *connection;
 728                 GVariant *param = NULL;
 729                 char *client_id;
 730                 void *user_data;
 731
 732                 /* start server */
 733                 g_variant_get(parameter, "(usu)",
 734                                 (guint *)&connection,
 735                                 &client_id,
 736                                 (guint *)&user_data);
 737
 738                 param = g_variant_new("(usu)",
 739                                 GPOINTER_TO_UINT(g_object_ref(connection)),
 740                                 client_id,
 741                                 GPOINTER_TO_UINT(user_data));
 742
 743                 g_free(client_id);
 744
 745                 result = net_nfc_server_snep_server(handle, (char *)san, sap,
 746                                 _snep_server_cb, param);
 747                 if (result == NET_NFC_OK) {
 748                         _emit_snep_event_signal(parameter, handle,
 749                                         result, event, NULL);
 750                 } else {
 751                         NFC_ERR("net_nfc_server_snep_server failed, [%d]",
 752                                         result);
 753
 754                         g_variant_unref(param);
 755                 }
 756         } else {
 757                 _emit_snep_event_signal(parameter, handle,
 758                                 result, NET_NFC_LLCP_UNREGISTERED, NULL);
 759
 760                 /* unregister server */
 761                 g_variant_unref(parameter);
 762         }
 763 }
 764
 765 static void snep_register_server_thread_func(gpointer user_data)
 766 {
 767         NetNfcGDbusSnep *object;
 768         GDBusMethodInvocation *invocation;
 769         guint arg_sap;
 770         gchar *arg_san;
 771         guint arg_user_data;
 772
 773         net_nfc_error_e result;
 774         GVariant *parameter = NULL;
 775         GDBusConnection *connection;
 776
 777         g_assert(user_data != NULL);
 778
 779         g_variant_get((GVariant *)user_data,
 780                         "(uuusu)",
 781                         (guint *)&object,
 782                         (guint *)&invocation,
 783                         &arg_sap,
 784                         &arg_san,
 785                         &arg_user_data);
 786
 787         g_assert(object != NULL);
 788         g_assert(invocation != NULL);
 789
 790         connection = g_dbus_method_invocation_get_connection(invocation);
 791
 792         parameter = g_variant_new("(usu)",
 793                         GPOINTER_TO_UINT(g_object_ref(connection)),
 794                         g_dbus_method_invocation_get_sender(invocation),
 795                         arg_user_data);
 796         if (parameter != NULL) {
 797                 /* register default snep server */
 798                 result = net_nfc_server_llcp_register_service(
 799                                 g_dbus_method_invocation_get_sender(invocation),
 800                                 arg_sap,
 801                                 arg_san,
 802                                 _snep_activate_cb,
 803                                 parameter);
 804                 if (result != NET_NFC_OK) {
 805                         NFC_ERR("net_nfc_service_llcp_register_service failed, [%d]", result);
 806                         g_object_unref(connection);
 807                         g_variant_unref(parameter);
 808                 }
 809         } else {
 810                 result = NET_NFC_ALLOC_FAIL;
 811                 g_object_unref(connection);
 812         }
 813
 814         net_nfc_gdbus_snep_complete_server_register(object,
 815                         invocation,
 816                         result);
 817
 818         g_free(arg_san);
 819
 820         g_object_unref(invocation);
 821         g_object_unref(object);
 822
 823         g_variant_unref(user_data);
 824 }
 825
 826 static gboolean _handle_register_server(
 827                 NetNfcGDbusSnep *object,
 828                 GDBusMethodInvocation *invocation,
 829                 guint arg_sap,
 830                 const gchar *arg_san,
 831                 guint arg_user_data,
 832                 GVariant *arg_privilege)
 833 {
 834         GVariant *parameter;
 835         gboolean result;
 836
 837         NFC_INFO(">>> REQUEST from [%s]",
 838                         g_dbus_method_invocation_get_sender(invocation));
 839
 840         /* check privilege and update client context */
 841         if (net_nfc_server_gdbus_check_privilege(invocation,
 842                                 arg_privilege,
 843                                 "nfc-manager::p2p",
 844                                 "rw") == false) {
 845                 NFC_ERR("permission denied, and finished request");
 846
 847                 return FALSE;
 848         }
 849
 850         parameter = g_variant_new("(uuusu)",
 851                         GPOINTER_TO_UINT(g_object_ref(object)),
 852                         GPOINTER_TO_UINT(g_object_ref(invocation)),
 853                         arg_sap,
 854                         arg_san,
 855                         arg_user_data);
 856
 857         if (parameter != NULL)
 858         {
 859                 if ((result = net_nfc_server_controller_async_queue_push(
 860                                                 snep_register_server_thread_func, parameter)) == FALSE)
 861                 {
 862                         NFC_ERR("net_nfc_server_controller_async_queue_push failed");
 863
 864                         g_dbus_method_invocation_return_dbus_error(invocation,
 865                                         "org.tizen.NetNfcService.Snep.ThreadError",
 866                                         "can not push to controller thread");
 867
 868                         g_object_unref(invocation);
 869                         g_object_unref(object);
 870
 871                         g_variant_unref(parameter);
 872                 }
 873         }
 874         else
 875         {
 876                 NFC_ERR("g_variant_new failed");
 877
 878                 g_dbus_method_invocation_return_dbus_error(invocation,
 879                                 "org.tizen.NetNfcService.Snep.MemoryError",
 880                                 "Out of memory");
 881
 882                 result = FALSE;
 883         }
 884
 885         return result;
 886 }
 887
 888 static void snep_unregister_server_thread_func(gpointer user_data)
 889 {
 890         NetNfcGDbusSnep *object;
 891         GDBusMethodInvocation *invocation;
 892         guint arg_sap;
 893         gchar *arg_san;
 894
 895         net_nfc_error_e result;
 896
 897         g_assert(user_data != NULL);
 898
 899         g_variant_get((GVariant *)user_data,
 900                         "(uuus)",
 901                         (guint *)&object,
 902                         (guint *)&invocation,
 903                         &arg_sap,
 904                         &arg_san);
 905
 906         g_assert(object != NULL);
 907         g_assert(invocation != NULL);
 908
 909         result = net_nfc_server_llcp_unregister_service(
 910                         g_dbus_method_invocation_get_sender(invocation),
 911                         arg_sap,
 912                         arg_san);
 913
 914         net_nfc_gdbus_snep_complete_server_unregister(object,
 915                         invocation,
 916                         result);
 917
 918         g_free(arg_san);
 919
 920         g_object_unref(invocation);
 921         g_object_unref(object);
 922
 923         g_variant_unref(user_data);
 924 }
 925
 926 static gboolean _handle_unregister_server(
 927                 NetNfcGDbusSnep *object,
 928                 GDBusMethodInvocation *invocation,
 929                 guint arg_sap,
 930                 const gchar *arg_san,
 931                 GVariant *arg_privilege)
 932 {
 933         GVariant *parameter;
 934         gboolean result;
 935
 936         NFC_INFO(">>> REQUEST from [%s]",
 937                         g_dbus_method_invocation_get_sender(invocation));
 938
 939         /* check privilege and update client context */
 940         if (net_nfc_server_gdbus_check_privilege(invocation,
 941                                 arg_privilege,
 942                                 "nfc-manager::p2p",
 943                                 "rw") == false) {
 944                 NFC_ERR("permission denied, and finished request");
 945
 946                 return FALSE;
 947         }
 948
 949         parameter = g_variant_new("(uuus)",
 950                         GPOINTER_TO_UINT(g_object_ref(object)),
 951                         GPOINTER_TO_UINT(g_object_ref(invocation)),
 952                         arg_sap,
 953                         arg_san);
 954
 955         if (parameter != NULL)
 956         {
 957                 if ((result = net_nfc_server_controller_async_queue_push(
 958                                                 snep_unregister_server_thread_func, parameter)) == FALSE)
 959                 {
 960                         NFC_ERR("net_nfc_server_controller_async_queue_push failed");
 961
 962                         g_dbus_method_invocation_return_dbus_error(invocation,
 963                                         "org.tizen.NetNfcService.Snep.ThreadError",
 964                                         "can not push to controller thread");
 965
 966                         g_object_unref(invocation);
 967                         g_object_unref(object);
 968
 969                         g_variant_unref(parameter);
 970                 }
 971         }
 972         else
 973         {
 974                 NFC_ERR("g_variant_new failed");
 975
 976                 g_dbus_method_invocation_return_dbus_error(invocation,
 977                                 "org.tizen.NetNfcService.Snep.MemoryError",
 978                                 "Out of memory");
 979
 980                 result = FALSE;
 981         }
 982
 983         return result;
 984 }
 985
 986 gboolean net_nfc_server_snep_init(GDBusConnection *connection)
 987 {
 988         GError *error = NULL;
 989         gboolean result;
 990
 991         if (snep_skeleton)
 992                 g_object_unref(snep_skeleton);
 993
 994         snep_skeleton = net_nfc_gdbus_snep_skeleton_new();
 995
 996         g_signal_connect(snep_skeleton,
 997                         "handle-server-register",
 998                         G_CALLBACK(_handle_register_server),
 999                         NULL);
1000
1001         g_signal_connect(snep_skeleton,
1002                         "handle-server-unregister",
1003                         G_CALLBACK(_handle_unregister_server),
1004                         NULL);
1005
1006         g_signal_connect(snep_skeleton,
1007                         "handle-server-start",
1008                         G_CALLBACK(_handle_start_server),
1009                         NULL);
1010
1011         g_signal_connect(snep_skeleton,
1012                         "handle-client-start",
1013                         G_CALLBACK(_handle_start_client),
1014                         NULL);
1015
1016         g_signal_connect(snep_skeleton,
1017                         "handle-client-request",
1018                         G_CALLBACK(_handle_client_send_request),
1019                         NULL);
1020
1021         g_signal_connect(snep_skeleton,
1022                         "handle-stop-snep",
1023                         G_CALLBACK(_handle_stop_snep),
1024                         NULL);
1025
1026         result = g_dbus_interface_skeleton_export(
1027                         G_DBUS_INTERFACE_SKELETON(snep_skeleton),
1028                         connection,
1029                         "/org/tizen/NetNfcService/Snep",
1030                         &error);
1031         if (result == FALSE)
1032         {
1033                 g_error_free(error);
1034
1035                 net_nfc_server_snep_deinit();
1036         }
1037
1038         return result;
1039 }
1040
1041 void net_nfc_server_snep_deinit(void)
1042 {
1043         if (snep_skeleton)
1044         {
1045                 g_object_unref(snep_skeleton);
1046                 snep_skeleton = NULL;
1047         }
1048 }