From e8d5a8c47fcd482636b767e608be28ca527babe1 Mon Sep 17 00:00:00 2001 From: Abhijit R D Date: Mon, 16 Sep 2013 09:28:39 +0530 Subject: [PATCH] Wifi Handover implementation Wifi negotiated handover implementation Moved Wifi-Direct implementation under "TARGET" flag Addressed Prevent issues for the same Change-Id: I0eafb4eec223b7d1a9650e6639cd7e4ccb10b01e --- common/include/net_nfc_util_handover.h | 13 +- common/net_nfc_util_handover.c | 130 ++++- daemon/CMakeLists.txt | 12 +- daemon/net_nfc_server_handover_bss.c | 926 +++++++++++++++++++++++++------ daemon/net_nfc_server_handover_bss.h | 51 +- daemon/net_nfc_server_handover_bt.c | 24 +- daemon/net_nfc_server_process_handover.c | 536 +++++------------- daemon/net_nfc_server_process_handover.h | 14 +- packaging/nfc-manager.spec | 3 + tests/net_nfc_test_llcp.c | 6 +- tests/net_nfc_test_tag_felica.c | 2 +- 11 files changed, 1099 insertions(+), 618 deletions(-) mode change 100644 => 100755 common/include/net_nfc_util_handover.h mode change 100644 => 100755 common/net_nfc_util_handover.c mode change 100644 => 100755 daemon/CMakeLists.txt mode change 100644 => 100755 daemon/net_nfc_server_handover_bss.c mode change 100644 => 100755 daemon/net_nfc_server_handover_bss.h mode change 100644 => 100755 daemon/net_nfc_server_handover_bt.c mode change 100644 => 100755 daemon/net_nfc_server_process_handover.c mode change 100644 => 100755 daemon/net_nfc_server_process_handover.h mode change 100644 => 100755 packaging/nfc-manager.spec mode change 100644 => 100755 tests/net_nfc_test_llcp.c mode change 100644 => 100755 tests/net_nfc_test_tag_felica.c diff --git a/common/include/net_nfc_util_handover.h b/common/include/net_nfc_util_handover.h old mode 100644 new mode 100755 index 0f71d21..928ebf9 --- a/common/include/net_nfc_util_handover.h +++ b/common/include/net_nfc_util_handover.h @@ -25,6 +25,8 @@ #define CH_SAN "urn:nfc:sn:handover" #define CH_SAP 0x11 /* connection handover service access point */ +void net_nfc_convert_byte_order(unsigned char *array, int size); + net_nfc_error_e net_nfc_util_create_carrier_config(net_nfc_carrier_config_s **config, net_nfc_conn_handover_carrier_type_e type); net_nfc_error_e net_nfc_util_add_carrier_config_property(net_nfc_carrier_config_s *config, uint16_t attribute, uint16_t size, uint8_t *data); @@ -72,14 +74,14 @@ net_nfc_error_e net_nfc_util_set_alternative_carrier_power_status(ndef_message_s net_nfc_error_e net_nfc_util_get_alternative_carrier_type_from_record(ndef_record_s *record, net_nfc_conn_handover_carrier_type_e *type); /** - this function will get carrier type. + this function will get carrier type. - @param[in] carrier_info connection handover carrier info handler - @param[in] carrier_type record type. it can be a NET_NFC_CONN_HANDOVER_CARRIER_BT or NET_NFC_CONN_HANDOVER_CARRIER_WIFI or NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN. + @param[in] carrier_info connection handover carrier info handler + @param[in] carrier_type record type. it can be a NET_NFC_CONN_HANDOVER_CARRIER_BT or NET_NFC_CONN_HANDOVER_CARRIER_WIFI or NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN. - @return return the result of the calling the function + @return return the result of the calling the function - @exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illegal NULL pointer(s) + @exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illegal NULL pointer(s) */ net_nfc_error_e net_nfc_util_get_alternative_carrier_type(ndef_message_s *message, int index, net_nfc_conn_handover_carrier_type_e *power_state); @@ -87,6 +89,7 @@ net_nfc_error_e net_nfc_util_create_handover_request_message(ndef_message_s **me net_nfc_error_e net_nfc_util_create_handover_select_message(ndef_message_s **message); +net_nfc_error_e net_nfc_util_create_handover_carrier_record(ndef_record_s ** record); net_nfc_error_e net_nfc_util_create_handover_error_record(ndef_record_s **record, uint8_t reason, uint32_t data); net_nfc_error_e net_nfc_util_get_selector_power_status(ndef_message_s *message, net_nfc_conn_handover_carrier_state_e *power_state); diff --git a/common/net_nfc_util_handover.c b/common/net_nfc_util_handover.c old mode 100644 new mode 100755 index 2885d08..24374e4 --- a/common/net_nfc_util_handover.c +++ b/common/net_nfc_util_handover.c @@ -32,6 +32,19 @@ typedef struct _search_index void *found; } search_index; +inline void net_nfc_convert_byte_order(unsigned char *array, int size) +{ + int i; + unsigned char tmp_char; + + for (i=0;idata = g_list_append(config->data, group); - config->length += group->length; + config->length += group->length+4; return NET_NFC_OK; } @@ -483,7 +496,7 @@ net_nfc_error_e net_nfc_util_free_carrier_group(net_nfc_carrier_property_s *grou static void __make_serial_wifi(gpointer data, gpointer user_data) { net_nfc_carrier_property_s *info = (net_nfc_carrier_property_s *)data; - data_s *payload = user_data; + data_s *payload = (data_s *)user_data; uint8_t *current; int inc = 0; @@ -497,7 +510,9 @@ static void __make_serial_wifi(gpointer data, gpointer user_data) { DEBUG_MSG("[WIFI]Found Group make recursive"); *(uint16_t *)current = info->attribute; + net_nfc_convert_byte_order(current,2); *(uint16_t *)(current + inc) = info->length; + net_nfc_convert_byte_order((current + inc),2); payload->length += (inc + inc); g_list_foreach((GList *)info->data, __make_serial_wifi, payload); } @@ -505,7 +520,9 @@ static void __make_serial_wifi(gpointer data, gpointer user_data) { DEBUG_MSG("[WIFI]Element is found attrib:0x%X length:%d current:%d", info->attribute, info->length, payload->length); *(uint16_t *)current = info->attribute; + net_nfc_convert_byte_order(current,2); *(uint16_t *)(current + inc) = info->length; + net_nfc_convert_byte_order((current + inc),2); memcpy(current + inc + inc, info->data, info->length); payload->length += (inc + inc + info->length); } @@ -866,6 +883,43 @@ net_nfc_error_e net_nfc_util_create_handover_select_message(ndef_message_s **mes return NET_NFC_OK; } +net_nfc_error_e net_nfc_util_create_handover_carrier_record(ndef_record_s ** record) +{ + data_s payload = {NULL,0}; + + data_s type = { NULL, 0 }; + uint8_t *buffer_ptr = NULL; + + _net_nfc_util_alloc_mem(payload.buffer,26);//hardcoded as of now + if (payload.buffer == NULL) + return NET_NFC_ALLOC_FAIL; + + buffer_ptr = payload.buffer; + + //copy ctf + buffer_ptr[0]= NET_NFC_RECORD_MIME_TYPE; + + //copy the MIME type length + buffer_ptr[1] = strlen(CONN_HANDOVER_WIFI_BSS_CARRIER_MIME_NAME); + + //copy the MIME + memcpy(buffer_ptr[2],CONN_HANDOVER_WIFI_BSS_CARRIER_MIME_NAME,(payload.buffer)[1]); + payload.buffer[25] = '\0'; + + payload.length =26; + type.buffer = (uint8_t *)CH_CAR_RECORD_TYPE; + type.length = strlen(CH_CAR_RECORD_TYPE); + + net_nfc_util_create_record(NET_NFC_RECORD_MIME_TYPE, + &type, + NULL, + &payload, + (ndef_record_s **)record); + + _net_nfc_util_free_mem(payload.buffer); + + return NET_NFC_OK; +} net_nfc_error_e net_nfc_util_create_handover_error_record(ndef_record_s **record, uint8_t reason, uint32_t data) { data_s type; @@ -1467,23 +1521,71 @@ net_nfc_error_e net_nfc_util_set_alternative_carrier_power_status(ndef_message_s net_nfc_error_e net_nfc_util_get_alternative_carrier_type_from_record(ndef_record_s *record, net_nfc_conn_handover_carrier_type_e *type) { - if (strncmp((char *)record->type_s.buffer, CONN_HANDOVER_BT_CARRIER_MIME_NAME, (size_t)record->type_s.length) == 0) - { - *type = NET_NFC_CONN_HANDOVER_CARRIER_BT; - } - else if (strncmp((char *)record->type_s.buffer, CONN_HANDOVER_WIFI_BSS_CARRIER_MIME_NAME, (size_t)record->type_s.length) == 0) + if(strncmp((char*)record->type_s.buffer, CH_CAR_RECORD_TYPE, (size_t)record->type_s.length) == 0) { - *type = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS; - } - else if (strncmp((char *)record->type_s.buffer, CONN_HANDOVER_WIFI_IBSS_CARRIER_MIME_NAME, (size_t)record->type_s.length) == 0) - { - *type = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_IBSS; + DEBUG_MSG("CH_CAR_RECORD_TYPE"); + + char ctf = record->payload_s.buffer[0] & 0x07; + char ctype_length = record->payload_s.buffer[1]; + switch(ctf) + { + case NET_NFC_RECORD_MIME_TYPE: /* Media Type as defined in [RFC 2046] */ + if (strncmp((char *)&record->payload_s.buffer[2], + CONN_HANDOVER_BT_CARRIER_MIME_NAME, + (size_t)ctype_length) == 0) + { + *type = NET_NFC_CONN_HANDOVER_CARRIER_BT; + } + else if (strncmp((char *)&record->payload_s.buffer[2], + CONN_HANDOVER_WIFI_BSS_CARRIER_MIME_NAME, + (size_t)ctype_length) == 0) + { + *type = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS; + } + else if (strncmp((char *)&record->payload_s.buffer[2], + CONN_HANDOVER_WIFI_IBSS_CARRIER_MIME_NAME, + (size_t)ctype_length) == 0) + { + *type = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_IBSS; + } + else + { + *type = NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN; + } + break; + case NET_NFC_RECORD_WELL_KNOWN_TYPE: /* NFC Forum Well-known Type*/ + case NET_NFC_RECORD_URI: /* Absolute URIs as defined in [RFC 3986] */ + case NET_NFC_RECORD_EXTERNAL_RTD: /* NFC Forum external type */ + default: + *type = NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN; + break; + } + } else { - *type = NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN; + DEBUG_MSG("Other record type"); + if (strncmp((char *)record->type_s.buffer, CONN_HANDOVER_BT_CARRIER_MIME_NAME, (size_t)record->type_s.length) == 0) + { + *type = NET_NFC_CONN_HANDOVER_CARRIER_BT; + } + else if (strncmp((char *)record->type_s.buffer, + CONN_HANDOVER_WIFI_BSS_CARRIER_MIME_NAME, + (size_t)record->type_s.length) == 0) + { + *type = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS; + } + else if (strncmp((char *)record->type_s.buffer, + CONN_HANDOVER_WIFI_IBSS_CARRIER_MIME_NAME, + (size_t)record->type_s.length) == 0) + { + *type = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_IBSS; + } + else + { + *type = NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN; + } } - return NET_NFC_OK; } diff --git a/daemon/CMakeLists.txt b/daemon/CMakeLists.txt old mode 100644 new mode 100755 index c6ccc22..fd38c83 --- a/daemon/CMakeLists.txt +++ b/daemon/CMakeLists.txt @@ -6,9 +6,15 @@ SET(NFC_DAEMON "nfc-manager-daemon") FILE(GLOB DAEMON_SRCS *.c) -pkg_check_modules(daemon_pkgs REQUIRED aul glib-2.0 gio-unix-2.0 security-server - vconf dlog tapi appsvc libcurl bluetooth-api libssl svi capi-media-wav-player - pkgmgr pkgmgr-info capi-network-wifi ecore-x pmapi) +IF("${ARCH}" MATCHES "^arm.*") + pkg_check_modules(daemon_pkgs REQUIRED aul glib-2.0 gio-unix-2.0 security-server + vconf dlog tapi appsvc libcurl bluetooth-api libssl svi capi-media-wav-player + pkgmgr pkgmgr-info capi-network-wifi wifi-direct ecore-x pmapi) +ELSE() + pkg_check_modules(daemon_pkgs REQUIRED aul glib-2.0 gio-unix-2.0 security-server + vconf dlog tapi appsvc libcurl bluetooth-api libssl svi capi-media-wav-player + pkgmgr pkgmgr-info capi-network-wifi ecore-x pmapi) +ENDIF() FOREACH(flag ${daemon_pkgs_CFLAGS}) SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") diff --git a/daemon/net_nfc_server_handover_bss.c b/daemon/net_nfc_server_handover_bss.c old mode 100644 new mode 100755 index c4b75b9..7457fd6 --- a/daemon/net_nfc_server_handover_bss.c +++ b/daemon/net_nfc_server_handover_bss.c @@ -22,33 +22,60 @@ #include "net_nfc_util_ndef_record.h" #include "net_nfc_server_llcp.h" #include "net_nfc_server_handover_bss.h" +#include + +static gboolean _net_nfc_handover_bss_process_carrier_record( + gpointer user_data); + +static void _net_nfc_handover_bss_get_carrier_record( + net_nfc_handover_bss_create_context_t *context); + +static net_nfc_error_e _net_nfc_handover_bss_create_carrier_record( + ndef_record_s **record); + +#ifdef TARGET +static net_nfc_error_e _net_nfc_handover_bss_create_config_record( + ndef_record_s **record); + +static int _net_nfc_handover_process_wifi_direct_setup( + net_nfc_handover_bss_get_context_t *context); + +static gboolean _net_nfc_handover_bss_wfd_get_carrier_record( + net_nfc_handover_bss_get_context_t *context); + +static void _net_nfc_wifi_process_error(int error); + +static int _net_nfc_handover_process_wifi_group_setup( + net_nfc_handover_bss_get_context_t *context); + +static int _net_nfc_handover_getpassword(uint8_t** password ); +#endif -static gboolean _net_nfc_handover_bss_process_carrier_record(gpointer user_data); int _net_nfc_handover_bss_convert_security_type(int value) { int retval = 0; switch (value) { - case 0x0001: /* Open */ - retval = WIFI_SECURITY_TYPE_NONE; - break; - case 0x0002: /* WPA - Personal */ - retval = WIFI_SECURITY_TYPE_WPA_PSK; - break; - case 0x0004: /* WPA - Shared */ - retval = WIFI_SECURITY_TYPE_WEP; - break; - case 0x0008: /* WPA - Enterprise */ - case 0x0010: /* WPA2 - Enterprise */ - retval = WIFI_SECURITY_TYPE_EAP; - break; - case 0x0020: /* WPA2 - Personal */ - retval = WIFI_SECURITY_TYPE_WPA_PSK; - break; - default: - DEBUG_ERR_MSG("Invalid security Type"); - retval = 0; + case 0x0001: /* Open */ + retval = WIFI_SECURITY_TYPE_NONE; + break; + case 0x0002: /* WPA - Personal */ + retval = WIFI_SECURITY_TYPE_WPA_PSK; + break; + case 0x0004: /* WPA - Shared */ + retval = WIFI_SECURITY_TYPE_WEP; + break; + case 0x0008: /* WPA - Enterprise */ + case 0x0010: /* WPA2 - Enterprise */ + retval = WIFI_SECURITY_TYPE_EAP; + break; + case 0x0020: /* WPA2 - Personal */ + retval = WIFI_SECURITY_TYPE_WPA_PSK; + break; + default: + DEBUG_ERR_MSG("Invalid security Type"); + retval = 0; } return retval; } @@ -58,24 +85,24 @@ int _net_nfc_handover_bss_convert_encryption_type (int enc_type) int retval = 0; switch (enc_type) { - case 0x0001: /* None */ - retval = WIFI_ENCRYPTION_TYPE_NONE; - break; - case 0x0002: /* WEP */ - retval = WIFI_ENCRYPTION_TYPE_WEP; - break; - case 0x0004: /* TKIP */ - retval = WIFI_ENCRYPTION_TYPE_TKIP; - break; - case 0x0008: /* AES */ - retval = WIFI_ENCRYPTION_TYPE_AES; - break; - case 0x000C: /* TKIP + AES */ - retval = WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED; - break; - default: - DEBUG_ERR_MSG("Invalid Encryption type"); - retval = 0; + case 0x0001: /* None */ + retval = WIFI_ENCRYPTION_TYPE_NONE; + break; + case 0x0002: /* WEP */ + retval = WIFI_ENCRYPTION_TYPE_WEP; + break; + case 0x0004: /* TKIP */ + retval = WIFI_ENCRYPTION_TYPE_TKIP; + break; + case 0x0008: /* AES */ + retval = WIFI_ENCRYPTION_TYPE_AES; + break; + case 0x000C: /* TKIP + AES */ + retval = WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED; + break; + default: + DEBUG_ERR_MSG("Invalid Encryption type"); + retval = 0; } return retval; } @@ -89,7 +116,7 @@ _net_nfc_handover_bss_create_ap(net_nfc_carrier_config_s *config) // Sets SSID err = net_nfc_util_get_carrier_config_property(config, - NET_NFC_WIFI_ATTRIBUTE_SSID,(uint16_t *)&temp.length, &temp.buffer); + NET_NFC_WIFI_ATTRIBUTE_SSID,(uint16_t *)&temp.length, &temp.buffer); DEBUG_SERVER_MSG("SSID = [%s] err %d",temp.buffer, err); err = wifi_ap_create((char*)temp.buffer, &ap_handle); if(err != WIFI_ERROR_NONE) @@ -100,13 +127,13 @@ _net_nfc_handover_bss_create_ap(net_nfc_carrier_config_s *config) // Sets Authentication Type net_nfc_util_get_carrier_config_property(config, - NET_NFC_WIFI_ATTRIBUTE_AUTH_TYPE,(uint16_t *)&temp.length, &temp.buffer); + NET_NFC_WIFI_ATTRIBUTE_AUTH_TYPE,(uint16_t *)&temp.length, &temp.buffer); if(temp.length == 2) { uint16_t securitytype = temp.buffer[0] <<8 | temp.buffer[1]; DEBUG_MSG("wifi_ap_set_security_type %x", securitytype); err = wifi_ap_set_security_type(ap_handle, - _net_nfc_handover_bss_convert_security_type(securitytype)); + _net_nfc_handover_bss_convert_security_type(securitytype)); if(err != WIFI_ERROR_NONE) { DEBUG_ERR_MSG("set security type failed"); @@ -119,7 +146,7 @@ _net_nfc_handover_bss_create_ap(net_nfc_carrier_config_s *config) goto error; } net_nfc_util_get_carrier_config_property(config, - NET_NFC_WIFI_ATTRIBUTE_NET_KEY,(uint16_t *)&temp.length, &temp.buffer); + NET_NFC_WIFI_ATTRIBUTE_NET_KEY,(uint16_t *)&temp.length, &temp.buffer); // Sets Network Key err = wifi_ap_set_passphrase(ap_handle,(char*)temp.buffer); @@ -130,13 +157,13 @@ _net_nfc_handover_bss_create_ap(net_nfc_carrier_config_s *config) } // Sets encryption Type net_nfc_util_get_carrier_config_property(config, - NET_NFC_WIFI_ATTRIBUTE_ENC_TYPE,(uint16_t *)&temp.length, &temp.buffer); + NET_NFC_WIFI_ATTRIBUTE_ENC_TYPE,(uint16_t *)&temp.length, &temp.buffer); if(temp.length == 2) { uint16_t enc_type = temp.buffer[0] <<8 | temp.buffer[1]; DEBUG_MSG("wifi_ap_set_encryption_type %x", enc_type); err = wifi_ap_set_encryption_type(ap_handle, - _net_nfc_handover_bss_convert_encryption_type(enc_type)); + _net_nfc_handover_bss_convert_encryption_type(enc_type)); } else { @@ -159,7 +186,7 @@ _net_nfc_handover_bss_on_wifi_activated(wifi_error_e errorCode, void* user_data) if(context == NULL) { DEBUG_ERR_MSG("Invalid context"); - context->result = NET_NFC_OPERATION_FAIL; + return; } if (errorCode == WIFI_ERROR_NONE) { @@ -185,9 +212,6 @@ _net_nfc_handover_bss_wifi_for_each_access_point_found( if(context == NULL) { DEBUG_ERR_MSG("Invalid context"); - context->result = NET_NFC_OPERATION_FAIL; - context->step = NET_NFC_LLCP_STEP_RETURN; - g_idle_add(_net_nfc_handover_bss_process_carrier_record, context); return false; } @@ -201,7 +225,8 @@ _net_nfc_handover_bss_wifi_for_each_access_point_found( DEBUG_ERR_MSG("Wifi get carrier config failed"); context->result = NET_NFC_OPERATION_FAIL; context->step = NET_NFC_LLCP_STEP_RETURN; - g_idle_add(_net_nfc_handover_bss_process_carrier_record, context); + g_idle_add(_net_nfc_handover_bss_process_carrier_record, + context); return false; } @@ -219,102 +244,50 @@ _net_nfc_handover_bss_wifi_for_each_access_point_found( return true; } -void _net_nfc_handover_bss_on_wifi_bgscan_completed( - wifi_error_e errorCode, void* user_data) +void +_net_nfc_handover_bss_on_wifi_bgscan_completed(wifi_error_e error_code, + void* user_data) { - int err = WIFI_ERROR_NONE; + net_nfc_handover_bss_process_context_t *context = user_data; if(context == NULL) { DEBUG_ERR_MSG("Invalid context"); - context->result = NET_NFC_OPERATION_FAIL; - context->step = NET_NFC_LLCP_STEP_RETURN; - g_idle_add(_net_nfc_handover_bss_process_carrier_record, context); return; } - - if(errorCode != WIFI_ERROR_NONE) + if(error_code != WIFI_ERROR_NONE) { DEBUG_ERR_MSG("Wifi scan failed"); context->result = NET_NFC_OPERATION_FAIL; context->step = NET_NFC_LLCP_STEP_RETURN; - g_idle_add(_net_nfc_handover_bss_process_carrier_record,context); + g_idle_add( + _net_nfc_handover_bss_process_carrier_record, + context); } else { - net_nfc_util_create_carrier_config_from_config_record( - &context->config, context->carrier); - context->ap_handle = NULL; - err = wifi_foreach_found_aps( - _net_nfc_handover_bss_wifi_for_each_access_point_found, - context); - if(err != WIFI_ERROR_NONE) - { - DEBUG_ERR_MSG("wifi_foreach_found_aps failed Err[%x]",err); - context->result = NET_NFC_OPERATION_FAIL; - context->step = NET_NFC_LLCP_STEP_RETURN; - g_idle_add(_net_nfc_handover_bss_process_carrier_record, context); - } - if(context->ap_handle == NULL) - { - wifi_encryption_type_e enc_type; - wifi_security_type_e sec_type; - DEBUG_MSG("It's Hidden AP"); - context->ap_handle = _net_nfc_handover_bss_create_ap( - context->config); - wifi_ap_get_encryption_type(context->ap_handle, &enc_type); - DEBUG_MSG("Encryption type %x",enc_type); - wifi_ap_get_security_type(context->ap_handle, &sec_type); - DEBUG_MSG("Authentication type %x", sec_type); - } - else - { - data_s temp = { NULL, 0 }; - wifi_encryption_type_e enc_type = WIFI_ENCRYPTION_TYPE_NONE; - wifi_security_type_e sec_type = WIFI_SECURITY_TYPE_NONE; - //set passkey - net_nfc_util_get_carrier_config_property(context->config, - NET_NFC_WIFI_ATTRIBUTE_NET_KEY,(uint16_t *)&temp.length, - &temp.buffer); - - DEBUG_ERR_MSG("Network Key %s",temp.buffer); - // Sets Network Key - err = wifi_ap_set_passphrase(context->ap_handle, - (char*)temp.buffer); - - wifi_ap_get_encryption_type(context->ap_handle, &enc_type); - DEBUG_MSG("Encryption type %x",enc_type); - wifi_ap_get_security_type(context->ap_handle, &sec_type); - DEBUG_MSG("Authentication type %x", sec_type); - } - context->step = NET_NFC_LLCP_STEP_03; - g_idle_add(_net_nfc_handover_bss_process_carrier_record, context); + context->result = NET_NFC_OK; + context->step = NET_NFC_LLCP_STEP_02; } } -void _net_nfc_handover_bss_on_wifi_scan_completed(wifi_error_e errorCode, +void +_net_nfc_handover_bss_on_wifi_scan_completed(wifi_error_e error_code, void* user_data) { int err = WIFI_ERROR_NONE; net_nfc_handover_bss_process_context_t *context = user_data; - if(context == NULL) - { - DEBUG_ERR_MSG("Invalid context"); - context->result = NET_NFC_OPERATION_FAIL; - context->step = NET_NFC_LLCP_STEP_RETURN; - g_idle_add(_net_nfc_handover_bss_process_carrier_record, context); - return; - } - - if(errorCode != WIFI_ERROR_NONE) + if(error_code != WIFI_ERROR_NONE) { DEBUG_ERR_MSG("Wifi scan failed"); context->result = NET_NFC_OPERATION_FAIL; context->step = NET_NFC_LLCP_STEP_RETURN; - g_idle_add(_net_nfc_handover_bss_process_carrier_record, context); + g_idle_add( + _net_nfc_handover_bss_process_carrier_record, + context); } else { @@ -322,21 +295,23 @@ void _net_nfc_handover_bss_on_wifi_scan_completed(wifi_error_e errorCode, &context->config, context->carrier); context->ap_handle = NULL; err = wifi_foreach_found_aps( - _net_nfc_handover_bss_wifi_for_each_access_point_found, - context); + _net_nfc_handover_bss_wifi_for_each_access_point_found, + context); if(err != WIFI_ERROR_NONE) { DEBUG_ERR_MSG("wifi_foreach_found_aps failed Err[%x]",err); context->result = NET_NFC_OPERATION_FAIL; context->step = NET_NFC_LLCP_STEP_RETURN; - g_idle_add(_net_nfc_handover_bss_process_carrier_record, context); + g_idle_add( + _net_nfc_handover_bss_process_carrier_record, + context); } if(context->ap_handle == NULL) { wifi_encryption_type_e enc_type; wifi_security_type_e sec_type; - DEBUG_MSG("It's Hidden AP"); + context->ap_handle = _net_nfc_handover_bss_create_ap( context->config); wifi_ap_get_encryption_type(context->ap_handle, &enc_type); @@ -351,8 +326,8 @@ void _net_nfc_handover_bss_on_wifi_scan_completed(wifi_error_e errorCode, wifi_security_type_e sec_type = WIFI_SECURITY_TYPE_NONE; //set passkey net_nfc_util_get_carrier_config_property(context->config, - NET_NFC_WIFI_ATTRIBUTE_NET_KEY,(uint16_t *)&temp.length, - &temp.buffer); + NET_NFC_WIFI_ATTRIBUTE_NET_KEY,(uint16_t *)&temp.length, + &temp.buffer); DEBUG_ERR_MSG("Network Key %s",temp.buffer); // Sets Network Key @@ -364,27 +339,26 @@ void _net_nfc_handover_bss_on_wifi_scan_completed(wifi_error_e errorCode, DEBUG_MSG("Authentication type %x", sec_type); } context->step = NET_NFC_LLCP_STEP_03; - g_idle_add(_net_nfc_handover_bss_process_carrier_record, context); + g_idle_add( + _net_nfc_handover_bss_process_carrier_record, + context); } } void -_net_nfc_handover_bss_on_wifi_connected(wifi_error_e errorCode, void* user_data) +_net_nfc_handover_bss_on_wifi_connected(wifi_error_e error_code, void* user_data) { net_nfc_handover_bss_process_context_t *context = user_data; if(context == NULL) { DEBUG_ERR_MSG("Invalid context"); - context->result = NET_NFC_OPERATION_FAIL; - context->step = NET_NFC_LLCP_STEP_RETURN; - g_idle_add(_net_nfc_handover_bss_process_carrier_record, context); return; } - if(errorCode == WIFI_ERROR_NONE) + if(error_code == WIFI_ERROR_NONE) { DEBUG_ERR_MSG("WIFI Connected succesfully"); context->result = NET_NFC_OK; @@ -395,20 +369,23 @@ _net_nfc_handover_bss_on_wifi_connected(wifi_error_e errorCode, void* user_data) context->result = NET_NFC_OPERATION_FAIL; } context->step = NET_NFC_LLCP_STEP_RETURN; - g_idle_add(_net_nfc_handover_bss_process_carrier_record,context); + g_idle_add( + _net_nfc_handover_bss_process_carrier_record, + context); } -static gboolean _net_nfc_handover_bss_process_carrier_record(gpointer user_data) +static gboolean _net_nfc_handover_bss_process_carrier_record( + gpointer user_data) { - net_nfc_handover_bss_process_context_t *context = user_data; - LOGD("[%s:%d] START", __func__, __LINE__); + net_nfc_handover_bss_process_context_t *context = user_data; + if(context == NULL) { DEBUG_ERR_MSG("Invalid context"); DEBUG_ERR_MSG("Handover Failed"); - return -1; + return 0; } if (context->result != NET_NFC_OK && context->result != NET_NFC_BUSY) @@ -420,45 +397,48 @@ static gboolean _net_nfc_handover_bss_process_carrier_record(gpointer user_data) switch (context->step) { case NET_NFC_LLCP_STEP_01: - { - int err = WIFI_ERROR_NONE; - DEBUG_MSG("STEP [1]"); - err = wifi_initialize(); - /* WIFI returns WIFI_ERROR_INVALID_OPERATION in case already - * initialized*/ - if (err == WIFI_ERROR_NONE || err == WIFI_ERROR_INVALID_OPERATION) { - bool val = false; + int err = WIFI_ERROR_NONE; + DEBUG_MSG("STEP [1]"); + err = wifi_initialize(); + /* WIFI returns WIFI_ERROR_INVALID_OPERATION in case already + * initialized*/ + if (err == WIFI_ERROR_NONE || err == WIFI_ERROR_INVALID_OPERATION) + { + bool val = false; - err = wifi_is_activated(&val); - /* next step */ + err = wifi_is_activated(&val); + /* next step */ - if (val == false) - { - context->result = NET_NFC_OK; - wifi_set_background_scan_cb( - _net_nfc_handover_bss_on_wifi_bgscan_completed, context); - wifi_activate( - _net_nfc_handover_bss_on_wifi_activated, context); + if (val == false) + { + context->result = NET_NFC_OK; + wifi_set_background_scan_cb( + _net_nfc_handover_bss_on_wifi_bgscan_completed, context); + wifi_activate( + _net_nfc_handover_bss_on_wifi_activated, context); + } + else + { + /* do next step */ + DEBUG_MSG("Wifi is enabled already, go next step"); + context->result = NET_NFC_OK; + context->step = NET_NFC_LLCP_STEP_02; + g_idle_add(_net_nfc_handover_bss_process_carrier_record, + context); + } } else { - /* do next step */ - DEBUG_MSG("Wifi is enabled already, go next step"); - context->result = NET_NFC_OK; - context->step = NET_NFC_LLCP_STEP_02; - g_idle_add(_net_nfc_handover_bss_process_carrier_record, context); + DEBUG_ERR_MSG("Wifi init failed"); + context->result = NET_NFC_OPERATION_FAIL; + context->step = NET_NFC_LLCP_STEP_RETURN; + g_idle_add( + _net_nfc_handover_bss_process_carrier_record, + context); } } - else - { - DEBUG_ERR_MSG("Wifi init failed"); - context->result = NET_NFC_OPERATION_FAIL; - context->step = NET_NFC_LLCP_STEP_RETURN; - g_idle_add(_net_nfc_handover_bss_process_carrier_record, context); - } - } - break; + break; case NET_NFC_LLCP_STEP_02: { @@ -472,7 +452,9 @@ static gboolean _net_nfc_handover_bss_process_carrier_record(gpointer user_data) DEBUG_ERR_MSG("Wifi scan failed"); context->result = NET_NFC_OPERATION_FAIL; context->step = NET_NFC_LLCP_STEP_RETURN; - g_idle_add(_net_nfc_handover_bss_process_carrier_record, context); + g_idle_add( + _net_nfc_handover_bss_process_carrier_record, + context); } } @@ -481,14 +463,16 @@ static gboolean _net_nfc_handover_bss_process_carrier_record(gpointer user_data) { DEBUG_MSG("Connect with WIFI"); int err = wifi_connect(context->ap_handle, - _net_nfc_handover_bss_on_wifi_connected, context); + _net_nfc_handover_bss_on_wifi_connected, context); DEBUG_MSG("Connect with WIFI err [%x]",err); if(err != WIFI_ERROR_NONE) { DEBUG_ERR_MSG("Wifi Connect failed"); context->result = NET_NFC_OPERATION_FAIL; context->step = NET_NFC_LLCP_STEP_RETURN; - g_idle_add(_net_nfc_handover_bss_process_carrier_record, context); + g_idle_add( + _net_nfc_handover_bss_process_carrier_record, + context); } } break; @@ -504,6 +488,10 @@ static gboolean _net_nfc_handover_bss_process_carrier_record(gpointer user_data) DEBUG_ERR_MSG("Handover Failed"); } wifi_deinitialize(); + context->cb(context->result, + NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS, + NULL, + context->user_param); } break; @@ -517,9 +505,9 @@ static gboolean _net_nfc_handover_bss_process_carrier_record(gpointer user_data) } net_nfc_error_e net_nfc_server_handover_bss_process_carrier_record( - ndef_record_s *record, - net_nfc_server_handover_process_carrier_record_cb cb, - void *user_param) + ndef_record_s *record, + net_nfc_server_handover_process_carrier_record_cb cb, + void *user_param) { net_nfc_error_e result = NET_NFC_OK; net_nfc_handover_bss_process_context_t *context = NULL; @@ -531,14 +519,606 @@ net_nfc_error_e net_nfc_server_handover_bss_process_carrier_record( context->user_param = user_param; context->step = NET_NFC_LLCP_STEP_01; net_nfc_util_create_record(record->TNF, &record->type_s, - &record->id_s, &record->payload_s, &context->carrier); + &record->id_s, &record->payload_s, &context->carrier); - g_idle_add(_net_nfc_handover_bss_process_carrier_record, context); + g_idle_add( + _net_nfc_handover_bss_process_carrier_record, + context); } else { result = NET_NFC_ALLOC_FAIL; } + return result; +} + +#ifdef TARGET +void +_net_nfc_wifi_direct_power_changed(int err, wifi_direct_device_state_e device_state, void* user_data) +{ + + if(device_state == WIFI_DIRECT_DEVICE_STATE_ACTIVATED && err == WIFI_DIRECT_ERROR_NONE) + { + int err = wifi_direct_start_discovery(true, 0); + DEBUG_MSG("wifi direct is enabled %d",err); + } + else + { + DEBUG_ERR_MSG("wifi direct power state error"); + net_nfc_handover_bss_create_context_t* context = + (net_nfc_handover_bss_create_context_t*)user_data; + + context->step = NET_NFC_LLCP_STEP_RETURN; + context->result = NET_NFC_OPERATION_FAIL; + g_idle_add((GSourceFunc) + _net_nfc_handover_bss_wfd_get_carrier_record, + (gpointer)context); + } +} + +void +_net_nfc_wifi_scan_completed_cb(int err, wifi_direct_discovery_state_e discovery_state, void* user_data) +{ + + net_nfc_handover_bss_create_context_t* context = + (net_nfc_handover_bss_create_context_t*) user_data; + + if(discovery_state == WIFI_DIRECT_ONLY_LISTEN_STARTED && err == WIFI_DIRECT_ERROR_NONE) + { + g_idle_add((GSourceFunc) + _net_nfc_handover_bss_wfd_get_carrier_record, + (gpointer)context); + } + else + { + DEBUG_ERR_MSG("wifi scan error"); + context->step = NET_NFC_LLCP_STEP_RETURN; + context->result = NET_NFC_OPERATION_FAIL; + g_idle_add((GSourceFunc) + _net_nfc_handover_bss_wfd_get_carrier_record, + (gpointer)context); + } + +} + +void +_net_nfc_wifi_direct_connection_changed(wifi_direct_error_e error_code, + wifi_direct_connection_state_e connection_state, + const char* mac_address, + void *user_data) +{ + + net_nfc_handover_bss_create_context_t* context = + (net_nfc_handover_bss_create_context_t*) user_data; + + if(connection_state == WIFI_DIRECT_GROUP_CREATED + && error_code == WIFI_DIRECT_ERROR_NONE) + { + g_idle_add((GSourceFunc) + _net_nfc_handover_bss_wfd_get_carrier_record, + (gpointer)context); + } + else + { + DEBUG_ERR_MSG("_net_nfc_wifi_direct_connection_changed failed" + "[%d] [%d]",error_code,connection_state); + + context->step = NET_NFC_LLCP_STEP_RETURN; + context->result = NET_NFC_OPERATION_FAIL; + g_idle_add((GSourceFunc) + _net_nfc_handover_bss_wfd_get_carrier_record, + (gpointer)context); + } +} + +#endif + +static net_nfc_error_e _net_nfc_handover_bss_create_carrier_record( + ndef_record_s **record) +{ + net_nfc_error_e result; + + if ((result = net_nfc_util_create_handover_carrier_record( + record)) == NET_NFC_OK) + { + DEBUG_ERR_MSG("net_nfc_util_create_ndef_record" + "_with_carrier_config [%d]",result); + } + else + { + DEBUG_ERR_MSG("net_nfc_util_create_carrier_config failed " + "[%d]", result); + } return result; } + + +#ifdef TARGET +static int _net_nfc_handover_getpassword(uint8_t** password ) +{ + + char data[256]; + int ret_val; + + ret_val = system("wpa_cli -g /var/run/wpa_supplicant/p2p-wlan0-0 p2p_get_passphrase " + "> /tmp/nfc_p2p_passphrase.txt"); + + DEBUG_MSG("system command returned with [%d]",ret_val); + + FILE *f = fopen("/tmp/nfc_p2p_passphrase.txt","r"); + if(f != NULL) + { + int readlength; + int cnt; + readlength = fread(data, 1 , 255, f); + for(cnt = 0; cnt < readlength; cnt++) + { + if(data[cnt] == '\n') + { + break; + } + } + _net_nfc_util_alloc_mem(*password,(readlength - cnt)+1); + memcpy(*password, &data[cnt+1], (readlength - cnt)); + fclose(f); + return (readlength-cnt); + } + else + return 0; +} + + +static net_nfc_error_e _net_nfc_handover_bss_create_config_record( + ndef_record_s **record) +{ + char* mac_address = NULL; + char* ssid = NULL; + net_nfc_carrier_config_s *config = NULL; + net_nfc_carrier_property_s *cred_config = NULL; + net_nfc_error_e result; + uint8_t *password = NULL; + int pw_length = 0; + + data_s version_data = {NULL,0}; + data_s net_index_data = {NULL,0}; + data_s ssid_data = {NULL,0}; + data_s auth_data = {NULL,0}; + data_s enc_type = {NULL,0}; + data_s mac_data = {NULL,0}; + + _net_nfc_util_alloc_mem(version_data.buffer,1); + if(version_data.buffer) + { + version_data.length = 1; + *version_data.buffer = 0x01; + + if ((result = net_nfc_util_create_carrier_config( + &config, + NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS)) == NET_NFC_OK) + { + if ((result = net_nfc_util_add_carrier_config_property( + config, + NET_NFC_WIFI_ATTRIBUTE_VERSION, + version_data.length, version_data.buffer)) != NET_NFC_OK) + { + DEBUG_ERR_MSG("net_nfc_util_add_carrier_config_property failed" + "[%d]", result); + } + } + + _net_nfc_util_free_mem(version_data.buffer); + } + + if ((result = net_nfc_util_create_carrier_config_group( + &cred_config, + NET_NFC_WIFI_ATTRIBUTE_CREDENTIAL)) == NET_NFC_OK) + { + + _net_nfc_util_alloc_mem(net_index_data.buffer,1); + if(net_index_data.buffer) + { + net_index_data.length = 1; + *net_index_data.buffer = 1; + + + net_nfc_util_add_carrier_config_group_property( + cred_config, + NET_NFC_WIFI_ATTRIBUTE_NET_INDEX, + net_index_data.length, net_index_data.buffer); + + _net_nfc_util_free_mem(net_index_data.buffer); + } + + wifi_direct_get_ssid(&ssid); + + _net_nfc_util_alloc_mem(ssid_data.buffer,strlen(ssid)+2); + if(ssid_data.buffer) + { + ssid_data.length = strlen(ssid); + memcpy(ssid_data.buffer,ssid, strlen(ssid)); + + net_nfc_util_add_carrier_config_group_property( + cred_config, + NET_NFC_WIFI_ATTRIBUTE_SSID, + ssid_data.length, ssid_data.buffer); + + _net_nfc_util_free_mem(version_data.buffer); + } + + _net_nfc_util_alloc_mem(auth_data.buffer,2); + if(auth_data.buffer) + { + auth_data.length = 1; + *auth_data.buffer = 20; + + net_nfc_util_add_carrier_config_group_property( + cred_config, + NET_NFC_WIFI_ATTRIBUTE_AUTH_TYPE, + auth_data.length, auth_data.buffer); + + _net_nfc_util_free_mem(auth_data.buffer); + } + + _net_nfc_util_alloc_mem(enc_type.buffer,2); + if(enc_type.buffer) + { + enc_type.length = 1; + *enc_type.buffer = 8; + + net_nfc_util_add_carrier_config_group_property( + cred_config, + NET_NFC_WIFI_ATTRIBUTE_ENC_TYPE, + enc_type.length, enc_type.buffer); + + _net_nfc_util_free_mem(enc_type.buffer); + } + + pw_length = _net_nfc_handover_getpassword(&password); + + DEBUG_ERR_MSG("_net_nfc_handover_getpassword[%s]", password); + + net_nfc_util_add_carrier_config_group_property( + cred_config, + NET_NFC_WIFI_ATTRIBUTE_NET_KEY, + pw_length, password); + + _net_nfc_util_free_mem(password); + + wifi_direct_get_mac_address(&mac_address); + + _net_nfc_util_alloc_mem(mac_data.buffer,strlen(mac_address)+2); + if(mac_data.buffer) + { + mac_data.length = strlen(mac_address); + memcpy(mac_data.buffer,mac_address,strlen(mac_address)); + + if ((result = net_nfc_util_add_carrier_config_group_property( + cred_config, + NET_NFC_WIFI_ATTRIBUTE_MAC_ADDR, + mac_data.length, mac_data.buffer)) != NET_NFC_OK) + { + DEBUG_ERR_MSG("net_nfc_util_add_carrier" + "_config_property failed" + "[%d]", result); + } + } + + _net_nfc_util_free_mem(mac_data.buffer); + + } + net_nfc_util_append_carrier_config_group(config, cred_config); + + result = net_nfc_util_create_ndef_record_with_carrier_config( + record, + config); + + if (result != NET_NFC_OK) + { + DEBUG_ERR_MSG("net_nfc_util_create_ndef_record" + "_with_carrier_config failed" + "[%d]",result); + } + + return result; +} +#endif + + +static void _net_nfc_handover_bss_get_carrier_record( + net_nfc_handover_bss_create_context_t *context) +{ + LOGD("[%s:%d] START", __func__, __LINE__); + + if(context != NULL) + { + + if (context->result != NET_NFC_OK && context->result != NET_NFC_BUSY) + { + DEBUG_ERR_MSG("context->result is error [%d]", context->result); + } + + context->result = NET_NFC_OK; + + context->cps = NET_NFC_CONN_HANDOVER_CARRIER_ACTIVATE; + + /* Create carrier record */ + context->result =_net_nfc_handover_bss_create_carrier_record( + &context->carrier); + if (context->result!= NET_NFC_OK) + { + DEBUG_ERR_MSG("create_bss_config_record failed" + " [%d]", context->result); + } + + /* complete and return to upper step */ + context->cb(context->result, + context->cps, + context->carrier, + 0, + NULL, + context->user_param); + } +} + +#ifdef TARGET +static void _net_nfc_wifi_process_error(int error) +{ + DEBUG_ERR_MSG("_net_nfc_wifi_process_error - [%d]",error); + + context->step = NET_NFC_LLCP_STEP_RETURN; + context->result = NET_NFC_OPERATION_FAIL; + + g_idle_add((GSourceFunc) + _net_nfc_handover_bss_wfd_get_carrier_record, + (gpointer)context); + + return; +} + +static int _net_nfc_handover_process_wifi_direct_setup( + net_nfc_handover_bss_get_context_t *context) +{ + int err = WIFI_DIRECT_ERROR_NONE; + err = wifi_direct_initialize(); + if(err != WIFI_DIRECT_ERROR_NONE) + { + DEBUG_ERR_MSG("wifi_direct_initialize err value %d",err); + return err; + } + + err = wifi_direct_set_device_state_changed_cb( + _net_nfc_wifi_direct_power_changed, + context); + + if(err != WIFI_DIRECT_ERROR_NONE) + { + DEBUG_ERR_MSG("wifi_direct_set_device_state_changed_cb err value %d",err); + return err; + } + + err = wifi_direct_set_discovery_state_changed_cb( + _net_nfc_wifi_scan_completed_cb, + context); + + if(err != WIFI_DIRECT_ERROR_NONE) + { + DEBUG_ERR_MSG("wifi_direct_set_discovery_state_changed_cb err value %d",err); + return err; + } + + err = wifi_direct_set_connection_state_changed_cb( + _net_nfc_wifi_direct_connection_changed, + context); + + if (err != WIFI_DIRECT_ERROR_NONE) + { + DEBUG_ERR_MSG("wifi_direct_set_connection_state_changed_cb err value %d",err); + return err; + } + else + { + context->step = NET_NFC_LLCP_STEP_02; + context->result = NET_NFC_OK; + + wifi_direct_state_e status = WIFI_DIRECT_STATE_DEACTIVATED; + + err = wifi_direct_get_state(&status); + DEBUG_ERR_MSG("status value %d",status); + + if (status != WIFI_DIRECT_STATE_ACTIVATED) + { + wifi_direct_activate(); + } + else + { + DEBUG_MSG("wifi direct is enabled already"); + + /* do next step */ + g_idle_add((GSourceFunc) + _net_nfc_handover_bss_wfd_get_carrier_record, + (gpointer)context); + } + return WIFI_DIRECT_ERROR_NONE; + + } +} + +static int _net_nfc_handover_process_wifi_group_setup( + net_nfc_handover_bss_get_context_t *context) +{ + int err = WIFI_DIRECT_ERROR_NONE; + bool group_owner = false; + + err = wifi_direct_is_group_owner(&group_owner); + DEBUG_ERR_MSG("error value %d",err); + + context->step = NET_NFC_LLCP_STEP_03; + context->result = NET_NFC_OK; + + if(err == WIFI_DIRECT_ERROR_NONE) + { + if(group_owner == true) + { + DEBUG_MSG("Already group owner, continue next step"); + g_idle_add((GSourceFunc) + _net_nfc_handover_bss_wfd_get_carrier_record, + (gpointer)context); + } + else + { + err = wifi_direct_create_group(); + if (err != WIFI_DIRECT_ERROR_NONE) + { + DEBUG_ERR_MSG("wifi_direct_create_group failed [%d]",err); + return err; + } + } + } + else + { + DEBUG_ERR_MSG("wifi_direct_is_group_owner failed [%d]",err); + return err; + } + +} + +static gboolean _net_nfc_handover_bss_wfd_get_carrier_record( + net_nfc_handover_bss_get_context_t *context) +{ + LOGD("[%s:%d] START", __func__, __LINE__); + if(context == NULL) + { + DEBUG_ERR_MSG("Invalid context"); + return FALSE; + } + + if(context != NULL) + { + int err = WIFI_DIRECT_ERROR_NONE; + + if (context->result != NET_NFC_OK && context->result != NET_NFC_BUSY) + { + DEBUG_ERR_MSG("context->result is error" + " [%d]", context->result); + + context->step = NET_NFC_LLCP_STEP_RETURN; + } + + switch (context->step) + { + case NET_NFC_LLCP_STEP_01 : + DEBUG_ERR_MSG("NET_NFC_LLCP_STEP_01"); + err = _net_nfc_handover_process_wifi_direct_setup(context); + if(err != WIFI_DIRECT_ERROR_NONE) + { + DEBUG_ERR_MSG("_net_nfc_handover_process_wifi_direct_setup failed"); + _net_nfc_wifi_process_error(err); + } + break; + case NET_NFC_LLCP_STEP_02: + DEBUG_ERR_MSG("NET_NFC_LLCP_STEP_02"); + err = _net_nfc_handover_process_wifi_group_setup(context); + if(err != WIFI_DIRECT_ERROR_NONE) + { + DEBUG_ERR_MSG("_net_nfc_handover_process_wifi_group_setup failed"); + _net_nfc_wifi_process_error(err); + } + break; + case NET_NFC_LLCP_STEP_03 : + DEBUG_ERR_MSG("NET_NFC_LLCP_STEP_03"); + context->step = NET_NFC_LLCP_STEP_RETURN; + + /* append config to ndef message */ + context->result =_net_nfc_handover_bss_create_config_record( + &context->carrier); + if (context->result != NET_NFC_OK) + { + DEBUG_ERR_MSG("_net_nfc_handover_bss_create_config_record failed" + "[%d]", context->result); + } + + g_idle_add((GSourceFunc) + _net_nfc_handover_bss_wfd_get_carrier_record, + (gpointer)context); + + break; + case NET_NFC_LLCP_STEP_RETURN : + DEBUG_ERR_MSG("NET_NFC_LLCP_STEP_RETURN"); + /* unregister current callback */ + wifi_direct_unset_connection_state_changed_cb(); + wifi_direct_unset_device_state_changed_cb(); + wifi_direct_unset_discovery_state_changed_cb(); + wifi_direct_deinitialize(); + + /* complete and return to upper step */ + context->cb(context->result, + context->cps, + context->carrier, + context->aux_data_count, + context->aux_data, + context->user_param); + break; + + default : + break; + } + } + LOGD("[%s:%d] END", __func__, __LINE__); + + return TRUE; +} +#endif + +net_nfc_error_e net_nfc_server_handover_bss_get_carrier_record( + net_nfc_server_handover_get_carrier_record_cb cb, + void *user_param) +{ + net_nfc_error_e result = NET_NFC_OK; + net_nfc_handover_bss_create_context_t *context = NULL; + + _net_nfc_util_alloc_mem(context, sizeof(*context)); + if (context != NULL) + { + context->cb = cb; + context->user_param = user_param; + context->step = NET_NFC_LLCP_STEP_01; + + _net_nfc_handover_bss_get_carrier_record(context); + + } + else + { + result = NET_NFC_ALLOC_FAIL; + } + + return result; +} + +#ifdef TARGET +net_nfc_error_e net_nfc_server_handover_bss_wfd_get_carrier_record( + net_nfc_server_handover_get_carrier_record_cb cb, + void *user_param) +{ + net_nfc_handover_bss_get_context_t *context = NULL; + + _net_nfc_util_alloc_mem(context, sizeof(*context)); + if (context != NULL) + { + context->cb = cb; + context->user_param = user_param; + context->step = NET_NFC_LLCP_STEP_01; + context->cps = NET_NFC_CONN_HANDOVER_CARRIER_ACTIVATE; + + g_idle_add((GSourceFunc)_net_nfc_handover_bss_wfd_get_carrier_record, + (gpointer)context); + + return NET_NFC_OK: + } + else + { + return NET_NFC_ALLOC_FAIL; + } + +} +#endif diff --git a/daemon/net_nfc_server_handover_bss.h b/daemon/net_nfc_server_handover_bss.h old mode 100644 new mode 100755 index 87a2e9e..16638f5 --- a/daemon/net_nfc_server_handover_bss.h +++ b/daemon/net_nfc_server_handover_bss.h @@ -15,11 +15,19 @@ */ #ifndef __NET_NFC_SERVER_HANDOVER_BSS_H__ #define __NET_NFC_SERVER_HANDOVER_BSS_H__ - +#include #include - +#ifdef TARGET +#include +#endif +#include "net_nfc_debug_internal.h" #include "net_nfc_typedef_internal.h" +#include "net_nfc_util_internal.h" +#include "net_nfc_util_ndef_message.h" +#include "net_nfc_util_ndef_record.h" +#include "net_nfc_util_handover.h" #include "net_nfc_server_handover_bt.h" +#include "net_nfc_server_llcp.h" typedef struct _net_nfc_handover_bss_process_context_t { @@ -38,5 +46,44 @@ net_nfc_error_e net_nfc_server_handover_bss_process_carrier_record( ndef_record_s *record, net_nfc_server_handover_process_carrier_record_cb cb, void *user_param); +net_nfc_error_e net_nfc_server_handover_bss_get_carrier_record( + net_nfc_server_handover_get_carrier_record_cb cb, + void *user_param); +typedef struct _net_nfc_handover_bss_create_context_t +{ + int step; + net_nfc_error_e result; + net_nfc_server_handover_get_carrier_record_cb cb; + net_nfc_conn_handover_carrier_state_e cps; + ndef_record_s *carrier; + data_s data; + void *user_param; + wifi_ap_h ap_handle; + net_nfc_carrier_config_s *config; +} +net_nfc_handover_bss_create_context_t; +typedef struct _net_nfc_handover_bss_get_context_t +{ + int step; + net_nfc_error_e result; + net_nfc_conn_handover_carrier_state_e cps; + net_nfc_server_handover_get_carrier_record_cb cb; + ndef_record_s *carrier; + uint32_t aux_data_count; + ndef_record_s *aux_data; + void *user_param; +} +net_nfc_handover_bss_get_context_t; + +net_nfc_error_e net_nfc_server_handover_bss_process_carrier_record( + ndef_record_s *record, + net_nfc_server_handover_process_carrier_record_cb cb, + void *user_param); + +#ifdef TARGET +net_nfc_error_e net_nfc_server_handover_bss_wfd_get_carrier_record( + net_nfc_server_handover_get_carrier_record_cb cb, + void *user_param); +#endif #endif //__NET_NFC_SERVER_HANDOVER_BSS_H__ diff --git a/daemon/net_nfc_server_handover_bt.c b/daemon/net_nfc_server_handover_bt.c old mode 100644 new mode 100755 index 4b411fa..2825f88 --- a/daemon/net_nfc_server_handover_bt.c +++ b/daemon/net_nfc_server_handover_bt.c @@ -55,18 +55,6 @@ static int _net_nfc_handover_bt_get_carrier_record( static int _net_nfc_handover_bt_process_carrier_record( net_nfc_handover_bt_process_context_t *context); -static inline void _net_nfc_convert_byte_order(unsigned char *array, int size) -{ - int i; - unsigned char tmp_char; - - for (i=0;ihash_len = MIN(sizeof(oob->hash), hash.length); memcpy(oob->hash, hash.buffer, oob->hash_len); @@ -115,7 +103,7 @@ static net_nfc_error_e _net_nfc_handover_bt_get_oob_data( { DEBUG_MSG("randomizer.length == 16"); - _net_nfc_convert_byte_order(randomizer.buffer, 16); + net_nfc_convert_byte_order(randomizer.buffer, 16); oob->randomizer_len = MIN(sizeof(oob->randomizer), randomizer.length); memcpy(oob->randomizer, randomizer.buffer, oob->randomizer_len); @@ -193,7 +181,7 @@ static net_nfc_error_e _net_nfc_handover_bt_create_config_record( { bt_oob_data_t oob = { { 0 }, }; - _net_nfc_convert_byte_order(bt_addr.addr, 6); + net_nfc_convert_byte_order(bt_addr.addr, 6); if ((result = net_nfc_util_add_carrier_config_property( config, @@ -215,7 +203,7 @@ static net_nfc_error_e _net_nfc_handover_bt_create_config_record( DEBUG_SERVER_MSG("oob.randomizer_len" " [%d]", oob.randomizer_len); - _net_nfc_convert_byte_order(oob.hash, 16); + net_nfc_convert_byte_order(oob.hash, 16); if ((result = net_nfc_util_add_carrier_config_property( @@ -228,7 +216,7 @@ static net_nfc_error_e _net_nfc_handover_bt_create_config_record( " [%d]",result); } - _net_nfc_convert_byte_order(oob.randomizer, 16); + net_nfc_convert_byte_order(oob.randomizer, 16); if ((result = net_nfc_util_add_carrier_config_property( config, @@ -595,7 +583,7 @@ static int _net_nfc_handover_bt_process_carrier_record( if (temp.length == 6) { - _net_nfc_convert_byte_order(temp.buffer, 6); + net_nfc_convert_byte_order(temp.buffer, 6); memcpy(context->addr.addr, temp.buffer, diff --git a/daemon/net_nfc_server_process_handover.c b/daemon/net_nfc_server_process_handover.c old mode 100644 new mode 100755 index dc4cc8d..c412597 --- a/daemon/net_nfc_server_process_handover.c +++ b/daemon/net_nfc_server_process_handover.c @@ -76,7 +76,8 @@ typedef struct _net_nfc_server_handover_process_config_context_t -static void _net_nfc_server_handover_send_response(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); @@ -98,6 +99,19 @@ 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); @@ -241,7 +255,51 @@ static void _net_nfc_server_handover_bt_get_carrier_record_cb( /* 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) + { + 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(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_bt_process_carrier_record_cb( net_nfc_error_e result, net_nfc_conn_handover_carrier_type_e type, @@ -267,9 +325,32 @@ static void _net_nfc_server_handover_bt_process_carrier_record_cb( _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 + DEBUG_ERR_MSG("Invalid Callback"); -net_nfc_error_e net_nfc_server_handover_get_carrier_record_by_priority_order( - ndef_message_s *request, ndef_record_s **record) + _net_nfc_util_free_mem(context); + } +} +net_nfc_error_e +net_nfc_server_handover_get_carrier_record_by_priority_order( + ndef_message_s *request, + ndef_record_s **record) { net_nfc_error_e result; unsigned int carrier_count = 0; @@ -574,6 +655,7 @@ 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) { @@ -584,12 +666,26 @@ static int _net_nfc_server_handover_iterate_create_carrier_configs( 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 : + DEBUG_MSG("[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); + } + DEBUG_MSG("[%d]",result); + break; // case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_IBSS : // DEBUG_MSG("[NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS]"); @@ -618,7 +714,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) @@ -661,7 +758,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) @@ -671,12 +769,14 @@ static net_nfc_error_e _net_nfc_server_handover_create_selector_carrier_configs( LOGD("[%s:%d] START", __func__, __LINE__); - _net_nfc_util_alloc_mem(context, sizeof(*context)); + _net_nfc_util_alloc_mem(context, sizeof(net_nfc_server_handover_create_config_context_t)); if (context != NULL) { context->type = type; if (type == NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN) + { context->current_type = NET_NFC_CONN_HANDOVER_CARRIER_BT; + } else context->current_type = context->type; @@ -738,9 +838,8 @@ net_nfc_error_e net_nfc_server_handover_process_carrier_record( DEBUG_MSG("[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 : @@ -765,368 +864,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, @@ -1188,8 +925,6 @@ static net_nfc_error_e _net_nfc_server_handover_select_carrier_record( return result; } -#endif - static void _net_nfc_server_handover_create_carrier_configs_2_cb( net_nfc_error_e result, ndef_message_s *selector, @@ -1409,14 +1144,11 @@ static void _net_nfc_server_handover_server_process_carrier_record_cb( "_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); } @@ -1439,6 +1171,11 @@ 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( @@ -1446,7 +1183,10 @@ static void _net_nfc_server_handover_server_create_carrier_config_cb( &context->data); DEBUG_SERVER_MSG("selector message created, length [%d]", context->data.length); - context->state = NET_NFC_LLCP_STEP_03; + 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 { @@ -1744,7 +1484,7 @@ net_nfc_error_e net_nfc_server_handover_default_server_start( } 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; @@ -1841,10 +1581,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 { @@ -1854,7 +1599,8 @@ 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, @@ -1920,7 +1666,8 @@ static void _net_nfc_server_handover_client_recv_cb(net_nfc_error_e result, _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, @@ -2052,7 +1799,8 @@ static void _net_nfc_server_handover_client_process( if (result != NET_NFC_OK) { - DEBUG_ERR_MSG("net_nfc_server_handover_process_carrier_record failed [%d]",result); + DEBUG_ERR_MSG("net_nfc_server_handover_process_carrier_record" + "failed [%d]",result); } break; @@ -2113,6 +1861,8 @@ static void _net_nfc_server_handover_client_connected_cb( DEBUG_SERVER_MSG("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; @@ -2123,6 +1873,7 @@ 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); } @@ -2139,7 +1890,8 @@ static void _net_nfc_server_handover_client_connected_cb( } } -static void _net_nfc_server_handover_client_error_cb(net_nfc_error_e result, +static void _net_nfc_server_handover_client_error_cb( + net_nfc_error_e result, net_nfc_target_handle_s *handle, net_nfc_llcp_socket_t socket, data_s *data, diff --git a/daemon/net_nfc_server_process_handover.h b/daemon/net_nfc_server_process_handover.h old mode 100644 new mode 100755 index 6b3bb15..c6c156d --- a/daemon/net_nfc_server_process_handover.h +++ b/daemon/net_nfc_server_process_handover.h @@ -15,27 +15,27 @@ */ #ifndef __NET_NFC_SERVER_PROCESS_HANDOVER_H__ #define __NET_NFC_SERVER_PROCESS_HANDOVER_H__ - +#include "net_nfc_server_handover_bt.h" #include "net_nfc_typedef_internal.h" net_nfc_error_e net_nfc_server_handover_default_server_start( net_nfc_target_handle_s *handle); 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 net_nfc_server_handover_default_server_register(); net_nfc_error_e net_nfc_server_handover_default_server_unregister(); net_nfc_error_e net_nfc_server_handover_create_selector_from_rawdata( - ndef_message_s **selector, data_s *data); + ndef_message_s **selector,data_s *data); -net_nfc_error_e net_nfc_server_handover_get_carrier_record_by_priority_order( - ndef_message_s *request, ndef_record_s **record); +net_nfc_error_e +net_nfc_server_handover_get_carrier_record_by_priority_order( + ndef_message_s *request,ndef_record_s **record); net_nfc_error_e net_nfc_server_handover_process_carrier_record( - ndef_record_s *carrier, void *cb, void *user_param); + ndef_record_s *carrier,void *cb,void *user_param); #endif //__NET_NFC_SERVER_PROCESS_HANDOVER_H__ diff --git a/packaging/nfc-manager.spec b/packaging/nfc-manager.spec old mode 100644 new mode 100755 index f82a8c9..f11613f --- a/packaging/nfc-manager.spec +++ b/packaging/nfc-manager.spec @@ -17,6 +17,9 @@ BuildRequires: pkgconfig(dlog) BuildRequires: pkgconfig(tapi) BuildRequires: pkgconfig(bluetooth-api) BuildRequires: pkgconfig(capi-network-wifi) +%ifarch %arm +BuildRequires: pkgconfig(wifi-direct) +%endif BuildRequires: pkgconfig(mm-sound) BuildRequires: pkgconfig(appsvc) BuildRequires: pkgconfig(svi) diff --git a/tests/net_nfc_test_llcp.c b/tests/net_nfc_test_llcp.c old mode 100644 new mode 100755 index f822f7b..d9a9dc2 --- a/tests/net_nfc_test_llcp.c +++ b/tests/net_nfc_test_llcp.c @@ -296,7 +296,7 @@ void net_nfc_test_llcp_get_local_config(gpointer data, g_print("net_nfc_test_llcp_get_local_config: %d\n", local_config->option); } - */ + */ void net_nfc_test_llcp_get_config_miu(gpointer data, gpointer user_data) @@ -839,8 +839,8 @@ void net_nfc_test_llcp_receive_from_sync(gpointer data, gpointer user_data) { net_nfc_error_e result; - data_h out_data; - sap_t sap_data; + data_h out_data = NULL; + sap_t sap_data = 0; result = net_nfc_client_llcp_receive_from_sync(server_test_socket, 512, diff --git a/tests/net_nfc_test_tag_felica.c b/tests/net_nfc_test_tag_felica.c old mode 100644 new mode 100755 index ea10a3e..9c21e64 --- a/tests/net_nfc_test_tag_felica.c +++ b/tests/net_nfc_test_tag_felica.c @@ -142,7 +142,7 @@ void net_nfc_test_felica_write_without_encryption(gpointer data, net_nfc_error_e result = NET_NFC_OK; net_nfc_target_handle_h handle = NULL; uint8_t number_of_services = 10; - uint16_t service_list[2] = {0,}; + uint16_t service_list[10] = {0,}; uint8_t number_of_blocks = 1; uint8_t block_list[3] = {0,}; data_h data_to_write = NULL; -- 2.7.4