#include <sys/epoll.h>
#include <vconf.h>
-#include <net_nfc_oem_controller.h>
-#include <net_nfc_typedef.h>
-#include <net_nfc_util_internal.h>
-#include <net_nfc_util_ndef_message.h>
-#include <net_nfc_util_ndef_record.h>
+#include <arpa/inet.h>
+#include <hal-nfc-interface.h>
#include "nfc_debug_private.h"
+#ifndef EXPORT
+#define EXPORT __attribute__ ((visibility("default")))
+#endif
+
+#define NET_NFC_NDEF_RECORD_MASK_MB 0x80 /**< This marks the begin of a NDEF Message. */
+#define NET_NFC_NDEF_RECORD_MASK_ME 0x40 /**< Set if the record is at the Message End. */
+#define NET_NFC_NDEF_RECORD_MASK_CF 0x20 /**< Chunk Flag: The record is a record chunk only. */
+#define NET_NFC_NDEF_RECORD_MASK_SR 0x10 /**< Short Record: Payload Length is encoded in ONE byte only. */
+#define NET_NFC_NDEF_RECORD_MASK_IL 0x08 /**< The ID Length Field is present. */
+#define NET_NFC_NDEF_RECORD_MASK_TNF 0x07 /**< Type Name Format. */
+
typedef enum {
EMUL_NFC_TAG_DISCOVERED = 100,
EMUL_NFC_TAG_DETACHED,
EMUL_NDEF_TNF_MIME_MEDIA,
EMUL_NDEF_TNF_ABSOLUTE_URI,
EMUL_NDEF_TNF_EXTERNAL,
- EMUL_NDEF_TNF_UNKNOWN
+ EMUL_NDEF_TNF_UNKNOWN,
+ EMUL_NDEF_TNF_UNCHANGED
} emul_ndef_name_format;
typedef enum {
LOGE("FILE: %s, LINE:%d, Allocation is failed", filename, line);
}
+static bool _net_nfc_util_init_data(data_s * data, uint32_t length)
+{
+ if (data == NULL || length == 0)
+ return false;
+
+ _nfc_emul_util_alloc_mem(data->buffer, length);
+ if (data->buffer == NULL)
+ return false;
+
+ data->length = length;
+
+ return true;
+}
+
+static void _net_nfc_util_clear_data(data_s * data)
+{
+ if (data == NULL)
+ return;
+
+ if (data->buffer != NULL) {
+ _nfc_emul_util_free_mem(data->buffer);
+ data->buffer = NULL;
+ }
+
+ data->length = 0;
+}
+
+static net_nfc_error_e _net_nfc_util_free_record(ndef_record_s * record)
+{
+ if (record == NULL)
+ return NET_NFC_NULL_PARAMETER;
+
+ _net_nfc_util_clear_data(&record->type_s);
+ _net_nfc_util_clear_data(&record->id_s);
+ _net_nfc_util_clear_data(&record->payload_s);
+
+ _nfc_emul_util_free_mem(record);
+
+ return NET_NFC_OK;
+}
+
+static net_nfc_error_e _net_nfc_util_free_ndef_message(ndef_message_s * msg)
+{
+ int idx = 0;
+ ndef_record_s *prev, *current;
+
+ if (msg == NULL)
+ return NET_NFC_NULL_PARAMETER;
+
+ current = msg->records;
+
+ for (idx = 0; idx < msg->recordCount; idx++) {
+ if (current == NULL)
+ break;
+
+ prev = current;
+ current = current->next;
+
+ _net_nfc_util_free_record(prev);
+ }
+
+ _nfc_emul_util_free_mem(msg);
+
+ return NET_NFC_OK;
+}
+
+static net_nfc_error_e _net_nfc_util_create_record(net_nfc_record_tnf_e recordType, data_s * typeName, data_s * id, data_s * payload, ndef_record_s ** record)
+{
+ ndef_record_s *record_temp = NULL;
+
+ if (record == NULL)
+ return NET_NFC_NULL_PARAMETER;
+
+ if (recordType < NET_NFC_RECORD_EMPTY || recordType > NET_NFC_RECORD_UNCHAGNED)
+ return NET_NFC_OUT_OF_BOUND;
+
+ /* empty_tag */
+ if (recordType == NET_NFC_RECORD_EMPTY) {
+ if ((typeName != NULL && typeName->length > 0) || (payload != NULL && payload->length > 0) || (id != NULL && id->length > 0))
+ return NET_NFC_INVALID_PARAM;
+ } else {
+ if (typeName == NULL || typeName->buffer == NULL || typeName->length == 0)
+ return NET_NFC_INVALID_PARAM;
+ }
+
+ _nfc_emul_util_alloc_mem(record_temp, sizeof(ndef_record_s));
+ if (record_temp == NULL)
+ return NET_NFC_ALLOC_FAIL;
+ // set type name and length and TNF field
+ record_temp->TNF = recordType;
+
+ if (typeName != NULL && typeName->length > 0) {
+ if (_net_nfc_util_init_data(&record_temp->type_s, typeName->length) == false) {
+ _nfc_emul_util_free_mem(record_temp);
+
+ return NET_NFC_ALLOC_FAIL;
+ }
+
+ memcpy(record_temp->type_s.buffer, typeName->buffer, record_temp->type_s.length);
+ } else {
+ record_temp->type_s.buffer = NULL;
+ record_temp->type_s.length = 0;
+ }
+
+ record_temp->SR = 1;
+
+ // set payload
+ if (payload != NULL && payload->length > 0) {
+ if (_net_nfc_util_init_data(&record_temp->payload_s, payload->length) == false) {
+ _net_nfc_util_clear_data(&record_temp->type_s);
+ _nfc_emul_util_free_mem(record_temp);
+
+ return NET_NFC_ALLOC_FAIL;
+ }
+
+ memcpy(record_temp->payload_s.buffer, payload->buffer, record_temp->payload_s.length);
+
+ if (payload->length > 255)
+ record_temp->SR = 0;
+ } else {
+ record_temp->payload_s.buffer = NULL;
+ record_temp->payload_s.length = 0;
+ }
+
+ // set id and id length and IL field
+ if (id != NULL && id->buffer != NULL && id->length > 0) {
+ if (_net_nfc_util_init_data(&record_temp->id_s, id->length) == false) {
+ _net_nfc_util_clear_data(&record_temp->payload_s);
+ _net_nfc_util_clear_data(&record_temp->type_s);
+ _nfc_emul_util_free_mem(record_temp);
+
+ return NET_NFC_ALLOC_FAIL;
+ }
+
+ memcpy(record_temp->id_s.buffer, id->buffer, record_temp->id_s.length);
+ record_temp->IL = 1;
+ } else {
+ record_temp->IL = 0;
+ record_temp->id_s.buffer = NULL;
+ record_temp->id_s.length = 0;
+ }
+
+ // this is default value
+ record_temp->MB = 1;
+ record_temp->ME = 1;
+
+ record_temp->next = NULL;
+
+ *record = record_temp;
+
+ return NET_NFC_OK;
+}
+
+static net_nfc_error_e _net_nfc_util_append_record(ndef_message_s * msg, ndef_record_s * record)
+{
+ if (msg == NULL || record == NULL)
+ return NET_NFC_NULL_PARAMETER;
+
+ if (msg->recordCount == 0) {
+ // set short message and append
+ record->MB = 1;
+ record->ME = 1;
+ record->next = NULL;
+
+ msg->records = record;
+
+ msg->recordCount++;
+
+ DEBUG_MSG("record is added to NDEF message :: count [%d]", msg->recordCount);
+ } else {
+ ndef_record_s *current = NULL;
+ ndef_record_s *prev = NULL;
+
+ // set flag :: this record is FIRST
+ current = msg->records;
+
+ if (current != NULL) {
+ // first node
+ current->MB = 1;
+ current->ME = 0;
+
+ prev = current;
+
+ // second node
+ current = current->next;
+
+ while (current != NULL) {
+ current->MB = 0;
+ current->ME = 0;
+ prev = current;
+ current = current->next;
+ }
+
+ // set flag :: this record is END
+ record->MB = 0;
+ record->ME = 1;
+
+ prev->next = record;
+ msg->recordCount++;
+ }
+ }
+
+ return NET_NFC_OK;
+}
+
+static uint32_t _net_nfc_util_get_record_length(ndef_record_s * Record)
+{
+ uint32_t RecordLength = 1;
+
+ if (Record == NULL)
+ return 0;
+
+ /* Type length is present only for following TNF
+ NET_NFC_TNF_NFCWELLKNOWN
+ NET_NFC_TNF_MEDIATYPE
+ SLP_FRINET_NFC_NDEFRECORD_TNF_ABSURI
+ SLP_FRINET_NFC_NDEFRECORD_TNF_NFCEXT
+ */
+
+ /* ++ is for the Type Length Byte */
+ RecordLength++;
+ if (Record->TNF != EMUL_NDEF_TNF_EMPTY && Record->TNF != EMUL_NDEF_TNF_UNKNOWN && Record->TNF != EMUL_NDEF_TNF_UNCHANGED)
+ RecordLength += Record->type_s.length;
+
+ /* to check if payloadlength is 8bit or 32bit */
+ if (Record->SR != 0) {
+ /* ++ is for the Payload Length Byte */
+ RecordLength++; /* for short record */
+ } else {
+ /* + NET_NFC_NDEF_NORMAL_RECORD_BYTE is for the Payload Length Byte */
+ RecordLength += 4;
+ }
+
+ /* for non empty record */
+ if (Record->TNF != EMUL_NDEF_TNF_EMPTY)
+ RecordLength += Record->payload_s.length;
+
+ /* ID and IDlength are present only if IL flag is set */
+ if (Record->IL != 0) {
+ RecordLength += Record->id_s.length;
+ /* ++ is for the ID Length Byte */
+ RecordLength++;
+ }
+
+ return RecordLength;
+}
+
+static uint32_t _net_nfc_util_get_ndef_message_length(ndef_message_s * message)
+{
+ ndef_record_s *current;
+ int total = 0;
+
+ if (message == NULL)
+ return 0;
+
+ current = message->records;
+
+ while (current != NULL) {
+ total += _net_nfc_util_get_record_length(current);
+ current = current->next;
+ }
+
+ return total;
+}
+
+static net_nfc_error_e _net_nfc_util_create_ndef_message(ndef_message_s ** ndef_message)
+{
+ if (ndef_message == NULL)
+ return NET_NFC_NULL_PARAMETER;
+
+ _nfc_emul_util_alloc_mem(*ndef_message, sizeof(ndef_message_s));
+ if (*ndef_message == NULL)
+ return NET_NFC_ALLOC_FAIL;
+
+ return NET_NFC_OK;
+}
+
+static net_nfc_error_e _net_nfc_util_convert_ndef_message_to_rawdata(ndef_message_s * ndef, data_s * rawdata)
+{
+ ndef_record_s *record = NULL;
+ uint8_t *current = NULL;
+ uint8_t ndef_header;
+
+ if (rawdata == NULL || ndef == NULL)
+ return NET_NFC_NULL_PARAMETER;
+
+ record = ndef->records;
+ current = rawdata->buffer;
+
+ while (record) {
+ ndef_header = 0x00;
+
+ if (record->MB)
+ ndef_header |= NET_NFC_NDEF_RECORD_MASK_MB;
+ if (record->ME)
+ ndef_header |= NET_NFC_NDEF_RECORD_MASK_ME;
+ if (record->CF)
+ ndef_header |= NET_NFC_NDEF_RECORD_MASK_CF;
+ if (record->SR)
+ ndef_header |= NET_NFC_NDEF_RECORD_MASK_SR;
+ if (record->IL)
+ ndef_header |= NET_NFC_NDEF_RECORD_MASK_IL;
+
+ ndef_header |= record->TNF;
+
+ *current++ = ndef_header;
+
+ /* check empty record */
+ if (record->TNF == EMUL_NDEF_TNF_EMPTY) {
+ /* set type length to zero */
+ *current++ = 0x00;
+
+ /* set payload length to zero */
+ *current++ = 0x00;
+
+ /* set ID length to zero */
+ if (record->IL)
+ *current++ = 0x00;
+
+ record = record->next;
+
+ continue;
+ }
+
+
+ /* set type length */
+ if (record->TNF == EMUL_NDEF_TNF_UNKNOWN || record->TNF == EMUL_NDEF_TNF_UNCHANGED)
+ *current++ = 0x00;
+ else
+ *current++ = record->type_s.length;
+
+ /* set payload length */
+ if (record->SR) {
+ *current++ = (uint8_t) (record->payload_s.length & 0x000000FF);
+ } else {
+ *current++ = (uint8_t) ((record->payload_s.length & 0xFF000000) >> 24);
+ *current++ = (uint8_t) ((record->payload_s.length & 0x00FF0000) >> 16);
+ *current++ = (uint8_t) ((record->payload_s.length & 0x0000FF00) >> 8);
+ *current++ = (uint8_t) (record->payload_s.length & 0x000000FF);
+ }
+
+ /* set ID length */
+ if (record->IL)
+ *current++ = record->id_s.length;
+
+ /* set type buffer */
+ if ((record->TNF != EMUL_NDEF_TNF_UNKNOWN) && (record->TNF != EMUL_NDEF_TNF_UNCHANGED)) {
+ memcpy(current, record->type_s.buffer, record->type_s.length);
+ current += record->type_s.length;
+ }
+
+ /* set ID buffer */
+ memcpy(current, record->id_s.buffer, record->id_s.length);
+ current += record->id_s.length;
+
+ /* set payload buffer */
+ memcpy(current, record->payload_s.buffer, record->payload_s.length);
+ current += record->payload_s.length;
+
+ record = record->next;
+ }
+
+ return NET_NFC_OK;
+}
+
static bool __net_nfc_is_valide_target_handle(net_nfc_target_handle_s *handle)
{
bool result = (current_working_handle == handle);
memcpy(payload_data.buffer + 1, record->payload.buffer, payload_data.length - 1);
}
- if (net_nfc_util_create_record(record->tnf, &record->typeName, &record->id, &payload_data, (ndef_record_s**)new_record) != NET_NFC_OK) {
+ if (_net_nfc_util_create_record(record->tnf, &record->typeName, &record->id, &payload_data, (ndef_record_s**)new_record) != NET_NFC_OK) {
DEBUG_ERR_MSG("net_nfc_util_create_record is failed");
return -1;
}
memcpy(payload_data.buffer + offset, record->payload.buffer, strlen(record_payload));
}
- if (net_nfc_util_create_record(record->tnf, &record->typeName, &record->id, &payload_data, (ndef_record_s**)new_record) != NET_NFC_OK) {
+ if (_net_nfc_util_create_record(record->tnf, &record->typeName, &record->id, &payload_data, (ndef_record_s**)new_record) != NET_NFC_OK) {
DEBUG_ERR_MSG("net_nfc_util_create_record is failed");
return -1;
}
}
/* create record */
- int ret = net_nfc_util_create_record(record->tnf, &record->typeName, &record->id,
+ int ret = _net_nfc_util_create_record(record->tnf, &record->typeName, &record->id,
&filePayload, (ndef_record_s **)new_record);
_nfc_emul_util_free_mem(filePayload.buffer);
if (ret != NET_NFC_OK) {
switch (record.tnf) {
case NET_NFC_RECORD_EMPTY:
- result = net_nfc_util_create_record(NET_NFC_RECORD_EMPTY, &record.typeName,
+ result = _net_nfc_util_create_record(NET_NFC_RECORD_EMPTY, &record.typeName,
&record.id, &record.payload, (ndef_record_s **)&new_record);
if (NET_NFC_OK != result) {
DEBUG_MSG("net_nfc_create_record failed[%d]", result);
}
break;
case NET_NFC_RECORD_UNKNOWN:
- result = net_nfc_util_create_record(NET_NFC_RECORD_UNKNOWN, &record.typeName,
+ result = _net_nfc_util_create_record(NET_NFC_RECORD_UNKNOWN, &record.typeName,
&record.id, &record.payload, (ndef_record_s **)&new_record);
if (NET_NFC_OK != result) {
DEBUG_MSG("net_nfc_create_record failed[%d]", result);
break;
default:
/* NET_NFC_RECORD_URI or NET_NFC_RECORD_EXTERNAL_RTD */
- result = net_nfc_util_create_record(record.tnf, &record.typeName,
+ result = _net_nfc_util_create_record(record.tnf, &record.typeName,
&record.id, &record.payload, (ndef_record_s **)&new_record);
if (NET_NFC_OK != result) {
DEBUG_MSG("net_nfc_create_record failed[%d]", result);
}
/* append record to ndef msg */
- if ((result = net_nfc_util_append_record((ndef_message_s*)*ndef_message, (ndef_record_s *)new_record)) != NET_NFC_OK) {
+ if ((result = _net_nfc_util_append_record((ndef_message_s*)*ndef_message, (ndef_record_s *)new_record)) != NET_NFC_OK) {
DEBUG_MSG("net_nfc_util_append_record failed[%d]", result);
_create_records_free(&record);
return create_record_count;
if (buffer_len == -1)
buffer_len = 16384;
- _net_nfc_util_alloc_mem(buffer, buffer_len);
+ _nfc_emul_util_alloc_mem(buffer, buffer_len);
if (buffer == NULL)
return false;
getpwnam_r("inhouse", &pwd, buffer, buffer_len, &pw_inhouse);
- _net_nfc_util_free_mem(buffer);
+ _nfc_emul_util_free_mem(buffer);
/* get group id */
buffer_len = sysconf(_SC_GETGR_R_SIZE_MAX);
if (buffer_len == -1)
buffer_len = 16384;
- _net_nfc_util_alloc_mem(buffer, buffer_len);
+ _nfc_emul_util_alloc_mem(buffer, buffer_len);
if (buffer == NULL)
return false;
getgrnam_r("inhouse", &grp, buffer, buffer_len, &gr_inhouse);
- _net_nfc_util_free_mem(buffer);
+ _nfc_emul_util_free_mem(buffer);
if ((pw_inhouse != NULL) && (gr_inhouse != NULL)) {
if (fchown(fileno(file), pw_inhouse->pw_uid, gr_inhouse->gr_gid) < 0)
DEBUG_MSG("message length = [%ld]", size);
if (size > 0) {
- if (net_nfc_util_init_data(data, size) == true) {
+ if (_net_nfc_util_init_data(data, size) == true) {
int current;
size_t offset = 0;
ndef_message_h ndef_message = NULL;
int ndef_length = 0;
- if ((result = net_nfc_util_create_ndef_message((ndef_message_s **)&ndef_message)) != NET_NFC_OK)
+ if ((result = _net_nfc_util_create_ndef_message((ndef_message_s **)&ndef_message)) != NET_NFC_OK)
DEBUG_MSG("failed to create ndef message [%d]", result);
/* create records and append it to ndef_msg*/
emul_msg->record_count = _net_nfc_create_records_from_emulMsg(emul_msg, (ndef_message_s **)&ndef_message, record_count);
/* convert ndef msg to raw data */
- ndef_length = net_nfc_util_get_ndef_message_length((ndef_message_s *)ndef_message);
+ ndef_length = _net_nfc_util_get_ndef_message_length((ndef_message_s *)ndef_message);
if (!ndef_length)
DEBUG_MSG("ndef_message size is zero!");
rawdata.length = ndef_length;
_nfc_emul_util_alloc_mem(rawdata.buffer, ndef_length);
- if ((result = net_nfc_util_convert_ndef_message_to_rawdata((ndef_message_s*)ndef_message, &rawdata)) != NET_NFC_OK)
+ if ((result = _net_nfc_util_convert_ndef_message_to_rawdata((ndef_message_s*)ndef_message, &rawdata)) != NET_NFC_OK)
DEBUG_MSG("net_nfc_util_convert_ndef_message_to_rawdata is failed![%d]", result);
_net_nfc_store_ndef_message(&rawdata);
_nfc_emul_util_free_mem(rawdata.buffer);
- net_nfc_util_free_ndef_message(ndef_message);
+ _net_nfc_util_free_ndef_message(ndef_message);
DEBUG_EMUL_END();
DEBUG_ERR_MSG("se close end");
}
-__attribute__((visibility("default"))) bool onload(net_nfc_oem_interface_s *emul_interfaces)
-{
- DEBUG_EMUL_BEGIN();
-
- emul_interfaces->init = net_nfc_emul_controller_init;
- emul_interfaces->deinit = net_nfc_emul_controller_deinit;
- emul_interfaces->register_listener = net_nfc_emul_controller_register_listener;
- emul_interfaces->unregister_listener = net_nfc_emul_controller_unregister_listener;
- emul_interfaces->get_firmware_version = net_nfc_emul_controller_get_firmware_version;
- emul_interfaces->check_firmware_version = net_nfc_emul_controller_check_firmware_version;
- emul_interfaces->update_firmeware = net_nfc_emul_controller_update_firmware;
- emul_interfaces->get_stack_information = net_nfc_emul_controller_get_stack_information;
- emul_interfaces->configure_discovery = net_nfc_emul_controller_configure_discovery;
- emul_interfaces->get_secure_element_list = net_nfc_emul_controller_get_secure_element_list;
- emul_interfaces->set_secure_element_mode = net_nfc_emul_controller_set_secure_element_mode;
- emul_interfaces->connect = net_nfc_emul_controller_connect;
- emul_interfaces->disconnect = net_nfc_emul_controller_disconnect;
- emul_interfaces->check_ndef = net_nfc_emul_controller_check_ndef;
- emul_interfaces->check_presence = net_nfc_emul_controller_check_target_presence;
- emul_interfaces->read_ndef = net_nfc_emul_controller_read_ndef;
- emul_interfaces->write_ndef = net_nfc_emul_controller_write_ndef;
- emul_interfaces->make_read_only_ndef = net_nfc_emul_controller_make_read_only_ndef;
- emul_interfaces->transceive = net_nfc_emul_controller_transceive;
- emul_interfaces->format_ndef = net_nfc_emul_controller_format_ndef;
- emul_interfaces->exception_handler = net_nfc_emul_controller_exception_handler;
- emul_interfaces->is_ready = net_nfc_emul_controller_is_ready;
-
- emul_interfaces->config_llcp = net_nfc_emul_controller_llcp_config;
- emul_interfaces->check_llcp_status = net_nfc_emul_controller_llcp_check_llcp;
- emul_interfaces->activate_llcp = net_nfc_emul_controller_llcp_activate_llcp;
- emul_interfaces->create_llcp_socket = net_nfc_emul_controller_llcp_create_socket;
- emul_interfaces->bind_llcp_socket = net_nfc_emul_controller_llcp_bind;
- emul_interfaces->listen_llcp_socket = net_nfc_emul_controller_llcp_listen;
- emul_interfaces->accept_llcp_socket = net_nfc_emul_controller_llcp_accept;
- emul_interfaces->connect_llcp_by_url = net_nfc_emul_controller_llcp_connect_by_url;
- emul_interfaces->connect_llcp = net_nfc_emul_controller_llcp_connect;
- emul_interfaces->disconnect_llcp = net_nfc_emul_controller_llcp_disconnect;
- emul_interfaces->close_llcp_socket = net_nfc_emul_controller_llcp_socket_close;
- emul_interfaces->recv_llcp = net_nfc_emul_controller_llcp_recv;
- emul_interfaces->send_llcp = net_nfc_emul_controller_llcp_send;
- emul_interfaces->recv_from_llcp = net_nfc_emul_controller_llcp_recv_from;
- emul_interfaces->send_to_llcp = net_nfc_emul_controller_llcp_send_to;
- emul_interfaces->reject_llcp = net_nfc_emul_controller_llcp_reject;
- emul_interfaces->get_remote_config = net_nfc_emul_controller_llcp_get_remote_config;
- emul_interfaces->get_remote_socket_info = net_nfc_emul_controller_llcp_get_remote_socket_info;
-
- emul_interfaces->support_nfc = net_nfc_emul_controller_support_nfc;
-
- emul_interfaces->secure_element_open = net_nfc_emul_controller_secure_element_open;
- emul_interfaces->secure_element_get_atr = net_nfc_emul_controller_secure_element_get_atr;
- emul_interfaces->secure_element_send_apdu = net_nfc_emul_controller_secure_element_send_apdu;
- emul_interfaces->secure_element_close = net_nfc_emul_controller_secure_element_close;
-
- emul_interfaces->hce_response_apdu = NULL;
- emul_interfaces->route_aid = NULL;
- emul_interfaces->unroute_aid = NULL;
- emul_interfaces->commit_routing = NULL;
- emul_interfaces->set_default_route = NULL;
- emul_interfaces->clear_aid_table = NULL;
- emul_interfaces->get_aid_tablesize = NULL;
+static int nfc_backend_init(void **data)
+{
+ hal_backend_nfc_funcs *nfc_funcs;
+
+ nfc_funcs = calloc(1, sizeof(hal_backend_nfc_funcs));
+ if (!nfc_funcs)
+ return -ENOMEM;
+
+ nfc_funcs->start = net_nfc_emul_controller_init;
+ nfc_funcs->stop = net_nfc_emul_controller_deinit;
+ nfc_funcs->register_listener = net_nfc_emul_controller_register_listener;
+ nfc_funcs->unregister_listener = net_nfc_emul_controller_unregister_listener;
+ nfc_funcs->get_firmware_version = net_nfc_emul_controller_get_firmware_version;
+ nfc_funcs->check_firmware_version = net_nfc_emul_controller_check_firmware_version;
+ nfc_funcs->update_firmware = net_nfc_emul_controller_update_firmware;
+ nfc_funcs->get_stack_information = net_nfc_emul_controller_get_stack_information;
+ nfc_funcs->configure_discovery = net_nfc_emul_controller_configure_discovery;
+ nfc_funcs->get_secure_element_list = net_nfc_emul_controller_get_secure_element_list;
+ nfc_funcs->set_secure_element_mode = net_nfc_emul_controller_set_secure_element_mode;
+ nfc_funcs->connect = net_nfc_emul_controller_connect;
+ nfc_funcs->disconnect = net_nfc_emul_controller_disconnect;
+ nfc_funcs->check_ndef = net_nfc_emul_controller_check_ndef;
+ nfc_funcs->check_target_presence = net_nfc_emul_controller_check_target_presence;
+ nfc_funcs->read_ndef = net_nfc_emul_controller_read_ndef;
+ nfc_funcs->write_ndef = net_nfc_emul_controller_write_ndef;
+ nfc_funcs->make_read_only_ndef = net_nfc_emul_controller_make_read_only_ndef;
+ nfc_funcs->transceive = net_nfc_emul_controller_transceive;
+ nfc_funcs->format_ndef = net_nfc_emul_controller_format_ndef;
+ nfc_funcs->exception_handler = net_nfc_emul_controller_exception_handler;
+ nfc_funcs->is_ready = net_nfc_emul_controller_is_ready;
+
+ nfc_funcs->llcp_config = net_nfc_emul_controller_llcp_config;
+ nfc_funcs->llcp_check_llcp = net_nfc_emul_controller_llcp_check_llcp;
+ nfc_funcs->llcp_activate_llcp = net_nfc_emul_controller_llcp_activate_llcp;
+ nfc_funcs->llcp_create_socket = net_nfc_emul_controller_llcp_create_socket;
+ nfc_funcs->llcp_bind = net_nfc_emul_controller_llcp_bind;
+ nfc_funcs->llcp_listen = net_nfc_emul_controller_llcp_listen;
+ nfc_funcs->llcp_accept = net_nfc_emul_controller_llcp_accept;
+ nfc_funcs->llcp_connect_by_url = net_nfc_emul_controller_llcp_connect_by_url;
+ nfc_funcs->llcp_connect = net_nfc_emul_controller_llcp_connect;
+ nfc_funcs->llcp_disconnect = net_nfc_emul_controller_llcp_disconnect;
+ nfc_funcs->llcp_socket_close = net_nfc_emul_controller_llcp_socket_close;
+ nfc_funcs->llcp_recv = net_nfc_emul_controller_llcp_recv;
+ nfc_funcs->llcp_send = net_nfc_emul_controller_llcp_send;
+ nfc_funcs->llcp_recv_from = net_nfc_emul_controller_llcp_recv_from;
+ nfc_funcs->llcp_send_to = net_nfc_emul_controller_llcp_send_to;
+ nfc_funcs->llcp_reject = net_nfc_emul_controller_llcp_reject;
+ nfc_funcs->llcp_get_remote_config = net_nfc_emul_controller_llcp_get_remote_config;
+ nfc_funcs->llcp_get_remote_socket_info = net_nfc_emul_controller_llcp_get_remote_socket_info;
+
+ nfc_funcs->support_nfc = net_nfc_emul_controller_support_nfc;
+
+ nfc_funcs->secure_element_open = net_nfc_emul_controller_secure_element_open;
+ nfc_funcs->secure_element_get_atr = net_nfc_emul_controller_secure_element_get_atr;
+ nfc_funcs->secure_element_send_apdu = net_nfc_emul_controller_secure_element_send_apdu;
+ nfc_funcs->secure_element_close = net_nfc_emul_controller_secure_element_close;
+
+ nfc_funcs->hce_response_apdu = NULL;
+ nfc_funcs->secure_element_route_aid = NULL;
+ nfc_funcs->secure_element_unroute_aid = NULL;
+ nfc_funcs->secure_element_commit_routing = NULL;
+ nfc_funcs->secure_element_set_default_route = NULL;
+ nfc_funcs->secure_element_clear_aid_table = NULL;
+ nfc_funcs->secure_element_get_aid_table_size = NULL;
DEBUG_EMUL_END();
- return true;
+ *data = (void *)nfc_funcs;
+
+ return 0;
}
+
+static int nfc_backend_exit(void *data)
+{
+ if (!data)
+ return -EINVAL;
+ free(data);
+
+ return 0;
+}
+
+EXPORT hal_backend hal_backend_nfc_data = {
+ .name = "nfc-backend",
+ .vendor = "Emulator",
+ .abi_version = HAL_ABI_VERSION_TIZEN_6_5,
+ .init = nfc_backend_init,
+ .exit = nfc_backend_exit,
+};
projects / platform / adaptation / emulator / nfc-plugin-emul.git / commitdiff