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                 DEBUG_ERR_MSG("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                 DEBUG_ERR_MSG("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                 DEBUG_ERR_MSG("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                 DEBUG_ERR_MSG("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                 DEBUG_ERR_MSG("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                 DEBUG_ERR_MSG("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                 DEBUG_ERR_MSG("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                 DEBUG_ERR_MSG("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                 DEBUG_ERR_MSG("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                 DEBUG_ERR_MSG("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                 DEBUG_ERR_MSG("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                 DEBUG_ERR_MSG("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                 DEBUG_ERR_MSG("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                 DEBUG_ERR_MSG("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                 DEBUG_ERR_MSG("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                 DEBUG_ERR_MSG("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                 DEBUG_ERR_MSG("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         INFO_MSG(">>> 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         INFO_MSG(">>> 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         if (config == NULL) {
 668                 return NET_NFC_NULL_PARAMETER;
 669         }
 670
 671         if (llcp_proxy == NULL)
 672         {
 673                 DEBUG_ERR_MSG("Can not get LlcpProxy");
 674
 675                 return NET_NFC_NOT_INITIALIZED;
 676         }
 677
 678         /* prevent executing daemon when nfc is off */
 679         if (net_nfc_client_manager_is_activated() == false) {
 680                 return NET_NFC_INVALID_STATE;
 681         }
 682
 683         func_data = g_new0(LlcpFuncData, 1);
 684         if (func_data == NULL) {
 685                 DEBUG_ERR_MSG("g_new0 failed");
 686
 687                 return NET_NFC_ALLOC_FAIL;
 688         }
 689
 690         func_data->callback = (gpointer)callback;
 691         func_data->user_data = user_data;
 692
 693         memcpy(&llcp_config, config, sizeof(net_nfc_llcp_config_info_s));
 694
 695         variant = g_variant_new("(qqyy)",
 696                         config->miu,
 697                         config->wks,
 698                         config->lto,
 699                         config->option);
 700
 701         net_nfc_gdbus_llcp_call_config(llcp_proxy,
 702                         variant,
 703                         net_nfc_client_gdbus_get_privilege(),
 704                         NULL,
 705                         llcp_call_config,
 706                         func_data);
 707
 708         return NET_NFC_OK;
 709 }
 710
 711 API net_nfc_error_e net_nfc_client_llcp_config_sync(
 712                 net_nfc_llcp_config_info_h config)
 713 {
 714         net_nfc_error_e result;
 715         GVariant *variant = NULL;
 716         GError *error = NULL;
 717
 718         if (llcp_proxy == NULL)
 719         {
 720                 DEBUG_ERR_MSG("Can not get LlcpProxy");
 721
 722                 return NET_NFC_NOT_INITIALIZED;
 723         }
 724
 725         /* prevent executing daemon when nfc is off */
 726         if (net_nfc_client_manager_is_activated() == false) {
 727                 return NET_NFC_INVALID_STATE;
 728         }
 729
 730         memcpy(&llcp_config, config, sizeof(net_nfc_llcp_config_info_s));
 731
 732         variant = g_variant_new("(qqyy)",
 733                         config->miu,
 734                         config->wks,
 735                         config->lto,
 736                         config->option);
 737
 738         if (net_nfc_gdbus_llcp_call_config_sync(llcp_proxy,
 739                                 variant,
 740                                 net_nfc_client_gdbus_get_privilege(),
 741                                 &result,
 742                                 NULL,
 743                                 &error) == FALSE)
 744         {
 745                 DEBUG_ERR_MSG("can not config: %s", error->message);
 746
 747                 g_error_free(error);
 748
 749                 result = NET_NFC_IPC_FAIL;
 750         }
 751
 752         return result;
 753 }
 754
 755 API net_nfc_error_e net_nfc_client_llcp_get_config(
 756                 net_nfc_llcp_config_info_h *config)
 757 {
 758         if (config == NULL)
 759                 return NET_NFC_NULL_PARAMETER;
 760
 761         *config = (net_nfc_llcp_config_info_h)&llcp_config;
 762
 763         return NET_NFC_OK;
 764 }
 765
 766 API net_nfc_error_e net_nfc_client_llcp_listen(net_nfc_llcp_socket_t socket,
 767                 const char *service_name,
 768                 sap_t sap,
 769                 net_nfc_client_llcp_listen_completed callback,
 770                 void *user_data)
 771 {
 772         LlcpFuncData *func_data;
 773         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 774
 775         if (llcp_proxy == NULL)
 776         {
 777                 DEBUG_ERR_MSG("Can not get LlcpProxy");
 778
 779                 return NET_NFC_NOT_INITIALIZED;
 780         }
 781
 782         socket_data = llcp_socket_data_find(socket);
 783         if (socket_data == NULL)
 784         {
 785                 DEBUG_ERR_MSG("can not get socket_data");
 786                 return NET_NFC_LLCP_INVALID_SOCKET;
 787         }
 788
 789         /* FIXME: temporary typecast to (uint8_t *) */
 790         socket_data->service_name = (uint8_t *)g_strdup(service_name);
 791         socket_data->sap = sap;
 792
 793         /* prevent executing daemon when nfc is off */
 794         if (net_nfc_client_manager_is_activated() == false) {
 795                 return NET_NFC_INVALID_STATE;
 796         }
 797
 798         func_data = g_new0(LlcpFuncData, 1);
 799         if (func_data == NULL) {
 800                 DEBUG_ERR_MSG("g_new0 failed");
 801
 802                 return NET_NFC_ALLOC_FAIL;
 803         }
 804
 805         func_data->callback = (gpointer)callback;
 806         func_data->user_data = user_data;
 807
 808         net_nfc_gdbus_llcp_call_listen(llcp_proxy,
 809                         GPOINTER_TO_UINT(llcp_handle),
 810                         socket_data->client_socket,
 811                         socket_data->miu,
 812                         socket_data->rw,
 813                         socket_data->type,
 814                         socket_data->sap,
 815                         service_name,
 816                         net_nfc_client_gdbus_get_privilege(),
 817                         NULL,
 818                         llcp_call_listen,
 819                         func_data);
 820
 821         return NET_NFC_OK;
 822 }
 823
 824 API net_nfc_error_e net_nfc_client_llcp_listen_sync(net_nfc_llcp_socket_t socket,
 825                 const char *service_name,
 826                 sap_t sap,
 827                 net_nfc_llcp_socket_t *out_socket)
 828 {
 829         net_nfc_error_e result;
 830         GError *error = NULL;
 831         guint32 out_client_socket;
 832
 833         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 834         net_nfc_llcp_internal_socket_s *out_socket_data = NULL;
 835
 836         if (out_socket == NULL) {
 837                 return NET_NFC_NULL_PARAMETER;
 838         }
 839
 840         if (llcp_proxy == NULL)
 841         {
 842                 DEBUG_ERR_MSG("Can not get LlcpProxy");
 843
 844                 return NET_NFC_NOT_INITIALIZED;
 845         }
 846
 847         if (service_name == NULL)
 848         {
 849                 DEBUG_ERR_MSG("service_name is empty");
 850                 return NET_NFC_UNKNOWN_ERROR;
 851         }
 852
 853         socket_data = llcp_socket_data_find(socket);
 854         if (socket_data == NULL)
 855         {
 856                 DEBUG_ERR_MSG("can not get socket_data");
 857                 return NET_NFC_LLCP_INVALID_SOCKET;
 858         }
 859
 860         /* FIXME: temporary typecast to (uint8_t *) */
 861         socket_data->service_name = (uint8_t *)g_strdup(service_name);
 862         socket_data->sap = sap;
 863
 864         /* prevent executing daemon when nfc is off */
 865         if (net_nfc_client_manager_is_activated() == false) {
 866                 return NET_NFC_INVALID_STATE;
 867         }
 868
 869         if (net_nfc_gdbus_llcp_call_listen_sync(llcp_proxy,
 870                                 GPOINTER_TO_UINT(llcp_handle),
 871                                 socket_data->client_socket,
 872                                 socket_data->miu,
 873                                 socket_data->rw,
 874                                 socket_data->type,
 875                                 socket_data->sap,
 876                                 service_name,
 877                                 net_nfc_client_gdbus_get_privilege(),
 878                                 &result,
 879                                 &out_client_socket,
 880                                 NULL,
 881                                 &error) == true) {
 882                 out_socket_data = llcp_socket_data_find(out_client_socket);
 883                 if (out_socket_data == NULL || out_socket_data !=  socket_data)
 884                 {
 885                         DEBUG_ERR_MSG("Wrong client socket is returned");
 886                         return NET_NFC_UNKNOWN_ERROR;
 887                 }
 888
 889                 //              out_socket_data->oal_socket = out_oal_socket;
 890
 891                 if (out_socket)
 892                         *out_socket = out_client_socket;
 893         } else {
 894                 DEBUG_ERR_MSG("can not listen: %s", error->message);
 895
 896                 g_error_free(error);
 897
 898                 result = NET_NFC_IPC_FAIL;
 899         }
 900
 901         return result;
 902 }
 903
 904 API net_nfc_error_e net_nfc_client_llcp_accept(net_nfc_llcp_socket_t socket,
 905                 net_nfc_client_llcp_accept_completed callback, void *user_data)
 906 {
 907         LlcpFuncData *func_data;
 908
 909         if (llcp_proxy == NULL)
 910         {
 911                 DEBUG_ERR_MSG("Can not get LlcpProxy");
 912
 913                 return NET_NFC_NOT_INITIALIZED;
 914         }
 915
 916         /* prevent executing daemon when nfc is off */
 917         if (net_nfc_client_manager_is_activated() == false) {
 918                 return NET_NFC_INVALID_STATE;
 919         }
 920
 921         func_data = g_new0(LlcpFuncData, 1);
 922         if (func_data == NULL) {
 923                 DEBUG_ERR_MSG("g_new0 failed");
 924
 925                 return NET_NFC_ALLOC_FAIL;
 926         }
 927
 928         func_data->callback = (gpointer)callback;
 929         func_data->user_data = user_data;
 930
 931         net_nfc_gdbus_llcp_call_accept(llcp_proxy,
 932                         GPOINTER_TO_UINT(llcp_handle),
 933                         socket,
 934                         net_nfc_client_gdbus_get_privilege(),
 935                         NULL,
 936                         llcp_call_accept,
 937                         func_data);
 938
 939         return NET_NFC_OK;
 940 }
 941
 942 API net_nfc_error_e net_nfc_client_llcp_accept_sync(net_nfc_llcp_socket_t socket)
 943 {
 944         net_nfc_error_e result;
 945         GError *error = NULL;
 946
 947         if (llcp_proxy == NULL)
 948         {
 949                 DEBUG_ERR_MSG("Can not get LlcpProxy");
 950
 951                 return NET_NFC_NOT_INITIALIZED;
 952         }
 953
 954         /* prevent executing daemon when nfc is off */
 955         if (net_nfc_client_manager_is_activated() == false) {
 956                 return NET_NFC_INVALID_STATE;
 957         }
 958
 959         if (net_nfc_gdbus_llcp_call_accept_sync(llcp_proxy,
 960                                 GPOINTER_TO_UINT(llcp_handle),
 961                                 socket,
 962                                 net_nfc_client_gdbus_get_privilege(),
 963                                 &result,
 964                                 NULL,
 965                                 &error) == false) {
 966                 DEBUG_ERR_MSG("can not connect: %s", error->message);
 967
 968                 g_error_free(error);
 969
 970                 result = NET_NFC_IPC_FAIL;
 971         }
 972
 973         return result;
 974 }
 975
 976 API net_nfc_error_e net_nfc_client_llcp_reject(net_nfc_llcp_socket_t socket,
 977                 net_nfc_client_llcp_reject_completed callback,
 978                 void *user_data)
 979 {
 980         LlcpFuncData *func_data;
 981
 982         if (llcp_proxy == NULL)
 983         {
 984                 DEBUG_ERR_MSG("Can not get LlcpProxy");
 985
 986                 return NET_NFC_NOT_INITIALIZED;
 987         }
 988
 989         /* prevent executing daemon when nfc is off */
 990         if (net_nfc_client_manager_is_activated() == false) {
 991                 return NET_NFC_INVALID_STATE;
 992         }
 993
 994         func_data = g_new0(LlcpFuncData, 1);
 995         if (func_data == NULL) {
 996                 DEBUG_ERR_MSG("g_new0 failed");
 997
 998                 return NET_NFC_ALLOC_FAIL;
 999         }
1000
1001         func_data->callback = (gpointer)callback;
1002         func_data->user_data = user_data;
1003
1004         net_nfc_gdbus_llcp_call_reject(llcp_proxy,
1005                         GPOINTER_TO_UINT(llcp_handle),
1006                         socket,
1007                         net_nfc_client_gdbus_get_privilege(),
1008                         NULL,
1009                         llcp_call_reject,
1010                         func_data);
1011
1012         return NET_NFC_OK;
1013 }
1014
1015 API net_nfc_error_e net_nfc_client_llcp_reject_sync(net_nfc_llcp_socket_t socket)
1016 {
1017         net_nfc_error_e result;
1018         GError *error = NULL;
1019
1020         if (llcp_proxy == NULL)
1021         {
1022                 DEBUG_ERR_MSG("Can not get LlcpProxy");
1023
1024                 return NET_NFC_NOT_INITIALIZED;
1025         }
1026
1027         /* prevent executing daemon when nfc is off */
1028         if (net_nfc_client_manager_is_activated() == false) {
1029                 return NET_NFC_INVALID_STATE;
1030         }
1031
1032         if (net_nfc_gdbus_llcp_call_reject_sync(llcp_proxy,
1033                                 GPOINTER_TO_UINT(llcp_handle),
1034                                 socket,
1035                                 net_nfc_client_gdbus_get_privilege(),
1036                                 &result,
1037                                 NULL,
1038                                 &error) == false) {
1039                 DEBUG_ERR_MSG("can not connect: %s", error->message);
1040
1041                 g_error_free(error);
1042
1043                 result = NET_NFC_IPC_FAIL;
1044         }
1045
1046         return result;
1047 }
1048
1049 API net_nfc_error_e net_nfc_client_llcp_connect(net_nfc_llcp_socket_t socket,
1050                 const char *service_name,
1051                 net_nfc_client_llcp_connect_completed callback,
1052                 void *user_data)
1053 {
1054         LlcpFuncData *func_data;
1055         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1056
1057         if (service_name == NULL) {
1058                 return NET_NFC_NULL_PARAMETER;
1059         }
1060
1061         if (llcp_proxy == NULL)
1062         {
1063                 DEBUG_ERR_MSG("Can not get LlcpProxy");
1064
1065                 return NET_NFC_NOT_INITIALIZED;
1066         }
1067
1068         socket_data = llcp_socket_data_find(socket);
1069         if (socket_data == NULL)
1070         {
1071                 DEBUG_ERR_MSG("can not get socket_data");
1072                 return NET_NFC_LLCP_INVALID_SOCKET;
1073         }
1074
1075         /* prevent executing daemon when nfc is off */
1076         if (net_nfc_client_manager_is_activated() == false) {
1077                 return NET_NFC_INVALID_STATE;
1078         }
1079
1080         func_data = g_new0(LlcpFuncData, 1);
1081         if (func_data == NULL) {
1082                 DEBUG_ERR_MSG("g_new0 failed");
1083
1084                 return NET_NFC_ALLOC_FAIL;
1085         }
1086
1087         func_data->callback = (gpointer)callback;
1088         func_data->user_data = user_data;
1089
1090         net_nfc_gdbus_llcp_call_connect(llcp_proxy,
1091                         GPOINTER_TO_UINT(llcp_handle),
1092                         socket_data->client_socket,
1093                         socket_data->miu,
1094                         socket_data->rw,
1095                         socket_data->type,
1096                         service_name,
1097                         net_nfc_client_gdbus_get_privilege(),
1098                         NULL,
1099                         llcp_call_connect,
1100                         func_data);
1101
1102         return NET_NFC_OK;
1103 }
1104
1105 API net_nfc_error_e net_nfc_client_llcp_connect_sync(net_nfc_llcp_socket_t socket,
1106                 const char *service_name,
1107                 net_nfc_llcp_socket_t *out_socket)
1108 {
1109         net_nfc_error_e result;
1110         GError *error = NULL;
1111         guint32 out_client_socket;
1112
1113         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1114         net_nfc_llcp_internal_socket_s *out_socket_data = NULL;
1115
1116         if (service_name == NULL || out_socket == NULL) {
1117                 return NET_NFC_NULL_PARAMETER;
1118         }
1119
1120         if (llcp_proxy == NULL)
1121         {
1122                 DEBUG_ERR_MSG("Can not get LlcpProxy");
1123
1124                 return NET_NFC_NOT_INITIALIZED;
1125         }
1126
1127         socket_data = llcp_socket_data_find(socket);
1128         if (socket_data == NULL)
1129         {
1130                 DEBUG_ERR_MSG("can not get socket_data");
1131                 return NET_NFC_LLCP_INVALID_SOCKET;
1132         }
1133
1134         /* prevent executing daemon when nfc is off */
1135         if (net_nfc_client_manager_is_activated() == false) {
1136                 return NET_NFC_INVALID_STATE;
1137         }
1138
1139         if (net_nfc_gdbus_llcp_call_connect_sync(llcp_proxy,
1140                                 GPOINTER_TO_UINT(llcp_handle),
1141                                 socket_data->client_socket,
1142                                 socket_data->miu,
1143                                 socket_data->rw,
1144                                 socket_data->type,
1145                                 service_name,
1146                                 net_nfc_client_gdbus_get_privilege(),
1147                                 &result,
1148                                 &out_client_socket,
1149                                 NULL,
1150                                 &error) == true) {
1151                 out_socket_data = llcp_socket_data_find(out_client_socket);
1152                 if (out_socket_data == NULL || out_socket_data !=  socket_data)
1153                 {
1154                         DEBUG_ERR_MSG("Wrong client socket is returned");
1155                         return NET_NFC_UNKNOWN_ERROR;
1156                 }
1157
1158                 //              out_socket_data->oal_socket = out_oal_socket;
1159
1160                 if (out_socket)
1161                         *out_socket = out_client_socket;
1162         } else {
1163                 DEBUG_ERR_MSG("can not connect: %s", error->message);
1164
1165                 g_error_free(error);
1166
1167                 result = NET_NFC_IPC_FAIL;
1168         }
1169
1170         return result;
1171 }
1172
1173 API net_nfc_error_e net_nfc_client_llcp_connect_sap(net_nfc_llcp_socket_t socket,
1174                 sap_t sap,
1175                 net_nfc_client_llcp_connect_sap_completed callback,
1176                 void *user_data)
1177 {
1178         LlcpFuncData *func_data;
1179         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1180
1181         if (sap == 0) {
1182                 return NET_NFC_INVALID_PARAM;
1183         }
1184
1185         if (llcp_proxy == NULL)
1186         {
1187                 DEBUG_ERR_MSG("Can not get LlcpProxy");
1188
1189                 return NET_NFC_NOT_INITIALIZED;
1190         }
1191
1192         socket_data = llcp_socket_data_find(socket);
1193         if (socket_data == NULL)
1194         {
1195                 DEBUG_ERR_MSG("can not get socket_data");
1196                 return NET_NFC_LLCP_INVALID_SOCKET;
1197         }
1198
1199         /* prevent executing daemon when nfc is off */
1200         if (net_nfc_client_manager_is_activated() == false) {
1201                 return NET_NFC_INVALID_STATE;
1202         }
1203
1204         func_data = g_new0(LlcpFuncData, 1);
1205         if (func_data == NULL) {
1206                 DEBUG_ERR_MSG("g_new0 failed");
1207
1208                 return NET_NFC_ALLOC_FAIL;
1209         }
1210
1211         func_data->callback = (gpointer)callback;
1212         func_data->user_data = user_data;
1213
1214         net_nfc_gdbus_llcp_call_connect_sap(llcp_proxy,
1215                         GPOINTER_TO_UINT(llcp_handle),
1216                         socket_data->client_socket,
1217                         socket_data->miu,
1218                         socket_data->rw,
1219                         socket_data->type,
1220                         sap,
1221                         net_nfc_client_gdbus_get_privilege(),
1222                         NULL,
1223                         llcp_call_connect_sap,
1224                         func_data);
1225
1226         return NET_NFC_OK;
1227 }
1228
1229 API net_nfc_error_e net_nfc_client_llcp_connect_sap_sync(
1230                 net_nfc_llcp_socket_t socket,
1231                 sap_t sap,
1232                 net_nfc_llcp_socket_t *out_socket)
1233 {
1234         net_nfc_error_e result;
1235         GError *error = NULL;
1236         guint32 out_client_socket;
1237
1238         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1239         net_nfc_llcp_internal_socket_s *out_socket_data = NULL;
1240
1241         if (out_socket == NULL) {
1242                 return NET_NFC_NULL_PARAMETER;
1243         }
1244
1245         if (sap == 0) {
1246                 return NET_NFC_INVALID_PARAM;
1247         }
1248
1249         if (llcp_proxy == NULL)
1250         {
1251                 DEBUG_ERR_MSG("Can not get LlcpProxy");
1252
1253                 return NET_NFC_NOT_INITIALIZED;
1254         }
1255
1256         socket_data = llcp_socket_data_find(socket);
1257         if (socket_data == NULL)
1258         {
1259                 DEBUG_ERR_MSG("can not get socket_data");
1260                 return NET_NFC_LLCP_INVALID_SOCKET;
1261         }
1262
1263         /* prevent executing daemon when nfc is off */
1264         if (net_nfc_client_manager_is_activated() == false) {
1265                 return NET_NFC_INVALID_STATE;
1266         }
1267
1268         if (net_nfc_gdbus_llcp_call_connect_sap_sync(llcp_proxy,
1269                                 GPOINTER_TO_UINT(llcp_handle),
1270                                 socket_data->client_socket,
1271                                 socket_data->miu,
1272                                 socket_data->rw,
1273                                 socket_data->type,
1274                                 sap,
1275                                 net_nfc_client_gdbus_get_privilege(),
1276                                 &result,
1277                                 &out_client_socket,
1278                                 NULL,
1279                                 &error) == true) {
1280                 out_socket_data = llcp_socket_data_find(out_client_socket);
1281                 if (out_socket_data == NULL || out_socket_data !=  socket_data)
1282                 {
1283                         DEBUG_ERR_MSG("Wrong client socket is returned");
1284                         return NET_NFC_UNKNOWN_ERROR;
1285                 }
1286
1287                 //              out_socket_data->oal_socket = out_oal_socket;
1288
1289                 if (out_socket)
1290                         *out_socket = out_client_socket;
1291         } else {
1292                 DEBUG_ERR_MSG("can not connect: %s", error->message);
1293
1294                 g_error_free(error);
1295
1296                 result = NET_NFC_IPC_FAIL;
1297         }
1298
1299         return result;
1300 }
1301
1302 API net_nfc_error_e net_nfc_client_llcp_send(net_nfc_llcp_socket_t socket,
1303                 data_h data,
1304                 net_nfc_client_llcp_send_completed callback,
1305                 void *user_data)
1306 {
1307         LlcpFuncData *func_data;
1308         GVariant *variant;
1309         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1310
1311         if (data == NULL) {
1312                 return NET_NFC_NULL_PARAMETER;
1313         }
1314
1315         if (socket <= 0) {
1316                 return NET_NFC_INVALID_PARAM;
1317         }
1318
1319         if (llcp_proxy == NULL)
1320         {
1321                 DEBUG_ERR_MSG("Can not get LlcpProxy");
1322
1323                 return NET_NFC_NOT_INITIALIZED;
1324         }
1325
1326         /* prevent executing daemon when nfc is off */
1327         if (net_nfc_client_manager_is_activated() == false) {
1328                 return NET_NFC_INVALID_STATE;
1329         }
1330
1331         socket_data = llcp_socket_data_find(socket);
1332         if (socket_data == NULL)
1333         {
1334                 DEBUG_ERR_MSG("can not get socket_data");
1335                 return NET_NFC_LLCP_INVALID_SOCKET;
1336         }
1337
1338         func_data = g_new0(LlcpFuncData, 1);
1339         if (func_data == NULL) {
1340                 DEBUG_ERR_MSG("g_new0 failed");
1341
1342                 return NET_NFC_ALLOC_FAIL;
1343         }
1344
1345         func_data->callback = (gpointer)callback;
1346         func_data->user_data = user_data;
1347
1348         variant = net_nfc_util_gdbus_data_to_variant(data);
1349
1350         net_nfc_gdbus_llcp_call_send(llcp_proxy,
1351                         GPOINTER_TO_UINT(llcp_handle),
1352                         socket_data->client_socket,
1353                         variant,
1354                         net_nfc_client_gdbus_get_privilege(),
1355                         NULL,
1356                         llcp_call_send,
1357                         func_data);
1358
1359         return NET_NFC_OK;
1360 }
1361
1362 API net_nfc_error_e net_nfc_client_llcp_send_sync(net_nfc_llcp_socket_t socket,
1363                 data_h data)
1364 {
1365         net_nfc_error_e result;
1366         GVariant *variant;
1367         GError *error = NULL;
1368         guint32 out_client_socket;
1369
1370         net_nfc_llcp_internal_socket_s *socket_data;
1371         net_nfc_llcp_internal_socket_s *out_socket_data;
1372
1373         if (data == NULL) {
1374                 return NET_NFC_NULL_PARAMETER;
1375         }
1376
1377         if (socket <= 0) {
1378                 return NET_NFC_INVALID_PARAM;
1379         }
1380
1381         if (llcp_proxy == NULL)
1382         {
1383                 DEBUG_ERR_MSG("Can not get LlcpProxy");
1384
1385                 return NET_NFC_NOT_INITIALIZED;
1386         }
1387
1388         socket_data = llcp_socket_data_find(socket);
1389         if (socket_data == NULL)
1390         {
1391                 DEBUG_ERR_MSG("can not get socket_data");
1392                 return NET_NFC_LLCP_INVALID_SOCKET;
1393         }
1394
1395         if (data == NULL)
1396         {
1397                 DEBUG_ERR_MSG("data is empty");
1398                 return NET_NFC_INVALID_PARAM;
1399         }
1400
1401         /* prevent executing daemon when nfc is off */
1402         if (net_nfc_client_manager_is_activated() == false) {
1403                 return NET_NFC_INVALID_STATE;
1404         }
1405
1406         variant = net_nfc_util_gdbus_data_to_variant(data);
1407
1408         if (net_nfc_gdbus_llcp_call_send_sync(llcp_proxy,
1409                                 GPOINTER_TO_UINT(llcp_handle),
1410                                 socket_data->client_socket,
1411                                 variant,
1412                                 net_nfc_client_gdbus_get_privilege(),
1413                                 &result,
1414                                 &out_client_socket,
1415                                 NULL,
1416                                 &error) == true) {
1417                 out_socket_data = llcp_socket_data_find(out_client_socket);
1418                 if (out_socket_data == NULL)
1419                 {
1420                         DEBUG_ERR_MSG("can not find socket_data");
1421                         return NET_NFC_UNKNOWN_ERROR;
1422                 }
1423         } else {
1424                 DEBUG_ERR_MSG("can not call send: %s", error->message);
1425
1426                 g_error_free(error);
1427
1428                 result = NET_NFC_IPC_FAIL;
1429         }
1430
1431         return result;
1432 }
1433
1434 API net_nfc_error_e net_nfc_client_llcp_send_to(net_nfc_llcp_socket_t socket,
1435                 sap_t sap,
1436                 data_h data,
1437                 net_nfc_client_llcp_send_to_completed callback,
1438                 void *user_data)
1439 {
1440         LlcpFuncData *func_data;
1441         GVariant *variant;
1442         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1443
1444         if (data == NULL) {
1445                 return NET_NFC_NULL_PARAMETER;
1446         }
1447
1448         if (socket <= 0 || sap == 0) {
1449                 return NET_NFC_INVALID_PARAM;
1450         }
1451
1452         if (llcp_proxy == NULL)
1453         {
1454                 DEBUG_ERR_MSG("Can not get LlcpProxy");
1455
1456                 return NET_NFC_NOT_INITIALIZED;
1457         }
1458
1459         socket_data = llcp_socket_data_find(socket);
1460         if (socket_data == NULL)
1461         {
1462                 DEBUG_ERR_MSG("can not get socket_data");
1463                 return NET_NFC_LLCP_INVALID_SOCKET;
1464         }
1465
1466         /* prevent executing daemon when nfc is off */
1467         if (net_nfc_client_manager_is_activated() == false) {
1468                 return NET_NFC_INVALID_STATE;
1469         }
1470
1471         func_data = g_new0(LlcpFuncData, 1);
1472         if (func_data == NULL) {
1473                 DEBUG_ERR_MSG("g_new0 failed");
1474
1475                 return NET_NFC_ALLOC_FAIL;
1476         }
1477
1478         func_data->callback = (gpointer)callback;
1479         func_data->user_data = user_data;
1480
1481         variant = net_nfc_util_gdbus_data_to_variant(data);
1482
1483         net_nfc_gdbus_llcp_call_send_to(llcp_proxy,
1484                         GPOINTER_TO_UINT(llcp_handle),
1485                         socket_data->client_socket,
1486                         sap,
1487                         variant,
1488                         net_nfc_client_gdbus_get_privilege(),
1489                         NULL,
1490                         llcp_call_send_to,
1491                         func_data);
1492
1493         return NET_NFC_OK;
1494 }
1495
1496 API net_nfc_error_e net_nfc_client_llcp_send_to_sync(net_nfc_llcp_socket_t socket,
1497                 sap_t sap, data_h data)
1498 {
1499         net_nfc_error_e result;
1500         GVariant *variant;
1501         GError *error = NULL;
1502         guint32 out_client_socket;
1503
1504         net_nfc_llcp_internal_socket_s *socket_data;
1505         net_nfc_llcp_internal_socket_s *out_socket_data;
1506
1507         if (data == NULL) {
1508                 return NET_NFC_NULL_PARAMETER;
1509         }
1510
1511         if (socket <= 0 || sap == 0) {
1512                 return NET_NFC_INVALID_PARAM;
1513         }
1514
1515         if (llcp_proxy == NULL)
1516         {
1517                 DEBUG_ERR_MSG("Can not get LlcpProxy");
1518
1519                 return NET_NFC_NOT_INITIALIZED;
1520         }
1521
1522         socket_data = llcp_socket_data_find(socket);
1523         if (socket_data == NULL)
1524         {
1525                 DEBUG_ERR_MSG("can not get socket_data");
1526                 return NET_NFC_LLCP_INVALID_SOCKET;
1527         }
1528
1529         /* prevent executing daemon when nfc is off */
1530         if (net_nfc_client_manager_is_activated() == false) {
1531                 return NET_NFC_INVALID_STATE;
1532         }
1533
1534         variant = net_nfc_util_gdbus_data_to_variant(data);
1535
1536         if (net_nfc_gdbus_llcp_call_send_to_sync(llcp_proxy,
1537                                 GPOINTER_TO_UINT(llcp_handle),
1538                                 socket_data->client_socket,
1539                                 sap,
1540                                 variant,
1541                                 net_nfc_client_gdbus_get_privilege(),
1542                                 &result,
1543                                 &out_client_socket,
1544                                 NULL,
1545                                 &error) == true) {
1546                 out_socket_data = llcp_socket_data_find(out_client_socket);
1547                 if (out_socket_data == NULL)
1548                 {
1549                         DEBUG_ERR_MSG("can not find socket_data");
1550                         return NET_NFC_UNKNOWN_ERROR;
1551                 }
1552         } else {
1553                 DEBUG_ERR_MSG("can not call send to: %s", error->message);
1554
1555                 g_error_free(error);
1556
1557                 result = NET_NFC_IPC_FAIL;
1558         }
1559
1560         return result;
1561 }
1562
1563 API net_nfc_error_e net_nfc_client_llcp_receive(net_nfc_llcp_socket_t socket,
1564                 size_t request_length,
1565                 net_nfc_client_llcp_receive_completed callback,
1566                 void *user_data)
1567 {
1568         LlcpFuncData *func_data;
1569         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1570
1571         if (socket <= 0 || request_length == 0) {
1572                 return NET_NFC_INVALID_PARAM;
1573         }
1574
1575         if (llcp_proxy == NULL)
1576         {
1577                 DEBUG_ERR_MSG("Can not get LlcpProxy");
1578
1579                 return NET_NFC_NOT_INITIALIZED;
1580         }
1581
1582         socket_data = llcp_socket_data_find(socket);
1583         if (socket_data == NULL)
1584         {
1585                 DEBUG_ERR_MSG("can not get socket_data");
1586                 return NET_NFC_LLCP_INVALID_SOCKET;
1587         }
1588
1589         /* prevent executing daemon when nfc is off */
1590         if (net_nfc_client_manager_is_activated() == false) {
1591                 return NET_NFC_INVALID_STATE;
1592         }
1593
1594         func_data = g_new0(LlcpFuncData, 1);
1595         if (func_data == NULL) {
1596                 DEBUG_ERR_MSG("g_new0 failed");
1597
1598                 return NET_NFC_ALLOC_FAIL;
1599         }
1600
1601         func_data->callback = (gpointer)callback;
1602         func_data->user_data = user_data;
1603
1604         net_nfc_gdbus_llcp_call_receive(llcp_proxy,
1605                         GPOINTER_TO_UINT(llcp_handle),
1606                         socket_data->client_socket,
1607                         request_length,
1608                         net_nfc_client_gdbus_get_privilege(),
1609                         NULL,
1610                         llcp_call_receive,
1611                         func_data);
1612
1613         return NET_NFC_OK;
1614 }
1615
1616 API net_nfc_error_e net_nfc_client_llcp_receive_sync(net_nfc_llcp_socket_t socket,
1617                 size_t request_length,
1618                 data_h *out_data)
1619 {
1620         net_nfc_error_e result;
1621         GVariant *variant;
1622         GError *error = NULL;
1623         net_nfc_llcp_internal_socket_s *socket_data;
1624
1625         if (out_data == NULL) {
1626                 return NET_NFC_NULL_PARAMETER;
1627         }
1628
1629         *out_data = NULL;
1630
1631         if (socket <= 0 || request_length == 0) {
1632                 return NET_NFC_INVALID_PARAM;
1633         }
1634
1635         if (llcp_proxy == NULL)
1636         {
1637                 DEBUG_ERR_MSG("Can not get LlcpProxy");
1638
1639                 return NET_NFC_NOT_INITIALIZED;
1640         }
1641
1642         socket_data = llcp_socket_data_find(socket);
1643         if (socket_data == NULL)
1644         {
1645                 DEBUG_ERR_MSG("can not get socket_data");
1646                 return NET_NFC_LLCP_INVALID_SOCKET;
1647         }
1648
1649         /* prevent executing daemon when nfc is off */
1650         if (net_nfc_client_manager_is_activated() == false) {
1651                 return NET_NFC_INVALID_STATE;
1652         }
1653
1654         if (net_nfc_gdbus_llcp_call_receive_sync(llcp_proxy,
1655                                 GPOINTER_TO_UINT(llcp_handle),
1656                                 socket_data->client_socket,
1657                                 request_length,
1658                                 net_nfc_client_gdbus_get_privilege(),
1659                                 &result,
1660                                 &variant,
1661                                 NULL,
1662                                 &error) == true) {
1663                 *out_data = net_nfc_util_gdbus_variant_to_data(variant);
1664         } else {
1665                 DEBUG_ERR_MSG("can not call receive: %s", error->message);
1666
1667                 g_error_free(error);
1668
1669                 result = NET_NFC_IPC_FAIL;
1670         }
1671
1672         return result;
1673 }
1674
1675 API net_nfc_error_e net_nfc_client_llcp_receive_from(net_nfc_llcp_socket_t socket,
1676                 size_t request_length,
1677                 net_nfc_client_llcp_receive_from_completed callback,
1678                 void *user_data)
1679 {
1680         LlcpFuncData *func_data;
1681         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1682
1683         if (socket <= 0 || request_length == 0) {
1684                 return NET_NFC_INVALID_PARAM;
1685         }
1686
1687         if (llcp_proxy == NULL)
1688         {
1689                 DEBUG_ERR_MSG("Can not get LlcpProxy");
1690
1691                 return NET_NFC_NOT_INITIALIZED;
1692         }
1693
1694         socket_data = llcp_socket_data_find(socket);
1695         if (socket_data == NULL)
1696         {
1697                 DEBUG_ERR_MSG("can not get socket_data");
1698                 return NET_NFC_LLCP_INVALID_SOCKET;
1699         }
1700
1701         func_data = g_new0(LlcpFuncData, 1);
1702         if (func_data == NULL) {
1703                 DEBUG_ERR_MSG("g_new0 failed");
1704
1705                 return NET_NFC_ALLOC_FAIL;
1706         }
1707
1708         func_data->callback = (gpointer)callback;
1709         func_data->user_data = user_data;
1710
1711         net_nfc_gdbus_llcp_call_receive_from(llcp_proxy,
1712                         GPOINTER_TO_UINT(llcp_handle),
1713                         socket_data->client_socket,
1714                         request_length,
1715                         net_nfc_client_gdbus_get_privilege(),
1716                         NULL,
1717                         llcp_call_receive_from,
1718                         func_data);
1719
1720         return NET_NFC_OK;
1721 }
1722
1723 API net_nfc_error_e net_nfc_client_llcp_receive_from_sync(
1724                 net_nfc_llcp_socket_t socket,
1725                 size_t request_length,
1726                 sap_t *out_sap,
1727                 data_h *out_data)
1728 {
1729         net_nfc_error_e result;
1730         GError *error = NULL;
1731         GVariant *variant;
1732         sap_t sap;
1733
1734         net_nfc_llcp_internal_socket_s *socket_data;
1735
1736         if (out_sap == NULL || out_data == NULL) {
1737                 return NET_NFC_NULL_PARAMETER;
1738         }
1739
1740         *out_data = NULL;
1741         *out_sap = 0;
1742
1743         if (socket <= 0 || request_length == 0) {
1744                 return NET_NFC_INVALID_PARAM;
1745         }
1746
1747         if (llcp_proxy == NULL)
1748         {
1749                 DEBUG_ERR_MSG("Can not get LlcpProxy");
1750
1751                 return NET_NFC_NOT_INITIALIZED;
1752         }
1753
1754         socket_data = llcp_socket_data_find(socket);
1755         if (socket_data == NULL)
1756         {
1757                 DEBUG_ERR_MSG("can not get socket_data");
1758                 return NET_NFC_LLCP_INVALID_SOCKET;
1759         }
1760
1761         /* prevent executing daemon when nfc is off */
1762         if (net_nfc_client_manager_is_activated() == false) {
1763                 return NET_NFC_INVALID_STATE;
1764         }
1765
1766         if (net_nfc_gdbus_llcp_call_receive_from_sync(llcp_proxy,
1767                                 GPOINTER_TO_UINT(llcp_handle),
1768                                 socket_data->client_socket,
1769                                 request_length,
1770                                 net_nfc_client_gdbus_get_privilege(),
1771                                 &result,
1772                                 &sap,
1773                                 &variant,
1774                                 NULL,
1775                                 &error) == true) {
1776                 *out_sap = sap;
1777                 *out_data = net_nfc_util_gdbus_variant_to_data(variant);
1778         } else {
1779                 DEBUG_ERR_MSG("can not call receive from: %s", error->message);
1780
1781                 g_error_free(error);
1782
1783                 result = NET_NFC_IPC_FAIL;
1784         }
1785
1786         return result;
1787 }
1788
1789 API net_nfc_error_e net_nfc_client_llcp_close(net_nfc_llcp_socket_t socket,
1790                 net_nfc_client_llcp_close_completed callback,
1791                 void *user_data)
1792 {
1793         LlcpFuncData *func_data;
1794         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1795
1796         if (socket <= 0) {
1797                 return NET_NFC_INVALID_PARAM;
1798         }
1799
1800         if (llcp_proxy == NULL)
1801         {
1802                 DEBUG_ERR_MSG("Can not get LlcpProxy");
1803
1804                 return NET_NFC_NOT_INITIALIZED;
1805         }
1806
1807         socket_data = llcp_socket_data_find(socket);
1808         if (socket_data == NULL)
1809         {
1810                 DEBUG_ERR_MSG("can not get socket_data");
1811                 return NET_NFC_LLCP_INVALID_SOCKET;
1812         }
1813
1814         /* prevent executing daemon when nfc is off */
1815         if (net_nfc_client_manager_is_activated() == false) {
1816                 return NET_NFC_INVALID_STATE;
1817         }
1818
1819         func_data = g_new0(LlcpFuncData, 1);
1820         if (func_data == NULL) {
1821                 DEBUG_ERR_MSG("g_new0 failed");
1822
1823                 return NET_NFC_ALLOC_FAIL;
1824         }
1825
1826         func_data->callback = (gpointer)callback;
1827         func_data->user_data = user_data;
1828
1829         net_nfc_gdbus_llcp_call_close(llcp_proxy,
1830                         GPOINTER_TO_UINT(llcp_handle),
1831                         socket_data->client_socket,
1832                         net_nfc_client_gdbus_get_privilege(),
1833                         NULL,
1834                         llcp_call_close,
1835                         func_data);
1836
1837         return NET_NFC_OK;
1838 }
1839
1840 API net_nfc_error_e net_nfc_client_llcp_close_sync(net_nfc_llcp_socket_t socket)
1841 {
1842         net_nfc_error_e result;
1843         GError *error = NULL;
1844         guint32 out_client_socket;
1845
1846         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1847         net_nfc_llcp_internal_socket_s *out_socket_data = NULL;
1848
1849         if (socket <= 0) {
1850                 return NET_NFC_INVALID_PARAM;
1851         }
1852
1853         if (llcp_proxy == NULL)
1854         {
1855                 DEBUG_ERR_MSG("Can not get LlcpProxy");
1856
1857                 return NET_NFC_NOT_INITIALIZED;
1858         }
1859
1860         socket_data = llcp_socket_data_find(socket);
1861         if (socket_data == NULL)
1862         {
1863                 DEBUG_ERR_MSG("can not get socket_data");
1864                 return NET_NFC_LLCP_INVALID_SOCKET;
1865         }
1866
1867         /* prevent executing daemon when nfc is off */
1868         if (net_nfc_client_manager_is_activated() == false) {
1869                 return NET_NFC_INVALID_STATE;
1870         }
1871
1872         if (net_nfc_gdbus_llcp_call_close_sync(llcp_proxy,
1873                                 GPOINTER_TO_UINT(llcp_handle),
1874                                 socket_data->client_socket,
1875                                 net_nfc_client_gdbus_get_privilege(),
1876                                 &result,
1877                                 &out_client_socket,
1878                                 NULL,
1879                                 &error) == true) {
1880                 out_socket_data = llcp_socket_data_find(out_client_socket);
1881                 if (out_socket_data == NULL || out_socket_data !=  socket_data)
1882                 {
1883                         DEBUG_ERR_MSG("Wrong client socket is returned");
1884                         return NET_NFC_UNKNOWN_ERROR;
1885                 }
1886         } else {
1887                 DEBUG_ERR_MSG("can not close: %s", error->message);
1888
1889                 g_error_free(error);
1890
1891                 result = NET_NFC_IPC_FAIL;
1892         }
1893
1894         return result;
1895 }
1896
1897 API net_nfc_error_e net_nfc_client_llcp_disconnect(net_nfc_llcp_socket_t socket,
1898                 net_nfc_client_llcp_disconnect_completed callback,
1899                 void *user_data)
1900 {
1901         LlcpFuncData *func_data;
1902         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1903
1904         if (socket <= 0) {
1905                 return NET_NFC_INVALID_PARAM;
1906         }
1907
1908         if (llcp_proxy == NULL)
1909         {
1910                 DEBUG_ERR_MSG("Can not get LlcpProxy");
1911
1912                 return NET_NFC_NOT_INITIALIZED;
1913         }
1914
1915         socket_data = llcp_socket_data_find(socket);
1916         if (socket_data == NULL)
1917         {
1918                 DEBUG_ERR_MSG("can not get socket_data");
1919                 return NET_NFC_LLCP_INVALID_SOCKET;
1920         }
1921
1922         /* prevent executing daemon when nfc is off */
1923         if (net_nfc_client_manager_is_activated() == false) {
1924                 return NET_NFC_INVALID_STATE;
1925         }
1926
1927         func_data = g_new0(LlcpFuncData, 1);
1928         if (func_data == NULL) {
1929                 DEBUG_ERR_MSG("g_new0 failed");
1930
1931                 return NET_NFC_ALLOC_FAIL;
1932         }
1933
1934         func_data->callback = (gpointer)callback;
1935         func_data->user_data = user_data;
1936
1937         net_nfc_gdbus_llcp_call_disconnect(llcp_proxy,
1938                         GPOINTER_TO_UINT(llcp_handle),
1939                         socket_data->client_socket,
1940                         net_nfc_client_gdbus_get_privilege(),
1941                         NULL,
1942                         llcp_call_disconnect,
1943                         func_data);
1944
1945         return NET_NFC_OK;
1946 }
1947
1948 API net_nfc_error_e net_nfc_client_llcp_disconnect_sync(
1949                 net_nfc_llcp_socket_t socket)
1950 {
1951         net_nfc_error_e result;
1952         GError *error = NULL;
1953         guint32 out_client_socket;
1954
1955         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1956         net_nfc_llcp_internal_socket_s *out_socket_data = NULL;
1957
1958         if (socket <= 0) {
1959                 return NET_NFC_INVALID_PARAM;
1960         }
1961
1962         if (llcp_proxy == NULL)
1963         {
1964                 DEBUG_ERR_MSG("Can not get LlcpProxy");
1965
1966                 return NET_NFC_NOT_INITIALIZED;
1967         }
1968
1969         socket_data = llcp_socket_data_find(socket);
1970         if (socket_data == NULL)
1971         {
1972                 DEBUG_ERR_MSG("can not get socket_data");
1973                 return NET_NFC_LLCP_INVALID_SOCKET;
1974         }
1975
1976         /* prevent executing daemon when nfc is off */
1977         if (net_nfc_client_manager_is_activated() == false) {
1978                 return NET_NFC_INVALID_STATE;
1979         }
1980
1981         if (net_nfc_gdbus_llcp_call_disconnect_sync(llcp_proxy,
1982                                 GPOINTER_TO_UINT(llcp_handle),
1983                                 socket_data->client_socket,
1984                                 net_nfc_client_gdbus_get_privilege(),
1985                                 &result,
1986                                 &out_client_socket,
1987                                 NULL,
1988                                 &error) == true) {
1989                 out_socket_data = llcp_socket_data_find(out_client_socket);
1990                 if (out_socket_data == NULL || out_socket_data !=  socket_data)
1991                 {
1992                         DEBUG_ERR_MSG("Wrong client socket is returned");
1993                         return NET_NFC_UNKNOWN_ERROR;
1994                 }
1995         } else {
1996                 DEBUG_ERR_MSG("can not disconnect: %s", error->message);
1997
1998                 g_error_free(error);
1999
2000                 result = NET_NFC_IPC_FAIL;
2001         }
2002
2003         return result;
2004 }
2005
2006 API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
2007                 net_nfc_llcp_socket_option_h option)
2008 {
2009         net_nfc_llcp_internal_socket_s *socket_data = NULL;
2010
2011         socket_data = g_new0(net_nfc_llcp_internal_socket_s, 1);
2012
2013         socket_data->client_socket = socket_handle++;
2014
2015         if (option)
2016         {
2017                 socket_data->miu = option->miu;
2018                 socket_data->rw = option->rw;
2019                 socket_data->type = option->type;
2020         }
2021         else
2022         {
2023                 socket_data->miu = 128;
2024                 socket_data->rw = 1;
2025                 socket_data->type =
2026                         NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONORIENTED;
2027         }
2028
2029         socket_data->device_id = llcp_handle;
2030         socket_data->close_requested = false;
2031
2032
2033         if (socket)
2034                 *socket = socket_data->client_socket;
2035 }
2036
2037
2038 API net_nfc_error_e net_nfc_client_llcp_get_local_config(
2039                 net_nfc_llcp_config_info_h *config)
2040 {
2041         if (config == NULL)
2042                 return NET_NFC_NULL_PARAMETER;
2043
2044         *config = (net_nfc_llcp_config_info_h)&llcp_config;
2045
2046         return NET_NFC_OK;
2047 }
2048
2049 API net_nfc_error_e net_nfc_client_llcp_get_local_socket_option(
2050                 net_nfc_llcp_socket_t socket,
2051                 net_nfc_llcp_socket_option_h *info)
2052 {
2053         net_nfc_llcp_internal_socket_s *socket_data = NULL;
2054
2055         DEBUG_CLIENT_MSG("function %s is called", __func__);
2056
2057         socket_data = llcp_socket_data_find(socket);
2058         if (socket_data == NULL)
2059                 return NET_NFC_LLCP_INVALID_SOCKET;
2060
2061         *info = (net_nfc_llcp_socket_option_h)socket_data;
2062
2063         return NET_NFC_OK;
2064 }
2065
2066 API net_nfc_error_e net_nfc_client_llcp_create_socket_option(
2067                 net_nfc_llcp_socket_option_h *option,
2068                 uint16_t miu,
2069                 uint8_t rw,
2070                 net_nfc_socket_type_e type)
2071 {
2072         net_nfc_llcp_socket_option_s *struct_option = NULL;
2073
2074         if (option == NULL)
2075         {
2076                 return NET_NFC_NULL_PARAMETER;
2077         }
2078
2079         if (miu < 128 || miu > 1152 ||
2080                         rw < 1 || rw > 15 ||
2081                         type < NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONORIENTED ||
2082                         type > NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONLESS)
2083         {
2084                 return NET_NFC_OUT_OF_BOUND;
2085         }
2086
2087         _net_nfc_util_alloc_mem(struct_option, sizeof(net_nfc_llcp_socket_option_s));
2088         if (struct_option != NULL)
2089         {
2090                 struct_option->miu = miu;
2091                 struct_option->rw = rw;
2092                 struct_option->type = type;
2093
2094                 *option = (net_nfc_llcp_socket_option_h)struct_option;
2095
2096                 return NET_NFC_OK;
2097         }
2098         else
2099         {
2100                 return NET_NFC_ALLOC_FAIL;
2101         }
2102 }
2103
2104 API net_nfc_error_e net_nfc_client_llcp_create_socket_option_default(
2105                 net_nfc_llcp_socket_option_h *option)
2106 {
2107         return net_nfc_client_llcp_create_socket_option(
2108                         option,
2109                         128,
2110                         1,
2111                         NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONORIENTED);
2112 }
2113
2114 API net_nfc_error_e net_nfc_client_llcp_get_socket_option_miu(
2115                 net_nfc_llcp_socket_option_h option,
2116                 uint16_t *miu)
2117 {
2118         net_nfc_llcp_socket_option_s *struct_option =
2119                 (net_nfc_llcp_socket_option_s *)option;
2120
2121         if (option == NULL || miu == NULL)
2122         {
2123                 return NET_NFC_NULL_PARAMETER;
2124         }
2125
2126         *miu = struct_option->miu;
2127
2128         return NET_NFC_OK;
2129 }
2130
2131 API net_nfc_error_e net_nfc_client_llcp_set_socket_option_miu(
2132                 net_nfc_llcp_socket_option_h option,
2133                 uint16_t miu)
2134 {
2135         net_nfc_llcp_socket_option_s *struct_option =
2136                 (net_nfc_llcp_socket_option_s *)option;
2137
2138         if (option == NULL)
2139         {
2140                 return NET_NFC_NULL_PARAMETER;
2141         }
2142
2143         struct_option->miu = miu;
2144
2145         return NET_NFC_OK;
2146 }
2147
2148 API net_nfc_error_e net_nfc_client_llcp_get_socket_option_rw(
2149                 net_nfc_llcp_socket_option_h option,
2150                 uint8_t *rw)
2151 {
2152         if (option == NULL || rw == NULL)
2153         {
2154                 return NET_NFC_NULL_PARAMETER;
2155         }
2156         net_nfc_llcp_socket_option_s *struct_option = (net_nfc_llcp_socket_option_s *)option;
2157
2158         *rw = struct_option->rw;
2159         return NET_NFC_OK;
2160 }
2161
2162 API net_nfc_error_e net_nfc_client_llcp_set_socket_option_rw(
2163                 net_nfc_llcp_socket_option_h option,
2164                 uint8_t rw)
2165 {
2166         if (option == NULL)
2167         {
2168                 return NET_NFC_NULL_PARAMETER;
2169         }
2170         net_nfc_llcp_socket_option_s *struct_option = (net_nfc_llcp_socket_option_s *)option;
2171
2172         struct_option->rw = rw;
2173         return NET_NFC_OK;
2174 }
2175
2176 API net_nfc_error_e net_nfc_client_llcp_get_socket_option_type(
2177                 net_nfc_llcp_socket_option_h option,
2178                 net_nfc_socket_type_e * type)
2179 {
2180         if (option == NULL || type == NULL)
2181         {
2182                 return NET_NFC_NULL_PARAMETER;
2183         }
2184         net_nfc_llcp_socket_option_s *struct_option = (net_nfc_llcp_socket_option_s *)option;
2185
2186         *type = struct_option->type;
2187         return NET_NFC_OK;
2188 }
2189
2190 API net_nfc_error_e net_nfc_client_llcp_set_socket_option_type(
2191                 net_nfc_llcp_socket_option_h option,
2192                 net_nfc_socket_type_e type)
2193 {
2194         if (option == NULL)
2195         {
2196                 return NET_NFC_NULL_PARAMETER;
2197         }
2198         net_nfc_llcp_socket_option_s *struct_option = (net_nfc_llcp_socket_option_s *)option;
2199
2200         struct_option->type = type;
2201         return NET_NFC_OK;
2202 }
2203
2204 API net_nfc_error_e net_nfc_client_llcp_free_socket_option(
2205                 net_nfc_llcp_socket_option_h option)
2206 {
2207         if (option == NULL)
2208         {
2209                 return NET_NFC_NULL_PARAMETER;
2210         }
2211
2212         _net_nfc_util_free_mem(option);
2213
2214         return NET_NFC_OK;
2215 }
2216
2217 API net_nfc_error_e net_nfc_client_llcp_create_config(
2218                 net_nfc_llcp_config_info_h *config,
2219                 uint16_t miu,
2220                 uint16_t wks,
2221                 uint8_t lto,
2222                 uint8_t option)
2223 {
2224         net_nfc_llcp_config_info_s *tmp_config;
2225
2226         if (config == NULL)
2227                 return NET_NFC_NULL_PARAMETER;
2228
2229         _net_nfc_util_alloc_mem(tmp_config, sizeof(net_nfc_llcp_config_info_s));
2230
2231         if (tmp_config == NULL)
2232                 return NET_NFC_ALLOC_FAIL;
2233
2234         tmp_config->miu = miu;
2235         tmp_config->wks = wks;
2236         tmp_config->lto = lto;
2237         tmp_config->option = option;
2238
2239         *config = (net_nfc_llcp_config_info_h)tmp_config;
2240
2241         return NET_NFC_OK;
2242 }
2243
2244 API net_nfc_error_e net_nfc_client_llcp_create_config_default(
2245                 net_nfc_llcp_config_info_h *config)
2246 {
2247         return net_nfc_client_llcp_create_config(config, 128, 1, 10, 0);
2248 }
2249
2250 API net_nfc_error_e net_nfc_client_llcp_get_config_miu(
2251                 net_nfc_llcp_config_info_h config, uint16_t *miu)
2252 {
2253         if (config == NULL || miu == NULL)
2254                 return NET_NFC_NULL_PARAMETER;
2255
2256         net_nfc_llcp_config_info_s *tmp_config =
2257                 (net_nfc_llcp_config_info_s *)config;
2258
2259         *miu = tmp_config->miu;
2260
2261         return NET_NFC_OK;
2262 }
2263
2264 API net_nfc_error_e net_nfc_client_llcp_get_config_wks(
2265                 net_nfc_llcp_config_info_h config, uint16_t *wks)
2266 {
2267         if (config == NULL || wks == NULL)
2268                 return NET_NFC_NULL_PARAMETER;
2269
2270         net_nfc_llcp_config_info_s *tmp_config =
2271                 (net_nfc_llcp_config_info_s *)config;
2272
2273         *wks = tmp_config->wks;
2274
2275         return NET_NFC_OK;
2276 }
2277
2278 API net_nfc_error_e net_nfc_client_llcp_get_config_lto(
2279                 net_nfc_llcp_config_info_h config, uint8_t *lto)
2280 {
2281         if (config == NULL || lto == NULL)
2282                 return NET_NFC_NULL_PARAMETER;
2283
2284         net_nfc_llcp_config_info_s *tmp_config =
2285                 (net_nfc_llcp_config_info_s *)config;
2286
2287         *lto = tmp_config->lto;
2288
2289         return NET_NFC_OK;
2290 }
2291
2292 API net_nfc_error_e net_nfc_client_llcp_get_config_option(
2293                 net_nfc_llcp_config_info_h config, uint8_t *option)
2294 {
2295         if (config == NULL || option == NULL)
2296                 return NET_NFC_NULL_PARAMETER;
2297
2298         net_nfc_llcp_config_info_s *tmp_config =
2299                 (net_nfc_llcp_config_info_s *)config;
2300
2301         *option = tmp_config->option;
2302
2303         return NET_NFC_OK;
2304 }
2305
2306 API net_nfc_error_e net_nfc_client_llcp_set_config_miu(
2307                 net_nfc_llcp_config_info_h config, uint16_t miu)
2308 {
2309         if (config == NULL)
2310                 return NET_NFC_NULL_PARAMETER;
2311
2312         if (miu < 128 || miu > 1152)
2313                 return NET_NFC_OUT_OF_BOUND;
2314
2315         net_nfc_llcp_config_info_s * tmp_config =
2316                 (net_nfc_llcp_config_info_s *)config;
2317
2318         tmp_config->miu = miu;
2319
2320         return NET_NFC_OK;
2321 }
2322
2323 API net_nfc_error_e net_nfc_client_llcp_set_config_wks(
2324                 net_nfc_llcp_config_info_h config, uint16_t wks)
2325 {
2326         if (config == NULL)
2327                 return NET_NFC_NULL_PARAMETER;
2328
2329         net_nfc_llcp_config_info_s *tmp_config =
2330                 (net_nfc_llcp_config_info_s *)config;
2331
2332         tmp_config->wks = wks;
2333
2334         return NET_NFC_OK;
2335 }
2336
2337 API net_nfc_error_e net_nfc_client_llcp_set_config_lto(
2338                 net_nfc_llcp_config_info_h config, uint8_t lto)
2339 {
2340         if (config == NULL)
2341                 return NET_NFC_NULL_PARAMETER;
2342
2343         net_nfc_llcp_config_info_s *tmp_config =
2344                 (net_nfc_llcp_config_info_s *)config;
2345
2346         tmp_config->lto = lto;
2347
2348         return NET_NFC_OK;
2349 }
2350
2351 API net_nfc_error_e net_nfc_client_llcp_set_config_option(
2352                 net_nfc_llcp_config_info_h config, uint8_t option)
2353 {
2354         if (config == NULL)
2355                 return NET_NFC_NULL_PARAMETER;
2356
2357         net_nfc_llcp_config_info_s * tmp_config =
2358                 (net_nfc_llcp_config_info_s *)config;
2359
2360         tmp_config->option = option;
2361
2362         return NET_NFC_OK;
2363 }
2364
2365 API net_nfc_error_e net_nfc_client_llcp_free_config(
2366                 net_nfc_llcp_config_info_h config)
2367 {
2368         if (config == NULL)
2369                 return NET_NFC_NULL_PARAMETER;
2370
2371         _net_nfc_util_free_mem(config);
2372         return NET_NFC_OK;
2373 }
2374
2375 net_nfc_error_e net_nfc_client_llcp_init(void)
2376 {
2377         GError *error = NULL;
2378
2379         if (llcp_proxy)
2380         {
2381                 DEBUG_CLIENT_MSG("Already initialized");
2382                 return NET_NFC_OK;
2383         }
2384
2385         llcp_proxy = net_nfc_gdbus_llcp_proxy_new_for_bus_sync(
2386                         G_BUS_TYPE_SYSTEM,
2387                         G_DBUS_PROXY_FLAGS_NONE,
2388                         "org.tizen.NetNfcService",
2389                         "/org/tizen/NetNfcService/Llcp",
2390                         NULL,
2391                         &error);
2392
2393         if (llcp_proxy == NULL)
2394         {
2395                 DEBUG_ERR_MSG("Can not create proxy : %s", error->message);
2396                 g_error_free(error);
2397                 return NET_NFC_UNKNOWN_ERROR;
2398         }
2399
2400         g_signal_connect(llcp_proxy, "error",
2401                         G_CALLBACK(llcp_error), NULL);
2402
2403         g_signal_connect(llcp_proxy, "incoming",
2404                         G_CALLBACK(llcp_incoming), NULL);
2405
2406         return NET_NFC_OK;
2407 }
2408
2409 void net_nfc_client_llcp_deinit(void)
2410 {
2411         if (llcp_proxy)
2412         {
2413                 g_object_unref(llcp_proxy);
2414                 llcp_proxy = NULL;
2415         }
2416 }