#include <netpacket/packet.h>
#include "priv_netlink.h"
-#include "ieee802_11_defs.h"
-#include "../../hostapd/hostapd.h"
-#include "../../hostapd/hw_features.h"
-#include "../../hostapd/sta_flags.h"
+#include "netlink.h"
+#include "linux_ioctl.h"
+#include "common/ieee802_11_defs.h"
+/* MTU to be set for the wlan#ap device; this is mainly needed for IEEE 802.1X
+ * frames that might be longer than normal default MTU and they are not
+ * fragmented */
+#define HOSTAPD_MTU 2290
+
static const u8 rfc1042_header[6] = { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
struct hostap_driver_data {
char iface[IFNAMSIZ + 1];
int sock; /* raw packet socket for driver access */
int ioctl_sock; /* socket for ioctl() use */
- int wext_sock; /* socket for wireless events */
+ struct netlink_data *netlink;
int we_version;
u16 fc, ethertype;
u8 *pos, *sa;
size_t left;
+ union wpa_event_data event;
if (len < sizeof(struct ieee80211_hdr))
return;
}
sa = hdr->addr2;
- hostapd_rx_from_unknown_sta(drv->hapd, hdr, len);
+ os_memset(&event, 0, sizeof(event));
+ event.rx_from_unknown.frame = buf;
+ event.rx_from_unknown.len = len;
+ wpa_supplicant_event(drv->hapd, EVENT_RX_FROM_UNKNOWN, &event);
pos = (u8 *) (hdr + 1);
left = len - sizeof(*hdr);
left -= 2;
switch (ethertype) {
case ETH_P_PAE:
- hostapd_eapol_receive(drv->hapd, sa, pos, left);
+ drv_event_eapol_rx(drv->hapd, sa, pos, left);
break;
default:
size_t len, int ok)
{
struct ieee80211_hdr *hdr;
- u16 fc, type, stype;
+ u16 fc;
+ union wpa_event_data event;
hdr = (struct ieee80211_hdr *) buf;
fc = le_to_host16(hdr->frame_control);
- type = WLAN_FC_GET_TYPE(fc);
- stype = WLAN_FC_GET_STYPE(fc);
-
- switch (type) {
- case WLAN_FC_TYPE_MGMT:
- wpa_printf(MSG_DEBUG, "MGMT (TX callback) %s",
- ok ? "ACK" : "fail");
- hostapd_mgmt_tx_cb(drv->hapd, buf, len, stype, ok);
- break;
- case WLAN_FC_TYPE_CTRL:
- wpa_printf(MSG_DEBUG, "CTRL (TX callback) %s",
- ok ? "ACK" : "fail");
- break;
- case WLAN_FC_TYPE_DATA:
- wpa_printf(MSG_DEBUG, "DATA (TX callback) %s",
- ok ? "ACK" : "fail");
- hostapd_tx_status(drv->hapd, hdr->addr1, buf, len, ok);
- break;
- default:
- printf("unknown TX callback frame type %d\n", type);
- break;
- }
+ os_memset(&event, 0, sizeof(event));
+ event.tx_status.type = WLAN_FC_GET_TYPE(fc);
+ event.tx_status.stype = WLAN_FC_GET_STYPE(fc);
+ event.tx_status.dst = hdr->addr1;
+ event.tx_status.data = buf;
+ event.tx_status.data_len = len;
+ event.tx_status.ack = ok;
+ wpa_supplicant_event(drv->hapd, EVENT_TX_STATUS, &event);
}
unsigned char *extra = NULL;
size_t data_len = len;
int ver;
+ union wpa_event_data event;
/* PSPOLL is only 16 bytes, but driver does not (at least yet) pass
* these to user space */
switch (type) {
case WLAN_FC_TYPE_MGMT:
- if (stype != WLAN_FC_STYPE_BEACON)
- wpa_printf(MSG_MSGDUMP, "MGMT");
- hostapd_mgmt_rx(drv->hapd, buf, data_len, stype, NULL);
+ os_memset(&event, 0, sizeof(event));
+ event.rx_mgmt.frame = buf;
+ event.rx_mgmt.frame_len = data_len;
+ wpa_supplicant_event(drv->hapd, EVENT_RX_MGMT, &event);
break;
case WLAN_FC_TYPE_CTRL:
wpa_printf(MSG_DEBUG, "CTRL");
return -1;
}
- memset(&ifr, 0, sizeof(ifr));
- os_strlcpy(ifr.ifr_name, drv->iface, sizeof(ifr.ifr_name));
- if (ioctl(drv->sock, SIOCGIFHWADDR, &ifr) != 0) {
- perror("ioctl(SIOCGIFHWADDR)");
- return -1;
- }
-
- if (ifr.ifr_hwaddr.sa_family != ARPHRD_ETHER) {
- printf("Invalid HW-addr family 0x%04x\n",
- ifr.ifr_hwaddr.sa_family);
- return -1;
- }
- os_memcpy(own_addr, ifr.ifr_hwaddr.sa_data, ETH_ALEN);
-
- return 0;
+ return linux_get_ifhwaddr(drv->sock, drv->iface, own_addr);
}
struct hostap_driver_data *drv = priv;
struct prism2_hostapd_param param;
+ if (flags_or & WPA_STA_AUTHORIZED)
+ flags_or = BIT(5); /* WLAN_STA_AUTHORIZED */
+ if (!(flags_and & WPA_STA_AUTHORIZED))
+ flags_and = ~BIT(5);
+ else
+ flags_and = ~0;
memset(¶m, 0, sizeof(param));
param.cmd = PRISM2_HOSTAPD_SET_FLAGS_STA;
memcpy(param.sta_addr, addr, ETH_ALEN);
{
struct hostap_driver_data *drv = priv;
struct ifreq ifr;
+ char ifname[IFNAMSIZ];
- if (drv->ioctl_sock < 0)
- return -1;
-
- memset(&ifr, 0, sizeof(ifr));
- snprintf(ifr.ifr_name, IFNAMSIZ, "%sap", drv->iface);
-
- if (ioctl(drv->ioctl_sock, SIOCGIFFLAGS, &ifr) != 0) {
- perror("ioctl[SIOCGIFFLAGS]");
+ os_snprintf(ifname, IFNAMSIZ, "%sap", drv->iface);
+ if (linux_set_iface_flags(drv->ioctl_sock, ifname, dev_up) < 0)
return -1;
- }
-
- if (dev_up)
- ifr.ifr_flags |= IFF_UP;
- else
- ifr.ifr_flags &= ~IFF_UP;
-
- if (ioctl(drv->ioctl_sock, SIOCSIFFLAGS, &ifr) != 0) {
- perror("ioctl[SIOCSIFFLAGS]");
- return -1;
- }
if (dev_up) {
memset(&ifr, 0, sizeof(ifr));
- snprintf(ifr.ifr_name, IFNAMSIZ, "%sap", drv->iface);
+ os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
ifr.ifr_mtu = HOSTAPD_MTU;
if (ioctl(drv->ioctl_sock, SIOCSIFMTU, &ifr) != 0) {
perror("ioctl[SIOCSIFMTU]");
}
-static int hostap_set_key(const char *ifname, void *priv, wpa_alg alg,
- const u8 *addr, int key_idx, int set_tx,
- const u8 *seq, size_t seq_len, const u8 *key,
- size_t key_len)
+static int wpa_driver_hostap_set_key(const char *ifname, void *priv,
+ enum wpa_alg alg, const u8 *addr,
+ int key_idx, int set_tx,
+ const u8 *seq, size_t seq_len,
+ const u8 *key, size_t key_len)
{
struct hostap_driver_data *drv = priv;
struct prism2_hostapd_param *param;
}
-static int hostap_set_ieee8021x(const char *ifname, void *priv, int enabled)
+static int hostap_set_ieee8021x(void *priv, struct wpa_bss_params *params)
{
struct hostap_driver_data *drv = priv;
+ int enabled = params->enabled;
/* enable kernel driver support for IEEE 802.1X */
if (hostap_ioctl_prism2param(drv, PRISM2_PARAM_IEEE_802_1X, enabled)) {
}
-static int hostap_set_privacy(const char *ifname, void *priv, int enabled)
+static int hostap_set_privacy(void *priv, int enabled)
{
struct hostap_drvier_data *drv = priv;
}
-static int hostap_set_ssid(const char *ifname, void *priv, const u8 *buf,
- int len)
+static int hostap_set_ssid(void *priv, const u8 *buf, int len)
{
struct hostap_driver_data *drv = priv;
struct iwreq iwr;
}
-static int hostap_sta_add(const char *ifname, void *priv,
- struct hostapd_sta_add_params *params)
+static int hostap_sta_add(void *priv, struct hostapd_sta_add_params *params)
{
struct hostap_driver_data *drv = priv;
struct prism2_hostapd_param param;
struct hostap_driver_data *drv = priv;
struct prism2_hostapd_param param;
- hostap_sta_set_flags(drv, addr, 0, 0, ~WLAN_STA_AUTHORIZED);
+ hostap_sta_set_flags(drv, addr, 0, 0, ~WPA_STA_AUTHORIZED);
memset(¶m, 0, sizeof(param));
param.cmd = PRISM2_HOSTAPD_REMOVE_STA;
}
-static int hostap_set_generic_elem(const char *ifname, void *priv,
+static int hostap_set_generic_elem(void *priv,
const u8 *elem, size_t elem_len)
{
struct hostap_driver_data *drv = priv;
}
-static int hostap_set_wps_beacon_ie(const char *ifname, void *priv,
- const u8 *ie, size_t len)
-{
- /* Host AP driver supports only one set of extra IEs, so we need to
- * use the ProbeResp IEs also for Beacon frames since they include more
- * information. */
- return 0;
-}
-
-
-static int hostap_set_wps_probe_resp_ie(const char *ifname, void *priv,
- const u8 *ie, size_t len)
+static int hostap_set_ap_wps_ie(void *priv, const struct wpabuf *beacon,
+ const struct wpabuf *proberesp,
+ const struct wpabuf *assocresp)
{
struct hostap_driver_data *drv = priv;
+ /*
+ * Host AP driver supports only one set of extra IEs, so we need to
+ * use the Probe Response IEs also for Beacon frames since they include
+ * more information.
+ */
+
os_free(drv->wps_ie);
drv->wps_ie = NULL;
drv->wps_ie_len = 0;
- if (ie) {
- drv->wps_ie = os_malloc(len);
+ if (proberesp) {
+ drv->wps_ie = os_malloc(wpabuf_len(proberesp));
if (drv->wps_ie == NULL)
return -1;
- os_memcpy(drv->wps_ie, ie, len);
- drv->wps_ie_len = len;
+ os_memcpy(drv->wps_ie, wpabuf_head(proberesp),
+ wpabuf_len(proberesp));
+ drv->wps_ie_len = wpabuf_len(proberesp);
}
return hostapd_ioctl_set_generic_elem(drv);
}
pos += 5;
if (hwaddr_aton(pos, addr) == 0) {
- hostapd_michael_mic_failure(drv->hapd, addr);
+ union wpa_event_data data;
+ os_memset(&data, 0, sizeof(data));
+ data.michael_mic_failure.unicast = 1;
+ data.michael_mic_failure.src = addr;
+ wpa_supplicant_event(drv->hapd,
+ EVENT_MICHAEL_MIC_FAILURE, &data);
} else {
wpa_printf(MSG_DEBUG,
"MLME-MICHAELMICFAILURE.indication "
}
-static void hostapd_wireless_event_rtm_newlink(struct hostap_driver_data *drv,
- struct nlmsghdr *h, int len)
+static void hostapd_wireless_event_rtm_newlink(void *ctx,
+ struct ifinfomsg *ifi,
+ u8 *buf, size_t len)
{
- struct ifinfomsg *ifi;
- int attrlen, nlmsg_len, rta_len;
- struct rtattr * attr;
-
- if (len < (int) sizeof(*ifi))
- return;
-
- ifi = NLMSG_DATA(h);
+ struct hostap_driver_data *drv = ctx;
+ int attrlen, rta_len;
+ struct rtattr *attr;
/* TODO: use ifi->ifi_index to filter out wireless events from other
* interfaces */
- nlmsg_len = NLMSG_ALIGN(sizeof(struct ifinfomsg));
-
- attrlen = h->nlmsg_len - nlmsg_len;
- if (attrlen < 0)
- return;
-
- attr = (struct rtattr *) (((char *) ifi) + nlmsg_len);
+ attrlen = len;
+ attr = (struct rtattr *) buf;
rta_len = RTA_ALIGN(sizeof(struct rtattr));
while (RTA_OK(attr, attrlen)) {
}
-static void hostapd_wireless_event_receive(int sock, void *eloop_ctx,
- void *sock_ctx)
-{
- char buf[256];
- int left;
- struct sockaddr_nl from;
- socklen_t fromlen;
- struct nlmsghdr *h;
- struct hostap_driver_data *drv = eloop_ctx;
-
- fromlen = sizeof(from);
- left = recvfrom(sock, buf, sizeof(buf), MSG_DONTWAIT,
- (struct sockaddr *) &from, &fromlen);
- if (left < 0) {
- if (errno != EINTR && errno != EAGAIN)
- perror("recvfrom(netlink)");
- return;
- }
-
- h = (struct nlmsghdr *) buf;
- while (left >= (int) sizeof(*h)) {
- int len, plen;
-
- len = h->nlmsg_len;
- plen = len - sizeof(*h);
- if (len > left || plen < 0) {
- printf("Malformed netlink message: "
- "len=%d left=%d plen=%d\n",
- len, left, plen);
- break;
- }
-
- switch (h->nlmsg_type) {
- case RTM_NEWLINK:
- hostapd_wireless_event_rtm_newlink(drv, h, plen);
- break;
- }
-
- len = NLMSG_ALIGN(len);
- left -= len;
- h = (struct nlmsghdr *) ((char *) h + len);
- }
-
- if (left > 0) {
- printf("%d extra bytes in the end of netlink message\n", left);
- }
-}
-
-
static int hostap_get_we_version(struct hostap_driver_data *drv)
{
struct iw_range *range;
static int hostap_wireless_event_init(struct hostap_driver_data *drv)
{
- int s;
- struct sockaddr_nl local;
+ struct netlink_config *cfg;
hostap_get_we_version(drv);
- drv->wext_sock = -1;
-
- s = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
- if (s < 0) {
- perror("socket(PF_NETLINK,SOCK_RAW,NETLINK_ROUTE)");
+ cfg = os_zalloc(sizeof(*cfg));
+ if (cfg == NULL)
return -1;
- }
-
- memset(&local, 0, sizeof(local));
- local.nl_family = AF_NETLINK;
- local.nl_groups = RTMGRP_LINK;
- if (bind(s, (struct sockaddr *) &local, sizeof(local)) < 0) {
- perror("bind(netlink)");
- close(s);
+ cfg->ctx = drv;
+ cfg->newlink_cb = hostapd_wireless_event_rtm_newlink;
+ drv->netlink = netlink_init(cfg);
+ if (drv->netlink == NULL) {
+ os_free(cfg);
return -1;
}
- eloop_register_read_sock(s, hostapd_wireless_event_receive, drv,
- NULL);
- drv->wext_sock = s;
-
return 0;
}
-static void hostap_wireless_event_deinit(struct hostap_driver_data *drv)
-{
- if (drv->wext_sock < 0)
- return;
- eloop_unregister_read_sock(drv->wext_sock);
- close(drv->wext_sock);
-}
-
-
static void * hostap_init(struct hostapd_data *hapd,
struct wpa_init_params *params)
{
{
struct hostap_driver_data *drv = priv;
- hostap_wireless_event_deinit(drv);
+ netlink_deinit(drv->netlink);
(void) hostap_set_iface_flags(drv, 0);
(void) hostap_ioctl_prism2param(drv, PRISM2_PARAM_HOSTAPD, 0);
(void) hostap_ioctl_prism2param(drv, PRISM2_PARAM_HOSTAPD_STA, 0);
mode->num_rates = 4;
clen = mode->num_channels * sizeof(struct hostapd_channel_data);
- rlen = mode->num_rates * sizeof(struct hostapd_rate_data);
+ rlen = mode->num_rates * sizeof(int);
mode->channels = os_zalloc(clen);
mode->rates = os_zalloc(rlen);
if (mode->channels == NULL || mode->rates == NULL) {
- hostapd_free_hw_features(mode, *num_modes);
+ os_free(mode->channels);
+ os_free(mode->rates);
+ os_free(mode);
return NULL;
}
mode->channels[i].flag = HOSTAPD_CHAN_DISABLED;
}
- mode->rates[0].rate = 10;
- mode->rates[0].flags = HOSTAPD_RATE_CCK;
- mode->rates[1].rate = 20;
- mode->rates[1].flags = HOSTAPD_RATE_CCK;
- mode->rates[2].rate = 55;
- mode->rates[2].flags = HOSTAPD_RATE_CCK;
- mode->rates[3].rate = 110;
- mode->rates[3].flags = HOSTAPD_RATE_CCK;
+ mode->rates[0] = 10;
+ mode->rates[1] = 20;
+ mode->rates[2] = 55;
+ mode->rates[3] = 110;
return mode;
}
};
+static int wpa_driver_hostap_set_auth_alg(void *priv, int auth_alg);
+
+
static int hostapd_ioctl(struct wpa_driver_hostap_data *drv,
struct prism2_hostapd_param *param,
int len, int show_err)
}
-static int wpa_driver_hostap_set_key(void *priv, wpa_alg alg,
- const u8 *addr, int key_idx,
- int set_tx, const u8 *seq, size_t seq_len,
+static int wpa_driver_hostap_set_key(const char *ifname, void *priv,
+ enum wpa_alg alg, const u8 *addr,
+ int key_idx, int set_tx,
+ const u8 *seq, size_t seq_len,
const u8 *key, size_t key_len)
{
struct wpa_driver_hostap_data *drv = priv;
}
-static int wpa_driver_hostap_set_drop_unencrypted(void *priv, int enabled)
-{
- struct wpa_driver_hostap_data *drv = priv;
- wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled);
- return prism2param(drv, PRISM2_PARAM_DROP_UNENCRYPTED, enabled);
-}
-
-
static int wpa_driver_hostap_reset(struct wpa_driver_hostap_data *drv,
int type)
{
wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
+ if (prism2param(drv, PRISM2_PARAM_DROP_UNENCRYPTED,
+ params->drop_unencrypted) < 0)
+ ret = -1;
+ if (wpa_driver_hostap_set_auth_alg(drv, params->auth_alg) < 0)
+ ret = -1;
if (params->mode != drv->current_mode) {
/* At the moment, Host AP driver requires host_roaming=2 for
* infrastructure mode and host_roaming=0 for adhoc. */
}
-static int wpa_driver_hostap_scan(void *priv, const u8 *ssid, size_t ssid_len)
+static int wpa_driver_hostap_scan(void *priv,
+ struct wpa_driver_scan_params *params)
{
struct wpa_driver_hostap_data *drv = priv;
struct prism2_hostapd_param param;
int ret;
+ const u8 *ssid = params->ssids[0].ssid;
+ size_t ssid_len = params->ssids[0].ssid_len;
if (ssid == NULL) {
/* Use standard Linux Wireless Extensions ioctl if possible
* because some drivers using hostap code in wpa_supplicant
* might not support Host AP specific scan request (with SSID
* info). */
- return wpa_driver_wext_scan(drv->wext, ssid, ssid_len);
+ return wpa_driver_wext_scan(drv->wext, params);
}
if (ssid_len > 32)
struct wpa_driver_hostap_data *drv = priv;
int algs = 0;
- if (auth_alg & AUTH_ALG_OPEN_SYSTEM)
+ if (auth_alg & WPA_AUTH_ALG_OPEN)
algs |= 1;
- if (auth_alg & AUTH_ALG_SHARED_KEY)
+ if (auth_alg & WPA_AUTH_ALG_SHARED)
algs |= 2;
- if (auth_alg & AUTH_ALG_LEAP)
+ if (auth_alg & WPA_AUTH_ALG_LEAP)
algs |= 4;
if (algs == 0)
algs = 1; /* at least one algorithm should be set */
wpa_driver_wext_alternative_ifindex(drv->wext, ifname2);
}
+ wpa_driver_hostap_set_wpa(drv, 1);
+
return drv;
}
static void wpa_driver_hostap_deinit(void *priv)
{
struct wpa_driver_hostap_data *drv = priv;
+ wpa_driver_hostap_set_wpa(drv, 0);
wpa_driver_wext_deinit(drv->wext);
close(drv->sock);
os_free(drv);
const struct wpa_driver_ops wpa_driver_hostap_ops = {
.name = "hostap",
.desc = "Host AP driver (Intersil Prism2/2.5/3)",
+ .set_key = wpa_driver_hostap_set_key,
#ifdef HOSTAPD
.hapd_init = hostap_init,
.hapd_deinit = hostap_driver_deinit,
.set_ieee8021x = hostap_set_ieee8021x,
.set_privacy = hostap_set_privacy,
- .hapd_set_key = hostap_set_key,
.get_seqnum = hostap_get_seqnum,
.flush = hostap_flush,
.set_generic_elem = hostap_set_generic_elem,
.get_inact_sec = hostap_get_inact_sec,
.sta_clear_stats = hostap_sta_clear_stats,
.get_hw_feature_data = hostap_get_hw_feature_data,
- .set_wps_beacon_ie = hostap_set_wps_beacon_ie,
- .set_wps_probe_resp_ie = hostap_set_wps_probe_resp_ie,
+ .set_ap_wps_ie = hostap_set_ap_wps_ie,
#else /* HOSTAPD */
.get_bssid = wpa_driver_hostap_get_bssid,
.get_ssid = wpa_driver_hostap_get_ssid,
- .set_wpa = wpa_driver_hostap_set_wpa,
- .set_key = wpa_driver_hostap_set_key,
.set_countermeasures = wpa_driver_hostap_set_countermeasures,
- .set_drop_unencrypted = wpa_driver_hostap_set_drop_unencrypted,
- .scan = wpa_driver_hostap_scan,
+ .scan2 = wpa_driver_hostap_scan,
.get_scan_results2 = wpa_driver_hostap_get_scan_results,
.deauthenticate = wpa_driver_hostap_deauthenticate,
.disassociate = wpa_driver_hostap_disassociate,
.associate = wpa_driver_hostap_associate,
- .set_auth_alg = wpa_driver_hostap_set_auth_alg,
.init = wpa_driver_hostap_init,
.deinit = wpa_driver_hostap_deinit,
.set_operstate = wpa_driver_hostap_set_operstate,
projects / libeap.git / blobdiff