revise cumbersome structure that is a opaque type
[platform/core/connectivity/nfc-manager-neard.git] / daemon / net_nfc_server_process_handover.c
old mode 100644 (file)
new mode 100755 (executable)
index b2f8a15..898e770
@@ -47,7 +47,8 @@ typedef struct _net_nfc_handover_context_t
 }
 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;\
@@ -56,7 +57,13 @@ net_nfc_handover_context_t;
 
 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;
@@ -69,16 +76,22 @@ net_nfc_server_handover_create_config_context_t;
 
 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_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);
@@ -97,12 +110,22 @@ static void _net_nfc_server_handover_client_connected_cb(
                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,
@@ -138,45 +161,26 @@ static int _net_nfc_server_handover_iterate_carrier_configs_step(
 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)
        {
@@ -184,9 +188,10 @@ static void _net_nfc_server_handover_send_response(
                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(
@@ -243,12 +248,54 @@ static void _net_nfc_server_handover_bt_get_carrier_record_cb(
                                                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);
@@ -280,15 +327,38 @@ static void _net_nfc_server_handover_bt_process_carrier_record_cb(
        }
        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)
 {
@@ -324,12 +394,8 @@ net_nfc_error_e _net_nfc_server_handover_get_carrier_record_by_priority_order(
                                                                &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;
                                }
@@ -338,7 +404,7 @@ net_nfc_error_e _net_nfc_server_handover_get_carrier_record_by_priority_order(
        }
        else
        {
-               DEBUG_ERR_MSG("net_nfc_util_get_alternative_carrier"
+               NFC_ERR("net_nfc_util_get_alternative_carrier"
                                "_record_count failed");
        }
 
@@ -373,7 +439,7 @@ static net_nfc_error_e _net_nfc_server_handover_create_requester_from_rawdata(
                        }
                        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;
@@ -381,20 +447,19 @@ static net_nfc_error_e _net_nfc_server_handover_create_requester_from_rawdata(
                }
                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;
 
@@ -418,7 +483,7 @@ net_nfc_error_e _net_nfc_server_handover_create_selector_from_rawdata(
                        }
                        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;
@@ -426,13 +491,13 @@ net_nfc_error_e _net_nfc_server_handover_create_selector_from_rawdata(
                }
                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);
        }
 
@@ -455,21 +520,21 @@ static bool _net_nfc_server_handover_check_hr_record_validation(
        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;
        }
 
@@ -499,7 +564,7 @@ static bool _net_nfc_server_handover_check_hs_record_validation(
        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;
        }
@@ -507,14 +572,14 @@ static bool _net_nfc_server_handover_check_hs_record_validation(
        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;
        }
@@ -557,49 +622,6 @@ static int _net_nfc_server_handover_iterate_carrier_configs_step(
        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)
 {
@@ -607,16 +629,14 @@ static int _net_nfc_server_handover_iterate_carrier_configs_to_next(
        {
                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(
@@ -625,7 +645,7 @@ static int _net_nfc_server_handover_iterate_carrier_configs_to_next(
        }
        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,
@@ -639,39 +659,54 @@ static int _net_nfc_server_handover_iterate_create_carrier_configs(
                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);
@@ -683,7 +718,8 @@ static int _net_nfc_server_handover_iterate_create_carrier_configs(
        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)
@@ -699,8 +735,7 @@ static net_nfc_error_e _net_nfc_server_handover_create_requester_carrier_configs
                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;
@@ -717,7 +752,7 @@ static net_nfc_error_e _net_nfc_server_handover_create_requester_carrier_configs
        }
        else
        {
-               DEBUG_ERR_MSG("alloc failed");
+               NFC_ERR("alloc failed");
                result = NET_NFC_ALLOC_FAIL;
        }
 
@@ -726,7 +761,8 @@ static net_nfc_error_e _net_nfc_server_handover_create_requester_carrier_configs
        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)
@@ -757,7 +793,7 @@ static net_nfc_error_e _net_nfc_server_handover_create_selector_carrier_configs(
        }
        else
        {
-               DEBUG_ERR_MSG("alloc failed");
+               NFC_ERR("alloc failed");
                result = NET_NFC_ALLOC_FAIL;
        }
 
@@ -766,108 +802,8 @@ static net_nfc_error_e _net_nfc_server_handover_create_selector_carrier_configs(
        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;
@@ -892,7 +828,7 @@ net_nfc_error_e _net_nfc_server_handover_process_carrier_record(
                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,
@@ -900,28 +836,27 @@ net_nfc_error_e _net_nfc_server_handover_process_carrier_record(
                        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;
        }
 
@@ -930,368 +865,6 @@ net_nfc_error_e _net_nfc_server_handover_process_carrier_record(
        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,
@@ -1313,7 +886,7 @@ static net_nfc_error_e _net_nfc_server_handover_select_carrier_record(
 
                        /* 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)
                        {
@@ -1329,13 +902,13 @@ static net_nfc_error_e _net_nfc_server_handover_select_carrier_record(
                                }
                                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);
                        }
                }
@@ -1346,25 +919,20 @@ static net_nfc_error_e _net_nfc_server_handover_select_carrier_record(
        }
        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)
        {
@@ -1378,14 +946,13 @@ static void _net_nfc_server_handover_create_carrier_configs_2_cb(
                                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;
        }
@@ -1402,8 +969,8 @@ static void _net_nfc_server_handover_process_carrier_record_2_cb(
        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)
@@ -1436,7 +1003,7 @@ static void _net_nfc_server_handover_get_response_process(
        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,
@@ -1445,41 +1012,42 @@ static void _net_nfc_server_handover_get_response_process(
 
                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;
        }
@@ -1495,8 +1063,7 @@ static bool _net_nfc_server_handover_get_response_cb(
        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)
        {
@@ -1505,9 +1072,7 @@ static bool _net_nfc_server_handover_get_response_cb(
        }
 
        /* 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)
        {
@@ -1540,7 +1105,7 @@ static bool _net_nfc_server_handover_get_response_cb(
                        }
                        else
                        {
-                               DEBUG_ERR_MSG("_net_nfc_util_alloc_mem failed");
+                               NFC_ERR("_net_nfc_util_alloc_mem failed");
                                result = NET_NFC_ALLOC_FAIL;
                        }
                }
@@ -1553,8 +1118,7 @@ static bool _net_nfc_server_handover_get_response_cb(
        }
        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);
@@ -1570,18 +1134,15 @@ static void _net_nfc_server_handover_server_process_carrier_record_cb(
        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);
 }
@@ -1594,8 +1155,8 @@ static void _net_nfc_server_handover_server_create_carrier_config_cb(
        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)
        {
@@ -1604,18 +1165,25 @@ static void _net_nfc_server_handover_server_create_carrier_config_cb(
 
        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;
        }
@@ -1634,8 +1202,8 @@ static void _net_nfc_server_handover_server_recv_cb(
                (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;
 
@@ -1671,14 +1239,14 @@ static void _net_nfc_server_handover_server_recv_cb(
                }
                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;
        }
@@ -1695,8 +1263,8 @@ static void _net_nfc_server_handover_server_send_cb(net_nfc_error_e result,
        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;
 
@@ -1709,7 +1277,7 @@ static void _net_nfc_server_handover_server_send_cb(net_nfc_error_e 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;
        }
@@ -1728,7 +1296,7 @@ static void _net_nfc_server_handover_server_process(
        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,
@@ -1738,7 +1306,7 @@ static void _net_nfc_server_handover_server_process(
                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,
@@ -1747,27 +1315,27 @@ static void _net_nfc_server_handover_server_process(
 
                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(
@@ -1779,17 +1347,17 @@ static void _net_nfc_server_handover_server_process(
                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;
        }
@@ -1805,7 +1373,7 @@ static void _net_nfc_server_handover_server_error_cb(
        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)
@@ -1827,15 +1395,14 @@ static void _net_nfc_server_handover_server_incomming_cb(
                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;
@@ -1853,7 +1420,7 @@ static void _net_nfc_server_handover_server_incomming_cb(
 
        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;
@@ -1882,8 +1449,7 @@ net_nfc_error_e net_nfc_server_handover_default_server_start(
        /* 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(
@@ -1895,27 +1461,19 @@ net_nfc_error_e net_nfc_server_handover_default_server_start(
                        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 */
@@ -1928,13 +1486,11 @@ static void _handover_default_activate_cb(int event,
                                _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 */
        }
@@ -1998,8 +1554,8 @@ static void _net_nfc_server_handover_client_process_carrier_record_cb(
        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;
 
@@ -2007,10 +1563,15 @@ static void _net_nfc_server_handover_client_process_carrier_record_cb(
 
        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
        {
@@ -2020,8 +1581,7 @@ static void _net_nfc_server_handover_client_process_carrier_record_cb(
        _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,
@@ -2042,14 +1602,14 @@ static void _net_nfc_server_handover_client_recv_cb(
                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);
 
@@ -2065,21 +1625,21 @@ static void _net_nfc_server_handover_client_recv_cb(
                        }
                        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;
        }
@@ -2087,8 +1647,7 @@ static void _net_nfc_server_handover_client_recv_cb(
        _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,
@@ -2112,7 +1671,7 @@ static void _net_nfc_server_handover_client_send_cb(
        }
        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;
        }
@@ -2145,7 +1704,7 @@ static void _net_nfc_server_handover_client_create_carrier_configs_cb(
                }
                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;
@@ -2153,7 +1712,7 @@ static void _net_nfc_server_handover_client_create_carrier_configs_cb(
        }
        else
        {
-               DEBUG_ERR_MSG("null param, [%d]", result);
+               NFC_ERR("null param, [%d]", result);
                context->state = NET_NFC_STATE_ERROR;
                context->result = result;
        }
@@ -2176,20 +1735,20 @@ static void _net_nfc_server_handover_client_process(
        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(
@@ -2201,7 +1760,7 @@ static void _net_nfc_server_handover_client_process(
                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,
@@ -2211,22 +1770,21 @@ static void _net_nfc_server_handover_client_process(
                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)
@@ -2238,18 +1796,19 @@ static void _net_nfc_server_handover_client_process(
                }
                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);
@@ -2258,12 +1817,13 @@ static void _net_nfc_server_handover_client_process(
 
        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;
        }
 }
@@ -2277,9 +1837,10 @@ static void _net_nfc_server_handover_client_connected_cb(
                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;
@@ -2290,18 +1851,19 @@ static void _net_nfc_server_handover_client_connected_cb(
                        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);
        }
 }
@@ -2314,12 +1876,16 @@ static void _net_nfc_server_handover_client_error_cb(
                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);
@@ -2327,8 +1893,7 @@ static void _net_nfc_server_handover_client_error_cb(
 
 
 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;
 
@@ -2342,7 +1907,7 @@ net_nfc_error_e net_nfc_server_handover_default_client_start(
 
        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);
        }