From feae8feedb4838bf025e8f608e392cd01536a391 Mon Sep 17 00:00:00 2001 From: Wonkyu Kwon Date: Fri, 6 Sep 2013 10:42:29 +0900 Subject: [PATCH] Add functions converting between GVariant and ndef message. Change-Id: I5e6632fd4c4a080b626753ae88b2a08c175ff834 --- client/include/net_nfc_client_se.h | 4 +- client/net_nfc_client_ndef.c | 339 ++++++++++++----------------------- client/net_nfc_client_ndef_message.c | 45 +++-- client/net_nfc_client_ndef_record.c | 128 +++++++------ client/net_nfc_client_snep.c | 146 ++++++--------- common/net_nfc_util_gdbus.c | 71 ++++++++ common/net_nfc_util_gdbus_internal.h | 7 +- daemon/net_nfc_server_common.c | 42 ++--- daemon/net_nfc_server_manager.c | 20 ++- 9 files changed, 380 insertions(+), 422 deletions(-) diff --git a/client/include/net_nfc_client_se.h b/client/include/net_nfc_client_se.h index 9b4592d..b6c5ab5 100644 --- a/client/include/net_nfc_client_se.h +++ b/client/include/net_nfc_client_se.h @@ -28,7 +28,7 @@ typedef void (*net_nfc_se_set_card_emulation_cb)(net_nfc_error_e result, void *user_data); typedef void (*net_nfc_se_open_se_cb)(net_nfc_error_e result, - net_nfc_target_handle_h handle, void *user_data); + net_nfc_target_handle_h handle, void *user_data); typedef void (*net_nfc_se_close_se_cb)(net_nfc_error_e result, void *user_data); @@ -63,7 +63,7 @@ net_nfc_error_e net_nfc_client_se_get_secure_element_type(void *user_data); net_nfc_error_e net_nfc_client_se_get_secure_element_type_sync( - gint *se_type); + net_nfc_se_type_e *se_type); net_nfc_error_e net_nfc_set_card_emulation_mode( net_nfc_card_emulation_mode_t mode, diff --git a/client/net_nfc_client_ndef.c b/client/net_nfc_client_ndef.c index 767d405..048e16d 100644 --- a/client/net_nfc_client_ndef.c +++ b/client/net_nfc_client_ndef.c @@ -27,19 +27,8 @@ #include "net_nfc_client_ndef.h" #include "net_nfc_client_tag_internal.h" -typedef struct _NdefFuncData NdefFuncData; - -struct _NdefFuncData -{ - gpointer callback; - gpointer user_data; -}; - static NetNfcGDbusNdef *ndef_proxy = NULL; -static ndef_message_h ndef_variant_to_message(GVariant *variant); - -static GVariant *ndef_message_to_variant(ndef_message_h message); static gboolean ndef_is_supported_tag(void); @@ -59,59 +48,6 @@ static void ndef_call_format(GObject *source_object, GAsyncResult *res, gpointer user_data); -static ndef_message_h ndef_variant_to_message(GVariant *variant) -{ - data_s data; - ndef_message_h message = NULL; - - net_nfc_util_gdbus_variant_to_data_s(variant, &data); - - if (data.buffer && data.length > 0) - { - if (net_nfc_create_ndef_message_from_rawdata(&message, &data) - != NET_NFC_OK) - { - DEBUG_ERR_MSG("memory alloc fail..."); - } - - net_nfc_util_free_data(&data); - } - - return message; -} - -static GVariant *ndef_message_to_variant(ndef_message_h message) -{ - guint length; - data_s data; - GVariant *variant = NULL; - - length = net_nfc_util_get_ndef_message_length( - (ndef_message_s *)message); - - if (length == 0) - { - DEBUG_ERR_MSG("message length is 0"); - return NULL; - } - - data.length = length; - data.buffer = g_new0(guint8, length); - - if(net_nfc_util_convert_ndef_message_to_rawdata( - (ndef_message_s *)message, - &data) != NET_NFC_OK) - { - DEBUG_ERR_MSG("can not convert ndef_message to rawdata"); - return NULL; - } - - variant = net_nfc_util_gdbus_data_to_variant(&data); - - g_free(data.buffer); - - return variant; -} static gboolean ndef_is_supported_tag(void) { @@ -122,7 +58,7 @@ static gboolean ndef_is_supported_tag(void) if (target_info == NULL) { DEBUG_ERR_MSG("target_info does not exist"); - return TRUE; + return FALSE; } switch (target_info->devType) @@ -146,15 +82,13 @@ static void ndef_call_read(GObject *source_object, GAsyncResult *res, gpointer user_data) { - NdefFuncData *func_data; + NetNfcCallback *func_data = (NetNfcCallback *)user_data; net_nfc_error_e out_result = NET_NFC_OK; + GVariant *out_data = NULL; GError *error = NULL; - net_nfc_client_ndef_read_completed callback; - - GVariant *out_data = NULL; - ndef_message_h message = NULL; + g_assert(user_data != NULL); if (net_nfc_gdbus_ndef_call_read_finish( NET_NFC_GDBUS_NDEF(source_object), @@ -163,34 +97,25 @@ static void ndef_call_read(GObject *source_object, res, &error) == FALSE) { - out_result = NET_NFC_UNKNOWN_ERROR; DEBUG_ERR_MSG("Can not finish read: %s", error->message); g_error_free(error); - } - func_data = (NdefFuncData *)user_data; - if (func_data == NULL) - { - DEBUG_ERR_MSG("can not get NdefFuncData"); - return; + out_result = NET_NFC_IPC_FAIL; } - if (func_data->callback == NULL) + if (func_data->callback != NULL) { - DEBUG_CLIENT_MSG("callback function is not avaiilable"); - g_free(func_data); - return; - } + net_nfc_client_ndef_read_completed callback = + (net_nfc_client_ndef_read_completed)func_data->callback; + ndef_message_h message; - if (out_result == NET_NFC_OK) - message = ndef_variant_to_message(out_data); + message = net_nfc_util_gdbus_variant_to_ndef_message(out_data); - callback = (net_nfc_client_ndef_read_completed)func_data->callback; - callback(out_result, message, func_data->user_data); + callback(out_result, message, func_data->user_data); - if (message) net_nfc_util_free_ndef_message(message); + } g_free(func_data); } @@ -199,12 +124,12 @@ static void ndef_call_write(GObject *source_object, GAsyncResult *res, gpointer user_data) { - NdefFuncData *func_data; + NetNfcCallback *func_data = (NetNfcCallback *)user_data; net_nfc_error_e out_result = NET_NFC_OK; GError *error = NULL; - net_nfc_client_ndef_write_completed callback; + g_assert(user_data != NULL); if (net_nfc_gdbus_ndef_call_write_finish( NET_NFC_GDBUS_NDEF(source_object), @@ -212,28 +137,20 @@ static void ndef_call_write(GObject *source_object, res, &error) == FALSE) { - out_result = NET_NFC_UNKNOWN_ERROR; DEBUG_ERR_MSG("Can not finish write: %s", error->message); g_error_free(error); - } - func_data = (NdefFuncData *)user_data; - if (func_data == NULL) - { - DEBUG_ERR_MSG("can not get NdefFuncData"); - return; + out_result = NET_NFC_IPC_FAIL; } - if (func_data->callback == NULL) + if (func_data->callback != NULL) { - DEBUG_CLIENT_MSG("callback function is not avaiilable"); - g_free(func_data); - return; - } + net_nfc_client_ndef_write_completed callback = + (net_nfc_client_ndef_write_completed)func_data->callback; - callback = (net_nfc_client_ndef_write_completed)func_data->callback; - callback(out_result, func_data->user_data); + callback(out_result, func_data->user_data); + } g_free(func_data); } @@ -242,12 +159,12 @@ static void ndef_call_make_read_only(GObject *source_object, GAsyncResult *res, gpointer user_data) { - NdefFuncData *func_data; + NetNfcCallback *func_data = (NetNfcCallback *)user_data; net_nfc_error_e out_result = NET_NFC_OK; GError *error = NULL; - net_nfc_client_ndef_make_read_only_completed callback; + g_assert(user_data != NULL); if (net_nfc_gdbus_ndef_call_make_read_only_finish( NET_NFC_GDBUS_NDEF(source_object), @@ -255,30 +172,21 @@ static void ndef_call_make_read_only(GObject *source_object, res, &error) == FALSE) { - out_result = NET_NFC_UNKNOWN_ERROR; DEBUG_ERR_MSG("Can not finish make read only: %s", error->message); g_error_free(error); - } - func_data = (NdefFuncData *)user_data; - if (func_data == NULL) - { - DEBUG_ERR_MSG("can not get NdefFuncData"); - return; + out_result = NET_NFC_IPC_FAIL; } - if (func_data->callback == NULL) + if (func_data->callback != NULL) { - DEBUG_CLIENT_MSG("callback function is not avaiilable"); - g_free(func_data); - return; - } + net_nfc_client_ndef_make_read_only_completed callback = + (net_nfc_client_ndef_make_read_only_completed)func_data->callback; - callback = (net_nfc_client_ndef_make_read_only_completed) - func_data->callback; - callback(out_result, func_data->user_data); + callback(out_result, func_data->user_data); + } g_free(func_data); } @@ -287,12 +195,12 @@ static void ndef_call_format(GObject *source_object, GAsyncResult *res, gpointer user_data) { - NdefFuncData *func_data; + NetNfcCallback *func_data = (NetNfcCallback *)user_data; net_nfc_error_e out_result = NET_NFC_OK; GError *error = NULL; - net_nfc_client_ndef_format_completed callback; + g_assert(user_data != NULL); if (net_nfc_gdbus_ndef_call_format_finish( NET_NFC_GDBUS_NDEF(source_object), @@ -300,28 +208,20 @@ static void ndef_call_format(GObject *source_object, res, &error) == FALSE) { - out_result = NET_NFC_UNKNOWN_ERROR; DEBUG_ERR_MSG("Can not finish format: %s", error->message); g_error_free(error); - } - func_data = (NdefFuncData *)user_data; - if (func_data == NULL) - { - DEBUG_ERR_MSG("can not get NdefFuncData"); - return; + out_result = NET_NFC_IPC_FAIL; } - if (func_data->callback == NULL) + if (func_data->callback != NULL) { - DEBUG_CLIENT_MSG("callback function is not avaiilable"); - g_free(func_data); - return; - } + net_nfc_client_ndef_format_completed callback = + (net_nfc_client_ndef_format_completed)func_data->callback; - callback = (net_nfc_client_ndef_format_completed) func_data->callback; - callback(out_result, func_data->user_data); + callback(out_result, func_data->user_data); + } g_free(func_data); } @@ -330,12 +230,15 @@ API net_nfc_error_e net_nfc_client_ndef_read(net_nfc_target_handle_h handle, net_nfc_client_ndef_read_completed callback, void *user_data) { - NdefFuncData *func_data; + NetNfcCallback *func_data; + + if (handle == NULL) + return NET_NFC_NULL_PARAMETER; if (ndef_proxy == NULL) { DEBUG_ERR_MSG("Can not get NdefProxy"); - return NET_NFC_UNKNOWN_ERROR; + return NET_NFC_NOT_INITIALIZED; } /* prevent executing daemon when nfc is off */ @@ -343,15 +246,15 @@ API net_nfc_error_e net_nfc_client_ndef_read(net_nfc_target_handle_h handle, return NET_NFC_INVALID_STATE; } - DEBUG_CLIENT_MSG("send reqeust :: read ndef = [%p]", handle); - - if (handle == NULL) - return NET_NFC_NULL_PARAMETER; - if (net_nfc_client_tag_is_connected() == FALSE) - return NET_NFC_OPERATION_FAIL; + return NET_NFC_NOT_CONNECTED; + + DEBUG_CLIENT_MSG("send request :: read ndef = [%p]", handle); - func_data = g_new0(NdefFuncData, 1); + func_data = g_try_new0(NetNfcCallback, 1); + if (func_data == NULL) { + return NET_NFC_ALLOC_FAIL; + } func_data->callback = (gpointer)callback; func_data->user_data = user_data; @@ -369,15 +272,17 @@ API net_nfc_error_e net_nfc_client_ndef_read(net_nfc_target_handle_h handle, API net_nfc_error_e net_nfc_client_ndef_read_sync(net_nfc_target_handle_h handle, ndef_message_h *message) { + net_nfc_error_e out_result = NET_NFC_OK; GVariant *out_data = NULL; GError *error = NULL; - net_nfc_error_e out_result = NET_NFC_OK; + if (handle == NULL) + return NET_NFC_NULL_PARAMETER; if (ndef_proxy == NULL) { DEBUG_ERR_MSG("Can not get NdefProxy"); - return NET_NFC_UNKNOWN_ERROR; + return NET_NFC_NOT_INITIALIZED; } /* prevent executing daemon when nfc is off */ @@ -385,13 +290,10 @@ API net_nfc_error_e net_nfc_client_ndef_read_sync(net_nfc_target_handle_h handle return NET_NFC_INVALID_STATE; } - DEBUG_CLIENT_MSG("send reqeust :: read ndef = [%p]", handle); - - if (handle == NULL) - return NET_NFC_NULL_PARAMETER; - if (net_nfc_client_tag_is_connected() == FALSE) - return NET_NFC_OPERATION_FAIL; + return NET_NFC_NOT_CONNECTED; + + DEBUG_CLIENT_MSG("send request :: read ndef = [%p]", handle); if (net_nfc_gdbus_ndef_call_read_sync(ndef_proxy, GPOINTER_TO_UINT(handle), @@ -399,16 +301,15 @@ API net_nfc_error_e net_nfc_client_ndef_read_sync(net_nfc_target_handle_h handle (gint *)&out_result, &out_data, NULL, - &error) == FALSE) - { + &error) == TRUE) { + *message = net_nfc_util_gdbus_variant_to_ndef_message(out_data); + } else { DEBUG_ERR_MSG("can not call read: %s", error->message); g_error_free(error); - return NET_NFC_UNKNOWN_ERROR; + out_result = NET_NFC_IPC_FAIL; } - *message = ndef_variant_to_message(out_data); - return out_result; } @@ -417,14 +318,16 @@ API net_nfc_error_e net_nfc_client_ndef_write(net_nfc_target_handle_h handle, net_nfc_client_ndef_write_completed callback, void *user_data) { - NdefFuncData *func_data; + NetNfcCallback *func_data; + GVariant *arg_data; - GVariant *arg_data = NULL; + if (handle == NULL || message == NULL) + return NET_NFC_NULL_PARAMETER; if (ndef_proxy == NULL) { DEBUG_ERR_MSG("Can not get NdefProxy"); - return NET_NFC_UNKNOWN_ERROR; + return NET_NFC_NOT_INITIALIZED; } /* prevent executing daemon when nfc is off */ @@ -432,23 +335,18 @@ API net_nfc_error_e net_nfc_client_ndef_write(net_nfc_target_handle_h handle, return NET_NFC_INVALID_STATE; } - if (handle == NULL) - return NET_NFC_NULL_PARAMETER; - - if (message == NULL) - return NET_NFC_NULL_PARAMETER; - if (net_nfc_client_tag_is_connected() == FALSE) - return NET_NFC_OPERATION_FAIL; + return NET_NFC_NOT_CONNECTED; - func_data = g_new0(NdefFuncData, 1); + func_data = g_try_new0(NetNfcCallback, 1); + if (func_data == NULL) { + return NET_NFC_ALLOC_FAIL; + } func_data->callback = (gpointer)callback; func_data->user_data = user_data; - arg_data = ndef_message_to_variant(message); - if (arg_data == NULL) - return NET_NFC_INVALID_PARAM; + arg_data = net_nfc_util_gdbus_ndef_message_to_variant(message); net_nfc_gdbus_ndef_call_write(ndef_proxy, GPOINTER_TO_UINT(handle), @@ -464,15 +362,17 @@ API net_nfc_error_e net_nfc_client_ndef_write(net_nfc_target_handle_h handle, API net_nfc_error_e net_nfc_client_ndef_write_sync(net_nfc_target_handle_h handle, ndef_message_h message) { - GVariant *arg_data = NULL; + net_nfc_error_e out_result = NET_NFC_OK; GError *error = NULL; + GVariant *arg_data; - net_nfc_error_e out_result = NET_NFC_OK; + if (handle == NULL || message == NULL) + return NET_NFC_NULL_PARAMETER; if (ndef_proxy == NULL) { DEBUG_ERR_MSG("Can not get NdefProxy"); - return NET_NFC_UNKNOWN_ERROR; + return NET_NFC_NOT_INITIALIZED; } /* prevent executing daemon when nfc is off */ @@ -480,18 +380,10 @@ API net_nfc_error_e net_nfc_client_ndef_write_sync(net_nfc_target_handle_h handl return NET_NFC_INVALID_STATE; } - if (handle == NULL) - return NET_NFC_NULL_PARAMETER; - - if (message == NULL) - return NET_NFC_NULL_PARAMETER; - if (net_nfc_client_tag_is_connected() == FALSE) - return NET_NFC_OPERATION_FAIL; + return NET_NFC_NOT_CONNECTED; - arg_data = ndef_message_to_variant(message); - if (arg_data == NULL) - return NET_NFC_INVALID_PARAM; + arg_data = net_nfc_util_gdbus_ndef_message_to_variant(message); if (net_nfc_gdbus_ndef_call_write_sync(ndef_proxy , GPOINTER_TO_UINT(handle), @@ -504,7 +396,7 @@ API net_nfc_error_e net_nfc_client_ndef_write_sync(net_nfc_target_handle_h handl DEBUG_ERR_MSG("can not call write: %s", error->message); g_error_free(error); - return NET_NFC_UNKNOWN_ERROR; + out_result = NET_NFC_IPC_FAIL; } return out_result; @@ -515,12 +407,15 @@ API net_nfc_error_e net_nfc_client_ndef_make_read_only( net_nfc_client_ndef_make_read_only_completed callback, void *user_data) { - NdefFuncData *func_data; + NetNfcCallback *func_data; + + if (handle == NULL) + return NET_NFC_NULL_PARAMETER; if (ndef_proxy == NULL) { DEBUG_ERR_MSG("Can not get NdefProxy"); - return NET_NFC_UNKNOWN_ERROR; + return NET_NFC_NOT_INITIALIZED; } /* prevent executing daemon when nfc is off */ @@ -528,16 +423,17 @@ API net_nfc_error_e net_nfc_client_ndef_make_read_only( return NET_NFC_INVALID_STATE; } - if (handle == NULL) - return NET_NFC_NULL_PARAMETER; if (net_nfc_client_tag_is_connected() == FALSE) - return NET_NFC_OPERATION_FAIL; + return NET_NFC_NOT_CONNECTED; if (ndef_is_supported_tag() == FALSE) return NET_NFC_NOT_SUPPORTED; - func_data = g_new0(NdefFuncData, 1); + func_data = g_try_new0(NetNfcCallback, 1); + if (func_data == NULL) { + return NET_NFC_ALLOC_FAIL; + } func_data->callback = (gpointer)callback; func_data->user_data = user_data; @@ -555,14 +451,16 @@ API net_nfc_error_e net_nfc_client_ndef_make_read_only( API net_nfc_error_e net_nfc_client_ndef_make_read_only_sync( net_nfc_target_handle_h handle) { + net_nfc_error_e out_result = NET_NFC_OK; GError *error = NULL; - net_nfc_error_e out_result = NET_NFC_OK; + if (handle == NULL) + return NET_NFC_NULL_PARAMETER; if (ndef_proxy == NULL) { DEBUG_ERR_MSG("Can not get NdefProxy"); - return NET_NFC_UNKNOWN_ERROR; + return NET_NFC_NOT_INITIALIZED; } /* prevent executing daemon when nfc is off */ @@ -570,11 +468,9 @@ API net_nfc_error_e net_nfc_client_ndef_make_read_only_sync( return NET_NFC_INVALID_STATE; } - if (handle == NULL) - return NET_NFC_NULL_PARAMETER; if (net_nfc_client_tag_is_connected() == FALSE) - return NET_NFC_OPERATION_FAIL; + return NET_NFC_NOT_CONNECTED; if (ndef_is_supported_tag() == FALSE) return NET_NFC_NOT_SUPPORTED; @@ -589,7 +485,7 @@ API net_nfc_error_e net_nfc_client_ndef_make_read_only_sync( DEBUG_ERR_MSG("can not make read only: %s", error->message); g_error_free(error); - return NET_NFC_UNKNOWN_ERROR; + out_result = NET_NFC_IPC_FAIL; } return out_result; @@ -598,14 +494,16 @@ API net_nfc_error_e net_nfc_client_ndef_make_read_only_sync( API net_nfc_error_e net_nfc_client_ndef_format(net_nfc_target_handle_h handle, data_h key, net_nfc_client_ndef_format_completed callback, void *user_data) { - NdefFuncData *func_data; - GVariant *arg_data = NULL; + NetNfcCallback *func_data; + GVariant *arg_data; + if (handle == NULL) + return NET_NFC_NULL_PARAMETER; if (ndef_proxy == NULL) { DEBUG_ERR_MSG("Can not get NdefProxy"); - return NET_NFC_UNKNOWN_ERROR; + return NET_NFC_NOT_INITIALIZED; } /* prevent executing daemon when nfc is off */ @@ -613,21 +511,17 @@ API net_nfc_error_e net_nfc_client_ndef_format(net_nfc_target_handle_h handle, return NET_NFC_INVALID_STATE; } - if (handle == NULL) - return NET_NFC_NULL_PARAMETER; - - if (key == NULL) - arg_data = net_nfc_util_gdbus_buffer_to_variant(NULL, 0); - else - arg_data = net_nfc_util_gdbus_data_to_variant((data_s *)key); - - if (arg_data == NULL) - return NET_NFC_INVALID_PARAM; + if (net_nfc_client_tag_is_connected() == FALSE) + return NET_NFC_NOT_CONNECTED; - func_data = g_new0(NdefFuncData, 1); + func_data = g_try_new0(NetNfcCallback, 1); + if (func_data == NULL) { + return NET_NFC_ALLOC_FAIL; + } func_data->callback = (gpointer)callback; func_data->user_data = user_data; + arg_data = net_nfc_util_gdbus_data_to_variant((data_s *)key); net_nfc_gdbus_ndef_call_format(ndef_proxy, GPOINTER_TO_UINT(handle), @@ -643,15 +537,17 @@ API net_nfc_error_e net_nfc_client_ndef_format(net_nfc_target_handle_h handle, API net_nfc_error_e net_nfc_client_ndef_format_sync( net_nfc_target_handle_h handle, data_h key) { - GVariant *arg_data = NULL; + net_nfc_error_e out_result = NET_NFC_OK; + GVariant *arg_data; GError *error = NULL; - net_nfc_error_e out_result = NET_NFC_OK; + if (handle == NULL) + return NET_NFC_NULL_PARAMETER; if (ndef_proxy == NULL) { DEBUG_ERR_MSG("Can not get NdefProxy"); - return NET_NFC_UNKNOWN_ERROR; + return NET_NFC_NOT_INITIALIZED; } /* prevent executing daemon when nfc is off */ @@ -659,16 +555,11 @@ API net_nfc_error_e net_nfc_client_ndef_format_sync( return NET_NFC_INVALID_STATE; } - if (handle == NULL) - return NET_NFC_NULL_PARAMETER; + if (net_nfc_client_tag_is_connected() == FALSE) + return NET_NFC_NOT_CONNECTED; - if (key == NULL) - arg_data = net_nfc_util_gdbus_buffer_to_variant(NULL, 0); - else - arg_data = net_nfc_util_gdbus_data_to_variant((data_s *)key); + arg_data = net_nfc_util_gdbus_data_to_variant((data_s *)key); - if (arg_data == NULL) - return NET_NFC_INVALID_PARAM; if (net_nfc_gdbus_ndef_call_format_sync(ndef_proxy , GPOINTER_TO_UINT(handle), @@ -681,7 +572,7 @@ API net_nfc_error_e net_nfc_client_ndef_format_sync( DEBUG_ERR_MSG("can not call format: %s", error->message); g_error_free(error); - return NET_NFC_UNKNOWN_ERROR; + out_result = NET_NFC_IPC_FAIL; } return out_result; diff --git a/client/net_nfc_client_ndef_message.c b/client/net_nfc_client_ndef_message.c index 10b29fd..4e66b69 100644 --- a/client/net_nfc_client_ndef_message.c +++ b/client/net_nfc_client_ndef_message.c @@ -13,6 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +#include #include "net_nfc_debug_internal.h" #include "net_nfc_util_internal.h" @@ -121,11 +122,11 @@ API net_nfc_error_e net_nfc_free_ndef_message(ndef_message_h ndef_message) API net_nfc_error_e net_nfc_get_ndef_message_record_count( ndef_message_h ndef_message, int *count) { + ndef_message_s *msg = (ndef_message_s *)ndef_message; + if (ndef_message == NULL || count == NULL) return NET_NFC_NULL_PARAMETER; - ndef_message_s *msg = (ndef_message_s *)ndef_message; - *count = msg->recordCount; return NET_NFC_OK; @@ -165,7 +166,7 @@ API net_nfc_error_e net_nfc_retrieve_current_ndef_message( ndef_message_h* ndef_message) { net_nfc_error_e result = NET_NFC_UNKNOWN_ERROR; - char file_path[1024] = {0}; + char file_path[PATH_MAX] = { 0, }; FILE *fp = NULL; if (ndef_message == NULL) @@ -187,29 +188,37 @@ API net_nfc_error_e net_nfc_retrieve_current_ndef_message( if (size > 0) { - uint8_t *buffer = NULL; + data_s data = { NULL, 0 }; - _net_nfc_util_alloc_mem(buffer, size); - if (buffer != NULL) + if (net_nfc_util_alloc_data(&data, size) == true) { + int current; + size_t offset = 0; /* read fully */ - if ((size = fread(buffer, 1, size, fp)) > 0) - { - data_h data = NULL; - if ((result = net_nfc_create_data(&data, buffer, size)) == NET_NFC_OK) - { - result = net_nfc_create_ndef_message_from_rawdata(ndef_message, data); - - net_nfc_free_data(data); - } + do { + current = fread(data.buffer + offset, 1, + data.length - offset, fp); + if (current > 0) + offset += current; + else + break; + } while (offset < data.length); + + if (offset == data.length) { + result = net_nfc_create_ndef_message_from_rawdata(ndef_message, &data); + } else { + DEBUG_ERR_MSG("failed to read ndef message"); } - - _net_nfc_util_free_mem(buffer); + net_nfc_util_free_data(&data); + } + else + { + result = NET_NFC_ALLOC_FAIL; } } else { - result = NET_NFC_ALLOC_FAIL; + result = NET_NFC_NO_NDEF_MESSAGE; } fclose(fp); diff --git a/client/net_nfc_client_ndef_record.c b/client/net_nfc_client_ndef_record.c index 22f8892..caec3be 100644 --- a/client/net_nfc_client_ndef_record.c +++ b/client/net_nfc_client_ndef_record.c @@ -43,11 +43,12 @@ API net_nfc_error_e net_nfc_free_record(ndef_record_h record) API net_nfc_error_e net_nfc_get_record_payload(ndef_record_h record, data_h * payload) { + ndef_record_s *struct_record = (ndef_record_s *)record; + if (record == NULL || payload == NULL) { return NET_NFC_NULL_PARAMETER; } - ndef_record_s * struct_record = (ndef_record_s *)record; *payload = (data_h)&(struct_record->payload_s); @@ -56,11 +57,12 @@ API net_nfc_error_e net_nfc_get_record_payload(ndef_record_h record, data_h * pa API net_nfc_error_e net_nfc_get_record_type(ndef_record_h record, data_h * type) { + ndef_record_s *struct_record = (ndef_record_s *)record; + if (record == NULL || type == NULL) { return NET_NFC_NULL_PARAMETER; } - ndef_record_s * struct_record = (ndef_record_s *)record; *type = (data_h)&(struct_record->type_s); @@ -70,11 +72,12 @@ API net_nfc_error_e net_nfc_get_record_type(ndef_record_h record, data_h * type) API net_nfc_error_e net_nfc_get_record_id(ndef_record_h record, data_h * id) { + ndef_record_s *struct_record = (ndef_record_s *)record; + if (record == NULL || id == NULL) { return NET_NFC_NULL_PARAMETER; } - ndef_record_s * struct_record = (ndef_record_s *)record; *id = (data_h)&(struct_record->id_s); @@ -84,11 +87,12 @@ API net_nfc_error_e net_nfc_get_record_id(ndef_record_h record, data_h * id) API net_nfc_error_e net_nfc_get_record_tnf(ndef_record_h record, net_nfc_record_tnf_e * TNF) { + ndef_record_s *struct_record = (ndef_record_s *)record; + if (record == NULL || TNF == NULL) { return NET_NFC_NULL_PARAMETER; } - ndef_record_s * struct_record = (ndef_record_s *)record; *TNF = (net_nfc_record_tnf_e)struct_record->TNF; @@ -98,25 +102,25 @@ API net_nfc_error_e net_nfc_get_record_tnf(ndef_record_h record, net_nfc_record_ API net_nfc_error_e net_nfc_set_record_id(ndef_record_h record, data_h id) { - ndef_record_s * tmp_record = (ndef_record_s *)record; data_s * tmp_id = (data_s *)id; - if (tmp_id == NULL) + if (record == NULL || tmp_id == NULL) { return NET_NFC_NULL_PARAMETER; } - return net_nfc_util_set_record_id(tmp_record, tmp_id->buffer, tmp_id->length); + return net_nfc_util_set_record_id((ndef_record_s *)record, + tmp_id->buffer, tmp_id->length); } API net_nfc_error_e net_nfc_get_record_flags(ndef_record_h record, uint8_t * flag) { + ndef_record_s *struct_record = (ndef_record_s *)record; + if (record == NULL || flag == NULL) { return NET_NFC_NULL_PARAMETER; } - ndef_record_s * struct_record = (ndef_record_s *)record; - *flag = struct_record->MB; *flag <<= 1; *flag += struct_record->ME; @@ -157,30 +161,43 @@ API uint8_t net_nfc_get_record_il(uint8_t flag) return ((flag >> 3) & 0x01); } +static bool _is_text_record(ndef_record_h record) +{ + bool result = false; + data_h type; + + if ((net_nfc_get_record_type(record, &type) == NET_NFC_OK) && + (strncmp((char *)net_nfc_get_data_buffer(type), + TEXT_RECORD_TYPE, + net_nfc_get_data_length(type)) == 0)) + result = true; + + return result; +} + API net_nfc_error_e net_nfc_create_text_string_from_text_record( ndef_record_h record, char** buffer) { + net_nfc_error_e result; + data_h payload; + if (record == NULL || buffer == NULL) - return NET_NFC_ALLOC_FAIL; + return NET_NFC_NULL_PARAMETER; - data_h payload; - data_h rec_type; + *buffer = NULL; - if (net_nfc_get_record_type(record, &rec_type) == NET_NFC_OK) + if (_is_text_record(record) == false) { - if (strncmp((char *)net_nfc_get_data_buffer(rec_type), TEXT_RECORD_TYPE, 1) != 0) - { - DEBUG_CLIENT_MSG("record type is not matched"); - return NET_NFC_NDEF_RECORD_IS_NOT_EXPECTED_TYPE; - } + DEBUG_ERR_MSG("record type is not matched"); + return NET_NFC_NDEF_RECORD_IS_NOT_EXPECTED_TYPE; } - if (net_nfc_get_record_payload(record, &payload) == NET_NFC_OK) + result = net_nfc_get_record_payload(record, &payload); + if (result == NET_NFC_OK) { - uint8_t *buffer_temp; + uint8_t *buffer_temp = net_nfc_get_data_buffer(payload); uint32_t buffer_length = net_nfc_get_data_length(payload); - buffer_temp = net_nfc_get_data_buffer(payload); if (NULL == buffer_temp) return NET_NFC_NO_DATA_FOUND; @@ -189,44 +206,49 @@ API net_nfc_error_e net_nfc_create_text_string_from_text_record( int index = lang_code_length + 1; int text_length = buffer_length - (lang_code_length + 1); - if ((*buffer = (char *)calloc(1, text_length + 1)) != NULL) + char *temp = NULL; + + _net_nfc_util_alloc_mem(temp, text_length + 1); + if (temp != NULL) { - memcpy(*buffer, &(buffer_temp[index]), text_length); - DEBUG_CLIENT_MSG("text = [%s]", *buffer); + memcpy(temp, &(buffer_temp[index]), text_length); + + DEBUG_CLIENT_MSG("text = [%s]", temp); + + *buffer = temp; } else { - return NET_NFC_ALLOC_FAIL; + result = NET_NFC_ALLOC_FAIL; } } - return NET_NFC_OK; + return result; } API net_nfc_error_e net_nfc_get_languange_code_string_from_text_record( ndef_record_h record, char** lang_code_str) { + net_nfc_error_e result; + data_h payload; + if (record == NULL || lang_code_str == NULL) - return NET_NFC_ALLOC_FAIL; + return NET_NFC_NULL_PARAMETER; - data_h payload; - data_h rec_type; + *lang_code_str = NULL; - if (net_nfc_get_record_type(record, &rec_type) == NET_NFC_OK) + if (_is_text_record(record) == false) { - if (strncmp((char *)net_nfc_get_data_buffer(rec_type), TEXT_RECORD_TYPE, 1) != 0) - { - DEBUG_CLIENT_MSG("record type is not matched"); - return NET_NFC_NDEF_RECORD_IS_NOT_EXPECTED_TYPE; - } + DEBUG_ERR_MSG("record type is not matched"); + return NET_NFC_NDEF_RECORD_IS_NOT_EXPECTED_TYPE; } - if (net_nfc_get_record_payload(record, &payload) == NET_NFC_OK) + result = net_nfc_get_record_payload(record, &payload); + if (result == NET_NFC_OK) { char *buffer = NULL; - uint8_t *buffer_temp; + uint8_t *buffer_temp = net_nfc_get_data_buffer(payload); - buffer_temp = net_nfc_get_data_buffer(payload); if (NULL == buffer_temp) return NET_NFC_NO_DATA_FOUND; @@ -234,7 +256,8 @@ API net_nfc_error_e net_nfc_get_languange_code_string_from_text_record( int lang_code_length = controllbyte & 0x3F; int index = 1; - if ((buffer = (char *)calloc(1, lang_code_length + 1)) != NULL) + _net_nfc_util_alloc_mem(buffer, lang_code_length + 1); + if (buffer != NULL) { memcpy(buffer, &(buffer_temp[index]), lang_code_length); DEBUG_CLIENT_MSG("language code = [%s]", buffer); @@ -243,34 +266,35 @@ API net_nfc_error_e net_nfc_get_languange_code_string_from_text_record( } else { - return NET_NFC_ALLOC_FAIL; + result = NET_NFC_ALLOC_FAIL; } } - return NET_NFC_OK; + return result; } API net_nfc_error_e net_nfc_get_encoding_type_from_text_record( ndef_record_h record, net_nfc_encode_type_e * encoding) { + net_nfc_error_e result; + data_h payload; + if (record == NULL || encoding == NULL) return NET_NFC_NULL_PARAMETER; - data_h payload; - data_h rec_type; + *encoding = NET_NFC_ENCODE_UTF_8; - if (net_nfc_get_record_type(record, &rec_type) == NET_NFC_OK) + if (_is_text_record(record) == false) { - if (strncmp((char *)net_nfc_get_data_buffer(rec_type), TEXT_RECORD_TYPE, 1) != 0) - { - DEBUG_CLIENT_MSG("record type is not matched"); - return NET_NFC_NDEF_RECORD_IS_NOT_EXPECTED_TYPE; - } + DEBUG_ERR_MSG("record type is not matched"); + return NET_NFC_NDEF_RECORD_IS_NOT_EXPECTED_TYPE; } - if (net_nfc_get_record_payload(record, &payload) == NET_NFC_OK) + result = net_nfc_get_record_payload(record, &payload); + if (result == NET_NFC_OK) { uint8_t *buffer_temp = net_nfc_get_data_buffer(payload); + if (NULL == buffer_temp) return NET_NFC_NO_DATA_FOUND; @@ -278,11 +302,9 @@ API net_nfc_error_e net_nfc_get_encoding_type_from_text_record( if ((controllbyte & 0x80) == 0x80) *encoding = NET_NFC_ENCODE_UTF_16; - else - *encoding = NET_NFC_ENCODE_UTF_8; } - return NET_NFC_OK; + return result; } API net_nfc_error_e net_nfc_create_uri_string_from_uri_record( diff --git a/client/net_nfc_client_snep.c b/client/net_nfc_client_snep.c index 0293218..6a661aa 100644 --- a/client/net_nfc_client_snep.c +++ b/client/net_nfc_client_snep.c @@ -30,11 +30,6 @@ static NetNfcGDbusSnep *snep_proxy = NULL; /*******************************************************************/ -static GVariant *snep_message_to_variant(ndef_message_h message); - -static ndef_message_h snep_variant_to_message(GVariant *variant); - -/*********************************************************************/ static void snep_send_client_request(GObject *source_object, GAsyncResult *res, @@ -42,55 +37,21 @@ static void snep_send_client_request(GObject *source_object, /*********************************************************************/ -static GVariant *snep_message_to_variant(ndef_message_h message) -{ - data_h data = NULL; - GVariant *variant = NULL; - - if (net_nfc_create_rawdata_from_ndef_message(message, - &data) != NET_NFC_OK) - { - DEBUG_ERR_MSG("can not convert ndef_message to rawdata"); - return NULL; - } - - variant = net_nfc_util_gdbus_data_to_variant((data_s *)data); - - net_nfc_free_data(data); - - return variant; -} - -static ndef_message_h snep_variant_to_message(GVariant *variant) -{ - data_s data = { NULL, }; - ndef_message_h message = NULL; - - net_nfc_util_gdbus_variant_to_data_s(variant, &data); - - if (data.buffer && data.length > 0) - { - if (net_nfc_create_ndef_message_from_rawdata(&message, &data) - != NET_NFC_OK) - { - DEBUG_ERR_MSG("memory alloc fail..."); - } - - net_nfc_util_free_data(&data); - } - - return message; -} static void snep_send_client_request(GObject *source_object, GAsyncResult *res, gpointer user_data) { GVariant *parameter = (GVariant *)user_data; - GError *error = NULL; net_nfc_error_e out_result; net_nfc_snep_type_t out_type; GVariant *out_data; + GError *error = NULL; + net_nfc_client_snep_event_cb callback; + void *user_param; + net_nfc_snep_handle_h handle; + + g_assert(parameter != NULL); if (net_nfc_gdbus_snep_call_client_request_finish( NET_NFC_GDBUS_SNEP(source_object), @@ -104,29 +65,25 @@ static void snep_send_client_request(GObject *source_object, error->message); g_error_free(error); - out_result = NET_NFC_UNKNOWN_ERROR; + out_result = NET_NFC_IPC_FAIL; } - if (parameter != NULL) { - net_nfc_client_snep_event_cb callback; - void *user_param; - net_nfc_snep_handle_h handle; - ndef_message_h message = NULL; - - g_variant_get(parameter, "(uuu)", - (guint *)&callback, - (guint *)&user_param, - (guint *)&handle); + g_variant_get(parameter, "(uuu)", + (guint *)&callback, + (guint *)&user_param, + (guint *)&handle); - if (callback != NULL) { - message = snep_variant_to_message(out_data); + if (callback != NULL) { + ndef_message_h message = NULL; - callback(handle, out_type, out_result, - message, user_param); - } + message = net_nfc_util_gdbus_variant_to_ndef_message(out_data); - g_variant_unref(parameter); + callback(handle, out_type, out_result, + message, user_param); + net_nfc_free_ndef_message(message); } + + g_variant_unref(parameter); } API net_nfc_error_e net_nfc_client_snep_start_server( @@ -144,7 +101,7 @@ API net_nfc_error_e net_nfc_client_snep_start_server( { DEBUG_ERR_MSG("Can not get Snep Proxy"); - return NET_NFC_UNKNOWN_ERROR; + return NET_NFC_NOT_INITIALIZED; } /* prevent executing daemon when nfc is off */ @@ -169,9 +126,10 @@ API net_nfc_error_e net_nfc_client_snep_start_server( DEBUG_ERR_MSG("snep server(sync call) failed: %s", error->message); g_error_free(error); - g_variant_unref(parameter); - result = NET_NFC_UNKNOWN_ERROR; + result = NET_NFC_IPC_FAIL; + + g_variant_unref(parameter); } return result; @@ -192,7 +150,7 @@ API net_nfc_error_e net_nfc_client_snep_start_client( { DEBUG_ERR_MSG("Can not get Snep Proxy"); - return NET_NFC_UNKNOWN_ERROR; + return NET_NFC_NOT_INITIALIZED; } /* prevent executing daemon when nfc is off */ @@ -217,9 +175,10 @@ API net_nfc_error_e net_nfc_client_snep_start_client( DEBUG_ERR_MSG("snep client(sync call) failed: %s", error->message); g_error_free(error); - g_variant_unref(parameter); - result = NET_NFC_UNKNOWN_ERROR; + result = NET_NFC_IPC_FAIL; + + g_variant_unref(parameter); } return result; @@ -257,7 +216,7 @@ API net_nfc_error_e net_nfc_client_snep_send_client_request( GPOINTER_TO_UINT(user_data), GPOINTER_TO_UINT(target)); - ndef_msg = snep_message_to_variant(msg); + ndef_msg = net_nfc_util_gdbus_ndef_message_to_variant(msg); net_nfc_gdbus_snep_call_client_request(snep_proxy, GPOINTER_TO_UINT(target), @@ -284,11 +243,14 @@ API net_nfc_error_e net_nfc_client_snep_send_client_request_sync( net_nfc_error_e result; guint type; - if (target == NULL || msg == NULL) + if (target == NULL || msg == NULL + || resp_type == NULL || response == NULL) { return NET_NFC_NULL_PARAMETER; } + *response = NULL; + if (snep_proxy == NULL) { DEBUG_ERR_MSG("Can not get Snep Proxy"); @@ -296,7 +258,7 @@ API net_nfc_error_e net_nfc_client_snep_send_client_request_sync( return NET_NFC_NOT_INITIALIZED; } - arg_msg = snep_message_to_variant(msg); + arg_msg = net_nfc_util_gdbus_ndef_message_to_variant(msg); if (net_nfc_gdbus_snep_call_client_request_sync(snep_proxy, GPOINTER_TO_UINT(target), @@ -307,18 +269,7 @@ API net_nfc_error_e net_nfc_client_snep_send_client_request_sync( resp_type, &resp_msg, NULL, - &error) == FALSE) - { - DEBUG_ERR_MSG(" send client request (sync call) failed: %s", - error->message); - g_error_free(error); - - return NET_NFC_IPC_FAIL; - } - - *response = NULL; - - if (result == NET_NFC_OK) + &error) == TRUE) { data_s ndef_data = { NULL, }; @@ -333,6 +284,14 @@ API net_nfc_error_e net_nfc_client_snep_send_client_request_sync( net_nfc_util_free_data(&ndef_data); } } + else + { + DEBUG_ERR_MSG(" send client request (sync call) failed: %s", + error->message); + g_error_free(error); + + return NET_NFC_IPC_FAIL; + } return result; } @@ -373,7 +332,7 @@ API net_nfc_error_e net_nfc_client_snep_stop_service_sync( error->message); g_error_free(error); - return NET_NFC_IPC_FAIL; + result = NET_NFC_IPC_FAIL; } return result; @@ -408,14 +367,18 @@ static void _snep_event_cb(NetNfcGDbusSnep *object, if (callback != NULL) { - ndef_message_h message = - snep_variant_to_message(arg_ndef_msg); + ndef_message_h message; + + message = net_nfc_util_gdbus_variant_to_ndef_message( + arg_ndef_msg); callback(GUINT_TO_POINTER(arg_handle), arg_event, arg_result, message, user_data); + + net_nfc_free_ndef_message(message); } if (arg_event == NET_NFC_LLCP_UNREGISTERED) { @@ -437,7 +400,7 @@ API net_nfc_error_e net_nfc_client_snep_register_server(const char *san, { DEBUG_ERR_MSG("Can not get Snep Proxy"); - return NET_NFC_UNKNOWN_ERROR; + return NET_NFC_NOT_INITIALIZED; } /* prevent executing daemon when nfc is off */ @@ -461,9 +424,10 @@ API net_nfc_error_e net_nfc_client_snep_register_server(const char *san, DEBUG_ERR_MSG("snep register server(sync call) failed: %s", error->message); g_error_free(error); - g_variant_unref(parameter); - result = NET_NFC_UNKNOWN_ERROR; + result = NET_NFC_IPC_FAIL; + + g_variant_unref(parameter); } return result; @@ -479,7 +443,7 @@ API net_nfc_error_e net_nfc_client_snep_unregister_server(const char *san, { DEBUG_ERR_MSG("Can not get Snep Proxy"); - return NET_NFC_UNKNOWN_ERROR; + return NET_NFC_NOT_INITIALIZED; } /* prevent executing daemon when nfc is off */ @@ -499,7 +463,7 @@ API net_nfc_error_e net_nfc_client_snep_unregister_server(const char *san, error->message); g_error_free(error); - result = NET_NFC_UNKNOWN_ERROR; + result = NET_NFC_IPC_FAIL; } return result; diff --git a/common/net_nfc_util_gdbus.c b/common/net_nfc_util_gdbus.c index 41b1d1a..30e59a1 100644 --- a/common/net_nfc_util_gdbus.c +++ b/common/net_nfc_util_gdbus.c @@ -22,6 +22,7 @@ #include "net_nfc_debug_internal.h" #include "net_nfc_util_internal.h" #include "net_nfc_util_gdbus_internal.h" +#include "net_nfc_util_ndef_message.h" void net_nfc_util_gdbus_variant_to_buffer(GVariant *variant, uint8_t **buffer, size_t *length) @@ -175,3 +176,73 @@ GVariant *net_nfc_util_gdbus_data_to_variant(const data_s *data) return net_nfc_util_gdbus_buffer_to_variant(NULL, 0); } } + +ndef_message_s *net_nfc_util_gdbus_variant_to_ndef_message(GVariant *variant) +{ + ndef_message_s *message = NULL; + data_s data = { NULL, 0 }; + + if (variant == NULL) + return NULL; + + net_nfc_util_gdbus_variant_to_data_s(variant, &data); + + if (data.buffer && data.length > 0) + { + ndef_message_s *temp = NULL; + + if (net_nfc_util_create_ndef_message(&temp) == NET_NFC_OK) { + if (net_nfc_util_convert_rawdata_to_ndef_message( + &data, temp) == NET_NFC_OK) { + message = temp; + } else { + DEBUG_ERR_MSG("net_nfc_create_ndef_message_from_rawdata failed"); + + net_nfc_util_free_ndef_message(temp); + } + } else { + DEBUG_ERR_MSG("net_nfc_util_create_ndef_message failed"); + } + + net_nfc_util_free_data(&data); + } + + return message; +} + +GVariant *net_nfc_util_gdbus_ndef_message_to_variant( + const ndef_message_s *message) +{ + GVariant *variant = NULL; + data_s *data = NULL; + size_t length; + + length = net_nfc_util_get_ndef_message_length( + (ndef_message_s *)message); + if (length > 0) { + data_s temp = { NULL, 0 }; + + if (net_nfc_util_alloc_data(&temp, length) == true) { + if (net_nfc_util_convert_ndef_message_to_rawdata( + (ndef_message_s *)message, + &temp) == NET_NFC_OK) { + data = &temp; + } else { + DEBUG_ERR_MSG("can not convert ndef_message to rawdata"); + + net_nfc_util_free_data(&temp); + } + } else { + DEBUG_ERR_MSG("net_nfc_util_alloc_data failed"); + } + } else { + DEBUG_ERR_MSG("message length is 0"); + } + + variant = net_nfc_util_gdbus_data_to_variant(data); + + if (data != NULL) + net_nfc_util_free_data(data); + + return variant; +} diff --git a/common/net_nfc_util_gdbus_internal.h b/common/net_nfc_util_gdbus_internal.h index 518b3f4..e3d5868 100644 --- a/common/net_nfc_util_gdbus_internal.h +++ b/common/net_nfc_util_gdbus_internal.h @@ -28,8 +28,13 @@ 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); GVariant *net_nfc_util_gdbus_buffer_to_variant(const uint8_t *buffer, - size_t length); + size_t length); GVariant *net_nfc_util_gdbus_data_to_variant(const data_s *data); +ndef_message_s *net_nfc_util_gdbus_variant_to_ndef_message(GVariant *variant); + +GVariant *net_nfc_util_gdbus_ndef_message_to_variant( + const ndef_message_s *message); + #endif //__NET_NFC_UTIL_GDBUS_INTERNAL_H__ diff --git a/daemon/net_nfc_server_common.c b/daemon/net_nfc_server_common.c index 8ee4244..8c14c1a 100644 --- a/daemon/net_nfc_server_common.c +++ b/daemon/net_nfc_server_common.c @@ -220,37 +220,32 @@ static void controller_init_thread_func(gpointer user_data) if (net_nfc_controller_init(&result) == false) { - DEBUG_ERR_MSG("%s failed [%d]", - "net_nfc_controller_init", - result); + DEBUG_ERR_MSG("net_nfc_controller_init failed, [%d]", result); net_nfc_manager_quit(); return; } - DEBUG_SERVER_MSG("%s success [%d]", - "net_nfc_controller_init", - result); + INFO_MSG("net_nfc_controller_init success, [%d]", result); if (net_nfc_controller_register_listener(controller_target_detected_cb, controller_se_transaction_cb, controller_llcp_event_cb, &result) == false) { - DEBUG_ERR_MSG("%s failed [%d]", - "net_nfc_contorller_register_listener", + DEBUG_ERR_MSG("net_nfc_contorller_register_listener failed [%d]", result); } - else + INFO_MSG("net_nfc_contorller_register_listener success"); + + result = net_nfc_server_llcp_set_config(NULL); + if (result != NET_NFC_OK) { - DEBUG_SERVER_MSG("%s success !!", - "net_nfc_contorller_register_listener"); + DEBUG_ERR_MSG("net_nfc_server_llcp_set config failed, [%d]", + result); } - if (net_nfc_server_llcp_set_config(NULL) == NET_NFC_OK) - DEBUG_SERVER_MSG("llcp is enabled !!"); - else - DEBUG_ERR_MSG("net_nfc_server_llcp_set config failed"); + INFO_MSG("net_nfc_server_llcp_set_config success"); } #ifndef ESE_ALWAYS_ON @@ -258,23 +253,22 @@ static void controller_deinit_thread_func(gpointer user_data) { net_nfc_error_e result; - net_nfc_controller_configure_discovery(NET_NFC_DISCOVERY_MODE_CONFIG, - NET_NFC_ALL_DISABLE, - &result); + if (net_nfc_controller_configure_discovery(NET_NFC_DISCOVERY_MODE_CONFIG, + NET_NFC_ALL_DISABLE, + &result) == false) { + + DEBUG_ERR_MSG("net_nfc_controller_configure_discovery failed, [%d]", result); + } net_nfc_server_free_target_info(); if (net_nfc_controller_deinit() == false) { - DEBUG_ERR_MSG("%s is failed %d", - "net_nfc_controller_deinit", - result); + DEBUG_ERR_MSG("net_nfc_controller_deinit failed, [%d]", result); return; } - DEBUG_SERVER_MSG("%s success [%d]", - "net_nfc_controller_deinit", - result); + INFO_MSG("net_nfc_controller_deinit success"); net_nfc_manager_quit(); } diff --git a/daemon/net_nfc_server_manager.c b/daemon/net_nfc_server_manager.c index 4e03cb6..2177479 100644 --- a/daemon/net_nfc_server_manager.c +++ b/daemon/net_nfc_server_manager.c @@ -131,23 +131,23 @@ static net_nfc_error_e manager_deactive(void) /* unregister all services */ net_nfc_server_llcp_unregister_all(); - /* keep_SE_select_value do not need to update vconf and gdbus_se_setting */ -// result = net_nfc_server_se_change_se(SECURE_ELEMENT_TYPE_INVALID); + /* keep_SE_select_value do not need to update vconf and gdbus_se_setting */ + // result = net_nfc_server_se_change_se(SECURE_ELEMENT_TYPE_INVALID); { net_nfc_error_e result_ese, result_uicc; /*turn off ESE*/ net_nfc_controller_set_secure_element_mode( - SECURE_ELEMENT_TYPE_ESE, - SECURE_ELEMENT_OFF_MODE, - &result_ese); + SECURE_ELEMENT_TYPE_ESE, + SECURE_ELEMENT_OFF_MODE, + &result_ese); /*turn off UICC*/ net_nfc_controller_set_secure_element_mode( - SECURE_ELEMENT_TYPE_UICC, - SECURE_ELEMENT_OFF_MODE, - &result_uicc); + SECURE_ELEMENT_TYPE_UICC, + SECURE_ELEMENT_OFF_MODE, + &result_uicc); } @@ -196,6 +196,8 @@ static void manager_handle_active_thread_func(gpointer user_data) net_nfc_gdbus_manager_emit_activated(data->manager, data->is_active); + } else { + DEBUG_ERR_MSG("activation change failed, [%d]", result); } g_object_unref(data->invocation); @@ -318,7 +320,7 @@ static void manager_active_thread_func(gpointer user_data) } else { - DEBUG_ERR_MSG("can not set activation"); + DEBUG_ERR_MSG("activation change failed, [%d]", ret); } g_free(data); -- 2.7.4