daemon/net_nfc_server_controller.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 #define _GNU_SOURCE
  17 #include <linux/limits.h>
  18 #include <stdio.h>
  19 #include <dlfcn.h>
  20 #include <unistd.h>
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <dirent.h>
  24 #include <string.h>
  25 #include <errno.h>
  26
  27 #include <dd-display.h>/*for pm lock*/
  28
  29 #include "net_nfc_oem_controller.h"
  30 #include "net_nfc_server_controller.h"
  31 #include "net_nfc_util_internal.h"
  32 #include "net_nfc_debug_internal.h"
  33 #include "net_nfc_server_tag.h"
  34
  35 #define NET_NFC_DEFAULT_PLUGIN  "libnfc-plugin.so"
  36
  37 static net_nfc_oem_interface_s g_interface;
  38
  39 static void *net_nfc_controller_load_file(const char *dir_path, const char *filename)
  40 {
  41         struct stat st;
  42         void *handle = NULL;
  43         net_nfc_error_e result;
  44         char path[PATH_MAX] = { '\0' };
  45
  46         bool (*onload)(net_nfc_oem_interface_s *interfaces);
  47
  48         snprintf(path, PATH_MAX, "%s/%s", dir_path, filename);
  49         NFC_DBG("path : %s", path);
  50
  51         if (stat(path, &st) == -1)
  52         {
  53                 NFC_ERR("stat failed : file not found");
  54                 goto ERROR;
  55         }
  56
  57         if (S_ISREG(st.st_mode) == 0)
  58         {
  59                 NFC_ERR("S_ISREG(st.st_mode) == 0");
  60                 goto ERROR;
  61         }
  62
  63         handle = dlopen(path, RTLD_LAZY);
  64         if (NULL == handle)
  65         {
  66                 char buffer[1024];
  67                 NFC_ERR("dlopen failed, [%d] : %s",
  68                                 errno, strerror_r(errno, buffer, sizeof(buffer)));
  69                 goto ERROR;
  70         }
  71
  72         onload = dlsym(handle, "onload");
  73         if (NULL == onload)
  74         {
  75                 char buffer[1024];
  76                 NFC_ERR("dlsym failed, [%d] : %s",
  77                                 errno, strerror_r(errno, buffer, sizeof(buffer)));
  78                 goto ERROR;
  79         }
  80
  81         memset(&g_interface, 0, sizeof(g_interface));
  82         if (onload(&g_interface) == false)
  83         {
  84                 NFC_ERR("onload failed");
  85                 goto ERROR;
  86         }
  87
  88         if (net_nfc_controller_support_nfc(&result) == false)
  89         {
  90                 NFC_ERR("net_nfc_controller_support_nfc failed, [%d]", result);
  91                 goto ERROR;
  92         }
  93
  94         return handle;
  95
  96 ERROR :
  97         if (handle != NULL)
  98                 dlclose(handle);
  99
 100         return NULL;
 101 }
 102
 103 void *net_nfc_controller_onload()
 104 {
 105         DIR *dirp;
 106         struct dirent *dir;
 107
 108         void *handle = NULL;
 109
 110         dirp = opendir(NFC_MANAGER_MODULEDIR);
 111         if (NULL == dirp)
 112         {
 113                 NFC_ERR("Can not open directory %s", NFC_MANAGER_MODULEDIR);
 114                 return NULL;
 115         }
 116
 117         while ((dir = readdir(dirp)))
 118         {
 119                 if ((strcmp(dir->d_name, ".") == 0) || (strcmp(dir->d_name, "..") == 0))
 120                         continue;
 121
 122                 /* check ".so" suffix */
 123                 if (strcmp(dir->d_name + (strlen(dir->d_name) - strlen(".so")), ".so") != 0)
 124                         continue;
 125
 126                 /* check default plugin later */
 127                 if (strcmp(dir->d_name, NET_NFC_DEFAULT_PLUGIN) == 0)
 128                         continue;
 129
 130                 handle = net_nfc_controller_load_file(NFC_MANAGER_MODULEDIR, dir->d_name);
 131                 if (handle)
 132                 {
 133                         SECURE_LOGD("Successfully loaded : %s", dir->d_name);
 134                         closedir(dirp);
 135                         return handle;
 136                 }
 137         }
 138
 139         closedir(dirp);
 140
 141         /* load default plugin */
 142         handle = net_nfc_controller_load_file(NFC_MANAGER_MODULEDIR, NET_NFC_DEFAULT_PLUGIN);
 143
 144         if (handle)
 145         {
 146                 NFC_DBG("loaded default plugin : %s", NET_NFC_DEFAULT_PLUGIN);
 147                 return handle;
 148         }
 149         else
 150         {
 151                 NFC_ERR("can not load default plugin : %s", NET_NFC_DEFAULT_PLUGIN);
 152                 return NULL;
 153         }
 154 }
 155
 156 bool net_nfc_controller_unload(void *handle)
 157 {
 158         memset(&g_interface, 0x00, sizeof(net_nfc_oem_interface_s));
 159
 160         if (handle != NULL)
 161         {
 162                 dlclose(handle);
 163                 handle = NULL;
 164         }
 165         return true;
 166 }
 167
 168 bool net_nfc_controller_init(net_nfc_error_e *result)
 169 {
 170         if (g_interface.init != NULL)
 171         {
 172                 return g_interface.init(result);
 173         }
 174         else
 175         {
 176                 NFC_ERR("interface is null");
 177                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 178                 return false;
 179         }
 180 }
 181
 182 bool net_nfc_controller_deinit(void)
 183 {
 184         if (g_interface.deinit != NULL)
 185         {
 186                 return g_interface.deinit();
 187         }
 188         else
 189         {
 190                 NFC_ERR("interface is null");
 191                 return false;
 192         }
 193 }
 194
 195 bool net_nfc_controller_register_listener(
 196                 target_detection_listener_cb target_detection_listener,
 197                 se_transaction_listener_cb se_transaction_listener,
 198                 llcp_event_listener_cb llcp_event_listener, net_nfc_error_e *result)
 199 {
 200         if (g_interface.register_listener != NULL)
 201         {
 202                 return g_interface.register_listener(target_detection_listener,
 203                                 se_transaction_listener, llcp_event_listener, result);
 204         }
 205         else
 206         {
 207                 NFC_ERR("interface is null");
 208                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 209                 return false;
 210         }
 211 }
 212
 213 bool net_nfc_controller_unregister_listener()
 214 {
 215         if (g_interface.unregister_listener != NULL)
 216         {
 217                 return g_interface.unregister_listener();
 218         }
 219         else
 220         {
 221                 NFC_ERR("interface is null");
 222                 return false;
 223         }
 224 }
 225
 226 bool net_nfc_controller_get_firmware_version(data_s **data,
 227                 net_nfc_error_e *result)
 228 {
 229         if (g_interface.get_firmware_version != NULL)
 230         {
 231                 return g_interface.get_firmware_version(data, result);
 232         }
 233         else
 234         {
 235                 NFC_ERR("interface is null");
 236                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 237                 return false;
 238         }
 239 }
 240
 241 bool net_nfc_controller_check_firmware_version(net_nfc_error_e *result)
 242 {
 243         if (g_interface.check_firmware_version != NULL)
 244         {
 245                 return g_interface.check_firmware_version(result);
 246         }
 247         else
 248         {
 249                 NFC_ERR("interface is null");
 250                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 251                 return false;
 252         }
 253 }
 254
 255 bool net_nfc_controller_update_firmware(net_nfc_error_e *result)
 256 {
 257         if (g_interface.update_firmeware != NULL)
 258         {
 259                 return g_interface.update_firmeware(result);
 260         }
 261         else
 262         {
 263                 NFC_ERR("interface is null");
 264                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 265                 return false;
 266         }
 267 }
 268
 269 bool net_nfc_controller_get_stack_information(
 270                 net_nfc_stack_information_s *stack_info, net_nfc_error_e *result)
 271 {
 272         if (g_interface.get_stack_information != NULL)
 273         {
 274                 return g_interface.get_stack_information(stack_info, result);
 275         }
 276         else
 277         {
 278                 NFC_ERR("interface is null");
 279                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 280                 return false;
 281         }
 282 }
 283
 284 bool net_nfc_controller_configure_discovery(net_nfc_discovery_mode_e mode,
 285                 net_nfc_event_filter_e config, net_nfc_error_e *result)
 286 {
 287         if (g_interface.configure_discovery != NULL)
 288         {
 289                 return g_interface.configure_discovery(mode, config, result);
 290         }
 291         else
 292         {
 293                 NFC_ERR("interface is null");
 294                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 295                 return false;
 296         }
 297 }
 298
 299 bool net_nfc_controller_get_secure_element_list(
 300                 net_nfc_secure_element_info_s *list,
 301                 int *count,
 302                 net_nfc_error_e *result)
 303 {
 304         if (g_interface.get_secure_element_list != NULL)
 305         {
 306                 return g_interface.get_secure_element_list(list, count, result);
 307         }
 308         else
 309         {
 310                 NFC_ERR("interface is null");
 311                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 312                 return false;
 313         }
 314 }
 315
 316 bool net_nfc_controller_set_secure_element_mode(
 317                 net_nfc_secure_element_type_e element_type,
 318                 net_nfc_secure_element_mode_e mode,
 319                 net_nfc_error_e *result)
 320 {
 321         if (g_interface.set_secure_element_mode != NULL)
 322         {
 323                 return g_interface.set_secure_element_mode(element_type, mode, result);
 324         }
 325         else
 326         {
 327                 NFC_ERR("interface is null");
 328                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 329                 return false;
 330         }
 331 }
 332
 333 bool net_nfc_controller_secure_element_open(
 334                 net_nfc_secure_element_type_e element_type,
 335                 net_nfc_target_handle_s **handle,
 336                 net_nfc_error_e *result)
 337 {
 338         int ret_val = 0;
 339
 340         ret_val = display_lock_state(LCD_NORMAL, GOTO_STATE_NOW, 0);
 341
 342         NFC_DBG("display_lock_state [%d]!!", ret_val);
 343
 344         if (g_interface.secure_element_open != NULL)
 345         {
 346                 return g_interface.secure_element_open(element_type, handle, result);
 347         }
 348         else
 349         {
 350                 NFC_ERR("interface is null");
 351                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 352                 return false;
 353         }
 354 }
 355
 356 bool net_nfc_controller_secure_element_get_atr(net_nfc_target_handle_s *handle,
 357                 data_s **atr, net_nfc_error_e *result)
 358 {
 359         if (g_interface.secure_element_get_atr != NULL)
 360         {
 361                 return g_interface.secure_element_get_atr(handle, atr, result);
 362         }
 363         else
 364         {
 365                 NFC_ERR("interface is null");
 366                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 367                 return false;
 368         }
 369 }
 370
 371 bool net_nfc_controller_secure_element_send_apdu(
 372                 net_nfc_target_handle_s *handle,
 373                 data_s *command,
 374                 data_s **response,
 375                 net_nfc_error_e *result)
 376 {
 377         if (g_interface.secure_element_send_apdu != NULL)
 378         {
 379                 return g_interface.secure_element_send_apdu(handle, command, response, result);
 380         }
 381         else
 382         {
 383                 NFC_ERR("interface is null");
 384                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 385                 return false;
 386         }
 387 }
 388
 389 bool net_nfc_controller_secure_element_close(net_nfc_target_handle_s *handle,
 390                 net_nfc_error_e *result)
 391 {
 392         int ret_val = 0;
 393
 394         ret_val = display_unlock_state(LCD_NORMAL, PM_RESET_TIMER);
 395         NFC_DBG("display_unlock_state [%d]!!", ret_val);
 396
 397         if (g_interface.secure_element_close != NULL)
 398         {
 399                 return g_interface.secure_element_close(handle, result);
 400         }
 401         else
 402         {
 403                 NFC_ERR("interface is null");
 404                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 405                 return false;
 406         }
 407 }
 408
 409 bool net_nfc_controller_check_target_presence(net_nfc_target_handle_s *handle,
 410                 net_nfc_error_e *result)
 411 {
 412         if (g_interface.check_presence != NULL)
 413         {
 414                 return g_interface.check_presence(handle, result);
 415         }
 416         else
 417         {
 418                 NFC_ERR("interface is null");
 419                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 420                 return false;
 421         }
 422 }
 423
 424 bool net_nfc_controller_connect(net_nfc_target_handle_s *handle,
 425                 net_nfc_error_e *result)
 426 {
 427         int ret_val = 0;
 428
 429         ret_val = display_lock_state(LCD_NORMAL, GOTO_STATE_NOW, 0);
 430
 431         NFC_DBG("net_nfc_controller_connect display_lock_state [%d]!!", ret_val);
 432
 433         if (g_interface.connect != NULL)
 434         {
 435                 return g_interface.connect(handle, result);
 436         }
 437         else
 438         {
 439                 NFC_ERR("interface is null");
 440                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 441                 return false;
 442         }
 443 }
 444
 445 bool net_nfc_controller_disconnect(net_nfc_target_handle_s *handle,
 446                 net_nfc_error_e *result)
 447 {
 448         int ret_val = 0;
 449
 450         ret_val = display_unlock_state(LCD_NORMAL, PM_RESET_TIMER);
 451
 452         NFC_ERR("net_nfc_controller_disconnect display_unlock_state [%d]!!", ret_val);
 453
 454         if (g_interface.disconnect != NULL)
 455         {
 456                 net_nfc_server_free_target_info();
 457
 458                 return g_interface.disconnect(handle, result);
 459         }
 460         else
 461         {
 462                 NFC_ERR("interface is null");
 463                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 464                 return false;
 465         }
 466 }
 467
 468 bool net_nfc_controller_check_ndef(net_nfc_target_handle_s *handle,
 469                 uint8_t *ndef_card_state,
 470                 int *max_data_size,
 471                 int *real_data_size,
 472                 net_nfc_error_e *result)
 473 {
 474         if (g_interface.check_ndef != NULL)
 475         {
 476                 return g_interface.check_ndef(handle, ndef_card_state, max_data_size,
 477                                 real_data_size, result);
 478         }
 479         else
 480         {
 481                 NFC_ERR("interface is null");
 482                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 483                 return false;
 484         }
 485 }
 486
 487 bool net_nfc_controller_read_ndef(net_nfc_target_handle_s *handle, data_s **data,
 488                 net_nfc_error_e *result)
 489 {
 490         if (g_interface.read_ndef != NULL)
 491         {
 492                 return g_interface.read_ndef(handle, data, result);
 493         }
 494         else
 495         {
 496                 NFC_ERR("interface is null");
 497                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 498                 return false;
 499         }
 500 }
 501
 502 bool net_nfc_controller_write_ndef(net_nfc_target_handle_s *handle, data_s *data,
 503                 net_nfc_error_e *result)
 504 {
 505         if (g_interface.write_ndef != NULL)
 506         {
 507                 return g_interface.write_ndef(handle, data, result);
 508         }
 509         else
 510         {
 511                 NFC_ERR("interface is null");
 512                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 513                 return false;
 514         }
 515 }
 516
 517 bool net_nfc_controller_make_read_only_ndef(net_nfc_target_handle_s *handle,
 518                 net_nfc_error_e *result)
 519 {
 520         if (g_interface.make_read_only_ndef != NULL)
 521         {
 522                 return g_interface.make_read_only_ndef(handle, result);
 523         }
 524         else
 525         {
 526                 NFC_ERR("interface is null");
 527                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 528                 return false;
 529         }
 530 }
 531
 532 bool net_nfc_controller_format_ndef(net_nfc_target_handle_s *handle,
 533                 data_s *secure_key, net_nfc_error_e *result)
 534 {
 535         if (g_interface.format_ndef != NULL)
 536         {
 537                 return g_interface.format_ndef(handle, secure_key, result);
 538         }
 539         else
 540         {
 541                 NFC_ERR("interface is null");
 542                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 543                 return false;
 544         }
 545 }
 546
 547 bool net_nfc_controller_transceive(net_nfc_target_handle_s *handle,
 548                 net_nfc_transceive_info_s *info, data_s **data, net_nfc_error_e *result)
 549 {
 550         if (g_interface.transceive != NULL)
 551         {
 552                 return g_interface.transceive(handle, info, data, result);
 553         }
 554         else
 555         {
 556                 NFC_ERR("interface is null");
 557                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 558                 return false;
 559         }
 560 }
 561
 562 bool net_nfc_controller_exception_handler()
 563 {
 564         if (g_interface.exception_handler != NULL)
 565         {
 566                 return g_interface.exception_handler();
 567         }
 568         else
 569         {
 570                 NFC_ERR("interface is null");
 571                 return false;
 572         }
 573 }
 574
 575 bool net_nfc_controller_is_ready(net_nfc_error_e *result)
 576 {
 577         if (g_interface.is_ready != NULL)
 578         {
 579                 return g_interface.is_ready(result);
 580         }
 581         else
 582         {
 583                 NFC_ERR("interface is null");
 584                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 585                 return false;
 586         }
 587 }
 588
 589 bool net_nfc_controller_llcp_check_llcp(net_nfc_target_handle_s *handle,
 590                 net_nfc_error_e *result)
 591 {
 592         if (g_interface.check_llcp_status != NULL)
 593         {
 594                 return g_interface.check_llcp_status(handle, result);
 595         }
 596         else
 597         {
 598                 NFC_ERR("interface is null");
 599                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 600                 return false;
 601         }
 602 }
 603 bool net_nfc_controller_llcp_activate_llcp(net_nfc_target_handle_s *handle,
 604                 net_nfc_error_e *result)
 605 {
 606         if (g_interface.activate_llcp != NULL)
 607         {
 608                 return g_interface.activate_llcp(handle, result);
 609         }
 610         else
 611         {
 612                 NFC_ERR("interface is null");
 613                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 614                 return false;
 615         }
 616 }
 617
 618 static GSList *llcp_sockets;
 619
 620 static gint _compare_socket_info(gconstpointer a, gconstpointer b)
 621 {
 622         int result;
 623         socket_info_t *info = (socket_info_t *)a;
 624
 625         if (info->socket == (net_nfc_llcp_socket_t)b)
 626                 result = 0;
 627         else
 628                 result = -1;
 629
 630         return result;
 631 }
 632
 633 static socket_info_t* _get_socket_info(net_nfc_llcp_socket_t socket)
 634 {
 635         GSList *item;
 636         socket_info_t *result;
 637
 638         item = g_slist_find_custom(llcp_sockets, GUINT_TO_POINTER(socket),
 639                         _compare_socket_info);
 640         if (item != NULL)
 641                 result = (socket_info_t *)item->data;
 642         else
 643                 result = NULL;
 644
 645         return result;
 646 }
 647
 648 static socket_info_t* _add_socket_info(net_nfc_llcp_socket_t socket)
 649 {
 650         socket_info_t *result;
 651
 652         _net_nfc_util_alloc_mem(result, sizeof(socket_info_t));
 653         if (result != NULL)
 654         {
 655                 result->socket = socket;
 656
 657                 llcp_sockets = g_slist_append(llcp_sockets, result);
 658         }
 659
 660         return result;
 661 }
 662
 663 static void _remove_socket_info(net_nfc_llcp_socket_t socket)
 664 {
 665         GSList *item;
 666
 667         item = g_slist_find_custom(llcp_sockets, GUINT_TO_POINTER(socket),
 668                         _compare_socket_info);
 669         if (item != NULL)
 670         {
 671                 llcp_sockets = g_slist_remove_link(llcp_sockets, item);
 672                 free(item->data);
 673         }
 674 }
 675
 676 void net_nfc_controller_llcp_socket_error_cb(net_nfc_llcp_socket_t socket,
 677                 net_nfc_error_e result, void *data, void *user_param)
 678 {
 679         socket_info_t *info;
 680
 681         info = _get_socket_info(socket);
 682         if (info != NULL)
 683         {
 684                 if (info->err_cb != NULL)
 685                         info->err_cb(socket, result, NULL, NULL, info->err_param);
 686
 687                 _remove_socket_info(socket);
 688         }
 689 }
 690
 691 bool net_nfc_controller_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 692                 net_nfc_socket_type_e socketType,
 693                 uint16_t miu,
 694                 uint8_t rw,
 695                 net_nfc_error_e *result,
 696                 net_nfc_service_llcp_cb cb,
 697                 void *user_param)
 698 {
 699         if (g_interface.create_llcp_socket != NULL)
 700         {
 701                 bool ret;
 702                 socket_info_t *info;
 703
 704                 info = _add_socket_info(-1);
 705                 if (NULL == info)
 706                 {
 707                         NFC_ERR("_net_nfc_util_alloc_mem failed");
 708                         *result = NET_NFC_ALLOC_FAIL;
 709                         return false;
 710                 }
 711
 712                 ret = g_interface.create_llcp_socket(socket, socketType, miu, rw, result, NULL);
 713                 if (true == ret)
 714                 {
 715                         info->socket = *socket;
 716                         info->err_cb = cb;
 717                         info->err_param = user_param;
 718                 }
 719                 else
 720                 {
 721                         _remove_socket_info(-1);
 722                 }
 723
 724                 return ret;
 725         }
 726         else
 727         {
 728                 NFC_ERR("interface is null");
 729                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 730                 return false;
 731         }
 732 }
 733
 734 bool net_nfc_controller_llcp_bind(net_nfc_llcp_socket_t socket,
 735                 uint8_t service_access_point, net_nfc_error_e *result)
 736 {
 737         if (g_interface.bind_llcp_socket != NULL)
 738         {
 739                 return g_interface.bind_llcp_socket(socket, service_access_point, result);
 740         }
 741         else
 742         {
 743                 NFC_ERR("interface is null");
 744                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 745                 return false;
 746         }
 747 }
 748
 749 void net_nfc_controller_llcp_incoming_cb(net_nfc_llcp_socket_t socket,
 750                 net_nfc_error_e result, void *data, void *user_param)
 751 {
 752         socket_info_t *info = (socket_info_t *)user_param;
 753
 754         info = _get_socket_info(info->socket);
 755         if (info != NULL)
 756         {
 757                 if (_add_socket_info(socket) != NULL)
 758                 {
 759                         if (info->work_cb != NULL)
 760                                 info->work_cb(socket, result, NULL, NULL, info->work_param);
 761                 }
 762                 else
 763                 {
 764                         NFC_ERR("_net_nfc_util_alloc_mem failed");
 765                 }
 766         }
 767 }
 768
 769 bool net_nfc_controller_llcp_listen(net_nfc_target_handle_s* handle,
 770                 uint8_t *service_access_name,
 771                 net_nfc_llcp_socket_t socket,
 772                 net_nfc_error_e *result,
 773                 net_nfc_service_llcp_cb cb,
 774                 void *user_param)
 775 {
 776         if (g_interface.listen_llcp_socket != NULL)
 777         {
 778                 socket_info_t *info;
 779
 780                 info = _get_socket_info(socket);
 781                 if (NULL == info)
 782                 {
 783                         NFC_ERR("_get_socket_info failed");
 784                         *result = NET_NFC_INVALID_HANDLE;
 785                         return false;
 786                 }
 787
 788                 info->work_cb = cb;
 789                 info->work_param = user_param;
 790
 791                 return g_interface.listen_llcp_socket(handle, service_access_name, socket,
 792                                 result, info);
 793         }
 794         else
 795         {
 796                 NFC_ERR("interface is null");
 797                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 798                 return false;
 799         }
 800 }
 801
 802 bool net_nfc_controller_llcp_accept(net_nfc_llcp_socket_t socket,
 803                 net_nfc_error_e *result, net_nfc_service_llcp_cb cb, void *user_param)
 804 {
 805         if (g_interface.accept_llcp_socket != NULL)
 806         {
 807                 socket_info_t *info;
 808
 809                 info = _get_socket_info(socket);
 810                 if (NULL == info)
 811                 {
 812                         NFC_ERR("_get_socket_info failed");
 813                         *result = NET_NFC_INVALID_HANDLE;
 814                         return false;
 815                 }
 816
 817                 info->err_cb = cb;
 818                 info->err_param = user_param;
 819
 820                 return g_interface.accept_llcp_socket(socket, result, NULL);
 821         }
 822         else
 823         {
 824                 NFC_ERR("interface is null");
 825                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 826                 return false;
 827         }
 828 }
 829
 830 bool net_nfc_controller_llcp_reject(net_nfc_target_handle_s *handle,
 831                 net_nfc_llcp_socket_t socket, net_nfc_error_e *result)
 832 {
 833         if (g_interface.reject_llcp != NULL)
 834         {
 835                 bool ret;
 836
 837                 ret = g_interface.reject_llcp(handle, socket, result);
 838                 if (true == ret)
 839                         _remove_socket_info(socket);
 840
 841                 return ret;
 842         }
 843         else
 844         {
 845                 NFC_ERR("interface is null");
 846                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 847                 return false;
 848         }
 849 }
 850
 851 void net_nfc_controller_llcp_connected_cb(net_nfc_llcp_socket_t socket,
 852                 net_nfc_error_e result, void *data, void *user_param)
 853 {
 854         net_nfc_llcp_param_t *param = (net_nfc_llcp_param_t *)user_param;
 855
 856         RET_IF(NULL == param);
 857
 858         if (param->cb != NULL)
 859                 param->cb(param->socket, result, NULL, NULL, param->user_param);
 860
 861         _net_nfc_util_free_mem(param);
 862 }
 863
 864 bool net_nfc_controller_llcp_connect_by_url(net_nfc_target_handle_s *handle,
 865                 net_nfc_llcp_socket_t socket,
 866                 uint8_t *service_access_name,
 867                 net_nfc_error_e *result,
 868                 net_nfc_service_llcp_cb cb,
 869                 void *user_param)
 870 {
 871         int ret_val = 0;
 872
 873         ret_val = display_lock_state(LCD_NORMAL, GOTO_STATE_NOW, 0);
 874
 875         NFC_DBG("display_lock_state[%d]!!", ret_val);
 876
 877         if (g_interface.connect_llcp_by_url != NULL)
 878         {
 879                 net_nfc_llcp_param_t *param = NULL;
 880
 881                 _net_nfc_util_alloc_mem(param, sizeof(*param));
 882                 if (NULL == param)
 883                 {
 884                         NFC_ERR("_net_nfc_util_alloc_mem failed");
 885                         *result = NET_NFC_ALLOC_FAIL;
 886                         return false;
 887                 }
 888
 889                 param->socket = socket;
 890                 param->cb = cb;
 891                 param->user_param = user_param;
 892
 893                 return g_interface.connect_llcp_by_url(handle, socket, service_access_name,
 894                                 result, param);
 895         }
 896         else
 897         {
 898                 NFC_ERR("interface is null");
 899                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 900                 return false;
 901         }
 902 }
 903
 904 bool net_nfc_controller_llcp_connect(net_nfc_target_handle_s *handle,
 905                 net_nfc_llcp_socket_t socket,
 906                 uint8_t service_access_point,
 907                 net_nfc_error_e *result,
 908                 net_nfc_service_llcp_cb cb,
 909                 void *user_param)
 910 {
 911         int ret_val = 0;
 912
 913         ret_val = display_lock_state(LCD_NORMAL, GOTO_STATE_NOW, 0);
 914
 915         NFC_DBG("net_nfc_controller_llcp_connect display_lock_state [%d]!!", ret_val);
 916
 917         if (g_interface.connect_llcp != NULL)
 918         {
 919                 net_nfc_llcp_param_t *param = NULL;
 920
 921                 _net_nfc_util_alloc_mem(param, sizeof(*param));
 922                 if (param == NULL) {
 923                         NFC_ERR("_net_nfc_util_alloc_mem failed");
 924                         *result = NET_NFC_ALLOC_FAIL;
 925                         return false;
 926                 }
 927
 928                 param->socket = socket;
 929                 param->cb = cb;
 930                 param->user_param = user_param;
 931
 932                 return g_interface.connect_llcp(handle, socket, service_access_point, result, param);
 933         }
 934         else
 935         {
 936                 NFC_ERR("interface is null");
 937                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 938                 return false;
 939         }
 940 }
 941
 942 void net_nfc_controller_llcp_disconnected_cb(net_nfc_llcp_socket_t socket,
 943                 net_nfc_error_e result, void *data, void *user_param)
 944 {
 945         net_nfc_llcp_param_t *param = (net_nfc_llcp_param_t *)user_param;
 946
 947         RET_IF(NULL == param);
 948
 949         if (param->cb != NULL)
 950                 param->cb(param->socket, result, NULL, NULL, param->user_param);
 951
 952         _net_nfc_util_free_mem(param);
 953 }
 954
 955 bool net_nfc_controller_llcp_disconnect(net_nfc_target_handle_s *handle,
 956                 net_nfc_llcp_socket_t socket,
 957                 net_nfc_error_e *result,
 958                 net_nfc_service_llcp_cb cb,
 959                 void *user_param)
 960 {
 961         int ret_val = 0;
 962
 963         ret_val = display_unlock_state(LCD_NORMAL, PM_RESET_TIMER);
 964
 965         NFC_DBG("net_nfc_controller_llcp_disconnect display_unlock_state [%d]!!", ret_val);
 966
 967         if (g_interface.disconnect_llcp != NULL)
 968         {
 969                 net_nfc_llcp_param_t *param = NULL;
 970
 971                 _net_nfc_util_alloc_mem(param, sizeof(net_nfc_llcp_param_t));
 972                 if (NULL == param)
 973                 {
 974                         NFC_ERR("_net_nfc_util_alloc_mem failed");
 975                         *result = NET_NFC_ALLOC_FAIL;
 976                         return false;
 977                 }
 978
 979                 param->socket = socket;
 980                 param->cb = cb;
 981                 param->user_param = user_param;
 982
 983                 return g_interface.disconnect_llcp(handle, socket, result, param);
 984         }
 985         else
 986         {
 987                 NFC_ERR("interface is null");
 988                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
 989                 return false;
 990         }
 991 }
 992
 993 bool net_nfc_controller_llcp_socket_close(net_nfc_llcp_socket_t socket,
 994                 net_nfc_error_e *result)
 995 {
 996         if (g_interface.close_llcp_socket != NULL)
 997         {
 998                 return g_interface.close_llcp_socket(socket, result);
 999         }
1000         else
1001         {
1002                 NFC_ERR("interface is null");
1003                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1004                 return false;
1005         }
1006 }
1007
1008 void net_nfc_controller_llcp_received_cb(net_nfc_llcp_socket_t socket,
1009                 net_nfc_error_e result, void *data, void *user_param)
1010 {
1011         net_nfc_llcp_param_t *param = (net_nfc_llcp_param_t *)user_param;
1012
1013         RET_IF(NULL == param);
1014
1015         if (param->cb != NULL)
1016                 param->cb(param->socket, result, &param->data, data, param->user_param);
1017
1018         if (param->data.buffer != NULL)
1019                 _net_nfc_util_free_mem(param->data.buffer);
1020
1021         _net_nfc_util_free_mem(param);
1022 }
1023
1024 bool net_nfc_controller_llcp_recv(net_nfc_target_handle_s *handle,
1025                 net_nfc_llcp_socket_t socket,
1026                 uint32_t max_len,
1027                 net_nfc_error_e *result,
1028                 net_nfc_service_llcp_cb cb,
1029                 void *user_param)
1030 {
1031         if (g_interface.recv_llcp != NULL)
1032         {
1033                 net_nfc_llcp_param_t *param = NULL;
1034
1035                 _net_nfc_util_alloc_mem(param, sizeof(*param));
1036                 if (NULL == param)
1037                 {
1038                         NFC_ERR("_net_nfc_util_alloc_mem failed");
1039                         *result = NET_NFC_ALLOC_FAIL;
1040                         return false;
1041                 }
1042
1043                 param->socket = socket;
1044                 param->cb = cb;
1045                 if (max_len > 0)
1046                 {
1047                         _net_nfc_util_alloc_mem(param->data.buffer, max_len);
1048                         if (param->data.buffer == NULL)
1049                         {
1050                                 NFC_ERR("_net_nfc_util_alloc_mem failed");
1051                                 _net_nfc_util_free_mem(param);
1052                                 *result = NET_NFC_ALLOC_FAIL;
1053                                 return false;
1054                         }
1055                         param->data.length = max_len;
1056                 }
1057                 param->user_param = user_param;
1058
1059                 return g_interface.recv_llcp(handle, socket, &param->data, result, param);
1060         }
1061         else
1062         {
1063                 NFC_ERR("interface is null");
1064                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1065                 return false;
1066         }
1067 }
1068
1069 void net_nfc_controller_llcp_sent_cb(net_nfc_llcp_socket_t socket,
1070                 net_nfc_error_e result, void *data, void *user_param)
1071 {
1072         net_nfc_llcp_param_t *param = (net_nfc_llcp_param_t *)user_param;
1073
1074         RET_IF(NULL == param);
1075
1076         if (param->cb != NULL)
1077                 param->cb(param->socket, result, NULL, NULL, param->user_param);
1078
1079         _net_nfc_util_free_mem(param);
1080 }
1081
1082 bool net_nfc_controller_llcp_send(net_nfc_target_handle_s *handle,
1083                 net_nfc_llcp_socket_t socket,
1084                 data_s *data,
1085                 net_nfc_error_e *result,
1086                 net_nfc_service_llcp_cb cb,
1087                 void *user_param)
1088 {
1089         if (g_interface.send_llcp != NULL)
1090         {
1091                 net_nfc_llcp_param_t *param = NULL;
1092
1093                 _net_nfc_util_alloc_mem(param, sizeof(*param));
1094                 if (NULL == param)
1095                 {
1096                         NFC_ERR("_net_nfc_util_alloc_mem failed");
1097                         *result = NET_NFC_ALLOC_FAIL;
1098                         return false;
1099                 }
1100
1101                 param->socket = socket;
1102                 param->cb = cb;
1103                 param->user_param = user_param;
1104
1105                 return g_interface.send_llcp(handle, socket, data, result, param);
1106         }
1107         else
1108         {
1109                 NFC_ERR("interface is null");
1110                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1111                 return false;
1112         }
1113 }
1114 bool net_nfc_controller_llcp_recv_from(net_nfc_target_handle_s *handle,
1115                 net_nfc_llcp_socket_t socket,
1116                 uint32_t max_len,
1117                 net_nfc_error_e *result,
1118                 net_nfc_service_llcp_cb cb,
1119                 void *user_param)
1120 {
1121         if (g_interface.recv_from_llcp != NULL)
1122         {
1123                 net_nfc_llcp_param_t *param = NULL;
1124
1125                 _net_nfc_util_alloc_mem(param, sizeof(*param));
1126                 if (NULL == param)
1127                 {
1128                         NFC_ERR("_net_nfc_util_alloc_mem failed");
1129                         *result = NET_NFC_ALLOC_FAIL;
1130                         return false;
1131                 }
1132
1133                 param->socket = socket;
1134                 param->cb = cb;
1135                 if (max_len > 0)
1136                 {
1137                         _net_nfc_util_alloc_mem(param->data.buffer, max_len);
1138                         if (NULL == param->data.buffer)
1139                         {
1140                                 NFC_ERR("_net_nfc_util_alloc_mem failed");
1141                                 _net_nfc_util_free_mem(param);
1142                                 *result = NET_NFC_ALLOC_FAIL;
1143                                 return false;
1144                         }
1145                         param->data.length = max_len;
1146                 }
1147                 param->user_param = user_param;
1148
1149                 return g_interface.recv_from_llcp(handle, socket, &param->data, result, param);
1150         }
1151         else
1152         {
1153                 NFC_ERR("interface is null");
1154                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1155                 return false;
1156         }
1157 }
1158 bool net_nfc_controller_llcp_send_to(net_nfc_target_handle_s *handle,
1159                 net_nfc_llcp_socket_t socket,
1160                 data_s *data,
1161                 uint8_t service_access_point,
1162                 net_nfc_error_e *result,
1163                 net_nfc_service_llcp_cb cb,
1164                 void *user_param)
1165 {
1166         if (g_interface.send_to_llcp != NULL)
1167         {
1168                 net_nfc_llcp_param_t *param = NULL;
1169
1170                 _net_nfc_util_alloc_mem(param, sizeof(*param));
1171                 if (NULL == param)
1172                 {
1173                         NFC_ERR("_net_nfc_util_alloc_mem failed");
1174                         *result = NET_NFC_ALLOC_FAIL;
1175                         return false;
1176                 }
1177
1178                 param->socket = socket;
1179                 param->cb = cb;
1180                 param->user_param = user_param;
1181
1182                 return g_interface.send_to_llcp(handle, socket, data, service_access_point,
1183                                 result, param);
1184         }
1185         else
1186         {
1187                 NFC_ERR("interface is null");
1188                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1189                 return false;
1190         }
1191 }
1192
1193 bool net_nfc_controller_llcp_get_remote_config(net_nfc_target_handle_s *handle,
1194                 net_nfc_llcp_config_info_s *config, net_nfc_error_e *result)
1195 {
1196         if (g_interface.get_remote_config != NULL)
1197         {
1198                 return g_interface.get_remote_config(handle, config, result);
1199         }
1200         else
1201         {
1202                 NFC_ERR("interface is null");
1203                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1204                 return false;
1205         }
1206 }
1207 bool net_nfc_controller_llcp_get_remote_socket_info(
1208                 net_nfc_target_handle_s *handle,
1209                 net_nfc_llcp_socket_t socket,
1210                 net_nfc_llcp_socket_option_s *option,
1211                 net_nfc_error_e *result)
1212 {
1213         if (g_interface.get_remote_socket_info != NULL)
1214         {
1215                 return g_interface.get_remote_socket_info(handle, socket, option, result);
1216         }
1217         else
1218         {
1219                 NFC_ERR("interface is null");
1220                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1221                 return false;
1222         }
1223
1224 }
1225
1226 bool net_nfc_controller_sim_test(net_nfc_error_e *result)
1227 {
1228         if (g_interface.sim_test != NULL)
1229         {
1230                 return g_interface.sim_test(result);
1231         }
1232         else
1233         {
1234                 NFC_ERR("interface is null");
1235                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1236                 return false;
1237         }
1238 }
1239
1240 bool net_nfc_controller_prbs_test(net_nfc_error_e *result, uint32_t tech,
1241                 uint32_t rate)
1242 {
1243         if (g_interface.prbs_test != NULL)
1244         {
1245                 return g_interface.prbs_test(result, tech, rate);
1246         }
1247         else
1248         {
1249                 NFC_ERR("interface is null");
1250                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1251                 return false;
1252         }
1253 }
1254
1255 bool net_nfc_controller_test_mode_on(net_nfc_error_e *result)
1256 {
1257         if (g_interface.test_mode_on != NULL)
1258         {
1259                 return g_interface.test_mode_on(result);
1260         }
1261         else
1262         {
1263                 NFC_ERR("interface is null");
1264                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1265                 return false;
1266         }
1267 }
1268
1269 bool net_nfc_controller_test_mode_off(net_nfc_error_e *result)
1270 {
1271         if (g_interface.test_mode_off != NULL)
1272         {
1273                 return g_interface.test_mode_off(result);
1274         }
1275         else
1276         {
1277                 NFC_ERR("interface is null");
1278                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1279                 return false;
1280         }
1281 }
1282
1283 bool net_nfc_controller_support_nfc(net_nfc_error_e *result)
1284 {
1285         if (g_interface.support_nfc != NULL)
1286         {
1287                 return g_interface.support_nfc(result);
1288         }
1289         else
1290         {
1291                 NFC_ERR("interface is null");
1292                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1293                 return false;
1294         }
1295 }
1296
1297 bool net_nfc_controller_eedata_register_set(net_nfc_error_e *result,
1298                 uint32_t mode, uint32_t reg_id, data_s *data)
1299 {
1300         if (g_interface.eedata_register_set != NULL)
1301         {
1302                 return g_interface.eedata_register_set(result, mode, reg_id, data);
1303         }
1304         else
1305         {
1306                 NFC_ERR("interface is null");
1307                 *result = NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC;
1308                 return false;
1309         }
1310 }