client/net_nfc_client_llcp.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_gdbus_internal.h"
  21 #include "net_nfc_gdbus.h"
  22 #include "net_nfc_client.h"
  23 #include "net_nfc_client_manager.h"
  24 #include "net_nfc_client_llcp.h"
  25
  26 typedef struct _LlcpFuncData LlcpFuncData;
  27
  28 struct _LlcpFuncData
  29 {
  30         gpointer callback;
  31         gpointer user_data;
  32 };
  33
  34 static NetNfcGDbusLlcp *llcp_proxy = NULL;
  35 static net_nfc_llcp_config_info_s llcp_config = { 128, 0, 0, 1 };
  36 static net_nfc_target_handle_s *llcp_handle = NULL;
  37 static GList *socket_data_list = NULL;
  38 static guint socket_handle = 0;
  39
  40
  41 void llcp_socket_data_append(net_nfc_llcp_internal_socket_s *socket_data);
  42
  43 void llcp_socket_data_remove(net_nfc_llcp_internal_socket_s *socket_data);
  44
  45 net_nfc_llcp_internal_socket_s *llcp_socket_data_find(net_nfc_llcp_socket_t socket);
  46
  47 /* aysnc callback */
  48 static void llcp_call_config(GObject *source_object,
  49                 GAsyncResult *res,
  50                 gpointer user_data);
  51
  52 static void llcp_call_listen(GObject *source_object,
  53                 GAsyncResult *res,
  54                 gpointer user_data);
  55
  56 static void llcp_call_connect(GObject *source_object,
  57                 GAsyncResult *res,
  58                 gpointer user_data);
  59
  60 static void llcp_call_connect_sap(GObject *source_object,
  61                 GAsyncResult *res,
  62                 gpointer user_data);
  63
  64 static void llcp_call_send(GObject *source_object,
  65                 GAsyncResult *res,
  66                 gpointer user_data);
  67
  68 static void llcp_call_send_to(GObject *source_object,
  69                 GAsyncResult *res,
  70                 gpointer user_data);
  71
  72 static void llcp_call_receive(GObject *source_object,
  73                 GAsyncResult *res,
  74                 gpointer user_data);
  75
  76 static void llcp_call_receive_from(GObject *source_object,
  77                 GAsyncResult *res,
  78                 gpointer user_data);
  79
  80 static void llcp_call_close(GObject *source_object,
  81                 GAsyncResult *res,
  82                 gpointer user_data);
  83
  84 static void llcp_call_disconnect(GObject *source_object,
  85                 GAsyncResult *res,
  86                 gpointer user_data);
  87
  88 /* signal callback */
  89 static void llcp_error(NetNfcGDbusLlcp *object,
  90                 guint arg_handle,
  91                 guint client_socket,
  92                 gint error,
  93                 gpointer user_data);
  94
  95 static void llcp_incoming(NetNfcGDbusLlcp *object,
  96                 guint arg_handle,
  97                 guint client_socket,
  98                 guint incoming_socket,
  99                 gpointer user_data);
 100
 101 void llcp_socket_data_append(net_nfc_llcp_internal_socket_s *socket_data)
 102 {
 103         if (socket_data_list == NULL)
 104                 return;
 105
 106         if (socket_data)
 107         {
 108                 socket_data_list = g_list_append(socket_data_list,
 109                                 socket_data);
 110         }
 111 }
 112
 113 void llcp_socket_data_remove(net_nfc_llcp_internal_socket_s *socket_data)
 114 {
 115         if (socket_data_list == NULL)
 116                 return;
 117
 118         if (socket_data)
 119         {
 120                 socket_data_list = g_list_remove(socket_data_list,
 121                                 socket_data);
 122
 123                 g_free(socket_data->service_name);
 124                 g_free(socket_data);
 125         }
 126 }
 127
 128 net_nfc_llcp_internal_socket_s *llcp_socket_data_find(net_nfc_llcp_socket_t socket)
 129 {
 130         GList *pos;
 131
 132         if (socket_data_list == NULL)
 133                 return NULL;
 134
 135
 136         for (pos = g_list_first(socket_data_list); pos ; pos = pos->data)
 137         {
 138                 net_nfc_llcp_internal_socket_s *data;
 139
 140                 data = pos->data;
 141                 if (data == NULL)
 142                         continue;
 143
 144                 if (data->client_socket == socket)
 145                         break;
 146         }
 147
 148         if (pos == NULL)
 149                 return NULL;
 150
 151         return pos->data;
 152 }
 153
 154 static void llcp_call_config(GObject *source_object,
 155                 GAsyncResult *res,
 156                 gpointer user_data)
 157 {
 158         LlcpFuncData *func_data = user_data;
 159         net_nfc_error_e result;
 160         GError *error = NULL;
 161
 162         g_assert(func_data != NULL);
 163
 164         if (net_nfc_gdbus_llcp_call_config_finish(
 165                                 NET_NFC_GDBUS_LLCP(source_object),
 166                                 &result,
 167                                 res,
 168                                 &error) == FALSE)
 169         {
 170                 NFC_ERR("Can not finish config: %s",
 171                                 error->message);
 172
 173                 g_error_free(error);
 174
 175                 result = NET_NFC_IPC_FAIL;
 176         }
 177
 178         if (func_data->callback != NULL)
 179         {
 180                 net_nfc_client_llcp_config_completed callback =
 181                         (net_nfc_client_llcp_config_completed)func_data->callback;
 182
 183                 callback(result, func_data->user_data);
 184         }
 185
 186         g_free(func_data);
 187 }
 188
 189 static void llcp_call_listen(GObject *source_object,
 190                 GAsyncResult *res,
 191                 gpointer user_data)
 192 {
 193         LlcpFuncData *func_data = user_data;
 194         net_nfc_error_e result;
 195         guint32 out_client_socket;
 196         GError *error = NULL;
 197         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 198
 199         g_assert(func_data != NULL);
 200
 201         if (net_nfc_gdbus_llcp_call_listen_finish(
 202                                 NET_NFC_GDBUS_LLCP(source_object),
 203                                 &result,
 204                                 &out_client_socket,
 205                                 res,
 206                                 &error) == FALSE)
 207         {
 208                 NFC_ERR("Can not finish listen: %s",
 209                                 error->message);
 210
 211                 g_error_free(error);
 212
 213                 result = NET_NFC_IPC_FAIL;
 214         }
 215
 216         socket_data = llcp_socket_data_find(out_client_socket);
 217         if (socket_data == NULL)
 218         {
 219                 NFC_ERR("Wrong client socket is returned");
 220                 return;
 221         }
 222
 223         if (func_data->callback != NULL)
 224         {
 225                 net_nfc_client_llcp_listen_completed callback =
 226                         (net_nfc_client_llcp_listen_completed)func_data->callback;
 227
 228                 callback(result, out_client_socket, func_data->user_data);
 229         }
 230
 231         /* TODO : release resource when socket is closed */
 232         //      g_free(func_data);
 233 }
 234
 235 static void llcp_call_accept(GObject *source_object,
 236                 GAsyncResult *res,
 237                 gpointer user_data)
 238 {
 239         LlcpFuncData *func_data = user_data;
 240         net_nfc_error_e result;
 241         GError *error = NULL;
 242
 243         g_assert(func_data != NULL);
 244
 245         if (net_nfc_gdbus_llcp_call_accept_finish(
 246                                 NET_NFC_GDBUS_LLCP(source_object),
 247                                 &result,
 248                                 res,
 249                                 &error) == FALSE)
 250         {
 251                 NFC_ERR("Can not finish accept: %s",
 252                                 error->message);
 253
 254                 g_error_free(error);
 255
 256                 result = NET_NFC_IPC_FAIL;
 257         }
 258
 259         if (func_data->callback != NULL)
 260         {
 261                 net_nfc_client_llcp_accept_completed callback =
 262                         (net_nfc_client_llcp_accept_completed)func_data->callback;
 263
 264                 callback(result, func_data->user_data);
 265         }
 266
 267         g_free(func_data);
 268 }
 269
 270 static void llcp_call_reject(GObject *source_object,
 271                 GAsyncResult *res,
 272                 gpointer user_data)
 273 {
 274         LlcpFuncData *func_data = user_data;
 275         net_nfc_error_e result;
 276         GError *error = NULL;
 277
 278         g_assert(func_data != NULL);
 279
 280         if (net_nfc_gdbus_llcp_call_reject_finish(
 281                                 NET_NFC_GDBUS_LLCP(source_object),
 282                                 &result,
 283                                 res,
 284                                 &error) == FALSE)
 285         {
 286                 NFC_ERR("Can not finish reject: %s",
 287                                 error->message);
 288
 289                 g_error_free(error);
 290
 291                 result = NET_NFC_IPC_FAIL;
 292         }
 293
 294         if (func_data->callback != NULL)
 295         {
 296                 net_nfc_client_llcp_reject_completed callback =
 297                         (net_nfc_client_llcp_reject_completed)func_data->callback;
 298
 299                 callback(result, func_data->user_data);
 300         }
 301
 302         g_free(func_data);
 303 }
 304
 305 static void llcp_call_connect(GObject *source_object,
 306                 GAsyncResult *res,
 307                 gpointer user_data)
 308 {
 309         LlcpFuncData *func_data = user_data;
 310         net_nfc_error_e result;
 311         guint32 out_client_socket;
 312         GError *error = NULL;
 313         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 314
 315         g_assert(func_data != NULL);
 316
 317         if (net_nfc_gdbus_llcp_call_connect_finish(
 318                                 NET_NFC_GDBUS_LLCP(source_object),
 319                                 &result,
 320                                 &out_client_socket,
 321                                 res,
 322                                 &error) == FALSE)
 323         {
 324                 NFC_ERR("Can not finish connect: %s", error->message);
 325
 326                 g_error_free(error);
 327
 328                 result = NET_NFC_IPC_FAIL;
 329         }
 330
 331         socket_data = llcp_socket_data_find(out_client_socket);
 332         if (socket_data == NULL)
 333         {
 334                 NFC_ERR("Wrong client socket is returned");
 335                 return;
 336         }
 337
 338         if (func_data->callback != NULL)
 339         {
 340                 net_nfc_client_llcp_connect_completed callback =
 341                         (net_nfc_client_llcp_connect_completed)func_data->callback;
 342
 343                 callback(result, out_client_socket, func_data->user_data);
 344         }
 345
 346         /* TODO : release resource when socket is closed */
 347         //      g_free(func_data);
 348 }
 349
 350 static void llcp_call_connect_sap(GObject *source_object,
 351                 GAsyncResult *res,
 352                 gpointer user_data)
 353 {
 354         LlcpFuncData *func_data = user_data;
 355         net_nfc_error_e result;
 356         guint32 out_client_socket;
 357         GError *error = NULL;
 358         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 359
 360         g_assert(func_data != NULL);
 361
 362         if (net_nfc_gdbus_llcp_call_connect_sap_finish(
 363                                 NET_NFC_GDBUS_LLCP(source_object),
 364                                 &result,
 365                                 &out_client_socket,
 366                                 res,
 367                                 &error) == FALSE)
 368         {
 369                 NFC_ERR("Can not finish connect sap: %s", error->message);
 370                 g_error_free(error);
 371
 372                 result = NET_NFC_IPC_FAIL;
 373         }
 374
 375         socket_data = llcp_socket_data_find(out_client_socket);
 376         if (socket_data == NULL)
 377         {
 378                 NFC_ERR("Wrong client socket is returned");
 379                 return;
 380         }
 381
 382         if (func_data->callback != NULL)
 383         {
 384                 net_nfc_client_llcp_connect_sap_completed callback =
 385                         (net_nfc_client_llcp_connect_sap_completed)func_data->callback;
 386
 387                 callback(result, out_client_socket, func_data->user_data);
 388         }
 389
 390         /* TODO : release resource when socket is closed */
 391         //      g_free(func_data);
 392 }
 393
 394 static void llcp_call_send(GObject *source_object,
 395                 GAsyncResult *res,
 396                 gpointer user_data)
 397 {
 398         LlcpFuncData *func_data = user_data;
 399         net_nfc_error_e result;
 400         guint32 out_client_socket;
 401         GError *error = NULL;
 402
 403         g_assert(func_data != NULL);
 404
 405         if (net_nfc_gdbus_llcp_call_send_finish(
 406                                 NET_NFC_GDBUS_LLCP(source_object),
 407                                 &result,
 408                                 &out_client_socket,
 409                                 res,
 410                                 &error) == FALSE)
 411         {
 412                 NFC_ERR("Can not finish send: %s",
 413                                 error->message);
 414
 415                 g_error_free(error);
 416
 417                 result = NET_NFC_IPC_FAIL;
 418         }
 419
 420         if (func_data->callback != NULL)
 421         {
 422                 net_nfc_client_llcp_send_completed callback =
 423                         (net_nfc_client_llcp_send_completed)func_data->callback;
 424
 425                 callback(result, func_data->user_data);
 426         }
 427
 428         g_free(func_data);
 429 }
 430
 431 static void llcp_call_send_to(GObject *source_object,
 432                 GAsyncResult *res,
 433                 gpointer user_data)
 434 {
 435         LlcpFuncData *func_data = user_data;
 436         net_nfc_error_e result;
 437         guint32 out_client_socket;
 438         GError *error = NULL;
 439
 440         g_assert(func_data != NULL);
 441
 442         if (net_nfc_gdbus_llcp_call_send_to_finish(
 443                                 NET_NFC_GDBUS_LLCP(source_object),
 444                                 &result,
 445                                 &out_client_socket,
 446                                 res,
 447                                 &error) == FALSE)
 448         {
 449                 NFC_ERR("Can not finish send to: %s", error->message);
 450
 451                 g_error_free(error);
 452
 453                 result = NET_NFC_IPC_FAIL;
 454         }
 455
 456         if (func_data->callback != NULL)
 457         {
 458                 net_nfc_client_llcp_send_to_completed callback =
 459                         (net_nfc_client_llcp_send_to_completed)func_data->callback;
 460
 461                 callback(result, func_data->user_data);
 462         }
 463
 464         g_free(func_data);
 465 }
 466
 467 static void llcp_call_receive(GObject *source_object,
 468                 GAsyncResult *res,
 469                 gpointer user_data)
 470 {
 471         LlcpFuncData *func_data = user_data;
 472         net_nfc_error_e result;
 473         GVariant *variant;
 474         GError *error = NULL;
 475
 476         g_assert(func_data != NULL);
 477
 478         if (net_nfc_gdbus_llcp_call_receive_finish(
 479                                 NET_NFC_GDBUS_LLCP(source_object),
 480                                 &result,
 481                                 &variant,
 482                                 res,
 483                                 &error) == FALSE)
 484         {
 485                 NFC_ERR("Can not finish receive: %s", error->message);
 486
 487                 g_error_free(error);
 488
 489                 result = NET_NFC_IPC_FAIL;
 490         }
 491
 492         if (func_data->callback != NULL)
 493         {
 494                 net_nfc_client_llcp_receive_completed callback =
 495                         (net_nfc_client_llcp_receive_completed)func_data->callback;
 496                 data_s data = { NULL, 0 };
 497
 498                 net_nfc_util_gdbus_variant_to_data_s(variant, &data);
 499
 500                 callback(result, &data, func_data->user_data);
 501
 502                 net_nfc_util_free_data(&data);
 503         }
 504
 505         g_free(func_data);
 506 }
 507
 508 static void llcp_call_receive_from(GObject *source_object,
 509                 GAsyncResult *res,
 510                 gpointer user_data)
 511 {
 512         LlcpFuncData *func_data = user_data;
 513         net_nfc_error_e result;
 514         sap_t sap;
 515         GVariant *variant;
 516         GError *error = NULL;
 517
 518         g_assert(func_data != NULL);
 519
 520         if (net_nfc_gdbus_llcp_call_receive_from_finish(
 521                                 NET_NFC_GDBUS_LLCP(source_object),
 522                                 &result,
 523                                 &sap,
 524                                 &variant,
 525                                 res,
 526                                 &error) == FALSE)
 527         {
 528                 NFC_ERR("Can not finish receive from: %s",
 529                                 error->message);
 530
 531                 g_error_free(error);
 532
 533                 result = NET_NFC_IPC_FAIL;
 534         }
 535
 536         if (func_data->callback != NULL)
 537         {
 538                 net_nfc_client_llcp_receive_from_completed callback =
 539                         (net_nfc_client_llcp_receive_from_completed)func_data->callback;
 540                 data_s data = { NULL, 0 };
 541
 542                 net_nfc_util_gdbus_variant_to_data_s(variant, &data);
 543
 544                 callback(result, sap, &data, func_data->user_data);
 545
 546                 net_nfc_util_free_data(&data);
 547         }
 548
 549         g_free(func_data);
 550 }
 551
 552 static void llcp_call_close(GObject *source_object,
 553                 GAsyncResult *res,
 554                 gpointer user_data)
 555 {
 556         LlcpFuncData *func_data = user_data;
 557         net_nfc_error_e result;
 558         guint32 out_client_socket;
 559         GError *error = NULL;
 560
 561         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 562
 563         g_assert(func_data != NULL);
 564
 565         if (net_nfc_gdbus_llcp_call_close_finish(
 566                                 NET_NFC_GDBUS_LLCP(source_object),
 567                                 &result,
 568                                 &out_client_socket,
 569                                 res,
 570                                 &error) == FALSE)
 571         {
 572                 NFC_ERR("Can not finish close: %s", error->message);
 573
 574                 g_error_free(error);
 575
 576                 result = NET_NFC_IPC_FAIL;
 577         }
 578
 579         socket_data = llcp_socket_data_find(out_client_socket);
 580         if (socket_data == NULL)
 581         {
 582                 NFC_ERR("Wrong client socket is returned");
 583                 return;
 584         }
 585
 586         if (func_data->callback != NULL)
 587         {
 588                 net_nfc_client_llcp_close_completed callback =
 589                         (net_nfc_client_llcp_close_completed)func_data->callback;
 590
 591                 callback(result, func_data->user_data);
 592         }
 593
 594         g_free(func_data);
 595 }
 596
 597 static void llcp_call_disconnect(GObject *source_object,
 598                 GAsyncResult *res,
 599                 gpointer user_data)
 600 {
 601         LlcpFuncData *func_data = user_data;
 602         net_nfc_error_e result;
 603         guint32 out_client_socket;
 604         GError *error = NULL;
 605
 606         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 607
 608         g_assert(func_data != NULL);
 609
 610         if (net_nfc_gdbus_llcp_call_disconnect_finish(
 611                                 NET_NFC_GDBUS_LLCP(source_object),
 612                                 &result,
 613                                 &out_client_socket,
 614                                 res,
 615                                 &error) == FALSE)
 616         {
 617                 NFC_ERR("Can not finish disconnect: %s", error->message);
 618
 619                 g_error_free(error);
 620
 621                 result = NET_NFC_IPC_FAIL;
 622         }
 623
 624         socket_data = llcp_socket_data_find(out_client_socket);
 625         if (socket_data == NULL)
 626         {
 627                 NFC_ERR("Wrong client socket is returned");
 628                 return;
 629         }
 630
 631         if (func_data->callback != NULL) {
 632                 net_nfc_client_llcp_disconnect_completed callback =
 633                         (net_nfc_client_llcp_disconnect_completed)func_data->callback;
 634
 635                 callback(result, func_data->user_data);
 636         }
 637
 638         g_free(func_data);
 639 }
 640
 641 static void llcp_error(NetNfcGDbusLlcp *object,
 642                 guint arg_handle,
 643                 guint client_socket,
 644                 gint error,
 645                 gpointer user_data)
 646 {
 647         NFC_INFO(">>> SIGNAL arrived");
 648 }
 649
 650 static void llcp_incoming(NetNfcGDbusLlcp *object,
 651                 guint arg_handle,
 652                 guint client_socket,
 653                 guint incoming_socket,
 654                 gpointer user_data)
 655 {
 656         NFC_INFO(">>> SIGNAL arrived");
 657 }
 658
 659 /* Public APIs */
 660 API net_nfc_error_e net_nfc_client_llcp_config(net_nfc_llcp_config_info_h config,
 661                 net_nfc_client_llcp_config_completed callback,
 662                 void *user_data)
 663 {
 664         LlcpFuncData *func_data;
 665         GVariant *variant;
 666
 667         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
 668
 669         if (config == NULL) {
 670                 return NET_NFC_NULL_PARAMETER;
 671         }
 672
 673
 674         /* prevent executing daemon when nfc is off */
 675         if (net_nfc_client_manager_is_activated() == false) {
 676                 return NET_NFC_INVALID_STATE;
 677         }
 678
 679         func_data = g_new0(LlcpFuncData, 1);
 680         if (func_data == NULL) {
 681                 NFC_ERR("g_new0 failed");
 682
 683                 return NET_NFC_ALLOC_FAIL;
 684         }
 685
 686         func_data->callback = (gpointer)callback;
 687         func_data->user_data = user_data;
 688
 689         memcpy(&llcp_config, config, sizeof(net_nfc_llcp_config_info_s));
 690
 691         variant = g_variant_new("(qqyy)",
 692                         config->miu,
 693                         config->wks,
 694                         config->lto,
 695                         config->option);
 696
 697         net_nfc_gdbus_llcp_call_config(llcp_proxy,
 698                         variant,
 699                         net_nfc_client_gdbus_get_privilege(),
 700                         NULL,
 701                         llcp_call_config,
 702                         func_data);
 703
 704         return NET_NFC_OK;
 705 }
 706
 707 API net_nfc_error_e net_nfc_client_llcp_config_sync(
 708                 net_nfc_llcp_config_info_h config)
 709 {
 710         net_nfc_error_e result;
 711         GVariant *variant = NULL;
 712         GError *error = NULL;
 713
 714         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
 715
 716         /* prevent executing daemon when nfc is off */
 717         if (net_nfc_client_manager_is_activated() == false) {
 718                 return NET_NFC_INVALID_STATE;
 719         }
 720
 721         memcpy(&llcp_config, config, sizeof(net_nfc_llcp_config_info_s));
 722
 723         variant = g_variant_new("(qqyy)",
 724                         config->miu,
 725                         config->wks,
 726                         config->lto,
 727                         config->option);
 728
 729         if (net_nfc_gdbus_llcp_call_config_sync(llcp_proxy,
 730                                 variant,
 731                                 net_nfc_client_gdbus_get_privilege(),
 732                                 &result,
 733                                 NULL,
 734                                 &error) == FALSE)
 735         {
 736                 NFC_ERR("can not config: %s", error->message);
 737
 738                 g_error_free(error);
 739
 740                 result = NET_NFC_IPC_FAIL;
 741         }
 742
 743         return result;
 744 }
 745
 746 API net_nfc_error_e net_nfc_client_llcp_get_config(
 747                 net_nfc_llcp_config_info_h *config)
 748 {
 749         if (config == NULL)
 750                 return NET_NFC_NULL_PARAMETER;
 751
 752         *config = (net_nfc_llcp_config_info_h)&llcp_config;
 753
 754         return NET_NFC_OK;
 755 }
 756
 757 API net_nfc_error_e net_nfc_client_llcp_listen(net_nfc_llcp_socket_t socket,
 758                 const char *service_name,
 759                 sap_t sap,
 760                 net_nfc_client_llcp_listen_completed callback,
 761                 void *user_data)
 762 {
 763         LlcpFuncData *func_data;
 764         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 765
 766         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
 767
 768         socket_data = llcp_socket_data_find(socket);
 769         if (socket_data == NULL)
 770         {
 771                 NFC_ERR("can not get socket_data");
 772                 return NET_NFC_LLCP_INVALID_SOCKET;
 773         }
 774
 775         /* FIXME: temporary typecast to (uint8_t *) */
 776         socket_data->service_name = (uint8_t *)g_strdup(service_name);
 777         socket_data->sap = sap;
 778
 779         /* prevent executing daemon when nfc is off */
 780         if (net_nfc_client_manager_is_activated() == false) {
 781                 return NET_NFC_INVALID_STATE;
 782         }
 783
 784         func_data = g_new0(LlcpFuncData, 1);
 785         if (func_data == NULL) {
 786                 NFC_ERR("g_new0 failed");
 787
 788                 return NET_NFC_ALLOC_FAIL;
 789         }
 790
 791         func_data->callback = (gpointer)callback;
 792         func_data->user_data = user_data;
 793
 794         net_nfc_gdbus_llcp_call_listen(llcp_proxy,
 795                         GPOINTER_TO_UINT(llcp_handle),
 796                         socket_data->client_socket,
 797                         socket_data->miu,
 798                         socket_data->rw,
 799                         socket_data->type,
 800                         socket_data->sap,
 801                         service_name,
 802                         net_nfc_client_gdbus_get_privilege(),
 803                         NULL,
 804                         llcp_call_listen,
 805                         func_data);
 806
 807         return NET_NFC_OK;
 808 }
 809
 810 API net_nfc_error_e net_nfc_client_llcp_listen_sync(net_nfc_llcp_socket_t socket,
 811                 const char *service_name,
 812                 sap_t sap,
 813                 net_nfc_llcp_socket_t *out_socket)
 814 {
 815         net_nfc_error_e result;
 816         GError *error = NULL;
 817         guint32 out_client_socket;
 818
 819         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 820         net_nfc_llcp_internal_socket_s *out_socket_data = NULL;
 821
 822         if (out_socket == NULL) {
 823                 return NET_NFC_NULL_PARAMETER;
 824         }
 825
 826         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
 827
 828         if (service_name == NULL)
 829         {
 830                 NFC_ERR("service_name is empty");
 831                 return NET_NFC_UNKNOWN_ERROR;
 832         }
 833
 834         socket_data = llcp_socket_data_find(socket);
 835         if (socket_data == NULL)
 836         {
 837                 NFC_ERR("can not get socket_data");
 838                 return NET_NFC_LLCP_INVALID_SOCKET;
 839         }
 840
 841         /* FIXME: temporary typecast to (uint8_t *) */
 842         socket_data->service_name = (uint8_t *)g_strdup(service_name);
 843         socket_data->sap = sap;
 844
 845         /* prevent executing daemon when nfc is off */
 846         if (net_nfc_client_manager_is_activated() == false) {
 847                 return NET_NFC_INVALID_STATE;
 848         }
 849
 850         if (net_nfc_gdbus_llcp_call_listen_sync(llcp_proxy,
 851                                 GPOINTER_TO_UINT(llcp_handle),
 852                                 socket_data->client_socket,
 853                                 socket_data->miu,
 854                                 socket_data->rw,
 855                                 socket_data->type,
 856                                 socket_data->sap,
 857                                 service_name,
 858                                 net_nfc_client_gdbus_get_privilege(),
 859                                 &result,
 860                                 &out_client_socket,
 861                                 NULL,
 862                                 &error) == true) {
 863                 out_socket_data = llcp_socket_data_find(out_client_socket);
 864                 if (out_socket_data == NULL || out_socket_data !=  socket_data)
 865                 {
 866                         NFC_ERR("Wrong client socket is returned");
 867                         return NET_NFC_UNKNOWN_ERROR;
 868                 }
 869
 870                 //              out_socket_data->oal_socket = out_oal_socket;
 871
 872                 if (out_socket)
 873                         *out_socket = out_client_socket;
 874         } else {
 875                 NFC_ERR("can not listen: %s", error->message);
 876                 g_error_free(error);
 877                 result = NET_NFC_IPC_FAIL;
 878         }
 879
 880         return result;
 881 }
 882
 883 API net_nfc_error_e net_nfc_client_llcp_accept(net_nfc_llcp_socket_t socket,
 884                 net_nfc_client_llcp_accept_completed callback, void *user_data)
 885 {
 886         LlcpFuncData *func_data;
 887
 888         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
 889
 890         /* prevent executing daemon when nfc is off */
 891         if (net_nfc_client_manager_is_activated() == false) {
 892                 return NET_NFC_INVALID_STATE;
 893         }
 894
 895         func_data = g_new0(LlcpFuncData, 1);
 896         if (func_data == NULL) {
 897                 NFC_ERR("g_new0 failed");
 898                 return NET_NFC_ALLOC_FAIL;
 899         }
 900
 901         func_data->callback = (gpointer)callback;
 902         func_data->user_data = user_data;
 903
 904         net_nfc_gdbus_llcp_call_accept(llcp_proxy,
 905                         GPOINTER_TO_UINT(llcp_handle),
 906                         socket,
 907                         net_nfc_client_gdbus_get_privilege(),
 908                         NULL,
 909                         llcp_call_accept,
 910                         func_data);
 911
 912         return NET_NFC_OK;
 913 }
 914
 915 API net_nfc_error_e net_nfc_client_llcp_accept_sync(net_nfc_llcp_socket_t socket)
 916 {
 917         net_nfc_error_e result;
 918         GError *error = NULL;
 919
 920         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
 921
 922         /* prevent executing daemon when nfc is off */
 923         if (net_nfc_client_manager_is_activated() == false) {
 924                 return NET_NFC_INVALID_STATE;
 925         }
 926
 927         if (net_nfc_gdbus_llcp_call_accept_sync(llcp_proxy,
 928                                 GPOINTER_TO_UINT(llcp_handle),
 929                                 socket,
 930                                 net_nfc_client_gdbus_get_privilege(),
 931                                 &result,
 932                                 NULL,
 933                                 &error) == false)
 934         {
 935                 NFC_ERR("can not connect: %s", error->message);
 936                 g_error_free(error);
 937                 result = NET_NFC_IPC_FAIL;
 938         }
 939
 940         return result;
 941 }
 942
 943 API net_nfc_error_e net_nfc_client_llcp_reject(net_nfc_llcp_socket_t socket,
 944                 net_nfc_client_llcp_reject_completed callback,
 945                 void *user_data)
 946 {
 947         LlcpFuncData *func_data;
 948
 949         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
 950
 951         /* prevent executing daemon when nfc is off */
 952         if (net_nfc_client_manager_is_activated() == false) {
 953                 return NET_NFC_INVALID_STATE;
 954         }
 955
 956         func_data = g_new0(LlcpFuncData, 1);
 957         if (func_data == NULL) {
 958                 NFC_ERR("g_new0 failed");
 959                 return NET_NFC_ALLOC_FAIL;
 960         }
 961
 962         func_data->callback = (gpointer)callback;
 963         func_data->user_data = user_data;
 964
 965         net_nfc_gdbus_llcp_call_reject(llcp_proxy,
 966                         GPOINTER_TO_UINT(llcp_handle),
 967                         socket,
 968                         net_nfc_client_gdbus_get_privilege(),
 969                         NULL,
 970                         llcp_call_reject,
 971                         func_data);
 972
 973         return NET_NFC_OK;
 974 }
 975
 976 API net_nfc_error_e net_nfc_client_llcp_reject_sync(net_nfc_llcp_socket_t socket)
 977 {
 978         net_nfc_error_e result;
 979         GError *error = NULL;
 980
 981         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
 982
 983         /* prevent executing daemon when nfc is off */
 984         if (net_nfc_client_manager_is_activated() == false) {
 985                 return NET_NFC_INVALID_STATE;
 986         }
 987
 988         if (net_nfc_gdbus_llcp_call_reject_sync(llcp_proxy,
 989                                 GPOINTER_TO_UINT(llcp_handle),
 990                                 socket,
 991                                 net_nfc_client_gdbus_get_privilege(),
 992                                 &result,
 993                                 NULL,
 994                                 &error) == false)
 995         {
 996                 NFC_ERR("can not connect: %s", error->message);
 997                 g_error_free(error);
 998                 result = NET_NFC_IPC_FAIL;
 999         }
1000
1001         return result;
1002 }
1003
1004 API net_nfc_error_e net_nfc_client_llcp_connect(net_nfc_llcp_socket_t socket,
1005                 const char *service_name,
1006                 net_nfc_client_llcp_connect_completed callback,
1007                 void *user_data)
1008 {
1009         LlcpFuncData *func_data;
1010         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1011
1012         if (service_name == NULL) {
1013                 return NET_NFC_NULL_PARAMETER;
1014         }
1015
1016         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
1017
1018         socket_data = llcp_socket_data_find(socket);
1019         if (socket_data == NULL)
1020         {
1021                 NFC_ERR("can not get socket_data");
1022                 return NET_NFC_LLCP_INVALID_SOCKET;
1023         }
1024
1025         /* prevent executing daemon when nfc is off */
1026         if (net_nfc_client_manager_is_activated() == false) {
1027                 return NET_NFC_INVALID_STATE;
1028         }
1029
1030         func_data = g_new0(LlcpFuncData, 1);
1031         if (func_data == NULL) {
1032                 NFC_ERR("g_new0 failed");
1033
1034                 return NET_NFC_ALLOC_FAIL;
1035         }
1036
1037         func_data->callback = (gpointer)callback;
1038         func_data->user_data = user_data;
1039
1040         net_nfc_gdbus_llcp_call_connect(llcp_proxy,
1041                         GPOINTER_TO_UINT(llcp_handle),
1042                         socket_data->client_socket,
1043                         socket_data->miu,
1044                         socket_data->rw,
1045                         socket_data->type,
1046                         service_name,
1047                         net_nfc_client_gdbus_get_privilege(),
1048                         NULL,
1049                         llcp_call_connect,
1050                         func_data);
1051
1052         return NET_NFC_OK;
1053 }
1054
1055 API net_nfc_error_e net_nfc_client_llcp_connect_sync(net_nfc_llcp_socket_t socket,
1056                 const char *service_name,
1057                 net_nfc_llcp_socket_t *out_socket)
1058 {
1059         net_nfc_error_e result;
1060         GError *error = NULL;
1061         guint32 out_client_socket;
1062         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1063         net_nfc_llcp_internal_socket_s *out_socket_data = NULL;
1064
1065         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
1066
1067         if (service_name == NULL || out_socket == NULL) {
1068                 return NET_NFC_NULL_PARAMETER;
1069         }
1070
1071         socket_data = llcp_socket_data_find(socket);
1072         if (socket_data == NULL)
1073         {
1074                 NFC_ERR("can not get socket_data");
1075                 return NET_NFC_LLCP_INVALID_SOCKET;
1076         }
1077
1078         /* prevent executing daemon when nfc is off */
1079         if (net_nfc_client_manager_is_activated() == false) {
1080                 return NET_NFC_INVALID_STATE;
1081         }
1082
1083         if (net_nfc_gdbus_llcp_call_connect_sync(llcp_proxy,
1084                                 GPOINTER_TO_UINT(llcp_handle),
1085                                 socket_data->client_socket,
1086                                 socket_data->miu,
1087                                 socket_data->rw,
1088                                 socket_data->type,
1089                                 service_name,
1090                                 net_nfc_client_gdbus_get_privilege(),
1091                                 &result,
1092                                 &out_client_socket,
1093                                 NULL,
1094                                 &error) == true) {
1095                 out_socket_data = llcp_socket_data_find(out_client_socket);
1096                 if (out_socket_data == NULL || out_socket_data !=  socket_data)
1097                 {
1098                         NFC_ERR("Wrong client socket is returned");
1099                         return NET_NFC_UNKNOWN_ERROR;
1100                 }
1101
1102                 //              out_socket_data->oal_socket = out_oal_socket;
1103
1104                 if (out_socket)
1105                         *out_socket = out_client_socket;
1106         } else {
1107                 NFC_ERR("can not connect: %s", error->message);
1108
1109                 g_error_free(error);
1110
1111                 result = NET_NFC_IPC_FAIL;
1112         }
1113
1114         return result;
1115 }
1116
1117 API net_nfc_error_e net_nfc_client_llcp_connect_sap(net_nfc_llcp_socket_t socket,
1118                 sap_t sap,
1119                 net_nfc_client_llcp_connect_sap_completed callback,
1120                 void *user_data)
1121 {
1122         LlcpFuncData *func_data;
1123         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1124
1125         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
1126
1127         if (sap == 0) {
1128                 return NET_NFC_INVALID_PARAM;
1129         }
1130
1131         socket_data = llcp_socket_data_find(socket);
1132         if (socket_data == NULL)
1133         {
1134                 NFC_ERR("can not get socket_data");
1135                 return NET_NFC_LLCP_INVALID_SOCKET;
1136         }
1137
1138         /* prevent executing daemon when nfc is off */
1139         if (net_nfc_client_manager_is_activated() == false) {
1140                 return NET_NFC_INVALID_STATE;
1141         }
1142
1143         func_data = g_new0(LlcpFuncData, 1);
1144         if (func_data == NULL) {
1145                 NFC_ERR("g_new0 failed");
1146
1147                 return NET_NFC_ALLOC_FAIL;
1148         }
1149
1150         func_data->callback = (gpointer)callback;
1151         func_data->user_data = user_data;
1152
1153         net_nfc_gdbus_llcp_call_connect_sap(llcp_proxy,
1154                         GPOINTER_TO_UINT(llcp_handle),
1155                         socket_data->client_socket,
1156                         socket_data->miu,
1157                         socket_data->rw,
1158                         socket_data->type,
1159                         sap,
1160                         net_nfc_client_gdbus_get_privilege(),
1161                         NULL,
1162                         llcp_call_connect_sap,
1163                         func_data);
1164
1165         return NET_NFC_OK;
1166 }
1167
1168 API net_nfc_error_e net_nfc_client_llcp_connect_sap_sync(
1169                 net_nfc_llcp_socket_t socket,
1170                 sap_t sap,
1171                 net_nfc_llcp_socket_t *out_socket)
1172 {
1173         net_nfc_error_e result;
1174         GError *error = NULL;
1175         guint32 out_client_socket;
1176         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1177         net_nfc_llcp_internal_socket_s *out_socket_data = NULL;
1178
1179         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
1180
1181         if (out_socket == NULL) {
1182                 return NET_NFC_NULL_PARAMETER;
1183         }
1184
1185         if (sap == 0) {
1186                 return NET_NFC_INVALID_PARAM;
1187         }
1188
1189         socket_data = llcp_socket_data_find(socket);
1190         if (socket_data == NULL)
1191         {
1192                 NFC_ERR("can not get socket_data");
1193                 return NET_NFC_LLCP_INVALID_SOCKET;
1194         }
1195
1196         /* prevent executing daemon when nfc is off */
1197         if (net_nfc_client_manager_is_activated() == false) {
1198                 return NET_NFC_INVALID_STATE;
1199         }
1200
1201         if (net_nfc_gdbus_llcp_call_connect_sap_sync(llcp_proxy,
1202                                 GPOINTER_TO_UINT(llcp_handle),
1203                                 socket_data->client_socket,
1204                                 socket_data->miu,
1205                                 socket_data->rw,
1206                                 socket_data->type,
1207                                 sap,
1208                                 net_nfc_client_gdbus_get_privilege(),
1209                                 &result,
1210                                 &out_client_socket,
1211                                 NULL,
1212                                 &error) == true) {
1213                 out_socket_data = llcp_socket_data_find(out_client_socket);
1214                 if (out_socket_data == NULL || out_socket_data !=  socket_data)
1215                 {
1216                         NFC_ERR("Wrong client socket is returned");
1217                         return NET_NFC_UNKNOWN_ERROR;
1218                 }
1219
1220                 //              out_socket_data->oal_socket = out_oal_socket;
1221
1222                 if (out_socket)
1223                         *out_socket = out_client_socket;
1224         } else {
1225                 NFC_ERR("can not connect: %s", error->message);
1226
1227                 g_error_free(error);
1228
1229                 result = NET_NFC_IPC_FAIL;
1230         }
1231
1232         return result;
1233 }
1234
1235 API net_nfc_error_e net_nfc_client_llcp_send(net_nfc_llcp_socket_t socket,
1236                 data_h data,
1237                 net_nfc_client_llcp_send_completed callback,
1238                 void *user_data)
1239 {
1240         LlcpFuncData *func_data;
1241         GVariant *variant;
1242         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1243
1244         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
1245
1246         if (data == NULL) {
1247                 return NET_NFC_NULL_PARAMETER;
1248         }
1249
1250         if (socket <= 0) {
1251                 return NET_NFC_INVALID_PARAM;
1252         }
1253
1254         /* prevent executing daemon when nfc is off */
1255         if (net_nfc_client_manager_is_activated() == false) {
1256                 return NET_NFC_INVALID_STATE;
1257         }
1258
1259         socket_data = llcp_socket_data_find(socket);
1260         if (socket_data == NULL)
1261         {
1262                 NFC_ERR("can not get socket_data");
1263                 return NET_NFC_LLCP_INVALID_SOCKET;
1264         }
1265
1266         func_data = g_new0(LlcpFuncData, 1);
1267         if (func_data == NULL) {
1268                 NFC_ERR("g_new0 failed");
1269
1270                 return NET_NFC_ALLOC_FAIL;
1271         }
1272
1273         func_data->callback = (gpointer)callback;
1274         func_data->user_data = user_data;
1275
1276         variant = net_nfc_util_gdbus_data_to_variant(data);
1277
1278         net_nfc_gdbus_llcp_call_send(llcp_proxy,
1279                         GPOINTER_TO_UINT(llcp_handle),
1280                         socket_data->client_socket,
1281                         variant,
1282                         net_nfc_client_gdbus_get_privilege(),
1283                         NULL,
1284                         llcp_call_send,
1285                         func_data);
1286
1287         return NET_NFC_OK;
1288 }
1289
1290 API net_nfc_error_e net_nfc_client_llcp_send_sync(net_nfc_llcp_socket_t socket,
1291                 data_h data)
1292 {
1293         net_nfc_error_e result;
1294         GVariant *variant;
1295         GError *error = NULL;
1296         guint32 out_client_socket;
1297         net_nfc_llcp_internal_socket_s *socket_data;
1298         net_nfc_llcp_internal_socket_s *out_socket_data;
1299
1300         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
1301
1302         if (data == NULL) {
1303                 return NET_NFC_NULL_PARAMETER;
1304         }
1305
1306         if (socket <= 0) {
1307                 return NET_NFC_INVALID_PARAM;
1308         }
1309
1310         socket_data = llcp_socket_data_find(socket);
1311         if (socket_data == NULL)
1312         {
1313                 NFC_ERR("can not get socket_data");
1314                 return NET_NFC_LLCP_INVALID_SOCKET;
1315         }
1316
1317         if (data == NULL)
1318         {
1319                 NFC_ERR("data is empty");
1320                 return NET_NFC_INVALID_PARAM;
1321         }
1322
1323         /* prevent executing daemon when nfc is off */
1324         if (net_nfc_client_manager_is_activated() == false) {
1325                 return NET_NFC_INVALID_STATE;
1326         }
1327
1328         variant = net_nfc_util_gdbus_data_to_variant(data);
1329
1330         if (net_nfc_gdbus_llcp_call_send_sync(llcp_proxy,
1331                                 GPOINTER_TO_UINT(llcp_handle),
1332                                 socket_data->client_socket,
1333                                 variant,
1334                                 net_nfc_client_gdbus_get_privilege(),
1335                                 &result,
1336                                 &out_client_socket,
1337                                 NULL,
1338                                 &error) == true) {
1339                 out_socket_data = llcp_socket_data_find(out_client_socket);
1340                 if (out_socket_data == NULL)
1341                 {
1342                         NFC_ERR("can not find socket_data");
1343                         return NET_NFC_UNKNOWN_ERROR;
1344                 }
1345         } else {
1346                 NFC_ERR("can not call send: %s", error->message);
1347
1348                 g_error_free(error);
1349
1350                 result = NET_NFC_IPC_FAIL;
1351         }
1352
1353         return result;
1354 }
1355
1356 API net_nfc_error_e net_nfc_client_llcp_send_to(net_nfc_llcp_socket_t socket,
1357                 sap_t sap,
1358                 data_h data,
1359                 net_nfc_client_llcp_send_to_completed callback,
1360                 void *user_data)
1361 {
1362         LlcpFuncData *func_data;
1363         GVariant *variant;
1364         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1365
1366         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
1367
1368         if (data == NULL) {
1369                 return NET_NFC_NULL_PARAMETER;
1370         }
1371
1372         if (socket <= 0 || sap == 0) {
1373                 return NET_NFC_INVALID_PARAM;
1374         }
1375
1376         socket_data = llcp_socket_data_find(socket);
1377         if (socket_data == NULL)
1378         {
1379                 NFC_ERR("can not get socket_data");
1380                 return NET_NFC_LLCP_INVALID_SOCKET;
1381         }
1382
1383         /* prevent executing daemon when nfc is off */
1384         if (net_nfc_client_manager_is_activated() == false) {
1385                 return NET_NFC_INVALID_STATE;
1386         }
1387
1388         func_data = g_new0(LlcpFuncData, 1);
1389         if (func_data == NULL) {
1390                 NFC_ERR("g_new0 failed");
1391
1392                 return NET_NFC_ALLOC_FAIL;
1393         }
1394
1395         func_data->callback = (gpointer)callback;
1396         func_data->user_data = user_data;
1397
1398         variant = net_nfc_util_gdbus_data_to_variant(data);
1399
1400         net_nfc_gdbus_llcp_call_send_to(llcp_proxy,
1401                         GPOINTER_TO_UINT(llcp_handle),
1402                         socket_data->client_socket,
1403                         sap,
1404                         variant,
1405                         net_nfc_client_gdbus_get_privilege(),
1406                         NULL,
1407                         llcp_call_send_to,
1408                         func_data);
1409
1410         return NET_NFC_OK;
1411 }
1412
1413 API net_nfc_error_e net_nfc_client_llcp_send_to_sync(net_nfc_llcp_socket_t socket,
1414                 sap_t sap, data_h data)
1415 {
1416         net_nfc_error_e result;
1417         GVariant *variant;
1418         GError *error = NULL;
1419         guint32 out_client_socket;
1420
1421         net_nfc_llcp_internal_socket_s *socket_data;
1422         net_nfc_llcp_internal_socket_s *out_socket_data;
1423
1424         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
1425
1426         if (data == NULL) {
1427                 return NET_NFC_NULL_PARAMETER;
1428         }
1429
1430         if (socket <= 0 || sap == 0) {
1431                 return NET_NFC_INVALID_PARAM;
1432         }
1433
1434         socket_data = llcp_socket_data_find(socket);
1435         if (socket_data == NULL)
1436         {
1437                 NFC_ERR("can not get socket_data");
1438                 return NET_NFC_LLCP_INVALID_SOCKET;
1439         }
1440
1441         /* prevent executing daemon when nfc is off */
1442         if (net_nfc_client_manager_is_activated() == false) {
1443                 return NET_NFC_INVALID_STATE;
1444         }
1445
1446         variant = net_nfc_util_gdbus_data_to_variant(data);
1447
1448         if (net_nfc_gdbus_llcp_call_send_to_sync(llcp_proxy,
1449                                 GPOINTER_TO_UINT(llcp_handle),
1450                                 socket_data->client_socket,
1451                                 sap,
1452                                 variant,
1453                                 net_nfc_client_gdbus_get_privilege(),
1454                                 &result,
1455                                 &out_client_socket,
1456                                 NULL,
1457                                 &error) == true) {
1458                 out_socket_data = llcp_socket_data_find(out_client_socket);
1459                 if (out_socket_data == NULL)
1460                 {
1461                         NFC_ERR("can not find socket_data");
1462                         return NET_NFC_UNKNOWN_ERROR;
1463                 }
1464         } else {
1465                 NFC_ERR("can not call send to: %s", error->message);
1466
1467                 g_error_free(error);
1468
1469                 result = NET_NFC_IPC_FAIL;
1470         }
1471
1472         return result;
1473 }
1474
1475 API net_nfc_error_e net_nfc_client_llcp_receive(net_nfc_llcp_socket_t socket,
1476                 size_t request_length,
1477                 net_nfc_client_llcp_receive_completed callback,
1478                 void *user_data)
1479 {
1480         LlcpFuncData *func_data;
1481         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1482
1483         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
1484
1485         if (socket <= 0 || request_length == 0) {
1486                 return NET_NFC_INVALID_PARAM;
1487         }
1488
1489         socket_data = llcp_socket_data_find(socket);
1490         if (socket_data == NULL)
1491         {
1492                 NFC_ERR("can not get socket_data");
1493                 return NET_NFC_LLCP_INVALID_SOCKET;
1494         }
1495
1496         /* prevent executing daemon when nfc is off */
1497         if (net_nfc_client_manager_is_activated() == false) {
1498                 return NET_NFC_INVALID_STATE;
1499         }
1500
1501         func_data = g_new0(LlcpFuncData, 1);
1502         if (func_data == NULL) {
1503                 NFC_ERR("g_new0 failed");
1504
1505                 return NET_NFC_ALLOC_FAIL;
1506         }
1507
1508         func_data->callback = (gpointer)callback;
1509         func_data->user_data = user_data;
1510
1511         net_nfc_gdbus_llcp_call_receive(llcp_proxy,
1512                         GPOINTER_TO_UINT(llcp_handle),
1513                         socket_data->client_socket,
1514                         request_length,
1515                         net_nfc_client_gdbus_get_privilege(),
1516                         NULL,
1517                         llcp_call_receive,
1518                         func_data);
1519
1520         return NET_NFC_OK;
1521 }
1522
1523 API net_nfc_error_e net_nfc_client_llcp_receive_sync(net_nfc_llcp_socket_t socket,
1524                 size_t request_length,
1525                 data_h *out_data)
1526 {
1527         net_nfc_error_e result;
1528         GVariant *variant;
1529         GError *error = NULL;
1530         net_nfc_llcp_internal_socket_s *socket_data;
1531
1532         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
1533
1534         if (out_data == NULL) {
1535                 return NET_NFC_NULL_PARAMETER;
1536         }
1537
1538         *out_data = NULL;
1539
1540         if (socket <= 0 || request_length == 0) {
1541                 return NET_NFC_INVALID_PARAM;
1542         }
1543
1544         socket_data = llcp_socket_data_find(socket);
1545         if (socket_data == NULL)
1546         {
1547                 NFC_ERR("can not get socket_data");
1548                 return NET_NFC_LLCP_INVALID_SOCKET;
1549         }
1550
1551         /* prevent executing daemon when nfc is off */
1552         if (net_nfc_client_manager_is_activated() == false) {
1553                 return NET_NFC_INVALID_STATE;
1554         }
1555
1556         if (net_nfc_gdbus_llcp_call_receive_sync(llcp_proxy,
1557                                 GPOINTER_TO_UINT(llcp_handle),
1558                                 socket_data->client_socket,
1559                                 request_length,
1560                                 net_nfc_client_gdbus_get_privilege(),
1561                                 &result,
1562                                 &variant,
1563                                 NULL,
1564                                 &error) == true) {
1565                 *out_data = net_nfc_util_gdbus_variant_to_data(variant);
1566         } else {
1567                 NFC_ERR("can not call receive: %s", error->message);
1568
1569                 g_error_free(error);
1570
1571                 result = NET_NFC_IPC_FAIL;
1572         }
1573
1574         return result;
1575 }
1576
1577 API net_nfc_error_e net_nfc_client_llcp_receive_from(net_nfc_llcp_socket_t socket,
1578                 size_t request_length,
1579                 net_nfc_client_llcp_receive_from_completed callback,
1580                 void *user_data)
1581 {
1582         LlcpFuncData *func_data;
1583         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1584
1585         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
1586
1587         if (socket <= 0 || request_length == 0) {
1588                 return NET_NFC_INVALID_PARAM;
1589         }
1590
1591         socket_data = llcp_socket_data_find(socket);
1592         if (socket_data == NULL)
1593         {
1594                 NFC_ERR("can not get socket_data");
1595                 return NET_NFC_LLCP_INVALID_SOCKET;
1596         }
1597
1598         func_data = g_new0(LlcpFuncData, 1);
1599         if (func_data == NULL) {
1600                 NFC_ERR("g_new0 failed");
1601
1602                 return NET_NFC_ALLOC_FAIL;
1603         }
1604
1605         func_data->callback = (gpointer)callback;
1606         func_data->user_data = user_data;
1607
1608         net_nfc_gdbus_llcp_call_receive_from(llcp_proxy,
1609                         GPOINTER_TO_UINT(llcp_handle),
1610                         socket_data->client_socket,
1611                         request_length,
1612                         net_nfc_client_gdbus_get_privilege(),
1613                         NULL,
1614                         llcp_call_receive_from,
1615                         func_data);
1616
1617         return NET_NFC_OK;
1618 }
1619
1620 API net_nfc_error_e net_nfc_client_llcp_receive_from_sync(
1621                 net_nfc_llcp_socket_t socket,
1622                 size_t request_length,
1623                 sap_t *out_sap,
1624                 data_h *out_data)
1625 {
1626         net_nfc_error_e result;
1627         GError *error = NULL;
1628         GVariant *variant;
1629         sap_t sap;
1630         net_nfc_llcp_internal_socket_s *socket_data;
1631
1632         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
1633
1634         if (out_sap == NULL || out_data == NULL) {
1635                 return NET_NFC_NULL_PARAMETER;
1636         }
1637
1638         *out_data = NULL;
1639         *out_sap = 0;
1640
1641         if (socket <= 0 || request_length == 0) {
1642                 return NET_NFC_INVALID_PARAM;
1643         }
1644
1645         socket_data = llcp_socket_data_find(socket);
1646         if (socket_data == NULL)
1647         {
1648                 NFC_ERR("can not get socket_data");
1649                 return NET_NFC_LLCP_INVALID_SOCKET;
1650         }
1651
1652         /* prevent executing daemon when nfc is off */
1653         if (net_nfc_client_manager_is_activated() == false) {
1654                 return NET_NFC_INVALID_STATE;
1655         }
1656
1657         if (net_nfc_gdbus_llcp_call_receive_from_sync(llcp_proxy,
1658                                 GPOINTER_TO_UINT(llcp_handle),
1659                                 socket_data->client_socket,
1660                                 request_length,
1661                                 net_nfc_client_gdbus_get_privilege(),
1662                                 &result,
1663                                 &sap,
1664                                 &variant,
1665                                 NULL,
1666                                 &error) == true) {
1667                 *out_sap = sap;
1668                 *out_data = net_nfc_util_gdbus_variant_to_data(variant);
1669         } else {
1670                 NFC_ERR("can not call receive from: %s", error->message);
1671
1672                 g_error_free(error);
1673
1674                 result = NET_NFC_IPC_FAIL;
1675         }
1676
1677         return result;
1678 }
1679
1680 API net_nfc_error_e net_nfc_client_llcp_close(net_nfc_llcp_socket_t socket,
1681                 net_nfc_client_llcp_close_completed callback,
1682                 void *user_data)
1683 {
1684         LlcpFuncData *func_data;
1685         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1686
1687         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
1688
1689         if (socket <= 0) {
1690                 return NET_NFC_INVALID_PARAM;
1691         }
1692
1693         socket_data = llcp_socket_data_find(socket);
1694         if (socket_data == NULL)
1695         {
1696                 NFC_ERR("can not get socket_data");
1697                 return NET_NFC_LLCP_INVALID_SOCKET;
1698         }
1699
1700         /* prevent executing daemon when nfc is off */
1701         if (net_nfc_client_manager_is_activated() == false) {
1702                 return NET_NFC_INVALID_STATE;
1703         }
1704
1705         func_data = g_new0(LlcpFuncData, 1);
1706         if (func_data == NULL) {
1707                 NFC_ERR("g_new0 failed");
1708
1709                 return NET_NFC_ALLOC_FAIL;
1710         }
1711
1712         func_data->callback = (gpointer)callback;
1713         func_data->user_data = user_data;
1714
1715         net_nfc_gdbus_llcp_call_close(llcp_proxy,
1716                         GPOINTER_TO_UINT(llcp_handle),
1717                         socket_data->client_socket,
1718                         net_nfc_client_gdbus_get_privilege(),
1719                         NULL,
1720                         llcp_call_close,
1721                         func_data);
1722
1723         return NET_NFC_OK;
1724 }
1725
1726 API net_nfc_error_e net_nfc_client_llcp_close_sync(net_nfc_llcp_socket_t socket)
1727 {
1728         net_nfc_error_e result;
1729         GError *error = NULL;
1730         guint32 out_client_socket;
1731         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1732         net_nfc_llcp_internal_socket_s *out_socket_data = NULL;
1733
1734         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
1735
1736         if (socket <= 0) {
1737                 return NET_NFC_INVALID_PARAM;
1738         }
1739
1740         socket_data = llcp_socket_data_find(socket);
1741         if (socket_data == NULL)
1742         {
1743                 NFC_ERR("can not get socket_data");
1744                 return NET_NFC_LLCP_INVALID_SOCKET;
1745         }
1746
1747         /* prevent executing daemon when nfc is off */
1748         if (net_nfc_client_manager_is_activated() == false) {
1749                 return NET_NFC_INVALID_STATE;
1750         }
1751
1752         if (net_nfc_gdbus_llcp_call_close_sync(llcp_proxy,
1753                                 GPOINTER_TO_UINT(llcp_handle),
1754                                 socket_data->client_socket,
1755                                 net_nfc_client_gdbus_get_privilege(),
1756                                 &result,
1757                                 &out_client_socket,
1758                                 NULL,
1759                                 &error) == true) {
1760                 out_socket_data = llcp_socket_data_find(out_client_socket);
1761                 if (out_socket_data == NULL || out_socket_data !=  socket_data)
1762                 {
1763                         NFC_ERR("Wrong client socket is returned");
1764                         return NET_NFC_UNKNOWN_ERROR;
1765                 }
1766         } else {
1767                 NFC_ERR("can not close: %s", error->message);
1768
1769                 g_error_free(error);
1770
1771                 result = NET_NFC_IPC_FAIL;
1772         }
1773
1774         return result;
1775 }
1776
1777 API net_nfc_error_e net_nfc_client_llcp_disconnect(net_nfc_llcp_socket_t socket,
1778                 net_nfc_client_llcp_disconnect_completed callback,
1779                 void *user_data)
1780 {
1781         LlcpFuncData *func_data;
1782         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1783
1784         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
1785
1786         if (socket <= 0) {
1787                 return NET_NFC_INVALID_PARAM;
1788         }
1789
1790         socket_data = llcp_socket_data_find(socket);
1791         if (socket_data == NULL)
1792         {
1793                 NFC_ERR("can not get socket_data");
1794                 return NET_NFC_LLCP_INVALID_SOCKET;
1795         }
1796
1797         /* prevent executing daemon when nfc is off */
1798         if (net_nfc_client_manager_is_activated() == false) {
1799                 return NET_NFC_INVALID_STATE;
1800         }
1801
1802         func_data = g_new0(LlcpFuncData, 1);
1803         if (func_data == NULL) {
1804                 NFC_ERR("g_new0 failed");
1805
1806                 return NET_NFC_ALLOC_FAIL;
1807         }
1808
1809         func_data->callback = (gpointer)callback;
1810         func_data->user_data = user_data;
1811
1812         net_nfc_gdbus_llcp_call_disconnect(llcp_proxy,
1813                         GPOINTER_TO_UINT(llcp_handle),
1814                         socket_data->client_socket,
1815                         net_nfc_client_gdbus_get_privilege(),
1816                         NULL,
1817                         llcp_call_disconnect,
1818                         func_data);
1819
1820         return NET_NFC_OK;
1821 }
1822
1823 API net_nfc_error_e net_nfc_client_llcp_disconnect_sync(
1824                 net_nfc_llcp_socket_t socket)
1825 {
1826         net_nfc_error_e result;
1827         GError *error = NULL;
1828         guint32 out_client_socket;
1829         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1830         net_nfc_llcp_internal_socket_s *out_socket_data = NULL;
1831
1832         RETVM_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED, "Can not get LlcpProxy");
1833
1834         if (socket <= 0) {
1835                 return NET_NFC_INVALID_PARAM;
1836         }
1837
1838         socket_data = llcp_socket_data_find(socket);
1839         if (socket_data == NULL)
1840         {
1841                 NFC_ERR("can not get socket_data");
1842                 return NET_NFC_LLCP_INVALID_SOCKET;
1843         }
1844
1845         /* prevent executing daemon when nfc is off */
1846         if (net_nfc_client_manager_is_activated() == false) {
1847                 return NET_NFC_INVALID_STATE;
1848         }
1849
1850         if (net_nfc_gdbus_llcp_call_disconnect_sync(llcp_proxy,
1851                                 GPOINTER_TO_UINT(llcp_handle),
1852                                 socket_data->client_socket,
1853                                 net_nfc_client_gdbus_get_privilege(),
1854                                 &result,
1855                                 &out_client_socket,
1856                                 NULL,
1857                                 &error) == true) {
1858                 out_socket_data = llcp_socket_data_find(out_client_socket);
1859                 if (out_socket_data == NULL || out_socket_data !=  socket_data)
1860                 {
1861                         NFC_ERR("Wrong client socket is returned");
1862                         return NET_NFC_UNKNOWN_ERROR;
1863                 }
1864         } else {
1865                 NFC_ERR("can not disconnect: %s", error->message);
1866
1867                 g_error_free(error);
1868
1869                 result = NET_NFC_IPC_FAIL;
1870         }
1871
1872         return result;
1873 }
1874
1875 API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
1876                 net_nfc_llcp_socket_option_h option)
1877 {
1878         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1879
1880         socket_data = g_new0(net_nfc_llcp_internal_socket_s, 1);
1881
1882         socket_data->client_socket = socket_handle++;
1883
1884         if (option)
1885         {
1886                 socket_data->miu = option->miu;
1887                 socket_data->rw = option->rw;
1888                 socket_data->type = option->type;
1889         }
1890         else
1891         {
1892                 socket_data->miu = 128;
1893                 socket_data->rw = 1;
1894                 socket_data->type =
1895                         NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONORIENTED;
1896         }
1897
1898         socket_data->device_id = llcp_handle;
1899         socket_data->close_requested = false;
1900
1901
1902         if (socket)
1903                 *socket = socket_data->client_socket;
1904 }
1905
1906
1907 API net_nfc_error_e net_nfc_client_llcp_get_local_config(
1908                 net_nfc_llcp_config_info_h *config)
1909 {
1910         if (config == NULL)
1911                 return NET_NFC_NULL_PARAMETER;
1912
1913         *config = (net_nfc_llcp_config_info_h)&llcp_config;
1914
1915         return NET_NFC_OK;
1916 }
1917
1918 API net_nfc_error_e net_nfc_client_llcp_get_local_socket_option(
1919                 net_nfc_llcp_socket_t socket,
1920                 net_nfc_llcp_socket_option_h *info)
1921 {
1922         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1923
1924         socket_data = llcp_socket_data_find(socket);
1925         if (socket_data == NULL)
1926                 return NET_NFC_LLCP_INVALID_SOCKET;
1927
1928         *info = (net_nfc_llcp_socket_option_h)socket_data;
1929
1930         return NET_NFC_OK;
1931 }
1932
1933 API net_nfc_error_e net_nfc_client_llcp_create_socket_option(
1934                 net_nfc_llcp_socket_option_h *option,
1935                 uint16_t miu,
1936                 uint8_t rw,
1937                 net_nfc_socket_type_e type)
1938 {
1939         net_nfc_llcp_socket_option_s *struct_option = NULL;
1940
1941         if (option == NULL)
1942         {
1943                 return NET_NFC_NULL_PARAMETER;
1944         }
1945
1946         if (miu < 128 || miu > 1152 ||
1947                         rw < 1 || rw > 15 ||
1948                         type < NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONORIENTED ||
1949                         type > NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONLESS)
1950         {
1951                 return NET_NFC_OUT_OF_BOUND;
1952         }
1953
1954         _net_nfc_util_alloc_mem(struct_option, sizeof(net_nfc_llcp_socket_option_s));
1955         if (struct_option != NULL)
1956         {
1957                 struct_option->miu = miu;
1958                 struct_option->rw = rw;
1959                 struct_option->type = type;
1960
1961                 *option = (net_nfc_llcp_socket_option_h)struct_option;
1962
1963                 return NET_NFC_OK;
1964         }
1965         else
1966         {
1967                 return NET_NFC_ALLOC_FAIL;
1968         }
1969 }
1970
1971 API net_nfc_error_e net_nfc_client_llcp_create_socket_option_default(
1972                 net_nfc_llcp_socket_option_h *option)
1973 {
1974         return net_nfc_client_llcp_create_socket_option(
1975                         option,
1976                         128,
1977                         1,
1978                         NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONORIENTED);
1979 }
1980
1981 API net_nfc_error_e net_nfc_client_llcp_get_socket_option_miu(
1982                 net_nfc_llcp_socket_option_h option,
1983                 uint16_t *miu)
1984 {
1985         net_nfc_llcp_socket_option_s *struct_option =
1986                 (net_nfc_llcp_socket_option_s *)option;
1987
1988         if (option == NULL || miu == NULL)
1989         {
1990                 return NET_NFC_NULL_PARAMETER;
1991         }
1992
1993         *miu = struct_option->miu;
1994
1995         return NET_NFC_OK;
1996 }
1997
1998 API net_nfc_error_e net_nfc_client_llcp_set_socket_option_miu(
1999                 net_nfc_llcp_socket_option_h option,
2000                 uint16_t miu)
2001 {
2002         net_nfc_llcp_socket_option_s *struct_option =
2003                 (net_nfc_llcp_socket_option_s *)option;
2004
2005         if (option == NULL)
2006         {
2007                 return NET_NFC_NULL_PARAMETER;
2008         }
2009
2010         struct_option->miu = miu;
2011
2012         return NET_NFC_OK;
2013 }
2014
2015 API net_nfc_error_e net_nfc_client_llcp_get_socket_option_rw(
2016                 net_nfc_llcp_socket_option_h option,
2017                 uint8_t *rw)
2018 {
2019         if (option == NULL || rw == NULL)
2020         {
2021                 return NET_NFC_NULL_PARAMETER;
2022         }
2023         net_nfc_llcp_socket_option_s *struct_option = (net_nfc_llcp_socket_option_s *)option;
2024
2025         *rw = struct_option->rw;
2026         return NET_NFC_OK;
2027 }
2028
2029 API net_nfc_error_e net_nfc_client_llcp_set_socket_option_rw(
2030                 net_nfc_llcp_socket_option_h option,
2031                 uint8_t rw)
2032 {
2033         if (option == NULL)
2034         {
2035                 return NET_NFC_NULL_PARAMETER;
2036         }
2037         net_nfc_llcp_socket_option_s *struct_option = (net_nfc_llcp_socket_option_s *)option;
2038
2039         struct_option->rw = rw;
2040         return NET_NFC_OK;
2041 }
2042
2043 API net_nfc_error_e net_nfc_client_llcp_get_socket_option_type(
2044                 net_nfc_llcp_socket_option_h option,
2045                 net_nfc_socket_type_e * type)
2046 {
2047         if (option == NULL || type == NULL)
2048         {
2049                 return NET_NFC_NULL_PARAMETER;
2050         }
2051         net_nfc_llcp_socket_option_s *struct_option = (net_nfc_llcp_socket_option_s *)option;
2052
2053         *type = struct_option->type;
2054         return NET_NFC_OK;
2055 }
2056
2057 API net_nfc_error_e net_nfc_client_llcp_set_socket_option_type(
2058                 net_nfc_llcp_socket_option_h option,
2059                 net_nfc_socket_type_e type)
2060 {
2061         if (option == NULL)
2062         {
2063                 return NET_NFC_NULL_PARAMETER;
2064         }
2065         net_nfc_llcp_socket_option_s *struct_option = (net_nfc_llcp_socket_option_s *)option;
2066
2067         struct_option->type = type;
2068         return NET_NFC_OK;
2069 }
2070
2071 API net_nfc_error_e net_nfc_client_llcp_free_socket_option(
2072                 net_nfc_llcp_socket_option_h option)
2073 {
2074         if (option == NULL)
2075         {
2076                 return NET_NFC_NULL_PARAMETER;
2077         }
2078
2079         _net_nfc_util_free_mem(option);
2080
2081         return NET_NFC_OK;
2082 }
2083
2084 API net_nfc_error_e net_nfc_client_llcp_create_config(
2085                 net_nfc_llcp_config_info_h *config,
2086                 uint16_t miu,
2087                 uint16_t wks,
2088                 uint8_t lto,
2089                 uint8_t option)
2090 {
2091         net_nfc_llcp_config_info_s *tmp_config;
2092
2093         if (config == NULL)
2094                 return NET_NFC_NULL_PARAMETER;
2095
2096         _net_nfc_util_alloc_mem(tmp_config, sizeof(net_nfc_llcp_config_info_s));
2097
2098         if (tmp_config == NULL)
2099                 return NET_NFC_ALLOC_FAIL;
2100
2101         tmp_config->miu = miu;
2102         tmp_config->wks = wks;
2103         tmp_config->lto = lto;
2104         tmp_config->option = option;
2105
2106         *config = (net_nfc_llcp_config_info_h)tmp_config;
2107
2108         return NET_NFC_OK;
2109 }
2110
2111 API net_nfc_error_e net_nfc_client_llcp_create_config_default(
2112                 net_nfc_llcp_config_info_h *config)
2113 {
2114         return net_nfc_client_llcp_create_config(config, 128, 1, 10, 0);
2115 }
2116
2117 API net_nfc_error_e net_nfc_client_llcp_get_config_miu(
2118                 net_nfc_llcp_config_info_h config, uint16_t *miu)
2119 {
2120         if (config == NULL || miu == NULL)
2121                 return NET_NFC_NULL_PARAMETER;
2122
2123         net_nfc_llcp_config_info_s *tmp_config =
2124                 (net_nfc_llcp_config_info_s *)config;
2125
2126         *miu = tmp_config->miu;
2127
2128         return NET_NFC_OK;
2129 }
2130
2131 API net_nfc_error_e net_nfc_client_llcp_get_config_wks(
2132                 net_nfc_llcp_config_info_h config, uint16_t *wks)
2133 {
2134         if (config == NULL || wks == NULL)
2135                 return NET_NFC_NULL_PARAMETER;
2136
2137         net_nfc_llcp_config_info_s *tmp_config =
2138                 (net_nfc_llcp_config_info_s *)config;
2139
2140         *wks = tmp_config->wks;
2141
2142         return NET_NFC_OK;
2143 }
2144
2145 API net_nfc_error_e net_nfc_client_llcp_get_config_lto(
2146                 net_nfc_llcp_config_info_h config, uint8_t *lto)
2147 {
2148         if (config == NULL || lto == NULL)
2149                 return NET_NFC_NULL_PARAMETER;
2150
2151         net_nfc_llcp_config_info_s *tmp_config =
2152                 (net_nfc_llcp_config_info_s *)config;
2153
2154         *lto = tmp_config->lto;
2155
2156         return NET_NFC_OK;
2157 }
2158
2159 API net_nfc_error_e net_nfc_client_llcp_get_config_option(
2160                 net_nfc_llcp_config_info_h config, uint8_t *option)
2161 {
2162         if (config == NULL || option == NULL)
2163                 return NET_NFC_NULL_PARAMETER;
2164
2165         net_nfc_llcp_config_info_s *tmp_config =
2166                 (net_nfc_llcp_config_info_s *)config;
2167
2168         *option = tmp_config->option;
2169
2170         return NET_NFC_OK;
2171 }
2172
2173 API net_nfc_error_e net_nfc_client_llcp_set_config_miu(
2174                 net_nfc_llcp_config_info_h config, uint16_t miu)
2175 {
2176         if (config == NULL)
2177                 return NET_NFC_NULL_PARAMETER;
2178
2179         if (miu < 128 || miu > 1152)
2180                 return NET_NFC_OUT_OF_BOUND;
2181
2182         net_nfc_llcp_config_info_s * tmp_config =
2183                 (net_nfc_llcp_config_info_s *)config;
2184
2185         tmp_config->miu = miu;
2186
2187         return NET_NFC_OK;
2188 }
2189
2190 API net_nfc_error_e net_nfc_client_llcp_set_config_wks(
2191                 net_nfc_llcp_config_info_h config, uint16_t wks)
2192 {
2193         if (config == NULL)
2194                 return NET_NFC_NULL_PARAMETER;
2195
2196         net_nfc_llcp_config_info_s *tmp_config =
2197                 (net_nfc_llcp_config_info_s *)config;
2198
2199         tmp_config->wks = wks;
2200
2201         return NET_NFC_OK;
2202 }
2203
2204 API net_nfc_error_e net_nfc_client_llcp_set_config_lto(
2205                 net_nfc_llcp_config_info_h config, uint8_t lto)
2206 {
2207         if (config == NULL)
2208                 return NET_NFC_NULL_PARAMETER;
2209
2210         net_nfc_llcp_config_info_s *tmp_config =
2211                 (net_nfc_llcp_config_info_s *)config;
2212
2213         tmp_config->lto = lto;
2214
2215         return NET_NFC_OK;
2216 }
2217
2218 API net_nfc_error_e net_nfc_client_llcp_set_config_option(
2219                 net_nfc_llcp_config_info_h config, uint8_t option)
2220 {
2221         if (config == NULL)
2222                 return NET_NFC_NULL_PARAMETER;
2223
2224         net_nfc_llcp_config_info_s * tmp_config =
2225                 (net_nfc_llcp_config_info_s *)config;
2226
2227         tmp_config->option = option;
2228
2229         return NET_NFC_OK;
2230 }
2231
2232 API net_nfc_error_e net_nfc_client_llcp_free_config(
2233                 net_nfc_llcp_config_info_h config)
2234 {
2235         if (config == NULL)
2236                 return NET_NFC_NULL_PARAMETER;
2237
2238         _net_nfc_util_free_mem(config);
2239         return NET_NFC_OK;
2240 }
2241
2242 net_nfc_error_e net_nfc_client_llcp_init(void)
2243 {
2244         GError *error = NULL;
2245
2246         if (llcp_proxy)
2247         {
2248                 NFC_WARN("Already initialized");
2249                 return NET_NFC_OK;
2250         }
2251
2252         llcp_proxy = net_nfc_gdbus_llcp_proxy_new_for_bus_sync(
2253                         G_BUS_TYPE_SYSTEM,
2254                         G_DBUS_PROXY_FLAGS_NONE,
2255                         "org.tizen.NetNfcService",
2256                         "/org/tizen/NetNfcService/Llcp",
2257                         NULL,
2258                         &error);
2259
2260         if (llcp_proxy == NULL)
2261         {
2262                 NFC_ERR("Can not create proxy : %s", error->message);
2263                 g_error_free(error);
2264                 return NET_NFC_UNKNOWN_ERROR;
2265         }
2266
2267         g_signal_connect(llcp_proxy, "error",
2268                         G_CALLBACK(llcp_error), NULL);
2269
2270         g_signal_connect(llcp_proxy, "incoming",
2271                         G_CALLBACK(llcp_incoming), NULL);
2272
2273         return NET_NFC_OK;
2274 }
2275
2276 void net_nfc_client_llcp_deinit(void)
2277 {
2278         if (llcp_proxy)
2279         {
2280                 g_object_unref(llcp_proxy);
2281                 llcp_proxy = NULL;
2282         }
2283 }