INSTALL(FILES "${CMAKE_CURRENT_SOURCE_DIR}/sysinfo-softap.xml" DESTINATION "/etc/config/connectivity")
ENDIF(NOT "${ARCH}" STREQUAL "emul")
-#ADD_SUBDIRECTORY(test)
+ADD_SUBDIRECTORY(test)
IF(UNIX)
*/
typedef void * softap_h;
+#ifndef TIZEN_ERROR_SOFTAP
+#define TIZEN_ERROR_SOFTAP -0x03200000
+#endif
+
/**
* @brief Enumeration for the softap.
* @since_tizen 3.0
SOFTAP_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
SOFTAP_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
SOFTAP_ERROR_RESOURCE_BUSY = TIZEN_ERROR_RESOURCE_BUSY, /**< Resource busy */
- SOFTAP_ERROR_NOT_ENABLED = TIZEN_ERROR_TETHERING | 0x0501, /**< Not enabled */
- SOFTAP_ERROR_OPERATION_FAILED = TIZEN_ERROR_TETHERING | 0x0502, /**< Operation failed */
+ SOFTAP_ERROR_OPERATION_FAILED = TIZEN_ERROR_SOFTAP | 0x0501, /**< Operation failed */
SOFTAP_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION, /**< Invalid operation */
SOFTAP_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< API is not supported */
SOFTAP_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */
} softap_error_e;
/**
- * @brief Enumeration for the cause of disabling the SOFTAP.
+ * @brief Enumeration for the cause of disabling the softap.
* @since_tizen 3.0
*/
typedef enum
/**
- * @addtogroup CAPI_NETWORK_SOFTAP_WIFI_MODULE
+ * @addtogroup CAPI_NETWORK_SOFTAP_MANAGER_MODULE
* @{
*/
* @param[in] is_requested Indicates whether this change is requested
* @param[in] user_data The user data passed from softap_set_enabled_cb()
* @pre If you register callback function using softap_set_enabled_cb(), this will be invoked when the softap is enabled.
- * @see SOFTAP_enable()
- * @see SOFTAP_unset_enabled_cb()
+ * @see softap_enable()
+ * @see softap_unset_enabled_cb()
*/
typedef void (*softap_enabled_cb)(softap_error_e result, bool is_requested, void *user_data);
* @remarks @a client is valid only in this function. In order to use it outside this function, a user must copy the client with softap_client_clone().
* @param[in] client The client of which connection state is changed
* @param[in] opened @c true when connection is opened, otherwise false
- * @param[in] user_data The user data passed from softap_set_connection_state_changed_cb()
- * @pre If you register callback function using softap_set_connection_state_changed_cb(), this will be invoked when the connection state is changed.
- * @see softap_set_connection_state_changed_cb()
- * @see softap_unset_connection_state_changed_cb()
+ * @param[in] user_data The user data passed from softap_set_client_connection_state_changed_cb()
+ * @pre If you register callback function using softap_set_client_connection_state_changed_cb(), this will be invoked when the connection state is changed.
+ * @see softap_set_client_connection_state_changed_cb()
+ * @see softap_unset_client_connection_state_changed_cb()
*/
-typedef void (*softap_connection_state_changed_cb)(softap_client_h client, bool opened, void *user_data);
+typedef void (*softap_client_connection_state_changed_cb)(softap_client_h client, bool opened, void *user_data);
/**
* @brief Called when you get the connected client repeatedly.
*/
typedef bool(*softap_connected_client_cb)(softap_client_h client, void *user_data);
-/**
- * @brief Called when you get the data usage.
- * @since_tizen 3.0
- * @param[in] result The result of getting the data usage
- * @param[in] received_data The usage of received data
- * @param[in] sent_data The usage of sent data
- * @param[in] user_data The user data passed from the request function
- * @pre softap_get_data_usage() will invoked this callback.
- */
-typedef void (*softap_data_usage_cb)(softap_error_e result, unsigned long long received_data, unsigned long long sent_data, void *user_data);
-
/**
* @brief Called when the security type of Soft AP is changed.
* @since_tizen 3.0
/**
* @brief Creates the handle for softap.
* @since_tizen 3.0
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/softap
* @remarks The @a softap must be released using softap_destroy().
* @param[out] softap A handle of a new mobile ap handle on success
* @return 0 on success, otherwise a negative error value
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SOFTAP_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #SOFTAP_ERROR_NOT_SUPPORT_API API is not supported
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
+ * @retval #SOFTAP_ERROR_PERMISSION_DENIED Permission denied
* @see softap_destroy()
*/
int softap_create(softap_h *softap);
/**
* @brief Destroys the handle for softap.
* @since_tizen 3.0
- * @param[in] SOFTAP The softap handle
+ * @param[in] softap The softap handle
* @return 0 on success, otherwise a negative error value
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
- * @see SOFTAP_create()
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
+ * @see softap_create()
*/
int softap_destroy(softap_h softap);
* @param[in] softap The softap handle
* @return 0 on success, otherwise negative error value
* @retval #SOFTAP_ERROR_NONE Successful
+ * @retval #SOFTAP_ERROR_NOT_PERMITTED Operation not permitted
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
- * @post SOFTAP_enabled_cb() will be invoked.
- * @see SOFTAP_is_enabled()
- * @see SOFTAP_disable()
+ * @retval #SOFTAP_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #SOFTAP_ERROR_RESOURCE_BUSY Device or resource busy
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
+ * @post softap_enabled_cb() will be invoked.
+ * @see softap_is_enabled()
+ * @see softap_disable()
*/
int softap_enable(softap_h softap);
/**
* @return 0 on success, otherwise negative error value
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
- * @post SOFTAP_disabled_cb() will be invoked.
- * @see SOFTAP_is_enabled()
- * @see SOFTAP_enable()
+ * @retval #SOFTAP_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
+ * @post softap_disabled_cb() will be invoked.
+ * @see softap_is_enabled()
+ * @see softap_enable()
*/
int softap_disable(softap_h softap);
* @brief Checks whether the softap is enabled or not.
* @since_tizen 3.0
* @param[in] softap The softap handle
- * @return @c true if softap is enabled, \n @c false if softap is disabled
+ * @param[out] enable @c true if softap is enabled, \n @c false if softap is disabled
+ * @return 0 on success, otherwise negative error value
+ * @retval #SOFTAP_ERROR_NONE Successful
+ * @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
*/
-bool softap_is_enabled(softap_h softap);
+int softap_is_enabled(softap_h softap, bool *enable);
/**
* @brief Gets the MAC address of local device as "FC:A1:3E:D6:B1:B1".
* @since_tizen 3.0
* @remarks @a mac_address must be released using free().
- * @param[in] SOFTAP The softap handle
+ * @param[in] softap The softap handle
* @param[out] mac_address The MAC address
* @return 0 on success, otherwise a negative error value
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SOFTAP_ERROR_OUT_OF_MEMORY Out of memory
* @retval #SOFTAP_ERROR_OPERATION_FAILED Operation failed
- * @retval #SOFTAP_ERROR_NOT_ENABLED Not enabled
- * @pre The SOFTAP must be enabled.
- * @see SOFTAP_is_enabled()
- * @see SOFTAP_enable()
+ * @retval #SOFTAP_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
+ * @pre The softap must be enabled.
+ * @see softap_is_enabled()
+ * @see softap_enable()
*/
int softap_get_mac_address(softap_h softap, char **mac_address);
* @brief Gets the name of network interface (e.g. usb0).
* @since_tizen 3.0
* @remarks @a interface_name must be released using free().
- * @param[in] SOFTAP The softap handle
+ * @param[in] softap The softap handle
* @param[out] interface_name The name of the network interface
* @return 0 on success, otherwise negative error value
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SOFTAP_ERROR_OUT_OF_MEMORY Out of memory
* @retval #SOFTAP_ERROR_OPERATION_FAILED Operation failed
- * @retval #SOFTAP_ERROR_NOT_ENABLED Not enabled
- * @pre The SOFTAP must be enabled.
+ * @retval #SOFTAP_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
+ * @pre The softap must be enabled.
* @see softap_is_enabled()
* @see softap_enable()
*/
* @since_tizen 3.0
* @remarks @a ip_address must be released using free().
* @param[in] softap The softap handle
- * @param[in] type The softap type
* @param[in] address_family The address family of IP address (currently, #SOFTAP_ADDRESS_FAMILY_IPV4 is only supported)
* @param[out] ip_address The local IP address
* @return 0 on success, otherwise negative error value
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SOFTAP_ERROR_OUT_OF_MEMORY Out of memory
* @retval #SOFTAP_ERROR_OPERATION_FAILED Operation failed
- * @retval #SOFTAP_ERROR_NOT_ENABLED Not enabled
- * @pre The SOFTAP must be enabled.
+ * @retval #SOFTAP_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
+ * @pre The softap must be enabled.
* @see softap_is_enabled()
* @see softap_enable()
*/
* @remarks @a gateway_address must be released using free().
* @param[in] softap The softap handle
* @param[in] address_family The address family of IP address (currently, #SOFTAP_ADDRESS_FAMILY_IPV4 is only supported)
- * @param[out] gateway_address The local IP address
+ * @param[out] gateway_address Gateway address
* @return 0 on success, otherwise negative error value
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SOFTAP_ERROR_OUT_OF_MEMORY Out of memory
* @retval #SOFTAP_ERROR_OPERATION_FAILED Operation failed
- * @retval #SOFTAP_ERROR_NOT_ENABLED Not enabled
+ * @retval #SOFTAP_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
* @pre The softap must be enabled.
* @see softap_is_enabled()
* @see softap_enable()
* @remarks @a subnet_mask must be released using free().
* @param[in] softap The softap handle
* @param[in] address_family The address family of IP address (currently, #SOFTAP_ADDRESS_FAMILY_IPV4 is only supported)
- * @param[out] subnet_mask The local IP address
+ * @param[out] subnet_mask Subnet mask
* @return 0 on success, otherwise negative error value
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SOFTAP_ERROR_OUT_OF_MEMORY Out of memory
* @retval #SOFTAP_ERROR_OPERATION_FAILED Operation failed
- * @retval #SOFTAP_ERROR_NOT_ENABLED Not enabled
- * @pre The SOFTAP must be enabled.
- * @see SOFTAP_is_enabled()
- * @see SOFTAP_enable()
- */
-int softap_get_subnet_mask(softap_h softap, softap_address_family_e address_family, char **subnet_mask);
-
-/**
- * @brief Gets the data usage.
- * @since_tizen 3.0
- * @param[in] softap The softap handle
- * @param[out] usage The data usage
- * @return 0 on success, otherwise negative error value
- * @retval #SOFTAP_ERROR_NONE Successful
- * @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #SOFTAP_ERROR_OPERATION_FAILED Operation failed
- * @retval #SOFTAP_ERROR_NOT_ENABLED Not enabled
+ * @retval #SOFTAP_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
* @pre The softap must be enabled.
* @see softap_is_enabled()
* @see softap_enable()
*/
-int softap_get_data_usage(softap_h softap, softap_data_usage_cb callback, void *user_data);
+int softap_get_subnet_mask(softap_h softap, softap_address_family_e address_family, char **subnet_mask);
/**
* @brief Gets the clients which are connected.
* @param[in] user_data The user data to be passed to the callback function
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #SOFTAP_ERROR_NOT_ENABLED Not enabled
+ * @retval #SOFTAP_ERROR_INVALID_OPERATION Invalid operation
* @retval #SOFTAP_ERROR_OPERATION_FAILED Operation failed
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
* @pre The softap must be enabled.
* @see softap_is_enabled()
* @see softap_enable()
* @param[in] user_data The user data to be passed to the callback function
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
- * @see SOFTAP_unset_enabled_cb()
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
+ * @see softap_unset_enabled_cb()
*/
int softap_set_enabled_cb(softap_h softap, softap_enabled_cb callback, void *user_data);
* @param[in] softap The softap handle
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
* @see softap_set_enabled_cb()
*/
int softap_unset_enabled_cb(softap_h softap);
* @param[in] user_data The user data to be passed to the callback function
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
* @see softap_unset_disabled_cb()
*/
int softap_set_disabled_cb(softap_h softap, softap_disabled_cb callback, void *user_data);
* @param[in] softap The softap handle
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
- * @see SOFTAP_set_disabled_cb()
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
+ * @see softap_set_disabled_cb()
*/
int softap_unset_disabled_cb(softap_h softap);
* @param[in] user_data The user data to be passed to the callback function
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
- * @see softap_unset_connection_state_changed_cb_cb()
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
+ * @see softap_unset_client_connection_state_changed_cb()
*/
-int softap_set_connection_state_changed_cb(softap_h softap, softap_connection_state_changed_cb callback, void *user_data);
+int softap_set_client_connection_state_changed_cb(softap_h softap, softap_client_connection_state_changed_cb callback, void *user_data);
/**
* @brief Unregisters the callback function, which is called when the state of connection is changed.
* @param[in] softap The softap handle
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
- * @see softap_set_connection_state_changed_cb()
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
+ * @see softap_set_client_connection_state_changed_cb()
*/
-int softap_unset_connection_state_changed_cb(softap_h softap);
+int softap_unset_client_connection_state_changed_cb(softap_h softap);
/**
* @brief Registers the callback function, which is called when the security type of softap is changed.
* @param[in] user_data The user data to be passed to the callback function
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
* @see softap_unset_security_type_changed_cb()
*/
int softap_set_security_type_changed_cb(softap_h softap, softap_security_type_changed_cb callback, void *user_data);
* @brief Unregisters the callback function, which is called when the security type of softap is changed.
* @since_tizen 3.0
* @param[in] softap The softap handle
- * @param[in] type The SOFTAP type
+ * @param[in] type The softap type
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
* @see softap_set_security_type_changed_cb()
*/
int softap_unset_security_type_changed_cb(softap_h softap);
* @param[in] user_data The user data to be passed to the callback function
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
* @see softap_unset_ssid_visibility_changed_cb_cb()
*/
int softap_set_ssid_visibility_changed_cb(softap_h softap, softap_ssid_visibility_changed_cb callback, void *user_data);
* @param[in] softap The softap handle
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
- * @see SOFTAP_wifi_set_ssid_visibility_changed_cb()
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
+ * @see softap_wifi_set_ssid_visibility_changed_cb()
*/
int softap_unset_ssid_visibility_changed_cb(softap_h softap);
* @param[in] user_data The user data to be passed to the callback function
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
* @see softap_unset_passphrase_changed_cb()
*/
int softap_set_passphrase_changed_cb(softap_h softap, softap_passphrase_changed_cb callback, void *user_data);
* @param[in] softap The softap handle
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
* @see softap_set_passphrase_changed_cb()
*/
int softap_unset_passphrase_changed_cb(softap_h softap);
*/
/**
- * @addtogroup CAPI_NETWORK_SOFTAP_CLIENT_MODULE
+ * @addtogroup CAPI_NETWORK_SOFTAP_MANAGER_MODULE
* @{
*/
* @brief Sets the security type of softap.
* @details If security type is not set, WPA2_PSK is used.
* @since_tizen 3.0
+ * @remarks This change is applied next time softap is enabled. \
+ * You can use softap_enable() or softap_reload_settings() to enable softap.
* @param[in] softap The softap handle
* @param[in] type The security type
* @return 0 on success, otherwise negative error value
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SOFTAP_ERROR_OPERATION_FAILED Operation failed
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
* @see softap_wifi_ap_get_security_type()
*/
int softap_set_security_type(softap_h softap, softap_security_type_e type);
/**
- * @brief Gets the security type of Wi-Fi AP.
+ * @brief Gets the security type of Soft AP.
* @details If security type is not set, WPA2_PSK is used.
* @since_tizen 3.0
* @param[in] softap The softap handle
* @return 0 on success, otherwise negative error value
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
* @see softap_wifi_ap_set_security_type()
*/
int softap_get_security_type(softap_h softap, softap_security_type_e *type);
/**
- * @brief Sets the SSID (service set identifier) for Wi-Fi AP.
+ * @brief Sets the SSID (service set identifier) for Soft AP.
* @details The SSID cannot exceed 32 bytes. If SSID is not set, device name is used as SSID.
* @since_tizen 3.0
+ * @remarks This change is applied next time softap is enabled. \
+ * You can use softap_enable() or softap_reload_settings() to enable softap.
* @param[in] softap The softap handle
* @param[in] ssid The SSID
* @return 0 on success, otherwise negative error value
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SOFTAP_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
*/
int softap_set_ssid(softap_h softap, const char *ssid);
/**
- * @brief Gets the SSID (service set identifier) for Wi-Fi AP.
+ * @brief Gets the SSID (service set identifier) for Soft AP.
* @details If SSID is not set, Device name is used as SSID.
* @since_tizen 3.0
* @remarks @a ssid must be released using free().
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SOFTAP_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
*/
int softap_get_ssid(softap_h softap, char **ssid);
/**
- * @brief Sets the visibility of SSID (service set identifier) for Wi-Fi AP.
+ * @brief Sets the visibility of SSID (service set identifier) for Soft AP.
* @details If you set the visibility to invisible, then the SSID of this device is hidden and Wi-Fi scan won't find your device.
* @details By default visibility is set to @c true.
* @since_tizen 3.0
- * @remarks This change is applied next time Wi-Fi SOFTAP is enabled.
+ * @remarks This change is applied next time softap is enabled. \
+ * You can use softap_enable() or softap_reload_settings() to enable softap.
* @param[in] softap The softap handle
* @param[in] visible The visibility of SSID: (@c true = visible, @c false = invisible)
* @return 0 on success, otherwise negative error value
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SOFTAP_ERROR_OPERATION_FAILED Operation failed
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
* @see softap_get_ssid_visibility()
*/
int softap_set_ssid_visibility(softap_h softap, bool visible);
/**
- * @brief Gets the visibility of SSID (service set identifier) for Wi-Fi AP.
+ * @brief Gets the visibility of SSID (service set identifier) for Soft AP.
* @details If the visibility is set to invisible, then the SSID of this device is hidden and Wi-Fi scan won't find your device.
* @details By default visibility is set to @c true.
* @since_tizen 3.0
* @return 0 on success, otherwise negative error value
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
* @see softap_set_ssid_visibility()
*/
-int softap_ap_get_ssid_visibility(softap_h softap, bool *visible);
+int softap_get_ssid_visibility(softap_h softap, bool *visible);
/**
- * @brief Sets the passphrase for Wi-Fi AP.
+ * @brief Sets the passphrase for Soft AP.
* @details If the passphrase is not set, random string of 8 characters will be used.
* @since_tizen 3.0
+ * @remarks This change is applied next time softap is enabled. \
+ * You can use softap_enable() or softap_reload_settings() to enable softap.
* @param[in] softap The softap handle
* @param[in] passphrase The passphrase
* @return 0 on success, otherwise negative error value
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
* @see softap_get_passphrase()
*/
int softap_set_passphrase(softap_h softap, const char *passphrase);
/**
- * @brief Gets the passphrase for Wi-Fi AP.
+ * @brief Gets the passphrase for Soft AP.
* @details If the passphrase is not set, random string of 8 characters will be used.
* @since_tizen 3.0
* @remarks @a passphrase must be released using free().
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SOFTAP_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
* @see softap_set_passphrase()
*/
int softap_get_passphrase(softap_h softap, char **passphrase);
/**
- * @brief Reloads the settings (SSID / Passphrase / Security type / SSID visibility) for Wi-Fi AP.
+ * @brief Reloads the settings (SSID / Passphrase / Security type / SSID visibility) for Soft AP.
* @since_tizen 3.0
* @remarks Devices connected via MobileAP will be disconnected when the settings are reloaded.
* @param[in] softap The softap handle
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SOFTAP_ERROR_OPERATION_FAILED Operation failed
+ * @retval #SOFTAP_ERROR_RESOURCE_BUSY Device or resource busy
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
*/
int softap_reload_settings(softap_h softap, softap_settings_reloaded_cb callback, void *user_data);
/**
/**
* @brief Clones the handle of a client.
* @since_tizen 3.0
- * @remarks @a dest must be release using SOFTAP_client_destroy().
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/softap
+ * @remarks @a dest must be release using softap_client_destroy().
* @param[out] dest The cloned client handle
* @param[in] origin The origin client handle
* @return 0 on success, otherwise a negative error value
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SOFTAP_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #SOFTAP_ERROR_PERMISSION_DENIED Permission denied
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
* @see softap_client_destroy()
*/
int softap_client_clone(softap_client_h *dest, softap_client_h origin);
* @return 0 on success, otherwise a negative error value
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
- * @see SOFTAP_client_clone()
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
+ * @see softap_client_clone()
*/
int softap_client_destroy(softap_client_h client);
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SOFTAP_ERROR_OUT_OF_MEMORY Out of memory
- * @see SOFTAP_usb_get_connected_client()
- * @see SOFTAP_connection_state_changed_cb()
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
+ * @see softap_client_connection_state_changed_cb()
*/
int softap_client_get_name(softap_client_h client, char **name);
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SOFTAP_ERROR_OUT_OF_MEMORY Out of memory
- * @see SOFTAP_usb_get_connected_client()
- * @see SOFTAP_connection_state_changed_cb()
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
+ * @see softap_client_connection_state_changed_cb()
*/
int softap_client_get_ip_address(softap_client_h client, softap_address_family_e address_family, char **ip_address);
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #SOFTAP_ERROR_OUT_OF_MEMORY Out of memory
- * @see SOFTAP_usb_get_connected_client()
- * @see SOFTAP_connection_state_changed_cb()
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
+ * @see softap_client_connection_state_changed_cb()
*/
int softap_client_get_mac_address(softap_client_h client, char **mac_address);
* @return 0 on success, otherwise a negative error value
* @retval #SOFTAP_ERROR_NONE Successful
* @retval #SOFTAP_ERROR_INVALID_PARAMETER Invalid parameter
- * @see SOFTAP_usb_get_connected_client()
- * @see SOFTAP_connection_state_changed_cb()
+ * @retval #SOFTAP_ERROR_NOT_SUPPORTED API is not supported
+ * @see softap_client_connection_state_changed_cb()
*/
int softap_client_get_time(softap_client_h client, time_t *timestamp);
"http://standards.freedesktop.org/dbus/1.0/introspect.dtd">
<node>
- <interface name="org.tizen.tethering">
+ <interface name="org.tizen.softap">
<!-- Method definitions -->
<arg type="s" name="arg1" direction="out"/>
</signal>
- <signal name="wifi_ap_on">
+ <signal name="no_data_timeout">
<arg type="s" name="arg1" direction="out"/>
</signal>
- <signal name="wifi_ap_off">
+ <signal name="low_batt_mode">
<arg type="s" name="arg1" direction="out"/>
</signal>
- <signal name="no_data_timeout">
+ <signal name="flight_mode">
<arg type="s" name="arg1" direction="out"/>
</signal>
- <signal name="low_batt_mode">
+ <signal name="soft_ap_on">
<arg type="s" name="arg1" direction="out"/>
</signal>
- <signal name="flight_mode">
+ <signal name="soft_ap_off">
<arg type="s" name="arg1" direction="out"/>
</signal>
} mobile_ap_event_e;
typedef enum {
- MOBILE_AP_TYPE_WIFI,
- MOBILE_AP_TYPE_USB,
- MOBILE_AP_TYPE_BT,
- MOBILE_AP_TYPE_WIFI_AP,
- MOBILE_AP_TYPE_MAX,
-} mobile_ap_type_e;
-
-typedef enum {
- E_SIGNAL_NET_CLOSED = 0,
- E_SIGNAL_WIFI_TETHER_ON,
- E_SIGNAL_WIFI_TETHER_OFF,
- E_SIGNAL_WIFI_AP_ON = 9,
- E_SIGNAL_WIFI_AP_OFF,
- E_SIGNAL_NO_DATA_TIMEOUT,
+ E_SIGNAL_SOFTAP_ON,
+ E_SIGNAL_SOFTAP_OFF,
E_SIGNAL_LOW_BATTERY_MODE,
E_SIGNAL_FLIGHT_MODE,
E_SIGNAL_SECURITY_TYPE_CHANGED,
E_SIGNAL_MAX
} mobile_ap_sig_e;
-#define SOFTAP_SERVICE_OBJECT_PATH "/Tethering"
-#define SOFTAP_SERVICE_NAME "org.tizen.tethering"
-#define SOFTAP_SERVICE_INTERFACE "org.tizen.tethering"
+#define SOFTAP_SERVICE_OBJECT_PATH "/MobileapAgent"
+#define SOFTAP_SERVICE_NAME "org.tizen.MobileapAgent"
+#define SOFTAP_SERVICE_INTERFACE "org.tizen.softap"
-#define SOFTAP_SIGNAL_MATCH_RULE "type='signal',interface='org.tizen.tethering'"
+#define SOFTAP_SIGNAL_MATCH_RULE "type='signal',interface='org.tizen.softap'"
#define SOFTAP_SIGNAL_NAME_LEN 64
-#define SIGNAL_NAME_NET_CLOSED "net_closed"
#define SIGNAL_NAME_STA_CONNECT "sta_connected"
#define SIGNAL_NAME_STA_DISCONNECT "sta_disconnected"
-#define SIGNAL_NAME_WIFI_AP_ON "wifi_ap_on"
-#define SIGNAL_NAME_WIFI_AP_OFF "wifi_ap_off"
+#define SIGNAL_NAME_SOFTAP_ON "soft_ap_on"
+#define SIGNAL_NAME_SOFTAP_OFF "soft_ap_off"
#define SIGNAL_NAME_NO_DATA_TIMEOUT "no_data_timeout"
#define SIGNAL_NAME_LOW_BATTERY_MODE "low_batt_mode"
#define SIGNAL_NAME_FLIGHT_MODE "flight_mode"
#define SECURITY_TYPE_LEN 32
#define PSK_ITERATION_COUNT 4096
+typedef void(*__handle_cb_t)(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data);
+
+typedef struct {
+ int sig_id;
+ char name[SOFTAP_SIGNAL_NAME_LEN];
+ __handle_cb_t cb;
+} __softap_sig_t;
+
+typedef struct {
+ /* GDBus */
+ GDBusConnection *client_bus;
+ GDBusProxy *client_bus_proxy;
+ GCancellable *cancellable;
+
+ /* Callbacks*/
+ softap_enabled_cb enabled_cb;
+ void *enabled_user_data;
+ softap_disabled_cb disabled_cb;
+ void *disabled_user_data;
+ softap_client_connection_state_changed_cb changed_cb;
+ void *changed_user_data;
+ softap_security_type_changed_cb security_type_changed_cb;
+ void *security_type_user_data;
+ softap_ssid_visibility_changed_cb ssid_visibility_changed_cb;
+ void *ssid_visibility_user_data;
+ softap_passphrase_changed_cb passphrase_changed_cb;
+ void *passphrase_user_data;
+ softap_settings_reloaded_cb settings_reloaded_cb;
+ void *settings_reloaded_user_data;
+
+ /* Settings */
+ char *ssid;
+ char passphrase[SOFTAP_KEY_MAX_LEN + 1];
+ bool visibility;
+ softap_security_type_e sec_type;
+} __softap_h;
+
+typedef struct {
+ char ip[SOFTAP_STR_INFO_LEN]; /**< assigned IP address */
+ char mac[SOFTAP_STR_INFO_LEN]; /**< MAC Address */
+ char *hostname;
+ time_t tm; /**< connection time */
+} __softap_client_h;
+
+typedef struct {
+ char ssid[SOFTAP_SSID_MAX_LEN];
+ char key[SOFTAP_KEY_MAX_LEN + 1];
+ softap_security_type_e sec_type;
+ bool visibility;
+} _softap_settings_t;
+
#ifdef __cplusplus
}
#endif
Name: capi-network-softap
Summary: Softap Framework
-Version: 0.0.1
+Version: 0.0.2
Release: 1
Group: System/Network
License: Apache-2.0
%defattr(-,root,root,-)
%{_libdir}/*.so.*
/usr/share/license/capi-network-softap
-#%{_bindir}/softap_test
+%{_bindir}/softap_test
%ifarch %{arm}
/etc/config/connectivity/sysinfo-softap.xml
%else
#include <openssl/sha.h>
#include "softap_private.h"
-#if 0
-API int softap_create(softap_h *softap)
+static void __handle_softap_on(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data);
+
+static void __handle_softap_off(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data);
+
+static void __handle_low_battery_mode(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data);
+
+static void __handle_flight_mode(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data);
+
+static void __handle_security_type_changed(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data);
+
+static void __handle_ssid_visibility_changed(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data);
+
+static void __handle_passphrase_changed(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data);
+
+static void __handle_dhcp(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data);
+
+static __softap_sig_t sigs[] = {
+ {0, SIGNAL_NAME_LOW_BATTERY_MODE, __handle_low_battery_mode},
+ {0, SIGNAL_NAME_FLIGHT_MODE, __handle_flight_mode},
+ {0, SIGNAL_NAME_SECURITY_TYPE_CHANGED, __handle_security_type_changed},
+ {0, SIGNAL_NAME_SSID_VISIBILITY_CHANGED, __handle_ssid_visibility_changed},
+ {0, SIGNAL_NAME_PASSPHRASE_CHANGED, __handle_passphrase_changed},
+ {0, SIGNAL_NAME_DHCP_STATUS, __handle_dhcp},
+ {0, SIGNAL_NAME_SOFTAP_ON, __handle_softap_on},
+ {0, SIGNAL_NAME_SOFTAP_OFF, __handle_softap_off},
+ {0, "", NULL} };
+
+static int retry = 0;
+
+static int __get_common_ssid(char *ssid, unsigned int size)
{
- DBG("+\n");
+ if (ssid == NULL) {
+ ERR("ssid is null!!");
+ return SOFTAP_ERROR_INVALID_PARAMETER;
+ }
+
+ char *device_name = NULL;
+ char *end = NULL;
+
+ device_name = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
+ if (device_name == NULL) {
+ ERR("vconf_get_str is failed and set default ssid!!");
+ g_strlcpy(ssid, SOFTAP_DEFAULT_SSID, size);
+ } else
+ g_strlcpy(ssid, device_name, size);
+
+ if (!g_utf8_validate(ssid, -1, (const char **)&end))
+ *end = '\0';
return SOFTAP_ERROR_NONE;
}
+
+static int __get_initial_passphrase(char *passphrase, unsigned int size)
+{
+ if (passphrase == NULL ||
+ size == 0 || size < SOFTAP_KEY_MIN_LEN + 1)
+ return 0;
+
+ guint32 rand_int = 0;
+ int index = 0;
+
+ for (index = 0; index < SOFTAP_KEY_MIN_LEN; index++) {
+ rand_int = g_random_int_range('a', 'z');
+ passphrase[index] = rand_int;
+ }
+ passphrase[index] = '\0';
+
+ return index;
+}
+
+static softap_error_e __get_error(int agent_error)
+{
+ softap_error_e err = SOFTAP_ERROR_NONE;
+
+ switch (agent_error) {
+ case MOBILE_AP_ERROR_NONE:
+ err = SOFTAP_ERROR_NONE;
+ break;
+
+ case MOBILE_AP_ERROR_RESOURCE:
+ err = SOFTAP_ERROR_OUT_OF_MEMORY;
+ break;
+
+ case MOBILE_AP_ERROR_INTERNAL:
+ err = SOFTAP_ERROR_OPERATION_FAILED;
+ break;
+
+ case MOBILE_AP_ERROR_INVALID_PARAM:
+ err = SOFTAP_ERROR_INVALID_PARAMETER;
+ break;
+
+ case MOBILE_AP_ERROR_ALREADY_ENABLED:
+ err = SOFTAP_ERROR_OPERATION_FAILED;
+ break;
+
+ case MOBILE_AP_ERROR_NET_OPEN:
+ err = SOFTAP_ERROR_OPERATION_FAILED;
+ break;
+
+ case MOBILE_AP_ERROR_NET_CLOSE:
+ err = SOFTAP_ERROR_OPERATION_FAILED;
+ break;
+
+ case MOBILE_AP_ERROR_DHCP:
+ err = SOFTAP_ERROR_OPERATION_FAILED;
+ break;
+
+ case MOBILE_AP_ERROR_IN_PROGRESS:
+ err = SOFTAP_ERROR_OPERATION_FAILED;
+ break;
+
+ case MOBILE_AP_ERROR_NOT_PERMITTED:
+ err = SOFTAP_ERROR_NOT_PERMITTED;
+ break;
+
+ case MOBILE_AP_ERROR_PERMISSION_DENIED:
+ err = SOFTAP_ERROR_PERMISSION_DENIED;
+ break;
+
+ default:
+ ERR("Not defined error : %d\n", agent_error);
+ err = SOFTAP_ERROR_OPERATION_FAILED;
+ break;
+ }
+
+ return err;
+}
+
+static void __handle_dhcp(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data)
+{
+ DBG("+");
+
+ _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
+
+ __softap_h *sa = (__softap_h *)user_data;
+ bool opened = false;
+ softap_client_connection_state_changed_cb ccb = NULL;
+ __softap_client_h client;
+ void *data = NULL;
+ char *buf = NULL;
+ char *name = NULL;
+ char *mac = NULL;
+ char *ip = NULL;
+ guint timestamp;
+
+ memset(&client, 0, sizeof(__softap_client_h));
+ g_variant_get(parameters, "(ssssu)", &buf, &ip, &mac, &name, ×tamp);
+
+ if (!g_strcmp0(buf, "DhcpConnected")) {
+ opened = true;
+ } else if (!g_strcmp0(buf, "DhcpLeaseDeleted")) {
+ opened = false;
+ } else {
+ ERR("Unknown event [%s]", buf);
+ goto DONE;
+ }
+
+ ccb = sa->changed_cb;
+ if (ccb == NULL)
+ goto DONE;
+ data = sa->changed_user_data;
+
+ g_strlcpy(client.ip, ip, sizeof(client.ip));
+ g_strlcpy(client.mac, mac, sizeof(client.mac));
+ if (name != NULL)
+ client.hostname = g_strdup(name);
+ client.tm = (time_t)timestamp;
+
+ ccb((softap_client_h)&client, opened, data);
+ g_free(client.hostname);
+DONE:
+ g_free(buf);
+ g_free(ip);
+ g_free(mac);
+ g_free(name);
+ DBG("-");
+}
+
+static void __handle_softap_on(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data)
+{
+ DBG("+");
+
+ _retm_if(user_data == NULL, "parameter(user_data) is NULL");
+
+ __softap_h *sa = (__softap_h *)user_data;
+ bool is_requested = false;
+ softap_enabled_cb ecb = NULL;
+ void *data = NULL;
+
+ ecb = sa->enabled_cb;
+ if (ecb == NULL)
+ return;
+ data = sa->enabled_user_data;
+ ecb(SOFTAP_ERROR_NONE, is_requested, data);
+ DBG("-");
+}
+
+static void __handle_softap_off(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data)
+{
+ DBG("+");
+
+ _retm_if(user_data == NULL, "parameter(user_data) is NULL");
+
+ __softap_h *sa = (__softap_h *)user_data;
+ softap_disabled_cause_e code = SOFTAP_DISABLED_BY_OTHERS;
+ softap_disabled_cb dcb = NULL;
+ void *data = NULL;
+ char *buf = NULL;
+
+ dcb = sa->disabled_cb;
+ if (dcb == NULL)
+ return;
+ data = sa->disabled_user_data;
+ g_variant_get(parameters, "(s)", &buf);
+ if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
+ code = SOFTAP_DISABLED_BY_WIFI_ON;
+ else if (!g_strcmp0(buf, SIGNAL_MSG_TIMEOUT))
+ code = SOFTAP_DISABLED_BY_TIMEOUT;
+
+ g_free(buf);
+ dcb(SOFTAP_ERROR_NONE, code, data);
+
+ DBG("-");
+}
+
+static void __handle_low_battery_mode(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data)
+{
+ DBG("+");
+
+ _retm_if(user_data == NULL, "parameter(user_data) is NULL");
+
+ __softap_h *sa = (__softap_h *)user_data;
+ softap_disabled_cb dcb = NULL;
+ void *data = NULL;
+ softap_disabled_cause_e code = SOFTAP_DISABLED_BY_LOW_BATTERY;
+
+ dcb = sa->disabled_cb;
+ if (dcb == NULL)
+ return;
+
+ data = sa->disabled_user_data;
+
+ dcb(SOFTAP_ERROR_NONE, code, data);
+ DBG("-");
+}
+
+static void __handle_flight_mode(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data)
+{
+ DBG("+");
+
+ _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
+
+ __softap_h *sa = (__softap_h *)user_data;
+ softap_disabled_cb dcb = NULL;
+ void *data = NULL;
+ softap_disabled_cause_e code = SOFTAP_DISABLED_BY_FLIGHT_MODE;
+
+ dcb = sa->disabled_cb;
+ if (dcb == NULL)
+ return;
+ data = sa->disabled_user_data;
+
+ dcb(SOFTAP_ERROR_NONE, code, data);
+ DBG("-");
+}
+
+static void __handle_security_type_changed(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data)
+
+{
+ DBG("+");
+
+ _retm_if(user_data == NULL, "parameter(user_data) is NULL");
+ __softap_h *sa = (__softap_h *)user_data;
+
+ softap_security_type_changed_cb scb = NULL;
+ void *data = NULL;
+ softap_security_type_e security_type;
+ char *buf = NULL;
+
+ scb = sa->security_type_changed_cb;
+ if (scb == NULL)
+ return;
+
+ g_variant_get(parameters, "(s)", &buf);
+ data = sa->security_type_user_data;
+ if (g_strcmp0(buf, SOFTAP_SECURITY_TYPE_OPEN_STR) == 0)
+ security_type = SOFTAP_SECURITY_TYPE_NONE;
+ else if (g_strcmp0(buf, SOFTAP_SECURITY_TYPE_WPA2_PSK_STR) == 0)
+ security_type = SOFTAP_SECURITY_TYPE_WPA2_PSK;
+ else {
+ SERR("Unknown type : %s", buf);
+ g_free(buf);
+ return;
+ }
+ g_free(buf);
+ scb(security_type, data);
+
+ return;
+}
+
+static void __handle_ssid_visibility_changed(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data)
+{
+ DBG("+");
+
+ _retm_if(user_data == NULL, "parameter(user_data) is NULL");
+ __softap_h *sa = (__softap_h *)user_data;
+
+ softap_ssid_visibility_changed_cb scb = NULL;
+ void *data = NULL;
+ bool visible = false;
+ char *buf = NULL;
+
+ scb = sa->ssid_visibility_changed_cb;
+ if (scb == NULL) {
+ DBG("-");
+ return;
+ }
+ g_variant_get(parameters, "(s)", &buf);
+ data = sa->ssid_visibility_user_data;
+ if (g_strcmp0(buf, SIGNAL_MSG_SSID_VISIBLE) == 0)
+ visible = true;
+
+ scb(visible, data);
+ g_free(buf);
+ DBG("-");
+}
+
+static void __handle_passphrase_changed(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data)
+{
+ DBG("+");
+
+ _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
+ __softap_h *sa = (__softap_h *)user_data;
+
+ softap_passphrase_changed_cb pcb = NULL;
+ void *data = NULL;
+
+ pcb = sa->passphrase_changed_cb;
+ if (pcb == NULL)
+ return;
+
+ data = sa->passphrase_user_data;
+
+ pcb(data);
+ DBG("-");
+}
+
+static void __enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
+ gpointer user_data)
+{
+ DBG("+");
+ _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
+ __softap_h *sa = (__softap_h *)user_data;
+ GError *g_error = NULL;
+ GVariant *g_var;
+ guint info;
+ softap_error_e error;
+ softap_enabled_cb ecb = sa->enabled_cb;
+ void *data = sa->enabled_user_data;
+
+ g_var = g_dbus_proxy_call_finish(sa->client_bus_proxy, res, &g_error);
+ if (g_error) {
+ ERR("DBus error [%s]", g_error->message);
+ if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
+ ++retry < SOFTAP_ERROR_RECOVERY_MAX) {
+ g_error_free(g_error);
+ softap_enable((softap_h)sa);
+ DBG("-");
+ return;
+ }
+
+ if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ error = SOFTAP_ERROR_PERMISSION_DENIED;
+ else
+ error = SOFTAP_ERROR_OPERATION_FAILED;
+ g_error_free(g_error);
+ } else {
+ g_variant_get(g_var, "(u)", &info);
+ g_variant_unref(g_var);
+ error = __get_error(info);
+ if (error != SOFTAP_ERROR_NONE)
+ ERR("Fail to enable Soft AP (%d)!!", error);
+ }
+
+ retry = 0;
+
+ sigs[E_SIGNAL_SOFTAP_ON].sig_id = g_dbus_connection_signal_subscribe(sa->client_bus,
+ NULL, SOFTAP_SERVICE_INTERFACE, sigs[E_SIGNAL_SOFTAP_ON].name,
+ SOFTAP_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
+ sigs[E_SIGNAL_SOFTAP_ON].cb, (gpointer)sa, NULL);
+
+ DBG("[DBG] sig.id for softap on (%d)", sigs[E_SIGNAL_SOFTAP_ON].sig_id);
+
+ if (ecb)
+ ecb(error, true, data);
+
+ DBG("-");
+
+ return;
+}
+
+static void __disabled_cfm_cb(GObject *source_object, GAsyncResult *res,
+ gpointer user_data)
+{
+ DBG("+");
+ __softap_h *sa = (__softap_h *)user_data;
+ GError *g_error = NULL;
+ GVariant *g_var;
+ guint info;
+ softap_error_e error;
+ softap_disabled_cause_e code = SOFTAP_DISABLED_BY_REQUEST;
+ softap_disabled_cb dcb = sa->disabled_cb;
+ void *data = sa->disabled_user_data;
+
+ g_var = g_dbus_proxy_call_finish(sa->client_bus_proxy, res, &g_error);
+ if (g_error) {
+ ERR("DBus error [%s]", g_error->message);
+ g_error_free(g_error);
+ DBG("-");
+ return;
+ } else {
+ g_variant_get(g_var, "(u)", &info);
+ g_variant_unref(g_var);
+ error = __get_error(info);
+ if (error != SOFTAP_ERROR_NONE)
+ ERR("Fail to disable Soft AP (%d)!!", error);
+ }
+
+ sigs[E_SIGNAL_SOFTAP_OFF].sig_id = g_dbus_connection_signal_subscribe(sa->client_bus,
+ NULL, SOFTAP_SERVICE_INTERFACE, sigs[E_SIGNAL_SOFTAP_OFF].name,
+ SOFTAP_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
+ sigs[E_SIGNAL_SOFTAP_OFF].cb, (gpointer)sa, NULL);
+
+ if (dcb)
+ dcb(error, code, data);
+
+ DBG("-");
+ return;
+}
+
+static int __prepare_softap_settings(softap_h softap, _softap_settings_t *set)
+{
+ DBG("+");
+
+ __softap_h *sa = (__softap_h *) softap;
+
+ if (sa == NULL || set == NULL) {
+ ERR("Parameter is NULL!!");
+ return SOFTAP_ERROR_INVALID_PARAMETER;
+ }
+
+ g_strlcpy(set->ssid, sa->ssid, sizeof(set->ssid));
+ set->sec_type = sa->sec_type;
+ set->visibility = sa->visibility;
+
+ if (set->sec_type == SOFTAP_SECURITY_TYPE_NONE)
+ g_strlcpy(set->key, "", sizeof(set->key));
+ else
+ g_strlcpy(set->key, sa->passphrase, sizeof(set->key));
+
+ DBG("-");
+ return SOFTAP_ERROR_NONE;
+}
+
+static void __connect_signals(softap_h softap)
+{
+ DBG("+");
+ _retm_if(softap == NULL, "parameter(softap) is NULL");
+
+ __softap_h *sa = (__softap_h *)softap;
+ GDBusConnection *connection = sa->client_bus;
+ int i = 0;
+
+ for (i = E_SIGNAL_SOFTAP_ON; i < E_SIGNAL_MAX; i++) {
+ sigs[i].sig_id = g_dbus_connection_signal_subscribe(connection,
+ NULL,SOFTAP_SERVICE_INTERFACE, sigs[i].name,
+ SOFTAP_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
+ sigs[i].cb, softap, NULL);
+ }
+ DBG("-");
+}
+
+static void __disconnect_signals(softap_h softap)
+{
+ DBG("+");
+
+ _retm_if(softap == NULL, "parameter(softap) is NULL\n");
+
+ __softap_h *sa = (__softap_h *)softap;
+ GDBusConnection *connection = sa->client_bus;
+
+ int i = 0;
+
+ for (i = E_SIGNAL_SOFTAP_ON; i < E_SIGNAL_MAX; i++)
+ g_dbus_connection_signal_unsubscribe(connection, sigs[i].sig_id);
+ DBG("-");
+}
+
+API int softap_create(softap_h *softap)
+{
+ DBG("+");
+
+ __softap_h *sa = NULL;
+ GError *error = NULL;
+ char ssid[SOFTAP_SSID_MAX_LEN + 1] = {0, };
+
+ sa = (__softap_h *) malloc(sizeof(__softap_h));
+
+ memset(sa, 0x00, sizeof(__softap_h));
+
+ sa->visibility = true;
+ sa->sec_type = SOFTAP_SECURITY_TYPE_WPA2_PSK;
+
+ if (__get_common_ssid(ssid, sizeof(ssid)) != SOFTAP_ERROR_NONE) {
+ ERR("Fail to get default ssid!!");
+ free(sa);
+ return SOFTAP_ERROR_OPERATION_FAILED;
+ }
+
+ if (__get_initial_passphrase(sa->passphrase, sizeof(sa->passphrase)) == 0) {
+ ERR("Fail to generate random passphrase!!");
+ free(sa);
+ return SOFTAP_ERROR_OPERATION_FAILED;
+ }
+
+ sa->ssid = g_strdup(ssid);
+ if (sa->ssid == NULL) {
+ ERR("Fail to get default ssid!!");
+ free(sa);
+ return SOFTAP_ERROR_OPERATION_FAILED;
+ }
+
+ /* GDbus Setting */
+#if !GLIB_CHECK_VERSION(2, 36, 0)
+ g_type_init();
#endif
+ GCancellable *cancellable = g_cancellable_new();
+ sa->client_bus = g_bus_get_sync(DBUS_BUS_SYSTEM, cancellable, &error);
+ if (error) {
+ ERR("Couldn't connect to the System bus[%s]", error->message);
+ g_error_free(error);
+ g_cancellable_cancel(cancellable);
+ g_object_unref(cancellable);
+ free(sa);
+ return SOFTAP_ERROR_OPERATION_FAILED;
+ }
+ sa->cancellable = cancellable;
+
+ sa->client_bus_proxy = g_dbus_proxy_new_sync(sa->client_bus, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, SOFTAP_SERVICE_NAME, SOFTAP_SERVICE_OBJECT_PATH,
+ SOFTAP_SERVICE_INTERFACE, sa->cancellable, &error);
+ if (!sa->client_bus_proxy) {
+ ERR("Fail to create the proxy object because of %s", error->message);
+ g_cancellable_cancel(sa->cancellable);
+ g_object_unref(sa->cancellable);
+ free(sa);
+ return SOFTAP_ERROR_OPERATION_FAILED;
+ }
+
+ __connect_signals((softap_h)sa);
+
+ DBG("[DBG] create sig.id for softap on (%d)", sigs[E_SIGNAL_SOFTAP_ON].sig_id);
+
+ *softap = (softap_h) sa;
+ DBG("SoftAP Handle[0x%X] SSID[%s] Passphrase[%s] Security[%d] Visibilit[%d]",
+ sa, sa->ssid, sa->passphrase, sa->sec_type, sa->visibility);
+ DBG("-");
+
+ return SOFTAP_ERROR_NONE;
+}
+
+API int softap_destroy(softap_h softap)
+{
+ DBG("+");
+
+ _retvm_if(softap == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(softap) is NULL\n");
+
+ __softap_h *sa = (__softap_h *)softap;
+
+ DBG("SoftAP Handle : 0x%X\n", sa);
+ __disconnect_signals(softap);
+
+ if (sa->ssid)
+ free(sa->ssid);
+
+ g_object_unref(sa->cancellable);
+ g_object_unref(sa->client_bus_proxy);
+ g_object_unref(sa->client_bus);
+ memset(sa, 0x00, sizeof(__softap_h));
+ free(sa);
+
+ DBG("-");
+ return SOFTAP_ERROR_NONE;
+}
+
+API int softap_enable(softap_h softap)
+{
+ DBG("+");
+ _retvm_if(softap == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(softap) is NULL");
+
+ softap_error_e ret = SOFTAP_ERROR_NONE;
+ __softap_h *sa = (__softap_h *) softap;
+ GDBusProxy *proxy = sa->client_bus_proxy;
+// GDBusConnection *connection = sa->client_bus;
+
+ g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
+
+ _softap_settings_t set = {"", "", 0, false};
+
+ ret = __prepare_softap_settings(softap, &set);
+ if (ret != SOFTAP_ERROR_NONE) {
+ ERR("Fail to initialize softap settings\n");
+ return SOFTAP_ERROR_OPERATION_FAILED;
+ }
+
+ g_dbus_connection_signal_unsubscribe(sa->client_bus, sigs[E_SIGNAL_SOFTAP_ON].sig_id);
+ DBG("[DBG] unsubscribe sig.id for softap on (%d)", sigs[E_SIGNAL_SOFTAP_ON].sig_id);
+
+ g_dbus_proxy_call(proxy, "enable",
+ g_variant_new("(ssii)", set.ssid, set.key, set.visibility, set.sec_type),
+ G_DBUS_CALL_FLAGS_NONE, -1, sa->cancellable, (GAsyncReadyCallback) __enabled_cfm_cb, (gpointer)softap);
+
+ g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
+ DBG("-");
+
+ return SOFTAP_ERROR_NONE;
+}
+
+API int softap_disable(softap_h softap)
+{
+ DBG("+");
+ _retvm_if(softap == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(softap) is NULL");
+
+ __softap_h *sa = (__softap_h *) softap;
+ GDBusProxy *proxy = sa->client_bus_proxy;
+ GDBusConnection *connection = sa->client_bus;
+
+ g_dbus_connection_signal_unsubscribe(connection, sigs[E_SIGNAL_SOFTAP_OFF].sig_id);
+
+ g_dbus_proxy_call(proxy, "disable",
+ NULL, G_DBUS_CALL_FLAGS_NONE, -1, sa->cancellable,
+ (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)softap);
+
+ DBG("-");
+ return SOFTAP_ERROR_NONE;
+}
+
+API int softap_is_enabled(softap_h softap, bool *enable)
+{
+ DBG("+");
+ _retvm_if(softap == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(softap) is NULL");
+
+ int is_on = 0;
+ int vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI_AP;
+
+ if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &is_on) != 0) {
+ ERR("Fail to get vconf key!!");
+ return SOFTAP_ERROR_OPERATION_FAILED;
+ }
+
+ *enable = is_on & vconf_type ? true : false;
+
+ DBG("-");
+ return SOFTAP_ERROR_NONE;
+}
+
+API int softap_get_mac_address(softap_h softap, char **mac_address)
+{
+ DBG("+");
+ _retvm_if(softap == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(softap) is NULL\n");
+ _retvm_if(mac_address == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(mac_address) is NULL\n");
+
+ struct ifreq ifr;
+ int ret = SOFTAP_ERROR_NONE;
+ int s = 0;
+ char *macbuf = NULL;
+ bool enabled = false;
+
+ ret = softap_is_enabled(softap, &enabled);
+ _retvm_if(ret != SOFTAP_ERROR_NONE, SOFTAP_ERROR_OPERATION_FAILED, "Fail to check softap is enabled!!\n");
+ _retvm_if(enabled == false, SOFTAP_ERROR_NOT_PERMITTED, "Soft AP is not enabled\n");
+
+ g_strlcpy(ifr.ifr_name, SOFTAP_IF, sizeof(ifr.ifr_name));
+ s = socket(AF_INET, SOCK_DGRAM, 0);
+ _retvm_if(s < 0, SOFTAP_ERROR_OPERATION_FAILED,
+ "Fail to get socket!!\n");
+
+ if (ioctl(s, SIOCGIFHWADDR, &ifr) < 0) {
+ ERR("Fail to get mac address!!");
+ close(s);
+ return SOFTAP_ERROR_OPERATION_FAILED;
+ }
+
+ close(s);
+
+ macbuf = (char *)malloc(SOFTAP_STR_INFO_LEN);
+ _retvm_if(macbuf == NULL, SOFTAP_ERROR_OUT_OF_MEMORY, "Not enough memory\n");
+
+ snprintf(macbuf, SOFTAP_STR_INFO_LEN, "%02X:%02X:%02X:%02X:%02X:%02X",
+ (unsigned char)ifr.ifr_hwaddr.sa_data[0],
+ (unsigned char)ifr.ifr_hwaddr.sa_data[1],
+ (unsigned char)ifr.ifr_hwaddr.sa_data[2],
+ (unsigned char)ifr.ifr_hwaddr.sa_data[3],
+ (unsigned char)ifr.ifr_hwaddr.sa_data[4],
+ (unsigned char)ifr.ifr_hwaddr.sa_data[5]);
+
+ *mac_address = macbuf;
+
+ DBG("-");
+ return SOFTAP_ERROR_NONE;
+}
+
+API int softap_get_network_interface_name(softap_h softap, char **interface_name)
+{
+ DBG("+");
+ _retvm_if(softap == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(softap) is NULL\n");
+ _retvm_if(interface_name == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(interface_name) is NULL\n");
+
+ int ret = SOFTAP_ERROR_NONE;
+ bool enabled = false;
+
+ ret = softap_is_enabled(softap, &enabled);
+ _retvm_if(ret != SOFTAP_ERROR_NONE, SOFTAP_ERROR_OPERATION_FAILED, "Fail to check softap is enabled!!\n");
+ _retvm_if(enabled == false, SOFTAP_ERROR_NOT_PERMITTED, "Soft AP is not enabled\n");
+
+ *interface_name = strdup(SOFTAP_IF);
+ _retvm_if(*interface_name == NULL, SOFTAP_ERROR_OUT_OF_MEMORY,
+ "Not enough memory!!\n");
+
+ DBG("-");
+ return SOFTAP_ERROR_NONE;
+}
+
+API int softap_get_ip_address(softap_h softap, softap_address_family_e address_family, char **ip_address)
+{
+ DBG("+");
+ _retvm_if(softap == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(softap) is NULL\n");
+ _retvm_if(ip_address == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(ip_address) is NULL\n");
+
+ struct ifreq ifr;
+ int ret = SOFTAP_ERROR_NONE;
+ int s = 0;
+ bool enabled = false;
+ char *ipbuf = NULL;
+
+ ret = softap_is_enabled(softap, &enabled);
+ _retvm_if(ret != SOFTAP_ERROR_NONE, SOFTAP_ERROR_OPERATION_FAILED, "Fail to check softap is enabled!!\n");
+ _retvm_if(enabled == false, SOFTAP_ERROR_NOT_PERMITTED, "Soft AP is not enabled\n");
+
+ g_strlcpy(ifr.ifr_name, SOFTAP_IF, sizeof(ifr.ifr_name));
+ s = socket(AF_INET, SOCK_DGRAM, 0);
+ _retvm_if(s < 0, SOFTAP_ERROR_OPERATION_FAILED, "Fail to get socket!!\n");
+
+ if (ioctl(s,SIOCGIFADDR, &ifr) < 0) {
+ ERR("Fail to get interface name!!");
+ close(s);
+ return SOFTAP_ERROR_OPERATION_FAILED;
+ }
+
+ close(s);
+
+ ipbuf = inet_ntoa(((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr);
+ *ip_address = strdup(ipbuf);
+ _retvm_if(*ip_address == NULL, SOFTAP_ERROR_OUT_OF_MEMORY,
+ "Not enough memory\n");
+
+ DBG("-");
+ return SOFTAP_ERROR_NONE;
+}
+
+API int softap_get_gateway_address(softap_h softap, softap_address_family_e address_family, char **gateway_address)
+{
+ DBG("+");
+ _retvm_if(softap == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(softap) is NULL\n");
+ _retvm_if(gateway_address == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(gateway_address) is NULL\n");
+
+ int ret = SOFTAP_ERROR_NONE;
+ bool enabled = false;
+
+ ret = softap_is_enabled(softap, &enabled);
+ _retvm_if(ret != SOFTAP_ERROR_NONE, SOFTAP_ERROR_OPERATION_FAILED, "Fail to check softap is enabled!!\n");
+ _retvm_if(enabled == false, SOFTAP_ERROR_NOT_PERMITTED, "Soft AP is not enabled\n");
+
+ *gateway_address = strdup(SOFTAP_GATEWAY);
+
+ DBG("-");
+ return SOFTAP_ERROR_NONE;
+}
+
+API int softap_get_subnet_mask(softap_h softap, softap_address_family_e address_family, char **subnet_mask)
+{
+ DBG("+");
+ _retvm_if(softap == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(softap) is NULL\n");
+ _retvm_if(subnet_mask == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(subnet_mask) is NULL\n");
+
+ int ret = SOFTAP_ERROR_NONE;
+ bool enabled = false;
+
+ ret = softap_is_enabled(softap, &enabled);
+ _retvm_if(ret != SOFTAP_ERROR_NONE, SOFTAP_ERROR_OPERATION_FAILED, "Fail to check softap is enabled!!\n");
+ _retvm_if(enabled == false, SOFTAP_ERROR_NOT_PERMITTED, "Soft AP is not enabled\n");
+
+ *subnet_mask = strdup(SOFTAP_SUBNET_MASK);
+
+ DBG("-");
+ return SOFTAP_ERROR_NONE;
+}
+
+API int softap_set_enabled_cb(softap_h softap, softap_enabled_cb callback, void *user_data)
+{
+ _retvm_if(softap == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(softap) is NULL\n");
+ _retvm_if(callback == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(callback) is NULL\n");
+
+ __softap_h *sa = (__softap_h *) softap;
+
+ sa->enabled_cb = callback;
+ sa->enabled_user_data = user_data;
+
+ return SOFTAP_ERROR_NONE;
+}
+
+API int softap_unset_enabled_cb(softap_h softap)
+{
+ _retvm_if(softap == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(softap) is NULL\n");
+
+ __softap_h *sa = (__softap_h *) softap;
+
+ sa->enabled_cb = NULL;
+ sa->enabled_user_data = NULL;
+
+ return SOFTAP_ERROR_NONE;
+}
+
+API int softap_set_disabled_cb(softap_h softap, softap_disabled_cb callback, void *user_data)
+{
+ _retvm_if(softap == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(softap) is NULL\n");
+ _retvm_if(callback == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(callback) is NULL\n");
+
+ __softap_h *sa = (__softap_h *) softap;
+
+ sa->disabled_cb = callback;
+ sa->disabled_user_data = user_data;
+
+ return SOFTAP_ERROR_NONE;
+}
+
+API int softap_unset_disabled_cb(softap_h softap)
+{
+ _retvm_if(softap == NULL, SOFTAP_ERROR_INVALID_PARAMETER,
+ "parameter(softap) is NULL\n");
+
+ __softap_h *sa = (__softap_h *) softap;
+
+ sa->disabled_cb = NULL;
+ sa->disabled_user_data = NULL;
+
+ return SOFTAP_ERROR_NONE;
+}
<?xml version="1.0"?>
<sys-info>
<default>
- <key id="tethering-support" string="TRUE"/>
+ <key id="softap-support" string="TRUE"/>
</default>
</sys-info>
--- /dev/null
+SET(fw_test "${fw_name}_test")
+
+INCLUDE(FindPkgConfig)
+pkg_check_modules(${fw_test} REQUIRED glib-2.0)
+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 softap_test RUNTIME DESTINATION bin/)
--- /dev/null
+/*
+* 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.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <glib.h>
+#include <glib-object.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <vconf.h>
+
+#include "softap.h"
+
+#define DISABLE_REASON_TEXT_LEN 64
+#define COMMON_STR_BUF_LEN 32
+
+gboolean test_thread(GIOChannel *source, GIOCondition condition, gpointer data);
+
+softap_h sa = NULL;
+
+static const char *__convert_disabled_code_to_string(const softap_disabled_cause_e code)
+{
+ static char str_buf[DISABLE_REASON_TEXT_LEN] = {0, };
+
+ switch (code) {
+ case SOFTAP_DISABLED_BY_FLIGHT_MODE:
+ strncpy(str_buf, "disabled due to flight mode on", sizeof(str_buf));
+ break;
+
+ case SOFTAP_DISABLED_BY_LOW_BATTERY:
+ strncpy(str_buf, "disabled due to low battery", sizeof(str_buf));
+ break;
+
+ case SOFTAP_DISABLED_BY_NETWORK_CLOSE:
+ strncpy(str_buf, "disabled due to pdp network close", sizeof(str_buf));
+ break;
+
+ case SOFTAP_DISABLED_BY_TIMEOUT:
+ strncpy(str_buf, "disabled due to timeout", sizeof(str_buf));
+ break;
+
+ case SOFTAP_DISABLED_BY_OTHERS:
+ strncpy(str_buf, "disabled by other apps", sizeof(str_buf));
+ break;
+
+ case SOFTAP_DISABLED_BY_REQUEST:
+ strncpy(str_buf, "disabled by my request", sizeof(str_buf));
+ break;
+
+ case SOFTAP_DISABLED_BY_WIFI_ON:
+ strncpy(str_buf, "disabled by Wi-Fi station on", sizeof(str_buf));
+ break;
+
+ default:
+ strncpy(str_buf, "disabled by unknown reason", sizeof(str_buf));
+ break;
+ }
+
+ return str_buf;
+}
+
+/* Callback functions */
+static void __enabled_cb(softap_error_e error, bool is_requested, void *data)
+{
+ if (error != SOFTAP_ERROR_NONE) {
+ if (!is_requested)
+ return;
+
+ printf("Soft AP is not enabled. error code[0x%X]\n", error);
+ return;
+ }
+
+ if (is_requested)
+ printf("Soft AP is enabled successfully\n");
+ else
+ printf("Soft AP is enabled by other app\n");
+
+ return;
+}
+
+static void __disabled_cb(softap_error_e error, softap_disabled_cause_e code, void *data)
+{
+ if (error != SOFTAP_ERROR_NONE) {
+ if (code != SOFTAP_DISABLED_BY_REQUEST)
+ return;
+
+ printf("Soft AP is not disabled. error code[0x%X]\n", error);
+ return;
+ }
+
+ printf("Soft AP is %s\n", __convert_disabled_code_to_string(code));
+
+ return;
+}
+
+static void __register_cbs(void)
+{
+ int ret = SOFTAP_ERROR_NONE;
+
+ ret = softap_set_enabled_cb(sa, __enabled_cb, NULL);
+ if (ret != SOFTAP_ERROR_NONE)
+ printf("Fail to set enabled callback!!\n");
+
+ ret = softap_set_disabled_cb(sa, __disabled_cb, NULL);
+ if (ret != SOFTAP_ERROR_NONE)
+ printf("Fail to set disabled callback!!\n");
+
+ return;
+}
+
+static void __deregister_cbs(void)
+{
+ int ret = SOFTAP_ERROR_NONE;
+
+ ret = softap_unset_enabled_cb(sa);
+ if (ret != SOFTAP_ERROR_NONE)
+ printf("Fail to unset enabled callback!!\n");
+
+ ret = softap_unset_disabled_cb(sa);
+ if (ret != SOFTAP_ERROR_NONE)
+ printf("Fail to set disabled callback!!\n");
+
+ return;
+}
+
+
+static int test_softap_create(void)
+{
+ softap_create(&sa);
+ __register_cbs();
+
+ return 1;
+}
+
+static int test_softap_destroy(void)
+{
+ softap_destroy(sa);
+ __deregister_cbs();
+
+ return 1;
+}
+
+static int test_softap_enable(void)
+{
+ int ret = SOFTAP_ERROR_NONE;
+
+ ret = softap_enable(sa);
+ if (ret != SOFTAP_ERROR_NONE)
+ return 0;
+
+ return 1;
+}
+
+static int test_softap_disable(void)
+{
+ int ret = SOFTAP_ERROR_NONE;
+
+ ret = softap_disable(sa);
+ if (ret != SOFTAP_ERROR_NONE)
+ return 0;
+
+ return 1;
+}
+
+static int test_softap_is_enabled(void)
+{
+ int ret = SOFTAP_ERROR_NONE;
+ bool enabled = false;
+
+ ret = softap_is_enabled(sa, &enabled);
+ if (ret != SOFTAP_ERROR_NONE)
+ return 0;
+
+ printf("Soft AP is %s\n", enabled ? "enabled" : "disabled");
+
+ return 1;
+}
+
+static int test_softap_get_settings(void)
+{
+ int ret = SOFTAP_ERROR_NONE;
+ char *mac_address = NULL;
+ char *interface_name = NULL;
+ char *ip_address = NULL;
+ char *gateway_address = NULL;
+ char *subnet_mask = NULL;
+
+ ret = softap_get_mac_address(sa, &mac_address);
+ if (ret != SOFTAP_ERROR_NONE)
+ return 0;
+
+ ret = softap_get_network_interface_name(sa, &interface_name);
+ if (ret != SOFTAP_ERROR_NONE)
+ return 0;
+
+ ret = softap_get_ip_address(sa, SOFTAP_ADDRESS_FAMILY_IPV4, &ip_address);
+ if (ret != SOFTAP_ERROR_NONE)
+ return 0;
+
+ ret = softap_get_gateway_address(sa, SOFTAP_ADDRESS_FAMILY_IPV4, &gateway_address);
+ if (ret != SOFTAP_ERROR_NONE)
+ return 0;
+
+ ret = softap_get_subnet_mask(sa, SOFTAP_ADDRESS_FAMILY_IPV4, &subnet_mask);
+ if (ret != SOFTAP_ERROR_NONE)
+ return 0;
+
+
+ printf("* MAC address: %s\n", mac_address);
+ printf("* Network Interface: %s\n", interface_name);
+ printf("* IP address: %s\n", ip_address);
+ printf("* gateway_address: %s\n", gateway_address);
+ printf("* subnet_mask: %s\n", subnet_mask);
+
+ if (mac_address) g_free(mac_address);
+ if (interface_name) g_free(interface_name);
+ if (ip_address) g_free(ip_address);
+ if (gateway_address) g_free(gateway_address);
+ if (subnet_mask) g_free(subnet_mask);
+
+ 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')
+ exit(1);
+
+ if (a[0] == '\n' || a[0] == '\r') {
+ printf("\n\n Network Connection API Test App\n\n");
+ printf("Options..\n");
+ printf("1 - SoftAP create and set callbacks\n");
+ printf("2 - SoftAP destroy\n");
+ printf("3 - SoftAP enable\n");
+ printf("4 - SoftAP disable\n");
+ printf("5 - Is Soft AP enabled?\n");
+ printf("6 - Get Soft AP settings\n");
+ printf("0 - Exit \n");
+ printf("ENTER - Show options menu.......\n");
+ }
+
+ switch (a[0]) {
+ case '1':
+ rv = test_softap_create();
+ break;
+ case '2':
+ rv = test_softap_destroy();
+ break;
+ case '3':
+ rv = test_softap_enable();
+ break;
+ case '4':
+ rv = test_softap_disable();
+ break;
+ case '5':
+ rv = test_softap_is_enabled();
+ break;
+ case '6':
+ rv = test_softap_get_settings();
+ break;
+ }
+
+ if (rv == 1)
+ printf("Operation succeeded!\n");
+ else
+ printf("Operation failed!\n");
+
+ return true;
+}
projects / platform / core / api / softap.git / commitdiff