* limitations under the License.
*/
+#include <glib.h>
+#include <ctype.h>
#include <stdio.h>
#include <string.h>
-#include <ctype.h>
-#include <glib.h>
+
+#include "wifi_dbus_private.h"
#include "net_wifi_private.h"
-static GSList *ap_handle_list = NULL;
+static __thread bool is_init = false;
+static __thread GSList *ap_handle_list = NULL;
struct _wifi_cb_s {
wifi_device_state_changed_cb device_state_cb;
void *bg_scan_user_data;
wifi_scan_finished_cb scan_request_cb;
void *scan_request_user_data;
- wifi_scan_finished_cb scan_hidden_ap_cb;
- void *scan_hidden_ap_user_data;
+ wifi_scan_finished_cb specific_scan_cb;
+ void *specific_scan_user_data;
wifi_connection_state_changed_cb connection_state_cb;
void *connection_state_user_data;
wifi_activated_cb activated_cb;
net_profile_info_t *profiles;
};
-static struct _wifi_cb_s wifi_callbacks = {0,};
-static struct _profile_list_s profile_iterator = {0, NULL};
-static struct _profile_list_s hidden_profile_iterator = {0, NULL};
+struct _wifi_state_notify {
+ net_profile_info_t *ap_info;
+ wifi_connection_state_e state;
+};
+
+struct managed_idle_data {
+ GSourceFunc func;
+ gpointer user_data;
+ guint id;
+};
+
+static __thread struct _wifi_cb_s wifi_callbacks = { 0, };
+static __thread struct _profile_list_s profile_iterator = { 0, NULL };
+static __thread struct _profile_list_s specific_profile_iterator = {0, NULL};
+static __thread char specific_profile_essid[NET_WLAN_ESSID_LEN + 1] = { 0, };
+static __thread bool is_feature_checked = false;
+static __thread bool feature_supported = false;
+static __thread GSList *managed_idler_list = NULL;
+wifi_dbus *g_dbus_h = NULL;
+
+bool _wifi_is_init(void)
+{
+ return is_init;
+}
+
+static void __wifi_set_init(bool tag)
+{
+ is_init = tag;
+}
static wifi_error_e __libnet_convert_to_ap_error_type(net_err_t err_type)
{
return WIFI_ERROR_OPERATION_ABORTED;
case NET_ERR_TIME_OUT:
return WIFI_ERROR_NO_REPLY;
+ case NET_ERR_ACCESS_DENIED:
+ return WIFI_ERROR_PERMISSION_DENIED;
default:
return WIFI_ERROR_OPERATION_FAILED;
}
return "NO_REPLY";
case WIFI_ERROR_SECURITY_RESTRICTED:
return "SECURITY_RESTRICTED";
+ case WIFI_ERROR_PERMISSION_DENIED:
+ return "PERMISSION_DENIED";
+ case WIFI_ERROR_NOT_SUPPORTED:
+ return "NOT_SUPPROTED";
}
return "UNKNOWN";
static const char *__libnet_convert_ap_state_to_string(wifi_connection_state_e state)
{
switch (state) {
+ case WIFI_CONNECTION_STATE_FAILURE:
+ return "FAILURE";
case WIFI_CONNECTION_STATE_DISCONNECTED:
return "DISCONNECTED";
case WIFI_CONNECTION_STATE_ASSOCIATION:
profile_list->profiles = NULL;
}
-static void __libnet_update_profile_iterator(void)
+static int __libnet_update_profile_iterator(void)
{
- struct _profile_list_s wifi_profiles = {0, NULL};
+ int rv;
+ struct _profile_list_s wifi_profiles = { 0, NULL };
__libnet_clear_profile_list(&profile_iterator);
- net_get_profile_list(NET_DEVICE_WIFI, &wifi_profiles.profiles, &wifi_profiles.count);
- WIFI_LOG(WIFI_INFO, "Wifi profile count : %d\n", wifi_profiles.count);
+ rv = net_get_profile_list(NET_DEVICE_WIFI, &wifi_profiles.profiles, &wifi_profiles.count);
+ WIFI_LOG(WIFI_INFO, "Wi-Fi profile count: %d", wifi_profiles.count);
+
+ if (rv == NET_ERR_ACCESS_DENIED) {
+ WIFI_LOG(WIFI_ERROR, "Access denied");
+ return WIFI_ERROR_PERMISSION_DENIED;
+ }
if (wifi_profiles.count == 0)
- return;
+ return WIFI_ERROR_NONE;
profile_iterator.count = wifi_profiles.count;
profile_iterator.profiles = wifi_profiles.profiles;
+
+ return WIFI_ERROR_NONE;
}
-static void __libnet_update_hidden_profile_iterator(GSList *ap_list)
+static void __libnet_update_specific_profile_iterator(GSList *ap_list)
{
- int count;
+ int count = 0;
GSList *list = ap_list;
for (count = 0; list; list = list->next)
return;
}
- hidden_profile_iterator.count = count;
- hidden_profile_iterator.profiles = g_try_new0(net_profile_info_t, count);
+ specific_profile_iterator.count = count;
+ specific_profile_iterator.profiles = g_try_new0(net_profile_info_t, count);
list = ap_list;
for (count = 0; list; list = list->next) {
- net_wifi_connection_info_t *ap = list->data;
- net_profile_info_t *profile = &hidden_profile_iterator.profiles[count];
+ struct ssid_scan_bss_info_t *ap = (struct ssid_scan_bss_info_t *)list->data;
+ net_profile_info_t *profile = &specific_profile_iterator.profiles[count];
+
+ g_strlcpy(profile->ProfileInfo.Wlan.essid, ap->ssid, NET_WLAN_ESSID_LEN+1);
+ profile->ProfileInfo.Wlan.security_info.sec_mode = ap->security;
- g_strlcpy(profile->ProfileInfo.Wlan.essid, ap->essid, NET_WLAN_ESSID_LEN+1);
- profile->ProfileInfo.Wlan.security_info.sec_mode = ap->security_info.sec_mode;
count++;
}
- WIFI_LOG(WIFI_INFO, "Hidden AP count : %d\n", count);
+ WIFI_LOG(WIFI_INFO, "Specific AP count : %d\n", count);
}
static void __libnet_convert_profile_info_to_wifi_info(net_wifi_connection_info_t *wifi_info,
g_strlcpy(wifi_info->essid, ap_info->ProfileInfo.Wlan.essid, NET_WLAN_ESSID_LEN+1);
wifi_info->wlan_mode = ap_info->ProfileInfo.Wlan.wlan_mode;
memcpy(&wifi_info->security_info, &ap_info->ProfileInfo.Wlan.security_info, sizeof(wlan_security_info_t));
+ wifi_info->is_hidden = ap_info->ProfileInfo.Wlan.is_hidden;
}
static int __libnet_connect_with_wifi_info(net_profile_info_t *ap_info)
{
+ int rv;
net_wifi_connection_info_t wifi_info;
memset(&wifi_info, 0, sizeof(net_wifi_connection_info_t));
__libnet_convert_profile_info_to_wifi_info(&wifi_info, ap_info);
- if (net_open_connection_with_wifi_info(&wifi_info) != NET_ERR_NONE)
+ rv = net_open_connection_with_wifi_info(&wifi_info);
+ if (rv == NET_ERR_ACCESS_DENIED) {
+ WIFI_LOG(WIFI_ERROR, "Access denied");
+ return WIFI_ERROR_PERMISSION_DENIED;
+ } else if (rv != NET_ERR_NONE)
return WIFI_ERROR_OPERATION_FAILED;
return WIFI_ERROR_NONE;
}
+static gboolean __wifi_state_changed_cb(gpointer data)
+{
+ wifi_ap_h ap_info;
+ struct _wifi_state_notify *notify = (struct _wifi_state_notify *)data;
+
+ if (notify == NULL)
+ return FALSE;
+
+ if (notify->ap_info == NULL) {
+ g_free(notify);
+ return FALSE;
+ }
+
+ ap_info = (wifi_ap_h)notify->ap_info;
+
+ _wifi_libnet_add_to_ap_list(ap_info);
+
+ if (wifi_callbacks.connection_state_cb != NULL)
+ wifi_callbacks.connection_state_cb(notify->state, ap_info,
+ wifi_callbacks.connection_state_user_data);
+
+ _wifi_libnet_remove_from_ap_list(ap_info);
+
+ g_free(notify);
+
+ return FALSE;
+}
+
static void __libnet_state_changed_cb(char *profile_name, net_profile_info_t *profile_info,
wifi_connection_state_e state)
{
+ guint id;
+ net_profile_info_t *ap_info = NULL;
+ struct _wifi_state_notify *notify = NULL;
+
+ if (_wifi_is_init() != true) {
+ WIFI_LOG(WIFI_ERROR, "Application is not registered"
+ "If multi-threaded, thread integrity be broken.");
+ return;
+ }
+
+ if (wifi_callbacks.connection_state_cb == NULL)
+ return;
+
if (profile_name == NULL)
return;
if (profile_info == NULL) {
- WIFI_LOG(WIFI_ERROR, "Error!! Profile info not found! : %s\n", profile_name);
+ SECURE_WIFI_LOG(WIFI_ERROR, "Failed to find: %s", profile_name);
+ return;
+ }
+
+ ap_info = g_try_malloc0(sizeof(net_profile_info_t));
+ if (ap_info == NULL) {
+ WIFI_LOG(WIFI_ERROR, "Memory allocation error");
return;
}
- ap_handle_list = g_slist_append(ap_handle_list, (wifi_ap_h)profile_info);
+ memcpy(ap_info, profile_info, sizeof(net_profile_info_t));
+
+ notify = g_try_new0(struct _wifi_state_notify, 1);
+ if (notify == NULL) {
+ g_free(ap_info);
+ return;
+ }
- if (wifi_callbacks.connection_state_cb)
- wifi_callbacks.connection_state_cb(state, (wifi_ap_h)profile_info,
- wifi_callbacks.connection_state_user_data);
+ notify->ap_info = ap_info;
+ notify->state = state;
- ap_handle_list = g_slist_remove(ap_handle_list, (wifi_ap_h)profile_info);
+ id = _wifi_callback_add(__wifi_state_changed_cb, (gpointer)notify);
+ if (!id)
+ g_free(notify);
}
static void __libnet_set_activated_cb(wifi_activated_cb user_cb, void *user_data)
{
- if (user_cb) {
+ if (user_cb != NULL) {
wifi_callbacks.activated_cb = user_cb;
wifi_callbacks.activated_user_data = user_data;
}
}
-static void __libnet_activated_cb(wifi_error_e result)
+static gboolean __activated_cb_idle(gpointer data)
{
- if (wifi_callbacks.activated_cb)
+ wifi_error_e result = (wifi_error_e)data;
+
+ if (wifi_callbacks.activated_cb != NULL)
wifi_callbacks.activated_cb(result, wifi_callbacks.activated_user_data);
wifi_callbacks.activated_cb = NULL;
wifi_callbacks.activated_user_data = NULL;
+
+ return FALSE;
}
-static void __libnet_set_deactivated_cb(wifi_disconnected_cb user_cb, void *user_data)
+static void __libnet_set_deactivated_cb(wifi_deactivated_cb user_cb, void *user_data)
{
- if (user_cb) {
+ if (user_cb != NULL) {
wifi_callbacks.deactivated_cb = user_cb;
wifi_callbacks.deactivated_user_data = user_data;
}
}
-static void __libnet_deactivated_cb(wifi_error_e result)
+static gboolean __deactivated_cb_idle(gpointer data)
{
- if (wifi_callbacks.deactivated_cb)
+ wifi_error_e result = (wifi_error_e)data;
+
+ if (wifi_callbacks.deactivated_cb != NULL)
wifi_callbacks.deactivated_cb(result, wifi_callbacks.deactivated_user_data);
wifi_callbacks.deactivated_cb = NULL;
wifi_callbacks.deactivated_user_data = NULL;
+
+ return FALSE;
+}
+
+static gboolean __device_state_cb_idle(gpointer data)
+{
+ wifi_device_state_e state = (wifi_device_state_e)data;
+
+ if (wifi_callbacks.device_state_cb != NULL)
+ wifi_callbacks.device_state_cb(state, wifi_callbacks.device_state_user_data);
+
+ return FALSE;
}
static void __libnet_power_on_off_cb(net_event_info_t *event_cb, bool is_requested)
{
+ if (_wifi_is_init() != true) {
+ WIFI_LOG(WIFI_ERROR, "Application is not registered"
+ "If multi-threaded, thread integrity be broken.");
+ return;
+ }
+
if (wifi_callbacks.device_state_cb == NULL &&
- wifi_callbacks.activated_cb == NULL &&
- wifi_callbacks.deactivated_cb == NULL)
+ wifi_callbacks.activated_cb == NULL &&
+ wifi_callbacks.deactivated_cb == NULL)
return;
wifi_error_e error_code = WIFI_ERROR_NONE;
- wifi_device_state_e state;
- net_wifi_state_t *wifi_state = (net_wifi_state_t*)event_cb->Data;
+ wifi_device_state_e state = WIFI_DEVICE_STATE_DEACTIVATED;
+ net_wifi_state_t *wifi_state = (net_wifi_state_t *)event_cb->Data;
if (event_cb->Error == NET_ERR_NONE &&
- event_cb->Datalength == sizeof(net_wifi_state_t)) {
-
+ event_cb->Datalength == sizeof(net_wifi_state_t)) {
if (*wifi_state == WIFI_ON) {
- WIFI_LOG(WIFI_INFO, "Wi-Fi State : Power ON\n");
+ WIFI_LOG(WIFI_INFO, "Wi-Fi power on");
state = WIFI_DEVICE_STATE_ACTIVATED;
} else if (*wifi_state == WIFI_OFF) {
- WIFI_LOG(WIFI_INFO, "Wi-Fi State : Power OFF\n");
+ WIFI_LOG(WIFI_INFO, "Wi-Fi power off");
state = WIFI_DEVICE_STATE_DEACTIVATED;
__libnet_clear_profile_list(&profile_iterator);
- __libnet_clear_profile_list(&hidden_profile_iterator);
} else {
- WIFI_LOG(WIFI_INFO, "Wi-Fi State : Unknown\n");
+ WIFI_LOG(WIFI_ERROR, "Error Wi-Fi state %d", *wifi_state);
error_code = WIFI_ERROR_OPERATION_FAILED;
state = WIFI_DEVICE_STATE_DEACTIVATED;
}
} else {
- WIFI_LOG(WIFI_ERROR, "Wi-Fi Power on/off request failed! Error [%d]\n", event_cb->Error);
- error_code = WIFI_ERROR_OPERATION_FAILED;
+ WIFI_LOG(WIFI_ERROR, "Wi-Fi power request failed(%d)", event_cb->Error);
+
+ if (event_cb->Error == NET_ERR_SECURITY_RESTRICTED)
+ error_code = WIFI_ERROR_SECURITY_RESTRICTED;
+ else
+ error_code = WIFI_ERROR_OPERATION_FAILED;
+
state = WIFI_DEVICE_STATE_DEACTIVATED;
}
- __libnet_activated_cb(error_code);
- __libnet_deactivated_cb(error_code);
+ if (wifi_callbacks.activated_cb != NULL)
+ _wifi_callback_add(__activated_cb_idle, (gpointer)error_code);
- if (wifi_callbacks.device_state_cb)
- wifi_callbacks.device_state_cb(state, wifi_callbacks.device_state_user_data);
+ if (wifi_callbacks.deactivated_cb != NULL)
+ _wifi_callback_add(__deactivated_cb_idle, (gpointer)error_code);
+
+ if (wifi_callbacks.device_state_cb != NULL)
+ _wifi_callback_add(__device_state_cb_idle, (gpointer)state);
+}
+
+static gboolean __scan_request_cb_idle(gpointer data)
+{
+ wifi_error_e error_code = (wifi_error_e)data;
+
+ if (wifi_callbacks.scan_request_cb != NULL)
+ wifi_callbacks.scan_request_cb(error_code, wifi_callbacks.scan_request_user_data);
+
+ wifi_callbacks.scan_request_cb = NULL;
+ wifi_callbacks.scan_request_user_data = NULL;
+
+ return FALSE;
+}
+
+static void __libnet_set_specific_scan_cb(wifi_scan_finished_cb user_cb, void *user_data)
+{
+ if (user_cb != NULL) {
+ wifi_callbacks.specific_scan_cb = user_cb;
+ wifi_callbacks.specific_scan_user_data = user_data;
+ }
+}
+
+static gboolean __specific_scan_cb_idle(gpointer data)
+{
+ wifi_error_e error_code = (wifi_error_e)data;
+
+ if (wifi_callbacks.specific_scan_cb != NULL)
+ wifi_callbacks.specific_scan_cb(error_code, wifi_callbacks.specific_scan_user_data);
+
+ wifi_callbacks.specific_scan_cb = NULL;
+ wifi_callbacks.specific_scan_user_data = NULL;
+
+ return FALSE;
+}
+
+static gboolean __bgscan_cb_idle(gpointer data)
+{
+ wifi_error_e error_code = (wifi_error_e)data;
+
+ if (wifi_callbacks.bg_scan_cb != NULL)
+ wifi_callbacks.bg_scan_cb(error_code, wifi_callbacks.bg_scan_user_data);
+
+ return FALSE;
}
-static void __libnet_scan_cb(net_event_info_t *event_cb)
+static void __libnet_scan_cb(net_event_info_t *event_cb, bool is_requested)
{
wifi_error_e error_code = WIFI_ERROR_NONE;
+ if (_wifi_is_init() != 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!, Error [%d]\n", event_cb->Error);
+ WIFI_LOG(WIFI_ERROR, "Scan failed[%d]", event_cb->Error);
error_code = WIFI_ERROR_OPERATION_FAILED;
}
- if (wifi_callbacks.scan_request_cb) {
- wifi_callbacks.scan_request_cb(error_code, wifi_callbacks.scan_request_user_data);
- wifi_callbacks.scan_request_cb = NULL;
- wifi_callbacks.scan_request_user_data = NULL;
+ if (wifi_callbacks.scan_request_cb != NULL) {
+ _wifi_callback_add(__scan_request_cb_idle, (gpointer)error_code);
return;
}
if (wifi_callbacks.bg_scan_cb != NULL)
- wifi_callbacks.bg_scan_cb(error_code, wifi_callbacks.bg_scan_user_data);
+ _wifi_callback_add(__bgscan_cb_idle, (gpointer)error_code);
}
-static void __libnet_hidden_scan_cb(net_event_info_t *event_cb)
+static void __libnet_specific_scan_cb(net_event_info_t *event_cb)
{
wifi_error_e error_code = WIFI_ERROR_NONE;
- __libnet_clear_profile_list(&hidden_profile_iterator);
+ __libnet_clear_profile_list(&specific_profile_iterator);
if (event_cb->Error != NET_ERR_NONE) {
- WIFI_LOG(WIFI_ERROR, "Hidden scan failed!, Error [%d]\n", event_cb->Error);
+ WIFI_LOG(WIFI_ERROR, "Specific scan failed!, Error [%d]\n", event_cb->Error);
error_code = WIFI_ERROR_OPERATION_FAILED;
} else if (event_cb->Data) {
- GSList *ap_list = event_cb->Data;
- __libnet_update_hidden_profile_iterator(ap_list);
+ GSList *ap_list = (GSList *)event_cb->Data;
+ __libnet_update_specific_profile_iterator(ap_list);
}
- if (wifi_callbacks.scan_hidden_ap_cb) {
- wifi_callbacks.scan_hidden_ap_cb(error_code, wifi_callbacks.scan_hidden_ap_user_data);
- wifi_callbacks.scan_hidden_ap_cb = NULL;
- wifi_callbacks.scan_hidden_ap_user_data = NULL;
- }
+ if (wifi_callbacks.specific_scan_cb != NULL)
+ _wifi_callback_add(__specific_scan_cb_idle, (gpointer)error_code);
}
static void __libnet_set_connected_cb(wifi_connected_cb user_cb, void *user_data)
{
- if (user_cb) {
+ if (user_cb != NULL) {
wifi_callbacks.connected_cb = user_cb;
wifi_callbacks.connected_user_data = user_data;
}
}
-static void __libnet_connected_cb(wifi_error_e result)
+static gboolean __connected_cb_idle(gpointer data)
{
- if (wifi_callbacks.connected_cb)
+ wifi_error_e result = (wifi_error_e)data;
+
+ if (wifi_callbacks.connected_cb != NULL)
wifi_callbacks.connected_cb(result, wifi_callbacks.connected_user_data);
wifi_callbacks.connected_cb = NULL;
wifi_callbacks.connected_user_data = NULL;
+
+ return FALSE;
+}
+
+static void __libnet_connected_cb(wifi_error_e result)
+{
+ if (_wifi_is_init() != true) {
+ WIFI_LOG(WIFI_ERROR, "Application is not registered"
+ "If multi-threaded, thread integrity be broken.");
+ return;
+ }
+
+ if (wifi_callbacks.connected_cb != NULL)
+ _wifi_callback_add(__connected_cb_idle, (gpointer)result);
}
static void __libnet_set_disconnected_cb(wifi_disconnected_cb user_cb, void *user_data)
{
- if (user_cb) {
+ if (user_cb != NULL) {
wifi_callbacks.disconnected_cb = user_cb;
wifi_callbacks.disconnected_user_data = user_data;
}
}
-static void __libnet_disconnected_cb(wifi_error_e result)
+static gboolean __disconnected_cb_idle(gpointer data)
{
- if (wifi_callbacks.disconnected_cb)
+ wifi_error_e result = (wifi_error_e)data;
+
+ if (wifi_callbacks.disconnected_cb != NULL)
wifi_callbacks.disconnected_cb(result, wifi_callbacks.disconnected_user_data);
wifi_callbacks.disconnected_cb = NULL;
wifi_callbacks.disconnected_user_data = NULL;
+
+ return FALSE;
+}
+
+static void __libnet_disconnected_cb(wifi_error_e result)
+{
+ if (_wifi_is_init() != true) {
+ WIFI_LOG(WIFI_ERROR, "Application is not registered"
+ "If multi-threaded, thread integrity be broken.");
+ return;
+ }
+
+ if (wifi_callbacks.disconnected_cb != NULL)
+ _wifi_callback_add(__disconnected_cb_idle, (gpointer)result);
}
static void __libnet_evt_cb(net_event_info_t *event_cb, void *user_data)
net_profile_info_t *prof_info_p = NULL;
net_profile_info_t prof_info;
wifi_error_e result = WIFI_ERROR_NONE;
+ int i = 0;
+ bool is_profile_exists = false;
switch (event_cb->Event) {
case NET_EVENT_OPEN_RSP:
return;
result = __libnet_convert_to_ap_error_type(event_cb->Error);
- WIFI_LOG(WIFI_INFO, "Got Open RSP/IND : %s\n",
- __libnet_convert_ap_error_type_to_string(result));
+ WIFI_LOG(WIFI_INFO, "Connection open error %s",
+ __libnet_convert_ap_error_type_to_string(result));
if (is_requested)
__libnet_connected_cb(result);
switch (event_cb->Error) {
case NET_ERR_NONE:
- WIFI_LOG(WIFI_INFO, "Connection open succeeded\n");
-
if (event_cb->Datalength == sizeof(net_profile_info_t))
- prof_info_p = (net_profile_info_t*)event_cb->Data;
+ prof_info_p = (net_profile_info_t *)event_cb->Data;
__libnet_state_changed_cb(event_cb->ProfileName, prof_info_p,
WIFI_CONNECTION_STATE_CONNECTED);
return;
case NET_ERR_ACTIVE_CONNECTION_EXISTS:
- WIFI_LOG(WIFI_INFO, "Connection already existed\n");
return;
- default :
- WIFI_LOG(WIFI_ERROR, "Connection open failed!\n");
+ default:
break;
}
return;
result = __libnet_convert_to_ap_error_type(event_cb->Error);
- WIFI_LOG(WIFI_INFO, "Got Close RSP/IND : %s\n",
- __libnet_convert_ap_error_type_to_string(result));
+ WIFI_LOG(WIFI_ERROR, "Connection close error %s",
+ __libnet_convert_ap_error_type_to_string(result));
if (is_requested)
__libnet_disconnected_cb(result);
switch (event_cb->Error) {
case NET_ERR_NONE:
- WIFI_LOG(WIFI_INFO, "Connection close succeeded!\n");
if (net_get_profile_info(event_cb->ProfileName, &prof_info) == NET_ERR_NONE)
__libnet_state_changed_cb(event_cb->ProfileName, &prof_info,
- WIFI_CONNECTION_STATE_DISCONNECTED);
+ WIFI_CONNECTION_STATE_DISCONNECTED);
else
__libnet_state_changed_cb(event_cb->ProfileName, NULL,
- WIFI_CONNECTION_STATE_DISCONNECTED);
+ WIFI_CONNECTION_STATE_DISCONNECTED);
return;
default:
- WIFI_LOG(WIFI_ERROR, "Connection close failed!\n");
break;
}
if (_wifi_libnet_check_profile_name_validity(event_cb->ProfileName) != true)
return;
- WIFI_LOG(WIFI_INFO, "Got State changed IND\n");
-
if (event_cb->Datalength != sizeof(net_state_type_t))
return;
- net_state_type_t *profile_state = (net_state_type_t*)event_cb->Data;
+ net_state_type_t *profile_state = (net_state_type_t *)event_cb->Data;
wifi_connection_state_e ap_state = _wifi_convert_to_ap_state(*profile_state);
- WIFI_LOG(WIFI_INFO,
- "Profile State : %s, profile name : %s\n",
- __libnet_convert_ap_state_to_string(ap_state),
- event_cb->ProfileName);
+ WIFI_LOG(WIFI_INFO, "state: %s", __libnet_convert_ap_state_to_string(ap_state));
+ SECURE_WIFI_LOG(WIFI_INFO, "profile name: %s", event_cb->ProfileName);
if (net_get_profile_info(event_cb->ProfileName, &prof_info) == NET_ERR_NONE)
__libnet_state_changed_cb(event_cb->ProfileName, &prof_info, ap_state);
- else
+ else if (ap_state == WIFI_CONNECTION_STATE_DISCONNECTED) {
+ for (i = 0; i < profile_iterator.count; i++) {
+ if (!g_strcmp0(event_cb->ProfileName,
+ profile_iterator.profiles[i].ProfileName)) {
+ is_profile_exists = true;
+ break;
+ }
+ }
+
+ if (is_profile_exists == true) {
+ profile_iterator.profiles[i].ProfileState = *profile_state;
+ __libnet_state_changed_cb(event_cb->ProfileName,
+ &profile_iterator.profiles[i], ap_state);
+ } else
+ __libnet_state_changed_cb(event_cb->ProfileName,
+ NULL, ap_state);
+ } else
__libnet_state_changed_cb(event_cb->ProfileName, NULL, ap_state);
-
break;
case NET_EVENT_WIFI_SCAN_RSP:
case NET_EVENT_WIFI_SCAN_IND:
- WIFI_LOG(WIFI_INFO, "Got Wi-Fi scan IND\n");
- __libnet_scan_cb(event_cb);
+ __libnet_scan_cb(event_cb, is_requested);
break;
case NET_EVENT_SPECIFIC_SCAN_RSP:
- WIFI_LOG(WIFI_INFO, "Got Wi-Fi hidden scan RSP\n");
+ WIFI_LOG(WIFI_INFO, "Got Wi-Fi specific scan RSP\n");
break;
case NET_EVENT_SPECIFIC_SCAN_IND:
- WIFI_LOG(WIFI_INFO, "Got Wi-Fi hidden scan IND\n");
- __libnet_hidden_scan_cb(event_cb);
+ WIFI_LOG(WIFI_INFO, "Got Wi-Fi specific scan IND\n");
+ __libnet_specific_scan_cb(event_cb);
break;
case NET_EVENT_WIFI_POWER_RSP:
is_requested = true;
/* fall through */
case NET_EVENT_WIFI_POWER_IND:
- WIFI_LOG(WIFI_INFO, "Got Wi-Fi power IND\n");
__libnet_power_on_off_cb(event_cb, is_requested);
break;
- default :
- WIFI_LOG(WIFI_ERROR, "Error! Unknown Event\n\n");
+ default:
+ break;
}
}
-bool _wifi_libnet_init(void)
+int _wifi_libnet_init(void)
{
int rv;
rv = net_register_client_ext((net_event_cb_t)__libnet_evt_cb, NET_DEVICE_WIFI, NULL);
if (rv != NET_ERR_NONE)
- return false;
+ return rv;
- return true;
+ __wifi_set_init(true);
+
+ return NET_ERR_NONE;
}
bool _wifi_libnet_deinit(void)
return false;
__libnet_clear_profile_list(&profile_iterator);
- __libnet_clear_profile_list(&hidden_profile_iterator);
g_slist_free_full(ap_handle_list, g_free);
ap_handle_list = NULL;
memset(&wifi_callbacks, 0, sizeof(struct _wifi_cb_s));
+ __wifi_set_init(false);
+
return true;
}
-int _wifi_activate(wifi_activated_cb callback, void *user_data)
+int _wifi_activate(wifi_activated_cb callback, gboolean wifi_picker_test,
+ void *user_data)
{
- int rv;
+ int rv = NET_ERR_NONE;
- rv = net_wifi_power_on();
+ rv = net_wifi_power_on(wifi_picker_test);
if (rv == NET_ERR_NONE) {
__libnet_set_activated_cb(callback, user_data);
return WIFI_ERROR_NONE;
+ } else if (rv == NET_ERR_ACCESS_DENIED) {
+ WIFI_LOG(WIFI_ERROR, "Access denied");
+ return WIFI_ERROR_PERMISSION_DENIED;
} else if (rv == NET_ERR_INVALID_OPERATION)
return WIFI_ERROR_INVALID_OPERATION;
else if (rv == NET_ERR_ALREADY_EXISTS)
return WIFI_ERROR_ALREADY_EXISTS;
+ else if (rv == NET_ERR_IN_PROGRESS)
+ return WIFI_ERROR_NOW_IN_PROGRESS;
+ else if (rv == NET_ERR_SECURITY_RESTRICTED)
+ return WIFI_ERROR_SECURITY_RESTRICTED;
return WIFI_ERROR_OPERATION_FAILED;
}
int _wifi_deactivate(wifi_deactivated_cb callback, void *user_data)
{
- int rv;
+ int rv = NET_ERR_NONE;
rv = net_wifi_power_off();
if (rv == NET_ERR_NONE) {
__libnet_set_deactivated_cb(callback, user_data);
return WIFI_ERROR_NONE;
+ } else if (rv == NET_ERR_ACCESS_DENIED) {
+ WIFI_LOG(WIFI_ERROR, "Access denied");
+ return WIFI_ERROR_PERMISSION_DENIED;
} else if (rv == NET_ERR_INVALID_OPERATION)
return WIFI_ERROR_INVALID_OPERATION;
else if (rv == NET_ERR_ALREADY_EXISTS)
return WIFI_ERROR_ALREADY_EXISTS;
+ else if (rv == NET_ERR_IN_PROGRESS)
+ return WIFI_ERROR_NOW_IN_PROGRESS;
+ else if (rv == NET_ERR_SECURITY_RESTRICTED)
+ return WIFI_ERROR_SECURITY_RESTRICTED;
return WIFI_ERROR_OPERATION_FAILED;
}
bool _wifi_libnet_check_ap_validity(wifi_ap_h ap_h)
{
- GSList *list;
- int i = 0;
+ int i;
+ 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 (; i < profile_iterator.count; i++)
+ for (i = 0; i < profile_iterator.count; i++)
if (ap_h == &profile_iterator.profiles[i]) return true;
- for (i = 0; i < hidden_profile_iterator.count; i++)
- if (ap_h == &hidden_profile_iterator.profiles[i]) return true;
+ for (i = 0; i < specific_profile_iterator.count; i++)
+ if (ap_h == &specific_profile_iterator.profiles[i]) return true;
return false;
}
if (profile_name == NULL ||
g_str_has_prefix(profile_name, profile_prefix) != TRUE) {
- WIFI_LOG(WIFI_ERROR, "Error!!! Profile name is invalid\n");
+ 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_ERROR, "Error!!! Profile name is invalid\n");
+ WIFI_LOG(WIFI_INFO, "Invalid format: %s", profile_name);
return false;
}
i++;
return true;
}
-bool _wifi_libnet_get_wifi_device_state(wifi_device_state_e *device_state)
+int _wifi_libnet_get_wifi_device_state(wifi_device_state_e *device_state)
{
net_tech_info_t tech_info;
- if (net_get_technology_properties(NET_DEVICE_WIFI, &tech_info) != NET_ERR_NONE) {
- WIFI_LOG(WIFI_ERROR, "Error!! net_get_technology_properties() failed.\n");
- return false;
+ int rv = NET_ERR_NONE;
+ rv = net_get_technology_properties(NET_DEVICE_WIFI, &tech_info);
+ if (rv == NET_ERR_ACCESS_DENIED) {
+ WIFI_LOG(WIFI_ERROR, "Access denied");
+ return WIFI_ERROR_PERMISSION_DENIED;
+ } else if (rv != NET_ERR_NONE) {
+ WIFI_LOG(WIFI_ERROR, "Failed to get technology properties");
+ return WIFI_ERROR_OPERATION_FAILED;
}
if (tech_info.powered)
else
*device_state = WIFI_DEVICE_STATE_DEACTIVATED;
- WIFI_LOG(WIFI_ERROR, "Wi-Fi device state: %d", *device_state);
-
- return true;
+ return WIFI_ERROR_NONE;
}
-bool _wifi_libnet_get_wifi_state(wifi_connection_state_e* connection_state)
+int _wifi_libnet_get_wifi_state(wifi_connection_state_e *connection_state)
{
- net_wifi_state_t wlan_state = 0;
- net_profile_name_t profile_name;
+ wifi_dbus *dbus_h = NULL;
+ GError *error = NULL;
+ GVariant *result = NULL;
+ gint state = 0;
+
+ dbus_h = _wifi_get_dbus_handle();
+ if (dbus_h == NULL) {
+ WIFI_LOG(WIFI_ERROR, "Not initialized for wifi dbus connection");
+ return WIFI_ERROR_INVALID_OPERATION;
+ }
- if (net_get_wifi_state(&wlan_state, &profile_name) != NET_ERR_NONE) {
- WIFI_LOG(WIFI_ERROR, "Error!! net_get_wifi_state() failed.\n");
- return false;
+ result = g_dbus_connection_call_sync(dbus_h->dbus_conn,
+ NETCONFIG_SERVICE,
+ NETCONFIG_WIFI_PATH,
+ NETCONFIG_IWIFI,
+ "GetWifiState",
+ g_variant_new("()"),
+ NULL, G_DBUS_CALL_FLAGS_NONE,
+ DBUS_REPLY_TIMEOUT, dbus_h->ca,
+ &error);
+
+ if (error) {
+ WIFI_LOG(WIFI_ERROR, "Fail to GetWifiState [%d: %s]", error->code, error->message);
+ g_error_free(error);
+ return WIFI_ERROR_OPERATION_FAILED;
}
- switch (wlan_state) {
- case WIFI_OFF:
- case WIFI_ON:
- *connection_state = WIFI_CONNECTION_STATE_DISCONNECTED;
- break;
- case WIFI_CONNECTING:
- *connection_state = WIFI_CONNECTION_STATE_ASSOCIATION;
- break;
- case WIFI_CONNECTED:
- *connection_state = WIFI_CONNECTION_STATE_CONNECTED;
- break;
- case WIFI_DISCONNECTING:
- *connection_state = WIFI_CONNECTION_STATE_CONNECTED;
- break;
- default :
- WIFI_LOG(WIFI_ERROR, "Error!! Unknown state\n");
- return false;
+ if (result != NULL) {
+ g_variant_get(result, "(i)", &state);
+ g_variant_unref(result);
}
- return true;
+ *connection_state = state;
+
+ return WIFI_ERROR_NONE;
}
int _wifi_libnet_get_intf_name(char** name)
{
- if (profile_iterator.count == 0)
- __libnet_update_profile_iterator();
+ int rv;
+
+ if (profile_iterator.count == 0) {
+ rv = __libnet_update_profile_iterator();
+ if (rv == NET_ERR_ACCESS_DENIED) {
+ WIFI_LOG(WIFI_ERROR, "Access denied");
+ return WIFI_ERROR_PERMISSION_DENIED;
+ }
+ }
if (profile_iterator.count == 0) {
- WIFI_LOG(WIFI_ERROR, "Error!! There is no AP\n");
+ WIFI_LOG(WIFI_ERROR, "There is no AP");
return WIFI_ERROR_OPERATION_FAILED;
}
wifi_callbacks.scan_request_cb = callback;
wifi_callbacks.scan_request_user_data = user_data;
return WIFI_ERROR_NONE;
+ } else if (rv == NET_ERR_ACCESS_DENIED) {
+ WIFI_LOG(WIFI_ERROR, "Access denied");
+ return WIFI_ERROR_PERMISSION_DENIED;
} else if (rv == NET_ERR_INVALID_OPERATION)
return WIFI_ERROR_INVALID_OPERATION;
return WIFI_ERROR_OPERATION_FAILED;
}
-int _wifi_libnet_scan_hidden_ap(const char *essid,
- wifi_scan_finished_cb callback, void *user_data)
+int _wifi_libnet_scan_specific_ap(const char *essid,
+ wifi_scan_finished_cb callback, void *user_data)
{
int rv;
rv = net_specific_scan_wifi(essid);
if (rv == NET_ERR_NONE) {
- wifi_callbacks.scan_hidden_ap_cb = callback;
- wifi_callbacks.scan_hidden_ap_user_data = user_data;
+ g_strlcpy(specific_profile_essid, essid, NET_WLAN_ESSID_LEN+1);
+ __libnet_set_specific_scan_cb(callback, user_data);
return WIFI_ERROR_NONE;
+ } else if (rv == NET_ERR_ACCESS_DENIED) {
+ WIFI_LOG(WIFI_ERROR, "Access denied");
+ return WIFI_ERROR_PERMISSION_DENIED;
} else if (rv == NET_ERR_INVALID_OPERATION)
return WIFI_ERROR_INVALID_OPERATION;
int _wifi_libnet_get_connected_profile(wifi_ap_h *ap)
{
- int i = 0;
+ int i, rv;
wifi_ap_h ap_h = NULL;
- __libnet_update_profile_iterator();
+ rv = __libnet_update_profile_iterator();
+ if (rv == NET_ERR_ACCESS_DENIED) {
+ WIFI_LOG(WIFI_ERROR, "Access denied");
+ return WIFI_ERROR_PERMISSION_DENIED;
+ }
- for (;i < profile_iterator.count;i++) {
+ for (i = 0; i < profile_iterator.count; i++) {
if (profile_iterator.profiles[i].ProfileState == NET_STATE_TYPE_ONLINE ||
profile_iterator.profiles[i].ProfileState == NET_STATE_TYPE_READY) {
ap_h = (wifi_ap_h)(&profile_iterator.profiles[i]);
}
if (ap_h == NULL) {
- WIFI_LOG(WIFI_ERROR, "Error!! There is no connected AP.\n");
+ WIFI_LOG(WIFI_ERROR, "There is no connected AP");
return WIFI_ERROR_NO_CONNECTION;
}
return WIFI_ERROR_NONE;
}
-bool _wifi_libnet_foreach_found_aps(wifi_found_ap_cb callback, void *user_data)
+int _wifi_libnet_foreach_found_aps(wifi_found_ap_cb callback, void *user_data)
{
- int i = 0;
- bool rv = true;
+ int i, rv;
- __libnet_update_profile_iterator();
+ rv = __libnet_update_profile_iterator();
+ if (rv == NET_ERR_ACCESS_DENIED) {
+ WIFI_LOG(WIFI_ERROR, "Access denied");
+ return WIFI_ERROR_PERMISSION_DENIED;
+ }
if (profile_iterator.count == 0) {
- WIFI_LOG(WIFI_INFO, "There is no APs.\n");
- return true;
+ WIFI_LOG(WIFI_WARN, "There is no AP");
+ return WIFI_ERROR_NONE;
}
- for (;i < profile_iterator.count;i++) {
+ for (i = 0; i < profile_iterator.count; i++) {
+ if (profile_iterator.profiles[i].ProfileInfo.Wlan.is_hidden == TRUE)
+ continue;
+
rv = callback((wifi_ap_h)(&profile_iterator.profiles[i]), user_data);
if (rv == false) break;
}
- return true;
+ return WIFI_ERROR_NONE;
}
-bool _wifi_libnet_foreach_found_hidden_aps(wifi_found_ap_cb callback, void *user_data)
+int _wifi_libnet_foreach_found_specific_aps(wifi_found_ap_cb callback, void *user_data)
{
- int i = 0;
- bool rv = true;
+ int i, rv;
+
+ if (specific_profile_iterator.count == 0) {
+ WIFI_LOG(WIFI_WARN, "There is no specific APs");
+
+ rv = __libnet_update_profile_iterator();
+ if (rv == NET_ERR_ACCESS_DENIED) {
+ WIFI_LOG(WIFI_ERROR, "Access denied");
+ return WIFI_ERROR_PERMISSION_DENIED;
+ }
+
+ if (profile_iterator.count == 0) {
+ WIFI_LOG(WIFI_WARN, "There is no APs");
+ return WIFI_ERROR_NONE;
+ }
- if (hidden_profile_iterator.count == 0) {
- WIFI_LOG(WIFI_INFO, "There is no hidden APs.\n");
- return true;
+ for (i = 0; i < profile_iterator.count; i++) {
+ if (!g_strcmp0(specific_profile_essid,
+ profile_iterator.profiles[i].ProfileInfo.Wlan.essid)) {
+ rv = callback((wifi_ap_h)(&profile_iterator.profiles[i]), user_data);
+ if (rv == false) break;
+ }
+ }
+ return WIFI_ERROR_NONE;
}
- for (;i < hidden_profile_iterator.count;i++) {
- rv = callback((wifi_ap_h)(&hidden_profile_iterator.profiles[i]), user_data);
+ for (i = 0; i < specific_profile_iterator.count; i++) {
+ rv = callback((wifi_ap_h)(&specific_profile_iterator.profiles[i]), user_data);
if (rv == false) break;
}
- return true;
+ return WIFI_ERROR_NONE;
}
int _wifi_libnet_open_profile(wifi_ap_h ap_h, wifi_connected_cb callback, void *user_data)
{
int rv;
bool valid_profile;
- net_profile_name_t profile_name;
net_profile_info_t *ap_info = ap_h;
- g_strlcpy(profile_name.ProfileName, ap_info->ProfileName, NET_PROFILE_NAME_LEN_MAX+1);
-
valid_profile =
- _wifi_libnet_check_profile_name_validity(profile_name.ProfileName);
+ _wifi_libnet_check_profile_name_validity(ap_info->ProfileName);
if (valid_profile == true && ap_info->Favourite)
- rv = net_open_connection_with_profile(profile_name.ProfileName);
+ rv = net_open_connection_with_profile(ap_info->ProfileName);
else if (valid_profile == true &&
- ap_info->ProfileInfo.Wlan.security_info.sec_mode == WLAN_SEC_MODE_NONE)
- rv = net_open_connection_with_profile(profile_name.ProfileName);
+ ap_info->ProfileInfo.Wlan.is_hidden != TRUE &&
+ ap_info->ProfileInfo.Wlan.security_info.sec_mode ==
+ WLAN_SEC_MODE_NONE)
+ rv = net_open_connection_with_profile(ap_info->ProfileName);
else
rv = __libnet_connect_with_wifi_info(ap_info);
- if (rv != NET_ERR_NONE)
+ rv = __libnet_convert_to_ap_error_type(rv);
+ if (rv == WIFI_ERROR_NONE)
+ __libnet_set_connected_cb(callback, user_data);
+
+ return rv;
+}
+
+int _wifi_libnet_close_profile(wifi_ap_h ap_h, wifi_disconnected_cb callback, void *user_data)
+{
+ int rv;
+ net_profile_info_t *ap_info = ap_h;
+
+ rv = net_close_connection(ap_info->ProfileName);
+ if (rv == NET_ERR_ACCESS_DENIED) {
+ WIFI_LOG(WIFI_ERROR, "Access denied");
+ return WIFI_ERROR_PERMISSION_DENIED;
+ } else if (rv != NET_ERR_NONE)
return WIFI_ERROR_OPERATION_FAILED;
- __libnet_set_connected_cb(callback, user_data);
+ __libnet_set_disconnected_cb(callback, user_data);
return WIFI_ERROR_NONE;
}
-int _wifi_libnet_close_profile(wifi_ap_h ap_h, wifi_disconnected_cb callback, void *user_data)
+int _wifi_libnet_connect_with_wps_pbc(wifi_ap_h ap_h, wifi_connected_cb callback, void *user_data)
{
+ int rv;
net_profile_info_t *ap_info = ap_h;
- net_profile_name_t profile_name;
+ net_wifi_wps_info_t wps_info;
+ memset(&wps_info, 0, sizeof(net_wifi_wps_info_t));
- g_strlcpy(profile_name.ProfileName, ap_info->ProfileName, NET_PROFILE_NAME_LEN_MAX+1);
+ wps_info.type = WIFI_WPS_PBC;
- if (net_close_connection(profile_name.ProfileName) != NET_ERR_NONE)
+ rv = net_wifi_enroll_wps(ap_info->ProfileName, &wps_info);
+ if (rv == NET_ERR_ACCESS_DENIED) {
+ WIFI_LOG(WIFI_ERROR, "Access denied");
+ return WIFI_ERROR_PERMISSION_DENIED;
+ } else if (rv != NET_ERR_NONE)
return WIFI_ERROR_OPERATION_FAILED;
- __libnet_set_disconnected_cb(callback, user_data);
+ __libnet_set_connected_cb(callback, user_data);
return WIFI_ERROR_NONE;
}
-int _wifi_libnet_connect_with_wps(wifi_ap_h ap_h, wifi_connected_cb callback, void *user_data)
+int _wifi_libnet_connect_with_wps_pin(wifi_ap_h ap_h, const char *pin,
+ wifi_connected_cb callback, void *user_data)
{
+ int rv;
net_profile_info_t *ap_info = ap_h;
net_wifi_wps_info_t wps_info;
- net_profile_name_t profile_name;
- memset(&wps_info, 0 , sizeof(net_wifi_wps_info_t));
- g_strlcpy(profile_name.ProfileName, ap_info->ProfileName, NET_PROFILE_NAME_LEN_MAX+1);
+ if (ap_info == NULL) {
+ WIFI_LOG(WIFI_ERROR, "Invalid parameter");
+ return WIFI_ERROR_INVALID_PARAMETER;
+ }
- wps_info.type = WIFI_WPS_PBC;
+ wps_info.type = WIFI_WPS_PIN;
+ g_strlcpy(wps_info.pin, pin, NET_WLAN_MAX_WPSPIN_LEN + 1);
- if (net_wifi_enroll_wps(profile_name.ProfileName, &wps_info) != NET_ERR_NONE)
+ rv = net_wifi_enroll_wps(ap_info->ProfileName, &wps_info);
+ if (rv == NET_ERR_ACCESS_DENIED) {
+ WIFI_LOG(WIFI_ERROR, "Access denied");
+ return WIFI_ERROR_PERMISSION_DENIED;
+ } else if (rv != NET_ERR_NONE)
return WIFI_ERROR_OPERATION_FAILED;
__libnet_set_connected_cb(callback, user_data);
int _wifi_libnet_forget_ap(wifi_ap_h ap)
{
int rv = 0;
- net_profile_name_t profile_name;
net_profile_info_t *ap_info = ap;
- g_strlcpy(profile_name.ProfileName, ap_info->ProfileName, NET_PROFILE_NAME_LEN_MAX+1);
+ if (ap_info == NULL) {
+ WIFI_LOG(WIFI_ERROR, "Invalid parameter");
+ return WIFI_ERROR_INVALID_PARAMETER;
+ }
- rv = net_delete_profile(profile_name.ProfileName);
- if (rv != NET_ERR_NONE)
+ rv = net_delete_profile(ap_info->ProfileName);
+ if (rv == NET_ERR_ACCESS_DENIED) {
+ WIFI_LOG(WIFI_ERROR, "Access denied");
+ return WIFI_ERROR_PERMISSION_DENIED;
+ } else if (rv != NET_ERR_NONE)
return WIFI_ERROR_OPERATION_FAILED;
+ ap_info->Favourite = (char)FALSE;
+
return WIFI_ERROR_NONE;
}
int _wifi_set_power_on_off_cb(wifi_device_state_changed_cb callback, void *user_data)
{
- if (wifi_callbacks.device_state_cb)
+ if (wifi_callbacks.device_state_cb != NULL)
return WIFI_ERROR_INVALID_OPERATION;
wifi_callbacks.device_state_cb = callback;
wifi_callbacks.device_state_user_data = user_data;
+ WIFI_LOG(WIFI_INFO, "Wi-Fi registered device state changed callback");
+
return WIFI_ERROR_NONE;
}
int _wifi_set_background_scan_cb(wifi_scan_finished_cb callback, void *user_data)
{
- if (wifi_callbacks.bg_scan_cb)
+ if (wifi_callbacks.bg_scan_cb != NULL)
return WIFI_ERROR_INVALID_OPERATION;
wifi_callbacks.bg_scan_cb = callback;
int _wifi_set_connection_state_cb(wifi_connection_state_changed_cb callback, void *user_data)
{
- if (wifi_callbacks.connection_state_cb)
+ if (wifi_callbacks.connection_state_cb != NULL)
return WIFI_ERROR_INVALID_OPERATION;
wifi_callbacks.connection_state_cb = callback;
int _wifi_update_ap_info(net_profile_info_t *ap_info)
{
- if (net_modify_profile(ap_info->ProfileName, ap_info) != NET_ERR_NONE)
+ 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");
+ return WIFI_ERROR_PERMISSION_DENIED;
+ } else if (rv != NET_ERR_NONE)
return WIFI_ERROR_OPERATION_FAILED;
return WIFI_ERROR_NONE;
}
+
+static void __wifi_idle_destroy_cb(gpointer data)
+{
+ if (!data)
+ return;
+
+ managed_idler_list = g_slist_remove(managed_idler_list, data);
+ g_free(data);
+}
+
+static gboolean __wifi_idle_cb(gpointer user_data)
+{
+ struct managed_idle_data *data = (struct managed_idle_data *)user_data;
+
+ if (!data)
+ return FALSE;
+
+ return data->func(data->user_data);
+}
+
+guint _wifi_callback_add(GSourceFunc func, gpointer user_data)
+{
+ guint id;
+ struct managed_idle_data *data;
+ GMainContext *context;
+ GSource *src;
+
+ if (!func)
+ return 0;
+
+ data = g_try_new0(struct managed_idle_data, 1);
+ if (!data)
+ 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, __wifi_idle_cb, data, __wifi_idle_destroy_cb);
+ id = g_source_attach(src, context);
+ g_source_unref(src);
+
+ if (!id) {
+ g_free(data);
+ return id;
+ }
+
+ data->id = id;
+
+ managed_idler_list = g_slist_append(managed_idler_list, data);
+
+ return id;
+}
+
+void _wifi_callback_cleanup(void)
+{
+ GSList *cur = managed_idler_list;
+ GSource *src;
+ struct managed_idle_data *data;
+
+ while (cur) {
+ GSList *next = cur->next;
+ data = (struct managed_idle_data *)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;
+}
+
+int _wifi_check_feature_supported(const char *feature_name)
+{
+ if (is_feature_checked) {
+ if (!feature_supported) {
+ LOGE("%s feature is disabled", feature_name);
+ return WIFI_ERROR_NOT_SUPPORTED;
+ }
+ } else {
+ if (!system_info_get_platform_bool(feature_name, &feature_supported)) {
+ is_feature_checked = true;
+ if (!feature_supported) {
+ LOGE("%s feature is disabled", feature_name);
+ return WIFI_ERROR_NOT_SUPPORTED;
+ }
+ } else {
+ LOGE("Error - Feature getting from System Info");
+ return WIFI_ERROR_OPERATION_FAILED;
+ }
+ }
+
+ return WIFI_ERROR_NONE;
+}
+
+int _wifi_dbus_init(void)
+{
+ int rv;
+
+ rv = wifi_dbus_init(&g_dbus_h);
+ if (rv != NET_ERR_NONE)
+ return rv;
+
+ return NET_ERR_NONE;
+}
+
+int _wifi_dbus_deinit(void)
+{
+ wifi_dbus_deinit(g_dbus_h);
+ g_dbus_h = NULL;
+
+ return NET_ERR_NONE;
+}
+
+wifi_dbus *_wifi_get_dbus_handle(void)
+{
+ if (g_dbus_h == NULL) {
+ WIFI_LOG(WIFI_ERROR, "g_dbus_h is NULL");
+ return NULL;
+ }
+
+ return g_dbus_h;
+}
projects / platform / core / api / wifi.git / blobdiff