src/manager/net_nfc_service.c

   1 /*
   2  * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Flora License, Version 1.1 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <pthread.h>
  18 #include <malloc.h>
  19
  20 #include "vconf.h"
  21
  22 #include "net_nfc_controller_private.h"
  23 #include "net_nfc_util_private.h"
  24 #include "net_nfc_typedef.h"
  25 #include "net_nfc_debug_private.h"
  26 #include "net_nfc_service_private.h"
  27 #include "net_nfc_service_se_private.h"
  28 #include "net_nfc_app_util_private.h"
  29 #include "net_nfc_server_ipc_private.h"
  30 #include "net_nfc_server_dispatcher_private.h"
  31 #include "net_nfc_manager_util_private.h"
  32 #include "net_nfc_service_tag_private.h"
  33 #include "net_nfc_service_llcp_private.h"
  34 #include "net_nfc_util_ndef_message.h"
  35 #include "net_nfc_util_ndef_record.h"
  36 #include "net_nfc_server_context_private.h"
  37
  38 /* static variable */
  39
  40 /* static callback function */
  41
  42 /* static function */
  43
  44 #ifndef BROADCAST_MESSAGE
  45 extern uint8_t g_se_cur_type;
  46 extern uint8_t g_se_cur_mode;
  47
  48 static bool _net_nfc_service_check_internal_ese_detected()
  49 {
  50         if (g_se_cur_type == SECURE_ELEMENT_TYPE_ESE && g_se_cur_mode == SECURE_ELEMENT_WIRED_MODE)
  51         {
  52                 return true;
  53         }
  54
  55         return false;
  56 }
  57 #endif
  58
  59 static void _net_nfc_service_show_exception_msg(char* msg);
  60
  61 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  62
  63 void net_nfc_service_target_detected_cb(void *info, void *user_context)
  64 {
  65         net_nfc_request_msg_t *req_msg = (net_nfc_request_msg_t *)info;
  66
  67         if (info == NULL)
  68                 return;
  69
  70         if (req_msg->request_type == NET_NFC_MESSAGE_SERVICE_RESTART_POLLING_LOOP)
  71         {
  72                 net_nfc_dispatcher_queue_push(req_msg);
  73         }
  74 #ifdef BROADCAST_MESSAGE
  75         else
  76         {
  77                 net_nfc_server_set_tag_info(info);
  78
  79                 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_SLAVE_TARGET_DETECTED;
  80                 net_nfc_dispatcher_queue_push(req_msg);
  81         }
  82 #else
  83         else if (net_nfc_server_get_current_client_context(&client_context) == true &&
  84                 net_nfc_server_check_client_is_running(&client_context) == true)
  85         {
  86                 net_nfc_request_target_detected_t *detail = (net_nfc_request_target_detected_t *)req_msg;
  87
  88                 /* If target detected, sound should be played. */
  89                 net_nfc_manager_util_play_sound(NET_NFC_TASK_START);
  90
  91                 net_nfc_server_set_tag_info(info);
  92
  93                 if (!_net_nfc_service_check_internal_ese_detected())
  94                 {
  95                         req_msg->request_type = NET_NFC_MESSAGE_SERVICE_SLAVE_TARGET_DETECTED;
  96                 }
  97                 else
  98                 {
  99                         req_msg->request_type = NET_NFC_MESSAGE_SERVICE_SLAVE_ESE_DETECTED;
 100
 101                         (detail->handle)->connection_type = NET_NFC_SE_CONNECTION;
 102                 }
 103
 104                 net_nfc_server_set_current_client_target_handle(client_context, detail->handle);
 105
 106                 net_nfc_dispatcher_queue_push(req_msg);
 107
 108                 DEBUG_SERVER_MSG("current client is listener. stand alone mode will be activated");
 109         }
 110         else
 111         {
 112                 /* If target detected, sound should be played. */
 113                 net_nfc_manager_util_play_sound(NET_NFC_TASK_START);
 114
 115                 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_STANDALONE_TARGET_DETECTED;
 116                 net_nfc_dispatcher_queue_push(req_msg);
 117         }
 118 #endif
 119 }
 120
 121 void net_nfc_service_se_transaction_cb(void *info, void *user_context)
 122 {
 123         net_nfc_request_se_event_t *req_msg = (net_nfc_request_se_event_t *)info;
 124
 125         DEBUG_SERVER_MSG("se event [%d]", req_msg->request_type);
 126
 127         net_nfc_dispatcher_queue_push((net_nfc_request_msg_t *)req_msg);
 128 }
 129
 130 void net_nfc_service_llcp_event_cb(void* info, void* user_context)
 131 {
 132         net_nfc_request_llcp_msg_t *req_msg = (net_nfc_request_llcp_msg_t *)info;
 133
 134         if (req_msg == NULL)
 135         {
 136                 DEBUG_SERVER_MSG("req msg is null");
 137                 return;
 138         }
 139
 140         if (req_msg->request_type == NET_NFC_MESSAGE_SERVICE_LLCP_ACCEPT)
 141         {
 142                 net_nfc_request_accept_socket_t *detail = (net_nfc_request_accept_socket_t *)req_msg;
 143                 detail->trans_param = user_context;
 144         }
 145
 146         req_msg->user_param = (uint32_t)user_context;
 147
 148         net_nfc_dispatcher_queue_push((net_nfc_request_msg_t *)req_msg);
 149 }
 150
 151 static bool _is_isp_dep_ndef_formatable(net_nfc_target_handle_s *handle, int dev_type)
 152 {
 153         bool result = false;
 154         uint8_t cmd[] = { 0x90, 0x60, 0x00, 0x00, 0x00 };
 155         net_nfc_transceive_info_s info;
 156         data_s *response = NULL;
 157         net_nfc_error_e error = NET_NFC_OK;
 158
 159         info.dev_type = dev_type;
 160         info.trans_data.buffer = cmd;
 161         info.trans_data.length = sizeof(cmd);
 162
 163         if (net_nfc_controller_transceive(handle, &info, &response, &error) == true)
 164         {
 165                 if (response != NULL)
 166                 {
 167                         if (response->length == 9 && response->buffer[7] == (uint8_t)0x91 &&
 168                                 response->buffer[8] == (uint8_t)0xAF)
 169                         {
 170                                 result = true;
 171                         }
 172                         else
 173                         {
 174                                 DEBUG_ERR_MSG("Unknown response....");
 175                                 DEBUG_MSG_PRINT_BUFFER(response->buffer, response->length);
 176                         }
 177                 }
 178                 else
 179                 {
 180                         DEBUG_ERR_MSG("net_nfc_controller_transceive response is null");
 181                 }
 182         }
 183         else
 184         {
 185                 DEBUG_ERR_MSG("net_nfc_controller_transceive is failed, [%d]", error);
 186         }
 187
 188         return result;
 189 }
 190
 191 static net_nfc_error_e _read_ndef_message(net_nfc_target_handle_s *handle, int dev_type, data_s **read_ndef)
 192 {
 193         net_nfc_error_e result = NET_NFC_OK;
 194         data_s *temp = NULL;
 195
 196         if (handle == NULL || read_ndef == NULL)
 197                 return NET_NFC_INVALID_PARAM;
 198
 199         *read_ndef = NULL;
 200
 201         /* Desfire */
 202         if (dev_type == NET_NFC_MIFARE_DESFIRE_PICC)
 203         {
 204                 DEBUG_SERVER_MSG("DESFIRE : check ISO-DEP ndef formatable");
 205
 206                 if (_is_isp_dep_ndef_formatable(handle, dev_type) == true)
 207                 {
 208                         DEBUG_SERVER_MSG("DESFIRE : ISO-DEP ndef formatable");
 209
 210                         if (!net_nfc_controller_connect(handle, &result))
 211                         {
 212                                 DEBUG_ERR_MSG("net_nfc_controller_connect failed & Retry Polling!!");
 213
 214                                 if (net_nfc_controller_confiure_discovery(NET_NFC_DISCOVERY_MODE_RESUME,
 215                                         NET_NFC_ALL_ENABLE, &result) == false)
 216                                 {
 217                                         net_nfc_controller_exception_handler();
 218                                 }
 219
 220                                 return NET_NFC_TAG_READ_FAILED;
 221                         }
 222                 }
 223                 else
 224                 {
 225                         DEBUG_ERR_MSG("DESFIRE : ISO-DEP ndef not formatable");
 226
 227                         return NET_NFC_TAG_READ_FAILED;
 228                 }
 229         }
 230
 231         if (net_nfc_controller_read_ndef(handle, &temp, &result) == true)
 232         {
 233                 DEBUG_SERVER_MSG("net_nfc_controller_read_ndef success");
 234
 235                 if (dev_type == NET_NFC_MIFARE_DESFIRE_PICC)
 236                 {
 237                         if (!net_nfc_controller_connect(handle, &result))
 238                         {
 239                                 DEBUG_ERR_MSG("net_nfc_controller_connect failed & Retry Polling!!");
 240
 241                                 if (net_nfc_controller_confiure_discovery(NET_NFC_DISCOVERY_MODE_RESUME, NET_NFC_ALL_ENABLE, &result) == false)
 242                                 {
 243                                         net_nfc_controller_exception_handler();
 244                                 }
 245
 246                                 net_nfc_util_free_data(temp);
 247                                 _net_nfc_util_free_mem(temp);
 248
 249                                 return NET_NFC_TAG_READ_FAILED;
 250                         }
 251                 }
 252
 253                 *read_ndef = temp;
 254         }
 255         else
 256         {
 257                 DEBUG_ERR_MSG("net_nfc_controller_read_ndef failed [%d]", result);
 258         }
 259
 260         return result;
 261 }
 262
 263 #ifndef BROADCAST_MESSAGE
 264 bool net_nfc_service_standalone_mode_target_detected(net_nfc_request_msg_t* msg)
 265 {
 266         net_nfc_request_target_detected_t* stand_alone = (net_nfc_request_target_detected_t *)msg;
 267         net_nfc_error_e error_status = NET_NFC_OK;
 268
 269         data_s *recv_data = NULL;
 270
 271         DEBUG_SERVER_MSG("*** Detected! type [0x%X)] ***", stand_alone->devType);
 272
 273         switch (stand_alone->devType)
 274         {
 275         case NET_NFC_NFCIP1_TARGET :
 276         case NET_NFC_NFCIP1_INITIATOR :
 277                 {
 278                         DEBUG_SERVER_MSG(" LLCP is detected");
 279
 280                         net_nfc_service_llcp_process(stand_alone->handle, stand_alone->devType, &error_status);
 281
 282                         malloc_trim(0);
 283                         return true;
 284                 }
 285                 break;
 286
 287         default :
 288                 {
 289                         DEBUG_SERVER_MSG(" PICC or PCD is detectd.");
 290                         recv_data = net_nfc_service_tag_process(stand_alone->handle, stand_alone->devType, &error_status);
 291                 }
 292                 break;
 293         }
 294
 295         if (recv_data != NULL)
 296         {
 297                 net_nfc_service_msg_processing(recv_data);
 298         }
 299         else
 300         {
 301                 if (((stand_alone->devType == NET_NFC_NFCIP1_INITIATOR) || (stand_alone->devType == NET_NFC_NFCIP1_TARGET)))
 302                 {
 303                         DEBUG_SERVER_MSG("p2p operation. recv data is NULL");
 304                 }
 305                 else
 306                 {
 307                         if (error_status == NET_NFC_NO_NDEF_SUPPORT)
 308                         {
 309                                 DEBUG_SERVER_MSG("device type = [%d], it has null data", stand_alone->devType);
 310
 311                                 /* launch empty tag */
 312                                 uint8_t empty[] = { 0xd0, 0x00, 0x00 }; /* raw-data of empty ndef-message */
 313                                 data_s rawdata = { &empty, sizeof(empty) };
 314
 315                                 net_nfc_service_msg_processing(&rawdata);
 316                         }
 317                         else
 318                         {
 319                                 _net_nfc_service_show_exception_msg("Try again");
 320                         }
 321                 }
 322         }
 323
 324         if (stand_alone->devType != NET_NFC_NFCIP1_INITIATOR && stand_alone->devType != NET_NFC_NFCIP1_TARGET)
 325         {
 326                 net_nfc_request_watch_dog_t* watch_dog_msg = NULL;
 327
 328                 _net_nfc_util_alloc_mem(watch_dog_msg, sizeof(net_nfc_request_watch_dog_t));
 329
 330                 if (watch_dog_msg != NULL)
 331                 {
 332                         watch_dog_msg->length = sizeof(net_nfc_request_watch_dog_t);
 333                         watch_dog_msg->request_type = NET_NFC_MESSAGE_SERVICE_WATCH_DOG;
 334                         watch_dog_msg->devType = stand_alone->devType;
 335                         watch_dog_msg->handle = stand_alone->handle;
 336
 337                         net_nfc_dispatcher_queue_push((net_nfc_request_msg_t *)watch_dog_msg);
 338                 }
 339         }
 340
 341         DEBUG_SERVER_MSG("stand alone mode is end");
 342         malloc_trim(0);
 343
 344         return true;
 345 }
 346 #endif
 347
 348 bool net_nfc_service_slave_mode_target_detected(net_nfc_request_msg_t *msg)
 349 {
 350         net_nfc_request_target_detected_t *detail_msg = (net_nfc_request_target_detected_t *)msg;
 351         net_nfc_error_e result = NET_NFC_OK;
 352         bool success = true;
 353
 354         DEBUG_SERVER_MSG("target detected callback for client, device type = [%d]", detail_msg->devType);
 355
 356         if (detail_msg == NULL)
 357         {
 358                 return false;
 359         }
 360
 361         if (detail_msg->devType != NET_NFC_NFCIP1_TARGET && detail_msg->devType != NET_NFC_NFCIP1_INITIATOR)
 362         {
 363                 net_nfc_response_tag_discovered_t resp_msg = { 0, };
 364                 int request_type = NET_NFC_MESSAGE_TAG_DISCOVERED;
 365                 data_s *recv_data = NULL;
 366
 367                 if (!net_nfc_controller_connect(detail_msg->handle, &result))
 368                 {
 369                         DEBUG_ERR_MSG("connect failed & Retry Polling!!");
 370
 371                         if (net_nfc_controller_confiure_discovery(NET_NFC_DISCOVERY_MODE_RESUME, NET_NFC_ALL_ENABLE, &result) == false)
 372                         {
 373                                 net_nfc_controller_exception_handler();
 374                         }
 375                         return false;
 376                 }
 377
 378 #ifdef BROADCAST_MESSAGE
 379                 net_nfc_server_set_server_state(NET_NFC_TAG_CONNECTED);
 380 #endif
 381                 DEBUG_SERVER_MSG("tag is connected");
 382
 383                 uint8_t ndef_card_state = 0;
 384                 int max_data_size = 0;
 385                 int real_data_size = 0;
 386
 387                 if (net_nfc_controller_check_ndef(detail_msg->handle, &ndef_card_state, &max_data_size, &real_data_size, &result) == true)
 388                 {
 389                         resp_msg.ndefCardState = ndef_card_state;
 390                         resp_msg.maxDataSize = max_data_size;
 391                         resp_msg.actualDataSize = real_data_size;
 392                         resp_msg.is_ndef_supported = 1;
 393                 }
 394
 395                 resp_msg.devType = detail_msg->devType;
 396                 resp_msg.handle = detail_msg->handle;
 397                 resp_msg.number_of_keys = detail_msg->number_of_keys;
 398                 resp_msg.raw_data.length = 0;
 399
 400                 net_nfc_util_duplicate_data(&resp_msg.target_info_values, &detail_msg->target_info_values);
 401
 402                 if (resp_msg.is_ndef_supported)
 403                 {
 404                         DEBUG_SERVER_MSG("support NDEF");
 405
 406                         if ((result = _read_ndef_message(detail_msg->handle, detail_msg->devType, &recv_data)) == NET_NFC_OK &&
 407                                 recv_data != NULL)
 408                         {
 409                                 DEBUG_SERVER_MSG("net_nfc_controller_read_ndef success");
 410 #ifdef BROADCAST_MESSAGE
 411                                 net_nfc_service_msg_processing(recv_data);
 412 #endif
 413                                 resp_msg.raw_data.length = recv_data->length;
 414                                 success = net_nfc_broadcast_response_msg(request_type, (void *)&resp_msg, sizeof(net_nfc_response_tag_discovered_t),
 415                                         (void *)(resp_msg.target_info_values.buffer), resp_msg.target_info_values.length,
 416                                         (void *)(recv_data->buffer), recv_data->length, NULL);
 417
 418                                 net_nfc_util_free_data(recv_data);
 419                                 _net_nfc_util_free_mem(recv_data);
 420                         }
 421                         else
 422                         {
 423                                 DEBUG_ERR_MSG("net_nfc_controller_read_ndef failed");
 424
 425                                 success = net_nfc_broadcast_response_msg(request_type, (void *)&resp_msg, sizeof(net_nfc_response_tag_discovered_t),
 426                                         (void *)(resp_msg.target_info_values.buffer), resp_msg.target_info_values.length, NULL);
 427                         }
 428                 }
 429                 else
 430                 {
 431                         DEBUG_SERVER_MSG("not support NDEF");
 432 #ifdef BROADCAST_MESSAGE
 433                         /* launch empty tag */
 434                         uint8_t empty[] = { 0xd0, 0x00, 0x00 }; /* raw-data of empty ndef-message */
 435                         data_s rawdata = { empty, sizeof(empty) };
 436
 437                         net_nfc_service_msg_processing(&rawdata);
 438 #endif
 439                         success = net_nfc_broadcast_response_msg(request_type, (void *)&resp_msg, sizeof(net_nfc_response_tag_discovered_t),
 440                                 (void *)(resp_msg.target_info_values.buffer), resp_msg.target_info_values.length, NULL);
 441                 }
 442
 443                 net_nfc_util_free_data(&resp_msg.target_info_values);
 444
 445                 DEBUG_SERVER_MSG("turn on watch dog");
 446
 447                 net_nfc_request_watch_dog_t* watch_dog_msg = NULL;
 448
 449                 _net_nfc_util_alloc_mem(watch_dog_msg, sizeof(net_nfc_request_watch_dog_t));
 450                 if (watch_dog_msg != NULL)
 451                 {
 452                         watch_dog_msg->length = sizeof(net_nfc_request_watch_dog_t);
 453                         watch_dog_msg->request_type = NET_NFC_MESSAGE_SERVICE_WATCH_DOG;
 454                         watch_dog_msg->devType = detail_msg->devType;
 455                         watch_dog_msg->handle = detail_msg->handle;
 456
 457                         net_nfc_dispatcher_queue_push((net_nfc_request_msg_t *)watch_dog_msg);
 458                 }
 459         }
 460         else /* LLCP */
 461         {
 462                 net_nfc_error_e error_status = NET_NFC_OK;
 463
 464                 net_nfc_service_llcp_process(detail_msg->handle, detail_msg->devType, &error_status);
 465         }
 466
 467         /* If target detected, sound should be played. */
 468         net_nfc_manager_util_play_sound(NET_NFC_TASK_START);
 469
 470         return success;
 471 }
 472
 473 bool net_nfc_service_termination(net_nfc_request_msg_t* msg)
 474 {
 475         net_nfc_error_e result;
 476
 477         if (net_nfc_controller_is_ready(&result) == true)
 478         {
 479         }
 480         else
 481         {
 482                 DEBUG_SERVER_MSG("Not initialized");
 483                 net_nfc_controller_init(&result);
 484         }
 485
 486         if (net_nfc_controller_confiure_discovery(NET_NFC_DISCOVERY_MODE_CONFIG, NET_NFC_ALL_DISABLE, &result) != true)
 487         {
 488                 DEBUG_SERVER_MSG("failed to discover off %d", result);
 489         }
 490
 491         if (net_nfc_controller_set_secure_element_mode(NET_NFC_SE_CMD_UICC_ON, SECURE_ELEMENT_VIRTUAL_MODE, &result) != true)
 492         {
 493                 DEBUG_SERVER_MSG("failed to set se mode to default mode: %d", result);
 494         }
 495
 496         return true;
 497 }
 498
 499 void net_nfc_service_msg_processing(data_s* data)
 500 {
 501         if (data != NULL)
 502         {
 503                 net_nfc_app_util_process_ndef(data);
 504         }
 505         else
 506         {
 507                 _net_nfc_service_show_exception_msg("unknown type tag");
 508         }
 509 }
 510
 511 static void _net_nfc_service_show_exception_msg(char* msg)
 512 {
 513         bundle *kb = NULL;
 514
 515         kb = bundle_create();
 516         bundle_add(kb, "type", "default");
 517         bundle_add(kb, "text", msg);
 518
 519         net_nfc_app_util_aul_launch_app("com.samsung.nfc-app", kb); /* empty_tag */
 520
 521         bundle_free(kb);
 522 }
 523
 524 void net_nfc_service_is_tag_connected(net_nfc_request_msg_t *msg)
 525 {
 526         net_nfc_request_is_tag_connected_t *detail = (net_nfc_request_is_tag_connected_t *)msg;
 527         net_nfc_current_target_info_s *target_info;
 528
 529         target_info = net_nfc_server_get_tag_info();
 530         if (net_nfc_server_check_client_is_running(msg->client_fd))
 531         {
 532                 net_nfc_response_is_tag_connected_t resp = { 0, };
 533
 534                 resp.length = sizeof(net_nfc_response_is_tag_connected_t);
 535                 resp.flags = detail->flags;
 536                 resp.trans_param = detail->trans_param;
 537
 538                 if (target_info != NULL)
 539                 {
 540                         resp.result = NET_NFC_OK;
 541                         resp.devType = target_info->devType;
 542                 }
 543                 else
 544                 {
 545                         resp.result = NET_NFC_NOT_CONNECTED;
 546                         resp.devType = NET_NFC_UNKNOWN_TARGET;
 547                 }
 548
 549                 net_nfc_send_response_msg(msg->client_fd, msg->request_type,
 550                         (void *)&resp, sizeof(net_nfc_response_is_tag_connected_t), NULL);
 551         }
 552 }
 553
 554 void net_nfc_service_get_current_tag_info(net_nfc_request_msg_t *msg)
 555 {
 556         net_nfc_response_get_current_tag_info_t resp = { 0, };
 557         net_nfc_request_get_current_tag_info_t *detail = (net_nfc_request_get_current_tag_info_t *)msg;
 558         net_nfc_current_target_info_s *target_info = NULL;
 559         net_nfc_error_e result = NET_NFC_OK;
 560
 561         resp.length = sizeof(net_nfc_response_get_current_tag_info_t);
 562         resp.flags = detail->flags;
 563         resp.trans_param = detail->trans_param;
 564
 565         target_info = net_nfc_server_get_tag_info();
 566         if (target_info != NULL)
 567         {
 568                 bool success = true;
 569                 data_s *recv_data = NULL;
 570
 571                 if (target_info->devType != NET_NFC_NFCIP1_TARGET && target_info->devType != NET_NFC_NFCIP1_INITIATOR)
 572                 {
 573 #ifdef BROADCAST_MESSAGE
 574                         net_nfc_server_set_server_state(NET_NFC_TAG_CONNECTED);
 575 #endif
 576                         DEBUG_SERVER_MSG("tag is connected");
 577
 578                         uint8_t ndef_card_state = 0;
 579                         int max_data_size = 0;
 580                         int real_data_size = 0;
 581
 582                         if (net_nfc_controller_check_ndef(target_info->handle,
 583                                 &ndef_card_state, &max_data_size, &real_data_size, &result) == true)
 584                         {
 585                                 resp.ndefCardState = ndef_card_state;
 586                                 resp.maxDataSize = max_data_size;
 587                                 resp.actualDataSize = real_data_size;
 588                                 resp.is_ndef_supported = 1;
 589                         }
 590
 591                         resp.devType = target_info->devType;
 592                         resp.handle = target_info->handle;
 593                         resp.number_of_keys = target_info->number_of_keys;
 594
 595                         net_nfc_util_duplicate_data(&resp.target_info_values, &target_info->target_info_values);
 596
 597                         if (resp.is_ndef_supported)
 598                         {
 599                                 if (net_nfc_controller_read_ndef(target_info->handle, &recv_data, &(resp.result)) == true)
 600                                 {
 601                                         DEBUG_SERVER_MSG("net_nfc_controller_read_ndef is success");
 602
 603                                         resp.raw_data.length = recv_data->length;
 604
 605                                         success = net_nfc_send_response_msg(msg->client_fd, msg->request_type, (void *)&resp, sizeof(net_nfc_response_get_current_tag_info_t),
 606                                                         (void *)(resp.target_info_values.buffer), resp.target_info_values.length,
 607                                                         (void *)(recv_data->buffer), recv_data->length, NULL);
 608                                 }
 609                                 else
 610                                 {
 611                                         DEBUG_SERVER_MSG("net_nfc_controller_read_ndef is fail");
 612
 613                                         resp.raw_data.length = 0;
 614
 615                                         success = net_nfc_send_response_msg(msg->client_fd, msg->request_type, (void *)&resp, sizeof(net_nfc_response_get_current_tag_info_t),
 616                                                 (void *)(resp.target_info_values.buffer), resp.target_info_values.length, NULL);
 617                                 }
 618                         }
 619                         else
 620                         {
 621                                 resp.raw_data.length = 0;
 622
 623                                 success = net_nfc_send_response_msg(msg->client_fd, msg->request_type, (void *)&resp, sizeof(net_nfc_response_get_current_tag_info_t),
 624                                         (void *)(resp.target_info_values.buffer), resp.target_info_values.length, NULL);
 625                         }
 626
 627                         net_nfc_util_free_data(&resp.target_info_values);
 628                 }
 629                 else
 630                 {
 631                         /* LLCP */
 632                         resp.result = NET_NFC_NOT_CONNECTED;
 633                         net_nfc_send_response_msg(msg->client_fd, msg->request_type,
 634                                 (void *)&resp, sizeof(net_nfc_response_get_current_tag_info_t), NULL);
 635                 }
 636         }
 637         else
 638         {
 639                 resp.result = NET_NFC_NOT_CONNECTED;
 640                 net_nfc_send_response_msg(msg->client_fd, msg->request_type,
 641                         (void *)&resp, sizeof(net_nfc_response_get_current_tag_info_t), NULL);
 642         }
 643 }
 644
 645 void net_nfc_service_get_current_target_handle(net_nfc_request_msg_t *msg)
 646 {
 647         net_nfc_request_get_current_target_handle_t *detail = (net_nfc_request_get_current_target_handle_t *)msg;
 648         net_nfc_current_target_info_s *target_info = NULL;
 649
 650         target_info = net_nfc_server_get_tag_info();
 651         if (net_nfc_server_check_client_is_running(msg->client_fd))
 652         {
 653                 net_nfc_response_get_current_target_handle_t resp = { 0, };
 654
 655                 resp.length = sizeof(net_nfc_response_get_current_target_handle_t);
 656                 resp.flags = detail->flags;
 657                 resp.trans_param = detail->trans_param;
 658
 659                 if (target_info != NULL)
 660                 {
 661                         resp.handle = target_info->handle;
 662                         resp.devType = target_info->devType;
 663                         resp.result = NET_NFC_OK;
 664                 }
 665                 else
 666                 {
 667                         resp.result = NET_NFC_NOT_CONNECTED;
 668                 }
 669
 670                 net_nfc_send_response_msg(msg->client_fd, msg->request_type,
 671                         (void *)&resp, sizeof(net_nfc_response_get_current_target_handle_t), NULL);
 672         }
 673 }
 674
 675 void net_nfc_service_deinit(net_nfc_request_msg_t *msg)
 676 {
 677         net_nfc_error_e result;
 678
 679         result = net_nfc_service_se_change_se(SECURE_ELEMENT_TYPE_INVALID);
 680
 681         net_nfc_server_free_current_tag_info();
 682
 683         if (net_nfc_controller_deinit() == TRUE)
 684         {
 685                 DEBUG_SERVER_MSG("net_nfc_controller_deinit success [%d]", result);
 686
 687                 /*vconf off*/
 688                 if (vconf_set_bool(VCONFKEY_NFC_STATE, FALSE) != 0)
 689                 {
 690                         DEBUG_ERR_MSG("vconf_set_bool failed");
 691                 }
 692
 693                 net_nfc_response_test_t resp = { 0, };
 694
 695                 resp.length = sizeof(net_nfc_response_test_t);
 696                 resp.flags = msg->flags;
 697                 resp.result = NET_NFC_OK;
 698                 resp.trans_param = (void *)msg->user_param;
 699
 700                 net_nfc_broadcast_response_msg(msg->request_type, (void *)&resp,
 701                         sizeof(net_nfc_response_test_t), NULL);
 702         }
 703         else
 704         {
 705                 DEBUG_SERVER_MSG("net_nfc_controller_deinit failed");
 706
 707                 if (net_nfc_server_check_client_is_running(msg->client_fd))
 708                 {
 709                         net_nfc_response_test_t resp = { 0, };
 710
 711                         resp.length = sizeof(net_nfc_response_test_t);
 712                         resp.flags = msg->flags;
 713                         resp.result = NET_NFC_UNKNOWN_ERROR;
 714                         resp.trans_param = (void *)msg->user_param;
 715
 716                         net_nfc_send_response_msg(msg->client_fd, msg->request_type,
 717                                 (void *)&resp, sizeof(net_nfc_response_test_t), NULL);
 718                 }
 719         }
 720 }
 721
 722 void net_nfc_service_init(net_nfc_request_msg_t *msg)
 723 {
 724         net_nfc_error_e result;
 725
 726         if (net_nfc_controller_init(&result) == true)
 727         {
 728                 net_nfc_llcp_config_info_s config = { 128, 1, 100, 0 };
 729
 730                 if (net_nfc_controller_register_listener(net_nfc_service_target_detected_cb,
 731                         net_nfc_service_se_transaction_cb, net_nfc_service_llcp_event_cb, &result) == true)
 732                 {
 733                         DEBUG_SERVER_MSG("net_nfc_controller_register_listener Success!!");
 734                 }
 735                 else
 736                 {
 737                         DEBUG_ERR_MSG("net_nfc_controller_register_listener failed [%d]", result);
 738                 }
 739
 740                 if (net_nfc_controller_llcp_config(&config, &result) == true)
 741                 {
 742                         /*We need to check the stack that supports the llcp or not.*/
 743                         DEBUG_SERVER_MSG("llcp is enabled");
 744                 }
 745                 else
 746                 {
 747                         DEBUG_ERR_MSG("net_nfc_controller_llcp_config failed [%d]", result);
 748                 }
 749
 750                 result = net_nfc_service_se_change_se(SECURE_ELEMENT_TYPE_UICC);
 751
 752                 if (net_nfc_controller_confiure_discovery(NET_NFC_DISCOVERY_MODE_CONFIG,
 753                         NET_NFC_ALL_ENABLE, &result) == true)
 754                 {
 755                         DEBUG_SERVER_MSG("now, nfc is ready");
 756                 }
 757                 else
 758                 {
 759                         DEBUG_ERR_MSG("net_nfc_controller_confiure_discovery failed [%d]", result);
 760                 }
 761
 762                 /*Send the Init Success Response Msg*/
 763                 {
 764                         net_nfc_response_test_t resp = { 0, };
 765
 766                         DEBUG_SERVER_MSG("net_nfc_controller_init success [%d]", result);
 767
 768                         resp.length = sizeof(net_nfc_response_test_t);
 769                         resp.flags = msg->flags;
 770                         resp.result = NET_NFC_OK;
 771                         resp.trans_param = (void *)msg->user_param;
 772
 773                         /*vconf on*/
 774                         if (vconf_set_bool(VCONFKEY_NFC_STATE, TRUE) != 0)
 775                         {
 776                                 DEBUG_ERR_MSG("vconf_set_bool failed");
 777                         }
 778
 779                         net_nfc_broadcast_response_msg(msg->request_type,
 780                                 (void *)&resp, sizeof(net_nfc_response_test_t), NULL);
 781                 }
 782         }
 783         else
 784         {
 785                 DEBUG_ERR_MSG("net_nfc_controller_init failed [%d]", result);
 786
 787                 if (net_nfc_server_check_client_is_running(msg->client_fd))
 788                 {
 789                         net_nfc_response_test_t resp = { 0, };
 790
 791                         resp.length = sizeof(net_nfc_response_test_t);
 792                         resp.flags = msg->flags;
 793                         resp.result = result;
 794                         resp.trans_param = (void *)msg->user_param;
 795
 796                         net_nfc_send_response_msg(msg->client_fd, msg->request_type,
 797                                 (void *)&resp, sizeof(net_nfc_response_test_t), NULL);
 798                 }
 799         }
 800 }
 801
 802 void net_nfc_service_restart_polling(net_nfc_request_msg_t *msg)
 803 {
 804         net_nfc_request_msg_t *discovery_req = (net_nfc_request_msg_t *)msg;
 805         net_nfc_error_e result = NET_NFC_OK;
 806         int pm_state = 0;
 807         int set_config = 0;
 808
 809         pm_state = discovery_req->user_param;
 810
 811         DEBUG_SERVER_MSG("NET_NFC_MESSAGE_SERVICE_RESTART_POLLING_LOOP PM State = [%d]", pm_state);
 812
 813         if (pm_state == 1)
 814         {
 815                 set_config = NET_NFC_ALL_ENABLE;
 816         }
 817         else if (pm_state == 3)
 818         {
 819                 set_config = NET_NFC_ALL_DISABLE;
 820         }
 821         else
 822         {
 823                 DEBUG_SERVER_MSG("Do not anything!!");
 824         }
 825
 826         if (net_nfc_controller_confiure_discovery(NET_NFC_DISCOVERY_MODE_CONFIG, set_config, &result) == true)
 827         {
 828                 DEBUG_SERVER_MSG("now, nfc polling loop is running again");
 829         }
 830 }
 831
 832 void net_nfc_service_get_server_state(net_nfc_request_msg_t *msg)
 833 {
 834         if (net_nfc_server_check_client_is_running(msg->client_fd))
 835         {
 836                 net_nfc_response_get_server_state_t resp = { 0, };
 837
 838                 resp.length = sizeof(net_nfc_response_get_server_state_t);
 839                 resp.flags = msg->flags;
 840                 resp.state = net_nfc_server_get_server_state();
 841                 resp.result = NET_NFC_OK;
 842
 843                 net_nfc_send_response_msg(msg->client_fd, msg->request_type,
 844                         (void *)&resp, sizeof(net_nfc_response_get_server_state_t), NULL);
 845         }
 846 }