NET_NFC_NPP,
} llcp_app_protocol_e;
- typedef struct _data_s *data_h;
+ typedef struct _net_nfc_data_s *data_h;
typedef struct _ndef_record_s *ndef_record_h;
/**
This structure is just data, to express bytes array
*/
-typedef struct _data_s {
+typedef struct _net_nfc_data_s {
uint8_t *buffer;
uint32_t length;
-} data_s;
+} net_nfc_data_s;
typedef struct _net_nfc_data_t {
uint32_t length;
uint8_t buffer[0];
-} net_nfc_data_s;
+} net_nfc_data_internal_s;
typedef enum _net_nfc_connection_type_e {
NET_NFC_TAG_CONNECTION = 0x00,
net_nfc_target_handle_s *handle;
uint32_t devType;
int number_of_keys;
- net_nfc_data_s target_info_values;
+ net_nfc_data_internal_s target_info_values;
} net_nfc_current_target_info_s;
typedef struct _net_nfc_llcp_config_info_s {
uint8_t SR:1;
uint8_t IL:1;
uint8_t TNF:3;
- data_s type_s;
- data_s id_s;
- data_s payload_s;
+ net_nfc_data_s type_s;
+ net_nfc_data_s id_s;
+ net_nfc_data_s payload_s;
struct _record_s *next;
} ndef_record_s;
int number_of_keys;
net_nfc_tag_info_s *tag_info_list;
char **keylist;
- data_s raw_data;
+ net_nfc_data_s raw_data;
} net_nfc_target_info_s;
typedef struct _net_nfc_se_event_info_s {
- data_s aid;
- data_s param;
+ net_nfc_data_s aid;
+ net_nfc_data_s param;
} net_nfc_se_event_info_s;
typedef struct _net_nfc_transceive_info_s {
uint32_t dev_type;
- data_s trans_data;
+ net_nfc_data_s trans_data;
} net_nfc_transceive_info_s;
typedef struct _net_nfc_connection_handover_info_s {
net_nfc_conn_handover_carrier_type_e type;
- data_s data;
+ net_nfc_data_s data;
} net_nfc_connection_handover_info_s;
typedef enum _client_state_e {
NET_NFC_REQUEST_MSG_HEADER net_nfc_target_handle_s *handle;
uint32_t devType;
int number_of_keys;
- net_nfc_data_s target_info_values;
+ net_nfc_data_internal_s target_info_values;
} net_nfc_request_target_detected_t;
typedef struct _net_nfc_request_se_event_t {
- NET_NFC_REQUEST_MSG_HEADER data_s aid;
- data_s param;
+ NET_NFC_REQUEST_MSG_HEADER net_nfc_data_s aid;
+ net_nfc_data_s param;
} net_nfc_request_se_event_t;
typedef struct _net_nfc_request_llcp_msg_t {
} net_nfc_request_llcp_msg_t;
typedef struct _net_nfc_request_hce_apdu_t {
- NET_NFC_REQUEST_MSG_HEADER data_s apdu;
+ NET_NFC_REQUEST_MSG_HEADER net_nfc_data_s apdu;
} net_nfc_request_hce_apdu_t;
typedef struct _net_nfc_request_listen_socket_t {
net_nfc_llcp_socket_t oal_socket;
sap_t sap;
void *trans_param;
- net_nfc_data_s service_name;
+ net_nfc_data_internal_s service_name;
} net_nfc_request_listen_socket_t;
typedef struct _net_nfc_request_receive_socket_t {
net_nfc_llcp_socket_t oal_socket;
size_t req_length;
void *trans_param;
- net_nfc_data_s data;
+ net_nfc_data_internal_s data;
} net_nfc_request_receive_socket_t;
typedef struct _net_nfc_request_receive_from_socket_t {
size_t req_length;
sap_t sap;
void *trans_param;
- net_nfc_data_s data;
+ net_nfc_data_internal_s data;
} net_nfc_request_receive_from_socket_t;
// these are messages for response
-typedef void (*target_detection_listener_cb) (void *data, void *user_param);
-typedef void (*se_transaction_listener_cb) (void *data, void *user_param);
-typedef void (*llcp_event_listener_cb) (void *data, void *user_param);
+typedef void (*net_nfc_target_detection_listener_cb) (void *data, void *user_param);
+typedef void (*net_nfc_se_transaction_listener_cb) (void *data, void *user_param);
+typedef void (*net_nfc_llcp_event_listener_cb) (void *data, void *user_param);
/*HCE CB*/
-typedef void (*hce_active_listener_cb) (void *user_param);
-typedef void (*hce_deactive_listener_cb) (void *user_param);
-typedef void (*hce_apdu_listener_cb) (void *data, void *user_param);
+typedef void (*net_nfc_hce_active_listener_cb) (void *user_param);
+typedef void (*net_nfc_hce_deactive_listener_cb) (void *user_param);
+typedef void (*net_nfc_hce_apdu_listener_cb) (void *data, void *user_param);
typedef enum _llcp_event_e {
LLCP_EVENT_SOCKET_ACCEPTED = 0x1,
#define URI_SCHEM_FILE "file://"
-typedef void (*net_nfc_service_llcp_cb) (net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param);
+typedef void (*net_nfc_service_llcp_cb) (net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param);
typedef struct _net_nfc_llcp_param_t {
net_nfc_llcp_socket_t socket;
net_nfc_service_llcp_cb cb;
- data_s data;
+ net_nfc_data_s data;
void *user_param;
} net_nfc_llcp_param_t;
void net_nfc_util_gdbus_variant_to_buffer(GVariant * variant, uint8_t ** buffer, size_t * length);
-data_s *net_nfc_util_gdbus_variant_to_data(GVariant * variant);
+net_nfc_data_s *net_nfc_util_gdbus_variant_to_data(GVariant * variant);
-void net_nfc_util_gdbus_variant_to_data_s(GVariant * variant, data_s * data);
+void net_nfc_util_gdbus_variant_to_net_nfc_data_s(GVariant * variant, net_nfc_data_s * data);
GVariant *net_nfc_util_gdbus_buffer_to_variant(const uint8_t * buffer, size_t length);
-GVariant *net_nfc_util_gdbus_data_to_variant(const data_s * data);
+GVariant *net_nfc_util_gdbus_data_to_variant(const net_nfc_data_s * data);
ndef_message_s *net_nfc_util_gdbus_variant_to_ndef_message(GVariant * variant);
void net_nfc_util_hce_free_apdu_data(net_nfc_apdu_data_t * apdu_data);
-net_nfc_error_e net_nfc_util_hce_extract_parameter(data_s * apdu, net_nfc_apdu_data_t * apdu_data);
+net_nfc_error_e net_nfc_util_hce_extract_parameter(net_nfc_data_s * apdu, net_nfc_apdu_data_t * apdu_data);
-net_nfc_error_e net_nfc_util_hce_generate_apdu(net_nfc_apdu_data_t * apdu_data, data_s ** apdu);
+net_nfc_error_e net_nfc_util_hce_generate_apdu(net_nfc_apdu_data_t * apdu_data, net_nfc_data_s ** apdu);
typedef struct _net_nfc_hce_data_t {
uint32_t type;
void __net_nfc_util_free_mem(void **mem, char *filename, unsigned int line);
#define _net_nfc_util_free_mem(mem) __net_nfc_util_free_mem((void **)&mem, basename(__FILE__), __LINE__)
-data_s *net_nfc_util_create_data(uint32_t length);
-bool net_nfc_util_init_data(data_s * data, uint32_t length);
-data_s *net_nfc_util_duplicate_data(data_s * src);
-bool net_nfc_util_append_data(data_s * dest, data_s * src);
-void net_nfc_util_clear_data(data_s * data);
-void net_nfc_util_free_data(data_s * data);
+net_nfc_data_s *net_nfc_util_create_data(uint32_t length);
+bool net_nfc_util_init_data(net_nfc_data_s * data, uint32_t length);
+net_nfc_data_s *net_nfc_util_duplicate_data(net_nfc_data_s * src);
+bool net_nfc_util_append_data(net_nfc_data_s * dest, net_nfc_data_s * src);
+void net_nfc_util_clear_data(net_nfc_data_s * data);
+void net_nfc_util_free_data(net_nfc_data_s * data);
bool net_nfc_util_strip_string(char *buffer, int buffer_length);
void net_nfc_util_get_login_user(uid_t * uid);
bool net_nfc_util_get_pkgid_by_pid(pid_t pid, char *pkgid, size_t len);
-bool net_nfc_util_hex_string_to_binary(const char *str, data_s * result);
-bool net_nfc_util_binary_to_hex_string(data_s * data, char *out_buf, uint32_t max_len);
+bool net_nfc_util_hex_string_to_binary(const char *str, net_nfc_data_s * result);
+bool net_nfc_util_binary_to_hex_string(net_nfc_data_s * data, char *out_buf, uint32_t max_len);
int net_nfc_util_get_fd_from_systemd(void);
#endif //__NET_NFC_UTIL_INTERNAL_H__
/*
convert rawdata into ndef message structure
*/
-net_nfc_error_e net_nfc_util_convert_rawdata_to_ndef_message(data_s * rawdata, ndef_message_s * ndef);
+net_nfc_error_e net_nfc_util_convert_rawdata_to_ndef_message(net_nfc_data_s * rawdata, ndef_message_s * ndef);
/*
this util function converts into rawdata from ndef message structure
*/
-net_nfc_error_e net_nfc_util_convert_ndef_message_to_rawdata(ndef_message_s * ndef, data_s * rawdata);
+net_nfc_error_e net_nfc_util_convert_ndef_message_to_rawdata(ndef_message_s * ndef, net_nfc_data_s * rawdata);
/*
get total bytes of ndef message in serial form
net_nfc_error_e net_nfc_util_create_ndef_message(ndef_message_s ** ndef_message);
-net_nfc_error_e net_nfc_util_search_record_by_type(ndef_message_s * ndef_message, net_nfc_record_tnf_e tnf, data_s * type, ndef_record_s ** record);
+net_nfc_error_e net_nfc_util_search_record_by_type(ndef_message_s * ndef_message, net_nfc_record_tnf_e tnf, net_nfc_data_s * type, ndef_record_s ** record);
net_nfc_error_e net_nfc_util_append_record_by_index(ndef_message_s * ndef_message, int index, ndef_record_s * record);
net_nfc_error_e net_nfc_util_remove_record_by_index(ndef_message_s * ndef_message, int index);
-net_nfc_error_e net_nfc_util_search_record_by_id(ndef_message_s * ndef_message, data_s * id, ndef_record_s ** record);
+net_nfc_error_e net_nfc_util_search_record_by_id(ndef_message_s * ndef_message, net_nfc_data_s * id, ndef_record_s ** record);
void net_nfc_util_foreach_ndef_records(ndef_message_s * msg, net_nfc_foreach_ndef_records_cb func, void *user_data);
-net_nfc_error_e net_nfc_util_check_ndef_message_rawdata(data_s * rawdata);
+net_nfc_error_e net_nfc_util_check_ndef_message_rawdata(net_nfc_data_s * rawdata);
#endif //__NET_NFC_UTIL_NDEF_MESSAGE_H__
/*
create record structure with basic info
*/
-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);
+net_nfc_error_e net_nfc_util_create_record(net_nfc_record_tnf_e recordType, net_nfc_data_s * typeName, net_nfc_data_s * id, net_nfc_data_s * payload, ndef_record_s ** record);
/*
create text type record
SECURE_LOGD("FILE: %s, LINE:%d, strdup failed", filename, line);
}
-NET_NFC_EXPORT_API data_s *net_nfc_util_create_data(uint32_t length)
+NET_NFC_EXPORT_API net_nfc_data_s *net_nfc_util_create_data(uint32_t length)
{
- data_s *data = NULL;
+ net_nfc_data_s *data = NULL;
_net_nfc_util_alloc_mem(data, sizeof(*data));
if (length > 0)
return data;
}
-NET_NFC_EXPORT_API bool net_nfc_util_init_data(data_s * data, uint32_t length)
+NET_NFC_EXPORT_API bool net_nfc_util_init_data(net_nfc_data_s * data, uint32_t length)
{
if (data == NULL || length == 0)
return false;
return true;
}
-NET_NFC_EXPORT_API data_s *net_nfc_util_duplicate_data(data_s * src)
+NET_NFC_EXPORT_API net_nfc_data_s *net_nfc_util_duplicate_data(net_nfc_data_s * src)
{
- data_s *data;
+ net_nfc_data_s *data;
if (src == NULL || src->length == 0)
return false;
return data;
}
-NET_NFC_EXPORT_API bool net_nfc_util_append_data(data_s * dest, data_s * src)
+NET_NFC_EXPORT_API bool net_nfc_util_append_data(net_nfc_data_s * dest, net_nfc_data_s * src)
{
- data_s *data;
+ net_nfc_data_s *data;
if (dest == NULL || src == NULL || src->length == 0)
return false;
return true;
}
-NET_NFC_EXPORT_API void net_nfc_util_clear_data(data_s * data)
+NET_NFC_EXPORT_API void net_nfc_util_clear_data(net_nfc_data_s * data)
{
if (data == NULL)
return;
data->length = 0;
}
-NET_NFC_EXPORT_API void net_nfc_util_free_data(data_s * data)
+NET_NFC_EXPORT_API void net_nfc_util_free_data(net_nfc_data_s * data)
{
if (data == NULL)
return;
#define TO_BINARY(x) (((x) >= '0' && (x) <= '9') ? ((x) - '0') : (((x) >= 'A' && (x) <= 'F') ? ((x) - 'A' + 10) : (((x) >= 'a' && (x) <= 'f') ? ((x) - 'a' + 10) : 0)))
-bool net_nfc_util_hex_string_to_binary(const char *str, data_s * result)
+bool net_nfc_util_hex_string_to_binary(const char *str, net_nfc_data_s * result)
{
size_t len, i;
return true;
}
-bool net_nfc_util_binary_to_hex_string(data_s * data, char *out_buf, uint32_t max_len)
+bool net_nfc_util_binary_to_hex_string(net_nfc_data_s * data, char *out_buf, uint32_t max_len)
{
int current = 0;
uint8_t *buffer;
}
}
-data_s *net_nfc_util_gdbus_variant_to_data(GVariant * variant)
+net_nfc_data_s *net_nfc_util_gdbus_variant_to_data(GVariant * variant)
{
GVariantIter *iter;
guint size;
- data_s *result = NULL;
+ net_nfc_data_s *result = NULL;
if (variant == NULL)
return result;
return result;
}
-void net_nfc_util_gdbus_variant_to_data_s(GVariant * variant, data_s * data)
+void net_nfc_util_gdbus_variant_to_net_nfc_data_s(GVariant * variant, net_nfc_data_s * data)
{
GVariantIter *iter;
guint size;
return g_variant_builder_end(&builder);
}
-GVariant *net_nfc_util_gdbus_data_to_variant(const data_s * data)
+GVariant *net_nfc_util_gdbus_data_to_variant(const net_nfc_data_s * data)
{
if (data != NULL)
return net_nfc_util_gdbus_buffer_to_variant(data->buffer, data->length);
ndef_message_s *net_nfc_util_gdbus_variant_to_ndef_message(GVariant * variant)
{
ndef_message_s *message = NULL;
- data_s data = { NULL, 0 };
+ net_nfc_data_s data = { NULL, 0 };
if (variant == NULL)
return NULL;
- net_nfc_util_gdbus_variant_to_data_s(variant, &data);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(variant, &data);
if (data.buffer && data.length > 0) {
ndef_message_s *temp = NULL;
GVariant *net_nfc_util_gdbus_ndef_message_to_variant(const ndef_message_s * message)
{
GVariant *variant = NULL;
- data_s temp = { NULL, 0 };
- data_s *data = NULL;
+ net_nfc_data_s temp = { NULL, 0 };
+ net_nfc_data_s *data = NULL;
size_t length;
length = net_nfc_util_get_ndef_message_length((ndef_message_s *) message);
{
uint32_t state;
uint16_t random_num;
- data_s typeName = { (uint8_t *) CH_CR_RECORD_TYPE,
+ net_nfc_data_s typeName = { (uint8_t *) CH_CR_RECORD_TYPE,
CH_CR_RECORD_TYPE_LEN
};
- data_s payload = { (uint8_t *) & random_num, sizeof(random_num) };
+ net_nfc_data_s payload = { (uint8_t *) & random_num, sizeof(random_num) };
if (record == NULL)
return NET_NFC_NULL_PARAMETER;
net_nfc_error_e net_nfc_util_create_handover_error_record(ndef_record_s ** record, uint8_t reason, uint32_t data)
{
- data_s type = { (uint8_t *) CH_ERR_RECORD_TYPE, CH_ERR_RECORD_TYPE_LEN };
- data_s payload = { NULL, 0 };
+ net_nfc_data_s type = { (uint8_t *) CH_ERR_RECORD_TYPE, CH_ERR_RECORD_TYPE_LEN };
+ net_nfc_data_s payload = { NULL, 0 };
int size = 1;
switch (reason) {
static void _change_id_field_and_add_record(uint8_t * buffer, uint32_t length, ndef_record_s * record, ndef_message_s * message)
{
- data_s id = { buffer, length };
+ net_nfc_data_s id = { buffer, length };
ndef_record_s *temp = NULL;
net_nfc_util_create_record(record->TNF, &record->type_s, &id, &record->payload_s, &temp);
ndef_message_s *inner_msg;
ndef_message_s *main_msg;
int count;
- data_s type = { (uint8_t *) CH_AC_RECORD_TYPE, CH_AC_RECORD_TYPE_LEN };
- data_s payload = { NULL, 0 };
+ net_nfc_data_s type = { (uint8_t *) CH_AC_RECORD_TYPE, CH_AC_RECORD_TYPE_LEN };
+ net_nfc_data_s payload = { NULL, 0 };
ndef_record_s *record = NULL;
char *id;
net_nfc_util_clear_data(&payload);
}
-static void _get_handover_type_field(net_nfc_ch_type_e type, data_s * result)
+static void _get_handover_type_field(net_nfc_ch_type_e type, net_nfc_data_s * result)
{
switch (type) {
case NET_NFC_CH_TYPE_REQUEST:
gpointer params[3];
ndef_message_s *inner_msg = NULL;
ndef_message_s *main_msg = NULL;
- data_s payload = { NULL, 0 };
+ net_nfc_data_s payload = { NULL, 0 };
uint32_t len;
char id = 'A';
len = net_nfc_util_get_ndef_message_length(inner_msg);
if (net_nfc_util_init_data(&payload, sizeof(ch_payload_t) + len) == true) {
- data_s data;
+ net_nfc_data_s data;
ch_payload_t *header;
header = (ch_payload_t *) payload.buffer;
error = net_nfc_util_convert_ndef_message_to_rawdata(inner_msg, &data);
if (error == NET_NFC_OK) {
ndef_record_s *hr = NULL;
- data_s type;
+ net_nfc_data_s type;
/* set version */
header->version = CH_VERSION;
return error;
}
-static ndef_message_s *_raw_data_to_ndef_message(data_s * data)
+static ndef_message_s *_raw_data_to_ndef_message(net_nfc_data_s * data)
{
net_nfc_error_e result;
ndef_message_s *msg = NULL;
return result;
}
-static net_nfc_ch_type_e _get_handover_type_from_type_data(data_s * result)
+static net_nfc_ch_type_e _get_handover_type_from_type_data(net_nfc_data_s * result)
{
net_nfc_ch_type_e type;
return NET_NFC_INVALID_FORMAT;
ndef_message_s *inner;
- data_s data;
+ net_nfc_data_s data;
ch_payload_t *header;
/* check type */
static void _serialize_cb(GNode * node, gpointer data)
{
net_nfc_carrier_property_s *prop = node->data;
- data_s *payload = (data_s *) data;
+ net_nfc_data_s *payload = (net_nfc_data_s *) data;
eir_header_t *header;
if (prop == NULL)
net_nfc_error_e result;
uint32_t len;
uint8_t *buffer = NULL;
- data_s type = { (uint8_t *) CH_BT_MIME, CH_BT_MIME_LEN };
+ net_nfc_data_s type = { (uint8_t *) CH_BT_MIME, CH_BT_MIME_LEN };
if (record == NULL || config == NULL)
return NET_NFC_NULL_PARAMETER;
oob_header_t *header = (oob_header_t *) buffer;
uint16_t addr_len = 0;
uint8_t *addr = NULL;
- data_s payload;
+ net_nfc_data_s payload;
/* total length */
header->length = len;
static void _serialize_wsc_prop_cb(GNode * node, gpointer data)
{
net_nfc_carrier_property_s *prop = node->data;
- data_s *payload = (data_s *) data;
+ net_nfc_data_s *payload = (net_nfc_data_s *) data;
tlv_header_t *header;
header = (tlv_header_t *) (payload->buffer + payload->length);
static void _serialize_p2p_prop_cb(GNode * node, gpointer data)
{
net_nfc_carrier_property_s *prop = node->data;
- data_s *payload = (data_s *) data;
+ net_nfc_data_s *payload = (net_nfc_data_s *) data;
small_tlv_header_t *header;
header = (small_tlv_header_t *) (payload->buffer + payload->length);
{
net_nfc_error_e result;
uint32_t wsc_len, p2p_len;
- data_s payload = { 0, };
- data_s type = { (uint8_t *) CH_WIFI_P2P_MIME, CH_WIFI_P2P_MIME_LEN };
+ net_nfc_data_s payload = { 0, };
+ net_nfc_data_s type = { (uint8_t *) CH_WIFI_P2P_MIME, CH_WIFI_P2P_MIME_LEN };
if (record == NULL || config == NULL)
return NET_NFC_NULL_PARAMETER;
if (net_nfc_util_init_data(&payload, wsc_len + p2p_len) == true) {
ac_header_t *header;
- data_s temp;
+ net_nfc_data_s temp;
/* serialize WSC properties */
header = (ac_header_t *) payload.buffer;
static void _serialize_cb(GNode * node, gpointer data)
{
net_nfc_carrier_property_s *prop = node->data;
- data_s *payload = (data_s *) data;
+ net_nfc_data_s *payload = (net_nfc_data_s *) data;
tlv_header_t *header;
header = (tlv_header_t *) (payload->buffer + payload->length);
{
net_nfc_error_e result;
uint32_t len;
- data_s payload = { 0, };
- data_s type = { (uint8_t *) CH_WIFI_P2P_MIME, CH_WIFI_P2P_MIME_LEN };
+ net_nfc_data_s payload = { 0, };
+ net_nfc_data_s type = { (uint8_t *) CH_WIFI_P2P_MIME, CH_WIFI_P2P_MIME_LEN };
if (record == NULL || config == NULL)
return NET_NFC_NULL_PARAMETER;
}
}
-net_nfc_error_e net_nfc_util_hce_extract_parameter(data_s * apdu, net_nfc_apdu_data_t * apdu_data)
+net_nfc_error_e net_nfc_util_hce_extract_parameter(net_nfc_data_s * apdu, net_nfc_apdu_data_t * apdu_data)
{
net_nfc_error_e result;
apdu_header_t *header;
return result;
}
-net_nfc_error_e net_nfc_util_hce_generate_apdu(net_nfc_apdu_data_t * apdu_data, data_s ** apdu)
+net_nfc_error_e net_nfc_util_hce_generate_apdu(net_nfc_apdu_data_t * apdu_data, net_nfc_data_s ** apdu)
{
return NET_NFC_NOT_SUPPORTED;
}
static net_nfc_error_e __net_nfc_repair_record_flags(ndef_message_s * ndef_message);
/* LCOV_EXCL_START */
-net_nfc_error_e net_nfc_util_check_ndef_message_rawdata(data_s * rawdata)
+net_nfc_error_e net_nfc_util_check_ndef_message_rawdata(net_nfc_data_s * rawdata)
{
uint32_t offset = 0, records = 0;
uint8_t *buffer;
return NET_NFC_OK;
}
-net_nfc_error_e net_nfc_util_convert_rawdata_to_ndef_message(data_s * rawdata, ndef_message_s * ndef)
+net_nfc_error_e net_nfc_util_convert_rawdata_to_ndef_message(net_nfc_data_s * rawdata, ndef_message_s * ndef)
{
ndef_record_s *newRec = NULL;
ndef_record_s *prevRec = NULL;
return result;
}
-net_nfc_error_e net_nfc_util_convert_ndef_message_to_rawdata(ndef_message_s * ndef, data_s * rawdata)
+net_nfc_error_e net_nfc_util_convert_ndef_message_to_rawdata(ndef_message_s * ndef, net_nfc_data_s * rawdata)
{
ndef_record_s *record = NULL;
uint8_t *current = NULL;
return __net_nfc_repair_record_flags(ndef_message);
}
-net_nfc_error_e net_nfc_util_search_record_by_type(ndef_message_s * ndef_message, net_nfc_record_tnf_e tnf, data_s * type, ndef_record_s ** record)
+net_nfc_error_e net_nfc_util_search_record_by_type(ndef_message_s * ndef_message, net_nfc_record_tnf_e tnf, net_nfc_data_s * type, ndef_record_s ** record)
{
int idx = 0;
ndef_record_s *tmp_record;
return NET_NFC_NO_DATA_FOUND;
}
-net_nfc_error_e net_nfc_util_search_record_by_id(ndef_message_s * ndef_message, data_s * id, ndef_record_s ** record)
+net_nfc_error_e net_nfc_util_search_record_by_id(ndef_message_s * ndef_message, net_nfc_data_s * id, ndef_record_s ** record)
{
int idx = 0;
ndef_record_s *record_in_msg;
return NET_NFC_OK;
}
-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)
+net_nfc_error_e net_nfc_util_create_record(net_nfc_record_tnf_e recordType, net_nfc_data_s * typeName, net_nfc_data_s * id, net_nfc_data_s * payload, ndef_record_s ** record)
{
ndef_record_s *record_temp = NULL;
net_nfc_error_e net_nfc_util_create_uri_type_record(const char *uri, net_nfc_schema_type_e protocol_schema, ndef_record_s ** record)
{
net_nfc_error_e error;
- data_s type_data;
- data_s payload_data = { NULL, 0 };
+ net_nfc_data_s type_data;
+ net_nfc_data_s payload_data = { NULL, 0 };
if (uri == NULL)
return NET_NFC_NULL_PARAMETER;
net_nfc_error_e net_nfc_util_create_text_type_record(const char *text, const char *lang_code_str, net_nfc_encode_type_e encode, ndef_record_s ** record)
{
- data_s type_data;
- data_s payload_data;
+ net_nfc_data_s type_data;
+ net_nfc_data_s payload_data;
int controll_byte;
int offset = 0;
*uri = NULL;
if (record->TNF == NET_NFC_RECORD_WELL_KNOWN_TYPE && (record->type_s.length == 1 && record->type_s.buffer[0] == 'U')) {
- data_s *payload = &record->payload_s;
+ net_nfc_data_s *payload = &record->payload_s;
if (payload->length > 0) {
int length = 0;
DEBUG_ERR_MSG("invalid payload in record");
}
} else if (record->TNF == NET_NFC_RECORD_URI) {
- data_s *type = &record->type_s;
+ net_nfc_data_s *type = &record->type_s;
if (type->length > 0) {
*uri = (char *)calloc(1, type->length + 1);
{
net_nfc_error_e result = NET_NFC_UNKNOWN_ERROR;
ndef_record_s *begin_record = NULL, *end_record = NULL, *record = NULL;
- data_s payload = { NULL, 0 };
+ net_nfc_data_s payload = { NULL, 0 };
uint8_t *data_buffer = NULL;
uint32_t data_len = 0;
uint8_t signature[1024] = { 0, };
}
/* create record */
- data_s type = { (uint8_t *) SIGNATURE_RECORD_TYPE, 3 };
+ net_nfc_data_s type = { (uint8_t *) SIGNATURE_RECORD_TYPE, 3 };
net_nfc_util_create_record(NET_NFC_RECORD_WELL_KNOWN_TYPE, &type, NULL, &payload, &record);
#include "net_nfc_typedef_internal.h"
void net_nfc_addon_hce_ndef_enable(void);
-net_nfc_error_e net_nfc_addon_hce_ndef_set_data(data_s * data);
+net_nfc_error_e net_nfc_addon_hce_ndef_set_data(net_nfc_data_s * data);
void net_nfc_addon_hce_ndef_disable(void);
#endif // __NET_NFC_ADDON_HCE_NDEF_H__
static net_nfc_addon_hce_ops_t *selected_ops;
/* LCOV_EXCL_START */
-static void __process_command(net_nfc_target_handle_s * handle, data_s * data)
+static void __process_command(net_nfc_target_handle_s * handle, net_nfc_data_s * data)
{
net_nfc_apdu_data_t *apdu_data;
if (apdu_data->p1 == NET_NFC_HCE_P1_SELECT_BY_NAME) {
char aid[1024];
int i;
- data_s temp = { apdu_data->data, apdu_data->lc };
+ net_nfc_data_s temp = { apdu_data->data, apdu_data->lc };
net_nfc_util_binary_to_hex_string(&temp, aid, sizeof(aid));
net_nfc_util_hce_free_apdu_data(apdu_data);
}
-static void __hce_listener(net_nfc_target_handle_s * handle, int event, data_s * data, void *user_data)
+static void __hce_listener(net_nfc_target_handle_s * handle, int event, net_nfc_data_s * data, void *user_data)
{
switch (event) {
case NET_NFC_MESSAGE_ROUTING_HOST_EMU_ACTIVATED:
memcpy(buffer + offset, &sw, sizeof(sw));
/* send */
- data_s temp = { buffer, total_len };
+ net_nfc_data_s temp = { buffer, total_len };
net_nfc_server_hce_send_apdu_response(handle, &temp);
g_free(buffer);
}
-static void __process_command(net_nfc_target_handle_s * handle, data_s * cmd)
+static void __process_command(net_nfc_target_handle_s * handle, net_nfc_data_s * cmd)
{
net_nfc_apdu_data_t *apdu;
net_nfc_util_hce_free_apdu_data(apdu);
}
-static void __nfc_addon_hce_ndef_listener(net_nfc_target_handle_s * handle, int event, data_s * data, void *user_data)
+static void __nfc_addon_hce_ndef_listener(net_nfc_target_handle_s * handle, int event, net_nfc_data_s * data, void *user_data)
{
switch (event) {
case NET_NFC_MESSAGE_ROUTING_HOST_EMU_ACTIVATED:
}
}
-net_nfc_error_e net_nfc_addon_hce_ndef_set_data(data_s * data)
+net_nfc_error_e net_nfc_addon_hce_ndef_set_data(net_nfc_data_s * data)
{
if (data == NULL || data->buffer == NULL)
return NET_NFC_NULL_PARAMETER;
return offset;
}
-static size_t __fill_fci(uint8_t * tlv, size_t len, data_s * aid, data_s * label, uint8_t priority)
+static size_t __fill_fci(uint8_t * tlv, size_t len, net_nfc_data_s * aid, net_nfc_data_s * label, uint8_t priority)
{
uint8_t result[1024] = { 0, };
uint8_t temp[1024] = { 0, };
memcpy(buffer + offset, &sw, sizeof(sw));
/* send */
- data_s temp = { buffer, total_len };
+ net_nfc_data_s temp = { buffer, total_len };
net_nfc_server_hce_send_apdu_response(handle, &temp);
g_free(buffer);
}
-static void __process_command(net_nfc_target_handle_s * handle, data_s * cmd)
+static void __process_command(net_nfc_target_handle_s * handle, net_nfc_data_s * cmd)
{
net_nfc_apdu_data_t *apdu;
uint8_t buffer[1024];
size_t len;
uint8_t temp_aid[] = { 0x12, 0x34, 0x56, 0x78, 0x90 };
- data_s aid = { temp_aid, sizeof(temp_aid) };
+ net_nfc_data_s aid = { temp_aid, sizeof(temp_aid) };
uint8_t temp_label[] = { 'T', 'E', 'S', 'T' };
- data_s label = { temp_label, sizeof(temp_label) };
+ net_nfc_data_s label = { temp_label, sizeof(temp_label) };
DEBUG_ADDON_MSG("select ppse applet");
net_nfc_util_hce_free_apdu_data(apdu);
}
-static void __nfc_addon_hce_ppse_listener(net_nfc_target_handle_s * handle, int event, data_s * data, void *user_data)
+static void __nfc_addon_hce_ppse_listener(net_nfc_target_handle_s * handle, int event, net_nfc_data_s * data, void *user_data)
{
switch (event) {
case NET_NFC_MESSAGE_ROUTING_HOST_EMU_ACTIVATED:
memcpy(buffer + offset, &sw, sizeof(sw));
/* send */
- data_s temp = { buffer, total_len };
+ net_nfc_data_s temp = { buffer, total_len };
net_nfc_server_hce_send_apdu_response(handle, &temp);
g_free(buffer);
}
-static void __process_command(net_nfc_target_handle_s * handle, data_s * cmd)
+static void __process_command(net_nfc_target_handle_s * handle, net_nfc_data_s * cmd)
{
net_nfc_apdu_data_t *apdu;
net_nfc_util_hce_free_apdu_data(apdu);
}
-static void __nfc_addon_hce_tmoney_listener(net_nfc_target_handle_s * handle, int event, data_s * data, void *user_data)
+static void __nfc_addon_hce_tmoney_listener(net_nfc_target_handle_s * handle, int event, net_nfc_data_s * data, void *user_data)
{
switch (event) {
case NET_NFC_MESSAGE_ROUTING_HOST_EMU_ACTIVATED:
#define IDS_FAILED_TO_CONNECT_TO_PS \
gettext("IDS_NFC_TPOP_FAILED_TO_CONNECT_TO_PS")
-net_nfc_error_e net_nfc_app_util_store_ndef_message(data_s * data);
-net_nfc_error_e net_nfc_app_util_process_ndef(data_s * data);
+net_nfc_error_e net_nfc_app_util_store_ndef_message(net_nfc_data_s * data);
+net_nfc_error_e net_nfc_app_util_process_ndef(net_nfc_data_s * data);
void net_nfc_app_util_aul_launch_app(char *package_name, bundle * kb);
void net_nfc_app_util_clean_storage(char *src_path);
bool net_nfc_app_util_is_dir(const char *path_name);
bool net_nfc_controller_unload(void);
bool net_nfc_controller_init(net_nfc_error_e * result);
bool net_nfc_controller_deinit(void);
-bool net_nfc_controller_register_listener(target_detection_listener_cb target_detection_listener, se_transaction_listener_cb se_transaction_listener, llcp_event_listener_cb llcp_event_listener, hce_apdu_listener_cb hce_apdu_listener, net_nfc_error_e * result);
+bool net_nfc_controller_register_listener(net_nfc_target_detection_listener_cb target_detection_listener,
+ net_nfc_se_transaction_listener_cb se_transaction_listener,
+ net_nfc_llcp_event_listener_cb llcp_event_listener,
+ net_nfc_hce_apdu_listener_cb hce_apdu_listener,
+ net_nfc_error_e * result);
bool net_nfc_controller_unregister_listener(void);
bool net_nfc_controller_support_nfc(net_nfc_error_e * result);
-bool net_nfc_controller_get_firmware_version(data_s ** data, net_nfc_error_e * result);
+bool net_nfc_controller_get_firmware_version(net_nfc_data_s ** data, net_nfc_error_e * result);
bool net_nfc_controller_check_firmware_version(net_nfc_error_e * result);
bool net_nfc_controller_update_firmware(net_nfc_error_e * result);
bool net_nfc_controller_get_stack_information(net_nfc_stack_information_s * stack_info, net_nfc_error_e * result);
bool net_nfc_controller_connect(net_nfc_target_handle_s * handle, net_nfc_error_e * result);
bool net_nfc_controller_disconnect(net_nfc_target_handle_s * handle, net_nfc_error_e * result);
bool net_nfc_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);
-bool net_nfc_controller_read_ndef(net_nfc_target_handle_s * handle, data_s ** data, net_nfc_error_e * result);
-bool net_nfc_controller_write_ndef(net_nfc_target_handle_s * handle, data_s * data, net_nfc_error_e * result);
+bool net_nfc_controller_read_ndef(net_nfc_target_handle_s * handle, net_nfc_data_s ** data, net_nfc_error_e * result);
+bool net_nfc_controller_write_ndef(net_nfc_target_handle_s * handle, net_nfc_data_s * data, net_nfc_error_e * result);
bool net_nfc_controller_make_read_only_ndef(net_nfc_target_handle_s * handle, net_nfc_error_e * result);
-bool net_nfc_controller_format_ndef(net_nfc_target_handle_s * handle, data_s * secure_key, net_nfc_error_e * result);
-bool net_nfc_controller_transceive(net_nfc_target_handle_s * handle, net_nfc_transceive_info_s * info, data_s ** data, net_nfc_error_e * result);
+bool net_nfc_controller_format_ndef(net_nfc_target_handle_s * handle, net_nfc_data_s * secure_key, net_nfc_error_e * result);
+bool net_nfc_controller_transceive(net_nfc_target_handle_s * handle, net_nfc_transceive_info_s * info, net_nfc_data_s ** data, net_nfc_error_e * result);
bool net_nfc_controller_exception_handler(void);
bool net_nfc_controller_is_ready(net_nfc_error_e * result);
bool net_nfc_controller_llcp_disconnect(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_error_e * result, net_nfc_service_llcp_cb cb, void *user_param);
bool net_nfc_controller_llcp_socket_close(net_nfc_llcp_socket_t socket, net_nfc_error_e * result);
bool net_nfc_controller_llcp_recv(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, uint32_t max_len, net_nfc_error_e * result, net_nfc_service_llcp_cb cb, void *user_param);
-bool net_nfc_controller_llcp_send(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, net_nfc_error_e * result, net_nfc_service_llcp_cb cb, void *user_param);
+bool net_nfc_controller_llcp_send(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, net_nfc_error_e * result, net_nfc_service_llcp_cb cb, void *user_param);
bool net_nfc_controller_llcp_recv_from(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, uint32_t max_len, net_nfc_error_e * result, net_nfc_service_llcp_cb cb, void *user_param);
-bool net_nfc_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, net_nfc_service_llcp_cb cb, void *user_param);
+bool net_nfc_controller_llcp_send_to(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, uint8_t service_access_point, net_nfc_error_e * result, net_nfc_service_llcp_cb cb, void *user_param);
bool net_nfc_controller_llcp_reject(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_error_e * result);
bool net_nfc_controller_llcp_get_remote_config(net_nfc_target_handle_s * handle, net_nfc_llcp_config_info_s * config, net_nfc_error_e * result);
bool net_nfc_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);
/* secure element api */
bool net_nfc_controller_secure_element_open(net_nfc_secure_element_type_e element_type, net_nfc_target_handle_s ** handle, net_nfc_error_e * result);
-bool net_nfc_controller_secure_element_get_atr(net_nfc_target_handle_s * handle, data_s ** atr, net_nfc_error_e * result);
-bool net_nfc_controller_secure_element_send_apdu(net_nfc_target_handle_s * handle, data_s * command, data_s ** response, net_nfc_error_e * result);
+bool net_nfc_controller_secure_element_get_atr(net_nfc_target_handle_s * handle, net_nfc_data_s ** atr, net_nfc_error_e * result);
+bool net_nfc_controller_secure_element_send_apdu(net_nfc_target_handle_s * handle, net_nfc_data_s * command, net_nfc_data_s ** response, net_nfc_error_e * result);
bool net_nfc_controller_secure_element_close(net_nfc_target_handle_s * handle, net_nfc_error_e * result);
bool net_nfc_controller_get_secure_element_list(net_nfc_secure_element_info_s * list, int *count, net_nfc_error_e * result);
bool net_nfc_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);
/* test api */
-bool net_nfc_controller_sim_test(net_nfc_error_e * result);
-bool net_nfc_controller_prbs_test(net_nfc_error_e * result, uint32_t tech, uint32_t rate);
bool net_nfc_controller_test_mode_on(net_nfc_error_e * result);
bool net_nfc_controller_test_mode_off(net_nfc_error_e * result);
-bool net_nfc_controller_eedata_register_set(net_nfc_error_e * result, uint32_t mode, uint32_t reg_id, data_s * data);
-bool net_nfc_controller_ese_test(net_nfc_error_e * result);
-bool net_nfc_controller_test_set_se_tech_type(net_nfc_error_e * result, net_nfc_se_type_e type, uint32_t tech);
/* hce api */
-bool net_nfc_controller_hce_response_apdu(net_nfc_target_handle_s * handle, data_s * response, net_nfc_error_e * result);
+bool net_nfc_controller_hce_response_apdu(net_nfc_target_handle_s * handle, net_nfc_data_s * response, net_nfc_error_e * result);
-bool net_nfc_controller_secure_element_route_aid(data_s * aid, net_nfc_se_type_e se_type, int power, net_nfc_error_e * result);
-bool net_nfc_controller_secure_element_unroute_aid(data_s * aid, net_nfc_error_e * result);
+bool net_nfc_controller_secure_element_route_aid(net_nfc_data_s * aid, net_nfc_se_type_e se_type, int power, net_nfc_error_e * result);
+bool net_nfc_controller_secure_element_unroute_aid(net_nfc_data_s * aid, net_nfc_error_e * result);
bool net_nfc_controller_secure_element_commit_routing(net_nfc_error_e * result);
bool net_nfc_controller_secure_element_set_default_route(net_nfc_se_type_e switch_on, net_nfc_se_type_e switch_off, net_nfc_se_type_e battery_off, net_nfc_error_e * result);
bool net_nfc_controller_secure_element_clear_aid_table(net_nfc_error_e * result);
GDBusMethodInvocation *invocation;
guint32 handle;
gint32 type;
- data_s *data;
+ net_nfc_data_s *data;
};
net_nfc_error_e net_nfc_server_handover_emit_started_signal();
typedef void (*net_nfc_server_handover_get_carrier_cb) (net_nfc_error_e result, net_nfc_ch_carrier_s * carrier, void *user_param);
-typedef void (*net_nfc_server_handover_process_carrier_cb) (net_nfc_error_e result, net_nfc_conn_handover_carrier_type_e type, data_s * data, void *user_param);
+typedef void (*net_nfc_server_handover_process_carrier_cb) (net_nfc_error_e result, net_nfc_conn_handover_carrier_type_e type, net_nfc_data_s * data, void *user_param);
typedef struct _ch_hc_record_t {
uint8_t rfu:5;
#include "net_nfc_typedef_internal.h"
/******************************************************************************/
-typedef void (*net_nfc_server_hce_listener_cb) (net_nfc_target_handle_s * handle, int event, data_s * data, void *user_data);
+typedef void (*net_nfc_server_hce_listener_cb) (net_nfc_target_handle_s * handle, int event, net_nfc_data_s * data, void *user_data);
typedef void (*net_nfc_server_hce_user_data_destroy_cb) (void *user_data);
net_nfc_error_e net_nfc_server_hce_stop_hce_handler(const char *package);
-net_nfc_error_e net_nfc_server_hce_send_apdu_response(net_nfc_target_handle_s * handle, data_s * response);
+net_nfc_error_e net_nfc_server_hce_send_apdu_response(net_nfc_target_handle_s * handle, net_nfc_data_s * response);
/******************************************************************************/
/* internal */
void net_nfc_server_hce_apdu_received(void *info);
-void net_nfc_server_hce_handle_send_apdu_response(net_nfc_target_handle_s * handle, data_s * response);
+void net_nfc_server_hce_handle_send_apdu_response(net_nfc_target_handle_s * handle, net_nfc_data_s * response);
#endif //__NET_NFC_SERVER_SE_H__
void net_nfc_server_hce_ipc_deinit();
-bool net_nfc_server_hce_send_to_client(const char *id, int type, net_nfc_target_handle_s * handle, data_s * data);
+bool net_nfc_server_hce_send_to_client(const char *id, int type, net_nfc_target_handle_s * handle, net_nfc_data_s * data);
-bool net_nfc_server_hce_send_to_all_client(int type, net_nfc_target_handle_s * handle, data_s * data);
+bool net_nfc_server_hce_send_to_all_client(int type, net_nfc_target_handle_s * handle, net_nfc_data_s * data);
#endif //__NET_NFC_SERVER_HCE_IPC_H__
NET_NFC_STATE_ERROR,
} net_nfc_state_e;
-typedef void (*net_nfc_server_llcp_callback) (net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, gpointer user_data);
+typedef void (*net_nfc_server_llcp_callback) (net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, gpointer user_data);
typedef void (*net_nfc_server_llcp_activate_cb) (int event, net_nfc_target_handle_s * handle, uint32_t sap, const char *san, void *user_param);
net_nfc_error_e net_nfc_server_llcp_simple_accept(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_server_llcp_callback error_callback, gpointer user_data);
-net_nfc_error_e net_nfc_server_llcp_simple_send(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, net_nfc_server_llcp_callback callback, gpointer user_data);
+net_nfc_error_e net_nfc_server_llcp_simple_send(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, net_nfc_server_llcp_callback callback, gpointer user_data);
net_nfc_error_e net_nfc_server_llcp_simple_receive(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_server_llcp_callback callback, gpointer user_data);
void net_nfc_server_p2p_received(data_h user_data);
-void net_nfc_server_p2p_data_sent(net_nfc_error_e result, gpointer user_data);
+void net_nfc_server_p2p_net_nfc_data_sent(net_nfc_error_e result, gpointer user_data);
#endif //__NET_NFC_SERVER_P2P_H__
#include "net_nfc_typedef.h"
#include "net_nfc_typedef_internal.h"
-typedef void (*net_nfc_server_npp_callback) (net_nfc_error_e result, data_s * data, gpointer user_data);
+typedef void (*net_nfc_server_npp_callback) (net_nfc_error_e result, net_nfc_data_s * data, gpointer user_data);
net_nfc_error_e net_nfc_server_npp_server(net_nfc_target_handle_s * handle, char *san, sap_t sap, net_nfc_server_npp_callback callback, gpointer user_data);
-net_nfc_error_e net_nfc_server_npp_client(net_nfc_target_handle_s * handle, char *san, sap_t sap, data_s * data, net_nfc_server_npp_callback callback, gpointer user_data);
+net_nfc_error_e net_nfc_server_npp_client(net_nfc_target_handle_s * handle, char *san, sap_t sap, net_nfc_data_s * data, net_nfc_server_npp_callback callback, gpointer user_data);
net_nfc_error_e net_nfc_server_npp_default_server_start(net_nfc_target_handle_s * handle);
-net_nfc_error_e net_nfc_server_npp_default_client_start(net_nfc_target_handle_s * handle, data_s * data, int client, gpointer user_data);
+net_nfc_error_e net_nfc_server_npp_default_client_start(net_nfc_target_handle_s * handle, net_nfc_data_s * data, int client, gpointer user_data);
net_nfc_error_e net_nfc_server_npp_default_server_register();
SNEP_RESP_REJECT = 0xFF,
} snep_command_field_e;
-typedef bool(*net_nfc_server_snep_listen_cb) (net_nfc_snep_handle_h handle, uint32_t type, uint32_t max_len, data_s * data, void *user_param);
+typedef bool(*net_nfc_server_snep_listen_cb) (net_nfc_snep_handle_h handle, uint32_t type, uint32_t max_len, net_nfc_data_s * data, void *user_param);
-typedef net_nfc_error_e(*net_nfc_server_snep_cb) (net_nfc_snep_handle_h handle, net_nfc_error_e result, uint32_t type, data_s * data, void *user_param);
+typedef net_nfc_error_e(*net_nfc_server_snep_cb) (net_nfc_snep_handle_h handle, net_nfc_error_e result, uint32_t type, net_nfc_data_s * data, void *user_param);
net_nfc_error_e net_nfc_server_snep_server(net_nfc_target_handle_s * handle, const char *san, sap_t sap, net_nfc_server_snep_cb cb, void *user_param);
net_nfc_error_e net_nfc_server_snep_client(net_nfc_target_handle_s * handle, const char *san, sap_t sap, net_nfc_server_snep_cb cb, void *user_param);
-net_nfc_error_e net_nfc_server_snep_server_send_get_response(net_nfc_snep_handle_h snep_handle, data_s * data);
+net_nfc_error_e net_nfc_server_snep_server_send_get_response(net_nfc_snep_handle_h snep_handle, net_nfc_data_s * data);
-net_nfc_error_e net_nfc_server_snep_client_request(net_nfc_snep_handle_h snep, uint8_t type, data_s * data, net_nfc_server_snep_cb cb, void *user_param);
+net_nfc_error_e net_nfc_server_snep_client_request(net_nfc_snep_handle_h snep, uint8_t type, net_nfc_data_s * data, net_nfc_server_snep_cb cb, void *user_param);
net_nfc_error_e net_nfc_server_snep_default_server_start(net_nfc_target_handle_s * handle);
-net_nfc_error_e net_nfc_server_snep_default_client_start(net_nfc_target_handle_s * handle, int type, data_s * data, int client, void *user_param);
+net_nfc_error_e net_nfc_server_snep_default_client_start(net_nfc_target_handle_s * handle, int type, net_nfc_data_s * data, int client, void *user_param);
net_nfc_error_e net_nfc_server_snep_default_server_register_get_response_cb(net_nfc_server_snep_listen_cb cb, void *user_param);
net_nfc_error_e net_nfc_server_snep_default_server_unregister_get_response_cb(net_nfc_server_snep_listen_cb cb);
-net_nfc_error_e net_nfc_server_snep_default_server_send_get_response(net_nfc_snep_handle_h snep_handle, data_s * data);
+net_nfc_error_e net_nfc_server_snep_default_server_send_get_response(net_nfc_snep_handle_h snep_handle, net_nfc_data_s * data);
net_nfc_error_e net_nfc_server_snep_default_server_register();
net_nfc_error_e net_nfc_server_snep_default_server_unregister();
-net_nfc_error_e net_nfc_server_snep_parse_get_request(data_s * request, size_t * max_len, data_s * message);
+net_nfc_error_e net_nfc_server_snep_parse_get_request(net_nfc_data_s * request, size_t * max_len, net_nfc_data_s * message);
#endif //__NET_NFC_SERVER_PROCESS_SNEP_H__
/* TEMP : process handover message */
/* LCOV_EXCL_START */
-static void _process_carrier_record_cb(net_nfc_error_e result, net_nfc_conn_handover_carrier_type_e type, data_s * data, void *user_param)
+static void _process_carrier_record_cb(net_nfc_error_e result, net_nfc_conn_handover_carrier_type_e type, net_nfc_data_s * data, void *user_param)
{
- data_s *message = (data_s *) user_param;
+ net_nfc_data_s *message = (net_nfc_data_s *) user_param;
if (result == NET_NFC_OK)
DEBUG_SERVER_MSG("process carrier record success");
net_nfc_util_free_data(message);
}
-static net_nfc_error_e __process_ch_message(net_nfc_ch_message_s * message, data_s * data)
+static net_nfc_error_e __process_ch_message(net_nfc_ch_message_s * message, net_nfc_data_s * data)
{
net_nfc_error_e result;
uint32_t count;
}
if (carrier != NULL) {
- data_s *temp;
+ net_nfc_data_s *temp;
if (type == NET_NFC_CONN_HANDOVER_CARRIER_BT) {
temp = net_nfc_util_duplicate_data(data);
goto END;
}
- data_s data = { NULL, 0 };
+ net_nfc_data_s data = { NULL, 0 };
size_t length = net_nfc_util_get_ndef_message_length(message);
if (net_nfc_util_init_data(&data, length) == true)
NULL
};
-net_nfc_error_e net_nfc_app_util_process_ndef(data_s * data)
+net_nfc_error_e net_nfc_app_util_process_ndef(net_nfc_data_s * data)
{
net_nfc_error_e result = NET_NFC_UNKNOWN_ERROR;
ndef_message_s *msg = NULL;
return true;
}
-net_nfc_error_e net_nfc_app_util_store_ndef_message(data_s * data)
+net_nfc_error_e net_nfc_app_util_store_ndef_message(net_nfc_data_s * data)
{
net_nfc_error_e result = NET_NFC_UNKNOWN_ERROR;
char file_name[1024] = { 0, };
case NET_NFC_RECORD_EXTERNAL_RTD: /* external type */
{
- data_s *type = &record->type_s;
+ net_nfc_data_s *type = &record->type_s;
if (type->length > 0) {
#if 0
if (aid != NULL && aid_len > 0) {
char temp_string[1024] = { 0, };
char aid_string[1280] = { 0, };
- data_s temp = { aid, aid_len };
+ net_nfc_data_s temp = { aid, aid_len };
net_nfc_util_binary_to_hex_string(&temp, temp_string, sizeof(temp_string));
if (param != NULL && param_len > 0) {
char param_string[1024] = { 0, };
- data_s temp = { param, param_len };
+ net_nfc_data_s temp = { param, param_len };
net_nfc_util_binary_to_hex_string(&temp, param_string, sizeof(param_string));
if (aid != NULL && aid_len > 0) {
char temp_string[1024] = { 0, };
char aid_string[1280] = { 0, };
- data_s temp = { aid, aid_len };
+ net_nfc_data_s temp = { aid, aid_len };
net_nfc_util_binary_to_hex_string(&temp, temp_string, sizeof(temp_string));
if (param != NULL && param_len > 0) {
char param_string[1024] = { 0, };
- data_s temp = { param, param_len };
+ net_nfc_data_s temp = { param, param_len };
net_nfc_util_binary_to_hex_string(&temp, param_string, sizeof(param_string));
/* convert aid to aid string */
if (aid != NULL && aid_len > 0) {
char aid_string[1024] = { 0, };
- data_s temp = { aid, aid_len };
+ net_nfc_data_s temp = { aid, aid_len };
net_nfc_util_binary_to_hex_string(&temp, aid_string, sizeof(aid_string));
if (param != NULL && param_len > 0) {
char param_string[1024] = { 0, };
- data_s temp = { param, param_len };
+ net_nfc_data_s temp = { param, param_len };
net_nfc_util_binary_to_hex_string(&temp, param_string, sizeof(param_string));
bool net_nfc_controller_onload()
{
- bool ret = false;
+ int result = hal_nfc_get_backend();
- int ret_val = hal_nfc_get_backend();
- if (ret_val == NET_NFC_OK)
- ret = true;
-
- return ret;
+ return (result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_unload()
{
- bool ret = false;
-
- int ret_val = hal_nfc_put_backend();
- if (ret_val == NET_NFC_OK)
- ret = true;
+ int result = hal_nfc_put_backend();
- return ret;
+ return (result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_init(net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_start(result);
+ *result = hal_nfc_start();
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_deinit(void)
{
- bool ret = false;
+ int result = hal_nfc_stop();
- ret = hal_nfc_stop();
-
- return ret;
+ return (result == NET_NFC_OK) ? true : false;
}
-bool net_nfc_controller_register_listener(target_detection_listener_cb target_detection_listener, se_transaction_listener_cb se_transaction_listener, llcp_event_listener_cb llcp_event_listener, hce_apdu_listener_cb hce_apdu_listener, net_nfc_error_e * result)
+bool net_nfc_controller_register_listener(net_nfc_target_detection_listener_cb target_detection_listener,
+ net_nfc_se_transaction_listener_cb se_transaction_listener,
+ net_nfc_llcp_event_listener_cb llcp_event_listener,
+ net_nfc_hce_apdu_listener_cb hce_apdu_listener, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_register_listener(target_detection_listener, se_transaction_listener, llcp_event_listener, hce_apdu_listener, result);
+ *result = hal_nfc_register_listener(target_detection_listener, se_transaction_listener, llcp_event_listener, hce_apdu_listener);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
/* LCOV_EXCL_START */
bool net_nfc_controller_unregister_listener()
{
- bool ret = false;
+ int result = hal_nfc_unregister_listener();
- ret = hal_nfc_unregister_listener();
-
- return ret;
+ return (result == NET_NFC_OK) ? true : false;
}
-bool net_nfc_controller_get_firmware_version(data_s ** data, net_nfc_error_e * result)
+bool net_nfc_controller_get_firmware_version(net_nfc_data_s ** data, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_get_firmware_version(data, result);
+ *result = hal_nfc_get_firmware_version(data);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_check_firmware_version(net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_check_firmware_version(result);
+ *result = hal_nfc_check_firmware_version();
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_update_firmware(net_nfc_error_e * result)
{
- bool ret = false;
+ *result = hal_nfc_update_firmware();
- ret = hal_nfc_update_firmware(result);
-
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_get_stack_information(net_nfc_stack_information_s * stack_info, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_get_stack_information(stack_info, result);
+ *result = hal_nfc_get_stack_information(stack_info);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
/* LCOV_EXCL_STOP */
bool net_nfc_controller_configure_discovery(net_nfc_discovery_mode_e mode, net_nfc_event_filter_e config, net_nfc_error_e * result)
{
- bool ret = false;
+ *result = hal_nfc_configure_discovery(mode, config);
- ret = hal_nfc_configure_discovery(mode, config, result);
-
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
/* LCOV_EXCL_START */
bool net_nfc_controller_get_secure_element_list(net_nfc_secure_element_info_s * list, int *count, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_get_secure_element_list(list, count, result);
+ *result = hal_nfc_get_secure_element_list(list, count);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
/* LCOV_EXCL_STOP */
bool net_nfc_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)
{
- bool ret = false;
-
- ret = hal_nfc_set_secure_element_mode(element_type, mode, result);
+ *result = hal_nfc_set_secure_element_mode(element_type, mode);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
/* LCOV_EXCL_START */
bool net_nfc_controller_secure_element_open(net_nfc_secure_element_type_e element_type, net_nfc_target_handle_s ** handle, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_secure_element_open(element_type, handle, result);
- if (ret == true) {
+ *result = hal_nfc_secure_element_open(element_type, handle);
+ if (*result == NET_NFC_OK) {
int ret_val;
ret_val = device_power_request_lock(POWER_LOCK_CPU, 300000);
DEBUG_ERR_MSG("device_power_request_lock failed, [%d]", ret_val);
}
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
-bool net_nfc_controller_secure_element_get_atr(net_nfc_target_handle_s * handle, data_s ** atr, net_nfc_error_e * result)
+bool net_nfc_controller_secure_element_get_atr(net_nfc_target_handle_s * handle, net_nfc_data_s ** atr, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_secure_element_get_atr(handle, atr, result);
+ *result = hal_nfc_secure_element_get_atr(handle, atr);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
-bool net_nfc_controller_secure_element_send_apdu(net_nfc_target_handle_s * handle, data_s * command, data_s ** response, net_nfc_error_e * result)
+bool net_nfc_controller_secure_element_send_apdu(net_nfc_target_handle_s * handle, net_nfc_data_s * command, net_nfc_data_s ** response, net_nfc_error_e * result)
{
- bool ret = false;
+ *result = hal_nfc_secure_element_send_apdu(handle, command, response);
- ret = hal_nfc_secure_element_send_apdu(handle, command, response, result);
-
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_secure_element_close(net_nfc_target_handle_s * handle, net_nfc_error_e * result)
{
- bool ret = false;
int ret_val;
ret_val = device_power_release_lock(POWER_LOCK_CPU);
if (ret_val < 0)
DEBUG_ERR_MSG("device_power_release_lock failed, [%d]", ret_val);
- ret = hal_nfc_secure_element_close(handle, result);
+ *result = hal_nfc_secure_element_close(handle);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_check_target_presence(net_nfc_target_handle_s * handle, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_check_target_presence(handle, result);
+ *result = hal_nfc_check_target_presence(handle);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_connect(net_nfc_target_handle_s * handle, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_connect(handle, result);
- if (ret == true) {
+ *result = hal_nfc_connect(handle);
+ if (*result == NET_NFC_OK) {
int ret_val = 0;
ret_val = device_power_request_lock(POWER_LOCK_CPU, 20000);
DEBUG_ERR_MSG("device_power_request_lock failed, [%d]", ret_val);
}
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_disconnect(net_nfc_target_handle_s * handle, net_nfc_error_e * result)
{
- bool ret = false;
int ret_val;
ret_val = device_power_release_lock(POWER_LOCK_CPU);
net_nfc_server_free_target_info();
- ret = hal_nfc_disconnect(handle, result);
+ *result = hal_nfc_disconnect(handle);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_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)
{
- bool ret = false;
+ *result = hal_nfc_check_ndef(handle, ndef_card_state, max_data_size, real_data_size);
- ret = hal_nfc_check_ndef(handle, ndef_card_state, max_data_size, real_data_size, result);
-
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
-bool net_nfc_controller_read_ndef(net_nfc_target_handle_s * handle, data_s ** data, net_nfc_error_e * result)
+bool net_nfc_controller_read_ndef(net_nfc_target_handle_s * handle, net_nfc_data_s ** data, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_read_ndef(handle, data, result);
+ *result = hal_nfc_read_ndef(handle, data);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
-bool net_nfc_controller_write_ndef(net_nfc_target_handle_s * handle, data_s * data, net_nfc_error_e * result)
+bool net_nfc_controller_write_ndef(net_nfc_target_handle_s * handle, net_nfc_data_s * data, net_nfc_error_e * result)
{
- bool ret = false;
+ *result = hal_nfc_write_ndef(handle, data);
- ret = hal_nfc_write_ndef(handle, data, result);
-
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_make_read_only_ndef(net_nfc_target_handle_s * handle, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_make_read_only_ndef(handle, result);
+ *result = hal_nfc_make_read_only_ndef(handle);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
-bool net_nfc_controller_format_ndef(net_nfc_target_handle_s * handle, data_s * secure_key, net_nfc_error_e * result)
+bool net_nfc_controller_format_ndef(net_nfc_target_handle_s * handle, net_nfc_data_s * secure_key, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_format_ndef(handle, secure_key, result);
+ *result = hal_nfc_format_ndef(handle, secure_key);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
-bool net_nfc_controller_transceive(net_nfc_target_handle_s * handle, net_nfc_transceive_info_s * info, data_s ** data, net_nfc_error_e * result)
+bool net_nfc_controller_transceive(net_nfc_target_handle_s * handle, net_nfc_transceive_info_s * info, net_nfc_data_s ** data, net_nfc_error_e * result)
{
- bool ret = false;
+ *result = hal_nfc_transceive(handle, info, data);
- ret = hal_nfc_transceive(handle, info, data, result);
-
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_exception_handler()
{
- bool ret = false;
-
- ret = hal_nfc_exception_handler();
+ int result = hal_nfc_exception_handler();
- return ret;
+ return (result == NET_NFC_OK) ? true : false;
}
/* LCOV_EXCL_STOP */
bool net_nfc_controller_is_ready(net_nfc_error_e * result)
{
- bool ret = false;
+ *result = hal_nfc_is_ready();
- ret = hal_nfc_is_ready(result);
-
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_llcp_config(net_nfc_llcp_config_info_s * config, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_llcp_config(config, result);
+ *result = hal_nfc_llcp_config(config);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
/* LCOV_EXCL_START */
bool net_nfc_controller_llcp_check_llcp(net_nfc_target_handle_s * handle, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_llcp_check_llcp(handle, result);
+ *result = hal_nfc_llcp_check_llcp(handle);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_llcp_activate_llcp(net_nfc_target_handle_s * handle, net_nfc_error_e * result)
{
- bool ret = false;
+ *result = hal_nfc_llcp_activate_llcp(handle);
- ret = hal_nfc_llcp_activate_llcp(handle, result);
-
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
static GSList *llcp_sockets;
bool net_nfc_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, net_nfc_service_llcp_cb cb, void *user_param)
{
- bool ret = false;
socket_info_t *info;
info = _add_socket_info(-1);
return false;
}
- ret = hal_nfc_llcp_create_socket(socket, socketType, miu, rw, result, NULL);
- if (ret == true) {
+ *result = hal_nfc_llcp_create_socket(socket, socketType, miu, rw, NULL);
+ if (*result == NET_NFC_OK) {
info->socket = *socket;
info->err_cb = cb;
info->err_param = user_param;
_remove_socket_info(-1);
}
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_llcp_bind(net_nfc_llcp_socket_t socket, uint8_t service_access_point, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_llcp_bind(socket, service_access_point, result);
+ *result = hal_nfc_llcp_bind(socket, service_access_point);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
void net_nfc_controller_llcp_incoming_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, void *data, void *user_param)
bool net_nfc_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, net_nfc_service_llcp_cb cb, void *user_param)
{
- bool ret = false;
socket_info_t *info;
info = _get_socket_info(socket);
info->work_cb = cb;
info->work_param = user_param;
- ret = hal_nfc_llcp_listen(handle, service_access_name, socket, result, info);
+ *result = hal_nfc_llcp_listen(handle, service_access_name, socket, info);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_llcp_accept(net_nfc_llcp_socket_t socket, net_nfc_error_e * result, net_nfc_service_llcp_cb cb, void *user_param)
{
- bool ret = false;
socket_info_t *info;
info = _get_socket_info(socket);
info->err_cb = cb;
info->err_param = user_param;
- ret = hal_nfc_llcp_accept(socket, result, NULL);
+ *result = hal_nfc_llcp_accept(socket, NULL);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_llcp_reject(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_llcp_reject(handle, socket, result);
- if (ret == true)
+ *result = hal_nfc_llcp_reject(handle, socket);
+ if (*result == NET_NFC_OK)
_remove_socket_info(socket);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
void net_nfc_controller_llcp_connected_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, void *data, void *user_param)
bool net_nfc_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, net_nfc_service_llcp_cb cb, void *user_param)
{
- bool ret = false;
net_nfc_llcp_param_t *param = NULL;
_net_nfc_util_alloc_mem(param, sizeof(*param));
param->cb = cb;
param->user_param = user_param;
- ret = hal_nfc_llcp_connect_by_url(handle, socket, service_access_name, result, param);
- if (ret == true) {
+ *result = hal_nfc_llcp_connect_by_url(handle, socket, service_access_name, param);
+ if (*result == NET_NFC_OK) {
int ret_val;
ret_val = device_power_request_lock(POWER_LOCK_CPU, 20000);
_remove_socket_info(socket);
}
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_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, net_nfc_service_llcp_cb cb, void *user_param)
{
- bool ret = false;
net_nfc_llcp_param_t *param = NULL;
_net_nfc_util_alloc_mem(param, sizeof(*param));
param->cb = cb;
param->user_param = user_param;
- ret = hal_nfc_llcp_connect(handle, socket, service_access_point, result, param);
- if (ret == true) {
+ *result = hal_nfc_llcp_connect(handle, socket, service_access_point, param);
+ if (*result == NET_NFC_OK) {
int ret_val;
ret_val = device_power_request_lock(POWER_LOCK_CPU, 20000);
DEBUG_ERR_MSG("device_power_request_lock failed, [%d]", ret_val);
}
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
void net_nfc_controller_llcp_disconnected_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, void *data, void *user_param)
}
bool net_nfc_controller_llcp_disconnect(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_error_e * result, net_nfc_service_llcp_cb cb, void *user_param)
{
- bool ret = false;
int ret_val;
net_nfc_llcp_param_t *param = NULL;
param->cb = cb;
param->user_param = user_param;
- ret = hal_nfc_llcp_disconnect(handle, socket, result, param);
+ *result = hal_nfc_llcp_disconnect(handle, socket, param);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_llcp_socket_close(net_nfc_llcp_socket_t socket, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_llcp_socket_close(socket, result);
+ *result = hal_nfc_llcp_socket_close(socket);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
void net_nfc_controller_llcp_received_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, void *data, void *user_param)
bool net_nfc_controller_llcp_recv(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, uint32_t max_len, net_nfc_error_e * result, net_nfc_service_llcp_cb cb, void *user_param)
{
- bool ret = false;
net_nfc_llcp_param_t *param = NULL;
_net_nfc_util_alloc_mem(param, sizeof(*param));
param->user_param = user_param;
- ret = hal_nfc_llcp_recv(handle, socket, ¶m->data, result, param);
+ *result = hal_nfc_llcp_recv(handle, socket, ¶m->data, param);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
void net_nfc_controller_llcp_sent_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, void *data, void *user_param)
_net_nfc_util_free_mem(param);
}
-bool net_nfc_controller_llcp_send(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, net_nfc_error_e * result, net_nfc_service_llcp_cb cb, void *user_param)
+bool net_nfc_controller_llcp_send(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, net_nfc_error_e * result, net_nfc_service_llcp_cb cb, void *user_param)
{
- bool ret = false;
net_nfc_llcp_param_t *param = NULL;
_net_nfc_util_alloc_mem(param, sizeof(*param));
param->cb = cb;
param->user_param = user_param;
- ret = hal_nfc_llcp_send(handle, socket, data, result, param);
+ *result = hal_nfc_llcp_send(handle, socket, data, param);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_llcp_recv_from(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, uint32_t max_len, net_nfc_error_e * result, net_nfc_service_llcp_cb cb, void *user_param)
{
- bool ret = false;
net_nfc_llcp_param_t *param = NULL;
_net_nfc_util_alloc_mem(param, sizeof(*param));
}
param->user_param = user_param;
- ret = hal_nfc_llcp_recv_from(handle, socket, ¶m->data, result, param);
+ *result = hal_nfc_llcp_recv_from(handle, socket, ¶m->data, param);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
-bool net_nfc_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, net_nfc_service_llcp_cb cb, void *user_param)
+bool net_nfc_controller_llcp_send_to(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, uint8_t service_access_point, net_nfc_error_e * result, net_nfc_service_llcp_cb cb, void *user_param)
{
- bool ret = false;
net_nfc_llcp_param_t *param = NULL;
_net_nfc_util_alloc_mem(param, sizeof(*param));
param->cb = cb;
param->user_param = user_param;
- ret = hal_nfc_llcp_send_to(handle, socket, data, service_access_point, result, param);
+ *result = hal_nfc_llcp_send_to(handle, socket, data, service_access_point, param);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_llcp_get_remote_config(net_nfc_target_handle_s * handle, net_nfc_llcp_config_info_s * config, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_llcp_get_remote_config(handle, config, result);
+ *result = hal_nfc_llcp_get_remote_config(handle, config);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_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)
{
- bool ret = false;
-
- ret = hal_nfc_llcp_get_remote_socket_info(handle, socket, option, result);
-
- return ret;
-}
-
-bool net_nfc_controller_sim_test(net_nfc_error_e * result)
-{
- bool ret = false;
+ *result = hal_nfc_llcp_get_remote_socket_info(handle, socket, option);
- ret = hal_nfc_sim_test(result);
-
- return ret;
-}
-
-bool net_nfc_controller_prbs_test(net_nfc_error_e * result, uint32_t tech, uint32_t rate)
-{
- bool ret = false;
-
- ret = hal_nfc_prbs_test(result, tech, rate);
-
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_test_mode_on(net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_test_mode_on(result);
+ *result = hal_nfc_test_mode_on();
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_test_mode_off(net_nfc_error_e * result)
{
- bool ret = false;
+ *result = hal_nfc_test_mode_off();
- ret = hal_nfc_test_mode_off(result);
-
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
/* LCOV_EXCL_STOP */
bool net_nfc_controller_support_nfc(net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_support_nfc(result);
-
- return ret;
-}
-
-/* LCOV_EXCL_START */
-bool net_nfc_controller_eedata_register_set(net_nfc_error_e * result, uint32_t mode, uint32_t reg_id, data_s * data)
-{
- bool ret = false;
-
- ret = hal_nfc_eedata_register_set(result, mode, reg_id, data);
+ *result = hal_nfc_support_nfc();
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
-bool net_nfc_controller_ese_test(net_nfc_error_e * result)
+bool net_nfc_controller_hce_response_apdu(net_nfc_target_handle_s * handle, net_nfc_data_s * response, net_nfc_error_e * result)
{
- bool ret = false;
+ *result = hal_nfc_hce_response_apdu(handle, response);
- ret = hal_nfc_ese_test(result);
-
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
-bool net_nfc_controller_test_set_se_tech_type(net_nfc_error_e * result, net_nfc_se_type_e type, uint32_t tech)
+bool net_nfc_controller_secure_element_route_aid(net_nfc_data_s * aid, net_nfc_se_type_e se_type, int power, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_test_set_se_tech_type(result, type, tech);
+ *result = hal_nfc_secure_element_route_aid(aid, se_type, power);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
-bool net_nfc_controller_hce_response_apdu(net_nfc_target_handle_s * handle, data_s * response, net_nfc_error_e * result)
+bool net_nfc_controller_secure_element_unroute_aid(net_nfc_data_s * aid, net_nfc_error_e * result)
{
- bool ret = false;
+ *result = hal_nfc_secure_element_unroute_aid(aid);
- ret = hal_nfc_hce_response_apdu(handle, response, result);
-
- return ret;
-}
-
-bool net_nfc_controller_secure_element_route_aid(data_s * aid, net_nfc_se_type_e se_type, int power, net_nfc_error_e * result)
-{
- bool ret = false;
-
- ret = hal_nfc_secure_element_route_aid(aid, se_type, power, result);
-
- return ret;
-}
-
-bool net_nfc_controller_secure_element_unroute_aid(data_s * aid, net_nfc_error_e * result)
-{
- bool ret = false;
-
- ret = hal_nfc_secure_element_unroute_aid(aid, result);
-
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
/* LCOV_EXCL_STOP */
bool net_nfc_controller_secure_element_commit_routing(net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_secure_element_commit_routing(result);
+ *result = hal_nfc_secure_element_commit_routing();
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
/* LCOV_EXCL_START */
bool net_nfc_controller_secure_element_set_default_route(net_nfc_se_type_e switch_on, net_nfc_se_type_e switch_off, net_nfc_se_type_e battery_off, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_secure_element_set_default_route(switch_on, switch_off, battery_off, result);
+ *result = hal_nfc_secure_element_set_default_route(switch_on, switch_off, battery_off);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_secure_element_clear_aid_table(net_nfc_error_e * result)
{
- bool ret = false;
+ *result = hal_nfc_secure_element_clear_aid_table();
- ret = hal_nfc_secure_element_clear_aid_table(result);
-
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_secure_element_get_aid_table_size(int *AIDTableSize, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_secure_element_get_aid_table_size(AIDTableSize, result);
+ *result = hal_nfc_secure_element_get_aid_table_size(AIDTableSize);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
/* LCOV_EXCL_STOP */
bool net_nfc_controller_secure_element_set_route_entry(net_nfc_se_entry_type_e type, net_nfc_se_tech_protocol_type_e value, net_nfc_se_type_e route, int power, net_nfc_error_e * result)
{
- bool ret = false;
+ *result = hal_nfc_secure_element_set_route_entry(type, value, route, power);
- ret = hal_nfc_secure_element_set_route_entry(type, value, route, power, result);
-
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
bool net_nfc_controller_secure_element_clear_routing_entry(net_nfc_se_entry_type_e type, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_secure_element_clear_routing_entry(type, result);
+ *result = hal_nfc_secure_element_clear_routing_entry(type);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
-/* LCOV_EXCL_START*/
-bool net_nfc_controller_secure_element_set_listen_tech_mask(net_nfc_se_tech_protocol_type_e value, net_nfc_error_e * result)
-{
- bool ret = false;
-
- ret = hal_nfc_secure_element_set_listen_tech_mask(value, result);
-
- return ret;
-}
-/* LCOV_EXCL_STOP */
-
bool net_nfc_controller_set_screen_state(net_nfc_screen_state_type_e screen_state, net_nfc_error_e * result)
{
- bool ret = false;
-
- ret = hal_nfc_set_screen_state(screen_state, result);
+ *result = hal_nfc_set_screen_state(screen_state);
- return ret;
+ return (*result == NET_NFC_OK) ? true : false;
}
case NET_NFC_MESSAGE_SERVICE_LLCP_RECEIVE:
{
net_nfc_request_receive_socket_t *msg = (net_nfc_request_receive_socket_t *) user_data;
- data_s data = { msg->data.buffer, msg->data.length };
+ net_nfc_data_s data = { msg->data.buffer, msg->data.length };
net_nfc_controller_llcp_received_cb(msg->client_socket, msg->result, &data, (void *)req_msg->user_param);
}
case NET_NFC_MESSAGE_SERVICE_LLCP_RECEIVE_FROM:
{
net_nfc_request_receive_from_socket_t *msg = (net_nfc_request_receive_from_socket_t *) user_data;
- data_s data = { msg->data.buffer, msg->data.length };
+ net_nfc_data_s data = { msg->data.buffer, msg->data.length };
/* FIXME : pass sap */
net_nfc_controller_llcp_received_cb(msg->client_socket, msg->result, &data, (void *)req_msg->user_param);
return TRUE;
}
-net_nfc_error_e net_nfc_server_handover_emit_started_signal(net_nfc_target_handle_s * handle, data_s * message)
+net_nfc_error_e net_nfc_server_handover_emit_started_signal(net_nfc_target_handle_s * handle, net_nfc_data_s * message)
{
if (handover_skeleton == NULL)
return NET_NFC_INVALID_STATE;
return NET_NFC_OK;
}
-net_nfc_error_e net_nfc_server_handover_emit_finished_signal(net_nfc_error_e result, net_nfc_conn_handover_carrier_type_e type, data_s * address, data_s * message)
+net_nfc_error_e net_nfc_server_handover_emit_finished_signal(net_nfc_error_e result, net_nfc_conn_handover_carrier_type_e type, net_nfc_data_s * address, net_nfc_data_s * message)
{
if (handover_skeleton == NULL)
return NET_NFC_INVALID_STATE;
net_nfc_error_e result;
net_nfc_server_handover_process_carrier_cb cb;
net_nfc_ch_carrier_s *carrier;
- data_s data;
+ net_nfc_data_s data;
char remote_address[20];
bt_service_class_t service_mask;
void *user_param;
static net_nfc_error_e _bt_get_oob_data_from_config(net_nfc_carrier_config_s * config, net_nfc_handover_bt_oob_data_t * oob)
{
net_nfc_error_e result = NET_NFC_UNKNOWN_ERROR;
- data_s hash = { NULL, 0 };
- data_s randomizer = { NULL, 0 };
+ net_nfc_data_s hash = { NULL, 0 };
+ net_nfc_data_s randomizer = { NULL, 0 };
LOGD("[%s:%d] START", __func__, __LINE__);
case NET_NFC_LLCP_STEP_02:
{
net_nfc_carrier_config_s *config;
- data_s temp = { NULL, 0 };
+ net_nfc_data_s temp = { NULL, 0 };
INFO_MSG("STEP [2]");
case NET_NFC_LLCP_STEP_RETURN:
{
- data_s temp = { (uint8_t *) context->remote_address, (uint32_t) sizeof(context->remote_address) };
- data_s *data = NULL;
+ net_nfc_data_s temp = { (uint8_t *) context->remote_address, (uint32_t) sizeof(context->remote_address) };
+ net_nfc_data_s *data = NULL;
INFO_MSG("STEP return");
case NET_NFC_LLCP_STEP_02:
{
net_nfc_carrier_config_s *config;
- data_s temp = { NULL, 0 };
+ net_nfc_data_s temp = { NULL, 0 };
INFO_MSG("STEP [2]");
case NET_NFC_LLCP_STEP_RETURN:
{
- data_s temp = { (uint8_t *) context->remote_address, (uint32_t) sizeof(context->remote_address) };
- data_s *data = NULL;
+ net_nfc_data_s temp = { (uint8_t *) context->remote_address, (uint32_t) sizeof(context->remote_address) };
+ net_nfc_data_s *data = NULL;
INFO_MSG("STEP return");
net_nfc_error_e result;
net_nfc_ch_carrier_s *carrier = NULL;
ndef_record_s *record = NULL;
- data_s type = { (uint8_t *) CH_CAR_RECORD_TYPE, CH_CAR_RECORD_TYPE_LEN };
+ net_nfc_data_s type = { (uint8_t *) CH_CAR_RECORD_TYPE, CH_CAR_RECORD_TYPE_LEN };
uint8_t buffer[sizeof(ch_hc_record_t) + CH_WIFI_WPS_MIME_LEN];
- data_s payload = { buffer, sizeof(buffer) };
+ net_nfc_data_s payload = { buffer, sizeof(buffer) };
ch_hc_record_t *hc_buffer = (ch_hc_record_t *) buffer;
hc_buffer->ctf = NET_NFC_RECORD_MIME_TYPE;
{
if (context != NULL) {
if (context->cb != NULL) {
- data_s *data = NULL;
- data_s temp;
+ net_nfc_data_s *data = NULL;
+ net_nfc_data_s temp;
if (result == NET_NFC_OK) {
char *mac;
static char *selected_aid;
//static uint8_t android_hce_aid_buffer[] = { 0xA0, 0x00, 0x00, 0x04, 0x76, 0x41, 0x6E, 0x64, 0x72, 0x6F, 0x69, 0x64, 0x48, 0x43, 0x45 };
-//static data_s android_hce_aid = { android_hce_aid_buffer, sizeof(android_hce_aid_buffer) };
+//static net_nfc_data_s android_hce_aid = { android_hce_aid_buffer, sizeof(android_hce_aid_buffer) };
typedef struct _hce_listener_t {
char *id;
struct _ServerHceData {
net_nfc_target_handle_s *handle;
guint event;
- data_s apdu;
+ net_nfc_data_s apdu;
};
typedef struct _HceDataApdu HceDataApdu;
return NET_NFC_OK;
}
-net_nfc_error_e net_nfc_server_hce_send_apdu_response(net_nfc_target_handle_s * handle, data_s * response)
+net_nfc_error_e net_nfc_server_hce_send_apdu_response(net_nfc_target_handle_s * handle, net_nfc_data_s * response)
{
net_nfc_error_e result = NET_NFC_OK;
////////////////////////////////////////////////////////////////////////////////
#if 0
-static void _emit_event_received_signal(GDBusConnection * connection, const char *id, int event, net_nfc_target_handle_h handle, data_s * data)
+static void _emit_event_received_signal(GDBusConnection * connection, const char *id, int event, net_nfc_target_handle_h handle, net_nfc_data_s * data)
{
GVariant *arg_data;
GError *error = NULL;
}
}
-static void _hce_default_listener_cb(net_nfc_target_handle_s * handle, int event, data_s * data, void *user_data)
+static void _hce_default_listener_cb(net_nfc_target_handle_s * handle, int event, net_nfc_data_s * data, void *user_data)
{
hce_client_context_s *context = (hce_client_context_s *) user_data;
#else
/* LCOV_EXCL_START */
-static void _hce_default_listener_cb(net_nfc_target_handle_s * handle, int event, data_s * data, void *user_data)
+static void _hce_default_listener_cb(net_nfc_target_handle_s * handle, int event, net_nfc_data_s * data, void *user_data)
{
hce_client_context_s *context = (hce_client_context_s *) user_data;
static void hce_response_apdu_thread_func(gpointer user_data)
{
HceDataApdu *detail = (HceDataApdu *) user_data;
- data_s apdu_data = { NULL, 0 };
+ net_nfc_data_s apdu_data = { NULL, 0 };
net_nfc_error_e result = NET_NFC_OK;
g_assert(detail != NULL);
DEBUG_SERVER_MSG(">>> hce_response_apdu_thread_func!!");
- net_nfc_util_gdbus_variant_to_data_s(detail->data, &apdu_data);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(detail->data, &apdu_data);
result = net_nfc_server_hce_send_apdu_response(detail->handle, &apdu_data);
static void __hce_handle_send_apdu_response_thread_func(gpointer user_data)
{
HceDataApdu *detail = (HceDataApdu *) user_data;
- data_s *response;
+ net_nfc_data_s *response;
g_assert(detail != NULL);
g_assert(detail->data != NULL);
DEBUG_SERVER_MSG(">>> __hce_handle_send_apdu_response_thread_func!!");
- response = (data_s *) detail->data;
+ response = (net_nfc_data_s *) detail->data;
net_nfc_server_hce_send_apdu_response(detail->handle, response);
g_free(detail);
}
-void net_nfc_server_hce_handle_send_apdu_response(net_nfc_target_handle_s * handle, data_s * response)
+void net_nfc_server_hce_handle_send_apdu_response(net_nfc_target_handle_s * handle, net_nfc_data_s * response)
{
HceDataApdu *data;
ERROR:
if (data != NULL) {
- net_nfc_util_free_data((data_s *) data->data); /* caution : invalid type casting */
+ net_nfc_util_free_data((net_nfc_data_s *) data->data); /* caution : invalid type casting */
g_free(data);
}
return true;
}
-static bool __pre_process_apdu(net_nfc_target_handle_s * handle, data_s * cmd)
+static bool __pre_process_apdu(net_nfc_target_handle_s * handle, net_nfc_data_s * cmd)
{
apdu_header_t *apdu = (apdu_header_t *) cmd->buffer;
uint16_t lc, le;
/* send response */
uint8_t temp[] = { 0x69, 0x00 };
- data_s resp = { temp, sizeof(temp) };
+ net_nfc_data_s resp = { temp, sizeof(temp) };
net_nfc_server_hce_send_apdu_response(handle, &resp);
if (lc > 2) {
char aid[1024];
route_table_handler_t *listener;
- data_s temp = { data, lc };
+ net_nfc_data_s temp = { data, lc };
net_nfc_util_binary_to_hex_string(&temp, aid, sizeof(aid));
/* send response */
uint8_t temp[] = { 0x6A, 0x82 };
- data_s resp = { temp, sizeof(temp) };
+ net_nfc_data_s resp = { temp, sizeof(temp) };
net_nfc_server_hce_send_apdu_response(handle, &resp);
/* send response */
uint8_t temp[] = { 0x6B, 0x00 };
- data_s resp = { temp, sizeof(temp) };
+ net_nfc_data_s resp = { temp, sizeof(temp) };
net_nfc_server_hce_send_apdu_response(handle, &resp);
/* send response */
uint8_t temp[] = { 0x67, 0x00 };
- data_s resp = { temp, sizeof(temp) };
+ net_nfc_data_s resp = { temp, sizeof(temp) };
net_nfc_server_hce_send_apdu_response(handle, &resp);
char aid[1024];
int ret;
uid_t uid = 0;
- data_s temp_aid = { aid_data, lc };
+ net_nfc_data_s temp_aid = { aid_data, lc };
bd = bundle_create();
net_nfc_util_binary_to_hex_string(&temp_aid, aid, sizeof(aid));
}
} else {
uint8_t temp[] = { 0x69, 0x00 };
- data_s resp = { temp, sizeof(temp) };
+ net_nfc_data_s resp = { temp, sizeof(temp) };
DEBUG_ERR_MSG("?????");
}
} else {
uint8_t temp[] = { 0x69, 0x00 };
- data_s resp = { temp, sizeof(temp) };
+ net_nfc_data_s resp = { temp, sizeof(temp) };
DEBUG_ERR_MSG("no aid selected");
if (hce_apdu->request_type == NET_NFC_MESSAGE_ROUTING_HOST_EMU_DATA) {
uint8_t temp[] = { 0x69, 0x00 };
- data_s resp = { temp, sizeof(temp) };
+ net_nfc_data_s resp = { temp, sizeof(temp) };
net_nfc_server_hce_send_apdu_response(handle, &resp);
}
if (hce_apdu->request_type == NET_NFC_MESSAGE_ROUTING_HOST_EMU_DATA) {
uint8_t temp[] = { 0x69, 0x00 };
- data_s resp = { temp, sizeof(temp) };
+ net_nfc_data_s resp = { temp, sizeof(temp) };
net_nfc_server_hce_send_apdu_response(handle, &resp);
}
/******************************************************************************/
-static bool __receive_data_from_client(int socket, data_s * data)
+static bool __receive_data_from_client(int socket, net_nfc_data_s * data)
{
bool result;
ssize_t ret;
static bool __process_client_message(GIOChannel * channel)
{
bool result;
- data_s data = { NULL, 0 };
+ net_nfc_data_s data = { NULL, 0 };
net_nfc_hce_client_t *client;
client = __hce_client_find(channel);
if (client != NULL) {
if (__receive_data_from_client(client->socket, &data) == true) {
net_nfc_hce_data_t *header;
- data_s temp;
+ net_nfc_data_s temp;
header = (net_nfc_hce_data_t *) data.buffer;
}
/* LCOV_EXCL_START */
-static bool __send_data_to_client(int socket, data_s * data)
+static bool __send_data_to_client(int socket, net_nfc_data_s * data)
{
ssize_t ret;
return true;
}
-bool net_nfc_server_hce_send_to_client(const char *id, int type, net_nfc_target_handle_s * handle, data_s * data)
+bool net_nfc_server_hce_send_to_client(const char *id, int type, net_nfc_target_handle_s * handle, net_nfc_data_s * data)
{
bool ret;
net_nfc_hce_client_t *client;
- data_s temp = { NULL, 0 };
+ net_nfc_data_s temp = { NULL, 0 };
uint32_t len = sizeof(net_nfc_hce_data_t);
client = __hce_client_find_by_id(id);
return ret;
}
-bool net_nfc_server_hce_send_to_all_client(int type, net_nfc_target_handle_s * handle, data_s * data)
+bool net_nfc_server_hce_send_to_all_client(int type, net_nfc_target_handle_s * handle, net_nfc_data_s * data)
{
bool ret;
- data_s temp = { NULL, 0 };
+ net_nfc_data_s temp = { NULL, 0 };
uint32_t len = sizeof(net_nfc_hce_data_t);
if (data != NULL && data->length > 0)
guint32 handle;
guint32 client_socket;
- data_s data;
+ net_nfc_data_s data;
};
typedef struct _LlcpSendToData LlcpSendToData;
guint32 client_socket;
guint8 sap;
- data_s data;
+ net_nfc_data_s data;
};
typedef struct _LlcpReceiveData LlcpReceiveData;
gpointer user_data;
};
-static void llcp_socket_error_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param);
+static void llcp_socket_error_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param);
-static void llcp_incoming_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param);
+static void llcp_incoming_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param);
-static void llcp_connect_by_url_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param);
+static void llcp_connect_by_url_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param);
-static void llcp_connect_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param);
+static void llcp_connect_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param);
-static void llcp_send_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param);
+static void llcp_send_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param);
-static void llcp_send_to_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param);
+static void llcp_send_to_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param);
-static void llcp_receive_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param);
+static void llcp_receive_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param);
-static void llcp_receive_from_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param);
+static void llcp_receive_from_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param);
-static void llcp_disconnect_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param);
+static void llcp_disconnect_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param);
/* client method */
static void llcp_handle_config_thread_func(gpointer user_data);
static gboolean llcp_handle_disconnect(NetNfcGDbusLlcp * llcp, GDBusMethodInvocation * invocation, guint32 arg_handle, guint32 arg_client_socket, GVariant * smack_privilege, gpointer user_data);
/* simple */
-static void llcp_simple_socket_error_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param);
+static void llcp_simple_socket_error_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param);
-static void llcp_simple_listen_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param);
+static void llcp_simple_listen_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param);
-static void llcp_simple_connect_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param);
+static void llcp_simple_connect_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param);
-static void llcp_simple_send_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param);
+static void llcp_simple_send_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param);
-static void llcp_simple_receive_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param);
+static void llcp_simple_receive_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param);
/* LCOV_EXCL_START */
-static void llcp_socket_error_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param)
+static void llcp_socket_error_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param)
{
llcp_client_data *client_data = (llcp_client_data *) user_param;
GError *error = NULL;
}
}
-static void llcp_incoming_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param)
+static void llcp_incoming_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param)
{
llcp_client_data *client_data = (llcp_client_data *) user_param;
GError *error = NULL;
}
}
-static void llcp_connect_by_url_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param)
+static void llcp_connect_by_url_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param)
{
LlcpConnectData *llcp_data = (LlcpConnectData *) user_param;
g_free(llcp_data);
}
-static void llcp_connect_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param)
+static void llcp_connect_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param)
{
LlcpConnectSapData *llcp_data = (LlcpConnectSapData *) user_param;
g_free(llcp_data);
}
-static void llcp_send_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param)
+static void llcp_send_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param)
{
LlcpSendData *llcp_data = (LlcpSendData *) user_param;
g_free(llcp_data);
}
-static void llcp_send_to_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param)
+static void llcp_send_to_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param)
{
LlcpSendToData *llcp_data = (LlcpSendToData *) user_param;
g_free(llcp_data);
}
-static void llcp_receive_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param)
+static void llcp_receive_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param)
{
LlcpReceiveData *llcp_data = (LlcpReceiveData *) user_param;
GVariant *variant;
g_free(llcp_data);
}
-static void llcp_receive_from_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param)
+static void llcp_receive_from_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param)
{
LlcpReceiveData *llcp_data = (LlcpReceiveData *) user_param;
GVariant *variant;
g_free(llcp_data);
}
-static void llcp_disconnect_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param)
+static void llcp_disconnect_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param)
{
LlcpDisconnectData *llcp_data = (LlcpDisconnectData *) user_param;
data->handle = arg_handle;
data->client_socket = arg_client_socket;
- net_nfc_util_gdbus_variant_to_data_s(arg_data, &data->data);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(arg_data, &data->data);
if (net_nfc_server_controller_async_queue_push(llcp_handle_send_thread_func, data) == FALSE) {
/* return error if queue was blocked */
data->client_socket = arg_client_socket;
data->sap = arg_sap;
- net_nfc_util_gdbus_variant_to_data_s(arg_data, &data->data);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(arg_data, &data->data);
if (net_nfc_server_controller_async_queue_push(llcp_handle_send_to_thread_func, data) == FALSE) {
/* return error if queue was blocked */
}
}
-static void llcp_simple_socket_error_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param)
+static void llcp_simple_socket_error_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param)
{
LlcpSimpleData *simple_data = (LlcpSimpleData *) user_param;
simple_data = NULL;
}
-static void llcp_simple_listen_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param)
+static void llcp_simple_listen_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param)
{
LlcpSimpleData *simple_data = (LlcpSimpleData *) user_param;
/* 'simple_data' will be freed in socket error callback */
}
-static void llcp_simple_connect_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param)
+static void llcp_simple_connect_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param)
{
LlcpSimpleData *simple_data = (LlcpSimpleData *) user_param;
/* 'simple_data' will be freed in socket error callback */
}
-static void llcp_simple_send_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param)
+static void llcp_simple_send_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param)
{
LlcpSimpleData *simple_data = (LlcpSimpleData *) user_param;
g_free(simple_data);
}
-static void llcp_simple_receive_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param)
+static void llcp_simple_receive_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param)
{
LlcpSimpleData *simple_data = (LlcpSimpleData *) user_param;
return result;
}
-net_nfc_error_e net_nfc_server_llcp_simple_send(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, net_nfc_server_llcp_callback callback, gpointer user_data)
+net_nfc_error_e net_nfc_server_llcp_simple_send(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, net_nfc_server_llcp_callback callback, gpointer user_data)
{
net_nfc_error_e result;
LlcpSimpleData *simple_data;
NetNfcGDbusNdef *ndef;
GDBusMethodInvocation *invocation;
guint32 handle;
- data_s data;
+ net_nfc_data_s data;
};
typedef struct _MakeReadOnlyData MakeReadOnlyData;
NetNfcGDbusNdef *ndef;
GDBusMethodInvocation *invocation;
guint32 handle;
- data_s key;
+ net_nfc_data_s key;
};
static NetNfcGDbusNdef *ndef_skeleton = NULL;
net_nfc_target_handle_s *handle;
net_nfc_error_e result;
- data_s *read_data = NULL;
+ net_nfc_data_s *read_data = NULL;
GVariant *data_variant;
g_assert(data != NULL);
data->invocation = g_object_ref(invocation);
data->handle = arg_handle;
- net_nfc_util_gdbus_variant_to_data_s(arg_data, &data->data);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(arg_data, &data->data);
if (net_nfc_server_controller_async_queue_push(ndef_write_thread_func, data) == FALSE) {
/* return error if queue was blocked */
data->ndef = g_object_ref(ndef);
data->invocation = g_object_ref(invocation);
data->handle = arg_handle;
- net_nfc_util_gdbus_variant_to_data_s(arg_key, &data->key);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(arg_key, &data->key);
if (net_nfc_server_controller_async_queue_push(ndef_format_thread_func, data) == FALSE) {
/* return error if queue was blocked */
GDBusMethodInvocation *invocation;
gint32 type;
guint32 p2p_handle;
- data_s data;
+ net_nfc_data_s data;
};
static void p2p_send_data_thread_func(gpointer user_data);
data->invocation = g_object_ref(invocation);
data->type = arg_type;
data->p2p_handle = handle;
- net_nfc_util_gdbus_variant_to_data_s(arg_data, &data->data);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(arg_data, &data->data);
if (net_nfc_server_controller_async_queue_push(p2p_send_data_thread_func, data) == FALSE) {
/* return error if queue was blocked */
return;
}
- arg_data = net_nfc_util_gdbus_data_to_variant((data_s *) user_data);
+ arg_data = net_nfc_util_gdbus_data_to_variant((net_nfc_data_s *) user_data);
net_nfc_gdbus_p2p_emit_received(p2p_skeleton, arg_data);
net_nfc_manager_util_play_sound(NET_NFC_TASK_END);
}
-void net_nfc_server_p2p_data_sent(net_nfc_error_e result, gpointer user_data)
+void net_nfc_server_p2p_net_nfc_data_sent(net_nfc_error_e result, gpointer user_data)
{
P2pSendData *data = (P2pSendData *) user_data;
net_nfc_llcp_socket_t socket;
uint32_t state;
net_nfc_conn_handover_carrier_type_e type;
- data_s data;
+ net_nfc_data_s data;
net_nfc_ch_carrier_s *carrier;
void *user_param;
} net_nfc_handover_context_t;
static void _client_process(net_nfc_handover_context_t * context);
-static void _client_error_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, void *user_param);
+static void _client_error_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, void *user_param);
-static void _client_connected_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, void *user_param);
+static void _client_connected_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, void *user_param);
static void _get_response_process(net_nfc_handover_context_t * context);
static int _net_nfc_server_handover_append_wifi_carrier_config(_create_config_context_t * context);
#endif
-static net_nfc_error_e _create_requester_from_rawdata(ndef_message_s ** requestor, data_s * data);
+static net_nfc_error_e _create_requester_from_rawdata(ndef_message_s ** requestor, net_nfc_data_s * data);
static net_nfc_error_e _create_requester_handover_message(net_nfc_conn_handover_carrier_type_e type, _create_ch_msg_cb cb, void *user_param);
g_free(handover_data);
}
-static net_nfc_error_e _convert_ndef_message_to_data(ndef_message_s * msg, data_s * data)
+static net_nfc_error_e _convert_ndef_message_to_data(ndef_message_s * msg, net_nfc_data_s * data)
{
net_nfc_error_e result;
uint32_t length;
/* don't free context */
}
-static void _bt_process_carrier_cb(net_nfc_error_e result, net_nfc_conn_handover_carrier_type_e type, data_s * data, void *user_param)
+static void _bt_process_carrier_cb(net_nfc_error_e result, net_nfc_conn_handover_carrier_type_e type, net_nfc_data_s * data, void *user_param)
{
_process_config_context_t *context = (_process_config_context_t *) user_param;
_net_nfc_util_free_mem(context);
}
-static void _wps_process_carrier_cb(net_nfc_error_e result, net_nfc_conn_handover_carrier_type_e type, data_s * data, void *user_param)
+static void _wps_process_carrier_cb(net_nfc_error_e result, net_nfc_conn_handover_carrier_type_e type, net_nfc_data_s * data, void *user_param)
{
_process_config_context_t *context = (_process_config_context_t *) user_param;
_net_nfc_util_free_mem(context);
}
-static void _wfd_process_carrier_cb(net_nfc_error_e result, net_nfc_conn_handover_carrier_type_e type, data_s * data, void *user_param)
+static void _wfd_process_carrier_cb(net_nfc_error_e result, net_nfc_conn_handover_carrier_type_e type, net_nfc_data_s * data, void *user_param)
{
_process_config_context_t *context = (_process_config_context_t *) user_param;
return result;
}
-static net_nfc_error_e _create_requester_from_rawdata(ndef_message_s ** requestor, data_s * data)
+static net_nfc_error_e _create_requester_from_rawdata(ndef_message_s ** requestor, net_nfc_data_s * data)
{
net_nfc_error_e result;
ndef_message_s *temp = NULL;
return result;
}
-static net_nfc_error_e _create_selector_from_rawdata(ndef_message_s ** selector, data_s * data)
+static net_nfc_error_e _create_selector_from_rawdata(ndef_message_s ** selector, net_nfc_data_s * data)
{
net_nfc_error_e result;
ndef_message_s *temp = NULL;
/* LCOV_EXCL_STOP */
#if 0
-static net_nfc_error_e _net_nfc_server_handover_snep_client_cb(net_nfc_snep_handle_h handle, net_nfc_error_e result, uint32_t type, data_s * data, void *user_param)
+static net_nfc_error_e _net_nfc_server_handover_snep_client_cb(net_nfc_snep_handle_h handle, net_nfc_error_e result, uint32_t type, net_nfc_data_s * data, void *user_param)
{
_net_nfc_server_handover_client_context_t *context = (_net_nfc_server_handover_client_context_t *) user_param;
static void _net_nfc_server_handover_create_requester_carrier_configs_cb(net_nfc_error_e result, ndef_message_s * msg, void *user_param)
{
_net_nfc_server_handover_client_context_t *context = (_net_nfc_server_handover_client_context_t *) user_param;
- data_s data;
+ net_nfc_data_s data;
if (context == NULL)
return;
static void _net_nfc_server_handover_server_create_carrier_configs_cb(net_nfc_error_e result, ndef_message_s * selector, void *user_param)
{
_net_nfc_server_handover_create_config_context_t *context = (_net_nfc_server_handover_create_config_context_t *) user_param;
- data_s data;
+ net_nfc_data_s data;
if (context == NULL)
return;
return result;
}
-static net_nfc_error_e _net_nfc_server_handover_create_server_cb(net_nfc_snep_handle_h handle, net_nfc_error_e result, uint32_t type, data_s * data, void *user_param)
+static net_nfc_error_e _net_nfc_server_handover_create_server_cb(net_nfc_snep_handle_h handle, net_nfc_error_e result, uint32_t type, net_nfc_data_s * data, void *user_param)
{
DEBUG_SERVER_MSG("type [0x%02x], result [%d], data [%p], user_param [%p]", type, result, data, user_param);
_get_response_process(context);
}
-static void _process_carrier_record_2_cb(net_nfc_error_e result, net_nfc_conn_handover_carrier_type_e type, data_s * data, void *user_param)
+static void _process_carrier_record_2_cb(net_nfc_error_e result, net_nfc_conn_handover_carrier_type_e type, net_nfc_data_s * data, void *user_param)
{
net_nfc_handover_context_t *context = (net_nfc_handover_context_t *) user_param;
}
}
-static bool _get_response_cb(net_nfc_snep_handle_h handle, uint32_t type, uint32_t max_len, data_s * data, void *user_param)
+static bool _get_response_cb(net_nfc_snep_handle_h handle, uint32_t type, uint32_t max_len, net_nfc_data_s * data, void *user_param)
{
net_nfc_error_e result;
ndef_message_s *request;
}
////////////////////////////////////////////////////////////////////////////////
-static void _server_process_carrier_record_cb(net_nfc_error_e result, net_nfc_conn_handover_carrier_type_e type, data_s * data, void *user_param)
+static void _server_process_carrier_record_cb(net_nfc_error_e result, net_nfc_conn_handover_carrier_type_e type, net_nfc_data_s * data, void *user_param)
{
net_nfc_handover_context_t *context = (net_nfc_handover_context_t *) user_param;
_server_process(context);
}
-static void _handover_server_recv_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, void *user_param)
+static void _handover_server_recv_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, void *user_param)
{
net_nfc_handover_context_t *context = (net_nfc_handover_context_t *) user_param;
ndef_message_s *request;
_server_process(context);
}
-static void _server_send_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, void *user_param)
+static void _server_send_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, void *user_param)
{
net_nfc_handover_context_t *context = (net_nfc_handover_context_t *) user_param;
}
}
-static void _server_error_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, void *user_param)
+static void _server_error_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, void *user_param)
{
net_nfc_handover_context_t *context = (net_nfc_handover_context_t *) user_param;
_net_nfc_util_free_mem(user_param);
}
-static void _server_incomming_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, void *user_param)
+static void _server_incomming_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, void *user_param)
{
DEBUG_SERVER_MSG("result [%d], socket [%x], user_param [%p]", result, socket, user_param);
}
////////////////////////////////////////////////////////////////////////////////
-static void _client_process_carrier_record_cb(net_nfc_error_e result, net_nfc_conn_handover_carrier_type_e type, data_s * data, void *user_param)
+static void _client_process_carrier_record_cb(net_nfc_error_e result, net_nfc_conn_handover_carrier_type_e type, net_nfc_data_s * data, void *user_param)
{
net_nfc_handover_context_t *context = (net_nfc_handover_context_t *) user_param;
_client_process(context);
}
-static void _client_recv_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, void *user_param)
+static void _client_recv_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, void *user_param)
{
net_nfc_handover_context_t *context = (net_nfc_handover_context_t *) user_param;
_client_process(context);
}
-static void _client_send_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, void *user_param)
+static void _client_send_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, void *user_param)
{
net_nfc_handover_context_t *context = (net_nfc_handover_context_t *) user_param;
}
}
-static void _client_connected_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, void *user_param)
+static void _client_connected_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, void *user_param)
{
DEBUG_SERVER_MSG("result [%d], socket [%x], user_param [%p]", result, socket, user_param);
}
}
-static void _client_error_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, void *user_param)
+static void _client_error_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, void *user_param)
{
DEBUG_ERR_MSG("result [%d], socket [%x], user_param [%p]", result, socket, user_param);
net_nfc_llcp_socket_t socket;
uint32_t type;
size_t miu;
- data_s data;
+ net_nfc_data_s data;
size_t data_offset;
net_nfc_server_npp_callback callback;
gpointer user_data;
#define NPP_NDEF_ENTRY 0x00000001
#define NPP_ACTION_CODE 0x01
-static net_nfc_error_e npp_create_message(data_s * data, data_s * message);
+static net_nfc_error_e npp_create_message(net_nfc_data_s * data, net_nfc_data_s * message);
/* server */
-static void npp_server_receive_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, gpointer user_data);
+static void npp_server_receive_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, gpointer user_data);
static void npp_server_process(NppData * npp_data);
-static void npp_listen_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, gpointer user_data);
+static void npp_listen_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, gpointer user_data);
/* client */
-static void npp_client_send_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, gpointer user_data);
+static void npp_client_send_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, gpointer user_data);
static void npp_client_process(NppData * npp_data);
-static void npp_connected_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, gpointer user_data);
+static void npp_connected_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, gpointer user_data);
-static void npp_socket_error_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, gpointer user_data);
+static void npp_socket_error_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, gpointer user_data);
-static void npp_default_server_cb(net_nfc_error_e result, data_s * data, gpointer user_data);
+static void npp_default_server_cb(net_nfc_error_e result, net_nfc_data_s * data, gpointer user_data);
-static void npp_default_client_cb(net_nfc_error_e result, data_s * data, gpointer user_data);
+static void npp_default_client_cb(net_nfc_error_e result, net_nfc_data_s * data, gpointer user_data);
/* LCOV_EXCL_START */
-static net_nfc_error_e npp_create_message(data_s * data, data_s * message)
+static net_nfc_error_e npp_create_message(net_nfc_data_s * data, net_nfc_data_s * message)
{
size_t length = NPP_HEADER_LEN;
net_nfc_npp_msg_t *msg;
return NET_NFC_OK;
}
-static void __npp_server_received_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, gpointer user_data)
+static void __npp_server_received_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, gpointer user_data)
{
NppData *npp_data = (NppData *) user_data;
size_t length;
}
}
-static void npp_server_receive_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, gpointer user_data)
+static void npp_server_receive_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, gpointer user_data)
{
NppData *npp_data = (NppData *) user_data;
DEBUG_SERVER_MSG("action code [0x%02x], length [%zd]", entry->op, length);
if (length > 0) {
- data_s temp;
+ net_nfc_data_s temp;
/* buffer create */
net_nfc_util_init_data(&npp_data->data, length);
}
}
-static void npp_listen_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, gpointer user_data)
+static void npp_listen_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, gpointer user_data)
{
NppData *npp_data = (NppData *) user_data;
NppData *accept_data = NULL;
g_free(accept_data);
}
-static void npp_client_send_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, gpointer user_data)
+static void npp_client_send_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, gpointer user_data)
{
NppData *npp_data = (NppData *) user_data;
static void npp_client_process(NppData * npp_data)
{
net_nfc_error_e result;
- data_s data;
+ net_nfc_data_s data;
size_t length;
if (npp_data == NULL)
npp_data->callback(result, NULL, npp_data->user_data);
}
-static void npp_connected_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, gpointer user_data)
+static void npp_connected_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, gpointer user_data)
{
NppData *npp_data = (NppData *) user_data;
}
}
-static void npp_socket_error_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, gpointer user_data)
+static void npp_socket_error_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, gpointer user_data)
{
NppData *npp_data;
g_free(npp_data);
}
-static void npp_default_server_cb(net_nfc_error_e result, data_s * data, gpointer user_data)
+static void npp_default_server_cb(net_nfc_error_e result, net_nfc_data_s * data, gpointer user_data)
{
DEBUG_SERVER_MSG("result [%d], data [%p], user_data [%p]", result, data, user_data);
net_nfc_app_util_process_ndef(data);
}
-static void npp_default_client_cb(net_nfc_error_e result, data_s * data, gpointer user_data)
+static void npp_default_client_cb(net_nfc_error_e result, net_nfc_data_s * data, gpointer user_data)
{
NppClientStartData *npp_client_data;
npp_client_data = (NppClientStartData *) user_data;
- net_nfc_server_p2p_data_sent(result, npp_client_data->user_data);
+ net_nfc_server_p2p_net_nfc_data_sent(result, npp_client_data->user_data);
g_free(npp_client_data);
}
return result;
}
-net_nfc_error_e net_nfc_server_npp_client(net_nfc_target_handle_s * handle, char *san, sap_t sap, data_s * data, net_nfc_server_npp_callback callback, gpointer user_data)
+net_nfc_error_e net_nfc_server_npp_client(net_nfc_target_handle_s * handle, char *san, sap_t sap, net_nfc_data_s * data, net_nfc_server_npp_callback callback, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;;
NppData *npp_data;
return net_nfc_server_llcp_unregister_service(id, NPP_SAP, NPP_SAN);
}
-net_nfc_error_e net_nfc_server_npp_default_client_start(net_nfc_target_handle_s * handle, data_s * data, int client, gpointer user_data)
+net_nfc_error_e net_nfc_server_npp_default_client_start(net_nfc_target_handle_s * handle, net_nfc_data_s * data, int client, gpointer user_data)
{
NppClientStartData *npp_client_data;
net_nfc_error_e result;
net_nfc_llcp_socket_t socket;
uint32_t state;
uint32_t type;
- data_s data;
+ net_nfc_data_s data;
net_nfc_server_snep_cb cb;
void *user_param;
GQueue queue;
net_nfc_llcp_socket_t socket;
uint32_t state;
uint32_t type;
- data_s data;
+ net_nfc_data_s data;
net_nfc_server_snep_cb cb;
void *user_param;
} net_nfc_server_snep_job_t;
net_nfc_target_handle_s *handle;
int client;
uint32_t type;
- data_s data;
+ net_nfc_data_s data;
void *user_param;
} _net_nfc_server_snep_service_context_t;
-typedef void (*_net_nfc_server_snep_operation_cb) (net_nfc_error_e result, uint32_t type, data_s * data, void *user_param);
+typedef void (*_net_nfc_server_snep_operation_cb) (net_nfc_error_e result, uint32_t type, net_nfc_data_s * data, void *user_param);
typedef struct _net_nfc_server_snep_op_context_t {
net_nfc_target_handle_s *handle;
uint32_t type;
uint32_t current;
uint16_t miu;
- data_s data;
+ net_nfc_data_s data;
uint32_t offset;
_net_nfc_server_snep_operation_cb cb;
void *user_param;
static net_nfc_error_e net_nfc_server_snep_recv(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, _net_nfc_server_snep_operation_cb cb, void *user_param);
-static net_nfc_error_e net_nfc_server_snep_send(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, uint32_t type, data_s * data, _net_nfc_server_snep_operation_cb cb, void *user_param);
+static net_nfc_error_e net_nfc_server_snep_send(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, uint32_t type, net_nfc_data_s * data, _net_nfc_server_snep_operation_cb cb, void *user_param);
static void _net_nfc_server_snep_client_process(net_nfc_server_snep_job_t * job);
list_listen_cb = g_list_delete_link(list_listen_cb, list);
}
-static bool _net_nfc_server_snep_process_get_response_cb(net_nfc_target_handle_s * handle, data_s * data, uint32_t max_len)
+static bool _net_nfc_server_snep_process_get_response_cb(net_nfc_target_handle_s * handle, net_nfc_data_s * data, uint32_t max_len)
{
GList *list = list_listen_cb;
return false;
}
-static net_nfc_server_snep_op_context_t *_net_nfc_server_snep_create_send_context(uint32_t type, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, void *cb, void *user_param)
+static net_nfc_server_snep_op_context_t *_net_nfc_server_snep_create_send_context(uint32_t type, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, void *cb, void *user_param)
{
net_nfc_server_snep_op_context_t *context = NULL;
uint32_t data_len = 0;
}
}
-static void _net_nfc_server_recv_fragment_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param)
+static void _net_nfc_server_recv_fragment_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param)
{
net_nfc_server_snep_op_context_t *context = (net_nfc_server_snep_op_context_t *) user_param;
uint8_t *buffer;
}
}
-void _net_nfc_server_snep_recv_send_cb(net_nfc_error_e result, uint32_t type, data_s * data, void *user_param)
+void _net_nfc_server_snep_recv_send_cb(net_nfc_error_e result, uint32_t type, net_nfc_data_s * data, void *user_param)
{
net_nfc_server_snep_op_context_t *context = (net_nfc_server_snep_op_context_t *) user_param;
_net_nfc_server_snep_recv(context);
}
-void _net_nfc_server_snep_recv_send_reject_cb(net_nfc_error_e result, uint32_t type, data_s * data, void *user_param)
+void _net_nfc_server_snep_recv_send_reject_cb(net_nfc_error_e result, uint32_t type, net_nfc_data_s * data, void *user_param)
{
net_nfc_server_snep_op_context_t *context = (net_nfc_server_snep_op_context_t *) user_param;
return result;
}
-static void _net_nfc_server_send_fragment_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, data_s * data, void *extra, void *user_param)
+static void _net_nfc_server_send_fragment_cb(net_nfc_llcp_socket_t socket, net_nfc_error_e result, net_nfc_data_s * data, void *extra, void *user_param)
{
net_nfc_server_snep_op_context_t *context = (net_nfc_server_snep_op_context_t *) user_param;
static void _net_nfc_server_send_fragment(net_nfc_server_snep_op_context_t * context)
{
- data_s req_msg;
+ net_nfc_data_s req_msg;
uint32_t remain_len;
net_nfc_error_e result;
}
}
-void _net_nfc_server_snep_send_recv_cb(net_nfc_error_e result, uint32_t type, data_s * data, void *user_param)
+void _net_nfc_server_snep_send_recv_cb(net_nfc_error_e result, uint32_t type, net_nfc_data_s * data, void *user_param)
{
net_nfc_server_snep_op_context_t *context = (net_nfc_server_snep_op_context_t *) user_param;
}
}
-net_nfc_error_e net_nfc_server_snep_send(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, uint32_t type, data_s * data, _net_nfc_server_snep_operation_cb cb, void *user_param)
+net_nfc_error_e net_nfc_server_snep_send(net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, uint32_t type, net_nfc_data_s * data, _net_nfc_server_snep_operation_cb cb, void *user_param)
{
net_nfc_server_snep_op_context_t *context;
net_nfc_error_e result;
return result;
}
-static void _net_nfc_server_snep_server_recv_cb(net_nfc_error_e result, uint32_t type, data_s * data, void *user_param)
+static void _net_nfc_server_snep_server_recv_cb(net_nfc_error_e result, uint32_t type, net_nfc_data_s * data, void *user_param)
{
net_nfc_server_snep_context_t *context = (net_nfc_server_snep_context_t *) user_param;
_net_nfc_server_snep_server_process(context);
}
-static void _net_nfc_server_snep_server_send_cb(net_nfc_error_e result, uint32_t type, data_s * data, void *user_param)
+static void _net_nfc_server_snep_server_send_cb(net_nfc_error_e result, uint32_t type, net_nfc_data_s * data, void *user_param)
{
net_nfc_server_snep_context_t *context = (net_nfc_server_snep_context_t *) user_param;
}
}
-static void _net_nfc_server_snep_incomming_socket_error_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, void *user_param)
+static void _net_nfc_server_snep_incomming_socket_error_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, void *user_param)
{
net_nfc_server_snep_context_t *context = (net_nfc_server_snep_context_t *) user_param;
_net_nfc_util_free_mem(context);
}
-static void _net_nfc_server_snep_socket_error_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, void *user_param)
+static void _net_nfc_server_snep_socket_error_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, void *user_param)
{
net_nfc_server_snep_context_t *context = (net_nfc_server_snep_context_t *) user_param;
_net_nfc_util_free_mem(context);
}
-static void _net_nfc_server_snep_incoming_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, void *user_param)
+static void _net_nfc_server_snep_incoming_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, void *user_param)
{
net_nfc_server_snep_context_t *context = (net_nfc_server_snep_context_t *) user_param;
net_nfc_server_snep_context_t *accept_context = NULL;
return result;
}
-net_nfc_error_e net_nfc_server_snep_server_send_get_response(net_nfc_snep_handle_h snep_handle, data_s * data)
+net_nfc_error_e net_nfc_server_snep_server_send_get_response(net_nfc_snep_handle_h snep_handle, net_nfc_data_s * data)
{
net_nfc_server_snep_context_t *context = (net_nfc_server_snep_context_t *) snep_handle;
net_nfc_error_e result = NET_NFC_OK;
return result;
}
-static void _net_nfc_server_snep_client_send_cb(net_nfc_error_e result, uint32_t type, data_s * data, void *user_param)
+static void _net_nfc_server_snep_client_send_cb(net_nfc_error_e result, uint32_t type, net_nfc_data_s * data, void *user_param)
{
net_nfc_server_snep_job_t *job = (net_nfc_server_snep_job_t *) user_param;
_net_nfc_server_snep_client_process(job);
}
-static void _net_nfc_server_snep_client_recv_cb(net_nfc_error_e result, uint32_t type, data_s * data, void *user_param)
+static void _net_nfc_server_snep_client_recv_cb(net_nfc_error_e result, uint32_t type, net_nfc_data_s * data, void *user_param)
{
net_nfc_server_snep_job_t *job = (net_nfc_server_snep_job_t *) user_param;
}
}
-static void _net_nfc_server_snep_connected_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, data_s * data, void *user_param)
+static void _net_nfc_server_snep_connected_cb(net_nfc_error_e result, net_nfc_target_handle_s * handle, net_nfc_llcp_socket_t socket, net_nfc_data_s * data, void *user_param)
{
net_nfc_server_snep_context_t *context = (net_nfc_server_snep_context_t *) user_param;
return result;
}
-net_nfc_error_e net_nfc_server_snep_client_request(net_nfc_snep_handle_h snep, uint8_t type, data_s * data, net_nfc_server_snep_cb cb, void *user_param)
+net_nfc_error_e net_nfc_server_snep_client_request(net_nfc_snep_handle_h snep, uint8_t type, net_nfc_data_s * data, net_nfc_server_snep_cb cb, void *user_param)
{
net_nfc_server_snep_context_t *context = (net_nfc_server_snep_context_t *) snep;
net_nfc_error_e result = NET_NFC_OK;
return result;
}
-static net_nfc_error_e _net_nfc_server_default_server_cb_(net_nfc_snep_handle_h handle, net_nfc_error_e result, uint32_t type, data_s * data, void *user_param)
+static net_nfc_error_e _net_nfc_server_default_server_cb_(net_nfc_snep_handle_h handle, net_nfc_error_e result, uint32_t type, net_nfc_data_s * data, void *user_param)
{
DEBUG_SERVER_MSG("type [%d], result [%d], data [%p], user_param [%p]", type, result, data, user_param);
net_nfc_server_snep_get_msg_t *msg = (net_nfc_server_snep_get_msg_t *) data->buffer;
uint32_t max_len = htonl(msg->length);
- data_s get_msg = { msg->data, data->length - sizeof(msg->length) };
+ net_nfc_data_s get_msg = { msg->data, data->length - sizeof(msg->length) };
DEBUG_SERVER_MSG("GET : acceptable max_len [%d], message [%zd]", max_len, data->length - sizeof(msg->length));
return result;
}
-static net_nfc_error_e _net_nfc_server_default_client_cb_(net_nfc_snep_handle_h handle, net_nfc_error_e result, uint32_t type, data_s * data, void *user_param)
+static net_nfc_error_e _net_nfc_server_default_client_cb_(net_nfc_snep_handle_h handle, net_nfc_error_e result, uint32_t type, net_nfc_data_s * data, void *user_param)
{
_net_nfc_server_snep_service_context_t *context = (_net_nfc_server_snep_service_context_t *) user_param;
case SNEP_RESP_UNSUPPORTED_VER:
context = (_net_nfc_server_snep_service_context_t *) user_param;
- net_nfc_server_p2p_data_sent(result, context->user_param);
+ net_nfc_server_p2p_net_nfc_data_sent(result, context->user_param);
break;
default:
return result;
}
-static net_nfc_error_e _net_nfc_server_default_client_connected_cb_(net_nfc_snep_handle_h handle, net_nfc_error_e result, uint32_t type, data_s * data, void *user_param)
+static net_nfc_error_e _net_nfc_server_default_client_connected_cb_(net_nfc_snep_handle_h handle, net_nfc_error_e result, uint32_t type, net_nfc_data_s * data, void *user_param)
{
_net_nfc_server_snep_service_context_t *context = (_net_nfc_server_snep_service_context_t *) user_param;
return net_nfc_server_snep_server(handle, SNEP_SAN, SNEP_SAP, _net_nfc_server_default_server_cb_, (void *)1234);
}
-net_nfc_error_e net_nfc_server_snep_default_client_start(net_nfc_target_handle_s * handle, int type, data_s * data, int client, void *user_param)
+net_nfc_error_e net_nfc_server_snep_default_client_start(net_nfc_target_handle_s * handle, int type, net_nfc_data_s * data, int client, void *user_param)
{
_net_nfc_server_snep_service_context_t *context = NULL;
net_nfc_error_e result;
return NET_NFC_OK;
}
-net_nfc_error_e net_nfc_server_snep_default_server_send_get_response(net_nfc_snep_handle_h snep_handle, data_s * data)
+net_nfc_error_e net_nfc_server_snep_default_server_send_get_response(net_nfc_snep_handle_h snep_handle, net_nfc_data_s * data)
{
net_nfc_server_snep_context_t *context = (net_nfc_server_snep_context_t *) snep_handle;
net_nfc_error_e result = NET_NFC_OK;
return net_nfc_server_llcp_unregister_service(id, SNEP_SAP, SNEP_SAN);
}
-net_nfc_error_e net_nfc_server_snep_parse_get_request(data_s * request, size_t * max_len, data_s * message)
+net_nfc_error_e net_nfc_server_snep_parse_get_request(net_nfc_data_s * request, size_t * max_len, net_nfc_data_s * message)
{
net_nfc_server_snep_msg_t *msg = NULL;
net_nfc_error_e result = NET_NFC_OK;
if (info->is_routed == false) {
- data_s temp = { 0, };
+ net_nfc_data_s temp = { 0, };
SECURE_MSG("route aid, aid [%s]", info->aid);
net_nfc_error_e result = NET_NFC_OK;
if (info->is_routed == true) {
- data_s temp = { 0, };
+ net_nfc_data_s temp = { 0, };
SECURE_MSG("unroute aid, aid [%s]", info->aid);
typedef struct _ServerSeData ServerSeData;
struct _ServerSeData {
- data_s aid;
- data_s param;
+ net_nfc_data_s aid;
+ net_nfc_data_s param;
guint event;
};
g_main_loop_unref(loop);
}
-static bool _se_uicc_send_apdu(net_nfc_target_handle_s * handle, data_s * apdu, data_s ** response)
+static bool _se_uicc_send_apdu(net_nfc_target_handle_s * handle, net_nfc_data_s * apdu, net_nfc_data_s ** response)
{
bool ret;
int result;
result = tel_req_sim_apdu((TapiHandle *) handle, &apdu_data, _sim_apdu_cb, &loop);
if (result == 0 && resp_apdu->apdu_resp_len > 0) {
- data_s *temp = NULL;
+ net_nfc_data_s *temp = NULL;
g_main_loop_run(loop);
return ret;
}
-static bool _se_uicc_get_atr(net_nfc_target_handle_s * handle, data_s ** atr)
+static bool _se_uicc_get_atr(net_nfc_target_handle_s * handle, net_nfc_data_s ** atr)
{
bool ret;
int result;
result = tel_req_sim_atr((TapiHandle *) handle, _sim_atr_cb, &loop);
if (result == 0) {
- data_s *temp = NULL;
+ net_nfc_data_s *temp = NULL;
g_main_loop_run(loop);
{
SeDataHandle *detail = (SeDataHandle *) user_data;
net_nfc_error_e result = NET_NFC_INVALID_HANDLE;
- data_s *atr = NULL;
+ net_nfc_data_s *atr = NULL;
GVariant *data;
g_assert(detail != NULL);
static void se_send_apdu_thread_func(gpointer user_data)
{
SeDataApdu *detail = (SeDataApdu *) user_data;
- data_s apdu_data = { NULL, 0 };
- data_s *response = NULL;
+ net_nfc_data_s apdu_data = { NULL, 0 };
+ net_nfc_data_s *response = NULL;
net_nfc_error_e result = NET_NFC_OK;
GVariant *rspdata = NULL;
bool ret;
g_assert(detail->object != NULL);
g_assert(detail->invocation != NULL);
- net_nfc_util_gdbus_variant_to_data_s(detail->data, &apdu_data);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(detail->data, &apdu_data);
if(net_nfc_server_gdbus_check_client_context(g_dbus_method_invocation_get_sender(detail->invocation)) == true) {
if (detail->se_type == NET_NFC_SE_TYPE_UICC && gdbus_uicc_handle != NULL && gdbus_uicc_ready == SE_UICC_READY ) {
ret = _se_uicc_send_apdu((net_nfc_target_handle_s *)gdbus_uicc_handle, &apdu_data, &response);
net_nfc_target_handle_s *handle = NULL;
uint8_t cmd_select_scrs[] = { 0x00, 0xA4, 0x04, 0x00, 0x09, 0xA0, 0x00, 0x00, 0x01, 0x51, 0x43, 0x52, 0x53, 0x00 };
uint8_t *cmd = NULL;
- data_s *command = NULL;
- data_s *response = NULL;
+ net_nfc_data_s *command = NULL;
+ net_nfc_data_s *response = NULL;
net_nfc_error_e result = NET_NFC_OK;
int i, j, k = 0;
FILE *fp = NULL;
static NetNfcGDbusSnep *snep_skeleton = NULL;
/* LCOV_EXCL_START */
-static void _emit_snep_event_signal(GVariant * parameter, net_nfc_snep_handle_h handle, net_nfc_error_e result, uint32_t type, data_s * data)
+static void _emit_snep_event_signal(GVariant * parameter, net_nfc_snep_handle_h handle, net_nfc_error_e result, uint32_t type, net_nfc_data_s * data)
{
GDBusConnection *connection;
char *client_id;
g_free(client_id);
}
-static net_nfc_error_e _snep_server_cb(net_nfc_snep_handle_h handle, net_nfc_error_e result, uint32_t type, data_s * data, void *user_param)
+static net_nfc_error_e _snep_server_cb(net_nfc_snep_handle_h handle, net_nfc_error_e result, uint32_t type, net_nfc_data_s * data, void *user_param)
{
GVariant *parameter = (GVariant *) user_param;
- data_s *temp = data;
+ net_nfc_data_s *temp = data;
DEBUG_SERVER_MSG("type [%d], result [%d], data [%p], user_param [%p]", type, result, data, user_param);
return TRUE;
}
-static net_nfc_error_e _snep_start_client_cb(net_nfc_snep_handle_h handle, net_nfc_error_e result, uint32_t type, data_s * data, void *user_param)
+static net_nfc_error_e _snep_start_client_cb(net_nfc_snep_handle_h handle, net_nfc_error_e result, uint32_t type, net_nfc_data_s * data, void *user_param)
{
GVariant *parameter = (GVariant *) user_param;
return TRUE;
}
-static net_nfc_error_e _snep_client_request_cb(net_nfc_snep_handle_h handle, net_nfc_error_e result, net_nfc_snep_type_t type, data_s * data, void *user_param)
+static net_nfc_error_e _snep_client_request_cb(net_nfc_snep_handle_h handle, net_nfc_error_e result, net_nfc_snep_type_t type, net_nfc_data_s * data, void *user_param)
{
GVariant *parameter = (GVariant *) user_param;
net_nfc_snep_handle_h arg_snep_handle;
net_nfc_snep_type_t arg_type;
GVariant *arg_ndef_msg;
- data_s data = { NULL, };
+ net_nfc_data_s data = { NULL, };
net_nfc_error_e result;
if (user_data == NULL) {
g_assert(object != NULL);
g_assert(invocation != NULL);
- net_nfc_util_gdbus_variant_to_data_s(arg_ndef_msg, &data);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(arg_ndef_msg, &data);
result = net_nfc_server_snep_client_request(arg_snep_handle, arg_type, &data, _snep_client_request_cb, user_data);
if (result != NET_NFC_OK) {
net_nfc_target_handle_s *handle;
};
-static gboolean tag_read_ndef_message(net_nfc_target_handle_s * handle, int dev_type, data_s ** read_ndef);
+static gboolean tag_read_ndef_message(net_nfc_target_handle_s * handle, int dev_type, net_nfc_data_s ** read_ndef);
static void tag_check_presence_thread_func(gpointer user_data);
uint8_t cmd[] = { 0x90, 0x60, 0x00, 0x00, 0x00 };
net_nfc_transceive_info_s info;
- data_s *response = NULL;
+ net_nfc_data_s *response = NULL;
net_nfc_error_e error = NET_NFC_OK;
gboolean result = false;
}
#endif
/* LCOV_EXCL_START */
-static gboolean tag_read_ndef_message(net_nfc_target_handle_s * handle, int dev_type, data_s ** read_ndef)
+static gboolean tag_read_ndef_message(net_nfc_target_handle_s * handle, int dev_type, net_nfc_data_s ** read_ndef)
{
net_nfc_error_e result = NET_NFC_OK;
- data_s *temp = NULL;
+ net_nfc_data_s *temp = NULL;
if (handle == NULL)
return FALSE;
g_free(data);
}
-static data_s *_get_barcode_from_target_info(net_nfc_current_target_info_s * target_info)
+static net_nfc_data_s *_get_barcode_from_target_info(net_nfc_current_target_info_s * target_info)
{
gint i = 0;
gint length;
- data_s *data = NULL;
+ net_nfc_data_s *data = NULL;
gchar *str = NULL;
guint8 *pos = target_info->target_info_values.buffer;
pos++;
if (strncmp(str, "UID", 3) == 0 && length > 0) {
- data = (data_s *) calloc(1, sizeof(data_s));
+ data = (net_nfc_data_s *) calloc(1, sizeof(net_nfc_data_s));
if (data == NULL) {
g_free(str);
return NULL;
static void tag_get_barcode_thread_func(gpointer user_data)
{
- data_s *data = NULL;
+ net_nfc_data_s *data = NULL;
net_nfc_current_target_info_s *target_info;
net_nfc_error_e result = NET_NFC_OPERATION_FAIL;
CurrentTagInfoData *info_data = (CurrentTagInfoData *) user_data;
guint32 max_data_size = 0;
guint32 actual_data_size = 0;
gint number_of_keys = 0;
- data_s target_info_values = { NULL, 0 };
- data_s *raw_data = NULL;
+ net_nfc_data_s target_info_values = { NULL, 0 };
+ net_nfc_data_s *raw_data = NULL;
g_assert(info_data != NULL);
g_assert(info_data->tag != NULL);
#endif
is_ndef_supported = net_nfc_controller_check_ndef(target->handle, &ndef_card_state, (int *)&max_data_size, (int *)&actual_data_size, &result);
if (is_ndef_supported) {
- data_s *recv_data = NULL;
+ net_nfc_data_s *recv_data = NULL;
DEBUG_SERVER_MSG("support NDEF");
} else {
/* raw-data of empty ndef msseages */
uint8_t empty[] = { 0xd0, 0x00, 0x00 };
- data_s empty_data = { empty, sizeof(empty) };
+ net_nfc_data_s empty_data = { empty, sizeof(empty) };
DEBUG_SERVER_MSG("not support NDEF");
guint32 mode;
guint32 reg_id;
- data_s data;
+ net_nfc_data_s data;
};
typedef struct _TestSetListenTechData TestSetListenTechData;
static void test_handle_test_mode_off_thread_func(gpointer user_data);
-static void test_handle_sim_test_thread_func(gpointer user_data);
-
-static void test_handle_prbs_test_thread_func(gpointer user_data);
-
static void test_handle_get_firmware_version_thread_func(gpointer user_data);
-static void test_handle_set_ee_data_thread_func(gpointer user_data);
-
static gboolean test_handle_test_mode_on(NetNfcGDbusTest * test, GDBusMethodInvocation * invocation, GVariant * smack_privilege, gpointer user_data);
static gboolean test_handle_test_mode_off(NetNfcGDbusTest * test, GDBusMethodInvocation * invocation, GVariant * smack_privilege, gpointer user_data);
-static gboolean test_handle_sim_test(NetNfcGDbusTest * test, GDBusMethodInvocation * invocation, GVariant * smack_privilege, gpointer user_data);
-
-static gboolean test_handle_prbs_test(NetNfcGDbusTest * test, GDBusMethodInvocation * invocation, guint32 arg_tech, guint32 arg_rate, GVariant * smack_privilege, gpointer user_data);
-
static gboolean test_handle_get_firmware_version(NetNfcGDbusTest * test, GDBusMethodInvocation * invocation, GVariant * smack_privilege, gpointer user_data);
-static gboolean test_handle_set_ee_data(NetNfcGDbusTest * test, GDBusMethodInvocation * invocation, guint32 mode, guint32 reg_id, GVariant * variant, GVariant * smack_privilege, gpointer user_data);
-
static NetNfcGDbusTest *test_skeleton = NULL;
/* LCOV_EXCL_START */
g_free(data);
}
-static void test_handle_sim_test_thread_func(gpointer user_data)
-{
- TestData *data = (TestData *) user_data;
- net_nfc_error_e result = NET_NFC_OK;
-
- g_assert(data != NULL);
- g_assert(data->test != NULL);
- g_assert(data->invocation != NULL);
-
- net_nfc_controller_sim_test(&result);
-
- net_nfc_gdbus_test_complete_sim_test(data->test, data->invocation, (gint) result);
-
- g_object_unref(data->invocation);
- g_object_unref(data->test);
-
- g_free(data);
-}
-
-static void test_handle_prbs_test_thread_func(gpointer user_data)
-{
- TestPrbsData *data = (TestPrbsData *) user_data;
- net_nfc_error_e result = NET_NFC_OK;
-
- g_assert(data != NULL);
- g_assert(data->test != NULL);
- g_assert(data->invocation != NULL);
-
- net_nfc_controller_prbs_test(&result, data->tech, data->rate);
-
- net_nfc_gdbus_test_complete_prbs_test(data->test, data->invocation, (gint) result);
-
- g_object_unref(data->invocation);
- g_object_unref(data->test);
-
- g_free(data);
-}
-
static void test_handle_get_firmware_version_thread_func(gpointer user_data)
{
TestData *data = (TestData *) user_data;
- data_s *tmp_data = NULL;
+ net_nfc_data_s *tmp_data = NULL;
net_nfc_error_e result = NET_NFC_OK;
gchar *version = NULL;
g_free(data);
}
-static void test_handle_set_ee_data_thread_func(gpointer user_data)
-{
- TestSetEeData *data = (TestSetEeData *) user_data;
- net_nfc_error_e result = NET_NFC_OK;
-
- g_assert(data != NULL);
- g_assert(data->test != NULL);
- g_assert(data->invocation != NULL);
-
- net_nfc_controller_eedata_register_set(&result, data->mode, data->reg_id, &data->data);
-
- net_nfc_gdbus_test_complete_set_ee_data(data->test, data->invocation, (gint) result);
-
- net_nfc_util_clear_data(&data->data);
-
- g_object_unref(data->invocation);
- g_object_unref(data->test);
-
- g_free(data);
-}
-
-static void test_handle_ese_test_thread_func(gpointer user_data)
-{
- TestData *data = (TestData *) user_data;
- net_nfc_error_e result = NET_NFC_OK;
-
- DEBUG_SERVER_MSG("test_handle_ese_test_thread_func working!!");
-
- g_assert(data != NULL);
- g_assert(data->test != NULL);
- g_assert(data->invocation != NULL);
-
- net_nfc_controller_ese_test(&result);
-
- net_nfc_gdbus_test_complete_ese_test(data->test, data->invocation, (gint) result);
-
- g_object_unref(data->invocation);
- g_object_unref(data->test);
-
- g_free(data);
-}
-
static gboolean test_handle_test_mode_on(NetNfcGDbusTest * test, GDBusMethodInvocation * invocation, GVariant * smack_privilege, gpointer user_data)
{
TestData *data = NULL;
return TRUE;
}
-static gboolean test_handle_sim_test(NetNfcGDbusTest * test, GDBusMethodInvocation * invocation, GVariant * smack_privilege, gpointer user_data)
-{
- TestData *data = NULL;
- gint result;
-
- INFO_MSG(">>> REQUEST from [%s]", g_dbus_method_invocation_get_sender(invocation));
-
- /* check privilege and update client context */
- if (net_nfc_server_gdbus_check_privilege(invocation, NET_NFC_PRIVILEGE_NFC) == false) {
- DEBUG_ERR_MSG("permission denied, and finished request");
- result = NET_NFC_PERMISSION_DENIED;
-
- goto ERROR;
- }
-
- DEBUG_SERVER_MSG("sim_test");
-
- data = g_try_new0(TestData, 1);
- if (data == NULL) {
- DEBUG_ERR_MSG("Memory allocation failed");
- result = NET_NFC_ALLOC_FAIL;
-
- goto ERROR;
- }
-
- data->test = g_object_ref(test);
- data->invocation = g_object_ref(invocation);
-
- if (net_nfc_server_controller_async_queue_push(test_handle_sim_test_thread_func, data) == FALSE) {
- /* return error if queue was blocked */
- DEBUG_SERVER_MSG("controller is processing important message..");
- result = NET_NFC_BUSY;
-
- goto ERROR;
- }
-
- return TRUE;
-
- ERROR:
- if (data != NULL) {
- g_object_unref(data->invocation);
- g_object_unref(data->test);
-
- g_free(data);
- }
-
- net_nfc_gdbus_test_complete_sim_test(test, invocation, result);
-
- return TRUE;
-}
-
-static gboolean test_handle_prbs_test(NetNfcGDbusTest * test, GDBusMethodInvocation * invocation, guint32 arg_tech, guint32 arg_rate, GVariant * smack_privilege, gpointer user_data)
-{
- TestPrbsData *data = NULL;
- gint result;
-
- INFO_MSG(">>> REQUEST from [%s]", g_dbus_method_invocation_get_sender(invocation));
-
- /* check privilege and update client context */
- if (net_nfc_server_gdbus_check_privilege(invocation, NET_NFC_PRIVILEGE_NFC) == false) {
- DEBUG_ERR_MSG("permission denied, and finished request");
- result = NET_NFC_PERMISSION_DENIED;
-
- goto ERROR;
- }
-
- DEBUG_SERVER_MSG("prbs_test");
-
- data = g_try_new0(TestPrbsData, 1);
- if (data == NULL) {
- DEBUG_ERR_MSG("Memory allocation failed");
- result = NET_NFC_ALLOC_FAIL;
-
- goto ERROR;
- }
-
- data->test = g_object_ref(test);
- data->invocation = g_object_ref(invocation);
- data->tech = arg_tech;
- data->rate = arg_rate;
-
- if (net_nfc_server_controller_async_queue_push(test_handle_prbs_test_thread_func, data) == FALSE) {
- /* return error if queue was blocked */
- DEBUG_SERVER_MSG("controller is processing important message..");
- result = NET_NFC_BUSY;
-
- goto ERROR;
- }
-
- return TRUE;
-
- ERROR:
- if (data != NULL) {
- g_object_unref(data->invocation);
- g_object_unref(data->test);
-
- g_free(data);
- }
-
- net_nfc_gdbus_test_complete_prbs_test(test, invocation, result);
-
- return TRUE;
-}
-
static gboolean test_handle_get_firmware_version(NetNfcGDbusTest * test, GDBusMethodInvocation * invocation, GVariant * smack_privilege, gpointer user_data)
{
TestData *data = NULL;
return TRUE;
}
-static gboolean test_handle_set_ee_data(NetNfcGDbusTest * test, GDBusMethodInvocation * invocation, guint32 mode, guint32 reg_id, GVariant * variant, GVariant * smack_privilege, gpointer user_data)
-{
- TestSetEeData *data = NULL;
- gint result;
-
- INFO_MSG(">>> REQUEST from [%s]", g_dbus_method_invocation_get_sender(invocation));
-
- /* check privilege and update client context */
- if (net_nfc_server_gdbus_check_privilege(invocation, NET_NFC_PRIVILEGE_NFC) == false) {
- DEBUG_ERR_MSG("permission denied, and finished request");
- result = NET_NFC_PERMISSION_DENIED;
-
- goto ERROR;
- }
-
- data = g_try_new0(TestSetEeData, 1);
- if (data == NULL) {
- DEBUG_ERR_MSG("Memory allocation failed");
- result = NET_NFC_ALLOC_FAIL;
-
- goto ERROR;
- }
-
- data->test = g_object_ref(test);
- data->invocation = g_object_ref(invocation);
- data->mode = mode;
- data->reg_id = reg_id;
- net_nfc_util_gdbus_variant_to_data_s(variant, &data->data);
-
- if (net_nfc_server_controller_async_queue_push(test_handle_set_ee_data_thread_func, data) == FALSE) {
- /* return error if queue was blocked */
- DEBUG_SERVER_MSG("controller is processing important message..");
- result = NET_NFC_BUSY;
-
- goto ERROR;
- }
-
- return TRUE;
-
- ERROR:
- if (data != NULL) {
- g_object_unref(data->invocation);
- g_object_unref(data->test);
-
- g_free(data);
- }
-
- net_nfc_gdbus_test_complete_set_ee_data(test, invocation, result);
-
- return TRUE;
-}
-
-static gboolean test_handle_ese_test(NetNfcGDbusTest * test, GDBusMethodInvocation * invocation, GVariant * smack_privilege, gpointer user_data)
-{
- TestData *data = NULL;
- gint result;
-
- INFO_MSG(">>> ESE TEST REQUEST from [%s]", g_dbus_method_invocation_get_sender(invocation));
-#if 0
- /* check privilege and update client context */
- if (net_nfc_server_gdbus_check_privilege(invocation, NET_NFC_PRIVILEGE_NFC) == false) {
- DEBUG_ERR_MSG("permission denied, and finished request");
- result = NET_NFC_PERMISSION_DENIED;
-
- goto ERROR;
- }
-#endif
- DEBUG_SERVER_MSG("ese_test");
-
- data = g_try_new0(TestData, 1);
- if (data == NULL) {
- DEBUG_ERR_MSG("Memory allocation failed");
- result = NET_NFC_ALLOC_FAIL;
-
- goto ERROR;
- }
-
- data->test = g_object_ref(test);
- data->invocation = g_object_ref(invocation);
-
- if (net_nfc_server_controller_async_queue_push(test_handle_ese_test_thread_func, data) == FALSE) {
- /* return error if queue was blocked */
- DEBUG_SERVER_MSG("controller is processing important message..");
- result = NET_NFC_BUSY;
-
- goto ERROR;
- }
-
- return TRUE;
-
- ERROR:
- if (data != NULL) {
- g_object_unref(data->invocation);
- g_object_unref(data->test);
-
- g_free(data);
- }
-
- net_nfc_gdbus_test_complete_ese_test(test, invocation, result);
-
- return TRUE;
-}
-
-static void test_handle_set_se_tech_type_thread_func(gpointer user_data)
-{
- TestSetEeData *data = (TestSetEeData *) user_data;
- net_nfc_error_e result = NET_NFC_OK;
-
- g_assert(data != NULL);
- g_assert(data->test != NULL);
- g_assert(data->invocation != NULL);
-
- net_nfc_controller_test_set_se_tech_type(&result, (net_nfc_se_type_e) data->mode, data->reg_id);
-
- net_nfc_gdbus_test_complete_set_se_tech_type(data->test, data->invocation, (gint) result);
-
- g_object_unref(data->invocation);
- g_object_unref(data->test);
-
- g_free(data);
-}
-
-static gboolean test_handle_set_se_tech_type(NetNfcGDbusTest * test, GDBusMethodInvocation * invocation, guint32 type, guint32 tech, GVariant * smack_privilege, gpointer user_data)
-{
- TestSetEeData *data = NULL;
- gint result;
-
- INFO_MSG(">>> REQUEST from [%s]", g_dbus_method_invocation_get_sender(invocation));
-
- /* check privilege and update client context */
- if (net_nfc_server_gdbus_check_privilege(invocation, NET_NFC_PRIVILEGE_NFC) == false) {
- DEBUG_ERR_MSG("permission denied, and finished request");
- result = NET_NFC_PERMISSION_DENIED;
-
- goto ERROR;
- }
-
- data = g_try_new0(TestSetEeData, 1);
- if (data == NULL) {
- DEBUG_ERR_MSG("Memory allocation failed");
- result = NET_NFC_ALLOC_FAIL;
-
- goto ERROR;
- }
-
- data->test = g_object_ref(test);
- data->invocation = g_object_ref(invocation);
- data->mode = type;
- data->reg_id = tech;
-
- if (net_nfc_server_controller_async_queue_push(test_handle_set_se_tech_type_thread_func, data) == FALSE) {
- /* return error if queue was blocked */
- DEBUG_SERVER_MSG("controller is processing important message..");
- result = NET_NFC_BUSY;
-
- goto ERROR;
- }
-
- return TRUE;
-
- ERROR:
- if (data != NULL) {
- g_object_unref(data->invocation);
- g_object_unref(data->test);
-
- g_free(data);
- }
-
- net_nfc_gdbus_test_complete_set_se_tech_type(test, invocation, result);
-
- return TRUE;
-}
-
-static void test_set_listen_tech_mask_thread_func(gpointer user_data)
-{
- TestSetListenTechData *data = (TestSetListenTechData *) user_data;
- net_nfc_error_e result = NET_NFC_OK;
-
- g_assert(data != NULL);
- g_assert(data->test != NULL);
- g_assert(data->invocation != NULL);
-
- DEBUG_SERVER_MSG(">>> Call test_set_listen_tech_mask_thread_func");
-
- net_nfc_controller_secure_element_set_listen_tech_mask(data->mode, &result);
-
- net_nfc_gdbus_test_complete_set_listen_tech_mask(data->test, data->invocation, result);
-
- g_object_unref(data->invocation);
- g_object_unref(data->test);
-
- g_free(data);
-}
-
-static gboolean test_handle_set_listen_tech_mask(NetNfcGDbusTest * test, GDBusMethodInvocation * invocation, guint listen_tech_mask, GVariant * smack_privilege)
-{
- TestSetListenTechData *data = NULL;
- gint result;
-
- INFO_MSG(">>> REQUEST from [%s]", g_dbus_method_invocation_get_sender(invocation));
-
- /* check privilege and update client context */
- if (net_nfc_server_gdbus_check_privilege(invocation, NET_NFC_PRIVILEGE_NFC) == false) {
- DEBUG_ERR_MSG("permission denied, and finished request");
- result = NET_NFC_PERMISSION_DENIED;
-
- goto ERROR;
- }
-
- data = g_try_new0(TestSetListenTechData, 1);
- if (data == NULL) {
- DEBUG_ERR_MSG("Memory allocation failed");
- result = NET_NFC_ALLOC_FAIL;
-
- goto ERROR;
- }
-
- data->test = g_object_ref(test);
- data->invocation = g_object_ref(invocation);
- data->mode = listen_tech_mask;
-
- if (net_nfc_server_controller_async_queue_push_force(test_set_listen_tech_mask_thread_func, data) == FALSE) {
- /* return error if queue was blocked */
- DEBUG_SERVER_MSG("controller is processing important message..");
- result = NET_NFC_BUSY;
-
- goto ERROR;
- }
-
- return TRUE;
-
- ERROR:
-
- net_nfc_gdbus_test_complete_set_listen_tech_mask(test, invocation, result);
-
- if (data != NULL) {
- g_object_unref(data->invocation);
- g_object_unref(data->test);
-
- g_free(data);
- }
-
- return TRUE;
-}
/* LCOV_EXCL_STOP */
gboolean net_nfc_server_test_init(GDBusConnection * connection)
g_signal_connect(test_skeleton, "handle-test-mode-off", G_CALLBACK(test_handle_test_mode_off), NULL);
- g_signal_connect(test_skeleton, "handle-sim-test", G_CALLBACK(test_handle_sim_test), NULL);
-
- g_signal_connect(test_skeleton, "handle-prbs-test", G_CALLBACK(test_handle_prbs_test), NULL);
-
g_signal_connect(test_skeleton, "handle-get-firmware-version", G_CALLBACK(test_handle_get_firmware_version), NULL);
- g_signal_connect(test_skeleton, "handle-set-ee-data", G_CALLBACK(test_handle_set_ee_data), NULL);
-
- g_signal_connect(test_skeleton, "handle-ese-test", G_CALLBACK(test_handle_ese_test), NULL);
-
- g_signal_connect(test_skeleton, "handle-set-se-tech-type", G_CALLBACK(test_handle_set_se_tech_type), NULL);
-
- g_signal_connect(test_skeleton, "handle-set-listen-tech-mask", G_CALLBACK(test_handle_set_listen_tech_mask), NULL);
-
result = g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(test_skeleton), connection, "/org/tizen/NetNfcService/Test", &error);
if (result == FALSE) {
/* LCOV_EXCL_START */
TransceiveSendData *transceive_data = (TransceiveSendData *) user_data;
net_nfc_target_handle_s *handle;
net_nfc_error_e result = NET_NFC_OK;
- data_s *data = NULL;
+ net_nfc_data_s *data = NULL;
GVariant *resp_data = NULL;
/* use assert because it was checked in handle function */
data->invocation = g_object_ref(invocation);
data->transceive_handle = handle;
data->transceive_info.dev_type = dev_type;
- net_nfc_util_gdbus_variant_to_data_s(arg_data, &data->transceive_info.trans_data);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(arg_data, &data->transceive_info.trans_data);
if (net_nfc_server_controller_async_queue_push(transceive_data_thread_func, data) == FALSE) {
/* return error if queue was blocked */
TransceiveSendData *transceive_data = (TransceiveSendData *) user_data;
net_nfc_target_handle_s *handle;
net_nfc_error_e result = NET_NFC_OK;
- data_s *data = NULL;
+ net_nfc_data_s *data = NULL;
/* use assert because it was checked in handle function */
g_assert(transceive_data != NULL);
data->invocation = g_object_ref(invocation);
data->transceive_handle = handle;
data->transceive_info.dev_type = dev_type;
- net_nfc_util_gdbus_variant_to_data_s(arg_data, &data->transceive_info.trans_data);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(arg_data, &data->transceive_info.trans_data);
if (net_nfc_server_controller_async_queue_push(transceive_thread_func, data) == FALSE) {
/* return error if queue was blocked */
projects / platform / core / connectivity / nfc-manager.git / commitdiff