From af6481b3f5d36f4c7fc5b7db73ea4b70ec8962b1 Mon Sep 17 00:00:00 2001 From: hyunuktak Date: Tue, 9 Aug 2016 09:47:42 +0900 Subject: [PATCH 2/2] Initialize the wifi-manager package The handle based module to support multi instance Signed-off-by: hyunuktak Change-Id: I2d9445b1b42ebd2e5274b53192c5d577d1ab69b7 --- CMakeLists.txt | 110 ++ LICENSE | 204 +++ NOTICE | 3 + capi-network-wifi-manager.manifest | 5 + capi-network-wifi-manager.pc.in | 13 + doc/wifi_manager_doc.h | 255 +++ include/network_config.h | 114 ++ include/network_dbus.h | 145 ++ include/network_error.h | 68 + include/network_interface.h | 274 +++ include/network_internal.h | 169 ++ include/network_signal.h | 39 + include/network_wlan.h | 224 +++ include/wifi-manager.h | 2286 +++++++++++++++++++++++++ include/wifi_internal.h | 242 +++ packaging/capi-network-wifi-manager.spec | 80 + src/network_dbus.c | 2418 ++++++++++++++++++++++++++ src/network_interface.c | 2744 ++++++++++++++++++++++++++++++ src/network_internal.c | 640 +++++++ src/network_signal.c | 1132 ++++++++++++ src/wifi_ap.c | 1570 +++++++++++++++++ src/wifi_config.c | 606 +++++++ src/wifi_internal.c | 1712 +++++++++++++++++++ src/wifi_manager.c | 631 +++++++ src/wifi_tdls.c | 99 ++ test/CMakeLists.txt | 25 + test/wifi_manager_test.c | 1843 ++++++++++++++++++++ 27 files changed, 17651 insertions(+) create mode 100755 CMakeLists.txt create mode 100644 LICENSE create mode 100644 NOTICE create mode 100755 capi-network-wifi-manager.manifest create mode 100755 capi-network-wifi-manager.pc.in create mode 100755 doc/wifi_manager_doc.h create mode 100755 include/network_config.h create mode 100755 include/network_dbus.h create mode 100755 include/network_error.h create mode 100755 include/network_interface.h create mode 100755 include/network_internal.h create mode 100755 include/network_signal.h create mode 100755 include/network_wlan.h create mode 100755 include/wifi-manager.h create mode 100755 include/wifi_internal.h create mode 100755 packaging/capi-network-wifi-manager.spec create mode 100755 src/network_dbus.c create mode 100755 src/network_interface.c create mode 100755 src/network_internal.c create mode 100755 src/network_signal.c create mode 100755 src/wifi_ap.c create mode 100755 src/wifi_config.c create mode 100755 src/wifi_internal.c create mode 100755 src/wifi_manager.c create mode 100755 src/wifi_tdls.c create mode 100755 test/CMakeLists.txt create mode 100755 test/wifi_manager_test.c diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100755 index 0000000..09f2651 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,110 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +SET(fw_name "capi-network-wifi-manager") + +PROJECT(${fw_name}) + +SET(PREFIX ${CMAKE_INSTALL_PREFIX}) + +SET(LIB ${LIB_PATH}) +SET(LIBDIR ${PREFIX}/${LIB_PATH}) + +SET(INC_DIR include) +INCLUDE_DIRECTORIES(${INC_DIR}) + +SET(dependents "dlog vconf capi-base-common capi-system-info glib-2.0 gio-2.0 gthread-2.0 ") +SET(pc_dependents "capi-base-common") + +IF(TIZEN_WEARABLE) + ADD_DEFINITIONS(-DTIZEN_WEARABLE) +ENDIF(TIZEN_WEARABLE) +IF(TIZEN_MOBILE) + ADD_DEFINITIONS(-DTIZEN_MOBILE) +ENDIF(TIZEN_MOBILE) + +IF(TIZEN_TV) + ADD_DEFINITIONS(-DTIZEN_TV) +ENDIF(TIZEN_TV) + +INCLUDE(FindPkgConfig) +pkg_check_modules(${fw_name} REQUIRED ${dependents} ${APPFW_REQUIRED_PKGS}) +FOREACH(flag ${${fw_name}_CFLAGS}) + SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") +ENDFOREACH(flag) + +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -Werror -fvisibility=hidden") +#SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall") +SET(CMAKE_C_FLAGS_DEBUG "-O0 -g") + +IF("${ARCH}" STREQUAL "arm") + ADD_DEFINITIONS("-DTARGET") +ENDIF("${ARCH}" STREQUAL "arm") + +ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"") +ADD_DEFINITIONS("-DTIZEN_DEBUG") + +SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--rpath=${LIBDIR}") + +aux_source_directory(src SOURCES) +ADD_LIBRARY(${fw_name} SHARED ${SOURCES}) + +TARGET_LINK_LIBRARIES(${fw_name} ${${fw_name}_LDFLAGS}) + +SET_TARGET_PROPERTIES(${fw_name} + PROPERTIES + VERSION ${FULLVER} + SOVERSION ${MAJORVER} + CLEAN_DIRECT_OUTPUT 1 +) + +INSTALL(TARGETS ${fw_name} DESTINATION ${LIB}) +INSTALL( + DIRECTORY ${INC_DIR}/ DESTINATION include/network + FILES_MATCHING + PATTERN "network_*.h" EXCLUDE + PATTERN "wifi_*.h" EXCLUDE + PATTERN "${INC_DIR}/*.h" + ) + +SET(PC_NAME ${fw_name}) +SET(PC_REQUIRED ${pc_dependents}) +SET(PC_LDFLAGS -l${fw_name}) + +CONFIGURE_FILE( + ${fw_name}.pc.in + ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc + @ONLY +) +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc DESTINATION ${LIB}/pkgconfig) + +ADD_SUBDIRECTORY(test) + +IF(UNIX) + +ADD_CUSTOM_TARGET (distclean @echo cleaning for source distribution) +ADD_CUSTOM_COMMAND( + DEPENDS clean + COMMENT "distribution clean" + COMMAND find + ARGS . + -not -name config.cmake -and \( + -name tester.c -or + -name Testing -or + -name CMakeFiles -or + -name cmake.depends -or + -name cmake.check_depends -or + -name CMakeCache.txt -or + -name cmake.check_cache -or + -name *.cmake -or + -name Makefile -or + -name core -or + -name core.* -or + -name gmon.out -or + -name install_manifest.txt -or + -name *.pc -or + -name *~ \) + | grep -v TC | xargs rm -rf + TARGET distclean + VERBATIM +) + +ENDIF(UNIX) diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..100c877 --- /dev/null +++ b/LICENSE @@ -0,0 +1,204 @@ +Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. All rights reserved. + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/NOTICE b/NOTICE new file mode 100644 index 0000000..ccdad52 --- /dev/null +++ b/NOTICE @@ -0,0 +1,3 @@ +Copyright (c) Samsung Electronics Co., Ltd. All rights reserved. +Except as noted, this software is licensed under Apache License, Version 2. +Please, see the LICENSE file for Apache License terms and conditions. diff --git a/capi-network-wifi-manager.manifest b/capi-network-wifi-manager.manifest new file mode 100755 index 0000000..97e8c31 --- /dev/null +++ b/capi-network-wifi-manager.manifest @@ -0,0 +1,5 @@ + + + + + diff --git a/capi-network-wifi-manager.pc.in b/capi-network-wifi-manager.pc.in new file mode 100755 index 0000000..ee6db75 --- /dev/null +++ b/capi-network-wifi-manager.pc.in @@ -0,0 +1,13 @@ +# Package Information for pkg-config + +prefix=@PREFIX@ +exec_prefix=/usr +libdir=/usr/lib +includedir=/usr/include/network + +Name: @PC_NAME@ +Description: @PACKAGE_DESCRIPTION@ +Version: @VERSION@ +Requires: @PC_REQUIRED@ +Libs: -L${libdir} @PC_LDFLAGS@ +Cflags: -I${includedir} diff --git a/doc/wifi_manager_doc.h b/doc/wifi_manager_doc.h new file mode 100755 index 0000000..5ebefa4 --- /dev/null +++ b/doc/wifi_manager_doc.h @@ -0,0 +1,255 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __TIZEN_NETWORK_WIFI_MANAGER_DOC_H__ +#define __TIZEN_NETWORK_WIFI_MANAGER_DOC_H__ + +/** + * @defgroup CAPI_NETWORK_WIFI_PACKAGE Wi-Fi + * @ingroup CAPI_NETWORK_FRAMEWORK + * + * @section CAPI_NETWORK_WIFI_MANAGER_MODULE_OVERVIEW Overview + * Wi-Fi module will be substituted for Wi-Fi Manager module with handle based to support for multi instance. + */ + +/** + * @defgroup CAPI_NETWORK_WIFI_MANAGER_MODULE Wi-Fi Manager + * @brief The Wi-Fi API provides functions for managing Wi-Fi and monitoring the state of Wi-Fi. + * @ingroup CAPI_NETWORK_WIFI_PACKAGE + * + * @section CAPI_NETWORK_WIFI_MANAGER_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_WIFI_MANAGER_MODULE_OVERVIEW Overview + * Wi-Fi allows your application to connect to a Wireless Local Area Network (WLAN) and to transfer data over the network. + * The Wi-Fi Manager enables your application to activate and deactivate a local Wi-Fi device, and to connect to a WLAN network + * in the infrastructure mode. + * @section CAPI_NETWORK_WIFI_MANAGER_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.wifi\n + * + * It is recommended to design applications with regard to features, for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, and control your application's actions accordingly.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on using features in your application can be found in the Feature List. + * + */ + +/** + * @defgroup CAPI_NETWORK_WIFI_MANAGER_MANAGEMENT_MODULE Wi-Fi Management + * @brief The Wi-Fi API provides functions for managing Wi-Fi. + * @ingroup CAPI_NETWORK_WIFI_MANAGER_MODULE + * + * @section CAPI_NETWORK_WIFI_MANAGER_MANAGEMENT_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_WIFI_MANAGER_MANAGEMENT_MODULE_OVERVEW Overview + * To use Wifi Manager API, first create a wifi handle using wifi_initialize(). After that, you can obtain wifi information. + * You should destroy the created wifi handle if you do not need it anymore. + * The Wi-Fi Manager provides functions for managing Wi-Fi. + * Using the Wi-Fi Manager, you can implement features that allow the users of your application to: + * - Activate / Deactivate the Wi-Fi device + * - Connect to the access point + * - Scans the access points + * @section CAPI_NETWORK_WIFI_MANAGER_MANAGEMENT_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.wifi\n + * + * It is recommended to design applications with regard to features, for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, and control your application's actions accordingly.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on using features in your application can be found in the Feature List. + * + */ + +/** + * @defgroup CAPI_NETWORK_WIFI_MANAGER_MONITOR_MODULE Wi-Fi Monitor + * @brief The Wi-Fi API provides functions for monitoring the state of Wi-Fi. + * @ingroup CAPI_NETWORK_WIFI_MANAGER_MODULE + * + * @section CAPI_NETWORK_WIFI_MANAGER_MONITOR_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_WIFI_MANAGER_MONITOR_MODULE_OVERVIEW Overview + * The Wi-Fi Monitor allows monitoring the changes of Wi-Fi. + * @section CAPI_NETWORK_WIFI_MANAGER_MONITOR_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.wifi\n + * + * It is recommended to design applications with regard to features, for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, and control your application's actions accordingly.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on using features in your application can be found in the Feature List. + * + */ + +/** + * @defgroup CAPI_NETWORK_WIFI_MANAGER_AP_MODULE AP + * @brief The Access Point API provides functions for managing the Access Point. + * @ingroup CAPI_NETWORK_WIFI_MANAGER_MANAGEMENT_MODULE + * + * @section CAPI_NETWORK_WIFI_MANAGER_AP_MODULE Required Header + * \#include + * + * @section CAPI_NETWORK_WIFI_MANAGER_AP_MODULE_OVERVIEW Overview + * The Access Point API provides functions for managing the Access Point. You need to create the @a ap handle for using the functions. + * You can use Wi-Fi information with the handle. + * @section CAPI_NETWORK_WIFI_MANAGER_AP_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.wifi\n + * + * It is recommended to design applications with regard to features, for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, and control your application's actions accordingly.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on using features in your application can be found in the Feature List. + * + */ + +/** + * @defgroup CAPI_NETWORK_WIFI_MANAGER_AP_NETWORK_MODULE Network Information + * @brief The Connection Information API provides functions for managing the network information. + * @ingroup CAPI_NETWORK_WIFI_MANAGER_AP_MODULE + * + * @section CAPI_NETWORK_WIFI_MANAGER_AP_NETWORK_MODULE Required Header + * \#include + * + * @section CAPI_NETWORK_WIFI_MANAGER_AP_NETWORK_MODULE_OVERVIEW Overview + * The Connection Information API provides functions for managing the network information. You can manage the network information using the functions. + * @section CAPI_NETWORK_WIFI_MANAGER_AP_NETWORK_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.wifi\n + * + * It is recommended to design applications with regard to features, for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, and control your application's actions accordingly.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on using features in your application can be found in the Feature List. + * + */ + +/** + * @defgroup CAPI_NETWORK_WIFI_MANAGER_AP_SECURITY_MODULE Security Information + * @brief The Security Information API provides functions for managing the Security information. + * @ingroup CAPI_NETWORK_WIFI_MANAGER_AP_MODULE + * + * @section CAPI_NETWORK_WIFI_MANAGER_AP_SECURITY_MODULE Required Header + * \#include + * + * @section CAPI_NETWORK_WIFI_MANAGER_AP_SECURITY_MODULE_OVERVIEW Overview + * The Security Information API provides functions for managing the Security information. You can manage the Security information using the functions. + * @section CAPI_NETWORK_WIFI_MANAGER_AP_SECURITY_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.wifi\n + * + * It is recommended to design applications with regard to features, for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, and control your application's actions accordingly.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on using features in your application can be found in the Feature List. + * + */ + +/** + * @defgroup CAPI_NETWORK_WIFI_MANAGER_AP_SECURITY_EAP_MODULE EAP + * @brief The EAP API provides functions for managing the EAP information. + * @ingroup CAPI_NETWORK_WIFI_MANAGER_AP_SECURITY_MODULE + * + * @section CAPI_NETWORK_WIFI_MANAGER_AP_SECURITY_EAP_MODULE Required Header + * \#include + * + * @section CAPI_NETWORK_WIFI_MANAGER_AP_SECURITY_EAP_MODULE_OVERVIEW Overview + * The EAP API provides functions for managing the EAP information. You can manage the EAP information using the functions. + * @section CAPI_NETWORK_WIFI_MANAGER_AP_SECURITY_EAP_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.wifi\n + * + * It is recommended to design applications with regard to features, for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, and control your application's actions accordingly.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on using features in your application can be found in the Feature List. + * + */ + + +/** + * @defgroup CAPI_NETWORK_WIFI_MANAGER_CONFIG_MODULE Wi-Fi Configuration + * @brief The Configuration API provides functions for managing the configuration of Wi-Fi. + * @ingroup CAPI_NETWORK_WIFI_MANAGER_MODULE + * + * @section CAPI_NETWORK_WIFI_MANAGER_CONFIG_MODULE Required Header + * \#include + * + * @section CAPI_NETWORK_WIFI_MANAGER_CONFIG_MODULE_OVERVIEW Overview + * The Configuration API provides functions for managing the configuration of Wi-Fi. You can manage the configuration information using the functions. + * @section CAPI_NETWORK_WIFI_MANAGER_CONFIG_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.wifi\n + * + * It is recommended to design applications with regard to features, for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, and control your application's actions accordingly.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on using features in your application can be found in the Feature List. + * + */ + +/** + * @defgroup CAPI_NETWORK_WIFI_MANAGER_TDLS_MODULE Wi-Fi TDLS + * @brief The TDLS APIs for managing TDLS. + * @ingroup CAPI_NETWORK_WIFI_MANAGER_MODULE + * + * @section CAPI_NETWORK_WIFI_MANAGER_TDLS_MODULE Required Header + * \#include + * + * @section CAPI_NETWORK_WIFI_MANAGER_TDLS_MODULE_OVERVIEW Overview + * The TDLS APIs for managing TDLS. + * @section CAPI_NETWORK_WIFI_MANAGER_TDLS_MODULE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.wifi.tdls\n + * + * It is recommended to design applications with regard to features, for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, and control your application's actions accordingly. + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on using features in your application can be found in the Feature List. + * + */ + + +#endif /* __TIZEN_NETWORK_WIFI_MANAGER_DOC_H__ */ diff --git a/include/network_config.h b/include/network_config.h new file mode 100755 index 0000000..a0a08e1 --- /dev/null +++ b/include/network_config.h @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __NETWORK_CONFIG_H__ +#define __NETWORK_CONFIG_H__ + +#include + +#include "network_error.h" + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +#define NET_PROFILE_NAME_LEN_MAX 512 /** Profile name max length */ +#define NET_HOME_URL_LEN_MAX 512 /** Home URL max length in profile account */ +#define NET_IPV4_STR_LEN_MAX 15 /** Maximum length of IPv4 string type e.g., + "165.213.173.105". This length does not + include NULL in the last byte. */ +#define NET_IPV4_STR_LEN_MIN 7 /** Minimum length of IPv4 string type e.g., + "0.0.0.0". This length does not + include NULL in the last byte. */ +#define NET_IPV6_STR_LEN_MAX 39 /** Maximum length of IPv6 string type e.g., + "fe80:0000:0000:0000:a000:27ff:fe7a:65ea". + This length does not include NULL in the last byte. */ +#define NET_IPV6_STR_LEN_MIN 2 /** Minimum length of IPv6 string type e.g., + "::". This length does not include NULL in the last byte. */ +#define NET_PROXY_LEN_MAX 64 /** Maximum length of proxy string */ +#define NET_DNS_ADDR_MAX 2 /** MAX number of DNS Address */ +#define NET_MAX_DEVICE_NAME_LEN 32 /** Maximum length of device name */ +#define NET_MAX_MAC_ADDR_LEN 32 /** Maximum length of MAC address */ +#define NET_IPV6_MAX_PRIVACY_LEN 9 /** Maximum length of IPv6 Privacy + ["enabled", "disabled", "preferred"]*/ +#define NET_IPV6_MAX_PREFIX_LEN 128 /** Maximum length of IPv6 Prefix */ + +typedef enum { + NET_ADDR_IPV4 = 0x0, /** IPV4 Address type */ + NET_ADDR_IPV6 = 0x1, /** IPV6 Address type */ +} net_addr_type_e; + +typedef enum { + NET_PROXY_TYPE_UNKNOWN = 0x00, /** Not defined */ + NET_PROXY_TYPE_DIRECT = 0x01, /** Direct connection */ + NET_PROXY_TYPE_AUTO = 0x02, /** Auto configuration(Use PAC file) + * If URL property is not set, + DHCP/WPAD auto-discover will be tried */ + NET_PROXY_TYPE_MANUAL = 0x03, /** Manual configuration */ +} net_proxy_type_e; + +typedef enum { + NET_IP_CONFIG_TYPE_STATIC = 0x01, /** Manual IP configuration */ + NET_IP_CONFIG_TYPE_DYNAMIC, /** Config ip using DHCP client*/ + NET_IP_CONFIG_TYPE_AUTO_IP, /** Config IP from Auto IP pool (169.254/16) + * Later with DHCP client, if available */ + NET_IP_CONFIG_TYPE_FIXED, /** Indicates an IP address that can not be modified */ + NET_IP_CONFIG_TYPE_OFF, /** Don't use any method */ +} net_ip_config_type_e; + +typedef union { + struct in_addr Ipv4; /** IP Version 4 address */ + struct in6_addr Ipv6; /** IP Version 6 address */ +} net_ip_addr_u; + +typedef struct { + net_addr_type_e Type; /** Address Type: IPv4 or IPv6 */ + net_ip_addr_u Data; /** IP Address */ +} net_addr_s; + +typedef struct { + char ProfileName[NET_PROFILE_NAME_LEN_MAX+1]; /** Profile name */ +} net_profile_name_s; + +typedef struct { + char ProfileName[NET_PROFILE_NAME_LEN_MAX+1]; /** Profile Name of the connection link */ + char DevName[NET_MAX_DEVICE_NAME_LEN+1]; /** Device Name of the connection link */ + net_addr_s DnsAddr[NET_DNS_ADDR_MAX]; /** IPv4 Dns Server Address of the connection link */ + net_addr_s DnsAddr6[NET_DNS_ADDR_MAX]; /** IPv6 Dns Server Address of the connection link */ + int DnsCount; /** No of IPv4 DNS Address for the connection link */ + int DnsCount6; /** No of IPv6 DNS Address for the connection link */ + net_ip_config_type_e IpConfigType; /** Net IP configuration Type */ + net_addr_s IpAddr; /** IP Address for the connection link */ + char BNetmask; /** Whether subnet mask present or not. */ + net_addr_s SubnetMask; /** Subnet mask */ + char BDefGateway; /** Whether gateway address present or not */ + net_addr_s GatewayAddr; /** Gateway address */ + net_proxy_type_e ProxyMethod; /** Proxy Method type */ + char ProxyAddr[NET_PROXY_LEN_MAX+1]; /** Proxy address */ + char MacAddr[NET_MAX_MAC_ADDR_LEN+1]; /** MAC address */ + net_ip_config_type_e IpConfigType6; /** Net IP configuration Type */ + net_addr_s IpAddr6; /** IP Address for the connection link */ + int PrefixLen6; /** Prefix Length for the connection link */ + char BDefGateway6; /** Whether gateway address present or not */ + net_addr_s GatewayAddr6; /** Gateway address */ + char Privacy6[NET_IPV6_MAX_PRIVACY_LEN+1]; /** Privacy of the connection link */ +} net_dev_info_s; + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /** __NETWORK_CONFIG_H__ */ diff --git a/include/network_dbus.h b/include/network_dbus.h new file mode 100755 index 0000000..58287a1 --- /dev/null +++ b/include/network_dbus.h @@ -0,0 +1,145 @@ +/* + * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __NETWORK_DBUS_H__ +#define __NETWORK_DBUS_H__ + +#include "network_internal.h" +#include "network_interface.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define CONNMAN_CLIENT_DBUS_TYPE_STRING "string" +#define CONNMAN_CLIENT_DBUS_TYPE_INT16 "int16" +#define CONNMAN_CLIENT_DBUS_TYPE_UINT16 "uint16" +#define CONNMAN_CLIENT_DBUS_TYPE_INT32 "int32" +#define CONNMAN_CLIENT_DBUS_TYPE_UINT32 "uint32" +#define CONNMAN_CLIENT_DBUS_TYPE_INT64 "int64" +#define CONNMAN_CLIENT_DBUS_TYPE_UINT64 "uint64" +#define CONNMAN_CLIENT_DBUS_TYPE_DOUBLE "double" +#define CONNMAN_CLIENT_DBUS_TYPE_BYTE "byte" +#define CONNMAN_CLIENT_DBUS_TYPE_BOOLEAN "boolean" +#define CONNMAN_CLIENT_DBUS_TYPE_OBJECT_PATH "objpath" + +#define CONNMAN_CLIENT_DBUS_TYPE_VARIANT "variant" +#define CONNMAN_CLIENT_DBUS_TYPE_ARRAY "array" +#define CONNMAN_CLIENT_DBUS_TYPE_DICT_ENTRY "dict" + +#define NETCONFIG_AGENT_FIELD_SSID "SSID" +#define NETCONFIG_AGENT_FIELD_PASSPHRASE "Passphrase" +#define NETCONFIG_AGENT_FIELD_WPS_PBC "WPS_PBC" +#define NETCONFIG_AGENT_FIELD_WPS_PIN "WPS_PIN" + +#define CONNMAN_CONFIG_FIELD_TYPE "Type" +#define CONNMAN_CONFIG_FIELD_NAME "Name" +#define CONNMAN_CONFIG_FIELD_SSID "SSID" +#define CONNMAN_CONFIG_FIELD_EAP_METHOD "EAP" +#define CONNMAN_CONFIG_FIELD_IDENTITY "Identity" +#define CONNMAN_CONFIG_FIELD_PASSPHRASE "Passphrase" +#define CONNMAN_CONFIG_FIELD_PHASE2 "Phase2" +#define CONNMAN_CONFIG_FIELD_CA_CERT_FILE "CACertFile" +#define CONNMAN_CONFIG_FIELD_CLIENT_CERT_FILE "ClientCertFile" +#define CONNMAN_CONFIG_FIELD_PVT_KEY_FILE "PrivateKeyFile" +#define CONNMAN_CONFIG_FIELD_PVT_KEY_PASSPHRASE "PrivateKeyPassphrase" +#define CONNMAN_CONFIG_FIELD_EAP_KEYMGMT_TYPE "KeymgmtType" + +typedef struct { + char *type; + char *mode; + char *ssid; + char *security; + char *passphrase; + char *eap_type; + char *eap_auth; + char *identity; + char *password; + char *ca_cert_file; + char *client_cert_file; + char *private_key_file; + char *private_key_password; + char *eap_keymgmt_type; + gboolean is_hidden; +} net_wifi_connect_service_info_t; + +int _net_dbus_open_connection(const char* profile_name); +int _net_dbus_close_connection(const char* profile_name); +int _net_dbus_scan_request(void); +int _net_dbus_set_bgscan_mode(net_wifi_background_scan_mode_e mode); +int _net_dbus_set_agent_passphrase_and_connect( + const char *passphrase, const char *profilename); +int _net_dbus_get_wps_pin(char **wps_pin); +int _net_dbus_set_agent_wps_pbc_and_connect(const char *profilename); +int _net_dbus_set_agent_wps_pin_and_connect( + const char *wps_pin, const char *profilename); +int _net_dbus_get_tech_status(net_tech_info_s* tech_status); +int _net_dbus_get_wifi_state(char **wifi_state); +int _net_dbus_connect_service(const net_wifi_connect_service_info_t* wifi_connection_info); +int _net_dbus_set_profile_ipv4(net_profile_info_s* prof_info, char* profile_name); +int _net_dbus_set_profile_ipv6(net_profile_info_s* prof_info, char* profile_name); +int _net_dbus_set_profile_dns(net_profile_info_s* prof_info, char* profile_name); +int _net_dbus_set_proxy(net_profile_info_s* prof_info, char* profile_name); +int _net_dbus_get_technology_state(network_tech_state_info_s* tech_state); +GVariant *_net_invoke_dbus_method(const char *dest, const char *path, + const char *interface_name, const char *method, + GVariant *params, int *dbus_error); +int _net_invoke_dbus_method_nonblock(const char *dest, const char *path, + const char *interface_name, const char *method, + GVariant *params, int timeout, + GAsyncReadyCallback notify_func); +int _net_dbus_load_wifi_driver(gboolean wifi_picker_test); +int _net_dbus_remove_wifi_driver(void); +int _net_dbus_specific_scan_request(const char *ssid); +int _net_dbus_wps_scan_request(void); +int _net_dbus_get_passpoint(int *enabled); +int _net_dbus_set_passpoint(int enable); + +#if defined TIZEN_TV +int _net_dbus_cancel_wps(void); +int _net_dbus_open_connection_without_ssid(); +int _net_dbus_open_pin_connection_without_ssid(const char *pin); +int _net_dbus_set_agent_wps_pbc(void); +int _net_dbus_set_agent_wps_pin(const char *wps_pin); + +#endif + +int _net_dbus_tdls_disconnect(const char* peer_mac_addr); +int _net_dbus_tdls_connected_peer(char** peer_mac_addr); + +int _net_dbus_config_get_id_list(GSList **list); +int _net_dbus_config_set_field(const gchar *config_id, const gchar *key, const gchar *value); +int _net_dbus_config_get_passphrase(const gchar *config_id, gchar **passphrase); +int _net_dbus_config_save_configurations(const gchar *config_id, const gchar *name, + const gchar *ssid, const gchar *passphrase, const gchar *proxy_address, gboolean is_hidden); +int _net_dbus_config_save_eap_configurations(const gchar *config_id, + const gchar *name, const gchar *ssid, const gchar *passphrase, + const gchar *proxy_address, net_eap_config_s *eap_config, gboolean is_hidden); +int _net_dbus_config_remove_configurations(const gchar *config_id); +int _net_dbus_config_load_configurations(const gchar *config_id, gchar **name, + net_wifi_security_type_e *security_type, gchar **proxy_address, gboolean *is_hidden, void *last_error); +int _net_dbus_config_load_eap_configurations(const gchar *config_id, + gchar **name, net_wifi_security_type_e *security_type, gchar **proxy_address, + gboolean *is_hidden, net_eap_config_s **eap_config, void *last_error); + +int _net_dbus_device_policy_get_wifi(int *state); +int _net_dbus_device_policy_get_wifi_profile(int *state); + +#ifdef __cplusplus +} +#endif + +#endif /** __NETWORK_DBUS_H__ */ diff --git a/include/network_error.h b/include/network_error.h new file mode 100755 index 0000000..2cdf087 --- /dev/null +++ b/include/network_error.h @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __NETWORK_ERROR_H__ +#define __NETWORK_ERROR_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + NET_ERR_NONE = 0x00, /** No error */ + + /* Common Error value */ + NET_ERR_UNKNOWN = -999, /** Error unknown */ + + /* Client Register related Errors used in API return */ + NET_ERR_APP_ALREADY_REGISTERED = -990, /** Application is already registered */ + NET_ERR_APP_NOT_REGISTERED = -989, /** Application is not registered */ + + /* Connection Related Error */ + NET_ERR_NO_ACTIVE_CONNECTIONS = -899, /** No active connection exists for the given profile name */ + NET_ERR_ACTIVE_CONNECTION_EXISTS = -898, /** Active connection already exists for the given profile name */ + NET_ERR_CONNECTION_OUT_OF_RANGE = -897, /** Connection failure : out of range */ + NET_ERR_CONNECTION_PIN_MISSING = -896, /** Connection failure : pin missing */ + NET_ERR_CONNECTION_DHCP_FAILED = -895, /** Connection failure : dhcp failed */ + NET_ERR_CONNECTION_CONNECT_FAILED = -894, /** Connection failure : connect failed */ + NET_ERR_CONNECTION_LOGIN_FAILED = -893, /** Connection failure : login failed */ + NET_ERR_CONNECTION_AUTH_FAILED = -892, /** Connection failure : authentication failed */ + NET_ERR_CONNECTION_INVALID_KEY = -891, /** Connection failure : invalid key */ + + /* Other Error */ + NET_ERR_ACCESS_DENIED = -799, /** Access(permission) denied */ + NET_ERR_IN_PROGRESS = -798, /** Operation is in progress */ + NET_ERR_OPERATION_ABORTED = -797, /** Operation was aborted by client or network*/ + NET_ERR_INVALID_PARAM = -796, /** Invalid value of API parameter */ + NET_ERR_INVALID_OPERATION = -795, /** Invalid operation depending on current state */ + NET_ERR_NOT_SUPPORTED = -794, /** Feature not supported */ + NET_ERR_TIME_OUT = -793, /** TimeOut Error */ + NET_ERR_NO_SERVICE = -792, /** Network service is not available */ + NET_ERR_UNKNOWN_METHOD = -791, /** DBus can't find appropriate method */ + NET_ERR_SECURITY_RESTRICTED = -790, /** Operation is restricted */ + NET_ERR_ALREADY_EXISTS = -789, /** Already exists */ + NET_ERR_NO_PROFILE = -788, /** There is no profile */ + + /** WiFi driver on/off failed */ + NET_ERR_WIFI_DRIVER_FAILURE = -699, + NET_ERR_WIFI_DRIVER_LOAD_INPROGRESS = -698, +} net_err_e; + +#ifdef __cplusplus +} +#endif + +#endif /** __NETWORK_ERROR_H__ */ diff --git a/include/network_interface.h b/include/network_interface.h new file mode 100755 index 0000000..f20a56b --- /dev/null +++ b/include/network_interface.h @@ -0,0 +1,274 @@ +/* + * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __NETWORK_INTERFACE_H__ +#define __NETWORK_INTERFACE_H__ + +#include +#include "network_wlan.h" +#include "network_error.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define WIFI_INFO 1 +#define WIFI_ERROR 2 +#define WIFI_WARN 3 + +#define WIFI_LOG(log_level, format, args...) \ + do { \ + switch (log_level) { \ + case WIFI_ERROR: \ + LOGE(format, ## args); \ + break; \ + case WIFI_WARN: \ + LOGW(format, ## args); \ + break; \ + default: \ + LOGI(format, ## args); \ + } \ + } while (0) + +typedef enum { + NET_EVENT_OPEN_RSP, + NET_EVENT_CLOSE_RSP, + NET_EVENT_OPEN_IND, + NET_EVENT_CLOSE_IND, + NET_EVENT_NET_STATE_IND, + NET_EVENT_WIFI_SCAN_RSP, + NET_EVENT_WIFI_SCAN_IND, + NET_EVENT_WIFI_MAC_ID_IND, /** This is deprecated Event and maintained only for compatibility */ + NET_EVENT_WIFI_POWER_RSP, + NET_EVENT_WIFI_POWER_IND, + NET_EVENT_WIFI_SPECIFIC_SCAN_RSP, + NET_EVENT_WIFI_SPECIFIC_SCAN_IND, + NET_EVENT_WIFI_WPS_RSP, + NET_EVENT_WIFI_SCANNING_IND, + NET_EVENT_WIFI_WPS_SCAN_IND, + NET_EVENT_WIFI_TDLS_CONNECTED_IND, + NET_EVENT_WIFI_TDLS_DISCONNECTED_IND, +} net_event_e; + +typedef enum { + WIFI_UNKNOWN = 0x00, /** Unknown state */ + WIFI_OFF = 0x01, /** Wi-Fi is Off */ + WIFI_ON = 0x02, /** Wi-Fi is On(idle/failure) */ + WIFI_ASSOCIATION = 0x03, /** Trying association */ + WIFI_CONFIGURATION = 0x04, /** Trying configuration */ + WIFI_CONNECTED = 0x05, /** Wi-Fi is connected */ + WIFI_DISCONNECTING = 0x06, /** Trying to disconnect */ +} net_wifi_state_e; + +typedef enum { + WIFI_BGSCAN_MODE_EXPONENTIAL = 0x00, /** scan cycle : 4, 8, 16, ...128s */ + WIFI_BGSCAN_MODE_PERIODIC, /** scan cycle : 10s */ +} net_wifi_background_scan_mode_e; + +typedef enum { + WIFI_WPS_PBC = 0x00, /** WPS type is PBC */ + WIFI_WPS_PIN, /** WPS type is PIN */ +} net_wifi_wps_type_e; + +typedef enum { + WIFI_MANAGER_EAP_PEAP = 0x00, + WIFI_MANAGER_EAP_TLS, + WIFI_MANAGER_EAP_TTLS, + WIFI_MANAGER_EAP_SIM, + WIFI_MANAGER_EAP_AKA, +} net_wifi_eap_type_e; + +typedef enum { + WIFI_MANAGER_EAP_AUTH_NONE = 0x00, + WIFI_MANAGER_EAP_AUTH_PAP, + WIFI_MANAGER_EAP_AUTH_MSCHAP, + WIFI_MANAGER_EAP_AUTH_MSCHAPV2, + WIFI_MANAGER_EAP_AUTH_GTC, + WIFI_MANAGER_EAP_AUTH_MD5, +} net_wifi_eap_auth_type_e; + +typedef enum { + WIFI_SEC_NONE = 0x00, + WIFI_SEC_WEP, + WIFI_SEC_WPA_PSK, + WIFI_SEC_WPA2_PSK, + WIFI_SEC_EAP, +} net_wifi_security_type_e; + +typedef enum { + NET_STATE_TYPE_UNKNOWN = 0x00, /** Not defined */ + NET_STATE_TYPE_IDLE, /** Idle state */ + NET_STATE_TYPE_FAILURE, /** Failure state */ + NET_STATE_TYPE_ASSOCIATION, /** Association state */ + NET_STATE_TYPE_CONFIGURATION, /** Configuration state */ + NET_STATE_TYPE_READY, /** Ready state */ + NET_STATE_TYPE_ONLINE, /** Online state */ + NET_STATE_TYPE_DISCONNECT, /** Login state */ +} net_state_type_e; + +typedef enum { + NET_STATE_ERROR_NONE = 0x00, + NET_STATE_ERROR_OUT_OF_RANGE = 0x01, + NET_STATE_ERROR_PIN_MISSING = 0x02, + NET_STATE_ERROR_DHCP_FAILED = 0x03, + NET_STATE_ERROR_CONNECT_FAILED = 0x04, + NET_STATE_ERROR_LOGIN_FAILED = 0x05, + NET_STATE_ERROR_AUTH_FAILED = 0x06, + NET_STATE_ERROR_INVALID_KEY = 0x07, +} net_error_state_type_e; + +typedef struct { + char ProfileName[NET_PROFILE_NAME_LEN_MAX+1]; /** Profile name */ + net_state_type_e ProfileState; /** Service state */ + char essid[NET_WLAN_ESSID_LEN+1]; /** ESSID */ + char bssid[NET_MAX_MAC_ADDR_LEN+1]; /** Basic service set identification */ + unsigned char Strength; /** Strength : between 0 and 100 */ + unsigned int frequency; /** Frequency band(MHz) */ + unsigned int max_rate; /** Maximum speed of the line(bps) */ + char PassphraseRequired; /** If a passphrase has been set already or if no + passphrase is needed, then this property will + be set to FALSE. */ + wlan_connection_mode_type_e wlan_mode; /** Infrastucture / ad-hoc / auto mode */ + wlan_security_info_s security_info; /** Security mode and authentication info */ + gboolean passpoint; /** Passpoint AP or not */ + net_dev_info_s net_info; /** network information */ + gboolean is_hidden; /** Hidden network */ + net_error_state_type_e ProfileErrorState; /** Service error state */ + char Favourite; /** Favourite flag */ +} net_profile_info_s; + +typedef struct { + net_wifi_wps_type_e type; /** PBC / PIN */ + char pin[NET_WLAN_MAX_WPSPIN_LEN + 1]; /** Optional. This pin is needed when the user input PIN code */ +} net_wifi_wps_info_s; + +typedef struct { + char essid[NET_WLAN_ESSID_LEN + 1]; /** Basic feature */ + wlan_connection_mode_type_e wlan_mode; /** Infrastructure / ad-hoc / auto mode */ + wlan_security_info_s security_info; /** Security mode and authentication info */ + gboolean is_hidden; /** Hidden network */ +} net_wifi_connection_info_s; + +typedef struct { + char ssid[NET_WLAN_ESSID_LEN + 1]; + wlan_security_mode_type_e security; + char wps; +} net_ssid_scan_bss_info_s; + +typedef struct { + unsigned char ssid[NET_WLAN_ESSID_LEN + 1]; + char bssid[NET_WLAN_BSSID_LEN + 1]; + int rssi; + int mode; +} net_wps_scan_bss_info_s; + +typedef struct { + net_event_e Event; /** CM Asynchronous event */ + char ProfileName[NET_PROFILE_NAME_LEN_MAX+1]; /** Profile Identifier corresponding to the event */ + net_err_e Error; /** Event Status */ + int Datalength; /** Event data length */ + void * Data; /** Event data: Depending on the event, Event Data will be + type-casted to the appropriate event info data structure */ +} net_event_info_s; + +typedef struct { + char powered; /** powered state */ + char connected; /** connected state */ +} net_tech_info_s; + +typedef struct { + gchar *ca_cert; + gchar *private_key; + gchar *client_cert; + gchar *anonymous_identity; + gchar *identity; + gchar *subject_match; + net_wifi_eap_type_e eap_type; + net_wifi_eap_auth_type_e eap_auth_type; +} net_eap_config_s; + +typedef void (*net_event_cb)(const net_event_info_s* net_event, void* user_data); + +int net_register_client_ext(net_event_cb event_cb, void *user_data); +int net_deregister_client_ext(void); + +gboolean net_check_ref_count(void); + +int net_open_connection(const char *profile_name); +int net_close_connection(const char *profile_name); + +int net_get_technology_properties(net_tech_info_s *tech_info); + +int net_get_profile_info(const char *profile_name, net_profile_info_s *prof_info); +int net_get_profile_list(GSList **profile_list); + +int net_modify_profile(const char *profile_name, net_profile_info_s *prof_info); +int net_delete_profile(const char *profile_name); + +int net_get_wifi_state(net_wifi_state_e *current_state); +int net_wifi_set_background_scan_mode(net_wifi_background_scan_mode_e scan_mode); +int net_specific_scan_wifi(const char *ssid); +int net_get_wps_pin(char **wps_pin); +int net_wps_scan_wifi(void); +int net_wifi_get_passpoint(int *enable); +int net_wifi_set_passpoint(int enable); + +#if defined TIZEN_TV +int net_wifi_cancel_wps(void); +#endif + +int net_open_connection_with_wifi_info(const net_wifi_connection_info_s *wifi_info); +int net_scan_wifi(void); +int net_wifi_power_on(gboolean wifi_picker_test); +int net_wifi_power_off(void); +int net_wifi_enroll_wps(const char *profile_name, net_wifi_wps_info_s *wps_info); +int net_check_get_privilege(void); +int net_check_profile_privilege(void); + +#if defined TIZEN_TV +int net_wifi_enroll_wps_without_ssid(net_wifi_wps_info_s *wps_info); +#endif + +int net_wifi_tdls_disconnect(const char* peer_mac_addr); +int net_wifi_tdls_connected_peer(char** peer_mac_addr); + +int net_get_device_policy_wifi(void); +int net_get_device_policy_wifi_profile(void); + +int net_config_get_id_list(GSList **list); +int net_config_set_field(const gchar *config_id, const gchar *key, const gchar *value); +int net_config_get_passphrase(const gchar *config_id, gchar **passphrase); +int net_config_save_configurations(const gchar *config_id, const gchar *name, + const gchar *ssid, const gchar *passphrase, const gchar *proxy_address, gboolean is_hidden); +int net_config_save_eap_configurations(const gchar *config_id, + const gchar *name, const gchar *ssid, const gchar *passphrase, + const gchar *proxy_address, void *eap_config, gboolean is_hidden); +int net_config_remove_configurations(const gchar *config_id); +int net_config_load_configurations(const gchar *config_id, gchar **name, + void *security_type, gchar **proxy_address, gboolean *is_hidden, void *last_error); +int net_config_load_eap_configurations(const gchar *config_id, + gchar **name, void *security_type, gchar **proxy_address, + gboolean *is_hidden, void **eap_config, void *last_error); + +/** + * \} + */ + +#ifdef __cplusplus +} +#endif + +#endif /** __NETWORK_INTERFACE_H__ */ diff --git a/include/network_internal.h b/include/network_internal.h new file mode 100755 index 0000000..cceb14d --- /dev/null +++ b/include/network_internal.h @@ -0,0 +1,169 @@ +/* + * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __NETWORK_INTERNAL_H__ +#define __NETWORK_INTERNAL_H__ + +#include +#include +#include +#include +#include + +#include "network_interface.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#undef LOG_TAG +#define LOG_TAG "WIFI_MANAGER" + +/** Maximum Profile Count */ +#define NET_PROFILE_LIST_MAX 512 + +#define NET_TECH_LENGTH_MAX 64 + +#define CONNMAN_MAX_BUFLEN 512 + +#define CONNMAN_STATE_STRLEN 16 + +#define NET_MEMFREE(x) { g_free(x); x = NULL; } + +#define CONNMAN_SERVICE "net.connman" +#define CONNMAN_MANAGER_INTERFACE CONNMAN_SERVICE ".Manager" +#define CONNMAN_TECHNOLOGY_INTERFACE CONNMAN_SERVICE ".Technology" +#define CONNMAN_SERVICE_INTERFACE CONNMAN_SERVICE ".Service" +#define CONNMAN_PROFILE_INTERFACE CONNMAN_SERVICE ".Profile" +#define CONNMAN_COUNTER_INTERFACE CONNMAN_SERVICE ".Counter" +#define CONNMAN_ERROR_INTERFACE CONNMAN_SERVICE ".Error" +#define CONNMAN_AGENT_INTERFACE CONNMAN_SERVICE ".Agent" + +#define CONNMAN_MANAGER_PATH "/" +#define CONNMAN_PATH "/net/connman" +#define CONNMAN_TECHNOLOGY_PATH "/net/connman/technology" + +#define NETCONFIG_SERVICE "net.netconfig" +#define NETCONFIG_NETWORK_INTERFACE NETCONFIG_SERVICE ".network" +#define NETCONFIG_WIFI_INTERFACE NETCONFIG_SERVICE ".wifi" + +#define NETCONFIG_NETWORK_PATH "/net/netconfig/network" +#define NETCONFIG_WIFI_PATH "/net/netconfig/wifi" + +#if defined TIZEN_TV +#define NETCONFIG_TV_PROFILE_INTERFACE NETCONFIG_SERVICE ".tv_profile" +#endif + +#define SUPPLICANT_SERVICE "fi.w1.wpa_supplicant1" +#define SUPPLICANT_INTERFACE "fi.w1.wpa_supplicant1" +#define SUPPLICANT_IFACE_INTERFACE SUPPLICANT_INTERFACE ".Interface" +#define SUPPLICANT_IFACE_BSS SUPPLICANT_INTERFACE ".BSS" +#define SUPPLICANT_PATH "/fi/w1/wpa_supplicant1" + +#define DBUS_PROPERTIES_INTERFACE "org.freedesktop.DBus.Properties" + +#define CONNMAN_MANAGER_SIGNAL_FILTER "type='signal',interface='net.connman.Manager'" +#define CONNMAN_SERVICE_SIGNAL_FILTER "type='signal',interface='net.connman.Service'" +#define NETCONFIG_WIFI_FILTER "type='signal',interface='net.netconfig.wifi'" +#define SUPPLICANT_INTERFACE_SIGNAL_FILTER "type='signal',interface='fi.w1.wpa_supplicant1.Interface'" + +#define SIGNAL_PROPERTY_CHANGED "PropertyChanged" +#define SIGNAL_PROPERTIES_CHANGED "PropertiesChanged" +#define SIGNAL_TECHNOLOGY_ADDED "TechnologyAdded" +#define SIGNAL_TECHNOLOGY_REMOVED "TechnologyRemoved" +#define SIGNAL_SERVICES_CHANGED "ServicesChanged" +#define SIGNAL_SCAN_DONE "ScanDone" + +#define CONNMAN_WIFI_TECHNOLOGY_PREFIX CONNMAN_PATH "/technology/wifi" + +#define CONNMAN_WIFI_SERVICE_PROFILE_PREFIX CONNMAN_PATH "/service/wifi_" + +/** Network related Daemon Signals */ +#define NETCONFIG_SIGNAL_POWERON_COMPLETED "PowerOnCompleted" +#define NETCONFIG_SIGNAL_POWEROFF_COMPLETED "PowerOffCompleted" +#define NETCONFIG_SIGNAL_SPECIFIC_SCAN_DONE "SpecificScanCompleted" +#define NETCONFIG_SIGNAL_WPS_SCAN_DONE "WpsScanCompleted" +#define NETCONFIG_SIGNAL_TDLS_CONNECTED "TDLSConnect" +#define NETCONFIG_SIGNAL_TDLS_DISCONNECTED "TDLSDisconnect" +#define NETCONFIG_SIGNAL_TDLS_PEER_FOUND "TDLSPeerFound" +#define NETCONFIG_SIGNAL_WIFI_CONNECT_FAIL "WiFiConnectFail" +#define NETCONFIG_SIGNAL_DPM_WIFI "DPMWifi" +#define NETCONFIG_SIGNAL_DPM_WIFI_PROFILE "DPMWifiProfile" + +#define __NETWORK_FUNC_ENTER__ /*WIFI_LOG(WIFI_INFO, "Enter (%s)", __func__);*/ +#define __NETWORK_FUNC_EXIT__ /*WIFI_LOG(WIFI_INFO, "Quit (%s)", __func__);*/ + +typedef enum { + NETWORK_REQUEST_TYPE_SCAN = 0x00, + NETWORK_REQUEST_TYPE_OPEN_CONNECTION, + NETWORK_REQUEST_TYPE_CLOSE_CONNECTION, + NETWORK_REQUEST_TYPE_WIFI_POWER, + NETWORK_REQUEST_TYPE_ENROLL_WPS, + NETWORK_REQUEST_TYPE_SPECIFIC_SCAN, + NETWORK_REQUEST_TYPE_WPS_SCAN, + NETWORK_REQUEST_TYPE_SET_DEFAULT, + NETWORK_REQUEST_TYPE_RESET_DEFAULT, + NETWORK_REQUEST_TYPE_MAX +} network_async_request_type_e; + +typedef struct { + int flag; + char ProfileName[NET_PROFILE_NAME_LEN_MAX+1]; +} network_request_table_s; + +typedef struct { + net_wifi_state_e wifi_state; + net_event_cb ClientEventCb_wifi; + void* user_data_wifi; + int ref_count; + guint handler_id; +} network_info_s; + +typedef struct { + char technology[NET_TECH_LENGTH_MAX]; + char AvailableTechnology; + char EnabledTechnology; + char ConnectedTechnology; + char DefaultTechnology; + unsigned char Connected; + unsigned char Powered; +} network_tech_state_info_s; + +int _net_get_tech_state(GVariant *iter, network_tech_state_info_s* tech_state); +char* _net_print_error(net_err_e error); +int _net_open_connection_with_wifi_info(const net_wifi_connection_info_s* wifi_info); +int _net_check_profile_name(const char* ProfileName); +int _net_get_profile_list(GSList **profile_list); +void _net_client_callback(net_event_info_s *event_data); +net_wifi_state_e _net_get_wifi_state(net_err_e *net_error); +void _net_clear_request_table(void); + +guint _net_client_callback_add(GSourceFunc func, gpointer user_data); +void _net_client_callback_cleanup(void); + +gboolean _net_dbus_is_pending_call_used(void); +void _net_dbus_pending_call_ref(void); +void _net_dbus_pending_call_unref(void); +int _net_dbus_create_gdbus_call(void); +int _net_dbus_close_gdbus_call(void); +GDBusConnection *_net_dbus_get_gdbus_conn(void); +GCancellable *_net_dbus_get_gdbus_cancellable(void); + +#ifdef __cplusplus +} +#endif + +#endif /* __NETWORK_INTERNAL_H__ */ diff --git a/include/network_signal.h b/include/network_signal.h new file mode 100755 index 0000000..ad36219 --- /dev/null +++ b/include/network_signal.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __NETWORK_SIGNAL_H__ +#define __NETWORK_SIGNAL_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +int _net_deregister_signal(void); +int _net_register_signal(void); +int _net_init_service_state_table(void); + +/* Device Policy Manager */ +int _net_get_dpm_wifi_state(void); +void _net_set_dpm_wifi_state(int state); +int _net_get_dpm_wifi_profile_state(void); +void _net_set_dpm_wifi_profile_state(int state); + + +#ifdef __cplusplus +} +#endif + +#endif /** __NETWORK_SIGNAL_H__ */ diff --git a/include/network_wlan.h b/include/network_wlan.h new file mode 100755 index 0000000..183a3d8 --- /dev/null +++ b/include/network_wlan.h @@ -0,0 +1,224 @@ +/* + * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __NETWORK_WLAN_H__ +#define __NETWORK_WLAN_H__ + +#include + +#include "network_config.h" + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/** Length of essid */ +#define NET_WLAN_ESSID_LEN 128 + +/** Length of bssid */ +#define NET_WLAN_BSSID_LEN 17 + +/** + * Length of WPS PIN code + * WPS PIN code should be 4 or 8 digits + */ +#define NET_WLAN_MAX_WPSPIN_LEN 8 + +/** + * Passphrase length should be between 8..63, + * If we plan to use encrypted key(hex value generated by wpa_passphrase), + * then we have to set this value to some higher number + */ +#define NET_WLAN_MAX_PSK_PASSPHRASE_LEN 65 + +/** + * Length of WEP Key + * Max of 10 Hex digits allowed in case of 64 bit encryption + * Max of 26 Hex digits allowed in case of 128 bit encryption + */ +#define NET_WLAN_MAX_WEP_KEY_LEN 26 + +/** + * These lengths depends on authentication server being used, + * In case of freeradius server Max allowed length for username/password is 255 + * Let us restrict this value to some optimal value say 50. + * Used by EAP-TLS, optional for EAP-TTLS and EAP-PEAP + */ +#define NET_WLAN_USERNAME_LEN 50 + +/** + * These lengths depends on authentication server being used, + * In case of freeradius server Max allowed length for username/password is 255 + * Let us restrict this value to some optimal value say 50. + * Used by EAP-TLS, optional for EAP-TTLS and EAP-PEAP + */ +#define NET_WLAN_PASSWORD_LEN 50 + +/** + * length of CA Cert file name + * Used by EAP-TLS, optional for EAP-TTLS and EAP-PEAP + */ +#define NET_WLAN_CA_CERT_FILENAME_LEN 128 + +/** + * length of Client Cert file name + * Used by EAP-TLS, optional for EAP-TTLS and EAP-PEAP + */ +#define NET_WLAN_CLIENT_CERT_FILENAME_LEN 128 + +/** + * length of private key file name + * Used by EAP-TLS, optional for EAP-TTLS and EAP-PEAP + */ +#define NET_WLAN_PRIVATE_KEY_FILENAME_LEN 128 + +/** + * length of Private key password + * Used by EAP-TLS, optional for EAP-TTLS and EAP-PEAP + */ +#define NET_WLAN_PRIVATE_KEY_PASSWD_LEN 50 + +/** + * Below security modes are used in infrastructure and ad-hoc mode + * For now all EAP security mechanisms are provided only in infrastructure mode + */ +typedef enum { + WLAN_SEC_MODE_NONE = 0x01, /** Security disabled */ + WLAN_SEC_MODE_WEP, /** WEP */ + WLAN_SEC_MODE_IEEE8021X, /** EAP */ + WLAN_SEC_MODE_WPA_PSK, /** WPA-PSK */ + WLAN_SEC_MODE_WPA2_PSK, /** WPA2-PSK */ + WLAN_SEC_MODE_WPA_FT_PSK, +} wlan_security_mode_type_e; + +/** + * Below encryption modes are used in infrastructure and ad-hoc mode + */ +typedef enum { + WLAN_ENC_MODE_NONE = 0x01, /** Encryption disabled */ + WLAN_ENC_MODE_WEP, /** WEP */ + WLAN_ENC_MODE_TKIP, /** TKIP */ + WLAN_ENC_MODE_AES, /** AES */ + WLAN_ENC_MODE_TKIP_AES_MIXED, /** TKIP and AES are both supported */ +} wlan_encryption_mode_type_e; + +/** + * WLAN Operation Mode + */ +typedef enum { + NET_WLAN_CONNMODE_AUTO = 0x01, /** auto connection mode */ + NET_WLAN_CONNMODE_ADHOC, /** Connection mode Adhoc */ + NET_WLAN_CONNMODE_INFRA, /** Infra connection mode */ +} wlan_connection_mode_type_e; + +/** + * EAP type + */ +typedef enum { + WLAN_SEC_EAP_TYPE_PEAP = 0x01, /** EAP PEAP type */ + WLAN_SEC_EAP_TYPE_TLS, /** EAP TLS type */ + WLAN_SEC_EAP_TYPE_TTLS, /** EAP TTLS type */ + WLAN_SEC_EAP_TYPE_SIM, /** EAP SIM type */ + WLAN_SEC_EAP_TYPE_AKA, /** EAP AKA type */ +} wlan_eap_type_e; + +/** + * EAP phase2 authentication type + */ +typedef enum { + WLAN_SEC_EAP_AUTH_NONE = 0x01, /** EAP phase2 authentication none */ + WLAN_SEC_EAP_AUTH_PAP, /** EAP phase2 authentication PAP */ + WLAN_SEC_EAP_AUTH_MSCHAP, /** EAP phase2 authentication MSCHAP */ + WLAN_SEC_EAP_AUTH_MSCHAPV2, /** EAP phase2 authentication MSCHAPv2 */ + WLAN_SEC_EAP_AUTH_GTC, /** EAP phase2 authentication GTC */ + WLAN_SEC_EAP_AUTH_MD5, /** EAP phase2 authentication MD5 */ +} wlan_eap_auth_type_e; + +/** + * EAP keymgmt type + */ +typedef enum { + WLAN_SEC_EAP_KEYMGMT_UNKNOWN = 0x00, + WLAN_SEC_EAP_KEYMGMT_NONE, + WLAN_SEC_EAP_KEYMGMT_FT, + WLAN_SEC_EAP_KEYMGMT_CCKM, + WLAN_SEC_EAP_KEYMGMT_OKC, +} wlan_eap_keymgmt_type_e; + +/** + * Below structure is used by WPA-PSK or WPA2-PSK + * To see the maximum length of PSK passphrase key. + */ +typedef struct { + char pskKey[NET_WLAN_MAX_PSK_PASSPHRASE_LEN + 1]; /** key value for WPA-PSK or WPA2-PSK */ +} wlan_psk_info_s; + +/** + * Below structure is used by WEP + * To see the maximum length of WEP key. + */ +typedef struct { + char wepKey[NET_WLAN_MAX_WEP_KEY_LEN + 1]; /** key value for WEP */ +} wlan_wep_info_s; + +/** + * Below structure is used by EAP + */ +typedef struct { + char username[NET_WLAN_USERNAME_LEN+1]; /** User name */ + char password[NET_WLAN_PASSWORD_LEN+1]; /** Password */ + + /** + * Following fields are mandatory for EAP-TLS, + * Optional for EAP-TTLS and EAP-PEAP + * + * For EAP-TTLS and EAP-PEAP only ca_cert_filename[] can also be provided + */ + char ca_cert_filename[NET_WLAN_CA_CERT_FILENAME_LEN+1]; /* Used to authenticate server */ + char client_cert_filename[NET_WLAN_CLIENT_CERT_FILENAME_LEN+1]; /** client certificate file name */ + char private_key_filename[NET_WLAN_PRIVATE_KEY_FILENAME_LEN+1]; /** private key file name */ + char private_key_passwd[NET_WLAN_PRIVATE_KEY_PASSWD_LEN+1]; /** private key password */ + + wlan_eap_type_e eap_type; /** eap type */ + wlan_eap_auth_type_e eap_auth; /** eap phase2 authentication type */ + wlan_eap_keymgmt_type_e eap_keymgmt_type; /** eap keymgmt type */ +} wlan_eap_info_s; + +/** + * At any point of time only one security mechanism is supported + */ +typedef union { + wlan_wep_info_s wep; /** Wep Authentication */ + wlan_psk_info_s psk; /** psk Authentication */ + wlan_eap_info_s eap; /** eap Authentication */ +} wlan_auth_info_u; + +/** + * This is main security information structure + */ +typedef struct { + wlan_security_mode_type_e sec_mode; /** security mode type */ + wlan_encryption_mode_type_e enc_mode; /** encryption mode type */ + wlan_auth_info_u authentication; /** authentication information */ + char wps_support; /** If WPS is supported, then this property will be set to TRUE */ + unsigned int keymgmt; /** If WPS is supported, then this property will be set to TRUE */ +} wlan_security_info_s; + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* __NETWORK_WLAN_H__ */ diff --git a/include/wifi-manager.h b/include/wifi-manager.h new file mode 100755 index 0000000..d8d020a --- /dev/null +++ b/include/wifi-manager.h @@ -0,0 +1,2286 @@ +/* + * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __TIZEN_WIFI_MANAGER_H__ +#define __TIZEN_WIFI_MANAGER_H__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @file wifi-manager.h + */ + +/** +* @addtogroup CAPI_NETWORK_WIFI_MANAGER_MODULE +* @{ +*/ + +/** + * @brief The wifi manager handle. + * @since_tizen 3.0 +*/ +typedef void *wifi_manager_h; + +/** + * @brief Enumeration for the Wi-Fi error type. + * @since_tizen 3.0 + */ +typedef enum { + WIFI_MANAGER_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */ + WIFI_MANAGER_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */ + WIFI_MANAGER_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory error */ + WIFI_MANAGER_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION, /**< Invalid operation */ + WIFI_MANAGER_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED = TIZEN_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED, /**< Address family not supported */ + WIFI_MANAGER_ERROR_OPERATION_FAILED = TIZEN_ERROR_WIFI_MANAGER|0x01, /**< Operation failed */ + WIFI_MANAGER_ERROR_NO_CONNECTION = TIZEN_ERROR_WIFI_MANAGER|0x02, /**< There is no connected AP */ + WIFI_MANAGER_ERROR_NOW_IN_PROGRESS = TIZEN_ERROR_NOW_IN_PROGRESS, /**< Now in progress */ + WIFI_MANAGER_ERROR_ALREADY_EXISTS = TIZEN_ERROR_WIFI_MANAGER|0x03, /**< Already exists */ + WIFI_MANAGER_ERROR_OPERATION_ABORTED = TIZEN_ERROR_WIFI_MANAGER|0x04, /**< Operation is aborted */ + WIFI_MANAGER_ERROR_DHCP_FAILED = TIZEN_ERROR_WIFI_MANAGER|0x05, /**< DHCP failed */ + WIFI_MANAGER_ERROR_INVALID_KEY = TIZEN_ERROR_WIFI_MANAGER|0x06, /**< Invalid key */ + WIFI_MANAGER_ERROR_NO_REPLY = TIZEN_ERROR_WIFI_MANAGER|0x07, /**< No reply */ + WIFI_MANAGER_ERROR_SECURITY_RESTRICTED = TIZEN_ERROR_WIFI_MANAGER|0x08, /**< Restricted by security system policy */ + WIFI_MANAGER_ERROR_ALREADY_INITIALIZED = TIZEN_ERROR_WIFI_MANAGER|0x09, /**< Already initialized */ + WIFI_MANAGER_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission Denied */ + WIFI_MANAGER_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED /**< Not Supported */ +} wifi_manager_error_e; + +/** +* @} +*/ + + +/** +* @addtogroup CAPI_NETWORK_WIFI_MANAGER_MONITOR_MODULE +* @{ +*/ + +/** + * @brief Enumeration for the state of the Wi-Fi device. + * @since_tizen 3.0 + */ +typedef enum { + WIFI_MANAGER_DEVICE_STATE_DEACTIVATED = 0, /**< Wi-Fi is Deactivated */ + WIFI_MANAGER_DEVICE_STATE_ACTIVATED = 1, /**< Wi-Fi is activated */ +} wifi_manager_device_state_e; + +/** + * @brief Enumeration for the state of the Wi-Fi connection. + * @since_tizen 3.0 + */ +typedef enum { + WIFI_MANAGER_CONNECTION_STATE_FAILURE = -1, /**< Connection failed state */ + WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED = 0, /**< Disconnected state */ + WIFI_MANAGER_CONNECTION_STATE_ASSOCIATION = 1, /**< Association state */ + WIFI_MANAGER_CONNECTION_STATE_CONFIGURATION = 2, /**< Configuration state */ + WIFI_MANAGER_CONNECTION_STATE_CONNECTED = 3, /**< Connected state */ +} wifi_manager_connection_state_e; + +/** + * @brief Enumeration for the RSSI level. + * @since_tizen 3.0 + */ +typedef enum { + WIFI_MANAGER_RSSI_LEVEL_0 = 0, /**< level 0 */ + WIFI_MANAGER_RSSI_LEVEL_1 = 1, /**< level 1 */ + WIFI_MANAGER_RSSI_LEVEL_2 = 2, /**< level 2 */ + WIFI_MANAGER_RSSI_LEVEL_3 = 3, /**< level 3 */ + WIFI_MANAGER_RSSI_LEVEL_4 = 4, /**< level 4 */ +} wifi_manager_rssi_level_e; + +/** +* @} +*/ + + +/** +* @addtogroup CAPI_NETWORK_WIFI_MANAGER_AP_NETWORK_MODULE +* @{ +*/ + +/** + * @brief Enumeration for the Net IP configuration type. + * @since_tizen 3.0 + */ +typedef enum { + WIFI_MANAGER_IP_CONFIG_TYPE_NONE = 0, /**< Not defined */ + WIFI_MANAGER_IP_CONFIG_TYPE_STATIC = 1, /**< Manual IP configuration */ + WIFI_MANAGER_IP_CONFIG_TYPE_DYNAMIC = 2, /**< Config IP using DHCP client*/ + WIFI_MANAGER_IP_CONFIG_TYPE_AUTO = 3, /**< Config IP from Auto IP pool (169.254/16). Later with DHCP client, if available */ + WIFI_MANAGER_IP_CONFIG_TYPE_FIXED = 4, /**< Indicates an IP address that can not be modified */ +} wifi_manager_ip_config_type_e; + +/** + * @brief Enumeration for the address type. + * @since_tizen 3.0 + */ +typedef enum { + WIFI_MANAGER_ADDRESS_FAMILY_IPV4 = 0, /**< IPV4 Address family */ + WIFI_MANAGER_ADDRESS_FAMILY_IPV6 = 1, /**< IPV6 Address family */ +} wifi_manager_address_family_e; + +/** + * @brief Enumeration for the proxy method type. + * @since_tizen 3.0 + */ +typedef enum { + WIFI_MANAGER_PROXY_TYPE_DIRECT = 0, /**< Direct connection */ + WIFI_MANAGER_PROXY_TYPE_AUTO = 1, /**< Auto configuration(Use PAC file). If URL property is not set, DHCP/WPAD auto-discover will be tried */ + WIFI_MANAGER_PROXY_TYPE_MANUAL = 2 /**< Manual configuration */ +} wifi_manager_proxy_type_e; + +/** +* @} +*/ + + +/** +* @addtogroup CAPI_NETWORK_WIFI_MANAGER_AP_SECURITY_MODULE +* @{ +*/ + +/** + * @brief Enumeration for Wi-Fi security type. + * @details The following security modes are used in infrastructure and ad-hoc mode. + * For now all EAP security mechanisms are provided only in infrastructure mode. + * + * @since_tizen 3.0 + */ +typedef enum { + WIFI_MANAGER_SECURITY_TYPE_NONE = 0, /**< Security disabled */ + WIFI_MANAGER_SECURITY_TYPE_WEP = 1, /**< WEP */ + WIFI_MANAGER_SECURITY_TYPE_WPA_PSK = 2, /**< WPA-PSK */ + WIFI_MANAGER_SECURITY_TYPE_WPA2_PSK = 3, /**< WPA2-PSK */ + WIFI_MANAGER_SECURITY_TYPE_EAP = 4, /**< EAP */ +} wifi_manager_security_type_e; + +/** + * @brief Enumeration for Wi-Fi encryption type. + * @details The following encryption modes are used in infrastructure and ad-hoc mode. + * @since_tizen 3.0 + */ +typedef enum { + WIFI_MANAGER_ENCRYPTION_TYPE_NONE = 0, /**< Encryption disabled */ + WIFI_MANAGER_ENCRYPTION_TYPE_WEP = 1, /**< WEP */ + WIFI_MANAGER_ENCRYPTION_TYPE_TKIP = 2, /**< TKIP */ + WIFI_MANAGER_ENCRYPTION_TYPE_AES = 3, /**< AES */ + WIFI_MANAGER_ENCRYPTION_TYPE_TKIP_AES_MIXED = 4, /**< TKIP and AES are both supported */ +} wifi_manager_encryption_type_e; + +/** +* @} +*/ + + +/** +* @addtogroup CAPI_NETWORK_WIFI_MANAGER_AP_SECURITY_EAP_MODULE +* @{ +*/ + +/** + * @brief Enumeration for EAP type. + * @since_tizen 3.0 + */ +typedef enum { + WIFI_MANAGER_EAP_TYPE_PEAP = 0, /**< EAP PEAP type */ + WIFI_MANAGER_EAP_TYPE_TLS = 1, /**< EAP TLS type */ + WIFI_MANAGER_EAP_TYPE_TTLS = 2, /**< EAP TTLS type */ + WIFI_MANAGER_EAP_TYPE_SIM = 3, /**< EAP SIM type */ + WIFI_MANAGER_EAP_TYPE_AKA = 4, /**< EAP AKA type */ +} wifi_manager_eap_type_e; + +/** + * @brief Enumeration for EAP phase2 authentication type. + * @since_tizen 3.0 + */ +typedef enum { + WIFI_MANAGER_EAP_AUTH_TYPE_NONE = 0, /**< EAP phase2 authentication none */ + WIFI_MANAGER_EAP_AUTH_TYPE_PAP = 1, /**< EAP phase2 authentication PAP */ + WIFI_MANAGER_EAP_AUTH_TYPE_MSCHAP = 2, /**< EAP phase2 authentication MSCHAP */ + WIFI_MANAGER_EAP_AUTH_TYPE_MSCHAPV2 = 3, /**< EAP phase2 authentication MSCHAPv2 */ + WIFI_MANAGER_EAP_AUTH_TYPE_GTC = 4, /**< EAP phase2 authentication GTC */ + WIFI_MANAGER_EAP_AUTH_TYPE_MD5 = 5, /**< EAP phase2 authentication MD5 */ +} wifi_manager_eap_auth_type_e; + +/** +* @} +*/ + +/** + * @addtogroup CAPI_NETWORK_WIFI_MANAGER_TDLS_MODULE + * @{ + */ + +/** + * @brief Enumeration for the state of the Wi-Fi TDLS. + * @since_tizen 3.0 + */ +typedef enum { + WIFI_MANAGER_TDLS_STATE_DISCONNECTED = 0, /**< Wi-Fi TDLS is Disconnected */ + WIFI_MANAGER_TDLS_STATE_CONNECTED = 1, /**< Wi-Fi TDLS is Connected */ +} wifi_manager_tdls_state_e; + +/** + * @} + */ + +/** +* @addtogroup CAPI_NETWORK_WIFI_MANAGER_AP_MODULE +* @{ +*/ + +/** + * @brief The Wi-Fi access point handle. + * @since_tizen 3.0 + */ +typedef void *wifi_manager_ap_h; + +/** +* @} +*/ + +/** +* @addtogroup CAPI_NETWORK_WIFI_MANAGER_CONFIG_MODULE +* @{ +*/ + +/** + * @brief The Wi-Fi access point configuration handle + * @since_tizen 3.0 + */ +typedef void *wifi_manager_config_h; + +/** +* @} +*/ + +/** +* @addtogroup CAPI_NETWORK_WIFI_MANAGER_MANAGEMENT_MODULE +* @{ +*/ + +/** + * @brief Called for each found access point. + * @since_tizen 3.0 + * @remarks @a AP is valid only in this function. In order to use @a AP outside this function, you must copy the AP with wifi_manager_ap_clone(). + * @param[in] ap The access point + * @param[in] user_data The user data passed from the request function + * @return @c true to continue with the next iteration of the loop, \n + * otherwise @c false to break out of the loop + * @pre wifi_manager_foreach_found_ap() will invoke this callback. + * @pre wifi_manager_foreach_found_specific_ap() will invoke this callback. + * @see wifi_manager_foreach_found_ap() + * @see wifi_manager_foreach_found_specific_ap() + */ +typedef bool(*wifi_manager_found_ap_cb)(wifi_manager_ap_h ap, void *user_data); + +/** + * @brief Called when the scan is finished. + * @since_tizen 3.0 + * @param[in] error_code The error code + * @param[in] user_data The user data passed from the callback registration function + * @see wifi_manager_scan() + * @see wifi_manager_set_background_scan_cb() + * @see wifi_manager_unset_background_scan_cb() + */ +typedef void(*wifi_manager_scan_finished_cb)(wifi_manager_error_e error_code, void *user_data); + +/** + * @brief Called after wifi_manager_activate() or wifi_manager_activate_with_wifi_picker_tested() is completed. + * @since_tizen 3.0 + * @param[in] result The result + * @param[in] user_data The user data passed from wifi_manager_activate() and wifi_manager_activate_with_wifi_picker_tested() + * @pre wifi_manager_activate() or wifi_manager_activate_with_wifi_picker_tested() will invoke this callback function. + * @see wifi_manager_activate() + * @see wifi_manager_activate_with_wifi_picker_tested() + */ +typedef void(*wifi_manager_activated_cb)(wifi_manager_error_e result, void *user_data); + +/** + * @brief Called after wifi_manager_deactivate() is completed. + * @since_tizen 3.0 + * @param[in] result The result + * @param[in] user_data The user data passed from wifi_manager_deactivate() + * @pre wifi_manager_deactivate() will invoke this callback function. + * @see wifi_manager_deactivate() + */ +typedef void(*wifi_manager_deactivated_cb)(wifi_manager_error_e result, void *user_data); + +/** + * @brief Called after either wifi_manager_connect() or wifi_manager_connect_by_wps_pbc() or wifi_manager_connect_by_wps_pin() are completed. + * @since_tizen 3.0 + * @param[in] result The result + * @param[in] user_data The user data passed from either wifi_manager_connect() or wifi_manager_connect_by_wps_pbc() or wifi_manager_connect_by_wps_pin() + * @pre Either wifi_manager_connect() or wifi_manager_connect_by_wps_pbc() or wifi_manager_connect_by_wps_pin() will invoke this callback function. + * @see wifi_manager_connect() + * @see wifi_manager_connect_by_wps_pbc() + * @see wifi_manager_connect_by_wps_pin() + */ +typedef void(*wifi_manager_connected_cb)(wifi_manager_error_e result, void *user_data); + +/** + * @brief Called after wifi_manager_disconnect() is completed. + * @since_tizen 3.0 + * @param[in] result The result + * @param[in] user_data The user data passed from wifi_manager_disconnect() + * @pre wifi_manager_disconnect() will invoke this callback function. + * @see wifi_manager_disconnect() + */ +typedef void(*wifi_manager_disconnected_cb)(wifi_manager_error_e result, void *user_data); + +/** +* @} +*/ + + +/** +* @addtogroup CAPI_NETWORK_WIFI_MANAGER_MONITOR_MODULE +* @{ +*/ + +/** + * @brief Called when the device state is changed. + * @since_tizen 3.0 + * @param[in] state The device state + * @param[in] user_data The user data passed from the callback registration function + * @see wifi_manager_set_device_state_changed_cb() + * @see wifi_manager_unset_device_state_changed_cb() + */ +typedef void(*wifi_manager_device_state_changed_cb)(wifi_manager_device_state_e state, void *user_data); + +/** + * @brief Called when the connection state is changed. + * @since_tizen 3.0 + * @param[in] state The connection state + * @param[in] ap The access point + * @param[in] user_data The user data passed from the callback registration function + * @see wifi_manager_set_connection_state_changed_cb() + * @see wifi_manager_unset_connection_state_changed_cb() + */ +typedef void(*wifi_manager_connection_state_changed_cb)(wifi_manager_connection_state_e state, wifi_manager_ap_h ap, void *user_data); + +/** + * @brief Called when the RSSI of connected Wi-Fi is changed. + * @since_tizen 3.0 + * @param[in] rssi_level The level of RSSI + * @param[in] user_data The user data passed from the callback registration function + * @see wifi_manager_set_rssi_level_changed_cb() + * @see wifi_manager_unset_rssi_level_changed_cb() + */ +typedef void(*wifi_manager_rssi_level_changed_cb)(wifi_manager_rssi_level_e rssi_level, void *user_data); + +/** +* @} +*/ + +/** +* @addtogroup CAPI_NETWORK_WIFI_MANAGER_CONFIG_MODULE +* @{ +*/ + +/** + * @brief Called for each found access point configuration. + * @since_tizen 3.0 + * @remarks @a config is valid only in this function. In order to use @a config outside this function, you must copy the config with wifi_manager_config_clone(). + * + * @param[in] config The access point configuration handle + * @param[in] user_data The user data passed from the request function + * + * @return @c true to continue with the next iteration of the loop, otherwise @c false to break out of the loop \n + * @pre wifi_manager_config_foreach_configuration() will invoke this callback. + * @see wifi_manager_config_foreach_configuration() + */ +typedef bool (*wifi_manager_config_list_cb)(const wifi_manager_config_h config, void *user_data); + +/** +* @} +*/ + +/** + * @addtogroup CAPI_NETWORK_WIFI_MANAGER_TDLS_MODULE + * @{ + */ + +/** + * @brief Called when the WiFi TDLS state is changed. + * @since_tizen 3.0 + * + * @param[in] state The TDLS state + * @param[in] peer_mac_addr MAC address of the TDLS peer + * @param[in] user_data The user data passed from the callback registration function + * @see wifi_manager_tdls_set_state_changed_cb() + * @see wifi_manager_tdls_unset_state_changed_cb() + */ +typedef void(*wifi_manager_tdls_state_changed_cb)(wifi_manager_tdls_state_e state, + char *peer_mac_addr, void *user_data); + +/** + * @} + */ + +/** +* @addtogroup CAPI_NETWORK_WIFI_MANAGER_MODULE +* @{ +*/ + +/** + * @brief Initializes Wi-Fi. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.get + * @remarks You must release @a handle using wifi_manager_deinitialize(). + * @param[out] wifi The wifi handle + * @return @c 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_ALREADY_INITIALIZED Already initialized + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_initialize(wifi_manager_h *wifi); + +/** + * @brief Deinitializes Wi-Fi. + * @since_tizen 3.0 + * @param[in] wifi The wifi handle + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_deinitialize(wifi_manager_h wifi); + +/** +* @} +*/ + + +/** +* @addtogroup CAPI_NETWORK_WIFI_MANAGER_MANAGEMENT_MODULE +* @{ +*/ + +/** + * @brief Activates Wi-Fi asynchronously. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.set \n + * %http://tizen.org/privilege/network.get + * @remark This API needs both privileges. + * @param[in] wifi The wifi handle + * @param[in] callback The callback function to be called \n + * This can be @c NULL if you don't want to get the notification. + * @param[in] user_data The user data passed to the callback function + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_SECURITY_RESTRICTED Restricted by security system policy + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @post wifi_manager_activated_cb() will be invoked. + * @see wifi_manager_activated_cb() + * @see wifi_manager_deactivate() + */ +int wifi_manager_activate(wifi_manager_h wifi, wifi_manager_activated_cb callback, void *user_data); + +/** + * @brief Activates Wi-Fi asynchronously and displays Wi-Fi picker (popup) when Wi-Fi is not automatically connected. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.set \n + * %http://tizen.org/privilege/network.get + * @remark This API needs both privileges. + * @param[in] wifi The wifi handle + * @param[in] callback The callback function to be called \n + * This can be @c NULL if you don't want to get the notification. + * @param[in] user_data The user data passed to the callback function + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_SECURITY_RESTRICTED Restricted by security system policy + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @post wifi_manager_activated_cb() will be invoked. + * @see wifi_manager_activated_cb() + * @see wifi_manager_deactivate() + */ +int wifi_manager_activate_with_wifi_picker_tested(wifi_manager_h wifi, + wifi_manager_activated_cb callback, void *user_data); + +/** + * @brief Deactivates Wi-Fi asynchronously. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.set \n + * %http://tizen.org/privilege/network.get + * @remark This API needs both privileges. + * @param[in] wifi The wifi handle + * @param[in] callback The callback function to be called \n + * This can be @c NULL if you don't want to get the notification. + * @param[in] user_data The user data passed to the callback function + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @post wifi_manager_deactivated_cb() will be invoked. + * @see wifi_manager_deactivated_cb() + * @see wifi_manager_activate() + */ +int wifi_manager_deactivate(wifi_manager_h wifi, wifi_manager_deactivated_cb callback, void *user_data); + +/** + * @brief Checks whether Wi-Fi is activated. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.get + * @param[in] wifi The wifi handle + * @param[out] activated @c true if Wi-Fi is activated, + * otherwise @c false if Wi-Fi is not activated. + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_is_activated(wifi_manager_h wifi, bool *activated); + +/** + * @brief Gets the local MAC address. + * @since_tizen 3.0 + * @remarks You must release @a mac_address using free(). + * @param[in] wifi The wifi handle + * @param[out] mac_address The MAC address + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_get_mac_address(wifi_manager_h wifi, char **mac_address); + +/** + * @brief Gets the name of the network interface. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.get + * @remarks You must release @a name using free(). + * @param[in] wifi The wifi handle + * @param[out] name The name of network interface + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_get_network_interface_name(wifi_manager_h wifi, char **name); + +/** + * @brief Starts scan asynchronously. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.set \n + * %http://tizen.org/privilege/network.get + * @remark This API needs both privileges. + * @param[in] wifi The wifi handle + * @param[in] callback The callback function to be called + * @param[in] user_data The user data passed to the callback function + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @post This function invokes wifi_manager_scan_finished_cb(). + */ +int wifi_manager_scan(wifi_manager_h wifi, wifi_manager_scan_finished_cb callback, void *user_data); + +/** + * @brief Starts specific AP scan, asynchronously. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.set \n + * %http://tizen.org/privilege/network.get + * @remark This API needs both privileges. + * @param[in] wifi The wifi handle + * @param[in] essid The essid of hidden AP + * @param[in] callback The callback function to be called + * @param[in] user_data The user data passed to the callback function + * @return 0 on success, otherwise negative error value. + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @post This function invokes wifi_manager_scan_finished_cb(). + */ +int wifi_manager_scan_specific_ap(wifi_manager_h wifi, + const char *essid, wifi_manager_scan_finished_cb callback, void *user_data); + +/** + * @brief Gets the handle of the connected access point. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.get + * @remarks You must release @a handle using wifi_manager_ap_destroy(). + * @param[in] wifi The wifi handle + * @param[out] ap The access point handle + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_NO_CONNECTION There is no connected AP + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_get_connected_ap(wifi_manager_h wifi, wifi_manager_ap_h *ap); + +/** + * @brief Gets the result of the scan. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.get + * @param[in] wifi The wifi handle + * @param[in] callback The callback to be called + * @param[in] user_data The user data passed to the callback function + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @post This function invokes wifi_manager_found_ap_cb(). + */ +int wifi_manager_foreach_found_ap(wifi_manager_h wifi, wifi_manager_found_ap_cb callback, void *user_data); + +/** + * @brief Gets the result of specific AP scan. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.get + * @param[in] wifi The wifi handle + * @param[in] callback The callback to be called + * @param[in] user_data The user data passed to the callback function + * @return 0 on success, otherwise negative error value. + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @post This function invokes wifi_manager_found_ap_cb(). + * @see wifi_manager_scan_specific_ap() + */ +int wifi_manager_foreach_found_specific_ap(wifi_manager_h wifi, + wifi_manager_found_ap_cb callback, void *user_data); + +/** + * @brief Connects to the access point asynchronously. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.set \n + * %http://tizen.org/privilege/network.get + * @remark This API needs both privileges. + * @param[in] wifi The wifi handle + * @param[in] ap The access point handle + * @param[in] callback The callback function to be called \n + * This can be @c NULL if you don't want to get the notification. + * @param[in] user_data The user data passed to the callback function + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @post This function invokes wifi_manager_connected_cb(). + * @see wifi_manager_connected_cb() + * @see wifi_manager_connect_by_wps_pbc() + * @see wifi_manager_connect_by_wps_pin() + * @see wifi_manager_disconnect() + */ +int wifi_manager_connect(wifi_manager_h wifi, wifi_manager_ap_h ap, wifi_manager_connected_cb callback, void *user_data); + +/** + * @brief Disconnects to the access point asynchronously. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.set \n + * %http://tizen.org/privilege/network.get + * @remark This API needs both privileges. + * @param[in] wifi The wifi handle + * @param[in] ap The access point handle + * @param[in] callback The callback function to be called \n + * This can be @c NULL if you don't want to get the notification. + * @param[in] user_data The user data passed to the callback function + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @post This function invokes wifi_manager_disconnected_cb(). + * @see wifi_manager_disconnected_cb() + * @see wifi_manager_connect_by_wps_pbc() + * @see wifi_manager_connect_by_wps_pin() + * @see wifi_manager_connect() + */ +int wifi_manager_disconnect(wifi_manager_h wifi, wifi_manager_ap_h ap, wifi_manager_disconnected_cb callback, void *user_data); + +/** + * @brief Connects to the access point with WPS PBC asynchronously. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.profile \n + * %http://tizen.org/privilege/network.get + * @remark This API needs both privileges. + * @param[in] wifi The wifi handle + * @param[in] ap The access point handle + * @param[in] callback The callback function to be called \n + * This can be NULL if you don't want to get the notification. + * @param[in] user_data The user data passed to the callback function + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @post This function invokes wifi_manager_connected_cb(). + * @see wifi_manager_connected_cb() + * @see wifi_manager_connect() + * @see wifi_manager_disconnect() + * @see wifi_manager_ap_is_wps_supported() + */ +int wifi_manager_connect_by_wps_pbc(wifi_manager_h wifi, + wifi_manager_ap_h ap, wifi_manager_connected_cb callback, void *user_data); + +/** + * @brief Connects to the access point with WPS PIN asynchronously. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.profile \n + * %http://tizen.org/privilege/network.get + * @remark This API needs both privileges. + * @param[in] wifi The wifi handle + * @param[in] ap The access point handle + * @param[in] pin The WPS PIN is a non-NULL string with length greater than 0 and less than or equal to 8 + * @param[in] callback The callback function to be called (this can be NULL if you don't want to get the notification) + * @param[in] user_data The user data passed to the callback function + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @post This function invokes wifi_manager_connected_cb(). + * @see wifi_manager_connected_cb() + * @see wifi_manager_connect() + * @see wifi_manager_disconnect() + * @see wifi_manager_ap_is_wps_supported() + */ +int wifi_manager_connect_by_wps_pin(wifi_manager_h wifi, + wifi_manager_ap_h ap, const char *pin, wifi_manager_connected_cb callback, void *user_data); + +/** + * @brief Deletes the information of a stored access point and disconnects it if it was connected. + * @details If an AP is connected, then connection information will be stored. + * This information is used when a connection to that AP is established automatically. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.profile \n + * %http://tizen.org/privilege/network.get + * @remark This API needs both privileges. + * @param[in] wifi The wifi handle + * @param[in] ap The access point handle + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_forget_ap(wifi_manager_h wifi, wifi_manager_ap_h ap); + +/** + * @brief Updates an existing AP. + * @details When a AP is changed, these changes will be not applied to the Connection Manager immediately. + * When you call this function, your changes affect the Connection Manager and the existing AP is updated. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.profile \n + * %http://tizen.org/privilege/network.get + * @remark This API needs both privileges. + * @param[in] wifi The wifi handle + * @param[in] ap The access point handle + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_update_ap(wifi_manager_h wifi, wifi_manager_ap_h ap); + +/** +* @} +*/ + +/** +* @addtogroup CAPI_NETWORK_WIFI_MANAGER_MONITOR_MODULE +* @{ +*/ + +/** + * @brief Gets the connection state. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.get + * @param[in] wifi The wifi handle + * @param[out] connection_state The connection state + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_get_connection_state(wifi_manager_h wifi, + wifi_manager_connection_state_e *connection_state); + +/** + * @brief Registers the callback called when the device state is changed. + * @since_tizen 3.0 + * @param[in] wifi The wifi handle + * @param[in] callback The callback function to be called + * @param[in] user_data The user data passed to the callback function + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_set_device_state_changed_cb(wifi_manager_h wifi, + wifi_manager_device_state_changed_cb callback, void *user_data); + +/** + * @brief Unregisters the callback called when the device state is changed. + * @since_tizen 3.0 + * @param[in] wifi The wifi handle + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_unset_device_state_changed_cb(wifi_manager_h wifi); + +/** + * @brief Registers the callback called when the background scan is finished. + * @since_tizen 3.0 + * @param[in] wifi The wifi handle + * @param[in] callback The callback function to be called + * @param[in] user_data The user data passed to the callback function + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_set_background_scan_cb(wifi_manager_h wifi, + wifi_manager_scan_finished_cb callback, void *user_data); + +/** + * @brief Unregisters the callback called when the scan is finished. + * @since_tizen 3.0 + * @param[in] wifi The wifi handle + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_unset_background_scan_cb(wifi_manager_h wifi); + +/** + * @brief Registers the callback called when the connection state is changed. + * @since_tizen 3.0 + * @param[in] wifi The wifi handle + * @param[in] callback The callback function to be called + * @param[in] user_data The user data passed to the callback function + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_set_connection_state_changed_cb(wifi_manager_h wifi, + wifi_manager_connection_state_changed_cb callback, void *user_data); + +/** + * @brief Unregisters the callback called when the connection state is changed. + * @since_tizen 3.0 + * @param[in] wifi The wifi handle + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_unset_connection_state_changed_cb(wifi_manager_h wifi); + +/** + * @brief Registers callback called when the RSSI of connected Wi-Fi is changed. + * @since_tizen 3.0 + * @param[in] wifi The wifi handle + * @param[in] callback The callback function to be called + * @param[in] user_data The user data passed to the callback function + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_set_rssi_level_changed_cb(wifi_manager_h wifi, + wifi_manager_rssi_level_changed_cb callback, void *user_data); + +/** + * @brief Unregisters callback called when the RSSI of connected Wi-Fi is changed. + * @since_tizen 3.0 + * @param[in] wifi The wifi handle + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_unset_rssi_level_changed_cb(wifi_manager_h wifi); + +/** +* @} +*/ + + +/** +* @addtogroup CAPI_NETWORK_WIFI_MANAGER_AP_MODULE +* @{ +*/ + +/** + * @brief Creates the access point handle. + * @since_tizen 3.0 + * @remarks You must release @a AP using wifi_manager_ap_destroy(). + * @param[in] wifi The wifi handle + * @param[in] essid The ESSID (Extended Service Set Identifier) should be null-terminated and can be UTF-8 encoded + * @param[out] ap The access point handle + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @see wifi_manager_ap_destroy() + */ +int wifi_manager_ap_create(wifi_manager_h wifi, const char *essid, wifi_manager_ap_h *ap); + +/** + * @brief Creates the hidden access point handle. + * @since_tizen 3.0 + * @remarks You must release @a AP using wifi_manager_ap_destroy(). + * @param[in] wifi The wifi handle + * @param[in] essid The ESSID (Extended Service Set Identifier) should be null-terminated and can be UTF-8 encoded + * @param[out] ap The access point handle + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @see wifi_manager_ap_destroy() + */ +int wifi_manager_ap_hidden_create(wifi_manager_h wifi, const char *essid, wifi_manager_ap_h *ap); + +/** + * @brief Destroys the access point handle. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @see wifi_manager_ap_create() + */ +int wifi_manager_ap_destroy(wifi_manager_ap_h ap); + +/** + * @brief Clones the access point handle. + * @since_tizen 3.0 + * @remarks You must release @a cloned_ap using wifi_manager_ap_destroy(). + * @param[out] cloned_ap The cloned access point handle + * @param[in] origin The origin access point handle + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @see wifi_manager_ap_destroy() + */ +int wifi_manager_ap_clone(wifi_manager_ap_h *cloned_ap, wifi_manager_ap_h origin); + +/** + * @brief Refreshes the access point information. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.get + * @remarks You should call this function in order to get the current access point information, because the information can be changed. + * @param[in] ap The access point handle + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_refresh(wifi_manager_ap_h ap); + +/** +* @} +*/ + + +/** +* @addtogroup CAPI_NETWORK_WIFI_MANAGER_AP_NETWORK_MODULE +* @{ +*/ + +/** + * @brief Gets ESSID (Extended Service Set Identifier). + * @since_tizen 3.0 + * @remarks You must release @a essid using free(). + * @param[in] ap The access point handle + * @param[out] essid The ESSID + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_essid(wifi_manager_ap_h ap, char **essid); + +/** + * @brief Gets BSSID (Basic Service Set Identifier). + * @since_tizen 3.0 + * @remarks You must release @a bssid using free(). + * @param[in] ap The access point handle + * @param[out] bssid The BSSID + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_bssid(wifi_manager_ap_h ap, char **bssid); + +/** + * @brief Gets the RSSI. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[out] rssi The RSSI + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_rssi(wifi_manager_ap_h ap, int *rssi); + +/** + * @brief Gets the frequency band (MHz). + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[out] frequency The frequency + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_frequency(wifi_manager_ap_h ap, int *frequency); + +/** + * @brief Gets the max speed (Mbps). + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[out] max_speed The max speed + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_max_speed(wifi_manager_ap_h ap, int *max_speed); + +/** + * @brief Checks whether the access point is favorite or not. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[out] favorite @c true if access point is favorite, + * otherwise @c false if access point is not favorite + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_is_favorite(wifi_manager_ap_h ap, bool *favorite); + +/** + * @brief Checks whether the access point is passpoint or not. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[out] passpoint @c true if access point is passpoint, + * otherwise @c false if access point is not passpoint. + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_is_passpoint(wifi_manager_ap_h ap, bool *passpoint); + +/** + * @brief Gets the connection state. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[out] state The connection state + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_connection_state(wifi_manager_ap_h ap, wifi_manager_connection_state_e *state); + +/** + * @brief Gets the config type of IP. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[in] address_family The address family + * @param[out] type The type of IP config + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED Address family not supported + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_ip_config_type(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, wifi_manager_ip_config_type_e *type); + +/** + * @brief Sets the config type of IP. + * @details If you set IP config type to #WIFI_MANAGER_IP_CONFIG_TYPE_STATIC, + * then IP address, Gateway and Subnet mask will be set to the initial value "0.0.0.0". + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[in] address_family The address family + * @param[in] type The type of IP config + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED Address family not supported + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @see wifi_manager_update_ap() + */ +int wifi_manager_ap_set_ip_config_type(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, wifi_manager_ip_config_type_e type); + +/** + * @brief Gets the IP address. + * @since_tizen 3.0 + * @remarks You must release @a ip_address using free(). + * @param[in] ap The access point handle + * @param[in] address_family The address family + * @param[out] ip_address The IP address + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED Address family not supported + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_ip_address(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, char **ip_address); + +/** + * @brief Sets the IP address. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[in] address_family The address family + * @param[in] ip_address The IP address; if you set this value to NULL, then the existing value will be deleted + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED Address family not supported + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @see wifi_manager_update_ap() + */ +int wifi_manager_ap_set_ip_address(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, const char *ip_address); + +/** + * @brief Gets the subnet mask. + * @since_tizen 3.0 + * @remarks You must release @a subnet_mask using free(). + * @param[in] ap The access point handle + * @param[in] address_family The address family + * @param[out] subnet_mask The subnet mask + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED Address family not supported + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_subnet_mask(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, char **subnet_mask); + +/** + * @brief Sets the subnet mask. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[in] address_family The address family + * @param[in] subnet_mask The subnet mask; if you set this value to NULL, then the existing value will be deleted + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED Address family not supported + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @see wifi_manager_update_ap() + */ +int wifi_manager_ap_set_subnet_mask(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, const char *subnet_mask); + +/** + * @brief Gets the gateway address. + * @since_tizen 3.0 + * @remarks You must release @a gateway_address using free(). + * @param[in] ap The access point handle + * @param[in] address_family The address family + * @param[out] gateway_address The gateway address + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED Address family not supported + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_gateway_address(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, char **gateway_address); + +/** + * @brief Sets the gateway address. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[in] address_family The address family + * @param[in] gateway_address The gateway address \n + * If you set this value to @c NULL, then the existing value will be deleted. + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED Address family not supported + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @see wifi_manager_update_ap() + */ +int wifi_manager_ap_set_gateway_address(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, const char *gateway_address); + +/** + * @brief Gets the proxy address. + * @since_tizen 3.0 + * @remarks You must release @a proxy_address using free(). + * @param[in] ap The access point handle + * @param[in] address_family The address family + * @param[out] proxy_address The proxy address + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED Address family not supported + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_proxy_address(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, char **proxy_address); + +/** + * @brief Sets the proxy address. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[in] address_family The address family + * @param[in] proxy_address The proxy address \n + * If you set this value to @c NULL, then the existing value will be deleted. + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED Address family not supported + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @see wifi_manager_update_ap() + */ +int wifi_manager_ap_set_proxy_address(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, const char *proxy_address); + +/** + * @brief Gets the Proxy type. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[out] proxy_type The type of proxy + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_proxy_type(wifi_manager_ap_h ap, + wifi_manager_proxy_type_e *proxy_type); + +/** + * @brief Sets the Proxy address. + * @details If you set Proxy type to #WIFI_MANAGER_PROXY_TYPE_AUTO or #WIFI_MANAGER_PROXY_TYPE_MANUAL, then Proxy will be restored. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[in] proxy_type The type of proxy + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @see wifi_manager_update_ap() + */ +int wifi_manager_ap_set_proxy_type(wifi_manager_ap_h ap, + wifi_manager_proxy_type_e proxy_type); + +/** + * @brief Gets the DNS address. + * @since_tizen 3.0 + * @remarks The allowance of DNS address is @c 2.You must release @a dns_address using free(). + * @param[in] ap The access point handle + * @param[in] order The order of DNS address; it starts from 1, which means first DNS address + * @param[in] address_family The address family + * @param[out] dns_address The DNS address + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED Address family not supported + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_dns_address(wifi_manager_ap_h ap, + int order, wifi_manager_address_family_e address_family, char **dns_address); + +/** + * @brief Sets the DNS address. + * @since_tizen 3.0 + * @remarks The allowance of DNS address is @c 2 \n + * @param[in] ap The access point handle + * @param[in] order The order of DNS address \n + * It starts from @c 1, which means first DNS address. + * @param[in] address_family The address family + * @param[in] dns_address The DNS address \n + * If you set this value to @c NULL, then the existing value will be deleted. + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED Address family not supported + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @see wifi_manager_update_ap() + */ +int wifi_manager_ap_set_dns_address(wifi_manager_ap_h ap, + int order, wifi_manager_address_family_e address_family, const char *dns_address); + +/** +* @} +*/ + + +/** +* @addtogroup CAPI_NETWORK_WIFI_MANAGER_AP_SECURITY_MODULE +* @{ +*/ + +/** + * @brief Gets the Wi-Fi security mode. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[out] type The type of Wi-Fi security + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_security_type(wifi_manager_ap_h ap, wifi_manager_security_type_e *type); + +/** + * @brief Sets the Wi-Fi security mode. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[in] type The type of Wi-Fi security + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_set_security_type(wifi_manager_ap_h ap, wifi_manager_security_type_e type); + +/** + * @brief Gets the Wi-Fi encryption type. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[out] type The type of Wi-Fi encryption + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_encryption_type(wifi_manager_ap_h ap, wifi_manager_encryption_type_e *type); + +/** + * @brief Sets the Wi-Fi encryption type. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[in] type The type of Wi-Fi encryption + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_set_encryption_type(wifi_manager_ap_h ap, wifi_manager_encryption_type_e type); + +/** + * @brief Checks whether the passphrase is required or not. + * @since_tizen 3.0 + * @remarks This function is not valid if security type is #WIFI_MANAGER_SECURITY_TYPE_EAP. + * @param[in] ap The access point handle + * @param[out] required @c true if passphrase is required, + * @c false if passphrase is not required. + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_is_passphrase_required(wifi_manager_ap_h ap, bool *required); + +/** + * @brief Sets the passphrase. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[in] passphrase The passphrase of access point + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_set_passphrase(wifi_manager_ap_h ap, const char *passphrase); + +/** + * @brief Checks whether the WPS(Wi-Fi Protected Setup) is supported or not. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[out] supported @c true if WPS is supported, + * otherwise @c false is WPS is not supported. + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @see wifi_manager_connect_by_wps_pbc() + * @see wifi_manager_connect_by_wps_pin() + */ +int wifi_manager_ap_is_wps_supported(wifi_manager_ap_h ap, bool *supported); + +/** +* @} +*/ + + +/** +* @addtogroup CAPI_NETWORK_WIFI_MANAGER_AP_SECURITY_EAP_MODULE +* @{ +*/ + +/** + * @brief Sets the passphrase of EAP. + * @details You can set one of @a user_name and @a password as @c NULL. + * In this case, the value of a parameter which is set as @c NULL will be the previous value. + * But it is not allowed that both @a user_name and @a password are set as @c NULL. + * @since_tizen 3.0 + * @remarks This function is valid only if the EAP type is #WIFI_MANAGER_EAP_TYPE_PEAP or #WIFI_MANAGER_EAP_TYPE_TTLS. + * @param[in] ap The access point handle + * @param[in] user_name The user name \n + * This value can be @c NULL. + * @param[in] password The password \n + * This value can be @c NULL. + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_set_eap_passphrase(wifi_manager_ap_h ap, const char *user_name, const char *password); + +/** + * @brief Gets the passphrase of EAP. + * @since_tizen 3.0 + * @remarks This function is valid only if the EAP type is #WIFI_MANAGER_EAP_TYPE_PEAP or #WIFI_MANAGER_EAP_TYPE_TTLS. + * You must release @a user_name using free(). + * @param[in] ap The access point handle + * @param[out] user_name The user name + * @param[out] is_password_set @c true if password is set, + * otherwise @c flase if password is not set. + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_eap_passphrase(wifi_manager_ap_h ap, char **user_name, bool *is_password_set); + +/** + * @brief Gets the CA Certificate of EAP. + * @since_tizen 3.0 + * @remarks This function is valid only if the EAP type is #WIFI_MANAGER_EAP_TYPE_TLS. + * You must release @a file using free(). + * @param[in] ap The access point handle + * @param[out] file The file path of CA Certificate + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_eap_ca_cert_file(wifi_manager_ap_h ap, char **file); + +/** + * @brief Sets the CA Certificate of EAP. + * @since_tizen 3.0 + * @remarks This function is valid only if the EAP type is #WIFI_MANAGER_EAP_TYPE_TLS. + * @param[in] ap The access point handle + * @param[in] file The file path of CA Certificate + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_set_eap_ca_cert_file(wifi_manager_ap_h ap, const char *file); + +/** + * @brief Gets the Client Certificate of EAP. + * @since_tizen 3.0 + * @remarks This function is valid only if the EAP type is #WIFI_MANAGER_EAP_TYPE_TLS. + * You must release @a file using free(). + * @param[in] ap The access point handle + * @param[out] file The file path of Client Certificate + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_eap_client_cert_file(wifi_manager_ap_h ap, char **file); + +/** + * @brief Sets the CA Certificate of EAP. + * @since_tizen 3.0 + * @remarks This function is valid only if the EAP type is #WIFI_MANAGER_EAP_TYPE_TLS. + * @param[in] ap The access point handle + * @param[in] file The file path of Client Certificate + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_set_eap_client_cert_file(wifi_manager_ap_h ap, const char *file); + +/** + * @brief Gets the private key file of EAP. + * @since_tizen 3.0 + * @remarks This function is valid only if the EAP type is #WIFI_MANAGER_EAP_TYPE_TLS. + * You must release @a file using free(). + * @param[in] ap The access point handle + * @param[out] file The file path of private key + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_eap_private_key_file(wifi_manager_ap_h ap, char **file); + +/** + * @brief Sets the private key information of EAP. + * @since_tizen 3.0 + * @remarks This function is valid only if the EAP type is #WIFI_MANAGER_EAP_TYPE_TLS. + * @param[in] ap The access point handle + * @param[in] file The file path of private key + * @param[in] password The password + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_set_eap_private_key_info(wifi_manager_ap_h ap, + const char *file, const char *password); + +/** + * @brief Gets the EAP type of Wi-Fi. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[out] type The type of EAP + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_eap_type(wifi_manager_ap_h ap, wifi_manager_eap_type_e *type); + +/** + * @brief Sets the EAP type of Wi-Fi. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[in] type The type of EAP + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_set_eap_type(wifi_manager_ap_h ap, wifi_manager_eap_type_e type); + +/** + * @brief Gets the type of EAP phase2 authentication of Wi-Fi. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[out] type The type of EAP phase2 authentication + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_get_eap_auth_type(wifi_manager_ap_h ap, wifi_manager_eap_auth_type_e *type); + +/** + * @brief Sets the type of EAP phase2 authentication of Wi-Fi. + * @since_tizen 3.0 + * @param[in] ap The access point handle + * @param[in] type The type of EAP phase2 authentication + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_ap_set_eap_auth_type(wifi_manager_ap_h ap, wifi_manager_eap_auth_type_e type); + +/** +* @} +*/ + +/** +* @addtogroup CAPI_NETWORK_WIFI_MANAGER_CONFIG_MODULE +* @{ +*/ + +/** + * @brief Gets access point configuration handle. + * @since_tizen 3.0 + * @remarks You must release @a config using wifi_manager_config_destroy(). + * + * @param[in] wifi The wifi handle + * @param[in] name The access point name + * @param[in] passphrase The access point passphrase + * @param[in] security_type The access point security type + * @param[out] config The access point configuration handle + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @see wifi_manager_config_destroy() + * @pre This API needs wifi_manager_initialize() before use + */ +int wifi_manager_config_create(wifi_manager_h wifi, const char *name, + const char *passphrase, wifi_manager_security_type_e security_type, wifi_manager_config_h *config); + +/** + * @brief Clones the access point configuration handle. + * @since_tizen 3.0 + * @remarks You must release @a cloned_config using wifi_manager_config_destroy(). + * + * @param[in] origin The origin access point configuration handle + * @param[out] cloned_config The cloned access point configuration handle + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @see wifi_manager_config_destroy() + */ +int wifi_manager_config_clone(wifi_manager_config_h origin, wifi_manager_config_h *cloned_config); + +/** + * @brief Destroys the access point configuration handle. + * @since_tizen 3.0 + * + * @param[in] config The access point configuration handle + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @see wifi_manager_config_create() + * @see wifi_manager_config_clone() + */ +int wifi_manager_config_destroy(wifi_manager_config_h config); + +/** + * @brief Saves Wi-Fi configuration of access point. + * @details When a configuration is changed, these changes will be not applied to the Connection Manager immediately.\n + * When you call this function, your changes affect the Connection Manager and the existing configuration is updated. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.profile + * + * @param[in] wifi The wifi handle + * @param[in] config The access point configuration handle + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @see wifi_manager_config_create() + */ +int wifi_manager_config_save(wifi_manager_h wifi, wifi_manager_config_h config); + +/** + * @brief Removes Wi-Fi configuration of access point. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.profile + * + * @param[in] wifi The wifi handle + * @param[in] config The access point configuration handle + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @see wifi_manager_config_create() + * @see wifi_manager_config_foreach_configuration() + */ +int wifi_manager_config_remove(wifi_manager_h wifi, wifi_manager_config_h config); + +/** + * @brief Gets configurations of an access point. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.profile + * + * @param[in] wifi The wifi handle + * @param[in] callback The callback to be called + * @param[in] user_data The user data passed to the callback function + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission denied + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @pre This API needs wifi_manager_initialize() before use. + * @post This function invokes wifi_manager_config_list_cb(). + */ +int wifi_manager_config_foreach_configuration(wifi_manager_h wifi, + wifi_manager_config_list_cb callback, void *user_data); + +/** + * @brief Gets the name of access point from configuration. + * @since_tizen 3.0 + * @remarks You must release @a name using free(). + * + * @param[in] config The access point configuration handle + * @param[out] name The name of access point + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_config_get_name(wifi_manager_config_h config, char **name); + +/** + * @brief Gets the security type of access point from configuration. + * @since_tizen 3.0 + * + * @param[in] config The access point configuration handle + * @param[out] security_type The security type of access point + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_config_get_security_type(wifi_manager_config_h config, + wifi_manager_security_type_e *security_type); + +/** + * @brief Sets access point proxy address configuration. + * @since_tizen 3.0 + * + * @param[in] config The access point configuration handle + * @param[in] address_family The address family + * @param[in] proxy_address The proxy address + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission denied + * @retval #WIFI_MANAGER_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED Not supported address family + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @see wifi_manager_config_save() + */ +int wifi_manager_config_set_proxy_address(wifi_manager_config_h config, + wifi_manager_address_family_e address_family, const char *proxy_address); + +/** + * @brief Gets the proxy address of access point from configuration. + * @since_tizen 3.0 + * @remarks You must release @a proxy_address using free(). + * + * @param[in] config The access point configuration handle + * @param[out] address_family The address family + * @param[out] proxy_address The proxy address + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OUT_OF_MEMORY Out of memory + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_config_get_proxy_address(wifi_manager_config_h config, + wifi_manager_address_family_e *address_family, char **proxy_address); + +/** + * @brief Sets the hidden property of access point from the configuration. + * @since_tizen 3.0 + * + * @param[in] config The access point configuration handle + * @param[in] is_hidden The new value of the hidden property + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + * @see wifi_manager_config_save() + */ +int wifi_manager_config_set_hidden_ap_property(wifi_manager_config_h config, bool is_hidden); + +/** + * @brief Gets the hidden property of access point from the configuration. + * @since_tizen 3.0 + * + * @param[in] config The access point configuration handle + * @param[out] is_hidden The hidden property of access point + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_config_get_hidden_ap_property(wifi_manager_config_h config, bool *is_hidden); + +/** + * @brief Gets access point anonymous identity from configuration. + * @since_tizen 3.0 + * @remarks You must release @a anonymous_identity using free(). + * + * @param[in] config The access point configuration handle + * @param[out] anonymous_identity The anonymous identity of access point + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + */ +int wifi_manager_config_get_eap_anonymous_identity(wifi_manager_config_h config, + char **anonymous_identity); + +/** + * @brief Sets access point anonymous identity to configuration. + * @since_tizen 3.0 + * + * @param[in] config The access point configuration handle + * @param[in] anonymous_identity The anonymous identity + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @see wifi_manager_config_save() + */ +int wifi_manager_config_set_eap_anonymous_identity(wifi_manager_config_h config, + const char *anonymous_identity); + +/** + * @brief Gets access point cacert file from configuration. + * @since_tizen 3.0 + * @remarks You must release @a ca_cert using free(). + * @remarks The mediastorage privilege http://tizen.org/privilege/mediastorage is needed \n + * if @a image_path is relevant to media storage.\n + * The externalstorage privilege http://tizen.org/privilege/externalstorage is needed \n + * if @a image_path is relevant to external storage. + * + * @param[in] config The access point configuration handle + * @param[out] ca_cert The certification authority(CA) certificates file of access point + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + */ +int wifi_manager_config_get_eap_ca_cert_file(wifi_manager_config_h config, char **ca_cert); + +/** + * @brief Sets access point cacert file to configuration. + * @since_tizen 3.0 + * @remarks The mediastorage privilege http://tizen.org/privilege/mediastorage is needed \n + * if @a image_path is relevant to media storage.\n + * The externalstorage privilege http://tizen.org/privilege/externalstorage is needed \n + * if @a image_path is relevant to external storage. + * + * @param[in] config The access point configuration handle + * @param[in] ca_cert The certification authority(CA) certificates file of access point + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @see wifi_manager_config_save() + */ +int wifi_manager_config_set_eap_ca_cert_file(wifi_manager_config_h config, const char *ca_cert); + +/** + * @brief Gets access point client cert file from configuration. + * @since_tizen 3.0 + * @remarks You must release @a client_crt using free(). + * + * @param[in] config The access point configuration handle + * @param[out] client_cert The certification authority(CA) certificates file of access point + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + */ +int wifi_manager_config_get_eap_client_cert_file(wifi_manager_config_h config, char **client_cert); + +/** + * @brief Sets access point client cert file to configuration. + * @since_tizen 3.0 + * + * @param[in] config The access point configuration handle + * @param[in] private_key The private key file + * @param[in] client_cert The certification authority(CA) certificates file of access point + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @see wifi_manager_config_save() + */ +int wifi_manager_config_set_eap_client_cert_file(wifi_manager_config_h config, + const char *private_key, const char *client_cert); + +/** + * @brief Gets access point identity from configuration. + * @since_tizen 3.0 + * @remarks You must release @a identity using free(). + * + * @param[in] config The access point configuration handle + * @param[out] identity The identity of access point + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + */ +int wifi_manager_config_get_eap_identity(wifi_manager_config_h config, char **identity); + +/** + * @brief Sets access point identity to configuration. + * @since_tizen 3.0 + * + * @param[in] config The access point configuration handle + * @param[in] identity The identity + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @see wifi_manager_config_save() + */ +int wifi_manager_config_set_eap_identity(wifi_manager_config_h config, const char *identity); + +/** + * @brief Gets access point EAP type from configuration. + * @since_tizen 3.0 + * + * @param[in] config The access point configuration handle + * @param[out] eap_type The EAP type of access point + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + */ +int wifi_manager_config_get_eap_type(wifi_manager_config_h config, wifi_manager_eap_type_e *eap_type); + +/** + * @brief Sets access point EAP type to configuration. + * @since_tizen 3.0 + * + * @param[in] config The access point configuration handle + * @param[in] eap_type The EAP type + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @see wifi_manager_config_save() + */ +int wifi_manager_config_set_eap_type(wifi_manager_config_h config, wifi_manager_eap_type_e eap_type); + +/** + * @brief Gets access point EAP auth type from configuration. + * @since_tizen 3.0 + * + * @param[in] config The access point configuration handle + * @param[out] eap_auth_type The EAP auth type of access point + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + */ +int wifi_manager_config_get_eap_auth_type(wifi_manager_config_h config, + wifi_manager_eap_auth_type_e *eap_auth_type); + +/** + * @brief Sets access point EAP auth type to configuration. + * @since_tizen 3.0 + * + * @param[in] config The access point configuration handle + * @param[in] eap_auth_type The EAP auth type + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @see wifi_manager_config_save() + */ +int wifi_manager_config_set_eap_auth_type(wifi_manager_config_h config, + wifi_manager_eap_auth_type_e eap_auth_type); + +/** + * @brief Gets access point subject match from configuration. + * @since_tizen 3.0 + * @remarks You must release @a subject_match using free(). + * + * @param[in] config The access point configuration handle + * @param[out] subject_match The subject match of access point + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + */ +int wifi_manager_config_get_eap_subject_match(wifi_manager_config_h config, + char **subject_match); + +/** + * @brief Sets access point subject match to configuration. + * @since_tizen 3.0 + * + * @param[in] config The access point configuration handle + * @param[in] subject_match The subject match + * + * @return 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @see wifi_manager_config_save() + */ +int wifi_manager_config_set_eap_subject_match(wifi_manager_config_h config, + const char *subject_match); + +/** + * @} + */ + +/** + * @addtogroup CAPI_NETWORK_WIFI_MANAGER_TDLS_MODULE + * @{ + */ + +/** + * @brief Disconnects the connected peer. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.set + * + * @param[in] wifi The wifi handle + * @param[in] peer_mac_addr The MAC address of the connected peer + * + * @return @c 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_tdls_disconnect(wifi_manager_h wifi, const char *peer_mac_addr); + +/** + * @brief Gets Peer Mac address of Connected peer. + * @since_tizen 3.0 + * @privlevel public + * @privilege %http://tizen.org/privilege/network.get + * + * @remarks The @a peer_mac_addr should be freed using free(). + * @param[in] wifi The wifi handle + * @param[out] peer_mac_addr The MAC address of the connected peer + * + * @return @c 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_OPERATION_FAILED Operation failed + * @retval #WIFI_MANAGER_ERROR_NO_CONNECTION No active TDLS Connection + * @retval #WIFI_MANAGER_ERROR_PERMISSION_DENIED Permission Denied + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_tdls_get_connected_peer(wifi_manager_h wifi, char **peer_mac_addr); + +/** + * @brief Registers the callback called when TDLS state is changed. + * @since_tizen 3.0 + * + * @param[in] wifi The wifi handle + * @param[in] callback The callback function to be called + * @param[in] user_data The user data passed to the callback function + * + * @return @c 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_tdls_set_state_changed_cb(wifi_manager_h wifi, + wifi_manager_tdls_state_changed_cb callback, void *user_data); + +/** + * @brief Unregisters the callback called when TDLS state is changed. + * @since_tizen 3.0 + * + * @param[in] wifi The wifi handle + * @return @c 0 on success, otherwise negative error value + * @retval #WIFI_MANAGER_ERROR_NONE Successful + * @retval #WIFI_MANAGER_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #WIFI_MANAGER_ERROR_INVALID_OPERATION Invalid operation + * @retval #WIFI_MANAGER_ERROR_NOT_SUPPORTED Not supported + */ +int wifi_manager_tdls_unset_state_changed_cb(wifi_manager_h wifi); + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif /* __TIZEN_WIFI_MANAGER_H__ */ diff --git a/include/wifi_internal.h b/include/wifi_internal.h new file mode 100755 index 0000000..3849fba --- /dev/null +++ b/include/wifi_internal.h @@ -0,0 +1,242 @@ +/* + * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __WIFI_INTERNAL_H__ +#define __WIFI_INTERNAL_H__ + +#include +#include +#include +#include + +#include "wifi-manager.h" +#include "network_interface.h" + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +#undef LOG_TAG +#define LOG_TAG "WIFI_MANAGER" + +#define WIFI_INFO 1 +#define WIFI_ERROR 2 +#define WIFI_WARN 3 + +#define WIFI_FEATURE "http://tizen.org/feature/network.wifi" +#define WIFI_TDLS_FEATURE "http://tizen.org/feature/network.wifi.tdls" + +#define WIFI_CONFIG_NAME "Name" +#define WIFI_CONFIG_SSID "SSID" +#define WIFI_CONFIG_PASSPHRASE "Passphrase" +#define WIFI_CONFIG_SECURITY_TYPE "Security" +#define WIFI_CONFIG_PROXYADDRESS "ProxyAddress" +#define WIFI_CONFIG_HIDDEN "Hidden" +#define WIFI_CONFIG_FAILURE "Failure" +#define WIFI_CONFIG_EAP_ANONYMOUS_IDENTITY "AnonymousIdentity" +#define WIFI_CONFIG_EAP_CACERT "CACertFile" +#define WIFI_CONFIG_EAP_CLIENTCERT "ClientCertFile" +#define WIFI_CONFIG_EAP_PRIVATEKEY "PrivateKeyFile" +#define WIFI_CONFIG_EAP_IDENTITY "Identity" +#define WIFI_CONFIG_EAP_TYPE "EapType" +#define WIFI_CONFIG_EAP_AUTH_TYPE "EapAuthType" +#define WIFI_CONFIG_EAP_SUBJECT_MATCH "SubjectMatch" + +typedef enum { + WIFI_SUPPORTED_FEATURE_WIFI, + WIFI_SUPPORTED_FEATURE_WIFI_TDLS, + WIFI_SUPPORTED_FEATURE_MAX, +} wifi_supported_feature_e; + + +#define CHECK_FEATURE_SUPPORTED(...) \ + do { \ + int rv = _wifi_check_feature_supported(__VA_ARGS__, NULL); \ + if (rv != WIFI_MANAGER_ERROR_NONE) \ + return rv; \ + } while (0) + +#define WIFI_LOG(log_level, format, args...) \ + do { \ + switch (log_level) { \ + case WIFI_ERROR: \ + LOGE(format, ## args); \ + break; \ + case WIFI_WARN: \ + LOGW(format, ## args); \ + break; \ + default: \ + LOGI(format, ## args); \ + } \ + } while (0) + +typedef enum { + WIFI_DEVICE_STATE_CB, + WIFI_BG_SCAN_CB, + WIFI_SCAN_REQUEST_CB, + WIFI_SPECIFIC_SCAN_CB, + WIFI_MANAGER_CONNECTION_STATE_CB, + WIFI_ACTIVATED_CB, + WIFI_DEACTIVATED_CB, + WIFI_CONNECTED_CB, + WIFI_DISCONNECTED_CB, + WIFI_MANAGER_RSSI_LEVEL_CHANGED_CB, + WIFI_MANAGER_TDLS_STATE_CHANGED_CB, +} wifi_manager_handle_cb_e; + +typedef struct { + int count; + net_profile_info_s *profiles; +} wifi_profile_list_s; + +typedef struct { + GSourceFunc func; + gpointer user_data; + guint id; +} wifi_managed_idle_data_s; + +typedef struct { + gchar *ca_cert; + gchar *private_key; + gchar *client_cert; + gchar *anonymous_identity; + gchar *identity; + gchar *subject_match; + wifi_manager_eap_type_e eap_type; + wifi_manager_eap_auth_type_e eap_auth_type; +} wifi_eap_config_s; + +typedef struct { + gchar *name; + gchar *passphrase; + wifi_manager_security_type_e security_type; + gboolean is_saved; + + gboolean is_hidden; + gchar *proxy_address; + wifi_manager_address_family_e address_family; + wifi_eap_config_s *eap_config; + wifi_manager_error_e last_error; +} wifi_config_s; + +typedef struct { + wifi_manager_device_state_changed_cb device_state_cb; + void *device_state_user_data; + wifi_manager_scan_finished_cb bg_scan_cb; + void *bg_scan_user_data; + wifi_manager_scan_finished_cb scan_request_cb; + void *scan_request_user_data; + wifi_manager_scan_finished_cb specific_scan_cb; + void *specific_scan_user_data; + wifi_manager_connection_state_changed_cb connection_state_cb; + void *connection_state_user_data; + wifi_manager_activated_cb activated_cb; + void *activated_user_data; + wifi_manager_deactivated_cb deactivated_cb; + void *deactivated_user_data; + wifi_manager_connected_cb connected_cb; + void *connected_user_data; + wifi_manager_disconnected_cb disconnected_cb; + void *disconnected_user_data; + + wifi_manager_rssi_level_changed_cb rssi_level_changed_cb; + void *rssi_level_changed_user_data; + wifi_manager_tdls_state_changed_cb tdls_state_changed_cb; + void *tdls_state_changed_user_data; +} wifi_manager_handle_s; + +/* WIFI Manager */ +int _wifi_init(void); +bool _wifi_deinit(void); + +int _wifi_create_handle(wifi_manager_h *wifi); +int _wifi_add_to_handle_list(wifi_manager_h* wifi); +void _wifi_remove_from_handle_list(wifi_manager_h wifi); +bool _wifi_find_from_handle_list(wifi_manager_h wifi); +int _wifi_get_count_from_handle_list(void); +int _wifi_get_callback_count_from_handle_list(wifi_manager_handle_cb_e e); + +int _wifi_activate(wifi_manager_h wifi, wifi_manager_activated_cb callback, + gboolean wifi_picker_test, void *user_data); +int _wifi_deactivate(wifi_manager_h wifi, wifi_manager_deactivated_cb callback, void *user_data); + +bool _wifi_check_ap_validity(wifi_manager_ap_h ap_h); +void _wifi_add_to_ap_list(wifi_manager_ap_h ap_h); +void _wifi_remove_from_ap_list(wifi_manager_ap_h ap_h); +bool _wifi_check_profile_name_validity(const char *profile_name); + +int _wifi_get_wifi_device_state(wifi_manager_device_state_e *device_state); +int _wifi_get_wifi_state(wifi_manager_connection_state_e* connection_state); +int _wifi_get_intf_name(char** name); +int _wifi_scan_request(wifi_manager_h wifi, + wifi_manager_scan_finished_cb callback, void *user_data); +int _wifi_scan_specific_ap(wifi_manager_h wifi, const char *essid, + wifi_manager_scan_finished_cb callback, void *user_data); +int _wifi_get_connected_profile(wifi_manager_ap_h *ap); +int _wifi_foreach_found_ap(wifi_manager_found_ap_cb callback, void *user_data); +int _wifi_foreach_found_specific_ap(wifi_manager_found_ap_cb callback, void *user_data); + +int _wifi_open_profile(wifi_manager_h wifi, wifi_manager_ap_h ap_h, + wifi_manager_connected_cb callback, void *user_data); +int _wifi_close_profile(wifi_manager_h wifi, wifi_manager_ap_h ap_h, + wifi_manager_disconnected_cb callback, void *user_data); +int _wifi_connect_with_wps_pbc(wifi_manager_h wifi, wifi_manager_ap_h ap, + wifi_manager_connected_cb callback, void *user_data); +int _wifi_connect_with_wps_pin(wifi_manager_h wifi, wifi_manager_ap_h ap, + const char *pin, wifi_manager_connected_cb callback, void *user_data); +int _wifi_forget_ap(wifi_manager_ap_h ap); + +void _wifi_rssi_level_changed_cb(keynode_t *node, void *user_data); + +int _wifi_update_ap_info(net_profile_info_s *ap_info); +wifi_manager_connection_state_e _wifi_convert_to_ap_state(net_state_type_e state); + +/* WIFI Configuration */ +bool _wifi_check_config_validity(wifi_manager_config_h config_h); +void _wifi_add_to_config_list(wifi_manager_config_h config_h); +void _wifi_remove_from_config_list(wifi_manager_config_h config_h); +gchar * _wifi_config_get_config_id(const gchar *name, wifi_manager_security_type_e security_type); +int _wifi_config_get_config_id_list(GSList **list); + +int _wifi_save_configuration(const gchar *name, const gchar *passphrase, + wifi_manager_security_type_e security_type, const gchar *proxy_address, gboolean is_hidden); +int _wifi_load_configurations(void); +int _wifi_foreach_configuration(wifi_manager_config_list_cb callback, void *user_data); +int _wifi_remove_configuration(const gchar *config_id); +int _wifi_configuration_set_field(const gchar *config_id, const gchar *key, const gchar *value); +int _wifi_configuration_get_passphrase(const gchar *config_id, gchar **passphrase); +int _wifi_save_eap_configurations(const gchar *name, const gchar *passphrase, + wifi_manager_security_type_e security_type, const gchar *proxy_address, + wifi_eap_config_s *eap_config, gboolean is_hidden); +gchar *_wifi_eap_type_to_string(wifi_manager_eap_type_e eap_type); +gchar *_wifi_eap_auth_type_to_string(wifi_manager_eap_auth_type_e eap_auth_type); + +/* WIFI Privilege Check */ +int _wifi_check_get_privilege(); +int _wifi_check_profile_privilege(); + +/* WIFI Feature Check */ +bool __check_feature_supported(const char *key, wifi_supported_feature_e feature); +int _wifi_check_feature_supported(const char *feature_name, ...); + +/* WIFI Handle Check */ +bool __wifi_check_handle_validity(wifi_manager_h wifi); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* __WIFI_INTERNAL_H__ */ diff --git a/packaging/capi-network-wifi-manager.spec b/packaging/capi-network-wifi-manager.spec new file mode 100755 index 0000000..56797a7 --- /dev/null +++ b/packaging/capi-network-wifi-manager.spec @@ -0,0 +1,80 @@ +Name: capi-network-wifi-manager +Summary: Network Wi-Fi library in TIZEN C API +Version: 1.0.1 +Release: 1 +Group: System/Network +License: Apache-2.0 +Source0: %{name}-%{version}.tar.gz +BuildRequires: cmake +BuildRequires: pkgconfig(dlog) +BuildRequires: pkgconfig(vconf) +BuildRequires: pkgconfig(glib-2.0) +BuildRequires: pkgconfig(gio-2.0) +BuildRequires: pkgconfig(gthread-2.0) +BuildRequires: pkgconfig(capi-base-common) +BuildRequires: pkgconfig(capi-system-info) +Requires(post): /sbin/ldconfig +Requires(postun): /sbin/ldconfig + +%if "%{profile}" == "wearable" +BuildRequires: pkgconfig(capi-appfw-application) +%endif + +%description +Network Wi-Fi Manager library in Tizen C API + +%package devel +Summary: Network Wi-Fi Manager library in Tizen C API (Development) +Group: System/Network +Requires: %{name} = %{version}-%{release} + +%description devel +Network Wi-Fi Manager library in Tizen C API (Development) + +%prep +%setup -q + + +%build +export CFLAGS+=' -Wno-unused-local-typedefs' +MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'` +cmake -DCMAKE_INSTALL_PREFIX=/usr -DFULLVER=%{version} -DMAJORVER=${MAJORVER} \ + -DLIB_PATH=%{_lib} \ +%if "%{profile}" == "wearable" + -DTIZEN_WEARABLE=1 \ +%else +%if "%{profile}" == "mobile" + -DTIZEN_MOBILE=1 \ +%else +%if "%{profile}" == "tv" + -DTIZEN_TV=1 \ +%endif +%endif +%endif + . + +make %{?_smp_mflags} + + +%install +%make_install + +#License +mkdir -p %{buildroot}%{_datadir}/license +cp LICENSE %{buildroot}%{_datadir}/license/capi-network-wifi-manager + +%post -p /sbin/ldconfig + +%postun -p /sbin/ldconfig + + +%files +%manifest capi-network-wifi-manager.manifest +%attr(644,-,-) %{_libdir}/libcapi-network-wifi-manager.so.* +%{_datadir}/license/capi-network-wifi-manager +%{_bindir}/wifi_manager_test + +%files devel +%{_includedir}/network/*.h +%{_libdir}/pkgconfig/*.pc +%{_libdir}/libcapi-network-wifi-manager.so diff --git a/src/network_dbus.c b/src/network_dbus.c new file mode 100755 index 0000000..e9eac58 --- /dev/null +++ b/src/network_dbus.c @@ -0,0 +1,2418 @@ +/* + * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include "wifi_internal.h" +#include "network_internal.h" +#include "network_dbus.h" + +#define DBUS_REPLY_TIMEOUT (120 * 1000) + +#define WIFI_SECURITY_NONE "none" +#define WIFI_SECURITY_WEP "wep" +#define WIFI_SECURITY_WPA_PSK "psk" +#define WIFI_SECURITY_EAP "ieee8021x" + +extern __thread network_info_s NetworkInfo; +extern __thread network_request_table_s request_table[NETWORK_REQUEST_TYPE_MAX]; + +//LCOV_EXCL_START +static int __net_error_string_to_enum(const char *error) +{ + WIFI_LOG(WIFI_INFO, "Passed error value [%s]", error); + + if (NULL != strstr(error, "NoReply")) + return NET_ERR_TIME_OUT; + else if (NULL != strstr(error, "Failed")) + return NET_ERR_UNKNOWN; + else if (NULL != strstr(error, "UnknownMethod")) + return NET_ERR_UNKNOWN_METHOD; + else if (NULL != strstr(error, "InvalidArguments")) + return NET_ERR_INVALID_PARAM; + else if (NULL != strstr(error, "AccessDenied")) + return NET_ERR_ACCESS_DENIED; + else if (NULL != strstr(error, "PermissionDenied")) + return NET_ERR_ACCESS_DENIED; + else if (NULL != strstr(error, "PassphraseRequired")) + return NET_ERR_INVALID_OPERATION; + else if (NULL != strstr(error, "NotRegistered")) + return NET_ERR_INVALID_OPERATION; + else if (NULL != strstr(error, "NotUnique")) + return NET_ERR_INVALID_OPERATION; + else if (NULL != strstr(error, "NotSupported")) + return NET_ERR_NOT_SUPPORTED; + else if (NULL != strstr(error, "NotImplemented")) + return NET_ERR_NOT_SUPPORTED; + else if (NULL != strstr(error, "NotFound")) + return NET_ERR_NOT_SUPPORTED; + else if (NULL != strstr(error, "NoCarrier")) + return NET_ERR_NOT_SUPPORTED; + else if (NULL != strstr(error, "InProgress")) + return NET_ERR_IN_PROGRESS; + else if (NULL != strstr(error, "AlreadyExists")) + return NET_ERR_INVALID_OPERATION; + else if (NULL != strstr(error, "AlreadyEnabled")) + return NET_ERR_INVALID_OPERATION; + else if (NULL != strstr(error, "AlreadyDisabled")) + return NET_ERR_INVALID_OPERATION; + else if (NULL != strstr(error, "AlreadyConnected")) + return NET_ERR_ACTIVE_CONNECTION_EXISTS; + else if (NULL != strstr(error, "NotConnected")) + return NET_ERR_NO_ACTIVE_CONNECTIONS; + else if (NULL != strstr(error, "OperationAborted")) + return NET_ERR_OPERATION_ABORTED; + else if (NULL != strstr(error, "OperationTimeout")) + return NET_ERR_TIME_OUT; + else if (NULL != strstr(error, "InvalidService")) + return NET_ERR_NO_SERVICE; + else if (NULL != strstr(error, "InvalidProperty")) + return NET_ERR_INVALID_OPERATION; + else if (NULL != strstr(error, "NoProfile")) + return NET_ERR_NO_PROFILE; + return NET_ERR_UNKNOWN; +} + +static int __net_netconfig_error_string_to_enum(const char* error) +{ + WIFI_LOG(WIFI_ERROR, "Passed error value [%s]", error); + + if (error == NULL) + return NET_ERR_UNKNOWN; + + if (NULL != strstr(error, "WifiDriverFailed")) + return NET_ERR_WIFI_DRIVER_FAILURE; + else if (NULL != strstr(error, "PermissionDenied")) + return NET_ERR_SECURITY_RESTRICTED; + else if (NULL != strstr(error, "InProgress")) + return NET_ERR_WIFI_DRIVER_LOAD_INPROGRESS; + else if (NULL != strstr(error, "AccessDenied")) + return NET_ERR_ACCESS_DENIED; + else if (NULL != strstr(error, "NoProfile")) + return NET_ERR_NO_PROFILE; + return NET_ERR_UNKNOWN; +} + +static net_wifi_security_type_e __net_wifi_security_type_to_int(const gchar *type) +{ + net_wifi_security_type_e ret = WIFI_SEC_NONE; + + if (type == NULL) + return ret; + + if (g_strcmp0(type, WIFI_SECURITY_NONE) == 0) + ret = WIFI_SEC_NONE; + else if (g_strcmp0(type, WIFI_SECURITY_WEP) == 0) + ret = WIFI_SEC_WEP; + else if (g_strcmp0(type, WIFI_SECURITY_WPA_PSK) == 0) + ret = WIFI_SEC_WPA_PSK; + else if (g_strcmp0(type, WIFI_SECURITY_EAP) == 0) + ret = WIFI_SEC_EAP; + else + WIFI_LOG(WIFI_ERROR, "Not supported type (%s)", type); + + return ret; +} + +static int __net_wifi_last_error_to_enum(const gchar *last_error) +{ + wifi_manager_error_e ret = WIFI_MANAGER_ERROR_OPERATION_FAILED; + + if (g_strcmp0(last_error, "ERROR_NONE") == 0) { + ret = WIFI_MANAGER_ERROR_NONE; + } else if (g_strcmp0(last_error, "invalid-key") == 0) { + ret = WIFI_MANAGER_ERROR_INVALID_KEY; + } else if (g_strcmp0(last_error, "dhcp-failed") == 0) { + ret = WIFI_MANAGER_ERROR_DHCP_FAILED; + } else { + WIFI_LOG(WIFI_ERROR, "Not supported error type (%s)", last_error); + ret = WIFI_MANAGER_ERROR_NONE; + } + + return ret; +} + +gchar *__net_wifi_eap_type_to_string(net_wifi_eap_type_e eap_type) +{ + gchar *type = NULL; + + switch (eap_type) { + case WIFI_MANAGER_EAP_PEAP: + type = g_strdup("PEAP"); + break; + case WIFI_MANAGER_EAP_TLS: + type = g_strdup("TLS"); + break; + case WIFI_MANAGER_EAP_TTLS: + type = g_strdup("TTLS"); + break; + case WIFI_MANAGER_EAP_SIM: + type = g_strdup("SIM"); + break; + case WIFI_MANAGER_EAP_AKA: + type = g_strdup("AKA"); + break; + } + return type; +} + +gchar *__net_wifi_eap_auth_type_to_string(net_wifi_eap_auth_type_e eap_auth_type) +{ + gchar *type = NULL; + + switch (eap_auth_type) { + case WIFI_MANAGER_EAP_AUTH_PAP: + type = g_strdup("PAP"); + break; + case WIFI_MANAGER_EAP_AUTH_MSCHAP: + type = g_strdup("MSCHAP"); + break; + case WIFI_MANAGER_EAP_AUTH_MSCHAPV2: + type = g_strdup("MSCHAPV2"); + break; + case WIFI_MANAGER_EAP_AUTH_GTC: + type = g_strdup("GTC"); + break; + case WIFI_MANAGER_EAP_AUTH_MD5: + type = g_strdup("MD5"); + break; + default: + case WIFI_MANAGER_EAP_AUTH_NONE: + type = NULL; + break; + } + return type; +} + +net_wifi_eap_type_e __net_wifi_eap_type_to_int(const gchar *type) +{ + net_wifi_eap_type_e ret = -1; + + if (type == NULL) + return ret; + + if (g_strcmp0(type, "PEAP") == 0) + ret = WIFI_MANAGER_EAP_PEAP; + else if (g_strcmp0(type, "TLS") == 0) + ret = WIFI_MANAGER_EAP_TLS; + else if (g_strcmp0(type, "TTLS") == 0) + ret = WIFI_MANAGER_EAP_TTLS; + else if (g_strcmp0(type, "SIM") == 0) + ret = WIFI_MANAGER_EAP_SIM; + else if (g_strcmp0(type, "AKA") == 0) + ret = WIFI_MANAGER_EAP_AKA; + else + WIFI_LOG(WIFI_ERROR, "Not supported type (%s)", type); + + return ret; +} + +static net_wifi_eap_auth_type_e __net_wifi_eap_auth_type_to_int(const gchar *type) +{ + net_wifi_eap_auth_type_e ret = WIFI_MANAGER_EAP_AUTH_TYPE_NONE; + + if (type == NULL) + return ret; + + if (g_strcmp0(type, "PAP") == 0) + ret = WIFI_MANAGER_EAP_AUTH_PAP; + else if (g_strcmp0(type, "MSCHAP") == 0) + ret = WIFI_MANAGER_EAP_AUTH_MSCHAP; + else if (g_strcmp0(type, "MSCHAPV2") == 0) + ret = WIFI_MANAGER_EAP_AUTH_MSCHAPV2; + else if (g_strcmp0(type, "GTC") == 0) + ret = WIFI_MANAGER_EAP_AUTH_GTC; + else if (g_strcmp0(type, "MD5") == 0) + ret = WIFI_MANAGER_EAP_AUTH_MD5; + else + WIFI_LOG(WIFI_ERROR, "Not supported type (%s)", type); + + return ret; +} + +static void __net_open_connection_reply(GObject *source_object, GAsyncResult *res, gpointer user_data) +{ + __NETWORK_FUNC_ENTER__; + + net_event_info_s event_data = { 0, }; + net_profile_info_s prof_info; + network_request_table_s *open_info = + &request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION]; + network_request_table_s *wps_info = + &request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS]; + GDBusConnection *conn = NULL; + GError *error = NULL; + net_err_e Error = NET_ERR_NONE; + + WIFI_LOG(WIFI_INFO, "__net_open_connection_reply() called"); + + conn = G_DBUS_CONNECTION(source_object); + g_dbus_connection_call_finish(conn, res, &error); + + if (error != NULL) { + Error = __net_error_string_to_enum(error->message); + g_error_free(error); + } + + if (Error == NET_ERR_NONE) + goto done; + + WIFI_LOG(WIFI_ERROR, "Connection open failed[%d]", Error); + + if (open_info->flag == TRUE) { + g_strlcpy(event_data.ProfileName, open_info->ProfileName, + NET_PROFILE_NAME_LEN_MAX + 1); + memset(open_info, 0, sizeof(network_request_table_s)); + + event_data.Error = Error; + + if (Error == NET_ERR_ACTIVE_CONNECTION_EXISTS) { + Error = net_get_profile_info(event_data.ProfileName, &prof_info); + + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Fail to get profile info[%s]", + _net_print_error(Error)); + + event_data.Datalength = 0; + event_data.Data = NULL; + } else { + event_data.Datalength = sizeof(net_profile_info_s); + event_data.Data = &prof_info; + } + } + + event_data.Event = NET_EVENT_OPEN_RSP; + WIFI_LOG(WIFI_INFO, "Sending NET_EVENT_OPEN_RSP Error[%s]", + _net_print_error(event_data.Error)); + } else if (wps_info->flag == TRUE) { + g_strlcpy(event_data.ProfileName, wps_info->ProfileName, + NET_PROFILE_NAME_LEN_MAX + 1); + memset(wps_info, 0, sizeof(network_request_table_s)); + + event_data.Error = Error; + + if (Error == NET_ERR_ACTIVE_CONNECTION_EXISTS) { + Error = net_get_profile_info(event_data.ProfileName, &prof_info); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Fail to get profile info[%s]", + _net_print_error(Error)); + + event_data.Datalength = 0; + event_data.Data = NULL; + } else { + event_data.Datalength = sizeof(net_profile_info_s); + event_data.Data = &prof_info; + } + } + + event_data.Event = NET_EVENT_WIFI_WPS_RSP; + + WIFI_LOG(WIFI_INFO, "Sending NET_EVENT_WIFI_WPS_RSP Error[%s]", + _net_print_error(event_data.Error)); + } else { + _net_dbus_pending_call_unref(); + + __NETWORK_FUNC_EXIT__; + return; + } + +done: + _net_dbus_pending_call_unref(); + + _net_client_callback(&event_data); + + __NETWORK_FUNC_EXIT__; +} + +static void __net_close_connection_reply(GObject *source_object, GAsyncResult *res, gpointer user_data) +{ + __NETWORK_FUNC_ENTER__; + + WIFI_LOG(WIFI_INFO, "__net_close_connection_reply() called"); + + net_event_info_s event_data = { 0, }; + network_request_table_s *close_info = + &request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION]; + + GDBusConnection *conn = NULL; + GError *error = NULL; + net_err_e Error = NET_ERR_NONE; + + conn = G_DBUS_CONNECTION(source_object); + g_dbus_connection_call_finish(conn, res, &error); + if (error != NULL) { + Error = __net_error_string_to_enum(error->message); + g_error_free(error); + } + + if (Error == NET_ERR_NONE) + goto done; + + WIFI_LOG(WIFI_ERROR, "Connection close failed[%d]", Error); + + if (close_info->flag == TRUE) { + g_strlcpy(event_data.ProfileName, close_info->ProfileName, + NET_PROFILE_NAME_LEN_MAX + 1); + memset(close_info, 0, sizeof(network_request_table_s)); + + event_data.Error = Error; + event_data.Datalength = 0; + event_data.Data = NULL; + event_data.Event = NET_EVENT_CLOSE_RSP; + + WIFI_LOG(WIFI_INFO, "Sending NET_EVENT_CLOSE_RSP Error[%s]", + _net_print_error(event_data.Error)); + } else { + _net_dbus_pending_call_unref(); + + __NETWORK_FUNC_EXIT__; + return; + } + +done: + _net_dbus_pending_call_unref(); + + _net_client_callback(&event_data); + + __NETWORK_FUNC_EXIT__; +} + +static void __net_wifi_power_reply(GObject *source_object, GAsyncResult *res, gpointer user_data) +{ + __NETWORK_FUNC_ENTER__; + + GDBusConnection *conn = NULL; + GError *error = NULL; + net_err_e Error = NET_ERR_NONE; + net_event_info_s event_data = { 0, }; + + WIFI_LOG(WIFI_INFO, "__net_wifi_power_reply() called"); + + conn = G_DBUS_CONNECTION(source_object); + g_dbus_connection_call_finish(conn, res, &error); + if (error != NULL) { + Error = __net_netconfig_error_string_to_enum(error->message); + g_error_free(error); + } + + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, + "Wi-Fi power operation failed. Error [%d]", Error); + + if (Error != NET_ERR_WIFI_DRIVER_LOAD_INPROGRESS) { + if (request_table[NETWORK_REQUEST_TYPE_WIFI_POWER].flag == TRUE) { + memset(&request_table[NETWORK_REQUEST_TYPE_WIFI_POWER], + 0, sizeof(network_request_table_s)); + + event_data.Event = NET_EVENT_WIFI_POWER_RSP; + + WIFI_LOG(WIFI_INFO, + "Sending NET_EVENT_WIFI_POWER_RSP Wi-Fi: %d Error = %d", + NetworkInfo.wifi_state, Error); + + event_data.Datalength = sizeof(net_wifi_state_e); + event_data.Data = &(NetworkInfo.wifi_state); + event_data.Error = Error; + } + } + } else { + _net_dbus_pending_call_unref(); + + __NETWORK_FUNC_EXIT__; + return; + } + + _net_dbus_pending_call_unref(); + + _net_client_callback(&event_data); + + __NETWORK_FUNC_EXIT__; +} + +static void __net_specific_scan_wifi_reply(GObject *source_object, GAsyncResult *res, gpointer user_data) +{ + __NETWORK_FUNC_ENTER__; + + GDBusConnection *conn = NULL; + GError *error = NULL; + net_err_e Error = NET_ERR_NONE; + net_event_info_s event_data = { 0, }; + + conn = G_DBUS_CONNECTION(source_object); + g_dbus_connection_call_finish(conn, res, &error); + if (error != NULL) { + Error = __net_netconfig_error_string_to_enum(error->message); + g_error_free(error); + } + + if (Error != NET_ERR_NONE) + WIFI_LOG(WIFI_ERROR, "Find specific AP failed[%d]", Error); + else + WIFI_LOG(WIFI_INFO, "Specific AP found"); + + if (request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN].flag == TRUE) { + if (NET_ERR_NONE != Error) { + /* An error occurred. + * So lets reset specific scan request entry in the request table */ + memset(&request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN], + 0, sizeof(network_request_table_s)); + } + + event_data.Event = NET_EVENT_WIFI_SPECIFIC_SCAN_RSP; + + WIFI_LOG(WIFI_INFO, + "Sending NET_EVENT_SPECIFIC_SCAN_RSP Wi-Fi: %d Error[%d]", + NetworkInfo.wifi_state, Error); + + event_data.Datalength = sizeof(net_wifi_state_e); + event_data.Data = &(NetworkInfo.wifi_state); + event_data.Error = Error; + + _net_dbus_pending_call_unref(); + _net_client_callback(&event_data); + } else { + _net_dbus_pending_call_unref(); + __NETWORK_FUNC_EXIT__; + return; + } + + __NETWORK_FUNC_EXIT__; +} + +static void __net_wps_scan_wifi_reply(GObject *source_object, GAsyncResult *res, gpointer user_data) +{ + __NETWORK_FUNC_ENTER__; + + GDBusConnection *conn = NULL; + GError *error = NULL; + net_err_e Error = NET_ERR_NONE; + net_event_info_s event_data = { 0, }; + + conn = G_DBUS_CONNECTION(source_object); + g_dbus_connection_call_finish(conn, res, &error); + if (error != NULL) { + Error = __net_netconfig_error_string_to_enum(error->message); + g_error_free(error); + } + + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "WPS scan failed[%d]", Error); + + if (request_table[NETWORK_REQUEST_TYPE_WPS_SCAN].flag == TRUE) { + memset(&request_table[NETWORK_REQUEST_TYPE_WPS_SCAN], + 0, sizeof(network_request_table_s)); + + event_data.Event = NET_EVENT_WIFI_WPS_SCAN_IND; + event_data.Datalength = 0; + event_data.Data = NULL; + event_data.Error = Error; + + _net_dbus_pending_call_unref(); + + _net_client_callback(&event_data); + + __NETWORK_FUNC_EXIT__; + return; + } + } else + WIFI_LOG(WIFI_INFO, "WPS scan succeed"); + + _net_dbus_pending_call_unref(); + + __NETWORK_FUNC_EXIT__; +} + +static void __net_set_passpoint_reply(GObject *source_object, GAsyncResult *res, gpointer user_data) +{ + __NETWORK_FUNC_ENTER__; + + GDBusConnection *conn = NULL; + GError *error = NULL; + net_err_e Error = NET_ERR_NONE; + + conn = G_DBUS_CONNECTION(source_object); + g_dbus_connection_call_finish(conn, res, &error); + if (error != NULL) { + Error = __net_netconfig_error_string_to_enum(error->message); + g_error_free(error); + } + + if (Error != NET_ERR_NONE) + WIFI_LOG(WIFI_ERROR, "set passpoint failed[%d]", Error); + else + WIFI_LOG(WIFI_INFO, "set passpoint succeeded"); + + _net_dbus_pending_call_unref(); + + __NETWORK_FUNC_EXIT__; +} + +static char *__net_make_group_name(const char *ssid, + const char *net_mode, const char *sec) +{ + char *buf = NULL; + const char *hidden_str = "hidden"; + const char *g_sec; + char ssid_hex[NET_WLAN_ESSID_LEN * 2 + 1] = { 0, }; + int i; + int ssid_len = 0; + int actual_len = 0; + int buf_len = 0; + + if (net_mode == NULL || sec == NULL) + return NULL; + + if (NULL != ssid) { + ssid_len = strlen(ssid); + actual_len = ssid_len * 2; + } else { + ssid_len = strlen(hidden_str); + actual_len = ssid_len; + } + + if (g_strcmp0(net_mode, "managed") != 0) + return NULL; + + if (!g_strcmp0(sec, "wpa") || !g_strcmp0(sec, "rsn")) + g_sec = "psk"; + else + g_sec = sec; + + buf_len = actual_len + strlen(net_mode) + strlen(g_sec) + 4; + + buf = g_try_malloc0(buf_len); + if (buf == NULL) + return NULL; + + if (NULL != ssid) { + for (i = 0; i < ssid_len; i++) + g_snprintf(ssid_hex + i * 2, 3, "%02x", ssid[i]); + } else { + g_snprintf(ssid_hex, strlen(hidden_str) + 1, "%s", hidden_str); + } + + g_snprintf(buf, buf_len, "_%s_%s_%s", ssid_hex, net_mode, g_sec); + + WIFI_LOG(WIFI_INFO, "Group name: %s", buf); + + return buf; +} + +static int __net_dbus_set_agent_field_and_connect( + const char *key, const char *value, const char *profilename) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *params = NULL; + GVariantBuilder *builder; + + builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + g_variant_builder_add(builder, "{sv}", key, g_variant_new_string(value)); + + params = g_variant_new("(o@a{sv})", + profilename, g_variant_builder_end(builder)); + g_variant_builder_unref(builder); + + Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE, + NETCONFIG_WIFI_PATH, + CONNMAN_AGENT_INTERFACE, "SetField", params, + DBUS_REPLY_TIMEOUT, __net_open_connection_reply); + + __NETWORK_FUNC_EXIT__; + return Error; +} +//LCOV_EXCL_STOP + +GVariant *_net_invoke_dbus_method(const char *dest, const char *path, + const char *interface_name, const char *method, + GVariant *params, int *dbus_error) +{ + __NETWORK_FUNC_ENTER__; + + GError *error = NULL; + GVariant *reply = NULL; + *dbus_error = NET_ERR_NONE; + GDBusConnection *connection; + + connection = _net_dbus_get_gdbus_conn(); + if (connection == NULL) { + WIFI_LOG(WIFI_ERROR, "GDBusconnection is NULL"); //LCOV_EXCL_LINE + *dbus_error = NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + return reply; //LCOV_EXCL_LINE + } + + reply = g_dbus_connection_call_sync(connection, + dest, + path, + interface_name, + method, + params, + NULL, + G_DBUS_CALL_FLAGS_NONE, + DBUS_REPLY_TIMEOUT, + _net_dbus_get_gdbus_cancellable(), + &error); + if (reply == NULL) { + if (error != NULL) { + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "g_dbus_connection_call_sync() failed " + "error [%d: %s]", error->code, error->message); + *dbus_error = __net_error_string_to_enum(error->message); //LCOV_EXCL_LINE + g_error_free(error); //LCOV_EXCL_LINE + } else { + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "g_dbus_connection_call_sync() failed"); + *dbus_error = NET_ERR_UNKNOWN; //LCOV_EXCL_LINE + } + + __NETWORK_FUNC_EXIT__; + return NULL; + } + + __NETWORK_FUNC_EXIT__; + return reply; +} + +int _net_invoke_dbus_method_nonblock(const char *dest, const char *path, + const char *interface_name, const char *method, + GVariant *params, int timeout, + GAsyncReadyCallback notify_func) +{ + __NETWORK_FUNC_ENTER__; + + GDBusConnection *connection; + + connection = _net_dbus_get_gdbus_conn(); + if (connection == NULL) { + WIFI_LOG(WIFI_ERROR, "GDBusconnection is NULL"); //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + g_dbus_connection_call(connection, + dest, + path, + interface_name, + method, + params, + NULL, + G_DBUS_CALL_FLAGS_NONE, + timeout, + _net_dbus_get_gdbus_cancellable(), + (GAsyncReadyCallback) notify_func, + NULL); + + if (notify_func != NULL) + _net_dbus_pending_call_ref(); + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +int _net_dbus_open_connection(const char* profile_name) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + /* use DBus signal than reply pending because of performance reason */ + Error = _net_invoke_dbus_method_nonblock(CONNMAN_SERVICE, profile_name, + CONNMAN_SERVICE_INTERFACE, "Connect", NULL, + DBUS_REPLY_TIMEOUT, __net_open_connection_reply); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_dbus_close_connection(const char* profile_name) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + /* use DBus signal than reply pending because of performance reason */ + Error = _net_invoke_dbus_method_nonblock(CONNMAN_SERVICE, profile_name, + CONNMAN_SERVICE_INTERFACE, "Disconnect", NULL, + DBUS_REPLY_TIMEOUT, __net_close_connection_reply); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_dbus_scan_request(void) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + /* use DBus signal than reply pending because of performance reason */ + Error = _net_invoke_dbus_method_nonblock(CONNMAN_SERVICE, + CONNMAN_WIFI_TECHNOLOGY_PREFIX, + CONNMAN_TECHNOLOGY_INTERFACE, "Scan", NULL, + DBUS_REPLY_TIMEOUT, NULL); + + if (Error == NET_ERR_IN_PROGRESS) + Error = NET_ERR_NONE; //LCOV_EXCL_LINE + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_dbus_set_bgscan_mode(net_wifi_background_scan_mode_e mode) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *message = NULL; + GVariant *params; + + char path[CONNMAN_MAX_BUFLEN] = NETCONFIG_WIFI_PATH; + + params = g_variant_new("(u)", mode); + + message = _net_invoke_dbus_method(NETCONFIG_SERVICE, path, + NETCONFIG_WIFI_INTERFACE, "SetBgscan", params, &Error); + + if (Error != NET_ERR_NONE) + WIFI_LOG(WIFI_ERROR, "_net_invoke_dbus_method failed"); //LCOV_EXCL_LINE + + if (message != NULL) + g_variant_unref(message); //LCOV_EXCL_LINE + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_dbus_get_technology_state(network_tech_state_info_s* tech_state) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *message = NULL; + + if ((tech_state == NULL) || (strlen(tech_state->technology) == 0)) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_PARAM; //LCOV_EXCL_LINE + } + + message = _net_invoke_dbus_method(CONNMAN_SERVICE, + CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE, + "GetTechnologies", NULL, &Error); + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to get technology info"); //LCOV_EXCL_LINE + goto done; //LCOV_EXCL_LINE + } + + Error = _net_get_tech_state(message, tech_state); + + g_variant_unref(message); + +done: + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_dbus_get_tech_status(net_tech_info_s* tech_status) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + network_tech_state_info_s tech_state = {{0,},}; + + g_strlcpy(tech_state.technology, "wifi", NET_TECH_LENGTH_MAX); + + Error = _net_dbus_get_technology_state(&tech_state); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "_net_dbus_get_technology_state() failed. Error [%s]", + _net_print_error(Error)); + goto done; //LCOV_EXCL_LINE + } + + if (tech_state.Powered == TRUE) + tech_status->powered = TRUE; + else + tech_status->powered = FALSE; + + if (tech_state.Connected == TRUE) + tech_status->connected = TRUE; + else + tech_status->connected = FALSE; + +done: + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_dbus_get_wifi_state(char **wifi_state) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *message = NULL; + const char *method = "GetWifiState"; + + if (NULL == wifi_state) { + WIFI_LOG(WIFI_ERROR, "Invalid Parameter\n"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_PARAM; //LCOV_EXCL_LINE + } + + message = _net_invoke_dbus_method( + NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH, + NETCONFIG_WIFI_INTERFACE, method, NULL, &Error); + + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to get wifi state\n"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + g_variant_get(message, "(s)", wifi_state); + g_variant_unref(message); + + __NETWORK_FUNC_EXIT__; + + return Error; +} + +//LCOV_EXCL_START +int _net_dbus_set_eap_config_fields_and_connect( + const net_wifi_connect_service_info_t *wifi_info, + const char *profilename) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *params = NULL; + GVariantBuilder *builder; + + builder = g_variant_builder_new(G_VARIANT_TYPE("a{ss}")); + g_variant_builder_add(builder, "{ss}", CONNMAN_CONFIG_FIELD_TYPE, "wifi"); + + if (wifi_info->ssid) + g_variant_builder_add(builder, "{ss}", + CONNMAN_CONFIG_FIELD_NAME, wifi_info->ssid); + + if (wifi_info->eap_type) + g_variant_builder_add(builder, "{ss}", + CONNMAN_CONFIG_FIELD_EAP_METHOD, wifi_info->eap_type); + + if (wifi_info->eap_keymgmt_type) + g_variant_builder_add(builder, "{ss}", + CONNMAN_CONFIG_FIELD_EAP_KEYMGMT_TYPE, wifi_info->eap_keymgmt_type); + + if (wifi_info->identity) + g_variant_builder_add(builder, "{ss}", + CONNMAN_CONFIG_FIELD_IDENTITY, wifi_info->identity); + + if (wifi_info->password) + g_variant_builder_add(builder, "{ss}", + CONNMAN_CONFIG_FIELD_PASSPHRASE, wifi_info->password); + + if (wifi_info->eap_auth && + g_strcmp0(wifi_info->eap_auth, "NONE") != 0) + g_variant_builder_add(builder, "{ss}", + CONNMAN_CONFIG_FIELD_PHASE2, wifi_info->eap_auth); + + if (wifi_info->ca_cert_file) + g_variant_builder_add(builder, "{ss}", + CONNMAN_CONFIG_FIELD_CA_CERT_FILE, wifi_info->ca_cert_file); + + if (wifi_info->client_cert_file) + g_variant_builder_add(builder, "{ss}", + CONNMAN_CONFIG_FIELD_CLIENT_CERT_FILE, + wifi_info->client_cert_file); + + if (wifi_info->private_key_file) + g_variant_builder_add(builder, "{ss}", + CONNMAN_CONFIG_FIELD_PVT_KEY_FILE, + wifi_info->private_key_file); + + if (wifi_info->private_key_password) + g_variant_builder_add(builder, "{ss}", + CONNMAN_CONFIG_FIELD_PVT_KEY_PASSPHRASE, + wifi_info->private_key_password); + + params = g_variant_new("(o@a{ss})", + profilename, g_variant_builder_end(builder)); + g_variant_builder_unref(builder); + + Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE, + NETCONFIG_WIFI_PATH, + NETCONFIG_WIFI_INTERFACE, "CreateEapConfig", params, + DBUS_REPLY_TIMEOUT, __net_open_connection_reply); + + __NETWORK_FUNC_EXIT__; + return Error; +} +//LCOV_EXCL_STOP + +int _net_dbus_set_agent_passphrase_and_connect( + const char *passphrase, const char *profilename) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (NULL == passphrase || strlen(passphrase) <= 0 || NULL == profilename) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); + return NET_ERR_INVALID_PARAM; + } + + Error = __net_dbus_set_agent_field_and_connect( + NETCONFIG_AGENT_FIELD_PASSPHRASE, + passphrase, + profilename); + if (NET_ERR_NONE != Error) { + WIFI_LOG(WIFI_ERROR, "Configuration failed(%d)", Error); //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_dbus_set_agent_fields_and_connect(const char *ssid, + const char *passphrase, const char *profilename) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + /* If OPEN network, passphrase can be NULL */ + if (NULL == ssid || strlen(ssid) <= 0 || NULL == profilename) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return NET_ERR_INVALID_PARAM; //LCOV_EXCL_LINE + } + + GVariant *params = NULL; + GVariantBuilder *builder; + + builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + g_variant_builder_add(builder, "{sv}", NETCONFIG_AGENT_FIELD_SSID, + g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, ssid, + strlen(ssid), sizeof(guchar))); + + if (passphrase) + g_variant_builder_add(builder, "{sv}", NETCONFIG_AGENT_FIELD_PASSPHRASE, + g_variant_new_string(passphrase)); + + params = g_variant_new("(o@a{sv})", + profilename, g_variant_builder_end(builder)); + g_variant_builder_unref(builder); + + Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE, + NETCONFIG_WIFI_PATH, + CONNMAN_AGENT_INTERFACE, "SetField", params, + DBUS_REPLY_TIMEOUT, __net_open_connection_reply); + if (NET_ERR_NONE != Error) { + WIFI_LOG(WIFI_ERROR, "Configuration failed(%d)", Error); //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + __NETWORK_FUNC_EXIT__; + return Error; +} + +//LCOV_EXCL_START +int _net_dbus_get_wps_pin(char **wps_pin) +{ + __NETWORK_FUNC_ENTER__; + net_err_e error = NET_ERR_NONE; + GVariant *params = NULL; + GVariant *reply = NULL; + gchar *value = NULL; + char *path = NULL; + + params = g_variant_new("(s)", "wlan0"); + reply = _net_invoke_dbus_method(SUPPLICANT_SERVICE, SUPPLICANT_PATH, + SUPPLICANT_INTERFACE, "GetInterface", params, &error); + if (reply == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to get Wi-Fi interface"); + return error; + } + g_variant_get(reply, "(o)", &path); + + reply = _net_invoke_dbus_method(SUPPLICANT_SERVICE, path, + SUPPLICANT_INTERFACE ".Interface.WPS", "GetPin", NULL, &error); + if (reply == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to get wps pin"); + return error; + } + g_variant_get(reply, "(s)", &value); + *wps_pin = g_strdup_printf("%s", value); + g_variant_unref(reply); + + __NETWORK_FUNC_EXIT__; + return error; +} + +int _net_dbus_set_agent_wps_pbc_and_connect(const char *profilename) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + Error = __net_dbus_set_agent_field_and_connect( + NETCONFIG_AGENT_FIELD_WPS_PBC, + "enable", + profilename); + if (NET_ERR_NONE != Error) { + WIFI_LOG(WIFI_ERROR, "PBC configuration failed(%d)", Error); + return Error; + } + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_dbus_set_agent_wps_pin_and_connect( + const char *wps_pin, const char *profilename) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (NULL == wps_pin || strlen(wps_pin) <= 0) { + WIFI_LOG(WIFI_ERROR, "Invalid param "); + return NET_ERR_INVALID_PARAM; + } + + Error = __net_dbus_set_agent_field_and_connect( + NETCONFIG_AGENT_FIELD_WPS_PIN, + wps_pin, + profilename); + if (NET_ERR_NONE != Error) { + WIFI_LOG(WIFI_ERROR, "PIN configuration failed(%d)", Error); + return Error; + } + + __NETWORK_FUNC_EXIT__; + return Error; +} +//LCOV_EXCL_STOP + +int _net_dbus_connect_service(const net_wifi_connect_service_info_t *wifi_connection_info) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + char *grp_name = NULL; + GSList *list = NULL; + GSList *profile_list = NULL; + net_profile_info_s *prof_info = NULL; + + /* Get group name with prefix 'ssid' in hex */ + grp_name = __net_make_group_name(wifi_connection_info->is_hidden == TRUE ? + NULL : wifi_connection_info->ssid, + wifi_connection_info->mode, + wifi_connection_info->security); + if (NULL == grp_name) { + WIFI_LOG(WIFI_ERROR, "Failed to make a group name"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_UNKNOWN; //LCOV_EXCL_LINE + } + + Error = _net_get_profile_list(&profile_list); + if (NET_ERR_NONE != Error) { + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "_net_get_profile_list fail. Error [%s]", + _net_print_error(Error)); + + goto error; //LCOV_EXCL_LINE + } + + + + for (list = profile_list; list; list = list->next) { + prof_info = (net_profile_info_s *)list->data; + if (g_strstr_len(prof_info->ProfileName, + NET_PROFILE_NAME_LEN_MAX+1, grp_name) != NULL) { + WIFI_LOG(WIFI_INFO, "Found profile %s", prof_info->ProfileName); + + if (prof_info->ProfileState == NET_STATE_TYPE_READY || + prof_info->ProfileState == NET_STATE_TYPE_ONLINE) { + WIFI_LOG(WIFI_ERROR, "Already profile is connected"); //LCOV_EXCL_LINE + Error = NET_ERR_ACTIVE_CONNECTION_EXISTS; //LCOV_EXCL_LINE + + goto error; //LCOV_EXCL_LINE + } + + break; + } + } + + if (!list) { + WIFI_LOG(WIFI_ERROR, "No matching profile found"); //LCOV_EXCL_LINE + Error = NET_ERR_NO_SERVICE; //LCOV_EXCL_LINE + + goto error; //LCOV_EXCL_LINE + } + + if (wifi_connection_info->is_hidden == TRUE) { + //LCOV_EXCL_START + char *target_name = __net_make_group_name(wifi_connection_info->ssid, + wifi_connection_info->mode, + wifi_connection_info->security); + + for (list = profile_list; list; list = list->next) { + prof_info = (net_profile_info_s *)list->data; + if (g_strstr_len(prof_info->ProfileName, + NET_PROFILE_NAME_LEN_MAX+1, target_name) != NULL) { + g_strlcpy(request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].ProfileName, + prof_info->ProfileName, NET_PROFILE_NAME_LEN_MAX+1); + + break; + } + } + + g_free(target_name); + //LCOV_EXCL_STOP + } else { + g_strlcpy(request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].ProfileName, + prof_info->ProfileName, NET_PROFILE_NAME_LEN_MAX+1); + } + + //LCOV_EXCL_START + if (g_strcmp0(wifi_connection_info->security, "ieee8021x") == 0) { + /* Create the EAP config file */ + Error = _net_dbus_set_eap_config_fields_and_connect( + wifi_connection_info, prof_info->ProfileName); + if (NET_ERR_NONE != Error) { + WIFI_LOG(WIFI_ERROR, "Fail to create eap_config"); + + goto error; + } + } else if (wifi_connection_info->is_hidden == TRUE) { + Error = _net_dbus_set_agent_fields_and_connect( + wifi_connection_info->ssid, + wifi_connection_info->passphrase, + prof_info->ProfileName); + } else if (g_strcmp0(wifi_connection_info->security, "none") != 0) { + Error = _net_dbus_set_agent_passphrase_and_connect( + wifi_connection_info->passphrase, prof_info->ProfileName); + if (NET_ERR_NONE != Error) { + WIFI_LOG(WIFI_ERROR, "Fail to set agent_passphrase"); + + goto error; + } + } else + Error = _net_dbus_open_connection(prof_info->ProfileName); + //LCOV_EXCL_STOP + +error : + if (NET_ERR_NONE != Error) { + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "Failed to request open connection, Error [%s]", + _net_print_error(Error)); + + memset(&request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION], //LCOV_EXCL_LINE + 0, sizeof(network_request_table_s)); + } + + NET_MEMFREE(prof_info); + g_free(grp_name); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_dbus_set_profile_ipv4(net_profile_info_s* prof_info, char* profile_name) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + const char *manual_method = "manual"; + const char *dhcp_method = "dhcp"; + const char *off_method = "off"; + + const char *prop_ipv4_configuration = "IPv4.Configuration"; + const char *prop_method = "Method"; + const char *prop_address = "Address"; + const char *prop_gateway = "Gateway"; + const char *prop_netmask = "Netmask"; + + char ip_buffer[NET_IPV4_STR_LEN_MAX+1] = ""; + char netmask_buffer[NET_IPV4_STR_LEN_MAX+1] = ""; + char gateway_buffer[NET_IPV4_STR_LEN_MAX+1] = ""; + + char *ipaddress = ip_buffer; + char *netmask = netmask_buffer; + char *gateway = gateway_buffer; + + GVariant *params = NULL; + GVariantBuilder *builder; + net_dev_info_s *profile_net_info = NULL; + + GVariant *message = NULL; + + WIFI_LOG(WIFI_INFO, "profile_name: [%s]", profile_name); + + if ((prof_info == NULL) || (profile_name == NULL) || (strlen(profile_name) == 0)) { + WIFI_LOG(WIFI_ERROR, "Invalid argument"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_PARAM; //LCOV_EXCL_LINE + } + + profile_net_info = &(prof_info->net_info); + + g_strlcpy(ip_buffer, + inet_ntoa(profile_net_info->IpAddr.Data.Ipv4), + NET_IPV4_STR_LEN_MAX + 1); + + g_strlcpy(netmask_buffer, + inet_ntoa(profile_net_info->SubnetMask.Data.Ipv4), + NET_IPV4_STR_LEN_MAX + 1); + + g_strlcpy(gateway_buffer, + inet_ntoa(profile_net_info->GatewayAddr.Data.Ipv4), + NET_IPV4_STR_LEN_MAX + 1); + + WIFI_LOG(WIFI_INFO, "ip: %s, netmask: %s, gateway: %s", + ipaddress, netmask, gateway); + + builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + + //LCOV_EXCL_START + if (profile_net_info->IpConfigType == NET_IP_CONFIG_TYPE_DYNAMIC || + profile_net_info->IpConfigType == NET_IP_CONFIG_TYPE_AUTO_IP) { + + g_variant_builder_add(builder, "{sv}", prop_method, g_variant_new_string(dhcp_method)); + + } else if (profile_net_info->IpConfigType == NET_IP_CONFIG_TYPE_OFF) { + + g_variant_builder_add(builder, "{sv}", prop_method, g_variant_new_string(off_method)); + + } else if (profile_net_info->IpConfigType == NET_IP_CONFIG_TYPE_STATIC) { + + g_variant_builder_add(builder, "{sv}", prop_method, g_variant_new_string(manual_method)); + + if (strlen(ipaddress) >= NET_IPV4_STR_LEN_MIN) + g_variant_builder_add(builder, "{sv}", prop_address, g_variant_new_string(ipaddress)); + + if (strlen(netmask) >= NET_IPV4_STR_LEN_MIN) + g_variant_builder_add(builder, "{sv}", prop_netmask, g_variant_new_string(netmask)); + + if (strlen(gateway) >= NET_IPV4_STR_LEN_MIN) + g_variant_builder_add(builder, "{sv}", prop_gateway, g_variant_new_string(gateway)); + + } else { + WIFI_LOG(WIFI_ERROR, "Invalid argument"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_PARAM; + } + //LCOV_EXCL_STOP + + params = g_variant_new("(sv)", + prop_ipv4_configuration, g_variant_builder_end(builder)); + g_variant_builder_unref(builder); + + message = _net_invoke_dbus_method(CONNMAN_SERVICE, profile_name, + CONNMAN_SERVICE_INTERFACE, "SetProperty", params, + &Error); + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to set IPv4 Property"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + g_variant_unref(message); + WIFI_LOG(WIFI_INFO, "Successfully configured IPv4.Configuration\n"); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +//LCOV_EXCL_START +int _net_dbus_set_profile_ipv6(net_profile_info_s* prof_info, char* profile_name) +{ + __NETWORK_FUNC_ENTER__; + + const char *manual_method = "manual"; + const char *auto_method = "auto"; + const char *off_method = "off"; + + const char *prop_ipv6_configuration = "IPv6.Configuration"; + const char *prop_method = "Method"; + const char *prop_address = "Address"; + const char *prop_gateway = "Gateway"; + const char *prop_prefixlen = "PrefixLength"; + + char ipaddr6[INET6_ADDRSTRLEN]; + char gwaddr6[INET6_ADDRSTRLEN]; + + char *ip6_ptr = ipaddr6; + char *gw6_ptr = gwaddr6; + int prefix_length = 0; + + net_err_e Error = NET_ERR_NONE; + GVariant *params = NULL; + GVariantBuilder *builder; + GVariant *message = NULL; + net_dev_info_s *profile_net_info = NULL; + + if ((prof_info == NULL) || (profile_name == NULL) || (strlen(profile_name) == 0)) { + WIFI_LOG(WIFI_ERROR, "Error!!! Invalid argument\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_PARAM; + } + + profile_net_info = &(prof_info->net_info); + + inet_ntop(AF_INET6, &profile_net_info->IpAddr6.Data.Ipv6, ipaddr6, + INET6_ADDRSTRLEN); + inet_ntop(AF_INET6, &profile_net_info->GatewayAddr6.Data.Ipv6, gwaddr6, + INET6_ADDRSTRLEN); + prefix_length = profile_net_info->PrefixLen6; + + WIFI_LOG(WIFI_INFO, "ipaddress : %s, prefix_len : %d, gateway :" + " %s\n", ip6_ptr, prefix_length, gw6_ptr); + + builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + + if (profile_net_info->IpConfigType6 == NET_IP_CONFIG_TYPE_DYNAMIC || + profile_net_info->IpConfigType6 == NET_IP_CONFIG_TYPE_AUTO_IP) { + + g_variant_builder_add(builder, "{sv}", prop_method, + g_variant_new_string(auto_method)); + + } else if (profile_net_info->IpConfigType6 == NET_IP_CONFIG_TYPE_OFF) { + + g_variant_builder_add(builder, "{sv}", prop_method, + g_variant_new_string(off_method)); + + WIFI_LOG(WIFI_INFO, "DBus Message 2/2: %s %s\n", + prop_method, off_method); + } else if (profile_net_info->IpConfigType6 == NET_IP_CONFIG_TYPE_STATIC) { + + g_variant_builder_add(builder, "{sv}", prop_method, + g_variant_new_string(manual_method)); + + if (strlen(ipaddr6) >= NET_IPV6_STR_LEN_MIN) { + g_variant_builder_add(builder, "{sv}", prop_address, + g_variant_new_string(ip6_ptr)); + } + if (profile_net_info->PrefixLen6 <= NET_IPV6_MAX_PREFIX_LEN) { + g_variant_builder_add(builder, "{sv}", prop_prefixlen, + g_variant_new_byte(prefix_length)); + } + + if (strlen(gwaddr6) >= NET_IPV6_STR_LEN_MIN) { + g_variant_builder_add(builder, "{sv}", prop_gateway, + g_variant_new_string(gw6_ptr)); + } + WIFI_LOG(WIFI_INFO, "DBus Message 2/2: %s %s %s %s %s %d" + " %s %s\n", prop_method, manual_method, + prop_address, ipaddr6, prop_prefixlen, + prefix_length, prop_gateway, gwaddr6); + } else { + WIFI_LOG(WIFI_ERROR, "Invalid argument\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_PARAM; + } + + params = g_variant_new("(sv)", prop_ipv6_configuration, + g_variant_builder_end(builder)); + g_variant_builder_unref(builder); + + message = _net_invoke_dbus_method(CONNMAN_SERVICE, profile_name, + CONNMAN_SERVICE_INTERFACE, "SetProperty", params, + &Error); + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to set IPv6 Property"); + __NETWORK_FUNC_EXIT__; + return Error; + } + + g_variant_unref(message); + WIFI_LOG(WIFI_INFO, "Successfully configured IPv6.Configuration\n"); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_dbus_set_profile_dns(net_profile_info_s* prof_info, char* profile_name) +{ + __NETWORK_FUNC_ENTER__; + + const char *prop_nameserver_configuration = "Nameservers.Configuration"; + char dns_buffer[NET_DNS_ADDR_MAX][NET_IPV4_STR_LEN_MAX+1]; + char *dns_address[NET_DNS_ADDR_MAX]; + net_err_e Error = NET_ERR_NONE; + GVariant *params = NULL; + GVariantBuilder *builder; + int i = 0; + net_dev_info_s *profile_net_info = NULL; + GVariant *message = NULL; + + if ((prof_info == NULL) || (profile_name == NULL) || (strlen(profile_name) == 0)) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_PARAM; + } + + profile_net_info = &(prof_info->net_info); + + if (profile_net_info->DnsCount > NET_DNS_ADDR_MAX) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_PARAM; + } + + for (i = 0; i < profile_net_info->DnsCount; i++) { + dns_buffer[i][0] = '\0'; + dns_address[i] = NULL; + + if (profile_net_info->DnsAddr[i].Data.Ipv4.s_addr != 0) + g_strlcpy(dns_buffer[i], + inet_ntoa(profile_net_info->DnsAddr[i].Data.Ipv4), + NET_IPV4_STR_LEN_MAX + 1); + + dns_address[i] = dns_buffer[i]; + } + + if (profile_net_info->IpConfigType == NET_IP_CONFIG_TYPE_STATIC) { + + builder = g_variant_builder_new(G_VARIANT_TYPE("as")); + for (i = 0; i < profile_net_info->DnsCount; i++) + g_variant_builder_add(builder, "s", dns_address[i]); + + params = g_variant_new("(sv)", prop_nameserver_configuration, g_variant_builder_end(builder)); + g_variant_builder_unref(builder); + + message = _net_invoke_dbus_method(CONNMAN_SERVICE, profile_name, + CONNMAN_SERVICE_INTERFACE, "SetProperty", params, + &Error); + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to set " + "Nameservers.Configuration"); + __NETWORK_FUNC_EXIT__; + return Error; + } + WIFI_LOG(WIFI_INFO, "Successfully configured Nameservers.Configuration\n"); + g_variant_unref(message); + } + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_dbus_set_proxy(net_profile_info_s* prof_info, char* profile_name) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + const char *direct_method = "direct"; + const char *auto_method = "auto"; + const char *manual_method = "manual"; + + const char *prop_proxy_configuration = "Proxy.Configuration"; + const char *prop_method = "Method"; + const char *prop_url = "URL"; + const char *prop_servers = "Servers"; + + char proxy_buffer[NET_PROXY_LEN_MAX+1] = ""; + char *proxy_address = proxy_buffer; + + GVariant *params = NULL; + GVariantBuilder *builder; + GVariantBuilder *builder_sub; + net_dev_info_s *profile_net_info = NULL; + + GVariant *message = NULL; + + if ((prof_info == NULL) || (profile_name == NULL) || (strlen(profile_name) == 0)) { + WIFI_LOG(WIFI_ERROR, "Invalid argument"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_PARAM; + } + + profile_net_info = &(prof_info->net_info); + + g_strlcpy(proxy_buffer, + profile_net_info->ProxyAddr, NET_PROXY_LEN_MAX+1); + + WIFI_LOG(WIFI_INFO, "method: %d, proxy address: %s, Profile Name %s", + profile_net_info->ProxyMethod, proxy_address, profile_net_info->ProfileName); + + builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + + switch (profile_net_info->ProxyMethod) { + case NET_PROXY_TYPE_AUTO: + g_variant_builder_add(builder, "{sv}", prop_method, g_variant_new_string(auto_method)); + break; + case NET_PROXY_TYPE_MANUAL: + g_variant_builder_add(builder, "{sv}", prop_method, g_variant_new_string(manual_method)); + break; + default: + g_variant_builder_add(builder, "{sv}", prop_method, g_variant_new_string(direct_method)); + break; + } + + if (profile_net_info->ProxyMethod == NET_PROXY_TYPE_AUTO && + proxy_address[0] != '\0') { + g_variant_builder_add(builder, "{sv}", prop_url, g_variant_new_string(proxy_address)); + } + + if (profile_net_info->ProxyMethod == NET_PROXY_TYPE_MANUAL && + proxy_address[0] != '\0') { + builder_sub = g_variant_builder_new(G_VARIANT_TYPE("as")); + g_variant_builder_add(builder_sub, "s", proxy_address); + g_variant_builder_add(builder, "{sv}", prop_servers, g_variant_builder_end(builder_sub)); + g_variant_builder_unref(builder_sub); + } + + params = g_variant_new("(sv)", prop_proxy_configuration, g_variant_builder_end(builder)); + g_variant_builder_unref(builder); + + message = _net_invoke_dbus_method(CONNMAN_SERVICE, profile_name, + CONNMAN_SERVICE_INTERFACE, "SetProperty", params, + &Error); + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to set Proxy Configuration"); + __NETWORK_FUNC_EXIT__; + return Error; + } + WIFI_LOG(WIFI_INFO, "Successfully configured Proxy.Configuration\n"); + g_variant_unref(message); + + __NETWORK_FUNC_EXIT__; + return Error; +} +//LCOV_EXCL_STOP + +int _net_dbus_load_wifi_driver(gboolean wifi_picker_test) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *params; + + params = g_variant_new("(b)", wifi_picker_test); + + /* use DBus signal than reply pending because of performance reason */ + Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE, + NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE, + "LoadDriver", params, DBUS_REPLY_TIMEOUT, + __net_wifi_power_reply); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_dbus_remove_wifi_driver(void) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + /* use DBus signal than reply pending because of performance reason */ + Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE, + NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE, + "RemoveDriver", NULL, DBUS_REPLY_TIMEOUT, + __net_wifi_power_reply); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_dbus_specific_scan_request(const char *ssid) +{ + __NETWORK_FUNC_ENTER__; + + GVariant *params = NULL; + net_err_e Error = NET_ERR_NONE; + + params = g_variant_new("(s)", ssid); + + Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE, + NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE, + "RequestSpecificScan", params, 6 * DBUS_REPLY_TIMEOUT, + __net_specific_scan_wifi_reply); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +//LCOV_EXCL_START +int _net_dbus_wps_scan_request(void) +{ + __NETWORK_FUNC_ENTER__; + net_err_e Error = NET_ERR_NONE; + + Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE, + NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE, + "RequestWpsScan", NULL, 6 * DBUS_REPLY_TIMEOUT, + __net_wps_scan_wifi_reply); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_dbus_get_passpoint(int *enabled) +{ + __NETWORK_FUNC_ENTER__; + + GVariant *message = NULL; + net_err_e Error = NET_ERR_NONE; + + message = _net_invoke_dbus_method(NETCONFIG_SERVICE, + NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE, + "GetPasspoint", NULL, &Error); + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to Get Passpoint"); + __NETWORK_FUNC_EXIT__; + return Error; + } + + /** Check Reply */ + int result = 0; + g_variant_get(message, "(i)", &result); + *enabled = result; + + WIFI_LOG(WIFI_INFO, "Get passpoint result: %d", result); + + g_variant_unref(message); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_dbus_set_passpoint(int enable) +{ + __NETWORK_FUNC_ENTER__; + + GVariant *params; + net_err_e Error = NET_ERR_NONE; + + params = g_variant_new("(i)", enable); + + Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE, + NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE, + "SetPasspoint", params, 6 * DBUS_REPLY_TIMEOUT, + __net_set_passpoint_reply); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +#if defined TIZEN_TV +static void __net_wps_cancel_reply(GObject *source_object, + GAsyncResult *res, gpointer user_data) +{ + __NETWORK_FUNC_ENTER__; + + WIFI_LOG(WIFI_INFO, "__net_wps_cancel_wifi_reply() called\n"); + + GDBusConnection *conn = NULL; + GVariant *dbus_result = NULL; + GError *error = NULL; + + conn = G_DBUS_CONNECTION(source_object); + dbus_result = g_dbus_connection_call_finish(conn, res, &error); + + if (error != NULL) { + WIFI_LOG(WIFI_ERROR, "error msg - [%s]\n", error->message); + g_error_free(error); + } + + if (dbus_result) + g_variant_unref(dbus_result); + + _net_dbus_pending_call_unref(); + + __NETWORK_FUNC_EXIT__; +} + + +int _net_dbus_cancel_wps(void) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE, + NETCONFIG_WIFI_PATH, NETCONFIG_TV_PROFILE_INTERFACE, + "RequestWpsCancel", NULL, DBUS_REPLY_TIMEOUT, + __net_wps_cancel_reply); + + __NETWORK_FUNC_EXIT__; + return Error; + +} + +static int __net_dbus_set_agent_field(const char *key, const char *value) +{ + __NETWORK_FUNC_ENTER__; + + GVariant *params = NULL; + GVariantBuilder *builder; + net_err_e Error = NET_ERR_NONE; + GVariant *message = NULL; + + char path[CONNMAN_MAX_BUFLEN] = NETCONFIG_WIFI_PATH; + + builder = g_variant_builder_new(G_VARIANT_TYPE("a{ss}")); + g_variant_builder_add(builder, "{ss}", key, value); + + params = g_variant_new("(@a{ss})", g_variant_builder_end(builder)); + g_variant_builder_unref(builder); + + message = _net_invoke_dbus_method(NETCONFIG_SERVICE, path, + CONNMAN_AGENT_INTERFACE, "SetField", params, &Error); + + if (Error != NET_ERR_NONE) + WIFI_LOG(WIFI_ERROR, "_net_invoke_dbus_method failed"); + + if (message != NULL) + g_variant_unref(message); + else + WIFI_LOG(WIFI_ERROR, "Failed to set agent field"); + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +static void __net_wps_connect_wifi_reply(GObject *source_object, + GAsyncResult *res, gpointer user_data) +{ + __NETWORK_FUNC_ENTER__; + + int callback_flag = FALSE; + GDBusConnection *conn = NULL; + GError *error = NULL; + GVariant *dbus_result = NULL; + net_event_info_s event_data; + net_err_e Error = NET_ERR_NONE; + network_request_table_s *wps_info = + &request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS]; + memset(&event_data, 0, sizeof(event_data)); + + conn = G_DBUS_CONNECTION(source_object); + dbus_result = g_dbus_connection_call_finish(conn, res, &error); + + if (error != NULL) { + WIFI_LOG(WIFI_INFO, "error msg - [%s]\n", error->message); + Error = __net_error_string_to_enum(error->message); + g_error_free(error); + } else + WIFI_LOG(WIFI_INFO, "error msg is NULL\n"); + + if (dbus_result) + g_variant_unref(dbus_result); + + if (Error == NET_ERR_NONE) + goto done; + + WIFI_LOG(WIFI_ERROR, "Connection open failed. Error [%d]\n", Error); + + memset(wps_info, 0, sizeof(network_request_table_s)); + + event_data.Error = Error; + event_data.Event = NET_EVENT_WIFI_WPS_RSP; + + WIFI_LOG(WIFI_INFO, "Sending NET_EVENT_WIFI_WPS_RSP Error = %s\n", + _net_print_error(event_data.Error)); + + callback_flag = TRUE; + +done: + _net_dbus_pending_call_unref(); + + if (callback_flag) + _net_client_callback(&event_data); + + __NETWORK_FUNC_EXIT__; +} + +int _net_dbus_open_connection_without_ssid() +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *params = NULL; + + params = g_variant_new("(s)", "PBC"); + WIFI_LOG(WIFI_ERROR, "Invoke wps connection without ssid"); + + Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE, + NETCONFIG_WIFI_PATH, NETCONFIG_TV_PROFILE_INTERFACE, + "RequestWpsConnect", params, DBUS_REPLY_TIMEOUT, + __net_wps_connect_wifi_reply); + + __NETWORK_FUNC_EXIT__; + return Error; +} + + +int _net_dbus_open_pin_connection_without_ssid(const char *pin) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + GVariant *params = NULL; + params = g_variant_new("(s)", pin); + + Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE, + NETCONFIG_WIFI_PATH, NETCONFIG_TV_PROFILE_INTERFACE, + "RequestWpsConnect", params, DBUS_REPLY_TIMEOUT, + __net_wps_connect_wifi_reply); + + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_dbus_set_agent_wps_pbc(void) +{ + __NETWORK_FUNC_ENTER__; + + int ret_val; + + ret_val = __net_dbus_set_agent_field(NETCONFIG_AGENT_FIELD_WPS_PBC, "enable"); + if (NET_ERR_NONE != ret_val) { + WIFI_LOG(WIFI_ERROR, "__net_dbus_set_agent_field failed. Error = %d \n", ret_val); + return ret_val; + } + + WIFI_LOG(WIFI_INFO, "Successfully sent wps pbc\n"); + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +int _net_dbus_set_agent_wps_pin(const char *wps_pin) +{ + __NETWORK_FUNC_ENTER__; + + int ret_val; + + if (NULL == wps_pin || strlen(wps_pin) <= 0) { + WIFI_LOG(WIFI_ERROR, "Invalid param \n"); + return NET_ERR_INVALID_PARAM; + } + + ret_val = __net_dbus_set_agent_field(NETCONFIG_AGENT_FIELD_WPS_PIN, wps_pin); + if (NET_ERR_NONE != ret_val) { + WIFI_LOG(WIFI_ERROR, "__net_dbus_set_agent_field failed. Error = %d \n", ret_val); + return ret_val; + } + + WIFI_LOG(WIFI_INFO, "Successfully sent wps pin\n"); + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} +#endif + +int _net_dbus_tdls_disconnect(const char* peer_mac_addr) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *message = NULL; + GVariant *params = NULL; + gint32 ret = -1; + + params = g_variant_new("(s)", peer_mac_addr); + + message = _net_invoke_dbus_method( + NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH, + NETCONFIG_WIFI_INTERFACE, "TdlsDisconnect", params, &Error); + + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to TDLS Disconnect Request\n"); + __NETWORK_FUNC_EXIT__; + return Error; + } + + g_variant_get(message, "(i)", &ret); + + WIFI_LOG(WIFI_INFO, "Status [%d]\n", ret); + + if (ret) + Error = NET_ERR_NONE; + else + Error = NET_ERR_UNKNOWN; + + g_variant_unref(message); + __NETWORK_FUNC_EXIT__; + + return Error; +} + +int _net_dbus_tdls_connected_peer(char** peer_mac_addr) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *message = NULL; + + if (NULL == peer_mac_addr) { + WIFI_LOG(WIFI_ERROR, "Invalid Parameter\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_PARAM; + } + + message = _net_invoke_dbus_method( + NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH, + NETCONFIG_WIFI_INTERFACE, "TdlsConnectedPeer", NULL, &Error); + + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to Get Peer Connected Mac address\n"); + __NETWORK_FUNC_EXIT__; + return Error; + } + + g_variant_get(message, "(s)", peer_mac_addr); + + WIFI_LOG(WIFI_INFO, "TDLS Peer Mac address [%s]\n", *peer_mac_addr); + + g_variant_unref(message); + __NETWORK_FUNC_EXIT__; + + return Error; +} + +int _net_dbus_config_get_id_list(GSList **list) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *message = NULL; + GVariantIter *iter = NULL; + gchar *config_id = NULL; + + message = _net_invoke_dbus_method( + NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH, + NETCONFIG_WIFI_INTERFACE, "GetConfigIds", + g_variant_new("()"), &Error); + + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to GetConfigIds"); + __NETWORK_FUNC_EXIT__; + return Error; + } + + g_variant_get(message, "(as)", &iter); + while (g_variant_iter_loop(iter, "s", &config_id)) + *list = g_slist_append(*list, g_strdup(config_id)); + + g_variant_iter_free(iter); + g_variant_unref(message); + + __NETWORK_FUNC_EXIT__; + + return Error; +} + +int _net_dbus_config_set_field(const gchar *config_id, const gchar *key, const gchar *value) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *message = NULL; + + message = _net_invoke_dbus_method( + NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH, + NETCONFIG_WIFI_INTERFACE, "SetConfigField", + g_variant_new("(sss)", config_id, key, value), &Error); + + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to SetConfigField"); + __NETWORK_FUNC_EXIT__; + return Error; + } + + g_variant_unref(message); + + __NETWORK_FUNC_EXIT__; + + return Error; +} + +int _net_dbus_config_get_passphrase(const gchar *config_id, gchar **passphrase) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *message = NULL; + gchar *val = NULL; + + message = _net_invoke_dbus_method( + NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH, + NETCONFIG_WIFI_INTERFACE, "GetConfigPassphrase", + g_variant_new("(s)", config_id), &Error); + + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to GetConfigPassphrase"); + __NETWORK_FUNC_EXIT__; + return Error; + } + + g_variant_get(message, "(s)", &val); + + *passphrase = g_strdup(val); + g_free(val); + + g_variant_unref(message); + + __NETWORK_FUNC_EXIT__; + + return Error; +} + +int _net_dbus_config_save_configurations(const gchar *config_id, const gchar *name, + const gchar *ssid, const gchar *passphrase, const gchar *proxy_address, gboolean is_hidden) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariantBuilder *b = NULL; + GVariant *params = NULL; + GVariant *message = NULL; + + b = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_NAME, g_variant_new_string(name)); + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_SSID, g_variant_new_string(ssid)); + if (passphrase != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_PASSPHRASE, g_variant_new_string(passphrase)); + if (proxy_address != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_PROXYADDRESS, g_variant_new_string(proxy_address)); + if (is_hidden == TRUE) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_HIDDEN, g_variant_new_string("TRUE")); + + params = g_variant_new("(s@a{sv})", config_id, g_variant_builder_end(b)); + g_variant_builder_unref(b); + + message = _net_invoke_dbus_method( + NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH, + NETCONFIG_WIFI_INTERFACE, "SaveConfiguration", + params, &Error); + + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to SaveConfiguration"); + __NETWORK_FUNC_EXIT__; + return Error; + } + + g_variant_unref(message); + + __NETWORK_FUNC_EXIT__; + + return Error; +} + +int _net_dbus_config_save_eap_configurations(const gchar *config_id, + const gchar *name, const gchar *ssid, const gchar *passphrase, + const gchar *proxy_address, net_eap_config_s *eap_config, gboolean is_hidden) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariantBuilder *b = NULL; + GVariant *params = NULL; + GVariant *message = NULL; + + b = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_NAME, g_variant_new_string(name)); + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_SSID, g_variant_new_string(ssid)); + if (passphrase != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_PASSPHRASE, g_variant_new_string(passphrase)); + if (proxy_address != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_PROXYADDRESS, g_variant_new_string(proxy_address)); + if (is_hidden == TRUE) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_HIDDEN, g_variant_new_string("TRUE")); + + if (eap_config != NULL) { + gchar* auth_type = NULL; + gchar* eap_type = NULL; + if (eap_config->anonymous_identity != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_ANONYMOUS_IDENTITY, g_variant_new_string(eap_config->anonymous_identity)); + if (eap_config->ca_cert != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_CACERT, g_variant_new_string(eap_config->ca_cert)); + if (eap_config->client_cert != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_CLIENTCERT, g_variant_new_string(eap_config->client_cert)); + if (eap_config->private_key != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_PRIVATEKEY, g_variant_new_string(eap_config->private_key)); + if (eap_config->identity != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_IDENTITY, g_variant_new_string(eap_config->identity)); + if (eap_config->subject_match != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_SUBJECT_MATCH, g_variant_new_string(eap_config->subject_match)); + + auth_type = __net_wifi_eap_auth_type_to_string(eap_config->eap_auth_type); + if (auth_type != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_AUTH_TYPE, g_variant_new_string(auth_type)); + + eap_type = __net_wifi_eap_type_to_string(eap_config->eap_type); + if (eap_type != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_TYPE, g_variant_new_string(eap_type)); + + g_free(auth_type); + g_free(eap_type); + } + + params = g_variant_new("(s@a{sv})", config_id, g_variant_builder_end(b)); + g_variant_builder_unref(b); + + message = _net_invoke_dbus_method( + NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH, + NETCONFIG_WIFI_INTERFACE, "SaveEapConfiguration", + params, &Error); + + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to SaveEapConfiguration"); + __NETWORK_FUNC_EXIT__; + return Error; + } + + g_variant_unref(message); + + __NETWORK_FUNC_EXIT__; + + return Error; +} + +int _net_dbus_config_remove_configurations(const gchar *config_id) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *message = NULL; + + message = _net_invoke_dbus_method( + NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH, + NETCONFIG_WIFI_INTERFACE, "RemoveConfiguration", + g_variant_new("(s)", config_id), &Error); + + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to RemoveConfiguration"); + __NETWORK_FUNC_EXIT__; + return Error; + } + + g_variant_unref(message); + + __NETWORK_FUNC_EXIT__; + + return Error; +} + +int _net_dbus_config_load_configurations(const gchar *config_id, gchar **name, + net_wifi_security_type_e *security_type, gchar **proxy_address, gboolean *is_hidden, void *last_error) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *message = NULL; + GVariantIter *iter; + gchar *field; + GVariant *value; + int *wifi_last_error = (int *)last_error; + + message = _net_invoke_dbus_method( + NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH, + NETCONFIG_WIFI_INTERFACE, "LoadConfiguration", + g_variant_new("(s)", config_id), &Error); + + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to LoadConfiguration"); + __NETWORK_FUNC_EXIT__; + return Error; + } + + g_variant_get(message, "(a{sv})", &iter); + while (g_variant_iter_loop(iter, "{sv}", &field, &value)) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + if (g_strcmp0(field, WIFI_CONFIG_NAME) == 0) { + *name = g_strdup(g_variant_get_string(value, NULL)); + } else if (g_strcmp0(field, WIFI_CONFIG_SECURITY_TYPE) == 0) { + *security_type = __net_wifi_security_type_to_int(g_variant_get_string(value, NULL)); + } else if (g_strcmp0(field, WIFI_CONFIG_HIDDEN) == 0) { + const gchar *r_hidden = g_variant_get_string(value, NULL); + if (g_strcmp0(r_hidden, "TRUE") == 0) + *is_hidden = TRUE; + else + *is_hidden = FALSE; + } else if (g_strcmp0(field, WIFI_CONFIG_PROXYADDRESS) == 0) { + const gchar *r_proxy_address = g_variant_get_string(value, NULL); + if (g_strcmp0(r_proxy_address, "NONE") == 0) + *proxy_address = NULL; + else + *proxy_address = g_strdup(r_proxy_address); + } else if (g_strcmp0(field, WIFI_CONFIG_FAILURE) == 0) { + *wifi_last_error = __net_wifi_last_error_to_enum(g_variant_get_string(value, NULL)); + } + } + } + + g_variant_iter_free(iter); + g_variant_unref(message); + + __NETWORK_FUNC_EXIT__; + + return Error; +} + +int _net_dbus_config_load_eap_configurations(const gchar *config_id, + gchar **name, net_wifi_security_type_e *security_type, gchar **proxy_address, + gboolean *is_hidden, net_eap_config_s **eap_config, void *last_error) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *message = NULL; + GVariantIter *iter; + gchar *field; + GVariant *value; + int *wifi_last_error = (int *)last_error; + + message = _net_invoke_dbus_method( + NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH, + NETCONFIG_WIFI_INTERFACE, "LoadEapConfiguration", + g_variant_new("(s)", config_id), &Error); + + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to LoadEapConfiguration"); + __NETWORK_FUNC_EXIT__; + return Error; + } + + g_variant_get(message, "(a{sv})", &iter); + while (g_variant_iter_loop(iter, "{sv}", &field, &value)) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + if (g_strcmp0(field, WIFI_CONFIG_NAME) == 0) { + *name = g_strdup(g_variant_get_string(value, NULL)); + } else if (g_strcmp0(field, WIFI_CONFIG_SECURITY_TYPE) == 0) { + *security_type = __net_wifi_security_type_to_int(g_variant_get_string(value, NULL)); + } else if (g_strcmp0(field, WIFI_CONFIG_HIDDEN) == 0) { + const gchar *r_hidden = g_variant_get_string(value, NULL); + if (g_strcmp0(r_hidden, "TRUE") == 0) + *is_hidden = TRUE; + else + *is_hidden = FALSE; + } else if (g_strcmp0(field, WIFI_CONFIG_PROXYADDRESS) == 0) { + const gchar *r_proxy_address = g_variant_get_string(value, NULL); + if (g_strcmp0(r_proxy_address, "NONE") == 0) + *proxy_address = NULL; + else + *proxy_address = g_strdup(r_proxy_address); + } else if (g_strcmp0(field, WIFI_CONFIG_EAP_ANONYMOUS_IDENTITY) == 0) { + const gchar *anonymous_identity = g_variant_get_string(value, NULL); + (*eap_config)->anonymous_identity = g_strdup(anonymous_identity); + } else if (g_strcmp0(field, WIFI_CONFIG_EAP_CACERT) == 0) { + const gchar *ca_cert = g_variant_get_string(value, NULL); + (*eap_config)->ca_cert = g_strdup(ca_cert); + } else if (g_strcmp0(field, WIFI_CONFIG_EAP_CLIENTCERT) == 0) { + const gchar *client_cert = g_variant_get_string(value, NULL); + (*eap_config)->client_cert = g_strdup(client_cert); + } else if (g_strcmp0(field, WIFI_CONFIG_EAP_PRIVATEKEY) == 0) { + const gchar *private_key = g_variant_get_string(value, NULL); + (*eap_config)->private_key = g_strdup(private_key); + } else if (g_strcmp0(field, WIFI_CONFIG_EAP_IDENTITY) == 0) { + const gchar *identity = g_variant_get_string(value, NULL); + (*eap_config)->identity = g_strdup(identity); + } else if (g_strcmp0(field, WIFI_CONFIG_EAP_TYPE) == 0) { + const gchar *eap_type = g_variant_get_string(value, NULL); + (*eap_config)->eap_type = __net_wifi_eap_type_to_int(eap_type); + } else if (g_strcmp0(field, WIFI_CONFIG_EAP_AUTH_TYPE) == 0) { + const gchar *auth_type = g_variant_get_string(value, NULL); + (*eap_config)->eap_auth_type = __net_wifi_eap_auth_type_to_int(auth_type); + } else if (g_strcmp0(field, WIFI_CONFIG_EAP_SUBJECT_MATCH) == 0) { + const gchar *subject_match = g_variant_get_string(value, NULL); + (*eap_config)->subject_match = g_strdup(subject_match); + } else if (g_strcmp0(field, WIFI_CONFIG_FAILURE) == 0) { + *wifi_last_error = __net_wifi_last_error_to_enum(g_variant_get_string(value, NULL)); + } + } + } + g_variant_iter_free(iter); + g_variant_unref(message); + + __NETWORK_FUNC_EXIT__; + + return Error; +} + +int _net_dbus_device_policy_get_wifi(int *state) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *message = NULL; + + if (state == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid Parameter\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_PARAM; + } + + message = _net_invoke_dbus_method(NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH, + NETCONFIG_NETWORK_INTERFACE, "DevicePolicyGetWifi", NULL, &Error); + + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to get wifi device policy\n"); + return Error; + } + + g_variant_get(message, "(i)", state); + + WIFI_LOG(WIFI_INFO, "Wifi device policy state [%d]\n", *state); + + g_variant_unref(message); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_dbus_device_policy_get_wifi_profile(int *state) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *message = NULL; + + if (state == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid Parameter\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_PARAM; + } + + message = _net_invoke_dbus_method(NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH, + NETCONFIG_NETWORK_INTERFACE, "DevicePolicyGetWifiProfile", NULL, &Error); + + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to get wifi device policy\n"); + return Error; + } + + g_variant_get(message, "(i)", state); + + WIFI_LOG(WIFI_INFO, "Wifi profile device policy state [%d]\n", *state); + + g_variant_unref(message); + + __NETWORK_FUNC_EXIT__; + return Error; +} +//LCOV_EXCL_STOP + diff --git a/src/network_interface.c b/src/network_interface.c new file mode 100755 index 0000000..09b7588 --- /dev/null +++ b/src/network_interface.c @@ -0,0 +1,2744 @@ +/* + * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +#include "network_interface.h" +#include "network_internal.h" +#include "network_dbus.h" +#include "network_signal.h" + +#define DBUS_OBJECT_PATH_MAX 150 + +__thread network_info_s NetworkInfo = { 0, }; +extern __thread network_request_table_s request_table[NETWORK_REQUEST_TYPE_MAX]; + +static int __net_check_get_privilege() +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *message = NULL; + + message = _net_invoke_dbus_method(NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH, + NETCONFIG_NETWORK_INTERFACE, "CheckGetPrivilege", NULL, &Error); + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to check get privilege"); //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + g_variant_unref(message); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +static int __net_check_profile_privilege() +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *message = NULL; + + message = _net_invoke_dbus_method(NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH, + NETCONFIG_NETWORK_INTERFACE, "CheckProfilePrivilege", NULL, &Error); + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to check profile privilege"); //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + g_variant_unref(message); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +static int __net_init_profile_info(net_profile_info_s *ProfInfo) +{ + int i = 0; + net_dev_info_s *net_info = NULL; + + if (ProfInfo == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid Parameter\n"); + return NET_ERR_INVALID_PARAM; + } + + memset(ProfInfo, 0, sizeof(net_profile_info_s)); + ProfInfo->Favourite = (char)FALSE; + + ProfInfo->Strength = 0; + ProfInfo->frequency = 0; + ProfInfo->max_rate = 0; + ProfInfo->wlan_mode = 0; + ProfInfo->PassphraseRequired = FALSE; + ProfInfo->security_info.sec_mode = 0; + ProfInfo->security_info.enc_mode = 0; + ProfInfo->security_info.wps_support = FALSE; + + net_info = &(ProfInfo->net_info); + + net_info->DnsCount = 0; + + for (i = 0; i < NET_DNS_ADDR_MAX; i++) { + net_info->DnsAddr[i].Type = NET_ADDR_IPV4; + net_info->DnsAddr[i].Data.Ipv4.s_addr = 0; + } + + net_info->IpConfigType = 0; + net_info->IpAddr.Type = NET_ADDR_IPV4; + net_info->IpAddr.Data.Ipv4.s_addr = 0; + net_info->BNetmask = FALSE; + net_info->SubnetMask.Type = NET_ADDR_IPV4; + net_info->SubnetMask.Data.Ipv4.s_addr = 0; + net_info->BDefGateway = FALSE; + net_info->GatewayAddr.Type = NET_ADDR_IPV4; + net_info->GatewayAddr.Data.Ipv4.s_addr = 0; + + net_info->IpConfigType6 = 0; + net_info->IpAddr6.Type = NET_ADDR_IPV6; + inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6); + net_info->PrefixLen6 = 0; + net_info->BDefGateway6 = FALSE; + net_info->GatewayAddr6.Type = NET_ADDR_IPV6; + inet_pton(AF_INET6, "::", &net_info->GatewayAddr6.Data.Ipv6); + + net_info->ProxyMethod = NET_PROXY_TYPE_UNKNOWN; + + return NET_ERR_NONE; +} + +static net_wifi_state_e __net_get_wifi_connection_state(net_err_e *net_error) +{ + net_err_e Error = NET_ERR_NONE; + char *wifi_state = NULL; + net_wifi_state_e current_state = NetworkInfo.wifi_state; + + __NETWORK_FUNC_ENTER__; + Error = _net_dbus_get_wifi_state(&wifi_state); + + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Failed to get wifi state[%s]", //LCOV_EXCL_LINE + _net_print_error(Error)); + + *net_error = Error; //LCOV_EXCL_LINE + + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return current_state; //LCOV_EXCL_LINE + } + + //LCOV_EXCL_START + if (g_strcmp0(wifi_state, "unknown") == 0) + current_state = WIFI_UNKNOWN; + else if (g_strcmp0(wifi_state, "deactivated") == 0) + current_state = WIFI_OFF; + else if (g_strcmp0(wifi_state, "disconnected") == 0) + current_state = WIFI_ON; + else if (g_strcmp0(wifi_state, "association") == 0) + current_state = WIFI_ASSOCIATION; + else if (g_strcmp0(wifi_state, "configuration") == 0) + current_state = WIFI_CONFIGURATION; + else if (g_strcmp0(wifi_state, "connected") == 0) + current_state = WIFI_CONNECTED; + //LCOV_EXCL_STOP + + g_free(wifi_state); + + if (current_state == WIFI_CONNECTED && + request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].flag == TRUE) + current_state = WIFI_DISCONNECTING; //LCOV_EXCL_LINE + + *net_error = Error; + + __NETWORK_FUNC_EXIT__; + return current_state; +} + +//LCOV_EXCL_START +static int __net_extract_ip(const gchar *value, net_addr_s *ipAddr) +{ + __NETWORK_FUNC_ENTER__; + + unsigned char *ipValue = NULL; + char *saveptr = NULL; + char ipString[NET_IPV4_STR_LEN_MAX+1]; + char* ipToken[4]; + + ipValue = (unsigned char *)&(ipAddr->Data.Ipv4.s_addr); + + if (value != NULL) { + g_strlcpy(ipString, value, NET_IPV4_STR_LEN_MAX+1); + + ipToken[0] = strtok_r(ipString, ".", &saveptr); + + if (ipToken[0] != NULL) { + ipToken[1] = strtok_r(NULL, ".", &saveptr); + + if (ipToken[1] != NULL) { + ipToken[2] = strtok_r(NULL, ".", &saveptr); + + if (ipToken[2] != NULL) { + ipToken[3] = strtok_r(NULL, ".", &saveptr); + + if (ipToken[3] != NULL) { + ipValue[0] = (unsigned char)atoi(ipToken[0]); + ipValue[1] = (unsigned char)atoi(ipToken[1]); + ipValue[2] = (unsigned char)atoi(ipToken[2]); + ipValue[3] = (unsigned char)atoi(ipToken[3]); + } + } + } + } + } + + __NETWORK_FUNC_EXIT__; + + return NET_ERR_NONE; +} + +static int __net_extract_common_info(const char *key, GVariant *variant, net_profile_info_s* ProfInfo) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + const gchar *subKey = NULL; + const gchar *value = NULL; + net_dev_info_s* net_info = NULL; + GVariant *var = NULL; + GVariantIter *iter = NULL; + + net_info = &(ProfInfo->net_info); + + if (g_strcmp0(key, "State") == 0) { + value = g_variant_get_string(variant, NULL); + + if (g_strcmp0(value, "idle") == 0) + ProfInfo->ProfileState = NET_STATE_TYPE_IDLE; + else if (g_strcmp0(value, "failure") == 0) + ProfInfo->ProfileState = NET_STATE_TYPE_FAILURE; + else if (g_strcmp0(value, "association") == 0) + ProfInfo->ProfileState = NET_STATE_TYPE_ASSOCIATION; + else if (g_strcmp0(value, "configuration") == 0) + ProfInfo->ProfileState = NET_STATE_TYPE_CONFIGURATION; + else if (g_strcmp0(value, "ready") == 0) + ProfInfo->ProfileState = NET_STATE_TYPE_READY; + else if (g_strcmp0(value, "disconnect") == 0) + ProfInfo->ProfileState = NET_STATE_TYPE_DISCONNECT; + else if (g_strcmp0(value, "online") == 0) + ProfInfo->ProfileState = NET_STATE_TYPE_ONLINE; + else + ProfInfo->ProfileState = NET_STATE_TYPE_UNKNOWN; + } else if (g_strcmp0(key, "Error") == 0) { + value = g_variant_get_string(variant, NULL); + + if (g_strcmp0(value, "invalid-key") == 0) + ProfInfo->ProfileErrorState = NET_STATE_ERROR_INVALID_KEY; + else if (g_strcmp0(value, "connect-failed") == 0) + ProfInfo->ProfileErrorState = NET_STATE_ERROR_CONNECT_FAILED; + else if (g_strcmp0(value, "auth-failed") == 0) + ProfInfo->ProfileErrorState = NET_STATE_ERROR_AUTH_FAILED; + else if (g_strcmp0(value, "login-failed") == 0) + ProfInfo->ProfileErrorState = NET_STATE_ERROR_LOGIN_FAILED; + else if (g_strcmp0(value, "dhcp-failed") == 0) + ProfInfo->ProfileErrorState = NET_STATE_ERROR_DHCP_FAILED; + else if (g_strcmp0(value, "out-of-range") == 0) + ProfInfo->ProfileErrorState = NET_STATE_ERROR_OUT_OF_RANGE; + else if (g_strcmp0(value, "pin-missing") == 0) + ProfInfo->ProfileErrorState = NET_STATE_ERROR_PIN_MISSING; + } else if (g_strcmp0(key, "Favorite") == 0) { + gboolean val = g_variant_get_boolean(variant); + + if (val) + ProfInfo->Favourite = (char)TRUE; + else + ProfInfo->Favourite = (char)FALSE; + } else if (g_strcmp0(key, "Ethernet") == 0) { + g_variant_get(variant, "a{sv}", &iter); + while (g_variant_iter_loop(iter, "{sv}", &subKey, &var)) { + if (g_strcmp0(subKey, "Interface") == 0) { + value = g_variant_get_string(var, NULL); + + if (value != NULL) + g_strlcpy(net_info->DevName, value, NET_MAX_DEVICE_NAME_LEN); + } else if (g_strcmp0(subKey, "Address") == 0) { + value = g_variant_get_string(var, NULL); + + if (value != NULL) + g_strlcpy(net_info->MacAddr, value, NET_MAX_MAC_ADDR_LEN); + } + } + g_variant_iter_free(iter); + } else if (g_strcmp0(key, "IPv4") == 0) { + g_variant_get(variant, "a{sv}", &iter); + while (g_variant_iter_loop(iter, "{sv}", &subKey, &var)) { + if (g_strcmp0(subKey, "Method") == 0) { + value = g_variant_get_string(var, NULL); + + if (g_strcmp0(value, "dhcp") == 0) + net_info->IpConfigType = NET_IP_CONFIG_TYPE_DYNAMIC; + else if (g_strcmp0(value, "manual") == 0) + net_info->IpConfigType = NET_IP_CONFIG_TYPE_STATIC; + else if (g_strcmp0(value, "fixed") == 0) + net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED; + else if (g_strcmp0(value, "off") == 0) + net_info->IpConfigType = NET_IP_CONFIG_TYPE_OFF; + + } else if (g_strcmp0(subKey, "Address") == 0) { + value = g_variant_get_string(var, NULL); + + __net_extract_ip(value, &net_info->IpAddr); + } else if (g_strcmp0(subKey, "Netmask") == 0) { + value = g_variant_get_string(var, NULL); + + __net_extract_ip(value, &net_info->SubnetMask); + net_info->BNetmask = TRUE; + } else if (g_strcmp0(subKey, "Gateway") == 0) { + value = g_variant_get_string(var, NULL); + + __net_extract_ip(value, &net_info->GatewayAddr); + net_info->BDefGateway = TRUE; + } + } + g_variant_iter_free(iter); + } else if (g_strcmp0(key, "IPv4.Configuration") == 0) { + if (net_info->IpConfigType != NET_IP_CONFIG_TYPE_DYNAMIC && + net_info->IpConfigType != NET_IP_CONFIG_TYPE_STATIC && + net_info->IpConfigType != NET_IP_CONFIG_TYPE_FIXED && + net_info->IpConfigType != NET_IP_CONFIG_TYPE_OFF) { + + g_variant_get(variant, "a{sv}", &iter); + while (g_variant_iter_loop(iter, "{sv}", &subKey, &var)) { + if (g_strcmp0(subKey, "Method") == 0) { + value = g_variant_get_string(var, NULL); + + if (g_strcmp0(value, "dhcp") == 0) + net_info->IpConfigType = NET_IP_CONFIG_TYPE_DYNAMIC; + else if (g_strcmp0(value, "manual") == 0) + net_info->IpConfigType = NET_IP_CONFIG_TYPE_STATIC; + else if (g_strcmp0(value, "fixed") == 0) + net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED; + else if (g_strcmp0(value, "off") == 0) + net_info->IpConfigType = NET_IP_CONFIG_TYPE_OFF; + + } else if (g_strcmp0(subKey, "Address") == 0 && + net_info->IpAddr.Data.Ipv4.s_addr == 0) { + value = g_variant_get_string(var, NULL); + + __net_extract_ip(value, &net_info->IpAddr); + } else if (g_strcmp0(subKey, "Netmask") == 0 && + net_info->SubnetMask.Data.Ipv4.s_addr == 0) { + value = g_variant_get_string(var, NULL); + + __net_extract_ip(value, &net_info->SubnetMask); + net_info->BNetmask = TRUE; + } else if (g_strcmp0(subKey, "Gateway") == 0 && + net_info->GatewayAddr.Data.Ipv4.s_addr == 0) { + value = g_variant_get_string(var, NULL); + + __net_extract_ip(value, &net_info->GatewayAddr); + net_info->BDefGateway = TRUE; + } + } + g_variant_iter_free(iter); + } + } else if (g_strcmp0(key, "IPv6") == 0) { + g_variant_get(variant, "a{sv}", &iter); + while (g_variant_iter_loop(iter, "{sv}", &subKey, &var)) { + if (g_strcmp0(subKey, "Method") == 0) { + value = g_variant_get_string(var, NULL); + + if (g_strcmp0(value, "manual") == 0) + net_info->IpConfigType6 = NET_IP_CONFIG_TYPE_STATIC; + else if (g_strcmp0(value, "off") == 0) + net_info->IpConfigType6 = NET_IP_CONFIG_TYPE_OFF; + else if (g_strcmp0(value, "auto") == 0) + net_info->IpConfigType6 = NET_IP_CONFIG_TYPE_AUTO_IP; + + } else if (g_strcmp0(subKey, "Address") == 0) { + value = g_variant_get_string(var, NULL); + + inet_pton(AF_INET6, value, &net_info->IpAddr6.Data.Ipv6); + } else if (g_strcmp0(subKey, "PrefixLength") == 0) { + net_info->PrefixLen6 = g_variant_get_byte(var); + } else if (g_strcmp0(subKey, "Gateway") == 0) { + value = g_variant_get_string(var, NULL); + + inet_pton(AF_INET6, value, &net_info->GatewayAddr6.Data.Ipv6); + net_info->BDefGateway6 = TRUE; + } else if (g_strcmp0(subKey, "Privacy") == 0) { + value = g_variant_get_string(var, NULL); + + if (value != NULL) + g_strlcpy(net_info->Privacy6, value, NET_IPV6_MAX_PRIVACY_LEN); + } + } + g_variant_iter_free(iter); + } else if (g_strcmp0(key, "IPv6.Configuration") == 0) { + g_variant_get(variant, "a{sv}", &iter); + while (g_variant_iter_loop(iter, "{sv}", &subKey, &var)) { + if (g_strcmp0(subKey, "Method") == 0) { + value = g_variant_get_string(var, NULL); + + if (g_strcmp0(value, "manual") == 0) + net_info->IpConfigType6 = NET_IP_CONFIG_TYPE_STATIC; + else if (g_strcmp0(value, "off") == 0) + net_info->IpConfigType6 = NET_IP_CONFIG_TYPE_OFF; + else if (g_strcmp0(value, "auto") == 0) + net_info->IpConfigType6 = NET_IP_CONFIG_TYPE_AUTO_IP; + + } else if (g_strcmp0(subKey, "Address") == 0) { + value = g_variant_get_string(var, NULL); + + inet_pton(AF_INET6, value, &net_info->IpAddr6.Data.Ipv6); + } else if (g_strcmp0(subKey, "PrefixLength") == 0) { + net_info->PrefixLen6 = g_variant_get_byte(var); + } else if (g_strcmp0(subKey, "Gateway") == 0) { + value = g_variant_get_string(var, NULL); + + inet_pton(AF_INET6, value, &net_info->GatewayAddr6.Data.Ipv6); + net_info->BDefGateway6 = TRUE; + } else if (g_strcmp0(subKey, "Privacy") == 0) { + value = g_variant_get_string(var, NULL); + + if (value != NULL) + g_strlcpy(net_info->Privacy6, value, NET_IPV6_MAX_PRIVACY_LEN); + } + } + g_variant_iter_free(iter); + } else if (g_strcmp0(key, "Nameservers") == 0) { + int dnsCount = 0; + + g_variant_get(variant, "as", &iter); + while (g_variant_iter_loop(iter, "s", &value)) { + if (g_strcmp0(value, "dhcp") == 0 || g_strcmp0(value, "manual") == 0) + continue; + __net_extract_ip(value, &net_info->DnsAddr[dnsCount]); + + dnsCount++; + if (dnsCount >= NET_DNS_ADDR_MAX) { + if (NULL != value) + g_free((gchar*)value); + break; + } + } + + g_variant_iter_free(iter); + + net_info->DnsCount = dnsCount; + } else if (g_strcmp0(key, "Nameservers.Configuration") == 0 && net_info->DnsCount == 0) { + int dnsCount = 0; + + g_variant_get(variant, "as", &iter); + while (g_variant_iter_loop(iter, "s", &value)) { + if (g_strcmp0(value, "dhcp") == 0 || g_strcmp0(value, "manual") == 0 + || g_strcmp0(value, "unknown") == 0) + continue; + __net_extract_ip(value, &net_info->DnsAddr[dnsCount]); + + dnsCount++; + if (dnsCount >= NET_DNS_ADDR_MAX) { + if (NULL != value) + g_free((gchar*)value); + break; + } + } + g_variant_iter_free(iter); + + net_info->DnsCount = dnsCount; + } else if (g_strcmp0(key, "Domains") == 0) { + } else if (g_strcmp0(key, "Domains.Configuration") == 0) { + } else if (g_strcmp0(key, "Proxy") == 0) { + const gchar *url = NULL; + gchar *servers = NULL; + + g_variant_get(variant, "a{sv}", &iter); + while (g_variant_iter_loop(iter, "{sv}", &subKey, &var)) { + if (g_strcmp0(subKey, "Method") == 0) { + value = g_variant_get_string(var, NULL); + + if (g_strcmp0(value, "direct") == 0) + net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT; + else if (g_strcmp0(value, "auto") == 0) + net_info->ProxyMethod = NET_PROXY_TYPE_AUTO; + else if (g_strcmp0(value, "manual") == 0) + net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL; + else + net_info->ProxyMethod = NET_PROXY_TYPE_UNKNOWN; + } else if (g_strcmp0(subKey, "URL") == 0) { + url = g_variant_get_string(var, NULL); + } else if (g_strcmp0(subKey, "Servers") == 0) { + GVariantIter *iter_sub = NULL; + + g_variant_get(var, "as", &iter_sub); + g_variant_iter_loop(iter_sub, "s", &servers); + g_variant_iter_free(iter_sub); + } + } + g_variant_iter_free(iter); + + if (net_info->ProxyMethod == NET_PROXY_TYPE_AUTO && url != NULL) + g_strlcpy(net_info->ProxyAddr, url, NET_PROXY_LEN_MAX); + else if (net_info->ProxyMethod == NET_PROXY_TYPE_MANUAL && servers != NULL) + g_strlcpy(net_info->ProxyAddr, servers, NET_PROXY_LEN_MAX); + + if (servers) + g_free(servers); + } else if (g_strcmp0(key, "Proxy.Configuration") == 0 && + net_info->ProxyMethod != NET_PROXY_TYPE_AUTO && + net_info->ProxyMethod != NET_PROXY_TYPE_MANUAL) { + + const gchar *url = NULL; + gchar *servers = NULL; + + g_variant_get(variant, "a{sv}", &iter); + while (g_variant_iter_loop(iter, "{sv}", &subKey, &var)) { + if (g_strcmp0(subKey, "Method") == 0) { + value = g_variant_get_string(var, NULL); + + if (g_strcmp0(value, "direct") == 0) + net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT; + else if (g_strcmp0(value, "auto") == 0) + net_info->ProxyMethod = NET_PROXY_TYPE_AUTO; + else if (g_strcmp0(value, "manual") == 0) + net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL; + else + net_info->ProxyMethod = NET_PROXY_TYPE_UNKNOWN; + } else if (g_strcmp0(subKey, "URL") == 0) { + url = g_variant_get_string(var, NULL); + } else if (g_strcmp0(subKey, "Servers") == 0) { + GVariantIter *iter_sub = NULL; + + g_variant_get(var, "as", &iter_sub); + g_variant_iter_loop(iter_sub, "s", &servers); + g_variant_iter_free(iter_sub); + } + } + g_variant_iter_free(iter); + + if (net_info->ProxyMethod == NET_PROXY_TYPE_AUTO && url != NULL) + g_strlcpy(net_info->ProxyAddr, url, NET_PROXY_LEN_MAX); + else if (net_info->ProxyMethod == NET_PROXY_TYPE_MANUAL && servers != NULL) + g_strlcpy(net_info->ProxyAddr, servers, NET_PROXY_LEN_MAX); + + if (servers) + g_free(servers); + } else if (g_strcmp0(key, "Provider") == 0) { + /* Do noting */ + } + + __NETWORK_FUNC_EXIT__; + return Error; +} + +static wlan_eap_type_e __convert_eap_type_from_string(const char *eap_type) +{ + if (eap_type == NULL) + return WLAN_SEC_EAP_TYPE_PEAP; + else if (g_strcmp0(eap_type, "peap") == 0) + return WLAN_SEC_EAP_TYPE_PEAP; + else if (g_strcmp0(eap_type, "tls") == 0) + return WLAN_SEC_EAP_TYPE_TLS; + else if (g_strcmp0(eap_type, "ttls") == 0) + return WLAN_SEC_EAP_TYPE_TTLS; + else if (g_strcmp0(eap_type, "sim") == 0) + return WLAN_SEC_EAP_TYPE_SIM; + else if (g_strcmp0(eap_type, "aka") == 0) + return WLAN_SEC_EAP_TYPE_AKA; + else + return WLAN_SEC_EAP_TYPE_PEAP; +} + +static wlan_eap_auth_type_e __convert_eap_auth_from_string(const char *eap_auth) +{ + if (eap_auth == NULL) + return WLAN_SEC_EAP_AUTH_NONE; + else if (g_strcmp0(eap_auth, "NONE") == 0) + return WLAN_SEC_EAP_AUTH_NONE; + else if (g_strcmp0(eap_auth, "PAP") == 0) + return WLAN_SEC_EAP_AUTH_PAP; + else if (g_strcmp0(eap_auth, "MSCHAP") == 0) + return WLAN_SEC_EAP_AUTH_MSCHAP; + else if (g_strcmp0(eap_auth, "MSCHAPV2") == 0) + return WLAN_SEC_EAP_AUTH_MSCHAPV2; + else if (g_strcmp0(eap_auth, "GTC") == 0) + return WLAN_SEC_EAP_AUTH_GTC; + else if (g_strcmp0(eap_auth, "MD5") == 0) + return WLAN_SEC_EAP_AUTH_MD5; + else + return WLAN_SEC_EAP_AUTH_NONE; +} + +static int __net_update_connected_wifi_info(net_profile_info_s* ProfInfo) +{ + static char ifname[NET_MAX_DEVICE_NAME_LEN+1] = { '\0', }; + static char interface_path[DBUS_OBJECT_PATH_MAX] = { '\0', }; + char current_bss_path[DBUS_OBJECT_PATH_MAX] = { '\0', }; + net_err_e Error = NET_ERR_NONE; + GVariant *params = NULL; + GVariant *reply = NULL; + GVariant *value = NULL; + GVariantIter *iter = NULL; + gchar *key = NULL; + const char *path = NULL; + + /* Get proper interface */ + if (g_strcmp0(ProfInfo->net_info.DevName, ifname) != 0) { + g_strlcpy(ifname, ProfInfo->net_info.DevName, + NET_MAX_DEVICE_NAME_LEN+1); + + params = g_variant_new("(s)", ifname); + reply = _net_invoke_dbus_method(SUPPLICANT_SERVICE, SUPPLICANT_PATH, + SUPPLICANT_INTERFACE, "GetInterface", params, &Error); + if (reply == NULL) { + ifname[0] = '\0'; + WIFI_LOG(WIFI_ERROR, "Failed to get Wi-Fi interface"); + return Error; + } + g_variant_get(reply, "(o)", &path); + g_strlcpy(interface_path, path, DBUS_OBJECT_PATH_MAX); + + g_variant_unref(reply); + } + + /* Get CurrentBSS object path */ + params = g_variant_new("(ss)", SUPPLICANT_IFACE_INTERFACE, "CurrentBSS"); + reply = _net_invoke_dbus_method(SUPPLICANT_SERVICE, interface_path, + DBUS_PROPERTIES_INTERFACE, "Get", params, &Error); + if (reply == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to get CurrentBSS"); + return Error; + } + g_variant_get(reply, "(v)", &value); + path = g_variant_get_string(value, NULL); + g_strlcpy(current_bss_path, path, DBUS_OBJECT_PATH_MAX); + + g_variant_unref(value); + g_variant_unref(reply); + + /* Get Wi-Fi information */ + params = g_variant_new("(s)", SUPPLICANT_IFACE_BSS); + reply = _net_invoke_dbus_method(SUPPLICANT_SERVICE, current_bss_path, + DBUS_PROPERTIES_INTERFACE, "GetAll", params, &Error); + if (reply == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to get Wi-Fi information"); + return Error; + } + g_variant_get(reply, "(a{sv})", &iter); + while (g_variant_iter_loop(iter, "{sv}", &key, &value)) { + if (g_strcmp0(key, "BSSID") == 0) { + gsize bssid_len = 0; + const gchar *bssid = NULL; + + bssid = + g_variant_get_fixed_array(value, &bssid_len, sizeof(guchar)); + if (bssid && bssid_len == 6) + snprintf(ProfInfo->bssid, 18, + "%02x:%02x:%02x:%02x:%02x:%02x", + bssid[0], bssid[1], bssid[2], + bssid[3], bssid[4], bssid[5]); + + } else if (g_strcmp0(key, "Signal") == 0) { + ProfInfo->Strength = + (unsigned char)(120 + g_variant_get_int16(value)); + + if (ProfInfo->Strength > 100) + ProfInfo->Strength = 100; + + } else if (g_strcmp0(key, "Frequency") == 0) { + ProfInfo->frequency = + (unsigned int)g_variant_get_uint16(value); + + } else if (g_strcmp0(key, "Rates") == 0) { + GVariantIter *iter_sub = NULL; + guint32 value_sub; + + g_variant_get(value, "au", &iter_sub); + while (g_variant_iter_loop(iter_sub, "u", &value_sub)) { + ProfInfo->max_rate = (unsigned int)value_sub; + break; + } + + g_variant_iter_free(iter_sub); + } + } + + g_variant_iter_free(iter); + g_variant_unref(reply); + + return Error; +} + +static int __net_wifi_modify_profile(const char* ProfileName, + net_profile_info_s* ProfInfo, net_profile_info_s* exProfInfo) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + int i = 0; + char profilePath[NET_PROFILE_NAME_LEN_MAX+1] = ""; + + wlan_security_info_s *security_info = &(ProfInfo->security_info); + wlan_security_info_s *ex_security_info = &(exProfInfo->security_info); + net_dev_info_s *net_info = &(ProfInfo->net_info); + net_dev_info_s *ex_net_info = &(exProfInfo->net_info); + + g_strlcpy(profilePath, ProfileName, NET_PROFILE_NAME_LEN_MAX+1); + + /* Compare and Set 'Passphrase' */ + if (ex_security_info->sec_mode == WLAN_SEC_MODE_WEP) { + if (g_strcmp0(security_info->authentication.wep.wepKey, + ex_security_info->authentication.wep.wepKey) != 0) { + Error = _net_dbus_set_agent_passphrase_and_connect( + security_info->authentication.wep.wepKey, ProfileName); + + if (NET_ERR_NONE != Error) { + WIFI_LOG(WIFI_ERROR, "Failed to set agent field"); + + __NETWORK_FUNC_EXIT__; + return Error; + } + } + } else if (ex_security_info->sec_mode == WLAN_SEC_MODE_WPA_PSK || + ex_security_info->sec_mode == WLAN_SEC_MODE_WPA2_PSK) { + if (g_strcmp0(security_info->authentication.psk.pskKey, + ex_security_info->authentication.psk.pskKey) != 0) { + Error = _net_dbus_set_agent_passphrase_and_connect( + security_info->authentication.psk.pskKey, ProfileName); + + if (NET_ERR_NONE != Error) { + WIFI_LOG(WIFI_ERROR, "Failed to set agent field"); + + __NETWORK_FUNC_EXIT__; + return Error; + } + } + } + + /* Compare and Set 'Proxy' */ + if ((ex_net_info->ProxyMethod != net_info->ProxyMethod) || + (g_strcmp0(ex_net_info->ProxyAddr, net_info->ProxyAddr) != 0)) { + + Error = _net_dbus_set_proxy(ProfInfo, profilePath); + + if (Error != NET_ERR_NONE) { + __NETWORK_FUNC_EXIT__; + return Error; + } + } + + /* Compare and Set 'IPv4 addresses' */ + if ((ex_net_info->IpConfigType != net_info->IpConfigType) || + (net_info->IpConfigType == NET_IP_CONFIG_TYPE_STATIC && + (net_info->IpAddr.Data.Ipv4.s_addr != ex_net_info->IpAddr.Data.Ipv4.s_addr || + net_info->SubnetMask.Data.Ipv4.s_addr != ex_net_info->SubnetMask.Data.Ipv4.s_addr || + net_info->GatewayAddr.Data.Ipv4.s_addr != ex_net_info->GatewayAddr.Data.Ipv4.s_addr))) { + Error = _net_dbus_set_profile_ipv4(ProfInfo, profilePath); + + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Failed to set IPv4"); + + __NETWORK_FUNC_EXIT__; + return Error; + } + } + + /* Compare and Set 'IPv6 addresses' */ + if ((ex_net_info->IpConfigType6 != net_info->IpConfigType6) || + (net_info->IpConfigType6 == NET_IP_CONFIG_TYPE_STATIC && + (net_info->IpAddr6.Data.Ipv6.s6_addr != ex_net_info->IpAddr6.Data.Ipv6.s6_addr || + net_info->PrefixLen6 != ex_net_info->PrefixLen6 || + net_info->GatewayAddr6.Data.Ipv6.s6_addr != ex_net_info->GatewayAddr6.Data.Ipv6.s6_addr))) { + + Error = _net_dbus_set_profile_ipv6(ProfInfo, profilePath); + + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Error!!! Can't set IPv6\n"); + + __NETWORK_FUNC_EXIT__; + return Error; + } + } + + /* Compare and Set 'DNS addresses' */ + for (i = 0; i < net_info->DnsCount; i++) { + if (i >= NET_DNS_ADDR_MAX) { + net_info->DnsCount = NET_DNS_ADDR_MAX; + + break; + } + + if (net_info->DnsAddr[i].Data.Ipv4.s_addr != + ex_net_info->DnsAddr[i].Data.Ipv4.s_addr) + break; + } + + if (i < net_info->DnsCount) { + Error = _net_dbus_set_profile_dns(ProfInfo, profilePath); + + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Failed to set DNS\n"); + + __NETWORK_FUNC_EXIT__; + return Error; + } + } + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +static int __net_wifi_delete_profile(net_profile_name_s* WifiProfName, + wlan_security_mode_type_e sec_mode, gboolean passpoint) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *message = NULL; + char param0[NET_PROFILE_NAME_LEN_MAX + 8] = ""; + GVariant *params; + + if (passpoint == TRUE && WLAN_SEC_MODE_IEEE8021X == sec_mode) { + message = _net_invoke_dbus_method(CONNMAN_SERVICE, + WifiProfName->ProfileName, + CONNMAN_SERVICE_INTERFACE, "Remove", NULL, + &Error); + + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to Remove service(profile)"); + g_variant_unref(message); + goto done; + } + + g_variant_unref(message); + + g_snprintf(param0, NET_PROFILE_NAME_LEN_MAX + 8, "string:%s", + WifiProfName->ProfileName); + params = g_variant_new("(s)", param0); + + message = _net_invoke_dbus_method(NETCONFIG_SERVICE, + NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE, + "DeleteEapConfig", params, &Error); + } else if (passpoint == TRUE || WLAN_SEC_MODE_IEEE8021X != sec_mode) { + message = _net_invoke_dbus_method(CONNMAN_SERVICE, + WifiProfName->ProfileName, + CONNMAN_SERVICE_INTERFACE, "Remove", NULL, + &Error); + } else { + g_snprintf(param0, NET_PROFILE_NAME_LEN_MAX + 8, "string:%s", + WifiProfName->ProfileName); + params = g_variant_new("(s)", param0); + + message = _net_invoke_dbus_method(NETCONFIG_SERVICE, + NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE, + "DeleteEapConfig", params, &Error); + } + + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to Remove service(profile)"); + goto done; + } + + g_variant_unref(message); +done: + __NETWORK_FUNC_EXIT__; + return Error; +} + +static int __net_extract_wifi_info(GVariantIter *array, net_profile_info_s* ProfInfo) +{ + net_err_e Error = NET_ERR_NONE; + GVariant *var = NULL; + const gchar *key = NULL; + + __NETWORK_FUNC_ENTER__; + + while (g_variant_iter_loop(array, "{sv}", &key, &var)) { + const gchar *value = NULL; + + if (g_strcmp0(key, "Mode") == 0) { + value = g_variant_get_string(var, NULL); + + if (g_strcmp0(value, "managed") == 0) + ProfInfo->wlan_mode = NET_WLAN_CONNMODE_INFRA; + else if (g_strcmp0(value, "adhoc") == 0) + ProfInfo->wlan_mode = NET_WLAN_CONNMODE_ADHOC; + else + ProfInfo->wlan_mode = NET_WLAN_CONNMODE_AUTO; + + } else if (g_strcmp0(key, "Security") == 0) { + GVariantIter *iter_sub = NULL; + + g_variant_get(var, "as", &iter_sub); + while (g_variant_iter_loop(iter_sub, "s", &value)) { + if (g_strcmp0(value, "none") == 0 && + ProfInfo->security_info.sec_mode < WLAN_SEC_MODE_NONE) + ProfInfo->security_info.sec_mode = WLAN_SEC_MODE_NONE; + else if (g_strcmp0(value, "wep") == 0 && + ProfInfo->security_info.sec_mode < WLAN_SEC_MODE_WEP) + ProfInfo->security_info.sec_mode = WLAN_SEC_MODE_WEP; + else if (g_strcmp0(value, "psk") == 0 && + ProfInfo->security_info.sec_mode < WLAN_SEC_MODE_WPA_PSK) + ProfInfo->security_info.sec_mode = WLAN_SEC_MODE_WPA_PSK; + else if (g_strcmp0(value, "ft_psk") == 0 && + ProfInfo->security_info.sec_mode < WLAN_SEC_MODE_WPA_FT_PSK) + ProfInfo->security_info.sec_mode = WLAN_SEC_MODE_WPA_FT_PSK; + else if (g_strcmp0(value, "ieee8021x") == 0 && + ProfInfo->security_info.sec_mode < WLAN_SEC_MODE_IEEE8021X) + ProfInfo->security_info.sec_mode = WLAN_SEC_MODE_IEEE8021X; + else if (g_strcmp0(value, "wpa") == 0 && + ProfInfo->security_info.sec_mode < WLAN_SEC_MODE_WPA_PSK) + ProfInfo->security_info.sec_mode = WLAN_SEC_MODE_WPA_PSK; + else if (g_strcmp0(value, "rsn") == 0 && + ProfInfo->security_info.sec_mode < WLAN_SEC_MODE_WPA_PSK) + ProfInfo->security_info.sec_mode = WLAN_SEC_MODE_WPA2_PSK; + else if (g_strcmp0(value, "wps") == 0) + ProfInfo->security_info.wps_support = TRUE; + else if (ProfInfo->security_info.sec_mode < WLAN_SEC_MODE_NONE) + ProfInfo->security_info.sec_mode = WLAN_SEC_MODE_NONE; + } + g_variant_iter_free(iter_sub); + } else if (g_strcmp0(key, "EncryptionMode") == 0) { + value = g_variant_get_string(var, NULL); + + if (g_strcmp0(value, "none") == 0) + ProfInfo->security_info.enc_mode = WLAN_ENC_MODE_NONE; + else if (g_strcmp0(value, "wep") == 0) + ProfInfo->security_info.enc_mode = WLAN_ENC_MODE_WEP; + else if (g_strcmp0(value, "tkip") == 0) + ProfInfo->security_info.enc_mode = WLAN_ENC_MODE_TKIP; + else if (g_strcmp0(value, "aes") == 0) + ProfInfo->security_info.enc_mode = WLAN_ENC_MODE_AES; + else if (g_strcmp0(value, "mixed") == 0) + ProfInfo->security_info.enc_mode = WLAN_ENC_MODE_TKIP_AES_MIXED; + + } else if (g_strcmp0(key, "Passpoint") == 0) { + gboolean passpoint; + + passpoint = g_variant_get_boolean(var); + if (passpoint) + ProfInfo->passpoint = TRUE; + else + ProfInfo->passpoint = FALSE; + + } else if (g_strcmp0(key, "Strength") == 0) { + ProfInfo->Strength = g_variant_get_byte(var); + } else if (g_strcmp0(key, "Name") == 0) { + value = g_variant_get_string(var, NULL); + + if (value != NULL) + g_strlcpy(ProfInfo->essid, value, NET_WLAN_ESSID_LEN); + } else if (g_strcmp0(key, "Passphrase") == 0) { + wlan_security_info_s *security_info = &(ProfInfo->security_info); + value = g_variant_get_string(var, NULL); + + if (security_info->sec_mode == WLAN_SEC_MODE_WEP && value != NULL) + g_strlcpy(security_info->authentication.wep.wepKey, + value, NET_WLAN_MAX_WEP_KEY_LEN+1); + else if ((security_info->sec_mode == WLAN_SEC_MODE_WPA_PSK || + security_info->sec_mode == WLAN_SEC_MODE_WPA2_PSK) && + value != NULL) + g_strlcpy(security_info->authentication.psk.pskKey, + value, NET_WLAN_MAX_PSK_PASSPHRASE_LEN+1); + } else if (g_strcmp0(key, "PassphraseRequired") == 0) { + gboolean val; + + val = g_variant_get_boolean(var); + + if (val) + ProfInfo->PassphraseRequired = TRUE; + else + ProfInfo->PassphraseRequired = FALSE; + } else if (g_strcmp0(key, "BSSID") == 0) { + value = g_variant_get_string(var, NULL); + + if (value != NULL) + g_strlcpy(ProfInfo->bssid, value, NET_MAX_MAC_ADDR_LEN); + + } else if (g_strcmp0(key, "MaxRate") == 0) { + ProfInfo->max_rate = (unsigned int)g_variant_get_uint32(var); + + } else if (g_strcmp0(key, "Frequency") == 0) { + ProfInfo->frequency = (unsigned int)g_variant_get_uint16(var); + + } else if (g_strcmp0(key, "EAP") == 0) { + value = g_variant_get_string(var, NULL); + + if (value != NULL) + ProfInfo->security_info.authentication.eap.eap_type = + __convert_eap_type_from_string(value); + + } else if (g_strcmp0(key, "Phase2") == 0) { + value = g_variant_get_string(var, NULL); + + if (value != NULL) + ProfInfo->security_info.authentication.eap.eap_auth = + __convert_eap_auth_from_string(value); + + } else if (g_strcmp0(key, "Identity") == 0) { + value = g_variant_get_string(var, NULL); + + if (value != NULL) + g_strlcpy(ProfInfo->security_info.authentication.eap.username, + value, NET_WLAN_USERNAME_LEN+1); + + } else if (g_strcmp0(key, "Password") == 0) { + value = g_variant_get_string(var, NULL); + + if (value != NULL) + g_strlcpy(ProfInfo->security_info.authentication.eap.password, + value, NET_WLAN_PASSWORD_LEN+1); + + } else if (g_strcmp0(key, "CACertFile") == 0) { + value = g_variant_get_string(var, NULL); + + if (value != NULL) + g_strlcpy(ProfInfo->security_info.authentication.eap.ca_cert_filename, + value, NET_WLAN_CA_CERT_FILENAME_LEN+1); + + } else if (g_strcmp0(key, "ClientCertFile") == 0) { + value = g_variant_get_string(var, NULL); + + if (value != NULL) + g_strlcpy(ProfInfo->security_info.authentication.eap.client_cert_filename, + value, NET_WLAN_CLIENT_CERT_FILENAME_LEN+1); + + } else if (g_strcmp0(key, "PrivateKeyFile") == 0) { + value = g_variant_get_string(var, NULL); + + if (value != NULL) + g_strlcpy(ProfInfo->security_info.authentication.eap.private_key_filename, + value, NET_WLAN_PRIVATE_KEY_FILENAME_LEN+1); + + } else if (g_strcmp0(key, "PrivateKeyPassphrase") == 0) { + value = g_variant_get_string(var, NULL); + + if (value != NULL) + g_strlcpy(ProfInfo->security_info.authentication.eap.private_key_passwd, + value, NET_WLAN_PRIVATE_KEY_PASSWD_LEN+1); + + } else if (g_strcmp0(key, "Keymgmt") == 0) { + ProfInfo->security_info.keymgmt = (unsigned int)g_variant_get_uint32(var); + + } else + Error = __net_extract_common_info(key, var, ProfInfo); + } + + /* If there are multiple Wi-Fi networks which have the same SSID, + * and one of them is connected, we need to get the connected one + * rather than ConnMan grouped properties. + */ + if (ProfInfo->ProfileState == NET_STATE_TYPE_READY || + ProfInfo->ProfileState == NET_STATE_TYPE_ONLINE) + Error = __net_update_connected_wifi_info(ProfInfo); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +static int __net_extract_service_info( + const char* ProfileName, GVariantIter *iter, + net_profile_info_s* ProfInfo) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + gchar *key = NULL; + GVariant *value = NULL; + gboolean isProf = FALSE; + + while (g_variant_iter_loop(iter, "{sv}", &key, &value)) { + const gchar *tech = NULL; + + if (g_strcmp0(key, "Type") == 0) { + tech = g_variant_get_string(value, NULL); + + if (g_strcmp0(tech, "wifi") == 0) + isProf = TRUE; + + g_variant_unref(value); + g_free(key); + break; + } + } + + if (isProf) { + if ((Error = __net_init_profile_info(ProfInfo)) != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Failed to init profile"); + __NETWORK_FUNC_EXIT__; + return Error; + } + + g_strlcpy(ProfInfo->ProfileName, ProfileName, NET_PROFILE_NAME_LEN_MAX); + g_strlcpy(ProfInfo->net_info.ProfileName, + ProfileName, NET_PROFILE_NAME_LEN_MAX); + + Error = __net_extract_wifi_info(iter, ProfInfo); + } + + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, + "Failed to extract service information from received message"); + + __NETWORK_FUNC_EXIT__; + return Error; + } + + __NETWORK_FUNC_EXIT__; + return Error; +} + +static int __net_extract_all_services(GVariantIter *array, + const char *service_prefix, GSList **profile_list) +{ + net_profile_info_s *ProfInfo = NULL; + net_err_e Error = NET_ERR_NONE; + gchar *obj; + GVariantIter *next = NULL; + + __NETWORK_FUNC_ENTER__; + + if (array == NULL || service_prefix == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); + + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_PARAM; + } + + while (g_variant_iter_loop(array, "(oa{sv})", &obj, &next)) { + if (obj == NULL) + continue; + + if (g_str_has_prefix(obj, service_prefix) == TRUE) { + ProfInfo = g_try_malloc0(sizeof(net_profile_info_s)); + + if ((Error = __net_init_profile_info(ProfInfo)) != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Failed to init profile"); + goto error; + } + + if (g_strrstr(obj + strlen(service_prefix), "hidden") != NULL) + ProfInfo->is_hidden = TRUE; + + g_strlcpy(ProfInfo->ProfileName, obj, NET_PROFILE_NAME_LEN_MAX); + + g_strlcpy(ProfInfo->net_info.ProfileName, + obj, NET_PROFILE_NAME_LEN_MAX); + + Error = __net_extract_wifi_info(next, ProfInfo); + + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Failed to extract service info"); + goto error; + } + + *profile_list = g_slist_append(*profile_list, (net_profile_info_s *)ProfInfo); + } + } + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; + +error: + if (next) + g_variant_iter_free(next); + if (obj) + g_free(obj); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +static int __net_extract_services(GVariantIter *message, GSList **profile_list) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + char *service_prefix = NULL; + + service_prefix = CONNMAN_WIFI_SERVICE_PROFILE_PREFIX; + + Error = __net_extract_all_services(message, service_prefix, profile_list); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Failed to extract services from received message"); + __NETWORK_FUNC_EXIT__; + return Error; + } + + __NETWORK_FUNC_EXIT__; + return Error; +} + +static int __net_get_profile_info( + const char* ProfileName, net_profile_info_s* ProfInfo) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *message = NULL; + GVariantIter *iter = NULL; + GVariantIter *service = NULL; + gchar *path = NULL; + + message = _net_invoke_dbus_method(CONNMAN_SERVICE, CONNMAN_MANAGER_PATH, + CONNMAN_MANAGER_INTERFACE, "GetServices", NULL, &Error); + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to get profile"); + goto done; + } + + g_variant_get(message, "(a(oa{sv}))", &iter); + while (g_variant_iter_loop(iter, "(oa{sv})", &path, &service)) { + if (g_strcmp0(ProfileName, path) == 0) { + Error = __net_extract_service_info(ProfileName, service, ProfInfo); + g_variant_iter_free(service); + g_free(path); + break; + } + } + + g_variant_iter_free(iter); + g_variant_unref(message); + +done: + __NETWORK_FUNC_EXIT__; + return Error; +} + +static gboolean __net_is_connecting(const char *profile_name) +{ + __NETWORK_FUNC_ENTER__; + + char *svc_name1 = request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].ProfileName; + char *svc_name2 = request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].ProfileName; + + if (request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag == TRUE && + g_strcmp0(profile_name, svc_name1) == 0) { + __NETWORK_FUNC_EXIT__; + return TRUE; + } else if (request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag == TRUE && + g_strcmp0(profile_name, svc_name2) == 0) { + __NETWORK_FUNC_EXIT__; + return TRUE; + } + + __NETWORK_FUNC_EXIT__; + return FALSE; +} + +static void __net_abort_open_connection(const char *profile_name) +{ + __NETWORK_FUNC_ENTER__; + + net_event_info_s event_data; + char event_string[64]; + + char *svc_name1 = request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].ProfileName; + char *svc_name2 = request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].ProfileName; + + if (request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag == TRUE && + g_strcmp0(profile_name, svc_name1) == 0) { + memset(&request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION], 0, + sizeof(network_request_table_s)); + + event_data.Event = NET_EVENT_OPEN_RSP; + g_strlcpy(event_string, "Sending NET_EVENT_OPEN_RSP", 64); + + _net_dbus_pending_call_unref(); + } else if (request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag == TRUE && + g_strcmp0(profile_name, svc_name2) == 0) { + memset(&request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS], 0, + sizeof(network_request_table_s)); + + event_data.Event = NET_EVENT_WIFI_WPS_RSP; + g_strlcpy(event_string, "Sending NET_EVENT_WIFI_WPS_RSP", 64); + + _net_dbus_pending_call_unref(); + } else { + __NETWORK_FUNC_EXIT__; + return; + } + + g_strlcpy(event_data.ProfileName, profile_name, NET_PROFILE_NAME_LEN_MAX+1); + event_data.Error = NET_ERR_OPERATION_ABORTED; + event_data.Datalength = 0; + event_data.Data = NULL; + + WIFI_LOG(WIFI_INFO, "%s, Error: %d", event_string, event_data.Error); + _net_client_callback(&event_data); + + __NETWORK_FUNC_EXIT__; +} +//LCOV_EXCL_STOP + +int _net_check_profile_name(const char* ProfileName) +{ + __NETWORK_FUNC_ENTER__; + + const char *profileHeader = CONNMAN_PATH"/service/"; + int i = 0; + int stringLen = 0; + + if (ProfileName == NULL || strlen(ProfileName) <= strlen(profileHeader)) { + WIFI_LOG(WIFI_ERROR, "Profile name is invalid"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_PARAM; //LCOV_EXCL_LINE + } + + stringLen = strlen(ProfileName); + + if (strncmp(profileHeader, ProfileName, strlen(profileHeader)) == 0) { + for (i = 0; i < stringLen; i++) { + if (isgraph(ProfileName[i]) == 0) { + WIFI_LOG(WIFI_ERROR, "Profile name is invalid"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_PARAM; //LCOV_EXCL_LINE + } + } + } else { + WIFI_LOG(WIFI_ERROR, "Profile name is invalid"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_PARAM; //LCOV_EXCL_LINE + } + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +int _net_get_profile_list(GSList **profile_list) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *message; + GVariantIter *iter; + + message = _net_invoke_dbus_method(CONNMAN_SERVICE, CONNMAN_MANAGER_PATH, + CONNMAN_MANAGER_INTERFACE, "GetServices", NULL, &Error); + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to get service(profile) list"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + g_variant_get(message, "(a(oa{sv}))", &iter); + Error = __net_extract_services(iter, profile_list); + + if (iter != NULL) + g_variant_iter_free(iter); + + g_variant_unref(message); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int net_specific_scan_wifi(const char *ssid) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (ssid == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_PARAM; //LCOV_EXCL_LINE + } + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + if (request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN].flag == TRUE) { + WIFI_LOG(WIFI_ERROR, "Find hidden AP request in progress"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_IN_PROGRESS; //LCOV_EXCL_LINE + } + + if (NetworkInfo.wifi_state == WIFI_OFF) { + if ((NetworkInfo.wifi_state = _net_get_wifi_state(&Error)) == WIFI_OFF) { + WIFI_LOG(WIFI_ERROR, "Wi-Fi is powered off!"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_OPERATION; //LCOV_EXCL_LINE + } + } + + if (_net_dbus_is_pending_call_used() == TRUE) { + WIFI_LOG(WIFI_ERROR, "pending call in progress"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_OPERATION; //LCOV_EXCL_LINE + } + + request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN].flag = TRUE; + + Error = _net_dbus_specific_scan_request(ssid); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "_net_dbus_specific_scan_request() failed. Error [%s]", + _net_print_error(Error)); + + memset(&request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN], 0, //LCOV_EXCL_LINE + sizeof(network_request_table_s)); + } + + __NETWORK_FUNC_EXIT__; + return Error; +} + +//LCOV_EXCL_START +int net_wps_scan_wifi(void) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_APP_NOT_REGISTERED; + } + + if (_net_dbus_is_pending_call_used() == TRUE) { + WIFI_LOG(WIFI_ERROR, "pending call in progress"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_OPERATION; + } + + request_table[NETWORK_REQUEST_TYPE_WPS_SCAN].flag = TRUE; + + Error = _net_dbus_wps_scan_request(); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, + "_net_dbus_wps_scan_request() failed. Error [%s]", + _net_print_error(Error)); + + memset(&request_table[NETWORK_REQUEST_TYPE_WPS_SCAN], 0, + sizeof(network_request_table_s)); + } + + __NETWORK_FUNC_EXIT__; + return Error; +} +int net_get_wps_pin(char **wps_pin) +{ + net_err_e error = NET_ERR_NONE; + error = _net_dbus_get_wps_pin(wps_pin); + + if (error != NET_ERR_NONE) + WIFI_LOG(WIFI_ERROR, "Failed to get wps pin : %d", error); + + return error; +} + +int net_wifi_get_passpoint(int *enabled) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_APP_NOT_REGISTERED; + } + + if (NetworkInfo.wifi_state == WIFI_OFF) { + if ((NetworkInfo.wifi_state = _net_get_wifi_state(&Error)) == WIFI_OFF) { + WIFI_LOG(WIFI_ERROR, "Wi-Fi is powered off!"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_OPERATION; + } + } + + if (_net_dbus_is_pending_call_used() == TRUE) { + WIFI_LOG(WIFI_ERROR, "pending call in progress"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_OPERATION; + } + + Error = _net_dbus_get_passpoint(enabled); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, + "_net_dbus_get_passpoint() failed. Error [%s]", + _net_print_error(Error)); + } + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int net_wifi_set_passpoint(int enable) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_APP_NOT_REGISTERED; + } + + if (NetworkInfo.wifi_state == WIFI_OFF) { + if ((NetworkInfo.wifi_state = _net_get_wifi_state(&Error)) == WIFI_OFF) { + WIFI_LOG(WIFI_ERROR, "Wi-Fi is powered off!"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_OPERATION; + } + } + + if (_net_dbus_is_pending_call_used() == TRUE) { + WIFI_LOG(WIFI_ERROR, "pending call in progress"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_OPERATION; + } + + Error = _net_dbus_set_passpoint(enable); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, + "_net_dbus_set_passpoint() failed. Error [%s]", + _net_print_error(Error)); + } + + __NETWORK_FUNC_EXIT__; + return Error; +} +//LCOV_EXCL_STOP + +int net_open_connection_with_wifi_info(const net_wifi_connection_info_s *wifi_info) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (wifi_info == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_PARAM; //LCOV_EXCL_LINE + } + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + if (request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag == TRUE) { + WIFI_LOG(WIFI_ERROR, "Connection open request in progress"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_IN_PROGRESS; //LCOV_EXCL_LINE + } + + if (NetworkInfo.wifi_state == WIFI_OFF) { + if ((NetworkInfo.wifi_state = _net_get_wifi_state(&Error)) == WIFI_OFF) { + WIFI_LOG(WIFI_ERROR, "Wi-Fi is powered off!"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_OPERATION; //LCOV_EXCL_LINE + } + } + + if (_net_dbus_is_pending_call_used() == TRUE) { + WIFI_LOG(WIFI_ERROR, "pending call in progress"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_OPERATION; //LCOV_EXCL_LINE + } + + request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag = TRUE; + + Error = _net_open_connection_with_wifi_info(wifi_info); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "net_open_connection_with_wifi_info() failed. Error [%s]", + _net_print_error(Error)); + + if (request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag != 0) + memset(&request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION], 0, //LCOV_EXCL_LINE + sizeof(network_request_table_s)); + + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +int net_wifi_power_on(gboolean wifi_picker_test) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + int hotspot_state = 0; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + if (!net_get_device_policy_wifi()) { + WIFI_LOG(WIFI_ERROR, "Wifi profile device policy restricts"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_SECURITY_RESTRICTED; //LCOV_EXCL_LINE + } + + vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &hotspot_state); + if (hotspot_state & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI) { + WIFI_LOG(WIFI_ERROR, "Wi-Fi hotspot is enabled!"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_OPERATION; //LCOV_EXCL_LINE + } + + if (NetworkInfo.wifi_state != WIFI_OFF) { + if ((NetworkInfo.wifi_state = _net_get_wifi_state(&Error)) == WIFI_ON) { + WIFI_LOG(WIFI_ERROR, "Wi-Fi is powered on already!"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_ALREADY_EXISTS; //LCOV_EXCL_LINE + } else if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Failed to get Wi-Fi state"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + } + + if (request_table[NETWORK_REQUEST_TYPE_WIFI_POWER].flag == TRUE) { + WIFI_LOG(WIFI_ERROR, "Request in progress"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_IN_PROGRESS; //LCOV_EXCL_LINE + } + + _net_dbus_pending_call_unref(); + memset(request_table, 0, sizeof(request_table)); + + request_table[NETWORK_REQUEST_TYPE_WIFI_POWER].flag = TRUE; + + Error = _net_dbus_load_wifi_driver(wifi_picker_test); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "Failed to request Wi-Fi power on/off. Error [%s]", + _net_print_error(Error)); + + memset(&request_table[NETWORK_REQUEST_TYPE_WIFI_POWER], 0, //LCOV_EXCL_LINE + sizeof(network_request_table_s)); + + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +int net_wifi_power_off(void) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + if (NetworkInfo.wifi_state == WIFI_OFF) { + if ((NetworkInfo.wifi_state = _net_get_wifi_state(&Error)) == WIFI_OFF) { + WIFI_LOG(WIFI_ERROR, "Wi-Fi is powered off already!"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_ALREADY_EXISTS; //LCOV_EXCL_LINE + } + } + + if (request_table[NETWORK_REQUEST_TYPE_WIFI_POWER].flag == TRUE) { + WIFI_LOG(WIFI_ERROR, "Request in progress"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_IN_PROGRESS; //LCOV_EXCL_LINE + } + + //LCOV_EXCL_START + if (_net_dbus_is_pending_call_used() == TRUE) { + if (request_table[NETWORK_REQUEST_TYPE_SCAN].flag == TRUE) { + _net_dbus_pending_call_unref(); + + memset(&request_table[NETWORK_REQUEST_TYPE_SCAN], + 0, sizeof(network_request_table_s)); + } + + if (request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag == TRUE) { + _net_dbus_pending_call_unref(); + + memset(&request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION], + 0, sizeof(network_request_table_s)); + } + + if (request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag == TRUE) { + _net_dbus_pending_call_unref(); + + memset(&request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS], + 0, sizeof(network_request_table_s)); + } + + if (request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].flag == TRUE) { + _net_dbus_pending_call_unref(); + + memset(&request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION], + 0, sizeof(network_request_table_s)); + } + + if (request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN].flag == TRUE) { + _net_dbus_pending_call_unref(); + + memset(&request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN], + 0, sizeof(network_request_table_s)); + } + + if (request_table[NETWORK_REQUEST_TYPE_WPS_SCAN].flag == TRUE) { + _net_dbus_pending_call_unref(); + + memset(&request_table[NETWORK_REQUEST_TYPE_WPS_SCAN], + 0, sizeof(network_request_table_s)); + } + + if (_net_dbus_is_pending_call_used() == TRUE) { + WIFI_LOG(WIFI_ERROR, "pending call in progress"); + + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_OPERATION; + } + } + //LCOV_EXCL_STOP + + request_table[NETWORK_REQUEST_TYPE_WIFI_POWER].flag = TRUE; + + Error = _net_dbus_remove_wifi_driver(); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "Failed to request Wi-Fi power on/off. Error [%s]", + _net_print_error(Error)); + + memset(&request_table[NETWORK_REQUEST_TYPE_WIFI_POWER], //LCOV_EXCL_LINE + 0, sizeof(network_request_table_s)); + + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +int net_scan_wifi(void) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + if (request_table[NETWORK_REQUEST_TYPE_SCAN].flag == TRUE) { + WIFI_LOG(WIFI_ERROR, "Request in progress"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_IN_PROGRESS; //LCOV_EXCL_LINE + } + + if (NetworkInfo.wifi_state == WIFI_OFF) { + if ((NetworkInfo.wifi_state = _net_get_wifi_state(&Error)) == WIFI_OFF) { + WIFI_LOG(WIFI_ERROR, "Wi-Fi powered off!"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_OPERATION; //LCOV_EXCL_LINE + } + } + + if (_net_dbus_is_pending_call_used() == TRUE) { + if (request_table[NETWORK_REQUEST_TYPE_SCAN].flag == TRUE) { + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_IN_PROGRESS; //LCOV_EXCL_LINE + } else { + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_OPERATION; //LCOV_EXCL_LINE + } + } + + request_table[NETWORK_REQUEST_TYPE_SCAN].flag = TRUE; + + Error = _net_dbus_scan_request(); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Failed to request scan. Error [%s]", //LCOV_EXCL_LINE + _net_print_error(Error)); + + memset(&request_table[NETWORK_REQUEST_TYPE_SCAN], 0, //LCOV_EXCL_LINE + sizeof(network_request_table_s)); + + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +//LCOV_EXCL_START +int net_wifi_enroll_wps(const char *profile_name, net_wifi_wps_info_s *wps_info) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (_net_check_profile_name(profile_name) != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Invalid profile name"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_PARAM; + } + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_APP_NOT_REGISTERED; + } + + if (request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag == TRUE) { + WIFI_LOG(WIFI_ERROR, "Request in progress"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_IN_PROGRESS; + } + + if (NetworkInfo.wifi_state == WIFI_OFF) { + if ((NetworkInfo.wifi_state = _net_get_wifi_state(&Error)) == WIFI_OFF) { + WIFI_LOG(WIFI_ERROR, "Wi-Fi is powered off!"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_OPERATION; + } + } + + if (_net_dbus_is_pending_call_used() == TRUE) { + WIFI_LOG(WIFI_ERROR, "pending call in progress"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_OPERATION; + } + + request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag = TRUE; + g_strlcpy(request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].ProfileName, + profile_name, NET_PROFILE_NAME_LEN_MAX+1); + + if (wps_info->type == WIFI_WPS_PBC) + Error = _net_dbus_set_agent_wps_pbc_and_connect(profile_name); + else if (wps_info->type == WIFI_WPS_PIN) + Error = _net_dbus_set_agent_wps_pin_and_connect(wps_info->pin, profile_name); + else + Error = NET_ERR_INVALID_PARAM; + + if (NET_ERR_NONE != Error) { + WIFI_LOG(WIFI_ERROR, + "WPS configuration failed(%s)", _net_print_error(Error)); + + memset(&request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS], 0, + sizeof(network_request_table_s)); + } + + __NETWORK_FUNC_EXIT__; + return Error; +} + +#if defined TIZEN_TV +int net_wifi_cancel_wps(void) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + WIFI_LOG(WIFI_ERROR, "net_wifi_wps_cancel called\n"); + + if (g_atomic_int_get(&NetworkInfo.ref_count) == 0) { + WIFI_LOG(WIFI_ERROR, "Application is not registered\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_APP_NOT_REGISTERED; + } + + if (request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag == FALSE) { + WIFI_LOG(WIFI_ERROR, "No pending call in progress\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_OPERATION; + } + + if (_net_get_wifi_state(&Error) != WIFI_ON) { + WIFI_LOG(WIFI_ERROR, "Wi-Fi is powered off!\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_OPERATION; + } + + if (_net_dbus_is_pending_call_used() == TRUE) { + WIFI_LOG(WIFI_ERROR, "pending call in progress\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_OPERATION; + } + + if (request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].ProfileName[0] != '\0') + net_delete_profile(request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].ProfileName); + + Error = _net_dbus_cancel_wps(); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, + "Failed to request cancel WPS, Error [%s]\n", + _net_print_error(Error)); + } + + memset(&request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS], 0, + sizeof(network_request_table_s)); + + __NETWORK_FUNC_EXIT__; + return Error; +} +#endif + +int net_get_wifi_state(net_wifi_state_e *current_state) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_APP_NOT_REGISTERED; + } + + *current_state = __net_get_wifi_connection_state(&Error); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int net_wifi_set_background_scan_mode(net_wifi_background_scan_mode_e scan_mode) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_APP_NOT_REGISTERED; + } + + if (NetworkInfo.wifi_state == WIFI_OFF) { + if ((NetworkInfo.wifi_state = _net_get_wifi_state(&Error)) == WIFI_OFF) { + WIFI_LOG(WIFI_ERROR, "Wi-Fi is powered off!"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_OPERATION; + } + } + + if ((Error = _net_dbus_set_bgscan_mode(scan_mode)) != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, + "Failed to set bgscan mode. Error [%s]", + _net_print_error(Error)); + + __NETWORK_FUNC_EXIT__; + return Error; + } + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} +//LCOV_EXCL_STOP + +int net_check_get_privilege() +{ + net_err_e Error = NET_ERR_NONE; + + Error = __net_check_get_privilege(); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Failed to check get privilege. Error [%s]", //LCOV_EXCL_LINE + _net_print_error(Error)); + + return Error; //LCOV_EXCL_LINE + } + + return Error; +} + +int net_check_profile_privilege() +{ + net_err_e Error = NET_ERR_NONE; + + Error = __net_check_profile_privilege(); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Failed to check profile privilege. Error [%s]", //LCOV_EXCL_LINE + _net_print_error(Error)); + + return Error; //LCOV_EXCL_LINE + } + + return Error; +} + +//LCOV_EXCL_START +#if defined TIZEN_TV +int net_wifi_enroll_wps_without_ssid(net_wifi_wps_info_s *wps_info) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (g_atomic_int_get(&NetworkInfo.ref_count) == 0) { + WIFI_LOG(WIFI_ERROR, "Application is not registered\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_APP_NOT_REGISTERED; + } + + if (request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag == TRUE) { + WIFI_LOG(WIFI_ERROR, "Request in progress\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_IN_PROGRESS; + } + + if (_net_get_wifi_state(&Error) != WIFI_ON) { + WIFI_LOG(WIFI_ERROR, "Wi-Fi is powered off!\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_OPERATION; + } + + if (_net_dbus_is_pending_call_used() == TRUE) { + WIFI_LOG(WIFI_ERROR, "pending call in progress\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_OPERATION; + } + + request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag = TRUE; + + if (wps_info->type == WIFI_WPS_PBC) { + /* Look How to change the use of Connman agent */ + Error = _net_dbus_set_agent_wps_pbc(); + if (NET_ERR_NONE != Error) { + WIFI_LOG(WIFI_ERROR, + "_net_dbus_set_agent_wps_pbc() failed\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_OPERATION; + } + } else if (wps_info->type == WIFI_WPS_PIN) { + Error = _net_dbus_set_agent_wps_pin(wps_info->pin); + if (NET_ERR_NONE != Error) { + WIFI_LOG(WIFI_ERROR, + "_net_dbus_set_agent_wps_pin() failed\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_OPERATION; + } + } else { + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_PARAM; + } + + if (wps_info->type == WIFI_WPS_PBC) { + Error = _net_dbus_open_connection_without_ssid(); + } else if (wps_info->type == WIFI_WPS_PIN) { + Error = _net_dbus_open_pin_connection_without_ssid(wps_info->pin); + } else{ + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_PARAM; + } + + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, + "Failed to request open connection, Error [%s]\n", + _net_print_error(Error)); + + memset(&request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS], 0, + sizeof(network_request_table_s)); + } + + __NETWORK_FUNC_EXIT__; + return Error; +} +#endif + +int net_wifi_tdls_disconnect(const char* peer_mac_addr) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (peer_mac_addr == NULL) { + WIFI_LOG(WIFI_ERROR, "invalid parameter\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_PARAM; + } + + if (g_atomic_int_get(&NetworkInfo.ref_count) == 0) { + WIFI_LOG(WIFI_ERROR, "Application is not registered\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_APP_NOT_REGISTERED; + } + + Error = _net_dbus_tdls_disconnect(peer_mac_addr); + + if (Error != NET_ERR_NONE) + WIFI_LOG(WIFI_ERROR, "_net_dbus_tdls_set_device_type failed\n"); + + + __NETWORK_FUNC_EXIT__; + return Error; + +} + +int net_wifi_tdls_connected_peer(char** peer_mac_addr) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (peer_mac_addr == NULL) { + WIFI_LOG(WIFI_ERROR, "invalid parameter\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_PARAM; + } + + if (g_atomic_int_get(&NetworkInfo.ref_count) == 0) { + WIFI_LOG(WIFI_ERROR, "Application is not registered\n"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_APP_NOT_REGISTERED; + } + + Error = _net_dbus_tdls_connected_peer(peer_mac_addr); + + if (Error != NET_ERR_NONE) + WIFI_LOG(WIFI_ERROR, "net_wifi_tdls_connected_peer failed\n"); + + + __NETWORK_FUNC_EXIT__; + return Error; + +} + +int net_get_device_policy_wifi(void) +{ + __NETWORK_FUNC_ENTER__; + + int state = _net_get_dpm_wifi_state(); + if (state == -1) { + net_err_e Error = _net_dbus_device_policy_get_wifi(&state); + if (Error != NET_ERR_NONE) + WIFI_LOG(WIFI_ERROR, "_net_dbus_device_policy_get_wifi failed\n"); + else + _net_set_dpm_wifi_state(state); + } + + WIFI_LOG(WIFI_INFO, "Wifi device policy state [%d]\n", state); + + __NETWORK_FUNC_EXIT__; + return state; +} + +int net_get_device_policy_wifi_profile(void) +{ + __NETWORK_FUNC_ENTER__; + + int state = _net_get_dpm_wifi_profile_state(); + if (state == -1) { + net_err_e Error = _net_dbus_device_policy_get_wifi_profile(&state); + if (Error != NET_ERR_NONE) + WIFI_LOG(WIFI_ERROR, "_net_dbus_device_policy_get_wifi_profile failed\n"); + else + _net_set_dpm_wifi_profile_state(state); + } + + __NETWORK_FUNC_EXIT__; + return state; +} +//LCOV_EXCL_STOP + +int net_register_client_ext(net_event_cb event_cb, void *user_data) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (event_cb == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid EventCb parameter"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_PARAM; //LCOV_EXCL_LINE + } + + if (NetworkInfo.ClientEventCb_wifi != NULL) { + WIFI_LOG(WIFI_ERROR, "Wi-Fi EventCb Already registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_ALREADY_REGISTERED; //LCOV_EXCL_LINE + } + + if (NetworkInfo.ref_count < 1) { + Error = _net_register_signal(); + if (Error != NET_ERR_NONE && Error != NET_ERR_APP_ALREADY_REGISTERED) { + WIFI_LOG(WIFI_ERROR, "Failed to register DBus signal [%s]", //LCOV_EXCL_LINE + _net_print_error(Error)); + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + Error = _net_init_service_state_table(); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Failed to init service state table [%s]", //LCOV_EXCL_LINE + _net_print_error(Error)); + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + } + + NetworkInfo.ClientEventCb_wifi = event_cb; + NetworkInfo.user_data_wifi = user_data; + + __sync_fetch_and_add(&NetworkInfo.ref_count, 1); + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +int net_deregister_client_ext() +{ + __NETWORK_FUNC_ENTER__; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + if (NetworkInfo.ClientEventCb_wifi == NULL) { + WIFI_LOG(WIFI_ERROR, "Wi-Fi EventCb was not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + NetworkInfo.ClientEventCb_wifi = NULL; + NetworkInfo.user_data_wifi = NULL; + + if (__sync_sub_and_fetch(&NetworkInfo.ref_count, 1) < 1) { + _net_deregister_signal(); + _net_clear_request_table(); + _net_client_callback_cleanup(); + } + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +gboolean net_check_ref_count(void) +{ + if (NetworkInfo.ref_count > 0) + return TRUE; + + return FALSE; +} + +int net_open_connection(const char *profile_name) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + WIFI_LOG(WIFI_INFO, "Open: %s", profile_name); + + if (_net_check_profile_name(profile_name) != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Invalid profile name"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_PARAM; //LCOV_EXCL_LINE + } + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + if (request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag == TRUE) { + WIFI_LOG(WIFI_ERROR, "Request in progress"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_IN_PROGRESS; //LCOV_EXCL_LINE + } + + if (_net_dbus_is_pending_call_used() == TRUE) { + WIFI_LOG(WIFI_ERROR, "Pending call in progress"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_OPERATION; //LCOV_EXCL_LINE + } + + request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag = TRUE; + g_strlcpy(request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].ProfileName, + profile_name, NET_PROFILE_NAME_LEN_MAX+1); + + Error = _net_dbus_open_connection(profile_name); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "Failed to request open connection, Error [%s]", + _net_print_error(Error)); + + memset(&request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION], //LCOV_EXCL_LINE + 0, sizeof(network_request_table_s)); + + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +int net_close_connection(const char *profile_name) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + gboolean is_connecting = FALSE; + + WIFI_LOG(WIFI_INFO, "ProfileName [%s] passed", profile_name); + + if (_net_check_profile_name(profile_name) != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Invalid profile name"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_PARAM; //LCOV_EXCL_LINE + } + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + if (request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].flag == TRUE) { + WIFI_LOG(WIFI_ERROR, "Request in progress"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_IN_PROGRESS; //LCOV_EXCL_LINE + } + + if (_net_dbus_is_pending_call_used() == TRUE) { + is_connecting = __net_is_connecting(profile_name); + if (is_connecting == FALSE) { + WIFI_LOG(WIFI_ERROR, "pending call in progress"); //LCOV_EXCL_LINE + + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_IN_PROGRESS; //LCOV_EXCL_LINE + } + } + + request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].flag = TRUE; + g_strlcpy(request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].ProfileName, + profile_name, NET_PROFILE_NAME_LEN_MAX+1); + + Error = _net_dbus_close_connection(profile_name); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "Failed to request close connection, Error [%s]", + _net_print_error(Error)); + + memset(&request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION], //LCOV_EXCL_LINE + 0, sizeof(network_request_table_s)); + + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + if (is_connecting == TRUE) + __net_abort_open_connection(profile_name); + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +int net_delete_profile(const char* profile_name) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + net_profile_name_s wifi_prof_name; + net_profile_info_s prof_info; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + WIFI_LOG(WIFI_ERROR, "Delete Profile [%s]", profile_name); + + if (_net_check_profile_name(profile_name) != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Invalid Parameter"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_PARAM; //LCOV_EXCL_LINE + } + + Error = __net_get_profile_info(profile_name, &prof_info); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "Failed to get service(profile) information. Error [%s]", + _net_print_error(Error)); + + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + g_strlcpy(wifi_prof_name.ProfileName, profile_name, NET_PROFILE_NAME_LEN_MAX + 1); + + Error = __net_wifi_delete_profile(&wifi_prof_name, + prof_info.security_info.sec_mode, + prof_info.passpoint); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "Failed to delete service(profile). Error [%s]", + _net_print_error(Error)); + + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +int net_modify_profile(const char* profile_name, net_profile_info_s* prof_info) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + net_profile_info_s exProfInfo; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + if (!_net_get_dpm_wifi_state()) { + WIFI_LOG(WIFI_ERROR, "Wifi device policy restricts"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_SECURITY_RESTRICTED; //LCOV_EXCL_LINE + } + + if (!_net_get_dpm_wifi_profile_state()) { + WIFI_LOG(WIFI_ERROR, "Wifi profile device policy restricts"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_SECURITY_RESTRICTED; //LCOV_EXCL_LINE + } + + Error = net_get_profile_info(profile_name, &exProfInfo); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "Failed to get service(profile) information. Error [%s]", + _net_print_error(Error)); + + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + if (prof_info == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid Parameter\n"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_PARAM; //LCOV_EXCL_LINE + } + + + Error = __net_wifi_modify_profile(profile_name, prof_info, &exProfInfo); + + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "Failed to modify service(profile) information. Error [%s]", + _net_print_error(Error)); + + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +int net_get_profile_info(const char *profile_name, net_profile_info_s *prof_info) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + if (prof_info == NULL || + _net_check_profile_name(profile_name) != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Invalid Parameter"); //LCOV_EXCL_LINE + + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_INVALID_PARAM; //LCOV_EXCL_LINE + } + + Error = __net_get_profile_info(profile_name, prof_info); + if (Error != NET_ERR_NONE) + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "Failed to get service(profile) information. Error [%s]", + _net_print_error(Error)); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int net_get_profile_list(GSList **profile_list) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + Error = _net_get_profile_list(profile_list); + + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "Failed to get service(profile) list. Error [%s]", + _net_print_error(Error)); + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +int net_get_technology_properties(net_tech_info_s *tech_info) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + if ((Error = _net_dbus_get_tech_status(tech_info)) != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Failed to get technology status. Error [%s]", //LCOV_EXCL_LINE + _net_print_error(Error)); + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +int net_config_get_id_list(GSList **list) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + Error = _net_dbus_config_get_id_list(list); + if (Error != NET_ERR_NONE) + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "Failed to get config id list. Error [%s]", + _net_print_error(Error)); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int net_config_set_field(const gchar *config_id, const gchar *key, const gchar *value) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + Error = _net_dbus_config_set_field(config_id, key, value); + if (Error != NET_ERR_NONE) + WIFI_LOG(WIFI_ERROR, + "Failed to set field. Error [%s]", + _net_print_error(Error)); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int net_config_get_passphrase(const gchar *config_id, gchar **passphrase) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + Error = _net_dbus_config_get_passphrase(config_id, passphrase); + if (Error != NET_ERR_NONE) + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "Failed to get config id list. Error [%s]", + _net_print_error(Error)); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int net_config_save_configurations(const gchar *config_id, const gchar *name, + const gchar *ssid, const gchar *passphrase, const gchar *proxy_address, gboolean is_hidden) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + Error = _net_dbus_config_save_configurations(config_id, + name, ssid, passphrase, proxy_address, is_hidden); + if (Error != NET_ERR_NONE) + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "Failed to save configurations. Error [%s]", + _net_print_error(Error)); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +//LCOV_EXCL_START +int net_config_save_eap_configurations(const gchar *config_id, + const gchar *name, const gchar *ssid, const gchar *passphrase, + const gchar *proxy_address, void *eap_config, gboolean is_hidden) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + net_eap_config_s *net_eap_config = (net_eap_config_s *)eap_config; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_APP_NOT_REGISTERED; + } + + Error = _net_dbus_config_save_eap_configurations(config_id, + name, ssid, passphrase, proxy_address, net_eap_config, is_hidden); + if (Error != NET_ERR_NONE) + WIFI_LOG(WIFI_ERROR, + "Failed to save configurations. Error [%s]", + _net_print_error(Error)); + + __NETWORK_FUNC_EXIT__; + return Error; +} +//LCOV_EXCL_STOP + +int net_config_remove_configurations(const gchar *config_id) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + Error = _net_dbus_config_remove_configurations(config_id); + if (Error != NET_ERR_NONE) + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "Failed to remove configurations. Error [%s]", + _net_print_error(Error)); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int net_config_load_configurations(const gchar *config_id, gchar **name, + void *security_type, gchar **proxy_address, gboolean *is_hidden, void *last_error) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + net_wifi_security_type_e *sec_type = (net_wifi_security_type_e *)security_type; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + Error = _net_dbus_config_load_configurations(config_id, name, sec_type, + proxy_address, is_hidden, last_error); + if (Error != NET_ERR_NONE) + WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE + "Failed to load configurations. Error [%s]", + _net_print_error(Error)); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +//LCOV_EXCL_START +int net_config_load_eap_configurations(const gchar *config_id, + gchar **name, void *security_type, gchar **proxy_address, + gboolean *is_hidden, void **eap_config, void *last_error) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + net_eap_config_s **net_eap_config = (net_eap_config_s **)eap_config; + net_wifi_security_type_e *sec_type = (net_wifi_security_type_e *)security_type; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_APP_NOT_REGISTERED; + } + + Error = _net_dbus_config_load_eap_configurations(config_id, name, sec_type, + proxy_address, is_hidden, net_eap_config, last_error); + if (Error != NET_ERR_NONE) + WIFI_LOG(WIFI_ERROR, + "Failed to load eap configurations. Error [%s]", + _net_print_error(Error)); + + __NETWORK_FUNC_EXIT__; + return Error; +} +//LCOV_EXCL_STOP + diff --git a/src/network_internal.c b/src/network_internal.c new file mode 100755 index 0000000..ae64d93 --- /dev/null +++ b/src/network_internal.c @@ -0,0 +1,640 @@ +/* + * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "wifi_internal.h" +#include "network_internal.h" +#include "network_dbus.h" + +typedef struct { + GDBusConnection *connection; + int conn_ref_count; + GCancellable *cancellable; + void *handle_libnetwork; +} gdbus_connection_data_s; + +typedef struct { + GSourceFunc func; + gpointer user_data; + guint id; +} managed_idle_data_s; + +extern __thread network_info_s NetworkInfo; +__thread network_request_table_s request_table[NETWORK_REQUEST_TYPE_MAX] = { { 0, }, }; + +static __thread gdbus_connection_data_s gdbus_conn = { NULL, 0, NULL, NULL }; +static __thread GSList *managed_idler_list = NULL; + +//LCOV_EXCL_START +static char *__convert_eap_type_to_string(gchar eap_type) +{ + switch (eap_type) { + case WLAN_SEC_EAP_TYPE_PEAP: + return "peap"; + + case WLAN_SEC_EAP_TYPE_TLS: + return "tls"; + + case WLAN_SEC_EAP_TYPE_TTLS: + return "ttls"; + + case WLAN_SEC_EAP_TYPE_SIM: + return "sim"; + + case WLAN_SEC_EAP_TYPE_AKA: + return "aka"; + + default: + return NULL; + } +} + +static char *__convert_eap_auth_to_string(gchar eap_auth) +{ + switch (eap_auth) { + case WLAN_SEC_EAP_AUTH_NONE: + return "NONE"; + + case WLAN_SEC_EAP_AUTH_PAP: + return "PAP"; + + case WLAN_SEC_EAP_AUTH_MSCHAP: + return "MSCHAP"; + + case WLAN_SEC_EAP_AUTH_MSCHAPV2: + return "MSCHAPV2"; + + case WLAN_SEC_EAP_AUTH_GTC: + return "GTC"; + + case WLAN_SEC_EAP_AUTH_MD5: + return "MD5"; + + default: + return NULL; + } +} + +static char *__convert_eap_keymgmt_type_to_string(gchar eap_keymgmt) +{ + switch (eap_keymgmt) { + case WLAN_SEC_EAP_KEYMGMT_FT: + return "FT"; + + case WLAN_SEC_EAP_KEYMGMT_CCKM: + return "CCKM"; + + case WLAN_SEC_EAP_KEYMGMT_OKC: + return "OKC"; + + default: + return NULL; + } +} + +char* _net_print_error(net_err_e error) +{ + switch (error) { + case NET_ERR_NONE: + return "NET_ERR_NONE"; + + case NET_ERR_UNKNOWN: + return "NET_ERR_UNKNOWN"; + + case NET_ERR_APP_ALREADY_REGISTERED: + return "NET_ERR_APP_ALREADY_REGISTERED"; + case NET_ERR_APP_NOT_REGISTERED: + return "NET_ERR_APP_NOT_REGISTERED"; + + case NET_ERR_NO_ACTIVE_CONNECTIONS: + return "NET_ERR_NO_ACTIVE_CONNECTIONS"; + case NET_ERR_ACTIVE_CONNECTION_EXISTS: + return "NET_ERR_ACTIVE_CONNECTION_EXISTS"; + case NET_ERR_CONNECTION_OUT_OF_RANGE: + return "NET_ERR_CONNECTION_OUT_OF_RANGE"; + case NET_ERR_CONNECTION_PIN_MISSING: + return "NET_ERR_CONNECTION_PIN_MISSING"; + case NET_ERR_CONNECTION_DHCP_FAILED: + return "NET_ERR_CONNECTION_DHCP_FAILED"; + case NET_ERR_CONNECTION_CONNECT_FAILED: + return "NET_ERR_CONNECTION_CONNECT_FAILED"; + case NET_ERR_CONNECTION_LOGIN_FAILED: + return "NET_ERR_CONNECTION_LOGIN_FAILED"; + case NET_ERR_CONNECTION_AUTH_FAILED: + return "NET_ERR_CONNECTION_AUTH_FAILED"; + case NET_ERR_CONNECTION_INVALID_KEY: + return "NET_ERR_CONNECTION_INVALID_KEY"; + + case NET_ERR_ACCESS_DENIED: + return "NET_ERR_ACCESS_DENIED"; + case NET_ERR_IN_PROGRESS: + return "NET_ERR_IN_PROGRESS"; + case NET_ERR_OPERATION_ABORTED: + return "NET_ERR_OPERATION_ABORTED"; + case NET_ERR_INVALID_PARAM: + return "NET_ERR_INVALID_PARAM"; + case NET_ERR_INVALID_OPERATION: + return "NET_ERR_INVALID_OPERATION"; + case NET_ERR_NOT_SUPPORTED: + return "NET_ERR_NOT_SUPPORTED"; + case NET_ERR_TIME_OUT: + return "NET_ERR_TIME_OUT"; + case NET_ERR_NO_SERVICE: + return "NET_ERR_NO_SERVICE"; + case NET_ERR_UNKNOWN_METHOD: + return "NET_ERR_UNKNOWN_METHOD"; + case NET_ERR_SECURITY_RESTRICTED: + return "NET_ERR_SECURITY_RESTRICTED"; + case NET_ERR_WIFI_DRIVER_FAILURE: + return "NET_ERR_WIFI_DRIVER_FAILURE"; + default: + return "INVALID"; + } +} + +int _net_get_tech_state(GVariant *msg, network_tech_state_info_s* tech_state) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariantIter *iter_main = NULL; + GVariantIter *var = NULL; + GVariant *value = NULL; + gchar *tech_prefix; + gchar *path = NULL; + gchar *key = NULL; + gboolean data; + + tech_prefix = CONNMAN_WIFI_TECHNOLOGY_PREFIX; + + g_variant_get(msg, "(a(oa{sv}))", &iter_main); + while (g_variant_iter_loop(iter_main, "(oa{sv})", &path, &var)) { + + if (path == NULL || g_strcmp0(path, tech_prefix) != 0) + continue; + + while (g_variant_iter_loop(var, "{sv}", &key, &value)) { + if (g_strcmp0(key, "Powered") == 0) { + data = g_variant_get_boolean(value); + + if (data) + tech_state->Powered = TRUE; + else + tech_state->Powered = FALSE; + } else if (g_strcmp0(key, "Connected") == 0) { + data = g_variant_get_boolean(value); + + if (data) + tech_state->Connected = TRUE; + else + tech_state->Connected = FALSE; + } else if (g_strcmp0(key, "Tethering") == 0) { + /* For further use */ + } + } + } + g_variant_iter_free(iter_main); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +/** This function is used only to open Wi-Fi connection with hidden APs */ +int _net_open_connection_with_wifi_info(const net_wifi_connection_info_s* wifi_info) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + net_wifi_connect_service_info_t wifi_connection_info; + memset(&wifi_connection_info, 0, sizeof(net_wifi_connect_service_info_t)); + + wifi_connection_info.type = "wifi"; + + if (wifi_info->wlan_mode == NET_WLAN_CONNMODE_ADHOC) + wifi_connection_info.mode = "adhoc"; + else + wifi_connection_info.mode = "managed"; + + wifi_connection_info.ssid = (char *)wifi_info->essid; + + wifi_connection_info.is_hidden = wifi_info->is_hidden; + + switch (wifi_info->security_info.sec_mode) { + case WLAN_SEC_MODE_NONE: + wifi_connection_info.security = "none"; + break; + + case WLAN_SEC_MODE_WEP: + wifi_connection_info.security = "wep"; + wifi_connection_info.passphrase = + (char *)wifi_info->security_info.authentication.wep.wepKey; + break; + + /** WPA-PSK(equivalent to WPA-NONE in case of Ad-Hoc) */ + case WLAN_SEC_MODE_WPA_PSK: + wifi_connection_info.security = "psk"; + wifi_connection_info.passphrase = + (char *)wifi_info->security_info.authentication.psk.pskKey; + break; + + /** WPA2-PSK */ + /** WPA-PSK / WPA2-PSK supported */ + case WLAN_SEC_MODE_WPA2_PSK: + wifi_connection_info.security = "rsn"; + wifi_connection_info.passphrase = + (char *)wifi_info->security_info.authentication.psk.pskKey; + break; + case WLAN_SEC_MODE_WPA_FT_PSK: + wifi_connection_info.security = "ft_psk"; + wifi_connection_info.passphrase = + (char *)wifi_info->security_info.authentication.psk.pskKey; + break; + + + + case WLAN_SEC_MODE_IEEE8021X: + wifi_connection_info.security = "ieee8021x"; + + wifi_connection_info.eap_type = + __convert_eap_type_to_string( + wifi_info->security_info.authentication.eap.eap_type); + wifi_connection_info.eap_auth = + __convert_eap_auth_to_string( + wifi_info->security_info.authentication.eap.eap_auth); + wifi_connection_info.eap_keymgmt_type = + __convert_eap_keymgmt_type_to_string( + wifi_info->security_info.authentication.eap.eap_keymgmt_type); + + if (wifi_info->security_info.authentication.eap.username[0] != '\0') + wifi_connection_info.identity = + (char *)wifi_info->security_info.authentication.eap.username; + + if (wifi_info->security_info.authentication.eap.password[0] != '\0') + wifi_connection_info.password = + (char *)wifi_info->security_info.authentication.eap.password; + + if (wifi_info->security_info.authentication.eap.ca_cert_filename[0] != '\0') + wifi_connection_info.ca_cert_file = + (char *)wifi_info->security_info.authentication.eap.ca_cert_filename; + + if (wifi_info->security_info.authentication.eap.client_cert_filename[0] != '\0') + wifi_connection_info.client_cert_file = + (char *)wifi_info->security_info.authentication.eap.client_cert_filename; + + if (wifi_info->security_info.authentication.eap.private_key_filename[0] != '\0') + wifi_connection_info.private_key_file = + (char *)wifi_info->security_info.authentication.eap.private_key_filename; + + if (wifi_info->security_info.authentication.eap.private_key_passwd[0] != '\0') + wifi_connection_info.private_key_password = + (char *)wifi_info->security_info.authentication.eap.private_key_passwd; + break; + + default: + WIFI_LOG(WIFI_ERROR, "Invalid security type"); + + __NETWORK_FUNC_EXIT__; + return NET_ERR_INVALID_PARAM; + } + + Error = _net_dbus_connect_service(&wifi_connection_info); + if (Error != NET_ERR_NONE) + WIFI_LOG(WIFI_ERROR, "Failed to request connect service. Error [%s]", + _net_print_error(Error)); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +static gboolean __net_client_cb_wifi_idle(gpointer data) +{ + net_event_info_s *event_data = (net_event_info_s *)data; + + if (NetworkInfo.ClientEventCb_wifi != NULL) + NetworkInfo.ClientEventCb_wifi(event_data, NetworkInfo.user_data_wifi); + + if (event_data->Datalength > 0) + g_free(event_data->Data); + + g_free(event_data); + + return FALSE; +} + +void _net_client_callback(net_event_info_s *event_data) +{ + guint id; + + __NETWORK_FUNC_ENTER__; + + if (NetworkInfo.ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "Application is not registered. " + "If multi-threaded, thread integrity be broken."); + __NETWORK_FUNC_EXIT__; + return; + } + + if (NetworkInfo.ClientEventCb_wifi != NULL) { + net_event_info_s *client = g_try_new0(net_event_info_s, 1); + if (client == NULL) { + __NETWORK_FUNC_EXIT__; + return; + } + + memcpy(client, event_data, sizeof(net_event_info_s)); + if (event_data->Datalength > 0) { + if (event_data->Event == NET_EVENT_WIFI_SPECIFIC_SCAN_IND || + event_data->Event == NET_EVENT_WIFI_WPS_SCAN_IND) { + client->Data = g_try_malloc0(sizeof(GSList)); + if (client->Data == NULL) { + g_free(client); + __NETWORK_FUNC_EXIT__; + return; + } + + memcpy(client->Data, event_data->Data, sizeof(GSList)); + } else { + client->Data = g_try_malloc0(event_data->Datalength); + if (client->Data == NULL) { + g_free(client); + __NETWORK_FUNC_EXIT__; + return; + } + + memcpy(client->Data, event_data->Data, event_data->Datalength); + } + } else { + client->Datalength = 0; + client->Data = NULL; + } + + id = _net_client_callback_add(__net_client_cb_wifi_idle, (gpointer)client); + if (!id) { + if (client->Datalength > 0) + g_free(client->Data); + + g_free(client); + } + } + + __NETWORK_FUNC_EXIT__; +} + +net_wifi_state_e _net_get_wifi_state(net_err_e *net_error) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + network_tech_state_info_s tech_state = { { 0, }, }; + net_wifi_state_e wifi_state = WIFI_UNKNOWN; + + g_strlcpy(tech_state.technology, "wifi", NET_TECH_LENGTH_MAX); + Error = _net_dbus_get_technology_state(&tech_state); + if (Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, + "_net_dbus_get_technology_state() failed. Error [%s]", + _net_print_error(Error)); + *net_error = Error; + goto state_done; + } + + if (tech_state.Powered == TRUE) + wifi_state = WIFI_ON; + else + wifi_state = WIFI_OFF; + +state_done: + __NETWORK_FUNC_EXIT__; + return wifi_state; +} + +static void __net_client_idle_destroy_cb(gpointer data) +{ + __NETWORK_FUNC_ENTER__; + + if (!data) { + __NETWORK_FUNC_EXIT__; + return; + } + + managed_idler_list = g_slist_remove(managed_idler_list, data); + g_free(data); + + __NETWORK_FUNC_EXIT__; +} + +static gboolean __net_client_idle_cb(gpointer user_data) +{ + __NETWORK_FUNC_ENTER__; + + managed_idle_data_s *data = (managed_idle_data_s *)user_data; + + if (!data) { + __NETWORK_FUNC_EXIT__; + return FALSE; + } + + __NETWORK_FUNC_EXIT__; + return data->func(data->user_data); +} + +guint _net_client_callback_add(GSourceFunc func, gpointer user_data) +{ + __NETWORK_FUNC_ENTER__; + + guint id; + managed_idle_data_s *data; + GMainContext *context; + GSource *src; + + if (!func) { + __NETWORK_FUNC_EXIT__; + return 0; + } + + data = g_try_new0(managed_idle_data_s, 1); + if (!data) { + __NETWORK_FUNC_EXIT__; + return 0; + } + + data->func = func; + data->user_data = user_data; + + context = g_main_context_get_thread_default(); + src = g_idle_source_new(); + g_source_set_callback(src, __net_client_idle_cb, data, + __net_client_idle_destroy_cb); + id = g_source_attach(src, context); + g_source_unref(src); + if (!id) { + g_free(data); + __NETWORK_FUNC_EXIT__; + return id; + } + + data->id = id; + + managed_idler_list = g_slist_append(managed_idler_list, data); + + __NETWORK_FUNC_EXIT__; + return id; +} + +void _net_client_callback_cleanup(void) +{ + __NETWORK_FUNC_ENTER__; + + GSList *cur = managed_idler_list; + GSource *src; + managed_idle_data_s *data; + + while (cur) { + GSList *next = cur->next; + data = (managed_idle_data_s *)cur->data; + + src = g_main_context_find_source_by_id(g_main_context_default(), data->id); + if (src) { + g_source_destroy(src); + cur = managed_idler_list; + } else + cur = next; + } + + g_slist_free(managed_idler_list); + managed_idler_list = NULL; + + __NETWORK_FUNC_EXIT__; +} + +void _net_clear_request_table(void) +{ + __NETWORK_FUNC_ENTER__; + + int i; + + for (i = 0; i < NETWORK_REQUEST_TYPE_MAX; i++) + memset(&request_table[i], 0, sizeof(network_request_table_s)); + + __NETWORK_FUNC_EXIT__; +} + +gboolean _net_dbus_is_pending_call_used(void) +{ + if (gdbus_conn.conn_ref_count > 0) + return TRUE; + + return FALSE; +} + +void _net_dbus_pending_call_ref(void) +{ + g_object_ref(gdbus_conn.connection); + + __sync_fetch_and_add(&gdbus_conn.conn_ref_count, 1); +} + +void _net_dbus_pending_call_unref(void) +{ + if (gdbus_conn.conn_ref_count < 1) + return; + + g_object_unref(gdbus_conn.connection); + + if (__sync_sub_and_fetch(&gdbus_conn.conn_ref_count, 1) < 1 && + gdbus_conn.handle_libnetwork != NULL) { + WIFI_LOG(WIFI_ERROR, "A handle of libnetwork is not NULL"); + + gdbus_conn.connection = NULL; + } +} + +int _net_dbus_create_gdbus_call(void) +{ + GError *error = NULL; + + if (gdbus_conn.connection != NULL) { + __NETWORK_FUNC_EXIT__; + return NET_ERR_APP_ALREADY_REGISTERED; + } + +#if !GLIB_CHECK_VERSION(2, 36, 0) + g_type_init(); +#endif + + gdbus_conn.connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); + if (gdbus_conn.connection == NULL) { + if (error != NULL) { + WIFI_LOG(WIFI_ERROR, + "Failed to connect to the D-BUS daemon [%s]", error->message); + g_error_free(error); + } + return NET_ERR_UNKNOWN; + } + + gdbus_conn.cancellable = g_cancellable_new(); + + if (gdbus_conn.handle_libnetwork != NULL) { + WIFI_LOG(WIFI_ERROR, + "A handle of libnetwork is not NULL and should be released"); + + dlclose(gdbus_conn.handle_libnetwork); + gdbus_conn.handle_libnetwork = NULL; + } + + return NET_ERR_NONE; +} + +int _net_dbus_close_gdbus_call(void) +{ + g_cancellable_cancel(gdbus_conn.cancellable); + g_object_unref(gdbus_conn.cancellable); + gdbus_conn.cancellable = NULL; + + if (gdbus_conn.conn_ref_count < 1) { + WIFI_LOG(WIFI_ERROR, "There is no pending call"); + + g_object_unref(gdbus_conn.connection); + gdbus_conn.connection = NULL; + } else { + WIFI_LOG(WIFI_ERROR, + "There are %d pending calls, waiting to be cleared", + gdbus_conn.conn_ref_count); + + if (gdbus_conn.handle_libnetwork != NULL) + WIFI_LOG(WIFI_ERROR, "A handle of libnetwork is not NULL"); + + gdbus_conn.handle_libnetwork = dlopen("/usr/lib/libnetwork.so", RTLD_LAZY); + + g_object_unref(gdbus_conn.connection); + } + + return NET_ERR_NONE; +} + +GDBusConnection *_net_dbus_get_gdbus_conn(void) +{ + return gdbus_conn.connection; +} + +GCancellable *_net_dbus_get_gdbus_cancellable(void) +{ + return gdbus_conn.cancellable; +} +//LCOV_EXCL_STOP + diff --git a/src/network_signal.c b/src/network_signal.c new file mode 100755 index 0000000..dbb8274 --- /dev/null +++ b/src/network_signal.c @@ -0,0 +1,1132 @@ +/* + * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "wifi_internal.h" +#include "network_internal.h" +#include "network_dbus.h" +#include "network_signal.h" + +extern __thread network_info_s NetworkInfo; +extern __thread network_request_table_s request_table[NETWORK_REQUEST_TYPE_MAX]; + +static __thread net_state_type_e service_state_table = NET_STATE_TYPE_UNKNOWN; +static __thread int net_service_error = NET_ERR_NONE; +static __thread guint gdbus_conn_subscribe_id_connman_state = 0; +static __thread guint gdbus_conn_subscribe_id_connman_error = 0; +static __thread guint gdbus_conn_subscribe_id_supplicant = 0; +static __thread guint gdbus_conn_subscribe_id_netconfig_wifi = 0; +static __thread guint gdbus_conn_subscribe_id_netconfig = 0; +static __thread int net_dpm_wifi_state = -1; +static __thread int net_dpm_wifi_profile_state = -1; + +//LCOV_EXCL_START +static int string2state(const char *state) +{ + if (g_strcmp0(state, "idle") == 0) + return NET_STATE_TYPE_IDLE; + else if (g_strcmp0(state, "association") == 0) + return NET_STATE_TYPE_ASSOCIATION; + else if (g_strcmp0(state, "configuration") == 0) + return NET_STATE_TYPE_CONFIGURATION; + else if (g_strcmp0(state, "ready") == 0) + return NET_STATE_TYPE_READY; + else if (g_strcmp0(state, "online") == 0) + return NET_STATE_TYPE_ONLINE; + else if (g_strcmp0(state, "disconnect") == 0) + return NET_STATE_TYPE_DISCONNECT; + else if (g_strcmp0(state, "failure") == 0) + return NET_STATE_TYPE_FAILURE; + + return NET_STATE_TYPE_UNKNOWN; +} + +static int string2error(const char *error) +{ + if (g_strcmp0(error, "out-of-range") == 0) + return NET_ERR_CONNECTION_OUT_OF_RANGE; + else if (g_strcmp0(error, "pin-missing") == 0) + return NET_ERR_CONNECTION_PIN_MISSING; + else if (g_strcmp0(error, "dhcp-failed") == 0) + return NET_ERR_CONNECTION_DHCP_FAILED; + else if (g_strcmp0(error, "connect-failed") == 0) + return NET_ERR_CONNECTION_CONNECT_FAILED; + else if (g_strcmp0(error, "login-failed") == 0) + return NET_ERR_CONNECTION_LOGIN_FAILED; + else if (g_strcmp0(error, "auth-failed") == 0) + return NET_ERR_CONNECTION_AUTH_FAILED; + else if (g_strcmp0(error, "invalid-key") == 0) + return NET_ERR_CONNECTION_INVALID_KEY; + + return NET_ERR_UNKNOWN; +} + +static int __net_handle_wifi_power_rsp(gboolean value) +{ + __NETWORK_FUNC_ENTER__; + + net_event_info_s event_data = { 0, }; + + if (value == TRUE) { + NetworkInfo.wifi_state = WIFI_ON; + event_data.Error = NET_ERR_NONE; + } else { + NetworkInfo.wifi_state = WIFI_OFF; + event_data.Error = NET_ERR_NONE; + + if (request_table[NETWORK_REQUEST_TYPE_SCAN].flag == TRUE) + memset(&request_table[NETWORK_REQUEST_TYPE_SCAN], + 0, sizeof(network_request_table_s)); + } + + if (request_table[NETWORK_REQUEST_TYPE_WIFI_POWER].flag == TRUE) { + memset(&request_table[NETWORK_REQUEST_TYPE_WIFI_POWER], + 0, sizeof(network_request_table_s)); + + event_data.Event = NET_EVENT_WIFI_POWER_RSP; + WIFI_LOG(WIFI_INFO, "NET_EVENT_WIFI_POWER_RSP wifi state: %d", + NetworkInfo.wifi_state); + + _net_dbus_pending_call_unref(); + } else { + event_data.Event = NET_EVENT_WIFI_POWER_IND; + WIFI_LOG(WIFI_INFO, "NET_EVENT_WIFI_POWER_IND wifi state: %d", + NetworkInfo.wifi_state); + } + + event_data.Datalength = sizeof(net_wifi_state_e); + event_data.Data = &(NetworkInfo.wifi_state); + + _net_client_callback(&event_data); + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +static wlan_security_mode_type_e __net_get_wlan_sec_mode(int security) +{ + switch (security) { + case 2: + return WLAN_SEC_MODE_WEP; + case 3: + return WLAN_SEC_MODE_WPA_PSK; + case 4: + return WLAN_SEC_MODE_IEEE8021X; + default: + return WLAN_SEC_MODE_NONE; + } +} + +static int __net_handle_specific_scan_resp(GSList *bss_info_list) +{ + __NETWORK_FUNC_ENTER__; + + int count = 0;; + net_event_info_s event_data = { 0, }; + + if (request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN].flag == TRUE) { + memset(&request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN], + 0, sizeof(network_request_table_s)); + + _net_dbus_pending_call_unref(); + + count = (int)g_slist_length(bss_info_list); + WIFI_LOG(WIFI_INFO, + "Received the signal: %s with total bss count = %d", + NETCONFIG_SIGNAL_SPECIFIC_SCAN_DONE, + count); + + event_data.Event = NET_EVENT_WIFI_SPECIFIC_SCAN_IND; + event_data.Datalength = count; + event_data.Data = bss_info_list; + + _net_client_callback(&event_data); + } else + g_slist_free_full(bss_info_list, g_free); + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +static int __net_handle_wifi_specific_scan_rsp(GVariant *param) +{ + GVariantIter *iter = NULL; + GVariant *value = NULL; + gchar *key = NULL; + const gchar *ssid = NULL; + gint32 security = 0; + gboolean wps = FALSE; + GSList *bss_info_list = NULL; + gboolean ssid_found = FALSE; + gboolean sec_found = FALSE; + gboolean wps_found = FALSE; + + g_variant_get(param, "(a{sv})", &iter); + + while (g_variant_iter_loop(iter, "{sv}", &key, &value)) { + if (g_strcmp0(key, "ssid") == 0 && ssid_found == FALSE) { + ssid = g_variant_get_string(value, NULL); + WIFI_LOG(WIFI_INFO, "SSID: %s", ssid); + ssid_found = TRUE; + } + if (g_strcmp0(key, "security") == 0 && sec_found == FALSE) { + security = g_variant_get_int32(value); + WIFI_LOG(WIFI_INFO, "with security: %d", security); + sec_found = TRUE; + } + if (g_strcmp0(key, "wps") == 0 && wps_found == FALSE) { + wps = g_variant_get_boolean(value); + WIFI_LOG(WIFI_INFO, "wps supported: %d", wps); + wps_found = TRUE; + } + + if (ssid_found == TRUE && sec_found == TRUE && wps_found == TRUE) { + net_ssid_scan_bss_info_s *bss = NULL; + bss = g_try_new0(net_ssid_scan_bss_info_s, 1); + if (bss == NULL) { + WIFI_LOG(WIFI_ERROR, "Memory allocation error"); + + g_slist_free_full(bss_info_list, g_free); + g_variant_unref(value); + g_free(key); + return NET_ERR_UNKNOWN; + } + + g_strlcpy(bss->ssid, ssid, NET_WLAN_ESSID_LEN); + bss->security = __net_get_wlan_sec_mode(security); + bss->wps = (char)wps; + bss_info_list = g_slist_append(bss_info_list, bss); + + ssid_found = sec_found = wps_found = FALSE; + } + } + g_variant_iter_free(iter); + + __net_handle_specific_scan_resp(bss_info_list); + + /* To enhance performance, + * BSS list should be release in a delayed manner in _net_client_callback */ + + return NET_ERR_NONE; +} + +static int __net_handle_wps_scan_resp(GSList *bss_info_list) +{ + __NETWORK_FUNC_ENTER__; + + int count = 0;; + net_event_info_s event_data = { 0, }; + + if (request_table[NETWORK_REQUEST_TYPE_WPS_SCAN].flag == TRUE) { + memset(&request_table[NETWORK_REQUEST_TYPE_WPS_SCAN], + 0, sizeof(network_request_table_s)); + + _net_dbus_pending_call_unref(); + + count = (int)g_slist_length(bss_info_list); + WIFI_LOG(WIFI_INFO, + "Received the signal: %s with total bss count = %d", + NETCONFIG_SIGNAL_WPS_SCAN_DONE, + count); + + event_data.Event = NET_EVENT_WIFI_WPS_SCAN_IND; + event_data.Datalength = count; + event_data.Data = bss_info_list; + + _net_client_callback(&event_data); + } else + g_slist_free_full(bss_info_list, g_free); + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +static int __net_handle_wifi_wps_scan_rsp(GVariant *param) +{ + GVariantIter *iter = NULL; + GVariant *value = NULL; + gchar *key = NULL; + GSList *bss_info_list = NULL; + const gchar *ssid = NULL; + const gchar *bssid = NULL; + gsize ssid_len; + int rssi = -89; + int mode = 0; + gboolean ssid_found = FALSE; + gboolean bssid_found = FALSE; + gboolean rssi_found = FALSE; + gboolean mode_found = FALSE; + + g_variant_get(param, "(a{sv})", &iter); + + while (g_variant_iter_loop(iter, "{sv}", &key, &value)) { + if (g_strcmp0(key, "ssid") == 0) { + ssid = g_variant_get_fixed_array(value, &ssid_len, sizeof(guchar)); + ssid_found = TRUE; + } else if (g_strcmp0(key, "bssid") == 0) { + bssid = g_variant_get_string(value, NULL); + bssid_found = TRUE; + } else if (g_strcmp0(key, "rssi") == 0) { + rssi = g_variant_get_int32(value); + rssi_found = TRUE; + } else if (g_strcmp0(key, "mode") == 0) { + mode = g_variant_get_int32(value); + mode_found = TRUE; + } + + if (ssid_found == TRUE && bssid_found == TRUE && + rssi_found == TRUE && mode_found == TRUE) { + net_wps_scan_bss_info_s *bss = NULL; + bss = g_try_new0(net_wps_scan_bss_info_s, 1); + if (bss == NULL) { + WIFI_LOG(WIFI_ERROR, "Memory allocation error"); + + g_slist_free_full(bss_info_list, g_free); + g_variant_unref(value); + g_free(key); + return NET_ERR_UNKNOWN; + } + + memcpy(bss->ssid, ssid, ssid_len); + g_strlcpy(bss->bssid, bssid, NET_WLAN_BSSID_LEN+1); + bss->rssi = rssi; + bss->mode = mode; + bss_info_list = g_slist_append(bss_info_list, bss); + + ssid_found = bssid_found = FALSE; + rssi_found = mode_found = FALSE; + } + } + g_variant_iter_free(iter); + + __net_handle_wps_scan_resp(bss_info_list); + + return NET_ERR_NONE; +} + +static void __net_handle_state_ind(const char *profile_name, + net_state_type_e profile_state) +{ + __NETWORK_FUNC_ENTER__; + + net_event_info_s event_data = { 0, }; + + event_data.Error = NET_ERR_NONE; + event_data.Event = NET_EVENT_NET_STATE_IND; + + g_strlcpy(event_data.ProfileName, profile_name, sizeof(event_data.ProfileName)); + + event_data.Datalength = sizeof(net_state_type_e); + event_data.Data = &profile_state; + + WIFI_LOG(WIFI_INFO, + "Sending NET_EVENT_NET_STATE_IND, state: %d, profile name: %s", + profile_state, event_data.ProfileName); + + _net_client_callback(&event_data); + + __NETWORK_FUNC_EXIT__; +} + +static void __net_handle_failure_ind(const char *profile_name) +{ + __NETWORK_FUNC_ENTER__; + + net_event_info_s event_data = { 0, }; + + const char *svc_name1 = + request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].ProfileName; + const char *svc_name2 = + request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].ProfileName; + const char *svc_name3 = + request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].ProfileName; + + if (request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag == TRUE && + strstr(profile_name, svc_name1) != NULL) { + memset(&request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION], 0, + sizeof(network_request_table_s)); + + event_data.Event = NET_EVENT_OPEN_RSP; + + _net_dbus_pending_call_unref(); + } else if (request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag == TRUE && + g_strcmp0(profile_name, svc_name2) == 0) { + memset(&request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS], 0, + sizeof(network_request_table_s)); + + event_data.Event = NET_EVENT_WIFI_WPS_RSP; + + memset(&request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION], 0, + sizeof(network_request_table_s)); + + _net_dbus_pending_call_unref(); + } else if (request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].flag == TRUE && + g_strcmp0(profile_name, svc_name3) == 0) { + memset(&request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION], 0, + sizeof(network_request_table_s)); + + event_data.Event = NET_EVENT_CLOSE_RSP; + + _net_dbus_pending_call_unref(); + } else { + __net_handle_state_ind(profile_name, NET_STATE_TYPE_FAILURE); + + __NETWORK_FUNC_EXIT__; + return; + } + + g_strlcpy(event_data.ProfileName, + profile_name, NET_PROFILE_NAME_LEN_MAX+1); + + if (net_service_error != NET_ERR_NONE) + event_data.Error = net_service_error; + else { + event_data.Error = NET_ERR_CONNECTION_CONNECT_FAILED; + WIFI_LOG(WIFI_ERROR, "Event error defined %d", event_data.Error); + } + event_data.Datalength = 0; + event_data.Data = NULL; + + net_service_error = NET_ERR_NONE; + + WIFI_LOG(WIFI_ERROR, "State failure %d", event_data.Error); + _net_client_callback(&event_data); + + /* Reseting the state back in case of failure state */ + service_state_table = NET_STATE_TYPE_IDLE; + + __NETWORK_FUNC_EXIT__; +} + +static int __net_handle_service_state_changed(const gchar *sig_path, + const char *key, const char *state) +{ + net_err_e Error = NET_ERR_NONE; + net_state_type_e old_state, new_state; + + net_event_info_s event_data = { 0, }; + + if (sig_path == NULL) + return Error; + + WIFI_LOG(WIFI_INFO, "[%s] %s", state, sig_path); + + if (NetworkInfo.wifi_state == WIFI_OFF) { + WIFI_LOG(WIFI_INFO, "Wi-Fi is off"); + return Error; + } + + old_state = service_state_table; + new_state = string2state(state); + + if (old_state == new_state) + return Error; + + service_state_table = new_state; + + switch (new_state) { + case NET_STATE_TYPE_IDLE: + if (NetworkInfo.wifi_state == WIFI_CONNECTED) + NetworkInfo.wifi_state = WIFI_ON; + case NET_STATE_TYPE_ASSOCIATION: + case NET_STATE_TYPE_CONFIGURATION: + __net_handle_state_ind(sig_path, new_state); + break; + + case NET_STATE_TYPE_READY: + case NET_STATE_TYPE_ONLINE: + { + if (old_state != NET_STATE_TYPE_READY && + old_state != NET_STATE_TYPE_ONLINE) { + const char *svc_name1 = + request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].ProfileName; + const char *svc_name2 = + request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].ProfileName; + + if (request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag == TRUE && + strstr(sig_path, svc_name1) != NULL) { + memset(&request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION], 0, + sizeof(network_request_table_s)); + + event_data.Event = NET_EVENT_OPEN_RSP; + + WIFI_LOG(WIFI_INFO, "Sending NET_EVENT_OPEN_RSP"); + + _net_dbus_pending_call_unref(); + } else if (request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag == TRUE && + g_strcmp0(sig_path, svc_name2) == 0) { + memset(&request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS], 0, + sizeof(network_request_table_s)); + + event_data.Event = NET_EVENT_WIFI_WPS_RSP; + + WIFI_LOG(WIFI_INFO, "Sending NET_EVENT_WIFI_WPS_RSP"); + + _net_dbus_pending_call_unref(); + } else { + event_data.Event = NET_EVENT_OPEN_IND; + + WIFI_LOG(WIFI_INFO, "Sending NET_EVENT_OPEN_IND"); + } + + net_profile_info_s prof_info; + if ((Error = net_get_profile_info(sig_path, &prof_info)) != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "net_get_profile_info() failed [%s]", + _net_print_error(Error)); + + event_data.Datalength = 0; + event_data.Data = NULL; + } else { + event_data.Datalength = sizeof(net_profile_info_s); + event_data.Data = &prof_info; + } + + event_data.Error = Error; + g_strlcpy(event_data.ProfileName, sig_path, NET_PROFILE_NAME_LEN_MAX+1); + + _net_client_callback(&event_data); + } else + __net_handle_state_ind(sig_path, new_state); + + break; + } + case NET_STATE_TYPE_DISCONNECT: + { + const char *svc_name1 = + request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].ProfileName; + const char *svc_name2 = + request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].ProfileName; + const char *svc_name3 = + request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].ProfileName; + + if (request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag != TRUE && + request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag != TRUE && + request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].flag != TRUE) { + /** Send Close Ind */ + event_data.Error = Error; + event_data.Event = NET_EVENT_CLOSE_IND; + g_strlcpy(event_data.ProfileName, sig_path, NET_PROFILE_NAME_LEN_MAX+1); + + event_data.Datalength = 0; + event_data.Data = NULL; + + WIFI_LOG(WIFI_INFO, "Sending NET_EVENT_CLOSE_IND"); + + _net_client_callback(&event_data); + } + + if (request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag == TRUE && + strstr(sig_path, svc_name2) != NULL) { + memset(&request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION], 0, + sizeof(network_request_table_s)); + + /** Send Open Resp */ + event_data.Error = NET_ERR_OPERATION_ABORTED; + event_data.Event = NET_EVENT_OPEN_RSP; + g_strlcpy(event_data.ProfileName, sig_path, NET_PROFILE_NAME_LEN_MAX+1); + + event_data.Datalength = 0; + event_data.Data = NULL; + + WIFI_LOG(WIFI_INFO, "Sending NET_EVENT_OPEN_RSP"); + + _net_dbus_pending_call_unref(); + + _net_client_callback(&event_data); + } + + if (request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag == TRUE && + g_strcmp0(sig_path, svc_name3) == 0) { + memset(&request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS], 0, + sizeof(network_request_table_s)); + + /** Send WPS Resp */ + event_data.Error = NET_ERR_OPERATION_ABORTED; + event_data.Event = NET_EVENT_WIFI_WPS_RSP; + g_strlcpy(event_data.ProfileName, sig_path, NET_PROFILE_NAME_LEN_MAX+1); + + event_data.Datalength = 0; + event_data.Data = NULL; + + WIFI_LOG(WIFI_INFO, "Sending NET_EVENT_WIFI_WPS_RSP"); + _net_dbus_pending_call_unref(); + + _net_client_callback(&event_data); + } + + if (request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].flag == TRUE && + g_strcmp0(sig_path, svc_name1) == 0) { + memset(&request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION], 0, + sizeof(network_request_table_s)); + + /** Send Close Resp */ + event_data.Error = Error; + event_data.Event = NET_EVENT_CLOSE_RSP; + g_strlcpy(event_data.ProfileName, sig_path, NET_PROFILE_NAME_LEN_MAX+1); + + event_data.Datalength = 0; + event_data.Data = NULL; + + WIFI_LOG(WIFI_INFO, "Sending NET_EVENT_CLOSE_RSP"); + + _net_dbus_pending_call_unref(); + + _net_client_callback(&event_data); + } + break; + } + case NET_STATE_TYPE_FAILURE: + __net_handle_failure_ind(sig_path); + break; + + default: + Error = NET_ERR_UNKNOWN_METHOD; + break; + } + + return Error; +} + +static int __net_handle_service_set_error(const char *key, const char *error) +{ + if (error == NULL || *error == '\0') + return NET_ERR_NONE; + + WIFI_LOG(WIFI_ERROR, "[%s] %s", key, error); + + net_service_error = string2error(error); + + return NET_ERR_NONE; +} + +static int __net_handle_scan_done(GVariant *param) +{ + net_event_info_s event_data = { 0, }; + + if (request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN].flag == TRUE) + return NET_ERR_NONE; + else if (request_table[NETWORK_REQUEST_TYPE_SCAN].flag == TRUE) { + memset(&request_table[NETWORK_REQUEST_TYPE_SCAN], 0, + sizeof(network_request_table_s)); + + event_data.Event = NET_EVENT_WIFI_SCAN_RSP; + + _net_dbus_pending_call_unref(); + } else { + event_data.Event = NET_EVENT_WIFI_SCAN_IND; + } + + event_data.Error = NET_ERR_NONE; + event_data.Datalength = 0; + event_data.Data = NULL; + + _net_client_callback(&event_data); + + return NET_ERR_NONE; +} + +static int __net_handle_network_dpm_wifi_event(GVariant *param) +{ + __NETWORK_FUNC_ENTER__; + + GVariantIter *iter = NULL; + GVariant *value = NULL; + const char *key = NULL; + const gchar *sig_value = NULL; + + g_variant_get(param, "(a{sv})", &iter); + + while (g_variant_iter_loop(iter, "{sv}", &key, &value)) { + if (g_strcmp0(key, "key") == 0) { + sig_value = g_variant_get_string(value, NULL); + WIFI_LOG(WIFI_INFO, "Wifi device policy : %s", + sig_value); + if (g_strcmp0(sig_value, "allowed") == 0) + net_dpm_wifi_state = TRUE; + else + net_dpm_wifi_state = FALSE; + } + } + g_variant_iter_free(iter); + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +static int __net_handle_network_dpm_wifi_profile_event(GVariant *param) +{ + __NETWORK_FUNC_ENTER__; + + GVariantIter *iter = NULL; + GVariant *value = NULL; + const char *key = NULL; + const gchar *sig_value = NULL; + + g_variant_get(param, "(a{sv})", &iter); + + while (g_variant_iter_loop(iter, "{sv}", &key, &value)) { + if (g_strcmp0(key, "key") == 0) { + sig_value = g_variant_get_string(value, NULL); + WIFI_LOG(WIFI_INFO, "Wifi profile device policy : %s", + sig_value); + if (g_strcmp0(sig_value, "allowed") == 0) + net_dpm_wifi_profile_state = TRUE; + else + net_dpm_wifi_profile_state = FALSE; + } + } + g_variant_iter_free(iter); + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +static void __net_connman_service_signal_filter(GDBusConnection *conn, + const gchar *name, const gchar *path, const gchar *interface, + const gchar *sig, GVariant *param, gpointer user_data) +{ + __NETWORK_FUNC_ENTER__; + + const char *key = NULL; + const char *value = NULL; + GVariant *var; + + if (g_strcmp0(sig, SIGNAL_PROPERTY_CHANGED) == 0) { + g_variant_get(param, "(sv)", &key, &var); + + if (g_strcmp0(key, "State") == 0) { + g_variant_get(var, "s", &value); + + __net_handle_service_state_changed(path, key, value); + } else if (g_strcmp0(key, "Error") == 0) { + g_variant_get(var, "s", &value); + + __net_handle_service_set_error(key, value); + } + + g_free((gchar *)value); + g_free((gchar *)key); + if (NULL != var) + g_variant_unref(var); + } + + __NETWORK_FUNC_EXIT__; +} +static int __net_handle_wifi_tdls_connected_event(GVariant *param) +{ + __NETWORK_FUNC_ENTER__; + + GVariantIter *iter = NULL; + GVariant *value = NULL; + const char *key = NULL; + const gchar *sig_value = NULL; + + g_variant_get(param, "(a{sv})", &iter); + + while (g_variant_iter_loop(iter, "{sv}", &key, &value)) { + if (g_strcmp0(key, "peermac") == 0) { + sig_value = g_variant_get_string(value, NULL); + + WIFI_LOG(WIFI_ERROR, "TDLS Connected Peer Mac Adress: %s", + sig_value); + } + } + g_variant_iter_free(iter); + + net_event_info_s event_data; + memset(&event_data, 0, sizeof(event_data)); + + event_data.Error = NET_ERR_NONE; + event_data.Event = NET_EVENT_WIFI_TDLS_CONNECTED_IND; + event_data.Data = g_strdup(sig_value); + + if (event_data.Data) + event_data.Datalength = strlen(event_data.Data); + else + event_data.Datalength = 0; + + WIFI_LOG(WIFI_ERROR, "Sending NET_EVENT_TDLS_CONNECTED_IND"); + _net_client_callback(&event_data); + g_free(event_data.Data); + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +static int __net_handle_wifi_tdls_disconnected_event(GVariant *param) +{ + __NETWORK_FUNC_ENTER__; + + GVariantIter *iter = NULL; + GVariant *value = NULL; + const char *key = NULL; + const gchar *sig_value = NULL; + + g_variant_get(param, "(a{sv})", &iter); + + while (g_variant_iter_loop(iter, "{sv}", &key, &value)) { + if (g_strcmp0(key, "peermac") == 0) { + sig_value = g_variant_get_string(value, NULL); + + WIFI_LOG(WIFI_ERROR, "TDLS Connected Peer Mac Adress: %s", + sig_value); + } + } + g_variant_iter_free(iter); + + net_event_info_s event_data; + memset(&event_data, 0, sizeof(event_data)); + + event_data.Error = NET_ERR_NONE; + event_data.Event = NET_EVENT_WIFI_TDLS_DISCONNECTED_IND; + event_data.Data = g_strdup(sig_value); + + if (event_data.Data) + event_data.Datalength = strlen(event_data.Data); + else + event_data.Datalength = 0; + + WIFI_LOG(WIFI_ERROR, "Sending NET_EVENT_TDLS_DISCONNECTED_IND"); + _net_client_callback(&event_data); + g_free(event_data.Data); + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +static int __net_handle_wifi_connect_fail_event(GVariant *param) +{ + __NETWORK_FUNC_ENTER__; + + net_event_info_s event_data = { 0, }; + network_request_table_s *open_info = + &request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION]; + network_request_table_s *wps_info = + &request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS]; + + event_data.Datalength = 0; + event_data.Data = NULL; + + WIFI_LOG(WIFI_ERROR, "Failed to connect WiFi"); + + if (open_info->flag == TRUE) { + memset(open_info, 0, sizeof(network_request_table_s)); + event_data.Error = NET_ERR_INVALID_OPERATION; + event_data.Event = NET_EVENT_OPEN_RSP; + WIFI_LOG(WIFI_INFO, "Sending NET_EVENT_OPEN_RSP"); + } else if (wps_info->flag == TRUE) { + memset(wps_info, 0, sizeof(network_request_table_s)); + event_data.Error = NET_ERR_INVALID_OPERATION; + event_data.Event = NET_EVENT_WIFI_WPS_RSP; + WIFI_LOG(WIFI_INFO, "Sending NET_EVENT_WIFI_WPS_RSP"); + } else { + WIFI_LOG(WIFI_WARN, "WiFi Connection flag not set"); + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; + } + _net_client_callback(&event_data); + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} + +static void __net_supplicant_signal_filter(GDBusConnection *conn, + const gchar *name, const gchar *path, const gchar *interface, + const gchar *sig, GVariant *param, gpointer user_data) +{ + if (g_strcmp0(sig, SIGNAL_SCAN_DONE) == 0) + __net_handle_scan_done(param); +} + +static void __net_netconfig_signal_filter(GDBusConnection *conn, + const gchar *name, const gchar *path, const gchar *interface, + const gchar *sig, GVariant *param, gpointer user_data) +{ + if (g_strcmp0(sig, NETCONFIG_SIGNAL_POWERON_COMPLETED) == 0) + __net_handle_wifi_power_rsp(TRUE); + else if (g_strcmp0(sig, NETCONFIG_SIGNAL_POWEROFF_COMPLETED) == 0) + __net_handle_wifi_power_rsp(FALSE); + else if (g_strcmp0(sig, NETCONFIG_SIGNAL_SPECIFIC_SCAN_DONE) == 0) + __net_handle_wifi_specific_scan_rsp(param); + else if (g_strcmp0(sig, NETCONFIG_SIGNAL_WPS_SCAN_DONE) == 0) + __net_handle_wifi_wps_scan_rsp(param); + else if (g_strcmp0(sig, NETCONFIG_SIGNAL_TDLS_CONNECTED) == 0) + __net_handle_wifi_tdls_connected_event(param); + else if (g_strcmp0(sig, NETCONFIG_SIGNAL_TDLS_DISCONNECTED) == 0) + __net_handle_wifi_tdls_disconnected_event(param); + else if (g_strcmp0(sig, NETCONFIG_SIGNAL_WIFI_CONNECT_FAIL) == 0) + __net_handle_wifi_connect_fail_event(param); +} + +static void __net_netconfig_network_signal_filter(GDBusConnection *conn, + const gchar *name, const gchar *path, const gchar *interface, + const gchar *sig, GVariant *param, gpointer user_data) +{ + if (g_strcmp0(sig, NETCONFIG_SIGNAL_DPM_WIFI) == 0) + __net_handle_network_dpm_wifi_event(param); + else if (g_strcmp0(sig, NETCONFIG_SIGNAL_DPM_WIFI_PROFILE) == 0) + __net_handle_network_dpm_wifi_profile_event(param); +} + +static int __net_get_tech_states(GVariant *msg, net_state_type_e *state_table) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariantIter *iter_main = NULL; + GVariantIter *var = NULL; + GVariant *value = NULL; + gchar *path = NULL; + gchar *key = NULL; + gboolean data; + + if (NetworkInfo.wifi_state == WIFI_UNKNOWN) + NetworkInfo.wifi_state = WIFI_OFF; + + g_variant_get(msg, "(a(oa{sv}))", &iter_main); + while (g_variant_iter_loop(iter_main, "(oa{sv})", &path, &var)) { + + if (path == NULL) + continue; + + while (g_variant_iter_loop(var, "{sv}", &key, &value)) { + if (g_strcmp0(key, "Connected") == 0) { + data = g_variant_get_boolean(value); + if (!data) + continue; + + if (g_strcmp0(path, CONNMAN_WIFI_TECHNOLOGY_PREFIX) == 0) { + *(state_table) = NET_STATE_TYPE_READY; + NetworkInfo.wifi_state = WIFI_CONNECTED; + } else + WIFI_LOG(WIFI_ERROR, "Invalid technology type"); + } else if (g_strcmp0(path, CONNMAN_WIFI_TECHNOLOGY_PREFIX) == 0 && + g_strcmp0(key, "Powered") == 0) { + data = g_variant_get_boolean(value); + if (data == FALSE) + NetworkInfo.wifi_state = WIFI_OFF; + else if (data == TRUE && NetworkInfo.wifi_state < WIFI_ON) + NetworkInfo.wifi_state = WIFI_ON; + } + } + } + g_variant_iter_free(iter_main); + + __NETWORK_FUNC_EXIT__; + return Error; +} + +static int __net_dbus_get_technology_states(net_state_type_e *state_table) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + GVariant *message = NULL; + + message = _net_invoke_dbus_method(CONNMAN_SERVICE, + CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE, + "GetTechnologies", NULL, &Error); + if (message == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to get technology info"); + goto done; + } + + Error = __net_get_tech_states(message, state_table); + + g_variant_unref(message); + +done: + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_get_dpm_wifi_state(void) +{ + return net_dpm_wifi_state; +} + +void _net_set_dpm_wifi_state(int state) +{ + net_dpm_wifi_state = state; +} + +gboolean _net_get_dpm_wifi_profile_state() +{ + return net_dpm_wifi_profile_state; +} + +void _net_set_dpm_wifi_profile_state(int state) +{ + net_dpm_wifi_profile_state = state; +} +//LCOV_EXCL_STOP + +int _net_deregister_signal(void) +{ + __NETWORK_FUNC_ENTER__; + + GDBusConnection *connection; + net_err_e Error = NET_ERR_NONE; + + connection = _net_dbus_get_gdbus_conn(); + if (connection == NULL) { + WIFI_LOG(WIFI_ERROR, "Already de-registered"); //LCOV_EXCL_LINE + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_APP_NOT_REGISTERED; //LCOV_EXCL_LINE + } + + g_dbus_connection_signal_unsubscribe(connection, + gdbus_conn_subscribe_id_connman_state); + g_dbus_connection_signal_unsubscribe(connection, + gdbus_conn_subscribe_id_connman_error); + g_dbus_connection_signal_unsubscribe(connection, + gdbus_conn_subscribe_id_supplicant); + g_dbus_connection_signal_unsubscribe(connection, + gdbus_conn_subscribe_id_netconfig_wifi); + g_dbus_connection_signal_unsubscribe(connection, + gdbus_conn_subscribe_id_netconfig); + + Error = _net_dbus_close_gdbus_call(); + if (Error != NET_ERR_NONE) { + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_register_signal(void) +{ + __NETWORK_FUNC_ENTER__; + + GDBusConnection *connection; + net_err_e Error = NET_ERR_NONE; + + Error = _net_dbus_create_gdbus_call(); + if (Error != NET_ERR_NONE) { + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + connection = _net_dbus_get_gdbus_conn(); + if (connection == NULL) { + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return NET_ERR_UNKNOWN; //LCOV_EXCL_LINE + } + + /* Create connman service state connection */ + gdbus_conn_subscribe_id_connman_state = g_dbus_connection_signal_subscribe( + connection, + CONNMAN_SERVICE, + CONNMAN_SERVICE_INTERFACE, + SIGNAL_PROPERTY_CHANGED, + NULL, + "State", + G_DBUS_SIGNAL_FLAGS_NONE, + __net_connman_service_signal_filter, + NULL, + NULL); + + /* Create connman service error connection */ + gdbus_conn_subscribe_id_connman_error = g_dbus_connection_signal_subscribe( + connection, + CONNMAN_SERVICE, + CONNMAN_SERVICE_INTERFACE, + SIGNAL_PROPERTY_CHANGED, + NULL, + "Error", + G_DBUS_SIGNAL_FLAGS_NONE, + __net_connman_service_signal_filter, + NULL, + NULL); + + /* Create net-config service connection for network */ + gdbus_conn_subscribe_id_netconfig = g_dbus_connection_signal_subscribe( + connection, + NETCONFIG_SERVICE, + NETCONFIG_NETWORK_INTERFACE, + NULL, + NETCONFIG_NETWORK_PATH, + NULL, + G_DBUS_SIGNAL_FLAGS_NONE, + __net_netconfig_network_signal_filter, + NULL, + NULL); + + /* Create supplicant service connection */ + gdbus_conn_subscribe_id_supplicant = g_dbus_connection_signal_subscribe( + connection, + SUPPLICANT_SERVICE, + SUPPLICANT_IFACE_INTERFACE, + "ScanDone", + NULL, + NULL, + G_DBUS_SIGNAL_FLAGS_NONE, + __net_supplicant_signal_filter, + NULL, + NULL); + + /* Create net-config service connection */ + gdbus_conn_subscribe_id_netconfig_wifi = g_dbus_connection_signal_subscribe( + connection, + NETCONFIG_SERVICE, + NETCONFIG_WIFI_INTERFACE, + NULL, + NETCONFIG_WIFI_PATH, + NULL, + G_DBUS_SIGNAL_FLAGS_NONE, + __net_netconfig_signal_filter, + NULL, + NULL); + + if (gdbus_conn_subscribe_id_connman_state == 0 || + gdbus_conn_subscribe_id_connman_error == 0 || + gdbus_conn_subscribe_id_netconfig == 0 || + gdbus_conn_subscribe_id_supplicant == 0 || + gdbus_conn_subscribe_id_netconfig_wifi == 0) { + WIFI_LOG(WIFI_ERROR, "Failed register signals " //LCOV_EXCL_LINE + "connman_state(%d), connman_error(%d), netconfig(%d), " + "supplicant(%d), netconfig_wifi(%d)", + gdbus_conn_subscribe_id_connman_state, + gdbus_conn_subscribe_id_connman_error, + gdbus_conn_subscribe_id_netconfig, + gdbus_conn_subscribe_id_supplicant, + gdbus_conn_subscribe_id_netconfig_wifi); + Error = NET_ERR_NOT_SUPPORTED; //LCOV_EXCL_LINE + } + + __NETWORK_FUNC_EXIT__; + return Error; +} + +int _net_init_service_state_table(void) +{ + __NETWORK_FUNC_ENTER__; + + net_err_e Error = NET_ERR_NONE; + + Error = __net_dbus_get_technology_states(&service_state_table); + if (Error != NET_ERR_NONE) { + __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE + return Error; //LCOV_EXCL_LINE + } + + WIFI_LOG(WIFI_INFO, "init service state table. " + "wifi:%d", service_state_table); + + __NETWORK_FUNC_EXIT__; + return NET_ERR_NONE; +} diff --git a/src/wifi_ap.c b/src/wifi_ap.c new file mode 100755 index 0000000..54b6342 --- /dev/null +++ b/src/wifi_ap.c @@ -0,0 +1,1570 @@ +/* + * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include + +#include "wifi_internal.h" + +#define MAX_PREFIX_LENGTH 6 + +//LCOV_EXCL_START +static char *__ap_convert_ip_to_string(net_addr_s *ip_addr, + wifi_manager_address_family_e address_family) +{ + unsigned char *ipaddr = NULL; + char *ipstr = NULL; + + if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4) { + ipaddr = (unsigned char *)&ip_addr->Data.Ipv4.s_addr; + ipstr = g_try_malloc0(INET_ADDRSTRLEN); + if (ipstr == NULL) + return NULL; + + inet_ntop(AF_INET, ipaddr, ipstr, INET_ADDRSTRLEN); + } else { + ipaddr = (unsigned char *)&ip_addr->Data.Ipv6; + ipstr = g_try_malloc0(INET6_ADDRSTRLEN); + if (ipstr == NULL) + return NULL; + + inet_ntop(AF_INET6, ipaddr, ipstr, INET6_ADDRSTRLEN); + } + return ipstr; +} + +static void __wifi_init_ap(net_profile_info_s *profile_info, const char *essid) +{ + profile_info->ProfileState = NET_STATE_TYPE_IDLE; + profile_info->net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF; + profile_info->net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT; + profile_info->wlan_mode = NET_WLAN_CONNMODE_AUTO; + profile_info->security_info.sec_mode = WLAN_SEC_MODE_NONE; + profile_info->security_info.enc_mode = WLAN_ENC_MODE_NONE; + g_strlcpy(profile_info->essid, essid, NET_WLAN_ESSID_LEN+1); +} + +static char *__wifi_create_profile_name(const char *ssid, + const int net_mode, const int sec_mode) +{ + char *buf = NULL; + char *pbuf = NULL; + const char *hidden_str = "hidden"; + char buf_tmp[32] = { 0, }; + int i; + int ssid_len = 0; + int actual_len = 0; + const char *mode = "managed"; + char *g_sec = NULL; + + if (net_mode == NET_WLAN_CONNMODE_ADHOC) { + WIFI_LOG(WIFI_ERROR, "wlan_mode is adhoc"); + return NULL; + } + + switch (sec_mode) { + case WLAN_SEC_MODE_NONE: + g_sec = "none"; + break; + case WLAN_SEC_MODE_WEP: + g_sec = "wep"; + break; + case WLAN_SEC_MODE_WPA_PSK: + case WLAN_SEC_MODE_WPA2_PSK: + g_sec = "psk"; + break; + case WLAN_SEC_MODE_IEEE8021X: + g_sec = "ieee8021x"; + break; + default: + WIFI_LOG(WIFI_ERROR, "Invalid security type"); + return NULL; + } + + if (NULL != ssid) { + ssid_len = strlen(ssid); + actual_len = ssid_len * 2; + } else { + ssid_len = strlen(hidden_str); + actual_len = ssid_len; + } + + buf = g_try_malloc0(actual_len + strlen(mode) + strlen(g_sec) + 3); + if (buf == NULL) + return NULL; + + if (NULL != ssid) { + pbuf = buf; + + for (i = 0; i < ssid_len; i++) { + g_snprintf(pbuf, 3, "%02x", ssid[i]); + pbuf += 2; + } + } else + g_strlcat(buf, hidden_str, + actual_len + strlen(mode) + strlen(g_sec) + 3); + + g_snprintf(buf_tmp, 32, "_%s_%s", mode, g_sec); + g_strlcat(buf, buf_tmp, + actual_len + strlen(mode) + strlen(g_sec) + 3); + + WIFI_LOG(WIFI_INFO, "Profile name: %s", buf); + + return buf; +} + +static bool _wifi_set_profile_name_to_ap(net_profile_info_s *ap_info) +{ + char *profile_name = NULL; + + if (ap_info == NULL) { + WIFI_LOG(WIFI_ERROR, "profile_info is NULL"); + return false; + } + + profile_name = __wifi_create_profile_name( + ap_info->is_hidden == TRUE ? + NULL : ap_info->essid, + ap_info->wlan_mode, + ap_info->security_info.sec_mode); + if (profile_name == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to make a group name"); + return false; + } + + g_strlcpy(ap_info->net_info.ProfileName, + profile_name, NET_PROFILE_NAME_LEN_MAX); + + g_free(profile_name); + + return true; +} + +wifi_manager_connection_state_e _wifi_convert_to_ap_state(net_state_type_e state) +{ + wifi_manager_connection_state_e ap_state; + + switch (state) { + case NET_STATE_TYPE_ONLINE: + case NET_STATE_TYPE_READY: + ap_state = WIFI_MANAGER_CONNECTION_STATE_CONNECTED; + break; + case NET_STATE_TYPE_FAILURE: + ap_state = WIFI_MANAGER_CONNECTION_STATE_FAILURE; + break; + case NET_STATE_TYPE_IDLE: + case NET_STATE_TYPE_DISCONNECT: + ap_state = WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED; + break; + case NET_STATE_TYPE_ASSOCIATION: + ap_state = WIFI_MANAGER_CONNECTION_STATE_ASSOCIATION; + break; + case NET_STATE_TYPE_CONFIGURATION: + ap_state = WIFI_MANAGER_CONNECTION_STATE_CONFIGURATION; + break; + default: + ap_state = -1; + break; + } + + return ap_state; +} +//LCOV_EXCL_STOP + +EXPORT_API int wifi_manager_ap_create(wifi_manager_h wifi, + const char *essid, wifi_manager_ap_h *ap) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + if (essid == NULL || ap == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *ap_info = g_try_malloc0(sizeof(net_profile_info_s)); + if (ap_info == NULL) + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + + __wifi_init_ap(ap_info, essid); + + _wifi_add_to_ap_list((wifi_manager_ap_h)ap_info); + *ap = (wifi_manager_ap_h)ap_info; + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_hidden_create(wifi_manager_h wifi, + const char *essid, wifi_manager_ap_h *ap) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + if (essid == NULL || ap == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *ap_info = g_try_malloc0(sizeof(net_profile_info_s)); + if (ap_info == NULL) + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + + __wifi_init_ap(ap_info, essid); + ap_info->is_hidden = TRUE; + + _wifi_add_to_ap_list((wifi_manager_ap_h)ap_info); + *ap = (wifi_manager_ap_h)ap_info; + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_destroy(wifi_manager_ap_h ap) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + _wifi_remove_from_ap_list(ap); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_clone(wifi_manager_ap_h *cloned_ap, wifi_manager_ap_h origin) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(origin) == false || cloned_ap == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *ap_info = g_try_malloc0(sizeof(net_profile_info_s)); + if (ap_info == NULL) + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + + memcpy(ap_info, origin, sizeof(net_profile_info_s)); + + _wifi_add_to_ap_list((wifi_manager_ap_h)ap_info); + *cloned_ap = (wifi_manager_ap_h)ap_info; + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_refresh(wifi_manager_ap_h ap) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + net_profile_info_s ap_info_local; + net_profile_info_s *ap_info = ap; + + if (_wifi_check_ap_validity(ap) == false) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + int rv = NET_ERR_NONE; + rv = net_get_profile_info(ap_info->ProfileName, &ap_info_local); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Failed to getprofile_info"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + + memcpy(ap, &ap_info_local, sizeof(net_profile_info_s)); + + return WIFI_MANAGER_ERROR_NONE; +} + +/* Wi-Fi network information ************************************************/ +EXPORT_API int wifi_manager_ap_get_essid(wifi_manager_ap_h ap, char **essid) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || essid == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + *essid = g_strdup(profile_info->essid); + if (*essid == NULL) + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_get_bssid(wifi_manager_ap_h ap, char **bssid) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || bssid == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + *bssid = g_strdup(profile_info->bssid); + if (*bssid == NULL) + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_get_rssi(wifi_manager_ap_h ap, int *rssi) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || rssi == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + *rssi = (int)(profile_info->Strength - 120); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_get_frequency(wifi_manager_ap_h ap, int *frequency) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || frequency == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + *frequency = (int)profile_info->frequency; + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_get_max_speed(wifi_manager_ap_h ap, int *max_speed) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || max_speed == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + *max_speed = (int)profile_info->max_rate / 1000000; + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_is_favorite(wifi_manager_ap_h ap, bool *favorite) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || favorite == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + if (profile_info->Favourite) + *favorite = true; + else + *favorite = false; + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_is_passpoint(wifi_manager_ap_h ap, bool *passpoint) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || passpoint == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + if (profile_info->passpoint) + *passpoint = true; + else + *passpoint = false; + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_get_connection_state(wifi_manager_ap_h ap, + wifi_manager_connection_state_e *state) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || state == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + *state = _wifi_convert_to_ap_state(profile_info->ProfileState); + + if (*state < 0) + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_get_ip_config_type(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, wifi_manager_ip_config_type_e *type) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + net_ip_config_type_e profileType ; + + if (_wifi_check_ap_validity(ap) == false || + (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 && + address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6) || + type == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4) + profileType = profile_info->net_info.IpConfigType ; + else + profileType = profile_info->net_info.IpConfigType6 ; //LCOV_EXCL_LINE + + if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4) { + switch (profileType) { + //LCOV_EXCL_START + case NET_IP_CONFIG_TYPE_STATIC: + *type = WIFI_MANAGER_IP_CONFIG_TYPE_STATIC; + break; + + case NET_IP_CONFIG_TYPE_DYNAMIC: + *type = WIFI_MANAGER_IP_CONFIG_TYPE_DYNAMIC; + break; + + case NET_IP_CONFIG_TYPE_AUTO_IP: + *type = WIFI_MANAGER_IP_CONFIG_TYPE_AUTO; + break; + + case NET_IP_CONFIG_TYPE_FIXED: + *type = WIFI_MANAGER_IP_CONFIG_TYPE_FIXED; + break; + + case NET_IP_CONFIG_TYPE_OFF: + *type = WIFI_MANAGER_IP_CONFIG_TYPE_NONE; + break; + + default: + return WIFI_MANAGER_ERROR_OPERATION_FAILED; + //LCOV_EXCL_STOP + } + } else { + //LCOV_EXCL_START + switch (profileType) { + case NET_IP_CONFIG_TYPE_STATIC: + *type = WIFI_MANAGER_IP_CONFIG_TYPE_STATIC; + break; + case NET_IP_CONFIG_TYPE_AUTO_IP: + *type = WIFI_MANAGER_IP_CONFIG_TYPE_AUTO; + break; + case NET_IP_CONFIG_TYPE_OFF: + *type = WIFI_MANAGER_IP_CONFIG_TYPE_NONE; + break; + default: + return WIFI_MANAGER_ERROR_OPERATION_FAILED; + } + //LCOV_EXCL_STOP + } + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_set_ip_config_type(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, wifi_manager_ip_config_type_e type) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + net_ip_config_type_e *profileType = NULL; + + if (_wifi_check_ap_validity(ap) == false || + (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 && + address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6)) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4) + profileType = &profile_info->net_info.IpConfigType ; + else + profileType = &profile_info->net_info.IpConfigType6 ; + + if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4) { + //LCOV_EXCL_START + switch (type) { + case WIFI_MANAGER_IP_CONFIG_TYPE_STATIC: + *profileType = NET_IP_CONFIG_TYPE_STATIC; + profile_info->net_info.IpAddr.Data.Ipv4.s_addr = 0; + profile_info->net_info.SubnetMask.Data.Ipv4.s_addr = 0; + profile_info->net_info.GatewayAddr.Data.Ipv4.s_addr = 0 ; + break; + + case WIFI_MANAGER_IP_CONFIG_TYPE_DYNAMIC: + *profileType = NET_IP_CONFIG_TYPE_DYNAMIC; + break; + + case WIFI_MANAGER_IP_CONFIG_TYPE_AUTO: + *profileType = NET_IP_CONFIG_TYPE_AUTO_IP; + break; + + case WIFI_MANAGER_IP_CONFIG_TYPE_FIXED: + *profileType = NET_IP_CONFIG_TYPE_FIXED; + break; + + case WIFI_MANAGER_IP_CONFIG_TYPE_NONE: + *profileType = NET_IP_CONFIG_TYPE_OFF; + break; + + default: + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + } + //LCOV_EXCL_STOP + } else { + //LCOV_EXCL_START + switch (type) { + case WIFI_MANAGER_IP_CONFIG_TYPE_STATIC: + *profileType = NET_IP_CONFIG_TYPE_STATIC; + inet_pton(AF_INET6, "::", &profile_info->net_info.IpAddr6.Data.Ipv6); + profile_info->net_info.PrefixLen6 = 0 ; + inet_pton(AF_INET6, "::", &profile_info->net_info.GatewayAddr6.Data.Ipv6); + break; + case WIFI_MANAGER_IP_CONFIG_TYPE_AUTO: + *profileType = NET_IP_CONFIG_TYPE_AUTO_IP; + break; + case WIFI_MANAGER_IP_CONFIG_TYPE_NONE: + *profileType = NET_IP_CONFIG_TYPE_OFF; + break; + default: + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + } + //LCOV_EXCL_STOP + } + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_get_ip_address(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, char **ip_address) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || + (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 && + address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6) || + ip_address == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4) + *ip_address = __ap_convert_ip_to_string( + &profile_info->net_info.IpAddr, + address_family); + else + *ip_address = __ap_convert_ip_to_string( + &profile_info->net_info.IpAddr6, + address_family); + + if (*ip_address == NULL) + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_set_ip_address(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, const char *ip_address) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || + (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 && + address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6)) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4) { + if (ip_address == NULL) + profile_info->net_info.IpAddr.Data.Ipv4.s_addr = 0; + else if (inet_aton(ip_address, + &(profile_info->net_info.IpAddr.Data.Ipv4)) == 0) + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + } else { + //LCOV_EXCL_START + if (ip_address == NULL) + inet_pton(AF_INET6, "::", + &profile_info->net_info.IpAddr6.Data.Ipv6); + else if (inet_pton(AF_INET6, ip_address, + &profile_info->net_info.IpAddr6.Data.Ipv6) == 0) + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + //LCOV_EXCL_STOP + } + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_get_subnet_mask(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, char **subnet_mask) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + char* prefixlen; + + if (_wifi_check_ap_validity(ap) == false || + (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 && + address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6) || + subnet_mask == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4) + *subnet_mask = __ap_convert_ip_to_string( + &profile_info->net_info.SubnetMask, + address_family); + else { + //LCOV_EXCL_START + prefixlen = g_try_malloc0(MAX_PREFIX_LENGTH); + if (prefixlen != NULL) { + snprintf(prefixlen, MAX_PREFIX_LENGTH, "%d", + profile_info->net_info.PrefixLen6); + *subnet_mask = prefixlen; + } else + *subnet_mask = NULL; + //LCOV_EXCL_STOP + } + + if (*subnet_mask == NULL) + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_set_subnet_mask(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, const char *subnet_mask) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || + (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 && + address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6)) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + /* Based on the family of address provided subnet mask should be set. + * For IPv6 address subnet mask is prefix length, an integer, while for + * Ipv6 address subnet mask is a ipv6 address. + */ + if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV6) { + //LCOV_EXCL_START + if (subnet_mask == NULL) + profile_info->net_info.PrefixLen6 = 0; + else { + /* subnet mask provided as input parameter is a string + * while for IPv6 address subnet mask in prefix length + * which should be in integer form */ + profile_info->net_info.PrefixLen6 = + atoi(subnet_mask) ; + } + //LCOV_EXCL_STOP + } else { + if (subnet_mask == NULL) + profile_info->net_info.SubnetMask.Data.Ipv4.s_addr = 0; + else if (inet_pton(AF_INET, subnet_mask, + &(profile_info->net_info.SubnetMask.Data.Ipv4)) < 1) + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_get_gateway_address(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, char **gateway_address) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || + (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 && + address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6) || + gateway_address == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + /* Based on the family of address provided, gateway should be set. + * For IPv6 address gateway is of form GatewayAddr6 but for IPv4 + * gateway is of form GatewayAddr. + */ + if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4) + *gateway_address = __ap_convert_ip_to_string( + &profile_info->net_info.GatewayAddr, + address_family); + else + *gateway_address = __ap_convert_ip_to_string( //LCOV_EXCL_LINE + &profile_info->net_info.GatewayAddr6, + address_family); + + if (*gateway_address == NULL) + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_set_gateway_address(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, const char *gateway_address) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || + (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 && + address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6)) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV6) { + //LCOV_EXCL_START + if (gateway_address == NULL) + inet_pton(AF_INET6, "::", + &profile_info->net_info.GatewayAddr6.Data.Ipv6); + else if (inet_pton(AF_INET6, gateway_address, + &profile_info->net_info.GatewayAddr6.Data.Ipv6) < 1) + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + //LCOV_EXCL_STOP + } else { + if (gateway_address == NULL) + profile_info->net_info.GatewayAddr.Data.Ipv4.s_addr = 0; + else if (inet_pton(AF_INET, gateway_address, + &profile_info->net_info.GatewayAddr.Data.Ipv4) < 1) + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_get_proxy_address(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, char **proxy_address) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || + (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 && + address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6) || + proxy_address == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + *proxy_address = g_strdup(profile_info->net_info.ProxyAddr); + if (*proxy_address == NULL) + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_set_proxy_address(wifi_manager_ap_h ap, + wifi_manager_address_family_e address_family, const char *proxy_address) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || + (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 && + address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6)) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + if (proxy_address == NULL) + profile_info->net_info.ProxyAddr[0] = '\0'; + else + g_strlcpy(profile_info->net_info.ProxyAddr, + proxy_address, NET_PROXY_LEN_MAX+1); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_get_proxy_type(wifi_manager_ap_h ap, + wifi_manager_proxy_type_e *proxy_type) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || proxy_type == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + //LCOV_EXCL_START + switch (profile_info->net_info.ProxyMethod) { + case NET_PROXY_TYPE_DIRECT: + *proxy_type = WIFI_MANAGER_PROXY_TYPE_DIRECT; + break; + case NET_PROXY_TYPE_AUTO: + *proxy_type = WIFI_MANAGER_PROXY_TYPE_AUTO; + break; + case NET_PROXY_TYPE_MANUAL: + *proxy_type = WIFI_MANAGER_PROXY_TYPE_MANUAL; + break; + case NET_PROXY_TYPE_UNKNOWN: + *proxy_type = WIFI_MANAGER_PROXY_TYPE_DIRECT; + break; + default: + return WIFI_MANAGER_ERROR_OPERATION_FAILED; + } + //LCOV_EXCL_STOP + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_set_proxy_type(wifi_manager_ap_h ap, + wifi_manager_proxy_type_e proxy_type) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + //LCOV_EXCL_START + switch (proxy_type) { + case WIFI_MANAGER_PROXY_TYPE_DIRECT: + profile_info->net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT; + break; + case WIFI_MANAGER_PROXY_TYPE_AUTO: + profile_info->net_info.ProxyAddr[0] = '\0'; + profile_info->net_info.ProxyMethod = NET_PROXY_TYPE_AUTO; + break; + case WIFI_MANAGER_PROXY_TYPE_MANUAL: + profile_info->net_info.ProxyAddr[0] = '\0'; + profile_info->net_info.ProxyMethod = NET_PROXY_TYPE_MANUAL; + g_strlcpy(profile_info->net_info.ProxyAddr, "0.0.0.0:8080", 15); + break; + default: + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + } + //LCOV_EXCL_STOP + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_get_dns_address(wifi_manager_ap_h ap, + int order, wifi_manager_address_family_e address_family, char **dns_address) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || + (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 && + address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6) || + dns_address == NULL || + order <= 0 || + order > NET_DNS_ADDR_MAX) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4) + *dns_address = __ap_convert_ip_to_string( + &profile_info->net_info.DnsAddr[order-1], + address_family); + else + *dns_address = __ap_convert_ip_to_string( //LCOV_EXCL_LINE + &profile_info->net_info.DnsAddr6[order-1], + address_family); + + if (*dns_address == NULL) + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_set_dns_address(wifi_manager_ap_h ap, + int order, wifi_manager_address_family_e address_family, const char *dns_address) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || + (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 && + address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6) || + order <= 0 || + order > NET_DNS_ADDR_MAX) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV6) { + //LCOV_EXCL_START + profile_info->net_info.DnsAddr6[order-1].Type = + NET_ADDR_IPV6; + if (dns_address == NULL) + inet_pton(AF_INET6, "::", + &profile_info->net_info.DnsAddr6[order-1].Data.Ipv6); + else if (inet_pton(AF_INET6, dns_address, + &profile_info->net_info.DnsAddr6[order-1].Data.Ipv6) < 1) + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + + if (profile_info->net_info.DnsCount6 < order) + profile_info->net_info.DnsCount6 = order; + //LCOV_EXCL_STOP + } else { + profile_info->net_info.DnsAddr[order-1].Type = + NET_ADDR_IPV4; + if (dns_address == NULL) + profile_info->net_info.DnsAddr[order-1].Data.Ipv4.s_addr = 0; + else if (inet_pton(AF_INET, dns_address, + &(profile_info->net_info.DnsAddr[order-1].Data.Ipv4)) < 1) + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + + if (profile_info->net_info.DnsCount < order) + profile_info->net_info.DnsCount = order; + } + + return WIFI_MANAGER_ERROR_NONE; +} + +/* Wi-Fi security information ************************************************/ +EXPORT_API int wifi_manager_ap_get_security_type(wifi_manager_ap_h ap, + wifi_manager_security_type_e *type) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || type == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + //LCOV_EXCL_START + switch (profile_info->security_info.sec_mode) { + case WLAN_SEC_MODE_NONE: + *type = WIFI_MANAGER_SECURITY_TYPE_NONE; + break; + case WLAN_SEC_MODE_WEP: + *type = WIFI_MANAGER_SECURITY_TYPE_WEP; + break; + case WLAN_SEC_MODE_IEEE8021X: + *type = WIFI_MANAGER_SECURITY_TYPE_EAP; + break; + case WLAN_SEC_MODE_WPA_PSK: + *type = WIFI_MANAGER_SECURITY_TYPE_WPA_PSK; + break; + case WLAN_SEC_MODE_WPA2_PSK: + *type = WIFI_MANAGER_SECURITY_TYPE_WPA2_PSK; + break; + default: + return WIFI_MANAGER_ERROR_OPERATION_FAILED; + } + //LCOV_EXCL_STOP + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_set_security_type(wifi_manager_ap_h ap, + wifi_manager_security_type_e type) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + //LCOV_EXCL_START + switch (type) { + case WIFI_MANAGER_SECURITY_TYPE_NONE: + profile_info->security_info.sec_mode = WLAN_SEC_MODE_NONE; + break; + case WIFI_MANAGER_SECURITY_TYPE_WEP: + profile_info->security_info.sec_mode = WLAN_SEC_MODE_WEP; + break; + case WIFI_MANAGER_SECURITY_TYPE_EAP: + profile_info->security_info.sec_mode = WLAN_SEC_MODE_IEEE8021X; + break; + case WIFI_MANAGER_SECURITY_TYPE_WPA_PSK: + profile_info->security_info.sec_mode = WLAN_SEC_MODE_WPA_PSK; + break; + case WIFI_MANAGER_SECURITY_TYPE_WPA2_PSK: + profile_info->security_info.sec_mode = WLAN_SEC_MODE_WPA2_PSK; + break; + default: + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + } + //LCOV_EXCL_STOP + + _wifi_set_profile_name_to_ap(profile_info); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_get_encryption_type(wifi_manager_ap_h ap, + wifi_manager_encryption_type_e *type) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || type == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + //LCOV_EXCL_START + switch (profile_info->security_info.enc_mode) { + case WLAN_ENC_MODE_NONE: + *type = WIFI_MANAGER_ENCRYPTION_TYPE_NONE; + break; + case WLAN_ENC_MODE_WEP: + *type = WIFI_MANAGER_ENCRYPTION_TYPE_WEP; + break; + case WLAN_ENC_MODE_TKIP: + *type = WIFI_MANAGER_ENCRYPTION_TYPE_TKIP; + break; + case WLAN_ENC_MODE_AES: + *type = WIFI_MANAGER_ENCRYPTION_TYPE_AES; + break; + case WLAN_ENC_MODE_TKIP_AES_MIXED: + *type = WIFI_MANAGER_ENCRYPTION_TYPE_TKIP_AES_MIXED; + break; + default: + return WIFI_MANAGER_ERROR_OPERATION_FAILED; + } + //LCOV_EXCL_STOP + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_set_encryption_type(wifi_manager_ap_h ap, + wifi_manager_encryption_type_e type) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + //LCOV_EXCL_START + switch (type) { + case WIFI_MANAGER_ENCRYPTION_TYPE_NONE: + profile_info->security_info.enc_mode = WLAN_ENC_MODE_NONE; + break; + case WIFI_MANAGER_ENCRYPTION_TYPE_WEP: + profile_info->security_info.enc_mode = WLAN_ENC_MODE_WEP; + break; + case WIFI_MANAGER_ENCRYPTION_TYPE_TKIP: + profile_info->security_info.enc_mode = WLAN_ENC_MODE_TKIP; + break; + case WIFI_MANAGER_ENCRYPTION_TYPE_AES: + profile_info->security_info.enc_mode = WLAN_ENC_MODE_AES; + break; + case WIFI_MANAGER_ENCRYPTION_TYPE_TKIP_AES_MIXED: + profile_info->security_info.enc_mode = WLAN_ENC_MODE_TKIP_AES_MIXED; + break; + default: + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + } + //LCOV_EXCL_STOP + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_is_passphrase_required(wifi_manager_ap_h ap, + bool *required) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || required == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + if (profile_info->Favourite) { + *required = false; + return WIFI_MANAGER_ERROR_NONE; + } + + //LCOV_EXCL_START + switch (profile_info->security_info.sec_mode) { + case WLAN_SEC_MODE_NONE: + *required = false; + break; + case WLAN_SEC_MODE_WEP: + case WLAN_SEC_MODE_IEEE8021X: + case WLAN_SEC_MODE_WPA_PSK: + case WLAN_SEC_MODE_WPA2_PSK: + *required = true; + break; + default: + return WIFI_MANAGER_ERROR_OPERATION_FAILED; + } + //LCOV_EXCL_STOP + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_set_passphrase(wifi_manager_ap_h ap, const char *passphrase) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || passphrase == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + //LCOV_EXCL_START + switch (profile_info->security_info.sec_mode) { + case WLAN_SEC_MODE_WEP: + g_strlcpy(profile_info->security_info.authentication.wep.wepKey, + passphrase, NET_WLAN_MAX_WEP_KEY_LEN+1); + break; + case WLAN_SEC_MODE_WPA_PSK: + case WLAN_SEC_MODE_WPA2_PSK: + g_strlcpy(profile_info->security_info.authentication.psk.pskKey, + passphrase, NET_WLAN_MAX_PSK_PASSPHRASE_LEN+1); + break; + case WLAN_SEC_MODE_NONE: + case WLAN_SEC_MODE_IEEE8021X: + default: + return WIFI_MANAGER_ERROR_OPERATION_FAILED; + } + //LCOV_EXCL_STOP + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_is_wps_supported(wifi_manager_ap_h ap, bool *supported) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || supported == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + if (profile_info->security_info.wps_support) + *supported = true; + else + *supported = false; + + return WIFI_MANAGER_ERROR_NONE; +} + +/* Wi-Fi EAP *****************************************************************/ +EXPORT_API int wifi_manager_ap_set_eap_passphrase(wifi_manager_ap_h ap, + const char *user_name, const char *password) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || (user_name == NULL && password == NULL)) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) + return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE + + if (user_name) + g_strlcpy(profile_info->security_info.authentication.eap.username, + user_name, NET_WLAN_USERNAME_LEN+1); + + if (password) + g_strlcpy(profile_info->security_info.authentication.eap.password, + password, NET_WLAN_PASSWORD_LEN+1); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_get_eap_passphrase(wifi_manager_ap_h ap, + char **user_name, bool *is_password_set) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || user_name == NULL || is_password_set == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) + return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE + + *user_name = g_strdup(profile_info->security_info.authentication.eap.username); + if (*user_name == NULL) + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + + if (strlen(profile_info->security_info.authentication.eap.password) > 0) + *is_password_set = true; + else + *is_password_set = false; + + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_get_eap_ca_cert_file(wifi_manager_ap_h ap, char **file) +{ + net_profile_info_s *profile_info = NULL; + + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || file == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + profile_info = (net_profile_info_s *)ap; + if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) + return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE + + *file = g_strdup(profile_info->security_info.authentication.eap.ca_cert_filename); + if (*file == NULL) + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_set_eap_ca_cert_file(wifi_manager_ap_h ap, const char *file) +{ + net_profile_info_s *profile_info = NULL; + + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || file == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + profile_info = (net_profile_info_s *)ap; + if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) + return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE + + g_strlcpy(profile_info->security_info.authentication.eap.ca_cert_filename, + file, NET_WLAN_CA_CERT_FILENAME_LEN+1); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_get_eap_client_cert_file(wifi_manager_ap_h ap, char **file) +{ + net_profile_info_s *profile_info = NULL; + + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || file == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + profile_info = (net_profile_info_s *)ap; + if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) + return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE + + *file = g_strdup(profile_info->security_info.authentication.eap.client_cert_filename); + if (*file == NULL) + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_set_eap_client_cert_file(wifi_manager_ap_h ap, + const char *file) +{ + net_profile_info_s *profile_info = NULL; + + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || file == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + profile_info = (net_profile_info_s *)ap; + if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) + return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE + + g_strlcpy(profile_info->security_info.authentication.eap.client_cert_filename, + file, NET_WLAN_CLIENT_CERT_FILENAME_LEN+1); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_get_eap_private_key_file(wifi_manager_ap_h ap, char **file) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || file == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) + return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE + + *file = g_strdup(profile_info->security_info.authentication.eap.private_key_filename); + if (*file == NULL) + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_set_eap_private_key_info(wifi_manager_ap_h ap, + const char *file, const char *password) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || file == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) + return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE + + g_strlcpy(profile_info->security_info.authentication.eap.private_key_filename, + file, NET_WLAN_PRIVATE_KEY_FILENAME_LEN+1); + + if (password) { + g_strlcpy(profile_info->security_info.authentication.eap.private_key_passwd, + password, NET_WLAN_PRIVATE_KEY_PASSWD_LEN+1); + } + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_get_eap_type(wifi_manager_ap_h ap, + wifi_manager_eap_type_e *type) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || type == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) + return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE + + //LCOV_EXCL_START + switch (profile_info->security_info.authentication.eap.eap_type) { + case WLAN_SEC_EAP_TYPE_PEAP: + *type = WIFI_MANAGER_EAP_TYPE_PEAP; + break; + case WLAN_SEC_EAP_TYPE_TLS: + *type = WIFI_MANAGER_EAP_TYPE_TLS; + break; + case WLAN_SEC_EAP_TYPE_TTLS: + *type = WIFI_MANAGER_EAP_TYPE_TTLS; + break; + case WLAN_SEC_EAP_TYPE_SIM: + *type = WIFI_MANAGER_EAP_TYPE_SIM; + break; + case WLAN_SEC_EAP_TYPE_AKA: + *type = WIFI_MANAGER_EAP_TYPE_AKA; + break; + default: + return WIFI_MANAGER_ERROR_OPERATION_FAILED; + } + //LCOV_EXCL_STOP + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_set_eap_type(wifi_manager_ap_h ap, + wifi_manager_eap_type_e type) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) + return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE + + //LCOV_EXCL_START + switch (type) { + case WIFI_MANAGER_EAP_TYPE_PEAP: + profile_info->security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_PEAP; + break; + case WIFI_MANAGER_EAP_TYPE_TLS: + profile_info->security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_TLS; + break; + case WIFI_MANAGER_EAP_TYPE_TTLS: + profile_info->security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_TTLS; + break; + case WIFI_MANAGER_EAP_TYPE_SIM: + profile_info->security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_SIM; + break; + case WIFI_MANAGER_EAP_TYPE_AKA: + profile_info->security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_AKA; + break; + default: + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + } + //LCOV_EXCL_STOP + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_get_eap_auth_type(wifi_manager_ap_h ap, + wifi_manager_eap_auth_type_e *type) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false || type == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) + return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE + + //LCOV_EXCL_START + switch (profile_info->security_info.authentication.eap.eap_auth) { + case WLAN_SEC_EAP_AUTH_NONE: + *type = WIFI_MANAGER_EAP_AUTH_TYPE_NONE; + break; + case WLAN_SEC_EAP_AUTH_PAP: + *type = WIFI_MANAGER_EAP_AUTH_TYPE_PAP; + break; + case WLAN_SEC_EAP_AUTH_MSCHAP: + *type = WIFI_MANAGER_EAP_AUTH_TYPE_MSCHAP; + break; + case WLAN_SEC_EAP_AUTH_MSCHAPV2: + *type = WIFI_MANAGER_EAP_AUTH_TYPE_MSCHAPV2; + break; + case WLAN_SEC_EAP_AUTH_GTC: + *type = WIFI_MANAGER_EAP_AUTH_TYPE_GTC; + break; + case WLAN_SEC_EAP_AUTH_MD5: + *type = WIFI_MANAGER_EAP_AUTH_TYPE_MD5; + break; + default: + return WIFI_MANAGER_ERROR_OPERATION_FAILED; + } + //LCOV_EXCL_STOP + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_ap_set_eap_auth_type(wifi_manager_ap_h ap, + wifi_manager_eap_auth_type_e type) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (_wifi_check_ap_validity(ap) == false) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) + return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE + + //LCOV_EXCL_START + switch (type) { + case WIFI_MANAGER_EAP_AUTH_TYPE_NONE: + profile_info->security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_NONE; + break; + case WIFI_MANAGER_EAP_AUTH_TYPE_PAP: + profile_info->security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_PAP; + break; + case WIFI_MANAGER_EAP_AUTH_TYPE_MSCHAP: + profile_info->security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_MSCHAP; + break; + case WIFI_MANAGER_EAP_AUTH_TYPE_MSCHAPV2: + profile_info->security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_MSCHAPV2; + break; + case WIFI_MANAGER_EAP_AUTH_TYPE_GTC: + profile_info->security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_GTC; + break; + case WIFI_MANAGER_EAP_AUTH_TYPE_MD5: + profile_info->security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_MD5; + break; + default: + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + } + //LCOV_EXCL_STOP + + return WIFI_MANAGER_ERROR_NONE; +} diff --git a/src/wifi_config.c b/src/wifi_config.c new file mode 100755 index 0000000..cfa10d5 --- /dev/null +++ b/src/wifi_config.c @@ -0,0 +1,606 @@ +/* + * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "wifi-manager.h" +#include "wifi_internal.h" + +/** + * Wifi Configuration CAPI + */ +EXPORT_API int wifi_manager_config_create(wifi_manager_h wifi, const char *name, + const char *passphrase, wifi_manager_security_type_e security_type, wifi_manager_config_h *config) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = NULL; + + if (!(__wifi_check_handle_validity(wifi)) || + config == NULL || name == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + h = g_new0(wifi_config_s, 1); + if (h == NULL) + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + + h->name = g_strdup(name); + h->passphrase = g_strdup(passphrase); + h->security_type = security_type; + h->is_saved = FALSE; + h->is_hidden = FALSE; + h->proxy_address = NULL; + h->address_family = WIFI_MANAGER_ADDRESS_FAMILY_IPV4; + h->eap_config = NULL; + + if (security_type == WIFI_MANAGER_SECURITY_TYPE_EAP) { + h->eap_config = g_new0(wifi_eap_config_s, 1); + if (h->eap_config == NULL) { + g_free(h->name); //LCOV_EXCL_LINE + g_free(h->passphrase); //LCOV_EXCL_LINE + g_free(h); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + } + + h->eap_config->ca_cert = NULL; + h->eap_config->client_cert = NULL; + h->eap_config->private_key = NULL; + h->eap_config->anonymous_identity = NULL; + h->eap_config->identity = NULL; + h->eap_config->subject_match = NULL; + h->eap_config->eap_type = -1; + h->eap_config->eap_auth_type = WIFI_MANAGER_EAP_AUTH_TYPE_NONE; + } + + _wifi_add_to_config_list((wifi_manager_config_h)h); + *config = (wifi_manager_config_h)h; + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_config_clone(wifi_manager_config_h origin, wifi_manager_config_h *cloned_config) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = NULL; + wifi_config_s *config = NULL; + + if (_wifi_check_config_validity(origin) == false || cloned_config == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + config = (wifi_config_s *)origin; + + h = g_new0(wifi_config_s, 1); + if (h == NULL) + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + + h->name = g_strdup(config->name); + h->passphrase = g_strdup(config->passphrase); + h->security_type = config->security_type; + h->is_saved = config->is_saved; + h->is_hidden = config->is_hidden; + h->proxy_address = g_strdup(config->proxy_address); + h->address_family = config->address_family; + + if (config->eap_config) { + h->eap_config = g_new0(wifi_eap_config_s, 1); + if (h->eap_config == NULL) { + g_free(h->name); //LCOV_EXCL_LINE + g_free(h->passphrase); //LCOV_EXCL_LINE + g_free(h->proxy_address); //LCOV_EXCL_LINE + g_free(h); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + } + + h->eap_config->ca_cert = g_strdup(config->eap_config->ca_cert); + h->eap_config->client_cert = g_strdup(config->eap_config->client_cert); + h->eap_config->private_key = g_strdup(config->eap_config->private_key); + h->eap_config->anonymous_identity = g_strdup(config->eap_config->anonymous_identity); + h->eap_config->identity = g_strdup(config->eap_config->identity); + h->eap_config->subject_match = g_strdup(config->eap_config->subject_match); + h->eap_config->eap_type = config->eap_config->eap_type; + h->eap_config->eap_auth_type = config->eap_config->eap_auth_type; + } + + _wifi_add_to_config_list((wifi_manager_config_h)h); + *cloned_config = (wifi_manager_config_h)h; + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_config_destroy(wifi_manager_config_h config) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + + if (_wifi_check_config_validity(config) == false) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + g_free(h->name); + g_free(h->passphrase); + g_free(h->proxy_address); + if (h->eap_config) { + g_free(h->eap_config->ca_cert); + g_free(h->eap_config->client_cert); + g_free(h->eap_config->private_key); + g_free(h->eap_config->anonymous_identity); + g_free(h->eap_config->identity); + g_free(h->eap_config->subject_match); + g_free(h->eap_config); + } + + _wifi_remove_from_config_list(config); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_config_save(wifi_manager_h wifi, + wifi_manager_config_h config) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + int ret = WIFI_MANAGER_ERROR_NONE; + wifi_config_s *h = (wifi_config_s *)config; + + if (!(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + if (_wifi_check_config_validity(config) == false || h->name == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + if (h->security_type == WIFI_MANAGER_SECURITY_TYPE_EAP) { + ret = _wifi_save_eap_configurations(h->name, h->passphrase, + h->security_type, h->proxy_address, h->eap_config, h->is_hidden); + if (ret != WIFI_MANAGER_ERROR_NONE) + WIFI_LOG(WIFI_ERROR, "Fail to wifi_save_eap_configurations"); //LCOV_EXCL_LINE + } else { + ret = _wifi_save_configuration(h->name, + h->passphrase, h->security_type, h->proxy_address, h->is_hidden); + if (ret != WIFI_MANAGER_ERROR_NONE) + WIFI_LOG(WIFI_ERROR, "Fail to save configurations [%d]", ret); //LCOV_EXCL_LINE + } + + h->is_saved = TRUE; + + return ret; +} + +EXPORT_API int wifi_manager_config_remove(wifi_manager_h wifi, wifi_manager_config_h config) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + int ret = WIFI_MANAGER_ERROR_NONE; + wifi_config_s *h = (wifi_config_s *)config; + + if (!(__wifi_check_handle_validity(wifi)) || + config == NULL || h->name == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + if (_wifi_check_config_validity(config) == false) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + if (h->is_saved == TRUE) { + gchar *config_id = NULL; + + config_id = _wifi_config_get_config_id(h->name, h->security_type); + + ret = _wifi_remove_configuration(config_id); + if (ret != WIFI_MANAGER_ERROR_NONE) + WIFI_LOG(WIFI_ERROR, "Fail to remove configurations [%d]", ret); + + g_free(config_id); + } + + return ret; +} + +EXPORT_API int wifi_manager_config_foreach_configuration(wifi_manager_h wifi, + wifi_manager_config_list_cb callback, void *user_data) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + int ret = WIFI_MANAGER_ERROR_NONE; + + if (!(__wifi_check_handle_validity(wifi)) || callback == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + ret = _wifi_load_configurations(); + if (ret != WIFI_MANAGER_ERROR_NONE) { + WIFI_LOG(WIFI_ERROR, "Fail to load configurations [%d]", ret); //LCOV_EXCL_LINE + return ret; //LCOV_EXCL_LINE + } + + return _wifi_foreach_configuration(callback, user_data); +} + +EXPORT_API int wifi_manager_config_get_name(wifi_manager_config_h config, char **name) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + + if (_wifi_check_config_validity(config) == false || name == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + if (h->name != NULL) + *name = g_strdup(h->name); + else + *name = NULL; + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_config_get_security_type(wifi_manager_config_h config, + wifi_manager_security_type_e *security_type) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + + if (_wifi_check_config_validity(config) == false || security_type == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + *security_type = h->security_type; + + return WIFI_MANAGER_ERROR_NONE; +} + +/** + * wifi configuration set field + */ +EXPORT_API int wifi_manager_config_set_proxy_address(wifi_manager_config_h config, + wifi_manager_address_family_e address_family, const char *proxy_address) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + int ret = WIFI_MANAGER_ERROR_NONE; + + if (_wifi_check_config_validity(config) == false) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + if ((address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 && address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6)) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV6) { + WIFI_LOG(WIFI_ERROR, "Not supported yet"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED; //LCOV_EXCL_LINE + } + + h->address_family = address_family; + h->proxy_address = g_strdup(proxy_address); + + return ret; +} + +EXPORT_API int wifi_manager_config_get_proxy_address(wifi_manager_config_h config, + wifi_manager_address_family_e *address_family, char **proxy_address) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + + if (_wifi_check_config_validity(config) == false || + address_family == NULL || proxy_address == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + *address_family = h->address_family; + *proxy_address = g_strdup(h->proxy_address); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_config_set_hidden_ap_property(wifi_manager_config_h config, bool hidden) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + int ret = WIFI_MANAGER_ERROR_NONE; + + if (_wifi_check_config_validity(config) == false) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + h->is_hidden = hidden; + + return ret; +} + +EXPORT_API int wifi_manager_config_get_hidden_ap_property(wifi_manager_config_h config, + bool *hidden) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + + if (_wifi_check_config_validity(config) == false || hidden == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + *hidden = h->is_hidden; + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_config_get_eap_anonymous_identity(wifi_manager_config_h config, + char **anonymous_identity) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + + if (_wifi_check_config_validity(config) == false || + h->eap_config == NULL || anonymous_identity == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + *anonymous_identity = g_strdup(h->eap_config->anonymous_identity); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_config_set_eap_anonymous_identity(wifi_manager_config_h config, + const char *anonymous_identity) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + + if (_wifi_check_config_validity(config) == false || h->eap_config == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + h->eap_config->anonymous_identity = g_strdup(anonymous_identity); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_config_get_eap_ca_cert_file(wifi_manager_config_h config, + char **ca_cert) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + + if (_wifi_check_config_validity(config) == false || + h->eap_config == NULL || ca_cert == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + *ca_cert = g_strdup(h->eap_config->ca_cert); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_config_set_eap_ca_cert_file(wifi_manager_config_h config, + const char *ca_cert) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + + if (_wifi_check_config_validity(config) == false || h->eap_config == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + h->eap_config->ca_cert = g_strdup(ca_cert); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_config_get_eap_client_cert_file(wifi_manager_config_h config, + char **client_cert) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + + if (_wifi_check_config_validity(config) == false || + h->eap_config == NULL || client_cert == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + *client_cert = g_strdup(h->eap_config->client_cert); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_config_set_eap_client_cert_file(wifi_manager_config_h config, + const char *private_key, const char *client_cert) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + + if (_wifi_check_config_validity(config) == false || h->eap_config == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + h->eap_config->private_key = g_strdup(private_key); + h->eap_config->client_cert = g_strdup(client_cert); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_config_get_eap_identity(wifi_manager_config_h config, char **identity) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + + if (_wifi_check_config_validity(config) == false || + h->eap_config == NULL || identity == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + *identity = g_strdup(h->eap_config->identity); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_config_set_eap_identity(wifi_manager_config_h config, const char *identity) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + + if (_wifi_check_config_validity(config) == false || h->eap_config == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + h->eap_config->identity = g_strdup(identity); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_config_get_eap_type(wifi_manager_config_h config, + wifi_manager_eap_type_e *eap_type) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + + if (_wifi_check_config_validity(config) == false || + h->eap_config == NULL || eap_type == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + *eap_type = h->eap_config->eap_type; + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_config_set_eap_type(wifi_manager_config_h config, + wifi_manager_eap_type_e eap_type) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + + if (_wifi_check_config_validity(config) == false || h->eap_config == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + h->eap_config->eap_type = eap_type; + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_config_get_eap_auth_type(wifi_manager_config_h config, + wifi_manager_eap_auth_type_e *eap_auth_type) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + + if (_wifi_check_config_validity(config) == false || + h->eap_config == NULL || eap_auth_type == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + *eap_auth_type = h->eap_config->eap_auth_type; + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_config_set_eap_auth_type(wifi_manager_config_h config, + wifi_manager_eap_auth_type_e eap_auth_type) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + + if (_wifi_check_config_validity(config) == false || h->eap_config == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + h->eap_config->eap_auth_type = eap_auth_type; + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_config_get_eap_subject_match(wifi_manager_config_h config, + char **subject_match) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + + if (_wifi_check_config_validity(config) == false || + h->eap_config == NULL || subject_match == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + *subject_match = g_strdup(h->eap_config->subject_match); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_config_set_eap_subject_match(wifi_manager_config_h config, + const char *subject_match) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + wifi_config_s *h = (wifi_config_s *)config; + + if (_wifi_check_config_validity(config) == false || h->eap_config == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + h->eap_config->subject_match = g_strdup(subject_match); + + return WIFI_MANAGER_ERROR_NONE; +} diff --git a/src/wifi_internal.c b/src/wifi_internal.c new file mode 100755 index 0000000..7887c93 --- /dev/null +++ b/src/wifi_internal.c @@ -0,0 +1,1712 @@ +/* + * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +#include "wifi_internal.h" + +#define WIFI_SECURITY_NONE "none" +#define WIFI_SECURITY_WEP "wep" +#define WIFI_SECURITY_WPA_PSK "psk" +#define WIFI_SECURITY_EAP "ieee8021x" + +static __thread GSList *wifi_manager_handle_list = NULL; +static __thread GSList *ap_handle_list = NULL; +static __thread GSList *config_handle_list = NULL; + +static __thread GSList *profile_iterator = NULL; +static __thread GSList *specific_profile_iterator = NULL; +static __thread GSList *config_iterator = NULL; +static __thread char specific_profile_essid[NET_WLAN_ESSID_LEN + 1] = { 0, }; +static __thread bool wifi_is_feature_checked[WIFI_SUPPORTED_FEATURE_MAX] = {0, }; +static __thread bool wifi_feature_supported[WIFI_SUPPORTED_FEATURE_MAX] = {0, }; + +//LCOV_EXCL_START +static wifi_manager_error_e __convert_to_ap_error_type(net_err_e err_type) +{ + switch (err_type) { + case NET_ERR_NONE: + return WIFI_MANAGER_ERROR_NONE; + case NET_ERR_APP_ALREADY_REGISTERED: + return WIFI_MANAGER_ERROR_INVALID_OPERATION; + case NET_ERR_APP_NOT_REGISTERED: + return WIFI_MANAGER_ERROR_INVALID_OPERATION; + case NET_ERR_NO_ACTIVE_CONNECTIONS: + return WIFI_MANAGER_ERROR_NO_CONNECTION; + case NET_ERR_ACTIVE_CONNECTION_EXISTS: + return WIFI_MANAGER_ERROR_ALREADY_EXISTS; + case NET_ERR_CONNECTION_DHCP_FAILED: + return WIFI_MANAGER_ERROR_DHCP_FAILED; + case NET_ERR_CONNECTION_INVALID_KEY: + return WIFI_MANAGER_ERROR_INVALID_KEY; + case NET_ERR_IN_PROGRESS: + return WIFI_MANAGER_ERROR_NOW_IN_PROGRESS; + case NET_ERR_OPERATION_ABORTED: + return WIFI_MANAGER_ERROR_OPERATION_ABORTED; + case NET_ERR_TIME_OUT: + return WIFI_MANAGER_ERROR_NO_REPLY; + case NET_ERR_ACCESS_DENIED: + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; + default: + return WIFI_MANAGER_ERROR_OPERATION_FAILED; + } +} + +static const char *__convert_ap_error_type_to_string(wifi_manager_error_e err_type) +{ + switch (err_type) { + case WIFI_MANAGER_ERROR_NONE: + return "NONE"; + case WIFI_MANAGER_ERROR_INVALID_PARAMETER: + return "INVALID_PARAMETER"; + case WIFI_MANAGER_ERROR_OUT_OF_MEMORY: + return "OUT_OF_MEMORY"; + case WIFI_MANAGER_ERROR_INVALID_OPERATION: + return "INVALID_OPERATION"; + case WIFI_MANAGER_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED: + return "ADDRESS_FAMILY_NOT_SUPPORTED"; + case WIFI_MANAGER_ERROR_OPERATION_FAILED: + return "OPERATION_FAILED"; + case WIFI_MANAGER_ERROR_NO_CONNECTION: + return "NO_CONNECTION"; + case WIFI_MANAGER_ERROR_NOW_IN_PROGRESS: + return "NOW_IN_PROGRESS"; + case WIFI_MANAGER_ERROR_ALREADY_EXISTS: + return "ALREADY_EXISTS"; + case WIFI_MANAGER_ERROR_OPERATION_ABORTED: + return "OPERATION_ABORTED"; + case WIFI_MANAGER_ERROR_DHCP_FAILED: + return "DHCP_FAILED"; + case WIFI_MANAGER_ERROR_INVALID_KEY: + return "INVALID_KEY"; + case WIFI_MANAGER_ERROR_NO_REPLY: + return "NO_REPLY"; + case WIFI_MANAGER_ERROR_SECURITY_RESTRICTED: + return "SECURITY_RESTRICTED"; + case WIFI_MANAGER_ERROR_ALREADY_INITIALIZED: + return "ALREADY_INITIALIZED"; + case WIFI_MANAGER_ERROR_PERMISSION_DENIED: + return "PERMISSION_DENIED"; + case WIFI_MANAGER_ERROR_NOT_SUPPORTED: + return "NOT_SUPPROTED"; + default: + return "UNKNOWN"; + } +} + +static const char *__convert_ap_state_to_string(wifi_manager_connection_state_e state) +{ + switch (state) { + case WIFI_MANAGER_CONNECTION_STATE_FAILURE: + return "FAILURE"; + case WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED: + return "DISCONNECTED"; + case WIFI_MANAGER_CONNECTION_STATE_ASSOCIATION: + return "ASSOCIATION"; + case WIFI_MANAGER_CONNECTION_STATE_CONFIGURATION: + return "CONFIGURATION"; + case WIFI_MANAGER_CONNECTION_STATE_CONNECTED: + return "CONNECTED"; + default: + return "UNKNOWN"; + } +} +//LCOV_EXCL_STOP + +static gchar *__wifi_change_name_to_hexadecimal(const gchar *name) +{ + GString *string; + gint i = 0; + gint length = 0; + gchar *hex = NULL; + + if (name == NULL) + return NULL; + + length = strlen(name); + + string = g_string_sized_new((gsize)(length * 2)); + if (string == NULL) + return NULL; + + for (i = 0; i < length; i++) + g_string_append_printf(string, "%02x", name[i]); + + hex = g_strdup_printf("%s", string->str); + g_string_free(string, TRUE); + + return hex; +} + +//LCOV_EXCL_START +static gchar *__wifi_security_type_to_string(wifi_manager_security_type_e security_type) +{ + switch (security_type) { + case WIFI_MANAGER_SECURITY_TYPE_NONE: + return WIFI_SECURITY_NONE; + + case WIFI_MANAGER_SECURITY_TYPE_WEP: + return WIFI_SECURITY_WEP; + + case WIFI_MANAGER_SECURITY_TYPE_WPA_PSK: + case WIFI_MANAGER_SECURITY_TYPE_WPA2_PSK: + return WIFI_SECURITY_WPA_PSK; + + case WIFI_MANAGER_SECURITY_TYPE_EAP: + return WIFI_SECURITY_EAP; + + default: + return NULL; + } +} + +gchar *_wifi_eap_type_to_string(wifi_manager_eap_type_e eap_type) +{ + gchar *type = NULL; + + switch (eap_type) { + case WIFI_MANAGER_EAP_TYPE_PEAP: + type = g_strdup("PEAP"); + break; + case WIFI_MANAGER_EAP_TYPE_TLS: + type = g_strdup("TLS"); + break; + case WIFI_MANAGER_EAP_TYPE_TTLS: + type = g_strdup("TTLS"); + break; + case WIFI_MANAGER_EAP_TYPE_SIM: + type = g_strdup("SIM"); + break; + case WIFI_MANAGER_EAP_TYPE_AKA: + type = g_strdup("AKA"); + break; + } + return type; +} + +gchar *_wifi_eap_auth_type_to_string(wifi_manager_eap_auth_type_e eap_auth_type) +{ + gchar *type = NULL; + + switch (eap_auth_type) { + case WIFI_MANAGER_EAP_AUTH_TYPE_PAP: + type = g_strdup("PAP"); + break; + case WIFI_MANAGER_EAP_AUTH_TYPE_MSCHAP: + type = g_strdup("MSCHAP"); + break; + case WIFI_MANAGER_EAP_AUTH_TYPE_MSCHAPV2: + type = g_strdup("MSCHAPV2"); + break; + case WIFI_MANAGER_EAP_AUTH_TYPE_GTC: + type = g_strdup("GTC"); + break; + case WIFI_MANAGER_EAP_AUTH_TYPE_MD5: + type = g_strdup("MD5"); + break; + default: + case WIFI_MANAGER_EAP_AUTH_TYPE_NONE: + type = NULL; + break; + } + return type; +} +//LCOV_EXCL_STOP + +static void __clear_profile_list(void) +{ + profile_iterator = g_slist_nth(profile_iterator, 0); + g_slist_free_full(profile_iterator, g_free); + profile_iterator = NULL; +} + +static void __clear_specific_profile_list(void) +{ + specific_profile_iterator = g_slist_nth(specific_profile_iterator, 0); + g_slist_free_full(specific_profile_iterator, g_free); + specific_profile_iterator = NULL; +} + +static void __clear_config_list(void) +{ + config_iterator = g_slist_nth(config_iterator, 0); + g_slist_free_full(config_iterator, g_free); + config_iterator = NULL; +} + +static int __update_profile_iterator(void) +{ + int rv; + + __clear_profile_list(); + + rv = net_get_profile_list(&profile_iterator); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } + + return WIFI_MANAGER_ERROR_NONE; +} + +static void __convert_profile_info_to_wifi_info(net_wifi_connection_info_s *wifi_info, + net_profile_info_s *ap_info) +{ + g_strlcpy(wifi_info->essid, ap_info->essid, NET_WLAN_ESSID_LEN+1); + wifi_info->wlan_mode = ap_info->wlan_mode; + memcpy(&wifi_info->security_info, &ap_info->security_info, sizeof(wlan_security_info_s)); + wifi_info->is_hidden = ap_info->is_hidden; +} + +static int __connect_with_wifi_info(net_profile_info_s *ap_info) +{ + int rv; + net_wifi_connection_info_s wifi_info; + memset(&wifi_info, 0, sizeof(net_wifi_connection_info_s)); + + __convert_profile_info_to_wifi_info(&wifi_info, ap_info); + + rv = net_open_connection_with_wifi_info(&wifi_info); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; + } else if (rv != NET_ERR_NONE) + return WIFI_MANAGER_ERROR_OPERATION_FAILED; + + return WIFI_MANAGER_ERROR_NONE; +} + +static int __load_configurations(const gchar *config_id, gchar **name, + wifi_manager_security_type_e *security_type, gchar **proxy_address, gboolean *is_hidden, + wifi_manager_error_e *last_error) +{ + int rv; + + rv = net_config_load_configurations(config_id, name, security_type, + proxy_address, is_hidden, last_error); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + + return WIFI_MANAGER_ERROR_NONE; +} + +static int __load_eap_configurations(const gchar *config_id, gchar **name, + wifi_manager_security_type_e *security_type, gchar **proxy_address, gboolean *is_hidden, + wifi_eap_config_s **eap_config, wifi_manager_error_e *last_error) +{ + int rv; + + rv = net_config_load_eap_configurations(config_id, name, security_type, + proxy_address, is_hidden, (void **)eap_config, last_error); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + + return WIFI_MANAGER_ERROR_NONE; +} + +//LCOV_EXCL_START +static void __state_changed_cb(char *profile_name, + net_profile_info_s *profile_info, wifi_manager_connection_state_e state) +{ + GSList *list; + net_profile_info_s *ap_info = NULL; + + if (profile_name == NULL) + return; + + WIFI_LOG(WIFI_INFO, "%s state changed : %d", profile_name, state); + + if (_wifi_get_callback_count_from_handle_list(WIFI_MANAGER_CONNECTION_STATE_CB)) { + ap_info = g_try_malloc0(sizeof(net_profile_info_s)); + if (ap_info == NULL) { + WIFI_LOG(WIFI_ERROR, "Memory allocation error"); + return; + } + + WIFI_LOG(WIFI_INFO, "[Ap info] profile name(%s) essid(%s) bssid(%s)", + ap_info->ProfileName, ap_info->essid, ap_info->bssid); + + if (profile_info) + memcpy(ap_info, profile_info, sizeof(net_profile_info_s)); + + WIFI_LOG(WIFI_INFO, "[Ap info] profile name(%s) essid(%s) bssid(%s)", + ap_info->ProfileName, ap_info->essid, ap_info->bssid); + + _wifi_add_to_ap_list(ap_info); + + for (list = wifi_manager_handle_list; list; list = list->next) { + wifi_manager_handle_s *local_handle = (wifi_manager_handle_s *)list->data; + if (local_handle->connection_state_cb) + local_handle->connection_state_cb(state, ap_info, + local_handle->connection_state_user_data); + } + + _wifi_remove_from_ap_list(ap_info); + } +} + +static void __set_activated_cb(wifi_manager_h wifi, + wifi_manager_activated_cb user_cb, void *user_data) +{ + wifi_manager_handle_s *local_handle = (wifi_manager_handle_s *)wifi; + + if (user_cb != NULL) { + local_handle->activated_cb = user_cb; + local_handle->activated_user_data = user_data; + } +} + +static void __set_deactivated_cb(wifi_manager_h wifi, + wifi_manager_deactivated_cb user_cb, void *user_data) +{ + wifi_manager_handle_s *local_handle = (wifi_manager_handle_s *)wifi; + + if (user_cb != NULL) { + local_handle->deactivated_cb = user_cb; + local_handle->deactivated_user_data = user_data; + } +} + +static void __power_on_off_cb(net_event_info_s *event_cb, bool is_requested) +{ + if (net_check_ref_count() != true) { + WIFI_LOG(WIFI_ERROR, "Application is not registered" + "If multi-threaded, thread integrity be broken."); + return; + } + + if (!_wifi_get_callback_count_from_handle_list(WIFI_ACTIVATED_CB) && + !_wifi_get_callback_count_from_handle_list(WIFI_DEACTIVATED_CB) && + !_wifi_get_callback_count_from_handle_list(WIFI_DEVICE_STATE_CB)) + return; + + GSList *list; + wifi_manager_error_e error_code = WIFI_MANAGER_ERROR_NONE; + wifi_manager_device_state_e state = WIFI_MANAGER_DEVICE_STATE_DEACTIVATED; + net_wifi_state_e *wifi_state = (net_wifi_state_e *)event_cb->Data; + + if (event_cb->Error == NET_ERR_NONE && + event_cb->Datalength == sizeof(net_wifi_state_e)) { + if (*wifi_state == WIFI_ON) { + WIFI_LOG(WIFI_INFO, "Wi-Fi power on"); + state = WIFI_MANAGER_DEVICE_STATE_ACTIVATED; + } else if (*wifi_state == WIFI_OFF) { + WIFI_LOG(WIFI_INFO, "Wi-Fi power off"); + state = WIFI_MANAGER_DEVICE_STATE_DEACTIVATED; + __clear_profile_list(); + __clear_specific_profile_list(); + } else { + WIFI_LOG(WIFI_ERROR, "Error Wi-Fi state %d", *wifi_state); + error_code = WIFI_MANAGER_ERROR_OPERATION_FAILED; + state = WIFI_MANAGER_DEVICE_STATE_DEACTIVATED; + } + } else { + WIFI_LOG(WIFI_ERROR, "Wi-Fi power request failed(%d)", event_cb->Error); + + if (event_cb->Error == NET_ERR_SECURITY_RESTRICTED) + error_code = WIFI_MANAGER_ERROR_SECURITY_RESTRICTED; + else + error_code = WIFI_MANAGER_ERROR_OPERATION_FAILED; + + state = WIFI_MANAGER_DEVICE_STATE_DEACTIVATED; + } + + if (_wifi_get_callback_count_from_handle_list(WIFI_ACTIVATED_CB)) { + for (list = wifi_manager_handle_list; list; list = list->next) { + wifi_manager_handle_s *local_handle = (wifi_manager_handle_s *)list->data; + if (local_handle->activated_cb) + local_handle->activated_cb(error_code, local_handle->activated_user_data); + + local_handle->activated_cb = NULL; + local_handle->activated_user_data = NULL; + } + } + + if (_wifi_get_callback_count_from_handle_list(WIFI_DEACTIVATED_CB)) { + for (list = wifi_manager_handle_list; list; list = list->next) { + wifi_manager_handle_s *local_handle = (wifi_manager_handle_s *)list->data; + if (local_handle->deactivated_cb != NULL) + local_handle->deactivated_cb(error_code, local_handle->deactivated_user_data); + + local_handle->deactivated_cb = NULL; + local_handle->deactivated_user_data = NULL; + } + } + + if (_wifi_get_callback_count_from_handle_list(WIFI_DEVICE_STATE_CB)) { + for (list = wifi_manager_handle_list; list; list = list->next) { + wifi_manager_handle_s *local_handle = (wifi_manager_handle_s *)list->data; + if (local_handle->device_state_cb) + local_handle->device_state_cb(state, local_handle->device_state_user_data); + } + } +} + +static void __set_scan_cb(wifi_manager_h wifi, + wifi_manager_scan_finished_cb user_cb, void *user_data) +{ + wifi_manager_handle_s *local_handle = (wifi_manager_handle_s *)wifi; + + if (user_cb) { + local_handle->scan_request_cb = user_cb; + local_handle->scan_request_user_data = user_data; + } +} + +static void __set_specific_scan_cb(wifi_manager_h wifi, + wifi_manager_scan_finished_cb user_cb, void *user_data) +{ + wifi_manager_handle_s *local_handle = (wifi_manager_handle_s *)wifi; + + if (user_cb) { + local_handle->specific_scan_cb = user_cb; + local_handle->specific_scan_user_data = user_data; + } +} + +static void __scan_cb(net_event_info_s *event_cb, bool is_requested) +{ + GSList *list; + wifi_manager_error_e error_code = WIFI_MANAGER_ERROR_NONE; + + if (net_check_ref_count() != true) { + WIFI_LOG(WIFI_ERROR, "Application is not registered" + "If multi-threaded, thread integrity be broken."); + return; + } + + if (event_cb->Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Scan failed[%d]", event_cb->Error); + error_code = WIFI_MANAGER_ERROR_OPERATION_FAILED; + } + + if (_wifi_get_callback_count_from_handle_list(WIFI_SCAN_REQUEST_CB)) { + for (list = wifi_manager_handle_list; list; list = list->next) { + wifi_manager_handle_s *local_handle = (wifi_manager_handle_s *)list->data; + if (local_handle->scan_request_cb) + local_handle->scan_request_cb(error_code, local_handle->scan_request_user_data); + + local_handle->scan_request_cb = NULL; + local_handle->scan_request_user_data = NULL; + } + return; + } + + if (_wifi_get_callback_count_from_handle_list(WIFI_BG_SCAN_CB)){ + for (list = wifi_manager_handle_list; list; list = list->next) { + wifi_manager_handle_s *local_handle = (wifi_manager_handle_s *)list->data; + if (local_handle->bg_scan_cb) + local_handle->bg_scan_cb(error_code, local_handle->bg_scan_user_data); + } + } +} + +static void __specific_scan_cb(net_event_info_s *event_cb) +{ + GSList *list; + wifi_manager_error_e error_code = WIFI_MANAGER_ERROR_NONE; + + __clear_specific_profile_list(); + + if (event_cb->Error != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Specific scan failed!, Error [%d]\n", event_cb->Error); + error_code = WIFI_MANAGER_ERROR_OPERATION_FAILED; + } else if (event_cb->Data) { + specific_profile_iterator = (GSList *)event_cb->Data; + WIFI_LOG(WIFI_INFO, "Specific AP count : %d\n", + (int)g_slist_length(specific_profile_iterator)); + } + + if (_wifi_get_callback_count_from_handle_list(WIFI_SPECIFIC_SCAN_CB)) { + for (list = wifi_manager_handle_list; list; list = list->next) { + wifi_manager_handle_s *local_handle = (wifi_manager_handle_s *)list->data; + if (local_handle->specific_scan_cb) + local_handle->specific_scan_cb(error_code, local_handle->specific_scan_user_data); + + local_handle->specific_scan_cb = NULL; + local_handle->specific_scan_user_data = NULL; + } + } +} + +static void __set_connected_cb(wifi_manager_h wifi, + wifi_manager_connected_cb user_cb, void *user_data) +{ + wifi_manager_handle_s *local_handle = (wifi_manager_handle_s *)wifi; + + if (user_cb != NULL) { + local_handle->connected_cb = user_cb; + local_handle->connected_user_data = user_data; + } +} + +static void __connected_cb(wifi_manager_error_e result) +{ + GSList *list; + + if (net_check_ref_count() != true) { + WIFI_LOG(WIFI_ERROR, "Application is not registered" + "If multi-threaded, thread integrity be broken."); + return; + } + + if (_wifi_get_callback_count_from_handle_list(WIFI_CONNECTED_CB)) { + for (list = wifi_manager_handle_list; list; list = list->next) { + wifi_manager_handle_s *local_handle = (wifi_manager_handle_s *)list->data; + if (local_handle->connected_cb != NULL) + local_handle->connected_cb(result, local_handle->connected_user_data); + + local_handle->connected_cb = NULL; + local_handle->connected_user_data = NULL; + } + } +} + +static void __set_disconnected_cb(wifi_manager_h wifi, + wifi_manager_disconnected_cb user_cb, void *user_data) +{ + wifi_manager_handle_s *local_handle = (wifi_manager_handle_s *)wifi; + + if (user_cb != NULL) { + local_handle->disconnected_cb = user_cb; + local_handle->disconnected_user_data = user_data; + } +} + +static void __disconnected_cb(wifi_manager_error_e result) +{ + GSList *list; + + if (net_check_ref_count() != true) { + WIFI_LOG(WIFI_ERROR, "Application is not registered" + "If multi-threaded, thread integrity be broken."); + return; + } + + if (_wifi_get_callback_count_from_handle_list(WIFI_DISCONNECTED_CB)) { + for (list = wifi_manager_handle_list; list; list = list->next) { + wifi_manager_handle_s *local_handle = (wifi_manager_handle_s *)list->data; + if (local_handle->disconnected_cb != NULL) + local_handle->disconnected_cb(result, local_handle->disconnected_user_data); + + local_handle->disconnected_cb = NULL; + local_handle->disconnected_user_data = NULL; + } + } +} +//LCOV_EXCL_STOP + +static void _wifi_evt_cb(net_event_info_s *event_cb, void *user_data) +{ + bool is_requested = false; + net_profile_info_s *prof_info_p = NULL; + net_profile_info_s prof_info; + wifi_manager_error_e result = WIFI_MANAGER_ERROR_NONE; + bool is_profile_exists = false; + GSList *list = NULL; + + switch (event_cb->Event) { + case NET_EVENT_OPEN_RSP: + case NET_EVENT_WIFI_WPS_RSP: + is_requested = true; + /* fall through */ + case NET_EVENT_OPEN_IND: + if (_wifi_check_profile_name_validity(event_cb->ProfileName) != true) + return; + + result = __convert_to_ap_error_type(event_cb->Error); + WIFI_LOG(WIFI_INFO, "Connection open error %s", + __convert_ap_error_type_to_string(result)); + + if (is_requested) + __connected_cb(result); + + switch (event_cb->Error) { + case NET_ERR_NONE: + if (event_cb->Datalength == sizeof(net_profile_info_s)) + prof_info_p = (net_profile_info_s *)event_cb->Data; + + __state_changed_cb(event_cb->ProfileName, prof_info_p, + WIFI_MANAGER_CONNECTION_STATE_CONNECTED); + return; + case NET_ERR_ACTIVE_CONNECTION_EXISTS: + return; + default: + break; + } + + if (net_get_profile_info(event_cb->ProfileName, &prof_info) == NET_ERR_NONE) + __state_changed_cb(event_cb->ProfileName, &prof_info, + WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED); + else + __state_changed_cb(event_cb->ProfileName, NULL, + WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED); + + break; + case NET_EVENT_CLOSE_RSP: + is_requested = true; + /* fall through */ + case NET_EVENT_CLOSE_IND: + if (_wifi_check_profile_name_validity(event_cb->ProfileName) != true) + return; + + result = __convert_to_ap_error_type(event_cb->Error); + WIFI_LOG(WIFI_ERROR, "Connection close error %s", + __convert_ap_error_type_to_string(result)); + + if (is_requested) + __disconnected_cb(result); + + switch (event_cb->Error) { + case NET_ERR_NONE: + if (net_get_profile_info(event_cb->ProfileName, &prof_info) == NET_ERR_NONE) + __state_changed_cb(event_cb->ProfileName, &prof_info, + WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED); + else + __state_changed_cb(event_cb->ProfileName, NULL, + WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED); + return; + default: + break; + } + + break; + case NET_EVENT_NET_STATE_IND: + if (_wifi_check_profile_name_validity(event_cb->ProfileName) != true) + return; + + if (event_cb->Datalength != sizeof(net_state_type_e)) + return; + + net_state_type_e *profile_state = (net_state_type_e *)event_cb->Data; + wifi_manager_connection_state_e ap_state = _wifi_convert_to_ap_state(*profile_state); + + WIFI_LOG(WIFI_INFO, "state: %s", __convert_ap_state_to_string(ap_state)); + WIFI_LOG(WIFI_INFO, "profile name: %s", event_cb->ProfileName); + + if (net_get_profile_info(event_cb->ProfileName, &prof_info) == NET_ERR_NONE) + __state_changed_cb(event_cb->ProfileName, &prof_info, ap_state); + else if (ap_state == WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED) { + net_profile_info_s *profile = NULL; + for (list = profile_iterator; list; list = list->next) { + profile = (net_profile_info_s *)list->data; + if (!g_strcmp0(event_cb->ProfileName, profile->ProfileName)) { + is_profile_exists = true; + break; + } + } + + if (is_profile_exists == true) { + profile->ProfileState = *profile_state; + __state_changed_cb(event_cb->ProfileName, profile, ap_state); + } else + __state_changed_cb(event_cb->ProfileName, + NULL, ap_state); + } else + __state_changed_cb(event_cb->ProfileName, NULL, ap_state); + + break; + case NET_EVENT_WIFI_SCAN_RSP: + case NET_EVENT_WIFI_SCAN_IND: + __scan_cb(event_cb, is_requested); + break; + case NET_EVENT_WIFI_SPECIFIC_SCAN_RSP: + WIFI_LOG(WIFI_INFO, "Got Wi-Fi specific scan RSP\n"); + break; + case NET_EVENT_WIFI_SPECIFIC_SCAN_IND: + WIFI_LOG(WIFI_INFO, "Got Wi-Fi specific scan IND\n"); + __specific_scan_cb(event_cb); + break; + case NET_EVENT_WIFI_POWER_RSP: + is_requested = true; + /* fall through */ + case NET_EVENT_WIFI_POWER_IND: + __power_on_off_cb(event_cb, is_requested); + break; + default: + break; + } +} + +int _wifi_init(void) +{ + int rv; + + rv = net_register_client_ext((net_event_cb)_wifi_evt_cb, NULL); + if (rv != NET_ERR_NONE && rv != NET_ERR_APP_ALREADY_REGISTERED) { + WIFI_LOG(WIFI_ERROR, "Failed to register client [%d]", rv); + return rv; + } + + return NET_ERR_NONE; +} + +int _wifi_create_handle(wifi_manager_h *wifi) +{ + *wifi = g_try_malloc0(sizeof(wifi_manager_handle_s)); + + if (*wifi != NULL) + WIFI_LOG(WIFI_INFO, "New handle create[%p]", *wifi); + else { + WIFI_LOG(WIFI_ERROR, "Failed to create wifi handle"); + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + } + + return WIFI_MANAGER_ERROR_NONE; +} + +int _wifi_add_to_handle_list(wifi_manager_h *wifi) +{ + wifi_manager_handle_list = g_slist_append(wifi_manager_handle_list, *wifi); + return WIFI_MANAGER_ERROR_NONE; +} + +void _wifi_remove_from_handle_list(wifi_manager_h wifi) +{ + wifi_manager_handle_list = g_slist_remove(wifi_manager_handle_list, wifi); + + g_free(wifi); + wifi = NULL; +} + +bool _wifi_find_from_handle_list(wifi_manager_h wifi) +{ + if (g_slist_find(wifi_manager_handle_list, wifi) != NULL) + return true; + else + return false; +} + +int _wifi_get_count_from_handle_list(void) +{ + return ((int)g_slist_length(wifi_manager_handle_list)); +} + +int _wifi_get_callback_count_from_handle_list(wifi_manager_handle_cb_e e) +{ + GSList *list; + int count = 0; + + for (list = wifi_manager_handle_list; list; list = list->next) { + wifi_manager_handle_s *local_handle = (wifi_manager_handle_s *)list->data; + switch (e) { + case WIFI_DEVICE_STATE_CB: + if (local_handle->device_state_cb) + ++count; + break; + case WIFI_BG_SCAN_CB: + if (local_handle->bg_scan_cb) + ++count; + break; + case WIFI_SCAN_REQUEST_CB: + if (local_handle->scan_request_cb) + ++count; + break; + case WIFI_SPECIFIC_SCAN_CB: + if (local_handle->specific_scan_cb) + ++count; + break; + case WIFI_MANAGER_CONNECTION_STATE_CB: + if (local_handle->connection_state_cb) + ++count; + break; + case WIFI_ACTIVATED_CB: + if (local_handle->activated_cb) + ++count; + break; + case WIFI_DEACTIVATED_CB: + if (local_handle->deactivated_cb) + ++count; + break; + case WIFI_CONNECTED_CB: + if (local_handle->connected_cb) + ++count; + break; + case WIFI_DISCONNECTED_CB: + if (local_handle->disconnected_cb) + ++count; + break; + case WIFI_MANAGER_RSSI_LEVEL_CHANGED_CB: + if (local_handle->rssi_level_changed_cb) + ++count; + break; + case WIFI_MANAGER_TDLS_STATE_CHANGED_CB: + if (local_handle->tdls_state_changed_cb) + ++count; + break; + default: + break; + } + } + + return count; +} + +bool _wifi_deinit(void) +{ + int rv = net_deregister_client_ext(); + if (rv != NET_ERR_NONE && rv != NET_ERR_APP_NOT_REGISTERED) + return false; + + __clear_profile_list(); + __clear_specific_profile_list(); + + g_slist_free_full(ap_handle_list, g_free); + ap_handle_list = NULL; + + g_slist_free_full(config_handle_list, g_free); + config_handle_list = NULL; + + g_slist_free_full(config_iterator, g_free); + config_iterator = NULL; + + return true; +} + +int _wifi_activate(wifi_manager_h wifi, wifi_manager_activated_cb callback, + gboolean wifi_picker_test, void *user_data) +{ + int rv = NET_ERR_NONE; + + rv = net_wifi_power_on(wifi_picker_test); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv == NET_ERR_INVALID_OPERATION) { + return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE + } else if (rv == NET_ERR_ALREADY_EXISTS) { + return WIFI_MANAGER_ERROR_ALREADY_EXISTS; //LCOV_EXCL_LINE + } else if (rv == NET_ERR_IN_PROGRESS) { + return WIFI_MANAGER_ERROR_NOW_IN_PROGRESS; //LCOV_EXCL_LINE + } else if (rv == NET_ERR_SECURITY_RESTRICTED) { + return WIFI_MANAGER_ERROR_SECURITY_RESTRICTED; //LCOV_EXCL_LINE + } else if (rv == NET_ERR_NONE) { + __set_activated_cb(wifi, callback, user_data); + return WIFI_MANAGER_ERROR_NONE; + } + + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE +} + +int _wifi_deactivate(wifi_manager_h wifi, wifi_manager_deactivated_cb callback, void *user_data) +{ + int rv = NET_ERR_NONE; + + rv = net_wifi_power_off(); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv == NET_ERR_INVALID_OPERATION) { + return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE + } else if (rv == NET_ERR_ALREADY_EXISTS) { + return WIFI_MANAGER_ERROR_ALREADY_EXISTS; //LCOV_EXCL_LINE + } else if (rv == NET_ERR_IN_PROGRESS) { + return WIFI_MANAGER_ERROR_NOW_IN_PROGRESS; //LCOV_EXCL_LINE + } else if (rv == NET_ERR_SECURITY_RESTRICTED) { + return WIFI_MANAGER_ERROR_SECURITY_RESTRICTED; //LCOV_EXCL_LINE + } else if (rv == NET_ERR_NONE) { + __set_deactivated_cb(wifi, callback, user_data); + return WIFI_MANAGER_ERROR_NONE; + } + + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE +} + +bool _wifi_check_ap_validity(wifi_manager_ap_h ap_h) +{ + GSList *list = NULL; + + if (ap_h == NULL) + return false; + + for (list = ap_handle_list; list; list = list->next) + if (ap_h == list->data) return true; + + for (list = profile_iterator; list; list = list->next) + if (ap_h == list->data) return true; + + for (list = specific_profile_iterator; list; list = list->next) + if (ap_h == list->data) return true; + + return false; +} + +void _wifi_add_to_ap_list(wifi_manager_ap_h ap_h) +{ + ap_handle_list = g_slist_append(ap_handle_list, ap_h); +} + +void _wifi_remove_from_ap_list(wifi_manager_ap_h ap_h) +{ + ap_handle_list = g_slist_remove(ap_handle_list, ap_h); + g_free(ap_h); +} + +bool _wifi_check_profile_name_validity(const char *profile_name) +{ + const char *profile_prefix = "/net/connman/service/wifi_"; + int i = 0; + + if (profile_name == NULL || + g_str_has_prefix(profile_name, profile_prefix) != TRUE) { + WIFI_LOG(WIFI_INFO, "The profile is a hidden or not a regular Wi-Fi profile"); + return false; + } + + while (profile_name[i] != '\0') { + if (isgraph(profile_name[i]) == 0) { + WIFI_LOG(WIFI_INFO, "Invalid format: %s", profile_name); //LCOV_EXCL_LINE + return false; //LCOV_EXCL_LINE + } + i++; + } + + return true; +} + +int _wifi_get_wifi_device_state(wifi_manager_device_state_e *device_state) +{ + net_tech_info_s tech_info; + + int rv = NET_ERR_NONE; + rv = net_get_technology_properties(&tech_info); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Failed to get technology properties"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + + if (tech_info.powered) + *device_state = WIFI_MANAGER_DEVICE_STATE_ACTIVATED; + else + *device_state = WIFI_MANAGER_DEVICE_STATE_DEACTIVATED; + + return WIFI_MANAGER_ERROR_NONE; +} + +int _wifi_get_wifi_state(wifi_manager_connection_state_e *connection_state) +{ + int rv; + net_wifi_state_e wlan_state = 0; + + rv = net_get_wifi_state(&wlan_state); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Failed to get Wi-Fi state"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + + switch (wlan_state) { + //LCOV_EXCL_START + case WIFI_OFF: + case WIFI_ON: + *connection_state = WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED; + break; + case WIFI_ASSOCIATION: + *connection_state = WIFI_MANAGER_CONNECTION_STATE_ASSOCIATION; + break; + case WIFI_CONFIGURATION: + *connection_state = WIFI_MANAGER_CONNECTION_STATE_CONFIGURATION; + break; + case WIFI_CONNECTED: + *connection_state = WIFI_MANAGER_CONNECTION_STATE_CONNECTED; + break; + case WIFI_DISCONNECTING: + *connection_state = WIFI_MANAGER_CONNECTION_STATE_CONNECTED; + break; + default: + WIFI_LOG(WIFI_ERROR, "Unknown state"); + return WIFI_MANAGER_ERROR_OPERATION_FAILED; + //LCOV_EXCL_STOP + } + + return WIFI_MANAGER_ERROR_NONE; +} + +int _wifi_get_intf_name(char** name) +{ + int rv; + + if ((int)g_slist_length(profile_iterator) == 0) { + rv = __update_profile_iterator(); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } + } + + if ((int)g_slist_length(profile_iterator) == 0) { + WIFI_LOG(WIFI_ERROR, "There is no AP"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile = (net_profile_info_s *)profile_iterator->data; + *name = g_strdup(profile->net_info.DevName); + if (*name == NULL) + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; + + return WIFI_MANAGER_ERROR_NONE; +} + +int _wifi_scan_request(wifi_manager_h wifi, + wifi_manager_scan_finished_cb callback, void *user_data) +{ + int rv; + rv = net_scan_wifi(); + + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv == NET_ERR_INVALID_OPERATION) { + return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE + } else if (rv == NET_ERR_NONE) { + __set_scan_cb(wifi, callback, user_data); + return WIFI_MANAGER_ERROR_NONE; + } + + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE +} + +int _wifi_scan_specific_ap(wifi_manager_h wifi, const char *essid, + wifi_manager_scan_finished_cb callback, void *user_data) +{ + int rv; + rv = net_specific_scan_wifi(essid); + + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv == NET_ERR_INVALID_OPERATION) { + return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE + } else if (rv == NET_ERR_NONE) { + g_strlcpy(specific_profile_essid, essid, NET_WLAN_ESSID_LEN+1); + __set_specific_scan_cb(wifi, callback, user_data); + return WIFI_MANAGER_ERROR_NONE; + } + + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE +} + +int _wifi_get_connected_profile(wifi_manager_ap_h *ap) +{ + int rv; + wifi_manager_ap_h ap_h = NULL; + GSList *list; + + rv = __update_profile_iterator(); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } + + for (list = profile_iterator; list; list = list->next) { + net_profile_info_s *prof_info = (net_profile_info_s *)list->data; + if (prof_info->ProfileState == NET_STATE_TYPE_ONLINE || + prof_info->ProfileState == NET_STATE_TYPE_READY) { + ap_h = (wifi_manager_ap_h)prof_info; + break; + } + } + + if (ap_h == NULL) { + WIFI_LOG(WIFI_ERROR, "There is no connected AP"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_NO_CONNECTION; //LCOV_EXCL_LINE + } + + *ap = g_try_malloc0(sizeof(net_profile_info_s)); + if (*ap == NULL) + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; + + memcpy(*ap, ap_h, sizeof(net_profile_info_s)); + + _wifi_add_to_ap_list(*ap); + + return WIFI_MANAGER_ERROR_NONE; +} + +int _wifi_foreach_found_ap(wifi_manager_found_ap_cb callback, void *user_data) +{ + int rv; + GSList *list; + + rv = __update_profile_iterator(); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } + + if ((int)g_slist_length(profile_iterator) == 0) { + WIFI_LOG(WIFI_WARN, "There is no AP"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_NONE; //LCOV_EXCL_LINE + } + + for (list = profile_iterator; list; list = list->next) { + net_profile_info_s *prof_info = (net_profile_info_s *)list->data; + if (prof_info->is_hidden == TRUE) + continue; + + rv = callback((wifi_manager_ap_h)prof_info, user_data); + if (rv == false) break; + } + + return WIFI_MANAGER_ERROR_NONE; +} + +int _wifi_foreach_found_specific_ap(wifi_manager_found_ap_cb callback, void *user_data) +{ + int rv; + GSList *list; + + if ((int)g_slist_length(specific_profile_iterator) == 0) { + WIFI_LOG(WIFI_WARN, "There is no specific APs"); + + rv = __update_profile_iterator(); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } + + if ((int)g_slist_length(profile_iterator) == 0) { + WIFI_LOG(WIFI_WARN, "There is no APs"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_NONE; //LCOV_EXCL_LINE + } + + for (list = profile_iterator; list; list = list->next) { + net_profile_info_s *prof_info = (net_profile_info_s *)list->data; + if (!g_strcmp0(specific_profile_essid, prof_info->essid)) { + rv = callback((wifi_manager_ap_h)prof_info, user_data); + if (rv == false) break; + } + } + + return WIFI_MANAGER_ERROR_NONE; + } + + for (list = specific_profile_iterator; list; list = list->next) { + net_profile_info_s *prof_info = (net_profile_info_s *)list->data; + rv = callback((wifi_manager_ap_h)prof_info, user_data); + if (rv == false) break; + } + + return WIFI_MANAGER_ERROR_NONE; +} + +int _wifi_open_profile(wifi_manager_h wifi, wifi_manager_ap_h ap_h, + wifi_manager_connected_cb callback, void *user_data) +{ + int rv; + bool valid_profile; + net_profile_info_s *ap_info = ap_h; + + valid_profile = + _wifi_check_profile_name_validity(ap_info->ProfileName); + + if (valid_profile == true && ap_info->Favourite) + rv = net_open_connection(ap_info->ProfileName); + else if (valid_profile == true && + ap_info->is_hidden != TRUE && + ap_info->security_info.sec_mode == WLAN_SEC_MODE_NONE) + rv = net_open_connection(ap_info->ProfileName); + else + rv = __connect_with_wifi_info(ap_info); + + rv = __convert_to_ap_error_type(rv); + if (rv == WIFI_MANAGER_ERROR_NONE) + __set_connected_cb(wifi, callback, user_data); + + return rv; +} + +int _wifi_close_profile(wifi_manager_h wifi, wifi_manager_ap_h ap_h, + wifi_manager_disconnected_cb callback, void *user_data) +{ + int rv; + net_profile_info_s *ap_info = ap_h; + + rv = net_close_connection(ap_info->ProfileName); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) { + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + + __set_disconnected_cb(wifi, callback, user_data); + + return WIFI_MANAGER_ERROR_NONE; +} + +//LCOV_EXCL_START +int _wifi_connect_with_wps_pbc(wifi_manager_h wifi, wifi_manager_ap_h ap_h, + wifi_manager_connected_cb callback, void *user_data) +{ + int rv; + net_profile_info_s *ap_info = ap_h; + net_wifi_wps_info_s wps_info; + memset(&wps_info, 0, sizeof(net_wifi_wps_info_s)); + + wps_info.type = WIFI_WPS_PBC; + + rv = net_wifi_enroll_wps(ap_info->ProfileName, &wps_info); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; + } else if (rv != NET_ERR_NONE) { + return WIFI_MANAGER_ERROR_OPERATION_FAILED; + } + + __set_connected_cb(wifi, callback, user_data); + + return WIFI_MANAGER_ERROR_NONE; +} + +int _wifi_connect_with_wps_pin(wifi_manager_h wifi, wifi_manager_ap_h ap_h, + const char *pin, wifi_manager_connected_cb callback, void *user_data) +{ + int rv; + net_profile_info_s *ap_info = ap_h; + net_wifi_wps_info_s wps_info; + + if (ap_info == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + } + + wps_info.type = WIFI_WPS_PIN; + g_strlcpy(wps_info.pin, pin, NET_WLAN_MAX_WPSPIN_LEN + 1); + + rv = net_wifi_enroll_wps(ap_info->ProfileName, &wps_info); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; + } else if (rv != NET_ERR_NONE) { + return WIFI_MANAGER_ERROR_OPERATION_FAILED; + } + + __set_connected_cb(wifi, callback, user_data); + + return WIFI_MANAGER_ERROR_NONE; +} +//LCOV_EXCL_STOP + +int _wifi_forget_ap(wifi_manager_ap_h ap) +{ + int rv = 0; + net_profile_info_s *ap_info = ap; + + if (ap_info == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + rv = net_delete_profile(ap_info->ProfileName); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) { + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + + ap_info->Favourite = (char)FALSE; + + return WIFI_MANAGER_ERROR_NONE; +} + +void _wifi_rssi_level_changed_cb(keynode_t *node, void *user_data) +{ + GSList *list; + wifi_manager_handle_s *handle; + int rssi_level = 0; + + if (net_check_ref_count() != true) { + WIFI_LOG(WIFI_ERROR, "Application is not registered" + "If multi-threaded, thread integrity be broken."); + return; + } + + for (list = wifi_manager_handle_list; list; list = list->next) { + handle = (wifi_manager_handle_s *)list->data; + + if (__wifi_check_handle_validity((wifi_manager_h)handle) != true) + return; + + if (vconf_get_int(VCONFKEY_WIFI_STRENGTH, &rssi_level) != 0) + return; + + if (handle->rssi_level_changed_cb) + handle->rssi_level_changed_cb(rssi_level, + handle->rssi_level_changed_user_data); + } +} + +int _wifi_update_ap_info(net_profile_info_s *ap_info) +{ + int rv = NET_ERR_NONE; + rv = net_modify_profile(ap_info->ProfileName, ap_info); + + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv == NET_ERR_SECURITY_RESTRICTED) { + WIFI_LOG(WIFI_ERROR, "Security restricted"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_SECURITY_RESTRICTED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) { + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + + return WIFI_MANAGER_ERROR_NONE; +} + +bool _wifi_check_config_validity(wifi_manager_config_h config_h) +{ + GSList *list = NULL; + + if (config_h == NULL) + return false; + + for (list = config_handle_list; list; list = list->next) + if (config_h == list->data) return true; + + for (list = config_iterator; list; list = list->next) + if (config_h == list->data) return true; + + return false; +} + +void _wifi_add_to_config_list(wifi_manager_config_h config_h) +{ + config_handle_list = g_slist_append(config_handle_list, config_h); +} + +void _wifi_remove_from_config_list(wifi_manager_config_h config_h) +{ + config_handle_list = g_slist_remove(config_handle_list, config_h); + g_free(config_h); +} + +gchar *_wifi_config_get_config_id(const gchar *name, wifi_manager_security_type_e security_type) +{ + gchar *config_id = NULL; + gchar *ssid = NULL; + gchar *type = NULL; + + ssid = __wifi_change_name_to_hexadecimal(name); + type = g_strdup(__wifi_security_type_to_string(security_type)); + config_id = g_strdup_printf("%s_managed_%s", ssid, type); + + g_free(ssid); + g_free(type); + + return config_id; +} + +int _wifi_config_get_config_id_list(GSList **list) +{ + int rv; + + rv = net_config_get_id_list(list); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv == NET_ERR_NO_PROFILE) { + WIFI_LOG(WIFI_ERROR, "There is no configuration"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_NONE; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) { + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + + return WIFI_MANAGER_ERROR_NONE; +} + +int _wifi_save_configuration(const gchar *name, const gchar *passphrase, + wifi_manager_security_type_e security_type, const gchar *proxy_address, gboolean is_hidden) +{ + int rv; + gchar *config_id = NULL; + gchar *ssid = NULL; + + if (security_type != WIFI_MANAGER_SECURITY_TYPE_NONE) { + if (passphrase == NULL) { + WIFI_LOG(WIFI_ERROR, "Fail to wifi_save_configurations " //LCOV_EXCL_LINE + "[secu_type is not NONE[%d] but passphrase is NULL]", security_type); + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } else { + if (strlen(passphrase) == 0) { + WIFI_LOG(WIFI_ERROR, "Fail to wifi_save_configurations " //LCOV_EXCL_LINE + "passphrase length is 0"); + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + } + } + + config_id = _wifi_config_get_config_id(name, security_type); + ssid = __wifi_change_name_to_hexadecimal(name); + + rv = net_config_save_configurations(config_id, name, ssid, passphrase, proxy_address, is_hidden); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) { + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + + return WIFI_MANAGER_ERROR_NONE; +} + +int _wifi_load_configurations(void) +{ + int rv; + GSList *config_ids = NULL; + + __clear_config_list(); + + rv = _wifi_config_get_config_id_list(&config_ids); + if (rv != WIFI_MANAGER_ERROR_NONE) { + WIFI_LOG(WIFI_ERROR, "Fail to load configurations [%d]", rv); //LCOV_EXCL_LINE + return rv; //LCOV_EXCL_LINE + } + + if (config_ids == NULL) { + WIFI_LOG(WIFI_ERROR, "Fail to get config id list"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_NONE; //LCOV_EXCL_LINE + } + + while (config_ids) { + bool rv = 0; + wifi_config_s *h; + gchar *id = config_ids->data; + + h = g_new0(wifi_config_s, 1); + if (h == NULL) { + rv = WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + break; + } + + if (g_str_has_suffix(id, "ieee8021x") == TRUE) { + h->eap_config = g_new0(wifi_eap_config_s, 1); + if (h->eap_config == NULL) { + rv = WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + break; + } + rv = __load_eap_configurations(id, &h->name, + &h->security_type, &h->proxy_address, &h->is_hidden, &h->eap_config, &h->last_error); + } else { + rv = __load_configurations(id, &h->name, + &h->security_type, &h->proxy_address, &h->is_hidden, &h->last_error); + } + + if (rv != WIFI_MANAGER_ERROR_NONE) { + WIFI_LOG(WIFI_ERROR, "Fail to load configurations [%d]", rv); //LCOV_EXCL_LINE + return rv; //LCOV_EXCL_LINE + } + + h->address_family = WIFI_MANAGER_ADDRESS_FAMILY_IPV4; + h->is_saved = TRUE; + + config_iterator = g_slist_append(config_iterator, (wifi_manager_config_h)h); + + config_ids = config_ids->next; + } + + config_ids = g_slist_nth(config_ids, 0); + g_slist_free_full(config_ids, g_free); + + return WIFI_MANAGER_ERROR_NONE; +} + +int _wifi_foreach_configuration(wifi_manager_config_list_cb callback, void *user_data) +{ + int rv; + GSList *list; + + for (list = config_iterator; list; list = list->next) { + rv = callback((wifi_manager_config_h)list->data, user_data); + if (rv == false) + break; + } + + return WIFI_MANAGER_ERROR_NONE; +} + +int _wifi_remove_configuration(const gchar *config_id) +{ + int rv; + + rv = net_config_remove_configurations(config_id); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + + return WIFI_MANAGER_ERROR_NONE; +} + +//LCOV_EXCL_START +int _wifi_save_eap_configurations(const gchar *name, const gchar *passphrase, + wifi_manager_security_type_e security_type, const gchar *proxy_address, + wifi_eap_config_s *eap_config, gboolean is_hidden) +{ + int rv; + gchar *config_id = NULL; + gchar *ssid = NULL; + + if (security_type != WIFI_MANAGER_SECURITY_TYPE_EAP) { + WIFI_LOG(WIFI_ERROR, "Fail to wifi_save_configurations " + "[secu_type is not EAP[%d]]", security_type); + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + } + + if (passphrase == NULL) { + WIFI_LOG(WIFI_ERROR, "Fail to wifi_save_configurations [secu_type is not NONE[%d] " + "but passphrase is NULL]", security_type); + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + } else { + if (strlen(passphrase) == 0) { + WIFI_LOG(WIFI_ERROR, "Fail to wifi_save_configurations passphrase length is 0"); + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + } + } + + if (security_type == (WIFI_MANAGER_EAP_TYPE_SIM | WIFI_MANAGER_EAP_TYPE_AKA)) + WIFI_LOG(WIFI_INFO, "security_type: %d", security_type); + + config_id = _wifi_config_get_config_id(name, security_type); + ssid = __wifi_change_name_to_hexadecimal(name); + + + rv = net_config_save_eap_configurations(config_id, name, + ssid, passphrase, proxy_address, (void *)eap_config, is_hidden); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + + return WIFI_MANAGER_ERROR_NONE; +} + +int _wifi_configuration_set_field(const gchar *config_id, const gchar *key, const gchar *value) +{ + int rv; + + rv = net_config_set_field(config_id, key, value); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + + return WIFI_MANAGER_ERROR_NONE; +} + +int _wifi_configuration_get_passphrase(const gchar *config_id, gchar **passphrase) +{ + int rv; + + rv = net_config_get_passphrase(config_id, passphrase); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + + return WIFI_MANAGER_ERROR_NONE; +} +//LCOV_EXCL_STOP + +int _wifi_check_get_privilege() +{ + int rv; + + rv = net_check_get_privilege(); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + + return WIFI_MANAGER_ERROR_NONE; +} + +int _wifi_check_profile_privilege() +{ + int rv = net_check_profile_privilege(); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + + return WIFI_MANAGER_ERROR_NONE; +} + +bool __check_feature_supported(const char *key, wifi_supported_feature_e feature) +{ + if (!wifi_is_feature_checked[feature]) { + if (system_info_get_platform_bool(key, &wifi_feature_supported[feature]) < 0) { + WIFI_LOG(WIFI_ERROR, "Error - Feature getting from System Info"); //LCOV_EXCL_LINE + set_last_result(WIFI_MANAGER_ERROR_OPERATION_FAILED); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + wifi_is_feature_checked[feature] = true; + } + return wifi_feature_supported[feature]; +} + +int _wifi_check_feature_supported(const char *feature_name, ...) +{ + va_list list; + const char *key; + bool value = false; + bool feature_supported = false; + + va_start(list, feature_name); + key = feature_name; + while (1) { + if (strcmp(key, WIFI_FEATURE) == 0) + value = __check_feature_supported(key, WIFI_SUPPORTED_FEATURE_WIFI); + else if (strcmp(key, WIFI_TDLS_FEATURE) == 0) + value = __check_feature_supported(key, WIFI_SUPPORTED_FEATURE_WIFI_TDLS); + + feature_supported |= value; + key = va_arg(list, const char *); + if (!key) break; + } + if (!feature_supported) { + WIFI_LOG(WIFI_ERROR, "Error - Feature is not supported"); //LCOV_EXCL_LINE + set_last_result(WIFI_MANAGER_ERROR_NOT_SUPPORTED); //LCOV_EXCL_LINE + va_end(list); + return WIFI_MANAGER_ERROR_NOT_SUPPORTED; //LCOV_EXCL_LINE + } + + va_end(list); + set_last_result(WIFI_MANAGER_ERROR_NONE); + return WIFI_MANAGER_ERROR_NONE; +} diff --git a/src/wifi_manager.c b/src/wifi_manager.c new file mode 100755 index 0000000..af74029 --- /dev/null +++ b/src/wifi_manager.c @@ -0,0 +1,631 @@ +/* + * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "wifi_internal.h" + +#define WIFI_MAC_ADDR_LENGTH 17 +#define WIFI_MAC_ADDR_PATH "/sys/class/net/wlan0/address" + +//LCOV_EXCL_START +bool __wifi_check_handle_validity(wifi_manager_h wifi) +{ + if (wifi == NULL) { + WIFI_LOG(WIFI_ERROR, "Wifi handle is null"); + return false; + } + + return _wifi_find_from_handle_list(wifi); +} + +static int __wifi_set_device_state_changed_cb(wifi_manager_h wifi, + void *callback, void *user_data) +{ + wifi_manager_handle_s *local_handle = (wifi_manager_handle_s *)wifi; + + local_handle->device_state_cb = callback; + local_handle->device_state_user_data = user_data; + + return WIFI_MANAGER_ERROR_NONE; +} + +static int __wifi_set_background_scan_cb(wifi_manager_h wifi, + void *callback, void *user_data) +{ + wifi_manager_handle_s *local_handle = (wifi_manager_handle_s *)wifi; + + local_handle->bg_scan_cb = callback; + local_handle->bg_scan_user_data = user_data; + + return WIFI_MANAGER_ERROR_NONE; +} + +static int __wifi_set_connection_state_changed_cb(wifi_manager_h wifi, + void *callback, void *user_data) +{ + wifi_manager_handle_s *local_handle = (wifi_manager_handle_s *)wifi; + + local_handle->connection_state_cb = callback; + local_handle->connection_state_user_data = user_data; + + return WIFI_MANAGER_ERROR_NONE; +} + +static int __wifi_set_rssi_level_changed_cb(wifi_manager_h wifi, + void *callback, void *user_data) +{ + static __thread gint refcount = 0; + wifi_manager_handle_s *local_handle; + + local_handle = (wifi_manager_handle_s *)wifi; + + if (callback) { + if (refcount == 0) + vconf_notify_key_changed(VCONFKEY_WIFI_STRENGTH, + _wifi_rssi_level_changed_cb, NULL); + + refcount++; + WIFI_LOG(WIFI_INFO, "Successfully registered(%d)", refcount); + } else { + if (refcount > 0 && local_handle->rssi_level_changed_cb) { + if (--refcount == 0) { + if (vconf_ignore_key_changed(VCONFKEY_WIFI_STRENGTH, + _wifi_rssi_level_changed_cb) < 0) { + WIFI_LOG(WIFI_ERROR, "Error to de-register vconf callback(%d)", refcount); + } else { + WIFI_LOG(WIFI_INFO, "Successfully de-registered(%d)", refcount); + } + } + } + } + + local_handle->rssi_level_changed_cb = callback; + local_handle->rssi_level_changed_user_data = user_data; + + return WIFI_MANAGER_ERROR_NONE; +} + +static int __wifi_get_handle_count(void) +{ + return _wifi_get_count_from_handle_list(); +} +//LCOV_EXCL_STOP + +EXPORT_API int wifi_manager_initialize(wifi_manager_h *wifi) +{ + int rv; + + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (wifi == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + if (__wifi_check_handle_validity(*wifi)) { + WIFI_LOG(WIFI_ERROR, "Already initialized"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_ALREADY_INITIALIZED; //LCOV_EXCL_LINE + } + + rv = _wifi_init(); + if (rv == NET_ERR_ACCESS_DENIED) { + WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE + } else if (rv != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Init failed[%d]", rv); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + + rv = _wifi_create_handle(wifi); + if (rv != WIFI_MANAGER_ERROR_NONE) { + WIFI_LOG(WIFI_ERROR, "Init failed[%d]", rv); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + } + + _wifi_add_to_handle_list(wifi); + WIFI_LOG(WIFI_INFO, "Wi-Fi successfully initialized"); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_deinitialize(wifi_manager_h wifi) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + wifi_manager_unset_rssi_level_changed_cb(wifi); + + WIFI_LOG(WIFI_INFO, "Destroy handle: %p", wifi); + + _wifi_remove_from_handle_list(wifi); + + if (__wifi_get_handle_count() == 0) { + if (_wifi_deinit() == false) { + WIFI_LOG(WIFI_ERROR, "Deinit failed"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + } + + WIFI_LOG(WIFI_INFO, "Wi-Fi successfully de-initialized"); + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_activate(wifi_manager_h wifi, + wifi_manager_activated_cb callback, void *user_data) +{ + int rv; + + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!(__wifi_check_handle_validity(wifi)) || callback == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + rv = _wifi_activate(wifi, callback, FALSE, user_data); + if (rv != WIFI_MANAGER_ERROR_NONE) + WIFI_LOG(WIFI_ERROR, "Failed to activate Wi-Fi[%d]", rv); //LCOV_EXCL_LINE + + return rv; +} + +EXPORT_API int wifi_manager_activate_with_wifi_picker_tested( + wifi_manager_h wifi, wifi_manager_activated_cb callback, void *user_data) +{ + int rv; + + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!(__wifi_check_handle_validity(wifi)) || callback == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + rv = _wifi_activate(wifi, callback, TRUE, user_data); + if (rv != WIFI_MANAGER_ERROR_NONE) + WIFI_LOG(WIFI_ERROR, "Failed to activate Wi-Fi[%d]", rv); //LCOV_EXCL_LINE + + return rv; +} + +EXPORT_API int wifi_manager_deactivate(wifi_manager_h wifi, + wifi_manager_deactivated_cb callback, void *user_data) +{ + int rv; + + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!(__wifi_check_handle_validity(wifi)) || callback == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + rv = _wifi_deactivate(wifi, callback, user_data); + if (rv != WIFI_MANAGER_ERROR_NONE) + WIFI_LOG(WIFI_ERROR, "Wi-Fi deactivation failed"); //LCOV_EXCL_LINE + + return rv; +} + +EXPORT_API int wifi_manager_is_activated(wifi_manager_h wifi, bool *activated) +{ + int rv; + wifi_manager_device_state_e device_state; + + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (activated == NULL || !(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + rv = _wifi_get_wifi_device_state(&device_state); + if (rv == WIFI_MANAGER_ERROR_NONE) { + if (WIFI_MANAGER_DEVICE_STATE_DEACTIVATED == device_state) + *activated = false; + else + *activated = true; + } + + return rv; +} + +EXPORT_API int wifi_manager_get_mac_address(wifi_manager_h wifi, char **mac_address) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (mac_address == NULL || !(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + +#if defined TIZEN_TV + FILE *fp = NULL; + char buf[WIFI_MAC_ADDR_LENGTH + 1]; + if (0 == access(WIFI_MAC_ADDR_PATH, F_OK)) + fp = fopen(WIFI_MAC_ADDR_PATH, "r"); + + if (fp == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to open file" //LCOV_EXCL_LINE + " %s\n", WIFI_MAC_ADDR_PATH); + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + + if (fgets(buf, sizeof(buf), fp) == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to get MAC" + " info from %s\n", WIFI_MAC_ADDR_PATH); //LCOV_EXCL_LINE + fclose(fp); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } + + WIFI_LOG(WIFI_INFO, "%s : %s\n", WIFI_MAC_ADDR_PATH, buf); + + *mac_address = (char *)g_try_malloc0(WIFI_MAC_ADDR_LENGTH + 1); + if (*mac_address == NULL) { + WIFI_LOG(WIFI_ERROR, "malloc() failed"); //LCOV_EXCL_LINE + fclose(fp); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE + } + g_strlcpy(*mac_address, buf, WIFI_MAC_ADDR_LENGTH + 1); + fclose(fp); +#else + *mac_address = vconf_get_str(VCONFKEY_WIFI_BSSID_ADDRESS); + + if (*mac_address == NULL) { + WIFI_LOG(WIFI_ERROR, "Failed to get vconf" //LCOV_EXCL_LINE + " from %s", VCONFKEY_WIFI_BSSID_ADDRESS); + return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE + } +#endif + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_get_network_interface_name(wifi_manager_h wifi, char **name) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (name == NULL || !(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + return _wifi_get_intf_name(name); +} + +EXPORT_API int wifi_manager_scan(wifi_manager_h wifi, + wifi_manager_scan_finished_cb callback, void *user_data) +{ + int rv; + + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!(__wifi_check_handle_validity(wifi)) || callback == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + rv = _wifi_scan_request(wifi, callback, user_data); + if (rv != WIFI_MANAGER_ERROR_NONE) + WIFI_LOG(WIFI_ERROR, "Wi-Fi scan failed"); //LCOV_EXCL_LINE + + return rv; +} + +EXPORT_API int wifi_manager_scan_specific_ap(wifi_manager_h wifi, + const char* essid, wifi_manager_scan_finished_cb callback, void *user_data) +{ + int rv; + + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!(__wifi_check_handle_validity(wifi)) || + essid == NULL || callback == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + rv = _wifi_scan_specific_ap(wifi, essid, callback, user_data); + if (rv != WIFI_MANAGER_ERROR_NONE) + WIFI_LOG(WIFI_ERROR, "Wi-Fi hidden scan failed.\n"); //LCOV_EXCL_LINE + + return rv; +} + + + +EXPORT_API int wifi_manager_get_connected_ap(wifi_manager_h wifi, wifi_manager_ap_h *ap) +{ + int rv; + + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (ap == NULL || !(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + rv = _wifi_get_connected_profile(ap); + WIFI_LOG(WIFI_INFO, "Connected AP %p, rv %d", *ap, rv); + + return rv; +} + +EXPORT_API int wifi_manager_foreach_found_ap(wifi_manager_h wifi, + wifi_manager_found_ap_cb callback, void *user_data) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (callback == NULL || !(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + return _wifi_foreach_found_ap(callback, user_data); +} + +EXPORT_API int wifi_manager_foreach_found_specific_ap(wifi_manager_h wifi, + wifi_manager_found_ap_cb callback, void* user_data) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (callback == NULL || !(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + return _wifi_foreach_found_specific_ap(callback, user_data); +} + +EXPORT_API int wifi_manager_connect(wifi_manager_h wifi, + wifi_manager_ap_h ap, wifi_manager_connected_cb callback, void *user_data) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!(__wifi_check_handle_validity(wifi)) || callback == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + if (_wifi_check_ap_validity(ap) == false) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + return _wifi_open_profile(wifi, ap, callback, user_data); +} + +EXPORT_API int wifi_manager_disconnect(wifi_manager_h wifi, + wifi_manager_ap_h ap, wifi_manager_disconnected_cb callback, void *user_data) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!(__wifi_check_handle_validity(wifi)) || callback == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + if (_wifi_check_ap_validity(ap) == false) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + return _wifi_close_profile(wifi, ap, callback, user_data); +} + +//LCOV_EXCL_START +EXPORT_API int wifi_manager_connect_by_wps_pbc(wifi_manager_h wifi, + wifi_manager_ap_h ap, wifi_manager_connected_cb callback, void *user_data) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!(__wifi_check_handle_validity(wifi)) || callback == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + if (_wifi_check_ap_validity(ap) == false) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + return _wifi_connect_with_wps_pbc(wifi, ap, callback, user_data); +} + +EXPORT_API int wifi_manager_connect_by_wps_pin(wifi_manager_h wifi, + wifi_manager_ap_h ap, const char *pin, wifi_manager_connected_cb callback, void *user_data) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!(__wifi_check_handle_validity(wifi)) || callback == NULL) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + if (_wifi_check_ap_validity(ap) == false) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + if (NULL == pin || 0 == strlen(pin) || strlen(pin) > NET_WLAN_MAX_WPSPIN_LEN) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + return _wifi_connect_with_wps_pin(wifi, ap, pin, callback, user_data); +} +//LCOV_EXCL_STOP + +EXPORT_API int wifi_manager_forget_ap(wifi_manager_h wifi, wifi_manager_ap_h ap) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + if (_wifi_check_ap_validity(ap) == false) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + return _wifi_forget_ap(ap); +} + +EXPORT_API int wifi_manager_update_ap(wifi_manager_h wifi, wifi_manager_ap_h ap) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!(__wifi_check_handle_validity(wifi)) || + (_wifi_check_ap_validity(ap) == false)) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + net_profile_info_s *profile_info = ap; + + if (_wifi_check_profile_name_validity(profile_info->ProfileName) == false) + return WIFI_MANAGER_ERROR_NONE; + + return _wifi_update_ap_info(profile_info); +} + +EXPORT_API int wifi_manager_get_connection_state(wifi_manager_h wifi, + wifi_manager_connection_state_e *connection_state) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (connection_state == NULL || !(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + return _wifi_get_wifi_state(connection_state); +} + +EXPORT_API int wifi_manager_set_device_state_changed_cb(wifi_manager_h wifi, + wifi_manager_device_state_changed_cb callback, void *user_data) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (callback == NULL || !(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + return __wifi_set_device_state_changed_cb(wifi, callback, user_data); +} + +EXPORT_API int wifi_manager_unset_device_state_changed_cb(wifi_manager_h wifi) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + return __wifi_set_device_state_changed_cb(wifi, NULL, NULL); +} + +EXPORT_API int wifi_manager_set_background_scan_cb(wifi_manager_h wifi, + wifi_manager_scan_finished_cb callback, void *user_data) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (callback == NULL || !(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + return __wifi_set_background_scan_cb(wifi, callback, user_data); +} + +EXPORT_API int wifi_manager_unset_background_scan_cb(wifi_manager_h wifi) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + return __wifi_set_background_scan_cb(wifi, NULL, NULL); +} + +EXPORT_API int wifi_manager_set_connection_state_changed_cb(wifi_manager_h wifi, + wifi_manager_connection_state_changed_cb callback, void *user_data) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (callback == NULL || !(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + return __wifi_set_connection_state_changed_cb(wifi, callback, user_data); +} + +EXPORT_API int wifi_manager_unset_connection_state_changed_cb(wifi_manager_h wifi) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + return __wifi_set_connection_state_changed_cb(wifi, NULL, NULL); +} + +EXPORT_API int wifi_manager_set_rssi_level_changed_cb(wifi_manager_h wifi, + wifi_manager_rssi_level_changed_cb callback, void *user_data) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (callback == NULL || !(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + return __wifi_set_rssi_level_changed_cb(wifi, callback, user_data); +} + +EXPORT_API int wifi_manager_unset_rssi_level_changed_cb(wifi_manager_h wifi) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + + if (!(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE + } + + return __wifi_set_rssi_level_changed_cb(wifi, NULL, NULL); +} + diff --git a/src/wifi_tdls.c b/src/wifi_tdls.c new file mode 100755 index 0000000..4953d15 --- /dev/null +++ b/src/wifi_tdls.c @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "wifi-manager.h" +#include "wifi_internal.h" + +/** + * wifi tunneled direct link setup + */ + +//LCOV_EXCL_START +EXPORT_API int wifi_manager_tdls_disconnect(wifi_manager_h wifi, const char *peer_mac_addr) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + CHECK_FEATURE_SUPPORTED(WIFI_TDLS_FEATURE); + + if (peer_mac_addr == NULL || !(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + } + + int rv = 0; + rv = net_wifi_tdls_disconnect(peer_mac_addr); + + if (rv != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Failed to disconnect tdls"); + return WIFI_MANAGER_ERROR_OPERATION_FAILED; + } + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_tdls_get_connected_peer(wifi_manager_h wifi, char **peer_mac_addr) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + CHECK_FEATURE_SUPPORTED(WIFI_TDLS_FEATURE); + + if (peer_mac_addr == NULL || !(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + } + + int rv = 0; + rv = net_wifi_tdls_connected_peer(peer_mac_addr); + + if (rv != NET_ERR_NONE) { + WIFI_LOG(WIFI_ERROR, "Failed to get connected peer"); + return WIFI_MANAGER_ERROR_OPERATION_FAILED; + } + + if (g_strcmp0(*peer_mac_addr, "00.00.00.00.00.00") == 0) { + g_free(*peer_mac_addr); + return WIFI_MANAGER_ERROR_NO_CONNECTION; + } + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_tdls_set_state_changed_cb(wifi_manager_h wifi, + wifi_manager_tdls_state_changed_cb callback, void *user_data) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + CHECK_FEATURE_SUPPORTED(WIFI_TDLS_FEATURE); + + if (!(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + } + + return WIFI_MANAGER_ERROR_NONE; +} + +EXPORT_API int wifi_manager_tdls_unset_state_changed_cb(wifi_manager_h wifi) +{ + CHECK_FEATURE_SUPPORTED(WIFI_FEATURE); + CHECK_FEATURE_SUPPORTED(WIFI_TDLS_FEATURE); + + if (!(__wifi_check_handle_validity(wifi))) { + WIFI_LOG(WIFI_ERROR, "Invalid parameter"); + return WIFI_MANAGER_ERROR_INVALID_PARAMETER; + } + + return WIFI_MANAGER_ERROR_NONE; +} +//LCOV_EXCL_STOP + diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt new file mode 100755 index 0000000..6772f67 --- /dev/null +++ b/test/CMakeLists.txt @@ -0,0 +1,25 @@ +PROJECT(wifi_manager_test C) + +SET(fw_test "${fw_name}-test") + +SET(dependents "capi-base-common glib-2.0") +SET(pc_dependents "capi-base-common") + +INCLUDE(FindPkgConfig) +pkg_check_modules(${fw_test} REQUIRED ${dependents}) +FOREACH(flag ${${fw_test}_CFLAGS}) + SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") +ENDFOREACH(flag) + +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -Wall -fPIE") +SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -pie") + +aux_source_directory(. sources) +FOREACH(src ${sources}) + GET_FILENAME_COMPONENT(src_name ${src} NAME_WE) + MESSAGE("${src_name}") + ADD_EXECUTABLE(${src_name} ${src}) + TARGET_LINK_LIBRARIES(${src_name} ${fw_name} ${${fw_test}_LDFLAGS}) +ENDFOREACH() + +INSTALL(TARGETS wifi_manager_test RUNTIME DESTINATION bin/) diff --git a/test/wifi_manager_test.c b/test/wifi_manager_test.c new file mode 100755 index 0000000..d29c6b7 --- /dev/null +++ b/test/wifi_manager_test.c @@ -0,0 +1,1843 @@ +/* + * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define LOG_RED "\033[0;31m" +#define LOG_GREEN "\033[0;32m" +#define LOG_BROWN "\033[0;33m" +#define LOG_BLUE "\033[0;34m" +#define LOG_END "\033[0;m" + +wifi_manager_h wifi = NULL; +wifi_manager_h wifi2 = NULL; + +gboolean test_thread(GIOChannel *source, GIOCondition condition, gpointer data); + +static const char *__test_convert_error_to_string(wifi_manager_error_e err_type) +{ + switch (err_type) { + case WIFI_MANAGER_ERROR_NONE: + return "NONE"; + case WIFI_MANAGER_ERROR_INVALID_PARAMETER: + return "INVALID_PARAMETER"; + case WIFI_MANAGER_ERROR_OUT_OF_MEMORY: + return "OUT_OF_MEMORY"; + case WIFI_MANAGER_ERROR_INVALID_OPERATION: + return "INVALID_OPERATION"; + case WIFI_MANAGER_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED: + return "ADDRESS_FAMILY_NOT_SUPPORTED"; + case WIFI_MANAGER_ERROR_OPERATION_FAILED: + return "OPERATION_FAILED"; + case WIFI_MANAGER_ERROR_NO_CONNECTION: + return "NO_CONNECTION"; + case WIFI_MANAGER_ERROR_NOW_IN_PROGRESS: + return "NOW_IN_PROGRESS"; + case WIFI_MANAGER_ERROR_ALREADY_EXISTS: + return "ALREADY_EXISTS"; + case WIFI_MANAGER_ERROR_OPERATION_ABORTED: + return "OPERATION_ABORTED"; + case WIFI_MANAGER_ERROR_DHCP_FAILED: + return "DHCP_FAILED"; + case WIFI_MANAGER_ERROR_INVALID_KEY: + return "INVALID_KEY"; + case WIFI_MANAGER_ERROR_NO_REPLY: + return "NO_REPLY"; + case WIFI_MANAGER_ERROR_SECURITY_RESTRICTED: + return "SECURITY_RESTRICTED"; + case WIFI_MANAGER_ERROR_ALREADY_INITIALIZED: + return "ALREADY_INITIALIZED"; + case WIFI_MANAGER_ERROR_PERMISSION_DENIED: + return "PERMISSION_DENIED"; + case WIFI_MANAGER_ERROR_NOT_SUPPORTED: + return "NOT_SUPPORTED"; + } + + return "UNKNOWN"; +} + +static void __test_device_state_callback(wifi_manager_device_state_e state, void* user_data) +{ + printf("[%s] Device state changed callback", (char *)user_data); + + if (state == WIFI_MANAGER_DEVICE_STATE_ACTIVATED) + printf(", state : Activated\n"); + else + printf(", state : Deactivated\n"); +} + +static void __test_bg_scan_completed_callback(wifi_manager_error_e error_code, void* user_data) +{ + printf("[%s] Background Scan Completed, error code : %s\n", + (char *)user_data, __test_convert_error_to_string(error_code)); +} + +static void __test_scan_request_callback(wifi_manager_error_e error_code, void* user_data) +{ + if (user_data != NULL) + printf("user_data : %s\n", (char *)user_data); + + printf("Scan Completed from scan request, error code : %s\n", + __test_convert_error_to_string(error_code)); +} + +static void __test_connection_state_callback(wifi_manager_connection_state_e state, wifi_manager_ap_h ap, void* user_data) +{ + int rv = 0; + char *ap_name = NULL; + + printf("[%s] Connection state changed callback", (char *)user_data); + + switch (state) { + case WIFI_MANAGER_CONNECTION_STATE_CONNECTED: + printf(", state : Connected"); + break; + case WIFI_MANAGER_CONNECTION_STATE_ASSOCIATION: + printf(", state : Association"); + break; + case WIFI_MANAGER_CONNECTION_STATE_CONFIGURATION: + printf(", state : Configuration"); + break; + case WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED: + printf(", state : Disconnected"); + break; + default: + printf(", state : Unknown"); + } + + rv = wifi_manager_ap_get_essid(ap, &ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) + printf(", Fail to get AP name [%s]\n", __test_convert_error_to_string(rv)); + else { + printf(", AP name : %s\n", ap_name); + g_free(ap_name); + } +} + +static void __test_activated_callback(wifi_manager_error_e result, void* user_data) +{ + if (result == WIFI_MANAGER_ERROR_NONE) + printf("Wi-Fi Activation Succeeded\n"); + else + printf("Wi-Fi Activation Failed! error : %s\n", __test_convert_error_to_string(result)); +} + +static void __test_deactivated_callback(wifi_manager_error_e result, void* user_data) +{ + if (result == WIFI_MANAGER_ERROR_NONE) + printf("Wi-Fi Deactivation Succeeded\n"); + else + printf("Wi-Fi Deactivation Failed! error : %s\n", __test_convert_error_to_string(result)); +} + +static void __test_connected_callback(wifi_manager_error_e result, void* user_data) +{ + if (result == WIFI_MANAGER_ERROR_NONE) + printf("Wi-Fi Connection Succeeded\n"); + else + printf("Wi-Fi Connection Failed! error : %s\n", __test_convert_error_to_string(result)); +} + +static void __test_disconnected_callback(wifi_manager_error_e result, void* user_data) +{ + if (result == WIFI_MANAGER_ERROR_NONE) + printf("Wi-Fi Disconnection Succeeded\n"); + else + printf("Wi-Fi Disconnection Failed! error : %s\n", __test_convert_error_to_string(result)); +} + +static void __test_rssi_level_callback(wifi_manager_rssi_level_e rssi_level, void* user_data) +{ + printf("[%s] RSSI level changed callback, level = %d\n", (char *)user_data, rssi_level); +} + +static const char* __test_print_state(wifi_manager_connection_state_e state) +{ + switch (state) { + case WIFI_MANAGER_CONNECTION_STATE_FAILURE: + return "Failure"; + case WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED: + return "Disconnected"; + case WIFI_MANAGER_CONNECTION_STATE_ASSOCIATION: + return "Association"; + case WIFI_MANAGER_CONNECTION_STATE_CONNECTED: + return "Connected"; + case WIFI_MANAGER_CONNECTION_STATE_CONFIGURATION: + return "Configuration"; + } + + return "Unknown"; +} + +static bool __test_compare_ap_name(const char *ap_name, const char *ap_name_part) +{ + int ap_name_len = strlen(ap_name); + int ap_name_part_len = strlen(ap_name_part); + + if (strncmp(ap_name, ap_name_part, + ap_name_len > ap_name_part_len ? ap_name_len : ap_name_part_len) == 0) + return true; + else + return false; +} + +static bool __test_found_ap_callback(wifi_manager_ap_h ap, void *user_data) +{ + int rv = 0; + char *ap_name = NULL; + wifi_manager_connection_state_e state; + + rv = wifi_manager_ap_get_essid(ap, &ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get AP name [%s]\n", __test_convert_error_to_string(rv)); + return false; + } + + rv = wifi_manager_ap_get_connection_state(ap, &state); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get State [%s]\n", __test_convert_error_to_string(rv)); + g_free(ap_name); + return false; + } + + printf("AP name : %s, state : %s\n", ap_name, __test_print_state(state)); + g_free(ap_name); + + return true; +} + +static bool __test_found_connect_ap_callback(wifi_manager_ap_h ap, void *user_data) +{ + int rv = 0; + char *ap_name = NULL; + char *ap_name_part = (char*)user_data; + + rv = wifi_manager_ap_get_essid(ap, &ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get AP name [%s]\n", __test_convert_error_to_string(rv)); + return false; + } + + if (__test_compare_ap_name(ap_name, ap_name_part)) { + bool required = false; + + if (wifi_manager_ap_is_passphrase_required(ap, &required) == WIFI_MANAGER_ERROR_NONE) + printf("Passphrase required : %s\n", required ? "TRUE" : "FALSE"); + else + printf("Fail to get Passphrase required\n"); + + if (required) { + char passphrase[100]; + printf("Input passphrase for %s : ", ap_name); + rv = scanf("%99s", passphrase); + + rv = wifi_manager_ap_set_passphrase(ap, passphrase); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to set passphrase : %s\n", __test_convert_error_to_string(rv)); + g_free(ap_name); + return false; + } + } + + rv = wifi_manager_connect(wifi, ap, __test_connected_callback, NULL); + if (rv != WIFI_MANAGER_ERROR_NONE) + printf("Fail to connection request [%s] : %s\n", ap_name, __test_convert_error_to_string(rv)); + else + printf("Success to connection request [%s]\n", ap_name); + + g_free(ap_name); + return false; + } + + g_free(ap_name); + return true; +} + +static bool __test_found_connect_wps_callback(wifi_manager_ap_h ap, void *user_data) +{ + int rv = 0; + char *ap_name = NULL; + char *ap_name_part = (char*)user_data; + + rv = wifi_manager_ap_get_essid(ap, &ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get AP name [%s]\n", __test_convert_error_to_string(rv)); + return false; + } + + if (__test_compare_ap_name(ap_name, ap_name_part)) { + int user_sel; + char pin[32] = {0,}; + + printf("%s - Input WPS method (1:PBC, 2:PIN) :\n", ap_name); + rv = scanf("%9d", &user_sel); + + switch (user_sel) { + case 1: + rv = wifi_manager_connect_by_wps_pbc(wifi, ap, __test_connected_callback, NULL); + break; + case 2: + printf("Input PIN code :\n"); + rv = scanf("%31s", pin); + rv = wifi_manager_connect_by_wps_pin(wifi, ap, pin, __test_connected_callback, NULL); + break; + default: + printf("Invalid input!\n"); + g_free(ap_name); + return false; + } + + if (rv != WIFI_MANAGER_ERROR_NONE) + printf("Fail to connection request [%s] : %s\n", ap_name, __test_convert_error_to_string(rv)); + else + printf("Success to connection request [%s]\n", ap_name); + + g_free(ap_name); + return false; + } + + g_free(ap_name); + return true; +} + +static bool __test_found_disconnect_ap_callback(wifi_manager_ap_h ap, void *user_data) +{ + int rv = 0; + char *ap_name = NULL; + char *ap_name_part = (char*)user_data; + + rv = wifi_manager_ap_get_essid(ap, &ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get AP name [%s]\n", __test_convert_error_to_string(rv)); + return false; + } + + if (__test_compare_ap_name(ap_name, ap_name_part)) { + rv = wifi_manager_disconnect(wifi, ap, __test_disconnected_callback, NULL); + if (rv != WIFI_MANAGER_ERROR_NONE) + printf("Fail to disconnection reqeust %s : [%s]\n", ap_name, __test_convert_error_to_string(rv)); + else + printf("Success to disconnection request %s\n", ap_name); + + g_free(ap_name); + return false; + } + + g_free(ap_name); + return true; +} + +static bool __test_found_forget_ap_callback(wifi_manager_ap_h ap, void *user_data) +{ + int rv = 0; + char *ap_name = NULL; + char *ap_name_part = (char*)user_data; + + rv = wifi_manager_ap_get_essid(ap, &ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get AP name [%s]\n", __test_convert_error_to_string(rv)); + return false; + } + + if (__test_compare_ap_name(ap_name, ap_name_part)) { + rv = wifi_manager_forget_ap(wifi, ap); + if (rv != WIFI_MANAGER_ERROR_NONE) + printf("Fail to forget [%s] : %s\n", ap_name, __test_convert_error_to_string(rv)); + else + printf("Success to forget [%s]\n", ap_name); + + g_free(ap_name); + return false; + } + + g_free(ap_name); + return true; +} + +static bool __test_found_eap_ap_callback(wifi_manager_ap_h ap, void *user_data) +{ + int rv = 0; + char *ap_name = NULL; + char *ap_name_part = (char*)user_data; + + rv = wifi_manager_ap_get_essid(ap, &ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get AP name [%s]\n", __test_convert_error_to_string(rv)); + return false; + } + + if (__test_compare_ap_name(ap_name, ap_name_part)) { + wifi_manager_security_type_e type; + + if (wifi_manager_ap_get_security_type(ap, &type) == WIFI_MANAGER_ERROR_NONE) + printf("Security type : %d\n", type); + else + printf("Fail to get Security type\n"); + + if (type != WIFI_MANAGER_SECURITY_TYPE_EAP) { + g_free(ap_name); + return false; + } + + char input_str1[100]; + printf("Input user name for %s : ", ap_name); + rv = scanf("%99s", input_str1); + + char input_str2[100]; + printf("Input password for %s : ", ap_name); + rv = scanf("%99s", input_str2); + + rv = wifi_manager_ap_set_eap_passphrase(ap, input_str1, input_str2); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to set eap passphrase : %s\n", __test_convert_error_to_string(rv)); + g_free(ap_name); + return false; + } + + char *inputed_name = NULL; + bool is_pass_set; + rv = wifi_manager_ap_get_eap_passphrase(ap, &inputed_name, &is_pass_set); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get eap passphrase : %s\n", __test_convert_error_to_string(rv)); + g_free(ap_name); + return false; + } + + printf("name : %s, is password set : %s\n", inputed_name, is_pass_set ? "TRUE" : "FALSE"); + + printf("Input certificate file:\n"); + rv = scanf("%99s", input_str1); + + rv = wifi_manager_ap_set_eap_ca_cert_file(ap, input_str1); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to set eap certificatefile : %s\n", __test_convert_error_to_string(rv)); + g_free(ap_name); + return false; + } + + int input_int; + printf("Input EAP type:\n"); + printf("0 -> WIFI_MANAGER_EAP_TYPE_PEAP\n"); + printf("1 -> WIFI_MANAGER_EAP_TYPE_TLS\n"); + printf("2 -> WIFI_MANAGER_EAP_TYPE_TTLS\n"); + printf("3 -> WIFI_MANAGER_EAP_TYPE_SIM\n"); + printf("4 -> WIFI_MANAGER_EAP_TYPE_AKA\n"); + rv = scanf("%d", &input_int); + + rv = wifi_manager_ap_set_eap_type(ap, input_int); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to set eap type : %s\n", __test_convert_error_to_string(rv)); + g_free(ap_name); + return false; + } + + printf("Input EAP authentication type:\n"); + printf("0 -> WIFI_MANAGER_EAP_AUTH_TYPE_NONE\n"); + printf("1 -> WIFI_MANAGER_EAP_AUTH_TYPE_PAP\n"); + printf("2 -> WIFI_MANAGER_EAP_AUTH_TYPE_MSCHAP\n"); + printf("3 -> WIFI_MANAGER_EAP_AUTH_TYPE_MSCHAPV2\n"); + printf("4 -> WIFI_MANAGER_EAP_AUTH_TYPE_GTC\n"); + printf("5 -> WIFI_MANAGER_EAP_AUTH_TYPE_MD5\n"); + rv = scanf("%d", &input_int); + + rv = wifi_manager_ap_set_eap_auth_type(ap, input_int); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to set eap auth type : %s\n", __test_convert_error_to_string(rv)); + g_free(ap_name); + return false; + } + + rv = wifi_manager_connect(wifi, ap, __test_connected_callback, NULL); + if (rv != WIFI_MANAGER_ERROR_NONE) + printf("Fail to connection request [%s] : %s\n", ap_name, __test_convert_error_to_string(rv)); + else + printf("Success to connection request [%s]\n", ap_name); + + g_free(ap_name); + g_free(inputed_name); + return false; + } + + g_free(ap_name); + return true; +} + +static bool test_get_user_int(const char *msg, int *num) +{ + if (msg == NULL || num == NULL) + return false; + + int rv; + char buf[32] = {0,}; + printf("%s\n", msg); + rv = read(0, buf, 32); + + if (rv < 0 || *buf == 0 || *buf == '\n' || *buf == '\r') + return false; + + *num = atoi(buf); + return true; +} + +static bool test_get_user_string(const char *msg, char *buf, int buf_size) +{ + if (msg == NULL || buf == NULL || buf_size < 2) + return false; + + int rv; + printf("%s\n", msg); + memset(buf, 0, buf_size); + rv = read(0, buf, buf_size - 1); + + if (rv < 0 || buf[0] == '\0' || buf[0] == '\n' || buf[0] == '\r') { + buf[0] = '\0'; + return false; + } + + buf[rv-1] = '\0'; + return true; +} + +static bool __test_found_change_ip_method_callback(wifi_manager_ap_h ap, void *user_data) +{ + int rv; + char *ap_name; + char *ap_name_part = (char*)user_data; + + rv = wifi_manager_ap_get_essid(ap, &ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get AP name [%s]\n", __test_convert_error_to_string(rv)); + return false; + } + + if (__test_compare_ap_name(ap_name, ap_name_part)) { + wifi_manager_ip_config_type_e type; + int method; + int address_type; + + printf("Input new method type (1:dhcp, 2:manual, 3:auto) :\n"); + rv = scanf("%9d", &method); + if (rv <= 0) { + g_free(ap_name); + return false; + } + + rv = test_get_user_int("Input Address type to get" + "(0:IPV4, 1:IPV6):", &address_type); + + if (rv == false || (address_type != 0 && address_type != 1)) { + printf("Invalid input!!\n"); + return false; + } + + switch (method) { + case 1: + type = WIFI_MANAGER_IP_CONFIG_TYPE_DYNAMIC; + break; + case 2: + type = WIFI_MANAGER_IP_CONFIG_TYPE_STATIC; + break; + case 3: + type = WIFI_MANAGER_IP_CONFIG_TYPE_AUTO; + break; + default: + printf("Invalid input!\n"); + g_free(ap_name); + return false; + } + + rv = wifi_manager_ap_set_ip_config_type(ap, address_type, type); + if (rv != WIFI_MANAGER_ERROR_NONE) + printf("Fail to set ip method type[%s]\n", __test_convert_error_to_string(rv)); + + if (type == WIFI_MANAGER_IP_CONFIG_TYPE_STATIC) { + char ip_addr[16]; + + printf("Input new ip address (x:skip, 0:clear) :\n"); + rv = scanf("%15s", ip_addr); + if (rv > 0) { + switch (ip_addr[0]) { + case 'x': + rv = WIFI_MANAGER_ERROR_NONE; + break; + case '0': + rv = wifi_manager_ap_set_ip_address(ap, address_type, NULL); + break; + default: + rv = wifi_manager_ap_set_ip_address(ap, address_type, ip_addr); + } + + if (rv != WIFI_MANAGER_ERROR_NONE) + printf("Fail to set ip address[%s]\n", + __test_convert_error_to_string(rv)); + } + + printf("Input new subnet mask (x:skip, 0:clear) :\n"); + rv = scanf("%15s", ip_addr); + if (rv > 0) { + switch (ip_addr[0]) { + case 'x': + rv = WIFI_MANAGER_ERROR_NONE; + break; + case '0': + rv = wifi_manager_ap_set_subnet_mask(ap, address_type, NULL); + break; + default: + rv = wifi_manager_ap_set_subnet_mask(ap, address_type, ip_addr); + } + + if (rv != WIFI_MANAGER_ERROR_NONE) + printf("Fail to set subnet mask[%s]\n", + __test_convert_error_to_string(rv)); + } + + printf("Input new gateway address (x:skip, 0:clear) :\n"); + rv = scanf("%15s", ip_addr); + if (rv > 0) { + switch (ip_addr[0]) { + case 'x': + rv = WIFI_MANAGER_ERROR_NONE; + break; + case '0': + rv = wifi_manager_ap_set_gateway_address(ap, address_type, NULL); + break; + default: + rv = wifi_manager_ap_set_gateway_address(ap, address_type, ip_addr); + } + + if (rv != WIFI_MANAGER_ERROR_NONE) + printf("Fail to set gateway address[%s]\n", + __test_convert_error_to_string(rv)); + } + } + + g_free(ap_name); + return false; + } + + g_free(ap_name); + return true; +} + +static bool __test_found_change_proxy_method_callback(wifi_manager_ap_h ap, void *user_data) +{ + int rv, address_type; + char *ap_name; + char *ap_name_part = (char*)user_data; + + rv = wifi_manager_ap_get_essid(ap, &ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get AP name [%s]\n", __test_convert_error_to_string(rv)); + return false; + } + + printf("ap_name %s, user input name %s\n", ap_name, ap_name_part); + if (__test_compare_ap_name(ap_name, ap_name_part)) { + wifi_manager_proxy_type_e type; + char proxy_addr[65]; + int method; + + printf("Input new method type (1:direct, 2:manual, 3:auto) :\n"); + rv = scanf("%9d", &method); + if (rv <= 0) { + g_free(ap_name); + return false; + } + + rv = test_get_user_int("Input Address type to get" + "(0:IPV4, 1:IPV6):", &address_type); + + if (rv == false || (address_type != 0 && address_type != 1)) { + printf("Invalid input!!\n"); + return false; + } + + switch (method) { + case 1: + type = WIFI_MANAGER_PROXY_TYPE_DIRECT; + break; + case 2: + type = WIFI_MANAGER_PROXY_TYPE_MANUAL; + break; + case 3: + type = WIFI_MANAGER_PROXY_TYPE_AUTO; + break; + default: + printf("Invalid input!\n"); + g_free(ap_name); + return false; + } + + rv = wifi_manager_ap_set_proxy_type(ap, type); + if (rv != WIFI_MANAGER_ERROR_NONE) + printf("Fail to set proxy method type[%s]\n", __test_convert_error_to_string(rv)); + + printf("Input new proxy address (x:skip, 0:clear) :\n"); + rv = scanf("%64s", proxy_addr); + + if (rv > 0) { + switch (proxy_addr[0]) { + case 'x': + rv = WIFI_MANAGER_ERROR_NONE; + break; + case '0': + rv = wifi_manager_ap_set_proxy_address(ap, address_type, NULL); + break; + default: + rv = wifi_manager_ap_set_proxy_address(ap, address_type, proxy_addr); + } + + if (rv != WIFI_MANAGER_ERROR_NONE) + printf("Fail to set proxy address[%s]\n", __test_convert_error_to_string(rv)); + } + + g_free(ap_name); + return false; + } + + g_free(ap_name); + return true; +} + +static bool __test_found_print_ap_info_callback(wifi_manager_ap_h ap, void *user_data) +{ + int rv, address_type = 0; + char *ap_name; + char *str_value; + int int_value; + wifi_manager_connection_state_e conn_state; + wifi_manager_ip_config_type_e ip_type; + wifi_manager_proxy_type_e proxy_type; + wifi_manager_security_type_e sec_type; + wifi_manager_encryption_type_e enc_type; + wifi_manager_eap_type_e eap_type; + wifi_manager_eap_auth_type_e eap_auth_type; + bool bool_value; + char *ap_name_part = (char*)user_data; + + rv = wifi_manager_ap_get_essid(ap, &ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get AP name [%s]\n", __test_convert_error_to_string(rv)); + return false; + } + + printf("ap_name %s, user input name %s\n", ap_name, ap_name_part); + if (__test_compare_ap_name(ap_name, ap_name_part)) { + /* Basic info */ + printf("ESSID : %s\n", ap_name); + + if (wifi_manager_ap_get_bssid(ap, &str_value) == WIFI_MANAGER_ERROR_NONE) { + printf("BSSID : %s\n", str_value); + g_free(str_value); + } else + printf("Fail to get BSSID\n"); + + if (wifi_manager_ap_get_rssi(ap, &int_value) == WIFI_MANAGER_ERROR_NONE) + printf("RSSI : %d\n", int_value); + else + printf("Fail to get RSSI\n"); + + if (wifi_manager_ap_get_frequency(ap, &int_value) == WIFI_MANAGER_ERROR_NONE) + printf("Frequency : %d\n", int_value); + else + printf("Fail to get Frequency\n"); + + if (wifi_manager_ap_get_max_speed(ap, &int_value) == WIFI_MANAGER_ERROR_NONE) + printf("Max speed : %d\n", int_value); + else + printf("Fail to get Max speed\n"); + + if (wifi_manager_ap_is_favorite(ap, &bool_value) == WIFI_MANAGER_ERROR_NONE) + printf("Favorite : %s\n", bool_value ? "TRUE" : "FALSE"); + else + printf("Fail to get Favorite\n"); + + /* Network info */ + if (wifi_manager_ap_get_connection_state(ap, &conn_state) == WIFI_MANAGER_ERROR_NONE) + printf("Connection State : %d\n", conn_state); + else + printf("Fail to get Connection State\n"); + + rv = test_get_user_int("Input Address type to get" + "(0:IPV4, 1:IPV6):", &address_type); + + if (rv == false || (address_type != 0 && address_type != 1)) { + printf("Invalid input!!\n"); + return false; + } + + if (wifi_manager_ap_get_ip_config_type(ap, address_type, &ip_type) == WIFI_MANAGER_ERROR_NONE) + printf("IP config type : %d\n", ip_type); + else + printf("Fail to get IP config type\n"); + + if (wifi_manager_ap_get_ip_address(ap, address_type, &str_value) == WIFI_MANAGER_ERROR_NONE) { + printf("IP : %s\n", str_value); + g_free(str_value); + } else + printf("Fail to get IP\n"); + + if (wifi_manager_ap_get_subnet_mask(ap, address_type, &str_value) == WIFI_MANAGER_ERROR_NONE) { + printf("Subnet mask : %s\n", str_value); + g_free(str_value); + } else + printf("Fail to get Subnet mask\n"); + + if (wifi_manager_ap_get_gateway_address(ap, address_type, &str_value) == WIFI_MANAGER_ERROR_NONE) { + printf("Gateway : %s\n", str_value); + g_free(str_value); + } else + printf("Fail to get Gateway\n"); + + if (wifi_manager_ap_get_proxy_type(ap, &proxy_type) == WIFI_MANAGER_ERROR_NONE) + printf("Proxy type : %d\n", proxy_type); + else + printf("Fail to get Proxy type\n"); + + if (wifi_manager_ap_get_proxy_address(ap, address_type, &str_value) == WIFI_MANAGER_ERROR_NONE) { + printf("Proxy : %s\n", str_value); + g_free(str_value); + } else + printf("Fail to get Proxy\n"); + + if (wifi_manager_ap_get_dns_address(ap, 1, address_type, &str_value) == WIFI_MANAGER_ERROR_NONE) { + printf("DNS1 : %s\n", str_value); + g_free(str_value); + } else + printf("Fail to get DNS1\n"); + + if (wifi_manager_ap_get_dns_address(ap, 2, address_type, &str_value) == WIFI_MANAGER_ERROR_NONE) { + printf("DNS2 : %s\n", str_value); + g_free(str_value); + } else + printf("Fail to get DNS2\n"); + + /* Security info */ + if (wifi_manager_ap_get_security_type(ap, &sec_type) == WIFI_MANAGER_ERROR_NONE) + printf("Security type : %d\n", sec_type); + else + printf("Fail to get Security type\n"); + + if (wifi_manager_ap_get_encryption_type(ap, &enc_type) == WIFI_MANAGER_ERROR_NONE) + printf("Encryption type : %d\n", enc_type); + else + printf("Fail to get Encryption type\n"); + + if (wifi_manager_ap_is_passphrase_required(ap, &bool_value) == WIFI_MANAGER_ERROR_NONE) + printf("Passphrase required : %s\n", bool_value ? "TRUE" : "FALSE"); + else + printf("Fail to get Passphrase required\n"); + + if (wifi_manager_ap_is_wps_supported(ap, &bool_value) == WIFI_MANAGER_ERROR_NONE) + printf("WPS supported : %s\n", bool_value ? "TRUE" : "FALSE"); + else + printf("Fail to get WPS supported\n"); + + if (sec_type != WIFI_MANAGER_SECURITY_TYPE_EAP) { + g_free(ap_name); + return false; + } + + /* EAP info */ + if (wifi_manager_ap_get_eap_type(ap, &eap_type) == WIFI_MANAGER_ERROR_NONE) + printf("EAP type : %d\n", eap_type); + else + printf("Fail to get EAP type\n"); + + if (wifi_manager_ap_get_eap_auth_type(ap, &eap_auth_type) == WIFI_MANAGER_ERROR_NONE) + printf("EAP auth type : %d\n", eap_auth_type); + else + printf("Fail to get EAP auth type\n"); + + if (wifi_manager_ap_get_eap_passphrase(ap, &str_value, &bool_value) == WIFI_MANAGER_ERROR_NONE) { + printf("EAP user name : %s\n", str_value); + printf("EAP is password setted : %s\n", bool_value ? "TRUE" : "FALSE"); + g_free(str_value); + } else + printf("Fail to get EAP passphrase(user name/password)\n"); + + if (wifi_manager_ap_get_eap_ca_cert_file(ap, &str_value) == WIFI_MANAGER_ERROR_NONE) { + printf("EAP ca cert file : %s\n", str_value); + g_free(str_value); + } else + printf("Fail to get EAP ca cert file\n"); + + if (wifi_manager_ap_get_eap_client_cert_file(ap, &str_value) == WIFI_MANAGER_ERROR_NONE) { + printf("EAP client cert file : %s\n", str_value); + g_free(str_value); + } else + printf("Fail to get EAP client cert file\n"); + + if (wifi_manager_ap_get_eap_private_key_file(ap, &str_value) == WIFI_MANAGER_ERROR_NONE) { + printf("EAP private key file : %s\n", str_value); + g_free(str_value); + } else + printf("Fail to get EAP private key file\n"); + + g_free(ap_name); + return false; + } + + g_free(ap_name); + return true; +} + +static bool _test_config_list_cb(const wifi_manager_config_h config, void *user_data) +{ + gchar *name = NULL; + wifi_manager_security_type_e security_type; + + wifi_manager_config_get_name(config, &name); + wifi_manager_config_get_security_type(config, &security_type); + + printf("Name[%s] ", name); + printf("Security type[%d] ", security_type); + if (security_type == WIFI_MANAGER_SECURITY_TYPE_EAP) { + wifi_manager_eap_type_e eap_type; + wifi_manager_eap_auth_type_e eap_auth_type; + wifi_manager_config_get_eap_type(config, &eap_type); + printf("Eap type[%d] ", eap_type); + wifi_manager_config_get_eap_auth_type(config, &eap_auth_type); + printf("Eap auth type[%d]", eap_auth_type); + } + printf("\n"); + + g_free(name); + + return true; +} + +struct _wifi_conf { + char name[33]; + int type; +}; +static bool _test_config_list_cb_for_remove(const wifi_manager_config_h config, void *user_data) +{ + + struct _wifi_conf *c = (struct _wifi_conf *)user_data; + gchar *name = NULL; + wifi_manager_security_type_e security_type; + + wifi_manager_config_get_name(config, &name); + wifi_manager_config_get_security_type(config, &security_type); + + if (__test_compare_ap_name(name, c->name) && security_type == c->type) { + int rv = wifi_manager_config_remove(wifi, config); + if (rv != WIFI_MANAGER_ERROR_NONE) + printf("Fail to remove configurations [%s]\n", __test_convert_error_to_string(rv)); + else + printf("Success to remove configuration [%s]\n", name); + g_free(name); + return false; + } + + return true; +} + +static bool __test_found_specific_ap_callback(wifi_manager_ap_h ap, void *user_data) +{ + printf("Found specific ap Completed\n"); + + int rv; + char *ap_name = NULL; + wifi_manager_security_type_e security_type = WIFI_MANAGER_SECURITY_TYPE_NONE; + + rv = wifi_manager_ap_get_essid(ap, &ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get AP name [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + printf("[AP name] : %s\n", ap_name); + + rv = wifi_manager_ap_get_security_type(ap, &security_type); + if (rv == WIFI_MANAGER_ERROR_NONE) + printf("[Security type] : %d\n", security_type); + else { + printf("Fail to get Security type\n"); + g_free(ap_name); + return false; + } + + switch (security_type) { + case WIFI_MANAGER_SECURITY_TYPE_WEP: + case WIFI_MANAGER_SECURITY_TYPE_WPA_PSK: + case WIFI_MANAGER_SECURITY_TYPE_WPA2_PSK: + { + char passphrase[100]; + printf("Input passphrase for %s : ", ap_name); + rv = scanf("%99s", passphrase); + + rv = wifi_manager_ap_set_passphrase(ap, passphrase); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to set passphrase : %s\n", __test_convert_error_to_string(rv)); + g_free(ap_name); + return false; + } + } + break; + case WIFI_MANAGER_SECURITY_TYPE_EAP: + { + char input_str1[100]; + printf("Input user name for %s : ", ap_name); + rv = scanf("%99s", input_str1); + + char input_str2[100]; + printf("Input password for %s : ", ap_name); + rv = scanf("%99s", input_str2); + + rv = wifi_manager_ap_set_eap_passphrase(ap, input_str1, input_str2); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to set eap passphrase : %s\n", __test_convert_error_to_string(rv)); + g_free(ap_name); + return false; + } + + char *inputed_name = NULL; + bool is_pass_set; + rv = wifi_manager_ap_get_eap_passphrase(ap, &inputed_name, &is_pass_set); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get eap passphrase : %s\n", __test_convert_error_to_string(rv)); + g_free(ap_name); + return false; + } + + printf("name : %s, is password set : %s\n", inputed_name, is_pass_set ? "TRUE" : "FALSE"); + g_free(inputed_name); + } + break; + case WIFI_MANAGER_SECURITY_TYPE_NONE: + default: + break; + } + + rv = wifi_manager_connect(wifi, ap, __test_connected_callback, NULL); + if (rv != WIFI_MANAGER_ERROR_NONE) + printf("Fail to connection request [%s] : %s\n", ap_name, __test_convert_error_to_string(rv)); + else + printf("Success to connection request [%s]\n", ap_name); + + g_free(ap_name); + return true; +} + +static void __test_scan_specific_ap_callback(wifi_manager_error_e error_code, void* user_data) +{ + int rv; + + printf("Specific scan Completed from scan request, error code : %s\n", + __test_convert_error_to_string(error_code)); + + if (error_code != WIFI_MANAGER_ERROR_NONE) + return; + + rv = wifi_manager_foreach_found_specific_ap(wifi, __test_found_specific_ap_callback, user_data); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get specific AP(can't get AP list) [%s]\n", __test_convert_error_to_string(rv)); + return; + } +} + +int test_wifi_manager_init(void) +{ + int rv = wifi_manager_initialize(&wifi); + + if (rv == WIFI_MANAGER_ERROR_NONE) { + wifi_manager_set_device_state_changed_cb(wifi, __test_device_state_callback, "1"); + wifi_manager_set_background_scan_cb(wifi, __test_bg_scan_completed_callback, "1"); + wifi_manager_set_connection_state_changed_cb(wifi, __test_connection_state_callback, "1"); + wifi_manager_set_rssi_level_changed_cb(wifi, __test_rssi_level_callback, "1"); + } else { + printf("[1] Wifi init failed [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + rv = wifi_manager_initialize(&wifi2); + + if (rv == WIFI_MANAGER_ERROR_NONE) { + wifi_manager_set_device_state_changed_cb(wifi2, __test_device_state_callback, "2"); + wifi_manager_set_background_scan_cb(wifi2, __test_bg_scan_completed_callback, "2"); + wifi_manager_set_connection_state_changed_cb(wifi2, __test_connection_state_callback, "2"); + wifi_manager_set_rssi_level_changed_cb(wifi2, __test_rssi_level_callback, "2"); + } else { + printf("[2] Wifi init failed [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + printf("Wifi init succeeded\n"); + return 1; +} + +int test_wifi_manager_deinit(void) +{ + int rv = wifi_manager_deinitialize(wifi); + + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("[1] Wifi deinit failed [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + rv = wifi_manager_deinitialize(wifi2); + + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("[2] Wifi deinit failed [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + printf("Wifi deinit succeeded\n"); + return 1; +} + +int test_wifi_manager_activate(void) +{ + int rv = 0; + + rv = wifi_manager_activate(wifi, __test_activated_callback, NULL); + + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to activate Wi-Fi device [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + printf("Success to activate Wi-Fi device\n"); + + return 1; +} + +int test_wifi_manager_deactivate(void) +{ + int rv = 0; + + rv = wifi_manager_deactivate(wifi, __test_deactivated_callback, NULL); + + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to deactivate Wi-Fi device [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + printf("Success to deactivate Wi-Fi device\n"); + + return 1; +} + +int test_wifi_manager_is_activated(void) +{ + int rv = 0; + bool state = false; + + rv = wifi_manager_is_activated(wifi, &state); + + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get Wi-Fi device state [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + printf("Success to get Wi-Fi device state : %s\n", (state) ? "TRUE" : "FALSE"); + + return 1; +} + +int test_wifi_manager_get_connection_state(void) +{ + int rv = 0; + wifi_manager_connection_state_e connection_state; + + rv = wifi_manager_get_connection_state(wifi, &connection_state); + + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get connection state [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + printf("Success to get connection state : "); + switch (connection_state) { + case WIFI_MANAGER_CONNECTION_STATE_ASSOCIATION: + printf("Association\n"); + break; + case WIFI_MANAGER_CONNECTION_STATE_CONNECTED: + printf("Connected\n"); + break; + case WIFI_MANAGER_CONNECTION_STATE_CONFIGURATION: + printf("Configuration\n"); + break; + case WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED: + printf("Disconnected\n"); + break; + default: + printf("Unknown\n"); + } + + return 1; +} + +int test_wifi_manager_get_mac_address(void) +{ + int rv = 0; + char *mac_addr = NULL; + + rv = wifi_manager_get_mac_address(wifi, &mac_addr); + + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get MAC address [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + printf("MAC address : %s\n", mac_addr); + g_free(mac_addr); + + return 1; +} + +int test_wifi_manager_get_interface_name(void) +{ + int rv = 0; + char *if_name = NULL; + + rv = wifi_manager_get_network_interface_name(wifi, &if_name); + + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get Interface name [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + printf("Interface name : %s\n", if_name); + g_free(if_name); + + return 1; +} + +int test_wifi_manager_scan(void) +{ + int rv = 0; + + rv = wifi_manager_scan(wifi, __test_scan_request_callback, NULL); + + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Scan request failed [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + printf("Scan request succeeded\n"); + + return 1; +} + +int test_wifi_manager_get_connected_ap(void) +{ + int rv = 0; + char *ap_name = NULL; + wifi_manager_ap_h ap_h; + + rv = wifi_manager_get_connected_ap(wifi, &ap_h); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get connected AP [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + rv = wifi_manager_ap_get_essid(ap_h, &ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get essid [%s]\n", __test_convert_error_to_string(rv)); + wifi_manager_ap_destroy(ap_h); + return -1; + } + + printf("Connected AP : %s\n", ap_name); + g_free(ap_name); + wifi_manager_ap_destroy(ap_h); + + return 1; +} + +int test_wifi_manager_foreach_found_ap(void) +{ + int rv = 0; + + rv = wifi_manager_foreach_found_ap(wifi, __test_found_ap_callback, NULL); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get AP list [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + printf("Get AP list finished\n"); + + return 1; +} + +int test_wifi_manager_connect(void) +{ + int rv = 0; + char ap_name[33]; + bool state = false; + + wifi_manager_is_activated(wifi, &state); + if (state == false) + return -1; + + printf("Input a part of AP name to connect : "); + rv = scanf("%32s", ap_name); + + rv = wifi_manager_foreach_found_ap(wifi, __test_found_connect_ap_callback, ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to connect (can't get AP list) [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + printf("Connection step finished\n"); + return 1; +} + +int test_wifi_manager_connect_specific_ap(void) +{ + int rv; + char ap_name[33]; + + printf("Input a part of specific AP name to connect : "); + rv = scanf("%32s", ap_name); + if (rv <= 0) + return -1; + + rv = wifi_manager_scan_specific_ap(wifi, ap_name, __test_scan_specific_ap_callback, NULL); + + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Scan request failed [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + printf("Scan specific AP request succeeded\n"); + return 1; +} + +int test_wifi_manager_disconnect(void) +{ + int rv = 0; + char ap_name[33]; + bool state = false; + + wifi_manager_is_activated(wifi, &state); + if (state == false) + return -1; + + printf("Input a part of AP name to disconnect : "); + rv = scanf("%32s", ap_name); + + rv = wifi_manager_foreach_found_ap(wifi, __test_found_disconnect_ap_callback, ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to disconnect (can't get AP list) [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + printf("Disconnection step finished\n"); + return 1; +} + +int test_wifi_manager_connect_wps(void) +{ + int rv = 0; + char ap_name[33]; + bool state = false; + + wifi_manager_is_activated(wifi, &state); + if (state == false) + return -1; + + printf("Input a part of AP name to connect by wps : "); + rv = scanf("%32s", ap_name); + + rv = wifi_manager_foreach_found_ap(wifi, __test_found_connect_wps_callback, ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to connect (can't get AP list) [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + printf("Connection step finished\n"); + return 1; +} + +int test_wifi_manager_forget_ap(void) +{ + int rv = 0; + char ap_name[33]; + bool state = false; + + wifi_manager_is_activated(wifi, &state); + if (state == false) + return -1; + + printf("Input a part of AP name to forget : "); + rv = scanf("%32s", ap_name); + + rv = wifi_manager_foreach_found_ap(wifi, __test_found_forget_ap_callback, ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to forget (can't get AP list) [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + printf("Forget AP finished\n"); + return 1; +} + +int test_wifi_manager_connect_eap_ap(void) +{ + int rv = 0; + char ap_name[33]; + bool state = false; + + wifi_manager_is_activated(wifi, &state); + if (state == false) + return -1; + + printf("Input a part of AP name to connect : "); + rv = scanf("%32s", ap_name); + + rv = wifi_manager_foreach_found_ap(wifi, __test_found_eap_ap_callback, ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to connect (can't get AP list) [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + printf("Connection step finished\n"); + return 1; +} + +int test_wifi_manager_set_ip_method(void) +{ + int rv; + char ap_name[33]; + bool state; + + rv = wifi_manager_is_activated(wifi, &state); + if (rv != WIFI_MANAGER_ERROR_NONE || state == false) + return -1; + + printf("Input a part of AP name to change IP method : "); + rv = scanf("%32s", ap_name); + if (rv <= 0) + return -1; + + rv = wifi_manager_foreach_found_ap(wifi, __test_found_change_ip_method_callback, ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to change (can't get AP list) [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + printf("IP method changing finished\n"); + return 1; +} + +int test_wifi_manager_set_proxy_method(void) +{ + int rv; + char ap_name[33]; + bool state; + + rv = wifi_manager_is_activated(wifi, &state); + if (rv != WIFI_MANAGER_ERROR_NONE || state == false) + return -1; + + printf("Input a part of AP name to change Proxy method : "); + rv = scanf("%32s", ap_name); + if (rv <= 0) + return -1; + + rv = wifi_manager_foreach_found_ap(wifi, __test_found_change_proxy_method_callback, ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to change (can't get AP list) [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + printf("Proxy method changing finished\n"); + return 1; +} + +int test_wifi_manager_get_ap_info(void) +{ + int rv; + char ap_name[33]; + bool state; + + rv = wifi_manager_is_activated(wifi, &state); + if (rv != WIFI_MANAGER_ERROR_NONE || state == false) + return -1; + + printf("Input a part of AP name to get detailed info : "); + rv = scanf("%32s", ap_name); + if (rv <= 0) + return -1; + + rv = wifi_manager_foreach_found_ap(wifi, __test_found_print_ap_info_callback, ap_name); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get AP info (can't get AP list) [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + printf("AP info printing finished\n"); + return 1; +} + +int test_wifi_manager_config_load_configuration(void) +{ + int rv; + + rv = wifi_manager_config_foreach_configuration(wifi, _test_config_list_cb, NULL); + if (rv != WIFI_MANAGER_ERROR_NONE) + return -1; + + return 1; +} + +int test_wifi_manager_config_save(void) +{ + int rv; + char name[33] = { 0, }; + char passphrase[100] = { 0, }; + int type = 0; + char proxy[100] = { 0, }; + int hidden = 0; + wifi_manager_config_h config; + + printf("Input AP configuration\n"); + printf("Name : "); + rv = scanf("%32s", name); + if (rv <= 0) + return -1; + + printf("Passphrase : "); + rv = scanf("%99s", passphrase); + if (rv <= 0) + return -1; + + printf("Security type(None(0), WEP(1), WPA-PSK(2), EAP(4)) : "); + rv = scanf("%d", &type); + if (rv <= 0) + return -1; + + rv = wifi_manager_config_create(wifi, name, passphrase, type, &config); + if (rv != WIFI_MANAGER_ERROR_NONE) + return -1; + + if (test_get_user_string("Proxy(server:port) - (Enter for skip): ", proxy, 99)) { + rv = wifi_manager_config_set_proxy_address(config, WIFI_MANAGER_ADDRESS_FAMILY_IPV4, proxy); + if (rv != WIFI_MANAGER_ERROR_NONE) + return -1; + } + + if (test_get_user_int("Hidden(1:Hidden) - (Enter for skip): ", &hidden)) { + if (hidden == 1) + rv = wifi_manager_config_set_hidden_ap_property(config, TRUE); + else + rv = wifi_manager_config_set_hidden_ap_property(config, FALSE); + if (rv != WIFI_MANAGER_ERROR_NONE) + return -1; + } + + if (type == WIFI_MANAGER_SECURITY_TYPE_EAP) { + char anonymous[100] = { 0, }; + char ca_cert[100] = { 0, }; + char private_key[100] = { 0, }; + char client_cert[100] = { 0, }; + char eap_identity[100] = { 0, }; + int eap_type; + int eap_auth_type; + char subject_match[100] = { 0, }; + + if (test_get_user_string("EAP Anonymous Identity - (Enter for skip): ", anonymous, 99)) { + rv = wifi_manager_config_set_eap_anonymous_identity(config, anonymous); + if (rv != WIFI_MANAGER_ERROR_NONE) + return -1; + } + + if (test_get_user_string("EAP ca cert file - (Enter for skip): ", ca_cert, 99)) { + rv = wifi_manager_config_set_eap_ca_cert_file(config, ca_cert); + if (rv != WIFI_MANAGER_ERROR_NONE) + return -1; + } + + if (test_get_user_string("EAP private key - (Enter for skip): ", private_key, 99) && + test_get_user_string("EAP client cert file - (Enter for skip): ", client_cert, 99)) { + rv = wifi_manager_config_set_eap_client_cert_file(config, private_key, client_cert); + if (rv != WIFI_MANAGER_ERROR_NONE) + return -1; + } + + if (test_get_user_string("EAP identity - (Enter for skip): ", eap_identity, 99)) { + rv = wifi_manager_config_set_eap_identity(config, eap_identity); + if (rv != WIFI_MANAGER_ERROR_NONE) + return -1; + } + + if (test_get_user_int("EAP type (PEAP(0), TLS(1), TTLS(2), SIM(3), AKA(4)) - (Enter for skip): ", &eap_type)) { + rv = wifi_manager_config_set_eap_type(config, eap_type); + if (rv != WIFI_MANAGER_ERROR_NONE) + return -1; + } + + if (test_get_user_int("EAP auth type (None(0), PAP(1), MSCHAP(2), MSCHAPv2(3), GTC(4), MD5(5)) - (Enter for skip): ", &eap_auth_type)) { + rv = wifi_manager_config_set_eap_auth_type(config, eap_auth_type); + if (rv != WIFI_MANAGER_ERROR_NONE) + return -1; + } + + if (test_get_user_string("EAP subject match - (Enter for skip): ", subject_match, 99)) { + rv = wifi_manager_config_set_eap_subject_match(config, subject_match); + if (rv != WIFI_MANAGER_ERROR_NONE) + return -1; + } + } + + rv = wifi_manager_config_save(wifi, config); + if (rv != WIFI_MANAGER_ERROR_NONE) + return -1; + + rv = wifi_manager_config_destroy(config); + if (rv != WIFI_MANAGER_ERROR_NONE) + return -1; + + return 1; +} + +int test_wifi_manager_config_remove(void) +{ + int rv; + struct _wifi_conf c; + + printf("Input AP configuration\n"); + printf("Name : "); + rv = scanf("%32s", c.name); + if (rv <= 0) + return -1; + + printf("Security type(None(0), WEP(1), WPA-PSK(2), EAP(4) : "); + rv = scanf("%d", &c.type); + if (rv <= 0) + return -1; + + rv = wifi_manager_config_foreach_configuration(wifi, _test_config_list_cb_for_remove, &c); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("Fail to get configurations [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + + return 1; +} + +int test_wifi_manager_tdls_disconnect(void) +{ + int rv = 0; + + char peer_mac[18]; + printf("Enter Mac_address: "); + if (scanf(" %17s", peer_mac) < 1) + return -1; + + if (strlen(peer_mac) > 17) { + printf("Wrong Mac_address\n"); + return -1; + } + + rv = wifi_manager_tdls_disconnect(wifi, peer_mac); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("test_wifi_tdls_disconnect() is failed [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + return 1; +} + +int test_wifi_manager_tdls_get_connected_peer(void) +{ + int rv = 0; + char *mac_addr = NULL; + + rv = wifi_manager_tdls_get_connected_peer(wifi, &mac_addr); + if (rv != WIFI_MANAGER_ERROR_NONE) { + printf("wifi_manager_tdls_get_connected_peer() is failed [%s]\n", __test_convert_error_to_string(rv)); + return -1; + } + printf("Peer Mac address is [%s]\n", mac_addr); + g_free(mac_addr); + return 1; +} + +int main(int argc, char **argv) +{ + GMainLoop *mainloop; +#if !GLIB_CHECK_VERSION(2, 36, 0) + g_type_init(); +#endif + mainloop = g_main_loop_new(NULL, FALSE); + + GIOChannel *channel = g_io_channel_unix_new(0); + g_io_add_watch(channel, (G_IO_IN|G_IO_ERR|G_IO_HUP|G_IO_NVAL), test_thread, NULL); + + printf("Test Thread created...\n"); + + g_main_loop_run(mainloop); + + return 0; +} + +gboolean test_thread(GIOChannel *source, GIOCondition condition, gpointer data) +{ + int rv; + char a[10]; + + printf("Event received from stdin\n"); + + rv = read(0, a, 10); + + if (rv <= 0 || a[0] == '0') { + rv = wifi_manager_deinitialize(wifi); + + if (rv != WIFI_MANAGER_ERROR_NONE) + printf("Fail to deinitialize.\n"); + + exit(1); + } + + if (a[0] == '\n' || a[0] == '\r') { + printf("\n\n Network Connection API Test App\n\n"); + printf("Options..\n"); + printf(LOG_GREEN "1 - Wi-Fi init and set callbacks\n" LOG_END); + printf("2 - Wi-Fi deinit(unset callbacks automatically)\n"); + printf(LOG_GREEN "3 - Activate Wi-Fi device\n" LOG_END); + printf("4 - Deactivate Wi-Fi device\n"); + printf("5 - Is Wi-Fi activated?\n"); + printf("6 - Get connection state\n"); + printf("7 - Get MAC address\n"); + printf("8 - Get Wi-Fi interface name\n"); + printf(LOG_GREEN "9 - Scan request\n" LOG_END); + printf("a - Get Connected AP\n"); + printf("b - Get AP list\n"); + printf(LOG_GREEN "c - Connect\n" LOG_END); + printf("d - Disconnect\n"); + printf("e - Connect by wps pbc\n"); + printf("f - Forget an AP\n"); + printf("g - Set & connect EAP\n"); + printf("h - Set IP method type\n"); + printf("i - Set Proxy method type\n"); + printf("j - Get Ap info\n"); + printf("k - Connect Specific AP\n"); + printf("l - Load configuration\n"); + printf("m - Save configuration\n"); + printf("n - Remove configuration\n"); + printf("o - TDLS TearDown\n"); + printf("p - TDLS Get Connected Peer\n"); + printf(LOG_RED "0 - Exit \n" LOG_END); + + printf("ENTER - Show options menu.......\n"); + } + + switch (a[0]) { + case '1': + rv = test_wifi_manager_init(); + break; + case '2': + rv = test_wifi_manager_deinit(); + break; + case '3': + rv = test_wifi_manager_activate(); + break; + case '4': + rv = test_wifi_manager_deactivate(); + break; + case '5': + rv = test_wifi_manager_is_activated(); + break; + case '6': + rv = test_wifi_manager_get_connection_state(); + break; + case '7': + rv = test_wifi_manager_get_mac_address(); + break; + case '8': + rv = test_wifi_manager_get_interface_name(); + break; + case '9': + rv = test_wifi_manager_scan(); + break; + case 'a': + rv = test_wifi_manager_get_connected_ap(); + break; + case 'b': + rv = test_wifi_manager_foreach_found_ap(); + break; + case 'c': + rv = test_wifi_manager_connect(); + break; + case 'd': + rv = test_wifi_manager_disconnect(); + break; + case 'e': + rv = test_wifi_manager_connect_wps(); + break; + case 'f': + rv = test_wifi_manager_forget_ap(); + break; + case 'g': + rv = test_wifi_manager_connect_eap_ap(); + break; + case 'h': + rv = test_wifi_manager_set_ip_method(); + break; + case 'i': + rv = test_wifi_manager_set_proxy_method(); + break; + case 'j': + rv = test_wifi_manager_get_ap_info(); + break; + case 'k': + rv = test_wifi_manager_connect_specific_ap(); + break; + case 'l': + rv = test_wifi_manager_config_load_configuration(); + break; + case 'm': + rv = test_wifi_manager_config_save(); + break; + case 'n': + rv = test_wifi_manager_config_remove(); + break; + case 'o': + rv = test_wifi_manager_tdls_disconnect(); + break; + case 'p': + rv = test_wifi_manager_tdls_get_connected_peer(); + break; + + default: + break; + } + + if (rv == 1) + printf("Operation succeeded!\n"); + else + printf("Operation failed!\n"); + + return TRUE; +} + -- 2.7.4