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