Integrate the hostap stuff that Thomas Skibo <skibo@packbell.net>

wrote.  This code was for 4.5-release, so I've ported it to -current
and made a few minor tweaks.  The biggest non-style tweak was to not
make access point the default.

More changes will be needed to get this actually working, but I wanted
to get a relatively pure baseline.  This doesn't seem to break what
works now.

8 files changed, 1769 insertions, 53 deletions

diff --git a/sys/dev/wi/if_wavelan_ieee.h b/sys/dev/wi/if_wavelan_ieee.h
index 159867e..2ba1dbf 100644
--- a/sys/dev/wi/if_wavelan_ieee.h
+++ b/sys/dev/wi/if_wavelan_ieee.h
@@ -50,6 +50,7 @@
 #ifndef SIOCGWAVELAN
 #define SIOCGWAVELAN	SIOCGIFGENERIC
 #endif
+#define WI_RID_MONITOR_MODE	0x0500
 
 /*
  * Technically I don't think there's a limit to a record
@@ -113,6 +114,13 @@ struct wi_80211_hdr {
 #define WI_STYPE_MGMT_AUTH	0x00B0	/* authentication */
 #define WI_STYPE_MGMT_DEAUTH	0x00C0	/* deauthentication */
 
+#define WI_STYPE_CTL_PSPOLL     0x00A0
+#define WI_STYPE_CTL_RTS        0x00B0
+#define WI_STYPE_CTL_CTS        0x00C0
+#define WI_STYPE_CTL_ACK        0x00D0
+#define WI_STYPE_CTL_CFEND      0x00E0
+#define WI_STYPE_CTL_CFENDACK   0x00F0
+
 struct wi_mgmt_hdr {
 	u_int16_t		frame_ctl;
 	u_int16_t		duration;
@@ -209,7 +217,7 @@ struct wi_counters {
 #define	 IV_EVERY100_FRAME	0x60	/* every 100 frame IV reuse */
 #define	 HOST_DECRYPT		0x80
 #define WI_RID_WEP_MAPTABLE	0xFC29
-#define WI_RID_AUTH_CNTL	0xFC2A
+#define WI_RID_CNFAUTHMODE	0xFC2A
 #define WI_RID_ROAMING_MODE	0xFC2D
 #define WI_RID_BASIC_RATE	0xFCB3
 #define WI_RID_SUPPORT_RATE	0xFCB4
@@ -221,7 +229,11 @@ struct wi_counters {
 #define WI_RID_CREATE_IBSS	0xFC81 /* create IBSS */
 #define WI_RID_FRAG_THRESH	0xFC82 /* frag len, unicast msg xmit */
 #define WI_RID_RTS_THRESH	0xFC83 /* frame len for RTS/CTS handshake */
-#define WI_RID_TX_RATE		0xFC84 /* data rate for message xmit */
+#define WI_RID_TX_RATE		0xFC84 /* data rate for message xmit
+ 					* 0 == Fixed 1mbps
+ 					* 1 == Fixed 2mbps
+ 					* 2 == auto fallback
+					*/
 #define WI_RID_PROMISC		0xFC85 /* enable promisc mode */
 #define WI_RID_FRAG_THRESH0	0xFC90
 #define WI_RID_FRAG_THRESH1	0xFC91
diff --git a/sys/dev/wi/if_wi.c b/sys/dev/wi/if_wi.c
index 87ac17b..3adecc1 100644
--- a/sys/dev/wi/if_wi.c
+++ b/sys/dev/wi/if_wi.c
@@ -95,6 +95,10 @@
 #include <net/bpf.h>
 
 #include <dev/wi/if_wavelan_ieee.h>
+#ifdef WI_HOSTAP
+#include <dev/wi/wi_hostap.h>
+#include <sys/random.h>
+#endif
 #include <dev/wi/if_wivar.h>
 #include <dev/wi/if_wireg.h>
 
@@ -124,7 +128,6 @@ static int wi_seek(struct wi_softc *, int, int, int);
 static int wi_alloc_nicmem(struct wi_softc *, int, int *);
 static void wi_inquire(void *);
 static void wi_setdef(struct wi_softc *, struct wi_req *);
-static int wi_mgmt_xmit(struct wi_softc *, caddr_t, int);
 
 #ifdef WICACHE
 static
@@ -214,6 +217,7 @@ wi_generic_attach(device_t dev)
 	struct ifnet		*ifp;
 	int			error;
 
+	/* XXX maybe we need the splimp stuff here XXX */
 	sc = device_get_softc(dev);
 	ifp = &sc->arpcom.ac_if;
 
@@ -290,6 +294,7 @@ wi_generic_attach(device_t dev)
 	sc->wi_max_sleep = WI_DEFAULT_MAX_SLEEP;
 	sc->wi_roaming = WI_DEFAULT_ROAMING;
 	sc->wi_authtype = WI_DEFAULT_AUTHTYPE;
+	sc->wi_authmode = IEEE80211_AUTH_OPEN;
 
 	/*
 	 * Read the default channel from the NIC. This may vary
@@ -311,11 +316,18 @@ wi_generic_attach(device_t dev)
 	sc->wi_has_wep = gen.wi_val;
 
 	if (bootverbose) {
-		device_printf(sc->dev,
-				"%s:wi_has_wep = %d\n",
-				__func__, sc->wi_has_wep);
+		device_printf(sc->dev, "%s:wi_has_wep = %d\n",
+		  __func__, sc->wi_has_wep);
 	}
 
+	/* 
+	 * Find supported rates.
+	 */
+	gen.wi_type = WI_RID_TX_RATE;
+	gen.wi_len = 2;
+	wi_read_record(sc, &gen);
+	sc->wi_supprates = gen.wi_val;
+
 	bzero((char *)&sc->wi_stats, sizeof(sc->wi_stats));
 
 	wi_init(sc);
@@ -339,6 +351,20 @@ wi_generic_attach(device_t dev)
 	ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_AUTO, 
 		IFM_IEEE80211_ADHOC, 0), 0);
 	ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_AUTO, 0, 0), 0);
+#ifdef IFM_IEEE80211_HOSTAP
+	if (sc->sc_firmware_type == WI_INTERSIL) {
+		ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS1,
+		    IFM_IEEE80211_HOSTAP, 0), 0);
+		ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS2,
+		    IFM_IEEE80211_HOSTAP, 0), 0);
+		ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS5,
+		    IFM_IEEE80211_HOSTAP, 0), 0);
+		ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS11,
+		    IFM_IEEE80211_HOSTAP, 0), 0);
+		ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_AUTO, 
+		    IFM_IEEE80211_HOSTAP, 0), 0);
+	}
+#endif
 #undef	ADD
 	ifmedia_set(&sc->ifmedia, IFM_MAKEWORD(IFM_IEEE80211, IFM_AUTO,
 	    0, 0));
@@ -587,6 +613,38 @@ wi_rxeof(sc)
 		eh = mtod(m, struct ether_header *);
 		m->m_pkthdr.rcvif = ifp;
 
+#ifdef WI_HOSTAP
+		if (rx_frame.wi_status == WI_STAT_MGMT &&
+		    sc->wi_ptype == WI_PORTTYPE_AP) {
+			if ((WI_802_11_OFFSET_RAW + rx_frame.wi_dat_len + 2) >
+			    MCLBYTES) {
+				device_printf(sc->dev, "oversized mgmt packet "
+				    "received in hostap mode " 
+				    "(wi_dat_len=%d, wi_status=0x%x)\n",
+				    rx_frame.wi_dat_len, rx_frame.wi_status);
+				m_freem(m);
+				ifp->if_ierrors++;
+				return;
+			}
+
+			/* Put the whole header in there. */
+			bcopy(&rx_frame, mtod(m, void *),
+			    sizeof(struct wi_frame));
+			if (wi_read_data(sc, id, WI_802_11_OFFSET_RAW, 
+			    mtod(m, caddr_t) + WI_802_11_OFFSET_RAW,
+			    rx_frame.wi_dat_len + 2)) {
+				m_freem(m);
+				ifp->if_ierrors++;
+				return;
+			}
+			m->m_pkthdr.len = m->m_len =
+			    WI_802_11_OFFSET_RAW + rx_frame.wi_dat_len;
+			/* XXX: consider giving packet to bhp? */
+			wihap_mgmt_input(sc, &rx_frame, m);
+			return;
+		}
+#endif /* WI_HOSTAP */
+
 		if (rx_frame.wi_status == WI_STAT_1042 ||
 		    rx_frame.wi_status == WI_STAT_TUNNEL ||
 		    rx_frame.wi_status == WI_STAT_WMP_MSG) {
@@ -653,6 +711,18 @@ wi_rxeof(sc)
 
 		ifp->if_ipackets++;
 
+#ifdef WI_HOSTAP
+		if (sc->wi_ptype == WI_PORTTYPE_AP) {
+			/* 
+			 * Give host AP code first crack at data
+			 * packets.  If it decides to handle it (or
+			 * drop it), it will return a non-zero.
+			 * Otherwise, it is destined for this host.
+			 */
+			if (wihap_data_input(sc, &rx_frame, m))
+				return;
+		}
+#endif
 		/* Receive packet. */
 		m_adj(m, sizeof(struct ether_header));
 #ifdef WICACHE
@@ -688,6 +758,7 @@ wi_inquire(xsc)
 {
 	struct wi_softc		*sc;
 	struct ifnet		*ifp;
+	int s;
 
 	sc = xsc;
 	ifp = &sc->arpcom.ac_if;
@@ -698,7 +769,9 @@ wi_inquire(xsc)
 	if (ifp->if_flags & IFF_OACTIVE)
 		return;
 
+	s = splimp();
 	wi_cmd(sc, WI_CMD_INQUIRE, WI_INFO_COUNTERS, 0, 0);
+	splx(s);
 
 	return;
 }
@@ -1002,7 +1075,7 @@ wi_read_record(sc, ltv)
 			oltv->wi_len = 2;
 			oltv->wi_val = ltv->wi_val;
 			break;
-		case WI_RID_AUTH_CNTL:
+		case WI_RID_CNFAUTHMODE:
                         oltv->wi_len = 2;
 			if (le16toh(ltv->wi_val) & 0x01)
 				oltv->wi_val = htole16(1);
@@ -1047,10 +1120,18 @@ wi_write_record(sc, ltv)
 		case WI_RID_ENCRYPTION:
 			p2ltv.wi_type = WI_RID_P2_ENCRYPTION;
 			p2ltv.wi_len = 2;
-			if (le16toh(ltv->wi_val))
+			if (le16toh(ltv->wi_val)) {
 				p2ltv.wi_val =htole16(PRIVACY_INVOKED |
 				    EXCLUDE_UNENCRYPTED);
-			else
+#ifdef WI_HOSTAP
+				if (sc->wi_ptype == WI_PORTTYPE_AP)
+					/* 
+					 * Disable tx encryption...
+					 * it's broken.
+					 */
+					p2ltv.wi_val |= htole16(HOST_ENCRYPT);
+#endif
+			} else
 				p2ltv.wi_val =
 				    htole16(HOST_ENCRYPT | HOST_DECRYPT);
 			ltv = &p2ltv;
@@ -1084,8 +1165,8 @@ wi_write_record(sc, ltv)
 			}
 			return 0;
 		    }
-		case WI_RID_AUTH_CNTL:
-			p2ltv.wi_type = WI_RID_AUTH_CNTL;
+		case WI_RID_CNFAUTHMODE:
+			p2ltv.wi_type = WI_RID_CNFAUTHMODE;
 			p2ltv.wi_len = 2;
 			if (le16toh(ltv->wi_val) == 1)
 				p2ltv.wi_val = htole16(0x01);
@@ -1372,7 +1453,7 @@ wi_setdef(sc, wreq)
 	case WI_RID_MAX_SLEEP:
 		sc->wi_max_sleep = le16toh(wreq->wi_val[0]);
 		break;
-	case WI_RID_AUTH_CNTL:
+	case WI_RID_CNFAUTHMODE:
 		sc->wi_authtype = le16toh(wreq->wi_val[0]);
 		break;
 	case WI_RID_ROAMING_MODE:
@@ -1632,7 +1713,7 @@ wi_ioctl(ifp, command, data)
 				ireq->i_val = sc->wi_tx_key;
 			break;
 		case IEEE80211_IOC_AUTHMODE:
-			ireq->i_val = IEEE80211_AUTH_NONE;
+			ireq->i_val = sc->wi_authmode;
 			break;
 		case IEEE80211_IOC_STATIONNAME:
 			error = copyout(sc->wi_node_name,
@@ -1712,7 +1793,7 @@ wi_ioctl(ifp, command, data)
 			sc->wi_tx_key = ireq->i_val;
 			break;
 		case IEEE80211_IOC_AUTHMODE:
-			error = EINVAL;
+			sc->wi_authmode = ireq->i_val;
 			break;
 		case IEEE80211_IOC_STATIONNAME:
 			if (ireq->i_len > 32) {
@@ -1763,7 +1844,18 @@ wi_ioctl(ifp, command, data)
 		/* Reinitialize WaveLAN. */
 		wi_init(sc);
 
+	break;
+#ifdef WI_HOSTAP
+	case SIOCHOSTAP_ADD:
+	case SIOCHOSTAP_DEL:
+	case SIOCHOSTAP_GET:
+	case SIOCHOSTAP_GETALL:
+	case SIOCHOSTAP_GFLAGS:
+	case SIOCHOSTAP_SFLAGS:
+		/* Send all Host AP specific ioctl's to Host AP code. */
+		error = wihap_ioctl(sc, command, data);
 		break;
+#endif
 	default:
 		error = EINVAL;
 		break;
@@ -1834,6 +1926,9 @@ wi_init(xsc)
 	/* Program the nodename. */
 	WI_SETSTR(WI_RID_NODENAME, sc->wi_node_name);
 
+	/* Specify the authentication mode. */
+	WI_SETVAL(WI_RID_CNFAUTHMODE, sc->wi_authmode);
+
 	/* Set our MAC address. */
 	mac.wi_len = 4;
 	mac.wi_type = WI_RID_MAC_NODE;
@@ -1863,7 +1958,7 @@ wi_init(xsc)
 				/* firm ver < 0.8 variant 2 */
 				WI_SETVAL(WI_RID_PROMISC, 1);
 			}
-			WI_SETVAL(WI_RID_AUTH_CNTL, sc->wi_authtype);
+			WI_SETVAL(WI_RID_CNFAUTHMODE, sc->wi_authtype);
 		}
 	}
 
@@ -1891,6 +1986,15 @@ wi_init(xsc)
 	/* enable interrupts */
 	CSR_WRITE_2(sc, WI_INT_EN, WI_INTRS);
 
+#ifdef WI_HOSTAP
+	wihap_init(sc);
+
+	/* 
+	 * Initialize ICV to something random.  XXX: this doesn't work
+	 * if init happens in early boot-up.  Fix later.
+	 */
+	read_random(&sc->wi_icv, sizeof(sc->wi_icv));
+#endif
 	ifp->if_flags |= IFF_RUNNING;
 	ifp->if_flags &= ~IFF_OACTIVE;
 
@@ -1900,6 +2004,159 @@ wi_init(xsc)
 	return;
 }
 
+#ifdef WI_HOSTAP
+
+/*
+ * Host encryption code: Transmits are broken in Host AP mode when WEP is
+ * enabled.  So, we disable TX encryption and manually encrypt it here.
+ */
+
+static u_int32_t
+wi_next_crc32(u_int32_t crc32, u_int8_t byte)
+{
+	/* Thanks again, RFC 1662. */
+	static u_int32_t fcstab_32[] = {
+		0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
+		0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
+		0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+		0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
+		0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+		0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+		0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
+		0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
+		0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+		0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+		0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
+		0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+		0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
+		0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
+		0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+		0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
+		0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
+		0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+		0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
+		0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+		0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+		0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
+		0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
+		0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+		0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+		0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
+		0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+		0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
+		0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
+		0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+		0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
+		0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
+		0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+		0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
+		0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+		0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+		0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
+		0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
+		0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+		0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+		0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
+		0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+		0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
+		0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
+		0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+		0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
+		0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
+		0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+		0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
+		0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+		0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+		0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
+		0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
+		0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+		0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+		0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
+		0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+		0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
+		0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
+		0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+		0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
+		0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
+		0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+		0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+	};
+
+	return (crc32>>8) ^ fcstab_32[(u_int8_t)(byte ^ crc32)];
+}
+
+
+static __inline void
+SWAP(u_int8_t *pa, u_int8_t *pb)
+{
+	u_int8_t c;
+	c = *pa;
+	*pa = *pb;
+	*pb = c;
+}
+
+static void
+wi_do_hostencrypt(struct wi_softc *sc, caddr_t buf, int len)
+{
+	int 		i;
+	u_int32_t	crc32;
+	u_int8_t 	k[16];
+	u_int8_t	state[256];
+	u_int8_t	x, y;
+	int		keylen;
+
+	keylen = (sc->wi_keys.wi_keys[sc->wi_tx_key].wi_keylen>5) ? 16:8;
+
+	/* Create ICV/key concatenation. */
+	k[0] = sc->wi_icv >> 16;
+	k[1] = sc->wi_icv >> 8;
+	k[2] = sc->wi_icv;
+	for (i=3; i<keylen; i++)
+		k[i] = sc->wi_keys.wi_keys[sc->wi_tx_key].wi_keydat[i-3];
+
+	/* Insert ICV in packet. */
+	buf[0] = k[0];
+	buf[1] = k[1];
+	buf[2] = k[2];
+	buf[3] = (sc->wi_tx_key<<6);
+	++sc->wi_icv;
+
+	/* Initialize key. */
+	for (i=0; i<256; i++)
+		state[i]=i;
+	x=0;
+	y=0;
+	for (i=0; i<256; i++) {
+		y = (k[x]+state[i]+y);
+		SWAP(&state[i], &state[y]);
+		x = (x+1) & (keylen-1);
+	}
+
+	/* Start encrypting. */
+	x=0;
+	y=0;
+	crc32=0xffffffff;
+	for (i=0; i<len; i++) {
+		x++;
+		y = state[x]+y;
+		SWAP(&state[x], &state[y]);
+		crc32 = wi_next_crc32(crc32, buf[i+4]);
+		buf[i+4] ^= state[ (u_int8_t)(state[x] + state[y]) ];
+	}
+
+	/* Append CRC-32, encrypt it too. */
+	crc32 ^= 0xffffffff;
+	for (i=0; i<4; i++) {
+		x++;
+		y = state[x]+y;
+		SWAP(&state[x], &state[y]);
+		buf[i+len+4] = crc32;
+		crc32 >>= 8;
+		buf[i+len+4] ^= state[ (u_int8_t)(state[x] + state[y]) ];
+	}
+}
+#endif /* WI_HOSTAP */
+
 static void
 wi_start(ifp)
 	struct ifnet		*ifp;
@@ -1923,6 +2180,9 @@ wi_start(ifp)
 		return;
 	}
 
+#ifdef WI_HOSTAP
+nextpkt:
+#endif
 	IF_DEQUEUE(&ifp->if_snd, m0);
 	if (m0 == NULL) {
 		WI_UNLOCK(sc);
@@ -1930,9 +2190,22 @@ wi_start(ifp)
 	}
 
 	bzero((char *)&tx_frame, sizeof(tx_frame));
+	tx_frame.wi_frame_ctl = htole16(WI_FTYPE_DATA);
 	id = sc->wi_tx_data_id;
 	eh = mtod(m0, struct ether_header *);
 
+#ifdef WI_HOSTAP
+	if (sc->wi_ptype == WI_PORTTYPE_AP) {
+		if (!wihap_check_tx(&sc->wi_hostap_info,
+		    eh->ether_dhost, &tx_frame.wi_tx_rate)) {
+			if (ifp->if_flags & IFF_DEBUG)
+				printf("wi_start: dropping unassoc "
+				       "dst %6D\n", eh->ether_dhost, ":");
+			m_freem(m0);
+			goto nextpkt;
+		}
+	}
+#endif
 	/*
 	 * Use RFC1042 encoding for IP and ARP datagrams,
 	 * 802.3 for anything else.
@@ -1940,38 +2213,81 @@ wi_start(ifp)
 	if (ntohs(eh->ether_type) > ETHER_MAX_LEN) {
 		bcopy((char *)&eh->ether_dhost,
 		    (char *)&tx_frame.wi_addr1, ETHER_ADDR_LEN);
-		bcopy((char *)&eh->ether_shost,
-		    (char *)&tx_frame.wi_addr2, ETHER_ADDR_LEN);
+#ifdef WI_HOSTAP
+		if (sc->wi_ptype == WI_PORTTYPE_AP) {
+			tx_frame.wi_tx_ctl = WI_ENC_TX_MGMT; /* XXX */
+			tx_frame.wi_frame_ctl |= WI_FCTL_FROMDS;
+			if (sc->wi_use_wep)
+				tx_frame.wi_frame_ctl |= WI_FCTL_WEP;
+			bcopy((char *)&sc->arpcom.ac_enaddr,
+			      (char *)&tx_frame.wi_addr2, ETHER_ADDR_LEN);
+			bcopy((char *)&eh->ether_shost,
+			      (char *)&tx_frame.wi_addr3, ETHER_ADDR_LEN);
+		}
+		else
+#endif
+			bcopy((char *)&eh->ether_shost,
+			    (char *)&tx_frame.wi_addr2, ETHER_ADDR_LEN);
 		bcopy((char *)&eh->ether_dhost,
 		    (char *)&tx_frame.wi_dst_addr, ETHER_ADDR_LEN);
 		bcopy((char *)&eh->ether_shost,
 		    (char *)&tx_frame.wi_src_addr, ETHER_ADDR_LEN);
 
 		tx_frame.wi_dat_len = m0->m_pkthdr.len - WI_SNAPHDR_LEN;
-		tx_frame.wi_frame_ctl = WI_FTYPE_DATA;
 		tx_frame.wi_dat[0] = htons(WI_SNAP_WORD0);
 		tx_frame.wi_dat[1] = htons(WI_SNAP_WORD1);
 		tx_frame.wi_len = htons(m0->m_pkthdr.len - WI_SNAPHDR_LEN);
 		tx_frame.wi_type = eh->ether_type;
 
-		m_copydata(m0, sizeof(struct ether_header),
-		    m0->m_pkthdr.len - sizeof(struct ether_header),
-		    (caddr_t)&sc->wi_txbuf);
-
-		wi_write_data(sc, id, 0, (caddr_t)&tx_frame,
-		    sizeof(struct wi_frame));
-		wi_write_data(sc, id, WI_802_11_OFFSET, (caddr_t)&sc->wi_txbuf,
-		    (m0->m_pkthdr.len - sizeof(struct ether_header)) + 2);
+#ifdef WI_HOSTAP
+		if (sc->wi_ptype == WI_PORTTYPE_AP && sc->wi_use_wep) {
+			/* Do host encryption. */
+			bcopy(&tx_frame.wi_dat[0], &sc->wi_txbuf[4], 8);
+			m_copydata(m0, sizeof(struct ether_header),
+			    m0->m_pkthdr.len - sizeof(struct ether_header),
+			    (caddr_t)&sc->wi_txbuf[12]);
+			wi_do_hostencrypt(sc, &sc->wi_txbuf[0],
+			    tx_frame.wi_dat_len);
+			tx_frame.wi_dat_len += 8;
+			wi_write_data(sc, id, 0, (caddr_t)&tx_frame,
+			    sizeof(struct wi_frame));
+			wi_write_data(sc, id, WI_802_11_OFFSET_RAW,
+			    (caddr_t)&sc->wi_txbuf, (m0->m_pkthdr.len -
+			    sizeof(struct ether_header)) + 18);
+		}
+		else
+#endif
+		{
+			m_copydata(m0, sizeof(struct ether_header),
+			    m0->m_pkthdr.len - sizeof(struct ether_header),
+			    (caddr_t)&sc->wi_txbuf);
+			wi_write_data(sc, id, 0, (caddr_t)&tx_frame,
+			    sizeof(struct wi_frame));
+			wi_write_data(sc, id, WI_802_11_OFFSET,
+			    (caddr_t)&sc->wi_txbuf, (m0->m_pkthdr.len -
+			    sizeof(struct ether_header)) + 2);
+		}
 	} else {
 		tx_frame.wi_dat_len = m0->m_pkthdr.len;
 
-		eh->ether_type = htons(m0->m_pkthdr.len - WI_SNAPHDR_LEN);
-		m_copydata(m0, 0, m0->m_pkthdr.len, (caddr_t)&sc->wi_txbuf);
-
-		wi_write_data(sc, id, 0, (caddr_t)&tx_frame,
-		    sizeof(struct wi_frame));
-		wi_write_data(sc, id, WI_802_3_OFFSET, (caddr_t)&sc->wi_txbuf,
-		    m0->m_pkthdr.len + 2);
+#ifdef WI_HOSTAP
+		if (sc->wi_ptype == WI_PORTTYPE_AP && sc->wi_use_wep) {
+			/* Do host encryption. */
+			printf( "XXX: host encrypt not implemented for 802.3\n" );
+		}
+		else
+#endif
+		{
+			eh->ether_type = htons(m0->m_pkthdr.len -
+			    WI_SNAPHDR_LEN);
+			m_copydata(m0, 0, m0->m_pkthdr.len,
+			    (caddr_t)&sc->wi_txbuf);
+
+			wi_write_data(sc, id, 0, (caddr_t)&tx_frame,
+			    sizeof(struct wi_frame));
+			wi_write_data(sc, id, WI_802_3_OFFSET,
+			    (caddr_t)&sc->wi_txbuf, m0->m_pkthdr.len + 2);
+		}
 	}
 
 	/*
@@ -1998,7 +2314,7 @@ wi_start(ifp)
 	return;
 }
 
-static int
+int
 wi_mgmt_xmit(sc, data, len)
 	struct wi_softc		*sc;
 	caddr_t			data;
@@ -2021,12 +2337,13 @@ wi_mgmt_xmit(sc, data, len)
 	bcopy((char *)hdr, (char *)&tx_frame.wi_frame_ctl,
 	   sizeof(struct wi_80211_hdr));
 
-	tx_frame.wi_dat_len = len - WI_SNAPHDR_LEN;
-	tx_frame.wi_len = htons(len - WI_SNAPHDR_LEN);
+	tx_frame.wi_tx_ctl = WI_ENC_TX_MGMT;
+	tx_frame.wi_dat_len = len - sizeof(struct wi_80211_hdr);
+	tx_frame.wi_len = htons(tx_frame.wi_dat_len);
 
 	wi_write_data(sc, id, 0, (caddr_t)&tx_frame, sizeof(struct wi_frame));
 	wi_write_data(sc, id, WI_802_11_OFFSET_RAW, dptr,
-	    (len - sizeof(struct wi_80211_hdr)) + 2);
+	    len - sizeof(struct wi_80211_hdr) + 2);
 
 	if (wi_cmd(sc, WI_CMD_TX|WI_RECLAIM, id, 0, 0)) {
 		device_printf(sc->dev, "xmit failed\n");
@@ -2049,6 +2366,10 @@ wi_stop(sc)
 		return;
 	}
 
+#ifdef WI_HOSTAP
+	wihap_shutdown(sc);
+#endif
+
 	ifp = &sc->arpcom.ac_if;
 
 	/*
@@ -2268,7 +2589,8 @@ wi_cache_store(struct wi_softc *sc, struct ether_header *eh,
 	int sig, noise;
 	int sawip=0;
 
-	/* filters:
+	/* 
+	 * filters:
 	 * 1. ip only
 	 * 2. configurable filter to throw out unicast packets,
 	 * keep multicast only.
@@ -2278,13 +2600,15 @@ wi_cache_store(struct wi_softc *sc, struct ether_header *eh,
 		sawip = 1;
 	}
 
-	/* filter for ip packets only 
+	/* 
+	 * filter for ip packets only 
 	*/
 	if (wi_cache_iponly && !sawip) {
 		return;
 	}
 
-	/* filter for broadcast/multicast only
+	/*
+	 *  filter for broadcast/multicast only
 	 */
 	if (wi_cache_mcastonly && ((eh->ether_dhost[0] & 1) == 0)) {
 		return;
@@ -2295,21 +2619,23 @@ wi_cache_store(struct wi_softc *sc, struct ether_header *eh,
 	    rx_quality & 0xffff, rx_quality >> 8, rx_quality & 0xff);
 #endif
 
-	/* find the ip header.  we want to store the ip_src
+	/*
+	 *  find the ip header.  we want to store the ip_src
 	 * address.  
 	 */
-	if (sawip) {
+	if (sawip)
 		ip = mtod(m, struct ip *);
-	}
         
-	/* do a linear search for a matching MAC address 
+	/*
+	 * do a linear search for a matching MAC address 
 	 * in the cache table
 	 * . MAC address is 6 bytes,
 	 * . var w_nextitem holds total number of entries already cached
 	 */
 	for(i = 0; i < sc->wi_nextitem; i++) {
 		if (! bcmp(eh->ether_shost , sc->wi_sigcache[i].macsrc,  6 )) {
-			/* Match!,
+			/* 
+			 * Match!,
 			 * so we already have this entry,
 			 * update the data
 			 */
@@ -2317,19 +2643,22 @@ wi_cache_store(struct wi_softc *sc, struct ether_header *eh,
 		}
 	}
 
-	/* did we find a matching mac address?
+	/*
+	 *  did we find a matching mac address?
 	 * if yes, then overwrite a previously existing cache entry
 	 */
 	if (i < sc->wi_nextitem )   {
 		cache_slot = i; 
 	}
-	/* else, have a new address entry,so
+	/*
+	 * else, have a new address entry,so
 	 * add this new entry,
 	 * if table full, then we need to replace LRU entry
 	 */
 	else    {                          
 
-		/* check for space in cache table 
+		/* 
+		 * check for space in cache table 
 		 * note: wi_nextitem also holds number of entries
 		 * added in the cache table 
 		 */
@@ -2349,7 +2678,8 @@ wi_cache_store(struct wi_softc *sc, struct ether_header *eh,
 		}
 	}
 
-	/* invariant: cache_slot now points at some slot
+	/* 
+	 * invariant: cache_slot now points at some slot
 	 * in cache.
 	 */
 	if (cache_slot < 0 || cache_slot >= MAXWICACHE) {
@@ -2359,14 +2689,14 @@ wi_cache_store(struct wi_softc *sc, struct ether_header *eh,
 		return;
 	}
 
-	/*  store items in cache
+	/*
+	 *  store items in cache
 	 *  .ip source address
 	 *  .mac src
 	 *  .signal, etc.
 	 */
-	if (sawip) {
+	if (sawip)
 		sc->wi_sigcache[cache_slot].ipsrc = ip->ip_src.s_addr;
-	}
 	bcopy( eh->ether_shost, sc->wi_sigcache[cache_slot].macsrc,  6);
 
 	sig = (rx_quality >> 8) & 0xFF;
@@ -2390,6 +2720,12 @@ wi_get_cur_ssid(sc, ssid, len)
 
 	wreq.wi_len = WI_MAX_DATALEN;
 	switch (sc->wi_ptype) {
+#ifdef WI_HOSTAP
+	case WI_PORTTYPE_AP:
+		*len = IEEE80211_NWID_LEN;
+		bcopy(sc->wi_net_name, ssid, IEEE80211_NWID_LEN);
+		break;
+#endif
 	case WI_PORTTYPE_ADHOC:
 		wreq.wi_type = WI_RID_CURRENT_SSID;
 		error = wi_read_record(sc, (struct wi_ltv_gen *)&wreq);
@@ -2442,6 +2778,10 @@ wi_media_change(ifp)
 
 	if ((sc->ifmedia.ifm_cur->ifm_media & IFM_IEEE80211_ADHOC) != 0)
 		sc->wi_ptype = WI_PORTTYPE_ADHOC;
+#if defined(WI_HOSTAP) && defined(IFM_IEEE80211_HOSTAP)
+	else if ((sc->ifmedia.ifm_cur->ifm_media & IFM_IEEE80211_HOSTAP) != 0)
+		sc->wi_ptype = WI_PORTTYPE_AP;
+#endif
 	else
 		sc->wi_ptype = WI_PORTTYPE_BSS;
 
@@ -2482,6 +2822,10 @@ wi_media_status(ifp, imr)
 		imr->ifm_active = IFM_IEEE80211|IFM_AUTO;
 		if (sc->wi_ptype == WI_PORTTYPE_ADHOC)
 			imr->ifm_active |= IFM_IEEE80211_ADHOC;
+#if defined(WI_HOSTAP) && defined(IFM_IEEE80211_HOSTAP)
+		else if (sc->wi_ptype == WI_PORTTYPE_AP)
+			imr->ifm_active |= IFM_IEEE80211_HOSTAP;
+#endif
 		wreq.wi_type = WI_RID_CUR_TX_RATE;
 		wreq.wi_len = WI_MAX_DATALEN;
 		if (wi_read_record(sc, (struct wi_ltv_gen *)&wreq) == 0) {
@@ -2512,6 +2856,10 @@ wi_media_status(ifp, imr)
 		 * created one ourselves.
 		 */
 		imr->ifm_status |= IFM_ACTIVE;
+#ifdef WI_HOSTAP
+	else if (sc->wi_ptype == WI_PORTTYPE_AP)
+		imr->ifm_status |= IFM_ACTIVE;
+#endif
 	else {
 		wreq.wi_type = WI_RID_COMMQUAL;
 		wreq.wi_len = WI_MAX_DATALEN;
diff --git a/sys/dev/wi/if_wi_pccard.c b/sys/dev/wi/if_wi_pccard.c
index 02a662c..642cdec 100644
--- a/sys/dev/wi/if_wi_pccard.c
+++ b/sys/dev/wi/if_wi_pccard.c
@@ -60,6 +60,9 @@
 #include <dev/pccard/pccarddevs.h>
 
 #include <dev/wi/if_wavelan_ieee.h>
+#ifdef WI_HOSTAP
+#include <dev/wi/wi_hostap.h>
+#endif
 #include <dev/wi/if_wivar.h>
 #include <dev/wi/if_wireg.h>
 
diff --git a/sys/dev/wi/if_wi_pci.c b/sys/dev/wi/if_wi_pci.c
index 9adc8ce..d2f8ef5 100644
--- a/sys/dev/wi/if_wi_pci.c
+++ b/sys/dev/wi/if_wi_pci.c
@@ -59,6 +59,9 @@
 #include <net/if_ieee80211.h>
 
 #include <dev/wi/if_wavelan_ieee.h>
+#ifdef WI_HOSTAP
+#include <dev/wi/wi_hostap.h>
+#endif
 #include <dev/wi/if_wivar.h>
 #include <dev/wi/if_wireg.h>
 
diff --git a/sys/dev/wi/if_wireg.h b/sys/dev/wi/if_wireg.h
index e3c705b..7a02987 100644
--- a/sys/dev/wi/if_wireg.h
+++ b/sys/dev/wi/if_wireg.h
@@ -497,9 +497,11 @@ struct wi_ltv_pcf {
  *	(Only PRISM2; not 802.11 compliant mode, testing use only)
  * 6 == HOST AP (Only PRISM2)
  */
+#define WI_PORTTYPE_IBSS	0x0
 #define WI_PORTTYPE_BSS		0x1
 #define WI_PORTTYPE_WDS		0x2
 #define WI_PORTTYPE_ADHOC	0x3
+#define WI_PORTTYPE_AP		0x6
 
 /*
  * Mac addresses. (0xFC01, 0xFC08)
@@ -539,6 +541,14 @@ struct wi_ltv_mcast {
 };
 
 /*
+ * supported rates. (0xFCB4)
+ */
+#define WI_SUPPRATES_1M		0x0001
+#define WI_SUPPRATES_2M		0x0002
+#define WI_SUPPRATES_5M		0x0004
+#define WI_SUPPRATES_11M	0x0008
+
+/*
  * Information frame types.
  */
 #define WI_INFO_NOTIFY		0xF000	/* Handover address */
@@ -556,7 +566,8 @@ struct wi_frame {
 	u_int16_t		wi_rsvd1;	/* 0x04 */
 	u_int16_t		wi_q_info;	/* 0x06 */
 	u_int16_t		wi_rsvd2;	/* 0x08 */
-	u_int16_t		wi_rsvd3;	/* 0x0A */
+	u_int8_t		wi_tx_rtry;	/* 0x0A */
+	u_int8_t		wi_tx_rate;	/* 0x0B */
 	u_int16_t		wi_tx_ctl;	/* 0x0C */
 	u_int16_t		wi_frame_ctl;	/* 0x0E */
 	u_int16_t		wi_id;		/* 0x10 */
@@ -576,6 +587,7 @@ struct wi_frame {
 #define WI_802_3_OFFSET		0x2E
 #define WI_802_11_OFFSET	0x44
 #define WI_802_11_OFFSET_RAW	0x3C
+#define WI_802_11_OFFSET_HDR    0x0E
 
 #define WI_STAT_BADCRC		0x0001
 #define WI_STAT_UNDECRYPTABLE	0x0002
@@ -584,10 +596,12 @@ struct wi_frame {
 #define WI_STAT_1042		0x2000	/* RFC1042 encoded */
 #define WI_STAT_TUNNEL		0x4000	/* Bridge-tunnel encoded */
 #define WI_STAT_WMP_MSG		0x6000	/* WaveLAN-II management protocol */
+#define WI_STAT_MGMT		0x8000	/* 802.11b management frames */
 #define WI_RXSTAT_MSG_TYPE	0xE000
 
 #define WI_ENC_TX_802_3		0x00
 #define WI_ENC_TX_802_11	0x11
+#define WI_ENC_TX_MGMT		0x08
 #define WI_ENC_TX_E_II		0x0E
 
 #define WI_ENC_TX_1042		0x00
@@ -595,6 +609,9 @@ struct wi_frame {
 
 #define WI_TXCNTL_MACPORT	0x00FF
 #define WI_TXCNTL_STRUCTTYPE	0xFF00
+#define WI_TXCNTL_TX_EX		0x0004
+#define WI_TXCNTL_TX_OK		0x0002
+#define WI_TXCNTL_NOCRYPT	0x0080
 
 /*
  * SNAP (sub-network access protocol) constants for transmission
@@ -608,3 +625,4 @@ struct wi_frame {
 #define WI_SNAP_WORD0		(WI_SNAP_K1 | (WI_SNAP_K1 << 8))
 #define WI_SNAP_WORD1		(WI_SNAP_K2 | (WI_SNAP_CONTROL << 8))
 #define WI_SNAPHDR_LEN		0x6
+#define WI_FCS_LEN		0x4
diff --git a/sys/dev/wi/if_wivar.h b/sys/dev/wi/if_wivar.h
index d86f0b7..cc1eaf8 100644
--- a/sys/dev/wi/if_wivar.h
+++ b/sys/dev/wi/if_wivar.h
@@ -136,6 +136,7 @@ struct wi_softc	{
 	u_int16_t		wi_pm_enabled;
 	u_int16_t		wi_mor_enabled;
 	u_int16_t		wi_max_sleep;
+	u_int16_t		wi_supprates;
 	u_int16_t		wi_authtype;
 	u_int16_t		wi_roaming;
 
@@ -148,6 +149,7 @@ struct wi_softc	{
 	struct wi_counters	wi_stats;
 	int			wi_has_wep;
 	int			wi_use_wep;
+	int			wi_authmode;
 	int			wi_tx_key;
 	struct wi_ltv_keys	wi_keys;
 #ifdef WICACHE
@@ -155,6 +157,10 @@ struct wi_softc	{
 	struct wi_sigcache	wi_sigcache[MAXWICACHE];
 	int			wi_nextitem;
 #endif
+#ifdef WI_HOSTAP
+	struct wihap_info	wi_hostap_info;
+	u_int32_t		wi_icv;
+#endif
 	struct callout_handle	wi_stat_ch;
 	struct mtx		wi_mtx;
 	int			wi_nic_type;
@@ -193,3 +199,4 @@ void wi_shutdown(device_t);
 int wi_alloc(device_t, int);
 void wi_free(device_t);
 extern devclass_t wi_devclass;
+int wi_mgmt_xmit(struct wi_softc *, caddr_t, int);
diff --git a/sys/dev/wi/wi_hostap.c b/sys/dev/wi/wi_hostap.c
new file mode 100644
index 0000000..cbd73d0
--- /dev/null
+++ b/sys/dev/wi/wi_hostap.c
@@ -0,0 +1,1189 @@
+/*
+ * Copyright (c) 2002
+ *	Thomas Skibo <skibo@pacbell.net>.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Thomas Skibo.
+ * 4. Neither the name of the author nor the names of any co-contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY Thomas Skibo AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL Thomas Skibo OR HIS DRINKING PALS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/* This is experimental Host AP software for Prism 2 802.11b interfaces.
+ *
+ * Much of this is based upon the "Linux Host AP driver Host AP driver
+ * for Intersil Prism2" by Jouni Malinen <jkm@ssh.com> or <jkmaline@cc.hut.fi>.
+ */
+
+#ifdef WI_HOSTAP
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/sockio.h>
+#include <sys/mbuf.h>
+#include <sys/malloc.h>
+#include <sys/kernel.h>
+#include <sys/proc.h>
+#include <sys/ucred.h>
+#include <sys/socket.h>
+#include <sys/module.h>
+#include <sys/queue.h>
+#include <sys/bus.h>
+#include <sys/syslog.h>
+#include <sys/sysctl.h>
+
+#include <machine/bus.h>
+#include <machine/resource.h>
+#include <machine/clock.h>
+#include <machine/md_var.h>
+#include <machine/bus_pio.h>
+#include <sys/rman.h>
+
+#include <net/if.h>
+#include <net/if_arp.h>
+#include <net/ethernet.h>
+#include <net/if_dl.h>
+#include <net/if_media.h>
+#include <net/if_types.h>
+#include <net/if_ieee80211.h>
+
+#include <netinet/in.h>
+#include <netinet/in_systm.h>
+#include <netinet/in_var.h>
+#include <netinet/ip.h>
+#include <netinet/if_ether.h>
+
+#include <dev/wi/if_wavelan_ieee.h>
+#ifdef WI_HOSTAP
+#include <dev/wi/wi_hostap.h>
+#endif
+#include <dev/wi/if_wivar.h>
+#include <dev/wi/if_wireg.h>
+
+MALLOC_DEFINE(M_HAP_STA, "hostap_sta", "if_wi host AP mode station entry");
+
+/*
+ * take_hword()
+ *
+ *	Used for parsing management frames.  The pkt pointer and length
+ *	variables are updated after the value is removed.
+ */
+static __inline u_int16_t
+take_hword(caddr_t *ppkt, int *plen)
+{
+	u_int16_t s = le16toh(* (u_int16_t *) *ppkt);
+	*ppkt += sizeof(u_int16_t);
+	*plen -= sizeof(u_int16_t);
+	return s;
+}
+
+/*
+ * take_tlv()
+ *
+ *	Parse out TLV element from a packet, check for underflow of packet
+ *	or overflow of buffer, update pkt/len.
+ */
+static int
+take_tlv(caddr_t *ppkt, int *plen, int id_expect, void *dst, int maxlen)
+{
+	u_int8_t id, len;
+
+	if (*plen < 2)
+		return -1;
+
+	id = ((u_int8_t *)*ppkt)[0];
+	len = ((u_int8_t *)*ppkt)[1];
+
+	if (id != id_expect || *plen < len+2 || maxlen < len)
+		return -1;
+
+	bcopy(*ppkt+2, dst, len);
+	*plen -= 2+len;
+	*ppkt += 2+len;
+
+	return len;
+}
+
+/*
+ * put_hword()
+ *	Put half-word element into management frames.
+ */
+static __inline void
+put_hword(caddr_t *ppkt, u_int16_t s)
+{
+	* (u_int16_t *) *ppkt = htole16(s);
+	*ppkt += sizeof(u_int16_t);
+}
+
+/*
+ * put_tlv()
+ *	Put TLV elements into management frames.
+ */
+static void
+put_tlv(caddr_t *ppkt, u_int8_t id, void *src, u_int8_t len)
+{
+	(*ppkt)[0] = id;
+	(*ppkt)[1] = len;
+	bcopy(src, (*ppkt)+2, len);
+	*ppkt += 2+len;
+}
+
+static int
+put_rates(caddr_t *ppkt, u_int16_t rates)
+{
+	int len = 0;
+	u_int8_t ratebuf[8];
+
+	if (rates & WI_SUPPRATES_1M)
+		ratebuf[len++] = 0x82;
+	if (rates & WI_SUPPRATES_2M)
+		ratebuf[len++] = 0x84;
+	if (rates & WI_SUPPRATES_5M)
+		ratebuf[len++] = 0x8b;
+	if (rates & WI_SUPPRATES_11M)
+		ratebuf[len++] = 0x96;
+
+	put_tlv(ppkt, IEEE80211_ELEMID_RATES, ratebuf, len);
+	return len;
+}
+
+/*
+ * wihap_init()
+ *
+ *	Initialize host AP data structures.  Called even if port type is
+ *	not AP.
+ */
+void
+wihap_init(struct wi_softc *sc)
+{
+	int i;
+	struct wihap_info *whi = &sc->wi_hostap_info;
+
+	if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
+		printf("wihap_init: sc=0x%x whi=0x%x\n", (int)sc, (int)whi);
+
+	bzero(whi, sizeof(struct wihap_info));
+
+	if (sc->wi_ptype != WI_PORTTYPE_AP)
+		return;
+
+	whi->apflags = WIHAPFL_ACTIVE;
+
+	LIST_INIT(&whi->sta_list);
+	for (i=0; i<WI_STA_HASH_SIZE; i++)
+		LIST_INIT(&whi->sta_hash[i]);
+
+	whi->inactivity_time = WIHAP_DFLT_INACTIVITY_TIME;
+	whi->hostap_ch = timeout(wihap_timer, sc, hz * WIHAP_INTERVAL);
+}
+
+/*
+ * wihap_sta_disassoc()
+ *
+ *	Send a disassociation frame to a specified station.
+ */
+static void
+wihap_sta_disassoc(struct wi_softc *sc, u_int8_t sta_addr[],
+		   u_int16_t reason)
+{
+	struct wi_80211_hdr 	*resp_hdr;
+	caddr_t			pkt;
+
+	if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
+		printf("Sending disassoc to sta %6D\n", sta_addr, ":");
+
+	/* Send disassoc packet. */
+	resp_hdr = (struct wi_80211_hdr *) sc->wi_txbuf;
+	bzero(resp_hdr, sizeof(struct wi_80211_hdr));
+	resp_hdr->frame_ctl = WI_FTYPE_MGMT | WI_STYPE_MGMT_DISAS;
+	pkt = sc->wi_txbuf + sizeof(struct wi_80211_hdr);
+
+	bcopy(sta_addr, resp_hdr->addr1, ETHER_ADDR_LEN);
+	bcopy(sc->arpcom.ac_enaddr, resp_hdr->addr2, ETHER_ADDR_LEN);
+	bcopy(sc->arpcom.ac_enaddr, resp_hdr->addr3, ETHER_ADDR_LEN);
+
+	put_hword(&pkt, reason);
+
+	wi_mgmt_xmit(sc, sc->wi_txbuf, 2+sizeof(struct wi_80211_hdr));
+}
+
+/*
+ * wihap_sta_deauth()
+ *
+ *	Send a deauthentication message to a specified station.
+ */
+static void
+wihap_sta_deauth(struct wi_softc *sc, u_int8_t sta_addr[],
+		 u_int16_t reason)
+{
+	struct wi_80211_hdr 	*resp_hdr;
+	caddr_t			pkt;
+
+	if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
+		printf("Sending deauth to sta %6D\n", sta_addr, ":");
+
+	/* Send deauth packet. */
+	resp_hdr = (struct wi_80211_hdr *) sc->wi_txbuf;
+	bzero(resp_hdr, sizeof(struct wi_80211_hdr));
+	resp_hdr->frame_ctl = htole16(WI_FTYPE_MGMT | WI_STYPE_MGMT_DEAUTH);
+	pkt = sc->wi_txbuf + sizeof(struct wi_80211_hdr);
+
+	bcopy(sta_addr, resp_hdr->addr1, ETHER_ADDR_LEN);
+	bcopy(sc->arpcom.ac_enaddr, resp_hdr->addr2, ETHER_ADDR_LEN);
+	bcopy(sc->arpcom.ac_enaddr, resp_hdr->addr3, ETHER_ADDR_LEN);
+
+	put_hword(&pkt, reason);
+
+	wi_mgmt_xmit(sc, sc->wi_txbuf, 2+sizeof(struct wi_80211_hdr));
+}
+
+/*
+ * wihap_shutdown()
+ *
+ *	Disassociate all stations and free up data structures.
+ */
+void
+wihap_shutdown(struct wi_softc *sc)
+{
+	struct wihap_info 	*whi = &sc->wi_hostap_info;
+	struct wihap_sta_info 	*sta, *next;
+
+	if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
+		printf("wihap_shutdown: sc=0x%x whi=0x%x\n",
+		       (int)sc, (int)whi);
+
+	if (!(whi->apflags & WIHAPFL_ACTIVE))
+		return;
+
+	/* 
+	 * XXX: I read somewhere you can deauth all the stations with
+	 * a single broadcast.  Maybe try that someday.
+	 */
+
+	sta = LIST_FIRST(&whi->sta_list);
+	while (sta) {
+
+		if (!sc->wi_gone) {
+			/* Disassociate station. */
+			if (sta->flags & WI_SIFLAGS_ASSOC)
+				wihap_sta_disassoc(sc, sta->addr,
+				    IEEE80211_REASON_ASSOC_LEAVE);
+			/* Deauth station. */
+			if (sta->flags & WI_SIFLAGS_AUTHEN)
+				wihap_sta_deauth(sc, sta->addr,
+				    IEEE80211_REASON_AUTH_LEAVE);
+		}
+
+		/* Delete the structure. */
+		if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
+			printf("wihap_shutdown: FREE(sta=0x%x)\n", (int) sta);
+		next = LIST_NEXT(sta, list);
+		FREE(sta, M_HAP_STA);
+		sta = next;
+	}
+
+	untimeout(wihap_timer, sc, whi->hostap_ch);
+
+	whi->apflags = 0;
+}
+
+/*
+ * sta_hash_func()
+ * Hash function for finding stations from ethernet address.
+ */
+static __inline int
+sta_hash_func(u_int8_t addr[])
+{
+	return ((addr[3] + addr[4] + addr[5]) % WI_STA_HASH_SIZE);
+}
+
+/*
+ * addr_cmp():  
+ * Maybe this is a faster way to compare addresses? 
+ */
+static __inline int
+addr_cmp(u_int8_t a[], u_int8_t b[])
+{
+	return (*(u_int16_t *)(a+4) == *(u_int16_t *)(b+4) &&
+		*(u_int32_t *)a     == *(u_int32_t *)b);
+}
+
+/*
+ * wihap_sta_delete()
+ * Delete a single station and free up its data structure.
+ */
+static void
+wihap_sta_delete(struct wihap_info *whi, struct wihap_sta_info *sta)
+{
+	int i = sta->asid - 0xc001;
+	whi->asid_inuse_mask[i>>4] &= ~(1ul<<(i&0xf));
+
+	LIST_REMOVE(sta, list);
+	LIST_REMOVE(sta, hash);
+	FREE(sta, M_HAP_STA);
+	whi->n_stations--;
+}
+
+/*
+ * wihap_sta_alloc()
+ *
+ *	Create a new station data structure and put it in the list
+ *	and hash table.
+ */
+static struct wihap_sta_info *
+wihap_sta_alloc(struct wihap_info *whi, u_int8_t *addr)
+{
+	int i;
+	int hash = sta_hash_func(addr);
+	struct wihap_sta_info *sta;
+
+	/* Allocate structure. */
+	MALLOC(sta, struct wihap_sta_info *, sizeof(struct wihap_sta_info),
+	       M_HAP_STA, M_NOWAIT);
+	if (sta == NULL)
+		return(NULL);
+
+	bzero(sta, sizeof(struct wihap_sta_info));
+
+	/* Allocate an ASID. */
+	i=hash<<4;
+	while (whi->asid_inuse_mask[i>>4] & (1ul<<(i&0xf)))
+		i = (i==(WI_STA_HASH_SIZE<<4)-1) ? 0 : (i+1);
+	whi->asid_inuse_mask[i>>4] |= (1ul<<(i&0xf));
+	sta->asid = 0xc001+i;
+
+	/* Insert in list and hash list. */
+	LIST_INSERT_HEAD(&whi->sta_list, sta, list);
+	LIST_INSERT_HEAD(&whi->sta_hash[hash], sta, hash);
+
+	whi->n_stations++;
+	bcopy(addr, &sta->addr, ETHER_ADDR_LEN);
+	sta->inactivity_timer = whi->inactivity_time;
+
+	return(sta);
+}
+
+/*
+ * wihap_sta_find()
+ *
+ *	Find station structure given address.
+ */
+static struct wihap_sta_info *
+wihap_sta_find(struct wihap_info *whi, u_int8_t *addr)
+{
+	int i;
+	struct wihap_sta_info *sta;
+
+	i = sta_hash_func(addr);
+	LIST_FOREACH(sta, &whi->sta_hash[i], hash)
+		if (addr_cmp(addr,sta->addr))
+			return sta;
+
+	return(NULL);
+}
+
+/*
+ * wihap_timer()
+ *
+ *	Called every WIHAP_INTERVAL seconds.  Look for inactive
+ *	stations and disassociate them.
+ */
+void
+wihap_timer(void *xsc)
+{
+	int	s;
+	struct wihap_sta_info 	*sta, *next;
+	struct wi_softc 	*sc = (struct wi_softc *) xsc;
+	struct wihap_info	*whi = &sc->wi_hostap_info;
+
+	s = splimp();
+
+	sta = LIST_FIRST(&whi->sta_list);
+	while (sta) {
+
+		/* Grab next station now just in case we delete it. */
+		next = LIST_NEXT(sta, list);
+
+		if (sta->inactivity_timer >= 0) {
+			if (--sta->inactivity_timer == 0) {
+
+				if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
+					printf("wihap_timer: disassoc due to "
+					       "inactivity: %6D\n",
+					       sta->addr, ":");
+
+				if (sta->flags & WI_SIFLAGS_ASSOC) {
+					/* Disassoc station. */
+					wihap_sta_disassoc(sc, sta->addr,
+					   IEEE80211_REASON_ASSOC_EXPIRE);
+
+					sta->flags &= ~WI_SIFLAGS_ASSOC;
+				}
+			}
+			else if (sta->inactivity_timer == -1) {
+
+				if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
+					printf("wihap_timer: deauth due to "
+					       "inactivity: %6D\n",
+					       sta->addr, ":");
+
+				if (sta->flags & WI_SIFLAGS_AUTHEN) {
+					/* Deauthenticate station. */
+					wihap_sta_deauth(sc, sta->addr,
+						 IEEE80211_REASON_AUTH_EXPIRE);
+
+					sta->flags &= ~WI_SIFLAGS_AUTHEN;
+				}
+
+				/* Delete the station if it's not permanent. */
+				if (!(sta->flags & WI_SIFLAGS_PERM))
+					wihap_sta_delete(whi, sta);
+			}
+		}
+
+		sta = next;
+	}
+
+	splx(s);
+				
+	whi->hostap_ch = timeout(wihap_timer, sc, hz * WIHAP_INTERVAL);
+}
+
+static int
+wihap_check_rates(struct wi_softc *sc, struct wihap_sta_info *sta,
+		  u_int8_t rates[], int rates_len)
+{
+	int	i;
+
+	sta->rates = 0;
+	sta->tx_max_rate = 0;
+	for (i=0; i<rates_len; i++)
+		switch (rates[i] & 0x7f) {
+		case 0x02:
+			sta->rates |= WI_SUPPRATES_1M;
+			break;
+		case 0x04:
+			sta->rates |= WI_SUPPRATES_2M;
+			if (sta->tx_max_rate<1)
+				sta->tx_max_rate = 1;
+			break;
+		case 0x0b:
+			sta->rates |= WI_SUPPRATES_5M;
+			if (sta->tx_max_rate<2)
+				sta->tx_max_rate = 2;
+			break;
+		case 0x16:
+			sta->rates |= WI_SUPPRATES_11M;
+			sta->tx_max_rate = 3;
+			break;
+		}
+
+	sta->rates &= sc->wi_supprates;
+	sta->tx_curr_rate = sta->tx_max_rate;
+
+	return (sta->rates == 0 ? -1 : 0);
+}
+
+
+/*
+ * wihap_auth_req()
+ *
+ *	Handle incoming authentication request.  Only handle OPEN
+ *	requests.
+ */
+static void
+wihap_auth_req(struct wi_softc *sc, struct wi_frame *rxfrm,
+	       caddr_t pkt, int len)
+{
+	struct wihap_info	*whi = &sc->wi_hostap_info;
+	struct wihap_sta_info	*sta;
+
+	u_int16_t		algo;
+	u_int16_t		seq;
+	u_int16_t		status;
+	int			challenge_len;
+	u_int8_t		challenge[128];
+
+	struct wi_80211_hdr 	*resp_hdr;
+
+	if (len<6)
+		return;
+
+	/* Break open packet. */
+	algo = take_hword(&pkt, &len);
+	seq = take_hword(&pkt, &len);
+	status = take_hword(&pkt, &len);
+	challenge_len=0;
+	if (len>0 && (challenge_len=take_tlv(&pkt, &len,
+					     IEEE80211_ELEMID_CHALLENGE,
+					     challenge, sizeof(challenge)))<0)
+		return;
+
+	if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
+		printf("wihap_auth_req: from station: %6D\n",
+		       rxfrm->wi_addr2, ":");
+
+	switch (algo) {
+	case IEEE80211_AUTH_ALG_OPEN:
+		if (seq != 1) {
+			status = IEEE80211_STATUS_SEQUENCE;
+			goto fail;
+		}
+		challenge_len=0;
+		break;
+	case IEEE80211_AUTH_ALG_SHARED:
+		/* NOT YET */
+	default:
+		if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
+			printf("wihap_auth_req: algorithm unsupported: %d\n",
+			       algo);
+		status = IEEE80211_STATUS_ALG;
+		goto fail;
+	}
+
+	sta = wihap_sta_find(whi, rxfrm->wi_addr2);
+	if (sta == NULL) {
+
+		/* Are we allowing new stations?
+		 */
+		if (whi->apflags & WIHAPFL_MAC_FILT) {
+			status = IEEE80211_STATUS_OTHER; /* XXX */
+			goto fail;
+		}
+
+		/* Check for too many stations.
+		 */
+		if (whi->n_stations >= WIHAP_MAX_STATIONS) {
+			status = IEEE80211_STATUS_TOO_MANY_STATIONS;
+			goto fail;
+		}
+
+		if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
+			printf("wihap_auth_req: new station\n");
+
+		/* Create new station. */
+		sta = wihap_sta_alloc(whi, rxfrm->wi_addr2);
+		if (sta == NULL) {
+			/* Out of memory! */
+			status = IEEE80211_STATUS_TOO_MANY_STATIONS;
+			goto fail;
+		}
+	}
+
+	sta->flags |= WI_SIFLAGS_AUTHEN;
+	sta->inactivity_timer = whi->inactivity_time;
+	status = IEEE80211_STATUS_SUCCESS;
+
+fail:
+	if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
+		printf("wihap_auth_req: returns status=0x%x\n", status);
+
+	/* Send response. */
+	resp_hdr = (struct wi_80211_hdr *) sc->wi_txbuf;
+	bzero(resp_hdr, sizeof(struct wi_80211_hdr));
+	resp_hdr->frame_ctl = WI_FTYPE_MGMT | WI_STYPE_MGMT_AUTH;
+	pkt = sc->wi_txbuf + sizeof(struct wi_80211_hdr);
+
+	bcopy(rxfrm->wi_addr2, resp_hdr->addr1, ETHER_ADDR_LEN);
+	bcopy(sc->arpcom.ac_enaddr, resp_hdr->addr2, ETHER_ADDR_LEN);
+	bcopy(sc->arpcom.ac_enaddr, resp_hdr->addr3, ETHER_ADDR_LEN);
+
+	put_hword(&pkt, algo);
+	put_hword(&pkt, 2);
+	put_hword(&pkt, status);
+	if (challenge_len>0)
+		put_tlv(&pkt, IEEE80211_ELEMID_CHALLENGE,
+			challenge, challenge_len);
+
+	wi_mgmt_xmit(sc, sc->wi_txbuf,
+		     6 + sizeof(struct wi_80211_hdr) +
+		     (challenge_len>0 ? challenge_len+2 : 0) );
+}
+
+
+/*
+ * wihap_assoc_req()
+ *
+ *	Handle incoming association and reassociation requests.
+ */
+static void
+wihap_assoc_req(struct wi_softc *sc, struct wi_frame *rxfrm,
+		caddr_t pkt, int len)
+{
+	struct wihap_info	*whi = &sc->wi_hostap_info;
+	struct wihap_sta_info	*sta;
+
+	struct wi_80211_hdr 	*resp_hdr;
+
+	u_int16_t		capinfo;
+	u_int16_t		lstintvl;
+	u_int8_t		rates[8];
+	int 			rates_len;
+	int 			ssid_len;
+	char			ssid[33];
+
+
+	u_int16_t		status;
+	u_int16_t		asid = 0;
+
+	if (len<8)
+		return;
+
+	/* Pull out request parameters. */
+	capinfo = take_hword(&pkt, &len);
+	lstintvl = take_hword(&pkt, &len);
+	if ((ssid_len=take_tlv(&pkt, &len, IEEE80211_ELEMID_SSID,
+			       ssid, sizeof(ssid)-1))<0)
+		return;
+	ssid[ssid_len] = '\0';
+	if ((rates_len=take_tlv(&pkt, &len, IEEE80211_ELEMID_RATES,
+				rates, sizeof(rates)))<0)
+		return;
+	if ((rxfrm->wi_frame_ctl & WI_FCTL_STYPE) == WI_STYPE_MGMT_REASREQ) {
+		/* Reassociation Request--
+		 * Current AP.  (Ignore?)
+		 */
+		if (len<6)
+			return;
+	}
+
+	if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
+		printf("wihap_assoc_req: from station %6D\n",
+		       rxfrm->wi_addr2, ":");
+
+	/* If SSID doesn't match, simply drop. */
+	if (strcmp(sc->wi_net_name, ssid) != 0) {
+		if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
+			printf("wihap_assoc_req: bad ssid: '%s'\n", ssid);
+		return;
+	}
+
+	/* Is this station authenticated yet? */
+	sta = wihap_sta_find(whi, rxfrm->wi_addr2);
+	if (sta == NULL || !(sta->flags & WI_SIFLAGS_AUTHEN)) {
+		wihap_sta_deauth(sc, rxfrm->wi_addr2,
+				 IEEE80211_REASON_NOT_AUTHED);
+		return;
+	}
+
+	/* Check capinfo.
+	 * Check for ESS, not IBSS.
+	 * Check WEP/PRIVACY flags match.  XXX: WEP doesn't work for host AP.
+	 * Refuse stations requesting to be put on CF-polling list.
+	 */
+	if ((capinfo & (IEEE80211_CAPINFO_ESS|IEEE80211_CAPINFO_IBSS)) !=
+	    IEEE80211_CAPINFO_ESS ||
+	    (sc->wi_use_wep && !(capinfo & IEEE80211_CAPINFO_PRIVACY)) ||
+	    (!sc->wi_use_wep && (capinfo & IEEE80211_CAPINFO_PRIVACY)) ||
+	    (capinfo & (IEEE80211_CAPINFO_CF_POLLABLE|
+			IEEE80211_CAPINFO_CF_POLLREQ)) ==
+	    IEEE80211_CAPINFO_CF_POLLABLE) {
+
+		if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
+			printf("wihap_assoc_req: capinfo mismatch: "
+			       "capinfo=0x%x\n", capinfo);
+
+		status = IEEE80211_STATUS_CAPINFO;
+		goto fail;
+	}
+	sta->capinfo = capinfo;
+		
+
+	/* Check supported rates against ours. */
+	if (wihap_check_rates(sc, sta, rates, rates_len)<0) {
+		status = IEEE80211_STATUS_RATES;
+		goto fail;
+	}
+
+	/* Use ASID is allocated by whi_sta_alloc(). */
+	asid = sta->asid;
+
+	if (sta->flags & WI_SIFLAGS_ASSOC) {
+		if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
+			printf("wihap_assoc_req: already assoc'ed?\n");
+	}
+
+	sta->flags |= WI_SIFLAGS_ASSOC;
+	sta->inactivity_timer = whi->inactivity_time;
+	status = IEEE80211_STATUS_SUCCESS;
+
+fail:
+	if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
+		printf("wihap_assoc_req: returns status=0x%x\n", status);
+
+	/* Send response. */
+	resp_hdr = (struct wi_80211_hdr *) sc->wi_txbuf;
+	bzero(resp_hdr, sizeof(struct wi_80211_hdr));
+	resp_hdr->frame_ctl = WI_FTYPE_MGMT | WI_STYPE_MGMT_ASRESP;
+	pkt = sc->wi_txbuf + sizeof(struct wi_80211_hdr);
+
+	bcopy(rxfrm->wi_addr2, resp_hdr->addr1, ETHER_ADDR_LEN);
+	bcopy(sc->arpcom.ac_enaddr, resp_hdr->addr2, ETHER_ADDR_LEN);
+	bcopy(sc->arpcom.ac_enaddr, resp_hdr->addr3, ETHER_ADDR_LEN);
+
+	put_hword(&pkt, capinfo);
+	put_hword(&pkt, status);
+	put_hword(&pkt, asid);
+	rates_len=put_rates(&pkt, sc->wi_supprates);
+
+	wi_mgmt_xmit(sc, sc->wi_txbuf,
+		     8+rates_len+sizeof(struct wi_80211_hdr));
+}
+
+/*
+ * wihap_deauth_req()
+ *
+ *	Handle deauthentication requests.  Delete the station.
+ */
+static void
+wihap_deauth_req(struct wi_softc *sc, struct wi_frame *rxfrm,
+		 caddr_t pkt, int len)
+{
+	struct wihap_info	*whi = &sc->wi_hostap_info;
+	struct wihap_sta_info	*sta;
+	u_int16_t 		reason;
+
+	if (len<2)
+		return;
+
+	reason = take_hword(&pkt, &len);
+
+	sta = wihap_sta_find(whi, rxfrm->wi_addr2);
+	if (sta == NULL) {
+		if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
+			printf("wihap_deauth_req: unknown station: 6D\n",
+			       rxfrm->wi_addr2, ":");
+	}
+	else
+		wihap_sta_delete(whi, sta);
+}
+
+/*
+ * wihap_disassoc_req()
+ *
+ *	Handle disassociation requests.  Just reset the assoc flag.
+ *	We'll free up the station resources when we get a deauth
+ *	request or when it times out.
+ */
+static void
+wihap_disassoc_req(struct wi_softc *sc, struct wi_frame *rxfrm,
+		  caddr_t pkt, int len)
+{
+	struct wihap_info	*whi = &sc->wi_hostap_info;
+	struct wihap_sta_info	*sta;
+	u_int16_t 		reason;
+
+	if (len<2)
+		return;
+
+	reason = take_hword(&pkt, &len);
+
+	sta = wihap_sta_find(whi, rxfrm->wi_addr2);
+	if (sta == NULL) {
+		if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
+			printf("wihap_disassoc_req: unknown station: 6D\n",
+			       rxfrm->wi_addr2, ":");
+	}
+	else if (!(sta->flags & WI_SIFLAGS_AUTHEN)) {
+		/* If station is not authenticated, send deauthentication
+		 * frame.
+		 */
+		wihap_sta_deauth(sc, rxfrm->wi_addr2,
+				 IEEE80211_REASON_NOT_AUTHED);
+		return;
+	}
+	else
+		sta->flags &= ~WI_SIFLAGS_ASSOC;
+}
+
+/*
+ * wihap_debug_frame_type()
+ *
+ * Print out frame type.  Used in early debugging.
+ */
+static void
+wihap_debug_frame_type(struct wi_frame *rxfrm)
+{
+	printf("wihap_mgmt_input: len=%d ", rxfrm->wi_dat_len);
+
+	if ((le16toh(rxfrm->wi_frame_ctl) & WI_FCTL_FTYPE) == WI_FTYPE_MGMT) {
+
+		printf("MGMT: ");
+
+		switch (le16toh(rxfrm->wi_frame_ctl) & WI_FCTL_STYPE) {
+		case WI_STYPE_MGMT_ASREQ:
+			printf("assoc req: \n");
+			break;
+		case WI_STYPE_MGMT_ASRESP:
+			printf("assoc resp: \n");
+			break;
+		case WI_STYPE_MGMT_REASREQ:
+			printf("reassoc req: \n");
+			break;
+		case WI_STYPE_MGMT_REASRESP:
+			printf("reassoc resp: \n");
+			break;
+		case WI_STYPE_MGMT_PROBEREQ:
+			printf("probe req: \n");
+			break;
+		case WI_STYPE_MGMT_PROBERESP:
+			printf("probe resp: \n");
+			break;
+		case WI_STYPE_MGMT_BEACON:
+			printf("beacon: \n");
+			break;
+		case WI_STYPE_MGMT_ATIM:
+			printf("ann traf ind \n");
+			break;
+		case WI_STYPE_MGMT_DISAS:
+			printf("disassociation: \n");
+			break;
+		case WI_STYPE_MGMT_AUTH:
+			printf("auth: \n");
+			break;
+		case WI_STYPE_MGMT_DEAUTH:
+			printf("deauth: \n");
+			break;
+		default:
+			printf("unknown (stype=0x%x)\n",
+				le16toh(rxfrm->wi_frame_ctl) & WI_FCTL_STYPE);
+		}
+
+	}
+	else {
+		printf("ftype=0x%x (ctl=0x%x)\n",
+			le16toh(rxfrm->wi_frame_ctl) & WI_FCTL_FTYPE,
+			le16toh(rxfrm->wi_frame_ctl));
+	}
+}
+
+/*
+ * wihap_mgmt_input:
+ *
+ *	Called for each management frame received in host ap mode.
+ *	wihap_mgmt_input() is expected to free the mbuf.
+ */
+void
+wihap_mgmt_input(struct wi_softc *sc, struct wi_frame *rxfrm, struct mbuf *m)
+{
+	caddr_t		pkt;
+	int		len;
+
+	if (sc->arpcom.ac_if.if_flags & IFF_DEBUG)
+		wihap_debug_frame_type(rxfrm);
+
+	pkt = mtod(m, caddr_t) + WI_802_11_OFFSET_RAW;
+	len = m->m_len - WI_802_11_OFFSET_RAW;
+
+	if ((rxfrm->wi_frame_ctl & WI_FCTL_FTYPE) == WI_FTYPE_MGMT) {
+
+		switch (le16toh(rxfrm->wi_frame_ctl) & WI_FCTL_STYPE) {
+		case WI_STYPE_MGMT_ASREQ:
+			wihap_assoc_req(sc, rxfrm, pkt, len);
+			break;
+		case WI_STYPE_MGMT_ASRESP:
+			break;
+		case WI_STYPE_MGMT_REASREQ:
+			wihap_assoc_req(sc, rxfrm, pkt, len);
+			break;
+		case WI_STYPE_MGMT_REASRESP:
+			break;
+		case WI_STYPE_MGMT_PROBEREQ:
+			break;
+		case WI_STYPE_MGMT_PROBERESP:
+			break;
+		case WI_STYPE_MGMT_BEACON:
+			break;
+		case WI_STYPE_MGMT_ATIM:
+			break;
+		case WI_STYPE_MGMT_DISAS:
+			wihap_disassoc_req(sc, rxfrm, pkt, len);
+			break;
+		case WI_STYPE_MGMT_AUTH:
+			wihap_auth_req(sc, rxfrm, pkt, len);
+			break;
+		case WI_STYPE_MGMT_DEAUTH:
+			wihap_deauth_req(sc, rxfrm, pkt, len);
+			break;
+		}
+
+	}
+
+	m_freem(m);
+}
+
+/*
+ * wihap_sta_is_assoc()
+ *
+ *	Determine if a station is assoc'ed.  Update its activity
+ *	counter as a side-effect.
+ */
+static int
+wihap_sta_is_assoc(struct wihap_info *whi, u_int8_t addr[])
+{
+	struct wihap_sta_info *sta;
+
+	sta = wihap_sta_find(whi, addr);
+	if (sta!=NULL && (sta->flags & WI_SIFLAGS_ASSOC)) {
+		/* Keep it active. */
+		sta->inactivity_timer = whi->inactivity_time;
+		return(1);
+	}
+	else
+		return(0);
+}
+
+/*
+ * wihap_check_tx()
+ *
+ *	Determine if a station is assoc'ed, get its tx rate, and update
+ *	its activity.
+ */
+int
+wihap_check_tx(struct wihap_info *whi, u_int8_t addr[], u_int8_t *txrate)
+{
+	struct wihap_sta_info *sta;
+	static u_int8_t txratetable[] = { 10, 20, 55, 110 };
+
+	if (addr[0] & 0x01) {
+		*txrate = 0; /* XXX: multicast rate? */
+		return(1);
+	}
+	sta = wihap_sta_find(whi, addr);
+	if (sta!=NULL && (sta->flags & WI_SIFLAGS_ASSOC)) {
+		/* Keep it active. */
+		sta->inactivity_timer = whi->inactivity_time;
+		*txrate = txratetable[ sta->tx_curr_rate ];
+		return(1);
+	}
+	return(0);
+}
+
+/*
+ * wihap_data_input()
+ *
+ *	Handle all data input on interface when in Host AP mode.
+ *	Some packets are destined for this machine, others are
+ *	repeated to other stations.
+ *
+ *	If wihap_data_input() returns a non-zero, it has processed
+ *	the packet and will free the mbuf.
+ */
+int
+wihap_data_input(struct wi_softc *sc, struct wi_frame *rxfrm, struct mbuf *m)
+{
+	struct ifnet		*ifp = &sc->arpcom.ac_if;
+	struct wihap_info	*whi = &sc->wi_hostap_info;
+	struct wihap_sta_info 	*sta;
+	int			mcast;
+
+	/* TODS flag must be set. */
+	if (!(le16toh(rxfrm->wi_frame_ctl) & WI_FCTL_TODS)) {
+		if (ifp->if_flags & IFF_DEBUG)
+			printf("wihap_data_input: no TODS src=%6D\n",
+				rxfrm->wi_addr2, ":");
+		return(1);
+	}
+
+	/* Check BSSID. (Is this necessary?) */
+	if (!addr_cmp(rxfrm->wi_addr1, sc->arpcom.ac_enaddr)) {
+		if (ifp->if_flags & IFF_DEBUG)
+			printf("wihap_data_input: incorrect bss: %6D\n",
+				rxfrm->wi_addr1, ":");
+		return(1);
+	}
+
+	/* Find source station. */
+	sta = wihap_sta_find(whi, rxfrm->wi_addr2);
+
+	/* Source station must be associated. */
+	if (sta == NULL || !(sta->flags & WI_SIFLAGS_ASSOC)) {
+		if (ifp->if_flags & IFF_DEBUG)
+			printf("wihap_data_input: dropping unassoc src %6D\n",
+				rxfrm->wi_addr2, ":");
+		return(1);
+	}
+
+	sta->inactivity_timer = whi->inactivity_time;
+	sta->sig_info = rxfrm->wi_q_info;
+
+	/* Repeat this packet to BSS? */
+	mcast = (rxfrm->wi_addr3[0] & 0x01) != 0;
+	if (mcast || wihap_sta_is_assoc(whi, rxfrm->wi_addr3)) {
+
+		/* If it's multicast, make a copy.
+		 */
+		if (mcast) {
+			m = m_copym(m, 0, M_COPYALL, M_DONTWAIT);
+			if (m == NULL)
+				return(0);
+			m->m_flags |= M_MCAST; /* XXX */
+		}
+
+		/* Queue up for repeating.
+		 */
+		IF_HANDOFF(&ifp->if_snd, m, ifp);
+		return (!mcast);
+	}
+
+	return (0);
+}
+
+/*
+ * wihap_ioctl()
+ *
+ *	Handle Host AP specific ioctls.  Called from wi_ioctl().
+ */
+int
+wihap_ioctl(struct wi_softc *sc, u_long command, caddr_t data)
+{
+	int 			error = 0;
+	struct ifreq		*ifr = (struct ifreq *) data;
+	struct wihap_info 	*whi = &sc->wi_hostap_info;
+	struct wihap_sta_info 	*sta;
+	struct hostap_getall 	reqall;
+	struct hostap_sta 	reqsta;
+	struct hostap_sta 	stabuf;
+	int			n;
+	int			flag;
+
+	if (!(sc->arpcom.ac_if.if_flags & IFF_RUNNING))
+		return ENODEV;
+
+	switch (command) {
+	case SIOCHOSTAP_DEL:
+		if ((error = suser(curthread)))
+			break;
+		if ((error = copyin(ifr->ifr_data, &reqsta, sizeof(reqsta))))
+			break;
+		sta = wihap_sta_find(whi, reqsta.addr);
+		if (sta == NULL)
+			error = ENOENT;
+		else {
+			/* Disassociate station. */
+			if (sta->flags & WI_SIFLAGS_ASSOC)
+				wihap_sta_disassoc(sc, sta->addr,
+					   IEEE80211_REASON_ASSOC_LEAVE);
+			/* Deauth station. */
+			if (sta->flags & WI_SIFLAGS_AUTHEN)
+				wihap_sta_deauth(sc, sta->addr,
+					 IEEE80211_REASON_AUTH_LEAVE);
+
+			wihap_sta_delete(whi, sta);
+		}
+		break;
+
+	case SIOCHOSTAP_GET:
+		if ((error = copyin(ifr->ifr_data, &reqsta, sizeof(reqsta))))
+			break;
+		sta = wihap_sta_find(whi, reqsta.addr);
+		if (sta == NULL)
+			error = ENOENT;
+		else {
+			reqsta.flags = sta->flags;
+			reqsta.asid = sta->asid;
+			reqsta.capinfo = sta->capinfo;
+			reqsta.sig_info = sta->sig_info;
+			reqsta.rates = sta->rates;
+
+			error = copyout(&reqsta, ifr->ifr_data,
+					sizeof(reqsta));
+		}
+		break;
+
+	case SIOCHOSTAP_ADD:
+		if ((error = suser(curthread)))
+			break;
+		if ((error = copyin(ifr->ifr_data, &reqsta, sizeof(reqsta))))
+			break;
+		sta = wihap_sta_find(whi, reqsta.addr);
+		if (sta != NULL) {
+			error = EEXIST;
+			break;
+		}
+		if (whi->n_stations >= WIHAP_MAX_STATIONS) {
+			error = ENOSPC;
+			break;
+		}
+		sta = wihap_sta_alloc(whi, reqsta.addr);
+		sta->flags = reqsta.flags;
+		sta->inactivity_timer = whi->inactivity_time;
+		break;
+
+	case SIOCHOSTAP_SFLAGS:
+		if ((error = suser(curthread)))
+			break;
+		if ((error = copyin(ifr->ifr_data, &flag, sizeof(int))))
+			break;
+
+		whi->apflags =
+			(whi->apflags & WIHAPFL_CANTCHANGE) |
+			(flag & ~WIHAPFL_CANTCHANGE);
+		break;
+
+	case SIOCHOSTAP_GFLAGS:
+		flag = (int) whi->apflags;
+		error = copyout(&flag, ifr->ifr_data, sizeof(int));
+		break;
+
+	case SIOCHOSTAP_GETALL:
+		if ((error = copyin(ifr->ifr_data, &reqall, sizeof(reqall))))
+			break;
+
+		reqall.nstations = whi->n_stations;
+		n = 0;
+		sta = LIST_FIRST(&whi->sta_list);
+		while (sta && reqall.size >= n+sizeof(struct hostap_sta)) {
+
+			bcopy(sta->addr, stabuf.addr, ETHER_ADDR_LEN);
+			stabuf.asid = sta->asid;
+			stabuf.flags = sta->flags;
+			stabuf.capinfo = sta->capinfo;
+			stabuf.sig_info = sta->sig_info;
+			stabuf.rates = sta->rates;
+
+			error = copyout(&stabuf, (caddr_t) reqall.addr + n,
+					sizeof(struct hostap_sta));
+			if (error)
+				break;
+
+			sta = LIST_NEXT(sta, list);
+			n += sizeof(struct hostap_sta);
+		}
+
+		if (!error)
+			error = copyout(&reqall, ifr->ifr_data,
+					sizeof(reqall));
+		break;
+	default:
+		printf("wihap_ioctl: i shouldn't get other ioctls!\n");
+		error = EINVAL;
+	}
+
+	return(error);
+}
+
+#endif /* WI_HOSTAP */
diff --git a/sys/dev/wi/wi_hostap.h b/sys/dev/wi/wi_hostap.h
new file mode 100644
index 0000000..493b5ad
--- /dev/null
+++ b/sys/dev/wi/wi_hostap.h
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2002
+ *	Thomas Skibo <skibo@pacbell.net>.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Thomas Skibo.
+ * 4. Neither the name of the author nor the names of any co-contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY Thomas Skibo AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL Thomas Skibo OR HIS DRINKING PALS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+#ifndef __WI_HOSTAP_H__
+#define __WI_HOSTAP_H__
+
+#define WIHAP_MAX_STATIONS	1800
+
+struct hostap_sta {
+	u_int8_t	addr[6];
+	u_int16_t	asid;
+	u_int16_t	flags;
+	u_int16_t	sig_info;	/* 15:8 signal, 7:0 noise */
+	u_int16_t	capinfo;
+	u_int8_t	rates;
+};
+
+#define HOSTAP_FLAGS_AUTHEN	0x0001
+#define HOSTAP_FLAGS_ASSOC	0x0002
+#define HOSTAP_FLAGS_PERM	0x0004
+
+#define SIOCHOSTAP_GET 		_IOWR('i', 210, struct ifreq)
+#define SIOCHOSTAP_ADD 		_IOWR('i', 211, struct ifreq)
+#define SIOCHOSTAP_DEL 		_IOWR('i', 212, struct ifreq)
+#define SIOCHOSTAP_GETALL 	_IOWR('i', 213, struct ifreq)
+#define SIOCHOSTAP_GFLAGS	_IOWR('i', 214, struct ifreq)
+#define SIOCHOSTAP_SFLAGS	_IOWR('i', 215, struct ifreq)
+
+/* Flags for SIOCHOSTAP_GFLAGS/SFLAGS */
+#define WIHAPFL_ACTIVE		0x0001
+#define WIHAPFL_MAC_FILT	0x0002
+
+/* Flags set inernally only: */
+#define WIHAPFL_CANTCHANGE	(WIHAPFL_ACTIVE)
+
+struct hostap_getall {
+	int 		nstations;
+	struct hostap_sta *addr;
+	int 		size;
+};
+
+
+
+#ifdef _KERNEL
+struct wihap_sta_info {
+	LIST_ENTRY(wihap_sta_info) list;
+	LIST_ENTRY(wihap_sta_info) hash;
+
+	u_int8_t	addr[6];
+	u_short		flags;
+	int		inactivity_timer;
+
+	u_int16_t	asid;
+	u_int16_t	capinfo;
+	u_int16_t	sig_info;	/* 15:8 signal, 7:0 noise */
+	u_int8_t	rates;
+	u_int8_t	tx_curr_rate;
+	u_int8_t	tx_max_rate;
+};
+
+#define WI_SIFLAGS_ASSOC	HOSTAP_FLAGS_ASSOC
+#define WI_SIFLAGS_AUTHEN	HOSTAP_FLAGS_AUTHEN
+#define WI_SIFLAGS_PERM		HOSTAP_FLAGS_PERM
+
+#define WI_STA_HASH_SIZE	113
+
+#if WI_STA_HASH_SIZE*16 >= 2007 /* will generate ASID's too large. */
+#error "WI_STA_HASH_SIZE too big"
+#endif
+#if WI_STA_HASH_SIZE*16 < WIHAP_MAX_STATIONS
+#error "WI_STA_HASH_SIZE too small"
+#endif
+
+struct wihap_info {
+	LIST_HEAD(sta_list, wihap_sta_info)	sta_list;
+	LIST_HEAD(sta_hash, wihap_sta_info)	sta_hash[WI_STA_HASH_SIZE];
+
+	u_int16_t		apflags;
+
+	int			n_stations;
+	u_int16_t		asid_inuse_mask[WI_STA_HASH_SIZE];
+
+	int			inactivity_time;
+	struct callout_handle	hostap_ch;
+};
+
+#define WIHAP_INTERVAL			5
+#define WIHAP_DFLT_INACTIVITY_TIME	(120/WIHAP_INTERVAL) /* 2 minutes */
+
+struct wi_softc;
+struct wi_frame;
+
+void wihap_timer		__P((void *));
+void wihap_mgmt_input		__P((struct wi_softc *, struct wi_frame *,
+				     struct mbuf *));
+int  wihap_data_input		__P((struct wi_softc *, struct wi_frame *,
+				     struct mbuf *));
+int  wihap_check_tx		__P((struct wihap_info *, u_int8_t [],
+				     u_int8_t *));
+void wihap_init			__P((struct wi_softc *));
+void wihap_shutdown		__P((struct wi_softc *));
+int  wihap_ioctl		__P((struct wi_softc *, u_long, caddr_t));
+
+#endif /* _KERNEL */
+#endif /* __WI_HOSTAP_H__ */