client/net_nfc_client_llcp.c

   1 /*
   2  * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (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://www.apache.org/licenses/LICENSE-2.0
   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 /* signal callback */
  41 static void llcp_error(NetNfcGDbusLlcp *object, guint arg_handle, guint client_socket,
  42                 gint error, gpointer user_data)
  43 {
  44         NFC_INFO(">>> SIGNAL arrived");
  45 }
  46
  47 static void llcp_incoming(NetNfcGDbusLlcp *object, guint arg_handle,
  48                 guint client_socket, guint incoming_socket, gpointer user_data)
  49 {
  50         NFC_INFO(">>> SIGNAL arrived");
  51 }
  52
  53 void llcp_socket_data_append(net_nfc_llcp_internal_socket_s *socket_data)
  54 {
  55         RET_IF(NULL == socket_data_list);
  56
  57         if (socket_data)
  58                 socket_data_list = g_list_append(socket_data_list, socket_data);
  59 }
  60
  61 void llcp_socket_data_remove(net_nfc_llcp_internal_socket_s *socket_data)
  62 {
  63         RET_IF(NULL == socket_data_list);
  64
  65         if (socket_data)
  66         {
  67                 socket_data_list = g_list_remove(socket_data_list, socket_data);
  68
  69                 g_free(socket_data->service_name);
  70                 g_free(socket_data);
  71         }
  72 }
  73
  74 net_nfc_llcp_internal_socket_s *llcp_socket_data_find(net_nfc_llcp_socket_t socket)
  75 {
  76         GList *pos;
  77
  78         RETV_IF(NULL == socket_data_list, NULL);
  79
  80         for (pos = g_list_first(socket_data_list); pos ; pos = pos->data)
  81         {
  82                 net_nfc_llcp_internal_socket_s *data;
  83
  84                 data = pos->data;
  85                 if (data == NULL)
  86                         continue;
  87
  88                 if (data->client_socket == socket)
  89                         break;
  90         }
  91
  92         if (pos == NULL)
  93                 return NULL;
  94
  95         return pos->data;
  96 }
  97
  98 static void llcp_call_listen(GObject *source_object, GAsyncResult *res,
  99                 gpointer user_data)
 100 {
 101         gboolean ret;
 102         GError *error = NULL;
 103         net_nfc_error_e result;
 104         guint32 out_client_socket = -1;
 105         LlcpFuncData *func_data = user_data;
 106         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 107
 108         g_assert(func_data != NULL);
 109
 110         ret = net_nfc_gdbus_llcp_call_listen_finish(NET_NFC_GDBUS_LLCP(source_object),
 111                         &result, &out_client_socket, res, &error);
 112         if (FALSE == ret)
 113         {
 114                 NFC_ERR("Can not finish listen: %s", error->message);
 115                 g_error_free(error);
 116                 result = NET_NFC_IPC_FAIL;
 117         }
 118
 119         socket_data = llcp_socket_data_find(out_client_socket);
 120         if (socket_data == NULL)
 121         {
 122                 NFC_ERR("Wrong client socket is returned");
 123                 return;
 124         }
 125
 126         if (func_data->callback != NULL)
 127         {
 128                 net_nfc_client_llcp_listen_completed callback =
 129                         (net_nfc_client_llcp_listen_completed)func_data->callback;
 130
 131                 callback(result, out_client_socket, func_data->user_data);
 132         }
 133
 134         /* TODO : release resource when socket is closed */
 135         //      g_free(func_data);
 136 }
 137
 138 static void llcp_call_accept(GObject *source_object, GAsyncResult *res,
 139                 gpointer user_data)
 140 {
 141         gboolean ret;
 142         GError *error = NULL;
 143         net_nfc_error_e result;
 144         LlcpFuncData *func_data = user_data;
 145
 146         g_assert(func_data != NULL);
 147
 148         ret = net_nfc_gdbus_llcp_call_accept_finish(NET_NFC_GDBUS_LLCP(source_object),
 149                         &result, res, &error);
 150         if (FALSE == ret)
 151         {
 152                 NFC_ERR("Can not finish accept: %s", error->message);
 153                 g_error_free(error);
 154                 result = NET_NFC_IPC_FAIL;
 155         }
 156
 157         if (func_data->callback != NULL)
 158         {
 159                 net_nfc_client_llcp_accept_completed callback =
 160                         (net_nfc_client_llcp_accept_completed)func_data->callback;
 161
 162                 callback(result, func_data->user_data);
 163         }
 164
 165         g_free(func_data);
 166 }
 167
 168 static void llcp_call_reject(GObject *source_object, GAsyncResult *res,
 169                 gpointer user_data)
 170 {
 171         gboolean ret;
 172         GError *error = NULL;
 173         net_nfc_error_e result;
 174         LlcpFuncData *func_data = user_data;
 175
 176         g_assert(func_data != NULL);
 177
 178         ret = net_nfc_gdbus_llcp_call_reject_finish(NET_NFC_GDBUS_LLCP(source_object),
 179                         &result, res, &error);
 180         if (FALSE == ret)
 181         {
 182                 NFC_ERR("Can not finish reject: %s", error->message);
 183                 g_error_free(error);
 184                 result = NET_NFC_IPC_FAIL;
 185         }
 186
 187         if (func_data->callback != NULL)
 188         {
 189                 net_nfc_client_llcp_reject_completed callback =
 190                         (net_nfc_client_llcp_reject_completed)func_data->callback;
 191
 192                 callback(result, func_data->user_data);
 193         }
 194
 195         g_free(func_data);
 196 }
 197
 198 static void llcp_call_connect(GObject *source_object, GAsyncResult *res,
 199                 gpointer user_data)
 200 {
 201         gboolean ret;
 202         GError *error = NULL;
 203         net_nfc_error_e result;
 204         guint32 out_client_socket = -1;
 205         LlcpFuncData *func_data = user_data;
 206         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 207
 208         g_assert(func_data != NULL);
 209
 210         ret = net_nfc_gdbus_llcp_call_connect_finish(NET_NFC_GDBUS_LLCP(source_object),
 211                         &result, &out_client_socket, res, &error);
 212         if (FALSE == ret)
 213         {
 214                 NFC_ERR("Can not finish connect: %s", error->message);
 215                 g_error_free(error);
 216                 result = NET_NFC_IPC_FAIL;
 217         }
 218
 219         socket_data = llcp_socket_data_find(out_client_socket);
 220         if (socket_data == NULL)
 221         {
 222                 NFC_ERR("Wrong client socket is returned");
 223                 return;
 224         }
 225
 226         if (func_data->callback != NULL)
 227         {
 228                 net_nfc_client_llcp_connect_completed callback =
 229                         (net_nfc_client_llcp_connect_completed)func_data->callback;
 230
 231                 callback(result, out_client_socket, func_data->user_data);
 232         }
 233
 234         /* TODO : release resource when socket is closed */
 235         //      g_free(func_data);
 236 }
 237
 238 static void llcp_call_connect_sap(GObject *source_object,
 239                 GAsyncResult *res,
 240                 gpointer user_data)
 241 {
 242         gboolean ret;
 243         GError *error = NULL;
 244         net_nfc_error_e result;
 245         guint32 out_client_socket = -1;
 246         LlcpFuncData *func_data = user_data;
 247         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 248
 249         g_assert(func_data != NULL);
 250
 251         ret = net_nfc_gdbus_llcp_call_connect_sap_finish(NET_NFC_GDBUS_LLCP(source_object),
 252                         &result, &out_client_socket, res, &error);
 253         if (FALSE == ret)
 254         {
 255                 NFC_ERR("Can not finish connect sap: %s", error->message);
 256                 g_error_free(error);
 257                 result = NET_NFC_IPC_FAIL;
 258         }
 259
 260         socket_data = llcp_socket_data_find(out_client_socket);
 261         if (socket_data == NULL)
 262         {
 263                 NFC_ERR("Wrong client socket is returned");
 264                 return;
 265         }
 266
 267         if (func_data->callback != NULL)
 268         {
 269                 net_nfc_client_llcp_connect_sap_completed callback =
 270                         (net_nfc_client_llcp_connect_sap_completed)func_data->callback;
 271
 272                 callback(result, out_client_socket, func_data->user_data);
 273         }
 274
 275         /* TODO : release resource when socket is closed */
 276         //      g_free(func_data);
 277 }
 278
 279 static void llcp_call_send(GObject *source_object, GAsyncResult *res,
 280                 gpointer user_data)
 281 {
 282         gboolean ret;
 283         GError *error = NULL;
 284         net_nfc_error_e result;
 285         guint32 out_client_socket = -1;
 286         LlcpFuncData *func_data = user_data;
 287
 288         g_assert(func_data != NULL);
 289
 290         ret = net_nfc_gdbus_llcp_call_send_finish(NET_NFC_GDBUS_LLCP(source_object),
 291                         &result, &out_client_socket, res, &error);
 292         if (FALSE == ret)
 293         {
 294                 NFC_ERR("Can not finish send: %s", error->message);
 295                 g_error_free(error);
 296                 result = NET_NFC_IPC_FAIL;
 297         }
 298
 299         if (func_data->callback != NULL)
 300         {
 301                 net_nfc_client_llcp_send_completed callback =
 302                         (net_nfc_client_llcp_send_completed)func_data->callback;
 303
 304                 callback(result, func_data->user_data);
 305         }
 306
 307         g_free(func_data);
 308 }
 309
 310 static void llcp_call_send_to(GObject *source_object, GAsyncResult *res,
 311                 gpointer user_data)
 312 {
 313         gboolean ret;
 314         GError *error = NULL;
 315         net_nfc_error_e result;
 316         guint32 out_client_socket = -1;
 317         LlcpFuncData *func_data = user_data;
 318
 319         g_assert(func_data != NULL);
 320
 321         ret = net_nfc_gdbus_llcp_call_send_to_finish(NET_NFC_GDBUS_LLCP(source_object),
 322                         &result, &out_client_socket, res, &error);
 323         if (FALSE == ret)
 324         {
 325                 NFC_ERR("Can not finish send to: %s", error->message);
 326                 g_error_free(error);
 327                 result = NET_NFC_IPC_FAIL;
 328         }
 329
 330         if (func_data->callback != NULL)
 331         {
 332                 net_nfc_client_llcp_send_to_completed callback =
 333                         (net_nfc_client_llcp_send_to_completed)func_data->callback;
 334
 335                 callback(result, func_data->user_data);
 336         }
 337
 338         g_free(func_data);
 339 }
 340
 341 static void llcp_call_receive(GObject *source_object, GAsyncResult *res,
 342                 gpointer user_data)
 343 {
 344         gboolean ret;
 345         GVariant *variant;
 346         GError *error = NULL;
 347         net_nfc_error_e result;
 348         LlcpFuncData *func_data = user_data;
 349
 350         g_assert(func_data != NULL);
 351
 352         ret = net_nfc_gdbus_llcp_call_receive_finish(NET_NFC_GDBUS_LLCP(source_object),
 353                         &result, &variant, res, &error);
 354         if (FALSE == ret)
 355         {
 356                 NFC_ERR("Can not finish receive: %s", error->message);
 357                 g_error_free(error);
 358                 result = NET_NFC_IPC_FAIL;
 359         }
 360
 361         if (func_data->callback != NULL)
 362         {
 363                 data_s data = { NULL, 0 };
 364                 net_nfc_client_llcp_receive_completed callback =
 365                         (net_nfc_client_llcp_receive_completed)func_data->callback;
 366
 367                 net_nfc_util_gdbus_variant_to_data_s(variant, &data);
 368
 369                 callback(result, &data, func_data->user_data);
 370
 371                 net_nfc_util_free_data(&data);
 372         }
 373
 374         g_free(func_data);
 375 }
 376
 377 static void llcp_call_receive_from(GObject *source_object, GAsyncResult *res,
 378                 gpointer user_data)
 379 {
 380         gboolean ret;
 381         sap_t sap = 0;
 382         GError *error = NULL;
 383         net_nfc_error_e result;
 384         GVariant *variant = NULL;
 385         LlcpFuncData *func_data = user_data;
 386
 387         g_assert(func_data != NULL);
 388
 389         ret = net_nfc_gdbus_llcp_call_receive_from_finish(NET_NFC_GDBUS_LLCP(source_object),
 390                         &result, &sap, &variant, res, &error);
 391         if (FALSE == ret)
 392         {
 393                 NFC_ERR("Can not finish receive from: %s", error->message);
 394                 g_error_free(error);
 395                 result = NET_NFC_IPC_FAIL;
 396         }
 397
 398         if (func_data->callback != NULL)
 399         {
 400                 data_s data = { NULL, 0 };
 401                 net_nfc_client_llcp_receive_from_completed callback =
 402                         (net_nfc_client_llcp_receive_from_completed)func_data->callback;
 403
 404                 net_nfc_util_gdbus_variant_to_data_s(variant, &data);
 405
 406                 callback(result, sap, &data, func_data->user_data);
 407
 408                 net_nfc_util_free_data(&data);
 409         }
 410
 411         g_free(func_data);
 412 }
 413
 414 static void llcp_call_close(GObject *source_object, GAsyncResult *res,
 415                 gpointer user_data)
 416 {
 417         gboolean ret;
 418         GError *error = NULL;
 419         net_nfc_error_e result;
 420         guint32 out_client_socket = -1;
 421         LlcpFuncData *func_data = user_data;
 422         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 423
 424         g_assert(func_data != NULL);
 425
 426         ret = net_nfc_gdbus_llcp_call_close_finish(NET_NFC_GDBUS_LLCP(source_object),
 427                         &result, &out_client_socket, res, &error);
 428         if (FALSE == ret)
 429         {
 430                 NFC_ERR("Can not finish close: %s", error->message);
 431                 g_error_free(error);
 432                 result = NET_NFC_IPC_FAIL;
 433         }
 434
 435         socket_data = llcp_socket_data_find(out_client_socket);
 436         if (socket_data == NULL)
 437         {
 438                 NFC_ERR("Wrong client socket is returned");
 439                 return;
 440         }
 441
 442         if (func_data->callback != NULL)
 443         {
 444                 net_nfc_client_llcp_close_completed callback =
 445                         (net_nfc_client_llcp_close_completed)func_data->callback;
 446
 447                 callback(result, func_data->user_data);
 448         }
 449
 450         g_free(func_data);
 451 }
 452
 453 static void llcp_call_disconnect(GObject *source_object,        GAsyncResult *res,
 454                 gpointer user_data)
 455 {
 456         gboolean ret;
 457         GError *error = NULL;
 458         net_nfc_error_e result;
 459         guint32 out_client_socket = -1;
 460         LlcpFuncData *func_data = user_data;
 461         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 462
 463         g_assert(func_data != NULL);
 464
 465         ret = net_nfc_gdbus_llcp_call_disconnect_finish(NET_NFC_GDBUS_LLCP(source_object),
 466                         &result, &out_client_socket, res, &error);
 467         if (FALSE == ret)
 468         {
 469                 NFC_ERR("Can not finish disconnect: %s", error->message);
 470                 g_error_free(error);
 471                 result = NET_NFC_IPC_FAIL;
 472         }
 473
 474         socket_data = llcp_socket_data_find(out_client_socket);
 475         if (socket_data == NULL)
 476         {
 477                 NFC_ERR("Wrong client socket is returned");
 478                 return;
 479         }
 480
 481         if (func_data->callback != NULL) {
 482                 net_nfc_client_llcp_disconnect_completed callback =
 483                         (net_nfc_client_llcp_disconnect_completed)func_data->callback;
 484
 485                 callback(result, func_data->user_data);
 486         }
 487
 488         g_free(func_data);
 489 }
 490
 491 API net_nfc_error_e net_nfc_client_llcp_get_config(
 492                 net_nfc_llcp_config_info_s **config)
 493 {
 494         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
 495
 496         *config = &llcp_config;
 497
 498         return NET_NFC_OK;
 499 }
 500
 501 API net_nfc_error_e net_nfc_client_llcp_listen(net_nfc_llcp_socket_t socket,
 502                 const char *service_name,
 503                 sap_t sap,
 504                 net_nfc_client_llcp_listen_completed callback,
 505                 void *user_data)
 506 {
 507         LlcpFuncData *func_data;
 508         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 509
 510         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
 511
 512         /* prevent executing daemon when nfc is off */
 513         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 514
 515         socket_data = llcp_socket_data_find(socket);
 516         if (socket_data == NULL)
 517         {
 518                 NFC_ERR("can not get socket_data");
 519                 return NET_NFC_LLCP_INVALID_SOCKET;
 520         }
 521
 522         /* FIXME: temporary typecast to (uint8_t *) */
 523         socket_data->service_name = (uint8_t *)g_strdup(service_name);
 524         socket_data->sap = sap;
 525
 526         func_data = g_new0(LlcpFuncData, 1);
 527         if (func_data == NULL) {
 528                 NFC_ERR("g_new0 failed");
 529
 530                 return NET_NFC_ALLOC_FAIL;
 531         }
 532
 533         func_data->callback = (gpointer)callback;
 534         func_data->user_data = user_data;
 535
 536         net_nfc_gdbus_llcp_call_listen(llcp_proxy,
 537                         GPOINTER_TO_UINT(llcp_handle),
 538                         socket_data->client_socket,
 539                         socket_data->miu,
 540                         socket_data->rw,
 541                         socket_data->type,
 542                         socket_data->sap,
 543                         service_name,
 544                         net_nfc_client_gdbus_get_privilege(),
 545                         NULL,
 546                         llcp_call_listen,
 547                         func_data);
 548
 549         return NET_NFC_OK;
 550 }
 551
 552 API net_nfc_error_e net_nfc_client_llcp_listen_sync(net_nfc_llcp_socket_t socket,
 553                 const char *service_name, sap_t sap, net_nfc_llcp_socket_t *out_socket)
 554 {
 555         gboolean ret;
 556         GError *error = NULL;
 557         net_nfc_error_e result;
 558         guint32 out_client_socket;
 559         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 560         net_nfc_llcp_internal_socket_s *out_socket_data = NULL;
 561
 562         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
 563         RETV_IF(NULL == out_socket, NET_NFC_NULL_PARAMETER);
 564         RETV_IF(NULL == service_name, NET_NFC_NULL_PARAMETER);
 565
 566         /* prevent executing daemon when nfc is off */
 567         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 568
 569         socket_data = llcp_socket_data_find(socket);
 570         if (socket_data == NULL)
 571         {
 572                 NFC_ERR("can not get socket_data");
 573                 return NET_NFC_LLCP_INVALID_SOCKET;
 574         }
 575
 576         /* FIXME: temporary typecast to (uint8_t *) */
 577         socket_data->service_name = (uint8_t *)g_strdup(service_name);
 578         socket_data->sap = sap;
 579
 580         ret = net_nfc_gdbus_llcp_call_listen_sync(llcp_proxy,
 581                         GPOINTER_TO_UINT(llcp_handle),
 582                         socket_data->client_socket,
 583                         socket_data->miu,
 584                         socket_data->rw,
 585                         socket_data->type,
 586                         socket_data->sap,
 587                         service_name,
 588                         net_nfc_client_gdbus_get_privilege(),
 589                         &result,
 590                         &out_client_socket,
 591                         NULL,
 592                         &error);
 593         if (TRUE == ret)
 594         {
 595                 out_socket_data = llcp_socket_data_find(out_client_socket);
 596                 if (out_socket_data == NULL || out_socket_data != socket_data)
 597                 {
 598                         NFC_ERR("out_socket_data(%p), socket_data(%p)", out_socket_data, socket_data);
 599                         return NET_NFC_UNKNOWN_ERROR;
 600                 }
 601
 602                 if (out_socket)
 603                         *out_socket = out_client_socket;
 604         }
 605         else
 606         {
 607                 NFC_ERR("can not listen: %s", error->message);
 608                 g_error_free(error);
 609                 result = NET_NFC_IPC_FAIL;
 610         }
 611
 612         return result;
 613 }
 614
 615 API net_nfc_error_e net_nfc_client_llcp_accept(net_nfc_llcp_socket_t socket,
 616                 net_nfc_client_llcp_accept_completed callback, void *user_data)
 617 {
 618         LlcpFuncData *func_data;
 619
 620         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
 621
 622         /* prevent executing daemon when nfc is off */
 623         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 624
 625         func_data = g_new0(LlcpFuncData, 1);
 626         if (func_data == NULL)
 627         {
 628                 NFC_ERR("g_new0 failed");
 629                 return NET_NFC_ALLOC_FAIL;
 630         }
 631
 632         func_data->callback = (gpointer)callback;
 633         func_data->user_data = user_data;
 634
 635         net_nfc_gdbus_llcp_call_accept(llcp_proxy,
 636                         GPOINTER_TO_UINT(llcp_handle),
 637                         socket,
 638                         net_nfc_client_gdbus_get_privilege(),
 639                         NULL,
 640                         llcp_call_accept,
 641                         func_data);
 642
 643         return NET_NFC_OK;
 644 }
 645
 646 API net_nfc_error_e net_nfc_client_llcp_accept_sync(net_nfc_llcp_socket_t socket)
 647 {
 648         gboolean ret;
 649         GError *error = NULL;
 650         net_nfc_error_e result;
 651
 652         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
 653
 654         /* prevent executing daemon when nfc is off */
 655         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 656
 657         ret = net_nfc_gdbus_llcp_call_accept_sync(llcp_proxy, GPOINTER_TO_UINT(llcp_handle),
 658                         socket, net_nfc_client_gdbus_get_privilege(), &result, NULL, &error);
 659         if (FALSE == ret)
 660         {
 661                 NFC_ERR("can not connect: %s", error->message);
 662                 g_error_free(error);
 663                 result = NET_NFC_IPC_FAIL;
 664         }
 665
 666         return result;
 667 }
 668
 669 API net_nfc_error_e net_nfc_client_llcp_reject(net_nfc_llcp_socket_t socket,
 670                 net_nfc_client_llcp_reject_completed callback, void *user_data)
 671 {
 672         LlcpFuncData *func_data;
 673
 674         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
 675
 676         /* prevent executing daemon when nfc is off */
 677         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 678
 679         func_data = g_new0(LlcpFuncData, 1);
 680         if (func_data == NULL)
 681         {
 682                 NFC_ERR("g_new0 failed");
 683                 return NET_NFC_ALLOC_FAIL;
 684         }
 685
 686         func_data->callback = (gpointer)callback;
 687         func_data->user_data = user_data;
 688
 689         net_nfc_gdbus_llcp_call_reject(llcp_proxy,
 690                         GPOINTER_TO_UINT(llcp_handle),
 691                         socket,
 692                         net_nfc_client_gdbus_get_privilege(),
 693                         NULL,
 694                         llcp_call_reject,
 695                         func_data);
 696
 697         return NET_NFC_OK;
 698 }
 699
 700 API net_nfc_error_e net_nfc_client_llcp_reject_sync(net_nfc_llcp_socket_t socket)
 701 {
 702         gboolean ret;
 703         GError *error = NULL;
 704         net_nfc_error_e result;
 705
 706         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
 707
 708         /* prevent executing daemon when nfc is off */
 709         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 710
 711         ret = net_nfc_gdbus_llcp_call_reject_sync(llcp_proxy, GPOINTER_TO_UINT(llcp_handle),
 712                         socket, net_nfc_client_gdbus_get_privilege(), &result, NULL, &error);
 713         if (FALSE == ret)
 714         {
 715                 NFC_ERR("can not connect: %s", error->message);
 716                 g_error_free(error);
 717                 result = NET_NFC_IPC_FAIL;
 718         }
 719
 720         return result;
 721 }
 722
 723 API net_nfc_error_e net_nfc_client_llcp_connect(net_nfc_llcp_socket_t socket,
 724                 const char *service_name,
 725                 net_nfc_client_llcp_connect_completed callback,
 726                 void *user_data)
 727 {
 728         LlcpFuncData *func_data;
 729         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 730
 731         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
 732         RETV_IF(NULL == service_name, NET_NFC_NULL_PARAMETER);
 733
 734         /* prevent executing daemon when nfc is off */
 735         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 736
 737         socket_data = llcp_socket_data_find(socket);
 738         if (socket_data == NULL)
 739         {
 740                 NFC_ERR("can not get socket_data");
 741                 return NET_NFC_LLCP_INVALID_SOCKET;
 742         }
 743
 744         func_data = g_new0(LlcpFuncData, 1);
 745         if (func_data == NULL)
 746         {
 747                 NFC_ERR("g_new0 failed");
 748
 749                 return NET_NFC_ALLOC_FAIL;
 750         }
 751
 752         func_data->callback = (gpointer)callback;
 753         func_data->user_data = user_data;
 754
 755         net_nfc_gdbus_llcp_call_connect(llcp_proxy,
 756                         GPOINTER_TO_UINT(llcp_handle),
 757                         socket_data->client_socket,
 758                         socket_data->miu,
 759                         socket_data->rw,
 760                         socket_data->type,
 761                         service_name,
 762                         net_nfc_client_gdbus_get_privilege(),
 763                         NULL,
 764                         llcp_call_connect,
 765                         func_data);
 766
 767         return NET_NFC_OK;
 768 }
 769
 770 API net_nfc_error_e net_nfc_client_llcp_connect_sync(net_nfc_llcp_socket_t socket,
 771                 const char *service_name, net_nfc_llcp_socket_t *out_socket)
 772 {
 773         gboolean ret;
 774         GError *error = NULL;
 775         net_nfc_error_e result;
 776         guint32 out_client_socket;
 777         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 778         net_nfc_llcp_internal_socket_s *out_socket_data = NULL;
 779
 780         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
 781         RETV_IF(NULL == service_name, NET_NFC_NULL_PARAMETER);
 782         RETV_IF(NULL == out_socket, NET_NFC_NULL_PARAMETER);
 783
 784         /* prevent executing daemon when nfc is off */
 785         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 786
 787         socket_data = llcp_socket_data_find(socket);
 788         if (socket_data == NULL)
 789         {
 790                 NFC_ERR("can not get socket_data");
 791                 return NET_NFC_LLCP_INVALID_SOCKET;
 792         }
 793
 794         ret = net_nfc_gdbus_llcp_call_connect_sync(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                         service_name,
 801                         net_nfc_client_gdbus_get_privilege(),
 802                         &result,
 803                         &out_client_socket,
 804                         NULL,
 805                         &error);
 806         if (TRUE == ret)
 807         {
 808                 out_socket_data = llcp_socket_data_find(out_client_socket);
 809                 if (out_socket_data == NULL || out_socket_data !=  socket_data)
 810                 {
 811                         NFC_ERR("out_socket_data(%p), socket_data(%p)", out_socket_data, socket_data);
 812                         return NET_NFC_UNKNOWN_ERROR;
 813                 }
 814
 815                 if (out_socket)
 816                         *out_socket = out_client_socket;
 817         }
 818         else
 819         {
 820                 NFC_ERR("can not connect: %s", error->message);
 821                 g_error_free(error);
 822                 result = NET_NFC_IPC_FAIL;
 823         }
 824
 825         return result;
 826 }
 827
 828 API net_nfc_error_e net_nfc_client_llcp_connect_sap(net_nfc_llcp_socket_t socket,
 829                 sap_t sap, net_nfc_client_llcp_connect_sap_completed callback, void *user_data)
 830 {
 831         LlcpFuncData *func_data;
 832         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 833
 834         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
 835         RETV_IF(0 == sap, NET_NFC_INVALID_PARAM);
 836
 837         /* prevent executing daemon when nfc is off */
 838         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 839
 840         socket_data = llcp_socket_data_find(socket);
 841         if (socket_data == NULL)
 842         {
 843                 NFC_ERR("can not get socket_data");
 844                 return NET_NFC_LLCP_INVALID_SOCKET;
 845         }
 846
 847         func_data = g_new0(LlcpFuncData, 1);
 848         if (func_data == NULL)
 849         {
 850                 NFC_ERR("g_new0 failed");
 851                 return NET_NFC_ALLOC_FAIL;
 852         }
 853
 854         func_data->callback = (gpointer)callback;
 855         func_data->user_data = user_data;
 856
 857         net_nfc_gdbus_llcp_call_connect_sap(llcp_proxy,
 858                         GPOINTER_TO_UINT(llcp_handle),
 859                         socket_data->client_socket,
 860                         socket_data->miu,
 861                         socket_data->rw,
 862                         socket_data->type,
 863                         sap,
 864                         net_nfc_client_gdbus_get_privilege(),
 865                         NULL,
 866                         llcp_call_connect_sap,
 867                         func_data);
 868
 869         return NET_NFC_OK;
 870 }
 871
 872 API net_nfc_error_e net_nfc_client_llcp_connect_sap_sync(
 873                 net_nfc_llcp_socket_t socket, sap_t sap, net_nfc_llcp_socket_t *out_socket)
 874 {
 875         gboolean ret;
 876         GError *error = NULL;
 877         net_nfc_error_e result;
 878         guint32 out_client_socket;
 879         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 880         net_nfc_llcp_internal_socket_s *out_socket_data = NULL;
 881
 882         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
 883         RETV_IF(NULL == out_socket, NET_NFC_NULL_PARAMETER);
 884         RETV_IF(0 == sap, NET_NFC_INVALID_PARAM);
 885
 886         /* prevent executing daemon when nfc is off */
 887         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 888
 889         socket_data = llcp_socket_data_find(socket);
 890         if (socket_data == NULL)
 891         {
 892                 NFC_ERR("can not get socket_data");
 893                 return NET_NFC_LLCP_INVALID_SOCKET;
 894         }
 895
 896         ret = net_nfc_gdbus_llcp_call_connect_sap_sync(llcp_proxy,
 897                         GPOINTER_TO_UINT(llcp_handle),
 898                         socket_data->client_socket,
 899                         socket_data->miu,
 900                         socket_data->rw,
 901                         socket_data->type,
 902                         sap,
 903                         net_nfc_client_gdbus_get_privilege(),
 904                         &result,
 905                         &out_client_socket,
 906                         NULL,
 907                         &error);
 908         if (TRUE == ret)
 909         {
 910                 out_socket_data = llcp_socket_data_find(out_client_socket);
 911                 if (out_socket_data == NULL || out_socket_data !=  socket_data)
 912                 {
 913                         NFC_ERR("out_socket_data(%p), socket_data(%p)", out_socket_data, socket_data);
 914                         return NET_NFC_UNKNOWN_ERROR;
 915                 }
 916
 917                 if (out_socket)
 918                         *out_socket = out_client_socket;
 919         }
 920         else
 921         {
 922                 NFC_ERR("can not connect: %s", error->message);
 923                 g_error_free(error);
 924                 result = NET_NFC_IPC_FAIL;
 925         }
 926
 927         return result;
 928 }
 929
 930 API net_nfc_error_e net_nfc_client_llcp_send(net_nfc_llcp_socket_t socket,
 931                 data_s *data, net_nfc_client_llcp_send_completed callback, void *user_data)
 932 {
 933         GVariant *variant;
 934         LlcpFuncData *func_data;
 935         net_nfc_llcp_internal_socket_s *socket_data = NULL;
 936
 937         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
 938         RETV_IF(NULL == data, NET_NFC_NULL_PARAMETER);
 939         RETV_IF(socket <= 0, NET_NFC_INVALID_PARAM);
 940
 941         /* prevent executing daemon when nfc is off */
 942         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 943
 944         socket_data = llcp_socket_data_find(socket);
 945         if (socket_data == NULL)
 946         {
 947                 NFC_ERR("can not get socket_data");
 948                 return NET_NFC_LLCP_INVALID_SOCKET;
 949         }
 950
 951         func_data = g_new0(LlcpFuncData, 1);
 952         if (func_data == NULL)
 953         {
 954                 NFC_ERR("g_new0 failed");
 955                 return NET_NFC_ALLOC_FAIL;
 956         }
 957
 958         func_data->callback = (gpointer)callback;
 959         func_data->user_data = user_data;
 960
 961         variant = net_nfc_util_gdbus_data_to_variant(data);
 962
 963         net_nfc_gdbus_llcp_call_send(llcp_proxy,
 964                         GPOINTER_TO_UINT(llcp_handle),
 965                         socket_data->client_socket,
 966                         variant,
 967                         net_nfc_client_gdbus_get_privilege(),
 968                         NULL,
 969                         llcp_call_send,
 970                         func_data);
 971
 972         return NET_NFC_OK;
 973 }
 974
 975 API net_nfc_error_e net_nfc_client_llcp_send_sync(net_nfc_llcp_socket_t socket,
 976                 data_s *data)
 977 {
 978         gboolean ret;
 979         GVariant *variant;
 980         GError *error = NULL;
 981         net_nfc_error_e result;
 982         guint32 out_client_socket;
 983         net_nfc_llcp_internal_socket_s *socket_data;
 984         net_nfc_llcp_internal_socket_s *out_socket_data;
 985
 986         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
 987         RETV_IF(NULL == data, NET_NFC_NULL_PARAMETER);
 988         RETV_IF(socket <= 0, NET_NFC_INVALID_PARAM);
 989
 990         /* prevent executing daemon when nfc is off */
 991         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 992
 993         socket_data = llcp_socket_data_find(socket);
 994         if (socket_data == NULL)
 995         {
 996                 NFC_ERR("can not get socket_data");
 997                 return NET_NFC_LLCP_INVALID_SOCKET;
 998         }
 999
1000         variant = net_nfc_util_gdbus_data_to_variant(data);
1001
1002         ret = net_nfc_gdbus_llcp_call_send_sync(llcp_proxy,
1003                         GPOINTER_TO_UINT(llcp_handle),
1004                         socket_data->client_socket,
1005                         variant,
1006                         net_nfc_client_gdbus_get_privilege(),
1007                         &result,
1008                         &out_client_socket,
1009                         NULL,
1010                         &error);
1011         if (TRUE == ret)
1012         {
1013                 out_socket_data = llcp_socket_data_find(out_client_socket);
1014                 if (out_socket_data == NULL)
1015                 {
1016                         NFC_ERR("out_socket_data is NULL");
1017                         return NET_NFC_UNKNOWN_ERROR;
1018                 }
1019         }
1020         else
1021         {
1022                 NFC_ERR("can not call send: %s", error->message);
1023                 g_error_free(error);
1024                 result = NET_NFC_IPC_FAIL;
1025         }
1026
1027         return result;
1028 }
1029
1030 API net_nfc_error_e net_nfc_client_llcp_send_to(net_nfc_llcp_socket_t socket,
1031                 sap_t sap,
1032                 data_s *data,
1033                 net_nfc_client_llcp_send_to_completed callback,
1034                 void *user_data)
1035 {
1036         GVariant *variant;
1037         LlcpFuncData *func_data;
1038         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1039
1040         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
1041         RETV_IF(NULL == data, NET_NFC_NULL_PARAMETER);
1042         RETV_IF(0 == sap, NET_NFC_INVALID_PARAM);
1043         RETV_IF(socket <= 0, NET_NFC_INVALID_PARAM);
1044
1045         /* prevent executing daemon when nfc is off */
1046         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
1047
1048         socket_data = llcp_socket_data_find(socket);
1049         if (socket_data == NULL)
1050         {
1051                 NFC_ERR("can not get socket_data");
1052                 return NET_NFC_LLCP_INVALID_SOCKET;
1053         }
1054
1055         func_data = g_new0(LlcpFuncData, 1);
1056         if (func_data == NULL)
1057         {
1058                 NFC_ERR("g_new0 failed");
1059                 return NET_NFC_ALLOC_FAIL;
1060         }
1061
1062         func_data->callback = (gpointer)callback;
1063         func_data->user_data = user_data;
1064
1065         variant = net_nfc_util_gdbus_data_to_variant(data);
1066
1067         net_nfc_gdbus_llcp_call_send_to(llcp_proxy,
1068                         GPOINTER_TO_UINT(llcp_handle),
1069                         socket_data->client_socket,
1070                         sap,
1071                         variant,
1072                         net_nfc_client_gdbus_get_privilege(),
1073                         NULL,
1074                         llcp_call_send_to,
1075                         func_data);
1076
1077         return NET_NFC_OK;
1078 }
1079
1080 API net_nfc_error_e net_nfc_client_llcp_send_to_sync(net_nfc_llcp_socket_t socket,
1081                 sap_t sap, data_s *data)
1082 {
1083         gboolean ret;
1084         GVariant *variant;
1085         GError *error = NULL;
1086         net_nfc_error_e result;
1087         guint32 out_client_socket;
1088         net_nfc_llcp_internal_socket_s *socket_data;
1089         net_nfc_llcp_internal_socket_s *out_socket_data;
1090
1091         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
1092         RETV_IF(NULL == data, NET_NFC_NULL_PARAMETER);
1093         RETV_IF(0 == sap, NET_NFC_INVALID_PARAM);
1094         RETV_IF(socket <= 0, NET_NFC_INVALID_PARAM);
1095
1096         /* prevent executing daemon when nfc is off */
1097         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
1098
1099         socket_data = llcp_socket_data_find(socket);
1100         if (socket_data == NULL)
1101         {
1102                 NFC_ERR("can not get socket_data");
1103                 return NET_NFC_LLCP_INVALID_SOCKET;
1104         }
1105
1106         variant = net_nfc_util_gdbus_data_to_variant(data);
1107
1108         ret = net_nfc_gdbus_llcp_call_send_to_sync(llcp_proxy,
1109                         GPOINTER_TO_UINT(llcp_handle),
1110                         socket_data->client_socket,
1111                         sap,
1112                         variant,
1113                         net_nfc_client_gdbus_get_privilege(),
1114                         &result,
1115                         &out_client_socket,
1116                         NULL,
1117                         &error);
1118         if (TRUE == ret)
1119         {
1120                 out_socket_data = llcp_socket_data_find(out_client_socket);
1121                 if (out_socket_data == NULL)
1122                 {
1123                         NFC_ERR("out_socket_data is NULL");
1124                         return NET_NFC_UNKNOWN_ERROR;
1125                 }
1126         }
1127         else
1128         {
1129                 NFC_ERR("can not call send to: %s", error->message);
1130                 g_error_free(error);
1131                 result = NET_NFC_IPC_FAIL;
1132         }
1133
1134         return result;
1135 }
1136
1137 API net_nfc_error_e net_nfc_client_llcp_receive(net_nfc_llcp_socket_t socket,
1138                 size_t request_length,
1139                 net_nfc_client_llcp_receive_completed callback,
1140                 void *user_data)
1141 {
1142         LlcpFuncData *func_data;
1143         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1144
1145         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
1146         RETV_IF(0 == request_length, NET_NFC_INVALID_PARAM);
1147         RETV_IF(socket <= 0, NET_NFC_INVALID_PARAM);
1148
1149         /* prevent executing daemon when nfc is off */
1150         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
1151
1152         socket_data = llcp_socket_data_find(socket);
1153         if (socket_data == NULL)
1154         {
1155                 NFC_ERR("can not get socket_data");
1156                 return NET_NFC_LLCP_INVALID_SOCKET;
1157         }
1158
1159         func_data = g_new0(LlcpFuncData, 1);
1160         if (func_data == NULL)
1161         {
1162                 NFC_ERR("g_new0 failed");
1163                 return NET_NFC_ALLOC_FAIL;
1164         }
1165
1166         func_data->callback = (gpointer)callback;
1167         func_data->user_data = user_data;
1168
1169         net_nfc_gdbus_llcp_call_receive(llcp_proxy,
1170                         GPOINTER_TO_UINT(llcp_handle),
1171                         socket_data->client_socket,
1172                         request_length,
1173                         net_nfc_client_gdbus_get_privilege(),
1174                         NULL,
1175                         llcp_call_receive,
1176                         func_data);
1177
1178         return NET_NFC_OK;
1179 }
1180
1181 API net_nfc_error_e net_nfc_client_llcp_receive_sync(net_nfc_llcp_socket_t socket,
1182                 size_t request_length, data_s **out_data)
1183 {
1184         gboolean ret;
1185         GVariant *variant;
1186         GError *error = NULL;
1187         net_nfc_error_e result;
1188         net_nfc_llcp_internal_socket_s *socket_data;
1189
1190         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
1191         RETV_IF(NULL == out_data, NET_NFC_NULL_PARAMETER);
1192         RETV_IF(0 == request_length, NET_NFC_INVALID_PARAM);
1193         RETV_IF(socket <= 0, NET_NFC_INVALID_PARAM);
1194
1195         /* prevent executing daemon when nfc is off */
1196         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
1197
1198         *out_data = NULL;
1199
1200         socket_data = llcp_socket_data_find(socket);
1201         if (socket_data == NULL)
1202         {
1203                 NFC_ERR("can not get socket_data");
1204                 return NET_NFC_LLCP_INVALID_SOCKET;
1205         }
1206
1207         ret = net_nfc_gdbus_llcp_call_receive_sync(llcp_proxy,
1208                         GPOINTER_TO_UINT(llcp_handle),
1209                         socket_data->client_socket,
1210                         request_length,
1211                         net_nfc_client_gdbus_get_privilege(),
1212                         &result,
1213                         &variant,
1214                         NULL,
1215                         &error);
1216         if (TRUE == ret)
1217         {
1218                 *out_data = net_nfc_util_gdbus_variant_to_data(variant);
1219         }
1220         else
1221         {
1222                 NFC_ERR("can not call receive: %s", error->message);
1223                 g_error_free(error);
1224                 result = NET_NFC_IPC_FAIL;
1225         }
1226
1227         return result;
1228 }
1229
1230 API net_nfc_error_e net_nfc_client_llcp_receive_from(net_nfc_llcp_socket_t socket,
1231                 size_t request_length,
1232                 net_nfc_client_llcp_receive_from_completed callback,
1233                 void *user_data)
1234 {
1235         LlcpFuncData *func_data;
1236         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1237
1238         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
1239         RETV_IF(0 == request_length, NET_NFC_INVALID_PARAM);
1240         RETV_IF(socket <= 0, NET_NFC_INVALID_PARAM);
1241
1242         socket_data = llcp_socket_data_find(socket);
1243         if (socket_data == NULL)
1244         {
1245                 NFC_ERR("can not get socket_data");
1246                 return NET_NFC_LLCP_INVALID_SOCKET;
1247         }
1248
1249         func_data = g_new0(LlcpFuncData, 1);
1250         if (func_data == NULL)
1251         {
1252                 NFC_ERR("g_new0 failed");
1253                 return NET_NFC_ALLOC_FAIL;
1254         }
1255
1256         func_data->callback = (gpointer)callback;
1257         func_data->user_data = user_data;
1258
1259         net_nfc_gdbus_llcp_call_receive_from(llcp_proxy,
1260                         GPOINTER_TO_UINT(llcp_handle),
1261                         socket_data->client_socket,
1262                         request_length,
1263                         net_nfc_client_gdbus_get_privilege(),
1264                         NULL,
1265                         llcp_call_receive_from,
1266                         func_data);
1267
1268         return NET_NFC_OK;
1269 }
1270
1271 API net_nfc_error_e net_nfc_client_llcp_receive_from_sync(
1272                 net_nfc_llcp_socket_t socket,
1273                 size_t request_length,
1274                 sap_t *out_sap,
1275                 data_s **out_data)
1276 {
1277         sap_t sap;
1278         gboolean ret;
1279         GVariant *variant;
1280         GError *error = NULL;
1281         net_nfc_error_e result;
1282         net_nfc_llcp_internal_socket_s *socket_data;
1283
1284         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
1285         RETV_IF(NULL == out_sap, NET_NFC_NULL_PARAMETER);
1286         RETV_IF(NULL == out_data, NET_NFC_NULL_PARAMETER);
1287         RETV_IF(0 == request_length, NET_NFC_INVALID_PARAM);
1288         RETV_IF(socket <= 0, NET_NFC_INVALID_PARAM);
1289
1290         /* prevent executing daemon when nfc is off */
1291         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
1292
1293         *out_data = NULL;
1294         *out_sap = 0;
1295
1296         socket_data = llcp_socket_data_find(socket);
1297         if (socket_data == NULL)
1298         {
1299                 NFC_ERR("can not get socket_data");
1300                 return NET_NFC_LLCP_INVALID_SOCKET;
1301         }
1302
1303         ret = net_nfc_gdbus_llcp_call_receive_from_sync(llcp_proxy,
1304                         GPOINTER_TO_UINT(llcp_handle),
1305                         socket_data->client_socket,
1306                         request_length,
1307                         net_nfc_client_gdbus_get_privilege(),
1308                         &result,
1309                         &sap,
1310                         &variant,
1311                         NULL,
1312                         &error);
1313         if (TRUE == ret)
1314         {
1315                 *out_sap = sap;
1316                 *out_data = net_nfc_util_gdbus_variant_to_data(variant);
1317         }
1318         else
1319         {
1320                 NFC_ERR("can not call receive from: %s", error->message);
1321                 g_error_free(error);
1322                 result = NET_NFC_IPC_FAIL;
1323         }
1324
1325         return result;
1326 }
1327
1328 API net_nfc_error_e net_nfc_client_llcp_close(net_nfc_llcp_socket_t socket,
1329                 net_nfc_client_llcp_close_completed callback, void *user_data)
1330 {
1331         LlcpFuncData *func_data;
1332         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1333
1334         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
1335         RETV_IF(socket <= 0, NET_NFC_INVALID_PARAM);
1336
1337         /* prevent executing daemon when nfc is off */
1338         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
1339
1340         socket_data = llcp_socket_data_find(socket);
1341         if (socket_data == NULL)
1342         {
1343                 NFC_ERR("can not get socket_data");
1344                 return NET_NFC_LLCP_INVALID_SOCKET;
1345         }
1346
1347         func_data = g_new0(LlcpFuncData, 1);
1348         if (func_data == NULL)
1349         {
1350                 NFC_ERR("g_new0 failed");
1351                 return NET_NFC_ALLOC_FAIL;
1352         }
1353
1354         func_data->callback = (gpointer)callback;
1355         func_data->user_data = user_data;
1356
1357         net_nfc_gdbus_llcp_call_close(llcp_proxy,
1358                         GPOINTER_TO_UINT(llcp_handle),
1359                         socket_data->client_socket,
1360                         net_nfc_client_gdbus_get_privilege(),
1361                         NULL,
1362                         llcp_call_close,
1363                         func_data);
1364
1365         return NET_NFC_OK;
1366 }
1367
1368 API net_nfc_error_e net_nfc_client_llcp_close_sync(net_nfc_llcp_socket_t socket)
1369 {
1370         gboolean ret;
1371         GError *error = NULL;
1372         net_nfc_error_e result;
1373         guint32 out_client_socket;
1374         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1375         net_nfc_llcp_internal_socket_s *out_socket_data = NULL;
1376
1377         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
1378         RETV_IF(socket <= 0, NET_NFC_INVALID_PARAM);
1379
1380         /* prevent executing daemon when nfc is off */
1381         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
1382
1383         socket_data = llcp_socket_data_find(socket);
1384         if (socket_data == NULL)
1385         {
1386                 NFC_ERR("can not get socket_data");
1387                 return NET_NFC_LLCP_INVALID_SOCKET;
1388         }
1389
1390         ret = net_nfc_gdbus_llcp_call_close_sync(llcp_proxy,
1391                         GPOINTER_TO_UINT(llcp_handle),
1392                         socket_data->client_socket,
1393                         net_nfc_client_gdbus_get_privilege(),
1394                         &result,
1395                         &out_client_socket,
1396                         NULL,
1397                         &error);
1398         if (TRUE == ret)
1399         {
1400                 out_socket_data = llcp_socket_data_find(out_client_socket);
1401                 if (out_socket_data == NULL || out_socket_data !=  socket_data)
1402                 {
1403                         NFC_ERR("out_socket_data(%p), socket_data(%p)", out_socket_data, socket_data);
1404                         return NET_NFC_UNKNOWN_ERROR;
1405                 }
1406         }
1407         else
1408         {
1409                 NFC_ERR("can not close: %s", error->message);
1410                 g_error_free(error);
1411                 result = NET_NFC_IPC_FAIL;
1412         }
1413
1414         return result;
1415 }
1416
1417 API net_nfc_error_e net_nfc_client_llcp_disconnect(net_nfc_llcp_socket_t socket,
1418                 net_nfc_client_llcp_disconnect_completed callback, void *user_data)
1419 {
1420         LlcpFuncData *func_data;
1421         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1422
1423         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
1424         RETV_IF(socket <= 0, NET_NFC_INVALID_PARAM);
1425
1426         /* prevent executing daemon when nfc is off */
1427         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
1428
1429         socket_data = llcp_socket_data_find(socket);
1430         if (socket_data == NULL)
1431         {
1432                 NFC_ERR("can not get socket_data");
1433                 return NET_NFC_LLCP_INVALID_SOCKET;
1434         }
1435
1436         func_data = g_new0(LlcpFuncData, 1);
1437         if (func_data == NULL)
1438         {
1439                 NFC_ERR("g_new0 failed");
1440                 return NET_NFC_ALLOC_FAIL;
1441         }
1442
1443         func_data->callback = (gpointer)callback;
1444         func_data->user_data = user_data;
1445
1446         net_nfc_gdbus_llcp_call_disconnect(llcp_proxy,
1447                         GPOINTER_TO_UINT(llcp_handle),
1448                         socket_data->client_socket,
1449                         net_nfc_client_gdbus_get_privilege(),
1450                         NULL,
1451                         llcp_call_disconnect,
1452                         func_data);
1453
1454         return NET_NFC_OK;
1455 }
1456
1457 API net_nfc_error_e net_nfc_client_llcp_disconnect_sync(
1458                 net_nfc_llcp_socket_t socket)
1459 {
1460         gboolean ret;
1461         GError *error = NULL;
1462         net_nfc_error_e result;
1463         guint32 out_client_socket;
1464         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1465         net_nfc_llcp_internal_socket_s *out_socket_data = NULL;
1466
1467         RETV_IF(NULL == llcp_proxy, NET_NFC_NOT_INITIALIZED);
1468         RETV_IF(socket <= 0, NET_NFC_INVALID_PARAM);
1469
1470         /* prevent executing daemon when nfc is off */
1471         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
1472
1473         socket_data = llcp_socket_data_find(socket);
1474         if (socket_data == NULL)
1475         {
1476                 NFC_ERR("can not get socket_data");
1477                 return NET_NFC_LLCP_INVALID_SOCKET;
1478         }
1479
1480         ret = net_nfc_gdbus_llcp_call_disconnect_sync(llcp_proxy,
1481                         GPOINTER_TO_UINT(llcp_handle),
1482                         socket_data->client_socket,
1483                         net_nfc_client_gdbus_get_privilege(),
1484                         &result,
1485                         &out_client_socket,
1486                         NULL,
1487                         &error);
1488         if (TRUE == ret)
1489         {
1490                 out_socket_data = llcp_socket_data_find(out_client_socket);
1491                 if (out_socket_data == NULL || out_socket_data !=  socket_data)
1492                 {
1493                         NFC_ERR("out_socket_data(%p), socket_data(%p)", out_socket_data, socket_data);
1494                         return NET_NFC_UNKNOWN_ERROR;
1495                 }
1496         }
1497         else
1498         {
1499                 NFC_ERR("can not disconnect: %s", error->message);
1500                 g_error_free(error);
1501                 result = NET_NFC_IPC_FAIL;
1502         }
1503
1504         return result;
1505 }
1506
1507 API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
1508                 net_nfc_llcp_socket_option_s *option)
1509 {
1510         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1511
1512         socket_data = g_new0(net_nfc_llcp_internal_socket_s, 1);
1513
1514         socket_data->client_socket = socket_handle++;
1515
1516         if (option)
1517         {
1518                 socket_data->miu = option->miu;
1519                 socket_data->rw = option->rw;
1520                 socket_data->type = option->type;
1521         }
1522         else
1523         {
1524                 socket_data->miu = 128;
1525                 socket_data->rw = 1;
1526                 socket_data->type = NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONORIENTED;
1527         }
1528
1529         socket_data->device_id = llcp_handle;
1530         socket_data->close_requested = false;
1531
1532
1533         if (socket)
1534                 *socket = socket_data->client_socket;
1535 }
1536
1537
1538 API net_nfc_error_e net_nfc_client_llcp_get_local_config(
1539                 net_nfc_llcp_config_info_s **config)
1540 {
1541         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
1542
1543         *config = &llcp_config;
1544
1545         return NET_NFC_OK;
1546 }
1547
1548 API net_nfc_error_e net_nfc_client_llcp_get_local_socket_option(
1549                 net_nfc_llcp_socket_t socket, net_nfc_llcp_socket_option_s **info)
1550 {
1551         net_nfc_llcp_internal_socket_s *socket_data = NULL;
1552
1553         socket_data = llcp_socket_data_find(socket);
1554         if (socket_data == NULL)
1555                 return NET_NFC_LLCP_INVALID_SOCKET;
1556
1557         *info = (net_nfc_llcp_socket_option_s*)socket_data;
1558
1559         return NET_NFC_OK;
1560 }
1561
1562 API net_nfc_error_e net_nfc_client_llcp_create_socket_option(
1563                 net_nfc_llcp_socket_option_s **option,
1564                 uint16_t miu,
1565                 uint8_t rw,
1566                 net_nfc_socket_type_e type)
1567 {
1568         net_nfc_llcp_socket_option_s *tmp_option = NULL;
1569
1570         RETV_IF(NULL == option, NET_NFC_NULL_PARAMETER);
1571         RETVM_IF(miu < 128 || miu > 1152, NET_NFC_OUT_OF_BOUND, "miu = %d", miu);
1572         RETVM_IF(rw < 1 || rw > 15, NET_NFC_OUT_OF_BOUND, "rw = %d", rw);
1573         RETVM_IF((type < NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONORIENTED
1574                                 || type > NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONLESS),
1575                         NET_NFC_OUT_OF_BOUND,
1576                         "type = %d", type);
1577
1578         _net_nfc_util_alloc_mem(tmp_option, sizeof(net_nfc_llcp_socket_option_s));
1579         if (tmp_option != NULL)
1580         {
1581                 tmp_option->miu = miu;
1582                 tmp_option->rw = rw;
1583                 tmp_option->type = type;
1584
1585                 *option = tmp_option;
1586
1587                 return NET_NFC_OK;
1588         }
1589         else
1590         {
1591                 return NET_NFC_ALLOC_FAIL;
1592         }
1593 }
1594
1595 API net_nfc_error_e net_nfc_client_llcp_create_socket_option_default(
1596                 net_nfc_llcp_socket_option_s **option)
1597 {
1598         return net_nfc_client_llcp_create_socket_option(option, 128, 1,
1599                         NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONORIENTED);
1600 }
1601
1602 API net_nfc_error_e net_nfc_client_llcp_get_socket_option_miu(
1603                 net_nfc_llcp_socket_option_s *option, uint16_t *miu)
1604 {
1605         RETV_IF(NULL == option, NET_NFC_NULL_PARAMETER);
1606         RETV_IF(NULL == miu, NET_NFC_NULL_PARAMETER);
1607
1608         *miu = option->miu;
1609         return NET_NFC_OK;
1610 }
1611
1612 API net_nfc_error_e net_nfc_client_llcp_set_socket_option_miu(
1613                 net_nfc_llcp_socket_option_s *option, uint16_t miu)
1614 {
1615         RETV_IF(NULL == option, NET_NFC_NULL_PARAMETER);
1616
1617         option->miu = miu;
1618         return NET_NFC_OK;
1619 }
1620
1621 API net_nfc_error_e net_nfc_client_llcp_get_socket_option_rw(
1622                 net_nfc_llcp_socket_option_s *option, uint8_t *rw)
1623 {
1624         RETV_IF(NULL == option, NET_NFC_NULL_PARAMETER);
1625         RETV_IF(NULL == rw, NET_NFC_NULL_PARAMETER);
1626
1627         *rw = option->rw;
1628         return NET_NFC_OK;
1629 }
1630
1631 API net_nfc_error_e net_nfc_client_llcp_set_socket_option_rw(
1632                 net_nfc_llcp_socket_option_s *option, uint8_t rw)
1633 {
1634         RETV_IF(NULL == option, NET_NFC_NULL_PARAMETER);
1635
1636         option->rw = rw;
1637         return NET_NFC_OK;
1638 }
1639
1640 API net_nfc_error_e net_nfc_client_llcp_get_socket_option_type(
1641                 net_nfc_llcp_socket_option_s *option, net_nfc_socket_type_e *type)
1642 {
1643         RETV_IF(NULL == type, NET_NFC_NULL_PARAMETER);
1644
1645         *type = option->type;
1646         return NET_NFC_OK;
1647 }
1648
1649 API net_nfc_error_e net_nfc_client_llcp_set_socket_option_type(
1650                 net_nfc_llcp_socket_option_s *option, net_nfc_socket_type_e type)
1651 {
1652         RETV_IF(NULL == option, NET_NFC_NULL_PARAMETER);
1653
1654         option->type = type;
1655         return NET_NFC_OK;
1656 }
1657
1658 API net_nfc_error_e net_nfc_client_llcp_free_socket_option(
1659                 net_nfc_llcp_socket_option_s *option)
1660 {
1661         RETV_IF(NULL == option, NET_NFC_NULL_PARAMETER);
1662
1663         _net_nfc_util_free_mem(option);
1664         return NET_NFC_OK;
1665 }
1666
1667 API net_nfc_error_e net_nfc_client_llcp_create_config(
1668                 net_nfc_llcp_config_info_s **config,
1669                 uint16_t miu,
1670                 uint16_t wks,
1671                 uint8_t lto,
1672                 uint8_t option)
1673 {
1674         net_nfc_llcp_config_info_s *tmp_config;
1675
1676         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
1677
1678         _net_nfc_util_alloc_mem(tmp_config, sizeof(net_nfc_llcp_config_info_s));
1679         if (tmp_config == NULL)
1680                 return NET_NFC_ALLOC_FAIL;
1681
1682         tmp_config->miu = miu;
1683         tmp_config->wks = wks;
1684         tmp_config->lto = lto;
1685         tmp_config->option = option;
1686
1687         *config = tmp_config;
1688
1689         return NET_NFC_OK;
1690 }
1691
1692 API net_nfc_error_e net_nfc_client_llcp_create_config_default(
1693                 net_nfc_llcp_config_info_s **config)
1694 {
1695         return net_nfc_client_llcp_create_config(config, 128, 1, 10, 0);
1696 }
1697
1698 API net_nfc_error_e net_nfc_client_llcp_get_config_miu(
1699                 net_nfc_llcp_config_info_s *config, uint16_t *miu)
1700 {
1701         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
1702         RETV_IF(NULL == miu, NET_NFC_NULL_PARAMETER);
1703
1704         *miu = config->miu;
1705         return NET_NFC_OK;
1706 }
1707
1708 API net_nfc_error_e net_nfc_client_llcp_get_config_wks(
1709                 net_nfc_llcp_config_info_s *config, uint16_t *wks)
1710 {
1711         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
1712         RETV_IF(NULL == wks, NET_NFC_NULL_PARAMETER);
1713
1714         *wks = config->wks;
1715         return NET_NFC_OK;
1716 }
1717
1718 API net_nfc_error_e net_nfc_client_llcp_get_config_lto(
1719                 net_nfc_llcp_config_info_s *config, uint8_t *lto)
1720 {
1721         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
1722         RETV_IF(NULL == lto, NET_NFC_NULL_PARAMETER);
1723
1724         *lto = config->lto;
1725         return NET_NFC_OK;
1726 }
1727
1728 API net_nfc_error_e net_nfc_client_llcp_get_config_option(
1729                 net_nfc_llcp_config_info_s *config, uint8_t *option)
1730 {
1731         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
1732         RETV_IF(NULL == option, NET_NFC_NULL_PARAMETER);
1733
1734         *option = config->option;
1735         return NET_NFC_OK;
1736 }
1737
1738 API net_nfc_error_e net_nfc_client_llcp_set_config_miu(
1739                 net_nfc_llcp_config_info_s *config, uint16_t miu)
1740 {
1741         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
1742         RETVM_IF(miu < 128 || miu > 1152, NET_NFC_OUT_OF_BOUND, "miu = %d", miu);
1743
1744         config->miu = miu;
1745         return NET_NFC_OK;
1746 }
1747
1748 API net_nfc_error_e net_nfc_client_llcp_set_config_wks(
1749                 net_nfc_llcp_config_info_s *config, uint16_t wks)
1750 {
1751         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
1752
1753         config->wks = wks;
1754         return NET_NFC_OK;
1755 }
1756
1757 API net_nfc_error_e net_nfc_client_llcp_set_config_lto(
1758                 net_nfc_llcp_config_info_s *config, uint8_t lto)
1759 {
1760         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
1761
1762         config->lto = lto;
1763         return NET_NFC_OK;
1764 }
1765
1766 API net_nfc_error_e net_nfc_client_llcp_set_config_option(
1767                 net_nfc_llcp_config_info_s *config, uint8_t option)
1768 {
1769         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
1770
1771         config->option = option;
1772         return NET_NFC_OK;
1773 }
1774
1775 API net_nfc_error_e net_nfc_client_llcp_free_config(
1776                 net_nfc_llcp_config_info_s *config)
1777 {
1778         RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
1779
1780         _net_nfc_util_free_mem(config);
1781         return NET_NFC_OK;
1782 }
1783
1784 net_nfc_error_e net_nfc_client_llcp_init(void)
1785 {
1786         GError *error = NULL;
1787
1788         if (llcp_proxy)
1789         {
1790                 NFC_WARN("Already initialized");
1791                 return NET_NFC_OK;
1792         }
1793
1794         llcp_proxy = net_nfc_gdbus_llcp_proxy_new_for_bus_sync(
1795                         G_BUS_TYPE_SYSTEM,
1796                         G_DBUS_PROXY_FLAGS_NONE,
1797                         "org.tizen.NetNfcService",
1798                         "/org/tizen/NetNfcService/Llcp",
1799                         NULL,
1800                         &error);
1801
1802         if (llcp_proxy == NULL)
1803         {
1804                 NFC_ERR("Can not create proxy : %s", error->message);
1805                 g_error_free(error);
1806                 return NET_NFC_UNKNOWN_ERROR;
1807         }
1808
1809         g_signal_connect(llcp_proxy, "error",
1810                         G_CALLBACK(llcp_error), NULL);
1811
1812         g_signal_connect(llcp_proxy, "incoming",
1813                         G_CALLBACK(llcp_incoming), NULL);
1814
1815         return NET_NFC_OK;
1816 }
1817
1818 void net_nfc_client_llcp_deinit(void)
1819 {
1820         if (llcp_proxy)
1821         {
1822                 g_object_unref(llcp_proxy);
1823                 llcp_proxy = NULL;
1824         }
1825 }