#define P2P_LISTEN_PERIOD 500
#define P2P_LISTEN_INTERVAL 2000
+
static struct connman_technology *wifi_technology = NULL;
static struct connman_technology *p2p_technology = NULL;
int servicing;
#if defined TIZEN_EXT
int assoc_retry_count;
- struct connman_network *interface_disconnected_network;
struct connman_network *scan_pending_network;
+ bool allow_full_scan;
#endif
+ int disconnect_code;
+ int assoc_code;
};
#if defined TIZEN_EXT
#include "connman.h"
-#define TIZEN_ASSOC_RETRY_COUNT 3
+#define TIZEN_ASSOC_RETRY_COUNT 4
static gboolean wifi_first_scan = false;
static gboolean found_with_first_scan = false;
static gboolean is_wifi_notifier_registered = false;
#endif
+
static GList *iface_list = NULL;
static GList *pending_wifi_device = NULL;
struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
struct peer_service_registration *reg_data = user_data;
+#if defined TIZEN_EXT
+ if (!wifi)
+ return;
+#endif
+
DBG("");
if (result == 0)
if (wifi->tethering)
return -EBUSY;
-
+#if defined TIZEN_EXT
+ if (connman_device_get_scanning(device) && !wifi->allow_full_scan)
+#else
if (connman_device_get_scanning(device))
+#endif
return -EALREADY;
connman_device_ref(device);
return scan_callback(ret, interface, user_data);
}
- scanning = connman_device_get_scanning(device);
+#if defined TIZEN_EXT
+ if (wifi && wifi->allow_full_scan) {
+ int ret;
+ DBG("Trigger Full Channel Scan");
+ wifi->allow_full_scan = FALSE;
- if (scanning) {
+ ret = g_supplicant_interface_scan(wifi->interface, NULL,
+ scan_callback, device);
+ if (ret == 0)
+ return;
+
+ /* On error, let's recall scan_callback, which will cleanup */
+ return scan_callback(ret, interface, user_data);
+ }
+#endif
+
+ scanning = connman_device_get_scanning(device);
+ if (scanning)
connman_device_set_scanning(device,
CONNMAN_SERVICE_TYPE_WIFI, false);
- }
if (result != -ENOLINK)
#if defined TIZEN_EXT
connman_device_unref(device);
#if defined TIZEN_EXT
- if (wifi && wifi->scan_pending_network) {
+ if (wifi && wifi->scan_pending_network && result != -EIO) {
network_connect(wifi->scan_pending_network);
wifi->scan_pending_network = NULL;
+ connman_network_set_connecting(wifi->network);
}
if (is_wifi_notifier_registered != true &&
#if defined TIZEN_EXT
wifi->scan_pending_network = NULL;
- wifi->interface_disconnected_network = NULL;
if (is_wifi_notifier_registered == true) {
connman_notifier_unregister(¬ifier);
return ret;
}
+#if defined TIZEN_EXT
+static void specific_scan_callback(int result, GSupplicantInterface *interface,
+ void *user_data)
+{
+ struct connman_device *device = user_data;
+ struct wifi_data *wifi = connman_device_get_data(device);
+ bool scanning;
+
+ DBG("result %d wifi %p", result, wifi);
+
+ if (wifi && wifi->scan_params) {
+ g_supplicant_free_scan_params(wifi->scan_params);
+ wifi->scan_params = NULL;
+ }
+
+ scanning = connman_device_get_scanning(device);
+ if (scanning) {
+ connman_device_set_scanning(device,
+ CONNMAN_SERVICE_TYPE_WIFI, false);
+ connman_device_unref(device);
+ }
+}
+
+static int wifi_specific_scan(enum connman_service_type type,
+ struct connman_device *device, int scan_type,
+ GSList *specific_scan_list, void *user_data)
+{
+ GSList *list = NULL;
+ char *ssid = NULL;
+ struct wifi_data *wifi = connman_device_get_data(device);
+ GSupplicantScanParams *scan_params = NULL;
+ struct scan_ssid *scan_ssid = NULL;
+ bool scanning;
+ int ret;
+ int freq;
+ int count = 0;
+
+ if (!wifi)
+ return -ENODEV;
+
+ if (wifi->p2p_device)
+ return 0;
+
+ if (type == CONNMAN_SERVICE_TYPE_P2P)
+ return p2p_find(device);
+
+ if (wifi->tethering)
+ return 0;
+
+ scanning = connman_device_get_scanning(device);
+ if (scanning)
+ return -EALREADY;
+
+ DBG("scan_type: %d", scan_type);
+ if (scan_type == 1) { /* ssid based scan */
+ scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
+ if (!scan_params) {
+ DBG("Failed to allocate memory.");
+ return -ENOMEM;
+ }
+
+ for (list = specific_scan_list; list; list = list->next) {
+ ssid = (char *)list->data;
+ int ssid_len = strlen(ssid);
+
+ scan_ssid = g_try_new0(struct scan_ssid, 1);
+ if (!scan_ssid) {
+ DBG("Failed to allocate memory.");
+ g_supplicant_free_scan_params(scan_params);
+ return -ENOMEM;
+ }
+
+ memcpy(scan_ssid->ssid, ssid, (ssid_len + 1));
+ DBG("scan ssid %s len: %d", scan_ssid->ssid, ssid_len);
+ scan_ssid->ssid_len = ssid_len;
+ scan_params->ssids = g_slist_prepend(scan_params->ssids, scan_ssid);
+ count++;
+ }
+ scan_params->num_ssids = count;
+
+ } else if (scan_type == 2) { /* frequency based scan */
+
+ scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
+ if (!scan_params) {
+ DBG("Failed to allocate memory.");
+ return -ENOMEM;
+ }
+
+ guint num_freqs = g_slist_length(specific_scan_list);
+ DBG("num_freqs: %d", num_freqs);
+
+ scan_params->freqs = g_try_new0(uint16_t, num_freqs);
+ if (!scan_params->freqs) {
+ DBG("Failed to allocate memory.");
+ g_free(scan_params);
+ return -ENOMEM;
+ }
+
+ count = 0;
+ for (list = specific_scan_list; list; list = list->next) {
+ freq = (int)list->data;
+
+ scan_params->freqs[count] = freq;
+ DBG("scan_params->freqs[%d]: %d", count, scan_params->freqs[count]);
+ count++;
+ }
+ scan_params->num_freqs = count;
+
+ } else {
+ DBG("Invalid scan");
+ return -EINVAL;
+ }
+
+ reset_autoscan(device);
+ connman_device_ref(device);
+
+ ret = g_supplicant_interface_scan(wifi->interface, scan_params,
+ specific_scan_callback, device);
+
+ if (ret == 0) {
+ connman_device_set_scanning(device,
+ CONNMAN_SERVICE_TYPE_WIFI, true);
+ } else {
+ g_supplicant_free_scan_params(scan_params);
+ connman_device_unref(device);
+ }
+
+ return ret;
+}
+#endif
+
/*
* Note that the hidden scan is only used when connecting to this specific
* hidden AP first time. It is not used when system autoconnects to hidden AP.
reset_autoscan(device);
-#if defined TIZEN_EXT
- if (wifi->hidden) {
- ret = g_supplicant_interface_scan(wifi->interface, scan_params,
- scan_callback, device);
- }
- else {
- ret = g_supplicant_interface_scan(wifi->interface, NULL,
- scan_callback_hidden, device);
- }
-#else
ret = g_supplicant_interface_scan(wifi->interface, scan_params,
scan_callback, device);
-#endif
+
if (ret == 0) {
connman_device_set_scanning(device,
CONNMAN_SERVICE_TYPE_WIFI, true);
+#if defined TIZEN_EXT
+ /*To allow the Full Scan after ssid based scan, set the flag here
+ It is required because Tizen does not use the ConnMan specific
+ backgroung Scan feature.Tizen has added the BG Scan feature in
+ net-config. To sync with up ConnMan, we need to issue the Full Scan
+ after SSID specific scan.*/
+ wifi->allow_full_scan = TRUE;
+#endif
} else {
g_supplicant_free_scan_params(scan_params);
connman_device_unref(device);
.disable = wifi_disable,
.scan = wifi_scan,
.set_regdom = wifi_set_regdom,
+#if defined TIZEN_EXT
+ .specific_scan = wifi_specific_scan,
+#endif
};
static void system_ready(void)
if (wifi->scan_pending_network == network)
wifi->scan_pending_network = NULL;
-
- if (wifi->interface_disconnected_network == network)
- wifi->interface_disconnected_network = NULL;
#endif
}
return;
found:
- wifi->interface_disconnected_network = NULL;
#endif
if (result == -ENOKEY) {
connman_network_set_error(network,
return G_SUPPLICANT_SECURITY_PSK;
else if (g_str_equal(security, "ieee8021x"))
return G_SUPPLICANT_SECURITY_IEEE8021X;
+#if defined TIZEN_EXT
+ else if (g_str_equal(security, "ft_psk") == TRUE)
+ return G_SUPPLICANT_SECURITY_FT_PSK;
+ else if (g_str_equal(security, "ft_ieee8021x") == TRUE)
+ return G_SUPPLICANT_SECURITY_FT_IEEE8021X;
+#endif
return G_SUPPLICANT_SECURITY_UNKNOWN;
}
#if defined TIZEN_EXT
ssid->bssid = connman_network_get_bssid(network);
#endif
+#if defined TIZEN_EXT
+ ssid->freq = connman_network_get_frequency(network);
+#endif
if (connman_setting_get_bool("BackgroundScanning"))
ssid->bgscan = BGSCAN_DEFAULT;
ssid_init(ssid, network);
-#if defined TIZEN_EXT
- if (wifi->interface_disconnected_network == network) {
- g_free(ssid);
- throw_wifi_scan(device, scan_callback);
-
- if (wifi->disconnecting != TRUE) {
- wifi->scan_pending_network = network;
- wifi->interface_disconnected_network = NULL;
- }
-
- return -EINPROGRESS;
- }
-#endif
-
if (wifi->disconnecting) {
wifi->pending_network = network;
g_free(ssid);
wifi->network = connman_network_ref(network);
wifi->retries = 0;
#if defined TIZEN_EXT
- wifi->interface_disconnected_network = NULL;
wifi->scan_pending_network = NULL;
#endif
if (wifi->scan_pending_network == network)
wifi->scan_pending_network = NULL;
- if (wifi->interface_disconnected_network == network)
- wifi->interface_disconnected_network = NULL;
#endif
connman_network_set_associating(network, false);
security = connman_network_get_string(network, "WiFi.Security");
- if (g_str_equal(security, "ieee8021x") == true &&
+ if (security && g_str_equal(security, "ieee8021x") == true &&
wifi->state == G_SUPPLICANT_STATE_ASSOCIATED) {
wifi->retries = 0;
connman_network_set_error(network, CONNMAN_NETWORK_ERROR_INVALID_KEY);
wifi->retries = 0;
connman_network_set_error(network, CONNMAN_NETWORK_ERROR_INVALID_KEY);
-#if defined TIZEN_EXT
- /* not retry autoconnect in case of invalid-key error */
- __connman_service_set_autoconnect(service, false);
-#endif
-
return false;
}
}
security = connman_network_get_string(network, "WiFi.Security");
- if (g_str_equal(security, "ieee8021x") == true &&
+ if (security && g_str_equal(security, "ieee8021x") == true &&
wifi->state == G_SUPPLICANT_STATE_ASSOCIATED) {
wifi->assoc_retry_count = 0;
return false;
* however QA team recommends that the invalid-key error
* might be better to display for user experience.
*/
- connman_network_set_error(network, CONNMAN_NETWORK_ERROR_INVALID_KEY);
+ connman_network_set_error(network, CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
return false;
}
reset_autoscan(device);
wifi->assoc_retry_count = 0;
+
+ wifi->scan_pending_network = NULL;
+
+ /* should be cleared scanning flag */
+ bool scanning = connman_device_get_scanning(device);
+ if (scanning){
+ connman_device_set_scanning(device,
+ CONNMAN_SERVICE_TYPE_WIFI, false);
+ connman_device_unref(device);
+ }
#else
/* though it should be already stopped: */
stop_autoscan(device);
break;
connman_network_set_connected(network, true);
+ wifi->disconnect_code = 0;
+ wifi->assoc_code = 0;
break;
case G_SUPPLICANT_STATE_DISCONNECTED:
network, wifi))
break;
+ /* See table 8-36 Reason codes in IEEE Std 802.11 */
+ switch (wifi->disconnect_code) {
+ case 1: /* Unspecified reason */
+ /* Let's assume it's because we got blocked */
+
+ case 6: /* Class 2 frame received from nonauthenticated STA */
+ connman_network_set_error(network,
+ CONNMAN_NETWORK_ERROR_BLOCKED);
+ break;
+
+ default:
+ break;
+ }
+
+
/* We disable the selected network, if not then
* wpa_supplicant will loop retrying */
if (g_supplicant_interface_enable_selected_network(interface,
DBG("Could not disables selected network");
#if defined TIZEN_EXT
+ int err;
+
+ err = g_supplicant_interface_remove_network(wifi->interface);
+ if (err < 0)
+ DBG("Failed to remove network(%d)", err);
+
+
/* Some of Wi-Fi networks are not comply Wi-Fi specification.
* Retry association until its retry count is expired */
if (handle_wifi_assoc_retry(network, wifi) == true) {
break;
}
+ if(wifi->disconnect_code > 0){
+ DBG("Set disconnect reason code(%d)", wifi->disconnect_code);
+ connman_network_set_disconnect_reason(network, wifi->disconnect_code);
+ }
+
/* To avoid unnecessary repeated association in wpa_supplicant,
* "RemoveNetwork" should be made when Wi-Fi is disconnected */
if (wps != true && wifi->network && wifi->disconnecting == false) {
-#if 0 /* temporary disabled */
- int err;
-
wifi->disconnecting = true;
err = g_supplicant_interface_disconnect(wifi->interface,
disconnect_callback, wifi->network);
if (err < 0)
wifi->disconnecting = false;
-#endif
-
- if (wifi->connected)
- wifi->interface_disconnected_network = wifi->network;
- else
- wifi->interface_disconnected_network = NULL;
connman_network_set_connected(network, false);
connman_network_set_associating(network, false);
{
#if defined TIZEN_EXT
struct wifi_data *wifi;
+ bool is_associating = false;
+ static bool is_scanning = true;
#endif
DBG("");
network_connect(wifi->scan_pending_network);
wifi->scan_pending_network = NULL;
}
+
+ //service state - associating
+ if(!wifi || !wifi->network)
+ return;
+
+ is_associating = connman_network_get_associating(wifi->network);
+ if(is_associating && is_scanning){
+ is_scanning = false;
+ DBG("send scan for connecting");
+ throw_wifi_scan(wifi->device, scan_callback);
+
+ return;
+ }
+ is_scanning = true;
+
+ //go scan
+
#endif
}
unsigned char strength;
strength = 120 + g_supplicant_network_get_signal(supplicant_network);
+
+#if !defined TIZEN_EXT
if (strength > 100)
strength = 100;
-
+#endif
return strength;
}
bool wps_ready;
bool wps_advertizing;
+#if defined TIZEN_EXT
+ const char *wifi_vsie;
+ unsigned int wifi_vsie_len;
+#endif
+
mode = g_supplicant_network_get_mode(supplicant_network);
identifier = g_supplicant_network_get_identifier(supplicant_network);
ssid = g_supplicant_network_get_ssid(supplicant_network, &ssid_len);
+#if defined TIZEN_EXT
+ wifi_vsie = g_supplicant_network_get_wifi_vsie(supplicant_network, &wifi_vsie_len);
+#endif
network = connman_device_get_network(wifi->device, identifier);
if (!network) {
connman_network_set_blob(network, "WiFi.SSID",
ssid, ssid_len);
+#if defined TIZEN_EXT
+ if(wifi_vsie_len > 0 && wifi_vsie)
+ connman_network_set_blob(network, "WiFi.Vsie",
+ wifi_vsie, wifi_vsie_len);
+#endif
connman_network_set_string(network, "WiFi.Security", security);
connman_network_set_strength(network,
calculate_strength(supplicant_network));
g_supplicant_network_get_maxrate(supplicant_network));
connman_network_set_enc_mode(network,
g_supplicant_network_get_enc_mode(supplicant_network));
+ connman_network_set_rsn_mode(network,
+ g_supplicant_network_get_rsn_mode(supplicant_network));
+ connman_network_set_keymgmt(network,
+ g_supplicant_network_get_keymgmt(supplicant_network));
#endif
connman_network_set_available(network, true);
connman_network_set_string(network, "WiFi.Mode", mode);
#endif
if (wifi->hidden && ssid) {
+#if defined TIZEN_EXT
+ if (network_security(wifi->hidden->security) ==
+ network_security(security) &&
+#else
if (!g_strcmp0(wifi->hidden->security, security) &&
+#endif
wifi->hidden->ssid_len == ssid_len &&
!memcmp(wifi->hidden->ssid, ssid, ssid_len)) {
connman_network_connect_hidden(network,
if (connman_network == wifi->scan_pending_network)
wifi->scan_pending_network = NULL;
- if (connman_network == wifi->interface_disconnected_network)
- wifi->interface_disconnected_network = NULL;
-
if (connman_network == wifi->pending_network)
wifi->pending_network = NULL;
struct connman_peer *connman_peer;
const char *identifier, *name;
int ret;
-
+#if defined TIZEN_EXT
+ if (!wifi)
+ return;
+#endif
identifier = g_supplicant_peer_get_identifier(peer);
name = g_supplicant_peer_get_name(peer);
struct connman_peer *connman_peer;
const char *identifier;
+#if defined TIZEN_EXT
+ if (!wifi)
+ return;
+#endif
+
identifier = g_supplicant_peer_get_identifier(peer);
DBG("ident: %s", identifier);
struct connman_peer *connman_peer;
const char *identifier;
+#if defined TIZEN_EXT
+ if (!wifi)
+ return;
+#endif
+
identifier = g_supplicant_peer_get_identifier(peer);
DBG("ident: %s", identifier);
connman_debug("%s", str);
}
+static void disconnect_reasoncode(GSupplicantInterface *interface,
+ int reasoncode)
+{
+ struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
+ if (wifi != NULL) {
+ wifi->disconnect_code = reasoncode;
+ }
+}
+
+static void assoc_status_code(GSupplicantInterface *interface, int status_code)
+{
+ struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
+
+#if defined TIZEN_EXT
+ struct connman_network *network;
+#endif
+
+ if (wifi != NULL) {
+ wifi->assoc_code = status_code;
+
+#if defined TIZEN_EXT
+ network = wifi->network;
+ connman_network_set_assoc_status_code(network,status_code);
+#endif
+
+ }
+}
+
static const GSupplicantCallbacks callbacks = {
.system_ready = system_ready,
.system_killed = system_killed,
.system_power_off = system_power_off,
.network_merged = network_merged,
#endif
+ .disconnect_reasoncode = disconnect_reasoncode,
+ .assoc_status_code = assoc_status_code,
.debug = debug,
};
projects / platform / upstream / connman.git / blobdiff