static int madwifi_set_ieee8021x(void *priv, struct wpa_bss_params *params) { struct madwifi_driver_data *drv = priv; wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, params->enabled); if (!params->enabled) { /* XXX restore state */ return set80211param(priv, IEEE80211_PARAM_AUTHMODE, IEEE80211_AUTH_AUTO); } if (!params->wpa && !params->ieee802_1x) { wpa_printf(MSG_WARNING, "No 802.1X or WPA enabled!"); return -1; } if (params->wpa && madwifi_configure_wpa(drv, params) != 0) { wpa_printf(MSG_WARNING, "Error configuring WPA state!"); return -1; } if (set80211param(priv, IEEE80211_PARAM_AUTHMODE, (params->wpa ? IEEE80211_AUTH_WPA : IEEE80211_AUTH_8021X))) { wpa_printf(MSG_WARNING, "Error enabling WPA/802.1X!"); return -1; } return 0; }
static int madwifi_set_ieee8021x(const char *ifname, void *priv, int enabled) { struct madwifi_driver_data *drv = priv; struct hostapd_data *hapd = drv->hapd; struct hostapd_bss_config *conf = hapd->conf; wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled); if (!enabled) { /* XXX restore state */ return set80211param(priv, IEEE80211_PARAM_AUTHMODE, IEEE80211_AUTH_AUTO); } if (!conf->wpa && !conf->ieee802_1x) { hostapd_logger(hapd, NULL, HOSTAPD_MODULE_DRIVER, HOSTAPD_LEVEL_WARNING, "No 802.1X or WPA enabled!"); return -1; } if (conf->wpa && madwifi_configure_wpa(drv) != 0) { hostapd_logger(hapd, NULL, HOSTAPD_MODULE_DRIVER, HOSTAPD_LEVEL_WARNING, "Error configuring WPA state!"); return -1; } if (set80211param(priv, IEEE80211_PARAM_AUTHMODE, (conf->wpa ? IEEE80211_AUTH_WPA : IEEE80211_AUTH_8021X))) { hostapd_logger(hapd, NULL, HOSTAPD_MODULE_DRIVER, HOSTAPD_LEVEL_WARNING, "Error enabling WPA/802.1X!"); return -1; } return 0; }
static void wpa_driver_madwifi_deinit(void *priv) { struct wpa_driver_madwifi_data *drv = priv; if (wpa_driver_madwifi_set_wpa_ie(drv, NULL, 0) < 0) { wpa_printf(MSG_DEBUG, "%s: failed to clear WPA IE", __FUNCTION__); } if (set80211param(drv, IEEE80211_PARAM_ROAMING, 0, 1) < 0) { wpa_printf(MSG_DEBUG, "%s: failed to enable driver-based " "roaming", __FUNCTION__); } if (set80211param(drv, IEEE80211_PARAM_PRIVACY, 0, 1) < 0) { wpa_printf(MSG_DEBUG, "%s: failed to disable forced Privacy " "flag", __FUNCTION__); } if (set80211param(drv, IEEE80211_PARAM_WPA, 0, 1) < 0) { wpa_printf(MSG_DEBUG, "%s: failed to disable WPA", __FUNCTION__); } wpa_driver_wext_deinit(drv->wext); close(drv->sock); os_free(drv); }
static int atheros_set_ieee8021x(void *priv, struct wpa_bss_params *params) { struct atheros_driver_data *drv = priv; wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, params->enabled); if (!params->enabled) { /* XXX restore state */ if (set80211param(priv, IEEE80211_PARAM_AUTHMODE, IEEE80211_AUTH_AUTO) < 0) return -1; /* IEEE80211_AUTH_AUTO ends up enabling Privacy; clear that */ return atheros_set_privacy(drv, 0); } if (!params->wpa && !params->ieee802_1x) { hostapd_logger(drv->hapd, NULL, HOSTAPD_MODULE_DRIVER, HOSTAPD_LEVEL_WARNING, "No 802.1X or WPA enabled!"); return -1; } if (params->wpa && atheros_configure_wpa(drv, params) != 0) { hostapd_logger(drv->hapd, NULL, HOSTAPD_MODULE_DRIVER, HOSTAPD_LEVEL_WARNING, "Error configuring WPA state!"); return -1; } if (set80211param(priv, IEEE80211_PARAM_AUTHMODE, (params->wpa ? IEEE80211_AUTH_WPA : IEEE80211_AUTH_8021X))) { hostapd_logger(drv->hapd, NULL, HOSTAPD_MODULE_DRIVER, HOSTAPD_LEVEL_WARNING, "Error enabling WPA/802.1X!"); return -1; } return 0; }
static int bsd_set_ieee8021x(void *priv, int enabled) { struct bsd_driver_data *drv = priv; hostapd *hapd = drv->hapd; struct hostapd_config *conf = hapd->conf; HOSTAPD_DEBUG(HOSTAPD_DEBUG_VERBOSE, "%s: enabled=%d\n", __func__, enabled); if (!enabled) { /* XXX restore state */ return set80211param(priv, IEEE80211_IOC_AUTHMODE, IEEE80211_AUTH_AUTO); } if (!conf->wpa && !conf->ieee802_1x) { hostapd_logger(hapd, NULL, HOSTAPD_MODULE_DRIVER, HOSTAPD_LEVEL_WARNING, "No 802.1x or WPA enabled!"); return -1; } if (conf->wpa && bsd_configure_wpa(drv) != 0) { hostapd_logger(hapd, NULL, HOSTAPD_MODULE_DRIVER, HOSTAPD_LEVEL_WARNING, "Error configuring WPA state!"); return -1; } if (set80211param(priv, IEEE80211_IOC_AUTHMODE, (conf->wpa ? IEEE80211_AUTH_WPA : IEEE80211_AUTH_8021X))) { hostapd_logger(hapd, NULL, HOSTAPD_MODULE_DRIVER, HOSTAPD_LEVEL_WARNING, "Error enabling WPA/802.1x!"); return -1; } return bsd_set_iface_flags(priv, 1); }
static int bsd_set_ieee8021x(void *priv, struct wpa_bss_params *params) { wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, params->enabled); if (!params->enabled) { /* XXX restore state */ return set80211param(priv, IEEE80211_IOC_AUTHMODE, IEEE80211_AUTH_AUTO); } if (!params->wpa && !params->ieee802_1x) { wpa_printf(MSG_ERROR, "%s: No 802.1X or WPA enabled", __func__); return -1; } if (params->wpa && bsd_configure_wpa(priv, params) != 0) { wpa_printf(MSG_ERROR, "%s: Failed to configure WPA state", __func__); return -1; } if (set80211param(priv, IEEE80211_IOC_AUTHMODE, (params->wpa ? IEEE80211_AUTH_WPA : IEEE80211_AUTH_8021X))) { wpa_printf(MSG_ERROR, "%s: Failed to enable WPA/802.1X", __func__); return -1; } return bsd_ctrl_iface(priv, 1); }
static void wpa_driver_bsd_deinit(void *priv) { struct wpa_driver_bsd_data *drv = priv; int flags; /* NB: mark interface down */ if (getifflags(drv, &flags) == 0) (void) setifflags(drv, flags &~ IFF_UP); wpa_driver_bsd_set_wpa_internal(drv, drv->prev_wpa, drv->prev_privacy); if (set80211param(drv, IEEE80211_IOC_ROAMING, drv->prev_roaming) < 0) { /* NB: don't whinge if device ejected or equivalent */ if (errno != ENXIO) wpa_printf(MSG_DEBUG, "%s: failed to restore roaming " "state", __func__); } if (drv->drivercaps & IEEE80211_C_BGSCAN) { /* XXX check return value */ (void) set80211param(drv, IEEE80211_IOC_SCANVALID, drv->prev_scanvalid); } (void) close(drv->route); /* ioctl socket */ (void) close(drv->sock); /* event socket */ free(drv); }
static int wpa_driver_madwifi_associate(void *priv, struct wpa_driver_associate_params *params) { struct wpa_driver_madwifi_data *drv = priv; struct ieee80211req_mlme mlme; int ret = 0, privacy = 1; wpa_printf(MSG_DEBUG, "%s", __FUNCTION__); /* * NB: Don't need to set the freq or cipher-related state as * this is implied by the bssid which is used to locate * the scanned node state which holds it. The ssid is * needed to disambiguate an AP that broadcasts multiple * ssid's but uses the same bssid. */ /* XXX error handling is wrong but unclear what to do... */ if (wpa_driver_madwifi_set_wpa_ie(drv, params->wpa_ie, params->wpa_ie_len) < 0) ret = -1; if (params->pairwise_suite == CIPHER_NONE && params->group_suite == CIPHER_NONE && params->key_mgmt_suite == KEY_MGMT_NONE && params->wpa_ie_len == 0) privacy = 0; if (set80211param(drv, IEEE80211_PARAM_PRIVACY, privacy, 1) < 0) ret = -1; if (params->bssid == NULL) { /* ap_scan=2 mode - driver takes care of AP selection and * roaming */ /* FIX: this does not seem to work; would probably need to * change something in the driver */ if (set80211param(drv, IEEE80211_PARAM_ROAMING, 0, 1) < 0) ret = -1; } if (wpa_driver_wext_set_ssid(drv->wext, params->ssid, params->ssid_len) < 0) ret = -1; if (params->bssid) { if (set80211param(drv, IEEE80211_PARAM_ROAMING, 2, 1) < 0) ret = -1; memset(&mlme, 0, sizeof(mlme)); mlme.im_op = IEEE80211_MLME_ASSOC; memcpy(mlme.im_macaddr, params->bssid, IEEE80211_ADDR_LEN); if (set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme), 1) < 0) ret = -1; } return ret; }
static int wpa_driver_realtek_associate(void *priv, struct wpa_driver_associate_params *params) { struct wpa_driver_realtek_data *drv = priv; struct ieee80211req_mlme mlme; int ret = 0, privacy = 1; printf("Wpa_supplicant: %s +++\n", __FUNCTION__); wpa_printf(MSG_DEBUG, "%s", __FUNCTION__); //_Eric ?? if ret = -1, why still run continuously? if(realtek_config_security(drv, params) < 0) ret = -9; if (params->bssid == NULL) { //_Eric ?? it means no MAC but have SSID(name), driver shall try to find this AP automatically? if (set80211param(drv, IEEE80211_PARAM_ROAMING, 0, 1) < 0) ret = -2; if (wpa_driver_wext_set_ssid(drv->wext, params->ssid, params->ssid_len) < 0) ret = -3; } else { if (set80211param(drv, IEEE80211_PARAM_ROAMING, 2, 1) < 0) ret = -4; if (wpa_driver_wext_set_ssid(drv->wext, params->ssid, params->ssid_len) < 0) ret = -5; os_memset(&mlme, 0, sizeof(mlme)); mlme.im_op = IEEE80211_MLME_ASSOC; os_memcpy(mlme.im_macaddr, params->bssid, IEEE80211_ADDR_LEN); printf("Try to assoc %02x:%02x:%02x:%02x:%02x:%02x \n", params->bssid[0], params->bssid[1], params->bssid[2], params->bssid[3], params->bssid[4], params->bssid[5]); if (set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme), 1) < 0) { wpa_printf(MSG_DEBUG, "%s: SETMLME[ASSOC] failed", __func__); ret = -1; } } printf("Wpa_supplicant: %s --- ret = %d\n", __FUNCTION__, ret); return ret; }
static int wpa_driver_bsd_associate(void *priv, struct wpa_driver_associate_params *params) { struct wpa_driver_bsd_data *drv = priv; struct ieee80211req_mlme mlme; int privacy; wpa_printf(MSG_DEBUG, "%s: ssid '%.*s' wpa ie len %u pairwise %u group %u key mgmt %u" , __func__ , params->ssid_len, params->ssid , params->wpa_ie_len , params->pairwise_suite , params->group_suite , params->key_mgmt_suite ); /* XXX error handling is wrong but unclear what to do... */ if (wpa_driver_bsd_set_wpa_ie(drv, params->wpa_ie, params->wpa_ie_len) < 0) return -1; #ifndef NEW_FREEBSD_MLME_ASSOC if (wpa_driver_bsd_set_ssid(drv, params->ssid, params->ssid_len) < 0) return -1; #endif privacy = !(params->pairwise_suite == CIPHER_NONE && params->group_suite == CIPHER_NONE && params->key_mgmt_suite == KEY_MGMT_NONE && params->wpa_ie_len == 0); wpa_printf(MSG_DEBUG, "%s: set PRIVACY %u", __func__, privacy); if (set80211param(drv, IEEE80211_IOC_PRIVACY, privacy) < 0) return -1; if (params->wpa_ie_len && set80211param(drv, IEEE80211_IOC_WPA, params->wpa_ie[0] == RSN_INFO_ELEM ? 2 : 1) < 0) return -1; memset(&mlme, 0, sizeof(mlme)); mlme.im_op = IEEE80211_MLME_ASSOC; #ifdef NEW_FREEBSD_MLME_ASSOC if (params->ssid != NULL) memcpy(mlme.im_ssid, params->ssid, params->ssid_len); mlme.im_ssid_len = params->ssid_len; #endif if (params->bssid != NULL) memcpy(mlme.im_macaddr, params->bssid, IEEE80211_ADDR_LEN); if (set80211var(drv, IEEE80211_IOC_MLME, &mlme, sizeof(mlme)) < 0) return -1; return 0; }
static int wpa_driver_madwifi_set_wpa(const char *ifname, int enabled) { int ret = 0; if (set80211param(ifname, IEEE80211_PARAM_ROAMING, enabled ? 2 : 0) < 0) ret = -1; if (set80211param(ifname, IEEE80211_PARAM_PRIVACY, enabled) < 0) ret = -1; if (set80211param(ifname, IEEE80211_PARAM_WPA, enabled ? 3 : 0) < 0) ret = -1; return ret; }
static int wpa_driver_madwifi_set_drop_unencrypted(void *priv, int enabled) { struct wpa_driver_madwifi_data *drv = priv; wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled); return set80211param(drv, IEEE80211_PARAM_DROPUNENCRYPTED, enabled, 1); }
static int bsd_set_privacy(void *priv, int enabled) { wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled); return set80211param(priv, IEEE80211_IOC_PRIVACY, enabled); }
static int atheros_set_countermeasures(void *priv, int enabled) { struct atheros_driver_data *drv = priv; wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled); return set80211param(drv, IEEE80211_PARAM_COUNTERMEASURES, enabled); }
static int wpa_driver_bsd_set_drop_unencrypted(void *priv, int enabled) { struct wpa_driver_bsd_data *drv = priv; wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled); return set80211param(drv, IEEE80211_IOC_DROPUNENCRYPTED, enabled); }
static int wpa_driver_bsd_set_wpa_internal(void *priv, int wpa, int privacy) { int ret = 0; wpa_printf(MSG_DEBUG, "%s: wpa=%d privacy=%d", __FUNCTION__, wpa, privacy); if (!wpa && wpa_driver_bsd_set_wpa_ie(priv, NULL, 0) < 0) ret = -1; if (set80211param(priv, IEEE80211_IOC_PRIVACY, privacy) < 0) ret = -1; if (set80211param(priv, IEEE80211_IOC_WPA, wpa) < 0) ret = -1; return ret; }
static int wpa_driver_bsd_set_countermeasures(void *priv, int enabled) { struct wpa_driver_bsd_data *drv = priv; wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled); return set80211param(drv, IEEE80211_IOC_COUNTERMEASURES, enabled); }
static int wpa_driver_realtek_set_countermeasures(void *priv, int enabled) { struct wpa_driver_realtek_data *drv = priv; printf("Wpa_supplicant: %s +++\n", __FUNCTION__); wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled); return set80211param(drv, IEEE80211_PARAM_COUNTERMEASURES, enabled, 1); }
static int atheros_set_privacy(void *priv, int enabled) { struct atheros_driver_data *drv = priv; wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled); return set80211param(drv, IEEE80211_PARAM_PRIVACY, enabled); }
static int wpa_driver_realtek_set_drop_unencrypted(void *priv, int enabled) { struct wpa_driver_realtek_data *drv = priv; printf("Wpa_supplicant: %s +++\n", __FUNCTION__); wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled); return set80211param(drv, IEEE80211_PARAM_DROPUNENCRYPTED, enabled, 1); }
static int madwifi_set_privacy(const char *ifname, void *priv, int enabled) { struct madwifi_driver_data *drv = priv; wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled); return set80211param(drv, IEEE80211_PARAM_PRIVACY, enabled); }
static int wpa_driver_bsd_set_wpa_internal(void *priv, int wpa, int privacy) { struct wpa_driver_bsd_data *drv = priv; int ret = 0; wpa_printf(MSG_DEBUG, "%s: wpa=%d privacy=%d", __func__, wpa, privacy); if (!wpa && wpa_driver_bsd_set_wpa_ie(drv, NULL, 0) < 0) ret = -1; if (set80211param(drv, IEEE80211_IOC_PRIVACY, privacy) < 0) ret = -1; if (set80211param(drv, IEEE80211_IOC_WPA, wpa) < 0) ret = -1; return ret; }
static int bsd_configure_wpa(void *priv, struct wpa_bss_params *params) { wpa_printf(MSG_DEBUG, "%s: enable WPA= 0x%x", __func__, params->wpa); if (set80211param(priv, IEEE80211_IOC_WPA, params->wpa)) { printf("Unable to set WPA to %u\n", params->wpa); return -1; } return 0; }
static int wpa_driver_madwifi_set_wpa(void *priv, int enabled) { struct wpa_driver_madwifi_data *drv = priv; int ret = 0; wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled); if (!enabled && wpa_driver_madwifi_set_wpa_ie(drv, NULL, 0) < 0) ret = -1; if (set80211param(drv, IEEE80211_PARAM_ROAMING, enabled ? 2 : 0, 1) < 0) ret = -1; if (set80211param(drv, IEEE80211_PARAM_PRIVACY, enabled, 1) < 0) ret = -1; if (set80211param(drv, IEEE80211_PARAM_WPA, enabled ? 3 : 0, 1) < 0) ret = -1; return ret; }
static int bsd_set_privacy(void *priv, int enabled) { struct bsd_driver_data *drv = priv; hostapd *hapd = drv->hapd; HOSTAPD_DEBUG(HOSTAPD_DEBUG_MINIMAL, "%s: enabled=%d\n", __func__, enabled); return set80211param(priv, IEEE80211_IOC_PRIVACY, enabled); }
/* * Set the scan cache valid threshold to 1.5 x bg scan interval * to force all scan requests to consult the cache unless they * explicitly bypass it. */ static int setscanvalid(struct wpa_driver_bsd_data *drv) { int bgscan, scanvalid; if (!GETPARAM(drv, IEEE80211_IOC_SCANVALID, drv->prev_scanvalid) || !GETPARAM(drv, IEEE80211_IOC_BGSCAN_INTERVAL, bgscan)) return -1; scanvalid = 3*bgscan/2; return (drv->prev_scanvalid < scanvalid) ? set80211param(drv, IEEE80211_IOC_SCANVALID, scanvalid) : 0; }
static void * wpa_driver_madwifi_init(void *ctx, const char *ifname) { struct wpa_driver_madwifi_data *drv; drv = malloc(sizeof(*drv)); if (drv == NULL) return NULL; memset(drv, 0, sizeof(*drv)); drv->wext = wpa_driver_wext_init(ctx, ifname); if (drv->wext == NULL) goto fail; drv->ctx = ctx; strncpy(drv->ifname, ifname, sizeof(drv->ifname)); drv->sock = socket(PF_INET, SOCK_DGRAM, 0); if (drv->sock < 0) goto fail2; if (set80211param(drv, IEEE80211_PARAM_ROAMING, 2, 1) < 0) { wpa_printf(MSG_DEBUG, "%s: failed to set wpa_supplicant-based " "roaming", __FUNCTION__); goto fail3; } if (set80211param(drv, IEEE80211_PARAM_WPA, 3, 1) < 0) { wpa_printf(MSG_DEBUG, "%s: failed to enable WPA support", __FUNCTION__); goto fail3; } return drv; fail3: close(drv->sock); fail2: wpa_driver_wext_deinit(drv->wext); fail: free(drv); return NULL; }
static int wpa_driver_bsd_set_auth_alg(void *priv, int auth_alg) { int authmode; if ((auth_alg & WPA_AUTH_ALG_OPEN) && (auth_alg & WPA_AUTH_ALG_SHARED)) authmode = IEEE80211_AUTH_AUTO; else if (auth_alg & WPA_AUTH_ALG_SHARED) authmode = IEEE80211_AUTH_SHARED; else authmode = IEEE80211_AUTH_OPEN; return set80211param(priv, IEEE80211_IOC_AUTHMODE, authmode); }
static int atheros_set_authmode(void *priv, int auth_algs) { int authmode; if ((auth_algs & WPA_AUTH_ALG_OPEN) && (auth_algs & WPA_AUTH_ALG_SHARED)) authmode = IEEE80211_AUTH_AUTO; else if (auth_algs & WPA_AUTH_ALG_OPEN) authmode = IEEE80211_AUTH_OPEN; else if (auth_algs & WPA_AUTH_ALG_SHARED) authmode = IEEE80211_AUTH_SHARED; else return -1; return set80211param(priv, IEEE80211_PARAM_AUTHMODE, authmode); }
static int wpa_driver_madwifi_set_auth_alg(void *priv, int auth_alg) { struct wpa_driver_madwifi_data *drv = priv; int authmode; if ((auth_alg & AUTH_ALG_OPEN_SYSTEM) && (auth_alg & AUTH_ALG_SHARED_KEY)) authmode = IEEE80211_AUTH_AUTO; else if (auth_alg & AUTH_ALG_SHARED_KEY) authmode = IEEE80211_AUTH_SHARED; else authmode = IEEE80211_AUTH_OPEN; return set80211param(drv, IEEE80211_PARAM_AUTHMODE, authmode, 1); }