#define NET_NFC_MANAGER_DATA_PATH_MESSAGE "message"
#define NET_NFC_MANAGER_NDEF_FILE_NAME "ndef-message.txt"
-#define NET_NFC_REVERSE_ORDER_6_BYTES(__array) \
- do \
- { \
- uint16_t __x = htons(*(uint16_t *)(__array + 4)); \
- *(uint32_t *)(__array + 2) = htonl(*(uint32_t *)(__array)); \
- *(uint16_t *)(__array) = __x; \
- } while (0)
-
-#define NET_NFC_REVERSE_ORDER_16_BYTES(array) \
- do \
- { \
- uint32_t __x1 = htonl(*(uint32_t *)(array + 12)); \
- uint32_t __x2 = htonl(*(uint32_t *)(array + 8)); \
- *(uint32_t *)(array + 8) = htonl(*(uint32_t *)(array + 4)); \
- *(uint32_t *)(array + 12) = htonl(*(uint32_t *)(array)); \
- *(uint32_t *)(array) = __x1; \
- *(uint32_t *)(array + 4) = __x2; \
- } while (0)
typedef enum
{
#include "net_nfc_server_llcp.h"
#include "net_nfc_server_handover_bss.h"
-static int _net_nfc_handover_bss_process_carrier_record(
- net_nfc_handover_bss_process_context_t *context);
+static gboolean _net_nfc_handover_bss_process_carrier_record(gpointer user_data);
int _net_nfc_handover_bss_convert_security_type(int value)
{
DEBUG_ERR_MSG("Invalid context");
context->result = NET_NFC_OPERATION_FAIL;
context->step = NET_NFC_LLCP_STEP_RETURN;
- g_idle_add(
- (GSourceFunc)_net_nfc_handover_bss_process_carrier_record,
- (gpointer)context);
+ g_idle_add(_net_nfc_handover_bss_process_carrier_record, context);
return false;
}
DEBUG_ERR_MSG("Wifi get carrier config failed");
context->result = NET_NFC_OPERATION_FAIL;
context->step = NET_NFC_LLCP_STEP_RETURN;
- g_idle_add(
- (GSourceFunc)_net_nfc_handover_bss_process_carrier_record,
- (gpointer)context);
+ g_idle_add(_net_nfc_handover_bss_process_carrier_record, context);
return false;
}
return true;
}
-void
-_net_nfc_handover_bss_on_wifi_bgscan_completed(wifi_error_e errorCode,
- void* user_data)
+void _net_nfc_handover_bss_on_wifi_bgscan_completed(
+ wifi_error_e errorCode, void* user_data)
{
int err = WIFI_ERROR_NONE;
net_nfc_handover_bss_process_context_t *context = user_data;
DEBUG_ERR_MSG("Invalid context");
context->result = NET_NFC_OPERATION_FAIL;
context->step = NET_NFC_LLCP_STEP_RETURN;
- g_idle_add(
- (GSourceFunc)_net_nfc_handover_bss_process_carrier_record,
- (gpointer)context);
- return false;
+ g_idle_add(_net_nfc_handover_bss_process_carrier_record, context);
+ return;
}
if(errorCode != WIFI_ERROR_NONE)
DEBUG_ERR_MSG("Wifi scan failed");
context->result = NET_NFC_OPERATION_FAIL;
context->step = NET_NFC_LLCP_STEP_RETURN;
- g_idle_add(
- (GSourceFunc)_net_nfc_handover_bss_process_carrier_record,
- (gpointer)context);
+ g_idle_add(_net_nfc_handover_bss_process_carrier_record,context);
}
else
{
DEBUG_ERR_MSG("wifi_foreach_found_aps failed Err[%x]",err);
context->result = NET_NFC_OPERATION_FAIL;
context->step = NET_NFC_LLCP_STEP_RETURN;
- g_idle_add(
- (GSourceFunc)_net_nfc_handover_bss_process_carrier_record,
- (gpointer)context);
+ g_idle_add(_net_nfc_handover_bss_process_carrier_record, context);
}
if(context->ap_handle == NULL)
{
DEBUG_MSG("Authentication type %x", sec_type);
}
context->step = NET_NFC_LLCP_STEP_03;
- g_idle_add(
- (GSourceFunc)_net_nfc_handover_bss_process_carrier_record,
- (gpointer)context);
+ g_idle_add(_net_nfc_handover_bss_process_carrier_record, context);
}
}
-void
-_net_nfc_handover_bss_on_wifi_scan_completed(wifi_error_e errorCode,
+void _net_nfc_handover_bss_on_wifi_scan_completed(wifi_error_e errorCode,
void* user_data)
{
int err = WIFI_ERROR_NONE;
DEBUG_ERR_MSG("Invalid context");
context->result = NET_NFC_OPERATION_FAIL;
context->step = NET_NFC_LLCP_STEP_RETURN;
- g_idle_add(
- (GSourceFunc)_net_nfc_handover_bss_process_carrier_record,
- (gpointer)context);
- return false;
+ g_idle_add(_net_nfc_handover_bss_process_carrier_record, context);
+ return;
}
if(errorCode != WIFI_ERROR_NONE)
DEBUG_ERR_MSG("Wifi scan failed");
context->result = NET_NFC_OPERATION_FAIL;
context->step = NET_NFC_LLCP_STEP_RETURN;
- g_idle_add(
- (GSourceFunc)_net_nfc_handover_bss_process_carrier_record,
- (gpointer)context);
+ g_idle_add(_net_nfc_handover_bss_process_carrier_record, context);
}
else
{
DEBUG_ERR_MSG("wifi_foreach_found_aps failed Err[%x]",err);
context->result = NET_NFC_OPERATION_FAIL;
context->step = NET_NFC_LLCP_STEP_RETURN;
- g_idle_add(
- (GSourceFunc)_net_nfc_handover_bss_process_carrier_record,
- (gpointer)context);
+ g_idle_add(_net_nfc_handover_bss_process_carrier_record, context);
}
if(context->ap_handle == NULL)
DEBUG_MSG("Authentication type %x", sec_type);
}
context->step = NET_NFC_LLCP_STEP_03;
- g_idle_add(
- (GSourceFunc)_net_nfc_handover_bss_process_carrier_record,
- (gpointer)context);
+ g_idle_add(_net_nfc_handover_bss_process_carrier_record, context);
}
DEBUG_ERR_MSG("Invalid context");
context->result = NET_NFC_OPERATION_FAIL;
context->step = NET_NFC_LLCP_STEP_RETURN;
- g_idle_add(
- (GSourceFunc)_net_nfc_handover_bss_process_carrier_record,
- (gpointer)context);
- return false;
+ g_idle_add(_net_nfc_handover_bss_process_carrier_record, context);
+ return;
}
if(errorCode == WIFI_ERROR_NONE)
context->result = NET_NFC_OPERATION_FAIL;
}
context->step = NET_NFC_LLCP_STEP_RETURN;
- g_idle_add(
- (GSourceFunc)_net_nfc_handover_bss_process_carrier_record,
- (gpointer)context);
+ g_idle_add(_net_nfc_handover_bss_process_carrier_record,context);
}
-static int _net_nfc_handover_bss_process_carrier_record(
- net_nfc_handover_bss_process_context_t *context)
+static gboolean _net_nfc_handover_bss_process_carrier_record(gpointer user_data)
{
+ net_nfc_handover_bss_process_context_t *context = user_data;
+
LOGD("[%s:%d] START", __func__, __LINE__);
if(context == NULL)
if (context->result != NET_NFC_OK && context->result != NET_NFC_BUSY)
{
- DEBUG_ERR_MSG("context->result is error"
- " [%d]", context->result);
+ DEBUG_ERR_MSG("context->result is error [%d]", context->result);
context->step = NET_NFC_LLCP_STEP_RETURN;
}
switch (context->step)
{
- case NET_NFC_LLCP_STEP_01 :
+ case NET_NFC_LLCP_STEP_01:
{
int err = WIFI_ERROR_NONE;
DEBUG_MSG("STEP [1]");
DEBUG_MSG("Wifi is enabled already, go next step");
context->result = NET_NFC_OK;
context->step = NET_NFC_LLCP_STEP_02;
- g_idle_add((GSourceFunc)
- _net_nfc_handover_bss_process_carrier_record,
- (gpointer)context);
+ g_idle_add(_net_nfc_handover_bss_process_carrier_record, context);
}
}
else
DEBUG_ERR_MSG("Wifi init failed");
context->result = NET_NFC_OPERATION_FAIL;
context->step = NET_NFC_LLCP_STEP_RETURN;
- g_idle_add(
- (GSourceFunc)_net_nfc_handover_bss_process_carrier_record,
- (gpointer)context);
+ g_idle_add(_net_nfc_handover_bss_process_carrier_record, context);
}
}
break;
- case NET_NFC_LLCP_STEP_02 :
+ case NET_NFC_LLCP_STEP_02:
{
int err = WIFI_ERROR_NONE;
DEBUG_ERR_MSG("Wifi scan failed");
context->result = NET_NFC_OPERATION_FAIL;
context->step = NET_NFC_LLCP_STEP_RETURN;
- g_idle_add(
- (GSourceFunc)_net_nfc_handover_bss_process_carrier_record,
- (gpointer)context);
+ g_idle_add(_net_nfc_handover_bss_process_carrier_record, context);
}
}
DEBUG_ERR_MSG("Wifi Connect failed");
context->result = NET_NFC_OPERATION_FAIL;
context->step = NET_NFC_LLCP_STEP_RETURN;
- g_idle_add(
- (GSourceFunc)_net_nfc_handover_bss_process_carrier_record,
- (gpointer)context);
+ g_idle_add(_net_nfc_handover_bss_process_carrier_record, context);
}
}
break;
net_nfc_util_create_record(record->TNF, &record->type_s,
&record->id_s, &record->payload_s, &context->carrier);
- g_idle_add(
- (GSourceFunc)_net_nfc_handover_bss_process_carrier_record,
- (gpointer)context);
+ g_idle_add(_net_nfc_handover_bss_process_carrier_record, context);
}
else
{
static int _net_nfc_handover_bt_process_carrier_record(
net_nfc_handover_bt_process_context_t *context);
+static inline void _net_nfc_convert_byte_order(unsigned char *array, int size)
+{
+ int i;
+ unsigned char tmp_char;
+
+ for (i=0;i<size/2;i++) {
+ tmp_char = array[i];
+ array[i] = array[size-1-i];
+ array[size-1-i] = tmp_char;
+ }
+}
static net_nfc_error_e _net_nfc_handover_bt_get_oob_data(
net_nfc_carrier_config_s *config,
{
DEBUG_MSG("hash.length == 16");
- NET_NFC_REVERSE_ORDER_16_BYTES(hash.buffer);
+ _net_nfc_convert_byte_order(hash.buffer, 16);
oob->hash_len = MIN(sizeof(oob->hash), hash.length);
memcpy(oob->hash, hash.buffer, oob->hash_len);
{
DEBUG_MSG("randomizer.length == 16");
- NET_NFC_REVERSE_ORDER_16_BYTES(randomizer.buffer);
+ _net_nfc_convert_byte_order(randomizer.buffer, 16);
oob->randomizer_len = MIN(sizeof(oob->randomizer), randomizer.length);
memcpy(oob->randomizer, randomizer.buffer, oob->randomizer_len);
{
bt_oob_data_t oob = { { 0 }, };
- NET_NFC_REVERSE_ORDER_6_BYTES(bt_addr.addr);
+ _net_nfc_convert_byte_order(bt_addr.addr, 6);
if ((result = net_nfc_util_add_carrier_config_property(
config,
DEBUG_SERVER_MSG("oob.randomizer_len"
" [%d]", oob.randomizer_len);
- NET_NFC_REVERSE_ORDER_16_BYTES(oob.hash);
+ _net_nfc_convert_byte_order(oob.hash, 16);
if ((result =
net_nfc_util_add_carrier_config_property(
" [%d]",result);
}
- NET_NFC_REVERSE_ORDER_16_BYTES(oob.randomizer);
+ _net_nfc_convert_byte_order(oob.randomizer, 16);
if ((result = net_nfc_util_add_carrier_config_property(
config,
if (temp.length == 6)
{
- NET_NFC_REVERSE_ORDER_6_BYTES(temp.buffer);
+ _net_nfc_convert_byte_order(temp.buffer, 6);
memcpy(context->addr.addr,
temp.buffer,
static void _net_nfc_server_handover_get_response_process(
net_nfc_handover_context_t *context);
-static int _net_nfc_server_handover_append_wifi_carrier_config(
- net_nfc_server_handover_create_config_context_t *context);
-
static net_nfc_error_e
_net_nfc_server_handover_create_requester_from_rawdata(
ndef_message_s **requestor,
static void _net_nfc_server_handover_server_process(
net_nfc_handover_context_t *context);
-static net_nfc_error_e
-_net_nfc_server_handover_create_low_power_selector_message(
- ndef_message_s *request_msg,
- ndef_message_s *select_msg);
-
////////////////////////////////////////////////////////////////////////////
static void _net_nfc_server_handover_send_response(
}
g_object_unref(handover_data->handoverobj);
- g_free(handover_data);
+ g_free(handover_data);
}
static net_nfc_error_e _net_nfc_server_handover_convert_ndef_message_to_data(
return 0;
}
-static int _net_nfc_server_handover_append_wifi_carrier_config(
- net_nfc_server_handover_create_config_context_t *context)
-{
- LOGD("[%s:%d] START", __func__, __LINE__);
-
- switch (context->step)
- {
- case NET_NFC_LLCP_STEP_01 :
- DEBUG_MSG("STEP [1]");
-
- context->step = NET_NFC_LLCP_STEP_02;
- break;
-
- case NET_NFC_LLCP_STEP_02 :
- DEBUG_MSG("STEP [2]");
-
- context->step = NET_NFC_LLCP_STEP_03;
- break;
-
- case NET_NFC_LLCP_STEP_03 :
- DEBUG_MSG("STEP [3]");
-
- context->step = NET_NFC_LLCP_STEP_RETURN;
- break;
-
- case NET_NFC_LLCP_STEP_RETURN :
- DEBUG_MSG("STEP return");
-
- /* complete and return to upper step */
- g_idle_add(
- (GSourceFunc)_net_nfc_server_handover_iterate_carrier_configs_to_next,
- (gpointer)context);
- break;
-
- default :
- break;
- }
-
- LOGD("[%s:%d] END", __func__, __LINE__);
-
- return 0;
-}
-
static int _net_nfc_server_handover_iterate_carrier_configs_to_next(
net_nfc_server_handover_create_config_context_t *context)
{
return result;
}
- static net_nfc_error_e
-_net_nfc_server_handover_create_low_power_selector_message(
- ndef_message_s *request_msg,
- ndef_message_s *select_msg)
-{
- net_nfc_error_e result = NET_NFC_UNKNOWN_ERROR;
- unsigned int carrier_count = 0;
-
- LOGD("[%s] START", __func__);
-
- if (request_msg == NULL || select_msg == NULL)
- {
- return NET_NFC_NULL_PARAMETER;
- }
-
- if ((result = net_nfc_util_get_alternative_carrier_record_count(
- request_msg,
- &carrier_count)) == NET_NFC_OK)
- {
- int idx;
- ndef_record_s *carrier_record = NULL;
- net_nfc_conn_handover_carrier_type_e carrier_type =
- NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
-
- /* check each carrier record and create matched record */
- for (idx = 0; idx < carrier_count; idx++)
- {
- if ((net_nfc_util_get_alternative_carrier_type(
- request_msg,idx,&carrier_type) != NET_NFC_OK) ||
- (carrier_type == NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN))
- {
- DEBUG_ERR_MSG("net_nfc_util_get_alternative"
- "_carrier_type failed or unknown");
- continue;
- }
-
- DEBUG_SERVER_MSG("carrier type = [%d]", carrier_type);
-
- /* add temporary config record */
- {
- net_nfc_carrier_config_s *config = NULL;
-
- if ((result = net_nfc_util_create_carrier_config(
- &config,carrier_type)) == NET_NFC_OK)
- {
- if ((result =
- net_nfc_util_create_ndef_record_with_carrier_config(
- &carrier_record,config)) == NET_NFC_OK)
- {
- DEBUG_SERVER_MSG("net_nfc_util_create_ndef_record_"
- "with_carrier_config success");
- }
- else
- {
- DEBUG_ERR_MSG("create_ndef_record_with_carrier_config "
- "failed [%d]", result);
- net_nfc_util_free_carrier_config(config);
- continue;
- }
-
- net_nfc_util_free_carrier_config(config);
- }
- else
- {
- DEBUG_ERR_MSG("net_nfc_util_get_local_bt_address return NULL");
- continue;
- }
- }
-
- /* append carrier configure record to selector message */
- if ((result = net_nfc_util_append_carrier_config_record(
- select_msg,
- carrier_record,
- NET_NFC_CONN_HANDOVER_CARRIER_INACTIVATE)) == NET_NFC_OK)
- {
- DEBUG_SERVER_MSG("net_nfc_util_append_carrier_config_record success");
- }
- else
- {
- DEBUG_ERR_MSG("net_nfc_util_append_carrier_config_record"
- " failed [%d]", result);
-
- net_nfc_util_free_record(carrier_record);
- }
- }
-
- result = NET_NFC_OK;
- }
- else
- {
- DEBUG_ERR_MSG("net_nfc_util_get_alternative_carrier_record_count failed");
- }
-
- LOGD("[%s] END", __func__);
-
- return result;
-}
-
net_nfc_error_e net_nfc_server_handover_process_carrier_record(
ndef_record_s *carrier, void *cb, void *user_param)
{
if (stat(file_name, &st) == -1)
{
- int result;
+ int ret;
char command[1024];
SECURE_LOGD("path doesn't exist, do mkdir : %s", file_name);
snprintf(command, sizeof(command), "mkdir -p -m 755 %s", file_name);
- result = system(command);
+ ret = system(command);
if (stat(file_name, &st) == -1)
{
- DEBUG_ERR_MSG("mkdir failed");
+ DEBUG_ERR_MSG("mkdir failed(%d)", ret);
return NET_NFC_UNKNOWN_ERROR;
}
}
data_h data,
void *user_data);
-net_nfc_connection_handover_info_h global_info = NULL;
+static net_nfc_connection_handover_info_h global_info = NULL;
static void run_next_callback(gpointer user_data)
type,
p2p_connection_handover_cb,
user_data);
+ g_print("net_nfc_client_p2p_connection_handover() : %d\n", result);
}
void net_nfc_test_p2p_connection_handover_sync(gpointer data,
type,
&out_carrier,
&out_data);
+ g_print("net_nfc_client_p2p_connection_handover_sync() : %d\n", result);
g_print("Received out carrier type & carrier type %d, %d\n", out_carrier, type);
print_received_data(out_data);
net_nfc_conn_handover_carrier_type_e type;
result = net_nfc_client_handover_get_alternative_carrier_type(global_info, &type);
+ g_print("net_nfc_client_handover_get_alternative_carrier_type() : %d\n", result);
g_print("Handover alternative carrier type -> %d", type);
}
static net_nfc_target_handle_h get_handle();
-
static void run_next_callback(gpointer user_data);
-
-static void jewel_read_cb(net_nfc_error_e result,
- data_h resp_data,
- void *user_data);
-;
-static void jewel_write_cb(net_nfc_error_e result,
- void* user_data);
-
+static void jewel_read_cb(net_nfc_error_e result, data_h resp_data, void *user_data);
+static void jewel_write_cb(net_nfc_error_e result, void* user_data);
static net_nfc_target_handle_h get_handle()
{
result = net_nfc_client_jewel_read_id(handle,
jewel_read_cb,
user_data);
+ g_print("net_nfc_client_jewel_read_id() : %d\n", result);
}
void net_nfc_test_tag_jewel_read_byte(gpointer data,
byte,
jewel_read_cb,
user_data);
+ g_print("net_nfc_client_jewel_read_byte() : %d\n", result);
}
void net_nfc_test_tag_jewel_read_all(gpointer data,
result = net_nfc_client_jewel_read_all(handle,
jewel_read_cb,
user_data);
+ g_print("net_nfc_client_jewel_read_all() : %d\n", result);
}
void net_nfc_test_tag_jewel_write_with_erase(gpointer data,
data_to_write,
jewel_write_cb,
user_data);
+ g_print("net_nfc_client_jewel_write_with_erase() : %d\n", result);
}
void net_nfc_test_tag_jewel_write_with_no_erase(gpointer data,
data_to_write,
jewel_write_cb,
user_data);
+ g_print("net_nfc_client_jewel_write_with_erase() : %d\n", result);
}
void net_nfc_test_tag_jewel_write_with_no_erase(gpointer data,
gpointer user_data);
-#endif
+#endif //__NET_NFC_TEST_JEWEL_TAG_H__
\ No newline at end of file
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-
#ifndef __NET_NFC_TEST_P2P_H__
#define __NET_NFC_TEST_P2P_H__
#include <glib.h>
#include "net_nfc_target_info.h"
-void net_nfc_test_p2p_send(gpointer data,
- gpointer user_data);
-
-void net_nfc_test_p2p_send_sync(gpointer data,
- gpointer user_data);
-
-void net_nfc_test_p2p_set_device_discovered(gpointer data,
- gpointer user_data);
-
-void net_nfc_test_p2p_set_device_detached(gpointer data,
- gpointer user_data);
-
-void net_nfc_test_p2p_set_data_received(gpointer data,
- gpointer user_data);
-
-void net_nfc_test_p2p_unset_device_discovered(gpointer data,
- gpointer user_data);
-
-void net_nfc_test_p2p_unset_device_detached(gpointer data,
- gpointer user_data);
-
-void net_nfc_test_p2p_unset_data_received(gpointer data,
- gpointer user_data);
-
+void net_nfc_test_p2p_send(gpointer data, gpointer user_data);
+void net_nfc_test_p2p_send_sync(gpointer data, gpointer user_data);
+void net_nfc_test_p2p_set_device_discovered(gpointer data,gpointer user_data);
+void net_nfc_test_p2p_set_device_detached(gpointer data, gpointer user_data);
+void net_nfc_test_p2p_set_data_received(gpointer data, gpointer user_data);
+void net_nfc_test_p2p_unset_device_discovered(gpointer data, gpointer user_data);
+void net_nfc_test_p2p_unset_device_detached(gpointer data, gpointer user_data);
+void net_nfc_test_p2p_unset_data_received(gpointer data, gpointer user_data);
net_nfc_target_handle_h net_nfc_test_device_get_target_handle(void);
-#endif
+#endif //__NET_NFC_TEST_P2P_H__
static void se_set_event_cb(net_nfc_message_e event, void *user_data);
-static void se_ese_detection_cb(net_nfc_target_handle_h handle,
- int dev_type, data_h data, void *user_data);
+static void se_ese_detection_cb(net_nfc_target_handle_h handle, int dev_type,
+ data_h data, void *user_data);
-static void se_set_transaction_cb(data_h aid,
- data_h param,
- void *user_data);
+static void se_set_transaction_cb(data_h aid, data_h param, void *user_data);
/*This handle would be intialized by open secure element callback function*/
static net_nfc_target_handle_h global_handle = NULL;
run_next_callback(user_data);
}
-static void se_ese_detection_cb(net_nfc_target_handle_h handle,
- int dev_type,
- data_h data,
- void *user_data)
+static void se_ese_detection_cb(net_nfc_target_handle_h handle, int dev_type,
+ data_h data, void *user_data)
{
g_print("Set ese detection callback successfully\n");
g_print("Handle is %#x\n", GPOINTER_TO_UINT(handle));
print_received_data(data);
}
-static void se_set_transaction_cb(data_h aid,
- data_h param,
- void *user_data)
+static void se_set_transaction_cb(data_h aid, data_h param, void *user_data)
{
g_print("Set transaction callback successfully\n");
g_print("*****displaying Aid data****\n");
run_next_callback(user_data);
}
-void net_nfc_test_se_send_apdu(gpointer data,
- gpointer user_data)
+void net_nfc_test_se_send_apdu(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
data_h apdu_data = NULL;
net_nfc_create_data(&apdu_data, apdu_cmd, 4);
- result = net_nfc_client_se_send_apdu(global_handle,
- apdu_data,
- send_apdu_cb,
- user_data);
+ result = net_nfc_client_se_send_apdu(global_handle, apdu_data, send_apdu_cb, user_data);
+ g_print("net_nfc_client_se_send_apdu() : %d\n", result);
}
-void net_nfc_test_se_send_apdu_sync(gpointer data,
- gpointer user_data)
+void net_nfc_test_se_send_apdu_sync(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
data_h apdu_data = NULL;
data_h response = NULL;
net_nfc_create_data(&apdu_data, apdu_cmd, 4);
- result = net_nfc_client_se_send_apdu_sync(global_handle,
- apdu_data,
- &response);
+ result = net_nfc_client_se_send_apdu_sync(global_handle, apdu_data, &response);
g_print(" Send apdu data sync completed %d\n", result);
print_received_data(response);
run_next_callback(user_data);
}
-void net_nfc_test_se_set_secure_element_type(gpointer data,
- gpointer user_data)
+void net_nfc_test_se_set_secure_element_type(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
net_nfc_se_type_e se_type = NET_NFC_SE_TYPE_UICC;
se_type,
set_secure_element_cb,
user_data);
+ g_print("net_nfc_client_se_set_secure_element_type() : %d\n", result);
}
void net_nfc_test_se_set_secure_element_type_sync(gpointer data,
se_type,
open_secure_element_cb,
user_data);
+ g_print("net_nfc_client_se_open_internal_secure_element() : %d\n", result);
}
void net_nfc_test_se_open_internal_secure_element_sync(gpointer data,
&global_handle);
g_print("Handle is %#x\n", GPOINTER_TO_UINT(global_handle));
- g_print(" open secure element completed %d\n", result);
+ g_print("open secure element completed %d\n", result);
run_next_callback(user_data);
}
global_handle,
close_secure_element_cb,
user_data);
+ g_print("net_nfc_client_se_close_internal_secure_element() : %d\n", result);
}
void net_nfc_test_se_close_internal_secure_element_sync(gpointer data,
run_next_callback(user_data);
}
-void net_nfc_test_se_get_atr(gpointer data,
- gpointer user_data)
+void net_nfc_test_se_get_atr(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
-
result = net_nfc_client_se_get_atr(
global_handle,
get_atr_secure_element_cb,
user_data);
+ g_print("net_nfc_client_se_get_atr() : %d\n", result);
}
-void net_nfc_test_se_get_atr_sync(gpointer data,
- gpointer user_data)
+void net_nfc_test_se_get_atr_sync(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
data_h attr_data = NULL;
- result = net_nfc_client_se_get_atr_sync(
- global_handle,
- &attr_data);
+ result = net_nfc_client_se_get_atr_sync(global_handle, &attr_data);
g_print("Get atr data sync completed %d\n", result);
print_received_data(attr_data);
run_next_callback(user_data);
}
-void net_nfc_test_se_set_event_cb(gpointer data,
- gpointer user_data)
+void net_nfc_test_se_set_event_cb(gpointer data, gpointer user_data)
{
- net_nfc_client_se_set_event_cb(se_set_event_cb,
- user_data);
+ net_nfc_client_se_set_event_cb(se_set_event_cb, user_data);
}
-void net_nfc_test_se_unset_event_cb(gpointer data,
- gpointer user_data)
+void net_nfc_test_se_unset_event_cb(gpointer data, gpointer user_data)
{
net_nfc_client_se_unset_event_cb();
g_print(" Event unset callback successfully\n");
}
-void net_nfc_test_se_set_ese_detection_cb(gpointer data,
- gpointer user_data)
+void net_nfc_test_se_set_ese_detection_cb(gpointer data, gpointer user_data)
{
- net_nfc_client_se_set_ese_detection_cb(se_ese_detection_cb,
- user_data);
+ net_nfc_client_se_set_ese_detection_cb(se_ese_detection_cb, user_data);
}
-void net_nfc_test_se_unset_ese_detection_cb(gpointer data,
- gpointer user_data)
+void net_nfc_test_se_unset_ese_detection_cb(gpointer data, gpointer user_data)
{
net_nfc_client_se_unset_ese_detection_cb();
g_print("Detection unset callback successfuly\n");
}
-void net_nfc_test_se_set_transaction_event_cb(gpointer data,
- gpointer user_data)
+void net_nfc_test_se_set_transaction_event_cb(gpointer data, gpointer user_data)
{
- net_nfc_client_se_set_transaction_event_cb(se_set_transaction_cb,
- user_data);
+ net_nfc_client_se_set_transaction_event_cb(se_set_transaction_cb, user_data);
}
void net_nfc_test_se_unset_transaction_event_cb(gpointer data,
static void run_next_callback(gpointer user_data);
-static void felica_cb(net_nfc_error_e result,
- data_h resp_data,
- void *user_data);
+static void felica_cb(net_nfc_error_e result, data_h resp_data, void *user_data);
static net_nfc_target_handle_h get_handle()
}
}
-static void felica_cb(net_nfc_error_e result,
- data_h resp_data,
- void *user_data)
+static void felica_cb(net_nfc_error_e result, data_h resp_data, void *user_data)
{
g_print("felica_cb Completed %d\n", result);
run_next_callback(user_data);
}
-void net_nfc_test_felica_poll(gpointer data,
- gpointer user_data)
+void net_nfc_test_felica_poll(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
net_nfc_target_handle_h handle = NULL;
return ;
result = net_nfc_client_felica_poll(handle, req_code, time_slot, felica_cb, user_data);
+
+ g_print("net_nfc_client_felica_poll() : %d\n", result);
}
-void net_nfc_test_felica_request_service(gpointer data,
- gpointer user_data)
+void net_nfc_test_felica_request_service(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
net_nfc_target_handle_h handle = NULL;
number_of_services,
felica_cb,
user_data);
+ g_print("net_nfc_client_felica_request_service() : %d\n", result);
}
-void net_nfc_test_felica_request_response(gpointer data,
- gpointer user_data)
+void net_nfc_test_felica_request_response(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
net_nfc_target_handle_h handle = NULL;
return ;
result = net_nfc_client_felica_request_response(handle, felica_cb, user_data);
+ g_print("net_nfc_client_felica_request_response() : %d\n", result);
}
void net_nfc_test_felica_read_without_encryption(gpointer data,
net_nfc_error_e result = NET_NFC_OK;
net_nfc_target_handle_h handle = NULL;
uint8_t number_of_services = 10;
- uint16_t service_list[2] = {0,};
+ uint16_t service_list[10] = {0,};
uint8_t number_of_blocks = 1;
uint8_t block_list[3] = {0,};
block_list,
felica_cb,
user_data);
+ g_print("net_nfc_client_felica_read_without_encryption() : %d\n", result);
}
void net_nfc_test_felica_write_without_encryption(gpointer data,
data_to_write,
felica_cb,
user_data);
+ g_print("net_nfc_client_felica_write_without_encryption() : %d\n", result);
}
-void net_nfc_test_felica_request_system_code(gpointer data,
- gpointer user_data)
+void net_nfc_test_felica_request_system_code(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
net_nfc_target_handle_h handle = NULL;
return ;
result = net_nfc_client_felica_request_system_code(handle, felica_cb, user_data);
+ g_print("net_nfc_client_felica_request_system_code() : %d\n", result);
}
}
-void net_nfc_test_tag_mifare_read(gpointer data,
- gpointer user_data)
+void net_nfc_test_tag_mifare_read(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
net_nfc_target_handle_h handle = NULL;
}
g_print("Handle is %#x\n", GPOINTER_TO_UINT(handle));
- result = net_nfc_client_mifare_read(handle,
- block_index,
- mifare_read_cb,
- user_data);
+ result = net_nfc_client_mifare_read(handle, block_index, mifare_read_cb, user_data);
+
+ g_print("net_nfc_client_mifare_read() : %d\n", result);
}
-void net_nfc_test_tag_mifare_write_block(gpointer data,
- gpointer user_data)
+void net_nfc_test_tag_mifare_write_block(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
net_nfc_target_handle_h handle = NULL;
(data_h)& write_data,
mifare_write_block_cb,
user_data);
+
+ g_print("net_nfc_client_mifare_write_block() : %d\n", result);
}
-void net_nfc_test_tag_mifare_write_page(gpointer data,
- gpointer user_data)
+void net_nfc_test_tag_mifare_write_page(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
net_nfc_target_handle_h handle = NULL;
(data_h)& write_data,
mifare_write_page_cb,
user_data);
+
+ g_print("net_nfc_client_mifare_write_page() : %d\n", result);
}
-void net_nfc_test_tag_mifare_increment(gpointer data,
- gpointer user_data)
+void net_nfc_test_tag_mifare_increment(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
net_nfc_target_handle_h handle = NULL;
value,
mifare_write_mifare_incr_cb,
user_data);
+
+ g_print("net_nfc_client_mifare_increment() : %d\n", result);
}
-void net_nfc_test_tag_mifare_decrement(gpointer data,
- gpointer user_data)
+void net_nfc_test_tag_mifare_decrement(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
net_nfc_target_handle_h handle = NULL;
value,
mifare_write_mifare_decr_cb,
user_data);
+
+ g_print("net_nfc_client_mifare_decrement() : %d\n", result);
}
-void net_nfc_test_tag_mifare_transfer(gpointer data,
- gpointer user_data)
+void net_nfc_test_tag_mifare_transfer(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
net_nfc_target_handle_h handle = NULL;
block_index,
mifare_write_mifare_transfer_cb,
user_data);
+
+ g_print("net_nfc_client_mifare_transfer() : %d\n", result);
}
-void net_nfc_test_tag_mifare_restore(gpointer data,
- gpointer user_data)
+void net_nfc_test_tag_mifare_restore(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
net_nfc_target_handle_h handle = NULL;
block_index,
mifare_write_mifare_restore_cb,
user_data);
+
+ g_print("net_nfc_client_mifare_restore() : %d\n", result);
}
void net_nfc_test_tag_mifare_authenticate_with_keyA(gpointer data,
auth_key,
mifare_write_auth_keyA_cb,
user_data);
+
+ g_print("net_nfc_client_mifare_authenticate_with_keyA() : %d\n", result);
}
void net_nfc_test_tag_mifare_authenticate_with_keyB(gpointer data,
auth_key,
mifare_write_auth_keyB_cb,
user_data);
+
+ g_print("net_nfc_client_mifare_authenticate_with_keyB() : %d\n", result);
}
run_next_callback(user_data);
}
-void net_nfc_test_transceive(gpointer data,
- gpointer user_data)
+void net_nfc_test_transceive(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
data_s raw_data = {NULL,};
(data_h)&raw_data,
call_transceive_cb,
user_data);
+ g_print("net_nfc_client_transceive() : %d\n", result);
}
-void net_nfc_test_transceive_sync(gpointer data,
- gpointer user_data)
+void net_nfc_test_transceive_sync(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
data_s raw_data = {NULL,};
result = net_nfc_client_transceive_sync(handle, (data_h)& raw_data);
- g_print("Transceive Sync is completed \n");
+ g_print("Transceive Sync is completed(%d)\n", result);
}
-void net_nfc_test_transceive_data(gpointer data,
- gpointer user_data)
+void net_nfc_test_transceive_data(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
data_s raw_data = {NULL,};
(data_h) &raw_data,
call_transceive_data_cb,
user_data);
+ g_print("net_nfc_client_transceive_data() : %d\n", result);
}
-void net_nfc_test_transceive_data_sync(gpointer data,
- gpointer user_data)
+void net_nfc_test_transceive_data_sync(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
data_s raw_data = {NULL};
net_nfc_get_tag_handle(info, &handle);
result = net_nfc_client_transceive_data_sync(handle, &raw_data, &response);
+ g_print("net_nfc_client_transceive_data_sync() : %d\n", result);
if (NET_NFC_OK == result)
print_received_data(response);
projects / platform / core / connectivity / nfc-manager.git / commitdiff