X-Git-Url: http://www.project-moonshot.org/gitweb/?a=blobdiff_plain;f=src%2Fdrivers%2Fdriver_hostap.c;h=e47983cb7f306189784a715bf36a3543338dffa7;hb=0e2e565a44ab7b073491cab00847f7bc62731483;hp=1d9251788e5f6ea1f14a99c9749460b86ac03ccf;hpb=4b9841d34c0d601a898f508c4164fe2451494fdd;p=libeap.git

diff --git a/src/drivers/driver_hostap.c b/src/drivers/driver_hostap.c
index 1d92517..e47983c 100644
--- a/src/drivers/driver_hostap.c
+++ b/src/drivers/driver_hostap.c
@@ -29,12 +29,16 @@
 #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 {
@@ -43,7 +47,7 @@ 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;
 
@@ -65,6 +69,7 @@ static void handle_data(struct hostap_driver_data *drv, u8 *buf, size_t len,
 	u16 fc, ethertype;
 	u8 *pos, *sa;
 	size_t left;
+	union wpa_event_data event;
 
 	if (len < sizeof(struct ieee80211_hdr))
 		return;
@@ -78,7 +83,10 @@ static void handle_data(struct hostap_driver_data *drv, u8 *buf, size_t len,
 	}
 
 	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);
@@ -105,7 +113,7 @@ static void handle_data(struct hostap_driver_data *drv, u8 *buf, size_t len,
 	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:
@@ -119,33 +127,20 @@ static void handle_tx_callback(struct hostap_driver_data *drv, u8 *buf,
 			       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);
 }
 
 
@@ -156,6 +151,7 @@ static void handle_frame(struct hostap_driver_data *drv, u8 *buf, size_t len)
 	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 */
@@ -200,9 +196,10 @@ static void handle_frame(struct hostap_driver_data *drv, u8 *buf, size_t len)
 
 	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");
@@ -272,21 +269,7 @@ static int hostap_init_sockets(struct hostap_driver_data *drv, u8 *own_addr)
 		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);
 }
 
 
@@ -356,6 +339,12 @@ static int hostap_sta_set_flags(void *priv, const u8 *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(&param, 0, sizeof(param));
 	param.cmd = PRISM2_HOSTAPD_SET_FLAGS_STA;
 	memcpy(param.sta_addr, addr, ETH_ALEN);
@@ -369,31 +358,15 @@ static int hostap_set_iface_flags(void *priv, int dev_up)
 {
 	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]");
@@ -426,10 +399,11 @@ static int hostapd_ioctl(void *priv, struct prism2_hostapd_param *param,
 }
 
 
-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;
@@ -539,9 +513,10 @@ static int hostap_ioctl_prism2param(void *priv, int param, int value)
 }
 
 
-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)) {
@@ -566,7 +541,7 @@ static int hostap_set_ieee8021x(const char *ifname, void *priv, int 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;
 
@@ -575,8 +550,7 @@ static int hostap_set_privacy(const char *ifname, void *priv, int enabled)
 }
 
 
-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;
@@ -650,8 +624,7 @@ static int hostap_read_sta_data(void *priv,
 }
 
 
-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;
@@ -689,7 +662,7 @@ static int hostap_sta_remove(void *priv, const u8 *addr)
 	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(&param, 0, sizeof(param));
 	param.cmd = PRISM2_HOSTAPD_REMOVE_STA;
@@ -769,7 +742,7 @@ static int hostapd_ioctl_set_generic_elem(struct hostap_driver_data *drv)
 }
 
 
-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;
@@ -789,30 +762,28 @@ static int hostap_set_generic_elem(const char *ifname, void *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);
@@ -837,7 +808,12 @@ hostapd_wireless_event_wireless_custom(struct hostap_driver_data *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 "
@@ -898,28 +874,19 @@ static void hostapd_wireless_event_wireless(struct hostap_driver_data *drv,
 }
 
 
-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)) {
@@ -933,55 +900,6 @@ static void hostapd_wireless_event_rtm_newlink(struct hostap_driver_data *drv,
 }
 
 
-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;
@@ -1029,45 +947,25 @@ static int hostap_get_we_version(struct hostap_driver_data *drv)
 
 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)
 {
@@ -1113,7 +1011,7 @@ static void hostap_driver_deinit(void *priv)
 {
 	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);
@@ -1190,12 +1088,14 @@ static struct hostapd_hw_modes * hostap_get_hw_feature_data(void *priv,
 	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;
 	}
 
@@ -1207,14 +1107,10 @@ static struct hostapd_hw_modes * hostap_get_hw_feature_data(void *priv,
 			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;
 }
@@ -1230,6 +1126,9 @@ struct wpa_driver_hostap_data {
 };
 
 
+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)
@@ -1345,9 +1244,10 @@ static void show_set_key_error(struct prism2_hostapd_param *param)
 }
 
 
-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;
@@ -1430,14 +1330,6 @@ static int wpa_driver_hostap_set_countermeasures(void *priv, int enabled)
 }
 
 
-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)
 {
@@ -1513,6 +1405,11 @@ wpa_driver_hostap_associate(void *priv,
 
 	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. */
@@ -1563,18 +1460,21 @@ wpa_driver_hostap_associate(void *priv,
 }
 
 
-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)
@@ -1602,11 +1502,11 @@ static int wpa_driver_hostap_set_auth_alg(void *priv, int auth_alg)
 	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 */
@@ -1677,6 +1577,8 @@ static void * wpa_driver_hostap_init(void *ctx, const char *ifname)
 		wpa_driver_wext_alternative_ifindex(drv->wext, ifname2);
 	}
 
+	wpa_driver_hostap_set_wpa(drv, 1);
+
 	return drv;
 }
 
@@ -1684,6 +1586,7 @@ static void * wpa_driver_hostap_init(void *ctx, const char *ifname)
 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);
@@ -1695,12 +1598,12 @@ static void wpa_driver_hostap_deinit(void *priv)
 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,
@@ -1716,21 +1619,16 @@ const struct wpa_driver_ops wpa_driver_hostap_ops = {
 	.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,