From 35d77b9e8c200cd2ee788df25877afab02d346a4 Mon Sep 17 00:00:00 2001 From: Jihoon Jung Date: Mon, 15 Feb 2021 17:23:36 +0900 Subject: [PATCH] NFC hal : Change for nfc backend operation - And, Remove dependency with nfc fw Change-Id: I38bdbe42a22f64c89223edc9b9aad89d59658d67 Signed-off-by: Jihoon Jung --- CMakeLists.txt | 8 +- packaging/nfc-plugin-emul.spec | 8 +- src/oem_emul.c | 563 +++++++++++++++++++++++++++++++++++------ 3 files changed, 489 insertions(+), 90 deletions(-) mode change 100644 => 100755 src/oem_emul.c diff --git a/CMakeLists.txt b/CMakeLists.txt index 7388580..871cbea 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,12 +1,12 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.6) -PROJECT(nfc-plugin C) +PROJECT(hal-backend-nfc C) INCLUDE(FindPkgConfig) SET(EXTRA_FLAGS "-Wall -Werror -fvisibility=hidden") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_FLAGS}") -pkg_check_modules(pkgs REQUIRED dlog nfc-common-lib vconf) +pkg_check_modules(pkgs REQUIRED dlog vconf hal-api-nfc hal-api-common) INCLUDE_DIRECTORIES(${pkgs_INCLUDE_DIRS}) LINK_DIRECTORIES(${pkgs_LIBRARY_DIRS}) @@ -14,5 +14,5 @@ FILE(GLOB SRCS src/*.c) ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS}) TARGET_COMPILE_OPTIONS(${PROJECT_NAME} PUBLIC ${pkgs_CFLAGS_OTHER}) TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${pkgs_LIBRARIES} pthread) -INSTALL(TARGETS ${PROJECT_NAME} DESTINATION lib/nfc) -INSTALL(FILES 98-${PROJECT_NAME}-emul.rules DESTINATION ${CMAKE_INSTALL_PREFIX}/lib/udev/rules.d/) +INSTALL(TARGETS ${PROJECT_NAME} DESTINATION ${HAL_PATH}) +INSTALL(FILES 98-nfc-plugin-emul.rules DESTINATION ${CMAKE_INSTALL_PREFIX}/lib/udev/rules.d/) diff --git a/packaging/nfc-plugin-emul.spec b/packaging/nfc-plugin-emul.spec index 2424e16..f0ca530 100644 --- a/packaging/nfc-plugin-emul.spec +++ b/packaging/nfc-plugin-emul.spec @@ -8,8 +8,9 @@ Source0: %{name}-%{version}.tar.gz Source1001: %{name}.manifest BuildRequires: cmake BuildRequires: pkgconfig(dlog) -BuildRequires: pkgconfig(nfc-common-lib) BuildRequires: pkgconfig(vconf) +BuildRequires: pkgconfig(hal-api-nfc) +BuildRequires: pkgconfig(hal-api-common) %description NFC Plugin Emul @@ -19,7 +20,8 @@ NFC Plugin Emul cp %{SOURCE1001} ./%{name}.manifest %build -%cmake . -DCMAKE_VERBOSE_MAKEFILE=OFF +%cmake . -DCMAKE_VERBOSE_MAKEFILE=OFF \ + -DHAL_PATH=%{_hal_libdir} make %{?_smp_mflags} %install @@ -27,6 +29,6 @@ make %{?_smp_mflags} %files %manifest %{name}.manifest -/usr/lib/nfc/libnfc-plugin.so +%{_hal_libdir}/*.so* %{_prefix}/lib/udev/rules.d/98-%{name}.rules %license LICENSE.APLv2 diff --git a/src/oem_emul.c b/src/oem_emul.c old mode 100644 new mode 100755 index cd29c58..8d55576 --- a/src/oem_emul.c +++ b/src/oem_emul.c @@ -26,13 +26,21 @@ #include #include -#include -#include -#include -#include -#include +#include +#include #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, @@ -57,7 +65,8 @@ typedef enum { 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 { @@ -236,6 +245,371 @@ static void __nfc_emul_util_alloc_mem(void **mem, int size, char *filename, unsi 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); @@ -464,7 +838,7 @@ static inline int _create_records_well_known(emulMsg_data_s *record, char *recor 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; } @@ -498,7 +872,7 @@ static inline int _create_records_well_known(emulMsg_data_s *record, char *recor 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; } @@ -583,7 +957,7 @@ static inline int _create_records_mime(emulMsg_data_s *record, char *record_payl } /* 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) { @@ -694,7 +1068,7 @@ static int _net_nfc_create_records_from_emulMsg(emulMsg_s *emul_msg, ndef_messag 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); @@ -703,7 +1077,7 @@ static int _net_nfc_create_records_from_emulMsg(emulMsg_s *emul_msg, ndef_messag } 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); @@ -725,7 +1099,7 @@ static int _net_nfc_create_records_from_emulMsg(emulMsg_s *emul_msg, ndef_messag 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); @@ -736,7 +1110,7 @@ static int _net_nfc_create_records_from_emulMsg(emulMsg_s *emul_msg, ndef_messag } /* 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; @@ -775,24 +1149,24 @@ static bool _net_nfc_change_file_owner_permission(FILE *file) 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) @@ -857,7 +1231,7 @@ static net_nfc_error_e _net_nfc_retrieve_ndef_message(data_s *data) 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; @@ -910,14 +1284,14 @@ static bool _net_nfc_create_ndef_from_emulMsg(emulMsg_s *emul_msg) 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!"); @@ -925,13 +1299,13 @@ static bool _net_nfc_create_ndef_from_emulMsg(emulMsg_s *emul_msg) 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(); @@ -2892,68 +3266,91 @@ static bool net_nfc_emul_controller_secure_element_close(net_nfc_target_handle_s 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, +}; -- 2.7.4