}
net_nfc_handover_context_t;
-#define NET_NFC_CH_CONTEXT net_nfc_target_handle_s *handle;\
+#define NET_NFC_CH_CONTEXT \
+ net_nfc_target_handle_s *handle;\
net_nfc_llcp_socket_t socket;\
net_nfc_error_e result;\
int step;\
typedef struct _net_nfc_server_handover_create_config_context_t
{
- NET_NFC_CH_CONTEXT;
+ net_nfc_target_handle_s *handle;
+ net_nfc_llcp_socket_t socket;
+ net_nfc_error_e result;
+ int step;
+ net_nfc_conn_handover_carrier_type_e type;
+ void *user_param;
+ // TODO: above value MUST be same with NET_NFC_CH_CONTEXT
_net_nfc_server_handover_create_carrier_msg_cb cb;
net_nfc_conn_handover_carrier_type_e current_type;
typedef struct _net_nfc_server_handover_process_config_context_t
{
- NET_NFC_CH_CONTEXT;
+ net_nfc_target_handle_s *handle;
+ net_nfc_llcp_socket_t socket;
+ net_nfc_error_e result;
+ int step;
+ net_nfc_conn_handover_carrier_type_e type;
+ void *user_param;
+ // TODO: above value MUST be same with NET_NFC_CH_CONTEXT */
net_nfc_server_handover_process_carrier_record_cb cb;
}net_nfc_server_handover_process_config_context_t;
-
-static void _net_nfc_server_handover_send_response(void *user_param,
- data_h ac_data,
- net_nfc_error_e result);
+static void _net_nfc_server_handover_send_response(net_nfc_error_e result,
+ net_nfc_conn_handover_carrier_type_e carrier,
+ data_s *ac_data,
+ void *user_param);
static void _net_nfc_server_handover_client_process(
net_nfc_handover_context_t *context);
data_s *data,
void *user_param);
+static void _net_nfc_server_handover_bss_get_carrier_record_cb(
+ net_nfc_error_e result,
+ net_nfc_conn_handover_carrier_state_e cps,
+ ndef_record_s *carrier,
+ uint32_t aux_data_count,
+ ndef_record_s *aux_data,
+ void *user_param);
+
+static void _net_nfc_server_handover_bss_process_carrier_record_cb(
+ net_nfc_error_e result,
+ net_nfc_conn_handover_carrier_type_e type,
+ data_s *data,
+ void *user_param);
static void _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(
- void *user_param,
- data_h ac_data,
- net_nfc_error_e result)
+ net_nfc_error_e result,
+ net_nfc_conn_handover_carrier_type_e carrier,
+ data_s *ac_data,
+ void *user_param)
{
- HandoverRequestData *handover_data = NULL;
- guint32 resp_event;
- guint32 resp_type;
- GVariant* data = NULL;
-
- handover_data = (HandoverRequestData*)user_param;
-
- data = net_nfc_util_gdbus_data_to_variant(ac_data);
-
- resp_type = NET_NFC_MESSAGE_CONNECTION_HANDOVER;
-
- if (result == NET_NFC_OK)
- resp_event = NET_NFC_EXCHANGER_TRANSFER_COMPLETED;
- else
- resp_event = NET_NFC_EXCHANGER_TRANSFER_FAILED;
+ HandoverRequestData *handover_data = (HandoverRequestData *)user_param;
- if (handover_data->invocation)
- {
- net_nfc_gdbus_handover_complete_request(
- handover_data->handoverobj,
- handover_data->invocation,
- resp_event,
- resp_type,
- data);
+ g_assert(handover_data != NULL);
+ g_assert(handover_data->invocation != NULL);
+ g_assert(handover_data->handoverobj != NULL);
- g_object_unref(handover_data->invocation);
- }
+ net_nfc_gdbus_handover_complete_request(
+ handover_data->handoverobj,
+ handover_data->invocation,
+ result,
+ carrier,
+ net_nfc_util_gdbus_data_to_variant(ac_data));
if (handover_data->data)
{
g_free(handover_data->data);
}
+ g_object_unref(handover_data->invocation);
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(
record,
cps)) == NET_NFC_OK)
{
- DEBUG_SERVER_MSG("net_nfc_util_append_carrier"
+ NFC_DBG("net_nfc_util_append_carrier_config_record success");
+ }
+ else
+ {
+ NFC_ERR("net_nfc_util_append_carrier_config_record failed [%d]", result);
+ net_nfc_util_free_record(record);
+ }
+
+ g_idle_add(
+ (GSourceFunc)_net_nfc_server_handover_iterate_carrier_configs_to_next,
+ (gpointer)context);
+ }
+
+ /* don't free context */
+}
+static void _net_nfc_server_handover_bss_get_carrier_record_cb(
+ net_nfc_error_e result,
+ net_nfc_conn_handover_carrier_state_e cps,
+ ndef_record_s *carrier,
+ uint32_t aux_data_count,
+ ndef_record_s *aux_data,
+ void *user_param)
+{
+ net_nfc_server_handover_create_config_context_t *context =
+ (net_nfc_server_handover_create_config_context_t *)user_param;
+
+ /* append record to ndef message */
+ if (result == NET_NFC_OK)
+ {
+ ndef_record_s *record;
+
+ net_nfc_util_create_record(carrier->TNF,
+ &carrier->type_s,
+ &carrier->id_s,
+ &carrier->payload_s,
+ &record);
+
+ if ((result = net_nfc_util_append_carrier_config_record(
+ context->ndef_message,
+ record,
+ cps)) == NET_NFC_OK)
+ {
+ NFC_DBG("net_nfc_util_append_carrier"
"_config_record success");
}
else
{
- DEBUG_ERR_MSG("net_nfc_util_append_carrier"
+ NFC_ERR("net_nfc_util_append_carrier"
"_config_record failed [%d]",
result);
net_nfc_util_free_record(record);
}
else
{
- DEBUG_ERR_MSG("_handover_bt_process_carrier_record failed [%d]",
+ NFC_ERR("_handover_bt_process_carrier_record failed [%d]",
result);
}
_net_nfc_util_free_mem(context);
}
+static void _net_nfc_server_handover_bss_process_carrier_record_cb(
+ net_nfc_error_e result,
+ net_nfc_conn_handover_carrier_type_e type,
+ data_s *data,
+ void *user_param)
+{
+
+ net_nfc_server_handover_process_config_context_t *context =
+ (net_nfc_server_handover_process_config_context_t *)user_param;
+
+ if(context)
+ {
+ if (context->cb != NULL)
+ {
+ context->cb(result, type, data, context->user_param);
+ }
+ else
+ NFC_ERR("Invalid Callback");
+
+ _net_nfc_util_free_mem(context);
+ }
+}
-net_nfc_error_e _net_nfc_server_handover_get_carrier_record_by_priority_order(
+net_nfc_error_e
+net_nfc_server_handover_get_carrier_record_by_priority_order(
ndef_message_s *request,
ndef_record_s **record)
{
&carrier_type)== NET_NFC_OK)
&& (carrier_type == priority))
{
- DEBUG_SERVER_MSG("selected carrier type"
- " = [%d]", carrier_type);
- net_nfc_util_get_carrier_config_record(
- request,
- idx,
- record);
+ NFC_DBG("selected carrier type = [%d]", carrier_type);
+ net_nfc_util_get_carrier_config_record(request, idx, record);
result = NET_NFC_OK;
break;
}
}
else
{
- DEBUG_ERR_MSG("net_nfc_util_get_alternative_carrier"
+ NFC_ERR("net_nfc_util_get_alternative_carrier"
"_record_count failed");
}
}
else
{
- DEBUG_ERR_MSG("record is not valid or"
+ NFC_ERR("record is not valid or"
" is not available");
net_nfc_util_free_ndef_message(*requestor);
result = NET_NFC_INVALID_PARAM;
}
else
{
- DEBUG_ERR_MSG("_net_nfc_ndef_rawdata_to_ndef"
+ NFC_ERR("_net_nfc_ndef_rawdata_to_ndef"
"failed [%d]",result);
}
} else {
- DEBUG_ERR_MSG("net_nfc_util_create_ndef_message failed [%d]",
+ NFC_ERR("net_nfc_util_create_ndef_message failed [%d]",
result);
}
return result;
}
-net_nfc_error_e _net_nfc_server_handover_create_selector_from_rawdata(
- ndef_message_s **selector,
- data_s *data)
+net_nfc_error_e net_nfc_server_handover_create_selector_from_rawdata(
+ ndef_message_s **selector, data_s *data)
{
net_nfc_error_e result;
}
else
{
- DEBUG_ERR_MSG("record is not valid or is "
+ NFC_ERR("record is not valid or is "
"not available");
net_nfc_util_free_ndef_message(*selector);
result = NET_NFC_INVALID_PARAM;
}
else
{
- DEBUG_ERR_MSG("_net_nfc_ndef_rawdata_to_ndef"
+ NFC_ERR("_net_nfc_ndef_rawdata_to_ndef"
" failed [%d]",result);
}
}
else
{
- DEBUG_ERR_MSG("_net_nfc_util_create_ndef_message"
+ NFC_ERR("_net_nfc_util_create_ndef_message"
" failed [%d]",result);
}
if (memcmp(rec->type_s.buffer, CH_REQ_RECORD_TYPE,
rec->type_s.length) != 0)
{
- DEBUG_ERR_MSG("This is not connection handover"
+ NFC_ERR("This is not connection handover"
" request message");
goto ERROR;
}
if (rec->payload_s.buffer[0] != CH_VERSION)
{
- DEBUG_ERR_MSG("connection handover version is not matched");
+ NFC_ERR("connection handover version is not matched");
goto ERROR;
}
if (net_nfc_util_get_alternative_carrier_record_count(message, &count)
!= NET_NFC_OK || count == 0)
{
- DEBUG_ERR_MSG("there is no carrier reference");
+ NFC_ERR("there is no carrier reference");
goto ERROR;
}
if (memcmp(rec->type_s.buffer, CH_SEL_RECORD_TYPE,
rec->type_s.length) != 0)
{
- DEBUG_ERR_MSG("This is not connection handover"
+ NFC_ERR("This is not connection handover"
" request message");
goto ERROR;
}
if (net_nfc_util_get_alternative_carrier_record_count(
message,&count)!= NET_NFC_OK || count == 0)
{
- DEBUG_ERR_MSG("there is no carrrier reference");
+ NFC_ERR("there is no carrrier reference");
goto ERROR;
}
/* check version */
if (rec->payload_s.buffer[0] != CH_VERSION)
{
- DEBUG_ERR_MSG("connection handover version"
+ NFC_ERR("connection handover version"
" is not matched");
goto ERROR;
}
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)
{
{
if (context->type == NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN)
{
- if (context->current_type <
- NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN)
+ if (context->current_type < NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN)
{
context->current_type++;
}
}
else
{
- context->current_type =
- NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
+ context->current_type = NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
}
g_idle_add(
}
else
{
- DEBUG_ERR_MSG("context->result is error [%d]", context->result);
+ NFC_ERR("context->result is error [%d]", context->result);
g_idle_add(
(GSourceFunc)_net_nfc_server_handover_iterate_carrier_configs_step,
net_nfc_server_handover_create_config_context_t *context)
{
LOGD("[%s:%d] START", __func__, __LINE__);
+ net_nfc_error_e result = NET_NFC_OK;
switch (context->current_type)
{
case NET_NFC_CONN_HANDOVER_CARRIER_BT :
- DEBUG_MSG("[NET_NFC_CONN_HANDOVER_CARRIER_BT]");
+ NFC_DBG("[NET_NFC_CONN_HANDOVER_CARRIER_BT]");
net_nfc_server_handover_bt_get_carrier_record(
_net_nfc_server_handover_bt_get_carrier_record_cb,
context);
break;
- // case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS :
- // DEBUG_MSG("[NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS]");
- // g_idle_add(
- // (GSourceFunc)net_nfc_service_llcp_handover_append_wifi_carrier_config,
- // context);
- // break;
+ case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS :
+ NFC_DBG("[NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS]");
+
+#ifdef TARGET
+ if(memcmp(context->ndef_message->records->type_s.buffer ,CH_SEL_RECORD_TYPE,
+ context->ndef_message->records->type_s.length)==0)
+ {
+ result = net_nfc_server_handover_bss_wfd_get_carrier_record(
+ _net_nfc_server_handover_bss_get_carrier_record_cb,
+ context);
+ }
+ else
+#endif
+ {
+ result = net_nfc_server_handover_bss_get_carrier_record(
+ _net_nfc_server_handover_bss_get_carrier_record_cb,
+ context);
+ }
+ NFC_DBG("[%d]",result);
+ break;
// case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_IBSS :
- // DEBUG_MSG("[NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS]");
+ // NFC_DBG("[NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS]");
// g_idle_add(
// (GSourceFunc)_net_nfc_server_handover_append_wifi_carrier_config,
// context);
// break;
case NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN :
- DEBUG_MSG("[NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN]");
+ NFC_DBG("[NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN]");
g_idle_add(
(GSourceFunc)_net_nfc_server_handover_iterate_carrier_configs_step,
(gpointer)context);
break;
default :
- DEBUG_MSG("[unknown : %d]", context->current_type);
+ NFC_DBG("[unknown : %d]", context->current_type);
g_idle_add(
(GSourceFunc)_net_nfc_server_handover_iterate_carrier_configs_step,
(gpointer)context);
return 0;
}
-static net_nfc_error_e _net_nfc_server_handover_create_requester_carrier_configs(
+static net_nfc_error_e
+_net_nfc_server_handover_create_requester_carrier_configs(
net_nfc_conn_handover_carrier_type_e type,
void *cb,
void *user_param)
context->type = type;
if (type == NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN)
{
- context->current_type =
- NET_NFC_CONN_HANDOVER_CARRIER_BT;
+ context->current_type = NET_NFC_CONN_HANDOVER_CARRIER_BT;
}
else
context->current_type = context->type;
}
else
{
- DEBUG_ERR_MSG("alloc failed");
+ NFC_ERR("alloc failed");
result = NET_NFC_ALLOC_FAIL;
}
return result;
}
-static net_nfc_error_e _net_nfc_server_handover_create_selector_carrier_configs(
+static net_nfc_error_e
+_net_nfc_server_handover_create_selector_carrier_configs(
net_nfc_conn_handover_carrier_type_e type,
void *cb,
void *user_param)
}
else
{
- DEBUG_ERR_MSG("alloc failed");
+ NFC_ERR("alloc failed");
result = NET_NFC_ALLOC_FAIL;
}
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)
+net_nfc_error_e net_nfc_server_handover_process_carrier_record(
+ ndef_record_s *carrier, void *cb, void *user_param)
{
net_nfc_error_e result = NET_NFC_OK;
net_nfc_server_handover_process_config_context_t *context = NULL;
switch (type)
{
case NET_NFC_CONN_HANDOVER_CARRIER_BT :
- DEBUG_MSG("[NET_NFC_CONN_HANDOVER_CARRIER_BT]");
+ NFC_DBG("[NET_NFC_CONN_HANDOVER_CARRIER_BT]");
net_nfc_server_handover_bt_process_carrier_record(
carrier,
_net_nfc_server_handover_bt_process_carrier_record_cb,
break;
case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS :
- DEBUG_MSG("[NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS]");
+ NFC_DBG("[NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS]");
net_nfc_server_handover_bss_process_carrier_record(
carrier,
- NULL,
- NULL);
- _net_nfc_util_free_mem(context);
+ _net_nfc_server_handover_bss_process_carrier_record_cb,
+ context);
break;
case NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN :
- DEBUG_MSG("[NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN]");
+ NFC_DBG("[NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN]");
_net_nfc_util_free_mem(context);
break;
default :
- DEBUG_MSG("[unknown]");
+ NFC_DBG("[unknown]");
_net_nfc_util_free_mem(context);
break;
}
}
else
{
- DEBUG_ERR_MSG("alloc failed");
+ NFC_ERR("alloc failed");
result = NET_NFC_ALLOC_FAIL;
}
return result;
}
-#if 0
-static net_nfc_error_e _net_nfc_server_handover_snep_client_cb(
- net_nfc_snep_handle_h handle,
- net_nfc_error_e result,
- uint32_t type,
- data_s *data,
- void *user_param)
-{
- _net_nfc_server_handover_client_context_t *context =
- (_net_nfc_server_handover_client_context_t *)user_param;
-
- DEBUG_SERVER_MSG("type [%d], result [%d], data [%p], user_param [%p]",
- type, result, data, user_param);
-
- switch (type) {
- case SNEP_RESP_SUCCESS :
- {
- ndef_message_s *selector;
-
- result = _net_nfc_server_handover_create_selector_from_rawdata(
- &selector,
- data);
- if (result == NET_NFC_OK) {
- if (false /* is low power ??? */) {
- result =
- _net_nfc_server_handover_process_selector_msg(
- selector,
- user_param);
- } else {
- result =
- _net_nfc_server_handover_process_selector_msg(
- selector,
- user_param);
- }
-
- if (result != NET_NFC_OK) {
- DEBUG_ERR_MSG("_net_nfc_server_handover_process"
- "_selector_msg failed [%d]",result);
- if (context->cb != NULL) {
- context->cb(result,
- context->type,
- NULL,
- context->user_param);
- }
- _net_nfc_util_free_mem(context);
- }
-
- net_nfc_util_free_ndef_message(selector);
- } else {
- DEBUG_ERR_MSG("_net_nfc_server_handover_create"
- "_selector_from_rawdata failed [%d]",result);
- if (context->cb != NULL) {
- context->cb(result,
- context->type,
- NULL,
- context->user_param);
- }
- _net_nfc_util_free_mem(context);
- }
- }
- break;
-
- case SNEP_RESP_BAD_REQ :
- case SNEP_RESP_EXCESS_DATA :
- case SNEP_RESP_NOT_FOUND :
- case SNEP_RESP_NOT_IMPLEMENT :
- case SNEP_RESP_REJECT :
- case SNEP_RESP_UNSUPPORTED_VER :
- default :
- {
- DEBUG_ERR_MSG("error response [0x%02x]", type);
- if (context->cb != NULL) {
- context->cb(result, context->type, NULL,
- context->user_param);
- }
- _net_nfc_util_free_mem(context);
- }
- break;
- }
-
- return result;
-}
-
-
-static void _net_nfc_server_handover_create_requester_carrier_configs_cb(
- net_nfc_error_e result,
- ndef_message_s *msg,
- void *user_param)
-{
- _net_nfc_server_handover_client_context_t *context =
- (_net_nfc_server_handover_client_context_t *)user_param;
- data_s data;
-
- if (context == NULL)
- {
- return;
- }
-
- if (msg != NULL) {
- /* convert ndef message */
- if ((result = _net_nfc_server_handover_convert_ndef_message_to_data(msg,
- &data)) == NET_NFC_OK) {
- net_nfc_service_snep_client(context->handle,
- SNEP_SAN,
- 0,
- SNEP_REQ_GET,
- &data,
- _net_nfc_server_handover_snep_client_cb,
- context);
-
- net_nfc_util_free_data(&data);
- }
- else
- {
- DEBUG_ERR_MSG("_net_nfc_server_handover_convert"
- "_ndef_message_to_datafailed [%d]",result);
- if (context->cb != NULL)
- {
- context->cb(result,
- context->type,
- NULL,
- context->user_param);
- }
- _net_nfc_util_free_mem(context);
- }
- }
- else
- {
- DEBUG_ERR_MSG("null param, [%d]", result);
- if (context->cb != NULL)
- {
- context->cb(result,
- context->type,
- NULL,
- context->user_param);
- }
- _net_nfc_util_free_mem(context);
- }
-}
-#endif
-
-
-#if 0
-
-static void _net_nfc_server_handover_server_create_carrier_configs_cb(
- net_nfc_error_e result,
- ndef_message_s *selector,
- void *user_param)
-{
- _net_nfc_server_handover_create_config_context_t *context =
- (_net_nfc_server_handover_create_config_context_t *)user_param;
- data_s data;
-
- if (context == NULL)
- {
- return;
- }
-
- if (result == NET_NFC_OK)
- {
- result = _net_nfc_server_handover_convert_ndef_message_to_data(
- selector,
- &data);
-
- if (result == NET_NFC_OK)
- {
- /* process message */
- _net_nfc_server_handover_process_carrier_record(
- context->record,
- NULL,
- NULL);
-
- result = net_nfc_service_snep_server_send_get_response(
- context->user_param,
- &data);
- if (result != NET_NFC_OK)
- {
- DEBUG_ERR_MSG("net_nfc_service_snep_server"
- "_send_get_response failed [%d]",result);
- }
- net_nfc_util_free_data(&data);
- }
- else
- {
- DEBUG_ERR_MSG("_net_nfc_server_handover_convert_ndef_message_to_data"
- "failed [%d]",result);
- }
- }
- else
- {
- DEBUG_ERR_MSG("_net_nfc_server_handover_create_selector_msg"
- "failed [%d]",result);
- }
-
- _net_nfc_util_free_mem(context);
-}
-
-static net_nfc_error_e _net_nfc_server_handover_create_selector_msg(
- net_nfc_snep_handle_h handle,
- ndef_message_s *request,
- void *user_param)
-{
- net_nfc_error_e result;
- uint32_t count;
-
- net_nfc_manager_util_play_sound(NET_NFC_TASK_END);
-
- /* get requester message */
- if ((result = net_nfc_util_get_alternative_carrier_record_count(
- request,
- &count)) == NET_NFC_OK)
- {
- if (1/* power state */ || count == 1)
- {
- ndef_record_s *record = NULL;
-
- /* fill alternative carrier information */
- if ((result =
- _net_nfc_server_handover_get_carrier_record_by_priority_order(
- request,
- &record)) == NET_NFC_OK)
- {
- net_nfc_conn_handover_carrier_type_e type =
- NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
-
- if ((result = net_nfc_util_get_alternative_carrier_type_from_record(
- record,
- &type)) == NET_NFC_OK)
- {
- _net_nfc_server_handover_create_config_context_t *context = NULL;
-
- _net_nfc_util_alloc_mem(context, sizeof(*context));
-
- context->user_param = handle;
-
- net_nfc_util_create_record(record->TNF,
- &record->type_s, &record->id_s,
- &record->payload_s,
- &context->record);
-
- if ((result = _net_nfc_server_handover_create_selector_carrier_configs(
- type,
- _net_nfc_server_handover_server_create_carrier_configs_cb,
- context)) != NET_NFC_OK)
- {
- DEBUG_ERR_MSG("_create_selector_carrier_configs "
- "failed [%d]", result);
- }
- }
- else
- {
- DEBUG_ERR_MSG("get_alternative_carrier_type_from_record "
- "failed [%d]", result);
- }
- }
- else
- {
- DEBUG_ERR_MSG("r_get_carrier_record_by_priority_order"
- " failed [%d]", result);
- }
- }
- else /* low power && count > 1 */
- {
- ndef_message_s selector;
-
- if ((result = _net_nfc_server_handover_create_low_power_selector_message(
- request,
- &selector)) == NET_NFC_OK)
- {
- _net_nfc_server_handover_server_create_carrier_configs_cb(
- NET_NFC_OK,
- &selector,
- user_param);
-
- net_nfc_util_free_ndef_message(&selector);
- }
- else
- {
- DEBUG_ERR_MSG("_create_low_power_selector_message"
- "failed [%d]", result);
- }
- }
- }
- else
- {
- DEBUG_ERR_MSG("net_nfc_util_get_alternative_carrier_record_count"
- "failed [%d]", result);
- }
-
- return result;
-}
-
-
-static net_nfc_error_e _net_nfc_server_handover_create_server_cb(
- net_nfc_snep_handle_h handle,
- net_nfc_error_e result,
- uint32_t type,
- data_s *data,
- void *user_param)
-{
- DEBUG_SERVER_MSG("type [0x%02x], result [%d], data [%p], user_param [%p]",
- type, result, data, user_param);
-
- if (result != NET_NFC_OK || data == NULL || data->buffer == NULL)
- {
- /* restart */
- return NET_NFC_NULL_PARAMETER;
- }
-
- switch (type)
- {
- case SNEP_REQ_GET :
- {
- ndef_message_s *request;
-
- /* TODO : send select response to requester */
- result =
- _net_nfc_server_handover_create_requester_from_rawdata(
- &request,
- data);
- if (result == NET_NFC_OK) {
- if (1/* TODO : check version */)
- {
- _net_nfc_server_handover_create_selector_msg(
- handle,
- request,
- user_param);
- }
- else
- {
- DEBUG_ERR_MSG("not supported version [0x%x]",
- result);
-
- result = NET_NFC_NOT_SUPPORTED;
- }
-
- net_nfc_util_free_ndef_message(request);
- }
- else
- {
- DEBUG_ERR_MSG("_net_nfc_server_handover_create"
- "_requester_from_rawdata failed [%d]",result);
- }
- }
- break;
-
- case SNEP_REQ_PUT :
- DEBUG_ERR_MSG("PUT request doesn't supported");
- result = NET_NFC_NOT_SUPPORTED;
- break;
-
- default :
- DEBUG_ERR_MSG("error [%d]", result);
- break;
- }
-
- return result;
-}
-#else
-
-
-
static net_nfc_error_e _net_nfc_server_handover_select_carrier_record(
ndef_message_s *request,
net_nfc_conn_handover_carrier_type_e *type,
/* fill alternative carrier information */
if ((result =
- _net_nfc_server_handover_get_carrier_record_by_priority_order(
+ net_nfc_server_handover_get_carrier_record_by_priority_order(
request,
&temp)) == NET_NFC_OK)
{
}
else
{
- DEBUG_ERR_MSG("net_nfc_util_get_alternative"
+ NFC_ERR("net_nfc_util_get_alternative"
"_carrier_type_from_record failed [%d]", result);
}
}
else
{
- DEBUG_ERR_MSG("_handover_get_carrier_record"
+ NFC_ERR("_handover_get_carrier_record"
"_by_priority_order failed [%d]", result);
}
}
}
else
{
- DEBUG_ERR_MSG("net_nfc_util_get_alternative_carrier_record_count "
+ NFC_ERR("net_nfc_util_get_alternative_carrier_record_count "
"failed [%d]", result);
}
return result;
}
-#endif
-
static void _net_nfc_server_handover_create_carrier_configs_2_cb(
- net_nfc_error_e result,
- ndef_message_s *selector,
- void *user_param)
+ net_nfc_error_e result, ndef_message_s *selector, void *user_param)
{
- net_nfc_handover_context_t *context =
- (net_nfc_handover_context_t *)user_param;
+ net_nfc_handover_context_t *context = user_param;
- DEBUG_SERVER_MSG("_net_nfc_server_handover_server_create_carrier_config_cb"
- "result [%d]",result);
+ NFC_DBG("_net_nfc_server_handover_server_create_carrier_config_cb result [%d]",
+ result);
if (context == NULL)
{
selector,
&context->data);
- DEBUG_SERVER_MSG("selector message created, length [%d]",
- context->data.length);
+ NFC_DBG("selector message created, length [%d]", context->data.length);
context->state = NET_NFC_LLCP_STEP_03;
}
else
{
- DEBUG_ERR_MSG("_net_nfc_server_handover_create_selector_msg failed [%d]",
+ NFC_ERR("_net_nfc_server_handover_create_selector_msg failed [%d]",
result);
context->state = NET_NFC_MESSAGE_LLCP_ERROR;
}
net_nfc_handover_context_t *context =
(net_nfc_handover_context_t *)user_param;
- DEBUG_SERVER_MSG("_net_nfc_server_handover_server_process_carrier_record_cb"
- "result [%d]",result);
+ NFC_DBG("_net_nfc_server_handover_server_process_carrier_record_cb result [%d]",
+ result);
context->result = result;
if (result == NET_NFC_OK)
switch (context->state)
{
case NET_NFC_LLCP_STEP_02 :
- DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_02");
+ NFC_DBG("NET_NFC_LLCP_STEP_02");
result = _net_nfc_server_handover_create_selector_carrier_configs(
context->type,
if (result != NET_NFC_OK)
{
- DEBUG_ERR_MSG("_net_nfc_server_handover_create_"
+ NFC_ERR("_net_nfc_server_handover_create_"
"selector_carrier_config failed [%d]",result);
}
break;
case NET_NFC_LLCP_STEP_03 :
- DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_03");
+ NFC_DBG("NET_NFC_LLCP_STEP_03");
- result = _net_nfc_server_handover_process_carrier_record(
+ result = net_nfc_server_handover_process_carrier_record(
context->record,
_net_nfc_server_handover_process_carrier_record_2_cb,
context);
if (result != NET_NFC_OK)
{
- DEBUG_ERR_MSG("_net_nfc_server_handover_process_carrier_record"
+ NFC_ERR("net_nfc_server_handover_process_carrier_record"
"failed [%d]",result);
}
break;
case NET_NFC_LLCP_STEP_04 :
- DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_04");
+ NFC_DBG("NET_NFC_LLCP_STEP_04");
/* response select message */
+ // TODO: context->handle may is not valid type. we should find a right function or parameter
result = net_nfc_server_snep_server_send_get_response(
(net_nfc_snep_handle_h)context->handle,
&context->data);
break;
case NET_NFC_STATE_ERROR :
- DEBUG_SERVER_MSG("NET_NFC_STATE_ERROR");
+ NFC_DBG("NET_NFC_STATE_ERROR");
break;
default :
- DEBUG_ERR_MSG("NET_NFC_LLCP_STEP_??");
+ NFC_ERR("NET_NFC_LLCP_STEP_??");
/* TODO */
break;
}
net_nfc_error_e result;
ndef_message_s *request;
- DEBUG_SERVER_MSG("type [%d], data [%p], user_param [%p]",
- type, data, user_param);
+ NFC_DBG("type [%d], data [%p], user_param [%p]", type, data, user_param);
if (data == NULL || data->buffer == NULL)
{
}
/* TODO : send select response to requester */
- result = _net_nfc_server_handover_create_requester_from_rawdata(
- &request,
- data);
+ result = _net_nfc_server_handover_create_requester_from_rawdata(&request, data);
if (result == NET_NFC_OK)
{
}
else
{
- DEBUG_ERR_MSG("_net_nfc_util_alloc_mem failed");
+ NFC_ERR("_net_nfc_util_alloc_mem failed");
result = NET_NFC_ALLOC_FAIL;
}
}
}
else
{
- DEBUG_SERVER_MSG("it is not handover requester message, [%d]",
- result);
+ NFC_ERR("it is not handover requester message, [%d]", result);
}
return (result == NET_NFC_OK);
net_nfc_handover_context_t *context =
(net_nfc_handover_context_t *)user_param;
- DEBUG_SERVER_MSG("_net_nfc_server_handover_server_process"
- "_carrier_record_cb result [%d]",result);
+ NFC_DBG("_net_nfc_server_handover_server_process_carrier_record_cb result [%d]",
+ result);
context->result = result;
+
if (result == NET_NFC_OK)
- {
context->state = NET_NFC_LLCP_STEP_04;
- }
else
- {
context->state = NET_NFC_MESSAGE_LLCP_ERROR;
- }
_net_nfc_server_handover_server_process(context);
}
net_nfc_handover_context_t *context =
(net_nfc_handover_context_t *)user_param;
- DEBUG_SERVER_MSG("_net_nfc_server_handover_server_create"
- "_carrier_config_cb,result [%d]",result);
+ NFC_DBG("_net_nfc_server_handover_server_create_carrier_config_cb,result [%d]",
+ result);
if (context == NULL)
{
context->result = result;
+ net_nfc_conn_handover_carrier_type_e type;
+
+ net_nfc_util_get_alternative_carrier_type_from_record(
+ context->record,
+ &type);
if (result == NET_NFC_OK)
{
result = _net_nfc_server_handover_convert_ndef_message_to_data(
selector,
&context->data);
- DEBUG_SERVER_MSG("selector message created, length [%d]",
- context->data.length);
- context->state = NET_NFC_LLCP_STEP_03;
+ NFC_DBG("selector message created, length [%d]", context->data.length);
+ if(type == NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS)
+ context->state = NET_NFC_LLCP_STEP_04;
+ else
+ context->state = NET_NFC_LLCP_STEP_03;
}
else
{
- DEBUG_ERR_MSG("_net_nfc_server_handover_create_selector_msg"
+ NFC_ERR("_net_nfc_server_handover_create_selector_msg"
" failed [%d]", result);
context->state = NET_NFC_MESSAGE_LLCP_ERROR;
}
(net_nfc_handover_context_t *)user_param;
ndef_message_s *request;
- DEBUG_SERVER_MSG("_net_nfc_server_handover_server_recv_cb,"
- " socket [%x], result [%d]", socket, result);
+ NFC_DBG("_net_nfc_server_handover_server_recv_cb, socket [%x], result [%d]",
+ socket, result);
context->result = result;
}
else
{
- DEBUG_ERR_MSG("_net_nfc_server_handover_create"
+ NFC_ERR("_net_nfc_server_handover_create"
"_requester_from_rawdata failed [%d]",result);
context->state = NET_NFC_MESSAGE_LLCP_ERROR;
}
}
else
{
- DEBUG_ERR_MSG("net_nfc_server_llcp_simple_receive failed [%d]",
+ NFC_ERR("net_nfc_server_llcp_simple_receive failed [%d]",
result);
context->state = NET_NFC_MESSAGE_LLCP_ERROR;
}
net_nfc_handover_context_t *context =
(net_nfc_handover_context_t *)user_param;
- DEBUG_SERVER_MSG("_net_nfc_server_handover_server_send_cb"
- " socket [%x], result [%d]", socket, result);
+ NFC_DBG("_net_nfc_server_handover_server_send_cb socket[%x], result[%d]",
+ socket, result);
context->result = result;
}
else
{
- DEBUG_ERR_MSG("net_nfc_server_llcp_simple_send failed [%d]",
+ NFC_ERR("net_nfc_server_llcp_simple_send failed [%d]",
result);
context->state = NET_NFC_MESSAGE_LLCP_ERROR;
}
switch (context->state)
{
case NET_NFC_LLCP_STEP_01 :
- DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_01");
+ NFC_DBG("NET_NFC_LLCP_STEP_01");
/* receive request message */
net_nfc_server_llcp_simple_receive(context->handle,
break;
case NET_NFC_LLCP_STEP_02 :
- DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_02");
+ NFC_DBG("NET_NFC_LLCP_STEP_02");
context->result = _net_nfc_server_handover_create_selector_carrier_configs(
context->type,
if (context->result != NET_NFC_OK)
{
- DEBUG_ERR_MSG("_net_nfc_server_handover_create_selector"
+ NFC_ERR("_net_nfc_server_handover_create_selector"
"_carrier_configs failed [%d]", context->result);
}
break;
case NET_NFC_LLCP_STEP_03 :
- DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_03");
+ NFC_DBG("NET_NFC_LLCP_STEP_03");
- context->result = _net_nfc_server_handover_process_carrier_record(
+ context->result = net_nfc_server_handover_process_carrier_record(
context->record,
_net_nfc_server_handover_server_process_carrier_record_cb,
context);
if (context->result != NET_NFC_OK)
{
- DEBUG_ERR_MSG("_net_nfc_server_handover_process_carrier_"
+ NFC_ERR("_net_nfc_server_handover_process_carrier_"
"record failed [%d]",context->result);
}
break;
case NET_NFC_LLCP_STEP_04 :
- DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_04");
+ NFC_DBG("NET_NFC_LLCP_STEP_04");
/* send select message */
net_nfc_server_llcp_simple_send(
break;
case NET_NFC_STATE_ERROR :
- DEBUG_SERVER_MSG("NET_NFC_STATE_ERROR");
+ NFC_DBG("NET_NFC_STATE_ERROR");
/* error, invoke callback */
- DEBUG_ERR_MSG("handover_server failed, [%d]",
+ NFC_ERR("handover_server failed, [%d]",
context->result);
/* restart?? */
break;
default :
- DEBUG_ERR_MSG("NET_NFC_LLCP_STEP_??");
+ NFC_ERR("NET_NFC_LLCP_STEP_??");
/* TODO */
break;
}
net_nfc_handover_context_t *context =
(net_nfc_handover_context_t *)user_param;
- DEBUG_ERR_MSG("result [%d], socket [%x], user_param [%p]",
+ NFC_ERR("result [%d], socket [%x], user_param [%p]",
result, socket, user_param);
if (context == NULL)
data_s *data,
void *user_param)
{
- DEBUG_SERVER_MSG("result [%d], socket [%x], user_param [%p]",
- result, socket, user_param);
+ NFC_DBG("result[%d], socket[%x], user_param[%p]", result, socket, user_param);
net_nfc_handover_context_t *accept_context = NULL;
_net_nfc_util_alloc_mem(accept_context, sizeof(*accept_context));
if (accept_context == NULL)
{
- DEBUG_ERR_MSG("_net_nfc_util_alloc_mem failed");
+ NFC_ERR("_net_nfc_util_alloc_mem failed");
result = NET_NFC_ALLOC_FAIL;
goto ERROR;
if (result != NET_NFC_OK)
{
- DEBUG_ERR_MSG("net_nfc_server_llcp_simple_accept failed, [%d]",
+ NFC_ERR("net_nfc_server_llcp_simple_accept failed, [%d]",
result);
goto ERROR;
/* start default handover server using snep */
result =
net_nfc_server_snep_default_server_register_get_response_cb(
- _net_nfc_server_handover_get_response_cb,
- NULL);
+ _net_nfc_server_handover_get_response_cb, NULL);
/* start default handover server */
result = net_nfc_server_llcp_simple_server(
NULL);
if (result == NET_NFC_OK)
- {
- DEBUG_SERVER_MSG("start handover server, san [%s], sap [%d]",
- CH_SAN,CH_SAP);
- }
+ NFC_DBG("start handover server, san[%s], sap[%d]", CH_SAN, CH_SAP);
else
- {
- DEBUG_ERR_MSG("net_nfc_server_llcp_simple_server failed, [%d]",
- result);
- }
+ NFC_ERR("net_nfc_server_llcp_simple_server failed, [%d]", result);
return result;
}
static void _handover_default_activate_cb(int event,
- net_nfc_target_handle_s *handle,
- uint32_t sap, const char *san, void *user_param)
+ net_nfc_target_handle_s *handle,uint32_t sap, const char *san, void *user_param)
{
net_nfc_error_e result;
- DEBUG_SERVER_MSG("event [%d], handle [%p], sap [%d], san [%s]",
- event, handle, sap, san);
+ NFC_DBG("event [%d], handle [%p], sap [%d], san [%s]", event, handle, sap, san);
if (event == NET_NFC_LLCP_START) {
/* start default handover server using snep */
_net_nfc_server_handover_server_incomming_cb,
_net_nfc_server_handover_server_error_cb, NULL);
- if (result == NET_NFC_OK) {
- DEBUG_SERVER_MSG("start handover server, san [%s], sap [%d]",
- CH_SAN, CH_SAP);
- } else {
- DEBUG_ERR_MSG("net_nfc_service_llcp_server failed, [%d]",
- result);
- }
+ if (result == NET_NFC_OK)
+ NFC_DBG("start handover server, san [%s], sap [%d]", CH_SAN, CH_SAP);
+ else
+ NFC_ERR("net_nfc_service_llcp_server failed, [%d]", result);
+
} else if (event == NET_NFC_LLCP_UNREGISTERED) {
/* unregister server, do nothing */
}
net_nfc_handover_context_t *context =
(net_nfc_handover_context_t *)user_param;
- DEBUG_SERVER_MSG("_net_nfc_server_handover_server_process"
- "_carrier_record_cb,result [%d]",result);
+ NFC_DBG("_net_nfc_server_handover_server_process_carrier_record_cb, result[%d]",
+ result);
context->result = result;
if (result == NET_NFC_OK)
{
- net_nfc_util_alloc_data(&context->data, data->length);
- memcpy(context->data.buffer, data->buffer, data->length);
+ if(context->type == NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS)
+ context->state = NET_NFC_LLCP_STEP_RETURN;
+ else
+ {
+ net_nfc_util_alloc_data(&context->data, data->length);
+ memcpy(context->data.buffer, data->buffer, data->length);
- context->state = NET_NFC_LLCP_STEP_05;
+ context->state = NET_NFC_LLCP_STEP_05;
+ }
}
else
{
_net_nfc_server_handover_client_process(context);
}
-static void _net_nfc_server_handover_client_recv_cb(
- net_nfc_error_e result,
+static void _net_nfc_server_handover_client_recv_cb(net_nfc_error_e result,
net_nfc_target_handle_s *handle,
net_nfc_llcp_socket_t socket,
data_s *data,
ndef_message_s *selector;
ndef_record_s *record;
- result = _net_nfc_server_handover_create_selector_from_rawdata(
+ result = net_nfc_server_handover_create_selector_from_rawdata(
&selector,
data);
if (result == NET_NFC_OK)
{
result =
- _net_nfc_server_handover_get_carrier_record_by_priority_order(
+ net_nfc_server_handover_get_carrier_record_by_priority_order(
selector,
&record);
}
else
{
- DEBUG_ERR_MSG("_get_carrier_record_by_priority_order"
+ NFC_ERR("_get_carrier_record_by_priority_order"
" failed, [%d]",result);
context->state = NET_NFC_STATE_ERROR;
}
}
else
{
- DEBUG_ERR_MSG("_net_nfc_server_handover_create"
+ NFC_ERR("_net_nfc_server_handover_create"
"_selector_from_rawdata failed, [%d]",result);
context->state = NET_NFC_STATE_ERROR;
}
}
else
{
- DEBUG_ERR_MSG("net_nfc_server_llcp_simple_receive failed, [%d]",
+ NFC_ERR("net_nfc_server_llcp_simple_receive failed, [%d]",
result);
context->state = NET_NFC_STATE_ERROR;
}
_net_nfc_server_handover_client_process(context);
}
-static void _net_nfc_server_handover_client_send_cb(
- net_nfc_error_e result,
+static void _net_nfc_server_handover_client_send_cb(net_nfc_error_e result,
net_nfc_target_handle_s *handle,
net_nfc_llcp_socket_t socket,
data_s *data,
}
else
{
- DEBUG_ERR_MSG("net_nfc_server_llcp_simple_client failed, [%d]",
+ NFC_ERR("net_nfc_server_llcp_simple_client failed, [%d]",
result);
context->state = NET_NFC_STATE_ERROR;
}
}
else
{
- DEBUG_ERR_MSG("_net_nfc_server_handover_convert_ndef_"
+ NFC_ERR("_net_nfc_server_handover_convert_ndef_"
"message_to_data failed [%d]",result);
context->state = NET_NFC_STATE_ERROR;
context->result = result;
}
else
{
- DEBUG_ERR_MSG("null param, [%d]", result);
+ NFC_ERR("null param, [%d]", result);
context->state = NET_NFC_STATE_ERROR;
context->result = result;
}
switch (context->state)
{
case NET_NFC_LLCP_STEP_01 :
- DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_01");
+ NFC_DBG("NET_NFC_LLCP_STEP_01");
if ((result = _net_nfc_server_handover_create_requester_carrier_configs(
context->type,
_net_nfc_server_handover_client_create_carrier_configs_cb,
context)) != NET_NFC_OK)
{
- DEBUG_ERR_MSG("_net_nfc_server_handover_create_requester"
+ NFC_ERR("_net_nfc_server_handover_create_requester"
"_carrier_configs failed [%d]",result);
}
break;
case NET_NFC_LLCP_STEP_02 :
- DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_02");
+ NFC_DBG("NET_NFC_LLCP_STEP_02");
/* send request */
net_nfc_server_llcp_simple_send(
break;
case NET_NFC_LLCP_STEP_03 :
- DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_03");
+ NFC_DBG("NET_NFC_LLCP_STEP_03");
/* receive response */
net_nfc_server_llcp_simple_receive(context->handle,
break;
case NET_NFC_LLCP_STEP_04 :
- DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_04");
+ NFC_DBG("NET_NFC_LLCP_STEP_04");
- result = _net_nfc_server_handover_process_carrier_record(
+ result = net_nfc_server_handover_process_carrier_record(
context->record,
_net_nfc_server_handover_client_process_carrier_record_cb,
context);
if (result != NET_NFC_OK)
{
- DEBUG_ERR_MSG("_net_nfc_server_handover_process_carrier_record"
- "failed [%d]",result);
+ NFC_ERR("net_nfc_server_handover_process_carrier_record failed [%d]",result);
}
break;
case NET_NFC_LLCP_STEP_05 :
- DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_05");
+ NFC_DBG("NET_NFC_LLCP_STEP_05");
/* start post process */
if (context->type == NET_NFC_CONN_HANDOVER_CARRIER_BT)
}
else
{
- DEBUG_ERR_MSG("not supported...");
+ NFC_ERR("not supported...");
}
break;
case NET_NFC_LLCP_STEP_RETURN :
- DEBUG_SERVER_MSG("NET_NFC_LLCP_STEP_RETURN");
+ NFC_DBG("NET_NFC_LLCP_STEP_RETURN");
/* complete and invoke callback */
_net_nfc_server_handover_send_response(
- context->user_param,
+ context->result,
+ context->type,
&context->data,
- context->result);
+ context->user_param);
net_nfc_util_free_data(&context->data);
net_nfc_util_free_record(context->record);
case NET_NFC_STATE_ERROR :
default :
- DEBUG_ERR_MSG("NET_NFC_STATE_ERROR");
+ NFC_ERR("NET_NFC_STATE_ERROR");
_net_nfc_server_handover_send_response(
- context->user_param,
+ context->result,
+ context->type,
NULL,
- context->result);
+ context->user_param);
break;
}
}
data_s *data,
void *user_param)
{
- DEBUG_SERVER_MSG("result [%d], socket [%x], user_param [%p]",
- result, socket, user_param);
+ NFC_DBG("result [%d], socket [%x], user_param [%p]", result, socket, user_param);
+ HandoverRequestData *handover_data = NULL;
+ handover_data = (HandoverRequestData *)user_param;
if (result == NET_NFC_OK)
{
net_nfc_handover_context_t *context = NULL;
context->handle = handle;
context->socket = socket;
context->state = NET_NFC_LLCP_STEP_01;
+ context->type = handover_data->type;
context->user_param = user_param;
_net_nfc_server_handover_client_process(context);
}
else
{
- DEBUG_ERR_MSG("_net_nfc_util_alloc_mem failed");
+ NFC_ERR("_net_nfc_util_alloc_mem failed");
result = NET_NFC_ALLOC_FAIL;
}
}
else
{
- DEBUG_ERR_MSG("net_nfc_server_llcp_simple_client"
+ NFC_ERR("net_nfc_server_llcp_simple_client"
" failed, [%d]", result);
}
}
void *user_param)
{
- DEBUG_ERR_MSG("result [%d], socket [%x], user_param [%p]",
+ NFC_ERR("result [%d], socket [%x], user_param [%p]",
result, socket, user_param);
if (false)
{
- _net_nfc_server_handover_send_response(user_param, NULL, result);
+ _net_nfc_server_handover_send_response(
+ result,
+ NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN,
+ NULL,
+ user_param);
}
net_nfc_controller_llcp_socket_close(socket, &result);
net_nfc_error_e net_nfc_server_handover_default_client_start(
- net_nfc_target_handle_s *handle,
- void *user_data)
+ net_nfc_target_handle_s *handle, void *user_data)
{
net_nfc_error_e result;
if (result != NET_NFC_OK)
{
- DEBUG_ERR_MSG("net_nfc_server_llcp_simple_client"
+ NFC_ERR("net_nfc_server_llcp_simple_client"
" failed, [%d]",result);
}
projects / platform / core / connectivity / nfc-manager-neard.git / blobdiff