2 * Copyright (c) 2012, Intel Corportation
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.
22 #include <sys/types.h>
28 #include <sys/socket.h>
29 #include <linux/socket.h>
31 #include "net_nfc_oem_controller.h"
32 #include "net_nfc_typedef.h"
33 #include "net_nfc_util_private.h"
34 #include "net_nfc_util_ndef_message.h"
35 #include "net_nfc_util_ndef_record.h"
40 #ifndef NET_NFC_EXPORT_API
41 #define NET_NFC_EXPORT_API __attribute__((visibility("default")))
49 /* TODO get real data */
50 #define NET_NFC_JEWEL_PICC_MAX_SIZE 116
51 #define NET_NFC_MIFARE_ULTRA_PICC_MAX_SIZE 48
52 #define NET_NFC_FELICA_PICC_MAX_SIZE 256
53 #define NET_NFC_MIFARE_DESFIRE_PICC_MAX_SIZE 2048
55 /*************************** INTERFACE CALLBACKS *****************************/
56 static target_detection_listener_cb interface_target_detection_cb;
57 static se_transaction_listener_cb interface_se_transaction_cb;
58 static llcp_event_listener_cb interface_llcp_event_cb;
60 /*************************** INTERFACE START *********************************/
61 static bool neard_plugin_init(net_nfc_error_e* result);
62 static bool neard_plugin_deinit(void);
63 static bool neard_plugin_register_listener(
64 target_detection_listener_cb target_detection_listener,
65 se_transaction_listener_cb se_transaction_listener,
66 llcp_event_listener_cb llcp_event_listener,
67 net_nfc_error_e* result);
68 static bool neard_plugin_unregister_listener();
69 static bool neard_plugin_check_firmware_version(net_nfc_error_e* result);
70 static bool neard_plugin_update_firmware(net_nfc_error_e* result);
71 static bool neard_plugin_get_stack_information(
72 net_nfc_stack_information_s* stack_info,
73 net_nfc_error_e* result);
74 static bool neard_plugin_configure_discovery(
75 net_nfc_discovery_mode_e mode,
76 net_nfc_event_filter_e config,
77 net_nfc_error_e* result);
78 static bool neard_plugin_get_secure_element_list(
79 net_nfc_secure_element_info_s* list,
80 int* count, net_nfc_error_e* result);
81 static bool neard_plugin_set_secure_element_mode(
82 net_nfc_secure_element_type_e element_type,
83 net_nfc_secure_element_mode_e mode,
84 net_nfc_error_e* result);
85 static bool neard_plugin_connect(net_nfc_target_handle_s* handle,
86 net_nfc_error_e* result);
87 static bool neard_plugin_disconnect(net_nfc_target_handle_s* handle,
88 net_nfc_error_e* result);
89 static bool neard_plugin_check_ndef(net_nfc_target_handle_s* handle,
90 uint8_t *ndef_card_state,
93 net_nfc_error_e* result);
94 static bool neard_plugin_check_target_presence(net_nfc_target_handle_s* handle,
95 net_nfc_error_e* result);
96 static bool neard_plugin_read_ndef(net_nfc_target_handle_s* handle,
98 net_nfc_error_e* result);
99 static bool neard_plugin_write_ndef(net_nfc_target_handle_s* handle,
100 data_s* data, net_nfc_error_e* result);
101 static bool neard_plugin_make_read_only_ndef(net_nfc_target_handle_s* handle,
102 net_nfc_error_e* result);
103 static bool neard_plugin_transceive(net_nfc_target_handle_s* handle,
104 net_nfc_transceive_info_s* info,
106 net_nfc_error_e* result);
107 static bool neard_plugin_format_ndef(net_nfc_target_handle_s* handle,
109 net_nfc_error_e* result);
110 static bool neard_plugin_exception_handler(void);
111 static bool neard_plugin_is_ready(net_nfc_error_e* error);
113 static bool neard_plugin_llcp_config(net_nfc_llcp_config_info_s *config,
114 net_nfc_error_e *result);
115 static bool neard_plugin_llcp_check_llcp(net_nfc_target_handle_s *handle,
116 net_nfc_error_e *result);
117 static bool neard_plugin_llcp_activate_llcp(net_nfc_target_handle_s *handle,
118 net_nfc_error_e *result);
119 static bool neard_plugin_llcp_create_socket(net_nfc_llcp_socket_t *socket,
120 net_nfc_socket_type_e socketType,
121 uint16_t miu, uint8_t rw,
122 net_nfc_error_e* result,
124 static bool neard_plugin_llcp_bind(net_nfc_llcp_socket_t socket,
125 uint8_t service_access_point,
126 net_nfc_error_e* result);
127 static bool neard_plugin_llcp_listen(net_nfc_target_handle_s* handle,
128 uint8_t* service_access_name,
129 net_nfc_llcp_socket_t socket,
130 net_nfc_error_e* result,
132 static bool neard_plugin_llcp_accept(net_nfc_llcp_socket_t socket,
133 net_nfc_error_e* result);
134 static bool neard_plugin_llcp_connect_by_url(net_nfc_target_handle_s* handle,
135 net_nfc_llcp_socket_t socket,
136 uint8_t* service_access_name,
137 net_nfc_error_e* result,
139 static bool neard_plugin_llcp_connect(net_nfc_target_handle_s* handle,
140 net_nfc_llcp_socket_t socket,
141 uint8_t service_access_point,
142 net_nfc_error_e* result,
144 static bool neard_plugin_llcp_reject(net_nfc_target_handle_s* handle,
145 net_nfc_llcp_socket_t socket,
146 net_nfc_error_e* result);
147 static bool neard_plugin_llcp_disconnect(net_nfc_target_handle_s* handle,
148 net_nfc_llcp_socket_t socket,
149 net_nfc_error_e* result,
151 static bool neard_plugin_llcp_socket_close(net_nfc_llcp_socket_t socket,
152 net_nfc_error_e* result);
153 static bool neard_plugin_llcp_recv(net_nfc_target_handle_s* handle,
154 net_nfc_llcp_socket_t socket,
155 data_s* data, net_nfc_error_e* result,
157 static bool neard_plugin_llcp_send(net_nfc_target_handle_s* handle,
158 net_nfc_llcp_socket_t socket,
159 data_s* data, net_nfc_error_e* result,
161 static bool neard_plugin_llcp_recv_from(net_nfc_target_handle_s* handle,
162 net_nfc_llcp_socket_t socket,
164 net_nfc_error_e* result,
166 static bool neard_plugin_llcp_send_to(net_nfc_target_handle_s* handle,
167 net_nfc_llcp_socket_t socket,
169 uint8_t service_access_point,
170 net_nfc_error_e* result,
172 static bool neard_plugin_llcp_get_remote_config(
173 net_nfc_target_handle_s* handle,
174 net_nfc_llcp_config_info_s *config,
175 net_nfc_error_e* result);
176 static bool neard_plugin_llcp_get_remote_socket_info(
177 net_nfc_target_handle_s* handle,
178 net_nfc_llcp_socket_t socket,
179 net_nfc_llcp_socket_option_s * option,
180 net_nfc_error_e* result);
181 static bool neard_plugin_support_nfc(net_nfc_error_e* result);
182 static bool neard_plugin_eedata_register_set(net_nfc_error_e* result,
183 uint32_t mode, uint32_t reg_id,
186 /*************************** INTERFACE END ***********************************/
188 struct neard_plugin_p2p_data {
189 uint32_t adapter_idx;
196 net_nfc_target_handle_s* handle;
199 static char *neard_adp_path = NULL;
200 static bool neard_adp_powered = false;
201 static bool neard_adp_polling = false;
202 static char *neard_adp_mode = NULL;
203 static net_nfc_target_handle_s *current_handle = NULL;
204 static neardal_tag *tag = NULL;
205 static neardal_dev *dev = NULL;
206 static GHashTable *server_hash;
208 static void neard_plugin_debug(const char *format, ...)
209 __attribute__((format(printf, 1, 2)));
211 #define DBG(fmt, arg...) neard_plugin_debug("%d:%s() " fmt, \
212 __LINE__ ,__FUNCTION__ , ## arg);
214 /* neard plugin logging functions */
215 static void neard_plugin_log_open(const char *name)
217 openlog(name, LOG_PID | LOG_NDELAY | LOG_PERROR, LOG_DAEMON);
220 static void neard_plugin_log_close(void)
225 static void neard_plugin_debug(const char *format, ...)
229 va_start(ap, format);
230 vsyslog(LOG_DEBUG, format, ap);
234 /* Target handle related functions */
235 static bool __neard_plugin_is_valid_target_handle(
236 net_nfc_target_handle_s *handle)
238 return (current_handle == handle);
241 static void __neard_plugin_make_valid_target_handle(
242 net_nfc_target_handle_s **handle)
244 if (current_handle != NULL) {
245 *handle = current_handle;
249 *handle = g_try_malloc0(sizeof(net_nfc_target_handle_s));
251 current_handle = *handle;
254 static void __neard_plugin_make_invalid_target_handle()
257 if (current_handle != NULL) {
258 g_free(current_handle);
259 current_handle = NULL;
263 /* neard plugin helper funtions */
264 static int __neard_plugin_convert_target_type(const char *type)
270 /* TODO tag sub types */
273 return NET_NFC_UNKNOWN_TARGET;
275 if (!g_strcmp0(type, "Type 1"))
276 t_type = NET_NFC_JEWEL_PICC;
277 else if (!g_strcmp0(type, "Type 2"))
278 t_type = NET_NFC_MIFARE_ULTRA_PICC;
280 NET_NFC_MIFARE_MINI_PICC
281 NET_NFC_MIFARE_1K_PICC
282 NET_NFC_MIFARE_4K_PICC
283 NET_NFC_MIFARE_ULTRA_PICC
285 else if (!g_strcmp0(type, "Type 3"))
286 t_type = NET_NFC_FELICA_PICC;
287 else if (!g_strcmp0(type, "Type 4"))
288 t_type = NET_NFC_MIFARE_DESFIRE_PICC;
289 else if (!g_strcmp0(type, "Target"))
290 t_type = NET_NFC_NFCIP1_TARGET;
291 else if (!g_strcmp0(type, "Initiator"))
292 t_type = NET_NFC_NFCIP1_INITIATOR;
294 t_type = NET_NFC_UNKNOWN_TARGET;
299 static uint32_t __neard_plugin_get_tag_id(const char *name)
304 s = g_strsplit(name, "tag", 2);
311 static uint32_t __neard_plugin_get_dev_id(const char *name)
316 s = g_strsplit(name, "device", 2);
323 static uint32_t __neard_plugin_get_adapter_id(const char *name)
328 s = g_strsplit(name, "nfc", 2);
335 static void __neard_plugin_free_client(gpointer data, gpointer user_data)
337 int socket = GPOINTER_TO_INT(data);
343 static gboolean __neard_plugin_free_server(gpointer key, gpointer value,
346 int socket = GPOINTER_TO_INT(key);
347 struct neard_plugin_p2p_data *server = value;
352 if (server->watch > 0)
353 g_source_remove(server->watch);
357 if (server->client_list != NULL) {
358 g_list_foreach(server->client_list,
359 __neard_plugin_free_client, NULL);
360 g_list_free(server->client_list);
361 server->client_list = NULL;
369 static void __neard_plugin_free_server_hash(void)
373 g_hash_table_foreach_remove(server_hash,
374 __neard_plugin_free_server,
378 /* neardal callbaks */
379 static void __neardal_adp_added_cb(const char *adpName, void *user_data)
383 if (neard_adp_path) {
384 g_free(neard_adp_path);
385 neard_adp_path = NULL;
389 neard_adp_path = g_strdup(adpName);
392 static void __neardal_adp_removed_cb(const char *adpName, void *user_data)
396 if (neard_adp_path) {
397 g_free(neard_adp_path);
398 neard_adp_path = NULL;
402 static void __neardal_adp_prop_changed_cb(char *adpName, char *propName,
403 void *value, void *user_data)
405 DBG(" %s", propName);
407 if (!g_strcmp0(propName, "Polling")) {
408 if ((int*) value == 0) {
409 neard_adp_polling = false;
412 neard_adp_polling = true;
415 } else if (!g_strcmp0(propName, "Mode")) {
416 if (neard_adp_mode) {
417 g_free(neard_adp_mode);
418 neard_adp_mode = NULL;
421 neard_adp_mode = g_strdup((char *)value);
422 DBG(" '%s'", neard_adp_mode);
426 static void __neardal_tag_found_cb(const char *tagName, void *user_data)
430 net_nfc_target_handle_s *handle = NULL;
431 net_nfc_request_target_detected_t *tag_detected = NULL;
433 if (neardal_get_tag_properties(tagName, &tag) != NEARDAL_SUCCESS)
436 __neard_plugin_make_valid_target_handle(&handle);
440 handle->connection_id = __neard_plugin_get_tag_id(tagName);
441 handle->connection_type = NET_NFC_TAG_CONNECTION;
443 tag_detected = g_try_malloc0(sizeof(net_nfc_request_target_detected_t));
444 if (tag_detected == NULL)
447 tag_detected->length = sizeof(net_nfc_request_target_detected_t);
448 tag_detected->request_type = NET_NFC_MESSAGE_SERVICE_STANDALONE_TARGET_DETECTED;
449 tag_detected->devType = __neard_plugin_convert_target_type(tag->type);
450 tag_detected->number_of_keys = 0;
451 tag_detected->handle = handle;
452 tag_detected->target_info_values.length = 0;
454 if (interface_target_detection_cb != NULL)
455 interface_target_detection_cb(tag_detected, NULL);
460 g_free(tag_detected);
463 static void __neardal_tag_lost_cb(const char *tagName, void *userdata)
468 neardal_free_tag(tag);
472 if (neard_adp_polling == true)
475 if (neardal_start_poll_loop(neard_adp_path,
476 NEARD_ADP_MODE_DUAL) == NEARDAL_SUCCESS)
477 neard_adp_polling = true;
481 static void __neardal_record_found_cb(const char *rcdName, void *user_data)
486 static void __neardal_device_found_cb(const char *devName, void *user_data)
488 net_nfc_target_handle_s *handle = NULL;
489 net_nfc_request_target_detected_t *dev_detected = NULL;
493 if (g_hash_table_size(server_hash) > 0) {
494 __neard_plugin_free_server_hash();
497 if (neardal_get_dev_properties(devName, &dev) != NEARDAL_SUCCESS)
500 __neard_plugin_make_valid_target_handle(&handle);
504 handle->connection_id = __neard_plugin_get_dev_id(devName);
506 dev_detected = g_try_malloc0(sizeof(net_nfc_request_target_detected_t));
507 if (dev_detected == NULL)
510 dev_detected->length = sizeof(net_nfc_request_target_detected_t);
511 dev_detected->request_type = NET_NFC_MESSAGE_SERVICE_STANDALONE_TARGET_DETECTED;
512 /* Note: This one is neard role, depends upon neard role we are
513 * deciding detected device role. */
514 dev_detected->devType = __neard_plugin_convert_target_type(neard_adp_mode);
515 dev_detected->number_of_keys = 0;
516 dev_detected->target_info_values.length = 0;
518 if (dev_detected->devType == NET_NFC_NFCIP1_INITIATOR)
519 handle->connection_type = NET_NFC_P2P_CONNECTION_TARGET;
520 else if(dev_detected->devType == NET_NFC_NFCIP1_TARGET)
521 handle->connection_type = NET_NFC_P2P_CONNECTION_INITIATOR;
523 dev_detected->handle = handle;
525 if (interface_target_detection_cb != NULL)
526 interface_target_detection_cb(dev_detected, NULL);
531 g_free(dev_detected);
534 static void __neardal_device_lost_cb(const char *devName, void *user_data)
536 net_nfc_request_llcp_msg_t *message;
540 __neard_plugin_free_server_hash();
541 __neard_plugin_make_invalid_target_handle();
544 neardal_free_device(dev);
548 message = g_try_malloc0(sizeof(net_nfc_request_llcp_msg_t));
549 if (message != NULL) {
550 message->length = sizeof(net_nfc_request_llcp_msg_t);
551 message->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_DEACTIVATED;
552 interface_llcp_event_cb(message, NULL);
555 if (neard_adp_polling == true)
558 if (neardal_start_poll_loop(neard_adp_path,
559 NEARD_ADP_MODE_DUAL) == NEARDAL_SUCCESS)
560 neard_adp_polling = true;
563 static errorCode_t __neardal_init(void)
566 neardal_adapter *neard_adp = NULL;
567 char **adapters = NULL;
572 server_hash = g_hash_table_new_full(g_direct_hash,
576 /* Get neard adapters */
577 err = neardal_get_adapters(&adapters, &len);
578 if (err != NEARDAL_SUCCESS)
581 if (!(len > 0 && adapters != NULL))
584 /* Cache the current/default adapter path */
585 neard_adp_path = g_strdup(adapters[0]);
586 neardal_free_array(&adapters);
589 /* Get adapters properties */
590 err = neardal_get_adapter_properties(neard_adp_path, &neard_adp);
591 if (err != NEARDAL_SUCCESS)
594 if (neard_adp == NULL) {
595 err = NEARDAL_ERROR_DBUS;
599 neard_adp_powered = (neard_adp->powered) ? true : false;
600 neard_adp_polling = (neard_adp->polling) ? true : false;
601 neardal_free_adapter(neard_adp);
604 /* If adpater is not powered on then power it on */
605 if (neard_adp_powered == false) {
607 err = neardal_set_adapter_property(neard_adp_path,
608 NEARD_ADP_PROP_POWERED, (void*) powered);
609 if (err != NEARDAL_SUCCESS)
612 neard_adp_powered = true;
615 if (neard_adp_polling == false) {
616 err = neardal_start_poll_loop(neard_adp_path,
617 NEARD_ADP_MODE_DUAL);
618 if (err != NEARDAL_SUCCESS)
621 neard_adp_polling = true;
624 return NEARDAL_SUCCESS;
629 neardal_free_array(&adapters);
632 neardal_free_adapter(neard_adp);
637 static bool neard_plugin_init(net_nfc_error_e *result)
639 neard_plugin_log_open("neard-plugin");
643 if (neardal_set_cb_adapter_added(
644 __neardal_adp_added_cb, NULL) != NEARDAL_SUCCESS ||
645 neardal_set_cb_adapter_removed(
646 __neardal_adp_removed_cb, NULL) != NEARDAL_SUCCESS ||
647 neardal_set_cb_adapter_property_changed(
648 __neardal_adp_prop_changed_cb, NULL) != NEARDAL_SUCCESS ||
649 neardal_set_cb_tag_found(
650 __neardal_tag_found_cb, NULL) != NEARDAL_SUCCESS ||
651 neardal_set_cb_tag_lost(
652 __neardal_tag_lost_cb, NULL) != NEARDAL_SUCCESS ||
653 neardal_set_cb_record_found(
654 __neardal_record_found_cb, NULL) != NEARDAL_SUCCESS ||
655 neardal_set_cb_dev_found(
656 __neardal_device_found_cb, NULL) != NEARDAL_SUCCESS ||
657 neardal_set_cb_dev_lost(
658 __neardal_device_lost_cb, NULL) != NEARDAL_SUCCESS) {
660 *result = NET_NFC_INVALID_HANDLE;
665 if (__neardal_init() != NEARDAL_SUCCESS) {
666 *result = NET_NFC_UNKNOWN_ERROR;
671 *result = NET_NFC_OK;
676 static bool neard_plugin_deinit(void)
682 if (neard_adp_polling == true)
683 neardal_stop_poll(neard_adp_path);
685 if (neard_adp_powered == true)
686 neardal_set_adapter_property(neard_adp_path,
687 NEARD_ADP_PROP_POWERED, (void*) powered);
689 if (neard_adp_path) {
690 g_free(neard_adp_path);
691 neard_adp_path = NULL;
694 if (neard_adp_mode) {
695 g_free(neard_adp_mode);
696 neard_adp_mode = NULL;
700 neardal_free_tag(tag);
705 neardal_free_device(dev);
709 if (server_hash != NULL) {
710 __neard_plugin_free_server_hash();
711 g_hash_table_destroy(server_hash);
716 neard_plugin_log_close();
721 static bool neard_plugin_register_listener(
722 target_detection_listener_cb target_detection_listener,
723 se_transaction_listener_cb se_transaction_listener,
724 llcp_event_listener_cb llcp_event_listener,
725 net_nfc_error_e* result)
732 interface_target_detection_cb = target_detection_listener;
733 interface_se_transaction_cb = se_transaction_listener;
734 interface_llcp_event_cb = llcp_event_listener;
736 *result = NET_NFC_OK;
741 static bool neard_plugin_unregister_listener()
745 interface_target_detection_cb = NULL;
746 interface_se_transaction_cb = NULL;
747 interface_llcp_event_cb = NULL;
752 static bool neard_plugin_support_nfc(net_nfc_error_e* result)
754 char **adapters = NULL;
763 /* Get neard adapters */
764 err = neardal_get_adapters(&adapters, &len);
765 if (err != NEARDAL_SUCCESS) {
766 *result = NET_NFC_NOT_SUPPORTED;
770 if (!(len > 0 && adapters != NULL)) {
771 *result = NET_NFC_NOT_SUPPORTED;
775 neardal_free_array(&adapters);
778 *result = NET_NFC_OK;
782 static bool neard_plugin_check_firmware_version(net_nfc_error_e* result)
789 *result = NET_NFC_NOT_SUPPORTED;
794 static bool neard_plugin_update_firmware(net_nfc_error_e* result)
801 *result = NET_NFC_NOT_SUPPORTED;
806 static bool neard_plugin_get_stack_information(
807 net_nfc_stack_information_s* stack_info,
808 net_nfc_error_e* result)
815 *result = NET_NFC_NOT_SUPPORTED;
820 static bool neard_plugin_configure_discovery(
821 net_nfc_discovery_mode_e mode,
822 net_nfc_event_filter_e config,
823 net_nfc_error_e* result)
830 if (mode == NET_NFC_DISCOVERY_MODE_CONFIG &&
831 config == NET_NFC_ALL_ENABLE) {
832 *result = NET_NFC_OK;
836 *result = NET_NFC_NOT_SUPPORTED;
841 static bool neard_plugin_get_secure_element_list(
842 net_nfc_secure_element_info_s* list,
843 int* count, net_nfc_error_e* result)
850 *result = NET_NFC_NOT_SUPPORTED;
855 static bool neard_plugin_set_secure_element_mode(
856 net_nfc_secure_element_type_e element_type,
857 net_nfc_secure_element_mode_e mode,
858 net_nfc_error_e* result)
865 *result = NET_NFC_NOT_SUPPORTED;
870 static bool neard_plugin_connect(net_nfc_target_handle_s* handle,
871 net_nfc_error_e* result)
878 if (handle == NULL) {
879 *result = NET_NFC_NULL_PARAMETER;
883 if (!__neard_plugin_is_valid_target_handle(handle)) {
884 *result = NET_NFC_INVALID_HANDLE;
888 *result = NET_NFC_OK;
893 static bool neard_plugin_disconnect(net_nfc_target_handle_s* handle,
894 net_nfc_error_e* result)
901 if (handle == NULL) {
902 *result = NET_NFC_NULL_PARAMETER;
906 __neard_plugin_make_invalid_target_handle();
907 *result = NET_NFC_OK;
913 static bool neard_plugin_check_ndef(net_nfc_target_handle_s* handle,
914 uint8_t *ndef_card_state,
917 net_nfc_error_e* result)
927 if (handle == NULL || ndef_card_state == NULL ||
928 max_data_size == NULL || real_data_size == NULL) {
930 *result = NET_NFC_NULL_PARAMETER;
934 if (!__neard_plugin_is_valid_target_handle(handle)) {
935 *result = NET_NFC_INVALID_HANDLE;
940 *result = NET_NFC_UNKNOWN_ERROR;
944 if (neardal_tag_get_rawNDEF(tag->name, &ndef, &len)
945 != NEARDAL_SUCCESS) {
946 *ndef_card_state = 0;
948 *real_data_size = -1;
949 *result = NET_NFC_TAG_READ_FAILED;
953 *ndef_card_state = NET_NFC_NDEF_CARD_READ_ONLY;
955 *ndef_card_state = NET_NFC_NDEF_CARD_READ_WRITE;
957 /* TODO get real data */
958 switch (__neard_plugin_convert_target_type(tag->type)) {
959 case NET_NFC_JEWEL_PICC:
960 *max_data_size = NET_NFC_JEWEL_PICC_MAX_SIZE;
963 case NET_NFC_MIFARE_ULTRA_PICC:
964 *max_data_size = NET_NFC_MIFARE_ULTRA_PICC_MAX_SIZE;;
967 case NET_NFC_FELICA_PICC:
968 *max_data_size = NET_NFC_FELICA_PICC_MAX_SIZE;
971 case NET_NFC_MIFARE_DESFIRE_PICC:
972 *max_data_size = NET_NFC_MIFARE_DESFIRE_PICC_MAX_SIZE;
979 *real_data_size = len;
980 *result = NET_NFC_OK;
985 static bool neard_plugin_check_target_presence(net_nfc_target_handle_s* handle,
986 net_nfc_error_e* result)
993 if (handle == NULL) {
994 *result = NET_NFC_NULL_PARAMETER;
998 if (!__neard_plugin_is_valid_target_handle(handle)) {
999 *result = NET_NFC_INVALID_HANDLE;
1004 DBG(" not connected");
1005 *result = NET_NFC_NOT_CONNECTED;
1009 *result = NET_NFC_OK;
1014 static bool neard_plugin_read_ndef(net_nfc_target_handle_s* handle,
1016 net_nfc_error_e* result)
1018 char *buffer = NULL;
1026 if (handle == NULL || data == NULL) {
1027 *result = NET_NFC_NULL_PARAMETER;
1031 if (!__neard_plugin_is_valid_target_handle(handle)) {
1032 *result = NET_NFC_INVALID_HANDLE;
1036 *data = g_try_malloc0(sizeof(data_s));
1037 if (*data == NULL) {
1038 *result = NET_NFC_ALLOC_FAIL;
1042 if (neardal_tag_get_rawNDEF(tag->name, &buffer,
1043 &len) != NEARDAL_SUCCESS) {
1046 *result = NET_NFC_TAG_READ_FAILED;
1051 (*data)->length = len;
1052 (*data)->buffer = g_try_malloc0((*data)->length);
1053 if ((*data)->buffer == NULL) {
1056 *result = NET_NFC_ALLOC_FAIL;
1060 memcpy((*data)->buffer, buffer, (*data)->length);
1064 *result = NET_NFC_OK;
1069 static bool neard_plugin_write_ndef(net_nfc_target_handle_s* handle,
1070 data_s* data, net_nfc_error_e* result)
1072 neardal_record *record;
1079 if (handle == NULL || data == NULL) {
1080 *result = NET_NFC_NULL_PARAMETER;
1084 if (!__neard_plugin_is_valid_target_handle(handle)) {
1085 *result = NET_NFC_INVALID_HANDLE;
1089 if ((data->buffer == NULL && data->length != 0) ||
1090 (data->buffer != NULL && data->length == 0)) {
1091 *result = NET_NFC_NULL_PARAMETER;
1095 record = g_try_malloc0(sizeof(neardal_record));
1096 if (record == NULL) {
1097 *result = NET_NFC_ALLOC_FAIL;
1101 record->name = g_strdup(tag->records[0]);
1102 record->type = g_strdup("Raw");
1103 record->rawNDEF = g_try_malloc0(data->length);
1104 if (record->rawNDEF == NULL) {
1105 neardal_free_record(record);
1106 *result = NET_NFC_ALLOC_FAIL;
1110 memcpy(record->rawNDEF, data->buffer, data->length);
1111 record->rawNDEFSize = data->length;
1113 if (neardal_tag_write(record) != NEARDAL_SUCCESS) {
1114 neardal_free_record(record);
1115 *result = NET_NFC_TAG_WRITE_FAILED;
1119 neardal_free_record(record);
1120 *result = NET_NFC_OK;
1125 static bool neard_plugin_make_read_only_ndef(net_nfc_target_handle_s* handle,
1126 net_nfc_error_e* result)
1133 if (handle == NULL) {
1134 *result = NET_NFC_NULL_PARAMETER;
1138 if (!__neard_plugin_is_valid_target_handle(handle)) {
1139 *result = NET_NFC_INVALID_HANDLE;
1143 *result = NET_NFC_NOT_SUPPORTED;
1148 static bool neard_plugin_transceive(net_nfc_target_handle_s* handle,
1149 net_nfc_transceive_info_s* info,
1151 net_nfc_error_e* result)
1158 static bool neard_plugin_format_ndef(net_nfc_target_handle_s* handle,
1160 net_nfc_error_e* result)
1167 if (handle == NULL || secure_key == NULL) {
1168 *result = NET_NFC_NULL_PARAMETER;
1172 if (!__neard_plugin_is_valid_target_handle(handle)) {
1173 *result = NET_NFC_INVALID_HANDLE;
1177 *result = NET_NFC_NOT_SUPPORTED;
1182 static bool neard_plugin_exception_handler(void)
1189 static bool neard_plugin_is_ready(net_nfc_error_e* result)
1196 *result = NET_NFC_OK;
1202 static bool neard_plugin_llcp_config(net_nfc_llcp_config_info_s *config,
1203 net_nfc_error_e *result)
1210 if (config == NULL) {
1211 *result = NET_NFC_NULL_PARAMETER;
1215 /* TODO : have to set these config options */
1216 DBG("set llcp config params lto=%d, miu=%d, option=0x%02x, wks=0x%02x): ",
1217 config->lto, config->miu, config->option, config->wks);
1219 *result = NET_NFC_OK;
1224 static bool neard_plugin_llcp_check_llcp(net_nfc_target_handle_s *handle,
1225 net_nfc_error_e *result)
1232 if (handle == NULL) {
1233 *result = NET_NFC_NULL_PARAMETER;
1237 if (!__neard_plugin_is_valid_target_handle(handle)) {
1238 *result = NET_NFC_INVALID_HANDLE;
1242 /* TODO : how ??? (adapter->protocals == NFC_DEP)*/
1244 *result = NET_NFC_OK;
1249 static bool neard_plugin_llcp_activate_llcp(net_nfc_target_handle_s *handle,
1250 net_nfc_error_e *result)
1257 if (handle == NULL) {
1258 *result = NET_NFC_NULL_PARAMETER;
1262 if (!__neard_plugin_is_valid_target_handle(handle)) {
1263 *result = NET_NFC_INVALID_HANDLE;
1267 *result = NET_NFC_OK;
1271 static bool neard_plugin_llcp_create_socket(net_nfc_llcp_socket_t *s,
1272 net_nfc_socket_type_e socketType,
1273 uint16_t miu, uint8_t rw,
1274 net_nfc_error_e* result,
1278 struct neard_plugin_p2p_data *server;
1286 *result = NET_NFC_NULL_PARAMETER;
1290 if (socketType != NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONORIENTED) {
1291 *result = NET_NFC_NOT_SUPPORTED;
1295 fd = socket(AF_NFC, SOCK_STREAM, NFC_SOCKPROTO_LLCP);
1297 *result = NET_NFC_OPERATION_FAIL;
1301 /* TODO : set these config options for socket */
1302 // DBG(" socketType : %d, miu : %d, rw : %d", socketType, miu, rw);
1304 server = g_try_malloc0(sizeof(struct neard_plugin_p2p_data));
1305 if (server == NULL) {
1307 *result = NET_NFC_ALLOC_FAIL;
1311 g_hash_table_insert(server_hash, GINT_TO_POINTER(fd), server);
1314 *result = NET_NFC_OK;
1319 static bool neard_plugin_llcp_bind(net_nfc_llcp_socket_t socket,
1320 uint8_t service_access_point,
1321 net_nfc_error_e* result)
1323 DBG("service_access_point : %d", service_access_point);
1328 /* Note: binding requires service access name, and it is
1329 * available in listen call, so binind and listen in
1332 *result = NET_NFC_OK;
1337 static gboolean __neard_plugin_p2p_listen_cb(GIOChannel *channel,
1338 GIOCondition condition,
1341 net_nfc_request_accept_socket_t *message;
1342 struct neard_plugin_p2p_data *server = user_data;
1343 struct sockaddr_nfc_llcp client_addr;
1344 socklen_t client_addr_len;
1347 DBG("condition 0x%x", condition);
1349 message = g_try_malloc0(sizeof(net_nfc_request_accept_socket_t));
1350 if (message == NULL)
1353 if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
1354 DBG("error in listener event");
1355 message->length = sizeof(net_nfc_request_accept_socket_t);
1356 message->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_SOCKET_ERROR;
1357 message->result = NET_NFC_OPERATION_FAIL;
1359 interface_llcp_event_cb(message, server->user_param);
1364 client_addr_len = sizeof(client_addr);
1365 client_fd = accept(server->socket, (struct sockaddr *) &client_addr,
1367 if (client_fd < 0) {
1368 DBG("accept failed");
1369 message->length = sizeof(net_nfc_request_accept_socket_t);
1370 message->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_SOCKET_ACCEPTED_ERROR;
1371 message->result = NET_NFC_OPERATION_FAIL;
1373 interface_llcp_event_cb(message, server->user_param);
1378 server->client_list = g_list_append(server->client_list, &client_fd);
1380 message->length = sizeof(net_nfc_request_accept_socket_t);
1381 message->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_ACCEPT;
1382 message->handle = server->handle;
1383 message->incomming_socket = client_fd;
1384 message->trans_param = server->user_param;
1385 message->result = NET_NFC_OK;
1387 interface_llcp_event_cb(message, server->user_param);
1392 static bool neard_plugin_llcp_listen(net_nfc_target_handle_s* handle,
1393 uint8_t* service_access_name,
1394 net_nfc_llcp_socket_t socket,
1395 net_nfc_error_e* result,
1398 struct sockaddr_nfc_llcp addr;
1399 struct neard_plugin_p2p_data *server;
1400 net_nfc_request_accept_socket_t *message;
1408 if (handle == NULL || service_access_name == NULL) {
1409 *result = NET_NFC_NULL_PARAMETER;
1413 if (!__neard_plugin_is_valid_target_handle(handle)) {
1414 *result = NET_NFC_INVALID_HANDLE;
1418 DBG("service_access_name : %s, socket : %d",
1419 (char *)service_access_name, socket);
1421 memset(&addr, 0, sizeof(struct sockaddr_nfc_llcp));
1422 addr.sa_family = AF_NFC;
1423 addr.dev_idx = __neard_plugin_get_adapter_id(neard_adp_path);
1424 addr.nfc_protocol = NFC_PROTO_NFC_DEP;
1425 addr.service_name_len = strlen((char *)service_access_name);
1426 strcpy(addr.service_name, (char *)service_access_name);
1429 err = bind(socket, (struct sockaddr *) &addr,
1430 sizeof(struct sockaddr_nfc_llcp));
1432 if (errno == EADDRINUSE) {
1433 DBG("%s is already bound", addr.service_name);
1434 *result = NET_NFC_OPERATION_FAIL;
1438 DBG("%s bind failed %d", addr.service_name, err);
1440 message = g_try_malloc0(sizeof(net_nfc_request_accept_socket_t));
1441 if (message == NULL)
1444 message->length = sizeof(net_nfc_request_accept_socket_t);
1445 message->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_SOCKET_ERROR;
1446 message->result = NET_NFC_OPERATION_FAIL;
1448 interface_llcp_event_cb(message, user_param);
1451 *result = NET_NFC_OPERATION_FAIL;
1456 err = listen(socket, 10);
1458 DBG("%s listen failed %d", addr.service_name, err);
1460 message = g_try_malloc0(sizeof(net_nfc_request_accept_socket_t));
1461 if (message == NULL)
1464 message->length = sizeof(net_nfc_request_accept_socket_t);
1465 message->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_SOCKET_ERROR;
1466 message->result = NET_NFC_OPERATION_FAIL;
1468 interface_llcp_event_cb(message, user_param);
1471 *result = NET_NFC_OPERATION_FAIL;
1475 server = g_hash_table_lookup(server_hash, GINT_TO_POINTER(socket));
1476 if (server == NULL) {
1477 *result = NET_NFC_UNKNOWN_ERROR;
1481 server->adapter_idx = addr.dev_idx;
1482 server->socket = socket;
1483 server->handle = handle;
1484 server->user_param = user_param;
1486 server->channel = g_io_channel_unix_new(socket);
1487 g_io_channel_set_close_on_unref(server->channel, TRUE);
1489 server->watch = g_io_add_watch(server->channel,
1490 G_IO_IN | G_IO_HUP | G_IO_NVAL | G_IO_ERR,
1491 __neard_plugin_p2p_listen_cb,
1493 g_io_channel_unref(server->channel);
1495 *result = NET_NFC_OK;
1499 static bool neard_plugin_llcp_accept(net_nfc_llcp_socket_t socket,
1500 net_nfc_error_e* result)
1507 *result = NET_NFC_OK;
1511 static bool neard_plugin_llcp_connect_by_url(net_nfc_target_handle_s* handle,
1512 net_nfc_llcp_socket_t socket,
1513 uint8_t* service_access_name,
1514 net_nfc_error_e* result,
1518 struct sockaddr_nfc_llcp addr;
1519 net_nfc_request_llcp_msg_t *message;
1526 if (handle == NULL || service_access_name == NULL) {
1527 *result = NET_NFC_NULL_PARAMETER;
1531 if (!__neard_plugin_is_valid_target_handle(handle)) {
1532 *result = NET_NFC_INVALID_HANDLE;
1536 memset(&addr, 0, sizeof(struct sockaddr_nfc_llcp));
1537 addr.sa_family = AF_NFC;
1538 addr.dev_idx = __neard_plugin_get_adapter_id(neard_adp_path);
1539 addr.target_idx = handle->connection_id;
1540 addr.nfc_protocol = NFC_PROTO_NFC_DEP;
1541 addr.service_name_len = strlen((char *)service_access_name);
1542 strcpy(addr.service_name, (char *)service_access_name);
1544 err = connect(socket, (struct sockaddr *) &addr,
1545 sizeof(struct sockaddr_nfc_llcp));
1547 DBG("Connect failed %d", err);
1548 *result = NET_NFC_LLCP_INVALID_SOCKET;
1552 message = g_try_malloc0(sizeof(net_nfc_request_llcp_msg_t));
1553 if (message == NULL) {
1554 *result = NET_NFC_ALLOC_FAIL;
1558 message->length = sizeof(net_nfc_request_llcp_msg_t);
1559 message->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_CONNECT;
1560 message->result = NET_NFC_OK;
1562 interface_llcp_event_cb(message, user_param);
1564 *result = NET_NFC_OK;
1568 static bool neard_plugin_llcp_connect(net_nfc_target_handle_s* handle,
1569 net_nfc_llcp_socket_t socket,
1570 uint8_t service_access_point,
1571 net_nfc_error_e* result,
1579 if (handle == NULL) {
1580 *result = NET_NFC_NULL_PARAMETER;
1584 if (!__neard_plugin_is_valid_target_handle(handle)) {
1585 *result = NET_NFC_INVALID_HANDLE;
1589 *result = NET_NFC_NOT_SUPPORTED;
1593 static bool neard_plugin_llcp_reject(net_nfc_target_handle_s* handle,
1594 net_nfc_llcp_socket_t socket,
1595 net_nfc_error_e* result)
1602 if (handle == NULL) {
1603 *result = NET_NFC_NULL_PARAMETER;
1607 if (!__neard_plugin_is_valid_target_handle(handle)) {
1608 *result = NET_NFC_INVALID_HANDLE;
1612 *result = NET_NFC_NOT_SUPPORTED;
1616 static bool neard_plugin_llcp_disconnect(net_nfc_target_handle_s* handle,
1617 net_nfc_llcp_socket_t socket,
1618 net_nfc_error_e* result,
1626 if (handle == NULL) {
1627 *result = NET_NFC_NULL_PARAMETER;
1631 if (!__neard_plugin_is_valid_target_handle(handle)) {
1632 *result = NET_NFC_INVALID_HANDLE;
1636 *result = NET_NFC_NOT_SUPPORTED;
1640 static bool neard_plugin_llcp_socket_close(net_nfc_llcp_socket_t socket,
1641 net_nfc_error_e* result)
1643 struct neard_plugin_p2p_data *data;
1650 data = g_hash_table_lookup(server_hash, GINT_TO_POINTER(socket));
1652 __neard_plugin_free_server(GINT_TO_POINTER(socket),
1654 g_hash_table_remove(server_hash, GINT_TO_POINTER(socket));
1657 *result = NET_NFC_OK;
1662 static bool neard_plugin_llcp_recv(net_nfc_target_handle_s* handle,
1663 net_nfc_llcp_socket_t socket,
1664 data_s* data, net_nfc_error_e* result,
1667 net_nfc_request_llcp_msg_t *message;
1668 uint8_t buffer[128];
1676 if (handle == NULL || data == NULL) {
1677 *result = NET_NFC_NULL_PARAMETER;
1681 if (!__neard_plugin_is_valid_target_handle(handle)) {
1682 *result = NET_NFC_INVALID_HANDLE;
1686 bytes_recv = recv(socket, buffer, 128, 0);
1687 DBG("bytes read %d", bytes_recv);
1689 if (bytes_recv < 0) {
1690 DBG("Could not recv data from socket");
1692 *result = NET_NFC_LLCP_INVALID_SOCKET;
1696 if (bytes_recv == 0) {
1698 *result = NET_NFC_OK;
1702 data->length = bytes_recv;
1703 memcpy(data->buffer, buffer, data->length);
1705 message = g_try_malloc0(sizeof(net_nfc_request_llcp_msg_t));
1706 if (message == NULL) {
1707 *result = NET_NFC_ALLOC_FAIL;
1711 message->length = sizeof(net_nfc_request_llcp_msg_t);
1712 message->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_RECEIVE;
1713 message->result = NET_NFC_OK;
1715 interface_llcp_event_cb(message, user_param);
1717 *result = NET_NFC_OK;
1722 static bool neard_plugin_llcp_send(net_nfc_target_handle_s* handle,
1723 net_nfc_llcp_socket_t socket,
1724 data_s* data, net_nfc_error_e* result,
1727 net_nfc_request_llcp_msg_t *message;
1735 if (handle == NULL || data == NULL) {
1736 *result = NET_NFC_NULL_PARAMETER;
1740 if (!__neard_plugin_is_valid_target_handle(handle)) {
1741 *result = NET_NFC_INVALID_HANDLE;
1745 err = send(socket, data->buffer, data->length, 0);
1747 DBG("sending failed %d", err);
1748 *result = NET_NFC_P2P_SEND_FAIL;
1752 DBG("Sent %d bytes", data->length);
1754 message = g_try_malloc0(sizeof(net_nfc_request_llcp_msg_t));
1755 if (message == NULL) {
1756 *result = NET_NFC_ALLOC_FAIL;
1760 message->length = sizeof(net_nfc_request_llcp_msg_t);
1761 message->request_type = NET_NFC_MESSAGE_SERVICE_LLCP_SEND;
1762 message->result = NET_NFC_OK;
1764 interface_llcp_event_cb(message, user_param);
1766 *result = NET_NFC_OK;
1770 static bool neard_plugin_llcp_recv_from(net_nfc_target_handle_s* handle,
1771 net_nfc_llcp_socket_t socket,
1773 net_nfc_error_e* result,
1781 if (handle == NULL || data == NULL) {
1782 *result = NET_NFC_NULL_PARAMETER;
1786 if (!__neard_plugin_is_valid_target_handle(handle)) {
1787 *result = NET_NFC_INVALID_HANDLE;
1791 *result = NET_NFC_NOT_SUPPORTED;
1796 static bool neard_plugin_llcp_send_to(net_nfc_target_handle_s* handle,
1797 net_nfc_llcp_socket_t socket,
1799 uint8_t service_access_point,
1800 net_nfc_error_e* result,
1808 if (handle == NULL) {
1809 *result = NET_NFC_NULL_PARAMETER;
1813 if (!__neard_plugin_is_valid_target_handle(handle)) {
1814 *result = NET_NFC_INVALID_HANDLE;
1818 *result = NET_NFC_NOT_SUPPORTED;
1823 static bool neard_plugin_llcp_get_remote_config(
1824 net_nfc_target_handle_s* handle,
1825 net_nfc_llcp_config_info_s *config,
1826 net_nfc_error_e* result)
1833 if (handle == NULL) {
1834 *result = NET_NFC_NULL_PARAMETER;
1838 if (!__neard_plugin_is_valid_target_handle(handle)) {
1839 *result = NET_NFC_INVALID_HANDLE;
1843 *result = NET_NFC_NOT_SUPPORTED;
1848 static bool neard_plugin_llcp_get_remote_socket_info(
1849 net_nfc_target_handle_s* handle,
1850 net_nfc_llcp_socket_t socket,
1851 net_nfc_llcp_socket_option_s *option,
1852 net_nfc_error_e* result)
1859 if (handle == NULL || option == NULL) {
1860 *result = NET_NFC_NULL_PARAMETER;
1864 if (!__neard_plugin_is_valid_target_handle(handle)) {
1865 *result = NET_NFC_INVALID_HANDLE;
1869 /* TODO : get real values */
1872 option->type = NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONORIENTED;
1874 *result = NET_NFC_OK;
1878 static bool neard_plugin_eedata_register_set(net_nfc_error_e* result,
1879 uint32_t mode, uint32_t reg_id,
1888 *result = NET_NFC_NULL_PARAMETER;
1892 *result = NET_NFC_NOT_SUPPORTED;
1896 NET_NFC_EXPORT_API bool onload(net_nfc_oem_interface_s* iface)
1898 iface->init = neard_plugin_init;
1899 iface->deinit = neard_plugin_deinit;
1900 iface->register_listener = neard_plugin_register_listener;
1901 iface->unregister_listener = neard_plugin_unregister_listener;
1902 iface->support_nfc = neard_plugin_support_nfc;
1903 iface->check_firmware_version = neard_plugin_check_firmware_version;
1904 iface->update_firmeware = neard_plugin_update_firmware;
1905 iface->get_stack_information = neard_plugin_get_stack_information;
1906 iface->configure_discovery = neard_plugin_configure_discovery;
1907 iface->get_secure_element_list = neard_plugin_get_secure_element_list;
1908 iface->set_secure_element_mode = neard_plugin_set_secure_element_mode;
1909 iface->connect = neard_plugin_connect;
1910 iface->disconnect = neard_plugin_disconnect;
1911 iface->check_ndef = neard_plugin_check_ndef;
1912 iface->check_presence = neard_plugin_check_target_presence;
1913 iface->read_ndef = neard_plugin_read_ndef;
1914 iface->write_ndef = neard_plugin_write_ndef;
1915 iface->make_read_only_ndef = neard_plugin_make_read_only_ndef;
1916 iface->transceive = neard_plugin_transceive;
1917 iface->format_ndef = neard_plugin_format_ndef;
1918 iface->exception_handler = neard_plugin_exception_handler;
1919 iface->is_ready = neard_plugin_is_ready;
1921 iface->config_llcp = neard_plugin_llcp_config;
1922 iface->check_llcp_status = neard_plugin_llcp_check_llcp;
1923 iface->activate_llcp = neard_plugin_llcp_activate_llcp;
1924 iface->create_llcp_socket = neard_plugin_llcp_create_socket;
1925 iface->bind_llcp_socket = neard_plugin_llcp_bind;
1926 iface->listen_llcp_socket = neard_plugin_llcp_listen;
1927 iface->accept_llcp_socket = neard_plugin_llcp_accept;
1928 iface->connect_llcp_by_url = neard_plugin_llcp_connect_by_url;
1929 iface->connect_llcp = neard_plugin_llcp_connect;
1930 iface->disconnect_llcp = neard_plugin_llcp_disconnect;
1931 iface->close_llcp_socket = neard_plugin_llcp_socket_close;
1932 iface->recv_llcp = neard_plugin_llcp_recv;
1933 iface->send_llcp = neard_plugin_llcp_send;
1934 iface->recv_from_llcp = neard_plugin_llcp_recv_from;
1935 iface->send_to_llcp = neard_plugin_llcp_send_to;
1936 iface->reject_llcp = neard_plugin_llcp_reject;
1937 iface->get_remote_config = neard_plugin_llcp_get_remote_config;
1938 iface->get_remote_socket_info = neard_plugin_llcp_get_remote_socket_info;
1939 iface->eedata_register_set = neard_plugin_eedata_register_set;