src/oem_emul.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 <pthread.h>
  18 #include <time.h>
  19 #include <sys/time.h>
  20 #include <dirent.h>
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23 #include <unistd.h>
  24 #include <sys/stat.h>
  25 #include <sys/types.h>
  26 #include <fcntl.h>
  27 #include <malloc.h>
  28 #include <vconf.h>
  29
  30 #include <pwd.h>
  31 #include <grp.h>
  32 #include <sys/epoll.h>
  33
  34 #ifdef USE_GLIB_MAIN_LOOP
  35 #include <glib.h>
  36 #endif
  37
  38 #include <net_nfc_oem_controller.h>
  39 #include "net_nfc_typedef.h"
  40 #include "nfc_debug_private.h"
  41 #include "net_nfc_util_internal.h"
  42 #include "net_nfc_util_ndef_message.h"
  43 #include "net_nfc_util_ndef_record.h"
  44
  45 #include <netinet/in.h>
  46
  47 /***************************    STRUCTURE DEFINE START  ***************************************/
  48
  49 #ifndef NET_NFC_EXPORT_API
  50 #define NET_NFC_EXPORT_API __attribute__((visibility("default")))
  51 #endif
  52
  53 typedef enum {
  54         EMUL_NFC_TAG_DISCOVERED = 100,
  55         EMUL_NFC_TAG_DETACHED,
  56         EMUL_NFC_P2P_DISCOVERED,
  57         EMUL_NFC_P2P_DETACHED,
  58         EMUL_NFC_P2P_SEND,
  59         EMUL_NFC_UNKNOWN_MSG
  60 } emul_message_id;
  61
  62 typedef enum {
  63         EMUL_TAG_TOPAZ_JEWEL = 1,
  64         EMUL_TAG_MIFARE_UL,
  65         EMUL_TAG_FELICA,
  66         EMUL_TAG_MIFARE_DESFIRE,
  67         EMUL_NFC_TARGET,
  68         EMUL_TARGET_TYPE_MAX
  69 } emul_target_type;
  70
  71 typedef enum {
  72         EMUL_NDEF_TNF_EMPTY = 0,
  73         EMUL_NDEF_TNF_WELL_KNOWN,
  74         EMUL_NDEF_TNF_MIME_MEDIA,
  75         EMUL_NDEF_TNF_ABSOLUTE_URI,
  76         EMUL_NDEF_TNF_EXTERNAL,
  77         EMUL_NDEF_TNF_UNKNOWN
  78 } emul_ndef_name_format;
  79
  80 typedef enum {
  81         NET_NFC_STATE_EXCHANGER_SERVER = 0x00,
  82         NET_NFC_STATE_EXCHANGER_SERVER_NPP,
  83
  84         NET_NFC_STATE_EXCHANGER_CLIENT,
  85         NET_NFC_STATE_CONN_HANDOVER_REQUEST,
  86         NET_NFC_STATE_CONN_HANDOVER_SELECT,
  87         NET_NFC_STATE_UNKNOWN
  88 } llcp_state_e;
  89
  90 typedef enum {
  91         SNEP_REQ_CONTINUE = 0x00,
  92         SNEP_REQ_GET = 0x01,
  93         SNEP_REQ_PUT = 0x02,
  94         SNEP_REQ_REJECT = 0x7F,
  95         SNEP_RESP_CONT = 0x80,
  96         SNEP_RESP_SUCCESS = 0x81,
  97         SNEP_RESP_NOT_FOUND = 0xC0,
  98         SNEP_RESP_EXCESS_DATA = 0xC1,
  99         SNEP_RESP_BAD_REQ = 0xC2,
 100         SNEP_RESP_NOT_IMPLEMENT = 0xE0,
 101         SNEP_RESP_UNSUPPORTED_VER = 0xE1,
 102         SNEP_RESP_REJECT = 0xFF,
 103 } snep_command_field_e;
 104
 105 typedef struct _socket_info_s {
 106         net_nfc_llcp_socket_t socket_handle;
 107         bool isValid;
 108         void* user_context;
 109 } socket_info_s;
 110
 111 typedef struct _net_nfc_oem_llcp_state_t {
 112         int client_fd;
 113         unsigned int step;
 114         unsigned int fragment_offset;
 115         llcp_state_e state;
 116         net_nfc_llcp_socket_t socket;
 117         uint16_t max_capability;
 118         net_nfc_target_handle_s * handle;
 119         net_nfc_error_e prev_result;
 120         net_nfc_llcp_socket_t incomming_socket;
 121         ndef_message_s *requester;
 122         ndef_message_s *selector;
 123         bool low_power;
 124         void * user_data;
 125         void * payload;
 126
 127         llcp_app_protocol_e type_app_protocol;
 128         net_nfc_conn_handover_carrier_type_e type;
 129
 130 } net_nfc_oem_llcp_state_t;
 131
 132 typedef struct _snep_msg_s {
 133         data_s *data;
 134         int offset;
 135         bool isSegment;
 136
 137         /* Members below are used for snep msg of client */
 138         bool firstTime;
 139         bool RespContinue;
 140 } snep_msg_s;
 141
 142 typedef struct _emulMsg_data_s {
 143         net_nfc_record_tnf_e tnf;
 144         data_s typeName;
 145         data_s id;
 146         data_s payload;
 147
 148         bool realRecord;
 149 } emulMsg_data_s;
 150
 151 typedef struct _emulMsg_s {
 152         emul_message_id message_id;
 153         emul_target_type target_type;
 154         int record_count;
 155         uint8_t* file_data;
 156 } emulMsg_s;
 157
 158 typedef void * (*emul_Nfc_thread_handler_t)   (void * pParam);
 159
 160 /***************************    STRUCTURE DEFINE START  ***************************************/
 161
 162 #define __USE_EPOLL_FOR_FILE__ 1
 163
 164
 165 /******************************             DEFINE START        *******************************************/
 166
 167 /* for emulator management */
 168 #define NET_NFC_EMUL_DATA_PATH                          "/dev"
 169 #define NET_NFC_EMUL_MESSAGE_FILE_NAME          "nfc0"
 170 #define NET_NFC_EMUL_MSG_ID_SEPERATOR                   "\n:"
 171 #define NET_NFC_EMUL_MSG_DATA_SEPERATOR         "\n\0"
 172 #define NET_NFC_EMUL_MSG_RECORD_SEPERATOR       "\n,"
 173 #define NET_NFC_EMUL_TAG_DISCOVERED_DATA_FORMAT "%d,%d,%[^\n]"
 174 #define NET_NFC_EMUL_HEADER_LENGTH              8
 175
 176 #ifdef __USE_EPOLL_FOR_FILE__
 177 #define EPOLL_SIZE 128
 178 #endif
 179
 180 /* for llcp functionality */
 181 #define LLCP_NB_SOCKET_MAX 5
 182 #define NET_NFC_EMUL_SNEP_SERVER_SOCKET_NUMBER 0
 183 #define NET_NFC_EMUL_INCOMING_SOCKET_NUMBER 0
 184 #define NET_NFC_EMUL_NPP_SERVER_SOCKET_NUMBER 1
 185 #define NET_NFC_EMUL_CLIENT_SOCKET_NUMBER 2
 186 #define NET_NFC_EMUL_HANDOVER_REQUEST_SOCKET_NUMBER 3
 187 #define NET_NFC_EMUL_HANDOVER_SELECT_SOCKET_NUMBER 4
 188
 189 #define SNEP_MAX_BUFFER 128
 190 #define SNEP_MAJOR_VER 1
 191 #define SNEP_MINOR_VER 0
 192
 193 /* static variable */
 194 #define BUFFER_LENGTH_MAX 4096
 195 #define READ_BUFFER_LENGTH_MAX BUFFER_LENGTH_MAX
 196 #define WRITE_BUFFER_LENGTH_MAX BUFFER_LENGTH_MAX
 197 #define NET_NFC_MAX_LLCP_SOCKET_BUFFER BUFFER_LENGTH_MAX
 198
 199 /******************************             DEFINE END  *******************************************/
 200
 201
 202
 203 /******************************          VARIABLE START *******************************************/
 204
 205 /* listener callback */
 206 static target_detection_listener_cb g_emul_controller_target_cb ;
 207 static se_transaction_listener_cb g_emul_controller_se_cb ;
 208 static llcp_event_listener_cb g_emul_controller_llcp_cb ;
 209 static hce_apdu_listener_cb g_emul_controller_hce_cb ;
 210
 211 /* for emulator management */
 212 pthread_t                       gEmulThread;
 213
 214 /* for stack management */
 215 static net_nfc_target_handle_s * current_working_handle = NULL;
 216 static bool g_stack_init_successful = 0;
 217 static bool g_tag_attached = 0;
 218 static bool g_p2p_attached = 0;
 219 static int current_connection_id = 1;
 220 /* for llcp functionality */
 221
 222 socket_info_s socket_info_array[LLCP_NB_SOCKET_MAX] = { {0, } };
 223
 224 snep_msg_s* Snep_Server_msg;
 225 data_s* llcp_server_data = NULL;
 226
 227 pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
 228
 229 /******************************          VARIABLE END   *******************************************/
 230
 231
 232
 233 /***************************    STATIC FUNCTION DECLARE START   ***************************************/
 234
 235 /***************************    INTERFACE START ***************************************/
 236
 237 static bool net_nfc_emul_controller_init(net_nfc_error_e* result);
 238 static bool net_nfc_emul_controller_deinit(void);
 239 static bool net_nfc_emul_controller_register_listener(
 240         target_detection_listener_cb target_detection_listener,
 241         se_transaction_listener_cb se_transaction_listener,
 242         llcp_event_listener_cb llcp_event_listener,
 243         hce_apdu_listener_cb hce_apdu_listener,
 244         net_nfc_error_e* result);
 245 static bool net_nfc_emul_controller_unregister_listener();
 246 static bool net_nfc_emul_controller_get_firmware_version(data_s **data, net_nfc_error_e *result);
 247 static bool net_nfc_emul_controller_check_firmware_version(net_nfc_error_e* result);
 248 static bool net_nfc_emul_controller_update_firmware(net_nfc_error_e* result);
 249 static bool net_nfc_emul_controller_get_stack_information(net_nfc_stack_information_s* stack_info, net_nfc_error_e* result);
 250 static bool net_nfc_emul_controller_configure_discovery(net_nfc_discovery_mode_e mode, net_nfc_event_filter_e config, net_nfc_error_e* result);
 251 static bool net_nfc_emul_controller_get_secure_element_list(net_nfc_secure_element_info_s* list, int* count, net_nfc_error_e* result);
 252 static bool net_nfc_emul_controller_set_secure_element_mode(net_nfc_secure_element_type_e element_type, net_nfc_secure_element_mode_e mode, net_nfc_error_e* result);
 253 static bool net_nfc_emul_controller_connect(net_nfc_target_handle_s* handle, net_nfc_error_e* result);
 254 static bool net_nfc_emul_controller_disconnect(net_nfc_target_handle_s* handle, net_nfc_error_e* result);
 255 static bool net_nfc_emul_controller_check_ndef(net_nfc_target_handle_s* handle, uint8_t *ndef_card_state, int* max_data_size, int* real_data_size, net_nfc_error_e* result);
 256 static bool net_nfc_emul_controller_check_target_presence(net_nfc_target_handle_s* handle, net_nfc_error_e* result);
 257 static bool net_nfc_emul_controller_read_ndef(net_nfc_target_handle_s* handle, data_s** data, net_nfc_error_e* result);
 258 static bool net_nfc_emul_controller_write_ndef(net_nfc_target_handle_s* handle, data_s* data, net_nfc_error_e* result);
 259 static bool net_nfc_emul_controller_make_read_only_ndef(net_nfc_target_handle_s* handle, net_nfc_error_e* result);
 260 static bool net_nfc_emul_controller_transceive(net_nfc_target_handle_s* handle, net_nfc_transceive_info_s* info, data_s** data, net_nfc_error_e* result);
 261 static bool net_nfc_emul_controller_format_ndef(net_nfc_target_handle_s* handle, data_s* secure_key, net_nfc_error_e* result);
 262 static bool net_nfc_emul_controller_exception_handler(void);
 263 static bool net_nfc_emul_controller_is_ready(net_nfc_error_e* error);
 264
 265 static bool net_nfc_emul_controller_llcp_config(net_nfc_llcp_config_info_s * config, net_nfc_error_e * result);
 266 static bool net_nfc_emul_controller_llcp_check_llcp(net_nfc_target_handle_s * handle, net_nfc_error_e* result);
 267 static bool net_nfc_emul_controller_llcp_activate_llcp(net_nfc_target_handle_s * handle, net_nfc_error_e* result);
 268 static bool net_nfc_emul_controller_llcp_create_socket(net_nfc_llcp_socket_t* socket, net_nfc_socket_type_e socketType, uint16_t miu, uint8_t rw,  net_nfc_error_e* result, void * user_param);
 269 static bool net_nfc_emul_controller_llcp_bind(net_nfc_llcp_socket_t socket, uint8_t service_access_point, net_nfc_error_e* result);
 270 static bool net_nfc_emul_controller_llcp_listen(net_nfc_target_handle_s* handle, uint8_t* service_access_name, net_nfc_llcp_socket_t socket, net_nfc_error_e* result, void * user_param);
 271 static bool net_nfc_emul_controller_llcp_accept(net_nfc_llcp_socket_t socket, net_nfc_error_e* result, void *user_param);
 272 static bool net_nfc_emul_controller_llcp_connect_by_url(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t  socket, uint8_t* service_access_name, net_nfc_error_e* result, void * user_param);
 273 static bool net_nfc_emul_controller_llcp_connect(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, uint8_t service_access_point, net_nfc_error_e* result, void * user_param);
 274 static bool net_nfc_emul_controller_llcp_reject(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t  socket, net_nfc_error_e* result);
 275 static bool net_nfc_emul_controller_llcp_disconnect(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, net_nfc_error_e* result, void * user_param);
 276 static bool net_nfc_emul_controller_llcp_socket_close(net_nfc_llcp_socket_t socket, net_nfc_error_e* result);
 277 static bool net_nfc_emul_controller_llcp_recv(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, data_s* data, net_nfc_error_e* result, void * user_param);
 278 static bool net_nfc_emul_controller_llcp_send(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t    socket, data_s* data, net_nfc_error_e* result, void * user_param);
 279 static bool net_nfc_emul_controller_llcp_recv_from(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, data_s * data, net_nfc_error_e* result, void * user_param);
 280 static bool net_nfc_emul_controller_llcp_send_to(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, data_s* data, uint8_t service_access_point, net_nfc_error_e* result, void * user_param);
 281 static bool net_nfc_emul_controller_llcp_get_remote_config(net_nfc_target_handle_s* handle, net_nfc_llcp_config_info_s *config, net_nfc_error_e* result);
 282 static bool net_nfc_emul_controller_llcp_get_remote_socket_info(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, net_nfc_llcp_socket_option_s * option, net_nfc_error_e* result);
 283
 284 static bool net_nfc_emul_controller_support_nfc(net_nfc_error_e *result);
 285 static bool net_nfc_emul_controller_secure_element_open(net_nfc_secure_element_type_e element_type,
 286         net_nfc_target_handle_s **handle, net_nfc_error_e *result);
 287 static bool net_nfc_emul_controller_secure_element_get_atr(net_nfc_target_handle_s *handle,
 288         data_s **atr, net_nfc_error_e *result);
 289 static bool net_nfc_emul_controller_secure_element_send_apdu(net_nfc_target_handle_s *handle,
 290         data_s *command, data_s **response, net_nfc_error_e *result);
 291 static bool net_nfc_emul_controller_secure_element_close(net_nfc_target_handle_s *handle,
 292             net_nfc_error_e *result);
 293
 294
 295 /***************************    INTERFACE END   ***************************************/
 296
 297
 298
 299 /***************************    ETC Function    ***************************************/
 300
 301 /* Memory utils */
 302 /* free memory, after free given memory it set NULL. Before proceed free, this function also check NULL */
 303 void __nfc_emul_util_free_mem(void** mem, char * filename, unsigned int line);
 304 /* allocation memory */
 305 void __nfc_emul_util_alloc_mem(void** mem, int size, char * filename, unsigned int line);
 306 #define  _nfc_emul_util_alloc_mem(mem, size) __nfc_emul_util_alloc_mem((void **)&mem, size, __FILE__, __LINE__)
 307 #define  _nfc_emul_util_free_mem(mem) __nfc_emul_util_free_mem((void **)&mem, __FILE__, __LINE__)
 308
 309
 310 static bool __net_nfc_is_valide_target_handle(net_nfc_target_handle_s * handle);
 311 static void __net_nfc_make_valid_target_handle(net_nfc_target_handle_s ** handle);
 312 static void __net_nfc_make_invalid_target_handle();
 313
 314 /***************************    STATIC FUNCTION DECLARE END             ***************************************/
 315
 316
 317
 318 void __nfc_emul_util_free_mem(void** mem, char * filename, unsigned int line)
 319 {
 320         if (mem == NULL || *mem == NULL) {
 321                 LOGE("FILE: %s, LINE:%d, Invalid parameter in mem free util (pinter is NULL)", filename, line);
 322                 return;
 323         }
 324         free(*mem);
 325         *mem = NULL;
 326 }
 327
 328 void __nfc_emul_util_alloc_mem(void** mem, int size, char * filename, unsigned int line)
 329 {
 330         if (mem == NULL || size <= 0) {
 331                 LOGE("FILE: %s, LINE:%d, Invalid parameter in mem alloc util", filename, line);
 332                 return;
 333         }
 334
 335         DEBUG_MSG("size to malloc() = [%d]", size);
 336
 337         if (*mem != NULL)
 338                 LOGE("FILE: %s, LINE:%d, WARNING: Pointer is already allocated or it was not initialized with NULL", filename, line);
 339
 340         *mem = malloc(size);
 341
 342         if (*mem != NULL)
 343                 memset(*mem, 0x0, size);
 344         else
 345                 LOGE("FILE: %s, LINE:%d, Allocation is failed", filename, line);
 346 }
 347
 348 static bool __net_nfc_is_valide_target_handle(net_nfc_target_handle_s * handle)
 349 {
 350         bool result = (current_working_handle == handle);
 351         if (!result)
 352                 DEBUG_MSG("[WARNING]: INVALID HANDLE IS DETECTED!");
 353
 354         return result;
 355 }
 356 static void __net_nfc_make_valid_target_handle(net_nfc_target_handle_s ** handle)
 357 {
 358         if (current_working_handle != NULL)
 359                 DEBUG_MSG("[WARNING]: HANDLE WAS ALLOCATED ALREADY!");
 360
 361         _nfc_emul_util_alloc_mem(*handle, sizeof(net_nfc_target_handle_s));
 362         if (*handle != NULL)
 363                 current_working_handle = *handle;
 364 }
 365 static void __net_nfc_make_invalid_target_handle()
 366 {
 367         if (current_working_handle != NULL) {
 368                 _nfc_emul_util_free_mem(current_working_handle);
 369                 current_working_handle = NULL;
 370         }
 371 }
 372
 373 static socket_info_s * _net_nfc_get_available_socket_slot()
 374 {
 375         int idx = 0;
 376         for (; idx < LLCP_NB_SOCKET_MAX; idx++) {
 377                 if (socket_info_array[idx].isValid == false) {
 378                         memset(&(socket_info_array[idx]), 0x00, sizeof(socket_info_s));
 379                         socket_info_array[idx].isValid = true;
 380                         return &(socket_info_array[idx]);
 381                 }
 382         }
 383
 384         DEBUG_ERR_MSG("_net_nfc_get_available_socket_slot is failed");
 385         return NULL;
 386 }
 387
 388 static void _net_nfc_remove_socket_slot(net_nfc_llcp_socket_t socket)
 389 {
 390         int idx = 0;
 391
 392         for (; idx < LLCP_NB_SOCKET_MAX; idx++) {
 393                 if (socket_info_array[idx].isValid == true &&
 394                         socket_info_array[idx].socket_handle == socket) {
 395                         socket_info_array[idx].isValid = false;
 396                         socket_info_array[idx].socket_handle = 0;
 397                         socket_info_array[idx].user_context = NULL;
 398                 }
 399         }
 400 }
 401
 402 static socket_info_s * _net_nfc_find_server_socket(net_nfc_llcp_socket_t socket)
 403 {
 404         int idx = 0;
 405         for (; idx < LLCP_NB_SOCKET_MAX; idx++) {
 406                 if (socket_info_array[idx].socket_handle == socket && socket_info_array[idx].isValid == true)
 407                         return &(socket_info_array[idx]);
 408         }
 409
 410         DEBUG_ERR_MSG("_net_nfc_find_server_socket is failed");
 411         return NULL;
 412 }
 413
 414 ////////////// INTERFACE START //////////
 415
 416 NET_NFC_EXPORT_API bool onload(net_nfc_oem_interface_s * emul_interfaces)
 417 {
 418         DEBUG_EMUL_BEGIN();
 419
 420         emul_interfaces->init = net_nfc_emul_controller_init;
 421         emul_interfaces->deinit = net_nfc_emul_controller_deinit;
 422         emul_interfaces->register_listener = net_nfc_emul_controller_register_listener;
 423         emul_interfaces->unregister_listener = net_nfc_emul_controller_unregister_listener;
 424         emul_interfaces->get_firmware_version = net_nfc_emul_controller_get_firmware_version;
 425         emul_interfaces->check_firmware_version = net_nfc_emul_controller_check_firmware_version;
 426         emul_interfaces->update_firmeware = net_nfc_emul_controller_update_firmware;
 427         emul_interfaces->get_stack_information = net_nfc_emul_controller_get_stack_information;
 428         emul_interfaces->configure_discovery = net_nfc_emul_controller_configure_discovery;
 429         emul_interfaces->get_secure_element_list = net_nfc_emul_controller_get_secure_element_list;
 430         emul_interfaces->set_secure_element_mode = net_nfc_emul_controller_set_secure_element_mode;
 431         emul_interfaces->connect = net_nfc_emul_controller_connect;
 432         emul_interfaces->disconnect = net_nfc_emul_controller_disconnect;
 433         emul_interfaces->check_ndef = net_nfc_emul_controller_check_ndef;
 434         emul_interfaces->check_presence = net_nfc_emul_controller_check_target_presence;
 435         emul_interfaces->read_ndef = net_nfc_emul_controller_read_ndef;
 436         emul_interfaces->write_ndef = net_nfc_emul_controller_write_ndef;
 437         emul_interfaces->make_read_only_ndef = net_nfc_emul_controller_make_read_only_ndef;
 438         emul_interfaces->transceive = net_nfc_emul_controller_transceive;
 439         emul_interfaces->format_ndef = net_nfc_emul_controller_format_ndef;
 440         emul_interfaces->exception_handler = net_nfc_emul_controller_exception_handler;
 441         emul_interfaces->is_ready = net_nfc_emul_controller_is_ready;
 442
 443         emul_interfaces->config_llcp = net_nfc_emul_controller_llcp_config;
 444         emul_interfaces->check_llcp_status = net_nfc_emul_controller_llcp_check_llcp;
 445         emul_interfaces->activate_llcp = net_nfc_emul_controller_llcp_activate_llcp;
 446         emul_interfaces->create_llcp_socket = net_nfc_emul_controller_llcp_create_socket;
 447         emul_interfaces->bind_llcp_socket = net_nfc_emul_controller_llcp_bind;
 448         emul_interfaces->listen_llcp_socket = net_nfc_emul_controller_llcp_listen;
 449         emul_interfaces->accept_llcp_socket = net_nfc_emul_controller_llcp_accept;
 450         emul_interfaces->connect_llcp_by_url = net_nfc_emul_controller_llcp_connect_by_url;
 451         emul_interfaces->connect_llcp = net_nfc_emul_controller_llcp_connect;
 452         emul_interfaces->disconnect_llcp = net_nfc_emul_controller_llcp_disconnect;
 453         emul_interfaces->close_llcp_socket = net_nfc_emul_controller_llcp_socket_close;
 454         emul_interfaces->recv_llcp = net_nfc_emul_controller_llcp_recv;
 455         emul_interfaces->send_llcp = net_nfc_emul_controller_llcp_send;
 456         emul_interfaces->recv_from_llcp = net_nfc_emul_controller_llcp_recv_from;
 457         emul_interfaces->send_to_llcp = net_nfc_emul_controller_llcp_send_to;
 458         emul_interfaces->reject_llcp = net_nfc_emul_controller_llcp_reject;
 459         emul_interfaces->get_remote_config = net_nfc_emul_controller_llcp_get_remote_config;
 460         emul_interfaces->get_remote_socket_info = net_nfc_emul_controller_llcp_get_remote_socket_info;
 461
 462         emul_interfaces->support_nfc = net_nfc_emul_controller_support_nfc;
 463
 464         emul_interfaces->secure_element_open = net_nfc_emul_controller_secure_element_open;
 465         emul_interfaces->secure_element_get_atr = net_nfc_emul_controller_secure_element_get_atr;
 466         emul_interfaces->secure_element_send_apdu = net_nfc_emul_controller_secure_element_send_apdu;
 467         emul_interfaces->secure_element_close = net_nfc_emul_controller_secure_element_close;
 468
 469         emul_interfaces->hce_response_apdu = NULL;
 470         emul_interfaces->route_aid = NULL;
 471         emul_interfaces->unroute_aid = NULL;
 472         emul_interfaces->commit_routing = NULL;
 473         emul_interfaces->set_default_route = NULL;
 474         emul_interfaces->clear_aid_table = NULL;
 475         emul_interfaces->get_aid_tablesize = NULL;
 476
 477         DEBUG_EMUL_END();
 478
 479         return true;
 480 }
 481
 482 static void _net_nfc_initialize_llcp(void)
 483 {
 484         DEBUG_EMUL_BEGIN();
 485
 486         if (Snep_Server_msg == NULL) {
 487                 Snep_Server_msg = (snep_msg_s *)calloc(1, sizeof(snep_msg_s));
 488                 if (Snep_Server_msg == NULL)
 489                         return;
 490
 491                 Snep_Server_msg->data = (data_s *)calloc(1, sizeof(data_s));
 492                 if (Snep_Server_msg->data == NULL)
 493                         return;
 494
 495                 Snep_Server_msg->data->buffer = (uint8_t *)calloc(1, sizeof(uint8_t) * BUFFER_LENGTH_MAX);
 496         }
 497
 498         DEBUG_EMUL_END();
 499 }
 500
 501 static void _net_nfc_deinitialize_llcp(void)
 502 {
 503         DEBUG_EMUL_BEGIN();
 504
 505         if (Snep_Server_msg != NULL) {
 506                 if (Snep_Server_msg->data != NULL) {
 507                         if (Snep_Server_msg->data->buffer != NULL) {
 508                                 free(Snep_Server_msg->data->buffer);
 509                                 Snep_Server_msg->data->buffer = NULL;
 510                         }
 511
 512                         free(Snep_Server_msg->data);
 513                         Snep_Server_msg->data = NULL;
 514                 }
 515
 516                 free(Snep_Server_msg);
 517                 Snep_Server_msg = NULL;
 518         }
 519
 520         llcp_server_data = NULL;
 521
 522         DEBUG_EMUL_END();
 523 }
 524
 525 static bool _net_nfc_emul_get_is_tag_attached(void)
 526 {
 527         return g_tag_attached;
 528 }
 529
 530 static void _net_nfc_emul_set_is_tag_attached(bool is_detached)
 531 {
 532         g_tag_attached = is_detached;
 533         DEBUG_MSG("set g_tag_attached [%d]", g_tag_attached);
 534 }
 535
 536 static bool _net_nfc_emul_get_is_p2p_attached(void)
 537 {
 538         return g_p2p_attached;
 539 }
 540
 541 static void _net_nfc_emul_set_is_p2p_attached(bool is_detached)
 542 {
 543         g_p2p_attached = is_detached;
 544         DEBUG_MSG("set g_p2p_attached [%d]", g_p2p_attached);
 545 }
 546
 547 static bool _net_nfc_is_data_emulMsgData(emul_message_id messageId)
 548 {
 549         DEBUG_EMUL_BEGIN();
 550
 551         bool retval = false;
 552
 553         switch (messageId) {
 554         case EMUL_NFC_TAG_DISCOVERED:
 555                 retval = true;
 556                 break;
 557
 558         case EMUL_NFC_P2P_SEND:
 559                 retval = true;
 560                 break;
 561
 562         case EMUL_NFC_TAG_DETACHED:
 563         case EMUL_NFC_P2P_DISCOVERED:
 564         case EMUL_NFC_P2P_DETACHED:
 565         default:
 566                 break;
 567
 568         }
 569
 570         DEBUG_MSG("retval [%d]", retval);
 571
 572         DEBUG_EMUL_END();
 573
 574         return retval;
 575 }
 576
 577 static net_nfc_record_tnf_e _net_nfc_get_tnf_type(int name_format)
 578 {
 579         DEBUG_EMUL_BEGIN();
 580
 581         net_nfc_record_tnf_e tnf = NET_NFC_RECORD_EMPTY;
 582
 583         switch (name_format) {
 584         case EMUL_NDEF_TNF_EMPTY:
 585                 tnf = NET_NFC_RECORD_EMPTY;
 586                 break;
 587
 588         case EMUL_NDEF_TNF_WELL_KNOWN:
 589                 tnf = NET_NFC_RECORD_WELL_KNOWN_TYPE;
 590                 break;
 591
 592         case EMUL_NDEF_TNF_MIME_MEDIA:
 593                 tnf = NET_NFC_RECORD_MIME_TYPE;
 594                 break;
 595
 596         case EMUL_NDEF_TNF_ABSOLUTE_URI:
 597                 tnf = NET_NFC_RECORD_URI;
 598                 break;
 599
 600         case EMUL_NDEF_TNF_EXTERNAL:
 601                 tnf = NET_NFC_RECORD_EXTERNAL_RTD;
 602                 break;
 603
 604         case EMUL_NDEF_TNF_UNKNOWN:
 605                 tnf = NET_NFC_RECORD_UNKNOWN;
 606                 break;
 607
 608         default:
 609                 tnf = NET_NFC_RECORD_UNKNOWN;
 610                 DEBUG_MSG("data is currupted");
 611                 break;
 612         }
 613
 614         DEBUG_MSG("tnf [%d]", tnf);
 615
 616         DEBUG_EMUL_END();
 617
 618         return tnf;
 619
 620 }
 621
 622 static int _net_nfc_create_records_from_emulMsg(emulMsg_s *emul_msg, ndef_message_s **ndef_message, int record_count)
 623 {
 624         DEBUG_EMUL_BEGIN();
 625
 626         int index;
 627         int create_record_count = 0;
 628         char emulMsg[BUFFER_LENGTH_MAX] = { 0, };
 629
 630         memcpy(emulMsg, emul_msg->file_data, sizeof(emulMsg)-1);
 631
 632         /* parsing data and create record to record structure */
 633         for (index = 0; index < record_count ; index++) {
 634                 char *name_format;
 635                 char *type_name;
 636                 char *record_id;
 637                 char *record_payload;
 638
 639                 emulMsg_data_s record = { 0, };
 640                 data_s filePayload = { NULL, 0 };
 641
 642                 /* parse string */
 643                 if (index == 0)
 644                         name_format = strtok((char *) emulMsg, NET_NFC_EMUL_MSG_RECORD_SEPERATOR);
 645                 else
 646                         name_format = strtok(NULL, NET_NFC_EMUL_MSG_RECORD_SEPERATOR);
 647
 648                 type_name = strtok(NULL, NET_NFC_EMUL_MSG_RECORD_SEPERATOR);
 649                 record_id = strtok(NULL, NET_NFC_EMUL_MSG_RECORD_SEPERATOR);
 650                 if (index == record_count-1) {
 651                         /* the last payload : we have to read sentence fully */
 652                         record_payload = strtok(NULL, "\n");
 653                 } else {
 654                         record_payload = strtok(NULL, NET_NFC_EMUL_MSG_RECORD_SEPERATOR);
 655                 }
 656
 657                 /* assign data to record structure */
 658                 record.tnf = _net_nfc_get_tnf_type(atoi(name_format));
 659
 660                 DEBUG_MSG("Data : type_name ");
 661
 662                 record.typeName.length = strlen(type_name);
 663                 _nfc_emul_util_alloc_mem(record.typeName.buffer, record.typeName.length + 1);
 664
 665                 if (record.typeName.buffer == NULL) {
 666                         DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
 667                         goto ERROR;
 668                 }
 669                 memcpy(record.typeName.buffer, type_name, sizeof(record.typeName.buffer) - 1);
 670
 671                 DEBUG_MSG("Data : record_id ");
 672
 673                 record.id.length = strlen(record_id);
 674                 _nfc_emul_util_alloc_mem(record.id.buffer, record.id.length + 1);
 675
 676                 if (record.id.buffer == NULL) {
 677                         DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
 678                         goto ERROR;
 679                 }
 680                 memcpy(record.id.buffer, record_id, sizeof(record.id.buffer) - 1);
 681
 682                 DEBUG_MSG("Data : record_payload ");
 683
 684                 record.payload.length = strlen(record_payload);
 685                 _nfc_emul_util_alloc_mem(record.payload.buffer, record.payload.length + 1);
 686
 687                 if (record.payload.buffer == NULL) {
 688                         DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
 689                         goto ERROR;
 690                 }
 691                 memcpy(record.payload.buffer, record_payload, sizeof(record.payload.buffer) - 1);
 692
 693 #ifndef __EMUL_DEBUG__
 694                 DEBUG_ERR_MSG("RECORD DATA START >>>>>>>>>>>>>>>>>>>>>>>>");
 695                 DEBUG_MSG("TNF >>>>[%d]", record.tnf);
 696                 LOGE("type_name >>>>[%s]", type_name);
 697                 LOGE("record_id >>>>[%s]", record_id);
 698                 DEBUG_MSG("record_payload >>>>[%s]", record_payload);
 699                 DEBUG_ERR_MSG("RECORD DATA END >>>>>>>>>>>>>>>>>>>>>>>>");
 700 #endif
 701
 702                 /* create record */
 703                 ndef_record_h new_record = NULL;
 704                 net_nfc_error_e result = NET_NFC_OK;
 705
 706                 if (record.tnf == NET_NFC_RECORD_EMPTY) {
 707                         if ((result = net_nfc_util_create_record(NET_NFC_RECORD_EMPTY, &record.typeName, &record.id, &record.payload, (ndef_record_s **) &new_record)) != NET_NFC_OK) {
 708                                 DEBUG_MSG("net_nfc_create_record failed[%d]", result);
 709                                 goto ERROR;;
 710                         }
 711                 } else if (record.tnf == NET_NFC_RECORD_UNKNOWN) {
 712                         if ((result = net_nfc_util_create_record(NET_NFC_RECORD_UNKNOWN, &record.typeName, &record.id, &record.payload, (ndef_record_s **) &new_record)) != NET_NFC_OK) {
 713                                 DEBUG_MSG("net_nfc_create_record failed[%d]", result);
 714                                 goto ERROR;;
 715                         }
 716                 } else if (record.tnf == NET_NFC_RECORD_WELL_KNOWN_TYPE) {
 717                         if (!strncmp((char *)record.typeName.buffer, "U", 1)) {
 718                                 DEBUG_MSG("URI Type ");
 719
 720                                 data_s payload_data = { NULL, 0 };
 721
 722                                 if (record.payload.buffer != NULL) {
 723                                         payload_data.length = strlen((char *)record_payload) + 1;
 724
 725                                         _nfc_emul_util_alloc_mem(payload_data.buffer, payload_data.length);
 726                                         if (payload_data.buffer == NULL) {
 727                                                 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
 728                                                 goto ERROR;
 729                                         }
 730
 731                                         payload_data.buffer[0] = NET_NFC_SCHEMA_FULL_URI;       /* first byte of payload is protocol scheme */
 732                                         memcpy(payload_data.buffer + 1, record.payload.buffer, payload_data.length - 1);
 733                                 }
 734
 735                                 if (net_nfc_util_create_record(record.tnf, &record.typeName, &record.id, &payload_data, (ndef_record_s**) &new_record) != NET_NFC_OK) {
 736                                         DEBUG_ERR_MSG("net_nfc_util_create_record is failed");
 737                                         goto ERROR;
 738                                 }
 739
 740                                 if (payload_data.buffer != NULL)
 741                                         _nfc_emul_util_free_mem(payload_data.buffer);
 742                         } else if (!strncmp((char *)record.typeName.buffer, "T", 1)) {
 743                                 DEBUG_MSG("TEXT Type ");
 744
 745                                 data_s payload_data = { NULL, 0 };
 746                                 int offset = 0;
 747                                 int controll_byte;
 748
 749                                 if (record.payload.buffer != NULL) {
 750                                         payload_data.length = strlen((char *)record_payload) + strlen("en-US") + 1;
 751
 752                                         _nfc_emul_util_alloc_mem(payload_data.buffer, payload_data.length);
 753                                         if (payload_data.buffer == NULL) {
 754                                                 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
 755                                                 goto ERROR;
 756                                         }
 757
 758                                         controll_byte = strlen("en-US") & 0x3F;
 759
 760                                         payload_data.buffer[0] = controll_byte;
 761
 762                                         offset = 1;
 763                                         memcpy(payload_data.buffer + offset, "en-US", strlen("en-US"));
 764
 765                                         offset = offset + strlen("en-US");
 766                                         memcpy(payload_data.buffer + offset, record.payload.buffer, strlen(record_payload));
 767                                 }
 768
 769                                 if (net_nfc_util_create_record(record.tnf, &record.typeName, &record.id, &payload_data, (ndef_record_s**) &new_record) != NET_NFC_OK) {
 770                                         DEBUG_ERR_MSG("net_nfc_util_create_record is failed");
 771                                         goto ERROR;
 772                                 }
 773
 774                                 if (payload_data.buffer != NULL)
 775                                         _nfc_emul_util_free_mem(payload_data.buffer);
 776                         } else {
 777                                 DEBUG_ERR_MSG("NET_NFC_RECORD_WELL_KNOWN_TYPE >> typeName is wrong");
 778                                 goto ERROR;
 779                         }
 780                 } else if ((record.tnf == NET_NFC_RECORD_MIME_TYPE)) {
 781                         FILE *file = NULL;
 782
 783                         /* open file : size limit? 10k? */
 784                         file = fopen(record_payload, "r");
 785                         if (file != NULL) {
 786                                 long int file_len = 0, read_count = 0, read_total = 0;
 787                                 uint8_t *file_data = NULL;
 788
 789                                 fseek(file, 0, SEEK_END);
 790                                 file_len = ftell(file);
 791                                 fseek(file, 0, SEEK_SET);
 792
 793                                 _nfc_emul_util_alloc_mem(file_data, file_len);
 794
 795                                 if (file_data == NULL) {
 796                                         DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
 797                                         fclose(file);
 798                                         goto ERROR;
 799                                 }
 800
 801                                 /* create payload */
 802                                 do {
 803                                         read_count = fread(file_data + read_total, 1, file_len - read_total, file);
 804                                         read_total += read_count;
 805                                 } while (read_count != 0 && read_total < file_len);
 806
 807                                 fclose(file);
 808
 809                                 DEBUG_MSG("fread(%s) success, size %ld", record.payload.buffer, file_len);
 810
 811                                 filePayload.length = file_len;
 812                                 _nfc_emul_util_alloc_mem(filePayload.buffer, filePayload.length);
 813
 814                                 if (filePayload.buffer == NULL) {
 815                                         DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
 816                                         _nfc_emul_util_free_mem(file_data);
 817                                         goto ERROR;
 818                                 }
 819                                 memcpy(filePayload.buffer, file_data, filePayload.length);
 820
 821                                 _nfc_emul_util_free_mem(file_data);
 822
 823                                 /* set id */
 824                                 if (record.id.buffer == NULL) {
 825                                         char *file_name = NULL;
 826
 827                                         file_name = strrchr(record_payload, '/');
 828                                         if (file_name == NULL)
 829                                                 file_name = (char *) record_payload;
 830                                         else
 831                                                 file_name++;
 832
 833                                         record.id.length = strlen(file_name);
 834                                         _nfc_emul_util_alloc_mem(record.id.buffer, record.id.length + 1);
 835
 836                                         if (record.id.buffer == NULL) {
 837                                                 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
 838                                                 _nfc_emul_util_free_mem(filePayload.buffer);
 839                                                 goto ERROR;
 840                                         }
 841                                         memcpy(record.id.buffer, file_name, sizeof(record.id.buffer) - 1);
 842                                 }
 843                         } else {
 844                                 DEBUG_MSG("file open error");
 845                                 goto ERROR;;
 846                         }
 847
 848                         /* create record */
 849                         if ((result = net_nfc_util_create_record(record.tnf, &record.typeName, &record.id, &filePayload, (ndef_record_s **) &new_record)) != NET_NFC_OK) {
 850                                 DEBUG_MSG("net_nfc_create_record failed[%d]", result);
 851                                 goto ERROR;;
 852                         }
 853                 } else {
 854                         /* NET_NFC_RECORD_URI or NET_NFC_RECORD_EXTERNAL_RTD */
 855                         if ((result = net_nfc_util_create_record(record.tnf, &record.typeName, &record.id, &record.payload, (ndef_record_s **) &new_record)) != NET_NFC_OK) {
 856                                 DEBUG_MSG("net_nfc_create_record failed[%d]", result);
 857                                 goto ERROR;;
 858                         }
 859                 }
 860
 861                 /* append record to ndef msg */
 862                 if ((result = net_nfc_util_append_record((ndef_message_s*) *ndef_message, (ndef_record_s *) new_record)) != NET_NFC_OK) {
 863                         DEBUG_MSG("net_nfc_util_append_record failed[%d]", result);
 864                         goto ERROR;;
 865                 }
 866
 867                 create_record_count++;
 868                 DEBUG_MSG("Create Record Sucess. Create Record Count[%d]", create_record_count);
 869                 continue;
 870 ERROR:
 871
 872                 /* free data */
 873                 if (record.typeName.buffer != NULL)
 874                         _nfc_emul_util_free_mem(record.typeName.buffer);
 875
 876                 if (record.id.buffer != NULL)
 877                         _nfc_emul_util_free_mem(record.id.buffer);
 878
 879                 if (record.payload.buffer != NULL)
 880                         _nfc_emul_util_free_mem(record.payload.buffer);
 881
 882                 if (filePayload.buffer != NULL)
 883                         _nfc_emul_util_free_mem(filePayload.buffer);
 884
 885                 DEBUG_MSG("Create Record Loop End");
 886                 break;
 887         }
 888
 889         DEBUG_EMUL_END();
 890
 891         return create_record_count;
 892 }
 893
 894 static bool _net_nfc_change_file_owner_permission(FILE *file)
 895 {
 896         char *buffer = NULL;
 897         size_t buffer_len = 0;
 898         struct passwd pwd = { 0, };
 899         struct passwd *pw_inhouse = NULL;
 900         struct group grp = { 0, };
 901         struct group *gr_inhouse = NULL;
 902
 903         if (file == NULL)
 904                 return false;
 905
 906         /* change permission */
 907         fchmod(fileno(file), 0644);
 908
 909         /* change owner */
 910         /* get passwd id */
 911         buffer_len = sysconf(_SC_GETPW_R_SIZE_MAX);
 912         if (buffer_len == -1)
 913                 buffer_len = 16384;
 914
 915         _net_nfc_util_alloc_mem(buffer, buffer_len);
 916         if (buffer == NULL)
 917                 return false;
 918
 919         getpwnam_r("inhouse", &pwd, buffer, buffer_len, &pw_inhouse);
 920         _net_nfc_util_free_mem(buffer);
 921
 922         /* get group id */
 923         buffer_len = sysconf(_SC_GETGR_R_SIZE_MAX);
 924         if (buffer_len == -1)
 925                 buffer_len = 16384;
 926
 927         _net_nfc_util_alloc_mem(buffer, buffer_len);
 928         if (buffer == NULL)
 929                 return false;
 930
 931         getgrnam_r("inhouse", &grp, buffer, buffer_len, &gr_inhouse);
 932         _net_nfc_util_free_mem(buffer);
 933
 934         if ((pw_inhouse != NULL) && (gr_inhouse != NULL)) {
 935                 if (fchown(fileno(file), pw_inhouse->pw_uid, gr_inhouse->gr_gid) < 0)
 936                         DEBUG_MSG("failed to change owner");
 937         }
 938
 939         return true;
 940 }
 941
 942 static void _net_nfc_store_ndef_message(data_s *data)
 943 {
 944         char file_name[1024] = { 0, };
 945         FILE *fp = NULL;
 946
 947         if (data == NULL)
 948                 return;
 949
 950         /* create file */
 951         snprintf(file_name, sizeof(file_name), "%s/%s/%s", "/opt/usr/share/nfc-manager-daemon",
 952                 "message", "emul-ndef-message.txt");
 953
 954         unlink(file_name);
 955
 956         if ((fp = fopen(file_name, "w")) != NULL) {
 957                 int length = 0;
 958
 959                 if ((length = fwrite(data->buffer, 1, data->length, fp)) > 0) {
 960                         DEBUG_MSG("[%d] bytes is written", length);
 961
 962                         _net_nfc_change_file_owner_permission(fp);
 963                         fflush(fp);
 964                         fsync(fileno(fp));
 965                 } else {
 966                         DEBUG_MSG("write is failed = [%d]", data->length);
 967                 }
 968
 969                 fclose(fp);
 970         }
 971 }
 972
 973 static net_nfc_error_e _net_nfc_retrieve_ndef_message(data_s *data)
 974 {
 975         char file_name[1024] = { 0, };
 976         FILE *fp = NULL;
 977         net_nfc_error_e result = NET_NFC_OK;
 978
 979         if (data == NULL)
 980                 return NET_NFC_NULL_PARAMETER;
 981
 982         /* retreive file */
 983         snprintf(file_name, sizeof(file_name), "%s/%s/%s", "/opt/usr/share/nfc-manager-daemon",
 984                 "message", "emul-ndef-message.txt");
 985
 986         if ((fp = fopen(file_name, "r")) != NULL) {
 987                 long int size = 0;
 988
 989                 /* rewind to start of file */
 990                 fseek(fp, 0, SEEK_END);
 991                 size = ftell(fp);
 992                 fseek(fp, 0, SEEK_SET);
 993
 994                 DEBUG_MSG("message length = [%ld]", size);
 995
 996                 if (size > 0) {
 997                         if (net_nfc_util_init_data(data, size) == true) {
 998                                 int current;
 999                                 size_t offset = 0;
1000
1001                                 /* read fully */
1002                                 do {
1003                                         current = fread(data->buffer + offset, 1,
1004                                                 data->length - offset, fp);
1005                                         if (current > 0)
1006                                                 offset += current;
1007                                         else
1008                                                 break;
1009                                 } while (offset < data->length);
1010
1011                                 if (offset == data->length)
1012                                         result = NET_NFC_OK;
1013                                 else
1014                                         result = NET_NFC_NO_NDEF_MESSAGE;
1015                         } else {
1016                                 result = NET_NFC_ALLOC_FAIL;
1017                         }
1018                 } else {
1019                         result = NET_NFC_OPERATION_FAIL;
1020                 }
1021
1022                 fclose(fp);
1023         } else {
1024                 result = NET_NFC_NO_DATA_FOUND;
1025         }
1026
1027         return result;
1028 }
1029
1030 static bool _net_nfc_create_ndef_from_emulMsg(emulMsg_s *emul_msg)
1031 {
1032         DEBUG_EMUL_BEGIN();
1033
1034         if (emul_msg->file_data == NULL)
1035                 return false;
1036
1037         int retval = true;
1038         net_nfc_error_e result = NET_NFC_OK;
1039         data_s rawdata = { NULL, 0 };
1040
1041         int record_count  = emul_msg->record_count;
1042
1043         if (record_count == 0)
1044                 return false;
1045
1046         /* create ndef msg */
1047         ndef_message_h ndef_message = NULL;
1048         int ndef_length = 0;
1049
1050         if ((result = net_nfc_util_create_ndef_message((ndef_message_s **) &ndef_message)) != NET_NFC_OK)
1051                 DEBUG_MSG("failed to create ndef message [%d]", result);
1052
1053         /* create records and append it to ndef_msg*/
1054         emul_msg->record_count = _net_nfc_create_records_from_emulMsg(emul_msg, (ndef_message_s **) &ndef_message, record_count);
1055
1056         /* convert ndef msg to raw data */
1057         ndef_length = net_nfc_util_get_ndef_message_length((ndef_message_s *) ndef_message);
1058
1059         if (!ndef_length)
1060                 DEBUG_MSG("ndef_message size is zero!");
1061
1062         rawdata.length = ndef_length;
1063         _nfc_emul_util_alloc_mem(rawdata.buffer, ndef_length);
1064
1065         if ((result = net_nfc_util_convert_ndef_message_to_rawdata((ndef_message_s*)ndef_message, &rawdata)) != NET_NFC_OK)
1066                 DEBUG_MSG("net_nfc_util_convert_ndef_message_to_rawdata is failed![%d]", result);
1067
1068         _net_nfc_store_ndef_message(&rawdata);
1069
1070         _nfc_emul_util_free_mem(rawdata.buffer);
1071         net_nfc_util_free_ndef_message(ndef_message);
1072
1073         DEBUG_EMUL_END();
1074
1075         return retval;
1076 }
1077
1078 static bool _net_nfc_create_emulMsg(emulMsg_s **emul_msg, uint8_t * data, long int size)
1079 {
1080         DEBUG_EMUL_BEGIN();
1081
1082         char *emulMsgID;
1083         char *emulMsgData;
1084
1085         *emul_msg = (emulMsg_s *)calloc(1, sizeof(emulMsg_s));
1086         if (*emul_msg == NULL)
1087                 return false;
1088
1089         /* emulData => ID : MSG ex) 100:1,1,1,U,samsung,http://www.naver.com */
1090         emulMsgID = strtok((char *)data, NET_NFC_EMUL_MSG_ID_SEPERATOR);
1091         if (emulMsgID != NULL)
1092                 (*emul_msg)->message_id = (emul_message_id) (atoi(emulMsgID));
1093
1094         DEBUG_MSG("emul_msg->message_id >>>>[%d]", (*emul_msg)->message_id);
1095
1096         if (_net_nfc_is_data_emulMsgData((*emul_msg)->message_id)) {
1097
1098                 emulMsgData = strtok(NULL, NET_NFC_EMUL_MSG_DATA_SEPERATOR);
1099                 DEBUG_MSG("emulMsgData >>>>[%s]", emulMsgData);
1100
1101                 switch ((*emul_msg)->message_id) {
1102                 case EMUL_NFC_TAG_DISCOVERED:
1103                 case EMUL_NFC_P2P_SEND:
1104                 {
1105                         /* get message : Tag Type, Record Count, Records */
1106                         int target_type = -1;
1107                         char file_data[BUFFER_LENGTH_MAX] = {0, };
1108                         int length = 0;
1109
1110                         sscanf(emulMsgData, NET_NFC_EMUL_TAG_DISCOVERED_DATA_FORMAT, &target_type, &((*emul_msg)->record_count), file_data);
1111
1112                         (*emul_msg)->target_type = (emul_target_type) target_type;
1113
1114                         length = strlen(file_data)+1;
1115                         _nfc_emul_util_alloc_mem((*emul_msg)->file_data, length);
1116                         memcpy((*emul_msg)->file_data, file_data, length);
1117
1118                         DEBUG_ERR_MSG("EMUL MESSAGE DATA START >>>>>>>>>>>>>>>>>>>>>>>>");
1119                         DEBUG_MSG("message_id >>>>[%d]", (*emul_msg)->message_id);
1120                         DEBUG_MSG("target_type >>>>[%d]", (*emul_msg)->target_type);
1121                         DEBUG_MSG("record_count >>>>[%d]", (*emul_msg)->record_count);
1122                         DEBUG_MSG("file_data >>>>[%s]", (char *)(*emul_msg)->file_data);
1123                         DEBUG_ERR_MSG("EMUL MESSAGE DATA END >>>>>>>>>>>>>>>>>>>>>>>>");
1124
1125                         if (!_net_nfc_create_ndef_from_emulMsg((*emul_msg)))
1126                                 DEBUG_ERR_MSG("read ndef_msg is failed >>>");
1127
1128                         DEBUG_ERR_MSG("_net_nfc_create_ndef_from_emulMsg end");
1129                         break;
1130                 }
1131
1132                 default:
1133                         /* exception case */
1134                         DEBUG_ERR_MSG("_net_nfc_set_emulMsg error. Data is currupted");
1135                         return false;
1136                         break;
1137                 }
1138         } else {
1139                 switch ((*emul_msg)->message_id) {
1140                 case EMUL_NFC_P2P_DISCOVERED:
1141                         (*emul_msg)->target_type = EMUL_NFC_TARGET;
1142                         break;
1143
1144                 case EMUL_NFC_TAG_DETACHED:
1145                         DEBUG_MSG("TAG DETACHED");
1146                         if (!_net_nfc_emul_get_is_tag_attached()) {
1147                                 DEBUG_ERR_MSG("tag is not attached!!");
1148                                 return false;
1149                         }
1150                         break;
1151
1152                 case EMUL_NFC_P2P_DETACHED:
1153                         DEBUG_MSG("P2P DETACHED");
1154                         if (!_net_nfc_emul_get_is_p2p_attached()) {
1155                                 DEBUG_ERR_MSG("tag is not attached!!");
1156                                 return false;
1157                         }
1158                         break;
1159
1160                 default:
1161                         /* exception case */
1162                         DEBUG_ERR_MSG("_net_nfc_set_emulMsg error. Data is currupted");
1163                         return false;
1164                         break;
1165                 }
1166         }
1167
1168         DEBUG_EMUL_END();
1169
1170         return true;
1171 }
1172
1173 static void _net_nfc_destroy_emulMsg(emulMsg_s *emul_msg)
1174 {
1175         DEBUG_EMUL_BEGIN();
1176
1177         if (emul_msg != NULL) {
1178                 if (emul_msg->file_data != NULL)
1179                         free(emul_msg->file_data);
1180
1181                 free(emul_msg);
1182         }
1183
1184         DEBUG_EMUL_END();
1185 }
1186
1187 static int _net_nfc_emul_convert_target_type(emul_target_type targetType)
1188 {
1189         DEBUG_EMUL_BEGIN();
1190
1191         int covert = 0;
1192
1193         switch (targetType) {
1194         case EMUL_TAG_TOPAZ_JEWEL:
1195                 covert = NET_NFC_JEWEL_PICC;
1196                 break;
1197
1198         case EMUL_TAG_MIFARE_UL:
1199                 covert = NET_NFC_MIFARE_ULTRA_PICC;
1200                 break;
1201
1202         case EMUL_TAG_FELICA:
1203                 covert = NET_NFC_FELICA_PICC;
1204                 break;
1205
1206         case EMUL_TAG_MIFARE_DESFIRE:
1207                 covert = NET_NFC_MIFARE_DESFIRE_PICC;
1208                 break;
1209
1210         case EMUL_NFC_TARGET:
1211                 covert = NET_NFC_NFCIP1_TARGET;
1212                 break;
1213
1214         case EMUL_TARGET_TYPE_MAX:
1215         default:
1216                 /* exception case */
1217                 DEBUG_ERR_MSG("_net_nfc_emul_convert_target_type error. Target type is unknown");
1218                 break;
1219         }
1220
1221         DEBUG_MSG("covert [%d]", covert);
1222
1223         DEBUG_EMUL_END();
1224
1225         return covert;
1226 }
1227
1228 static void _net_nfc_target_discovered_cb(emulMsg_s *emul_msg)
1229 {
1230         DEBUG_EMUL_BEGIN();
1231
1232         /* make handle */
1233         net_nfc_target_handle_s* handle = NULL;
1234         int length = 0;
1235
1236         __net_nfc_make_valid_target_handle(&handle);
1237         if (handle == NULL)
1238                 return;
1239
1240         /* make msg */
1241         net_nfc_request_target_detected_t* target_detected = NULL;
1242         uint8_t device_info[] = { 0x03, 0x55, 0x49, 0x44, 0x07, 0x04, 0x93, 0xB7, 0xD9, 0x5B, 0x02, 0x80, \
1243                 0x08, 0x41, 0x50, 0x50, 0x5F, 0x44, 0x41, 0x54, 0x41, 0x00, 0x03, 0x53, 0x41, 0x4B, \
1244                 0x01, 0x00, 0x04, 0x41, 0x54, 0x51, 0x41, 0x02, 0x44, 0x00, 0x0D, 0x4D, 0x41, 0x58, \
1245                 0x5F, 0x44, 0x41, 0x54, 0x41, 0x5F, 0x52, 0x41, 0x54, 0x45, 0x01, 0x00, 0x08, 0x46, \
1246                 0x57, 0x49, 0x5F, 0x53, 0x46, 0x47, 0x54, 0x01, 0x03, 0x49, 0x44, 0x6D, 0x07, 0x04, \
1247                 0x93, 0xB7, 0xD9, 0x5B, 0x02, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
1248
1249
1250         length = sizeof(net_nfc_request_target_detected_t) + sizeof(device_info);
1251         _nfc_emul_util_alloc_mem(target_detected, length);
1252         if (target_detected == NULL)
1253                 return;
1254
1255         target_detected->length = length;
1256         target_detected->request_type = NET_NFC_MESSAGE_SERVICE_STANDALONE_TARGET_DETECTED;
1257         target_detected->handle = handle;
1258
1259         target_detected->devType = _net_nfc_emul_convert_target_type(emul_msg->target_type);
1260         if (!target_detected->devType) {
1261                 DEBUG_MSG("target_detected->devType is unknown");
1262                 _nfc_emul_util_free_mem(target_detected);
1263                 return;
1264         }
1265
1266         target_detected->handle->connection_id = current_connection_id++;
1267
1268         if (target_detected->devType == NET_NFC_NFCIP1_TARGET) {
1269                 DEBUG_MSG("set llcp connection  type. remote device is target");
1270                 handle->connection_type = NET_NFC_P2P_CONNECTION_TARGET;
1271                 _net_nfc_emul_set_is_p2p_attached(true);
1272         } else if (target_detected->devType == NET_NFC_NFCIP1_INITIATOR) {
1273                 DEBUG_MSG("set llcp connection  type. remote device is initiator");
1274                 handle->connection_type = NET_NFC_P2P_CONNECTION_INITIATOR;
1275                 _net_nfc_emul_set_is_p2p_attached(true);
1276         } else {
1277                 DEBUG_MSG("set tag connection");
1278                 handle->connection_type = NET_NFC_TAG_CONNECTION;
1279                 _net_nfc_emul_set_is_tag_attached(true);
1280         }
1281
1282         target_detected->number_of_keys = 7;
1283         target_detected->target_info_values.length = sizeof(device_info);
1284         memcpy(&target_detected->target_info_values.buffer, device_info, target_detected->target_info_values.length);
1285
1286         /* call target_cb */
1287         if (g_emul_controller_target_cb != NULL) {
1288                 DEBUG_MSG("discovered callback is called");
1289                 g_emul_controller_target_cb(target_detected, NULL);
1290         }
1291         DEBUG_EMUL_END();
1292 }
1293
1294 static void _net_nfc_tag_detached_cb(void)
1295 {
1296         DEBUG_EMUL_BEGIN();
1297
1298         _net_nfc_emul_set_is_tag_attached(false);
1299
1300         DEBUG_EMUL_END();
1301 }
1302
1303 static void _net_nfc_target_detached_cb(void)
1304 {
1305         DEBUG_EMUL_BEGIN();
1306
1307         _net_nfc_emul_set_is_p2p_attached(false);
1308
1309         /* For P2P, we send msg to manager */
1310         net_nfc_request_llcp_msg_t *req_msg = NULL;
1311
1312         _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
1313
1314         if (req_msg != NULL) {
1315                 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
1316                 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_DEACTIVATED;
1317
1318                 DEBUG_MSG("deactivated callback is called");
1319                 g_emul_controller_llcp_cb(req_msg, NULL);
1320         }
1321 }
1322
1323 static void _net_nfc_llcp_data_receive_cb(void* pContext)
1324 {
1325         DEBUG_EMUL_BEGIN();
1326
1327         net_nfc_request_llcp_msg_t *req_msg = NULL;
1328
1329         _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
1330
1331         if (req_msg != NULL) {
1332                 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
1333                 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_RECEIVE;
1334                 req_msg->result = NET_NFC_OK;
1335
1336                 DEBUG_MSG("receive callback is called >>");
1337                 g_emul_controller_llcp_cb(req_msg, pContext);
1338         }
1339
1340         DEBUG_EMUL_END();
1341 }
1342
1343 static void _net_nfc_llcp_data_receive_from_cb(void* pContext)
1344 {
1345         DEBUG_EMUL_BEGIN();
1346
1347         net_nfc_request_llcp_msg_t *req_msg = NULL;
1348
1349         _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
1350
1351         if (req_msg != NULL) {
1352                 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
1353                 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_RECEIVE_FROM;
1354                 req_msg->result = NET_NFC_OK;
1355
1356                 DEBUG_MSG("receive_from callback is called >>");
1357                 g_emul_controller_llcp_cb(req_msg, pContext);
1358         }
1359
1360         DEBUG_EMUL_END();
1361 }
1362
1363 static void _net_nfc_llcp_create_snep_server_msg(snep_command_field_e resp_field)
1364 {
1365         DEBUG_EMUL_BEGIN();
1366
1367         uint8_t* temp = Snep_Server_msg->data->buffer;
1368         uint8_t response = (uint8_t)resp_field;
1369         uint8_t version = 0;
1370         uint32_t length_field = 0;
1371         data_s rawdata = { NULL, 0 };
1372
1373         version = SNEP_MAJOR_VER;
1374         version = (((version << 4) & 0xf0) | (SNEP_MINOR_VER & 0x0f));
1375
1376         _net_nfc_retrieve_ndef_message(&rawdata);
1377
1378         /* version response length payload*/
1379         Snep_Server_msg->data->length = sizeof(uint8_t) + sizeof(uint8_t) + sizeof(uint32_t) + rawdata.length;
1380
1381         /* copy version */
1382         *temp = version;
1383         temp++;
1384
1385         /* copy response */
1386         *temp = response;
1387         temp++;
1388
1389         length_field = htonl(rawdata.length);
1390
1391         /* length will be se 0. so we don't need to copy value */
1392         memcpy(temp, &length_field, sizeof(uint32_t));
1393         temp += sizeof(uint32_t);
1394
1395         /* copy ndef information to response msg */
1396         if (rawdata.length > 0)
1397                 memcpy(temp, rawdata.buffer, rawdata.length);
1398
1399         _nfc_emul_util_free_mem(rawdata.buffer);
1400
1401         DEBUG_EMUL_END();
1402 }
1403
1404 static llcp_state_e _net_nfc_get_llcp_state(void* pContext)
1405 {
1406         DEBUG_EMUL_BEGIN();
1407         llcp_state_e state;
1408
1409         state = NET_NFC_STATE_EXCHANGER_SERVER;
1410
1411         DEBUG_EMUL_END();
1412
1413         return state;
1414 }
1415
1416 static bool _net_nfc_make_llcp_data(emulMsg_s *emul_msg)
1417 {
1418         DEBUG_EMUL_BEGIN();
1419         data_s rawdata = { NULL, 0 };
1420
1421         _net_nfc_retrieve_ndef_message(&rawdata);
1422         _nfc_emul_util_free_mem(rawdata.buffer);
1423
1424         if (emul_msg->record_count == 0 || rawdata.length == 0) {
1425                 DEBUG_ERR_MSG("data is zero >>>");
1426                 return false;
1427         }
1428
1429         /* For SNEP, we should create snep msg, and then copy it to llcp_server_data */
1430         _net_nfc_llcp_create_snep_server_msg(SNEP_REQ_PUT);
1431
1432         /* copy rawdata to llcp_server_data->buffer */
1433         if (Snep_Server_msg->data->length <= SNEP_MAX_BUFFER) {
1434                 DEBUG_MSG("The snep msg size is small than SNEP_MAX_BUFFER >>>");
1435
1436                 if (llcp_server_data == NULL)
1437                         return false;
1438
1439                 llcp_server_data->length = Snep_Server_msg->data->length;
1440                 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer, Snep_Server_msg->data->length);
1441         } else {
1442                 DEBUG_MSG("send first segment >>>");
1443
1444                 if (llcp_server_data == NULL)
1445                         return false;
1446
1447                 llcp_server_data->length = SNEP_MAX_BUFFER;
1448                 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer, SNEP_MAX_BUFFER);
1449
1450                 Snep_Server_msg->isSegment = true;
1451                 Snep_Server_msg->offset = SNEP_MAX_BUFFER;
1452         }
1453
1454         DEBUG_EMUL_END();
1455
1456         return true;
1457 }
1458
1459 static void _net_nfc_send_emulMsg_to_nfc_manager(emulMsg_s *emul_msg)
1460 {
1461         DEBUG_EMUL_BEGIN();
1462
1463         switch (emul_msg->message_id) {
1464         case EMUL_NFC_TAG_DISCOVERED:
1465                 _net_nfc_target_discovered_cb(emul_msg);
1466                 break;
1467
1468         case EMUL_NFC_TAG_DETACHED:
1469                 _net_nfc_tag_detached_cb();
1470                 break;
1471
1472         case EMUL_NFC_P2P_DISCOVERED:
1473                 _net_nfc_initialize_llcp();
1474                 _net_nfc_target_discovered_cb(emul_msg);
1475                 break;
1476
1477         case EMUL_NFC_P2P_SEND:
1478                 if (!_net_nfc_emul_get_is_p2p_attached()) {
1479                         DEBUG_ERR_MSG("target is not attached!!");
1480                         return;
1481                 }
1482
1483                 if (_net_nfc_make_llcp_data(emul_msg)) {
1484                         /* find snep server*/
1485                         socket_info_s *socket_info = _net_nfc_find_server_socket(NET_NFC_EMUL_SNEP_SERVER_SOCKET_NUMBER);
1486                         if (socket_info == NULL) {
1487                                 DEBUG_ERR_MSG("socket_info is NULL");
1488                                 return;
1489                         }
1490
1491                         _net_nfc_llcp_data_receive_cb(socket_info->user_context); /* call callback */
1492                 } else {
1493                         DEBUG_ERR_MSG("make_p2p_data is fail!!");
1494                         return;
1495                 }
1496                 break;
1497
1498         case EMUL_NFC_P2P_DETACHED:
1499                 if (!_net_nfc_emul_get_is_p2p_attached()) {
1500                         DEBUG_ERR_MSG("target is not attached!!");
1501                         return;
1502                 }
1503
1504                 _net_nfc_target_detached_cb();
1505                 _net_nfc_deinitialize_llcp();
1506                 break;
1507
1508         default:
1509                 DEBUG_ERR_MSG("message_id is wrong!!");
1510                 break;
1511         }
1512
1513         DEBUG_EMUL_END();
1514 }
1515
1516 static void _net_nfc_process_emulMsg(uint8_t * data, long int size)
1517 {
1518         DEBUG_EMUL_BEGIN();
1519
1520         emulMsg_s *emul_msg = NULL;
1521
1522         /* create emul_msg */
1523         _net_nfc_create_emulMsg(&emul_msg, data, size);
1524
1525         DEBUG_MSG("emul_msg->message_id >>>>[%d]", emul_msg->message_id);
1526
1527         /* processing emul_msg */
1528         _net_nfc_send_emulMsg_to_nfc_manager(emul_msg);
1529
1530         /* destroy emul_msg */
1531         _net_nfc_destroy_emulMsg(emul_msg);
1532
1533         DEBUG_EMUL_END();
1534 }
1535
1536 #ifdef __USE_EPOLL_FOR_FILE__
1537 static void emul_ReaderThread(void * pArg)
1538 {
1539         DEBUG_MSG("emul_ReaderThread START >>>>");
1540
1541         char file_name[1024] = { 0, };
1542         bool condition = true;
1543
1544         int emulMsg_file_fd = -1;
1545         int emulMsg_poll_fd = -1;
1546         struct epoll_event *emulMsg_poll_events = NULL;
1547
1548         /* make file name */
1549         snprintf(file_name, sizeof(file_name), "%s/%s", NET_NFC_EMUL_DATA_PATH, NET_NFC_EMUL_MESSAGE_FILE_NAME);
1550         LOGE("file path : %s", file_name);
1551
1552         /* open file for poll */
1553         emulMsg_file_fd = open(file_name, O_RDONLY|O_NONBLOCK);
1554         if (emulMsg_file_fd < 0) {
1555                 DEBUG_MSG("file open error !!!!");
1556                 return;
1557         }
1558
1559         /* create epoll */
1560         if ((emulMsg_poll_fd = epoll_create1(EPOLL_CLOEXEC)) == -1) {
1561                 DEBUG_MSG("epoll_create1 is occured");
1562                 close(emulMsg_file_fd);
1563                 return;
1564         }
1565
1566         if ((emulMsg_poll_events = (struct epoll_event *)calloc(1, sizeof(struct epoll_event) * EPOLL_SIZE)) == NULL) {
1567                 DEBUG_MSG("calloc is occured");
1568                 close(emulMsg_file_fd);
1569                 return;
1570         }
1571
1572         /* set event */
1573         struct epoll_event ev;
1574
1575         ev.events = EPOLLIN | EPOLLET | EPOLLHUP | EPOLLERR;
1576         ev.data.fd = emulMsg_file_fd;
1577
1578         /* add file fd to epoll */
1579         epoll_ctl(emulMsg_poll_fd, EPOLL_CTL_ADD, emulMsg_file_fd, &ev);
1580
1581         while (condition == true) {
1582
1583                 int num_of_files = 0;
1584                 int index = 0;
1585
1586                 /* to do : I will add mutex in the future */
1587                 /* lock mutex */
1588
1589                 DEBUG_MSG("epoll wait >>>>");
1590
1591                 while ((num_of_files = epoll_wait(emulMsg_poll_fd, emulMsg_poll_events, EPOLL_SIZE, -1)) == 0)
1592                         DEBUG_MSG("no data is changed ");
1593
1594                 for (index = 0; index < num_of_files; index++) {
1595                         if ((emulMsg_poll_events[index].events & (EPOLLHUP)) || (emulMsg_poll_events[index].events & (EPOLLERR))) {
1596                                 DEBUG_MSG("connection is closed");
1597
1598                                 condition = 0;
1599                         } else if (emulMsg_poll_events[index].events & EPOLLIN) {
1600                                 if (emulMsg_poll_events[index].data.fd == emulMsg_file_fd) {
1601                                         char readbuffer[READ_BUFFER_LENGTH_MAX + 1];
1602                                         int readcnt = 0;
1603
1604                                         DEBUG_MSG("precess POLLIN ");
1605
1606                                         memset(readbuffer, 0x00, sizeof(READ_BUFFER_LENGTH_MAX) + 1);
1607
1608                                         readcnt = read(emulMsg_file_fd, readbuffer, READ_BUFFER_LENGTH_MAX);
1609
1610                                         DEBUG_MSG("message readcnt= [%d] ", readcnt);
1611                                         DEBUG_MSG("message = [%s] ", readbuffer);
1612
1613                                         /* remove header */
1614                                         _net_nfc_process_emulMsg((uint8_t *)readbuffer + NET_NFC_EMUL_HEADER_LENGTH, (long int)readcnt - NET_NFC_EMUL_HEADER_LENGTH);
1615                                 } else {
1616                                         DEBUG_MSG("not expected socket connection");
1617                                         condition = 0;
1618                                 }
1619                         } else {
1620                                 if (num_of_files == index) {
1621                                         DEBUG_MSG("unknown event");
1622                                         condition = 0;
1623                                 }
1624                         }
1625
1626
1627                 }
1628
1629                 /* unlock mutex */
1630
1631         }
1632
1633         close(emulMsg_file_fd);
1634
1635         if (emulMsg_poll_events != NULL)
1636                 free(emulMsg_poll_events);
1637
1638         DEBUG_MSG("emul_ReaderThread END >>>>");
1639 }
1640
1641 #else
1642
1643 static void emul_ReaderThread(void * pArg)
1644 {
1645         DEBUG_MSG("emul_ReaderThread START >>>>");
1646
1647         FILE *fp = NULL;
1648         char file_name[1024] = { 0, };
1649
1650         char readBuffer[READ_BUFFER_LENGTH_MAX];
1651
1652         struct stat st;
1653
1654         time_t curTime;
1655
1656         bool condition = true;
1657
1658         /* make file name */
1659         snprintf(file_name, sizeof(file_name), "%s/%s", NET_NFC_EMUL_DATA_PATH, NET_NFC_EMUL_MESSAGE_FILE_NAME);
1660         LOGE("file path : %s", file_name);
1661
1662         time(&curTime);
1663         DEBUG_MSG("Start Current Time [%ld]", (unsigned long) curTime);
1664
1665         /* polling 500 ms */
1666
1667         while (condition != 0) {
1668                 usleep(500 * 1000);
1669
1670                 /* open file */
1671                 if ((fp = fopen(file_name, "r")) == NULL) {
1672                         DEBUG_MSG("file open error");
1673                         condition = false;
1674                 } else {
1675                         /* get the modified time of the file */
1676                         if (stat(file_name, &st) == 0) {
1677                                 if ((unsigned long) st.st_mtime <= (unsigned long) curTime) {
1678                                         fclose(fp);
1679                                         continue;
1680                                 } else {
1681                                         DEBUG_MSG("FILE Modified Time [%ld]", (unsigned long) st.st_mtime);
1682                                         /* update current time */
1683                                         time(&curTime);
1684                                         DEBUG_MSG("Get New Current Time [%ld]", (unsigned long) curTime);
1685                                 }
1686
1687                         } else {
1688                                 DEBUG_MSG("stat error");
1689                                 fclose(fp);
1690                                 continue;
1691                         }
1692
1693                         /* read data */
1694                         memset(readBuffer, 0x00, READ_BUFFER_LENGTH_MAX);
1695
1696                         if (fscanf(fp, "%[^\n]", readBuffer))
1697                                 DEBUG_MSG("get DATA >>>> readBuffer [%s]", readBuffer);
1698
1699                         /* process message */
1700                         _net_nfc_process_emulMsg((uint8_t *) readBuffer, (long int) strlen(readBuffer));
1701
1702                         fclose(fp);
1703                 }
1704
1705                 DEBUG_MSG("LOOP END >>>>");
1706
1707         }
1708
1709         DEBUG_MSG("emul_ReaderThread END >>>>");
1710 }
1711 #endif
1712
1713 static bool _net_nfc_emul_controller_start_thread(void)
1714 {
1715         bool ret = true;
1716
1717         DEBUG_EMUL_BEGIN();
1718
1719         ret = pthread_create(&gEmulThread, NULL,  (emul_Nfc_thread_handler_t)emul_ReaderThread,  (void*) "emul_read_thread");
1720
1721         if (ret != 0)
1722                 return false;
1723
1724         DEBUG_EMUL_END();
1725
1726         return true;
1727 }
1728
1729 static void _net_nfc_emul_controller_stop_thread(void)
1730 {
1731         DEBUG_EMUL_BEGIN();
1732
1733         pthread_cancel(gEmulThread);
1734
1735         usleep(500 * 1000);
1736
1737         pthread_cond_signal(&cond);
1738
1739         pthread_join(gEmulThread, NULL);
1740
1741         DEBUG_EMUL_END();
1742 }
1743
1744 static bool net_nfc_emul_controller_init(net_nfc_error_e* result)
1745 {
1746         bool ret = true;
1747
1748         if (result == NULL)
1749                 return false;
1750
1751         DEBUG_EMUL_BEGIN();
1752
1753         DEBUG_MSG("start stack init ");
1754
1755         if (g_stack_init_successful == true) {
1756                 DEBUG_MSG("Already statck is initialized");
1757                 return true;
1758         }
1759
1760
1761         /* start reader thread : to get event from Inject */
1762         if (!_net_nfc_emul_controller_start_thread()) {
1763                 DEBUG_ERR_MSG("Failed to create emul thread");
1764                 return false;
1765         }
1766
1767         DEBUG_MSG("Stack init finished");
1768
1769         g_stack_init_successful = true;
1770         *result = NET_NFC_OK;
1771
1772         DEBUG_EMUL_END();
1773
1774         return ret;
1775 }
1776
1777 static bool net_nfc_emul_controller_deinit(void)
1778 {
1779         DEBUG_EMUL_BEGIN();
1780
1781         /* End thread */
1782         if (g_stack_init_successful == false) {
1783                 DEBUG_MSG("Already statck is deinitialized");
1784                 return true;
1785         }
1786
1787         _net_nfc_emul_controller_stop_thread();
1788
1789         g_stack_init_successful = false;
1790
1791         DEBUG_EMUL_END();
1792
1793         return true;
1794 }
1795 static bool net_nfc_emul_controller_register_listener(
1796         target_detection_listener_cb target_detection_listener,
1797         se_transaction_listener_cb se_transaction_listener,
1798         llcp_event_listener_cb llcp_event_listener,
1799         hce_apdu_listener_cb hce_apdu_listener,
1800         net_nfc_error_e* result)
1801 {
1802         if (result == NULL)
1803                 return false;
1804
1805         *result = NET_NFC_OK;
1806
1807         DEBUG_EMUL_BEGIN();
1808
1809         g_emul_controller_target_cb = target_detection_listener;
1810         g_emul_controller_se_cb = se_transaction_listener;
1811         g_emul_controller_llcp_cb = llcp_event_listener;
1812         g_emul_controller_hce_cb = hce_apdu_listener;
1813
1814         DEBUG_EMUL_END();
1815
1816         return true;
1817 }
1818
1819 static bool net_nfc_emul_controller_unregister_listener()
1820 {
1821         DEBUG_EMUL_BEGIN();
1822
1823         g_emul_controller_target_cb = NULL;
1824         g_emul_controller_se_cb = NULL;
1825         g_emul_controller_llcp_cb = NULL;
1826
1827         DEBUG_EMUL_END();
1828
1829         return true;
1830 }
1831
1832 static bool net_nfc_emul_controller_get_firmware_version(data_s **data, net_nfc_error_e *result)
1833 {
1834         if (data == NULL || result == NULL)
1835                 return false;
1836
1837         *result = NET_NFC_OK;
1838
1839         DEBUG_EMUL_BEGIN();
1840
1841         *data = (data_s *)calloc(1, sizeof(data_s));
1842
1843         if (*data == NULL)
1844                 return false;
1845
1846         (*data)->length = 10;
1847         (*data)->buffer = (uint8_t *)calloc(1, (*data)->length);
1848
1849         if ((*data)->buffer == NULL)
1850                 return false;
1851
1852         snprintf((char *)(*data)->buffer, (*data)->length, "%d.%d", 1, 0);
1853
1854         DEBUG_EMUL_END();
1855
1856         return true;
1857 }
1858
1859 static bool net_nfc_emul_controller_check_firmware_version(net_nfc_error_e* result)
1860 {
1861         if (result == NULL)
1862                 return false;
1863
1864         *result = NET_NFC_OK;
1865
1866         DEBUG_EMUL_BEGIN();
1867
1868         DEBUG_EMUL_END();
1869
1870         return true;
1871 }
1872
1873 static bool net_nfc_emul_controller_update_firmware(net_nfc_error_e* result)
1874 {
1875         if (result == NULL)
1876                 return false;
1877
1878         *result = NET_NFC_OK;
1879
1880         DEBUG_EMUL_BEGIN();
1881
1882         DEBUG_EMUL_END();
1883
1884         return true;
1885 }
1886
1887 static bool net_nfc_emul_controller_get_stack_information(net_nfc_stack_information_s* stack_info, net_nfc_error_e* result)
1888 {
1889         if (result == NULL)
1890                 return false;
1891
1892         *result = NET_NFC_OK;
1893
1894         DEBUG_EMUL_BEGIN();
1895
1896         DEBUG_EMUL_END();
1897
1898         return true;
1899 }
1900
1901 static bool net_nfc_emul_controller_configure_discovery(net_nfc_discovery_mode_e mode, net_nfc_event_filter_e config, net_nfc_error_e* result)
1902 {
1903         int idx;
1904         bool ret = true;
1905
1906         if (result == NULL)
1907                 return false;
1908
1909         *result = NET_NFC_OK;
1910
1911         if (mode == NET_NFC_DISCOVERY_MODE_START) {
1912                 mode = NET_NFC_DISCOVERY_MODE_CONFIG;
1913         } else if (mode == NET_NFC_DISCOVERY_MODE_STOP) {
1914                 mode = NET_NFC_DISCOVERY_MODE_CONFIG;
1915                 config = NET_NFC_ALL_DISABLE;
1916         }
1917
1918         DEBUG_EMUL_BEGIN();
1919
1920         if ((mode == NET_NFC_DISCOVERY_MODE_CONFIG)) {
1921                 if (config == NET_NFC_ALL_DISABLE) {
1922                         /* This handle is not useful anymore */
1923                         __net_nfc_make_invalid_target_handle();
1924
1925                         /* reset socket_info */
1926                         for (idx = 0; idx < LLCP_NB_SOCKET_MAX; idx++)
1927                                 _net_nfc_remove_socket_slot((net_nfc_llcp_socket_t) idx);
1928
1929                         DEBUG_MSG("Kill Thread");
1930
1931                         ret = net_nfc_emul_controller_deinit();
1932                 } else if (config == NET_NFC_ALL_ENABLE) {
1933                         net_nfc_error_e err;
1934
1935                         DEBUG_MSG("Create Thread");
1936                         ret = net_nfc_emul_controller_init(&err);
1937                 }
1938         }
1939
1940         DEBUG_EMUL_END();
1941
1942         return ret;
1943 }
1944
1945 static bool net_nfc_emul_controller_get_secure_element_list(net_nfc_secure_element_info_s* list, int* count, net_nfc_error_e* result)
1946 {
1947         if (result == NULL)
1948                 return false;
1949
1950         *result = NET_NFC_OK;
1951
1952         DEBUG_EMUL_BEGIN();
1953
1954         DEBUG_EMUL_END();
1955
1956         return true;
1957 }
1958
1959 static bool net_nfc_emul_controller_set_secure_element_mode(net_nfc_secure_element_type_e element_type, net_nfc_secure_element_mode_e mode, net_nfc_error_e* result)
1960 {
1961         if (result == NULL)
1962                 return false;
1963
1964         *result = NET_NFC_OK;
1965
1966         DEBUG_EMUL_BEGIN();
1967
1968         DEBUG_EMUL_END();
1969
1970         return true;
1971 }
1972
1973 static bool net_nfc_emul_controller_check_target_presence(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
1974 {
1975         if (result == NULL)
1976                 return false;
1977
1978         *result = NET_NFC_OK;
1979
1980         usleep(300*1000);
1981
1982         if (_net_nfc_emul_get_is_tag_attached()) {
1983                 return true;
1984         } else {
1985                 DEBUG_MSG("TAG Detached");
1986                 return false;
1987         }
1988 }
1989
1990 static bool net_nfc_emul_controller_connect(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
1991 {
1992         if (result == NULL)
1993                 return false;
1994
1995         *result = NET_NFC_OK;
1996
1997         if (!__net_nfc_is_valide_target_handle(handle)) {
1998                 *result = NET_NFC_INVALID_HANDLE;
1999                 return false;
2000         }
2001
2002         DEBUG_EMUL_BEGIN();
2003
2004         DEBUG_EMUL_END();
2005
2006         return true;
2007 }
2008
2009 static bool net_nfc_emul_controller_disconnect(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2010 {
2011         if (result == NULL)
2012                 return false;
2013
2014         *result = NET_NFC_OK;
2015
2016         DEBUG_EMUL_BEGIN();
2017
2018         if (!__net_nfc_is_valide_target_handle(handle)) {
2019                 *result = NET_NFC_INVALID_HANDLE;
2020                 return false;
2021         }
2022
2023         // This handle is not useful anymore
2024         __net_nfc_make_invalid_target_handle();
2025
2026         /* reset socket_info */
2027         int idx = 0;
2028         for (; idx < LLCP_NB_SOCKET_MAX; idx++)
2029                 _net_nfc_remove_socket_slot((net_nfc_llcp_socket_t) idx);
2030
2031         DEBUG_EMUL_END();
2032
2033         return true;
2034 }
2035
2036 static bool net_nfc_emul_controller_check_ndef(net_nfc_target_handle_s* handle, uint8_t *ndef_card_state, int* max_data_size, int* real_data_size, net_nfc_error_e* result)
2037 {
2038         data_s rawdata = { NULL, 0 };
2039
2040         if (result == NULL)
2041                 return false;
2042
2043         *result = NET_NFC_OK;
2044
2045         if (handle == NULL || ndef_card_state == NULL || max_data_size == NULL || real_data_size == NULL || result == NULL) {
2046                 *result = NET_NFC_NULL_PARAMETER;
2047                 return false;
2048         }
2049
2050         if (!__net_nfc_is_valide_target_handle(handle)) {
2051                 *result = NET_NFC_INVALID_HANDLE;
2052                 return false;
2053         }
2054
2055         DEBUG_EMUL_BEGIN();
2056
2057         _net_nfc_retrieve_ndef_message(&rawdata);
2058         _nfc_emul_util_free_mem(rawdata.buffer);
2059
2060         if (_net_nfc_emul_get_is_tag_attached()) {
2061                 *ndef_card_state = NET_NFC_NDEF_CARD_READ_WRITE;
2062                 *max_data_size = BUFFER_LENGTH_MAX;
2063                 *real_data_size = rawdata.length;
2064                 DEBUG_MSG("Card State : [%d] MAX data size :[%d] actual data size = [%d]", *ndef_card_state, *max_data_size, *real_data_size);
2065         } else {
2066                 DEBUG_MSG("target detached");
2067         }
2068
2069         DEBUG_EMUL_END();
2070
2071         return true;
2072 }
2073
2074 static bool net_nfc_emul_controller_make_read_only_ndef(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2075 {
2076         if (result == NULL)
2077                 return false;
2078
2079         *result = NET_NFC_OK;
2080
2081         if (!__net_nfc_is_valide_target_handle(handle)) {
2082                 *result = NET_NFC_INVALID_HANDLE;
2083                 return false;
2084         }
2085
2086         DEBUG_EMUL_BEGIN();
2087
2088         DEBUG_EMUL_END();
2089
2090         return true;
2091 }
2092
2093 static bool net_nfc_emul_controller_read_ndef(net_nfc_target_handle_s* handle, data_s** data, net_nfc_error_e* result)
2094 {
2095         int real_data_size = 0;
2096         data_s rawdata = { NULL, 0 };
2097
2098         DEBUG_EMUL_BEGIN();
2099
2100         if (result == NULL)
2101                 return false;
2102
2103         *result = NET_NFC_OK;
2104
2105         if (handle == NULL || data == NULL || result == NULL) {
2106                 DEBUG_ERR_MSG("NET_NFC_NULL_PARAMETER >>>");
2107                 *result = NET_NFC_NULL_PARAMETER;
2108                 return false;
2109         }
2110
2111         if (!__net_nfc_is_valide_target_handle(handle)) {
2112                 DEBUG_ERR_MSG("NET_NFC_INVALID_HANDLE >>>");
2113                 *result = NET_NFC_INVALID_HANDLE;
2114                 return false;
2115         }
2116
2117         if (!_net_nfc_emul_get_is_tag_attached()) {
2118                 DEBUG_ERR_MSG("NET_NFC_NOT_ALLOWED_OPERATION >>>");
2119                 *result = NET_NFC_NOT_ALLOWED_OPERATION;
2120                 return false;
2121         }
2122
2123         *result = _net_nfc_retrieve_ndef_message(&rawdata);
2124         if (*result != NET_NFC_OK) {
2125                 _nfc_emul_util_free_mem(rawdata.buffer);
2126                 return false;
2127         }
2128
2129         real_data_size = rawdata.length;
2130
2131         if (real_data_size == 0) {
2132                 DEBUG_ERR_MSG("read ndef_msg is failed >>> real_data_size is zero");
2133                 *result = NET_NFC_NO_NDEF_MESSAGE;
2134                 _nfc_emul_util_free_mem(rawdata.buffer);
2135                 return false;
2136         }
2137
2138         *data = (data_s*) calloc(1, sizeof(data_s));
2139
2140         if (*data == NULL) {
2141                 *result = NET_NFC_ALLOC_FAIL;
2142                 _nfc_emul_util_free_mem(rawdata.buffer);
2143                 return false;
2144         }
2145
2146         (*data)->length = real_data_size;
2147         (*data)->buffer = (uint8_t *)calloc(1, real_data_size);
2148
2149         if ((*data)->buffer == NULL) {
2150                 free(*data);
2151                 *result = NET_NFC_ALLOC_FAIL;
2152                 _nfc_emul_util_free_mem(rawdata.buffer);
2153                 return false;
2154         }
2155
2156         /* copy rawdata to data->buffer */
2157         memcpy((*data)->buffer, rawdata.buffer, real_data_size);
2158         _nfc_emul_util_free_mem(rawdata.buffer);
2159
2160         DEBUG_EMUL_END();
2161
2162         return true;
2163 }
2164
2165 static bool net_nfc_emul_controller_write_ndef(net_nfc_target_handle_s* handle, data_s* data, net_nfc_error_e* result)
2166 {
2167         if (result == NULL)
2168                 return false;
2169
2170         *result = NET_NFC_OK;
2171
2172         if (!__net_nfc_is_valide_target_handle(handle)) {
2173                 *result = NET_NFC_INVALID_HANDLE;
2174                 return false;
2175         }
2176
2177         DEBUG_EMUL_BEGIN();
2178
2179         DEBUG_MSG("net_nfc_emul_controller_write_ndef success >>>");
2180
2181         _net_nfc_store_ndef_message(data);
2182
2183         DEBUG_EMUL_END();
2184
2185         return true;
2186 }
2187
2188
2189 static bool net_nfc_emul_controller_transceive(net_nfc_target_handle_s *handle,
2190         net_nfc_transceive_info_s *info, data_s **data, net_nfc_error_e *result)
2191 {
2192         bool ret = false;
2193
2194         if (result == NULL)
2195                 return ret;
2196
2197         if (info == NULL || info->trans_data.buffer == NULL ||
2198                 info->trans_data.length == 0) {
2199                 *result = NET_NFC_INVALID_PARAM;
2200                 return ret;
2201         }
2202
2203         *result = NET_NFC_OK;
2204         *data = NULL;
2205
2206         if (!__net_nfc_is_valide_target_handle(handle)) {
2207                 *result = NET_NFC_INVALID_HANDLE;
2208                 return ret;
2209         }
2210
2211         DEBUG_EMUL_BEGIN();
2212
2213         /* This implementation is not needed on Emulator environment */
2214
2215         DEBUG_EMUL_END();
2216
2217         return ret;
2218 }
2219
2220 static bool net_nfc_emul_controller_format_ndef(net_nfc_target_handle_s* handle, data_s* secure_key, net_nfc_error_e* result)
2221 {
2222         if (result == NULL)
2223                 return false;
2224
2225         *result = NET_NFC_OK;
2226
2227         if (!__net_nfc_is_valide_target_handle(handle)) {
2228                 *result = NET_NFC_INVALID_HANDLE;
2229                 return false;
2230         }
2231
2232         DEBUG_EMUL_BEGIN();
2233
2234         DEBUG_EMUL_END();
2235
2236         return true;
2237 }
2238
2239 static bool net_nfc_emul_controller_exception_handler(void)
2240 {
2241         DEBUG_EMUL_BEGIN();
2242
2243         net_nfc_error_e error;
2244
2245         if (net_nfc_emul_controller_init(&error) == false) {
2246                 DEBUG_ERR_MSG("exception handler is failed!!");
2247                 exit(0xff);
2248         }
2249
2250         DEBUG_EMUL_END();
2251
2252         return true;
2253 }
2254
2255 static bool net_nfc_emul_controller_is_ready(net_nfc_error_e* result)
2256 {
2257         if (result == NULL)
2258                 return false;
2259
2260         *result = NET_NFC_OK;
2261
2262         DEBUG_EMUL_BEGIN();
2263
2264         DEBUG_EMUL_END();
2265
2266         return g_stack_init_successful;
2267 }
2268
2269
2270 /*******************
2271 *       LLCP definition     *
2272 ********************/
2273
2274 static bool net_nfc_emul_controller_llcp_config(net_nfc_llcp_config_info_s * config, net_nfc_error_e * result)
2275 {
2276         if (result == NULL)
2277                 return false;
2278
2279         *result = NET_NFC_OK;
2280
2281         DEBUG_EMUL_BEGIN();
2282
2283         DEBUG_EMUL_END();
2284
2285         return true;
2286 }
2287
2288 static bool net_nfc_emul_controller_llcp_check_llcp(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2289 {
2290         if (result == NULL)
2291                 return false;
2292
2293         *result = NET_NFC_OK;
2294
2295         if (!__net_nfc_is_valide_target_handle(handle)) {
2296                 *result = NET_NFC_INVALID_HANDLE;
2297                 return false;
2298         }
2299
2300         DEBUG_EMUL_BEGIN();
2301
2302         DEBUG_EMUL_END();
2303
2304         return true;
2305 }
2306
2307 static bool net_nfc_emul_controller_llcp_activate_llcp(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2308 {
2309         if (result == NULL)
2310                 return false;
2311
2312         *result = NET_NFC_OK;
2313
2314         if (!__net_nfc_is_valide_target_handle(handle)) {
2315                 *result = NET_NFC_INVALID_HANDLE;
2316                 return false;
2317         }
2318
2319         DEBUG_EMUL_BEGIN();
2320
2321         DEBUG_EMUL_END();
2322
2323         return true;
2324 }
2325
2326 static bool net_nfc_emul_controller_llcp_create_socket(net_nfc_llcp_socket_t* socket, net_nfc_socket_type_e socketType, uint16_t miu, uint8_t rw,  net_nfc_error_e* result, void * user_param)
2327 {
2328         if (result == NULL)
2329                 return false;
2330
2331         *result = NET_NFC_OK;
2332
2333         DEBUG_EMUL_BEGIN();
2334
2335         /* get available socket */
2336         socket_info_s* socket_info = _net_nfc_get_available_socket_slot();
2337         if (socket_info == NULL) {
2338                 DEBUG_ERR_MSG("The available socket is nothing!!");
2339                 return false;
2340         }
2341
2342         /* get llcp state */
2343         llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2344         llcp_state = _net_nfc_get_llcp_state(user_param);
2345         if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2346                 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN!!");
2347                 return false;
2348         }
2349
2350         if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2351                 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_SERVER");
2352
2353                 *socket = NET_NFC_EMUL_SNEP_SERVER_SOCKET_NUMBER;
2354         } else if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER_NPP) {
2355                 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_SERVER_NPP");
2356
2357                 *socket  = NET_NFC_EMUL_NPP_SERVER_SOCKET_NUMBER;
2358         } else if (llcp_state == NET_NFC_STATE_EXCHANGER_CLIENT) {
2359                 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_CLIENT");
2360
2361                 *socket  = NET_NFC_EMUL_CLIENT_SOCKET_NUMBER;
2362         } else if (llcp_state == NET_NFC_STATE_CONN_HANDOVER_REQUEST) {
2363                 DEBUG_MSG("NET_NFC_STATE_CONN_HANDOVER_REQUEST");
2364
2365                 *socket  = NET_NFC_EMUL_HANDOVER_REQUEST_SOCKET_NUMBER;
2366         } else if (llcp_state == NET_NFC_STATE_CONN_HANDOVER_SELECT) {
2367                 DEBUG_MSG("NET_NFC_STATE_CONN_HANDOVER_SELECT");
2368
2369                 *socket  = NET_NFC_EMUL_HANDOVER_SELECT_SOCKET_NUMBER;
2370         } else {
2371                 DEBUG_MSG("we doesn't support..");
2372
2373                 return false;
2374         }
2375
2376         DEBUG_MSG("socket is created = [0x%x]", *socket);
2377
2378         socket_info->socket_handle = *socket;
2379         socket_info->user_context = (void *) user_param;
2380
2381         DEBUG_EMUL_END();
2382
2383         return true;
2384 }
2385
2386 static bool net_nfc_emul_controller_llcp_bind(net_nfc_llcp_socket_t socket, uint8_t service_access_point, net_nfc_error_e* result)
2387 {
2388         if (result == NULL)
2389                 return false;
2390
2391         *result = NET_NFC_OK;
2392
2393         DEBUG_EMUL_BEGIN();
2394
2395         DEBUG_EMUL_END();
2396
2397         return true;
2398 }
2399
2400 static bool net_nfc_emul_controller_llcp_listen(net_nfc_target_handle_s* handle, uint8_t* service_access_name, net_nfc_llcp_socket_t socket, net_nfc_error_e* result, void * user_param)
2401 {
2402         if (result == NULL)
2403                 return false;
2404
2405         *result = NET_NFC_OK;
2406
2407         if (!__net_nfc_is_valide_target_handle(handle)) {
2408                 *result = NET_NFC_INVALID_HANDLE;
2409                 return false;
2410         }
2411
2412         DEBUG_EMUL_BEGIN();
2413
2414         /* Emul don't create real socket. So, we don't need to wait accept from remote socket */
2415         /* In here, send accept event for only snep */
2416         net_nfc_request_listen_socket_t *detail = NULL;
2417
2418         socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2419         if (socket_info == NULL) {
2420                 DEBUG_ERR_MSG("socket_info is NULL");
2421                 return false;
2422         }
2423
2424         llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2425         llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2426         if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2427                 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN");
2428                 return false;
2429         }
2430
2431         if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2432                 _nfc_emul_util_alloc_mem(detail, sizeof(*detail));
2433
2434                 if (detail != NULL) {
2435                         detail->length = sizeof(*detail);
2436                         detail->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_LISTEN;
2437
2438                         socket_info->user_context = user_param;
2439
2440                         detail->handle = handle;
2441                         detail->client_socket = NET_NFC_EMUL_INCOMING_SOCKET_NUMBER;
2442                         detail->trans_param = socket_info->user_context;
2443                         detail->result = NET_NFC_OK;
2444
2445                         DEBUG_MSG("accept callback is called");
2446                         g_emul_controller_llcp_cb(detail, socket_info->user_context);
2447                 }
2448         } else {
2449                 DEBUG_MSG("llcp_state is [%d]", llcp_state);
2450         }
2451
2452         DEBUG_EMUL_END();
2453
2454         return true;
2455 }
2456
2457 /* below accept function does not used. */
2458 static bool net_nfc_emul_controller_llcp_accept(net_nfc_llcp_socket_t   socket, net_nfc_error_e* result, void *user_param)
2459 {
2460         if (result == NULL)
2461                 return false;
2462
2463         *result = NET_NFC_OK;
2464
2465         DEBUG_EMUL_BEGIN();
2466
2467         DEBUG_EMUL_END();
2468
2469         return true;
2470 }
2471
2472 static bool net_nfc_emul_controller_llcp_connect(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, uint8_t service_access_point, net_nfc_error_e* result, void * user_param)
2473 {
2474         if (result == NULL)
2475                 return false;
2476
2477         *result = NET_NFC_OK;
2478
2479         if (!__net_nfc_is_valide_target_handle(handle)) {
2480                 *result = NET_NFC_INVALID_HANDLE;
2481                 return false;
2482         }
2483
2484         DEBUG_EMUL_BEGIN();
2485
2486         socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2487         if (socket_info == NULL) {
2488                 DEBUG_ERR_MSG("socket_info is NULL");
2489                 return false;
2490         }
2491
2492         llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2493         llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2494         if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2495                 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN");
2496                 return false;
2497         }
2498
2499         DEBUG_EMUL_END();
2500
2501         return true;
2502 }
2503
2504 static bool net_nfc_emul_controller_llcp_connect_by_url(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t  socket, uint8_t* service_access_name, net_nfc_error_e* result, void * user_param)
2505 {
2506         if (result == NULL)
2507                 return false;
2508
2509         *result = NET_NFC_OK;
2510
2511         if (!__net_nfc_is_valide_target_handle(handle)) {
2512                 *result = NET_NFC_INVALID_HANDLE;
2513                 return false;
2514         }
2515
2516         DEBUG_EMUL_BEGIN();
2517
2518         socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2519         if (socket_info == NULL) {
2520                 DEBUG_ERR_MSG("socket_info is NULL");
2521                 return false;
2522         }
2523
2524         llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2525         llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2526         if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2527                 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN");
2528                 return false;
2529         }
2530
2531         DEBUG_EMUL_END();
2532
2533         return true;
2534 }
2535
2536 static bool net_nfc_emul_controller_llcp_send(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t    socket, data_s* data, net_nfc_error_e* result, void * user_param)
2537 {
2538         if (result == NULL)
2539                 return false;
2540
2541         *result = NET_NFC_OK;
2542
2543         if (!__net_nfc_is_valide_target_handle(handle)) {
2544                 *result = NET_NFC_INVALID_HANDLE;
2545                 return false;
2546         }
2547
2548         DEBUG_EMUL_BEGIN();
2549
2550         socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2551         if (socket_info == NULL) {
2552                 DEBUG_ERR_MSG("socket_info is NULL");
2553                 return false;
2554         }
2555
2556         llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2557         llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2558         if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2559                 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN");
2560                 return false;
2561         }
2562
2563         if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2564                 net_nfc_request_llcp_msg_t *req_msg = NULL;
2565
2566                 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
2567
2568                 socket_info->user_context = user_param;
2569
2570                 if (req_msg != NULL) {
2571                         req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
2572                         req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_SEND;
2573                         req_msg->result = NET_NFC_OK;
2574
2575                         DEBUG_MSG("send callback is called");
2576                         g_emul_controller_llcp_cb(req_msg, socket_info->user_context);
2577                 }
2578         }
2579
2580         DEBUG_EMUL_END();
2581
2582         return true;
2583 }
2584
2585 static bool net_nfc_emul_controller_llcp_send_to(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, data_s* data, uint8_t service_access_point, net_nfc_error_e* result, void * user_param)
2586 {
2587         if (result == NULL)
2588                 return false;
2589
2590         *result = NET_NFC_OK;
2591
2592         if (!__net_nfc_is_valide_target_handle(handle)) {
2593                 *result = NET_NFC_INVALID_HANDLE;
2594                 return false;
2595         }
2596
2597         DEBUG_EMUL_BEGIN();
2598
2599         socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2600         if (socket_info == NULL) {
2601                 DEBUG_ERR_MSG("socket_info is NULL");
2602                 return false;
2603         }
2604
2605         llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2606         llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2607         if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2608                 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN");
2609                 return false;
2610         }
2611
2612         if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2613                 net_nfc_request_llcp_msg_t *req_msg = NULL;
2614
2615                 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
2616
2617                 socket_info->user_context = user_param;
2618
2619                 if (req_msg != NULL) {
2620                         req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
2621                         req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_SEND_TO;
2622                         req_msg->result = NET_NFC_OK;
2623
2624                         DEBUG_MSG("send_to callback is called");
2625                         g_emul_controller_llcp_cb(req_msg, socket_info->user_context);
2626                 }
2627         }
2628
2629         DEBUG_EMUL_END();
2630
2631         return true;
2632 }
2633
2634
2635 static bool net_nfc_emul_controller_llcp_recv(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, data_s * data, net_nfc_error_e* result, void * user_param)
2636 {
2637         if (result == NULL || data == NULL)
2638                 return false;
2639
2640         *result = NET_NFC_OK;
2641
2642         if (!__net_nfc_is_valide_target_handle(handle)) {
2643                 *result = NET_NFC_INVALID_HANDLE;
2644                 return false;
2645         }
2646
2647         DEBUG_EMUL_BEGIN();
2648
2649         socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2650         if (socket_info == NULL) {
2651                 DEBUG_ERR_MSG("socket_info is NULL");
2652                 return false;
2653         }
2654
2655         llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2656         llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2657         if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2658                 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN");
2659                 return false;
2660         }
2661
2662         if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2663
2664                 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_SERVER");
2665                 socket_info->user_context = user_param;
2666
2667                 if (Snep_Server_msg->isSegment) {
2668                         /* send snep msg continueosly  ..*/
2669                         DEBUG_MSG("send segments for snep msg");
2670
2671                         int remained_size = 0;
2672
2673                         remained_size = Snep_Server_msg->data->length - Snep_Server_msg->offset;
2674                         DEBUG_MSG("remained_size[%d]", remained_size);
2675
2676                         /* copy rawdata to llcp_server_data->buffer */
2677                         if (remained_size <= SNEP_MAX_BUFFER) {
2678                                 DEBUG_MSG("send last segment >>>");
2679
2680                                 llcp_server_data->length = remained_size;
2681                                 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer+Snep_Server_msg->offset , remained_size);
2682
2683                                 Snep_Server_msg->isSegment = false;
2684                         } else {
2685                                 DEBUG_MSG("send continue segment >>>");
2686
2687                                 llcp_server_data->length = SNEP_MAX_BUFFER;
2688                                 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer+Snep_Server_msg->offset, SNEP_MAX_BUFFER);
2689
2690                                 Snep_Server_msg->offset += SNEP_MAX_BUFFER;
2691                         }
2692
2693                         _net_nfc_llcp_data_receive_cb(socket_info->user_context); /* call callback */
2694                 } else {
2695                         /* In here, we dosen't call _net_nfc_llcp_data_receive_cb. just wait event from emulator */
2696                         /*After copying data address, we will return it, immediately */
2697                         DEBUG_MSG("data address is set");
2698                         llcp_server_data = data;
2699                 }
2700         } else {
2701                 DEBUG_MSG("we don't support..");
2702         }
2703
2704         DEBUG_EMUL_END();
2705
2706         return true;
2707 }
2708
2709 static bool net_nfc_emul_controller_llcp_recv_from(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, data_s * data, net_nfc_error_e* result, void * user_param)
2710 {
2711         if (result == NULL)
2712                 return false;
2713
2714         *result = NET_NFC_OK;
2715
2716         if (!__net_nfc_is_valide_target_handle(handle)) {
2717                 *result = NET_NFC_INVALID_HANDLE;
2718                 return false;
2719         }
2720
2721         DEBUG_EMUL_BEGIN();
2722
2723         socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2724         if (socket_info == NULL) {
2725                 DEBUG_ERR_MSG("socket_info is NULL");
2726                 return false;
2727         }
2728
2729         llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2730         llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2731         if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2732                 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN");
2733                 return false;
2734         }
2735
2736         if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2737
2738                 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_SERVER");
2739                 socket_info->user_context = user_param;
2740
2741                 if (Snep_Server_msg->isSegment) {
2742                         /* send snep msg continueosly  ..*/
2743                         DEBUG_MSG("send segments for snep msg");
2744
2745                         int remained_size = 0;
2746
2747                         remained_size = Snep_Server_msg->data->length - Snep_Server_msg->offset;
2748                         DEBUG_MSG("remained_size[%d]", remained_size);
2749
2750                         /* copy rawdata to llcp_server_data->buffer */
2751                         if (remained_size <= SNEP_MAX_BUFFER) {
2752                                 DEBUG_MSG("send last segment >>>");
2753
2754                                 llcp_server_data->length = remained_size;
2755                                 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer+Snep_Server_msg->offset , remained_size);
2756
2757                                 Snep_Server_msg->isSegment = false;
2758                         } else {
2759                                 DEBUG_MSG("send continue segment >>>");
2760
2761                                 llcp_server_data->length = SNEP_MAX_BUFFER;
2762                                 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer+Snep_Server_msg->offset, SNEP_MAX_BUFFER);
2763
2764                                 Snep_Server_msg->offset += SNEP_MAX_BUFFER;
2765                         }
2766
2767                         _net_nfc_llcp_data_receive_from_cb(socket_info->user_context); /* call callback */
2768                 } else {
2769                         /* In here, we dosen't call _net_nfc_llcp_data_receive_cb. just wait event from emulator */
2770                         /*After copying data address, we will return it, immediately */
2771                         if (data != NULL) {
2772                                 DEBUG_MSG("data address is set");
2773                                 llcp_server_data = data;
2774                         } else {
2775                                 DEBUG_ERR_MSG("data address is NULL");
2776                                 return false;
2777                         }
2778                 }
2779         } else {
2780                 DEBUG_MSG("we donen't support..");
2781         }
2782
2783         DEBUG_EMUL_END();
2784
2785         return true;
2786 }
2787
2788 static bool net_nfc_emul_controller_llcp_disconnect(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t      socket, net_nfc_error_e* result, void * user_param)
2789 {
2790         if (result == NULL)
2791                 return false;
2792
2793         *result = NET_NFC_OK;
2794
2795         if (!__net_nfc_is_valide_target_handle(handle)) {
2796                 *result = NET_NFC_INVALID_HANDLE;
2797                 return false;
2798         }
2799
2800         DEBUG_EMUL_BEGIN();
2801
2802         socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2803         if (socket_info == NULL) {
2804                 DEBUG_ERR_MSG("socket_info is NULL");
2805                 return false;
2806         }
2807
2808         llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2809         llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2810         if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2811                 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN");
2812                 return false;
2813         }
2814
2815         /* send msg to framework */
2816         net_nfc_request_llcp_msg_t *req_msg = NULL;
2817
2818         _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
2819
2820         socket_info->user_context = user_param;
2821
2822         if (req_msg != NULL) {
2823                 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
2824                 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_DISCONNECT;
2825                 req_msg->result = NET_NFC_OK;
2826
2827                 DEBUG_MSG("disconnect callback is called");
2828                 g_emul_controller_llcp_cb(req_msg, user_param);
2829         }
2830
2831         /* reset socket_info */
2832         _net_nfc_remove_socket_slot((net_nfc_llcp_socket_t) socket);
2833
2834         DEBUG_EMUL_END();
2835
2836         return true;
2837 }
2838
2839 static bool net_nfc_emul_controller_llcp_socket_close(net_nfc_llcp_socket_t socket, net_nfc_error_e* result)
2840 {
2841         if (result == NULL)
2842                 return false;
2843
2844         *result = NET_NFC_OK;
2845
2846         DEBUG_EMUL_BEGIN();
2847
2848         DEBUG_EMUL_END();
2849
2850         return true;
2851 }
2852
2853 static bool net_nfc_emul_controller_llcp_reject(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t  socket, net_nfc_error_e* result)
2854 {
2855         if (result == NULL)
2856                 return false;
2857
2858         *result = NET_NFC_OK;
2859
2860         if (!__net_nfc_is_valide_target_handle(handle)) {
2861                 *result = NET_NFC_INVALID_HANDLE;
2862                 return false;
2863         }
2864
2865         DEBUG_EMUL_BEGIN();
2866
2867         DEBUG_EMUL_END();
2868
2869         return true;
2870 }
2871
2872 static bool net_nfc_emul_controller_llcp_get_remote_config(net_nfc_target_handle_s* handle, net_nfc_llcp_config_info_s *config, net_nfc_error_e* result)
2873 {
2874         /* In llcp specification ver 1.1, default miu size is 128 */
2875         const uint16_t default_miu = 128;
2876
2877         if (result == NULL)
2878                 return false;
2879
2880         *result = NET_NFC_OK;
2881
2882         if (!__net_nfc_is_valide_target_handle(handle)) {
2883                 *result = NET_NFC_INVALID_HANDLE;
2884                 return false;
2885         }
2886
2887         DEBUG_EMUL_BEGIN();
2888
2889         config->miu = default_miu;
2890
2891         DEBUG_EMUL_END();
2892
2893         return true;
2894 }
2895
2896 static bool net_nfc_emul_controller_llcp_get_remote_socket_info(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, net_nfc_llcp_socket_option_s * option, net_nfc_error_e* result)
2897 {
2898         /* In llcp specification ver 1.1, default miu size is 128 */
2899         const uint16_t default_miu = 128;
2900
2901         if (result == NULL)
2902                 return false;
2903
2904         *result = NET_NFC_OK;
2905
2906         if (!__net_nfc_is_valide_target_handle(handle)) {
2907                 *result = NET_NFC_INVALID_HANDLE;
2908                 return false;
2909         }
2910
2911         DEBUG_EMUL_BEGIN();
2912
2913         option->miu = default_miu;
2914
2915         DEBUG_EMUL_END();
2916
2917         return true;
2918 }
2919
2920
2921 static bool net_nfc_emul_controller_support_nfc(net_nfc_error_e *result)
2922 {
2923         bool ret = false;
2924         struct stat st = { 0, };
2925
2926         if (stat("/dev/nfc0", &st) == -1) {
2927                 if (result)
2928                         *result = NET_NFC_NOT_SUPPORTED;
2929                 return ret;
2930         }
2931
2932         if (result)
2933                 *result = NET_NFC_OK;
2934
2935         ret = true;
2936
2937         return ret;
2938 }
2939 static bool net_nfc_emul_controller_secure_element_open(net_nfc_secure_element_type_e element_type, net_nfc_target_handle_s **handle, net_nfc_error_e *result)
2940 {
2941         DEBUG_ERR_MSG("se open start");
2942         *result = NET_NFC_OK;
2943         __net_nfc_make_valid_target_handle(handle);
2944
2945         DEBUG_ERR_MSG("se_open end");
2946         return true;
2947 }
2948 static bool net_nfc_emul_controller_secure_element_get_atr(net_nfc_target_handle_s *handle,
2949                     data_s **atr, net_nfc_error_e *result)
2950 {
2951         bool ret = true;
2952         char buffer[1024];
2953         int length = sizeof(buffer);
2954         data_s *temp;
2955
2956         DEBUG_ERR_MSG("se get_atr start");
2957         *result = NET_NFC_OK;
2958         *atr = NULL;
2959
2960         strncpy(buffer, "getatr", sizeof(buffer));
2961
2962         temp = (data_s *)calloc(1, sizeof(*temp));
2963         if (temp != NULL) {
2964                 temp->buffer = (uint8_t *)calloc(1, length);
2965                 if (temp->buffer != NULL) {
2966                         memcpy(temp->buffer, buffer, length);
2967                         temp->length = length;
2968                         *atr = temp;
2969                         *result = NET_NFC_OK;
2970                 } else {
2971                         free(temp);
2972                         *result = NET_NFC_ALLOC_FAIL;
2973                         ret = false;
2974                 }
2975         } else {
2976                 *result = NET_NFC_ALLOC_FAIL;
2977                 ret = false;
2978         }
2979         DEBUG_ERR_MSG("se get atr end");
2980         return ret;
2981 }
2982 static bool net_nfc_emul_controller_secure_element_send_apdu(net_nfc_target_handle_s *handle,
2983                     data_s *command, data_s **response, net_nfc_error_e *result)
2984 {
2985         bool ret = true;
2986         char buffer[1024];
2987         int length;
2988         data_s *temp;
2989
2990         DEBUG_ERR_MSG("se send apdu start");
2991
2992         *result = NET_NFC_OK;
2993         *response = NULL;
2994
2995         //buffer response
2996         strncpy(buffer, "response", sizeof(buffer));
2997
2998         length = strlen(buffer);
2999
3000         temp = (data_s *)calloc(1, sizeof(*temp));
3001         if (temp != NULL) {
3002                 temp->buffer = (uint8_t *)calloc(1, length + 1);
3003                 if (temp->buffer != NULL) {
3004                         memcpy(temp->buffer, buffer, sizeof(temp->buffer) - 1);
3005                         temp->length = length;
3006
3007                         *response = temp;
3008                         *result = NET_NFC_OK;
3009                 } else {
3010                         free(temp);
3011                         *result = NET_NFC_ALLOC_FAIL;
3012                         ret = false;
3013                 }
3014         } else {
3015             *result = NET_NFC_ALLOC_FAIL;
3016             ret = false;
3017         }
3018
3019         DEBUG_ERR_MSG("se send apdu end");
3020         return ret;
3021 }
3022 static bool net_nfc_emul_controller_secure_element_close(net_nfc_target_handle_s *handle,
3023                 net_nfc_error_e *result)
3024 {
3025         DEBUG_ERR_MSG("se close start");
3026         *result = NET_NFC_OK;
3027         return true;
3028         DEBUG_ERR_MSG("se close end");
3029 }
3030
3031 ////////////// INTERFACE END //////////