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.
25 #include <sys/types.h>
32 #include <sys/epoll.h>
34 #ifdef USE_GLIB_MAIN_LOOP
38 #include <net_nfc_oem_controller.h>
39 #include "net_nfc_typedef.h"
40 #include "nfc_debug_private.h"
41 #include "net_nfc_util_internal.h"
42 #include "net_nfc_util_ndef_message.h"
43 #include "net_nfc_util_ndef_record.h"
45 #include <netinet/in.h>
47 /*************************** STRUCTURE DEFINE START ***************************************/
49 #ifndef NET_NFC_EXPORT_API
50 #define NET_NFC_EXPORT_API __attribute__((visibility("default")))
54 EMUL_NFC_TAG_DISCOVERED = 100,
55 EMUL_NFC_TAG_DETACHED,
56 EMUL_NFC_P2P_DISCOVERED,
57 EMUL_NFC_P2P_DETACHED,
63 EMUL_TAG_TOPAZ_JEWEL = 1,
66 EMUL_TAG_MIFARE_DESFIRE,
72 EMUL_NDEF_TNF_EMPTY = 0,
73 EMUL_NDEF_TNF_WELL_KNOWN,
74 EMUL_NDEF_TNF_MIME_MEDIA,
75 EMUL_NDEF_TNF_ABSOLUTE_URI,
76 EMUL_NDEF_TNF_EXTERNAL,
78 } emul_ndef_name_format;
81 NET_NFC_STATE_EXCHANGER_SERVER = 0x00,
82 NET_NFC_STATE_EXCHANGER_SERVER_NPP,
84 NET_NFC_STATE_EXCHANGER_CLIENT,
85 NET_NFC_STATE_CONN_HANDOVER_REQUEST,
86 NET_NFC_STATE_CONN_HANDOVER_SELECT,
91 SNEP_REQ_CONTINUE = 0x00,
94 SNEP_REQ_REJECT = 0x7F,
95 SNEP_RESP_CONT = 0x80,
96 SNEP_RESP_SUCCESS = 0x81,
97 SNEP_RESP_NOT_FOUND = 0xC0,
98 SNEP_RESP_EXCESS_DATA = 0xC1,
99 SNEP_RESP_BAD_REQ = 0xC2,
100 SNEP_RESP_NOT_IMPLEMENT = 0xE0,
101 SNEP_RESP_UNSUPPORTED_VER = 0xE1,
102 SNEP_RESP_REJECT = 0xFF,
103 } snep_command_field_e;
105 typedef struct _socket_info_s {
106 net_nfc_llcp_socket_t socket_handle;
111 typedef struct _net_nfc_oem_llcp_state_t {
114 unsigned int fragment_offset;
116 net_nfc_llcp_socket_t socket;
117 uint16_t max_capability;
118 net_nfc_target_handle_s * handle;
119 net_nfc_error_e prev_result;
120 net_nfc_llcp_socket_t incomming_socket;
121 ndef_message_s *requester;
122 ndef_message_s *selector;
127 llcp_app_protocol_e type_app_protocol;
128 net_nfc_conn_handover_carrier_type_e type;
130 } net_nfc_oem_llcp_state_t;
132 typedef struct _snep_msg_s {
137 /* Members below are used for snep msg of client */
142 typedef struct _emulMsg_data_s {
143 net_nfc_record_tnf_e tnf;
151 typedef struct _emulMsg_s {
152 emul_message_id message_id;
153 emul_target_type target_type;
158 typedef void * (*emul_Nfc_thread_handler_t) (void * pParam);
160 /*************************** STRUCTURE DEFINE START ***************************************/
162 #define __USE_EPOLL_FOR_FILE__ 1
165 /****************************** DEFINE START *******************************************/
167 /* for emulator management */
168 #define NET_NFC_EMUL_DATA_PATH "/dev"
169 #define NET_NFC_EMUL_MESSAGE_FILE_NAME "nfc0"
170 #define NET_NFC_EMUL_MSG_ID_SEPERATOR "\n:"
171 #define NET_NFC_EMUL_MSG_DATA_SEPERATOR "\n\0"
172 #define NET_NFC_EMUL_MSG_RECORD_SEPERATOR "\n,"
173 #define NET_NFC_EMUL_TAG_DISCOVERED_DATA_FORMAT "%d,%d,%[^\n]"
174 #define NET_NFC_EMUL_HEADER_LENGTH 8
176 #ifdef __USE_EPOLL_FOR_FILE__
177 #define EPOLL_SIZE 128
180 /* for llcp functionality */
181 #define LLCP_NB_SOCKET_MAX 5
182 #define NET_NFC_EMUL_SNEP_SERVER_SOCKET_NUMBER 0
183 #define NET_NFC_EMUL_INCOMING_SOCKET_NUMBER 0
184 #define NET_NFC_EMUL_NPP_SERVER_SOCKET_NUMBER 1
185 #define NET_NFC_EMUL_CLIENT_SOCKET_NUMBER 2
186 #define NET_NFC_EMUL_HANDOVER_REQUEST_SOCKET_NUMBER 3
187 #define NET_NFC_EMUL_HANDOVER_SELECT_SOCKET_NUMBER 4
189 #define SNEP_MAX_BUFFER 128
190 #define SNEP_MAJOR_VER 1
191 #define SNEP_MINOR_VER 0
193 /* static variable */
194 #define BUFFER_LENGTH_MAX 4096
195 #define READ_BUFFER_LENGTH_MAX BUFFER_LENGTH_MAX
196 #define WRITE_BUFFER_LENGTH_MAX BUFFER_LENGTH_MAX
197 #define NET_NFC_MAX_LLCP_SOCKET_BUFFER BUFFER_LENGTH_MAX
199 /****************************** DEFINE END *******************************************/
203 /****************************** VARIABLE START *******************************************/
205 /* listener callback */
206 static target_detection_listener_cb g_emul_controller_target_cb ;
207 static se_transaction_listener_cb g_emul_controller_se_cb ;
208 static llcp_event_listener_cb g_emul_controller_llcp_cb ;
209 static hce_apdu_listener_cb g_emul_controller_hce_cb ;
211 /* for emulator management */
212 pthread_t gEmulThread;
214 /* for stack management */
215 static net_nfc_target_handle_s * current_working_handle = NULL;
216 static bool g_stack_init_successful = 0;
217 static bool g_tag_attached = 0;
218 static bool g_p2p_attached = 0;
219 static int current_connection_id = 1;
220 /* for llcp functionality */
222 socket_info_s socket_info_array[LLCP_NB_SOCKET_MAX] = { {0, } };
224 snep_msg_s* Snep_Server_msg;
225 data_s* llcp_server_data = NULL;
227 pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
229 /****************************** VARIABLE END *******************************************/
233 /*************************** STATIC FUNCTION DECLARE START ***************************************/
235 /*************************** INTERFACE START ***************************************/
237 static bool net_nfc_emul_controller_init(net_nfc_error_e* result);
238 static bool net_nfc_emul_controller_deinit(void);
239 static bool net_nfc_emul_controller_register_listener(
240 target_detection_listener_cb target_detection_listener,
241 se_transaction_listener_cb se_transaction_listener,
242 llcp_event_listener_cb llcp_event_listener,
243 hce_apdu_listener_cb hce_apdu_listener,
244 net_nfc_error_e* result);
245 static bool net_nfc_emul_controller_unregister_listener();
246 static bool net_nfc_emul_controller_get_firmware_version(data_s **data, net_nfc_error_e *result);
247 static bool net_nfc_emul_controller_check_firmware_version(net_nfc_error_e* result);
248 static bool net_nfc_emul_controller_update_firmware(net_nfc_error_e* result);
249 static bool net_nfc_emul_controller_get_stack_information(net_nfc_stack_information_s* stack_info, net_nfc_error_e* result);
250 static bool net_nfc_emul_controller_configure_discovery(net_nfc_discovery_mode_e mode, net_nfc_event_filter_e config, net_nfc_error_e* result);
251 static bool net_nfc_emul_controller_get_secure_element_list(net_nfc_secure_element_info_s* list, int* count, net_nfc_error_e* result);
252 static bool net_nfc_emul_controller_set_secure_element_mode(net_nfc_secure_element_type_e element_type, net_nfc_secure_element_mode_e mode, net_nfc_error_e* result);
253 static bool net_nfc_emul_controller_connect(net_nfc_target_handle_s* handle, net_nfc_error_e* result);
254 static bool net_nfc_emul_controller_disconnect(net_nfc_target_handle_s* handle, net_nfc_error_e* result);
255 static bool net_nfc_emul_controller_check_ndef(net_nfc_target_handle_s* handle, uint8_t *ndef_card_state, int* max_data_size, int* real_data_size, net_nfc_error_e* result);
256 static bool net_nfc_emul_controller_check_target_presence(net_nfc_target_handle_s* handle, net_nfc_error_e* result);
257 static bool net_nfc_emul_controller_read_ndef(net_nfc_target_handle_s* handle, data_s** data, net_nfc_error_e* result);
258 static bool net_nfc_emul_controller_write_ndef(net_nfc_target_handle_s* handle, data_s* data, net_nfc_error_e* result);
259 static bool net_nfc_emul_controller_make_read_only_ndef(net_nfc_target_handle_s* handle, net_nfc_error_e* result);
260 static bool net_nfc_emul_controller_transceive(net_nfc_target_handle_s* handle, net_nfc_transceive_info_s* info, data_s** data, net_nfc_error_e* result);
261 static bool net_nfc_emul_controller_format_ndef(net_nfc_target_handle_s* handle, data_s* secure_key, net_nfc_error_e* result);
262 static bool net_nfc_emul_controller_exception_handler(void);
263 static bool net_nfc_emul_controller_is_ready(net_nfc_error_e* error);
265 static bool net_nfc_emul_controller_llcp_config(net_nfc_llcp_config_info_s * config, net_nfc_error_e * result);
266 static bool net_nfc_emul_controller_llcp_check_llcp(net_nfc_target_handle_s * handle, net_nfc_error_e* result);
267 static bool net_nfc_emul_controller_llcp_activate_llcp(net_nfc_target_handle_s * handle, net_nfc_error_e* result);
268 static bool net_nfc_emul_controller_llcp_create_socket(net_nfc_llcp_socket_t* socket, net_nfc_socket_type_e socketType, uint16_t miu, uint8_t rw, net_nfc_error_e* result, void * user_param);
269 static bool net_nfc_emul_controller_llcp_bind(net_nfc_llcp_socket_t socket, uint8_t service_access_point, net_nfc_error_e* result);
270 static bool net_nfc_emul_controller_llcp_listen(net_nfc_target_handle_s* handle, uint8_t* service_access_name, net_nfc_llcp_socket_t socket, net_nfc_error_e* result, void * user_param);
271 static bool net_nfc_emul_controller_llcp_accept(net_nfc_llcp_socket_t socket, net_nfc_error_e* result, void *user_param);
272 static bool net_nfc_emul_controller_llcp_connect_by_url(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, uint8_t* service_access_name, net_nfc_error_e* result, void * user_param);
273 static bool net_nfc_emul_controller_llcp_connect(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, uint8_t service_access_point, net_nfc_error_e* result, void * user_param);
274 static bool net_nfc_emul_controller_llcp_reject(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, net_nfc_error_e* result);
275 static bool net_nfc_emul_controller_llcp_disconnect(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, net_nfc_error_e* result, void * user_param);
276 static bool net_nfc_emul_controller_llcp_socket_close(net_nfc_llcp_socket_t socket, net_nfc_error_e* result);
277 static bool net_nfc_emul_controller_llcp_recv(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, data_s* data, net_nfc_error_e* result, void * user_param);
278 static bool net_nfc_emul_controller_llcp_send(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, data_s* data, net_nfc_error_e* result, void * user_param);
279 static bool net_nfc_emul_controller_llcp_recv_from(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, data_s * data, net_nfc_error_e* result, void * user_param);
280 static bool net_nfc_emul_controller_llcp_send_to(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, data_s* data, uint8_t service_access_point, net_nfc_error_e* result, void * user_param);
281 static bool net_nfc_emul_controller_llcp_get_remote_config(net_nfc_target_handle_s* handle, net_nfc_llcp_config_info_s *config, net_nfc_error_e* result);
282 static bool net_nfc_emul_controller_llcp_get_remote_socket_info(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, net_nfc_llcp_socket_option_s * option, net_nfc_error_e* result);
284 static bool net_nfc_emul_controller_support_nfc(net_nfc_error_e *result);
285 static bool net_nfc_emul_controller_secure_element_open(net_nfc_secure_element_type_e element_type,
286 net_nfc_target_handle_s **handle, net_nfc_error_e *result);
287 static bool net_nfc_emul_controller_secure_element_get_atr(net_nfc_target_handle_s *handle,
288 data_s **atr, net_nfc_error_e *result);
289 static bool net_nfc_emul_controller_secure_element_send_apdu(net_nfc_target_handle_s *handle,
290 data_s *command, data_s **response, net_nfc_error_e *result);
291 static bool net_nfc_emul_controller_secure_element_close(net_nfc_target_handle_s *handle,
292 net_nfc_error_e *result);
295 /*************************** INTERFACE END ***************************************/
299 /*************************** ETC Function ***************************************/
302 /* free memory, after free given memory it set NULL. Before proceed free, this function also check NULL */
303 void __nfc_emul_util_free_mem(void** mem, char * filename, unsigned int line);
304 /* allocation memory */
305 void __nfc_emul_util_alloc_mem(void** mem, int size, char * filename, unsigned int line);
306 #define _nfc_emul_util_alloc_mem(mem, size) __nfc_emul_util_alloc_mem((void **)&mem, size, __FILE__, __LINE__)
307 #define _nfc_emul_util_free_mem(mem) __nfc_emul_util_free_mem((void **)&mem, __FILE__, __LINE__)
310 static bool __net_nfc_is_valide_target_handle(net_nfc_target_handle_s * handle);
311 static void __net_nfc_make_valid_target_handle(net_nfc_target_handle_s ** handle);
312 static void __net_nfc_make_invalid_target_handle();
314 /*************************** STATIC FUNCTION DECLARE END ***************************************/
318 void __nfc_emul_util_free_mem(void** mem, char * filename, unsigned int line)
320 if (mem == NULL || *mem == NULL) {
321 LOGE("FILE: %s, LINE:%d, Invalid parameter in mem free util (pinter is NULL)", filename, line);
328 void __nfc_emul_util_alloc_mem(void** mem, int size, char * filename, unsigned int line)
330 if (mem == NULL || size <= 0) {
331 LOGE("FILE: %s, LINE:%d, Invalid parameter in mem alloc util", filename, line);
335 DEBUG_MSG("size to malloc() = [%d]", size);
338 LOGE("FILE: %s, LINE:%d, WARNING: Pointer is already allocated or it was not initialized with NULL", filename, line);
343 memset(*mem, 0x0, size);
345 LOGE("FILE: %s, LINE:%d, Allocation is failed", filename, line);
348 static bool __net_nfc_is_valide_target_handle(net_nfc_target_handle_s * handle)
350 bool result = (current_working_handle == handle);
352 DEBUG_MSG("[WARNING]: INVALID HANDLE IS DETECTED!");
356 static void __net_nfc_make_valid_target_handle(net_nfc_target_handle_s ** handle)
358 if (current_working_handle != NULL)
359 DEBUG_MSG("[WARNING]: HANDLE WAS ALLOCATED ALREADY!");
361 _nfc_emul_util_alloc_mem(*handle, sizeof(net_nfc_target_handle_s));
363 current_working_handle = *handle;
365 static void __net_nfc_make_invalid_target_handle()
367 if (current_working_handle != NULL) {
368 _nfc_emul_util_free_mem(current_working_handle);
369 current_working_handle = NULL;
373 static socket_info_s * _net_nfc_get_available_socket_slot()
376 for (; idx < LLCP_NB_SOCKET_MAX; idx++) {
377 if (socket_info_array[idx].isValid == false) {
378 memset(&(socket_info_array[idx]), 0x00, sizeof(socket_info_s));
379 socket_info_array[idx].isValid = true;
380 return &(socket_info_array[idx]);
384 DEBUG_ERR_MSG("_net_nfc_get_available_socket_slot is failed");
388 static void _net_nfc_remove_socket_slot(net_nfc_llcp_socket_t socket)
392 for (; idx < LLCP_NB_SOCKET_MAX; idx++) {
393 if (socket_info_array[idx].isValid == true &&
394 socket_info_array[idx].socket_handle == socket) {
395 socket_info_array[idx].isValid = false;
396 socket_info_array[idx].socket_handle = 0;
397 socket_info_array[idx].user_context = NULL;
402 static socket_info_s * _net_nfc_find_server_socket(net_nfc_llcp_socket_t socket)
405 for (; idx < LLCP_NB_SOCKET_MAX; idx++) {
406 if (socket_info_array[idx].socket_handle == socket && socket_info_array[idx].isValid == true)
407 return &(socket_info_array[idx]);
410 DEBUG_ERR_MSG("_net_nfc_find_server_socket is failed");
414 ////////////// INTERFACE START //////////
416 NET_NFC_EXPORT_API bool onload(net_nfc_oem_interface_s * emul_interfaces)
420 emul_interfaces->init = net_nfc_emul_controller_init;
421 emul_interfaces->deinit = net_nfc_emul_controller_deinit;
422 emul_interfaces->register_listener = net_nfc_emul_controller_register_listener;
423 emul_interfaces->unregister_listener = net_nfc_emul_controller_unregister_listener;
424 emul_interfaces->get_firmware_version = net_nfc_emul_controller_get_firmware_version;
425 emul_interfaces->check_firmware_version = net_nfc_emul_controller_check_firmware_version;
426 emul_interfaces->update_firmeware = net_nfc_emul_controller_update_firmware;
427 emul_interfaces->get_stack_information = net_nfc_emul_controller_get_stack_information;
428 emul_interfaces->configure_discovery = net_nfc_emul_controller_configure_discovery;
429 emul_interfaces->get_secure_element_list = net_nfc_emul_controller_get_secure_element_list;
430 emul_interfaces->set_secure_element_mode = net_nfc_emul_controller_set_secure_element_mode;
431 emul_interfaces->connect = net_nfc_emul_controller_connect;
432 emul_interfaces->disconnect = net_nfc_emul_controller_disconnect;
433 emul_interfaces->check_ndef = net_nfc_emul_controller_check_ndef;
434 emul_interfaces->check_presence = net_nfc_emul_controller_check_target_presence;
435 emul_interfaces->read_ndef = net_nfc_emul_controller_read_ndef;
436 emul_interfaces->write_ndef = net_nfc_emul_controller_write_ndef;
437 emul_interfaces->make_read_only_ndef = net_nfc_emul_controller_make_read_only_ndef;
438 emul_interfaces->transceive = net_nfc_emul_controller_transceive;
439 emul_interfaces->format_ndef = net_nfc_emul_controller_format_ndef;
440 emul_interfaces->exception_handler = net_nfc_emul_controller_exception_handler;
441 emul_interfaces->is_ready = net_nfc_emul_controller_is_ready;
443 emul_interfaces->config_llcp = net_nfc_emul_controller_llcp_config;
444 emul_interfaces->check_llcp_status = net_nfc_emul_controller_llcp_check_llcp;
445 emul_interfaces->activate_llcp = net_nfc_emul_controller_llcp_activate_llcp;
446 emul_interfaces->create_llcp_socket = net_nfc_emul_controller_llcp_create_socket;
447 emul_interfaces->bind_llcp_socket = net_nfc_emul_controller_llcp_bind;
448 emul_interfaces->listen_llcp_socket = net_nfc_emul_controller_llcp_listen;
449 emul_interfaces->accept_llcp_socket = net_nfc_emul_controller_llcp_accept;
450 emul_interfaces->connect_llcp_by_url = net_nfc_emul_controller_llcp_connect_by_url;
451 emul_interfaces->connect_llcp = net_nfc_emul_controller_llcp_connect;
452 emul_interfaces->disconnect_llcp = net_nfc_emul_controller_llcp_disconnect;
453 emul_interfaces->close_llcp_socket = net_nfc_emul_controller_llcp_socket_close;
454 emul_interfaces->recv_llcp = net_nfc_emul_controller_llcp_recv;
455 emul_interfaces->send_llcp = net_nfc_emul_controller_llcp_send;
456 emul_interfaces->recv_from_llcp = net_nfc_emul_controller_llcp_recv_from;
457 emul_interfaces->send_to_llcp = net_nfc_emul_controller_llcp_send_to;
458 emul_interfaces->reject_llcp = net_nfc_emul_controller_llcp_reject;
459 emul_interfaces->get_remote_config = net_nfc_emul_controller_llcp_get_remote_config;
460 emul_interfaces->get_remote_socket_info = net_nfc_emul_controller_llcp_get_remote_socket_info;
462 emul_interfaces->support_nfc = net_nfc_emul_controller_support_nfc;
464 emul_interfaces->secure_element_open = net_nfc_emul_controller_secure_element_open;
465 emul_interfaces->secure_element_get_atr = net_nfc_emul_controller_secure_element_get_atr;
466 emul_interfaces->secure_element_send_apdu = net_nfc_emul_controller_secure_element_send_apdu;
467 emul_interfaces->secure_element_close = net_nfc_emul_controller_secure_element_close;
469 emul_interfaces->hce_response_apdu = NULL;
470 emul_interfaces->route_aid = NULL;
471 emul_interfaces->unroute_aid = NULL;
472 emul_interfaces->commit_routing = NULL;
473 emul_interfaces->set_default_route = NULL;
474 emul_interfaces->clear_aid_table = NULL;
475 emul_interfaces->get_aid_tablesize = NULL;
482 static void _net_nfc_initialize_llcp(void)
486 if (Snep_Server_msg == NULL) {
487 Snep_Server_msg = (snep_msg_s *)calloc(1, sizeof(snep_msg_s));
488 if (Snep_Server_msg == NULL)
491 Snep_Server_msg->data = (data_s *)calloc(1, sizeof(data_s));
492 if (Snep_Server_msg->data == NULL)
495 Snep_Server_msg->data->buffer = (uint8_t *)calloc(1, sizeof(uint8_t) * BUFFER_LENGTH_MAX);
501 static void _net_nfc_deinitialize_llcp(void)
505 if (Snep_Server_msg != NULL) {
506 if (Snep_Server_msg->data != NULL) {
507 if (Snep_Server_msg->data->buffer != NULL) {
508 free(Snep_Server_msg->data->buffer);
509 Snep_Server_msg->data->buffer = NULL;
512 free(Snep_Server_msg->data);
513 Snep_Server_msg->data = NULL;
516 free(Snep_Server_msg);
517 Snep_Server_msg = NULL;
520 llcp_server_data = NULL;
525 static bool _net_nfc_emul_get_is_tag_attached(void)
527 return g_tag_attached;
530 static void _net_nfc_emul_set_is_tag_attached(bool is_detached)
532 g_tag_attached = is_detached;
533 DEBUG_MSG("set g_tag_attached [%d]", g_tag_attached);
536 static bool _net_nfc_emul_get_is_p2p_attached(void)
538 return g_p2p_attached;
541 static void _net_nfc_emul_set_is_p2p_attached(bool is_detached)
543 g_p2p_attached = is_detached;
544 DEBUG_MSG("set g_p2p_attached [%d]", g_p2p_attached);
547 static bool _net_nfc_is_data_emulMsgData(emul_message_id messageId)
554 case EMUL_NFC_TAG_DISCOVERED:
558 case EMUL_NFC_P2P_SEND:
562 case EMUL_NFC_TAG_DETACHED:
563 case EMUL_NFC_P2P_DISCOVERED:
564 case EMUL_NFC_P2P_DETACHED:
570 DEBUG_MSG("retval [%d]", retval);
577 static net_nfc_record_tnf_e _net_nfc_get_tnf_type(int name_format)
581 net_nfc_record_tnf_e tnf = NET_NFC_RECORD_EMPTY;
583 switch (name_format) {
584 case EMUL_NDEF_TNF_EMPTY:
585 tnf = NET_NFC_RECORD_EMPTY;
588 case EMUL_NDEF_TNF_WELL_KNOWN:
589 tnf = NET_NFC_RECORD_WELL_KNOWN_TYPE;
592 case EMUL_NDEF_TNF_MIME_MEDIA:
593 tnf = NET_NFC_RECORD_MIME_TYPE;
596 case EMUL_NDEF_TNF_ABSOLUTE_URI:
597 tnf = NET_NFC_RECORD_URI;
600 case EMUL_NDEF_TNF_EXTERNAL:
601 tnf = NET_NFC_RECORD_EXTERNAL_RTD;
604 case EMUL_NDEF_TNF_UNKNOWN:
605 tnf = NET_NFC_RECORD_UNKNOWN;
609 tnf = NET_NFC_RECORD_UNKNOWN;
610 DEBUG_MSG("data is currupted");
614 DEBUG_MSG("tnf [%d]", tnf);
622 static int _net_nfc_create_records_from_emulMsg(emulMsg_s *emul_msg, ndef_message_s **ndef_message, int record_count)
627 int create_record_count = 0;
628 char emulMsg[BUFFER_LENGTH_MAX] = { 0, };
630 memcpy(emulMsg, emul_msg->file_data, sizeof(emulMsg)-1);
632 /* parsing data and create record to record structure */
633 for (index = 0; index < record_count ; index++) {
637 char *record_payload;
639 emulMsg_data_s record = { 0, };
640 data_s filePayload = { NULL, 0 };
644 name_format = strtok((char *) emulMsg, NET_NFC_EMUL_MSG_RECORD_SEPERATOR);
646 name_format = strtok(NULL, NET_NFC_EMUL_MSG_RECORD_SEPERATOR);
648 type_name = strtok(NULL, NET_NFC_EMUL_MSG_RECORD_SEPERATOR);
649 record_id = strtok(NULL, NET_NFC_EMUL_MSG_RECORD_SEPERATOR);
650 if (index == record_count-1) {
651 /* the last payload : we have to read sentence fully */
652 record_payload = strtok(NULL, "\n");
654 record_payload = strtok(NULL, NET_NFC_EMUL_MSG_RECORD_SEPERATOR);
657 /* assign data to record structure */
658 record.tnf = _net_nfc_get_tnf_type(atoi(name_format));
660 DEBUG_MSG("Data : type_name ");
662 record.typeName.length = strlen(type_name);
663 _nfc_emul_util_alloc_mem(record.typeName.buffer, record.typeName.length + 1);
665 if (record.typeName.buffer == NULL) {
666 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
669 memcpy(record.typeName.buffer, type_name, sizeof(record.typeName.buffer) - 1);
671 DEBUG_MSG("Data : record_id ");
673 record.id.length = strlen(record_id);
674 _nfc_emul_util_alloc_mem(record.id.buffer, record.id.length + 1);
676 if (record.id.buffer == NULL) {
677 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
680 memcpy(record.id.buffer, record_id, sizeof(record.id.buffer) - 1);
682 DEBUG_MSG("Data : record_payload ");
684 record.payload.length = strlen(record_payload);
685 _nfc_emul_util_alloc_mem(record.payload.buffer, record.payload.length + 1);
687 if (record.payload.buffer == NULL) {
688 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
691 memcpy(record.payload.buffer, record_payload, sizeof(record.payload.buffer) - 1);
693 #ifndef __EMUL_DEBUG__
694 DEBUG_ERR_MSG("RECORD DATA START >>>>>>>>>>>>>>>>>>>>>>>>");
695 DEBUG_MSG("TNF >>>>[%d]", record.tnf);
696 LOGE("type_name >>>>[%s]", type_name);
697 LOGE("record_id >>>>[%s]", record_id);
698 DEBUG_MSG("record_payload >>>>[%s]", record_payload);
699 DEBUG_ERR_MSG("RECORD DATA END >>>>>>>>>>>>>>>>>>>>>>>>");
703 ndef_record_h new_record = NULL;
704 net_nfc_error_e result = NET_NFC_OK;
706 if (record.tnf == NET_NFC_RECORD_EMPTY) {
707 if ((result = net_nfc_util_create_record(NET_NFC_RECORD_EMPTY, &record.typeName, &record.id, &record.payload, (ndef_record_s **) &new_record)) != NET_NFC_OK) {
708 DEBUG_MSG("net_nfc_create_record failed[%d]", result);
711 } else if (record.tnf == NET_NFC_RECORD_UNKNOWN) {
712 if ((result = net_nfc_util_create_record(NET_NFC_RECORD_UNKNOWN, &record.typeName, &record.id, &record.payload, (ndef_record_s **) &new_record)) != NET_NFC_OK) {
713 DEBUG_MSG("net_nfc_create_record failed[%d]", result);
716 } else if (record.tnf == NET_NFC_RECORD_WELL_KNOWN_TYPE) {
717 if (!strncmp((char *)record.typeName.buffer, "U", 1)) {
718 DEBUG_MSG("URI Type ");
720 data_s payload_data = { NULL, 0 };
722 if (record.payload.buffer != NULL) {
723 payload_data.length = strlen((char *)record_payload) + 1;
725 _nfc_emul_util_alloc_mem(payload_data.buffer, payload_data.length);
726 if (payload_data.buffer == NULL) {
727 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
731 payload_data.buffer[0] = NET_NFC_SCHEMA_FULL_URI; /* first byte of payload is protocol scheme */
732 memcpy(payload_data.buffer + 1, record.payload.buffer, payload_data.length - 1);
735 if (net_nfc_util_create_record(record.tnf, &record.typeName, &record.id, &payload_data, (ndef_record_s**) &new_record) != NET_NFC_OK) {
736 DEBUG_ERR_MSG("net_nfc_util_create_record is failed");
740 if (payload_data.buffer != NULL)
741 _nfc_emul_util_free_mem(payload_data.buffer);
742 } else if (!strncmp((char *)record.typeName.buffer, "T", 1)) {
743 DEBUG_MSG("TEXT Type ");
745 data_s payload_data = { NULL, 0 };
749 if (record.payload.buffer != NULL) {
750 payload_data.length = strlen((char *)record_payload) + strlen("en-US") + 1;
752 _nfc_emul_util_alloc_mem(payload_data.buffer, payload_data.length);
753 if (payload_data.buffer == NULL) {
754 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
758 controll_byte = strlen("en-US") & 0x3F;
760 payload_data.buffer[0] = controll_byte;
763 memcpy(payload_data.buffer + offset, "en-US", strlen("en-US"));
765 offset = offset + strlen("en-US");
766 memcpy(payload_data.buffer + offset, record.payload.buffer, strlen(record_payload));
769 if (net_nfc_util_create_record(record.tnf, &record.typeName, &record.id, &payload_data, (ndef_record_s**) &new_record) != NET_NFC_OK) {
770 DEBUG_ERR_MSG("net_nfc_util_create_record is failed");
774 if (payload_data.buffer != NULL)
775 _nfc_emul_util_free_mem(payload_data.buffer);
777 DEBUG_ERR_MSG("NET_NFC_RECORD_WELL_KNOWN_TYPE >> typeName is wrong");
780 } else if ((record.tnf == NET_NFC_RECORD_MIME_TYPE)) {
783 /* open file : size limit? 10k? */
784 file = fopen(record_payload, "r");
786 long int file_len = 0, read_count = 0, read_total = 0;
787 uint8_t *file_data = NULL;
789 fseek(file, 0, SEEK_END);
790 file_len = ftell(file);
791 fseek(file, 0, SEEK_SET);
793 _nfc_emul_util_alloc_mem(file_data, file_len);
795 if (file_data == NULL) {
796 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
803 read_count = fread(file_data + read_total, 1, file_len - read_total, file);
804 read_total += read_count;
805 } while (read_count != 0 && read_total < file_len);
809 DEBUG_MSG("fread(%s) success, size %ld", record.payload.buffer, file_len);
811 filePayload.length = file_len;
812 _nfc_emul_util_alloc_mem(filePayload.buffer, filePayload.length);
814 if (filePayload.buffer == NULL) {
815 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
816 _nfc_emul_util_free_mem(file_data);
819 memcpy(filePayload.buffer, file_data, filePayload.length);
821 _nfc_emul_util_free_mem(file_data);
824 if (record.id.buffer == NULL) {
825 char *file_name = NULL;
827 file_name = strrchr(record_payload, '/');
828 if (file_name == NULL)
829 file_name = (char *) record_payload;
833 record.id.length = strlen(file_name);
834 _nfc_emul_util_alloc_mem(record.id.buffer, record.id.length + 1);
836 if (record.id.buffer == NULL) {
837 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
838 _nfc_emul_util_free_mem(filePayload.buffer);
841 memcpy(record.id.buffer, file_name, sizeof(record.id.buffer) - 1);
844 DEBUG_MSG("file open error");
849 if ((result = net_nfc_util_create_record(record.tnf, &record.typeName, &record.id, &filePayload, (ndef_record_s **) &new_record)) != NET_NFC_OK) {
850 DEBUG_MSG("net_nfc_create_record failed[%d]", result);
854 /* NET_NFC_RECORD_URI or NET_NFC_RECORD_EXTERNAL_RTD */
855 if ((result = net_nfc_util_create_record(record.tnf, &record.typeName, &record.id, &record.payload, (ndef_record_s **) &new_record)) != NET_NFC_OK) {
856 DEBUG_MSG("net_nfc_create_record failed[%d]", result);
861 /* append record to ndef msg */
862 if ((result = net_nfc_util_append_record((ndef_message_s*) *ndef_message, (ndef_record_s *) new_record)) != NET_NFC_OK) {
863 DEBUG_MSG("net_nfc_util_append_record failed[%d]", result);
867 create_record_count++;
868 DEBUG_MSG("Create Record Sucess. Create Record Count[%d]", create_record_count);
873 if (record.typeName.buffer != NULL)
874 _nfc_emul_util_free_mem(record.typeName.buffer);
876 if (record.id.buffer != NULL)
877 _nfc_emul_util_free_mem(record.id.buffer);
879 if (record.payload.buffer != NULL)
880 _nfc_emul_util_free_mem(record.payload.buffer);
882 if (filePayload.buffer != NULL)
883 _nfc_emul_util_free_mem(filePayload.buffer);
885 DEBUG_MSG("Create Record Loop End");
891 return create_record_count;
894 static bool _net_nfc_change_file_owner_permission(FILE *file)
897 size_t buffer_len = 0;
898 struct passwd pwd = { 0, };
899 struct passwd *pw_inhouse = NULL;
900 struct group grp = { 0, };
901 struct group *gr_inhouse = NULL;
906 /* change permission */
907 fchmod(fileno(file), 0644);
911 buffer_len = sysconf(_SC_GETPW_R_SIZE_MAX);
912 if (buffer_len == -1)
915 _net_nfc_util_alloc_mem(buffer, buffer_len);
919 getpwnam_r("inhouse", &pwd, buffer, buffer_len, &pw_inhouse);
920 _net_nfc_util_free_mem(buffer);
923 buffer_len = sysconf(_SC_GETGR_R_SIZE_MAX);
924 if (buffer_len == -1)
927 _net_nfc_util_alloc_mem(buffer, buffer_len);
931 getgrnam_r("inhouse", &grp, buffer, buffer_len, &gr_inhouse);
932 _net_nfc_util_free_mem(buffer);
934 if ((pw_inhouse != NULL) && (gr_inhouse != NULL)) {
935 if (fchown(fileno(file), pw_inhouse->pw_uid, gr_inhouse->gr_gid) < 0)
936 DEBUG_MSG("failed to change owner");
942 static void _net_nfc_store_ndef_message(data_s *data)
944 char file_name[1024] = { 0, };
951 snprintf(file_name, sizeof(file_name), "%s/%s/%s", "/opt/usr/share/nfc-manager-daemon",
952 "message", "emul-ndef-message.txt");
956 if ((fp = fopen(file_name, "w")) != NULL) {
959 if ((length = fwrite(data->buffer, 1, data->length, fp)) > 0) {
960 DEBUG_MSG("[%d] bytes is written", length);
962 _net_nfc_change_file_owner_permission(fp);
966 DEBUG_MSG("write is failed = [%d]", data->length);
973 static net_nfc_error_e _net_nfc_retrieve_ndef_message(data_s *data)
975 char file_name[1024] = { 0, };
977 net_nfc_error_e result = NET_NFC_OK;
980 return NET_NFC_NULL_PARAMETER;
983 snprintf(file_name, sizeof(file_name), "%s/%s/%s", "/opt/usr/share/nfc-manager-daemon",
984 "message", "emul-ndef-message.txt");
986 if ((fp = fopen(file_name, "r")) != NULL) {
989 /* rewind to start of file */
990 fseek(fp, 0, SEEK_END);
992 fseek(fp, 0, SEEK_SET);
994 DEBUG_MSG("message length = [%ld]", size);
997 if (net_nfc_util_init_data(data, size) == true) {
1003 current = fread(data->buffer + offset, 1,
1004 data->length - offset, fp);
1009 } while (offset < data->length);
1011 if (offset == data->length)
1012 result = NET_NFC_OK;
1014 result = NET_NFC_NO_NDEF_MESSAGE;
1016 result = NET_NFC_ALLOC_FAIL;
1019 result = NET_NFC_OPERATION_FAIL;
1024 result = NET_NFC_NO_DATA_FOUND;
1030 static bool _net_nfc_create_ndef_from_emulMsg(emulMsg_s *emul_msg)
1034 if (emul_msg->file_data == NULL)
1038 net_nfc_error_e result = NET_NFC_OK;
1039 data_s rawdata = { NULL, 0 };
1041 int record_count = emul_msg->record_count;
1043 if (record_count == 0)
1046 /* create ndef msg */
1047 ndef_message_h ndef_message = NULL;
1048 int ndef_length = 0;
1050 if ((result = net_nfc_util_create_ndef_message((ndef_message_s **) &ndef_message)) != NET_NFC_OK)
1051 DEBUG_MSG("failed to create ndef message [%d]", result);
1053 /* create records and append it to ndef_msg*/
1054 emul_msg->record_count = _net_nfc_create_records_from_emulMsg(emul_msg, (ndef_message_s **) &ndef_message, record_count);
1056 /* convert ndef msg to raw data */
1057 ndef_length = net_nfc_util_get_ndef_message_length((ndef_message_s *) ndef_message);
1060 DEBUG_MSG("ndef_message size is zero!");
1062 rawdata.length = ndef_length;
1063 _nfc_emul_util_alloc_mem(rawdata.buffer, ndef_length);
1065 if ((result = net_nfc_util_convert_ndef_message_to_rawdata((ndef_message_s*)ndef_message, &rawdata)) != NET_NFC_OK)
1066 DEBUG_MSG("net_nfc_util_convert_ndef_message_to_rawdata is failed![%d]", result);
1068 _net_nfc_store_ndef_message(&rawdata);
1070 _nfc_emul_util_free_mem(rawdata.buffer);
1071 net_nfc_util_free_ndef_message(ndef_message);
1078 static bool _net_nfc_create_emulMsg(emulMsg_s **emul_msg, uint8_t * data, long int size)
1085 *emul_msg = (emulMsg_s *)calloc(1, sizeof(emulMsg_s));
1086 if (*emul_msg == NULL)
1089 /* emulData => ID : MSG ex) 100:1,1,1,U,samsung,http://www.naver.com */
1090 emulMsgID = strtok((char *)data, NET_NFC_EMUL_MSG_ID_SEPERATOR);
1091 if (emulMsgID != NULL)
1092 (*emul_msg)->message_id = (emul_message_id) (atoi(emulMsgID));
1094 DEBUG_MSG("emul_msg->message_id >>>>[%d]", (*emul_msg)->message_id);
1096 if (_net_nfc_is_data_emulMsgData((*emul_msg)->message_id)) {
1098 emulMsgData = strtok(NULL, NET_NFC_EMUL_MSG_DATA_SEPERATOR);
1099 DEBUG_MSG("emulMsgData >>>>[%s]", emulMsgData);
1101 switch ((*emul_msg)->message_id) {
1102 case EMUL_NFC_TAG_DISCOVERED:
1103 case EMUL_NFC_P2P_SEND:
1105 /* get message : Tag Type, Record Count, Records */
1106 int target_type = -1;
1107 char file_data[BUFFER_LENGTH_MAX] = {0, };
1110 sscanf(emulMsgData, NET_NFC_EMUL_TAG_DISCOVERED_DATA_FORMAT, &target_type, &((*emul_msg)->record_count), file_data);
1112 (*emul_msg)->target_type = (emul_target_type) target_type;
1114 length = strlen(file_data)+1;
1115 _nfc_emul_util_alloc_mem((*emul_msg)->file_data, length);
1116 memcpy((*emul_msg)->file_data, file_data, length);
1118 DEBUG_ERR_MSG("EMUL MESSAGE DATA START >>>>>>>>>>>>>>>>>>>>>>>>");
1119 DEBUG_MSG("message_id >>>>[%d]", (*emul_msg)->message_id);
1120 DEBUG_MSG("target_type >>>>[%d]", (*emul_msg)->target_type);
1121 DEBUG_MSG("record_count >>>>[%d]", (*emul_msg)->record_count);
1122 DEBUG_MSG("file_data >>>>[%s]", (char *)(*emul_msg)->file_data);
1123 DEBUG_ERR_MSG("EMUL MESSAGE DATA END >>>>>>>>>>>>>>>>>>>>>>>>");
1125 if (!_net_nfc_create_ndef_from_emulMsg((*emul_msg)))
1126 DEBUG_ERR_MSG("read ndef_msg is failed >>>");
1128 DEBUG_ERR_MSG("_net_nfc_create_ndef_from_emulMsg end");
1133 /* exception case */
1134 DEBUG_ERR_MSG("_net_nfc_set_emulMsg error. Data is currupted");
1139 switch ((*emul_msg)->message_id) {
1140 case EMUL_NFC_P2P_DISCOVERED:
1141 (*emul_msg)->target_type = EMUL_NFC_TARGET;
1144 case EMUL_NFC_TAG_DETACHED:
1145 DEBUG_MSG("TAG DETACHED");
1146 if (!_net_nfc_emul_get_is_tag_attached()) {
1147 DEBUG_ERR_MSG("tag is not attached!!");
1152 case EMUL_NFC_P2P_DETACHED:
1153 DEBUG_MSG("P2P DETACHED");
1154 if (!_net_nfc_emul_get_is_p2p_attached()) {
1155 DEBUG_ERR_MSG("tag is not attached!!");
1161 /* exception case */
1162 DEBUG_ERR_MSG("_net_nfc_set_emulMsg error. Data is currupted");
1173 static void _net_nfc_destroy_emulMsg(emulMsg_s *emul_msg)
1177 if (emul_msg != NULL) {
1178 if (emul_msg->file_data != NULL)
1179 free(emul_msg->file_data);
1187 static int _net_nfc_emul_convert_target_type(emul_target_type targetType)
1193 switch (targetType) {
1194 case EMUL_TAG_TOPAZ_JEWEL:
1195 covert = NET_NFC_JEWEL_PICC;
1198 case EMUL_TAG_MIFARE_UL:
1199 covert = NET_NFC_MIFARE_ULTRA_PICC;
1202 case EMUL_TAG_FELICA:
1203 covert = NET_NFC_FELICA_PICC;
1206 case EMUL_TAG_MIFARE_DESFIRE:
1207 covert = NET_NFC_MIFARE_DESFIRE_PICC;
1210 case EMUL_NFC_TARGET:
1211 covert = NET_NFC_NFCIP1_TARGET;
1214 case EMUL_TARGET_TYPE_MAX:
1216 /* exception case */
1217 DEBUG_ERR_MSG("_net_nfc_emul_convert_target_type error. Target type is unknown");
1221 DEBUG_MSG("covert [%d]", covert);
1228 static void _net_nfc_target_discovered_cb(emulMsg_s *emul_msg)
1233 net_nfc_target_handle_s* handle = NULL;
1236 __net_nfc_make_valid_target_handle(&handle);
1241 net_nfc_request_target_detected_t* target_detected = NULL;
1242 uint8_t device_info[] = { 0x03, 0x55, 0x49, 0x44, 0x07, 0x04, 0x93, 0xB7, 0xD9, 0x5B, 0x02, 0x80, \
1243 0x08, 0x41, 0x50, 0x50, 0x5F, 0x44, 0x41, 0x54, 0x41, 0x00, 0x03, 0x53, 0x41, 0x4B, \
1244 0x01, 0x00, 0x04, 0x41, 0x54, 0x51, 0x41, 0x02, 0x44, 0x00, 0x0D, 0x4D, 0x41, 0x58, \
1245 0x5F, 0x44, 0x41, 0x54, 0x41, 0x5F, 0x52, 0x41, 0x54, 0x45, 0x01, 0x00, 0x08, 0x46, \
1246 0x57, 0x49, 0x5F, 0x53, 0x46, 0x47, 0x54, 0x01, 0x03, 0x49, 0x44, 0x6D, 0x07, 0x04, \
1247 0x93, 0xB7, 0xD9, 0x5B, 0x02, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
1250 length = sizeof(net_nfc_request_target_detected_t) + sizeof(device_info);
1251 _nfc_emul_util_alloc_mem(target_detected, length);
1252 if (target_detected == NULL)
1255 target_detected->length = length;
1256 target_detected->request_type = NET_NFC_MESSAGE_SERVICE_STANDALONE_TARGET_DETECTED;
1257 target_detected->handle = handle;
1259 target_detected->devType = _net_nfc_emul_convert_target_type(emul_msg->target_type);
1260 if (!target_detected->devType) {
1261 DEBUG_MSG("target_detected->devType is unknown");
1262 _nfc_emul_util_free_mem(target_detected);
1266 target_detected->handle->connection_id = current_connection_id++;
1268 if (target_detected->devType == NET_NFC_NFCIP1_TARGET) {
1269 DEBUG_MSG("set llcp connection type. remote device is target");
1270 handle->connection_type = NET_NFC_P2P_CONNECTION_TARGET;
1271 _net_nfc_emul_set_is_p2p_attached(true);
1272 } else if (target_detected->devType == NET_NFC_NFCIP1_INITIATOR) {
1273 DEBUG_MSG("set llcp connection type. remote device is initiator");
1274 handle->connection_type = NET_NFC_P2P_CONNECTION_INITIATOR;
1275 _net_nfc_emul_set_is_p2p_attached(true);
1277 DEBUG_MSG("set tag connection");
1278 handle->connection_type = NET_NFC_TAG_CONNECTION;
1279 _net_nfc_emul_set_is_tag_attached(true);
1282 target_detected->number_of_keys = 7;
1283 target_detected->target_info_values.length = sizeof(device_info);
1284 memcpy(&target_detected->target_info_values.buffer, device_info, target_detected->target_info_values.length);
1286 /* call target_cb */
1287 if (g_emul_controller_target_cb != NULL) {
1288 DEBUG_MSG("discovered callback is called");
1289 g_emul_controller_target_cb(target_detected, NULL);
1294 static void _net_nfc_tag_detached_cb(void)
1298 _net_nfc_emul_set_is_tag_attached(false);
1303 static void _net_nfc_target_detached_cb(void)
1307 _net_nfc_emul_set_is_p2p_attached(false);
1309 /* For P2P, we send msg to manager */
1310 net_nfc_request_llcp_msg_t *req_msg = NULL;
1312 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
1314 if (req_msg != NULL) {
1315 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
1316 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_DEACTIVATED;
1318 DEBUG_MSG("deactivated callback is called");
1319 g_emul_controller_llcp_cb(req_msg, NULL);
1323 static void _net_nfc_llcp_data_receive_cb(void* pContext)
1327 net_nfc_request_llcp_msg_t *req_msg = NULL;
1329 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
1331 if (req_msg != NULL) {
1332 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
1333 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_RECEIVE;
1334 req_msg->result = NET_NFC_OK;
1336 DEBUG_MSG("receive callback is called >>");
1337 g_emul_controller_llcp_cb(req_msg, pContext);
1343 static void _net_nfc_llcp_data_receive_from_cb(void* pContext)
1347 net_nfc_request_llcp_msg_t *req_msg = NULL;
1349 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
1351 if (req_msg != NULL) {
1352 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
1353 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_RECEIVE_FROM;
1354 req_msg->result = NET_NFC_OK;
1356 DEBUG_MSG("receive_from callback is called >>");
1357 g_emul_controller_llcp_cb(req_msg, pContext);
1363 static void _net_nfc_llcp_create_snep_server_msg(snep_command_field_e resp_field)
1367 uint8_t* temp = Snep_Server_msg->data->buffer;
1368 uint8_t response = (uint8_t)resp_field;
1369 uint8_t version = 0;
1370 uint32_t length_field = 0;
1371 data_s rawdata = { NULL, 0 };
1373 version = SNEP_MAJOR_VER;
1374 version = (((version << 4) & 0xf0) | (SNEP_MINOR_VER & 0x0f));
1376 _net_nfc_retrieve_ndef_message(&rawdata);
1378 /* version response length payload*/
1379 Snep_Server_msg->data->length = sizeof(uint8_t) + sizeof(uint8_t) + sizeof(uint32_t) + rawdata.length;
1389 length_field = htonl(rawdata.length);
1391 /* length will be se 0. so we don't need to copy value */
1392 memcpy(temp, &length_field, sizeof(uint32_t));
1393 temp += sizeof(uint32_t);
1395 /* copy ndef information to response msg */
1396 if (rawdata.length > 0)
1397 memcpy(temp, rawdata.buffer, rawdata.length);
1399 _nfc_emul_util_free_mem(rawdata.buffer);
1404 static llcp_state_e _net_nfc_get_llcp_state(void* pContext)
1409 state = NET_NFC_STATE_EXCHANGER_SERVER;
1416 static bool _net_nfc_make_llcp_data(emulMsg_s *emul_msg)
1419 data_s rawdata = { NULL, 0 };
1421 _net_nfc_retrieve_ndef_message(&rawdata);
1422 _nfc_emul_util_free_mem(rawdata.buffer);
1424 if (emul_msg->record_count == 0 || rawdata.length == 0) {
1425 DEBUG_ERR_MSG("data is zero >>>");
1429 /* For SNEP, we should create snep msg, and then copy it to llcp_server_data */
1430 _net_nfc_llcp_create_snep_server_msg(SNEP_REQ_PUT);
1432 /* copy rawdata to llcp_server_data->buffer */
1433 if (Snep_Server_msg->data->length <= SNEP_MAX_BUFFER) {
1434 DEBUG_MSG("The snep msg size is small than SNEP_MAX_BUFFER >>>");
1436 if (llcp_server_data == NULL)
1439 llcp_server_data->length = Snep_Server_msg->data->length;
1440 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer, Snep_Server_msg->data->length);
1442 DEBUG_MSG("send first segment >>>");
1444 if (llcp_server_data == NULL)
1447 llcp_server_data->length = SNEP_MAX_BUFFER;
1448 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer, SNEP_MAX_BUFFER);
1450 Snep_Server_msg->isSegment = true;
1451 Snep_Server_msg->offset = SNEP_MAX_BUFFER;
1459 static void _net_nfc_send_emulMsg_to_nfc_manager(emulMsg_s *emul_msg)
1463 switch (emul_msg->message_id) {
1464 case EMUL_NFC_TAG_DISCOVERED:
1465 _net_nfc_target_discovered_cb(emul_msg);
1468 case EMUL_NFC_TAG_DETACHED:
1469 _net_nfc_tag_detached_cb();
1472 case EMUL_NFC_P2P_DISCOVERED:
1473 _net_nfc_initialize_llcp();
1474 _net_nfc_target_discovered_cb(emul_msg);
1477 case EMUL_NFC_P2P_SEND:
1478 if (!_net_nfc_emul_get_is_p2p_attached()) {
1479 DEBUG_ERR_MSG("target is not attached!!");
1483 if (_net_nfc_make_llcp_data(emul_msg)) {
1484 /* find snep server*/
1485 socket_info_s *socket_info = _net_nfc_find_server_socket(NET_NFC_EMUL_SNEP_SERVER_SOCKET_NUMBER);
1486 if (socket_info == NULL) {
1487 DEBUG_ERR_MSG("socket_info is NULL");
1491 _net_nfc_llcp_data_receive_cb(socket_info->user_context); /* call callback */
1493 DEBUG_ERR_MSG("make_p2p_data is fail!!");
1498 case EMUL_NFC_P2P_DETACHED:
1499 if (!_net_nfc_emul_get_is_p2p_attached()) {
1500 DEBUG_ERR_MSG("target is not attached!!");
1504 _net_nfc_target_detached_cb();
1505 _net_nfc_deinitialize_llcp();
1509 DEBUG_ERR_MSG("message_id is wrong!!");
1516 static void _net_nfc_process_emulMsg(uint8_t * data, long int size)
1520 emulMsg_s *emul_msg = NULL;
1522 /* create emul_msg */
1523 _net_nfc_create_emulMsg(&emul_msg, data, size);
1525 DEBUG_MSG("emul_msg->message_id >>>>[%d]", emul_msg->message_id);
1527 /* processing emul_msg */
1528 _net_nfc_send_emulMsg_to_nfc_manager(emul_msg);
1530 /* destroy emul_msg */
1531 _net_nfc_destroy_emulMsg(emul_msg);
1536 #ifdef __USE_EPOLL_FOR_FILE__
1537 static void emul_ReaderThread(void * pArg)
1539 DEBUG_MSG("emul_ReaderThread START >>>>");
1541 char file_name[1024] = { 0, };
1542 bool condition = true;
1544 int emulMsg_file_fd = -1;
1545 int emulMsg_poll_fd = -1;
1546 struct epoll_event *emulMsg_poll_events = NULL;
1548 /* make file name */
1549 snprintf(file_name, sizeof(file_name), "%s/%s", NET_NFC_EMUL_DATA_PATH, NET_NFC_EMUL_MESSAGE_FILE_NAME);
1550 LOGE("file path : %s", file_name);
1552 /* open file for poll */
1553 emulMsg_file_fd = open(file_name, O_RDONLY|O_NONBLOCK);
1554 if (emulMsg_file_fd < 0) {
1555 DEBUG_MSG("file open error !!!!");
1560 if ((emulMsg_poll_fd = epoll_create1(EPOLL_CLOEXEC)) == -1) {
1561 DEBUG_MSG("epoll_create1 is occured");
1562 close(emulMsg_file_fd);
1566 if ((emulMsg_poll_events = (struct epoll_event *)calloc(1, sizeof(struct epoll_event) * EPOLL_SIZE)) == NULL) {
1567 DEBUG_MSG("calloc is occured");
1568 close(emulMsg_file_fd);
1573 struct epoll_event ev;
1575 ev.events = EPOLLIN | EPOLLET | EPOLLHUP | EPOLLERR;
1576 ev.data.fd = emulMsg_file_fd;
1578 /* add file fd to epoll */
1579 epoll_ctl(emulMsg_poll_fd, EPOLL_CTL_ADD, emulMsg_file_fd, &ev);
1581 while (condition == true) {
1583 int num_of_files = 0;
1586 /* to do : I will add mutex in the future */
1589 DEBUG_MSG("epoll wait >>>>");
1591 while ((num_of_files = epoll_wait(emulMsg_poll_fd, emulMsg_poll_events, EPOLL_SIZE, -1)) == 0)
1592 DEBUG_MSG("no data is changed ");
1594 for (index = 0; index < num_of_files; index++) {
1595 if ((emulMsg_poll_events[index].events & (EPOLLHUP)) || (emulMsg_poll_events[index].events & (EPOLLERR))) {
1596 DEBUG_MSG("connection is closed");
1599 } else if (emulMsg_poll_events[index].events & EPOLLIN) {
1600 if (emulMsg_poll_events[index].data.fd == emulMsg_file_fd) {
1601 char readbuffer[READ_BUFFER_LENGTH_MAX + 1];
1604 DEBUG_MSG("precess POLLIN ");
1606 memset(readbuffer, 0x00, sizeof(READ_BUFFER_LENGTH_MAX) + 1);
1608 readcnt = read(emulMsg_file_fd, readbuffer, READ_BUFFER_LENGTH_MAX);
1610 DEBUG_MSG("message readcnt= [%d] ", readcnt);
1611 DEBUG_MSG("message = [%s] ", readbuffer);
1614 _net_nfc_process_emulMsg((uint8_t *)readbuffer + NET_NFC_EMUL_HEADER_LENGTH, (long int)readcnt - NET_NFC_EMUL_HEADER_LENGTH);
1616 DEBUG_MSG("not expected socket connection");
1620 if (num_of_files == index) {
1621 DEBUG_MSG("unknown event");
1633 close(emulMsg_file_fd);
1635 if (emulMsg_poll_events != NULL)
1636 free(emulMsg_poll_events);
1638 DEBUG_MSG("emul_ReaderThread END >>>>");
1643 static void emul_ReaderThread(void * pArg)
1645 DEBUG_MSG("emul_ReaderThread START >>>>");
1648 char file_name[1024] = { 0, };
1650 char readBuffer[READ_BUFFER_LENGTH_MAX];
1656 bool condition = true;
1658 /* make file name */
1659 snprintf(file_name, sizeof(file_name), "%s/%s", NET_NFC_EMUL_DATA_PATH, NET_NFC_EMUL_MESSAGE_FILE_NAME);
1660 LOGE("file path : %s", file_name);
1663 DEBUG_MSG("Start Current Time [%ld]", (unsigned long) curTime);
1665 /* polling 500 ms */
1667 while (condition != 0) {
1671 if ((fp = fopen(file_name, "r")) == NULL) {
1672 DEBUG_MSG("file open error");
1675 /* get the modified time of the file */
1676 if (stat(file_name, &st) == 0) {
1677 if ((unsigned long) st.st_mtime <= (unsigned long) curTime) {
1681 DEBUG_MSG("FILE Modified Time [%ld]", (unsigned long) st.st_mtime);
1682 /* update current time */
1684 DEBUG_MSG("Get New Current Time [%ld]", (unsigned long) curTime);
1688 DEBUG_MSG("stat error");
1694 memset(readBuffer, 0x00, READ_BUFFER_LENGTH_MAX);
1696 if (fscanf(fp, "%[^\n]", readBuffer))
1697 DEBUG_MSG("get DATA >>>> readBuffer [%s]", readBuffer);
1699 /* process message */
1700 _net_nfc_process_emulMsg((uint8_t *) readBuffer, (long int) strlen(readBuffer));
1705 DEBUG_MSG("LOOP END >>>>");
1709 DEBUG_MSG("emul_ReaderThread END >>>>");
1713 static bool _net_nfc_emul_controller_start_thread(void)
1719 ret = pthread_create(&gEmulThread, NULL, (emul_Nfc_thread_handler_t)emul_ReaderThread, (void*) "emul_read_thread");
1729 static void _net_nfc_emul_controller_stop_thread(void)
1733 pthread_cancel(gEmulThread);
1737 pthread_cond_signal(&cond);
1739 pthread_join(gEmulThread, NULL);
1744 static bool net_nfc_emul_controller_init(net_nfc_error_e* result)
1753 DEBUG_MSG("start stack init ");
1755 if (g_stack_init_successful == true) {
1756 DEBUG_MSG("Already statck is initialized");
1761 /* start reader thread : to get event from Inject */
1762 if (!_net_nfc_emul_controller_start_thread()) {
1763 DEBUG_ERR_MSG("Failed to create emul thread");
1767 DEBUG_MSG("Stack init finished");
1769 g_stack_init_successful = true;
1770 *result = NET_NFC_OK;
1777 static bool net_nfc_emul_controller_deinit(void)
1782 if (g_stack_init_successful == false) {
1783 DEBUG_MSG("Already statck is deinitialized");
1787 _net_nfc_emul_controller_stop_thread();
1789 g_stack_init_successful = false;
1795 static bool net_nfc_emul_controller_register_listener(
1796 target_detection_listener_cb target_detection_listener,
1797 se_transaction_listener_cb se_transaction_listener,
1798 llcp_event_listener_cb llcp_event_listener,
1799 hce_apdu_listener_cb hce_apdu_listener,
1800 net_nfc_error_e* result)
1805 *result = NET_NFC_OK;
1809 g_emul_controller_target_cb = target_detection_listener;
1810 g_emul_controller_se_cb = se_transaction_listener;
1811 g_emul_controller_llcp_cb = llcp_event_listener;
1812 g_emul_controller_hce_cb = hce_apdu_listener;
1819 static bool net_nfc_emul_controller_unregister_listener()
1823 g_emul_controller_target_cb = NULL;
1824 g_emul_controller_se_cb = NULL;
1825 g_emul_controller_llcp_cb = NULL;
1832 static bool net_nfc_emul_controller_get_firmware_version(data_s **data, net_nfc_error_e *result)
1834 if (data == NULL || result == NULL)
1837 *result = NET_NFC_OK;
1841 *data = (data_s *)calloc(1, sizeof(data_s));
1846 (*data)->length = 10;
1847 (*data)->buffer = (uint8_t *)calloc(1, (*data)->length);
1849 if ((*data)->buffer == NULL)
1852 snprintf((char *)(*data)->buffer, (*data)->length, "%d.%d", 1, 0);
1859 static bool net_nfc_emul_controller_check_firmware_version(net_nfc_error_e* result)
1864 *result = NET_NFC_OK;
1873 static bool net_nfc_emul_controller_update_firmware(net_nfc_error_e* result)
1878 *result = NET_NFC_OK;
1887 static bool net_nfc_emul_controller_get_stack_information(net_nfc_stack_information_s* stack_info, net_nfc_error_e* result)
1892 *result = NET_NFC_OK;
1901 static bool net_nfc_emul_controller_configure_discovery(net_nfc_discovery_mode_e mode, net_nfc_event_filter_e config, net_nfc_error_e* result)
1909 *result = NET_NFC_OK;
1911 if (mode == NET_NFC_DISCOVERY_MODE_START) {
1912 mode = NET_NFC_DISCOVERY_MODE_CONFIG;
1913 } else if (mode == NET_NFC_DISCOVERY_MODE_STOP) {
1914 mode = NET_NFC_DISCOVERY_MODE_CONFIG;
1915 config = NET_NFC_ALL_DISABLE;
1920 if ((mode == NET_NFC_DISCOVERY_MODE_CONFIG)) {
1921 if (config == NET_NFC_ALL_DISABLE) {
1922 /* This handle is not useful anymore */
1923 __net_nfc_make_invalid_target_handle();
1925 /* reset socket_info */
1926 for (idx = 0; idx < LLCP_NB_SOCKET_MAX; idx++)
1927 _net_nfc_remove_socket_slot((net_nfc_llcp_socket_t) idx);
1929 DEBUG_MSG("Kill Thread");
1931 ret = net_nfc_emul_controller_deinit();
1932 } else if (config == NET_NFC_ALL_ENABLE) {
1933 net_nfc_error_e err;
1935 DEBUG_MSG("Create Thread");
1936 ret = net_nfc_emul_controller_init(&err);
1945 static bool net_nfc_emul_controller_get_secure_element_list(net_nfc_secure_element_info_s* list, int* count, net_nfc_error_e* result)
1950 *result = NET_NFC_OK;
1959 static bool net_nfc_emul_controller_set_secure_element_mode(net_nfc_secure_element_type_e element_type, net_nfc_secure_element_mode_e mode, net_nfc_error_e* result)
1964 *result = NET_NFC_OK;
1973 static bool net_nfc_emul_controller_check_target_presence(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
1978 *result = NET_NFC_OK;
1982 if (_net_nfc_emul_get_is_tag_attached()) {
1985 DEBUG_MSG("TAG Detached");
1990 static bool net_nfc_emul_controller_connect(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
1995 *result = NET_NFC_OK;
1997 if (!__net_nfc_is_valide_target_handle(handle)) {
1998 *result = NET_NFC_INVALID_HANDLE;
2009 static bool net_nfc_emul_controller_disconnect(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2014 *result = NET_NFC_OK;
2018 if (!__net_nfc_is_valide_target_handle(handle)) {
2019 *result = NET_NFC_INVALID_HANDLE;
2023 // This handle is not useful anymore
2024 __net_nfc_make_invalid_target_handle();
2026 /* reset socket_info */
2028 for (; idx < LLCP_NB_SOCKET_MAX; idx++)
2029 _net_nfc_remove_socket_slot((net_nfc_llcp_socket_t) idx);
2036 static bool net_nfc_emul_controller_check_ndef(net_nfc_target_handle_s* handle, uint8_t *ndef_card_state, int* max_data_size, int* real_data_size, net_nfc_error_e* result)
2038 data_s rawdata = { NULL, 0 };
2043 *result = NET_NFC_OK;
2045 if (handle == NULL || ndef_card_state == NULL || max_data_size == NULL || real_data_size == NULL || result == NULL) {
2046 *result = NET_NFC_NULL_PARAMETER;
2050 if (!__net_nfc_is_valide_target_handle(handle)) {
2051 *result = NET_NFC_INVALID_HANDLE;
2057 _net_nfc_retrieve_ndef_message(&rawdata);
2058 _nfc_emul_util_free_mem(rawdata.buffer);
2060 if (_net_nfc_emul_get_is_tag_attached()) {
2061 *ndef_card_state = NET_NFC_NDEF_CARD_READ_WRITE;
2062 *max_data_size = BUFFER_LENGTH_MAX;
2063 *real_data_size = rawdata.length;
2064 DEBUG_MSG("Card State : [%d] MAX data size :[%d] actual data size = [%d]", *ndef_card_state, *max_data_size, *real_data_size);
2066 DEBUG_MSG("target detached");
2074 static bool net_nfc_emul_controller_make_read_only_ndef(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2079 *result = NET_NFC_OK;
2081 if (!__net_nfc_is_valide_target_handle(handle)) {
2082 *result = NET_NFC_INVALID_HANDLE;
2093 static bool net_nfc_emul_controller_read_ndef(net_nfc_target_handle_s* handle, data_s** data, net_nfc_error_e* result)
2095 int real_data_size = 0;
2096 data_s rawdata = { NULL, 0 };
2103 *result = NET_NFC_OK;
2105 if (handle == NULL || data == NULL || result == NULL) {
2106 DEBUG_ERR_MSG("NET_NFC_NULL_PARAMETER >>>");
2107 *result = NET_NFC_NULL_PARAMETER;
2111 if (!__net_nfc_is_valide_target_handle(handle)) {
2112 DEBUG_ERR_MSG("NET_NFC_INVALID_HANDLE >>>");
2113 *result = NET_NFC_INVALID_HANDLE;
2117 if (!_net_nfc_emul_get_is_tag_attached()) {
2118 DEBUG_ERR_MSG("NET_NFC_NOT_ALLOWED_OPERATION >>>");
2119 *result = NET_NFC_NOT_ALLOWED_OPERATION;
2123 *result = _net_nfc_retrieve_ndef_message(&rawdata);
2124 if (*result != NET_NFC_OK) {
2125 _nfc_emul_util_free_mem(rawdata.buffer);
2129 real_data_size = rawdata.length;
2131 if (real_data_size == 0) {
2132 DEBUG_ERR_MSG("read ndef_msg is failed >>> real_data_size is zero");
2133 *result = NET_NFC_NO_NDEF_MESSAGE;
2134 _nfc_emul_util_free_mem(rawdata.buffer);
2138 *data = (data_s*) calloc(1, sizeof(data_s));
2140 if (*data == NULL) {
2141 *result = NET_NFC_ALLOC_FAIL;
2142 _nfc_emul_util_free_mem(rawdata.buffer);
2146 (*data)->length = real_data_size;
2147 (*data)->buffer = (uint8_t *)calloc(1, real_data_size);
2149 if ((*data)->buffer == NULL) {
2151 *result = NET_NFC_ALLOC_FAIL;
2152 _nfc_emul_util_free_mem(rawdata.buffer);
2156 /* copy rawdata to data->buffer */
2157 memcpy((*data)->buffer, rawdata.buffer, real_data_size);
2158 _nfc_emul_util_free_mem(rawdata.buffer);
2165 static bool net_nfc_emul_controller_write_ndef(net_nfc_target_handle_s* handle, data_s* data, net_nfc_error_e* result)
2170 *result = NET_NFC_OK;
2172 if (!__net_nfc_is_valide_target_handle(handle)) {
2173 *result = NET_NFC_INVALID_HANDLE;
2179 DEBUG_MSG("net_nfc_emul_controller_write_ndef success >>>");
2181 _net_nfc_store_ndef_message(data);
2189 static bool net_nfc_emul_controller_transceive(net_nfc_target_handle_s *handle,
2190 net_nfc_transceive_info_s *info, data_s **data, net_nfc_error_e *result)
2197 if (info == NULL || info->trans_data.buffer == NULL ||
2198 info->trans_data.length == 0) {
2199 *result = NET_NFC_INVALID_PARAM;
2203 *result = NET_NFC_OK;
2206 if (!__net_nfc_is_valide_target_handle(handle)) {
2207 *result = NET_NFC_INVALID_HANDLE;
2213 /* This implementation is not needed on Emulator environment */
2220 static bool net_nfc_emul_controller_format_ndef(net_nfc_target_handle_s* handle, data_s* secure_key, net_nfc_error_e* result)
2225 *result = NET_NFC_OK;
2227 if (!__net_nfc_is_valide_target_handle(handle)) {
2228 *result = NET_NFC_INVALID_HANDLE;
2239 static bool net_nfc_emul_controller_exception_handler(void)
2243 net_nfc_error_e error;
2245 if (net_nfc_emul_controller_init(&error) == false) {
2246 DEBUG_ERR_MSG("exception handler is failed!!");
2255 static bool net_nfc_emul_controller_is_ready(net_nfc_error_e* result)
2260 *result = NET_NFC_OK;
2266 return g_stack_init_successful;
2270 /*******************
2272 ********************/
2274 static bool net_nfc_emul_controller_llcp_config(net_nfc_llcp_config_info_s * config, net_nfc_error_e * result)
2279 *result = NET_NFC_OK;
2288 static bool net_nfc_emul_controller_llcp_check_llcp(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2293 *result = NET_NFC_OK;
2295 if (!__net_nfc_is_valide_target_handle(handle)) {
2296 *result = NET_NFC_INVALID_HANDLE;
2307 static bool net_nfc_emul_controller_llcp_activate_llcp(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2312 *result = NET_NFC_OK;
2314 if (!__net_nfc_is_valide_target_handle(handle)) {
2315 *result = NET_NFC_INVALID_HANDLE;
2326 static bool net_nfc_emul_controller_llcp_create_socket(net_nfc_llcp_socket_t* socket, net_nfc_socket_type_e socketType, uint16_t miu, uint8_t rw, net_nfc_error_e* result, void * user_param)
2331 *result = NET_NFC_OK;
2335 /* get available socket */
2336 socket_info_s* socket_info = _net_nfc_get_available_socket_slot();
2337 if (socket_info == NULL) {
2338 DEBUG_ERR_MSG("The available socket is nothing!!");
2342 /* get llcp state */
2343 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2344 llcp_state = _net_nfc_get_llcp_state(user_param);
2345 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2346 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN!!");
2350 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2351 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_SERVER");
2353 *socket = NET_NFC_EMUL_SNEP_SERVER_SOCKET_NUMBER;
2354 } else if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER_NPP) {
2355 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_SERVER_NPP");
2357 *socket = NET_NFC_EMUL_NPP_SERVER_SOCKET_NUMBER;
2358 } else if (llcp_state == NET_NFC_STATE_EXCHANGER_CLIENT) {
2359 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_CLIENT");
2361 *socket = NET_NFC_EMUL_CLIENT_SOCKET_NUMBER;
2362 } else if (llcp_state == NET_NFC_STATE_CONN_HANDOVER_REQUEST) {
2363 DEBUG_MSG("NET_NFC_STATE_CONN_HANDOVER_REQUEST");
2365 *socket = NET_NFC_EMUL_HANDOVER_REQUEST_SOCKET_NUMBER;
2366 } else if (llcp_state == NET_NFC_STATE_CONN_HANDOVER_SELECT) {
2367 DEBUG_MSG("NET_NFC_STATE_CONN_HANDOVER_SELECT");
2369 *socket = NET_NFC_EMUL_HANDOVER_SELECT_SOCKET_NUMBER;
2371 DEBUG_MSG("we doesn't support..");
2376 DEBUG_MSG("socket is created = [0x%x]", *socket);
2378 socket_info->socket_handle = *socket;
2379 socket_info->user_context = (void *) user_param;
2386 static bool net_nfc_emul_controller_llcp_bind(net_nfc_llcp_socket_t socket, uint8_t service_access_point, net_nfc_error_e* result)
2391 *result = NET_NFC_OK;
2400 static bool net_nfc_emul_controller_llcp_listen(net_nfc_target_handle_s* handle, uint8_t* service_access_name, net_nfc_llcp_socket_t socket, net_nfc_error_e* result, void * user_param)
2405 *result = NET_NFC_OK;
2407 if (!__net_nfc_is_valide_target_handle(handle)) {
2408 *result = NET_NFC_INVALID_HANDLE;
2414 /* Emul don't create real socket. So, we don't need to wait accept from remote socket */
2415 /* In here, send accept event for only snep */
2416 net_nfc_request_listen_socket_t *detail = NULL;
2418 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2419 if (socket_info == NULL) {
2420 DEBUG_ERR_MSG("socket_info is NULL");
2424 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2425 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2426 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2427 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN");
2431 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2432 _nfc_emul_util_alloc_mem(detail, sizeof(*detail));
2434 if (detail != NULL) {
2435 detail->length = sizeof(*detail);
2436 detail->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_LISTEN;
2438 socket_info->user_context = user_param;
2440 detail->handle = handle;
2441 detail->client_socket = NET_NFC_EMUL_INCOMING_SOCKET_NUMBER;
2442 detail->trans_param = socket_info->user_context;
2443 detail->result = NET_NFC_OK;
2445 DEBUG_MSG("accept callback is called");
2446 g_emul_controller_llcp_cb(detail, socket_info->user_context);
2449 DEBUG_MSG("llcp_state is [%d]", llcp_state);
2457 /* below accept function does not used. */
2458 static bool net_nfc_emul_controller_llcp_accept(net_nfc_llcp_socket_t socket, net_nfc_error_e* result, void *user_param)
2463 *result = NET_NFC_OK;
2472 static bool net_nfc_emul_controller_llcp_connect(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, uint8_t service_access_point, net_nfc_error_e* result, void * user_param)
2477 *result = NET_NFC_OK;
2479 if (!__net_nfc_is_valide_target_handle(handle)) {
2480 *result = NET_NFC_INVALID_HANDLE;
2486 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2487 if (socket_info == NULL) {
2488 DEBUG_ERR_MSG("socket_info is NULL");
2492 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2493 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2494 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2495 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN");
2504 static bool net_nfc_emul_controller_llcp_connect_by_url(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, uint8_t* service_access_name, net_nfc_error_e* result, void * user_param)
2509 *result = NET_NFC_OK;
2511 if (!__net_nfc_is_valide_target_handle(handle)) {
2512 *result = NET_NFC_INVALID_HANDLE;
2518 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2519 if (socket_info == NULL) {
2520 DEBUG_ERR_MSG("socket_info is NULL");
2524 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2525 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2526 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2527 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN");
2536 static bool net_nfc_emul_controller_llcp_send(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, data_s* data, net_nfc_error_e* result, void * user_param)
2541 *result = NET_NFC_OK;
2543 if (!__net_nfc_is_valide_target_handle(handle)) {
2544 *result = NET_NFC_INVALID_HANDLE;
2550 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2551 if (socket_info == NULL) {
2552 DEBUG_ERR_MSG("socket_info is NULL");
2556 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2557 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2558 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2559 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN");
2563 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2564 net_nfc_request_llcp_msg_t *req_msg = NULL;
2566 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
2568 socket_info->user_context = user_param;
2570 if (req_msg != NULL) {
2571 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
2572 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_SEND;
2573 req_msg->result = NET_NFC_OK;
2575 DEBUG_MSG("send callback is called");
2576 g_emul_controller_llcp_cb(req_msg, socket_info->user_context);
2585 static bool net_nfc_emul_controller_llcp_send_to(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, data_s* data, uint8_t service_access_point, net_nfc_error_e* result, void * user_param)
2590 *result = NET_NFC_OK;
2592 if (!__net_nfc_is_valide_target_handle(handle)) {
2593 *result = NET_NFC_INVALID_HANDLE;
2599 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2600 if (socket_info == NULL) {
2601 DEBUG_ERR_MSG("socket_info is NULL");
2605 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2606 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2607 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2608 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN");
2612 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2613 net_nfc_request_llcp_msg_t *req_msg = NULL;
2615 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
2617 socket_info->user_context = user_param;
2619 if (req_msg != NULL) {
2620 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
2621 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_SEND_TO;
2622 req_msg->result = NET_NFC_OK;
2624 DEBUG_MSG("send_to callback is called");
2625 g_emul_controller_llcp_cb(req_msg, socket_info->user_context);
2635 static bool net_nfc_emul_controller_llcp_recv(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, data_s * data, net_nfc_error_e* result, void * user_param)
2637 if (result == NULL || data == NULL)
2640 *result = NET_NFC_OK;
2642 if (!__net_nfc_is_valide_target_handle(handle)) {
2643 *result = NET_NFC_INVALID_HANDLE;
2649 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2650 if (socket_info == NULL) {
2651 DEBUG_ERR_MSG("socket_info is NULL");
2655 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2656 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2657 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2658 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN");
2662 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2664 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_SERVER");
2665 socket_info->user_context = user_param;
2667 if (Snep_Server_msg->isSegment) {
2668 /* send snep msg continueosly ..*/
2669 DEBUG_MSG("send segments for snep msg");
2671 int remained_size = 0;
2673 remained_size = Snep_Server_msg->data->length - Snep_Server_msg->offset;
2674 DEBUG_MSG("remained_size[%d]", remained_size);
2676 /* copy rawdata to llcp_server_data->buffer */
2677 if (remained_size <= SNEP_MAX_BUFFER) {
2678 DEBUG_MSG("send last segment >>>");
2680 llcp_server_data->length = remained_size;
2681 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer+Snep_Server_msg->offset , remained_size);
2683 Snep_Server_msg->isSegment = false;
2685 DEBUG_MSG("send continue segment >>>");
2687 llcp_server_data->length = SNEP_MAX_BUFFER;
2688 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer+Snep_Server_msg->offset, SNEP_MAX_BUFFER);
2690 Snep_Server_msg->offset += SNEP_MAX_BUFFER;
2693 _net_nfc_llcp_data_receive_cb(socket_info->user_context); /* call callback */
2695 /* In here, we dosen't call _net_nfc_llcp_data_receive_cb. just wait event from emulator */
2696 /*After copying data address, we will return it, immediately */
2697 DEBUG_MSG("data address is set");
2698 llcp_server_data = data;
2701 DEBUG_MSG("we don't support..");
2709 static bool net_nfc_emul_controller_llcp_recv_from(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, data_s * data, net_nfc_error_e* result, void * user_param)
2714 *result = NET_NFC_OK;
2716 if (!__net_nfc_is_valide_target_handle(handle)) {
2717 *result = NET_NFC_INVALID_HANDLE;
2723 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2724 if (socket_info == NULL) {
2725 DEBUG_ERR_MSG("socket_info is NULL");
2729 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2730 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2731 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2732 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN");
2736 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2738 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_SERVER");
2739 socket_info->user_context = user_param;
2741 if (Snep_Server_msg->isSegment) {
2742 /* send snep msg continueosly ..*/
2743 DEBUG_MSG("send segments for snep msg");
2745 int remained_size = 0;
2747 remained_size = Snep_Server_msg->data->length - Snep_Server_msg->offset;
2748 DEBUG_MSG("remained_size[%d]", remained_size);
2750 /* copy rawdata to llcp_server_data->buffer */
2751 if (remained_size <= SNEP_MAX_BUFFER) {
2752 DEBUG_MSG("send last segment >>>");
2754 llcp_server_data->length = remained_size;
2755 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer+Snep_Server_msg->offset , remained_size);
2757 Snep_Server_msg->isSegment = false;
2759 DEBUG_MSG("send continue segment >>>");
2761 llcp_server_data->length = SNEP_MAX_BUFFER;
2762 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer+Snep_Server_msg->offset, SNEP_MAX_BUFFER);
2764 Snep_Server_msg->offset += SNEP_MAX_BUFFER;
2767 _net_nfc_llcp_data_receive_from_cb(socket_info->user_context); /* call callback */
2769 /* In here, we dosen't call _net_nfc_llcp_data_receive_cb. just wait event from emulator */
2770 /*After copying data address, we will return it, immediately */
2772 DEBUG_MSG("data address is set");
2773 llcp_server_data = data;
2775 DEBUG_ERR_MSG("data address is NULL");
2780 DEBUG_MSG("we donen't support..");
2788 static bool net_nfc_emul_controller_llcp_disconnect(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, net_nfc_error_e* result, void * user_param)
2793 *result = NET_NFC_OK;
2795 if (!__net_nfc_is_valide_target_handle(handle)) {
2796 *result = NET_NFC_INVALID_HANDLE;
2802 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2803 if (socket_info == NULL) {
2804 DEBUG_ERR_MSG("socket_info is NULL");
2808 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2809 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2810 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2811 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN");
2815 /* send msg to framework */
2816 net_nfc_request_llcp_msg_t *req_msg = NULL;
2818 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
2820 socket_info->user_context = user_param;
2822 if (req_msg != NULL) {
2823 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
2824 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_DISCONNECT;
2825 req_msg->result = NET_NFC_OK;
2827 DEBUG_MSG("disconnect callback is called");
2828 g_emul_controller_llcp_cb(req_msg, user_param);
2831 /* reset socket_info */
2832 _net_nfc_remove_socket_slot((net_nfc_llcp_socket_t) socket);
2839 static bool net_nfc_emul_controller_llcp_socket_close(net_nfc_llcp_socket_t socket, net_nfc_error_e* result)
2844 *result = NET_NFC_OK;
2853 static bool net_nfc_emul_controller_llcp_reject(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, net_nfc_error_e* result)
2858 *result = NET_NFC_OK;
2860 if (!__net_nfc_is_valide_target_handle(handle)) {
2861 *result = NET_NFC_INVALID_HANDLE;
2872 static bool net_nfc_emul_controller_llcp_get_remote_config(net_nfc_target_handle_s* handle, net_nfc_llcp_config_info_s *config, net_nfc_error_e* result)
2874 /* In llcp specification ver 1.1, default miu size is 128 */
2875 const uint16_t default_miu = 128;
2880 *result = NET_NFC_OK;
2882 if (!__net_nfc_is_valide_target_handle(handle)) {
2883 *result = NET_NFC_INVALID_HANDLE;
2889 config->miu = default_miu;
2896 static bool net_nfc_emul_controller_llcp_get_remote_socket_info(net_nfc_target_handle_s* handle, net_nfc_llcp_socket_t socket, net_nfc_llcp_socket_option_s * option, net_nfc_error_e* result)
2898 /* In llcp specification ver 1.1, default miu size is 128 */
2899 const uint16_t default_miu = 128;
2904 *result = NET_NFC_OK;
2906 if (!__net_nfc_is_valide_target_handle(handle)) {
2907 *result = NET_NFC_INVALID_HANDLE;
2913 option->miu = default_miu;
2921 static bool net_nfc_emul_controller_support_nfc(net_nfc_error_e *result)
2924 struct stat st = { 0, };
2926 if (stat("/dev/nfc0", &st) == -1) {
2928 *result = NET_NFC_NOT_SUPPORTED;
2933 *result = NET_NFC_OK;
2939 static bool net_nfc_emul_controller_secure_element_open(net_nfc_secure_element_type_e element_type, net_nfc_target_handle_s **handle, net_nfc_error_e *result)
2941 DEBUG_ERR_MSG("se open start");
2942 *result = NET_NFC_OK;
2943 __net_nfc_make_valid_target_handle(handle);
2945 DEBUG_ERR_MSG("se_open end");
2948 static bool net_nfc_emul_controller_secure_element_get_atr(net_nfc_target_handle_s *handle,
2949 data_s **atr, net_nfc_error_e *result)
2953 int length = sizeof(buffer);
2956 DEBUG_ERR_MSG("se get_atr start");
2957 *result = NET_NFC_OK;
2960 strncpy(buffer, "getatr", sizeof(buffer));
2962 temp = (data_s *)calloc(1, sizeof(*temp));
2964 temp->buffer = (uint8_t *)calloc(1, length);
2965 if (temp->buffer != NULL) {
2966 memcpy(temp->buffer, buffer, length);
2967 temp->length = length;
2969 *result = NET_NFC_OK;
2972 *result = NET_NFC_ALLOC_FAIL;
2976 *result = NET_NFC_ALLOC_FAIL;
2979 DEBUG_ERR_MSG("se get atr end");
2982 static bool net_nfc_emul_controller_secure_element_send_apdu(net_nfc_target_handle_s *handle,
2983 data_s *command, data_s **response, net_nfc_error_e *result)
2990 DEBUG_ERR_MSG("se send apdu start");
2992 *result = NET_NFC_OK;
2996 strncpy(buffer, "response", sizeof(buffer));
2998 length = strlen(buffer);
3000 temp = (data_s *)calloc(1, sizeof(*temp));
3002 temp->buffer = (uint8_t *)calloc(1, length + 1);
3003 if (temp->buffer != NULL) {
3004 memcpy(temp->buffer, buffer, sizeof(temp->buffer) - 1);
3005 temp->length = length;
3008 *result = NET_NFC_OK;
3011 *result = NET_NFC_ALLOC_FAIL;
3015 *result = NET_NFC_ALLOC_FAIL;
3019 DEBUG_ERR_MSG("se send apdu end");
3022 static bool net_nfc_emul_controller_secure_element_close(net_nfc_target_handle_s *handle,
3023 net_nfc_error_e *result)
3025 DEBUG_ERR_MSG("se close start");
3026 *result = NET_NFC_OK;
3028 DEBUG_ERR_MSG("se close end");
3031 ////////////// INTERFACE END //////////