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;
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 if(target_detected->devType == NET_NFC_NFCIP1_TARGET ){
1353 DEBUG_MSG("set llcp connection type. remote device is target");
1354 handle->connection_type = NET_NFC_P2P_CONNECTION_TARGET;
1355 _net_nfc_emul_set_is_p2p_attached(true);
1357 else if ( target_detected->devType == NET_NFC_NFCIP1_INITIATOR){
1358 DEBUG_MSG("set llcp connection type. remote device is initiator");
1359 handle->connection_type = NET_NFC_P2P_CONNECTION_INITIATOR;
1360 _net_nfc_emul_set_is_p2p_attached(true);
1364 DEBUG_MSG("set tag connection");
1365 handle->connection_type = NET_NFC_TAG_CONNECTION;
1366 _net_nfc_emul_set_is_tag_attached(true);
1369 target_detected->number_of_keys = 7;
1370 target_detected->target_info_values.length = sizeof(device_info);
1371 memcpy(&target_detected->target_info_values.buffer, device_info, target_detected->target_info_values.length);
1373 /* call target_cb */
1374 if(g_emul_controller_target_cb != NULL) {
1375 DEBUG_MSG("discovered callback is called");
1376 g_emul_controller_target_cb(target_detected, NULL);
1381 static void _net_nfc_tag_detached_cb(void)
1385 _net_nfc_emul_set_is_tag_attached(false);
1390 static void _net_nfc_target_detached_cb(void)
1394 _net_nfc_emul_set_is_p2p_attached(false);
1396 /* For P2P, we send msg to manager */
1397 net_nfc_request_llcp_msg_t *req_msg = NULL;
1399 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
1401 if (req_msg != NULL) {
1402 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
1403 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_DEACTIVATED;
1405 DEBUG_MSG("deactivated callback is called");
1406 g_emul_controller_llcp_cb(req_msg, NULL);
1410 static void _net_nfc_llcp_data_receive_cb(void* pContext)
1414 net_nfc_request_llcp_msg_t *req_msg = NULL;
1416 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
1418 if (req_msg != NULL) {
1419 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
1420 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_RECEIVE;
1421 req_msg->result = NET_NFC_OK;
1423 DEBUG_MSG("receive callback is called >>");
1424 g_emul_controller_llcp_cb(req_msg, pContext);
1430 static void _net_nfc_llcp_data_receive_from_cb(void* pContext)
1434 net_nfc_request_llcp_msg_t *req_msg = NULL;
1436 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
1438 if (req_msg != NULL){
1439 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
1440 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_RECEIVE_FROM;
1441 req_msg->result = NET_NFC_OK;
1443 DEBUG_MSG("receive_from callback is called >>");
1444 g_emul_controller_llcp_cb(req_msg, pContext);
1450 static void _net_nfc_llcp_create_snep_server_msg(snep_command_field_e resp_field)
1454 uint8_t* temp = Snep_Server_msg->data->buffer;
1455 uint8_t response = (uint8_t)resp_field;
1456 uint8_t version = 0;
1457 uint32_t length_field = 0;
1458 data_s rawdata = { NULL, 0 };
1460 version = SNEP_MAJOR_VER;
1461 version = (((version << 4) & 0xf0) | (SNEP_MINOR_VER & 0x0f));
1463 _net_nfc_retrieve_ndef_message(&rawdata);
1465 /* version response length payload*/
1466 Snep_Server_msg->data->length = sizeof(uint8_t) + sizeof(uint8_t) + sizeof(uint32_t) + rawdata.length;
1476 length_field = htonl(rawdata.length);
1478 /* length will be se 0. so we don't need to copy value */
1479 memcpy(temp, &length_field, sizeof(uint32_t));
1480 temp += sizeof(uint32_t);
1482 /* copy ndef information to response msg */
1483 if(rawdata.length > 0)
1484 memcpy(temp, rawdata.buffer, rawdata.length);
1489 static llcp_state_e _net_nfc_get_llcp_state(void* pContext)
1494 state = NET_NFC_STATE_EXCHANGER_SERVER;
1501 static bool _net_nfc_make_llcp_data(emulMsg_s *emul_msg)
1504 data_s rawdata = { NULL, 0 };
1506 _net_nfc_retrieve_ndef_message(&rawdata);
1508 if (emul_msg->record_count == 0 || rawdata.length == 0)
1510 DEBUG_ERR_MSG("data is zero >>>");
1514 /* For SNEP, we should create snep msg, and then copy it to llcp_server_data */
1515 _net_nfc_llcp_create_snep_server_msg(SNEP_REQ_PUT);
1517 /* copy rawdata to llcp_server_data->buffer */
1518 if (Snep_Server_msg->data->length <= SNEP_MAX_BUFFER) {
1519 DEBUG_MSG("The snep msg size is small than SNEP_MAX_BUFFER >>>");
1521 if (llcp_server_data == NULL)
1524 llcp_server_data->length = Snep_Server_msg->data->length;
1525 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer, Snep_Server_msg->data->length);
1528 DEBUG_MSG("send first segment >>>");
1530 if (llcp_server_data == NULL) {
1534 llcp_server_data->length = SNEP_MAX_BUFFER;
1535 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer, SNEP_MAX_BUFFER);
1537 Snep_Server_msg->isSegment = true;
1538 Snep_Server_msg->offset = SNEP_MAX_BUFFER;
1546 static void _net_nfc_send_emulMsg_to_nfc_manager(emulMsg_s *emul_msg)
1550 switch (emul_msg->message_id) {
1551 case EMUL_NFC_TAG_DISCOVERED :{
1552 _net_nfc_target_discovered_cb(emul_msg);
1556 case EMUL_NFC_TAG_DETACHED :{
1557 _net_nfc_tag_detached_cb();
1561 case EMUL_NFC_P2P_DISCOVERED : {
1562 _net_nfc_initialize_llcp();
1563 _net_nfc_target_discovered_cb(emul_msg);
1567 case EMUL_NFC_P2P_SEND : {
1568 if(!_net_nfc_emul_get_is_p2p_attached())
1570 DEBUG_ERR_MSG("target is not attached!!");
1574 if(_net_nfc_make_llcp_data(emul_msg)) {
1576 /* find snep server*/
1577 socket_info_s *socket_info = _net_nfc_find_server_socket(NET_NFC_EMUL_SNEP_SERVER_SOCKET_NUMBER);
1578 if (socket_info == NULL) {
1579 DEBUG_ERR_MSG ("socket_info is NULL");
1583 _net_nfc_llcp_data_receive_cb(socket_info->user_context); /* call callback */
1586 DEBUG_ERR_MSG("make_p2p_data is fail!!");
1592 case EMUL_NFC_P2P_DETACHED : {
1593 if(!_net_nfc_emul_get_is_p2p_attached())
1595 DEBUG_ERR_MSG("target is not attached!!");
1599 _net_nfc_target_detached_cb();
1600 _net_nfc_deinitialize_llcp();
1605 DEBUG_ERR_MSG("message_id is wrong!!");
1612 static void _net_nfc_process_emulMsg(uint8_t * data, long int size)
1616 emulMsg_s *emul_msg = NULL;
1618 /* create emul_msg */
1619 _net_nfc_create_emulMsg(&emul_msg, data, size);
1621 DEBUG_MSG("emul_msg->message_id >>>>[%d]", emul_msg->message_id);
1623 /* processing emul_msg */
1624 _net_nfc_send_emulMsg_to_nfc_manager(emul_msg);
1626 /* destroy emul_msg */
1627 _net_nfc_destroy_emulMsg(emul_msg);
1632 #ifdef __USE_EPOLL_FOR_FILE__
1633 static void emul_ReaderThread(void * pArg)
1635 DEBUG_MSG("emul_ReaderThread START >>>>");
1637 char file_name[1024] = { 0, };
1638 bool condition = true;
1640 int emulMsg_file_fd = -1;
1641 int emulMsg_poll_fd = -1;
1642 struct epoll_event *emulMsg_poll_events = NULL;
1644 /* make file name */
1645 snprintf(file_name, sizeof(file_name), "%s/%s", NET_NFC_EMUL_DATA_PATH, NET_NFC_EMUL_MESSAGE_FILE_NAME );
1646 LOGE("file path : %s", file_name);
1648 /* open file for poll */
1649 emulMsg_file_fd = open(file_name, O_RDONLY|O_NONBLOCK);
1650 if (emulMsg_file_fd < 0) {
1651 DEBUG_MSG("file open error !!!!");
1656 if((emulMsg_poll_fd = epoll_create1(EPOLL_CLOEXEC)) == -1)
1658 DEBUG_MSG("epoll_create1 is occured");
1659 close(emulMsg_file_fd);
1663 if((emulMsg_poll_events = (struct epoll_event *)calloc(1, sizeof(struct epoll_event) * EPOLL_SIZE)) == NULL)
1665 DEBUG_MSG("calloc is occured");
1666 close(emulMsg_file_fd);
1671 struct epoll_event ev;
1673 ev.events = EPOLLIN | EPOLLET | EPOLLHUP | EPOLLERR;
1674 ev.data.fd = emulMsg_file_fd;
1676 /* add file fd to epoll */
1677 epoll_ctl(emulMsg_poll_fd, EPOLL_CTL_ADD, emulMsg_file_fd, &ev);
1679 while (condition == true) {
1681 int num_of_files = 0;
1684 /* to do : I will add mutex in the future */
1687 DEBUG_MSG("epoll wait >>>>");
1689 if(emulMsg_poll_fd == -1 || emulMsg_file_fd == -1)
1691 DEBUG_MSG("client is deinitialized. ");
1695 while((num_of_files = epoll_wait(emulMsg_poll_fd, emulMsg_poll_events, EPOLL_SIZE, -1)) == 0){
1696 if(emulMsg_poll_fd == -1){
1697 DEBUG_MSG("client ipc thread is terminated");
1701 DEBUG_MSG("no data is changed ");
1706 for(index = 0; index < num_of_files; index++)
1708 if( (emulMsg_poll_events[index].events & (EPOLLHUP)) || (emulMsg_poll_events[index].events & (EPOLLERR)))
1710 DEBUG_MSG("connection is closed");
1714 else if(emulMsg_poll_events[index].events & EPOLLIN)
1716 if(emulMsg_poll_events[index].data.fd == emulMsg_file_fd)
1718 char readbuffer[READ_BUFFER_LENGTH_MAX];
1721 DEBUG_MSG("precess POLLIN ");
1723 memset(readbuffer, 0x00, sizeof(READ_BUFFER_LENGTH_MAX));
1725 readcnt = read(emulMsg_file_fd, readbuffer, READ_BUFFER_LENGTH_MAX);
1727 DEBUG_MSG("message readcnt= [%d] ", readcnt);
1728 DEBUG_MSG("message = [%s] ", readbuffer);
1731 _net_nfc_process_emulMsg((uint8_t *)readbuffer + NET_NFC_EMUL_HEADER_LENGTH, (long int)readcnt - NET_NFC_EMUL_HEADER_LENGTH);
1735 DEBUG_MSG("not expected socket connection");
1741 if(num_of_files == index)
1743 DEBUG_MSG("unknown event");
1755 close(emulMsg_file_fd);
1757 DEBUG_MSG("emul_ReaderThread END >>>>");
1762 static void emul_ReaderThread(void * pArg)
1764 DEBUG_MSG("emul_ReaderThread START >>>>");
1767 char file_name[1024] = { 0, };
1769 char readBuffer[READ_BUFFER_LENGTH_MAX];
1775 bool condition = true;
1777 /* make file name */
1778 snprintf(file_name, sizeof(file_name), "%s/%s", NET_NFC_EMUL_DATA_PATH, NET_NFC_EMUL_MESSAGE_FILE_NAME );
1779 LOGE("file path : %s", file_name);
1782 DEBUG_MSG("Start Current Time [%ld]", (unsigned long) curTime);
1784 /* polling 500 ms */
1786 while (condition != 0) {
1791 if ((fp = fopen(file_name, "r")) == NULL) {
1792 DEBUG_MSG("file open error");
1796 /* get the modified time of the file */
1797 if (stat(file_name, &st) ==0) {
1798 if ((unsigned long) st.st_mtime <= (unsigned long) curTime) {
1803 DEBUG_MSG("FILE Modified Time [%ld]", (unsigned long) st.st_mtime);
1804 /* update current time */
1806 DEBUG_MSG("Get New Current Time [%ld]", (unsigned long) curTime);
1811 DEBUG_MSG("stat error");
1817 memset(readBuffer, 0x00, READ_BUFFER_LENGTH_MAX);
1819 if (fscanf(fp, "%[^\n]", readBuffer)) {
1820 DEBUG_MSG("get DATA >>>> readBuffer [%s]", readBuffer);
1823 /* process message */
1824 _net_nfc_process_emulMsg((uint8_t *) readBuffer, (long int) strlen(readBuffer));
1829 DEBUG_MSG("LOOP END >>>>");
1833 DEBUG_MSG("emul_ReaderThread END >>>>");
1837 static bool _net_nfc_emul_controller_start_thread (void)
1843 ret = pthread_create(&gEmulThread, NULL, (emul_Nfc_thread_handler_t)emul_ReaderThread, (void*) "emul_read_thread");
1853 static void _net_nfc_emul_controller_stop_thread (void)
1857 pthread_cancel(gEmulThread);
1861 pthread_cond_signal(&cond);
1863 pthread_join(gEmulThread, NULL);
1868 static bool net_nfc_emul_controller_init (net_nfc_error_e* result)
1872 if (result == NULL) {
1878 DEBUG_MSG("start stack init ");
1880 if (g_stack_init_successful == true)
1882 DEBUG_MSG("Already statck is initialized");
1887 /* start reader thread : to get event from Inject */
1888 if (!_net_nfc_emul_controller_start_thread()) {
1889 DEBUG_ERR_MSG("Failed to create emul thread");
1893 DEBUG_MSG("Stack init finished");
1895 g_stack_init_successful = true;
1896 *result = NET_NFC_OK;
1903 static bool net_nfc_emul_controller_deinit (void)
1908 if (g_stack_init_successful == false)
1910 DEBUG_MSG("Already statck is deinitialized");
1914 _net_nfc_emul_controller_stop_thread();
1916 g_stack_init_successful = false;
1922 static bool net_nfc_emul_controller_register_listener(
1923 target_detection_listener_cb target_detection_listener,
1924 se_transaction_listener_cb se_transaction_listener,
1925 llcp_event_listener_cb llcp_event_listener,
1926 hce_apdu_listener_cb hce_apdu_listener,
1927 net_nfc_error_e* result)
1929 if (result == NULL) {
1933 *result = NET_NFC_OK;
1937 g_emul_controller_target_cb = target_detection_listener;
1938 g_emul_controller_se_cb = se_transaction_listener;
1939 g_emul_controller_llcp_cb = llcp_event_listener;
1940 g_emul_controller_hce_cb = hce_apdu_listener;
1947 static bool net_nfc_emul_controller_unregister_listener()
1951 g_emul_controller_target_cb = NULL;
1952 g_emul_controller_se_cb = NULL;
1953 g_emul_controller_llcp_cb = NULL;
1960 static bool net_nfc_emul_controller_get_firmware_version(data_s **data, net_nfc_error_e *result)
1962 if (data == NULL || result == NULL)
1967 *result = NET_NFC_OK;
1971 *data = (data_s *)calloc(1, sizeof(data_s));
1976 (*data)->length = 10;
1977 (*data)->buffer = (uint8_t *)calloc(1, (*data)->length);
1979 snprintf((char *)(*data)->buffer, (*data)->length, "%d.%d", 1, 0);
1986 static bool net_nfc_emul_controller_check_firmware_version(net_nfc_error_e* result)
1988 if (result == NULL) {
1992 *result = NET_NFC_OK;
2001 static bool net_nfc_emul_controller_update_firmware(net_nfc_error_e* result)
2003 if (result == NULL) {
2007 *result = NET_NFC_OK;
2016 static bool net_nfc_emul_controller_get_stack_information(net_nfc_stack_information_s* stack_info, net_nfc_error_e* result)
2018 if (result == NULL) {
2022 *result = NET_NFC_OK;
2031 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)
2041 *result = NET_NFC_OK;
2043 if (mode == NET_NFC_DISCOVERY_MODE_START)
2045 mode = NET_NFC_DISCOVERY_MODE_CONFIG;
2047 else if (mode == NET_NFC_DISCOVERY_MODE_STOP)
2049 mode = NET_NFC_DISCOVERY_MODE_CONFIG;
2050 config = NET_NFC_ALL_DISABLE;
2055 if ((mode == NET_NFC_DISCOVERY_MODE_CONFIG))
2057 if (config == NET_NFC_ALL_DISABLE)
2059 /* This handle is not useful anymore */
2060 __net_nfc_make_invalid_target_handle ();
2062 /* reset socket_info */
2063 for (idx = 0; idx < LLCP_NB_SOCKET_MAX; idx++)
2065 _net_nfc_remove_socket_slot((net_nfc_llcp_socket_t) idx);
2068 DEBUG_MSG("Kill Thread");
2070 ret = net_nfc_emul_controller_deinit();
2072 else if(config == NET_NFC_ALL_ENABLE)
2074 net_nfc_error_e err;
2076 DEBUG_MSG("Create Thread");
2077 ret = net_nfc_emul_controller_init(&err);
2086 static bool net_nfc_emul_controller_get_secure_element_list(net_nfc_secure_element_info_s* list, int* count, net_nfc_error_e* result)
2088 if (result == NULL) {
2092 *result = NET_NFC_OK;
2101 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)
2103 if (result == NULL) {
2107 *result = NET_NFC_OK;
2116 static bool net_nfc_emul_controller_check_target_presence(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2118 if (result == NULL) {
2122 *result = NET_NFC_OK;
2126 if (_net_nfc_emul_get_is_tag_attached()) {
2130 DEBUG_MSG("TAG Detached");
2135 static bool net_nfc_emul_controller_connect(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2137 if (result == NULL) {
2141 *result = NET_NFC_OK;
2143 if (!__net_nfc_is_valide_target_handle(handle)) {
2144 *result = NET_NFC_INVALID_HANDLE;
2155 static bool net_nfc_emul_controller_disconnect(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2157 if (result == NULL) {
2161 *result = NET_NFC_OK;
2165 if (!__net_nfc_is_valide_target_handle(handle)) {
2166 *result = NET_NFC_INVALID_HANDLE;
2170 // This handle is not useful anymore
2171 __net_nfc_make_invalid_target_handle ();
2173 /* reset socket_info */
2175 for (; idx < LLCP_NB_SOCKET_MAX; idx++)
2177 _net_nfc_remove_socket_slot((net_nfc_llcp_socket_t) idx);
2185 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)
2187 data_s rawdata = { NULL, 0 };
2189 if (result == NULL) {
2193 *result = NET_NFC_OK;
2195 if (handle == NULL || ndef_card_state == NULL || max_data_size == NULL || real_data_size == NULL || result == NULL)
2197 *result = NET_NFC_NULL_PARAMETER;
2201 if (!__net_nfc_is_valide_target_handle(handle)) {
2202 *result = NET_NFC_INVALID_HANDLE;
2208 _net_nfc_retrieve_ndef_message(&rawdata);
2210 if (_net_nfc_emul_get_is_tag_attached())
2212 *ndef_card_state = NET_NFC_NDEF_CARD_READ_WRITE;
2213 *max_data_size = BUFFER_LENGTH_MAX;
2214 *real_data_size = rawdata.length;
2215 DEBUG_MSG("Card State : [%d] MAX data size :[%d] actual data size = [%d]", *ndef_card_state, *max_data_size, *real_data_size);
2219 DEBUG_MSG("target detached");
2227 static bool net_nfc_emul_controller_make_read_only_ndef(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2229 if (result == NULL) {
2233 *result = NET_NFC_OK;
2235 if (!__net_nfc_is_valide_target_handle(handle)) {
2236 *result = NET_NFC_INVALID_HANDLE;
2247 static bool net_nfc_emul_controller_read_ndef(net_nfc_target_handle_s* handle, data_s** data, net_nfc_error_e* result)
2249 int real_data_size = 0;
2250 data_s rawdata = { NULL, 0 };
2254 if (result == NULL) {
2258 *result = NET_NFC_OK;
2260 if(handle == NULL || data == NULL || result == NULL)
2262 DEBUG_ERR_MSG("NET_NFC_NULL_PARAMETER >>>");
2263 *result = NET_NFC_NULL_PARAMETER;
2267 if (!__net_nfc_is_valide_target_handle(handle)) {
2268 DEBUG_ERR_MSG("NET_NFC_INVALID_HANDLE >>>");
2269 *result = NET_NFC_INVALID_HANDLE;
2273 if(!_net_nfc_emul_get_is_tag_attached()) {
2274 DEBUG_ERR_MSG("NET_NFC_NOT_ALLOWED_OPERATION >>>");
2275 *result = NET_NFC_NOT_ALLOWED_OPERATION;
2279 *result = _net_nfc_retrieve_ndef_message(&rawdata);
2280 if(*result != NET_NFC_OK)
2283 real_data_size = rawdata.length;
2285 if(real_data_size == 0)
2287 DEBUG_ERR_MSG("read ndef_msg is failed >>> real_data_size is zero");
2288 *result = NET_NFC_NO_NDEF_MESSAGE;
2292 *data = (data_s*) calloc(1, sizeof(data_s));
2296 *result = NET_NFC_ALLOC_FAIL;
2300 (*data)->length = real_data_size;
2301 (*data)->buffer = (uint8_t *)calloc(1, real_data_size);
2303 if((*data)->buffer == NULL)
2306 *result = NET_NFC_ALLOC_FAIL;
2310 /* copy rawdata to data->buffer */
2311 memcpy((*data)->buffer, rawdata.buffer, real_data_size);
2318 static bool net_nfc_emul_controller_write_ndef(net_nfc_target_handle_s* handle, data_s* data, net_nfc_error_e* result)
2320 if (result == NULL) {
2324 *result = NET_NFC_OK;
2326 if (!__net_nfc_is_valide_target_handle(handle)) {
2327 *result = NET_NFC_INVALID_HANDLE;
2333 DEBUG_MSG("net_nfc_emul_controller_write_ndef success >>>");
2335 _net_nfc_store_ndef_message(data);
2343 static bool net_nfc_emul_controller_transceive(net_nfc_target_handle_s *handle,
2344 net_nfc_transceive_info_s *info, data_s **data, net_nfc_error_e *result)
2348 if (result == NULL) {
2352 if (info == NULL || info->trans_data.buffer == NULL ||
2353 info->trans_data.length == 0) {
2354 *result = NET_NFC_INVALID_PARAM;
2358 *result = NET_NFC_OK;
2361 if (!__net_nfc_is_valide_target_handle(handle)) {
2362 *result = NET_NFC_INVALID_HANDLE;
2368 /* This implementation is not needed on Emulator environment */
2375 static bool net_nfc_emul_controller_format_ndef(net_nfc_target_handle_s* handle, data_s* secure_key, net_nfc_error_e* result)
2377 if (result == NULL) {
2381 *result = NET_NFC_OK;
2383 if (!__net_nfc_is_valide_target_handle(handle)) {
2384 *result = NET_NFC_INVALID_HANDLE;
2395 static bool net_nfc_emul_controller_exception_handler(void)
2399 net_nfc_error_e error;
2401 if(net_nfc_emul_controller_init(&error) == false)
2403 DEBUG_ERR_MSG("exception handler is failed!!");
2412 static bool net_nfc_emul_controller_is_ready(net_nfc_error_e* result)
2414 if (result == NULL) {
2418 *result = NET_NFC_OK;
2424 return g_stack_init_successful;
2428 /*******************
2430 ********************/
2432 static bool net_nfc_emul_controller_llcp_config (net_nfc_llcp_config_info_s * config, net_nfc_error_e * result)
2434 if (result == NULL) {
2438 *result = NET_NFC_OK;
2447 static bool net_nfc_emul_controller_llcp_check_llcp(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2449 if (result == NULL) {
2453 *result = NET_NFC_OK;
2455 if (!__net_nfc_is_valide_target_handle(handle)) {
2456 *result = NET_NFC_INVALID_HANDLE;
2467 static bool net_nfc_emul_controller_llcp_activate_llcp(net_nfc_target_handle_s* handle, net_nfc_error_e* result)
2469 if (result == NULL) {
2473 *result = NET_NFC_OK;
2475 if (!__net_nfc_is_valide_target_handle(handle)) {
2476 *result = NET_NFC_INVALID_HANDLE;
2487 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)
2489 if (result == NULL) {
2493 *result = NET_NFC_OK;
2497 /* get available socket */
2498 socket_info_s* socket_info = _net_nfc_get_available_socket_slot();
2499 if(socket_info == NULL) {
2500 DEBUG_ERR_MSG("The available socket is nothing!!");
2504 /* get llcp state */
2505 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2506 llcp_state = _net_nfc_get_llcp_state(user_param);
2507 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2508 DEBUG_ERR_MSG("llcp_state is NET_NFC_STATE_UNKNOWN!!");
2512 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2513 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_SERVER");
2515 *socket = NET_NFC_EMUL_SNEP_SERVER_SOCKET_NUMBER;
2517 else if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER_NPP) {
2518 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_SERVER_NPP");
2520 *socket = NET_NFC_EMUL_NPP_SERVER_SOCKET_NUMBER;
2522 else if (llcp_state == NET_NFC_STATE_EXCHANGER_CLIENT) {
2523 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_CLIENT");
2525 *socket = NET_NFC_EMUL_CLIENT_SOCKET_NUMBER;
2527 else if (llcp_state == NET_NFC_STATE_CONN_HANDOVER_REQUEST) {
2528 DEBUG_MSG("NET_NFC_STATE_CONN_HANDOVER_REQUEST");
2530 *socket = NET_NFC_EMUL_HANDOVER_REQUEST_SOCKET_NUMBER;
2532 else if (llcp_state == NET_NFC_STATE_CONN_HANDOVER_SELECT) {
2533 DEBUG_MSG("NET_NFC_STATE_CONN_HANDOVER_SELECT");
2535 *socket = NET_NFC_EMUL_HANDOVER_SELECT_SOCKET_NUMBER;
2538 DEBUG_MSG("we doesn't support..");
2543 DEBUG_MSG("socket is created = [0x%x]", *socket);
2545 socket_info->socket_handle = *socket;
2546 socket_info->user_context = (void *) user_param;
2553 static bool net_nfc_emul_controller_llcp_bind(net_nfc_llcp_socket_t socket, uint8_t service_access_point, net_nfc_error_e* result)
2555 if (result == NULL) {
2559 *result = NET_NFC_OK;
2568 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)
2570 if (result == NULL) {
2574 *result = NET_NFC_OK;
2576 if (!__net_nfc_is_valide_target_handle(handle)) {
2577 *result = NET_NFC_INVALID_HANDLE;
2583 /* Emul don't create real socket. So, we don't need to wait accept from remote socket */
2584 /* In here, send accept event for only snep */
2585 net_nfc_request_listen_socket_t *detail = NULL;
2587 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2588 if (socket_info == NULL) {
2589 DEBUG_ERR_MSG ("socket_info is NULL");
2593 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2594 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2595 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2596 DEBUG_ERR_MSG ("llcp_state is NET_NFC_STATE_UNKNOWN");
2600 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2601 _nfc_emul_util_alloc_mem(detail, sizeof(*detail));
2605 detail->length = sizeof(*detail);
2606 detail->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_LISTEN;
2608 socket_info->user_context = user_param;
2610 detail->handle = handle;
2611 detail->client_socket = NET_NFC_EMUL_INCOMING_SOCKET_NUMBER;
2612 detail->trans_param = socket_info->user_context;
2613 detail->result = NET_NFC_OK;
2615 DEBUG_MSG("accept callback is called");
2616 g_emul_controller_llcp_cb(detail, socket_info->user_context);
2620 DEBUG_MSG("llcp_state is [%d]", llcp_state);
2628 /* below accept function does not used. */
2629 static bool net_nfc_emul_controller_llcp_accept(net_nfc_llcp_socket_t socket, net_nfc_error_e* result, void *user_param)
2631 if (result == NULL) {
2635 *result = NET_NFC_OK;
2644 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)
2646 if (result == NULL) {
2650 *result = NET_NFC_OK;
2652 if (!__net_nfc_is_valide_target_handle(handle)) {
2653 *result = NET_NFC_INVALID_HANDLE;
2659 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2660 if (socket_info == NULL) {
2661 DEBUG_ERR_MSG ("socket_info is NULL");
2665 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2666 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2667 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2668 DEBUG_ERR_MSG ("llcp_state is NET_NFC_STATE_UNKNOWN");
2677 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)
2679 if (result == NULL) {
2683 *result = NET_NFC_OK;
2685 if (!__net_nfc_is_valide_target_handle(handle)) {
2686 *result = NET_NFC_INVALID_HANDLE;
2692 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2693 if (socket_info == NULL) {
2694 DEBUG_ERR_MSG ("socket_info is NULL");
2698 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2699 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2700 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2701 DEBUG_ERR_MSG ("llcp_state is NET_NFC_STATE_UNKNOWN");
2710 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)
2712 if (result == NULL) {
2716 *result = NET_NFC_OK;
2718 if (!__net_nfc_is_valide_target_handle(handle)) {
2719 *result = NET_NFC_INVALID_HANDLE;
2725 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2726 if (socket_info == NULL) {
2727 DEBUG_ERR_MSG ("socket_info is NULL");
2731 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2732 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2733 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2734 DEBUG_ERR_MSG ("llcp_state is NET_NFC_STATE_UNKNOWN");
2738 if(llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2739 net_nfc_request_llcp_msg_t *req_msg = NULL;
2741 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
2743 socket_info->user_context = user_param;
2745 if (req_msg != NULL){
2746 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
2747 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_SEND;
2748 req_msg->result = NET_NFC_OK;
2750 DEBUG_MSG("send callback is called");
2751 g_emul_controller_llcp_cb(req_msg, socket_info->user_context);
2760 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)
2762 if (result == NULL) {
2766 *result = NET_NFC_OK;
2768 if (!__net_nfc_is_valide_target_handle(handle)) {
2769 *result = NET_NFC_INVALID_HANDLE;
2775 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2776 if (socket_info == NULL) {
2777 DEBUG_ERR_MSG ("socket_info is NULL");
2781 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2782 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2783 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2784 DEBUG_ERR_MSG ("llcp_state is NET_NFC_STATE_UNKNOWN");
2788 if(llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2789 net_nfc_request_llcp_msg_t *req_msg = NULL;
2791 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
2793 socket_info->user_context = user_param;
2795 if (req_msg != NULL){
2796 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
2797 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_SEND_TO;
2798 req_msg->result = NET_NFC_OK;
2800 DEBUG_MSG("send_to callback is called");
2801 g_emul_controller_llcp_cb(req_msg, socket_info->user_context);
2811 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)
2813 if (result == NULL || data == NULL) {
2817 *result = NET_NFC_OK;
2819 if (!__net_nfc_is_valide_target_handle(handle)) {
2820 *result = NET_NFC_INVALID_HANDLE;
2826 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2827 if (socket_info == NULL) {
2828 DEBUG_ERR_MSG ("socket_info is NULL");
2832 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2833 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2834 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2835 DEBUG_ERR_MSG ("llcp_state is NET_NFC_STATE_UNKNOWN");
2839 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2841 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_SERVER");
2842 socket_info->user_context = user_param;
2844 if(Snep_Server_msg->isSegment) {
2845 /* send snep msg continueosly ..*/
2846 DEBUG_MSG("send segments for snep msg");
2848 int remained_size = 0;
2850 remained_size = Snep_Server_msg->data->length - Snep_Server_msg->offset;
2851 DEBUG_MSG("remained_size[%d]", remained_size);
2853 /* copy rawdata to llcp_server_data->buffer */
2854 if (remained_size <= SNEP_MAX_BUFFER) {
2855 DEBUG_MSG("send last segment >>>");
2857 llcp_server_data->length = remained_size;
2858 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer+Snep_Server_msg->offset , remained_size);
2860 Snep_Server_msg->isSegment = false;
2863 DEBUG_MSG("send continue segment >>>");
2865 llcp_server_data->length = SNEP_MAX_BUFFER;
2866 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer+Snep_Server_msg->offset, SNEP_MAX_BUFFER);
2868 Snep_Server_msg->offset += SNEP_MAX_BUFFER;
2871 _net_nfc_llcp_data_receive_cb(socket_info->user_context); /* call callback */
2874 /* In here, we dosen't call _net_nfc_llcp_data_receive_cb. just wait event from emulator */
2875 /*After copying data address, we will return it, immediately */
2877 DEBUG_MSG("data address is set");
2878 llcp_server_data = data;
2881 DEBUG_ERR_MSG("data address is NULL");
2887 DEBUG_MSG("we don't support..");
2895 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)
2897 if (result == NULL) {
2901 *result = NET_NFC_OK;
2903 if (!__net_nfc_is_valide_target_handle(handle)) {
2904 *result = NET_NFC_INVALID_HANDLE;
2910 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2911 if (socket_info == NULL) {
2912 DEBUG_ERR_MSG ("socket_info is NULL");
2916 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
2917 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
2918 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
2919 DEBUG_ERR_MSG ("llcp_state is NET_NFC_STATE_UNKNOWN");
2923 if (llcp_state == NET_NFC_STATE_EXCHANGER_SERVER) {
2925 DEBUG_MSG("NET_NFC_STATE_EXCHANGER_SERVER");
2926 socket_info->user_context = user_param;
2928 if(Snep_Server_msg->isSegment) {
2929 /* send snep msg continueosly ..*/
2930 DEBUG_MSG("send segments for snep msg");
2932 int remained_size = 0;
2934 remained_size = Snep_Server_msg->data->length - Snep_Server_msg->offset;
2935 DEBUG_MSG("remained_size[%d]", remained_size);
2937 /* copy rawdata to llcp_server_data->buffer */
2938 if (remained_size <= SNEP_MAX_BUFFER) {
2939 DEBUG_MSG("send last segment >>>");
2941 llcp_server_data->length = remained_size;
2942 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer+Snep_Server_msg->offset , remained_size);
2944 Snep_Server_msg->isSegment = false;
2947 DEBUG_MSG("send continue segment >>>");
2949 llcp_server_data->length = SNEP_MAX_BUFFER;
2950 memcpy(llcp_server_data->buffer, Snep_Server_msg->data->buffer+Snep_Server_msg->offset, SNEP_MAX_BUFFER);
2952 Snep_Server_msg->offset += SNEP_MAX_BUFFER;
2955 _net_nfc_llcp_data_receive_from_cb(socket_info->user_context); /* call callback */
2958 /* In here, we dosen't call _net_nfc_llcp_data_receive_cb. just wait event from emulator */
2959 /*After copying data address, we will return it, immediately */
2961 DEBUG_MSG("data address is set");
2962 llcp_server_data = data;
2965 DEBUG_ERR_MSG("data address is NULL");
2971 DEBUG_MSG("we donen't support..");
2979 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)
2981 if (result == NULL) {
2985 *result = NET_NFC_OK;
2987 if (!__net_nfc_is_valide_target_handle(handle)) {
2988 *result = NET_NFC_INVALID_HANDLE;
2994 socket_info_s *socket_info = _net_nfc_find_server_socket(socket);
2995 if (socket_info == NULL) {
2996 DEBUG_ERR_MSG ("socket_info is NULL");
3000 llcp_state_e llcp_state = NET_NFC_STATE_UNKNOWN;
3001 llcp_state = _net_nfc_get_llcp_state(socket_info->user_context);
3002 if (llcp_state == NET_NFC_STATE_UNKNOWN) {
3003 DEBUG_ERR_MSG ("llcp_state is NET_NFC_STATE_UNKNOWN");
3007 /* send msg to framework */
3008 net_nfc_request_llcp_msg_t *req_msg = NULL;
3010 _nfc_emul_util_alloc_mem(req_msg, sizeof(net_nfc_request_llcp_msg_t));
3012 socket_info->user_context = user_param;
3014 if (req_msg != NULL){
3015 req_msg->length = sizeof(net_nfc_request_llcp_msg_t);
3016 req_msg->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_DISCONNECT;
3017 req_msg->result = NET_NFC_OK;
3019 DEBUG_MSG("disconnect callback is called");
3020 g_emul_controller_llcp_cb(req_msg, user_param);
3023 /* reset socket_info */
3024 _net_nfc_remove_socket_slot((net_nfc_llcp_socket_t) socket);
3031 static bool net_nfc_emul_controller_llcp_socket_close(net_nfc_llcp_socket_t socket, net_nfc_error_e* result)
3033 if (result == NULL) {
3037 *result = NET_NFC_OK;
3046 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)
3048 if (result == NULL) {
3052 *result = NET_NFC_OK;
3054 if (!__net_nfc_is_valide_target_handle(handle)) {
3055 *result = NET_NFC_INVALID_HANDLE;
3066 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)
3068 if (result == NULL) {
3072 *result = NET_NFC_OK;
3074 if (!__net_nfc_is_valide_target_handle(handle)) {
3075 *result = NET_NFC_INVALID_HANDLE;
3086 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)
3088 /* In llcp specification ver 1.1, default miu size is 128 */
3089 const uint16_t default_miu = 128;
3091 if (result == NULL) {
3095 *result = NET_NFC_OK;
3097 if (!__net_nfc_is_valide_target_handle(handle)) {
3098 *result = NET_NFC_INVALID_HANDLE;
3104 option->miu = default_miu;
3112 static bool net_nfc_emul_controller_support_nfc(net_nfc_error_e *result)
3115 struct stat st = { 0, };
3117 if (stat("/dev/nfc0", &st) == -1)
3120 *result = NET_NFC_NOT_SUPPORTED;
3125 *result = NET_NFC_OK;
3131 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)
3133 DEBUG_ERR_MSG("se open start");
3134 *result = NET_NFC_OK;
3135 __net_nfc_make_valid_target_handle(handle);
3137 DEBUG_ERR_MSG("se_open end");
3140 static bool net_nfc_emul_controller_secure_element_get_atr(net_nfc_target_handle_s *handle,
3141 data_s **atr, net_nfc_error_e *result)
3145 int length = sizeof(buffer);
3148 DEBUG_ERR_MSG("se get_atr start");
3149 *result = NET_NFC_OK;
3152 strncpy(buffer, "getatr", sizeof(buffer));
3154 temp = (data_s *)calloc(1, sizeof(*temp));
3156 temp->buffer = (uint8_t *)calloc(1, length);
3157 if (temp->buffer != NULL) {
3158 memcpy(temp->buffer, buffer, length);
3159 temp->length = length;
3161 *result = NET_NFC_OK;
3164 *result = NET_NFC_ALLOC_FAIL;
3168 *result = NET_NFC_ALLOC_FAIL;
3171 DEBUG_ERR_MSG("se get atr end");
3174 static bool net_nfc_emul_controller_secure_element_send_apdu(net_nfc_target_handle_s *handle,
3175 data_s *command, data_s **response, net_nfc_error_e *result)
3182 DEBUG_ERR_MSG("se send apdu start");
3184 *result = NET_NFC_OK;
3188 strncpy(buffer, "response", sizeof(buffer));
3190 length = strlen(buffer);
3192 temp = (data_s *)calloc(1, sizeof(*temp));
3194 temp->buffer = (uint8_t *)calloc(1, length);
3195 if (temp->buffer != NULL) {
3196 memcpy(temp->buffer, buffer, length);
3197 temp->length = length;
3200 *result = NET_NFC_OK;
3203 *result = NET_NFC_ALLOC_FAIL;
3207 *result = NET_NFC_ALLOC_FAIL;
3211 DEBUG_ERR_MSG("se send apdu end");
3214 static bool net_nfc_emul_controller_secure_element_close(net_nfc_target_handle_s *handle,
3215 net_nfc_error_e *result)
3217 DEBUG_ERR_MSG("se close start");
3218 *result = NET_NFC_OK;
3220 DEBUG_ERR_MSG("se close end");
3223 ////////////// INTERFACE END //////////