src/oem_emul.c

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