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)
322 LOGE ("FILE: %s, LINE:%d, Invalid parameter in mem free util (pinter is NULL)", filename, line);
329 void __nfc_emul_util_alloc_mem(void** mem, int size, char * filename, unsigned int line)
331 if (mem == NULL || size <= 0)
333 LOGE ("FILE: %s, LINE:%d, Invalid parameter in mem alloc util", filename, line);
337 DEBUG_MSG("size to malloc() = [%d]", size);
341 LOGE("FILE: %s, LINE:%d, WARNING: Pointer is already allocated or it was not initialized with NULL", filename, line);
344 *mem = malloc (size);
348 memset (*mem, 0x0, size);
352 LOGE("FILE: %s, LINE:%d, Allocation is failed", filename, line);
356 static bool __net_nfc_is_valide_target_handle (net_nfc_target_handle_s * handle)
358 bool result = (current_working_handle == handle);
360 DEBUG_MSG ("[WARNING]: INVALID HANDLE IS DETECTED!");
364 static void __net_nfc_make_valid_target_handle (net_nfc_target_handle_s ** handle)
366 if (current_working_handle != NULL){
367 DEBUG_MSG ("[WARNING]: HANDLE WAS ALLOCATED ALREADY!");
369 _nfc_emul_util_alloc_mem (*handle, sizeof (net_nfc_target_handle_s));
370 if (*handle != NULL) {
371 current_working_handle = *handle;
374 static void __net_nfc_make_invalid_target_handle ()
376 if (current_working_handle != NULL) {
377 _nfc_emul_util_free_mem (current_working_handle);
378 current_working_handle = NULL;
382 static socket_info_s * _net_nfc_get_available_socket_slot ()
385 for (; idx < LLCP_NB_SOCKET_MAX; idx++)
387 if (socket_info_array [idx].isValid == false)
389 memset (&(socket_info_array[idx]), 0x00, sizeof (socket_info_s));
390 socket_info_array [idx].isValid = true;
391 return &(socket_info_array[idx]);
395 DEBUG_ERR_MSG("_net_nfc_get_available_socket_slot is failed");
399 static void _net_nfc_remove_socket_slot (net_nfc_llcp_socket_t socket)
403 for (; idx < LLCP_NB_SOCKET_MAX; idx++)
405 if (socket_info_array [idx].isValid == true &&
406 socket_info_array [idx].socket_handle == socket)
408 socket_info_array [idx].isValid = false;
409 socket_info_array [idx].socket_handle = 0;
410 socket_info_array [idx].user_context= NULL;
415 static socket_info_s * _net_nfc_find_server_socket (net_nfc_llcp_socket_t socket)
418 for (; idx < LLCP_NB_SOCKET_MAX; idx++)
420 if (socket_info_array [idx].socket_handle == socket && socket_info_array [idx].isValid == true)
422 return &(socket_info_array[idx]);
426 DEBUG_ERR_MSG("_net_nfc_find_server_socket is failed");
430 ////////////// INTERFACE START //////////
432 NET_NFC_EXPORT_API bool onload(net_nfc_oem_interface_s* emul_interfaces)
436 emul_interfaces->init = net_nfc_emul_controller_init;
437 emul_interfaces->deinit = net_nfc_emul_controller_deinit;
438 emul_interfaces->register_listener = net_nfc_emul_controller_register_listener;
439 emul_interfaces->unregister_listener = net_nfc_emul_controller_unregister_listener;
440 emul_interfaces->get_firmware_version = net_nfc_emul_controller_get_firmware_version;
441 emul_interfaces->check_firmware_version = net_nfc_emul_controller_check_firmware_version;
442 emul_interfaces->update_firmeware = net_nfc_emul_controller_update_firmware;
443 emul_interfaces->get_stack_information = net_nfc_emul_controller_get_stack_information;
444 emul_interfaces->configure_discovery = net_nfc_emul_controller_configure_discovery;
445 emul_interfaces->get_secure_element_list = net_nfc_emul_controller_get_secure_element_list;
446 emul_interfaces->set_secure_element_mode = net_nfc_emul_controller_set_secure_element_mode;
447 emul_interfaces->connect = net_nfc_emul_controller_connect;
448 emul_interfaces->disconnect = net_nfc_emul_controller_disconnect;
449 emul_interfaces->check_ndef = net_nfc_emul_controller_check_ndef;
450 emul_interfaces->check_presence = net_nfc_emul_controller_check_target_presence;
451 emul_interfaces->read_ndef = net_nfc_emul_controller_read_ndef;
452 emul_interfaces->write_ndef = net_nfc_emul_controller_write_ndef;
453 emul_interfaces->make_read_only_ndef = net_nfc_emul_controller_make_read_only_ndef;
454 emul_interfaces->transceive = net_nfc_emul_controller_transceive;
455 emul_interfaces->format_ndef = net_nfc_emul_controller_format_ndef;
456 emul_interfaces->exception_handler = net_nfc_emul_controller_exception_handler;
457 emul_interfaces->is_ready = net_nfc_emul_controller_is_ready;
459 emul_interfaces->config_llcp = net_nfc_emul_controller_llcp_config;
460 emul_interfaces->check_llcp_status = net_nfc_emul_controller_llcp_check_llcp;
461 emul_interfaces->activate_llcp = net_nfc_emul_controller_llcp_activate_llcp;
462 emul_interfaces->create_llcp_socket = net_nfc_emul_controller_llcp_create_socket;
463 emul_interfaces->bind_llcp_socket = net_nfc_emul_controller_llcp_bind;
464 emul_interfaces->listen_llcp_socket = net_nfc_emul_controller_llcp_listen;
465 emul_interfaces->accept_llcp_socket = net_nfc_emul_controller_llcp_accept;
466 emul_interfaces->connect_llcp_by_url = net_nfc_emul_controller_llcp_connect_by_url;
467 emul_interfaces->connect_llcp = net_nfc_emul_controller_llcp_connect;
468 emul_interfaces->disconnect_llcp = net_nfc_emul_controller_llcp_disconnect;
469 emul_interfaces->close_llcp_socket = net_nfc_emul_controller_llcp_socket_close;
470 emul_interfaces->recv_llcp = net_nfc_emul_controller_llcp_recv;
471 emul_interfaces->send_llcp = net_nfc_emul_controller_llcp_send;
472 emul_interfaces->recv_from_llcp = net_nfc_emul_controller_llcp_recv_from;
473 emul_interfaces->send_to_llcp = net_nfc_emul_controller_llcp_send_to;
474 emul_interfaces->reject_llcp = net_nfc_emul_controller_llcp_reject;
475 emul_interfaces->get_remote_config = net_nfc_emul_controller_llcp_get_remote_config;
476 emul_interfaces->get_remote_socket_info = net_nfc_emul_controller_llcp_get_remote_socket_info;
478 emul_interfaces->support_nfc = net_nfc_emul_controller_support_nfc;
480 emul_interfaces->secure_element_open = net_nfc_emul_controller_secure_element_open;
481 emul_interfaces->secure_element_get_atr = net_nfc_emul_controller_secure_element_get_atr;
482 emul_interfaces->secure_element_send_apdu = net_nfc_emul_controller_secure_element_send_apdu;
483 emul_interfaces->secure_element_close = net_nfc_emul_controller_secure_element_close;
485 emul_interfaces->hce_response_apdu = NULL;
486 emul_interfaces->route_aid = NULL;
487 emul_interfaces->unroute_aid = NULL;
488 emul_interfaces->commit_routing = NULL;
489 emul_interfaces->set_default_route = NULL;
490 emul_interfaces->clear_aid_table = NULL;
491 emul_interfaces->get_aid_tablesize = NULL;
498 static void _net_nfc_initialize_llcp(void)
502 if(Snep_Server_msg == NULL)
504 Snep_Server_msg = (snep_msg_s *)calloc(1, sizeof(snep_msg_s));
505 Snep_Server_msg->data = (data_s *)calloc(1, sizeof(data_s));
506 Snep_Server_msg->data->buffer = (uint8_t *)calloc(1, sizeof(uint8_t) * BUFFER_LENGTH_MAX);
512 static void _net_nfc_deinitialize_llcp(void)
516 if (Snep_Server_msg != NULL)
518 if (Snep_Server_msg->data != NULL)
521 if (Snep_Server_msg->data->buffer != NULL)
523 free(Snep_Server_msg->data->buffer);
524 Snep_Server_msg->data->buffer = NULL;
527 free(Snep_Server_msg->data);
528 Snep_Server_msg->data = NULL;
531 free(Snep_Server_msg);
532 Snep_Server_msg = NULL;
535 llcp_server_data = NULL;
540 static bool _net_nfc_emul_get_is_tag_attached(void)
542 return g_tag_attached;
545 static void _net_nfc_emul_set_is_tag_attached(bool is_detached)
547 g_tag_attached = is_detached;
548 DEBUG_MSG("set g_tag_attached [%d]", g_tag_attached);
551 static bool _net_nfc_emul_get_is_p2p_attached(void)
553 return g_p2p_attached;
556 static void _net_nfc_emul_set_is_p2p_attached(bool is_detached)
558 g_p2p_attached = is_detached;
559 DEBUG_MSG("set g_p2p_attached [%d]", g_p2p_attached);
562 static bool _net_nfc_is_data_emulMsgData(emul_message_id messageId)
569 case EMUL_NFC_TAG_DISCOVERED :{
574 case EMUL_NFC_P2P_SEND :{
579 case EMUL_NFC_TAG_DETACHED :
580 case EMUL_NFC_P2P_DISCOVERED :
581 case EMUL_NFC_P2P_DETACHED :
587 DEBUG_MSG("retval [%d]", retval);
594 static net_nfc_record_tnf_e _net_nfc_get_tnf_type(int name_format)
598 net_nfc_record_tnf_e tnf = NET_NFC_RECORD_EMPTY;
600 switch (name_format) {
601 case EMUL_NDEF_TNF_EMPTY :
602 tnf = NET_NFC_RECORD_EMPTY;
605 case EMUL_NDEF_TNF_WELL_KNOWN :
606 tnf = NET_NFC_RECORD_WELL_KNOWN_TYPE;
609 case EMUL_NDEF_TNF_MIME_MEDIA :
610 tnf = NET_NFC_RECORD_MIME_TYPE;
613 case EMUL_NDEF_TNF_ABSOLUTE_URI :
614 tnf = NET_NFC_RECORD_URI;
617 case EMUL_NDEF_TNF_EXTERNAL :
618 tnf = NET_NFC_RECORD_EXTERNAL_RTD;
621 case EMUL_NDEF_TNF_UNKNOWN :
622 tnf = NET_NFC_RECORD_UNKNOWN;
626 tnf = NET_NFC_RECORD_UNKNOWN;
627 DEBUG_MSG("data is currupted");
632 DEBUG_MSG("tnf [%d]", tnf);
640 static int _net_nfc_create_records_from_emulMsg(emulMsg_s *emul_msg, ndef_message_s **ndef_message, int record_count)
645 int create_record_count = 0;
646 char emulMsg[BUFFER_LENGTH_MAX] = { 0, };
648 memcpy(emulMsg, emul_msg->file_data, strlen((char*)emul_msg->file_data));
650 /* parsing data and create record to record structure */
651 for (index = 0; index < record_count ; index ++) {
655 char *record_payload;
657 emulMsg_data_s record = { 0, };
663 name_format = strtok((char *) emulMsg, NET_NFC_EMUL_MSG_RECORD_SEPERATOR);
667 name_format = strtok(NULL, NET_NFC_EMUL_MSG_RECORD_SEPERATOR);
669 type_name = strtok(NULL, NET_NFC_EMUL_MSG_RECORD_SEPERATOR);
670 record_id = strtok(NULL, NET_NFC_EMUL_MSG_RECORD_SEPERATOR);
671 if (index == record_count-1) {
672 /* the last payload : we have to read sentence fully */
673 record_payload = strtok(NULL, "\n");
676 record_payload = strtok(NULL, NET_NFC_EMUL_MSG_RECORD_SEPERATOR);
679 /* assign data to record structure */
680 record.tnf = _net_nfc_get_tnf_type(atoi(name_format));
682 DEBUG_MSG("Data : type_name ");
684 record.typeName.length = strlen(type_name);
685 _nfc_emul_util_alloc_mem(record.typeName.buffer, record.typeName.length);
687 if (record.typeName.buffer == NULL) {
688 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
691 memcpy(record.typeName.buffer, type_name, record.typeName.length);
693 DEBUG_MSG("Data : record_id ");
695 record.id.length = strlen(record_id);
696 _nfc_emul_util_alloc_mem(record.id.buffer, record.id.length);
698 if (record.id.buffer == NULL) {
699 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
702 memcpy(record.id.buffer, record_id, record.id.length);
704 DEBUG_MSG("Data : record_payload ");
706 record.payload.length = strlen(record_payload);
707 _nfc_emul_util_alloc_mem(record.payload.buffer, record.payload.length);
709 if (record.payload.buffer == NULL) {
710 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
713 memcpy(record.payload.buffer, record_payload, record.payload.length);
715 #ifndef __EMUL_DEBUG__
716 DEBUG_ERR_MSG("RECORD DATA START >>>>>>>>>>>>>>>>>>>>>>>>");
717 DEBUG_MSG("TNF >>>>[%d]", record.tnf);
718 LOGE("type_name >>>>[%s]", type_name);
719 LOGE("record_id >>>>[%s]", record_id);
720 DEBUG_MSG("record_payload >>>>[%s]", record_payload);
721 DEBUG_ERR_MSG("RECORD DATA END >>>>>>>>>>>>>>>>>>>>>>>>");
725 ndef_record_h new_record = NULL;
726 net_nfc_error_e result = NET_NFC_OK;
728 if (record.tnf == NET_NFC_RECORD_EMPTY) {
729 if((result = net_nfc_util_create_record(NET_NFC_RECORD_EMPTY, &record.typeName, &record.id, &record.payload, (ndef_record_s **) &new_record)) != NET_NFC_OK) {
730 DEBUG_MSG("net_nfc_create_record failed[%d]", result);
734 else if (record.tnf == NET_NFC_RECORD_UNKNOWN) {
735 if((result = net_nfc_util_create_record(NET_NFC_RECORD_UNKNOWN, &record.typeName, &record.id, &record.payload, (ndef_record_s **) &new_record)) != NET_NFC_OK) {
736 DEBUG_MSG("net_nfc_create_record failed[%d]", result);
740 else if ((record.tnf == NET_NFC_RECORD_WELL_KNOWN_TYPE)) {
741 if (!strncmp((char *)record.typeName.buffer, "U", 1)) {
742 DEBUG_MSG("URI Type ");
744 data_s payload_data = { NULL, 0 };
746 if (record.payload.buffer != NULL )
748 payload_data.length = strlen((char *)record_payload) + 1;
750 _nfc_emul_util_alloc_mem(payload_data.buffer, payload_data.length);
751 if (payload_data.buffer == NULL)
753 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
757 payload_data.buffer[0] = NET_NFC_SCHEMA_FULL_URI; /* first byte of payload is protocol scheme */
758 memcpy(payload_data.buffer + 1, record.payload.buffer, payload_data.length - 1);
761 if (net_nfc_util_create_record(record.tnf, &record.typeName, &record.id, &payload_data, (ndef_record_s**) &new_record) != NET_NFC_OK){
762 DEBUG_ERR_MSG("net_nfc_util_create_record is failed");
766 if (payload_data.buffer != NULL )
767 _nfc_emul_util_free_mem(payload_data.buffer);
769 else if (!strncmp((char *)record.typeName.buffer, "T", 1)) {
770 DEBUG_MSG("TEXT Type ");
772 data_s payload_data = { NULL, 0 };
776 if (record.payload.buffer != NULL )
778 payload_data.length = strlen((char *)record_payload) + strlen("en-US") + 1;
780 _nfc_emul_util_alloc_mem(payload_data.buffer, payload_data.length);
781 if (payload_data.buffer == NULL)
783 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
787 controll_byte = strlen("en-US") & 0x3F;
789 payload_data.buffer[0] = controll_byte;
792 memcpy(payload_data.buffer + offset, "en-US", strlen("en-US"));
794 offset = offset + strlen("en-US");
795 memcpy(payload_data.buffer + offset, record.payload.buffer, strlen(record_payload));
799 if (net_nfc_util_create_record(record.tnf, &record.typeName, &record.id, &payload_data, (ndef_record_s**) &new_record) != NET_NFC_OK){
800 DEBUG_ERR_MSG("net_nfc_util_create_record is failed");
804 if (payload_data.buffer != NULL )
805 _nfc_emul_util_free_mem(payload_data.buffer);
808 DEBUG_ERR_MSG("NET_NFC_RECORD_WELL_KNOWN_TYPE >> typeName is wrong");
812 else if ((record.tnf == NET_NFC_RECORD_MIME_TYPE)) {
816 /* open file : size limit? 10k? */
817 file = fopen(record_payload, "r");
819 long int file_len = 0, read_count = 0, read_total = 0;
820 uint8_t *file_data = NULL;
822 fseek(file, 0, SEEK_END);
823 file_len = ftell(file);
824 fseek(file, 0, SEEK_SET);
826 _nfc_emul_util_alloc_mem(file_data, file_len);
828 if (file_data == NULL)
830 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
838 read_count = fread(file_data + read_total, 1, file_len - read_total, file);
839 read_total += read_count;
841 while (read_count != 0 && read_total < file_len);
845 DEBUG_MSG("fread(%s) success, size %ld", record.payload.buffer, file_len);
847 filePayload.length= file_len;
848 _nfc_emul_util_alloc_mem(filePayload.buffer, filePayload.length);
850 if (filePayload.buffer == NULL) {
851 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
852 _nfc_emul_util_free_mem(file_data);
855 memcpy(filePayload.buffer, file_data, filePayload.length);
857 _nfc_emul_util_free_mem(file_data);
860 if (record.id.buffer == NULL) {
861 char *file_name = NULL;
863 file_name = strrchr(record_payload, '/');
864 if (file_name == NULL) {
865 file_name = (char *) record_payload;
871 record.id.length = strlen(file_name);
872 _nfc_emul_util_alloc_mem(record.id.buffer, record.id.length);
874 if (record.id.buffer == NULL) {
875 DEBUG_MSG("_nfc_emul_util_alloc_mem failed");
876 _nfc_emul_util_free_mem(filePayload.buffer);
879 memcpy(record.id.buffer, file_name, record.id.length);
883 DEBUG_MSG("file open error");
888 if((result = net_nfc_util_create_record(record.tnf, &record.typeName, &record.id, &filePayload, (ndef_record_s **) &new_record)) != NET_NFC_OK) {
889 DEBUG_MSG("net_nfc_create_record failed[%d]", result);
894 /* NET_NFC_RECORD_URI or NET_NFC_RECORD_EXTERNAL_RTD */
895 if((result = net_nfc_util_create_record(record.tnf, &record.typeName, &record.id, &record.payload, (ndef_record_s **) &new_record)) != NET_NFC_OK) {
896 DEBUG_MSG("net_nfc_create_record failed[%d]", result);
901 /* append record to ndef msg */
902 if((result = net_nfc_util_append_record((ndef_message_s*) *ndef_message, (ndef_record_s *) new_record)) != NET_NFC_OK){
903 DEBUG_MSG("net_nfc_util_append_record failed[%d]", result);
907 create_record_count++;
908 DEBUG_MSG("Create Record Sucess. Create Record Count[%d]", create_record_count);
910 /* To Do : memory issue */
913 if (record.typeName.buffer != NULL) {
914 _nfc_emul_util_free_mem(record.typeName.buffer);
916 if (record.id.buffer != NULL) {
917 _nfc_emul_util_free_mem(record.id.buffer);
919 if (record.payload.buffer != NULL) {
920 _nfc_emul_util_free_mem(record.payload.buffer);
922 if(filePayload.buffer != NULL) {
923 _nfc_emul_util_free_mem(filePayload.buffer);
926 DEBUG_MSG("Create Record Loop End");
932 return create_record_count;
935 static bool _net_nfc_change_file_owner_permission(FILE *file)
938 size_t buffer_len = 0;
939 struct passwd pwd = { 0, };
940 struct passwd *pw_inhouse = NULL;
941 struct group grp = { 0, };
942 struct group *gr_inhouse = NULL;
947 /* change permission */
948 fchmod(fileno(file), 0777);
952 buffer_len = sysconf(_SC_GETPW_R_SIZE_MAX);
953 if (buffer_len == -1)
958 _net_nfc_util_alloc_mem(buffer, buffer_len);
962 getpwnam_r("inhouse", &pwd, buffer, buffer_len, &pw_inhouse);
963 _net_nfc_util_free_mem(buffer);
966 buffer_len = sysconf(_SC_GETGR_R_SIZE_MAX);
967 if (buffer_len == -1)
972 _net_nfc_util_alloc_mem(buffer, buffer_len);
976 getgrnam_r("inhouse", &grp, buffer, buffer_len, &gr_inhouse);
977 _net_nfc_util_free_mem(buffer);
979 if ((pw_inhouse != NULL) && (gr_inhouse != NULL))
981 if (fchown(fileno(file), pw_inhouse->pw_uid, gr_inhouse->gr_gid) < 0)
983 DEBUG_MSG("failed to change owner");
990 static void _net_nfc_store_ndef_message(data_s *data)
992 char file_name[1024] = { 0, };
1001 snprintf(file_name, sizeof(file_name), "%s/%s/%s", "/opt/usr/share/nfc-manager-daemon",
1002 "message", "emul-ndef-message.txt");
1006 if ((fp = fopen(file_name, "w")) != NULL)
1010 if ((length = fwrite(data->buffer, 1, data->length, fp)) > 0)
1012 DEBUG_MSG("[%d] bytes is written", length);
1014 _net_nfc_change_file_owner_permission(fp);
1020 DEBUG_MSG("write is failed = [%d]", data->length);
1027 static net_nfc_error_e _net_nfc_retrieve_ndef_message(data_s *data)
1029 char file_name[1024] = { 0, };
1031 net_nfc_error_e result = NET_NFC_OK;
1035 return NET_NFC_NULL_PARAMETER;
1039 snprintf(file_name, sizeof(file_name), "%s/%s/%s", "/opt/usr/share/nfc-manager-daemon",
1040 "message", "emul-ndef-message.txt");
1042 if ((fp = fopen(file_name, "r")) != NULL)
1046 /* rewind to start of file */
1047 fseek(fp, 0, SEEK_END);
1049 fseek(fp, 0, SEEK_SET);
1051 DEBUG_MSG("message length = [%ld]", size);
1055 if (net_nfc_util_init_data(data, size) == true)
1062 current = fread(data->buffer + offset, 1,
1063 data->length - offset, fp);
1068 } while (offset < data->length);
1070 if (offset == data->length) {
1071 result = NET_NFC_OK;
1073 result = NET_NFC_NO_NDEF_MESSAGE;
1078 result = NET_NFC_ALLOC_FAIL;
1083 result = NET_NFC_OPERATION_FAIL;
1090 result = NET_NFC_NO_DATA_FOUND;
1096 static bool _net_nfc_create_ndef_from_emulMsg(emulMsg_s *emul_msg)
1100 if (emul_msg->file_data == NULL) {
1105 net_nfc_error_e result = NET_NFC_OK;
1106 data_s rawdata = { NULL, 0 };
1108 int record_count = emul_msg->record_count;
1110 if(record_count == 0) {
1114 /* create ndef msg */
1115 ndef_message_h ndef_message = NULL;
1116 int ndef_length = 0;
1118 if((result = net_nfc_util_create_ndef_message ((ndef_message_s **) &ndef_message)) != NET_NFC_OK)
1120 DEBUG_MSG("failed to create ndef message [%d]", result);
1123 /* create records and append it to ndef_msg*/
1124 emul_msg->record_count = _net_nfc_create_records_from_emulMsg(emul_msg, (ndef_message_s **) &ndef_message, record_count);
1126 /* convert ndef msg to raw data */
1127 ndef_length = net_nfc_util_get_ndef_message_length ((ndef_message_s *) ndef_message);
1130 DEBUG_MSG("ndef_message size is zero!");
1133 rawdata.length = ndef_length;
1134 _nfc_emul_util_alloc_mem(rawdata.buffer, ndef_length);
1136 if((result = net_nfc_util_convert_ndef_message_to_rawdata((ndef_message_s*)ndef_message, &rawdata)) != NET_NFC_OK) {
1137 DEBUG_MSG("net_nfc_util_convert_ndef_message_to_rawdata is failed![%d]", result);
1141 _net_nfc_store_ndef_message(&rawdata);
1148 static bool _net_nfc_create_emulMsg(emulMsg_s **emul_msg, uint8_t * data, long int size)
1155 *emul_msg = (emulMsg_s *)calloc(1, sizeof(emulMsg_s));
1156 if(*emul_msg == NULL)
1159 /* emulData => ID : MSG ex) 100:1,1,1,U,samsung,http://www.naver.com */
1160 emulMsgID = strtok((char *)data, NET_NFC_EMUL_MSG_ID_SEPERATOR);
1161 if (emulMsgID != NULL) {
1162 (*emul_msg)->message_id = (emul_message_id) (atoi(emulMsgID));
1165 DEBUG_MSG("emul_msg->message_id >>>>[%d]", (*emul_msg)->message_id);
1167 if (_net_nfc_is_data_emulMsgData((*emul_msg)->message_id)) {
1169 emulMsgData = strtok(NULL, NET_NFC_EMUL_MSG_DATA_SEPERATOR);
1170 DEBUG_MSG("emulMsgData >>>>[%s]", emulMsgData);
1172 switch ((*emul_msg)->message_id) {
1173 case EMUL_NFC_TAG_DISCOVERED :
1174 case EMUL_NFC_P2P_SEND :
1176 /* get message : Tag Type, Record Count, Records */
1177 int target_type = -1;
1178 char file_data[BUFFER_LENGTH_MAX]={ 0, };
1181 sscanf(emulMsgData, NET_NFC_EMUL_TAG_DISCOVERED_DATA_FORMAT, &target_type, &((*emul_msg)->record_count), file_data);
1183 (*emul_msg)->target_type = (emul_target_type) target_type;
1185 length = strlen(file_data)+1;
1186 _nfc_emul_util_alloc_mem((*emul_msg)->file_data, length);
1187 memcpy((*emul_msg)->file_data, file_data, length);
1189 DEBUG_ERR_MSG("EMUL MESSAGE DATA START >>>>>>>>>>>>>>>>>>>>>>>>");
1190 DEBUG_MSG("message_id >>>>[%d]", (*emul_msg)->message_id);
1191 DEBUG_MSG("target_type >>>>[%d]", (*emul_msg)->target_type);
1192 DEBUG_MSG("record_count >>>>[%d]", (*emul_msg)->record_count);
1193 DEBUG_MSG("file_data >>>>[%s]", (char *)(*emul_msg)->file_data);
1194 DEBUG_ERR_MSG("EMUL MESSAGE DATA END >>>>>>>>>>>>>>>>>>>>>>>>");
1196 if ( !_net_nfc_create_ndef_from_emulMsg((*emul_msg))) {
1197 DEBUG_ERR_MSG("read ndef_msg is failed >>>");
1200 DEBUG_ERR_MSG("_net_nfc_create_ndef_from_emulMsg end");
1205 /* exception case */
1206 DEBUG_ERR_MSG("_net_nfc_set_emulMsg error. Data is currupted");
1215 switch ((*emul_msg)->message_id) {
1216 case EMUL_NFC_P2P_DISCOVERED :{
1217 (*emul_msg)->target_type = EMUL_NFC_TARGET;
1221 case EMUL_NFC_TAG_DETACHED :{
1222 DEBUG_MSG("TAG DETACHED");
1223 if(!_net_nfc_emul_get_is_tag_attached())
1225 DEBUG_ERR_MSG("tag is not attached!!");
1231 case EMUL_NFC_P2P_DETACHED :{
1232 DEBUG_MSG("P2P DETACHED");
1233 if(!_net_nfc_emul_get_is_p2p_attached())
1235 DEBUG_ERR_MSG("tag is not attached!!");
1243 /* exception case */
1244 DEBUG_ERR_MSG("_net_nfc_set_emulMsg error. Data is currupted");
1256 static void _net_nfc_destroy_emulMsg(emulMsg_s *emul_msg)
1260 if(emul_msg != NULL && emul_msg->file_data != NULL)
1262 free(emul_msg->file_data);
1269 static int _net_nfc_emul_convert_target_type(emul_target_type targetType)
1275 switch (targetType) {
1276 case EMUL_TAG_TOPAZ_JEWEL :
1277 covert = NET_NFC_JEWEL_PICC;
1280 case EMUL_TAG_MIFARE_UL :
1281 covert = NET_NFC_MIFARE_ULTRA_PICC;
1284 case EMUL_TAG_FELICA :
1285 covert = NET_NFC_FELICA_PICC;
1288 case EMUL_TAG_MIFARE_DESFIRE :
1289 covert = NET_NFC_MIFARE_DESFIRE_PICC;
1292 case EMUL_NFC_TARGET :
1293 covert = NET_NFC_NFCIP1_TARGET;
1296 case EMUL_TARGET_TYPE_MAX :
1298 /* exception case */
1299 DEBUG_ERR_MSG("_net_nfc_emul_convert_target_type error. Target type is unknown");
1304 DEBUG_MSG("covert [%d]", covert);
1311 static void _net_nfc_target_discovered_cb(emulMsg_s *emul_msg)
1316 net_nfc_target_handle_s* handle = NULL;
1319 __net_nfc_make_valid_target_handle (&handle);
1320 if(handle == NULL) {
1325 net_nfc_request_target_detected_t* target_detected = NULL;
1326 uint8_t device_info[] = { 0x03, 0x55, 0x49, 0x44, 0x07, 0x04, 0x93, 0xB7, 0xD9, 0x5B, 0x02, 0x80, \
1327 0x08, 0x41, 0x50, 0x50, 0x5F, 0x44, 0x41, 0x54, 0x41, 0x00, 0x03, 0x53, 0x41, 0x4B, \
1328 0x01, 0x00, 0x04, 0x41, 0x54, 0x51, 0x41, 0x02, 0x44, 0x00, 0x0D, 0x4D, 0x41, 0x58, \
1329 0x5F, 0x44, 0x41, 0x54, 0x41, 0x5F, 0x52, 0x41, 0x54, 0x45, 0x01, 0x00, 0x08, 0x46, \
1330 0x57, 0x49, 0x5F, 0x53, 0x46, 0x47, 0x54, 0x01, 0x03, 0x49, 0x44, 0x6D, 0x07, 0x04, \
1331 0x93, 0xB7, 0xD9, 0x5B, 0x02, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
1334 length = sizeof(net_nfc_request_target_detected_t) + sizeof(device_info);
1335 _nfc_emul_util_alloc_mem(target_detected, length);
1336 if (target_detected == NULL)
1341 target_detected->length = length;
1342 target_detected->request_type = NET_NFC_MESSAGE_SERVICE_STANDALONE_TARGET_DETECTED;
1343 target_detected->handle = handle;
1345 target_detected->devType = _net_nfc_emul_convert_target_type(emul_msg->target_type);
1346 if (!target_detected->devType) {
1347 DEBUG_MSG("target_detected->devType is unknown");
1348 _nfc_emul_util_free_mem(target_detected);
1352 target_detected->handle->connection_id = current_connection_id++;
1354 if(target_detected->devType == NET_NFC_NFCIP1_TARGET ){
1355 DEBUG_MSG("set llcp connection type. remote device is target");
1356 handle->connection_type = NET_NFC_P2P_CONNECTION_TARGET;
1357 _net_nfc_emul_set_is_p2p_attached(true);
1359 else if ( target_detected->devType == NET_NFC_NFCIP1_INITIATOR){
1360 DEBUG_MSG("set llcp connection type. remote device is initiator");
1361 handle->connection_type = NET_NFC_P2P_CONNECTION_INITIATOR;
1362 _net_nfc_emul_set_is_p2p_attached(true);
1366 DEBUG_MSG("set tag connection");
1367 handle->connection_type = NET_NFC_TAG_CONNECTION;
1368 _net_nfc_emul_set_is_tag_attached(true);
1371 target_detected->number_of_keys = 7;
1372 target_detected->target_info_values.length = sizeof(device_info);
1373 memcpy(&target_detected->target_info_values.buffer, device_info, target_detected->target_info_values.length);
1375 /* call target_cb */
1376 if(g_emul_controller_target_cb != NULL) {
1377 DEBUG_MSG("discovered callback is called");
1378 g_emul_controller_target_cb(target_detected, NULL);
1383 static void _net_nfc_tag_detached_cb(void)
1387 _net_nfc_emul_set_is_tag_attached(false);
1392 static void _net_nfc_target_detached_cb(void)
1396 _net_nfc_emul_set_is_p2p_attached(false);
1398 /* For P2P, we send msg to manager */
1399 net_nfc_request_llcp_msg_t *req_msg = NULL;
1401 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
1403 if (req_msg != NULL) {
1404 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
1405 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_DEACTIVATED;
1407 DEBUG_MSG("deactivated callback is called");
1408 g_emul_controller_llcp_cb(req_msg, NULL);
1412 static void _net_nfc_llcp_data_receive_cb(void* pContext)
1416 net_nfc_request_llcp_msg_t *req_msg = NULL;
1418 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
1420 if (req_msg != NULL) {
1421 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
1422 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_RECEIVE;
1423 req_msg->result = NET_NFC_OK;
1425 DEBUG_MSG("receive callback is called >>");
1426 g_emul_controller_llcp_cb(req_msg, pContext);
1432 static void _net_nfc_llcp_data_receive_from_cb(void* pContext)
1436 net_nfc_request_llcp_msg_t *req_msg = NULL;
1438 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
1440 if (req_msg != NULL){
1441 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
1442 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_RECEIVE_FROM;
1443 req_msg->result = NET_NFC_OK;
1445 DEBUG_MSG("receive_from callback is called >>");
1446 g_emul_controller_llcp_cb(req_msg, pContext);
1452 static void _net_nfc_llcp_create_snep_server_msg(snep_command_field_e resp_field)
1456 uint8_t* temp = Snep_Server_msg->data->buffer;
1457 uint8_t response = (uint8_t)resp_field;
1458 uint8_t version = 0;
1459 uint32_t length_field = 0;
1460 data_s rawdata = { NULL, 0 };
1462 version = SNEP_MAJOR_VER;
1463 version = (((version << 4) & 0xf0) | (SNEP_MINOR_VER & 0x0f));
1465 _net_nfc_retrieve_ndef_message(&rawdata);
1467 /* version response length payload*/
1468 Snep_Server_msg->data->length = sizeof(uint8_t) + sizeof(uint8_t) + sizeof(uint32_t) + rawdata.length;
1478 length_field = htonl(rawdata.length);
1480 /* length will be se 0. so we don't need to copy value */
1481 memcpy(temp, &length_field, sizeof(uint32_t));
1482 temp += sizeof(uint32_t);
1484 /* copy ndef information to response msg */
1485 if(rawdata.length > 0)
1486 memcpy(temp, rawdata.buffer, rawdata.length);
1491 static llcp_state_e _net_nfc_get_llcp_state(void* pContext)
1496 state = NET_NFC_STATE_EXCHANGER_SERVER;
1503 static bool _net_nfc_make_llcp_data(emulMsg_s *emul_msg)
1506 data_s rawdata = { NULL, 0 };
1508 _net_nfc_retrieve_ndef_message(&rawdata);
1510 if (emul_msg->record_count == 0 || rawdata.length == 0)
1512 DEBUG_ERR_MSG("data is zero >>>");
1516 /* For SNEP, we should create snep msg, and then copy it to llcp_server_data */
1517 _net_nfc_llcp_create_snep_server_msg(SNEP_REQ_PUT);
1519 /* copy rawdata to llcp_server_data->buffer */
1520 if (Snep_Server_msg->data->length <= SNEP_MAX_BUFFER) {
1521 DEBUG_MSG("The snep msg size is small than SNEP_MAX_BUFFER >>>");
1523 if (llcp_server_data == NULL)
1526 llcp_server_data->length = Snep_Server_msg->data->length;
1527 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer, Snep_Server_msg->data->length);
1530 DEBUG_MSG("send first segment >>>");
1532 if (llcp_server_data == NULL) {
1536 llcp_server_data->length = SNEP_MAX_BUFFER;
1537 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer, SNEP_MAX_BUFFER);
1539 Snep_Server_msg->isSegment = true;
1540 Snep_Server_msg->offset = SNEP_MAX_BUFFER;
1548 static void _net_nfc_send_emulMsg_to_nfc_manager(emulMsg_s *emul_msg)
1552 switch (emul_msg->message_id) {
1553 case EMUL_NFC_TAG_DISCOVERED :{
1554 _net_nfc_target_discovered_cb(emul_msg);
1558 case EMUL_NFC_TAG_DETACHED :{
1559 _net_nfc_tag_detached_cb();
1563 case EMUL_NFC_P2P_DISCOVERED : {
1564 _net_nfc_initialize_llcp();
1565 _net_nfc_target_discovered_cb(emul_msg);
1569 case EMUL_NFC_P2P_SEND : {
1570 if(!_net_nfc_emul_get_is_p2p_attached())
1572 DEBUG_ERR_MSG("target is not attached!!");
1576 if(_net_nfc_make_llcp_data(emul_msg)) {
1578 /* find snep server*/
1579 socket_info_s *socket_info = _net_nfc_find_server_socket(NET_NFC_EMUL_SNEP_SERVER_SOCKET_NUMBER);
1580 if (socket_info == NULL) {
1581 DEBUG_ERR_MSG ("socket_info is NULL");
1585 _net_nfc_llcp_data_receive_cb(socket_info->user_context); /* call callback */
1588 DEBUG_ERR_MSG("make_p2p_data is fail!!");
1594 case EMUL_NFC_P2P_DETACHED : {
1595 if(!_net_nfc_emul_get_is_p2p_attached())
1597 DEBUG_ERR_MSG("target is not attached!!");
1601 _net_nfc_target_detached_cb();
1602 _net_nfc_deinitialize_llcp();
1607 DEBUG_ERR_MSG("message_id is wrong!!");
1614 static void _net_nfc_process_emulMsg(uint8_t * data, long int size)
1618 emulMsg_s *emul_msg = NULL;
1620 /* create emul_msg */
1621 _net_nfc_create_emulMsg(&emul_msg, data, size);
1623 DEBUG_MSG("emul_msg->message_id >>>>[%d]", emul_msg->message_id);
1625 /* processing emul_msg */
1626 _net_nfc_send_emulMsg_to_nfc_manager(emul_msg);
1628 /* destroy emul_msg */
1629 _net_nfc_destroy_emulMsg(emul_msg);
1634 #ifdef __USE_EPOLL_FOR_FILE__
1635 static void emul_ReaderThread(void * pArg)
1637 DEBUG_MSG("emul_ReaderThread START >>>>");
1639 char file_name[1024] = { 0, };
1640 bool condition = true;
1642 int emulMsg_file_fd = -1;
1643 int emulMsg_poll_fd = -1;
1644 struct epoll_event *emulMsg_poll_events = NULL;
1646 /* make file name */
1647 snprintf(file_name, sizeof(file_name), "%s/%s", NET_NFC_EMUL_DATA_PATH, NET_NFC_EMUL_MESSAGE_FILE_NAME );
1648 LOGE("file path : %s", file_name);
1650 /* open file for poll */
1651 emulMsg_file_fd = open(file_name, O_RDONLY|O_NONBLOCK);
1652 if (emulMsg_file_fd < 0) {
1653 DEBUG_MSG("file open error !!!!");
1658 if((emulMsg_poll_fd = epoll_create1(EPOLL_CLOEXEC)) == -1)
1660 DEBUG_MSG("epoll_create1 is occured");
1661 close(emulMsg_file_fd);
1665 if((emulMsg_poll_events = (struct epoll_event *)calloc(1, sizeof(struct epoll_event) * EPOLL_SIZE)) == NULL)
1667 DEBUG_MSG("calloc is occured");
1668 close(emulMsg_file_fd);
1673 struct epoll_event ev;
1675 ev.events = EPOLLIN | EPOLLET | EPOLLHUP | EPOLLERR;
1676 ev.data.fd = emulMsg_file_fd;
1678 /* add file fd to epoll */
1679 epoll_ctl(emulMsg_poll_fd, EPOLL_CTL_ADD, emulMsg_file_fd, &ev);
1681 while (condition == true) {
1683 int num_of_files = 0;
1686 /* to do : I will add mutex in the future */
1689 DEBUG_MSG("epoll wait >>>>");
1691 if(emulMsg_poll_fd == -1 || emulMsg_file_fd == -1)
1693 DEBUG_MSG("client is deinitialized. ");
1697 while((num_of_files = epoll_wait(emulMsg_poll_fd, emulMsg_poll_events, EPOLL_SIZE, -1)) == 0) {
1698 DEBUG_MSG("no data is changed ");
1701 for(index = 0; index < num_of_files; index++)
1703 if( (emulMsg_poll_events[index].events & (EPOLLHUP)) || (emulMsg_poll_events[index].events & (EPOLLERR)))
1705 DEBUG_MSG("connection is closed");
1709 else if(emulMsg_poll_events[index].events & EPOLLIN)
1711 if(emulMsg_poll_events[index].data.fd == emulMsg_file_fd)
1713 char readbuffer[READ_BUFFER_LENGTH_MAX];
1716 DEBUG_MSG("precess POLLIN ");
1718 memset(readbuffer, 0x00, sizeof(READ_BUFFER_LENGTH_MAX));
1720 readcnt = read(emulMsg_file_fd, readbuffer, READ_BUFFER_LENGTH_MAX);
1722 DEBUG_MSG("message readcnt= [%d] ", readcnt);
1723 DEBUG_MSG("message = [%s] ", readbuffer);
1726 _net_nfc_process_emulMsg((uint8_t *)readbuffer + NET_NFC_EMUL_HEADER_LENGTH, (long int)readcnt - NET_NFC_EMUL_HEADER_LENGTH);
1730 DEBUG_MSG("not expected socket connection");
1736 if(num_of_files == index)
1738 DEBUG_MSG("unknown event");
1750 close(emulMsg_file_fd);
1752 DEBUG_MSG("emul_ReaderThread END >>>>");
1757 static void emul_ReaderThread(void * pArg)
1759 DEBUG_MSG("emul_ReaderThread START >>>>");
1762 char file_name[1024] = { 0, };
1764 char readBuffer[READ_BUFFER_LENGTH_MAX];
1770 bool condition = true;
1772 /* make file name */
1773 snprintf(file_name, sizeof(file_name), "%s/%s", NET_NFC_EMUL_DATA_PATH, NET_NFC_EMUL_MESSAGE_FILE_NAME );
1774 LOGE("file path : %s", file_name);
1777 DEBUG_MSG("Start Current Time [%ld]", (unsigned long) curTime);
1779 /* polling 500 ms */
1781 while (condition != 0) {
1786 if ((fp = fopen(file_name, "r")) == NULL) {
1787 DEBUG_MSG("file open error");
1791 /* get the modified time of the file */
1792 if (stat(file_name, &st) ==0) {
1793 if ((unsigned long) st.st_mtime <= (unsigned long) curTime) {
1798 DEBUG_MSG("FILE Modified Time [%ld]", (unsigned long) st.st_mtime);
1799 /* update current time */
1801 DEBUG_MSG("Get New Current Time [%ld]", (unsigned long) curTime);
1806 DEBUG_MSG("stat error");
1812 memset(readBuffer, 0x00, READ_BUFFER_LENGTH_MAX);
1814 if (fscanf(fp, "%[^\n]", readBuffer)) {
1815 DEBUG_MSG("get DATA >>>> readBuffer [%s]", readBuffer);
1818 /* process message */
1819 _net_nfc_process_emulMsg((uint8_t *) readBuffer, (long int) strlen(readBuffer));
1824 DEBUG_MSG("LOOP END >>>>");
1828 DEBUG_MSG("emul_ReaderThread END >>>>");
1832 static bool _net_nfc_emul_controller_start_thread (void)
1838 ret = pthread_create(&gEmulThread, NULL, (emul_Nfc_thread_handler_t)emul_ReaderThread, (void*) "emul_read_thread");
1848 static void _net_nfc_emul_controller_stop_thread (void)
1852 pthread_cancel(gEmulThread);
1856 pthread_cond_signal(&cond);
1858 pthread_join(gEmulThread, NULL);
1863 static bool net_nfc_emul_controller_init (net_nfc_error_e* result)
1867 if (result == NULL) {
1873 DEBUG_MSG("start stack init ");
1875 if (g_stack_init_successful == true)
1877 DEBUG_MSG("Already statck is initialized");
1882 /* start reader thread : to get event from Inject */
1883 if (!_net_nfc_emul_controller_start_thread()) {
1884 DEBUG_ERR_MSG("Failed to create emul thread");
1888 DEBUG_MSG("Stack init finished");
1890 g_stack_init_successful = true;
1891 *result = NET_NFC_OK;
1898 static bool net_nfc_emul_controller_deinit (void)
1903 if (g_stack_init_successful == false)
1905 DEBUG_MSG("Already statck is deinitialized");
1909 _net_nfc_emul_controller_stop_thread();
1911 g_stack_init_successful = false;
1917 static bool net_nfc_emul_controller_register_listener(
1918 target_detection_listener_cb target_detection_listener,
1919 se_transaction_listener_cb se_transaction_listener,
1920 llcp_event_listener_cb llcp_event_listener,
1921 hce_apdu_listener_cb hce_apdu_listener,
1922 net_nfc_error_e* result)
1924 if (result == NULL) {
1928 *result = NET_NFC_OK;
1932 g_emul_controller_target_cb = target_detection_listener;
1933 g_emul_controller_se_cb = se_transaction_listener;
1934 g_emul_controller_llcp_cb = llcp_event_listener;
1935 g_emul_controller_hce_cb = hce_apdu_listener;
1942 static bool net_nfc_emul_controller_unregister_listener()
1946 g_emul_controller_target_cb = NULL;
1947 g_emul_controller_se_cb = NULL;
1948 g_emul_controller_llcp_cb = NULL;
1955 static bool net_nfc_emul_controller_get_firmware_version(data_s **data, net_nfc_error_e *result)
1957 if (data == NULL || result == NULL)
1962 *result = NET_NFC_OK;
1966 *data = (data_s *)calloc(1, sizeof(data_s));
1971 (*data)->length = 10;
1972 (*data)->buffer = (uint8_t *)calloc(1, (*data)->length);
1974 snprintf((char *)(*data)->buffer, (*data)->length, "%d.%d", 1, 0);
1981 static bool net_nfc_emul_controller_check_firmware_version(net_nfc_error_e* result)
1983 if (result == NULL) {
1987 *result = NET_NFC_OK;
1996 static bool net_nfc_emul_controller_update_firmware(net_nfc_error_e* result)
1998 if (result == NULL) {
2002 *result = NET_NFC_OK;
2011 static bool net_nfc_emul_controller_get_stack_information(net_nfc_stack_information_s* stack_info, net_nfc_error_e* result)
2013 if (result == NULL) {
2017 *result = NET_NFC_OK;
2026 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)
2036 *result = NET_NFC_OK;
2038 if (mode == NET_NFC_DISCOVERY_MODE_START)
2040 mode = NET_NFC_DISCOVERY_MODE_CONFIG;
2042 else if (mode == NET_NFC_DISCOVERY_MODE_STOP)
2044 mode = NET_NFC_DISCOVERY_MODE_CONFIG;
2045 config = NET_NFC_ALL_DISABLE;
2050 if ((mode == NET_NFC_DISCOVERY_MODE_CONFIG))
2052 if (config == NET_NFC_ALL_DISABLE)
2054 /* This handle is not useful anymore */
2055 __net_nfc_make_invalid_target_handle ();
2057 /* reset socket_info */
2058 for (idx = 0; idx < LLCP_NB_SOCKET_MAX; idx++)
2060 _net_nfc_remove_socket_slot((net_nfc_llcp_socket_t) idx);
2063 DEBUG_MSG("Kill Thread");
2065 ret = net_nfc_emul_controller_deinit();
2067 else if(config == NET_NFC_ALL_ENABLE)
2069 net_nfc_error_e err;
2071 DEBUG_MSG("Create Thread");
2072 ret = net_nfc_emul_controller_init(&err);
2081 static bool net_nfc_emul_controller_get_secure_element_list(net_nfc_secure_element_info_s* list, int* count, net_nfc_error_e* result)
2083 if (result == NULL) {
2087 *result = NET_NFC_OK;
2096 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)
2098 if (result == NULL) {
2102 *result = NET_NFC_OK;
2111 static bool net_nfc_emul_controller_check_target_presence(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2113 if (result == NULL) {
2117 *result = NET_NFC_OK;
2121 if (_net_nfc_emul_get_is_tag_attached()) {
2125 DEBUG_MSG("TAG Detached");
2130 static bool net_nfc_emul_controller_connect(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2132 if (result == NULL) {
2136 *result = NET_NFC_OK;
2138 if (!__net_nfc_is_valide_target_handle(handle)) {
2139 *result = NET_NFC_INVALID_HANDLE;
2150 static bool net_nfc_emul_controller_disconnect(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2152 if (result == NULL) {
2156 *result = NET_NFC_OK;
2160 if (!__net_nfc_is_valide_target_handle(handle)) {
2161 *result = NET_NFC_INVALID_HANDLE;
2165 // This handle is not useful anymore
2166 __net_nfc_make_invalid_target_handle ();
2168 /* reset socket_info */
2170 for (; idx < LLCP_NB_SOCKET_MAX; idx++)
2172 _net_nfc_remove_socket_slot((net_nfc_llcp_socket_t) idx);
2180 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)
2182 data_s rawdata = { NULL, 0 };
2184 if (result == NULL) {
2188 *result = NET_NFC_OK;
2190 if (handle == NULL || ndef_card_state == NULL || max_data_size == NULL || real_data_size == NULL || result == NULL)
2192 *result = NET_NFC_NULL_PARAMETER;
2196 if (!__net_nfc_is_valide_target_handle(handle)) {
2197 *result = NET_NFC_INVALID_HANDLE;
2203 _net_nfc_retrieve_ndef_message(&rawdata);
2205 if (_net_nfc_emul_get_is_tag_attached())
2207 *ndef_card_state = NET_NFC_NDEF_CARD_READ_WRITE;
2208 *max_data_size = BUFFER_LENGTH_MAX;
2209 *real_data_size = rawdata.length;
2210 DEBUG_MSG("Card State : [%d] MAX data size :[%d] actual data size = [%d]", *ndef_card_state, *max_data_size, *real_data_size);
2214 DEBUG_MSG("target detached");
2222 static bool net_nfc_emul_controller_make_read_only_ndef(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2224 if (result == NULL) {
2228 *result = NET_NFC_OK;
2230 if (!__net_nfc_is_valide_target_handle(handle)) {
2231 *result = NET_NFC_INVALID_HANDLE;
2242 static bool net_nfc_emul_controller_read_ndef(net_nfc_target_handle_s* handle, data_s** data, net_nfc_error_e* result)
2244 int real_data_size = 0;
2245 data_s rawdata = { NULL, 0 };
2249 if (result == NULL) {
2253 *result = NET_NFC_OK;
2255 if(handle == NULL || data == NULL || result == NULL)
2257 DEBUG_ERR_MSG("NET_NFC_NULL_PARAMETER >>>");
2258 *result = NET_NFC_NULL_PARAMETER;
2262 if (!__net_nfc_is_valide_target_handle(handle)) {
2263 DEBUG_ERR_MSG("NET_NFC_INVALID_HANDLE >>>");
2264 *result = NET_NFC_INVALID_HANDLE;
2268 if(!_net_nfc_emul_get_is_tag_attached()) {
2269 DEBUG_ERR_MSG("NET_NFC_NOT_ALLOWED_OPERATION >>>");
2270 *result = NET_NFC_NOT_ALLOWED_OPERATION;
2274 *result = _net_nfc_retrieve_ndef_message(&rawdata);
2275 if(*result != NET_NFC_OK)
2278 real_data_size = rawdata.length;
2280 if(real_data_size == 0)
2282 DEBUG_ERR_MSG("read ndef_msg is failed >>> real_data_size is zero");
2283 *result = NET_NFC_NO_NDEF_MESSAGE;
2287 *data = (data_s*) calloc(1, sizeof(data_s));
2291 *result = NET_NFC_ALLOC_FAIL;
2295 (*data)->length = real_data_size;
2296 (*data)->buffer = (uint8_t *)calloc(1, real_data_size);
2298 if((*data)->buffer == NULL)
2301 *result = NET_NFC_ALLOC_FAIL;
2305 /* copy rawdata to data->buffer */
2306 memcpy((*data)->buffer, rawdata.buffer, real_data_size);
2313 static bool net_nfc_emul_controller_write_ndef(net_nfc_target_handle_s* handle, data_s* data, net_nfc_error_e* result)
2315 if (result == NULL) {
2319 *result = NET_NFC_OK;
2321 if (!__net_nfc_is_valide_target_handle(handle)) {
2322 *result = NET_NFC_INVALID_HANDLE;
2328 DEBUG_MSG("net_nfc_emul_controller_write_ndef success >>>");
2330 _net_nfc_store_ndef_message(data);
2338 static bool net_nfc_emul_controller_transceive(net_nfc_target_handle_s *handle,
2339 net_nfc_transceive_info_s *info, data_s **data, net_nfc_error_e *result)
2343 if (result == NULL) {
2347 if (info == NULL || info->trans_data.buffer == NULL ||
2348 info->trans_data.length == 0) {
2349 *result = NET_NFC_INVALID_PARAM;
2353 *result = NET_NFC_OK;
2356 if (!__net_nfc_is_valide_target_handle(handle)) {
2357 *result = NET_NFC_INVALID_HANDLE;
2363 /* This implementation is not needed on Emulator environment */
2370 static bool net_nfc_emul_controller_format_ndef(net_nfc_target_handle_s* handle, data_s* secure_key, net_nfc_error_e* result)
2372 if (result == NULL) {
2376 *result = NET_NFC_OK;
2378 if (!__net_nfc_is_valide_target_handle(handle)) {
2379 *result = NET_NFC_INVALID_HANDLE;
2390 static bool net_nfc_emul_controller_exception_handler(void)
2394 net_nfc_error_e error;
2396 if(net_nfc_emul_controller_init(&error) == false)
2398 DEBUG_ERR_MSG("exception handler is failed!!");
2407 static bool net_nfc_emul_controller_is_ready(net_nfc_error_e* result)
2409 if (result == NULL) {
2413 *result = NET_NFC_OK;
2419 return g_stack_init_successful;
2423 /*******************
2425 ********************/
2427 static bool net_nfc_emul_controller_llcp_config (net_nfc_llcp_config_info_s * config, net_nfc_error_e * result)
2429 if (result == NULL) {
2433 *result = NET_NFC_OK;
2442 static bool net_nfc_emul_controller_llcp_check_llcp(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2444 if (result == NULL) {
2448 *result = NET_NFC_OK;
2450 if (!__net_nfc_is_valide_target_handle(handle)) {
2451 *result = NET_NFC_INVALID_HANDLE;
2462 static bool net_nfc_emul_controller_llcp_activate_llcp(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2464 if (result == NULL) {
2468 *result = NET_NFC_OK;
2470 if (!__net_nfc_is_valide_target_handle(handle)) {
2471 *result = NET_NFC_INVALID_HANDLE;
2482 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)
2484 if (result == NULL) {
2488 *result = NET_NFC_OK;
2492 /* get available socket */
2493 socket_info_s* socket_info = _net_nfc_get_available_socket_slot();
2494 if(socket_info == NULL) {
2495 DEBUG_ERR_MSG("The available socket is nothing!!");
2499 /* get llcp state */
2500 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2501 llcp_state = _net_nfc_get_llcp_state(user_param);
2502 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2503 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN!!");
2507 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2508 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_SERVER");
2510 *socket = NET_NFC_EMUL_SNEP_SERVER_SOCKET_NUMBER;
2512 else if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER_NPP) {
2513 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_SERVER_NPP");
2515 *socket = NET_NFC_EMUL_NPP_SERVER_SOCKET_NUMBER;
2517 else if (llcp_state == NET_NFC_STATE_EXCHANGER_CLIENT) {
2518 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_CLIENT");
2520 *socket = NET_NFC_EMUL_CLIENT_SOCKET_NUMBER;
2522 else if (llcp_state == NET_NFC_STATE_CONN_HANDOVER_REQUEST) {
2523 DEBUG_MSG("NET_NFC_STATE_CONN_HANDOVER_REQUEST");
2525 *socket = NET_NFC_EMUL_HANDOVER_REQUEST_SOCKET_NUMBER;
2527 else if (llcp_state == NET_NFC_STATE_CONN_HANDOVER_SELECT) {
2528 DEBUG_MSG("NET_NFC_STATE_CONN_HANDOVER_SELECT");
2530 *socket = NET_NFC_EMUL_HANDOVER_SELECT_SOCKET_NUMBER;
2533 DEBUG_MSG("we doesn't support..");
2538 DEBUG_MSG("socket is created = [0x%x]", *socket);
2540 socket_info->socket_handle = *socket;
2541 socket_info->user_context = (void *) user_param;
2548 static bool net_nfc_emul_controller_llcp_bind(net_nfc_llcp_socket_t socket, uint8_t service_access_point, net_nfc_error_e* result)
2550 if (result == NULL) {
2554 *result = NET_NFC_OK;
2563 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)
2565 if (result == NULL) {
2569 *result = NET_NFC_OK;
2571 if (!__net_nfc_is_valide_target_handle(handle)) {
2572 *result = NET_NFC_INVALID_HANDLE;
2578 /* Emul don't create real socket. So, we don't need to wait accept from remote socket */
2579 /* In here, send accept event for only snep */
2580 net_nfc_request_listen_socket_t *detail = NULL;
2582 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2583 if (socket_info == NULL) {
2584 DEBUG_ERR_MSG ("socket_info is NULL");
2588 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2589 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2590 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2591 DEBUG_ERR_MSG ("llcp_state is NET_NFC_STATE_UNKNOWN");
2595 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2596 _nfc_emul_util_alloc_mem(detail, sizeof(*detail));
2600 detail->length = sizeof(*detail);
2601 detail->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_LISTEN;
2603 socket_info->user_context = user_param;
2605 detail->handle = handle;
2606 detail->client_socket = NET_NFC_EMUL_INCOMING_SOCKET_NUMBER;
2607 detail->trans_param = socket_info->user_context;
2608 detail->result = NET_NFC_OK;
2610 DEBUG_MSG("accept callback is called");
2611 g_emul_controller_llcp_cb(detail, socket_info->user_context);
2615 DEBUG_MSG("llcp_state is [%d]", llcp_state);
2623 /* below accept function does not used. */
2624 static bool net_nfc_emul_controller_llcp_accept(net_nfc_llcp_socket_t socket, net_nfc_error_e* result, void *user_param)
2626 if (result == NULL) {
2630 *result = NET_NFC_OK;
2639 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)
2641 if (result == NULL) {
2645 *result = NET_NFC_OK;
2647 if (!__net_nfc_is_valide_target_handle(handle)) {
2648 *result = NET_NFC_INVALID_HANDLE;
2654 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2655 if (socket_info == NULL) {
2656 DEBUG_ERR_MSG ("socket_info is NULL");
2660 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2661 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2662 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2663 DEBUG_ERR_MSG ("llcp_state is NET_NFC_STATE_UNKNOWN");
2672 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)
2674 if (result == NULL) {
2678 *result = NET_NFC_OK;
2680 if (!__net_nfc_is_valide_target_handle(handle)) {
2681 *result = NET_NFC_INVALID_HANDLE;
2687 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2688 if (socket_info == NULL) {
2689 DEBUG_ERR_MSG ("socket_info is NULL");
2693 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2694 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2695 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2696 DEBUG_ERR_MSG ("llcp_state is NET_NFC_STATE_UNKNOWN");
2705 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)
2707 if (result == NULL) {
2711 *result = NET_NFC_OK;
2713 if (!__net_nfc_is_valide_target_handle(handle)) {
2714 *result = NET_NFC_INVALID_HANDLE;
2720 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2721 if (socket_info == NULL) {
2722 DEBUG_ERR_MSG ("socket_info is NULL");
2726 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2727 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2728 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2729 DEBUG_ERR_MSG ("llcp_state is NET_NFC_STATE_UNKNOWN");
2733 if(llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2734 net_nfc_request_llcp_msg_t *req_msg = NULL;
2736 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
2738 socket_info->user_context = user_param;
2740 if (req_msg != NULL){
2741 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
2742 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_SEND;
2743 req_msg->result = NET_NFC_OK;
2745 DEBUG_MSG("send callback is called");
2746 g_emul_controller_llcp_cb(req_msg, socket_info->user_context);
2755 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)
2757 if (result == NULL) {
2761 *result = NET_NFC_OK;
2763 if (!__net_nfc_is_valide_target_handle(handle)) {
2764 *result = NET_NFC_INVALID_HANDLE;
2770 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2771 if (socket_info == NULL) {
2772 DEBUG_ERR_MSG ("socket_info is NULL");
2776 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2777 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2778 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2779 DEBUG_ERR_MSG ("llcp_state is NET_NFC_STATE_UNKNOWN");
2783 if(llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2784 net_nfc_request_llcp_msg_t *req_msg = NULL;
2786 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
2788 socket_info->user_context = user_param;
2790 if (req_msg != NULL){
2791 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
2792 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_SEND_TO;
2793 req_msg->result = NET_NFC_OK;
2795 DEBUG_MSG("send_to callback is called");
2796 g_emul_controller_llcp_cb(req_msg, socket_info->user_context);
2806 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)
2808 if (result == NULL || data == NULL) {
2812 *result = NET_NFC_OK;
2814 if (!__net_nfc_is_valide_target_handle(handle)) {
2815 *result = NET_NFC_INVALID_HANDLE;
2821 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2822 if (socket_info == NULL) {
2823 DEBUG_ERR_MSG ("socket_info is NULL");
2827 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2828 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2829 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2830 DEBUG_ERR_MSG ("llcp_state is NET_NFC_STATE_UNKNOWN");
2834 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2836 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_SERVER");
2837 socket_info->user_context = user_param;
2839 if(Snep_Server_msg->isSegment) {
2840 /* send snep msg continueosly ..*/
2841 DEBUG_MSG("send segments for snep msg");
2843 int remained_size = 0;
2845 remained_size = Snep_Server_msg->data->length - Snep_Server_msg->offset;
2846 DEBUG_MSG("remained_size[%d]", remained_size);
2848 /* copy rawdata to llcp_server_data->buffer */
2849 if (remained_size <= SNEP_MAX_BUFFER) {
2850 DEBUG_MSG("send last segment >>>");
2852 llcp_server_data->length = remained_size;
2853 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer+Snep_Server_msg->offset , remained_size);
2855 Snep_Server_msg->isSegment = false;
2858 DEBUG_MSG("send continue segment >>>");
2860 llcp_server_data->length = SNEP_MAX_BUFFER;
2861 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer+Snep_Server_msg->offset, SNEP_MAX_BUFFER);
2863 Snep_Server_msg->offset += SNEP_MAX_BUFFER;
2866 _net_nfc_llcp_data_receive_cb(socket_info->user_context); /* call callback */
2869 /* In here, we dosen't call _net_nfc_llcp_data_receive_cb. just wait event from emulator */
2870 /*After copying data address, we will return it, immediately */
2871 DEBUG_MSG("data address is set");
2872 llcp_server_data = data;
2876 DEBUG_MSG("we don't support..");
2884 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)
2886 if (result == NULL) {
2890 *result = NET_NFC_OK;
2892 if (!__net_nfc_is_valide_target_handle(handle)) {
2893 *result = NET_NFC_INVALID_HANDLE;
2899 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2900 if (socket_info == NULL) {
2901 DEBUG_ERR_MSG ("socket_info is NULL");
2905 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2906 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2907 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2908 DEBUG_ERR_MSG ("llcp_state is NET_NFC_STATE_UNKNOWN");
2912 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2914 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_SERVER");
2915 socket_info->user_context = user_param;
2917 if(Snep_Server_msg->isSegment) {
2918 /* send snep msg continueosly ..*/
2919 DEBUG_MSG("send segments for snep msg");
2921 int remained_size = 0;
2923 remained_size = Snep_Server_msg->data->length - Snep_Server_msg->offset;
2924 DEBUG_MSG("remained_size[%d]", remained_size);
2926 /* copy rawdata to llcp_server_data->buffer */
2927 if (remained_size <= SNEP_MAX_BUFFER) {
2928 DEBUG_MSG("send last segment >>>");
2930 llcp_server_data->length = remained_size;
2931 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer+Snep_Server_msg->offset , remained_size);
2933 Snep_Server_msg->isSegment = false;
2936 DEBUG_MSG("send continue segment >>>");
2938 llcp_server_data->length = SNEP_MAX_BUFFER;
2939 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer+Snep_Server_msg->offset, SNEP_MAX_BUFFER);
2941 Snep_Server_msg->offset += SNEP_MAX_BUFFER;
2944 _net_nfc_llcp_data_receive_from_cb(socket_info->user_context); /* call callback */
2947 /* In here, we dosen't call _net_nfc_llcp_data_receive_cb. just wait event from emulator */
2948 /*After copying data address, we will return it, immediately */
2950 DEBUG_MSG("data address is set");
2951 llcp_server_data = data;
2954 DEBUG_ERR_MSG("data address is NULL");
2960 DEBUG_MSG("we donen't support..");
2968 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)
2970 if (result == NULL) {
2974 *result = NET_NFC_OK;
2976 if (!__net_nfc_is_valide_target_handle(handle)) {
2977 *result = NET_NFC_INVALID_HANDLE;
2983 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2984 if (socket_info == NULL) {
2985 DEBUG_ERR_MSG ("socket_info is NULL");
2989 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2990 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2991 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2992 DEBUG_ERR_MSG ("llcp_state is NET_NFC_STATE_UNKNOWN");
2996 /* send msg to framework */
2997 net_nfc_request_llcp_msg_t *req_msg = NULL;
2999 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
3001 socket_info->user_context = user_param;
3003 if (req_msg != NULL){
3004 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
3005 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_DISCONNECT;
3006 req_msg->result = NET_NFC_OK;
3008 DEBUG_MSG("disconnect callback is called");
3009 g_emul_controller_llcp_cb(req_msg, user_param);
3012 /* reset socket_info */
3013 _net_nfc_remove_socket_slot((net_nfc_llcp_socket_t) socket);
3020 static bool net_nfc_emul_controller_llcp_socket_close(net_nfc_llcp_socket_t socket, net_nfc_error_e* result)
3022 if (result == NULL) {
3026 *result = NET_NFC_OK;
3035 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)
3037 if (result == NULL) {
3041 *result = NET_NFC_OK;
3043 if (!__net_nfc_is_valide_target_handle(handle)) {
3044 *result = NET_NFC_INVALID_HANDLE;
3055 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)
3057 if (result == NULL) {
3061 *result = NET_NFC_OK;
3063 if (!__net_nfc_is_valide_target_handle(handle)) {
3064 *result = NET_NFC_INVALID_HANDLE;
3075 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)
3077 /* In llcp specification ver 1.1, default miu size is 128 */
3078 const uint16_t default_miu = 128;
3080 if (result == NULL) {
3084 *result = NET_NFC_OK;
3086 if (!__net_nfc_is_valide_target_handle(handle)) {
3087 *result = NET_NFC_INVALID_HANDLE;
3093 option->miu = default_miu;
3101 static bool net_nfc_emul_controller_support_nfc(net_nfc_error_e *result)
3104 struct stat st = { 0, };
3106 if (stat("/dev/nfc0", &st) == -1)
3109 *result = NET_NFC_NOT_SUPPORTED;
3114 *result = NET_NFC_OK;
3120 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)
3122 DEBUG_ERR_MSG("se open start");
3123 *result = NET_NFC_OK;
3124 __net_nfc_make_valid_target_handle(handle);
3126 DEBUG_ERR_MSG("se_open end");
3129 static bool net_nfc_emul_controller_secure_element_get_atr(net_nfc_target_handle_s *handle,
3130 data_s **atr, net_nfc_error_e *result)
3134 int length = sizeof(buffer);
3137 DEBUG_ERR_MSG("se get_atr start");
3138 *result = NET_NFC_OK;
3141 strncpy(buffer, "getatr", sizeof(buffer));
3143 temp = (data_s *)calloc(1, sizeof(*temp));
3145 temp->buffer = (uint8_t *)calloc(1, length);
3146 if (temp->buffer != NULL) {
3147 memcpy(temp->buffer, buffer, length);
3148 temp->length = length;
3150 *result = NET_NFC_OK;
3153 *result = NET_NFC_ALLOC_FAIL;
3157 *result = NET_NFC_ALLOC_FAIL;
3160 DEBUG_ERR_MSG("se get atr end");
3163 static bool net_nfc_emul_controller_secure_element_send_apdu(net_nfc_target_handle_s *handle,
3164 data_s *command, data_s **response, net_nfc_error_e *result)
3171 DEBUG_ERR_MSG("se send apdu start");
3173 *result = NET_NFC_OK;
3177 strncpy(buffer, "response", sizeof(buffer));
3179 length = strlen(buffer);
3181 temp = (data_s *)calloc(1, sizeof(*temp));
3183 temp->buffer = (uint8_t *)calloc(1, length);
3184 if (temp->buffer != NULL) {
3185 memcpy(temp->buffer, buffer, length);
3186 temp->length = length;
3189 *result = NET_NFC_OK;
3192 *result = NET_NFC_ALLOC_FAIL;
3196 *result = NET_NFC_ALLOC_FAIL;
3200 DEBUG_ERR_MSG("se send apdu end");
3203 static bool net_nfc_emul_controller_secure_element_close(net_nfc_target_handle_s *handle,
3204 net_nfc_error_e *result)
3206 DEBUG_ERR_MSG("se close start");
3207 *result = NET_NFC_OK;
3209 DEBUG_ERR_MSG("se close end");
3212 ////////////// INTERFACE END //////////