2 * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
26 #include <sys/epoll.h>
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"
37 EMUL_NFC_TAG_DISCOVERED = 100,
38 EMUL_NFC_TAG_DETACHED,
39 EMUL_NFC_P2P_DISCOVERED,
40 EMUL_NFC_P2P_DETACHED,
46 EMUL_TAG_TOPAZ_JEWEL = 1,
49 EMUL_TAG_MIFARE_DESFIRE,
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,
61 } emul_ndef_name_format;
64 NET_NFC_STATE_EXCHANGER_SERVER = 0x00,
65 NET_NFC_STATE_EXCHANGER_SERVER_NPP,
67 NET_NFC_STATE_EXCHANGER_CLIENT,
68 NET_NFC_STATE_CONN_HANDOVER_REQUEST,
69 NET_NFC_STATE_CONN_HANDOVER_SELECT,
74 SNEP_REQ_CONTINUE = 0x00,
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;
88 typedef struct _socket_info_s {
89 net_nfc_llcp_socket_t socket_handle;
94 typedef struct _net_nfc_oem_llcp_state_t {
97 unsigned int fragment_offset;
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;
110 llcp_app_protocol_e type_app_protocol;
111 net_nfc_conn_handover_carrier_type_e type;
113 } net_nfc_oem_llcp_state_t;
115 typedef struct _snep_msg_s {
120 /* Members below are used for snep msg of client */
125 typedef struct _emulMsg_data_s {
126 net_nfc_record_tnf_e tnf;
134 typedef struct _emulMsg_s {
135 emul_message_id message_id;
136 emul_target_type target_type;
141 typedef void* (*emul_Nfc_thread_handler_t)(void *pParam);
143 #define __USE_EPOLL_FOR_FILE__ 1
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
154 #ifdef __USE_EPOLL_FOR_FILE__
155 #define EPOLL_SIZE 128
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
167 #define SNEP_MAX_BUFFER 128
168 #define SNEP_MAJOR_VER 1
169 #define SNEP_MINOR_VER 0
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
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;
183 /* for emulator management */
184 static pthread_t gEmulThread;
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 */
194 static socket_info_s socket_info_array[LLCP_NB_SOCKET_MAX] = {{0}};
196 static snep_msg_s *Snep_Server_msg;
197 static data_s *llcp_server_data = NULL;
199 static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
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__)
211 static void __nfc_emul_util_free_mem(void **mem, char *filename, unsigned int line)
213 if (mem == NULL || *mem == NULL) {
214 LOGE("FILE: %s, LINE:%d, Invalid parameter in mem free util (pinter is NULL)", filename, line);
221 static void __nfc_emul_util_alloc_mem(void **mem, int size, char *filename, unsigned int line)
223 if (mem == NULL || size <= 0) {
224 LOGE("FILE: %s, LINE:%d, Invalid parameter in mem alloc util", filename, line);
228 DEBUG_MSG("size to malloc() = [%d]", size);
231 LOGE("FILE: %s, LINE:%d, WARNING: Pointer is already allocated or it was not initialized with NULL", filename, line);
233 *mem = calloc(1, size);
236 LOGE("FILE: %s, LINE:%d, Allocation is failed", filename, line);
239 static bool __net_nfc_is_valide_target_handle(net_nfc_target_handle_s *handle)
241 bool result = (current_working_handle == handle);
243 DEBUG_MSG("[WARNING]: INVALID HANDLE IS DETECTED!");
248 static void __net_nfc_make_valid_target_handle(net_nfc_target_handle_s **handle)
250 if (current_working_handle != NULL)
251 DEBUG_MSG("[WARNING]: HANDLE WAS ALLOCATED ALREADY!");
253 _nfc_emul_util_alloc_mem(*handle, sizeof(net_nfc_target_handle_s));
255 current_working_handle = *handle;
258 static void __net_nfc_make_invalid_target_handle()
260 if (current_working_handle != NULL) {
261 _nfc_emul_util_free_mem(current_working_handle);
262 current_working_handle = NULL;
266 static socket_info_s* _net_nfc_get_available_socket_slot()
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]);
277 DEBUG_ERR_MSG("_net_nfc_get_available_socket_slot is failed");
281 static void _net_nfc_remove_socket_slot(net_nfc_llcp_socket_t socket)
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;
295 static socket_info_s* _net_nfc_find_server_socket(net_nfc_llcp_socket_t socket)
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]);
303 DEBUG_ERR_MSG("_net_nfc_find_server_socket is failed");
307 static void _net_nfc_initialize_llcp(void)
311 if (Snep_Server_msg == NULL) {
312 Snep_Server_msg = calloc(1, sizeof(snep_msg_s));
313 if (Snep_Server_msg == NULL)
316 Snep_Server_msg->data = calloc(1, sizeof(data_s));
317 if (Snep_Server_msg->data == NULL)
320 Snep_Server_msg->data->buffer = calloc(1, sizeof(uint8_t) * BUFFER_LENGTH_MAX);
326 static void _net_nfc_deinitialize_llcp(void)
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;
337 free(Snep_Server_msg->data);
338 Snep_Server_msg->data = NULL;
341 free(Snep_Server_msg);
342 Snep_Server_msg = NULL;
345 llcp_server_data = NULL;
350 static bool _net_nfc_emul_get_is_tag_attached(void)
352 return g_tag_attached;
355 static void _net_nfc_emul_set_is_tag_attached(bool is_detached)
357 g_tag_attached = is_detached;
358 DEBUG_MSG("set g_tag_attached [%d]", g_tag_attached);
361 static bool _net_nfc_emul_get_is_p2p_attached(void)
363 return g_p2p_attached;
366 static void _net_nfc_emul_set_is_p2p_attached(bool is_detached)
368 g_p2p_attached = is_detached;
369 DEBUG_MSG("set g_p2p_attached [%d]", g_p2p_attached);
372 static bool _net_nfc_is_data_emulMsgData(emul_message_id messageId)
379 case EMUL_NFC_TAG_DISCOVERED:
383 case EMUL_NFC_P2P_SEND:
387 case EMUL_NFC_TAG_DETACHED:
388 case EMUL_NFC_P2P_DISCOVERED:
389 case EMUL_NFC_P2P_DETACHED:
395 DEBUG_MSG("retval [%d]", retval);
402 static net_nfc_record_tnf_e _net_nfc_get_tnf_type(int name_format)
406 net_nfc_record_tnf_e tnf = NET_NFC_RECORD_EMPTY;
408 switch (name_format) {
409 case EMUL_NDEF_TNF_EMPTY:
410 tnf = NET_NFC_RECORD_EMPTY;
413 case EMUL_NDEF_TNF_WELL_KNOWN:
414 tnf = NET_NFC_RECORD_WELL_KNOWN_TYPE;
417 case EMUL_NDEF_TNF_MIME_MEDIA:
418 tnf = NET_NFC_RECORD_MIME_TYPE;
421 case EMUL_NDEF_TNF_ABSOLUTE_URI:
422 tnf = NET_NFC_RECORD_URI;
425 case EMUL_NDEF_TNF_EXTERNAL:
426 tnf = NET_NFC_RECORD_EXTERNAL_RTD;
429 case EMUL_NDEF_TNF_UNKNOWN:
430 tnf = NET_NFC_RECORD_UNKNOWN;
434 tnf = NET_NFC_RECORD_UNKNOWN;
435 DEBUG_MSG("data is currupted");
439 DEBUG_MSG("tnf [%d]", tnf);
447 static inline int _create_records_well_known(emulMsg_data_s *record, char *record_payload, ndef_record_h *new_record)
449 if (!strncmp((char *)record->typeName.buffer, "U", 1)) {
450 DEBUG_MSG("URI Type ");
452 data_s payload_data = {NULL, 0};
454 if (record->payload.buffer != NULL) {
455 payload_data.length = strlen(record_payload) + 1;
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");
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);
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");
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 ");
477 data_s payload_data = {NULL, 0};
481 if (record->payload.buffer != NULL) {
482 payload_data.length = strlen((char *)record_payload) + strlen("en-US") + 1;
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");
490 controll_byte = strlen("en-US") & 0x3F;
492 payload_data.buffer[0] = controll_byte;
495 memcpy(payload_data.buffer + offset, "en-US", strlen("en-US"));
497 offset = offset + strlen("en-US");
498 memcpy(payload_data.buffer + offset, record->payload.buffer, strlen(record_payload));
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");
506 if (payload_data.buffer != NULL)
507 _nfc_emul_util_free_mem(payload_data.buffer);
509 DEBUG_ERR_MSG("NET_NFC_RECORD_WELL_KNOWN_TYPE >> typeName is wrong");
515 static inline int _create_records_mime(emulMsg_data_s *record, char *record_payload, ndef_record_h *new_record)
518 data_s filePayload = {NULL, 0};
520 /* open file : size limit? 10k? */
521 file = fopen(record_payload, "r");
523 long int file_len = 0, read_count = 0, read_total = 0;
524 uint8_t *file_data = NULL;
526 fseek(file, 0, SEEK_END);
527 file_len = ftell(file);
528 fseek(file, 0, SEEK_SET);
530 _nfc_emul_util_alloc_mem(file_data, file_len);
532 if (file_data == NULL) {
533 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
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);
546 DEBUG_MSG("fread(%s) success, size %ld", record->payload.buffer, file_len);
548 filePayload.length = file_len;
549 _nfc_emul_util_alloc_mem(filePayload.buffer, filePayload.length);
551 if (filePayload.buffer == NULL) {
552 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
553 _nfc_emul_util_free_mem(file_data);
556 memcpy(filePayload.buffer, file_data, filePayload.length);
558 _nfc_emul_util_free_mem(file_data);
561 if (record->id.buffer == NULL) {
562 char *file_name = NULL;
564 file_name = strrchr(record_payload, '/');
565 if (file_name == NULL)
566 file_name = (char *)record_payload;
570 record->id.length = strlen(file_name);
571 _nfc_emul_util_alloc_mem(record->id.buffer, record->id.length + 1);
573 if (record->id.buffer == NULL) {
574 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
575 _nfc_emul_util_free_mem(filePayload.buffer);
578 memcpy(record->id.buffer, file_name, sizeof(record->id.buffer) - 1);
581 DEBUG_MSG("file open error");
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);
597 static void _create_records_free(emulMsg_data_s *record)
599 if (record->typeName.buffer)
600 _nfc_emul_util_free_mem(record->typeName.buffer);
602 if (record->id.buffer)
603 _nfc_emul_util_free_mem(record->id.buffer);
605 if (record->payload.buffer)
606 _nfc_emul_util_free_mem(record->payload.buffer);
609 static int _net_nfc_create_records_from_emulMsg(emulMsg_s *emul_msg, ndef_message_s **ndef_message, int record_count)
614 int create_record_count = 0;
615 char emulMsg[BUFFER_LENGTH_MAX] = {0};
617 memcpy(emulMsg, emul_msg->file_data, sizeof(emulMsg) - 1);
619 /* parsing data and create record to record structure */
620 for (index = 0; index < record_count; index++) {
624 char *record_payload;
626 emulMsg_data_s record = {0};
630 name_format = strtok((char *)emulMsg, NET_NFC_EMUL_MSG_RECORD_SEPERATOR);
632 name_format = strtok(NULL, NET_NFC_EMUL_MSG_RECORD_SEPERATOR);
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");
640 record_payload = strtok(NULL, NET_NFC_EMUL_MSG_RECORD_SEPERATOR);
643 /* assign data to record structure */
644 record.tnf = _net_nfc_get_tnf_type(atoi(name_format));
646 DEBUG_MSG("Data : type_name ");
648 record.typeName.length = strlen(type_name);
649 _nfc_emul_util_alloc_mem(record.typeName.buffer, record.typeName.length + 1);
651 if (record.typeName.buffer == NULL) {
652 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
653 return create_record_count;
655 memcpy(record.typeName.buffer, type_name, sizeof(record.typeName.buffer) - 1);
657 DEBUG_MSG("Data : record_id ");
659 record.id.length = strlen(record_id);
660 _nfc_emul_util_alloc_mem(record.id.buffer, record.id.length + 1);
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;
667 memcpy(record.id.buffer, record_id, sizeof(record.id.buffer) - 1);
669 DEBUG_MSG("Data : record_payload ");
671 record.payload.length = strlen(record_payload);
672 _nfc_emul_util_alloc_mem(record.payload.buffer, record.payload.length + 1);
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;
680 memcpy(record.payload.buffer, record_payload, sizeof(record.payload.buffer) - 1);
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 >>>>>>>>>>>>>>>>>>>>>>>>");
692 ndef_record_h new_record = NULL;
693 net_nfc_error_e result = NET_NFC_OK;
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;
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;
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;
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;
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;
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;
745 create_record_count++;
746 DEBUG_MSG("Create Record Sucess. Create Record Count[%d]", create_record_count);
748 _create_records_free(&record);
749 DEBUG_MSG("Create Record Loop End");
754 return create_record_count;
757 static bool _net_nfc_change_file_owner_permission(FILE *file)
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;
769 /* change permission */
770 fchmod(fileno(file), 0644);
774 buffer_len = sysconf(_SC_GETPW_R_SIZE_MAX);
775 if (buffer_len == -1)
778 _net_nfc_util_alloc_mem(buffer, buffer_len);
782 getpwnam_r("inhouse", &pwd, buffer, buffer_len, &pw_inhouse);
783 _net_nfc_util_free_mem(buffer);
786 buffer_len = sysconf(_SC_GETGR_R_SIZE_MAX);
787 if (buffer_len == -1)
790 _net_nfc_util_alloc_mem(buffer, buffer_len);
794 getgrnam_r("inhouse", &grp, buffer, buffer_len, &gr_inhouse);
795 _net_nfc_util_free_mem(buffer);
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");
805 static void _net_nfc_store_ndef_message(data_s *data)
807 char file_name[1024] = {0};
814 snprintf(file_name, sizeof(file_name), "%s/%s/%s", "/opt/usr/share/nfc-manager-daemon",
815 "message", "emul-ndef-message.txt");
819 if ((fp = fopen(file_name, "w")) != NULL) {
822 if ((length = fwrite(data->buffer, 1, data->length, fp)) > 0) {
823 DEBUG_MSG("[%d] bytes is written", length);
825 _net_nfc_change_file_owner_permission(fp);
829 DEBUG_MSG("write is failed = [%d]", data->length);
836 static net_nfc_error_e _net_nfc_retrieve_ndef_message(data_s *data)
838 char file_name[1024] = {0};
840 net_nfc_error_e result = NET_NFC_OK;
843 return NET_NFC_NULL_PARAMETER;
846 snprintf(file_name, sizeof(file_name), "%s/%s/%s", "/opt/usr/share/nfc-manager-daemon",
847 "message", "emul-ndef-message.txt");
849 if ((fp = fopen(file_name, "r")) != NULL) {
852 /* rewind to start of file */
853 fseek(fp, 0, SEEK_END);
855 fseek(fp, 0, SEEK_SET);
857 DEBUG_MSG("message length = [%ld]", size);
860 if (net_nfc_util_init_data(data, size) == true) {
866 current = fread(data->buffer + offset, 1,
867 data->length - offset, fp);
872 } while (offset < data->length);
874 if (offset == data->length)
877 result = NET_NFC_NO_NDEF_MESSAGE;
879 result = NET_NFC_ALLOC_FAIL;
882 result = NET_NFC_OPERATION_FAIL;
887 result = NET_NFC_NO_DATA_FOUND;
893 static bool _net_nfc_create_ndef_from_emulMsg(emulMsg_s *emul_msg)
897 if (emul_msg->file_data == NULL)
901 net_nfc_error_e result = NET_NFC_OK;
902 data_s rawdata = {NULL, 0};
904 int record_count = emul_msg->record_count;
906 if (record_count == 0)
909 /* create ndef msg */
910 ndef_message_h ndef_message = NULL;
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);
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);
919 /* convert ndef msg to raw data */
920 ndef_length = net_nfc_util_get_ndef_message_length((ndef_message_s *)ndef_message);
923 DEBUG_MSG("ndef_message size is zero!");
925 rawdata.length = ndef_length;
926 _nfc_emul_util_alloc_mem(rawdata.buffer, ndef_length);
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);
931 _net_nfc_store_ndef_message(&rawdata);
933 _nfc_emul_util_free_mem(rawdata.buffer);
934 net_nfc_util_free_ndef_message(ndef_message);
941 static bool _net_nfc_create_emulMsg(emulMsg_s **emul_msg, uint8_t *data, long int size)
948 *emul_msg = calloc(1, sizeof(emulMsg_s));
949 if (*emul_msg == NULL)
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));
957 DEBUG_MSG("emul_msg->message_id >>>>[%d]", (*emul_msg)->message_id);
959 if (_net_nfc_is_data_emulMsgData((*emul_msg)->message_id)) {
961 emulMsgData = strtok(NULL, NET_NFC_EMUL_MSG_DATA_SEPERATOR);
962 DEBUG_MSG("emulMsgData >>>>[%s]", emulMsgData);
964 switch ((*emul_msg)->message_id) {
965 case EMUL_NFC_TAG_DISCOVERED:
966 case EMUL_NFC_P2P_SEND:
968 /* get message : Tag Type, Record Count, Records */
969 int target_type = -1;
970 char file_data[BUFFER_LENGTH_MAX] = {0};
973 sscanf(emulMsgData, NET_NFC_EMUL_TAG_DISCOVERED_DATA_FORMAT, &target_type, &((*emul_msg)->record_count), file_data);
975 (*emul_msg)->target_type = (emul_target_type)target_type;
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);
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 >>>>>>>>>>>>>>>>>>>>>>>>");
988 if (!_net_nfc_create_ndef_from_emulMsg((*emul_msg)))
989 DEBUG_ERR_MSG("read ndef_msg is failed >>>");
991 DEBUG_ERR_MSG("_net_nfc_create_ndef_from_emulMsg end");
997 DEBUG_ERR_MSG("_net_nfc_set_emulMsg error. Data is currupted");
1002 switch ((*emul_msg)->message_id) {
1003 case EMUL_NFC_P2P_DISCOVERED:
1004 (*emul_msg)->target_type = EMUL_NFC_TARGET;
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!!");
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!!");
1024 /* exception case */
1025 DEBUG_ERR_MSG("_net_nfc_set_emulMsg error. Data is currupted");
1036 static void _net_nfc_destroy_emulMsg(emulMsg_s *emul_msg)
1040 if (emul_msg != NULL) {
1041 if (emul_msg->file_data != NULL)
1042 free(emul_msg->file_data);
1050 static int _net_nfc_emul_convert_target_type(emul_target_type targetType)
1056 switch (targetType) {
1057 case EMUL_TAG_TOPAZ_JEWEL:
1058 covert = NET_NFC_JEWEL_PICC;
1061 case EMUL_TAG_MIFARE_UL:
1062 covert = NET_NFC_MIFARE_ULTRA_PICC;
1065 case EMUL_TAG_FELICA:
1066 covert = NET_NFC_FELICA_PICC;
1069 case EMUL_TAG_MIFARE_DESFIRE:
1070 covert = NET_NFC_MIFARE_DESFIRE_PICC;
1073 case EMUL_NFC_TARGET:
1074 covert = NET_NFC_NFCIP1_TARGET;
1077 case EMUL_TARGET_TYPE_MAX:
1079 /* exception case */
1080 DEBUG_ERR_MSG("_net_nfc_emul_convert_target_type error. Target type is unknown");
1084 DEBUG_MSG("covert [%d]", covert);
1091 static void _net_nfc_target_discovered_cb(emulMsg_s *emul_msg)
1096 net_nfc_target_handle_s *handle = NULL;
1099 __net_nfc_make_valid_target_handle(&handle);
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};
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)
1118 target_detected->length = length;
1119 target_detected->request_type = NET_NFC_MESSAGE_SERVICE_STANDALONE_TARGET_DETECTED;
1120 target_detected->handle = handle;
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);
1129 target_detected->handle->connection_id = current_connection_id++;
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);
1140 DEBUG_MSG("set tag connection");
1141 handle->connection_type = NET_NFC_TAG_CONNECTION;
1142 _net_nfc_emul_set_is_tag_attached(true);
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);
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);
1157 static void _net_nfc_tag_detached_cb(void)
1161 _net_nfc_emul_set_is_tag_attached(false);
1166 static void _net_nfc_target_detached_cb(void)
1170 _net_nfc_emul_set_is_p2p_attached(false);
1172 /* For P2P, we send msg to manager */
1173 net_nfc_request_llcp_msg_t *req_msg = NULL;
1175 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
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;
1181 DEBUG_MSG("deactivated callback is called");
1182 g_emul_controller_llcp_cb(req_msg, NULL);
1186 static void _net_nfc_llcp_data_receive_cb(void *pContext)
1190 net_nfc_request_llcp_msg_t *req_msg = NULL;
1192 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
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;
1199 DEBUG_MSG("receive callback is called >>");
1200 g_emul_controller_llcp_cb(req_msg, pContext);
1206 static void _net_nfc_llcp_data_receive_from_cb(void *pContext)
1210 net_nfc_request_llcp_msg_t *req_msg = NULL;
1212 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
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;
1219 DEBUG_MSG("receive_from callback is called >>");
1220 g_emul_controller_llcp_cb(req_msg, pContext);
1226 static void _net_nfc_llcp_create_snep_server_msg(snep_command_field_e resp_field)
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};
1236 version = SNEP_MAJOR_VER;
1237 version = (((version << 4) & 0xf0) | (SNEP_MINOR_VER & 0x0f));
1239 _net_nfc_retrieve_ndef_message(&rawdata);
1241 /* version response length payload*/
1242 Snep_Server_msg->data->length = sizeof(uint8_t) + sizeof(uint8_t) + sizeof(uint32_t) + rawdata.length;
1252 length_field = htonl(rawdata.length);
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);
1258 /* copy ndef information to response msg */
1259 if (rawdata.length > 0)
1260 memcpy(temp, rawdata.buffer, rawdata.length);
1262 _nfc_emul_util_free_mem(rawdata.buffer);
1267 static llcp_state_e _net_nfc_get_llcp_state(void *pContext)
1272 state = NET_NFC_STATE_EXCHANGER_SERVER;
1279 static bool _net_nfc_make_llcp_data(emulMsg_s *emul_msg)
1282 data_s rawdata = {NULL, 0};
1284 _net_nfc_retrieve_ndef_message(&rawdata);
1285 _nfc_emul_util_free_mem(rawdata.buffer);
1287 if (emul_msg->record_count == 0 || rawdata.length == 0) {
1288 DEBUG_ERR_MSG("data is zero >>>");
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);
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 >>>");
1299 if (llcp_server_data == NULL)
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);
1305 DEBUG_MSG("send first segment >>>");
1307 if (llcp_server_data == NULL)
1310 llcp_server_data->length = SNEP_MAX_BUFFER;
1311 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer, SNEP_MAX_BUFFER);
1313 Snep_Server_msg->isSegment = true;
1314 Snep_Server_msg->offset = SNEP_MAX_BUFFER;
1322 static void _net_nfc_send_emulMsg_to_nfc_manager(emulMsg_s *emul_msg)
1326 switch (emul_msg->message_id) {
1327 case EMUL_NFC_TAG_DISCOVERED:
1328 _net_nfc_target_discovered_cb(emul_msg);
1331 case EMUL_NFC_TAG_DETACHED:
1332 _net_nfc_tag_detached_cb();
1335 case EMUL_NFC_P2P_DISCOVERED:
1336 _net_nfc_initialize_llcp();
1337 _net_nfc_target_discovered_cb(emul_msg);
1340 case EMUL_NFC_P2P_SEND:
1341 if (!_net_nfc_emul_get_is_p2p_attached()) {
1342 DEBUG_ERR_MSG("target is not attached!!");
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");
1354 _net_nfc_llcp_data_receive_cb(socket_info->user_context); /* call callback */
1356 DEBUG_ERR_MSG("make_p2p_data is fail!!");
1361 case EMUL_NFC_P2P_DETACHED:
1362 if (!_net_nfc_emul_get_is_p2p_attached()) {
1363 DEBUG_ERR_MSG("target is not attached!!");
1367 _net_nfc_target_detached_cb();
1368 _net_nfc_deinitialize_llcp();
1372 DEBUG_ERR_MSG("message_id is wrong!!");
1379 static void _net_nfc_process_emulMsg(uint8_t *data, long int size)
1383 emulMsg_s *emul_msg = NULL;
1385 /* create emul_msg */
1386 _net_nfc_create_emulMsg(&emul_msg, data, size);
1388 DEBUG_MSG("emul_msg->message_id >>>>[%d]", emul_msg->message_id);
1390 /* processing emul_msg */
1391 _net_nfc_send_emulMsg_to_nfc_manager(emul_msg);
1393 /* destroy emul_msg */
1394 _net_nfc_destroy_emulMsg(emul_msg);
1399 #ifdef __USE_EPOLL_FOR_FILE__
1400 static void emul_ReaderThread(void *pArg)
1402 DEBUG_MSG("emul_ReaderThread START >>>>");
1404 char file_name[1024] = {0};
1405 bool condition = true;
1407 int emulMsg_file_fd = -1;
1408 int emulMsg_poll_fd = -1;
1409 struct epoll_event *emulMsg_poll_events = NULL;
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);
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 !!!!");
1423 if ((emulMsg_poll_fd = epoll_create1(EPOLL_CLOEXEC)) == -1) {
1424 DEBUG_MSG("epoll_create1 is occured");
1425 close(emulMsg_file_fd);
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);
1436 struct epoll_event ev;
1438 ev.events = EPOLLIN | EPOLLET | EPOLLHUP | EPOLLERR;
1439 ev.data.fd = emulMsg_file_fd;
1441 /* add file fd to epoll */
1442 epoll_ctl(emulMsg_poll_fd, EPOLL_CTL_ADD, emulMsg_file_fd, &ev);
1444 while (condition == true) {
1446 int num_of_files = 0;
1449 /* to do : I will add mutex in the future */
1452 DEBUG_MSG("epoll wait >>>>");
1454 while ((num_of_files = epoll_wait(emulMsg_poll_fd, emulMsg_poll_events, EPOLL_SIZE, -1)) == 0)
1455 DEBUG_MSG("no data is changed ");
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");
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];
1467 DEBUG_MSG("precess POLLIN ");
1469 memset(readbuffer, 0x00, sizeof(READ_BUFFER_LENGTH_MAX) + 1);
1471 readcnt = read(emulMsg_file_fd, readbuffer, READ_BUFFER_LENGTH_MAX);
1473 DEBUG_MSG("message readcnt= [%d] ", readcnt);
1474 DEBUG_MSG("message = [%s] ", readbuffer);
1477 _net_nfc_process_emulMsg((uint8_t *)readbuffer + NET_NFC_EMUL_HEADER_LENGTH, (long int)readcnt - NET_NFC_EMUL_HEADER_LENGTH);
1479 DEBUG_MSG("not expected socket connection");
1483 if (num_of_files == index) {
1484 DEBUG_MSG("unknown event");
1496 close(emulMsg_file_fd);
1498 if (emulMsg_poll_events != NULL)
1499 free(emulMsg_poll_events);
1501 DEBUG_MSG("emul_ReaderThread END >>>>");
1506 static void emul_ReaderThread(void *pArg)
1508 DEBUG_MSG("emul_ReaderThread START >>>>");
1511 char file_name[1024] = {0};
1513 char readBuffer[READ_BUFFER_LENGTH_MAX];
1519 bool condition = true;
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);
1526 DEBUG_MSG("Start Current Time [%ld]", (unsigned long)curTime);
1528 /* polling 500 ms */
1530 while (condition != 0) {
1534 if ((fp = fopen(file_name, "r")) == NULL) {
1535 DEBUG_MSG("file open error");
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) {
1544 DEBUG_MSG("FILE Modified Time [%ld]", (unsigned long)st.st_mtime);
1545 /* update current time */
1547 DEBUG_MSG("Get New Current Time [%ld]", (unsigned long)curTime);
1551 DEBUG_MSG("stat error");
1557 memset(readBuffer, 0x00, READ_BUFFER_LENGTH_MAX);
1559 if (fscanf(fp, "%[^\n]", readBuffer))
1560 DEBUG_MSG("get DATA >>>> readBuffer [%s]", readBuffer);
1562 /* process message */
1563 _net_nfc_process_emulMsg((uint8_t *)readBuffer, (long int)strlen(readBuffer));
1568 DEBUG_MSG("LOOP END >>>>");
1572 DEBUG_MSG("emul_ReaderThread END >>>>");
1576 static bool _net_nfc_emul_controller_start_thread(void)
1582 ret = pthread_create(&gEmulThread, NULL, (emul_Nfc_thread_handler_t)emul_ReaderThread, (void*)"emul_read_thread");
1592 static void _net_nfc_emul_controller_stop_thread(void)
1596 pthread_cancel(gEmulThread);
1600 pthread_cond_signal(&cond);
1602 pthread_join(gEmulThread, NULL);
1607 static bool net_nfc_emul_controller_init(net_nfc_error_e *result)
1616 DEBUG_MSG("start stack init ");
1618 if (g_stack_init_successful == true) {
1619 DEBUG_MSG("Already statck is initialized");
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");
1630 DEBUG_MSG("Stack init finished");
1632 g_stack_init_successful = true;
1633 *result = NET_NFC_OK;
1640 static bool net_nfc_emul_controller_deinit(void)
1645 if (g_stack_init_successful == false) {
1646 DEBUG_MSG("Already statck is deinitialized");
1650 _net_nfc_emul_controller_stop_thread();
1652 g_stack_init_successful = false;
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)
1668 *result = NET_NFC_OK;
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;
1682 static bool net_nfc_emul_controller_unregister_listener()
1686 g_emul_controller_target_cb = NULL;
1687 g_emul_controller_se_cb = NULL;
1688 g_emul_controller_llcp_cb = NULL;
1695 static bool net_nfc_emul_controller_get_firmware_version(data_s **data, net_nfc_error_e *result)
1697 if (data == NULL || result == NULL)
1700 *result = NET_NFC_OK;
1704 *data = calloc(1, sizeof(data_s));
1709 (*data)->length = 10;
1710 (*data)->buffer = calloc(1, (*data)->length);
1712 if ((*data)->buffer == NULL)
1715 snprintf((char *)(*data)->buffer, (*data)->length, "%d.%d", 1, 0);
1722 static bool net_nfc_emul_controller_check_firmware_version(net_nfc_error_e *result)
1727 *result = NET_NFC_OK;
1736 static bool net_nfc_emul_controller_update_firmware(net_nfc_error_e *result)
1741 *result = NET_NFC_OK;
1750 static bool net_nfc_emul_controller_get_stack_information(net_nfc_stack_information_s *stack_info, net_nfc_error_e *result)
1755 *result = NET_NFC_OK;
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)
1772 *result = NET_NFC_OK;
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;
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();
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);
1792 DEBUG_MSG("Kill Thread");
1794 ret = net_nfc_emul_controller_deinit();
1795 } else if (config == NET_NFC_ALL_ENABLE) {
1796 net_nfc_error_e err;
1798 DEBUG_MSG("Create Thread");
1799 ret = net_nfc_emul_controller_init(&err);
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)
1813 *result = NET_NFC_OK;
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)
1827 *result = NET_NFC_OK;
1836 static bool net_nfc_emul_controller_check_target_presence(net_nfc_target_handle_s *handle, net_nfc_error_e *result)
1841 *result = NET_NFC_OK;
1845 if (_net_nfc_emul_get_is_tag_attached()) {
1848 DEBUG_MSG("TAG Detached");
1853 static bool net_nfc_emul_controller_connect(net_nfc_target_handle_s *handle, net_nfc_error_e *result)
1858 *result = NET_NFC_OK;
1860 if (!__net_nfc_is_valide_target_handle(handle)) {
1861 *result = NET_NFC_INVALID_HANDLE;
1872 static bool net_nfc_emul_controller_disconnect(net_nfc_target_handle_s *handle, net_nfc_error_e *result)
1877 *result = NET_NFC_OK;
1881 if (!__net_nfc_is_valide_target_handle(handle)) {
1882 *result = NET_NFC_INVALID_HANDLE;
1886 // This handle is not useful anymore
1887 __net_nfc_make_invalid_target_handle();
1889 /* reset socket_info */
1891 for (; idx < LLCP_NB_SOCKET_MAX; idx++)
1892 _net_nfc_remove_socket_slot((net_nfc_llcp_socket_t)idx);
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)
1901 data_s rawdata = {NULL, 0};
1906 *result = NET_NFC_OK;
1908 if (handle == NULL || ndef_card_state == NULL || max_data_size == NULL || real_data_size == NULL || result == NULL) {
1909 *result = NET_NFC_NULL_PARAMETER;
1913 if (!__net_nfc_is_valide_target_handle(handle)) {
1914 *result = NET_NFC_INVALID_HANDLE;
1920 _net_nfc_retrieve_ndef_message(&rawdata);
1921 _nfc_emul_util_free_mem(rawdata.buffer);
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);
1929 DEBUG_MSG("target detached");
1937 static bool net_nfc_emul_controller_make_read_only_ndef(net_nfc_target_handle_s *handle, net_nfc_error_e *result)
1942 *result = NET_NFC_OK;
1944 if (!__net_nfc_is_valide_target_handle(handle)) {
1945 *result = NET_NFC_INVALID_HANDLE;
1956 static bool net_nfc_emul_controller_read_ndef(net_nfc_target_handle_s *handle, data_s **data, net_nfc_error_e *result)
1958 int real_data_size = 0;
1959 data_s rawdata = {NULL, 0};
1966 *result = NET_NFC_OK;
1968 if (handle == NULL || data == NULL || result == NULL) {
1969 DEBUG_ERR_MSG("NET_NFC_NULL_PARAMETER >>>");
1970 *result = NET_NFC_NULL_PARAMETER;
1974 if (!__net_nfc_is_valide_target_handle(handle)) {
1975 DEBUG_ERR_MSG("NET_NFC_INVALID_HANDLE >>>");
1976 *result = NET_NFC_INVALID_HANDLE;
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;
1986 *result = _net_nfc_retrieve_ndef_message(&rawdata);
1987 if (*result != NET_NFC_OK) {
1988 _nfc_emul_util_free_mem(rawdata.buffer);
1992 real_data_size = rawdata.length;
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);
2001 *data = calloc(1, sizeof(data_s));
2003 if (*data == NULL) {
2004 *result = NET_NFC_ALLOC_FAIL;
2005 _nfc_emul_util_free_mem(rawdata.buffer);
2009 (*data)->length = real_data_size;
2010 (*data)->buffer = calloc(1, real_data_size);
2012 if ((*data)->buffer == NULL) {
2014 *result = NET_NFC_ALLOC_FAIL;
2015 _nfc_emul_util_free_mem(rawdata.buffer);
2019 /* copy rawdata to data->buffer */
2020 memcpy((*data)->buffer, rawdata.buffer, real_data_size);
2021 _nfc_emul_util_free_mem(rawdata.buffer);
2028 static bool net_nfc_emul_controller_write_ndef(net_nfc_target_handle_s *handle, data_s *data, net_nfc_error_e *result)
2033 *result = NET_NFC_OK;
2035 if (!__net_nfc_is_valide_target_handle(handle)) {
2036 *result = NET_NFC_INVALID_HANDLE;
2042 DEBUG_MSG("net_nfc_emul_controller_write_ndef success >>>");
2044 _net_nfc_store_ndef_message(data);
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)
2060 if (info == NULL || info->trans_data.buffer == NULL ||
2061 info->trans_data.length == 0) {
2062 *result = NET_NFC_INVALID_PARAM;
2066 *result = NET_NFC_OK;
2069 if (!__net_nfc_is_valide_target_handle(handle)) {
2070 *result = NET_NFC_INVALID_HANDLE;
2076 /* This implementation is not needed on Emulator environment */
2083 static bool net_nfc_emul_controller_format_ndef(net_nfc_target_handle_s *handle, data_s *secure_key, net_nfc_error_e *result)
2088 *result = NET_NFC_OK;
2090 if (!__net_nfc_is_valide_target_handle(handle)) {
2091 *result = NET_NFC_INVALID_HANDLE;
2102 static bool net_nfc_emul_controller_exception_handler(void)
2106 net_nfc_error_e error;
2108 if (net_nfc_emul_controller_init(&error) == false) {
2109 DEBUG_ERR_MSG("exception handler is failed!!");
2118 static bool net_nfc_emul_controller_is_ready(net_nfc_error_e *result)
2123 *result = NET_NFC_OK;
2129 return g_stack_init_successful;
2133 /*******************
2135 ********************/
2137 static bool net_nfc_emul_controller_llcp_config(net_nfc_llcp_config_info_s *config, net_nfc_error_e *result)
2142 *result = NET_NFC_OK;
2151 static bool net_nfc_emul_controller_llcp_check_llcp(net_nfc_target_handle_s *handle, net_nfc_error_e *result)
2156 *result = NET_NFC_OK;
2158 if (!__net_nfc_is_valide_target_handle(handle)) {
2159 *result = NET_NFC_INVALID_HANDLE;
2170 static bool net_nfc_emul_controller_llcp_activate_llcp(net_nfc_target_handle_s *handle, net_nfc_error_e *result)
2175 *result = NET_NFC_OK;
2177 if (!__net_nfc_is_valide_target_handle(handle)) {
2178 *result = NET_NFC_INVALID_HANDLE;
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)
2194 *result = NET_NFC_OK;
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!!");
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!!");
2213 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2214 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_SERVER");
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");
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");
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");
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");
2232 *socket = NET_NFC_EMUL_HANDOVER_SELECT_SOCKET_NUMBER;
2234 DEBUG_MSG("we doesn't support..");
2239 DEBUG_MSG("socket is created = [0x%x]", *socket);
2241 socket_info->socket_handle = *socket;
2242 socket_info->user_context = (void *)user_param;
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)
2254 *result = NET_NFC_OK;
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)
2268 *result = NET_NFC_OK;
2270 if (!__net_nfc_is_valide_target_handle(handle)) {
2271 *result = NET_NFC_INVALID_HANDLE;
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;
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");
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");
2294 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2295 _nfc_emul_util_alloc_mem(detail, sizeof(*detail));
2297 if (detail != NULL) {
2298 detail->length = sizeof(*detail);
2299 detail->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_LISTEN;
2301 socket_info->user_context = user_param;
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;
2308 DEBUG_MSG("accept callback is called");
2309 g_emul_controller_llcp_cb(detail, socket_info->user_context);
2312 DEBUG_MSG("llcp_state is [%d]", llcp_state);
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)
2326 *result = NET_NFC_OK;
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)
2340 *result = NET_NFC_OK;
2342 if (!__net_nfc_is_valide_target_handle(handle)) {
2343 *result = NET_NFC_INVALID_HANDLE;
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");
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");
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)
2372 *result = NET_NFC_OK;
2374 if (!__net_nfc_is_valide_target_handle(handle)) {
2375 *result = NET_NFC_INVALID_HANDLE;
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");
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");
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)
2404 *result = NET_NFC_OK;
2406 if (!__net_nfc_is_valide_target_handle(handle)) {
2407 *result = NET_NFC_INVALID_HANDLE;
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");
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");
2426 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2427 net_nfc_request_llcp_msg_t *req_msg = NULL;
2429 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
2431 socket_info->user_context = user_param;
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;
2438 DEBUG_MSG("send callback is called");
2439 g_emul_controller_llcp_cb(req_msg, socket_info->user_context);
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)
2453 *result = NET_NFC_OK;
2455 if (!__net_nfc_is_valide_target_handle(handle)) {
2456 *result = NET_NFC_INVALID_HANDLE;
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");
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");
2475 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2476 net_nfc_request_llcp_msg_t *req_msg = NULL;
2478 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
2480 socket_info->user_context = user_param;
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;
2487 DEBUG_MSG("send_to callback is called");
2488 g_emul_controller_llcp_cb(req_msg, socket_info->user_context);
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)
2500 if (result == NULL || data == NULL)
2503 *result = NET_NFC_OK;
2505 if (!__net_nfc_is_valide_target_handle(handle)) {
2506 *result = NET_NFC_INVALID_HANDLE;
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");
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");
2525 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2527 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_SERVER");
2528 socket_info->user_context = user_param;
2530 if (Snep_Server_msg->isSegment) {
2531 /* send snep msg continueosly ..*/
2532 DEBUG_MSG("send segments for snep msg");
2534 int remained_size = 0;
2536 remained_size = Snep_Server_msg->data->length - Snep_Server_msg->offset;
2537 DEBUG_MSG("remained_size[%d]", remained_size);
2539 /* copy rawdata to llcp_server_data->buffer */
2540 if (remained_size <= SNEP_MAX_BUFFER) {
2541 DEBUG_MSG("send last segment >>>");
2543 llcp_server_data->length = remained_size;
2544 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer + Snep_Server_msg->offset, remained_size);
2546 Snep_Server_msg->isSegment = false;
2548 DEBUG_MSG("send continue segment >>>");
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);
2553 Snep_Server_msg->offset += SNEP_MAX_BUFFER;
2556 _net_nfc_llcp_data_receive_cb(socket_info->user_context); /* call callback */
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;
2564 DEBUG_MSG("we don't support..");
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)
2577 *result = NET_NFC_OK;
2579 if (!__net_nfc_is_valide_target_handle(handle)) {
2580 *result = NET_NFC_INVALID_HANDLE;
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");
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");
2599 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2601 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_SERVER");
2602 socket_info->user_context = user_param;
2604 if (Snep_Server_msg->isSegment) {
2605 /* send snep msg continueosly ..*/
2606 DEBUG_MSG("send segments for snep msg");
2608 int remained_size = 0;
2610 remained_size = Snep_Server_msg->data->length - Snep_Server_msg->offset;
2611 DEBUG_MSG("remained_size[%d]", remained_size);
2613 /* copy rawdata to llcp_server_data->buffer */
2614 if (remained_size <= SNEP_MAX_BUFFER) {
2615 DEBUG_MSG("send last segment >>>");
2617 llcp_server_data->length = remained_size;
2618 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer + Snep_Server_msg->offset, remained_size);
2620 Snep_Server_msg->isSegment = false;
2622 DEBUG_MSG("send continue segment >>>");
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);
2627 Snep_Server_msg->offset += SNEP_MAX_BUFFER;
2630 _net_nfc_llcp_data_receive_from_cb(socket_info->user_context); /* call callback */
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 */
2635 DEBUG_MSG("data address is set");
2636 llcp_server_data = data;
2638 DEBUG_ERR_MSG("data address is NULL");
2643 DEBUG_MSG("we donen't support..");
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)
2656 *result = NET_NFC_OK;
2658 if (!__net_nfc_is_valide_target_handle(handle)) {
2659 *result = NET_NFC_INVALID_HANDLE;
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");
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");
2678 /* send msg to framework */
2679 net_nfc_request_llcp_msg_t *req_msg = NULL;
2681 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
2683 socket_info->user_context = user_param;
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;
2690 DEBUG_MSG("disconnect callback is called");
2691 g_emul_controller_llcp_cb(req_msg, user_param);
2694 /* reset socket_info */
2695 _net_nfc_remove_socket_slot((net_nfc_llcp_socket_t)socket);
2702 static bool net_nfc_emul_controller_llcp_socket_close(net_nfc_llcp_socket_t socket,
2703 net_nfc_error_e *result)
2708 *result = NET_NFC_OK;
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)
2722 *result = NET_NFC_OK;
2724 if (!__net_nfc_is_valide_target_handle(handle)) {
2725 *result = NET_NFC_INVALID_HANDLE;
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)
2738 /* In llcp specification ver 1.1, default miu size is 128 */
2739 const uint16_t default_miu = 128;
2744 *result = NET_NFC_OK;
2746 if (!__net_nfc_is_valide_target_handle(handle)) {
2747 *result = NET_NFC_INVALID_HANDLE;
2753 config->miu = default_miu;
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)
2762 /* In llcp specification ver 1.1, default miu size is 128 */
2763 const uint16_t default_miu = 128;
2768 *result = NET_NFC_OK;
2770 if (!__net_nfc_is_valide_target_handle(handle)) {
2771 *result = NET_NFC_INVALID_HANDLE;
2777 option->miu = default_miu;
2785 static bool net_nfc_emul_controller_support_nfc(net_nfc_error_e *result)
2788 struct stat st = {0};
2790 if (stat("/dev/nfc0", &st) == -1) {
2792 *result = NET_NFC_NOT_SUPPORTED;
2797 *result = NET_NFC_OK;
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)
2805 DEBUG_ERR_MSG("se open start");
2806 *result = NET_NFC_OK;
2807 __net_nfc_make_valid_target_handle(handle);
2809 DEBUG_ERR_MSG("se_open end");
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)
2817 int length = sizeof(buffer);
2820 DEBUG_ERR_MSG("se get_atr start");
2821 *result = NET_NFC_OK;
2824 strncpy(buffer, "getatr", sizeof(buffer));
2826 temp = calloc(1, sizeof(*temp));
2828 temp->buffer = calloc(1, length);
2829 if (temp->buffer != NULL) {
2830 memcpy(temp->buffer, buffer, length);
2831 temp->length = length;
2833 *result = NET_NFC_OK;
2836 *result = NET_NFC_ALLOC_FAIL;
2840 *result = NET_NFC_ALLOC_FAIL;
2843 DEBUG_ERR_MSG("se get atr end");
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)
2854 DEBUG_ERR_MSG("se send apdu start");
2856 *result = NET_NFC_OK;
2860 strncpy(buffer, "response", sizeof(buffer));
2862 length = strlen(buffer);
2864 temp = calloc(1, sizeof(*temp));
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;
2872 *result = NET_NFC_OK;
2875 *result = NET_NFC_ALLOC_FAIL;
2879 *result = NET_NFC_ALLOC_FAIL;
2883 DEBUG_ERR_MSG("se send apdu end");
2886 static bool net_nfc_emul_controller_secure_element_close(net_nfc_target_handle_s *handle,
2887 net_nfc_error_e *result)
2889 DEBUG_ERR_MSG("se close start");
2890 *result = NET_NFC_OK;
2892 DEBUG_ERR_MSG("se close end");
2895 __attribute__((visibility("default"))) bool onload(net_nfc_oem_interface_s *emul_interfaces)
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;
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;
2941 emul_interfaces->support_nfc = net_nfc_emul_controller_support_nfc;
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;
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;