void wsc_supplicant_event_overlap()
{
wpa_printf(MSG_INFO,"wsc_supplicant: wsc_supplicant_event_overlap: PBC overlapped event occured\n");
wpa_supplicant_disassociate(WscSupplicantConfig.wpa_s, REASON_DEAUTH_LEAVING);
}
static int wpa_supplicant_ctrl_iface_remove_network(
struct wpa_supplicant *wpa_s, char *cmd)
{
int id;
struct wpa_ssid *ssid;
/* cmd: "<network id>" */
id = atoi(cmd);
wpa_printf(MSG_DEBUG, "CTRL_IFACE: REMOVE_NETWORK id=%d", id);
ssid = wpa_config_get_network(wpa_s->conf, id);
if (ssid == NULL ||
wpa_config_remove_network(wpa_s->conf, id) < 0) {
wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find network "
"id=%d", id);
return -1;
}
if (ssid == wpa_s->current_ssid) {
/*
* Invalidate the EAP session cache if the current network is
* removed.
*/
eapol_sm_invalidate_cached_session(wpa_s->eapol);
wpa_supplicant_disassociate(wpa_s, REASON_DEAUTH_LEAVING);
}
return 0;
}
void wpa_supplicant_disassociate_helper(void *ctx,
int reason_code)
{
struct wpa_supplicant *wpa_s = (struct wpa_supplicant *)ctx;
wpa_supplicant_disassociate(wpa_s, reason_code);
}
/**
* wpas_dbus_iface_disconnect - Terminate the current connection
* @message: Pointer to incoming dbus message
* @wpa_s: wpa_supplicant structure for a network interface
* Returns: A dbus message containing a UINT32 indicating success (1) or
* failure (0)
*
* Handler function for "disconnect" method call of network interface.
*/
DBusMessage * wpas_dbus_iface_disconnect(DBusMessage *message,
struct wpa_supplicant *wpa_s)
{
wpa_s->disconnected = 1;
wpa_supplicant_disassociate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
return wpas_dbus_new_success_reply(message);
}
static void wsc_supplicant_PushButtonWalktimeTimeout(void *eloop_ctx, void *timeout_ctx)
{
wpa_printf(MSG_INFO,"wsc_supplicant: wsc_supplicant_PushButtonWalktimeTimeout: 2 Min.Push-Button walk-time timed out.");
wpa_supplicant_disassociate(WscSupplicantConfig.wpa_s, REASON_DEAUTH_LEAVING);
wpa_drv_disassociate((struct wpa_supplicant *)WscSupplicantConfig.wpa_s, ((struct wpa_supplicant*)WscSupplicantConfig.wpa_s)->bssid, REASON_DEAUTH_LEAVING);
}
static int wpa_supplicant_ctrl_iface_disable_network(
struct wpa_supplicant *wpa_s, char *cmd)
{
int id;
struct wpa_ssid *ssid;
/* cmd: "<network id>" or "all" */
if (os_strcmp(cmd, "all") == 0) {
wpa_printf(MSG_DEBUG, "CTRL_IFACE: DISABLE_NETWORK all");
ssid = wpa_s->conf->ssid;
while (ssid) {
ssid->disabled = 1;
ssid = ssid->next;
}
if (wpa_s->current_ssid)
wpa_supplicant_disassociate(wpa_s,
WLAN_REASON_DEAUTH_LEAVING);
return 0;
}
id = atoi(cmd);
wpa_printf(MSG_DEBUG, "CTRL_IFACE: DISABLE_NETWORK id=%d", id);
ssid = wpa_config_get_network(wpa_s->conf, id);
if (ssid == NULL) {
wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find network "
"id=%d", id);
return -1;
}
#ifdef ANDROID
if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not disable WPS network "
"id=%d", id);
return -1;
}
#endif
if (ssid == wpa_s->current_ssid)
wpa_supplicant_disassociate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
ssid->disabled = 1;
return 0;
}
/**
* wpas_dbus_iface_disable_network - Mark a configured network as disabled
* @message: Pointer to incoming dbus message
* @wpa_s: wpa_supplicant structure for a network interface
* @ssid: wpa_ssid structure for a configured network
* Returns: A dbus message containing a UINT32 indicating success (1) or
* failure (0)
*
* Handler function for "disable" method call of a configured network.
*/
DBusMessage * wpas_dbus_iface_disable_network(DBusMessage *message,
struct wpa_supplicant *wpa_s,
struct wpa_ssid *ssid)
{
if (ssid == wpa_s->current_ssid)
wpa_supplicant_disassociate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
ssid->disabled = 1;
return wpas_dbus_new_success_reply(message);
}
/**
* wpas_dbus_iface_remove_network - Remove a configured network
* @message: Pointer to incoming dbus message
* @wpa_s: wpa_supplicant structure for a network interface
* Returns: A dbus message containing a UINT32 indicating success (1) or
* failure (0)
*
* Handler function for "removeNetwork" method call of a network interface.
*/
DBusMessage * wpas_dbus_iface_remove_network(DBusMessage *message,
struct wpa_supplicant *wpa_s)
{
DBusMessage *reply = NULL;
const char *op;
char *iface = NULL, *net_id = NULL;
int id;
struct wpa_ssid *ssid;
if (!dbus_message_get_args(message, NULL,
DBUS_TYPE_OBJECT_PATH, &op,
DBUS_TYPE_INVALID)) {
reply = wpas_dbus_new_invalid_opts_error(message, NULL);
goto out;
}
/* Extract the network ID */
iface = wpas_dbus_decompose_object_path(op, &net_id, NULL);
if (iface == NULL) {
reply = wpas_dbus_new_invalid_network_error(message);
goto out;
}
/* Ensure the network is actually a child of this interface */
if (strcmp(iface, wpa_supplicant_get_dbus_path(wpa_s)) != 0) {
reply = wpas_dbus_new_invalid_network_error(message);
goto out;
}
id = strtoul(net_id, NULL, 10);
ssid = wpa_config_get_network(wpa_s->conf, id);
if (ssid == NULL) {
reply = wpas_dbus_new_invalid_network_error(message);
goto out;
}
if (wpa_config_remove_network(wpa_s->conf, id) < 0) {
reply = dbus_message_new_error(message,
WPAS_ERROR_REMOVE_NETWORK_ERROR,
"error removing the specified "
"on this interface.");
goto out;
}
if (ssid == wpa_s->current_ssid)
wpa_supplicant_disassociate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
reply = wpas_dbus_new_success_reply(message);
out:
free(iface);
free(net_id);
return reply;
}
static int wpa_supplicant_ctrl_iface_select_network(
struct wpa_supplicant *wpa_s, char *cmd)
{
int id;
struct wpa_ssid *ssid;
/* cmd: "<network id>" or "any" */
if (os_strcmp(cmd, "any") == 0) {
wpa_printf(MSG_DEBUG, "CTRL_IFACE: SELECT_NETWORK any");
ssid = wpa_s->conf->ssid;
while (ssid) {
ssid->disabled = 0;
ssid = ssid->next;
}
wpa_s->reassociate = 1;
wpa_supplicant_req_scan(wpa_s, 0, 0);
return 0;
}
id = atoi(cmd);
wpa_printf(MSG_DEBUG, "CTRL_IFACE: SELECT_NETWORK id=%d", id);
ssid = wpa_config_get_network(wpa_s->conf, id);
if (ssid == NULL) {
wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find network "
"id=%d", id);
return -1;
}
if (ssid != wpa_s->current_ssid && wpa_s->current_ssid)
wpa_supplicant_disassociate(wpa_s, REASON_DEAUTH_LEAVING);
/* Mark all other networks disabled and trigger reassociation */
ssid = wpa_s->conf->ssid;
while (ssid) {
ssid->disabled = id != ssid->id;
ssid = ssid->next;
}
wpa_s->reassociate = 1;
wpa_s->prev_scan_ssid = BROADCAST_SSID_SCAN;
wpa_supplicant_req_scan(wpa_s, 0, 0);
return 0;
}
static int wpa_supplicant_ctrl_iface_disable_network(
struct wpa_supplicant *wpa_s, char *cmd)
{
int id;
struct wpa_ssid *ssid;
/* cmd: "<network id>" */
id = atoi(cmd);
wpa_printf(MSG_DEBUG, "CTRL_IFACE: DISABLE_NETWORK id=%d", id);
ssid = wpa_config_get_network(wpa_s->conf, id);
if (ssid == NULL) {
wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find network "
"id=%d", id);
return -1;
}
if (ssid == wpa_s->current_ssid)
wpa_supplicant_disassociate(wpa_s, REASON_DEAUTH_LEAVING);
ssid->disabled = 1;
return 0;
}
struct wpa_scan_result *wps_select_ssid(struct wpa_supplicant *wpa_s,
struct wpa_scan_result *results,
int num, struct wpa_ssid **ssid)
{
struct wpa_scan_result *bss;
struct wpa_scan_result *selected = 0;
int num_good;
struct wpa_scan_result *maybe = 0;
int num_maybe;
struct wpa_ssid *tmp;
int ret = -1;
char *var, *value;
struct wps_data *data = 0;
char bssid_str[18+1];
char ssid_str[32+3];
u8 uuidSel[SIZE_UUID];
u8 uuidBss[SIZE_UUID];
size_t length;
struct wps_config *wps;
int i;
int is_push_button;
do {
if (!wpa_s || !wpa_s->conf || !results || !num || !ssid)
break;
wps = wpa_s->conf->wps;
is_push_button = (wps->dev_pwd_len == 8 &&
memcmp(wps->dev_pwd, "00000000", 8) == 0);
if (wps->nwid_trying_wps != -1) {
(void)wpa_config_remove_network(wpa_s->conf, wps->nwid_trying_wps);
wps->nwid_trying_wps = -1;
}
*ssid = 0;
num_good = 0;
num_maybe = 0;
for (i = 0; i < num; i++) {
bss = &results[i];
if (wps->filter_bssid_flag && memcmp(
wps->filter_bssid, bss->bssid, 6) != 0) {
continue;
}
if (wps->filter_ssid_length > 0 && memcmp(
wps->filter_ssid, bss->ssid,
wps->filter_ssid_length) != 0) {
continue;
}
if (bss->wps_ie_len) {
u16 dev_pwd_id;
do {
if (wps_create_wps_data(&data))
break;
if (wps_parse_wps_ie(bss->wps_ie, bss->wps_ie_len, data))
break;
length = sizeof(uuidBss);
/* selected bss UUID-E */
if (wps_get_value(data, WPS_TYPE_UUID_E, uuidBss, &length))
break;
if (wps_get_value(data, WPS_TYPE_DEVICE_PWD_ID, &dev_pwd_id, 0))
break;
if (is_push_button) {
if (WPS_DEVICEPWDID_PUSH_BTN != dev_pwd_id)
break;
} else { /* PIN mode */
if (WPS_DEVICEPWDID_DEFAULT != dev_pwd_id) {
break;
}
}
/* In the case of a dual-band AP and a dual-band station,
* the station may discover more than one Registrar in PBC mode.
* If the dual-band station does discover more than one Registrar
* in PBC mode, one each RF band, and the UUID in the Beacon and
* Probe-Response are the same for all RF bands, then the station
* shall not consider this to be a session overlap.
*/
if (num_good) {
/* check dual-band concurrent AP case */
if (((selected->freq >= 4000) && (bss->freq <= 3000)) ||
((selected->freq <= 3000) && (bss->freq >= 4000)))
{
/* one is 2.4GHz and another is 5GHz */
if (memcmp(uuidSel, uuidBss, length) == 0)
{
/* UUID-E of them are totally the same */
/* Select the 5GHz one */
if (bss->freq >= 4000)
selected = bss;
break;
}
}
}
selected = bss;
memcpy(&uuidSel, &uuidBss, length);
num_good++;
} while (0);
(void)wps_destroy_wps_data(&data);
/* If we have WPS at all then it's a maybe
* for PIN
*/
if (!is_push_button) {
num_maybe++;
if ((!maybe) || (bss->qual > maybe->qual)) {
maybe = bss;
}
}
} else {
/* No WPS IE */
/* If in open mode, it may support WPS...
* (some microsoft products)
* take it as a maybe
*/
if ((bss->caps & IEEE80211_CAP_PRIVACY) == 0) {
num_maybe++;
if ((!maybe) || (bss->qual > maybe->qual)) {
maybe = bss;
}
}
}
}
/* Push button mode must have exact explicit match.
* For PIN mode, due to greater security, we are willing
* to be more lenient; and due to the ambiguity of the WPS
* standard, it is not actually required that the AP
* advertise it's PIN mode (as versus PB mode
* which requires such advertisement).
* But we want either one good match, or if no good match,
* then just one maybe... otherwise the user should have
* done pre-filtering....
* for best results, the user should do pre-filtering!
*/
if (is_push_button) {
if (num_good > 1) {
wpa_msg(wpa_s, MSG_INFO,
"Must be only one AP enabled WPS-PBC");
break;
} else if (num_good == 1) {
/* good */
} else if (num_good == 0) {
wpa_msg(wpa_s, MSG_INFO,
"There are no APs which are enabled WPS-PBC");
break;
}
} else { /* PIN mode */
if (num_good > 1) {
wpa_msg(wpa_s, MSG_INFO,
"Must be only one AP enabled WPS-PIN");
break;
} else if (num_good == 1) {
/* good */
} else if (num_maybe > 1) {
wpa_msg(wpa_s, MSG_INFO,
"There are no APs which are enabled WPS-PIN"
" but attaching WPS IE, concern some microsoft products,"
" try to connect strongest RSSI one");
selected = maybe;
} else if (num_maybe == 1) {
/* select this one */
selected = maybe;
} else {
wpa_msg(wpa_s, MSG_INFO,
"There are no APs available for WPS");
break;
}
}
if (!selected)
break;
*ssid = wpa_config_add_network(wpa_s->conf);
if (!*ssid)
break;
wpa_config_set_network_defaults(*ssid);
(*ssid)->disabled = 1;
/* bssid */
var = "bssid";
os_snprintf(bssid_str, sizeof(bssid_str), "%02X:%02X:%02X:%02X:%02X:%02X",
selected->bssid[0], selected->bssid[1],
selected->bssid[2], selected->bssid[3],
selected->bssid[4], selected->bssid[5]);
bssid_str[18] = 0;
if (wpa_config_set(*ssid, var, bssid_str, 0))
break;
/* ssid */
var = "ssid";
ssid_str[0] = '"';
os_memcpy(ssid_str + 1, selected->ssid, selected->ssid_len);
ssid_str[selected->ssid_len + 1] = '"';
ssid_str[selected->ssid_len + 2] = 0;
if (wpa_config_set(*ssid, var, ssid_str, 0))
break;
/* auth_alg */
var = "auth_alg";
value = "OPEN";
if (wpa_config_set(*ssid, var, value, 0))
break;
/* key_mgmt */
var = "key_mgmt";
value = "IEEE8021X";
if (wpa_config_set(*ssid, var, value, 0))
break;
/* eap */
var = "eap";
value = "WPS";
if (wpa_config_set(*ssid, var, value, 0))
break;
/* identity */
var = "identity";
free((*ssid)->identity);
switch (wps->reg_mode) {
case WPS_SUPPLICANT_REGMODE_NONE:
value = WPS_IDENTITY_ENROLLEE;
break;
default:
value = WPS_IDENTITY_REGISTRAR;
break;
}
(*ssid)->identity = (u8 *)os_strdup(value);
(*ssid)->identity_len = os_strlen(value);
ret = 0;
} while (0);
if (ret) {
if (*ssid)
(void)wpa_config_remove_network(wpa_s->conf, (*ssid)->id);
selected = 0;
} else {
wpa_msg(wpa_s, MSG_INFO, "Found AP for WPS [%*s]", (*ssid)->ssid_len,(*ssid)->ssid);
switch (wps->reg_mode) {
case WPS_SUPPLICANT_REGMODE_NONE:
if (wps->config) {
free(wps->config);
wps->config = 0;
wps->config_len = 0;
}
break;
case WPS_SUPPLICANT_REGMODE_CONFIGURE_AP:
break;
case WPS_SUPPLICANT_REGMODE_REGISTER_AP:
case WPS_SUPPLICANT_REGMODE_REGISTER_STA:
if (wps->config) {
free(wps->config);
wps->config = 0;
wps->config_len = 0;
}
(void)wps_get_supplicant_ssid_configuration(wpa_s, (*ssid)->id, &wps->config, &wps->config_len);
break;
default:
break;
}
if (wpa_s->current_ssid)
wpa_supplicant_disassociate(wpa_s, REASON_DEAUTH_LEAVING);
tmp = wpa_s->conf->ssid;
while (tmp) {
#if 0 /* original from Sony */
tmp->disabled = (*ssid)->id != tmp->id;
#else
/* Set bit 1 of disabled as "temporary WPS bit" */
tmp->disabled = ((*ssid)->id != tmp->id) << 1;
#endif
tmp = tmp->next;
}
wps->nwid_trying_wps = (*ssid)->id;
wpa_s->reassociate = 1;
wpa_supplicant_req_scan(wpa_s, 0, 0);
}
return selected;
}
char * wpa_supplicant_ctrl_iface_process(struct wpa_supplicant *wpa_s,
char *buf, size_t *resp_len)
{
char *reply;
const int reply_size = 4096;
int ctrl_rsp = 0;
int reply_len;
if (os_strncmp(buf, WPA_CTRL_RSP, os_strlen(WPA_CTRL_RSP)) == 0 ||
os_strncmp(buf, "SET_NETWORK ", 12) == 0) {
wpa_hexdump_ascii_key(MSG_DEBUG, "RX ctrl_iface",
(const u8 *) buf, os_strlen(buf));
} else {
if (os_strcmp(buf, "PING") != 0)
wpa_hexdump_ascii(MSG_DEBUG, "RX ctrl_iface",
(const u8 *) buf, os_strlen(buf));
}
reply = os_malloc(reply_size);
if (reply == NULL) {
*resp_len = 1;
return NULL;
}
os_memcpy(reply, "OK\n", 3);
reply_len = 3;
if (os_strcmp(buf, "PING") == 0) {
os_memcpy(reply, "PONG\n", 5);
reply_len = 5;
} else if (os_strcmp(buf, "MIB") == 0) {
reply_len = wpa_sm_get_mib(wpa_s->wpa, reply, reply_size);
if (reply_len >= 0) {
int res;
res = eapol_sm_get_mib(wpa_s->eapol, reply + reply_len,
reply_size - reply_len);
if (res < 0)
reply_len = -1;
else
reply_len += res;
}
} else if (os_strncmp(buf, "STATUS", 6) == 0) {
reply_len = wpa_supplicant_ctrl_iface_status(
wpa_s, buf + 6, reply, reply_size);
} else if (os_strcmp(buf, "PMKSA") == 0) {
reply_len = pmksa_cache_list(wpa_s->wpa, reply, reply_size);
} else if (os_strncmp(buf, "SET ", 4) == 0) {
if (wpa_supplicant_ctrl_iface_set(wpa_s, buf + 4))
reply_len = -1;
} else if (os_strcmp(buf, "LOGON") == 0) {
eapol_sm_notify_logoff(wpa_s->eapol, FALSE);
} else if (os_strcmp(buf, "LOGOFF") == 0) {
eapol_sm_notify_logoff(wpa_s->eapol, TRUE);
} else if (os_strcmp(buf, "REASSOCIATE") == 0) {
wpa_s->disconnected = 0;
wpa_s->reassociate = 1;
wpa_supplicant_req_scan(wpa_s, 0, 0);
} else if (os_strcmp(buf, "RECONNECT") == 0) {
if (wpa_s->disconnected) {
wpa_s->disconnected = 0;
wpa_s->reassociate = 1;
wpa_supplicant_req_scan(wpa_s, 0, 0);
}
#ifdef IEEE8021X_EAPOL
} else if (os_strncmp(buf, "PREAUTH ", 8) == 0) {
if (wpa_supplicant_ctrl_iface_preauth(wpa_s, buf + 8))
reply_len = -1;
#endif /* IEEE8021X_EAPOL */
#ifdef CONFIG_PEERKEY
} else if (os_strncmp(buf, "STKSTART ", 9) == 0) {
if (wpa_supplicant_ctrl_iface_stkstart(wpa_s, buf + 9))
reply_len = -1;
#endif /* CONFIG_PEERKEY */
} else if (os_strncmp(buf, WPA_CTRL_RSP, os_strlen(WPA_CTRL_RSP)) == 0)
{
if (wpa_supplicant_ctrl_iface_ctrl_rsp(
wpa_s, buf + os_strlen(WPA_CTRL_RSP)))
reply_len = -1;
else
ctrl_rsp = 1;
} else if (os_strcmp(buf, "RECONFIGURE") == 0) {
if (wpa_supplicant_reload_configuration(wpa_s))
reply_len = -1;
} else if (os_strcmp(buf, "TERMINATE") == 0) {
eloop_terminate();
} else if (os_strncmp(buf, "BSSID ", 6) == 0) {
if (wpa_supplicant_ctrl_iface_bssid(wpa_s, buf + 6))
reply_len = -1;
#ifdef ANDROID
} else if (os_strncmp(buf, "BLACKLIST", 9) == 0) {
reply_len = wpa_supplicant_ctrl_iface_blacklist(
wpa_s, buf + 9, reply, reply_size);
if (os_strlen(buf) > 10 && reply_len == 0) {
struct wpa_blacklist *bl = wpa_s->blacklist;
if (os_strncmp(buf+10, "clear", 5) == 0 ||
(bl != NULL && os_memcmp(bl->bssid, wpa_s->bssid, ETH_ALEN) == 0)) {
wpa_s->disconnected = 0;
wpa_s->reassociate = 1;
wpa_supplicant_req_scan(wpa_s, 0, 0);
}
}
#endif
} else if (os_strcmp(buf, "LIST_NETWORKS") == 0) {
reply_len = wpa_supplicant_ctrl_iface_list_networks(
wpa_s, reply, reply_size);
} else if (os_strcmp(buf, "DISCONNECT") == 0) {
wpa_s->reassociate = 0;
wpa_s->disconnected = 1;
wpa_supplicant_disassociate(wpa_s, REASON_DEAUTH_LEAVING);
} else if (os_strcmp(buf, "SCAN") == 0) {
#ifdef ANDROID
if (!wpa_s->scan_ongoing && ((wpa_s->wpa_state <= WPA_SCANNING) ||
(wpa_s->wpa_state >= WPA_COMPLETED))) {
#endif
wpa_s->scan_req = 2;
wpa_supplicant_req_scan(wpa_s, 0, 0);
#ifdef ANDROID
} else {
wpa_printf(MSG_DEBUG, "Ongoing Scan action...");
}
#endif
} else if (os_strcmp(buf, "SCAN_RESULTS") == 0) {
reply_len = wpa_supplicant_ctrl_iface_scan_results(
wpa_s, reply, reply_size);
} else if (os_strncmp(buf, "SELECT_NETWORK ", 15) == 0) {
if (wpa_supplicant_ctrl_iface_select_network(wpa_s, buf + 15))
reply_len = -1;
} else if (os_strncmp(buf, "ENABLE_NETWORK ", 15) == 0) {
if (wpa_supplicant_ctrl_iface_enable_network(wpa_s, buf + 15))
reply_len = -1;
} else if (os_strncmp(buf, "DISABLE_NETWORK ", 16) == 0) {
if (wpa_supplicant_ctrl_iface_disable_network(wpa_s, buf + 16))
reply_len = -1;
} else if (os_strcmp(buf, "ADD_NETWORK") == 0) {
reply_len = wpa_supplicant_ctrl_iface_add_network(
wpa_s, reply, reply_size);
} else if (os_strncmp(buf, "REMOVE_NETWORK ", 15) == 0) {
if (wpa_supplicant_ctrl_iface_remove_network(wpa_s, buf + 15))
reply_len = -1;
} else if (os_strncmp(buf, "SET_NETWORK ", 12) == 0) {
if (wpa_supplicant_ctrl_iface_set_network(wpa_s, buf + 12))
reply_len = -1;
} else if (os_strncmp(buf, "GET_NETWORK ", 12) == 0) {
reply_len = wpa_supplicant_ctrl_iface_get_network(
wpa_s, buf + 12, reply, reply_size);
} else if (os_strcmp(buf, "SAVE_CONFIG") == 0) {
if (wpa_supplicant_ctrl_iface_save_config(wpa_s))
reply_len = -1;
} else if (os_strncmp(buf, "GET_CAPABILITY ", 15) == 0) {
reply_len = wpa_supplicant_ctrl_iface_get_capability(
wpa_s, buf + 15, reply, reply_size);
} else if (os_strncmp(buf, "AP_SCAN ", 8) == 0) {
if (wpa_supplicant_ctrl_iface_ap_scan(wpa_s, buf + 8))
reply_len = -1;
} else if (os_strcmp(buf, "INTERFACES") == 0) {
reply_len = wpa_supplicant_global_iface_interfaces(
wpa_s->global, reply, reply_size);
} else if (os_strncmp(buf, "DRIVER ", 7) == 0) {
reply_len = wpa_supplicant_driver_cmd(wpa_s, buf + 7, reply, reply_size);
} else {
os_memcpy(reply, "UNKNOWN COMMAND\n", 16);
reply_len = 16;
}
if (reply_len < 0) {
os_memcpy(reply, "FAIL\n", 5);
reply_len = 5;
}
if (ctrl_rsp)
eapol_sm_notify_ctrl_response(wpa_s->eapol);
*resp_len = reply_len;
return reply;
}
static void wpa_supplicant_event_assoc(struct wpa_supplicant *wpa_s,
union wpa_event_data *data)
{
u8 bssid[ETH_ALEN];
int ft_completed = wpa_ft_is_completed(wpa_s->wpa);
if (data)
wpa_supplicant_event_associnfo(wpa_s, data);
wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATED);
if (wpa_s->use_client_mlme)
os_memcpy(bssid, wpa_s->bssid, ETH_ALEN);
if (wpa_s->use_client_mlme ||
(wpa_drv_get_bssid(wpa_s, bssid) >= 0 &&
os_memcmp(bssid, wpa_s->bssid, ETH_ALEN) != 0)) {
wpa_msg(wpa_s, MSG_DEBUG, "Associated to a new BSS: BSSID="
MACSTR, MAC2STR(bssid));
os_memcpy(wpa_s->bssid, bssid, ETH_ALEN);
os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
if (wpa_supplicant_dynamic_keys(wpa_s) && !ft_completed) {
wpa_clear_keys(wpa_s, bssid);
}
if (wpa_supplicant_select_config(wpa_s) < 0) {
wpa_supplicant_disassociate(
wpa_s, WLAN_REASON_DEAUTH_LEAVING);
return;
}
}
wpa_msg(wpa_s, MSG_INFO, "Associated with " MACSTR, MAC2STR(bssid));
if (wpa_s->current_ssid) {
/* When using scanning (ap_scan=1), SIM PC/SC interface can be
* initialized before association, but for other modes,
* initialize PC/SC here, if the current configuration needs
* smartcard or SIM/USIM. */
wpa_supplicant_scard_init(wpa_s, wpa_s->current_ssid);
}
wpa_sm_notify_assoc(wpa_s->wpa, bssid);
l2_packet_notify_auth_start(wpa_s->l2);
/*
* Set portEnabled first to FALSE in order to get EAP state machine out
* of the SUCCESS state and eapSuccess cleared. Without this, EAPOL PAE
* state machine may transit to AUTHENTICATING state based on obsolete
* eapSuccess and then trigger BE_AUTH to SUCCESS and PAE to
* AUTHENTICATED without ever giving chance to EAP state machine to
* reset the state.
*/
if (!ft_completed) {
eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
}
if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) || ft_completed)
eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
/* 802.1X::portControl = Auto */
eapol_sm_notify_portEnabled(wpa_s->eapol, TRUE);
wpa_s->eapol_received = 0;
if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
wpa_supplicant_cancel_auth_timeout(wpa_s);
wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
} else if (!ft_completed) {
/* Timeout for receiving the first EAPOL packet */
wpa_supplicant_req_auth_timeout(wpa_s, 10, 0);
}
wpa_supplicant_cancel_scan(wpa_s);
if (wpa_s->driver_4way_handshake &&
wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
/*
* We are done; the driver will take care of RSN 4-way
* handshake.
*/
wpa_supplicant_cancel_auth_timeout(wpa_s);
wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
eapol_sm_notify_eap_success(wpa_s->eapol, TRUE);
}
if (wpa_s->pending_eapol_rx) {
struct os_time now, age;
os_get_time(&now);
os_time_sub(&now, &wpa_s->pending_eapol_rx_time, &age);
if (age.sec == 0 && age.usec < 100000 &&
os_memcmp(wpa_s->pending_eapol_rx_src, bssid, ETH_ALEN) ==
0) {
wpa_printf(MSG_DEBUG, "Process pending EAPOL frame "
"that was received just before association "
"notification");
wpa_supplicant_rx_eapol(
wpa_s, wpa_s->pending_eapol_rx_src,
wpabuf_head(wpa_s->pending_eapol_rx),
wpabuf_len(wpa_s->pending_eapol_rx));
}
wpabuf_free(wpa_s->pending_eapol_rx);
wpa_s->pending_eapol_rx = NULL;
}
}
static void wpa_supplicant_event_assoc(struct wpa_supplicant *wpa_s,
union wpa_event_data *data)
{
u8 bssid[ETH_ALEN];
int ft_completed = wpa_ft_is_completed(wpa_s->wpa);
if (data)
wpa_supplicant_event_associnfo(wpa_s, data);
#ifdef CONFIG_WAPI_SUPPORT
if (wpa_s->key_mgmt == WAPI_KEY_MGMT_CERT ||
wpa_s->key_mgmt == WAPI_KEY_MGMT_PSK) {
static int loop = 0;
/* To avoiding state LOOP case, otherwise HAL will disable interface*/
/*[ALPS00127420][Wi-Fi] Can not auto-reconnect WAPI-PSK AP after power off--> power on WAPI AP*/
if((wpa_s->wpa_state == WPA_4WAY_HANDSHAKE ||
wpa_s->wpa_state == WPA_GROUP_HANDSHAKE) && (loop >= 1 && loop <= 20)){
/*dont set state*/
wpa_printf(MSG_INFO, "%s: [Loop = %d] dont set_state", __FUNCTION__, loop);
loop++;
}else{
wpa_printf(MSG_INFO, "%s: [Loop = %d] set_state", __FUNCTION__, loop);
loop=1;
wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATED);
}
} else {
wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATED);
}
#else
wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATED);
#endif
if (wpa_s->use_client_mlme)
os_memcpy(bssid, wpa_s->bssid, ETH_ALEN);
if (wpa_s->use_client_mlme ||
(wpa_drv_get_bssid(wpa_s, bssid) >= 0 &&
os_memcmp(bssid, wpa_s->bssid, ETH_ALEN) != 0)) {
wpa_msg(wpa_s, MSG_DEBUG, "Associated to a new BSS: BSSID="
MACSTR, MAC2STR(bssid));
os_memcpy(wpa_s->bssid, bssid, ETH_ALEN);
os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
if (wpa_supplicant_dynamic_keys(wpa_s) && !ft_completed) {
wpa_clear_keys(wpa_s, bssid);
}
if (wpa_supplicant_select_config(wpa_s) < 0) {
wpa_supplicant_disassociate(
wpa_s, WLAN_REASON_DEAUTH_LEAVING);
return;
}
}
wpa_msg(wpa_s, MSG_INFO, "associated with " MACSTR, MAC2STR(bssid));
#ifdef CONFIG_WAPI_SUPPORT
if (wpa_s->key_mgmt == WAPI_KEY_MGMT_CERT ||
wpa_s->key_mgmt == WAPI_KEY_MGMT_PSK) {
MAC_ADDRESS bssid_s;
MAC_ADDRESS own_s;
/* stop WPA and other time out use WAPI time only */
wpa_supplicant_cancel_auth_timeout(wpa_s);
wpa_printf(MSG_DEBUG,"[Debug-WAPI] AP MAC address "MACSTR" Own MAC address"MACSTR"!!",
MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->own_addr));
if (is_zero_ether_addr(wpa_s->bssid)){
wpa_printf(MSG_DEBUG,"[Debug-WAPI] Not to set msg to WAPI SM\n");
/*Have been disassociated with the WAPI AP*/
return;
}
memcpy(bssid_s.v, wpa_s->bssid, sizeof(bssid_s.v));
memcpy(own_s.v, wpa_s->own_addr, sizeof(own_s.v));
wpa_printf(MSG_DEBUG,"[Debug-WAPI ^_^!!] Ready send associate complete evert to WAPI Modules!!!");
wapi_set_msg(CONN_ASSOC, &bssid_s, &own_s, wpa_s->bss_wapi_ie , wpa_s->bss_wapi_ie_len);
return;
}
#endif
if (wpa_s->current_ssid) {
/* When using scanning (ap_scan=1), SIM PC/SC interface can be
* initialized before association, but for other modes,
* initialize PC/SC here, if the current configuration needs
* smartcard or SIM/USIM. */
wpa_supplicant_scard_init(wpa_s, wpa_s->current_ssid);
}
wpa_sm_notify_assoc(wpa_s->wpa, bssid);
l2_packet_notify_auth_start(wpa_s->l2);
/*
* Set portEnabled first to FALSE in order to get EAP state machine out
* of the SUCCESS state and eapSuccess cleared. Without this, EAPOL PAE
* state machine may transit to AUTHENTICATING state based on obsolete
* eapSuccess and then trigger BE_AUTH to SUCCESS and PAE to
* AUTHENTICATED without ever giving chance to EAP state machine to
* reset the state.
*/
if (!ft_completed) {
eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
}
if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) || ft_completed)
eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
/* 802.1X::portControl = Auto */
eapol_sm_notify_portEnabled(wpa_s->eapol, TRUE);
wpa_s->eapol_received = 0;
if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
wpa_supplicant_cancel_auth_timeout(wpa_s);
wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
} else if (!ft_completed) {
/* Timeout for receiving the first EAPOL packet */
wpa_supplicant_req_auth_timeout(wpa_s, 10, 0);
}
wpa_supplicant_cancel_scan(wpa_s);
if (wpa_s->driver_4way_handshake &&
wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
/*
* We are done; the driver will take care of RSN 4-way
* handshake.
*/
wpa_supplicant_cancel_auth_timeout(wpa_s);
wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
eapol_sm_notify_eap_success(wpa_s->eapol, TRUE);
}
if (wpa_s->pending_eapol_rx) {
struct os_time now, age;
os_get_time(&now);
os_time_sub(&now, &wpa_s->pending_eapol_rx_time, &age);
if (age.sec == 0 && age.usec < 100000 &&
os_memcmp(wpa_s->pending_eapol_rx_src, bssid, ETH_ALEN) ==
0) {
wpa_printf(MSG_DEBUG, "Process pending EAPOL frame "
"that was received just before association "
"notification");
wpa_supplicant_rx_eapol(
wpa_s, wpa_s->pending_eapol_rx_src,
wpabuf_head(wpa_s->pending_eapol_rx),
wpabuf_len(wpa_s->pending_eapol_rx));
}
wpabuf_free(wpa_s->pending_eapol_rx);
wpa_s->pending_eapol_rx = NULL;
}
}
static void _wpa_supplicant_disassociate(void *wpa_s, int reason_code)
{
wpa_supplicant_disassociate(wpa_s, reason_code);
}
void WIFI_Action_Deauth()
{
struct wpa_supplicant *wpa_s = g_wpa_s;
wpa_supplicant_disassociate(wpa_s, 15);
}
static void wpa_supplicant_event_assoc(struct wpa_supplicant *wpa_s,
union wpa_event_data *data)
{
u8 bssid[ETH_ALEN];
int ft_completed;
int bssid_changed;
struct wpa_driver_capa capa;
#ifdef CONFIG_AP
if (wpa_s->ap_iface) {
hostapd_notif_assoc(wpa_s->ap_iface->bss[0],
data->assoc_info.addr,
data->assoc_info.req_ies,
data->assoc_info.req_ies_len);
return;
}
#endif /* CONFIG_AP */
ft_completed = wpa_ft_is_completed(wpa_s->wpa);
if (data && wpa_supplicant_event_associnfo(wpa_s, data) < 0)
return;
wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATED);
if (wpa_drv_get_bssid(wpa_s, bssid) >= 0 &&
os_memcmp(bssid, wpa_s->bssid, ETH_ALEN) != 0) {
wpa_msg(wpa_s, MSG_DEBUG, "Associated to a new BSS: BSSID="
MACSTR, MAC2STR(bssid));
bssid_changed = os_memcmp(wpa_s->bssid, bssid, ETH_ALEN);
os_memcpy(wpa_s->bssid, bssid, ETH_ALEN);
os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
if (bssid_changed)
wpas_notify_bssid_changed(wpa_s);
if (wpa_supplicant_dynamic_keys(wpa_s) && !ft_completed) {
wpa_clear_keys(wpa_s, bssid);
}
if (wpa_supplicant_select_config(wpa_s) < 0) {
wpa_supplicant_disassociate(
wpa_s, WLAN_REASON_DEAUTH_LEAVING);
return;
}
if (wpa_s->current_ssid) {
struct wpa_bss *bss = NULL;
struct wpa_ssid *ssid = wpa_s->current_ssid;
if (ssid->ssid_len > 0)
bss = wpa_bss_get(wpa_s, bssid,
ssid->ssid, ssid->ssid_len);
if (!bss)
bss = wpa_bss_get_bssid(wpa_s, bssid);
if (bss)
wpa_s->current_bss = bss;
}
}
#ifdef CONFIG_SME
os_memcpy(wpa_s->sme.prev_bssid, bssid, ETH_ALEN);
wpa_s->sme.prev_bssid_set = 1;
#endif /* CONFIG_SME */
wpa_msg(wpa_s, MSG_INFO, "Associated with " MACSTR, MAC2STR(bssid));
if (wpa_s->current_ssid) {
/* When using scanning (ap_scan=1), SIM PC/SC interface can be
* initialized before association, but for other modes,
* initialize PC/SC here, if the current configuration needs
* smartcard or SIM/USIM. */
wpa_supplicant_scard_init(wpa_s, wpa_s->current_ssid);
}
wpa_sm_notify_assoc(wpa_s->wpa, bssid);
if (wpa_s->l2)
l2_packet_notify_auth_start(wpa_s->l2);
/*
* Set portEnabled first to FALSE in order to get EAP state machine out
* of the SUCCESS state and eapSuccess cleared. Without this, EAPOL PAE
* state machine may transit to AUTHENTICATING state based on obsolete
* eapSuccess and then trigger BE_AUTH to SUCCESS and PAE to
* AUTHENTICATED without ever giving chance to EAP state machine to
* reset the state.
*/
if (!ft_completed) {
eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
}
if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) || ft_completed)
eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
/* 802.1X::portControl = Auto */
eapol_sm_notify_portEnabled(wpa_s->eapol, TRUE);
wpa_s->eapol_received = 0;
if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE ||
(wpa_s->current_ssid &&
wpa_s->current_ssid->mode == IEEE80211_MODE_IBSS)) {
wpa_supplicant_cancel_auth_timeout(wpa_s);
wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
} else if (!ft_completed) {
/* Timeout for receiving the first EAPOL packet */
wpa_supplicant_req_auth_timeout(wpa_s, 10, 0);
}
wpa_supplicant_cancel_scan(wpa_s);
if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
/*
* We are done; the driver will take care of RSN 4-way
* handshake.
*/
wpa_supplicant_cancel_auth_timeout(wpa_s);
wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
eapol_sm_notify_eap_success(wpa_s->eapol, TRUE);
}
if (wpa_s->pending_eapol_rx) {
struct os_time now, age;
os_get_time(&now);
os_time_sub(&now, &wpa_s->pending_eapol_rx_time, &age);
if (age.sec == 0 && age.usec < 100000 &&
os_memcmp(wpa_s->pending_eapol_rx_src, bssid, ETH_ALEN) ==
0) {
wpa_printf(MSG_DEBUG, "Process pending EAPOL frame "
"that was received just before association "
"notification");
wpa_supplicant_rx_eapol(
wpa_s, wpa_s->pending_eapol_rx_src,
wpabuf_head(wpa_s->pending_eapol_rx),
wpabuf_len(wpa_s->pending_eapol_rx));
}
wpabuf_free(wpa_s->pending_eapol_rx);
wpa_s->pending_eapol_rx = NULL;
}
if ((wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) &&
wpa_s->current_ssid && wpa_drv_get_capa(wpa_s, &capa) == 0 &&
capa.flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC_DONE) {
/* Set static WEP keys again */
wpa_set_wep_keys(wpa_s, wpa_s->current_ssid);
}
}
static void _wpa_supplicant_disassociate(void *wpa_s, int reason_code)
{
wpa_supplicant_disassociate(wpa_s, reason_code);
/* Schedule a scan to make sure we continue looking for networks */
wpa_supplicant_req_scan(wpa_s, 5, 0);
}
/**
* wpas_dbus_iface_select_network - Attempt association with a configured network
* @message: Pointer to incoming dbus message
* @wpa_s: wpa_supplicant structure for a network interface
* Returns: A dbus message containing a UINT32 indicating success (1) or
* failure (0)
*
* Handler function for "selectNetwork" method call of network interface.
*/
DBusMessage * wpas_dbus_iface_select_network(DBusMessage *message,
struct wpa_supplicant *wpa_s)
{
DBusMessage *reply = NULL;
const char *op;
struct wpa_ssid *ssid;
char *iface_obj_path = NULL;
char *network = NULL;
if (strlen(dbus_message_get_signature(message)) == 0) {
/* Any network */
ssid = wpa_s->conf->ssid;
while (ssid) {
ssid->disabled = 0;
ssid = ssid->next;
}
wpa_s->reassociate = 1;
wpa_supplicant_req_scan(wpa_s, 0, 0);
} else {
const char *obj_path;
int nid;
if (!dbus_message_get_args(message, NULL,
DBUS_TYPE_OBJECT_PATH, &op,
DBUS_TYPE_INVALID)) {
reply = wpas_dbus_new_invalid_opts_error(message,
NULL);
goto out;
}
/* Extract the network number */
iface_obj_path = wpas_dbus_decompose_object_path(op,
&network,
NULL);
if (iface_obj_path == NULL) {
reply = wpas_dbus_new_invalid_iface_error(message);
goto out;
}
/* Ensure the object path really points to this interface */
obj_path = wpa_supplicant_get_dbus_path(wpa_s);
if (strcmp(iface_obj_path, obj_path) != 0) {
reply = wpas_dbus_new_invalid_network_error(message);
goto out;
}
nid = strtoul(network, NULL, 10);
if (errno == EINVAL) {
reply = wpas_dbus_new_invalid_network_error(message);
goto out;
}
ssid = wpa_config_get_network(wpa_s->conf, nid);
if (ssid == NULL) {
reply = wpas_dbus_new_invalid_network_error(message);
goto out;
}
/* Finally, associate with the network */
if (ssid != wpa_s->current_ssid && wpa_s->current_ssid)
wpa_supplicant_disassociate(
wpa_s, WLAN_REASON_DEAUTH_LEAVING);
/* Mark all other networks disabled and trigger reassociation
*/
ssid = wpa_s->conf->ssid;
while (ssid) {
ssid->disabled = (nid != ssid->id);
ssid = ssid->next;
}
wpa_s->disconnected = 0;
wpa_s->reassociate = 1;
wpa_supplicant_req_scan(wpa_s, 0, 0);
}
reply = wpas_dbus_new_success_reply(message);
out:
free(iface_obj_path);
free(network);
return reply;
}
int
main(int argc, char *argv[])
{
struct wpa_supplicant wpa_s;
char *link = NULL;
char *key = NULL;
dlpi_handle_t dh = NULL;
datalink_id_t linkid;
dladm_phys_attr_t dpa;
int c;
int exitcode;
char door_file[WPA_STRSIZE];
for (;;) {
c = getopt(argc, argv, "Dk:hi:v");
if (c < 0)
break;
switch (c) {
case 'D':
wpa_debug_level = MSG_DEBUG;
break;
case 'h':
usage();
return (-1);
case 'i':
link = optarg;
break;
case 'k':
key = optarg;
break;
case 'v':
(void) printf("%s\n", wpa_supplicant_version);
return (-1);
default:
usage();
return (-1);
}
}
/*
* key name is required to retrieve PSK value through libwdladm APIs.
* key is saved by dladm command by keyname
* see dladm.
*/
if ((link == NULL) || (key == NULL)) {
wpa_printf(MSG_ERROR, "\nLink & key is required.");
return (-1);
}
if ((strlen(key) >= sizeof (wpa_s.kname))) {
wpa_printf(MSG_ERROR, "Too long key name '%s'.", key);
return (-1);
}
if (daemon(0, 0))
return (-1);
/*
* Hold this link open to prevent a link renaming operation.
*/
if (dlpi_open(link, &dh, 0) != DLPI_SUCCESS) {
wpa_printf(MSG_ERROR, "Failed to open link '%s'.", link);
return (-1);
}
if (dladm_name2info(link, &linkid, NULL, NULL, NULL) !=
DLADM_STATUS_OK) {
wpa_printf(MSG_ERROR, "Invalid link name '%s'.", link);
dlpi_close(dh);
return (-1);
}
/*
* Get the device name of the link, which will be used as the door
* file name used to communicate with the driver. Note that different
* links use different doors.
*/
if (dladm_phys_info(linkid, &dpa, DLADM_OPT_ACTIVE) !=
DLADM_STATUS_OK) {
wpa_printf(MSG_ERROR,
"Failed to get device name of link '%s'.", link);
dlpi_close(dh);
return (-1);
}
(void) snprintf(door_file, WPA_STRSIZE, "%s_%s", WPA_DOOR, dpa.dp_dev);
(void) memset(&wpa_s, 0, sizeof (wpa_s));
wpa_s.driver = &wpa_driver_wifi_ops;
wpa_s.linkid = linkid;
(void) strlcpy(wpa_s.kname, key, sizeof (wpa_s.kname));
eloop_init(&wpa_s);
/*
* Setup default WPA/WPA2 configuration
* get ESSID and PSK value
*/
wpa_s.conf = wpa_config_read(&wpa_s);
if (wpa_s.conf == NULL || wpa_s.conf->ssid == NULL) {
wpa_printf(MSG_ERROR, "\nNo networks (SSID) configured.\n");
exitcode = -1;
goto cleanup;
}
exitcode = 0;
/*
* Setup door file to communicate with driver
*/
if (wpa_supplicant_door_setup(&wpa_s, door_file) != 0) {
wpa_printf(MSG_ERROR, "Failed to setup door(%s)", door_file);
exitcode = -1;
goto cleanup;
}
wpa_s.renew_snonce = 1;
if (wpa_supplicant_driver_init(link, &wpa_s) < 0) {
exitcode = -1;
goto cleanup;
}
/*
* This link is hold again in wpa_supplicant_driver_init(), so that
* we release the first reference.
*/
dlpi_close(dh);
dh = NULL;
wpa_printf(MSG_DEBUG, "=> eloop_run");
(void) eloop_register_signal(SIGINT, wpa_supplicant_terminate, NULL);
(void) eloop_register_signal(SIGTERM, wpa_supplicant_terminate, NULL);
(void) eloop_register_signal(SIGKILL, wpa_supplicant_terminate, NULL);
eloop_run();
wpa_printf(MSG_DEBUG, "<= eloop_run()");
wpa_supplicant_disassociate(&wpa_s, REASON_DEAUTH_LEAVING);
if (wpa_s.driver->set_wpa(wpa_s.linkid, 0) < 0) {
wpa_printf(MSG_ERROR, "Failed to disable WPA in the driver.\n");
}
cleanup:
wpa_supplicant_door_destroy(door_file);
wpa_supplicant_cleanup(&wpa_s);
eloop_destroy();
if (dh != NULL)
dlpi_close(dh);
return (exitcode);
}
static void wpa_supplicant_event_assoc(struct wpa_supplicant *wpa_s,
union wpa_event_data *data)
{
u8 bssid[ETH_ALEN];
if (data)
wpa_supplicant_event_associnfo(wpa_s, data);
wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATED);
if (wpa_s->use_client_mlme)
os_memcpy(bssid, wpa_s->bssid, ETH_ALEN);
if (wpa_s->use_client_mlme ||
(wpa_drv_get_bssid(wpa_s, bssid) >= 0 &&
os_memcmp(bssid, wpa_s->bssid, ETH_ALEN) != 0)) {
wpa_msg(wpa_s, MSG_DEBUG, "Associated to a new BSS: BSSID="
MACSTR, MAC2STR(bssid));
os_memcpy(wpa_s->bssid, bssid, ETH_ALEN);
os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
if (wpa_supplicant_dynamic_keys(wpa_s)) {
wpa_clear_keys(wpa_s, bssid);
}
if (wpa_supplicant_select_config(wpa_s) < 0) {
/* carell modfy */
#if 0
wpa_supplicant_disassociate(wpa_s,
REASON_DEAUTH_LEAVING);
return;
#endif
}
}
wpa_msg(wpa_s, MSG_INFO, "Associated with " MACSTR, MAC2STR(bssid));
if (wpa_s->current_ssid) {
/* When using scanning (ap_scan=1), SIM PC/SC interface can be
* initialized before association, but for other modes,
* initialize PC/SC here, if the current configuration needs
* smartcard or SIM/USIM. */
wpa_supplicant_scard_init(wpa_s, wpa_s->current_ssid);
}
wpa_sm_notify_assoc(wpa_s->wpa, bssid);
l2_packet_notify_auth_start(wpa_s->l2);
/*
* Set portEnabled first to FALSE in order to get EAP state machine out
* of the SUCCESS state and eapSuccess cleared. Without this, EAPOL PAE
* state machine may transit to AUTHENTICATING state based on obsolete
* eapSuccess and then trigger BE_AUTH to SUCCESS and PAE to
* AUTHENTICATED without ever giving chance to EAP state machine to
* reset the state.
*/
eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
if (wpa_s->key_mgmt == WPA_KEY_MGMT_PSK)
eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
/* 802.1X::portControl = Auto */
eapol_sm_notify_portEnabled(wpa_s->eapol, TRUE);
wpa_s->eapol_received = 0;
if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
wpa_supplicant_cancel_auth_timeout(wpa_s);
wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
} else {
/* Timeout for receiving the first EAPOL packet */
wpa_supplicant_req_auth_timeout(wpa_s, 10, 0);
}
wpa_supplicant_cancel_scan(wpa_s);
}
