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);
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,
#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);
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)
{
if (target_info == NULL)
{
DEBUG_ERR_MSG("target_info does not exist");
- return TRUE;
+ return FALSE;
}
switch (target_info->devType)
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),
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);
}
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),
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);
}
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),
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);
}
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),
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);
}
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 */
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;
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 */
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),
(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;
}
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 */
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),
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 */
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),
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;
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 */
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;
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 */
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;
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;
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 */
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),
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 */
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),
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;
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+#include <linux/limits.h>
#include "net_nfc_debug_internal.h"
#include "net_nfc_util_internal.h"
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;
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)
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);
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);
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);
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);
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;
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;
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;
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;
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);
}
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;
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(
/*******************************************************************/
-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,
/*********************************************************************/
-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),
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(
{
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 */
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;
{
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 */
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;
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),
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");
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),
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, };
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;
}
error->message);
g_error_free(error);
- return NET_NFC_IPC_FAIL;
+ result = NET_NFC_IPC_FAIL;
}
return result;
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) {
{
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 */
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;
{
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 */
error->message);
g_error_free(error);
- result = NET_NFC_UNKNOWN_ERROR;
+ result = NET_NFC_IPC_FAIL;
}
return result;
#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)
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;
+}
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__
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
{
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();
}
/* 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);
}
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);
}
else
{
- DEBUG_ERR_MSG("can not set activation");
+ DEBUG_ERR_MSG("activation change failed, [%d]", ret);
}
g_free(data);
projects / platform / core / connectivity / nfc-manager.git / commitdiff