diff -u wpasupplicant-0.4.8/debian/patches/00list wpasupplicant-0.4.8/debian/patches/00list --- wpasupplicant-0.4.8/debian/patches/00list +++ wpasupplicant-0.4.8/debian/patches/00list @@ -1,5 +1,6 @@ 01_config 10_madwifiold_20060207_includes +15_madwifing 20_comment_config 30_ctrl_iface_ap_scan 31_wpa_cli_ap_scan diff -u wpasupplicant-0.4.8/debian/changelog wpasupplicant-0.4.8/debian/changelog --- wpasupplicant-0.4.8/debian/changelog +++ wpasupplicant-0.4.8/debian/changelog @@ -1,3 +1,9 @@ +wpasupplicant (0.4.8-3ubuntu2) dapper; urgency=low + + * Added support for madwifi-ng (available with -Dmadwifi-ng) + + -- Soren Hansen Wed, 31 May 2006 10:22:11 +0200 + wpasupplicant (0.4.8-3ubuntu1) dapper; urgency=low [ Kel Modderman ] only in patch2: unchanged: --- wpasupplicant-0.4.8.orig/debian/patches/15_madwifing.dpatch +++ wpasupplicant-0.4.8/debian/patches/15_madwifing.dpatch @@ -0,0 +1,2678 @@ +#! /bin/sh /usr/share/dpatch/dpatch-run +## madwifing.patch by Soren Hansen +## +## All lines beginning with `## DP:' are a description of the patch. +## +## DP: Support for madwifi-ng + +@DPATCH@ +diff -urNw wpasupplicant-0.4.8.orig/.config wpasupplicant-0.4.8/.config +--- wpasupplicant-0.4.8.orig/.config 2006-05-31 11:40:30.977366297 +0200 ++++ wpasupplicant-0.4.8/.config 2006-05-31 11:41:11.328300849 +0200 +@@ -2,7 +2,9 @@ + CONFIG_DRIVER_HOSTAP=y + CONFIG_DRIVER_IPW=y + CONFIG_DRIVER_MADWIFI=y +-CFLAGS+=-I./driver_madwifi ++MADWIFI_CFLAGS+=-I./driver_madwifi ++CONFIG_DRIVER_MADWIFI_NG=y ++MADWIFI_NG_CFLAGS+=-I./driver_madwifi_ng + CONFIG_DRIVER_NDISWRAPPER=y + CONFIG_DRIVER_WEXT=y + CONFIG_DRIVER_WIRED=y +diff -urNw wpasupplicant-0.4.8.orig/driver_madwifi_ng/include/compat.h wpasupplicant-0.4.8/driver_madwifi_ng/include/compat.h +--- wpasupplicant-0.4.8.orig/driver_madwifi_ng/include/compat.h 1970-01-01 01:00:00.000000000 +0100 ++++ wpasupplicant-0.4.8/driver_madwifi_ng/include/compat.h 2006-05-31 11:44:38.479092639 +0200 +@@ -0,0 +1,87 @@ ++/*- ++ * Copyright (c) 2002-2005 Sam Leffler, Errno Consulting ++ * 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, ++ * without modification. ++ * 2. Redistributions in binary form must reproduce at minimum a disclaimer ++ * similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any ++ * redistribution must be conditioned upon including a substantially ++ * similar Disclaimer requirement for further binary redistribution. ++ * 3. Neither the names of the above-listed copyright holders nor the names ++ * of any contributors may be used to endorse or promote products derived ++ * from this software without specific prior written permission. ++ * ++ * Alternatively, this software may be distributed under the terms of the ++ * GNU General Public License ("GPL") version 2 as published by the Free ++ * Software Foundation. ++ * ++ * NO WARRANTY ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++ * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY ++ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ++ * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR 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 DAMAGES. ++ * ++ * $Id: compat.h 1426 2006-02-01 20:07:11Z mrenzmann $ ++ */ ++#ifndef _ATH_COMPAT_H_ ++#define _ATH_COMPAT_H_ ++/* ++ * BSD/Linux compatibility shims. These are used mainly to ++ * minimize differences when importing necesary BSD code. ++ */ ++#define NBBY 8 /* number of bits/byte */ ++ ++#define roundup(x, y) ((((x)+((y)-1))/(y))*(y)) /* to any y */ ++#define howmany(x, y) (((x)+((y)-1))/(y)) ++ ++/* Bit map related macros. */ ++#define setbit(a,i) ((a)[(i)/NBBY] |= 1<<((i)%NBBY)) ++#define clrbit(a,i) ((a)[(i)/NBBY] &= ~(1<<((i)%NBBY))) ++#define isset(a,i) ((a)[(i)/NBBY] & (1<<((i)%NBBY))) ++#define isclr(a,i) (((a)[(i)/NBBY] & (1<<((i)%NBBY))) == 0) ++ ++#define __packed __attribute__((__packed__)) ++#define __printflike(_a,_b) \ ++ __attribute__ ((__format__ (__printf__, _a, _b))) ++#define __offsetof(t,m) offsetof(t,m) ++ ++#ifndef ALIGNED_POINTER ++/* ++ * ALIGNED_POINTER is a boolean macro that checks whether an address ++ * is valid to fetch data elements of type t from on this architecture. ++ * This does not reflect the optimal alignment, just the possibility ++ * (within reasonable limits). ++ * ++ */ ++#define ALIGNED_POINTER(p,t) 1 ++#endif ++ ++#ifdef __KERNEL__ ++#include ++ ++#define KASSERT(exp, msg) do { \ ++ if (unlikely(!(exp))) { \ ++ printk msg; \ ++ BUG(); \ ++ } \ ++} while (0) ++#endif /* __KERNEL__ */ ++ ++/* ++ * NetBSD/FreeBSD defines for file version. ++ */ ++#define __FBSDID(_s) ++#define __KERNEL_RCSID(_n,_s) ++#endif /* _ATH_COMPAT_H_ */ +diff -urNw wpasupplicant-0.4.8.orig/driver_madwifi_ng/net80211/ieee80211_crypto.h wpasupplicant-0.4.8/driver_madwifi_ng/net80211/ieee80211_crypto.h +--- wpasupplicant-0.4.8.orig/driver_madwifi_ng/net80211/ieee80211_crypto.h 1970-01-01 01:00:00.000000000 +0100 ++++ wpasupplicant-0.4.8/driver_madwifi_ng/net80211/ieee80211_crypto.h 2006-05-31 11:44:56.588780000 +0200 +@@ -0,0 +1,205 @@ ++/*- ++ * Copyright (c) 2001 Atsushi Onoe ++ * Copyright (c) 2002-2005 Sam Leffler, Errno Consulting ++ * 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. The name of the author may not be used to endorse or promote products ++ * derived from this software without specific prior written permission. ++ * ++ * Alternatively, this software may be distributed under the terms of the ++ * GNU General Public License ("GPL") version 2 as published by the Free ++ * Software Foundation. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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. ++ * ++ * $Id: ieee80211_crypto.h 1441 2006-02-06 16:03:21Z mrenzmann $ ++ */ ++#ifndef _NET80211_IEEE80211_CRYPTO_H_ ++#define _NET80211_IEEE80211_CRYPTO_H_ ++ ++/* ++ * 802.11 protocol crypto-related definitions. ++ */ ++#define IEEE80211_KEYBUF_SIZE 16 ++#define IEEE80211_MICBUF_SIZE (8 + 8) /* space for both tx+rx keys */ ++#define IEEE80211_TID_SIZE 17 /* total number of TIDs */ ++ ++/* ++ * Old WEP-style key. Deprecated. ++ */ ++struct ieee80211_wepkey { ++ u_int wk_len; /* key length in bytes */ ++ u_int8_t wk_key[IEEE80211_KEYBUF_SIZE]; ++}; ++ ++struct ieee80211_cipher; ++ ++/* ++ * Crypto key state. There is sufficient room for all supported ++ * ciphers (see below). The underlying ciphers are handled ++ * separately through loadable cipher modules that register with ++ * the generic crypto support. A key has a reference to an instance ++ * of the cipher; any per-key state is hung off wk_private by the ++ * cipher when it is attached. Ciphers are automatically called ++ * to detach and cleanup any such state when the key is deleted. ++ * ++ * The generic crypto support handles encap/decap of cipher-related ++ * frame contents for both hardware- and software-based implementations. ++ * A key requiring software crypto support is automatically flagged and ++ * the cipher is expected to honor this and do the necessary work. ++ * Ciphers such as TKIP may also support mixed hardware/software ++ * encrypt/decrypt and MIC processing. ++ */ ++/* XXX need key index typedef */ ++/* XXX pack better? */ ++/* XXX 48-bit rsc/tsc */ ++struct ieee80211_key { ++ u_int8_t wk_keylen; /* key length in bytes */ ++ u_int8_t wk_flags; ++#define IEEE80211_KEY_XMIT 0x01 /* key used for xmit */ ++#define IEEE80211_KEY_RECV 0x02 /* key used for recv */ ++#define IEEE80211_KEY_GROUP 0x04 /* key used for WPA group operation */ ++#define IEEE80211_KEY_SWCRYPT 0x10 /* host-based encrypt/decrypt */ ++#define IEEE80211_KEY_SWMIC 0x20 /* host-based enmic/demic */ ++ u_int16_t wk_keyix; /* key index */ ++ u_int8_t wk_key[IEEE80211_KEYBUF_SIZE+IEEE80211_MICBUF_SIZE]; ++#define wk_txmic wk_key+IEEE80211_KEYBUF_SIZE+0 /* XXX can't () right */ ++#define wk_rxmic wk_key+IEEE80211_KEYBUF_SIZE+8 /* XXX can't () right */ ++ u_int64_t wk_keyrsc[IEEE80211_TID_SIZE]; /* key receive sequence counter */ ++ u_int64_t wk_keytsc; /* key transmit sequence counter */ ++ const struct ieee80211_cipher *wk_cipher; ++ void *wk_private; /* private cipher state */ ++}; ++#define IEEE80211_KEY_COMMON /* common flags passed in by apps */\ ++ (IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV | IEEE80211_KEY_GROUP) ++ ++/* ++ * NB: these values are ordered carefully; there are lots of ++ * of implications in any reordering. In particular beware ++ * that 4 is not used to avoid conflicting with IEEE80211_F_PRIVACY. ++ */ ++#define IEEE80211_CIPHER_WEP 0 ++#define IEEE80211_CIPHER_TKIP 1 ++#define IEEE80211_CIPHER_AES_OCB 2 ++#define IEEE80211_CIPHER_AES_CCM 3 ++#define IEEE80211_CIPHER_CKIP 5 ++#define IEEE80211_CIPHER_NONE 6 /* pseudo value */ ++ ++#define IEEE80211_CIPHER_MAX (IEEE80211_CIPHER_NONE+1) ++ ++#define IEEE80211_KEYIX_NONE ((u_int16_t) - 1) ++ ++#if defined(__KERNEL__) || defined(_KERNEL) ++ ++struct ieee80211com; ++struct ieee80211vap; ++struct ieee80211_node; ++struct sk_buff; ++ ++void ieee80211_crypto_attach(struct ieee80211com *); ++void ieee80211_crypto_detach(struct ieee80211com *); ++void ieee80211_crypto_vattach(struct ieee80211vap *); ++void ieee80211_crypto_vdetach(struct ieee80211vap *); ++int ieee80211_crypto_newkey(struct ieee80211vap *, int, int, ++ struct ieee80211_key *); ++int ieee80211_crypto_delkey(struct ieee80211vap *, struct ieee80211_key *, ++ struct ieee80211_node *); ++int ieee80211_crypto_setkey(struct ieee80211vap *, struct ieee80211_key *, ++ const u_int8_t macaddr[IEEE80211_ADDR_LEN], struct ieee80211_node *); ++void ieee80211_crypto_delglobalkeys(struct ieee80211vap *); ++ ++/* ++ * Template for a supported cipher. Ciphers register with the ++ * crypto code and are typically loaded as separate modules ++ * (the null cipher is always present). ++ * XXX may need refcnts ++ */ ++struct ieee80211_cipher { ++ const char *ic_name; /* printable name */ ++ u_int ic_cipher; /* IEEE80211_CIPHER_* */ ++ u_int ic_header; /* size of privacy header (bytes) */ ++ u_int ic_trailer; /* size of privacy trailer (bytes) */ ++ u_int ic_miclen; /* size of mic trailer (bytes) */ ++ void *(*ic_attach)(struct ieee80211vap *, struct ieee80211_key *); ++ void (*ic_detach)(struct ieee80211_key *); ++ int (*ic_setkey)(struct ieee80211_key *); ++ int (*ic_encap)(struct ieee80211_key *, struct sk_buff *, u_int8_t); ++ int (*ic_decap)(struct ieee80211_key *, struct sk_buff *, int); ++ int (*ic_enmic)(struct ieee80211_key *, struct sk_buff *, int); ++ int (*ic_demic)(struct ieee80211_key *, struct sk_buff *, int); ++}; ++extern const struct ieee80211_cipher ieee80211_cipher_none; ++ ++void ieee80211_crypto_register(const struct ieee80211_cipher *); ++void ieee80211_crypto_unregister(const struct ieee80211_cipher *); ++int ieee80211_crypto_available(u_int); ++ ++struct ieee80211_key *ieee80211_crypto_encap(struct ieee80211_node *, ++ struct sk_buff *); ++struct ieee80211_key *ieee80211_crypto_decap(struct ieee80211_node *, ++ struct sk_buff *, int); ++ ++/* ++ * Check and remove any MIC. ++ */ ++static __inline int ++ieee80211_crypto_demic(struct ieee80211vap *vap, struct ieee80211_key *k, ++ struct sk_buff *skb, int hdrlen) ++{ ++ const struct ieee80211_cipher *cip = k->wk_cipher; ++ return (cip->ic_miclen > 0 ? cip->ic_demic(k, skb, hdrlen) : 1); ++} ++ ++/* ++ * Add any MIC. ++ */ ++static __inline int ++ieee80211_crypto_enmic(struct ieee80211vap *vap, struct ieee80211_key *k, ++ struct sk_buff *skb, int force) ++{ ++ const struct ieee80211_cipher *cip = k->wk_cipher; ++ return (cip->ic_miclen > 0 ? cip->ic_enmic(k, skb, force) : 1); ++} ++ ++/* ++ * Reset key state to an unused state. The crypto ++ * key allocation mechanism ensures other state (e.g. ++ * key data) is properly setup before a key is used. ++ */ ++static __inline void ++ieee80211_crypto_resetkey(struct ieee80211vap *vap, struct ieee80211_key *k, ++ u_int16_t ix) ++{ ++ k->wk_cipher = &ieee80211_cipher_none;; ++ k->wk_private = k->wk_cipher->ic_attach(vap, k); ++ k->wk_keyix = ix; ++ k->wk_flags = IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV; ++} ++ ++/* ++ * Crypto-related notification methods. ++ */ ++void ieee80211_notify_replay_failure(struct ieee80211vap *, ++ const struct ieee80211_frame *, const struct ieee80211_key *, ++ u_int64_t rsc); ++void ieee80211_notify_michael_failure(struct ieee80211vap *, ++ const struct ieee80211_frame *, u_int keyix); ++#endif /* defined(__KERNEL__) || defined(_KERNEL) */ ++#endif /* _NET80211_IEEE80211_CRYPTO_H_ */ +diff -urNw wpasupplicant-0.4.8.orig/driver_madwifi_ng/net80211/_ieee80211.h wpasupplicant-0.4.8/driver_madwifi_ng/net80211/_ieee80211.h +--- wpasupplicant-0.4.8.orig/driver_madwifi_ng/net80211/_ieee80211.h 1970-01-01 01:00:00.000000000 +0100 ++++ wpasupplicant-0.4.8/driver_madwifi_ng/net80211/_ieee80211.h 2006-05-31 11:44:45.086789341 +0200 +@@ -0,0 +1,243 @@ ++/*- ++ * Copyright (c) 2001 Atsushi Onoe ++ * Copyright (c) 2002-2005 Sam Leffler, Errno Consulting ++ * 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. The name of the author may not be used to endorse or promote products ++ * derived from this software without specific prior written permission. ++ * ++ * Alternatively, this software may be distributed under the terms of the ++ * GNU General Public License ("GPL") version 2 as published by the Free ++ * Software Foundation. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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. ++ * ++ * $Id: _ieee80211.h 1441 2006-02-06 16:03:21Z mrenzmann $ ++ */ ++#ifndef _NET80211__IEEE80211_H_ ++#define _NET80211__IEEE80211_H_ ++ ++enum ieee80211_phytype { ++ IEEE80211_T_DS, /* direct sequence spread spectrum */ ++ IEEE80211_T_FH, /* frequency hopping */ ++ IEEE80211_T_OFDM, /* frequency division multiplexing */ ++ IEEE80211_T_TURBO, /* high rate OFDM, aka turbo mode */ ++}; ++#define IEEE80211_T_CCK IEEE80211_T_DS /* more common nomenclature */ ++ ++/* XXX not really a mode; there are really multiple PHY's */ ++enum ieee80211_phymode { ++ IEEE80211_MODE_AUTO = 0, /* autoselect */ ++ IEEE80211_MODE_11A = 1, /* 5GHz, OFDM */ ++ IEEE80211_MODE_11B = 2, /* 2GHz, CCK */ ++ IEEE80211_MODE_11G = 3, /* 2GHz, OFDM */ ++ IEEE80211_MODE_FH = 4, /* 2GHz, GFSK */ ++ IEEE80211_MODE_TURBO_A = 5, /* 5GHz, OFDM, 2x clock dynamic turbo */ ++ IEEE80211_MODE_TURBO_G = 6, /* 2GHz, OFDM, 2x clock dynamic turbo*/ ++}; ++#define IEEE80211_MODE_MAX (IEEE80211_MODE_TURBO_G+1) ++ ++enum ieee80211_opmode { ++ IEEE80211_M_STA = 1, /* infrastructure station */ ++ IEEE80211_M_IBSS = 0, /* IBSS (adhoc) station */ ++ IEEE80211_M_AHDEMO = 3, /* Old lucent compatible adhoc demo */ ++ IEEE80211_M_HOSTAP = 6, /* Software Access Point */ ++ IEEE80211_M_MONITOR = 8, /* Monitor mode */ ++ IEEE80211_M_WDS = 2 /* WDS link */ ++}; ++ ++/* ++ * 802.11g protection mode. ++ */ ++enum ieee80211_protmode { ++ IEEE80211_PROT_NONE = 0, /* no protection */ ++ IEEE80211_PROT_CTSONLY = 1, /* CTS to self */ ++ IEEE80211_PROT_RTSCTS = 2, /* RTS-CTS */ ++}; ++ ++/* ++ * Authentication mode. ++ */ ++enum ieee80211_authmode { ++ IEEE80211_AUTH_NONE = 0, ++ IEEE80211_AUTH_OPEN = 1, /* open */ ++ IEEE80211_AUTH_SHARED = 2, /* shared-key */ ++ IEEE80211_AUTH_8021X = 3, /* 802.1x */ ++ IEEE80211_AUTH_AUTO = 4, /* auto-select/accept */ ++ /* NB: these are used only for ioctls */ ++ IEEE80211_AUTH_WPA = 5, /* WPA/RSN w/ 802.1x/PSK */ ++}; ++ ++/* ++ * Roaming mode is effectively who controls the operation ++ * of the 802.11 state machine when operating as a station. ++ * State transitions are controlled either by the driver ++ * (typically when management frames are processed by the ++ * hardware/firmware), the host (auto/normal operation of ++ * the 802.11 layer), or explicitly through ioctl requests ++ * when applications like wpa_supplicant want control. ++ */ ++enum ieee80211_roamingmode { ++ IEEE80211_ROAMING_DEVICE= 0, /* driver/hardware control */ ++ IEEE80211_ROAMING_AUTO = 1, /* 802.11 layer control */ ++ IEEE80211_ROAMING_MANUAL= 2, /* application control */ ++}; ++ ++/* ++ * Scanning mode controls station scanning work; this is ++ * used only when roaming mode permits the host to select ++ * the bss to join/channel to use. ++ */ ++enum ieee80211_scanmode { ++ IEEE80211_SCAN_DEVICE = 0, /* driver/hardware control */ ++ IEEE80211_SCAN_BEST = 1, /* 802.11 layer selects best */ ++ IEEE80211_SCAN_FIRST = 2, /* take first suitable candidate */ ++}; ++ ++/* ++ * Channels are specified by frequency and attributes. ++ */ ++struct ieee80211_channel { ++ u_int16_t ic_freq; /* setting in Mhz */ ++ u_int16_t ic_flags; /* see below */ ++ u_int8_t ic_ieee; /* IEEE channel number */ ++ int8_t ic_maxregpower; /* maximum regulatory tx power in dBm */ ++ int8_t ic_maxpower; /* maximum tx power in dBm */ ++ int8_t ic_minpower; /* minimum tx power in dBm */ ++}; ++ ++#define IEEE80211_CHAN_MAX 255 ++#define IEEE80211_CHAN_BYTES 32 /* howmany(IEEE80211_CHAN_MAX, NBBY) */ ++#define IEEE80211_CHAN_ANY 0xffff /* token for ``any channel'' */ ++#define IEEE80211_CHAN_ANYC ((struct ieee80211_channel *) IEEE80211_CHAN_ANY) ++ ++#define IEEE80211_RADAR_11HCOUNT 1 ++#define IEEE80211_RADAR_TEST_MUTE_CHAN 36 /* Move to channel 36 for mute test */ ++ ++/* bits 0-3 are for private use by drivers */ ++/* channel attributes */ ++#define IEEE80211_CHAN_TURBO 0x0010 /* Turbo channel */ ++#define IEEE80211_CHAN_CCK 0x0020 /* CCK channel */ ++#define IEEE80211_CHAN_OFDM 0x0040 /* OFDM channel */ ++#define IEEE80211_CHAN_2GHZ 0x0080 /* 2 GHz spectrum channel. */ ++#define IEEE80211_CHAN_5GHZ 0x0100 /* 5 GHz spectrum channel */ ++#define IEEE80211_CHAN_PASSIVE 0x0200 /* Only passive scan allowed */ ++#define IEEE80211_CHAN_DYN 0x0400 /* Dynamic CCK-OFDM channel */ ++#define IEEE80211_CHAN_GFSK 0x0800 /* GFSK channel (FHSS PHY) */ ++#define IEEE80211_CHAN_RADAR 0x1000 /* Radar found on channel */ ++#define IEEE80211_CHAN_STURBO 0x2000 /* 11a static turbo channel only */ ++#define IEEE80211_CHAN_HALF 0x4000 /* Half rate channel */ ++#define IEEE80211_CHAN_QUARTER 0x8000 /* Quarter rate channel */ ++ ++/* ++ * Useful combinations of channel characteristics. ++ */ ++#define IEEE80211_CHAN_FHSS \ ++ (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_GFSK) ++#define IEEE80211_CHAN_A \ ++ (IEEE80211_CHAN_5GHZ | IEEE80211_CHAN_OFDM) ++#define IEEE80211_CHAN_B \ ++ (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_CCK) ++#define IEEE80211_CHAN_PUREG \ ++ (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_OFDM) ++#define IEEE80211_CHAN_G \ ++ (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_DYN) ++#define IEEE80211_CHAN_108A \ ++ (IEEE80211_CHAN_5GHZ | IEEE80211_CHAN_OFDM | IEEE80211_CHAN_TURBO) ++#define IEEE80211_CHAN_108G \ ++ (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_OFDM | IEEE80211_CHAN_TURBO) ++#define IEEE80211_CHAN_ST \ ++ (IEEE80211_CHAN_108A | IEEE80211_CHAN_STURBO) ++ ++#define IEEE80211_CHAN_ALL \ ++ (IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_5GHZ | IEEE80211_CHAN_GFSK | \ ++ IEEE80211_CHAN_CCK | IEEE80211_CHAN_OFDM | IEEE80211_CHAN_DYN) ++#define IEEE80211_CHAN_ALLTURBO \ ++ (IEEE80211_CHAN_ALL | IEEE80211_CHAN_TURBO | IEEE80211_CHAN_STURBO) ++ ++#define IEEE80211_IS_CHAN_FHSS(_c) \ ++ (((_c)->ic_flags & IEEE80211_CHAN_FHSS) == IEEE80211_CHAN_FHSS) ++#define IEEE80211_IS_CHAN_A(_c) \ ++ (((_c)->ic_flags & IEEE80211_CHAN_A) == IEEE80211_CHAN_A) ++#define IEEE80211_IS_CHAN_B(_c) \ ++ (((_c)->ic_flags & IEEE80211_CHAN_B) == IEEE80211_CHAN_B) ++#define IEEE80211_IS_CHAN_PUREG(_c) \ ++ (((_c)->ic_flags & IEEE80211_CHAN_PUREG) == IEEE80211_CHAN_PUREG) ++#define IEEE80211_IS_CHAN_G(_c) \ ++ (((_c)->ic_flags & IEEE80211_CHAN_G) == IEEE80211_CHAN_G) ++#define IEEE80211_IS_CHAN_ANYG(_c) \ ++ (IEEE80211_IS_CHAN_PUREG(_c) || IEEE80211_IS_CHAN_G(_c)) ++#define IEEE80211_IS_CHAN_ST(_c) \ ++ (((_c)->ic_flags & IEEE80211_CHAN_ST) == IEEE80211_CHAN_ST) ++#define IEEE80211_IS_CHAN_108A(_c) \ ++ (((_c)->ic_flags & IEEE80211_CHAN_108A) == IEEE80211_CHAN_108A) ++#define IEEE80211_IS_CHAN_108G(_c) \ ++ (((_c)->ic_flags & IEEE80211_CHAN_108G) == IEEE80211_CHAN_108G) ++ ++#define IEEE80211_IS_CHAN_2GHZ(_c) \ ++ (((_c)->ic_flags & IEEE80211_CHAN_2GHZ) != 0) ++#define IEEE80211_IS_CHAN_5GHZ(_c) \ ++ (((_c)->ic_flags & IEEE80211_CHAN_5GHZ) != 0) ++#define IEEE80211_IS_CHAN_OFDM(_c) \ ++ (((_c)->ic_flags & IEEE80211_CHAN_OFDM) != 0) ++#define IEEE80211_IS_CHAN_CCK(_c) \ ++ (((_c)->ic_flags & IEEE80211_CHAN_CCK) != 0) ++#define IEEE80211_IS_CHAN_GFSK(_c) \ ++ (((_c)->ic_flags & IEEE80211_CHAN_GFSK) != 0) ++#define IEEE80211_IS_CHAN_TURBO(_c) \ ++ (((_c)->ic_flags & IEEE80211_CHAN_TURBO) != 0) ++#define IEEE80211_IS_CHAN_STURBO(_c) \ ++ (((_c)->ic_flags & IEEE80211_CHAN_STURBO) != 0) ++#define IEEE80211_IS_CHAN_DTURBO(_c) \ ++ (((_c)->ic_flags & \ ++ (IEEE80211_CHAN_TURBO | IEEE80211_CHAN_STURBO)) == IEEE80211_CHAN_TURBO) ++#define IEEE80211_IS_CHAN_HALF(_c) \ ++ (((_c)->ic_flags & IEEE80211_CHAN_HALF) != 0) ++#define IEEE80211_IS_CHAN_QUARTER(_c) \ ++ (((_c)->ic_flags & IEEE80211_CHAN_QUARTER) != 0) ++ ++/* ni_chan encoding for FH phy */ ++#define IEEE80211_FH_CHANMOD 80 ++#define IEEE80211_FH_CHAN(set,pat) (((set) - 1) * IEEE80211_FH_CHANMOD + (pat)) ++#define IEEE80211_FH_CHANSET(chan) ((chan) / IEEE80211_FH_CHANMOD + 1) ++#define IEEE80211_FH_CHANPAT(chan) ((chan) % IEEE80211_FH_CHANMOD) ++ ++/* ++ * 802.11 rate set. ++ */ ++#define IEEE80211_RATE_SIZE 8 /* 802.11 standard */ ++#define IEEE80211_RATE_MAXSIZE 15 /* max rates we'll handle */ ++ ++struct ieee80211_rateset { ++ u_int8_t rs_nrates; ++ u_int8_t rs_rates[IEEE80211_RATE_MAXSIZE]; ++}; ++ ++struct ieee80211_roam { ++ int8_t rssi11a; /* rssi thresh for 11a bss */ ++ int8_t rssi11b; /* for 11g sta in 11b bss */ ++ int8_t rssi11bOnly; /* for 11b sta */ ++ u_int8_t pad1; ++ u_int8_t rate11a; /* rate thresh for 11a bss */ ++ u_int8_t rate11b; /* for 11g sta in 11b bss */ ++ u_int8_t rate11bOnly; /* for 11b sta */ ++ u_int8_t pad2; ++}; ++#endif /* _NET80211__IEEE80211_H_ */ +diff -urNw wpasupplicant-0.4.8.orig/driver_madwifi_ng/net80211/ieee80211.h wpasupplicant-0.4.8/driver_madwifi_ng/net80211/ieee80211.h +--- wpasupplicant-0.4.8.orig/driver_madwifi_ng/net80211/ieee80211.h 1970-01-01 01:00:00.000000000 +0100 ++++ wpasupplicant-0.4.8/driver_madwifi_ng/net80211/ieee80211.h 2006-05-31 11:44:52.295276621 +0200 +@@ -0,0 +1,909 @@ ++/*- ++ * Copyright (c) 2001 Atsushi Onoe ++ * Copyright (c) 2002-2005 Sam Leffler, Errno Consulting ++ * 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. The name of the author may not be used to endorse or promote products ++ * derived from this software without specific prior written permission. ++ * ++ * Alternatively, this software may be distributed under the terms of the ++ * GNU General Public License ("GPL") version 2 as published by the Free ++ * Software Foundation. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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. ++ * ++ * $Id: ieee80211.h 1488 2006-03-31 23:57:41Z kelmo $ ++ */ ++#ifndef _NET80211_IEEE80211_H_ ++#define _NET80211_IEEE80211_H_ ++ ++/* ++ * 802.11 protocol definitions. ++ */ ++ ++#define IEEE80211_ADDR_LEN 6 /* size of 802.11 address */ ++/* is 802.11 address multicast/broadcast? */ ++#define IEEE80211_IS_MULTICAST(_a) (*(_a) & 0x01) ++ ++/* IEEE 802.11 PLCP header */ ++struct ieee80211_plcp_hdr { ++ u_int16_t i_sfd; ++ u_int8_t i_signal; ++ u_int8_t i_service; ++ u_int16_t i_length; ++ u_int16_t i_crc; ++} __packed; ++ ++#define IEEE80211_PLCP_SFD 0xF3A0 ++#define IEEE80211_PLCP_SERVICE 0x00 ++ ++/* ++ * generic definitions for IEEE 802.11 frames ++ */ ++struct ieee80211_frame { ++ u_int8_t i_fc[2]; ++ u_int8_t i_dur[2]; ++ u_int8_t i_addr1[IEEE80211_ADDR_LEN]; ++ u_int8_t i_addr2[IEEE80211_ADDR_LEN]; ++ u_int8_t i_addr3[IEEE80211_ADDR_LEN]; ++ u_int8_t i_seq[2]; ++ /* possibly followed by addr4[IEEE80211_ADDR_LEN]; */ ++ /* see below */ ++} __packed; ++ ++struct ieee80211_qosframe { ++ u_int8_t i_fc[2]; ++ u_int8_t i_dur[2]; ++ u_int8_t i_addr1[IEEE80211_ADDR_LEN]; ++ u_int8_t i_addr2[IEEE80211_ADDR_LEN]; ++ u_int8_t i_addr3[IEEE80211_ADDR_LEN]; ++ u_int8_t i_seq[2]; ++ u_int8_t i_qos[2]; ++ /* possibly followed by addr4[IEEE80211_ADDR_LEN]; */ ++ /* see below */ ++} __packed; ++ ++struct ieee80211_qoscntl { ++ u_int8_t i_qos[2]; ++}; ++ ++struct ieee80211_frame_addr4 { ++ u_int8_t i_fc[2]; ++ u_int8_t i_dur[2]; ++ u_int8_t i_addr1[IEEE80211_ADDR_LEN]; ++ u_int8_t i_addr2[IEEE80211_ADDR_LEN]; ++ u_int8_t i_addr3[IEEE80211_ADDR_LEN]; ++ u_int8_t i_seq[2]; ++ u_int8_t i_addr4[IEEE80211_ADDR_LEN]; ++} __packed; ++ ++ ++struct ieee80211_qosframe_addr4 { ++ u_int8_t i_fc[2]; ++ u_int8_t i_dur[2]; ++ u_int8_t i_addr1[IEEE80211_ADDR_LEN]; ++ u_int8_t i_addr2[IEEE80211_ADDR_LEN]; ++ u_int8_t i_addr3[IEEE80211_ADDR_LEN]; ++ u_int8_t i_seq[2]; ++ u_int8_t i_addr4[IEEE80211_ADDR_LEN]; ++ u_int8_t i_qos[2]; ++} __packed; ++ ++struct ieee80211_ctlframe_addr2 { ++ u_int8_t i_fc[2]; ++ u_int8_t i_aidordur[2]; /* AID or duration */ ++ u_int8_t i_addr1[IEEE80211_ADDR_LEN]; ++ u_int8_t i_addr2[IEEE80211_ADDR_LEN]; ++} __packed; ++ ++#define IEEE80211_FC0_VERSION_MASK 0x03 ++#define IEEE80211_FC0_VERSION_SHIFT 0 ++#define IEEE80211_FC0_VERSION_0 0x00 ++#define IEEE80211_FC0_TYPE_MASK 0x0c ++#define IEEE80211_FC0_TYPE_SHIFT 2 ++#define IEEE80211_FC0_TYPE_MGT 0x00 ++#define IEEE80211_FC0_TYPE_CTL 0x04 ++#define IEEE80211_FC0_TYPE_DATA 0x08 ++ ++#define IEEE80211_FC0_SUBTYPE_MASK 0xf0 ++#define IEEE80211_FC0_SUBTYPE_SHIFT 4 ++/* for TYPE_MGT */ ++#define IEEE80211_FC0_SUBTYPE_ASSOC_REQ 0x00 ++#define IEEE80211_FC0_SUBTYPE_ASSOC_RESP 0x10 ++#define IEEE80211_FC0_SUBTYPE_REASSOC_REQ 0x20 ++#define IEEE80211_FC0_SUBTYPE_REASSOC_RESP 0x30 ++#define IEEE80211_FC0_SUBTYPE_PROBE_REQ 0x40 ++#define IEEE80211_FC0_SUBTYPE_PROBE_RESP 0x50 ++#define IEEE80211_FC0_SUBTYPE_BEACON 0x80 ++#define IEEE80211_FC0_SUBTYPE_ATIM 0x90 ++#define IEEE80211_FC0_SUBTYPE_DISASSOC 0xa0 ++#define IEEE80211_FC0_SUBTYPE_AUTH 0xb0 ++#define IEEE80211_FC0_SUBTYPE_DEAUTH 0xc0 ++#define IEEE80211_FC0_SUBTYPE_ACTION 0xd0 ++/* for TYPE_CTL */ ++#define IEEE80211_FC0_SUBTYPE_PS_POLL 0xa0 ++#define IEEE80211_FC0_SUBTYPE_RTS 0xb0 ++#define IEEE80211_FC0_SUBTYPE_CTS 0xc0 ++#define IEEE80211_FC0_SUBTYPE_ACK 0xd0 ++#define IEEE80211_FC0_SUBTYPE_CF_END 0xe0 ++#define IEEE80211_FC0_SUBTYPE_CF_END_ACK 0xf0 ++/* for TYPE_DATA (bit combination) */ ++#define IEEE80211_FC0_SUBTYPE_DATA 0x00 ++#define IEEE80211_FC0_SUBTYPE_CF_ACK 0x10 ++#define IEEE80211_FC0_SUBTYPE_CF_POLL 0x20 ++#define IEEE80211_FC0_SUBTYPE_CF_ACPL 0x30 ++#define IEEE80211_FC0_SUBTYPE_NODATA 0x40 ++#define IEEE80211_FC0_SUBTYPE_CFACK 0x50 ++#define IEEE80211_FC0_SUBTYPE_CFPOLL 0x60 ++#define IEEE80211_FC0_SUBTYPE_CF_ACK_CF_ACK 0x70 ++#define IEEE80211_FC0_SUBTYPE_QOS 0x80 ++#define IEEE80211_FC0_SUBTYPE_QOS_NULL 0xc0 ++ ++#define IEEE80211_FC1_DIR_MASK 0x03 ++#define IEEE80211_FC1_DIR_NODS 0x00 /* STA->STA */ ++#define IEEE80211_FC1_DIR_TODS 0x01 /* STA->AP */ ++#define IEEE80211_FC1_DIR_FROMDS 0x02 /* AP ->STA */ ++#define IEEE80211_FC1_DIR_DSTODS 0x03 /* AP ->AP */ ++ ++#define IEEE80211_FC1_MORE_FRAG 0x04 ++#define IEEE80211_FC1_RETRY 0x08 ++#define IEEE80211_FC1_PWR_MGT 0x10 ++#define IEEE80211_FC1_MORE_DATA 0x20 ++#define IEEE80211_FC1_WEP 0x40 ++#define IEEE80211_FC1_ORDER 0x80 ++ ++#define IEEE80211_SEQ_FRAG_MASK 0x000f ++#define IEEE80211_SEQ_FRAG_SHIFT 0 ++#define IEEE80211_SEQ_SEQ_MASK 0xfff0 ++#define IEEE80211_SEQ_SEQ_SHIFT 4 ++ ++#define IEEE80211_SEQ_LEQ(a,b) ((int)((a)-(b)) <= 0) ++ ++#define IEEE80211_NWID_LEN 32 ++ ++#define IEEE80211_QOS_TXOP 0x00ff ++/* bit 8 is reserved */ ++#define IEEE80211_QOS_ACKPOLICY 0x60 ++#define IEEE80211_QOS_ACKPOLICY_S 5 ++#define IEEE80211_QOS_EOSP 0x10 ++#define IEEE80211_QOS_EOSP_S 4 ++#define IEEE80211_QOS_TID 0x0f ++ ++/* ++ * Country/Region Codes from MS WINNLS.H ++ * Numbering from ISO 3166 ++ * XXX belongs elsewhere ++ */ ++enum CountryCode { ++ CTRY_ALBANIA = 8, /* Albania */ ++ CTRY_ALGERIA = 12, /* Algeria */ ++ CTRY_ARGENTINA = 32, /* Argentina */ ++ CTRY_ARMENIA = 51, /* Armenia */ ++ CTRY_AUSTRALIA = 36, /* Australia */ ++ CTRY_AUSTRIA = 40, /* Austria */ ++ CTRY_AZERBAIJAN = 31, /* Azerbaijan */ ++ CTRY_BAHRAIN = 48, /* Bahrain */ ++ CTRY_BELARUS = 112, /* Belarus */ ++ CTRY_BELGIUM = 56, /* Belgium */ ++ CTRY_BELIZE = 84, /* Belize */ ++ CTRY_BOLIVIA = 68, /* Bolivia */ ++ CTRY_BRAZIL = 76, /* Brazil */ ++ CTRY_BRUNEI_DARUSSALAM = 96, /* Brunei Darussalam */ ++ CTRY_BULGARIA = 100, /* Bulgaria */ ++ CTRY_CANADA = 124, /* Canada */ ++ CTRY_CHILE = 152, /* Chile */ ++ CTRY_CHINA = 156, /* People's Republic of China */ ++ CTRY_COLOMBIA = 170, /* Colombia */ ++ CTRY_COSTA_RICA = 188, /* Costa Rica */ ++ CTRY_CROATIA = 191, /* Croatia */ ++ CTRY_CYPRUS = 196, ++ CTRY_CZECH = 203, /* Czech Republic */ ++ CTRY_DENMARK = 208, /* Denmark */ ++ CTRY_DOMINICAN_REPUBLIC = 214, /* Dominican Republic */ ++ CTRY_ECUADOR = 218, /* Ecuador */ ++ CTRY_EGYPT = 818, /* Egypt */ ++ CTRY_EL_SALVADOR = 222, /* El Salvador */ ++ CTRY_ESTONIA = 233, /* Estonia */ ++ CTRY_FAEROE_ISLANDS = 234, /* Faeroe Islands */ ++ CTRY_FINLAND = 246, /* Finland */ ++ CTRY_FRANCE = 250, /* France */ ++ CTRY_FRANCE2 = 255, /* France2 */ ++ CTRY_GEORGIA = 268, /* Georgia */ ++ CTRY_GERMANY = 276, /* Germany */ ++ CTRY_GREECE = 300, /* Greece */ ++ CTRY_GUATEMALA = 320, /* Guatemala */ ++ CTRY_HONDURAS = 340, /* Honduras */ ++ CTRY_HONG_KONG = 344, /* Hong Kong S.A.R., P.R.C. */ ++ CTRY_HUNGARY = 348, /* Hungary */ ++ CTRY_ICELAND = 352, /* Iceland */ ++ CTRY_INDIA = 356, /* India */ ++ CTRY_INDONESIA = 360, /* Indonesia */ ++ CTRY_IRAN = 364, /* Iran */ ++ CTRY_IRAQ = 368, /* Iraq */ ++ CTRY_IRELAND = 372, /* Ireland */ ++ CTRY_ISRAEL = 376, /* Israel */ ++ CTRY_ITALY = 380, /* Italy */ ++ CTRY_JAMAICA = 388, /* Jamaica */ ++ CTRY_JAPAN = 392, /* Japan */ ++ CTRY_JAPAN1 = 393, /* Japan (JP1) */ ++ CTRY_JAPAN2 = 394, /* Japan (JP0) */ ++ CTRY_JAPAN3 = 395, /* Japan (JP1-1) */ ++ CTRY_JAPAN4 = 396, /* Japan (JE1) */ ++ CTRY_JAPAN5 = 397, /* Japan (JE2) */ ++ CTRY_JAPAN6 = 399, /* Japan (JP6) */ ++ CTRY_JAPAN7 = 900, /* Japan */ ++ CTRY_JAPAN8 = 901, /* Japan */ ++ CTRY_JAPAN9 = 902, /* Japan */ ++ CTRY_JAPAN10 = 903, /* Japan */ ++ CTRY_JAPAN11 = 904, /* Japan */ ++ CTRY_JAPAN12 = 905, /* Japan */ ++ CTRY_JAPAN13 = 906, /* Japan */ ++ CTRY_JAPAN14 = 907, /* Japan */ ++ CTRY_JAPAN15 = 908, /* Japan */ ++ CTRY_JAPAN16 = 909, /* Japan */ ++ CTRY_JAPAN17 = 910, /* Japan */ ++ CTRY_JAPAN18 = 911, /* Japan */ ++ CTRY_JAPAN19 = 912, /* Japan */ ++ CTRY_JAPAN20 = 913, /* Japan */ ++ CTRY_JAPAN21 = 914, /* Japan */ ++ CTRY_JAPAN22 = 915, /* Japan */ ++ CTRY_JAPAN23 = 916, /* Japan */ ++ CTRY_JAPAN24 = 917, /* Japan */ ++ CTRY_JAPAN25 = 918, /* Japan */ ++ CTRY_JAPAN26 = 919, /* Japan */ ++ CTRY_JAPAN27 = 920, /* Japan */ ++ CTRY_JAPAN28 = 921, /* Japan */ ++ CTRY_JAPAN29 = 922, /* Japan */ ++ CTRY_JAPAN30 = 923, /* Japan */ ++ CTRY_JAPAN31 = 924, /* Japan */ ++ CTRY_JAPAN32 = 925, /* Japan */ ++ CTRY_JAPAN33 = 926, /* Japan */ ++ CTRY_JAPAN34 = 927, /* Japan */ ++ CTRY_JAPAN35 = 928, /* Japan */ ++ CTRY_JAPAN36 = 929, /* Japan */ ++ CTRY_JAPAN37 = 930, /* Japan */ ++ CTRY_JAPAN38 = 931, /* Japan */ ++ CTRY_JAPAN39 = 932, /* Japan */ ++ CTRY_JAPAN40 = 933, /* Japan */ ++ CTRY_JAPAN41 = 934, /* Japan */ ++ CTRY_JAPAN42 = 935, /* Japan */ ++ CTRY_JAPAN43 = 936, /* Japan */ ++ CTRY_JAPAN44 = 937, /* Japan */ ++ CTRY_JAPAN45 = 938, /* Japan */ ++ CTRY_JAPAN46 = 939, /* Japan */ ++ CTRY_JAPAN47 = 940, /* Japan */ ++ CTRY_JAPAN48 = 941, /* Japan */ ++ CTRY_JORDAN = 400, /* Jordan */ ++ CTRY_KAZAKHSTAN = 398, /* Kazakhstan */ ++ CTRY_KENYA = 404, /* Kenya */ ++ CTRY_KOREA_NORTH = 408, /* North Korea */ ++ CTRY_KOREA_ROC = 410, /* South Korea */ ++ CTRY_KOREA_ROC2 = 411, /* South Korea */ ++ CTRY_KUWAIT = 414, /* Kuwait */ ++ CTRY_LATVIA = 428, /* Latvia */ ++ CTRY_LEBANON = 422, /* Lebanon */ ++ CTRY_LIBYA = 434, /* Libya */ ++ CTRY_LIECHTENSTEIN = 438, /* Liechtenstein */ ++ CTRY_LITHUANIA = 440, /* Lithuania */ ++ CTRY_LUXEMBOURG = 442, /* Luxembourg */ ++ CTRY_MACAU = 446, /* Macau */ ++ CTRY_MACEDONIA = 807, /* the Former Yugoslav Republic of Macedonia */ ++ CTRY_MALAYSIA = 458, /* Malaysia */ ++ CTRY_MEXICO = 484, /* Mexico */ ++ CTRY_MONACO = 492, /* Principality of Monaco */ ++ CTRY_MOROCCO = 504, /* Morocco */ ++ CTRY_NETHERLANDS = 528, /* Netherlands */ ++ CTRY_NEW_ZEALAND = 554, /* New Zealand */ ++ CTRY_NICARAGUA = 558, /* Nicaragua */ ++ CTRY_NORWAY = 578, /* Norway */ ++ CTRY_OMAN = 512, /* Oman */ ++ CTRY_PAKISTAN = 586, /* Islamic Republic of Pakistan */ ++ CTRY_PANAMA = 591, /* Panama */ ++ CTRY_PARAGUAY = 600, /* Paraguay */ ++ CTRY_PERU = 604, /* Peru */ ++ CTRY_PHILIPPINES = 608, /* Republic of the Philippines */ ++ CTRY_POLAND = 616, /* Poland */ ++ CTRY_PORTUGAL = 620, /* Portugal */ ++ CTRY_PUERTO_RICO = 630, /* Puerto Rico */ ++ CTRY_QATAR = 634, /* Qatar */ ++ CTRY_ROMANIA = 642, /* Romania */ ++ CTRY_RUSSIA = 643, /* Russia */ ++ CTRY_SAUDI_ARABIA = 682, /* Saudi Arabia */ ++ CTRY_SINGAPORE = 702, /* Singapore */ ++ CTRY_SLOVAKIA = 703, /* Slovak Republic */ ++ CTRY_SLOVENIA = 705, /* Slovenia */ ++ CTRY_SOUTH_AFRICA = 710, /* South Africa */ ++ CTRY_SPAIN = 724, /* Spain */ ++ CTRY_SWEDEN = 752, /* Sweden */ ++ CTRY_SWITZERLAND = 756, /* Switzerland */ ++ CTRY_SYRIA = 760, /* Syria */ ++ CTRY_TAIWAN = 158, /* Taiwan */ ++ CTRY_THAILAND = 764, /* Thailand */ ++ CTRY_TRINIDAD_Y_TOBAGO = 780, /* Trinidad y Tobago */ ++ CTRY_TUNISIA = 788, /* Tunisia */ ++ CTRY_TURKEY = 792, /* Turkey */ ++ CTRY_UAE = 784, /* U.A.E. */ ++ CTRY_UKRAINE = 804, /* Ukraine */ ++ CTRY_UNITED_KINGDOM = 826, /* United Kingdom */ ++ CTRY_UNITED_STATES = 840, /* United States */ ++ CTRY_UNITED_STATES_FCC49 = 842, /* United States (Public Safety)*/ ++ CTRY_URUGUAY = 858, /* Uruguay */ ++ CTRY_UZBEKISTAN = 860, /* Uzbekistan */ ++ CTRY_VENEZUELA = 862, /* Venezuela */ ++ CTRY_VIET_NAM = 704, /* Viet Nam */ ++ CTRY_YEMEN = 887, /* Yemen */ ++ CTRY_ZIMBABWE = 716 /* Zimbabwe */ ++}; ++ ++/* ++ * Country information element. ++ */ ++#define IEEE80211_COUNTRY_MAX_TRIPLETS (83) ++struct ieee80211_ie_country { ++ u_int8_t country_id; ++ u_int8_t country_len; ++ u_int8_t country_str[3]; ++ u_int8_t country_triplet[IEEE80211_COUNTRY_MAX_TRIPLETS * 3]; ++} __packed; ++ ++/* does frame have QoS sequence control data */ ++#define IEEE80211_QOS_HAS_SEQ(wh) \ ++ (((wh)->i_fc[0] & \ ++ (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_QOS)) == \ ++ (IEEE80211_FC0_TYPE_DATA | IEEE80211_FC0_SUBTYPE_QOS)) ++ ++#define WME_QOSINFO_COUNT 0x0f /* Mask for Param Set Count field */ ++/* ++ * WME/802.11e information element. ++ */ ++struct ieee80211_ie_wme { ++ u_int8_t wme_id; /* IEEE80211_ELEMID_VENDOR */ ++ u_int8_t wme_len; /* length in bytes */ ++ u_int8_t wme_oui[3]; /* 0x00, 0x50, 0xf2 */ ++ u_int8_t wme_type; /* OUI type */ ++ u_int8_t wme_subtype; /* OUI subtype */ ++ u_int8_t wme_version; /* spec revision */ ++ u_int8_t wme_info; /* QoS info */ ++} __packed; ++ ++/* ++ * WME/802.11e Tspec Element ++ */ ++struct ieee80211_wme_tspec { ++ u_int8_t ts_id; ++ u_int8_t ts_len; ++ u_int8_t ts_oui[3]; ++ u_int8_t ts_oui_type; ++ u_int8_t ts_oui_subtype; ++ u_int8_t ts_version; ++ u_int8_t ts_tsinfo[3]; ++ u_int8_t ts_nom_msdu[2]; ++ u_int8_t ts_max_msdu[2]; ++ u_int8_t ts_min_svc[4]; ++ u_int8_t ts_max_svc[4]; ++ u_int8_t ts_inactv_intv[4]; ++ u_int8_t ts_susp_intv[4]; ++ u_int8_t ts_start_svc[4]; ++ u_int8_t ts_min_rate[4]; ++ u_int8_t ts_mean_rate[4]; ++ u_int8_t ts_max_burst[4]; ++ u_int8_t ts_min_phy[4]; ++ u_int8_t ts_peak_rate[4]; ++ u_int8_t ts_delay[4]; ++ u_int8_t ts_surplus[2]; ++ u_int8_t ts_medium_time[2]; ++} __packed; ++ ++/* ++ * WME AC parameter field ++ */ ++ ++struct ieee80211_wme_acparams { ++ u_int8_t acp_aci_aifsn; ++ u_int8_t acp_logcwminmax; ++ u_int16_t acp_txop; ++} __packed; ++ ++#define IEEE80211_WME_PARAM_LEN 24 ++#define WME_NUM_AC 4 /* 4 AC categories */ ++ ++#define WME_PARAM_ACI 0x60 /* Mask for ACI field */ ++#define WME_PARAM_ACI_S 5 /* Shift for ACI field */ ++#define WME_PARAM_ACM 0x10 /* Mask for ACM bit */ ++#define WME_PARAM_ACM_S 4 /* Shift for ACM bit */ ++#define WME_PARAM_AIFSN 0x0f /* Mask for aifsn field */ ++#define WME_PARAM_AIFSN_S 0 /* Shift for aifsn field */ ++#define WME_PARAM_LOGCWMIN 0x0f /* Mask for CwMin field (in log) */ ++#define WME_PARAM_LOGCWMIN_S 0 /* Shift for CwMin field */ ++#define WME_PARAM_LOGCWMAX 0xf0 /* Mask for CwMax field (in log) */ ++#define WME_PARAM_LOGCWMAX_S 4 /* Shift for CwMax field */ ++ ++#define WME_AC_TO_TID(_ac) ( \ ++ ((_ac) == WME_AC_VO) ? 6 : \ ++ ((_ac) == WME_AC_VI) ? 5 : \ ++ ((_ac) == WME_AC_BK) ? 1 : \ ++ 0) ++ ++#define TID_TO_WME_AC(_tid) ( \ ++ ((_tid) < 1) ? WME_AC_BE : \ ++ ((_tid) < 3) ? WME_AC_BK : \ ++ ((_tid) < 6) ? WME_AC_VI : \ ++ WME_AC_VO) ++ ++/* ++ * WME Parameter Element ++ */ ++ ++struct ieee80211_wme_param { ++ u_int8_t param_id; ++ u_int8_t param_len; ++ u_int8_t param_oui[3]; ++ u_int8_t param_oui_type; ++ u_int8_t param_oui_sybtype; ++ u_int8_t param_version; ++ u_int8_t param_qosInfo; ++ u_int8_t param_reserved; ++ struct ieee80211_wme_acparams params_acParams[WME_NUM_AC]; ++} __packed; ++ ++/* ++ * WME U-APSD qos info field defines ++ */ ++#define WME_CAPINFO_UAPSD_EN 0x00000080 ++#define WME_CAPINFO_UAPSD_VO 0x00000001 ++#define WME_CAPINFO_UAPSD_VI 0x00000002 ++#define WME_CAPINFO_UAPSD_BK 0x00000004 ++#define WME_CAPINFO_UAPSD_BE 0x00000008 ++#define WME_CAPINFO_UAPSD_ACFLAGS_SHIFT 0 ++#define WME_CAPINFO_UAPSD_ACFLAGS_MASK 0xF ++#define WME_CAPINFO_UAPSD_MAXSP_SHIFT 5 ++#define WME_CAPINFO_UAPSD_MAXSP_MASK 0x3 ++#define WME_CAPINFO_IE_OFFSET 8 ++#define WME_UAPSD_MAXSP(_qosinfo) (((_qosinfo) >> WME_CAPINFO_UAPSD_MAXSP_SHIFT) & WME_CAPINFO_UAPSD_MAXSP_MASK) ++#define WME_UAPSD_AC_ENABLED(_ac, _qosinfo) ( (1<<(3 - (_ac))) & \ ++ (((_qosinfo) >> WME_CAPINFO_UAPSD_ACFLAGS_SHIFT) & WME_CAPINFO_UAPSD_ACFLAGS_MASK) ) ++ ++/* ++ * Atheros Advanced Capability information element. ++ */ ++struct ieee80211_ie_athAdvCap { ++ u_int8_t athAdvCap_id; /* IEEE80211_ELEMID_VENDOR */ ++ u_int8_t athAdvCap_len; /* length in bytes */ ++ u_int8_t athAdvCap_oui[3]; /* 0x00, 0x03, 0x7f */ ++ u_int8_t athAdvCap_type; /* OUI type */ ++ u_int8_t athAdvCap_subtype; /* OUI subtype */ ++ u_int8_t athAdvCap_version; /* spec revision */ ++ u_int8_t athAdvCap_capability; /* Capability info */ ++ u_int16_t athAdvCap_defKeyIndex; ++} __packed; ++ ++/* ++ * Atheros XR information element. ++ */ ++struct ieee80211_xr_param { ++ u_int8_t param_id; ++ u_int8_t param_len; ++ u_int8_t param_oui[3]; ++ u_int8_t param_oui_type; ++ u_int8_t param_oui_sybtype; ++ u_int8_t param_version; ++ u_int8_t param_Info; ++ u_int8_t param_base_bssid[IEEE80211_ADDR_LEN]; ++ u_int8_t param_xr_bssid[IEEE80211_ADDR_LEN]; ++ u_int16_t param_xr_beacon_interval; ++ u_int8_t param_base_ath_capability; ++ u_int8_t param_xr_ath_capability; ++} __packed; ++ ++/* Atheros capabilities */ ++#define IEEE80211_ATHC_TURBOP 0x0001 /* Turbo Prime */ ++#define IEEE80211_ATHC_COMP 0x0002 /* Compression */ ++#define IEEE80211_ATHC_FF 0x0004 /* Fast Frames */ ++#define IEEE80211_ATHC_XR 0x0008 /* Xtended Range support */ ++#define IEEE80211_ATHC_AR 0x0010 /* Advanced Radar support */ ++#define IEEE80211_ATHC_BURST 0x0020 /* Bursting - not negotiated */ ++#define IEEE80211_ATHC_WME 0x0040 /* CWMin tuning */ ++#define IEEE80211_ATHC_BOOST 0x0080 /* Boost */ ++ ++/* ++ * Management Notification Frame ++ */ ++struct ieee80211_mnf { ++ u_int8_t mnf_category; ++ u_int8_t mnf_action; ++ u_int8_t mnf_dialog; ++ u_int8_t mnf_status; ++} __packed; ++#define MNF_SETUP_REQ 0 ++#define MNF_SETUP_RESP 1 ++#define MNF_TEARDOWN 2 ++ ++/* ++ * Control frames. ++ */ ++struct ieee80211_frame_min { ++ u_int8_t i_fc[2]; ++ u_int8_t i_dur[2]; ++ u_int8_t i_addr1[IEEE80211_ADDR_LEN]; ++ u_int8_t i_addr2[IEEE80211_ADDR_LEN]; ++ /* FCS */ ++} __packed; ++ ++struct ieee80211_frame_rts { ++ u_int8_t i_fc[2]; ++ u_int8_t i_dur[2]; ++ u_int8_t i_ra[IEEE80211_ADDR_LEN]; ++ u_int8_t i_ta[IEEE80211_ADDR_LEN]; ++ /* FCS */ ++} __packed; ++ ++struct ieee80211_frame_cts { ++ u_int8_t i_fc[2]; ++ u_int8_t i_dur[2]; ++ u_int8_t i_ra[IEEE80211_ADDR_LEN]; ++ /* FCS */ ++} __packed; ++ ++struct ieee80211_frame_ack { ++ u_int8_t i_fc[2]; ++ u_int8_t i_dur[2]; ++ u_int8_t i_ra[IEEE80211_ADDR_LEN]; ++ /* FCS */ ++} __packed; ++ ++struct ieee80211_frame_pspoll { ++ u_int8_t i_fc[2]; ++ u_int8_t i_aid[2]; ++ u_int8_t i_bssid[IEEE80211_ADDR_LEN]; ++ u_int8_t i_ta[IEEE80211_ADDR_LEN]; ++ /* FCS */ ++} __packed; ++ ++struct ieee80211_frame_cfend { /* NB: also CF-End+CF-Ack */ ++ u_int8_t i_fc[2]; ++ u_int8_t i_dur[2]; /* should be zero */ ++ u_int8_t i_ra[IEEE80211_ADDR_LEN]; ++ u_int8_t i_bssid[IEEE80211_ADDR_LEN]; ++ /* FCS */ ++} __packed; ++ ++/* ++ * BEACON management packets ++ * ++ * octet timestamp[8] ++ * octet beacon interval[2] ++ * octet capability information[2] ++ * information element ++ * octet elemid ++ * octet length ++ * octet information[length] ++ */ ++ ++typedef u_int8_t *ieee80211_mgt_beacon_t; ++ ++#define IEEE80211_BEACON_INTERVAL(beacon) \ ++ ((beacon)[8] | ((beacon)[9] << 8)) ++#define IEEE80211_BEACON_CAPABILITY(beacon) \ ++ ((beacon)[10] | ((beacon)[11] << 8)) ++ ++#define IEEE80211_CAPINFO_ESS 0x0001 ++#define IEEE80211_CAPINFO_IBSS 0x0002 ++#define IEEE80211_CAPINFO_CF_POLLABLE 0x0004 ++#define IEEE80211_CAPINFO_CF_POLLREQ 0x0008 ++#define IEEE80211_CAPINFO_PRIVACY 0x0010 ++#define IEEE80211_CAPINFO_SHORT_PREAMBLE 0x0020 ++#define IEEE80211_CAPINFO_PBCC 0x0040 ++#define IEEE80211_CAPINFO_CHNL_AGILITY 0x0080 ++/* bits 8-9 are reserved (8 now for specturm management) */ ++#define IEEE80211_CAPINFO_SPECTRUM_MGMT 0x0100 ++#define IEEE80211_CAPINFO_SHORT_SLOTTIME 0x0400 ++#define IEEE80211_CAPINFO_RSN 0x0800 ++/* bit 12 is reserved */ ++#define IEEE80211_CAPINFO_DSSSOFDM 0x2000 ++/* bits 14-15 are reserved */ ++ ++/* ++ * 802.11i/WPA information element (maximally sized). ++ */ ++struct ieee80211_ie_wpa { ++ u_int8_t wpa_id; /* IEEE80211_ELEMID_VENDOR */ ++ u_int8_t wpa_len; /* length in bytes */ ++ u_int8_t wpa_oui[3]; /* 0x00, 0x50, 0xf2 */ ++ u_int8_t wpa_type; /* OUI type */ ++ u_int16_t wpa_version; /* spec revision */ ++ u_int32_t wpa_mcipher[1]; /* multicast/group key cipher */ ++ u_int16_t wpa_uciphercnt; /* # pairwise key ciphers */ ++ u_int32_t wpa_uciphers[8]; /* ciphers */ ++ u_int16_t wpa_authselcnt; /* authentication selector cnt*/ ++ u_int32_t wpa_authsels[8]; /* selectors */ ++ u_int16_t wpa_caps; /* 802.11i capabilities */ ++ u_int16_t wpa_pmkidcnt; /* 802.11i pmkid count */ ++ u_int16_t wpa_pmkids[8]; /* 802.11i pmkids */ ++} __packed; ++ ++/* ++ * Management information element payloads. ++ */ ++ ++enum { ++ IEEE80211_ELEMID_SSID = 0, ++ IEEE80211_ELEMID_RATES = 1, ++ IEEE80211_ELEMID_FHPARMS = 2, ++ IEEE80211_ELEMID_DSPARMS = 3, ++ IEEE80211_ELEMID_CFPARMS = 4, ++ IEEE80211_ELEMID_TIM = 5, ++ IEEE80211_ELEMID_IBSSPARMS = 6, ++ IEEE80211_ELEMID_COUNTRY = 7, ++ IEEE80211_ELEMID_REQINFO = 10, ++ IEEE80211_ELEMID_CHALLENGE = 16, ++ /* 17-31 reserved for challenge text extension */ ++ IEEE80211_ELEMID_PWRCNSTR = 32, ++ IEEE80211_ELEMID_PWRCAP = 33, ++ IEEE80211_ELEMID_TPCREQ = 34, ++ IEEE80211_ELEMID_TPCREP = 35, ++ IEEE80211_ELEMID_SUPPCHAN = 36, ++ IEEE80211_ELEMID_CHANSWITCHANN = 37, ++ IEEE80211_ELEMID_MEASREQ = 38, ++ IEEE80211_ELEMID_MEASREP = 39, ++ IEEE80211_ELEMID_QUIET = 40, ++ IEEE80211_ELEMID_IBSSDFS = 41, ++ IEEE80211_ELEMID_ERP = 42, ++ IEEE80211_ELEMID_RSN = 48, ++ IEEE80211_ELEMID_XRATES = 50, ++ IEEE80211_ELEMID_TPC = 150, ++ IEEE80211_ELEMID_CCKM = 156, ++ IEEE80211_ELEMID_VENDOR = 221, /* vendor private */ ++}; ++ ++#define IEEE80211_CHANSWITCHANN_BYTES 5 ++ ++struct ieee80211_tim_ie { ++ u_int8_t tim_ie; /* IEEE80211_ELEMID_TIM */ ++ u_int8_t tim_len; ++ u_int8_t tim_count; /* DTIM count */ ++ u_int8_t tim_period; /* DTIM period */ ++ u_int8_t tim_bitctl; /* bitmap control */ ++ u_int8_t tim_bitmap[1]; /* variable-length bitmap */ ++} __packed; ++ ++struct ieee80211_country_ie { ++ u_int8_t ie; /* IEEE80211_ELEMID_COUNTRY */ ++ u_int8_t len; ++ u_int8_t cc[3]; /* ISO CC+(I)ndoor/(O)utdoor */ ++ struct { ++ u_int8_t schan; /* starting channel */ ++ u_int8_t nchan; /* number channels */ ++ u_int8_t maxtxpwr; /* tx power cap */ ++ } __packed band[4]; /* up to 4 sub bands */ ++} __packed; ++ ++#define IEEE80211_CHALLENGE_LEN 128 ++ ++#define IEEE80211_SUPPCHAN_LEN 26 ++ ++#define IEEE80211_RATE_BASIC 0x80 ++#define IEEE80211_RATE_VAL 0x7f ++ ++/* EPR information element flags */ ++#define IEEE80211_ERP_NON_ERP_PRESENT 0x01 ++#define IEEE80211_ERP_USE_PROTECTION 0x02 ++#define IEEE80211_ERP_LONG_PREAMBLE 0x04 ++ ++/* Atheros private advanced capabilities info */ ++#define ATHEROS_CAP_TURBO_PRIME 0x01 ++#define ATHEROS_CAP_COMPRESSION 0x02 ++#define ATHEROS_CAP_FAST_FRAME 0x04 ++/* bits 3-6 reserved */ ++#define ATHEROS_CAP_BOOST 0x80 ++ ++#define ATH_OUI 0x7f0300 /* Atheros OUI */ ++#define ATH_OUI_TYPE 0x01 ++#define ATH_OUI_SUBTYPE 0x01 ++#define ATH_OUI_VERSION 0x00 ++#define ATH_OUI_TYPE_XR 0x03 ++#define ATH_OUI_VER_XR 0x01 ++ ++#define WPA_OUI 0xf25000 ++#define WPA_OUI_TYPE 0x01 ++#define WPA_VERSION 1 /* current supported version */ ++ ++#define WPA_CSE_NULL 0x00 ++#define WPA_CSE_WEP40 0x01 ++#define WPA_CSE_TKIP 0x02 ++#define WPA_CSE_CCMP 0x04 ++#define WPA_CSE_WEP104 0x05 ++ ++#define WPA_ASE_NONE 0x00 ++#define WPA_ASE_8021X_UNSPEC 0x01 ++#define WPA_ASE_8021X_PSK 0x02 ++ ++#define RSN_OUI 0xac0f00 ++#define RSN_VERSION 1 /* current supported version */ ++ ++#define RSN_CSE_NULL 0x00 ++#define RSN_CSE_WEP40 0x01 ++#define RSN_CSE_TKIP 0x02 ++#define RSN_CSE_WRAP 0x03 ++#define RSN_CSE_CCMP 0x04 ++#define RSN_CSE_WEP104 0x05 ++ ++#define RSN_ASE_NONE 0x00 ++#define RSN_ASE_8021X_UNSPEC 0x01 ++#define RSN_ASE_8021X_PSK 0x02 ++ ++#define RSN_CAP_PREAUTH 0x01 ++ ++#define WME_OUI 0xf25000 ++#define WME_OUI_TYPE 0x02 ++#define WME_INFO_OUI_SUBTYPE 0x00 ++#define WME_PARAM_OUI_SUBTYPE 0x01 ++#define WME_VERSION 1 ++ ++/* WME stream classes */ ++#define WME_AC_BE 0 /* best effort */ ++#define WME_AC_BK 1 /* background */ ++#define WME_AC_VI 2 /* video */ ++#define WME_AC_VO 3 /* voice */ ++ ++/* ++ * AUTH management packets ++ * ++ * octet algo[2] ++ * octet seq[2] ++ * octet status[2] ++ * octet chal.id ++ * octet chal.length ++ * octet chal.text[253] ++ */ ++ ++typedef u_int8_t *ieee80211_mgt_auth_t; ++ ++#define IEEE80211_AUTH_ALGORITHM(auth) \ ++ ((auth)[0] | ((auth)[1] << 8)) ++#define IEEE80211_AUTH_TRANSACTION(auth) \ ++ ((auth)[2] | ((auth)[3] << 8)) ++#define IEEE80211_AUTH_STATUS(auth) \ ++ ((auth)[4] | ((auth)[5] << 8)) ++ ++#define IEEE80211_AUTH_ALG_OPEN 0x0000 ++#define IEEE80211_AUTH_ALG_SHARED 0x0001 ++#define IEEE80211_AUTH_ALG_LEAP 0x0080 ++ ++enum { ++ IEEE80211_AUTH_OPEN_REQUEST = 1, ++ IEEE80211_AUTH_OPEN_RESPONSE = 2, ++}; ++ ++enum { ++ IEEE80211_AUTH_SHARED_REQUEST = 1, ++ IEEE80211_AUTH_SHARED_CHALLENGE = 2, ++ IEEE80211_AUTH_SHARED_RESPONSE = 3, ++ IEEE80211_AUTH_SHARED_PASS = 4, ++}; ++ ++/* ++ * Reason codes ++ * ++ * Unlisted codes are reserved ++ */ ++ ++enum { ++ IEEE80211_REASON_UNSPECIFIED = 1, ++ IEEE80211_REASON_AUTH_EXPIRE = 2, ++ IEEE80211_REASON_AUTH_LEAVE = 3, ++ IEEE80211_REASON_ASSOC_EXPIRE = 4, ++ IEEE80211_REASON_ASSOC_TOOMANY = 5, ++ IEEE80211_REASON_NOT_AUTHED = 6, ++ IEEE80211_REASON_NOT_ASSOCED = 7, ++ IEEE80211_REASON_ASSOC_LEAVE = 8, ++ IEEE80211_REASON_ASSOC_NOT_AUTHED = 9, ++ ++ IEEE80211_REASON_RSN_REQUIRED = 11, ++ IEEE80211_REASON_RSN_INCONSISTENT = 12, ++ IEEE80211_REASON_IE_INVALID = 13, ++ IEEE80211_REASON_MIC_FAILURE = 14, ++ ++ IEEE80211_STATUS_SUCCESS = 0, ++ IEEE80211_STATUS_UNSPECIFIED = 1, ++ IEEE80211_STATUS_CAPINFO = 10, ++ IEEE80211_STATUS_NOT_ASSOCED = 11, ++ IEEE80211_STATUS_OTHER = 12, ++ IEEE80211_STATUS_ALG = 13, ++ IEEE80211_STATUS_SEQUENCE = 14, ++ IEEE80211_STATUS_CHALLENGE = 15, ++ IEEE80211_STATUS_TIMEOUT = 16, ++ IEEE80211_STATUS_TOOMANY = 17, ++ IEEE80211_STATUS_BASIC_RATE = 18, ++ IEEE80211_STATUS_SP_REQUIRED = 19, ++ IEEE80211_STATUS_PBCC_REQUIRED = 20, ++ IEEE80211_STATUS_CA_REQUIRED = 21, ++ IEEE80211_STATUS_TOO_MANY_STATIONS = 22, ++ IEEE80211_STATUS_RATES = 23, ++ IEEE80211_STATUS_SHORTSLOT_REQUIRED = 25, ++ IEEE80211_STATUS_DSSSOFDM_REQUIRED = 26, ++}; ++ ++#define IEEE80211_WEP_KEYLEN 5 /* 40bit */ ++#define IEEE80211_WEP_IVLEN 3 /* 24bit */ ++#define IEEE80211_WEP_KIDLEN 1 /* 1 octet */ ++#define IEEE80211_WEP_CRCLEN 4 /* CRC-32 */ ++#define IEEE80211_WEP_NKID 4 /* number of key ids */ ++ ++/* ++ * 802.11i defines an extended IV for use with non-WEP ciphers. ++ * When the EXTIV bit is set in the key id byte an additional ++ * 4 bytes immediately follow the IV for TKIP. For CCMP the ++ * EXTIV bit is likewise set but the 8 bytes represent the ++ * CCMP header rather than IV+extended-IV. ++ */ ++#define IEEE80211_WEP_EXTIV 0x20 ++#define IEEE80211_WEP_EXTIVLEN 4 /* extended IV length */ ++#define IEEE80211_WEP_MICLEN 8 /* trailing MIC */ ++ ++#define IEEE80211_CRC_LEN 4 ++ ++/* ++ * Maximum acceptable MTU is: ++ * IEEE80211_MAX_LEN - WEP overhead - CRC - ++ * QoS overhead - RSN/WPA overhead ++ * Min is arbitrarily chosen > IEEE80211_MIN_LEN. The default ++ * mtu is Ethernet-compatible; it's set by ether_ifattach. ++ */ ++#define IEEE80211_MTU_MAX 2290 ++#define IEEE80211_MTU_MIN 32 ++ ++#define IEEE80211_MAX_LEN (2300 + IEEE80211_CRC_LEN + \ ++ (IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN + IEEE80211_WEP_CRCLEN)) ++#define IEEE80211_ACK_LEN \ ++ (sizeof(struct ieee80211_frame_ack) + IEEE80211_CRC_LEN) ++#define IEEE80211_MIN_LEN \ ++ (sizeof(struct ieee80211_frame_min) + IEEE80211_CRC_LEN) ++ ++/* ++ * The 802.11 spec says at most 2007 stations may be ++ * associated at once. For most AP's this is way more ++ * than is feasible so we use a default of 128. This ++ * number may be overridden by the driver and/or by ++ * user configuration. ++ */ ++#define IEEE80211_AID_MAX 2007 ++#define IEEE80211_AID_DEF 128 ++ ++#define IEEE80211_AID(b) ((b) &~ 0xc000) ++ ++/* ++ * RTS frame length parameters. The default is specified in ++ * the 802.11 spec. The max may be wrong for jumbo frames. ++ */ ++#define IEEE80211_RTS_DEFAULT 512 ++#define IEEE80211_RTS_MIN 1 ++#define IEEE80211_RTS_MAX 2346 ++ ++/* ++ * Regulatory extention identifier for country IE. ++ */ ++#define IEEE80211_REG_EXT_ID 201 ++ ++/* ++ * IEEE 802.11 timer synchronization function (TSF) timestamp length ++ */ ++#define IEEE80211_TSF_LEN 8 ++ ++#endif /* _NET80211_IEEE80211_H_ */ +diff -urNw wpasupplicant-0.4.8.orig/driver_madwifi_ng/net80211/ieee80211_ioctl.h wpasupplicant-0.4.8/driver_madwifi_ng/net80211/ieee80211_ioctl.h +--- wpasupplicant-0.4.8.orig/driver_madwifi_ng/net80211/ieee80211_ioctl.h 1970-01-01 01:00:00.000000000 +0100 ++++ wpasupplicant-0.4.8/driver_madwifi_ng/net80211/ieee80211_ioctl.h 2006-05-31 11:45:05.736591274 +0200 +@@ -0,0 +1,616 @@ ++/*- ++ * Copyright (c) 2001 Atsushi Onoe ++ * Copyright (c) 2002-2005 Sam Leffler, Errno Consulting ++ * 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. The name of the author may not be used to endorse or promote products ++ * derived from this software without specific prior written permission. ++ * ++ * Alternatively, this software may be distributed under the terms of the ++ * GNU General Public License ("GPL") version 2 as published by the Free ++ * Software Foundation. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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. ++ * ++ * $Id: ieee80211_ioctl.h 1453 2006-02-19 17:19:27Z mrenzmann $ ++ */ ++#ifndef _NET80211_IEEE80211_IOCTL_H_ ++#define _NET80211_IEEE80211_IOCTL_H_ ++ ++/* ++ * IEEE 802.11 ioctls. ++ */ ++#include ++#include ++#include ++ ++/* ++ * Per/node (station) statistics available when operating as an AP. ++ */ ++struct ieee80211_nodestats { ++ u_int32_t ns_rx_data; /* rx data frames */ ++ u_int32_t ns_rx_mgmt; /* rx management frames */ ++ u_int32_t ns_rx_ctrl; /* rx control frames */ ++ u_int32_t ns_rx_ucast; /* rx unicast frames */ ++ u_int32_t ns_rx_mcast; /* rx multi/broadcast frames */ ++ u_int64_t ns_rx_bytes; /* rx data count (bytes) */ ++ u_int64_t ns_rx_beacons; /* rx beacon frames */ ++ u_int32_t ns_rx_proberesp; /* rx probe response frames */ ++ ++ u_int32_t ns_rx_dup; /* rx discard because it's a dup */ ++ u_int32_t ns_rx_noprivacy; /* rx w/ wep but privacy off */ ++ u_int32_t ns_rx_wepfail; /* rx wep processing failed */ ++ u_int32_t ns_rx_demicfail; /* rx demic failed */ ++ u_int32_t ns_rx_decap; /* rx decapsulation failed */ ++ u_int32_t ns_rx_defrag; /* rx defragmentation failed */ ++ u_int32_t ns_rx_disassoc; /* rx disassociation */ ++ u_int32_t ns_rx_deauth; /* rx deauthentication */ ++ u_int32_t ns_rx_decryptcrc; /* rx decrypt failed on crc */ ++ u_int32_t ns_rx_unauth; /* rx on unauthorized port */ ++ u_int32_t ns_rx_unencrypted; /* rx unecrypted w/ privacy */ ++ ++ u_int32_t ns_tx_data; /* tx data frames */ ++ u_int32_t ns_tx_mgmt; /* tx management frames */ ++ u_int32_t ns_tx_ucast; /* tx unicast frames */ ++ u_int32_t ns_tx_mcast; /* tx multi/broadcast frames */ ++ u_int64_t ns_tx_bytes; /* tx data count (bytes) */ ++ u_int32_t ns_tx_probereq; /* tx probe request frames */ ++ u_int32_t ns_tx_uapsd; /* tx on uapsd queue */ ++ ++ u_int32_t ns_tx_novlantag; /* tx discard due to no tag */ ++ u_int32_t ns_tx_vlanmismatch; /* tx discard due to of bad tag */ ++ ++ u_int32_t ns_tx_eosplost; /* uapsd EOSP retried out */ ++ ++ u_int32_t ns_ps_discard; /* ps discard due to of age */ ++ ++ u_int32_t ns_uapsd_triggers; /* uapsd triggers */ ++ ++ /* MIB-related state */ ++ u_int32_t ns_tx_assoc; /* [re]associations */ ++ u_int32_t ns_tx_assoc_fail; /* [re]association failures */ ++ u_int32_t ns_tx_auth; /* [re]authentications */ ++ u_int32_t ns_tx_auth_fail; /* [re]authentication failures*/ ++ u_int32_t ns_tx_deauth; /* deauthentications */ ++ u_int32_t ns_tx_deauth_code; /* last deauth reason */ ++ u_int32_t ns_tx_disassoc; /* disassociations */ ++ u_int32_t ns_tx_disassoc_code; /* last disassociation reason */ ++ u_int32_t ns_psq_drops; /* power save queue drops */ ++}; ++ ++/* ++ * Summary statistics. ++ */ ++struct ieee80211_stats { ++ u_int32_t is_rx_badversion; /* rx frame with bad version */ ++ u_int32_t is_rx_tooshort; /* rx frame too short */ ++ u_int32_t is_rx_wrongbss; /* rx from wrong bssid */ ++ u_int32_t is_rx_dup; /* rx discard due to it's a dup */ ++ u_int32_t is_rx_wrongdir; /* rx w/ wrong direction */ ++ u_int32_t is_rx_mcastecho; /* rx discard due to of mcast echo */ ++ u_int32_t is_rx_notassoc; /* rx discard due to sta !assoc */ ++ u_int32_t is_rx_noprivacy; /* rx w/ wep but privacy off */ ++ u_int32_t is_rx_unencrypted; /* rx w/o wep and privacy on */ ++ u_int32_t is_rx_wepfail; /* rx wep processing failed */ ++ u_int32_t is_rx_decap; /* rx decapsulation failed */ ++ u_int32_t is_rx_mgtdiscard; /* rx discard mgt frames */ ++ u_int32_t is_rx_ctl; /* rx discard ctrl frames */ ++ u_int32_t is_rx_beacon; /* rx beacon frames */ ++ u_int32_t is_rx_rstoobig; /* rx rate set truncated */ ++ u_int32_t is_rx_elem_missing; /* rx required element missing*/ ++ u_int32_t is_rx_elem_toobig; /* rx element too big */ ++ u_int32_t is_rx_elem_toosmall; /* rx element too small */ ++ u_int32_t is_rx_elem_unknown; /* rx element unknown */ ++ u_int32_t is_rx_badchan; /* rx frame w/ invalid chan */ ++ u_int32_t is_rx_chanmismatch; /* rx frame chan mismatch */ ++ u_int32_t is_rx_nodealloc; /* rx frame dropped */ ++ u_int32_t is_rx_ssidmismatch; /* rx frame ssid mismatch */ ++ u_int32_t is_rx_auth_unsupported;/* rx w/ unsupported auth alg */ ++ u_int32_t is_rx_auth_fail; /* rx sta auth failure */ ++ u_int32_t is_rx_auth_countermeasures;/* rx auth discard due to CM */ ++ u_int32_t is_rx_assoc_bss; /* rx assoc from wrong bssid */ ++ u_int32_t is_rx_assoc_notauth; /* rx assoc w/o auth */ ++ u_int32_t is_rx_assoc_capmismatch;/* rx assoc w/ cap mismatch */ ++ u_int32_t is_rx_assoc_norate; /* rx assoc w/ no rate match */ ++ u_int32_t is_rx_assoc_badwpaie; /* rx assoc w/ bad WPA IE */ ++ u_int32_t is_rx_deauth; /* rx deauthentication */ ++ u_int32_t is_rx_disassoc; /* rx disassociation */ ++ u_int32_t is_rx_badsubtype; /* rx frame w/ unknown subtype*/ ++ u_int32_t is_rx_nobuf; /* rx failed for lack of buf */ ++ u_int32_t is_rx_decryptcrc; /* rx decrypt failed on crc */ ++ u_int32_t is_rx_ahdemo_mgt; /* rx discard ahdemo mgt frame*/ ++ u_int32_t is_rx_bad_auth; /* rx bad auth request */ ++ u_int32_t is_rx_unauth; /* rx on unauthorized port */ ++ u_int32_t is_rx_badkeyid; /* rx w/ incorrect keyid */ ++ u_int32_t is_rx_ccmpreplay; /* rx seq# violation (CCMP) */ ++ u_int32_t is_rx_ccmpformat; /* rx format bad (CCMP) */ ++ u_int32_t is_rx_ccmpmic; /* rx MIC check failed (CCMP) */ ++ u_int32_t is_rx_tkipreplay; /* rx seq# violation (TKIP) */ ++ u_int32_t is_rx_tkipformat; /* rx format bad (TKIP) */ ++ u_int32_t is_rx_tkipmic; /* rx MIC check failed (TKIP) */ ++ u_int32_t is_rx_tkipicv; /* rx ICV check failed (TKIP) */ ++ u_int32_t is_rx_badcipher; /* rx failed due to of key type */ ++ u_int32_t is_rx_nocipherctx; /* rx failed due to key !setup */ ++ u_int32_t is_rx_acl; /* rx discard due to of acl policy */ ++ u_int32_t is_rx_ffcnt; /* rx fast frames */ ++ u_int32_t is_rx_badathtnl; /* driver key alloc failed */ ++ u_int32_t is_tx_nobuf; /* tx failed for lack of buf */ ++ u_int32_t is_tx_nonode; /* tx failed for no node */ ++ u_int32_t is_tx_unknownmgt; /* tx of unknown mgt frame */ ++ u_int32_t is_tx_badcipher; /* tx failed due to of key type */ ++ u_int32_t is_tx_nodefkey; /* tx failed due to no defkey */ ++ u_int32_t is_tx_noheadroom; /* tx failed due to no space */ ++ u_int32_t is_tx_ffokcnt; /* tx fast frames sent success */ ++ u_int32_t is_tx_fferrcnt; /* tx fast frames sent success */ ++ u_int32_t is_scan_active; /* active scans started */ ++ u_int32_t is_scan_passive; /* passive scans started */ ++ u_int32_t is_node_timeout; /* nodes timed out inactivity */ ++ u_int32_t is_crypto_nomem; /* no memory for crypto ctx */ ++ u_int32_t is_crypto_tkip; /* tkip crypto done in s/w */ ++ u_int32_t is_crypto_tkipenmic; /* tkip en-MIC done in s/w */ ++ u_int32_t is_crypto_tkipdemic; /* tkip de-MIC done in s/w */ ++ u_int32_t is_crypto_tkipcm; /* tkip counter measures */ ++ u_int32_t is_crypto_ccmp; /* ccmp crypto done in s/w */ ++ u_int32_t is_crypto_wep; /* wep crypto done in s/w */ ++ u_int32_t is_crypto_setkey_cipher;/* cipher rejected key */ ++ u_int32_t is_crypto_setkey_nokey;/* no key index for setkey */ ++ u_int32_t is_crypto_delkey; /* driver key delete failed */ ++ u_int32_t is_crypto_badcipher; /* unknown cipher */ ++ u_int32_t is_crypto_nocipher; /* cipher not available */ ++ u_int32_t is_crypto_attachfail; /* cipher attach failed */ ++ u_int32_t is_crypto_swfallback; /* cipher fallback to s/w */ ++ u_int32_t is_crypto_keyfail; /* driver key alloc failed */ ++ u_int32_t is_crypto_enmicfail; /* en-MIC failed */ ++ u_int32_t is_ibss_capmismatch; /* merge failed-cap mismatch */ ++ u_int32_t is_ibss_norate; /* merge failed-rate mismatch */ ++ u_int32_t is_ps_unassoc; /* ps-poll for unassoc. sta */ ++ u_int32_t is_ps_badaid; /* ps-poll w/ incorrect aid */ ++ u_int32_t is_ps_qempty; /* ps-poll w/ nothing to send */ ++}; ++ ++/* ++ * Max size of optional information elements. We artificially ++ * constrain this; it's limited only by the max frame size (and ++ * the max parameter size of the wireless extensions). ++ */ ++#define IEEE80211_MAX_OPT_IE 256 ++ ++/* ++ * WPA/RSN get/set key request. Specify the key/cipher ++ * type and whether the key is to be used for sending and/or ++ * receiving. The key index should be set only when working ++ * with global keys (use IEEE80211_KEYIX_NONE for ``no index''). ++ * Otherwise a unicast/pairwise key is specified by the bssid ++ * (on a station) or mac address (on an ap). They key length ++ * must include any MIC key data; otherwise it should be no ++ more than IEEE80211_KEYBUF_SIZE. ++ */ ++struct ieee80211req_key { ++ u_int8_t ik_type; /* key/cipher type */ ++ u_int8_t ik_pad; ++ u_int16_t ik_keyix; /* key index */ ++ u_int8_t ik_keylen; /* key length in bytes */ ++ u_int8_t ik_flags; ++/* NB: IEEE80211_KEY_XMIT and IEEE80211_KEY_RECV defined elsewhere */ ++#define IEEE80211_KEY_DEFAULT 0x80 /* default xmit key */ ++ u_int8_t ik_macaddr[IEEE80211_ADDR_LEN]; ++ u_int64_t ik_keyrsc; /* key receive sequence counter */ ++ u_int64_t ik_keytsc; /* key transmit sequence counter */ ++ u_int8_t ik_keydata[IEEE80211_KEYBUF_SIZE+IEEE80211_MICBUF_SIZE]; ++}; ++ ++/* ++ * Delete a key either by index or address. Set the index ++ * to IEEE80211_KEYIX_NONE when deleting a unicast key. ++ */ ++struct ieee80211req_del_key { ++ u_int8_t idk_keyix; /* key index */ ++ u_int8_t idk_macaddr[IEEE80211_ADDR_LEN]; ++}; ++ ++/* ++ * MLME state manipulation request. IEEE80211_MLME_ASSOC ++ * only makes sense when operating as a station. The other ++ * requests can be used when operating as a station or an ++ * ap (to effect a station). ++ */ ++struct ieee80211req_mlme { ++ u_int8_t im_op; /* operation to perform */ ++#define IEEE80211_MLME_ASSOC 1 /* associate station */ ++#define IEEE80211_MLME_DISASSOC 2 /* disassociate station */ ++#define IEEE80211_MLME_DEAUTH 3 /* deauthenticate station */ ++#define IEEE80211_MLME_AUTHORIZE 4 /* authorize station */ ++#define IEEE80211_MLME_UNAUTHORIZE 5 /* unauthorize station */ ++#define IEEE80211_MLME_CLEAR_STATS 6 /* clear station statistic */ ++ u_int8_t im_ssid_len; /* length of optional ssid */ ++ u_int16_t im_reason; /* 802.11 reason code */ ++ u_int8_t im_macaddr[IEEE80211_ADDR_LEN]; ++ u_int8_t im_ssid[IEEE80211_NWID_LEN]; ++}; ++ ++/* ++ * MAC ACL operations. ++ */ ++enum { ++ IEEE80211_MACCMD_POLICY_OPEN = 0, /* set policy: no ACL's */ ++ IEEE80211_MACCMD_POLICY_ALLOW = 1, /* set policy: allow traffic */ ++ IEEE80211_MACCMD_POLICY_DENY = 2, /* set policy: deny traffic */ ++ IEEE80211_MACCMD_FLUSH = 3, /* flush ACL database */ ++ IEEE80211_MACCMD_DETACH = 4, /* detach ACL policy */ ++}; ++ ++/* ++ * Set the active channel list. Note this list is ++ * intersected with the available channel list in ++ * calculating the set of channels actually used in ++ * scanning. ++ */ ++struct ieee80211req_chanlist { ++ u_int8_t ic_channels[IEEE80211_CHAN_BYTES]; ++}; ++ ++/* ++ * Get the active channel list info. ++ */ ++struct ieee80211req_chaninfo { ++ u_int ic_nchans; ++ struct ieee80211_channel ic_chans[IEEE80211_CHAN_MAX]; ++}; ++ ++/* ++ * Retrieve the WPA/RSN information element for an associated station. ++ */ ++struct ieee80211req_wpaie { ++ u_int8_t wpa_macaddr[IEEE80211_ADDR_LEN]; ++ u_int8_t wpa_ie[IEEE80211_MAX_OPT_IE]; ++ u_int8_t rsn_ie[IEEE80211_MAX_OPT_IE]; ++}; ++ ++/* ++ * Retrieve per-node statistics. ++ */ ++struct ieee80211req_sta_stats { ++ union { ++ /* NB: explicitly force 64-bit alignment */ ++ u_int8_t macaddr[IEEE80211_ADDR_LEN]; ++ u_int64_t pad; ++ } is_u; ++ struct ieee80211_nodestats is_stats; ++}; ++ ++/* ++ * Station information block; the mac address is used ++ * to retrieve other data like stats, unicast key, etc. ++ */ ++struct ieee80211req_sta_info { ++ u_int16_t isi_len; /* length (mult of 4) */ ++ u_int16_t isi_freq; /* MHz */ ++ u_int16_t isi_flags; /* channel flags */ ++ u_int16_t isi_state; /* state flags */ ++ u_int8_t isi_authmode; /* authentication algorithm */ ++ u_int8_t isi_rssi; ++ u_int16_t isi_capinfo; /* capabilities */ ++ u_int8_t isi_athflags; /* Atheros capabilities */ ++ u_int8_t isi_erp; /* ERP element */ ++ u_int8_t isi_macaddr[IEEE80211_ADDR_LEN]; ++ u_int8_t isi_nrates; /* negotiated rates */ ++ u_int8_t isi_rates[IEEE80211_RATE_MAXSIZE]; ++ u_int8_t isi_txrate; /* index to isi_rates[] */ ++ u_int16_t isi_ie_len; /* IE length */ ++ u_int16_t isi_associd; /* assoc response */ ++ u_int16_t isi_txpower; /* current tx power */ ++ u_int16_t isi_vlan; /* vlan tag */ ++ u_int16_t isi_txseqs[17]; /* seq to be transmitted */ ++ u_int16_t isi_rxseqs[17]; /* seq previous for qos frames*/ ++ u_int16_t isi_inact; /* inactivity timer */ ++ u_int8_t isi_uapsd; /* UAPSD queues */ ++ u_int8_t isi_opmode; /* sta operating mode */ ++ ++ /* XXX frag state? */ ++ /* variable length IE data */ ++}; ++ ++enum { ++ IEEE80211_STA_OPMODE_NORMAL, ++ IEEE80211_STA_OPMODE_XR ++}; ++ ++/* ++ * Retrieve per-station information; to retrieve all ++ * specify a mac address of ff:ff:ff:ff:ff:ff. ++ */ ++struct ieee80211req_sta_req { ++ union { ++ /* NB: explicitly force 64-bit alignment */ ++ u_int8_t macaddr[IEEE80211_ADDR_LEN]; ++ u_int64_t pad; ++ } is_u; ++ struct ieee80211req_sta_info info[1]; /* variable length */ ++}; ++ ++/* ++ * Get/set per-station tx power cap. ++ */ ++struct ieee80211req_sta_txpow { ++ u_int8_t it_macaddr[IEEE80211_ADDR_LEN]; ++ u_int8_t it_txpow; ++}; ++ ++/* ++ * WME parameters are set and return using i_val and i_len. ++ * i_val holds the value itself. i_len specifies the AC ++ * and, as appropriate, then high bit specifies whether the ++ * operation is to be applied to the BSS or ourself. ++ */ ++#define IEEE80211_WMEPARAM_SELF 0x0000 /* parameter applies to self */ ++#define IEEE80211_WMEPARAM_BSS 0x8000 /* parameter applies to BSS */ ++#define IEEE80211_WMEPARAM_VAL 0x7fff /* parameter value */ ++ ++/* ++ * Scan result data returned for IEEE80211_IOC_SCAN_RESULTS. ++ */ ++struct ieee80211req_scan_result { ++ u_int16_t isr_len; /* length (mult of 4) */ ++ u_int16_t isr_freq; /* MHz */ ++ u_int16_t isr_flags; /* channel flags */ ++ u_int8_t isr_noise; ++ u_int8_t isr_rssi; ++ u_int8_t isr_intval; /* beacon interval */ ++ u_int16_t isr_capinfo; /* capabilities */ ++ u_int8_t isr_erp; /* ERP element */ ++ u_int8_t isr_bssid[IEEE80211_ADDR_LEN]; ++ u_int8_t isr_nrates; ++ u_int8_t isr_rates[IEEE80211_RATE_MAXSIZE]; ++ u_int8_t isr_ssid_len; /* SSID length */ ++ u_int8_t isr_ie_len; /* IE length */ ++ u_int8_t isr_pad[5]; ++ /* variable length SSID followed by IE data */ ++}; ++ ++#ifdef __FreeBSD__ ++/* ++ * FreeBSD-style ioctls. ++ */ ++/* the first member must be matched with struct ifreq */ ++struct ieee80211req { ++ char i_name[IFNAMSIZ]; /* if_name, e.g. "wi0" */ ++ u_int16_t i_type; /* req type */ ++ int16_t i_val; /* Index or simple value */ ++ int16_t i_len; /* Index or simple value */ ++ void *i_data; /* Extra data */ ++}; ++#define SIOCS80211 _IOW('i', 234, struct ieee80211req) ++#define SIOCG80211 _IOWR('i', 235, struct ieee80211req) ++#define SIOCG80211STATS _IOWR('i', 236, struct ifreq) ++#define SIOC80211IFCREATE _IOWR('i', 237, struct ifreq) ++#define SIOC80211IFDESTROY _IOW('i', 238, struct ifreq) ++ ++#define IEEE80211_IOC_SSID 1 ++#define IEEE80211_IOC_NUMSSIDS 2 ++#define IEEE80211_IOC_WEP 3 ++#define IEEE80211_WEP_NOSUP -1 ++#define IEEE80211_WEP_OFF 0 ++#define IEEE80211_WEP_ON 1 ++#define IEEE80211_WEP_MIXED 2 ++#define IEEE80211_IOC_WEPKEY 4 ++#define IEEE80211_IOC_NUMWEPKEYS 5 ++#define IEEE80211_IOC_WEPTXKEY 6 ++#define IEEE80211_IOC_AUTHMODE 7 ++#define IEEE80211_IOC_STATIONNAME 8 ++#define IEEE80211_IOC_CHANNEL 9 ++#define IEEE80211_IOC_POWERSAVE 10 ++#define IEEE80211_POWERSAVE_NOSUP -1 ++#define IEEE80211_POWERSAVE_OFF 0 ++#define IEEE80211_POWERSAVE_CAM 1 ++#define IEEE80211_POWERSAVE_PSP 2 ++#define IEEE80211_POWERSAVE_PSP_CAM 3 ++#define IEEE80211_POWERSAVE_ON IEEE80211_POWERSAVE_CAM ++#define IEEE80211_IOC_POWERSAVESLEEP 11 ++#define IEEE80211_IOC_RTSTHRESHOLD 12 ++#define IEEE80211_IOC_PROTMODE 13 ++#define IEEE80211_PROTMODE_OFF 0 ++#define IEEE80211_PROTMODE_CTS 1 ++#define IEEE80211_PROTMODE_RTSCTS 2 ++#define IEEE80211_IOC_TXPOWER 14 /* global tx power limit */ ++#define IEEE80211_IOC_BSSID 15 ++#define IEEE80211_IOC_ROAMING 16 /* roaming mode */ ++#define IEEE80211_IOC_PRIVACY 17 /* privacy invoked */ ++#define IEEE80211_IOC_DROPUNENCRYPTED 18 /* discard unencrypted frames */ ++#define IEEE80211_IOC_WPAKEY 19 ++#define IEEE80211_IOC_DELKEY 20 ++#define IEEE80211_IOC_MLME 21 ++#define IEEE80211_IOC_OPTIE 22 /* optional info. element */ ++#define IEEE80211_IOC_SCAN_REQ 23 ++#define IEEE80211_IOC_SCAN_RESULTS 24 ++#define IEEE80211_IOC_COUNTERMEASURES 25 /* WPA/TKIP countermeasures */ ++#define IEEE80211_IOC_WPA 26 /* WPA mode (0,1,2) */ ++#define IEEE80211_IOC_CHANLIST 27 /* channel list */ ++#define IEEE80211_IOC_WME 28 /* WME mode (on, off) */ ++#define IEEE80211_IOC_HIDESSID 29 /* hide SSID mode (on, off) */ ++#define IEEE80211_IOC_APBRIDGE 30 /* AP inter-sta bridging */ ++#define IEEE80211_IOC_MCASTCIPHER 31 /* multicast/default cipher */ ++#define IEEE80211_IOC_MCASTKEYLEN 32 /* multicast key length */ ++#define IEEE80211_IOC_UCASTCIPHERS 33 /* unicast cipher suites */ ++#define IEEE80211_IOC_UCASTCIPHER 34 /* unicast cipher */ ++#define IEEE80211_IOC_UCASTKEYLEN 35 /* unicast key length */ ++#define IEEE80211_IOC_DRIVER_CAPS 36 /* driver capabilities */ ++#define IEEE80211_IOC_KEYMGTALGS 37 /* key management algorithms */ ++#define IEEE80211_IOC_RSNCAPS 38 /* RSN capabilities */ ++#define IEEE80211_IOC_WPAIE 39 /* WPA information element */ ++#define IEEE80211_IOC_STA_STATS 40 /* per-station statistics */ ++#define IEEE80211_IOC_MACCMD 41 /* MAC ACL operation */ ++#define IEEE80211_IOC_TXPOWMAX 43 /* max tx power for channel */ ++#define IEEE80211_IOC_STA_TXPOW 44 /* per-station tx power limit */ ++#define IEEE80211_IOC_STA_INFO 45 /* station/neighbor info */ ++#define IEEE80211_IOC_WME_CWMIN 46 /* WME: ECWmin */ ++#define IEEE80211_IOC_WME_CWMAX 47 /* WME: ECWmax */ ++#define IEEE80211_IOC_WME_AIFS 48 /* WME: AIFSN */ ++#define IEEE80211_IOC_WME_TXOPLIMIT 49 /* WME: txops limit */ ++#define IEEE80211_IOC_WME_ACM 50 /* WME: ACM (bss only) */ ++#define IEEE80211_IOC_WME_ACKPOLICY 51 /* WME: ACK policy (!bss only)*/ ++#define IEEE80211_IOC_DTIM_PERIOD 52 /* DTIM period (beacons) */ ++#define IEEE80211_IOC_BEACON_INTERVAL 53 /* beacon interval (ms) */ ++#define IEEE80211_IOC_ADDMAC 54 /* add sta to MAC ACL table */ ++#define IEEE80211_IOC_DELMAC 55 /* del sta from MAC ACL table */ ++#define IEEE80211_IOC_FF 56 /* ATH fast frames (on, off) */ ++#define IEEE80211_IOC_TURBOP 57 /* ATH turbo' (on, off) */ ++ ++/* ++ * Scan result data returned for IEEE80211_IOC_SCAN_RESULTS. ++ */ ++struct ieee80211req_scan_result { ++ u_int16_t isr_len; /* length (mult of 4) */ ++ u_int16_t isr_freq; /* MHz */ ++ u_int16_t isr_flags; /* channel flags */ ++ u_int8_t isr_noise; ++ u_int8_t isr_rssi; ++ u_int8_t isr_intval; /* beacon interval */ ++ u_int16_t isr_capinfo; /* capabilities */ ++ u_int8_t isr_erp; /* ERP element */ ++ u_int8_t isr_bssid[IEEE80211_ADDR_LEN]; ++ u_int8_t isr_nrates; ++ u_int8_t isr_rates[IEEE80211_RATE_MAXSIZE]; ++ u_int8_t isr_ssid_len; /* SSID length */ ++ u_int8_t isr_ie_len; /* IE length */ ++ u_int8_t isr_pad[5]; ++ /* variable length SSID followed by IE data */ ++}; ++ ++#endif /* __FreeBSD__ */ ++ ++#ifdef __linux__ ++/* ++ * Wireless Extensions API, private ioctl interfaces. ++ * ++ * NB: Even-numbered ioctl numbers have set semantics and are privileged! ++ * (regardless of the incorrect comment in wireless.h!) ++ */ ++#ifdef __KERNEL__ ++#include ++#endif ++#define IEEE80211_IOCTL_SETPARAM (SIOCIWFIRSTPRIV+0) ++#define IEEE80211_IOCTL_GETPARAM (SIOCIWFIRSTPRIV+1) ++#define IEEE80211_IOCTL_SETMODE (SIOCIWFIRSTPRIV+2) ++#define IEEE80211_IOCTL_GETMODE (SIOCIWFIRSTPRIV+3) ++#define IEEE80211_IOCTL_SETWMMPARAMS (SIOCIWFIRSTPRIV+4) ++#define IEEE80211_IOCTL_GETWMMPARAMS (SIOCIWFIRSTPRIV+5) ++#define IEEE80211_IOCTL_SETCHANLIST (SIOCIWFIRSTPRIV+6) ++#define IEEE80211_IOCTL_GETCHANLIST (SIOCIWFIRSTPRIV+7) ++#define IEEE80211_IOCTL_CHANSWITCH (SIOCIWFIRSTPRIV+8) ++#define IEEE80211_IOCTL_GETCHANINFO (SIOCIWFIRSTPRIV+13) ++#define IEEE80211_IOCTL_SETOPTIE (SIOCIWFIRSTPRIV+14) ++#define IEEE80211_IOCTL_GETOPTIE (SIOCIWFIRSTPRIV+15) ++#define IEEE80211_IOCTL_SETMLME (SIOCIWFIRSTPRIV+16) ++#define IEEE80211_IOCTL_SETKEY (SIOCIWFIRSTPRIV+18) ++#define IEEE80211_IOCTL_DELKEY (SIOCIWFIRSTPRIV+20) ++#define IEEE80211_IOCTL_ADDMAC (SIOCIWFIRSTPRIV+22) ++#define IEEE80211_IOCTL_DELMAC (SIOCIWFIRSTPRIV+24) ++#define IEEE80211_IOCTL_WDSADDMAC (SIOCIWFIRSTPRIV+26) ++#define IEEE80211_IOCTL_WDSDELMAC (SIOCIWFIRSTPRIV+28) ++#define IEEE80211_IOCTL_KICKMAC (SIOCIWFIRSTPRIV+30) ++enum { ++ IEEE80211_WMMPARAMS_CWMIN = 1, ++ IEEE80211_WMMPARAMS_CWMAX = 2, ++ IEEE80211_WMMPARAMS_AIFS = 3, ++ IEEE80211_WMMPARAMS_TXOPLIMIT = 4, ++ IEEE80211_WMMPARAMS_ACM = 5, ++ IEEE80211_WMMPARAMS_NOACKPOLICY = 6, ++}; ++enum { ++ IEEE80211_PARAM_TURBO = 1, /* turbo mode */ ++ IEEE80211_PARAM_MODE = 2, /* phy mode (11a, 11b, etc.) */ ++ IEEE80211_PARAM_AUTHMODE = 3, /* authentication mode */ ++ IEEE80211_PARAM_PROTMODE = 4, /* 802.11g protection */ ++ IEEE80211_PARAM_MCASTCIPHER = 5, /* multicast/default cipher */ ++ IEEE80211_PARAM_MCASTKEYLEN = 6, /* multicast key length */ ++ IEEE80211_PARAM_UCASTCIPHERS = 7, /* unicast cipher suites */ ++ IEEE80211_PARAM_UCASTCIPHER = 8, /* unicast cipher */ ++ IEEE80211_PARAM_UCASTKEYLEN = 9, /* unicast key length */ ++ IEEE80211_PARAM_WPA = 10, /* WPA mode (0,1,2) */ ++ IEEE80211_PARAM_ROAMING = 12, /* roaming mode */ ++ IEEE80211_PARAM_PRIVACY = 13, /* privacy invoked */ ++ IEEE80211_PARAM_COUNTERMEASURES = 14, /* WPA/TKIP countermeasures */ ++ IEEE80211_PARAM_DROPUNENCRYPTED = 15, /* discard unencrypted frames */ ++ IEEE80211_PARAM_DRIVER_CAPS = 16, /* driver capabilities */ ++ IEEE80211_PARAM_MACCMD = 17, /* MAC ACL operation */ ++ IEEE80211_PARAM_WMM = 18, /* WMM mode (on, off) */ ++ IEEE80211_PARAM_HIDESSID = 19, /* hide SSID mode (on, off) */ ++ IEEE80211_PARAM_APBRIDGE = 20, /* AP inter-sta bridging */ ++ IEEE80211_PARAM_KEYMGTALGS = 21, /* key management algorithms */ ++ IEEE80211_PARAM_RSNCAPS = 22, /* RSN capabilities */ ++ IEEE80211_PARAM_INACT = 23, /* station inactivity timeout */ ++ IEEE80211_PARAM_INACT_AUTH = 24, /* station auth inact timeout */ ++ IEEE80211_PARAM_INACT_INIT = 25, /* station init inact timeout */ ++ IEEE80211_PARAM_ABOLT = 26, /* Atheros Adv. Capabilities */ ++ IEEE80211_PARAM_DTIM_PERIOD = 28, /* DTIM period (beacons) */ ++ IEEE80211_PARAM_BEACON_INTERVAL = 29, /* beacon interval (ms) */ ++ IEEE80211_PARAM_DOTH = 30, /* 11.h is on/off */ ++ IEEE80211_PARAM_PWRTARGET = 31, /* Current Channel Pwr Constraint */ ++ IEEE80211_PARAM_GENREASSOC = 32, /* Generate a reassociation request */ ++ IEEE80211_PARAM_COMPRESSION = 33, /* compression */ ++ IEEE80211_PARAM_FF = 34, /* fast frames support */ ++ IEEE80211_PARAM_XR = 35, /* XR support */ ++ IEEE80211_PARAM_BURST = 36, /* burst mode */ ++ IEEE80211_PARAM_PUREG = 37, /* pure 11g (no 11b stations) */ ++ IEEE80211_PARAM_AR = 38, /* AR support */ ++ IEEE80211_PARAM_WDS = 39, /* Enable 4 address processing */ ++ IEEE80211_PARAM_BGSCAN = 40, /* bg scanning (on, off) */ ++ IEEE80211_PARAM_BGSCAN_IDLE = 41, /* bg scan idle threshold */ ++ IEEE80211_PARAM_BGSCAN_INTERVAL = 42, /* bg scan interval */ ++ IEEE80211_PARAM_MCAST_RATE = 43, /* Multicast Tx Rate */ ++ IEEE80211_PARAM_COVERAGE_CLASS = 44, /* coverage class */ ++ IEEE80211_PARAM_COUNTRY_IE = 45, /* enable country IE */ ++ IEEE80211_PARAM_SCANVALID = 46, /* scan cache valid threshold */ ++ IEEE80211_PARAM_ROAM_RSSI_11A = 47, /* rssi threshold in 11a */ ++ IEEE80211_PARAM_ROAM_RSSI_11B = 48, /* rssi threshold in 11b */ ++ IEEE80211_PARAM_ROAM_RSSI_11G = 49, /* rssi threshold in 11g */ ++ IEEE80211_PARAM_ROAM_RATE_11A = 50, /* tx rate threshold in 11a */ ++ IEEE80211_PARAM_ROAM_RATE_11B = 51, /* tx rate threshold in 11b */ ++ IEEE80211_PARAM_ROAM_RATE_11G = 52, /* tx rate threshold in 11g */ ++ IEEE80211_PARAM_UAPSDINFO = 53, /* value for qos info field */ ++ IEEE80211_PARAM_SLEEP = 54, /* force sleep/wake */ ++ IEEE80211_PARAM_QOSNULL = 55, /* force sleep/wake */ ++ IEEE80211_PARAM_PSPOLL = 56, /* force ps-poll generation (sta only) */ ++ IEEE80211_PARAM_EOSPDROP = 57, /* force uapsd EOSP drop (ap only) */ ++ IEEE80211_PARAM_MARKDFS = 58, /* mark a dfs interference channel when found */ ++ IEEE80211_PARAM_REGCLASS = 59, /* enable regclass ids in country IE */ ++}; ++ ++#define SIOCG80211STATS (SIOCDEVPRIVATE+2) ++/* NB: require in+out parameters so cannot use wireless extensions, yech */ ++#define IEEE80211_IOCTL_GETKEY (SIOCDEVPRIVATE+3) ++#define IEEE80211_IOCTL_GETWPAIE (SIOCDEVPRIVATE+4) ++#define IEEE80211_IOCTL_STA_STATS (SIOCDEVPRIVATE+5) ++#define IEEE80211_IOCTL_STA_INFO (SIOCDEVPRIVATE+6) ++#define SIOC80211IFCREATE (SIOCDEVPRIVATE+7) ++#define SIOC80211IFDESTROY (SIOCDEVPRIVATE+8) ++#define IEEE80211_IOCTL_SCAN_RESULTS (SIOCDEVPRIVATE+9) ++ ++struct ieee80211_clone_params { ++ char icp_name[IFNAMSIZ]; /* device name */ ++ u_int16_t icp_opmode; /* operating mode */ ++ u_int16_t icp_flags; /* see below */ ++#define IEEE80211_CLONE_BSSID 0x0001 /* allocate unique mac/bssid */ ++#define IEEE80211_NO_STABEACONS 0x0002 /* Do not setup the station beacon timers */ ++}; ++ ++#endif /* __linux__ */ ++ ++#endif /* _NET80211_IEEE80211_IOCTL_H_ */ +diff -urNw wpasupplicant-0.4.8.orig/driver_madwifi_ng.c wpasupplicant-0.4.8/driver_madwifi_ng.c +--- wpasupplicant-0.4.8.orig/driver_madwifi_ng.c 1970-01-01 01:00:00.000000000 +0100 ++++ wpasupplicant-0.4.8/driver_madwifi_ng.c 2006-05-31 11:41:11.350293183 +0200 +@@ -0,0 +1,529 @@ ++/* ++ * WPA Supplicant - driver interaction with MADWIFI 802.11 driver ++ * Copyright (c) 2004, Sam Leffler ++ * Copyright (c) 2004-2005, Jouni Malinen ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * Alternatively, this software may be distributed under the terms of BSD ++ * license. ++ * ++ * See README and COPYING for more details. ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include "common.h" ++#include "driver.h" ++#include "driver_wext.h" ++#include "eloop.h" ++#include "wpa_supplicant.h" ++#include "wpa.h" ++#include "wireless_copy.h" ++ ++#include ++#include ++#ifdef WME_NUM_AC ++/* Assume this is built against BSD branch of madwifi driver. */ ++#define MADWIFI_BSD ++#include ++#endif /* WME_NUM_AC */ ++#include ++#include ++ ++#ifdef IEEE80211_IOCTL_SETWMMPARAMS ++/* Assume this is built against madwifi-ng */ ++#define MADWIFI_NG ++#endif /* IEEE80211_IOCTL_SETWMMPARAMS */ ++ ++struct wpa_driver_madwifi_data { ++ void *wext; /* private data for driver_wext */ ++ void *ctx; ++ char ifname[IFNAMSIZ + 1]; ++ int sock; ++}; ++ ++static int ++set80211priv(struct wpa_driver_madwifi_data *drv, int op, void *data, int len, ++ int show_err) ++{ ++ struct iwreq iwr; ++ ++ memset(&iwr, 0, sizeof(iwr)); ++ strncpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); ++ if (len < IFNAMSIZ) { ++ /* ++ * Argument data fits inline; put it there. ++ */ ++ memcpy(iwr.u.name, data, len); ++ } else { ++ /* ++ * Argument data too big for inline transfer; setup a ++ * parameter block instead; the kernel will transfer ++ * the data for the driver. ++ */ ++ iwr.u.data.pointer = data; ++ iwr.u.data.length = len; ++ } ++ ++ if (ioctl(drv->sock, op, &iwr) < 0) { ++ if (show_err) { ++#ifdef MADWIFI_NG ++ int first = IEEE80211_IOCTL_SETPARAM; ++ int last = IEEE80211_IOCTL_GETMODE; ++ static const char *opnames[] = { ++ "ioctl[IEEE80211_IOCTL_SETPARAM]", ++ "ioctl[IEEE80211_IOCTL_GETPARAM]", ++ "ioctl[IEEE80211_IOCTL_SETKEY]", ++ "ioctl[IEEE80211_IOCTL_SETWMMPARAMS]", ++ "ioctl[IEEE80211_IOCTL_DELKEY]", ++ "ioctl[IEEE80211_IOCTL_GETWMMPARAMS]", ++ "ioctl[IEEE80211_IOCTL_SETMLME]", ++ "ioctl[IEEE80211_IOCTL_GETCHANINFO]", ++ "ioctl[IEEE80211_IOCTL_SETOPTIE]", ++ "ioctl[IEEE80211_IOCTL_GETOPTIE]", ++ "ioctl[IEEE80211_IOCTL_ADDMAC]", ++ NULL, ++ "ioctl[IEEE80211_IOCTL_DELMAC]", ++ "ioctl[IEEE80211_IOCTL_GETCHANLIST]", ++ "ioctl[IEEE80211_IOCTL_SETCHANLIST]", ++ NULL, ++ "ioctl[IEEE80211_IOCTL_SETMODE]", ++ "ioctl[IEEE80211_IOCTL_GETMODE]", ++ }; ++#else /* MADWIFI_NG */ ++ int first = IEEE80211_IOCTL_SETPARAM; ++ int last = IEEE80211_IOCTL_CHANLIST; ++ static const char *opnames[] = { ++ "ioctl[IEEE80211_IOCTL_SETPARAM]", ++ "ioctl[IEEE80211_IOCTL_GETPARAM]", ++ "ioctl[IEEE80211_IOCTL_SETKEY]", ++ "ioctl[IEEE80211_IOCTL_GETKEY]", ++ "ioctl[IEEE80211_IOCTL_DELKEY]", ++ NULL, ++ "ioctl[IEEE80211_IOCTL_SETMLME]", ++ NULL, ++ "ioctl[IEEE80211_IOCTL_SETOPTIE]", ++ "ioctl[IEEE80211_IOCTL_GETOPTIE]", ++ "ioctl[IEEE80211_IOCTL_ADDMAC]", ++ NULL, ++ "ioctl[IEEE80211_IOCTL_DELMAC]", ++ NULL, ++ "ioctl[IEEE80211_IOCTL_CHANLIST]", ++ }; ++#endif /* MADWIFI_NG */ ++ if (first <= op && op <= last) ++ perror(opnames[op - first]); ++ else ++ perror("ioctl[unknown???]"); ++ } ++ return -1; ++ } ++ return 0; ++} ++ ++static int ++set80211param(struct wpa_driver_madwifi_data *drv, int op, int arg, ++ int show_err) ++{ ++ struct iwreq iwr; ++ ++ memset(&iwr, 0, sizeof(iwr)); ++ strncpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); ++ iwr.u.mode = op; ++ memcpy(iwr.u.name+sizeof(__u32), &arg, sizeof(arg)); ++ ++ if (ioctl(drv->sock, IEEE80211_IOCTL_SETPARAM, &iwr) < 0) { ++ if (show_err) ++ perror("ioctl[IEEE80211_IOCTL_SETPARAM]"); ++ return -1; ++ } ++ return 0; ++} ++ ++static int ++wpa_driver_madwifi_set_wpa_ie(struct wpa_driver_madwifi_data *drv, ++ const u8 *wpa_ie, size_t wpa_ie_len) ++{ ++ struct iwreq iwr; ++ ++ memset(&iwr, 0, sizeof(iwr)); ++ strncpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); ++ /* NB: SETOPTIE is not fixed-size so must not be inlined */ ++ iwr.u.data.pointer = (void *) wpa_ie; ++ iwr.u.data.length = wpa_ie_len; ++ ++ if (ioctl(drv->sock, IEEE80211_IOCTL_SETOPTIE, &iwr) < 0) { ++ perror("ioctl[IEEE80211_IOCTL_SETOPTIE]"); ++ return -1; ++ } ++ return 0; ++} ++ ++static int ++wpa_driver_madwifi_del_key(struct wpa_driver_madwifi_data *drv, int key_idx, ++ const u8 *addr) ++{ ++ struct ieee80211req_del_key wk; ++ ++ wpa_printf(MSG_DEBUG, "%s: keyidx=%d", __FUNCTION__, key_idx); ++ memset(&wk, 0, sizeof(wk)); ++ wk.idk_keyix = key_idx; ++ if (addr != NULL) ++ memcpy(wk.idk_macaddr, addr, IEEE80211_ADDR_LEN); ++ ++ return set80211priv(drv, IEEE80211_IOCTL_DELKEY, &wk, sizeof(wk), 1); ++} ++ ++static int ++wpa_driver_madwifi_set_key(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) ++{ ++ struct wpa_driver_madwifi_data *drv = priv; ++ struct ieee80211req_key wk; ++ char *alg_name; ++ u_int8_t cipher; ++ ++ if (alg == WPA_ALG_NONE) ++ return wpa_driver_madwifi_del_key(drv, key_idx, addr); ++ ++ switch (alg) { ++ case WPA_ALG_WEP: ++ if (addr == NULL || memcmp(addr, "\xff\xff\xff\xff\xff\xff", ++ ETH_ALEN) == 0) { ++ /* ++ * madwifi did not seem to like static WEP key ++ * configuration with IEEE80211_IOCTL_SETKEY, so use ++ * Linux wireless extensions ioctl for this. ++ */ ++ return wpa_driver_wext_set_key(drv->wext, alg, addr, ++ key_idx, set_tx, ++ seq, seq_len, ++ key, key_len); ++ } ++ alg_name = "WEP"; ++ cipher = IEEE80211_CIPHER_WEP; ++ break; ++ case WPA_ALG_TKIP: ++ alg_name = "TKIP"; ++ cipher = IEEE80211_CIPHER_TKIP; ++ break; ++ case WPA_ALG_CCMP: ++ alg_name = "CCMP"; ++ cipher = IEEE80211_CIPHER_AES_CCM; ++ break; ++ default: ++ wpa_printf(MSG_DEBUG, "%s: unknown/unsupported algorithm %d", ++ __FUNCTION__, alg); ++ return -1; ++ } ++ ++ wpa_printf(MSG_DEBUG, "%s: alg=%s key_idx=%d set_tx=%d seq_len=%lu " ++ "key_len=%lu", __FUNCTION__, alg_name, key_idx, set_tx, ++ (unsigned long) seq_len, (unsigned long) key_len); ++ ++ if (seq_len > sizeof(u_int64_t)) { ++ wpa_printf(MSG_DEBUG, "%s: seq_len %lu too big", ++ __FUNCTION__, (unsigned long) seq_len); ++ return -2; ++ } ++ if (key_len > sizeof(wk.ik_keydata)) { ++ wpa_printf(MSG_DEBUG, "%s: key length %lu too big", ++ __FUNCTION__, (unsigned long) key_len); ++ return -3; ++ } ++ ++ memset(&wk, 0, sizeof(wk)); ++ wk.ik_type = cipher; ++ wk.ik_flags = IEEE80211_KEY_RECV; ++ if (addr == NULL || ++ memcmp(addr, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) == 0) ++ wk.ik_flags |= IEEE80211_KEY_GROUP; ++ if (set_tx) { ++ wk.ik_flags |= IEEE80211_KEY_XMIT | IEEE80211_KEY_DEFAULT; ++ memcpy(wk.ik_macaddr, addr, IEEE80211_ADDR_LEN); ++ } else ++ memset(wk.ik_macaddr, 0, IEEE80211_ADDR_LEN); ++ wk.ik_keyix = key_idx; ++ wk.ik_keylen = key_len; ++ memcpy(&wk.ik_keyrsc, seq, seq_len); ++ memcpy(wk.ik_keydata, key, key_len); ++ ++ return set80211priv(drv, IEEE80211_IOCTL_SETKEY, &wk, sizeof(wk), 1); ++} ++ ++static int ++wpa_driver_madwifi_set_countermeasures(void *priv, int enabled) ++{ ++ struct wpa_driver_madwifi_data *drv = priv; ++ wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled); ++ return set80211param(drv, IEEE80211_PARAM_COUNTERMEASURES, enabled, 1); ++} ++ ++ ++static int ++wpa_driver_madwifi_set_drop_unencrypted(void *priv, int enabled) ++{ ++ struct wpa_driver_madwifi_data *drv = priv; ++ wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled); ++ return set80211param(drv, IEEE80211_PARAM_DROPUNENCRYPTED, enabled, 1); ++} ++ ++static int ++wpa_driver_madwifi_deauthenticate(void *priv, const u8 *addr, int reason_code) ++{ ++ struct wpa_driver_madwifi_data *drv = priv; ++ struct ieee80211req_mlme mlme; ++ ++ wpa_printf(MSG_DEBUG, "%s", __FUNCTION__); ++ mlme.im_op = IEEE80211_MLME_DEAUTH; ++ mlme.im_reason = reason_code; ++ memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN); ++ return set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme), 1); ++} ++ ++static int ++wpa_driver_madwifi_disassociate(void *priv, const u8 *addr, int reason_code) ++{ ++ struct wpa_driver_madwifi_data *drv = priv; ++ struct ieee80211req_mlme mlme; ++ ++ wpa_printf(MSG_DEBUG, "%s", __FUNCTION__); ++ mlme.im_op = IEEE80211_MLME_DISASSOC; ++ mlme.im_reason = reason_code; ++ memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN); ++ return set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme), 1); ++} ++ ++static int ++wpa_driver_madwifi_associate(void *priv, ++ struct wpa_driver_associate_params *params) ++{ ++ struct wpa_driver_madwifi_data *drv = priv; ++ struct ieee80211req_mlme mlme; ++ int ret = 0, privacy = 1; ++ ++ wpa_printf(MSG_DEBUG, "%s", __FUNCTION__); ++ ++ /* ++ * NB: Don't need to set the freq or cipher-related state as ++ * this is implied by the bssid which is used to locate ++ * the scanned node state which holds it. The ssid is ++ * needed to disambiguate an AP that broadcasts multiple ++ * ssid's but uses the same bssid. ++ */ ++ /* XXX error handling is wrong but unclear what to do... */ ++ if (wpa_driver_madwifi_set_wpa_ie(drv, params->wpa_ie, ++ params->wpa_ie_len) < 0) ++ ret = -1; ++ ++ if (params->pairwise_suite == CIPHER_NONE && ++ params->group_suite == CIPHER_NONE && ++ params->key_mgmt_suite == KEY_MGMT_NONE && ++ params->wpa_ie_len == 0) ++ privacy = 0; ++ ++ if (set80211param(drv, IEEE80211_PARAM_PRIVACY, privacy, 1) < 0) ++ ret = -1; ++ ++ if (params->wpa_ie_len && ++ set80211param(drv, IEEE80211_PARAM_WPA, ++ params->wpa_ie[0] == RSN_INFO_ELEM ? 2 : 1, 1) < 0) ++ ret = -1; ++ ++ if (params->bssid == NULL) { ++ /* ap_scan=2 mode - driver takes care of AP selection and ++ * roaming */ ++ /* FIX: this does not seem to work; would probably need to ++ * change something in the driver */ ++ if (set80211param(drv, IEEE80211_PARAM_ROAMING, 0, 1) < 0) ++ ret = -1; ++ } ++ ++ if (wpa_driver_wext_set_ssid(drv->wext, params->ssid, ++ params->ssid_len) < 0) ++ ret = -1; ++ if (params->bssid) { ++ if (set80211param(drv, IEEE80211_PARAM_ROAMING, 2, 1) < 0) ++ ret = -1; ++ memset(&mlme, 0, sizeof(mlme)); ++ mlme.im_op = IEEE80211_MLME_ASSOC; ++ memcpy(mlme.im_macaddr, params->bssid, IEEE80211_ADDR_LEN); ++ if (set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme, ++ sizeof(mlme), 1) < 0) ++ ret = -1; ++ } ++ ++ return ret; ++} ++ ++static int ++wpa_driver_madwifi_set_auth_alg(void *priv, int auth_alg) ++{ ++ struct wpa_driver_madwifi_data *drv = priv; ++ int authmode; ++ ++ if ((auth_alg & AUTH_ALG_OPEN_SYSTEM) && ++ (auth_alg & AUTH_ALG_SHARED_KEY)) ++ authmode = IEEE80211_AUTH_AUTO; ++ else if (auth_alg & AUTH_ALG_SHARED_KEY) ++ authmode = IEEE80211_AUTH_SHARED; ++ else ++ authmode = IEEE80211_AUTH_OPEN; ++ ++ return set80211param(drv, IEEE80211_PARAM_AUTHMODE, authmode, 1); ++} ++ ++static int ++wpa_driver_madwifi_scan(void *priv, const u8 *ssid, size_t ssid_len) ++{ ++ struct wpa_driver_madwifi_data *drv = priv; ++ struct iwreq iwr; ++ int ret = 0; ++ ++ memset(&iwr, 0, sizeof(iwr)); ++ strncpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); ++ ++ /* set desired ssid before scan */ ++ /* FIX: scan should not break the current association, so using ++ * set_ssid may not be the best way of doing this.. */ ++ if (wpa_driver_wext_set_ssid(drv->wext, ssid, ssid_len) < 0) ++ ret = -1; ++ ++ if (ioctl(drv->sock, SIOCSIWSCAN, &iwr) < 0) { ++ perror("ioctl[SIOCSIWSCAN]"); ++ ret = -1; ++ } ++ ++ /* ++ * madwifi delivers a scan complete event so no need to poll, but ++ * register a backup timeout anyway to make sure that we recover even ++ * if the driver does not send this event for any reason. This timeout ++ * will only be used if the event is not delivered (event handler will ++ * cancel the timeout). ++ */ ++ eloop_register_timeout(30, 0, wpa_driver_wext_scan_timeout, drv->wext, ++ drv->ctx); ++ ++ return ret; ++} ++ ++static int wpa_driver_madwifi_get_bssid(void *priv, u8 *bssid) ++{ ++ struct wpa_driver_madwifi_data *drv = priv; ++ return wpa_driver_wext_get_bssid(drv->wext, bssid); ++} ++ ++ ++static int wpa_driver_madwifi_get_ssid(void *priv, u8 *ssid) ++{ ++ struct wpa_driver_madwifi_data *drv = priv; ++ return wpa_driver_wext_get_ssid(drv->wext, ssid); ++} ++ ++ ++static int wpa_driver_madwifi_get_scan_results(void *priv, ++ struct wpa_scan_result *results, ++ size_t max_size) ++{ ++ struct wpa_driver_madwifi_data *drv = priv; ++ return wpa_driver_wext_get_scan_results(drv->wext, results, max_size); ++} ++ ++ ++static void * wpa_driver_madwifi_init(void *ctx, const char *ifname) ++{ ++ struct wpa_driver_madwifi_data *drv; ++ ++ drv = malloc(sizeof(*drv)); ++ if (drv == NULL) ++ return NULL; ++ memset(drv, 0, sizeof(*drv)); ++ drv->wext = wpa_driver_wext_init(ctx, ifname); ++ if (drv->wext == NULL) ++ goto fail; ++ ++ drv->ctx = ctx; ++ strncpy(drv->ifname, ifname, sizeof(drv->ifname)); ++ drv->sock = socket(PF_INET, SOCK_DGRAM, 0); ++ if (drv->sock < 0) ++ goto fail2; ++ ++ if (set80211param(drv, IEEE80211_PARAM_ROAMING, 2, 1) < 0) { ++ wpa_printf(MSG_DEBUG, "%s: failed to set wpa_supplicant-based " ++ "roaming", __FUNCTION__); ++ goto fail3; ++ } ++ ++ if (set80211param(drv, IEEE80211_PARAM_WPA, 3, 1) < 0) { ++ wpa_printf(MSG_DEBUG, "%s: failed to enable WPA support", ++ __FUNCTION__); ++ goto fail3; ++ } ++ ++ return drv; ++ ++fail3: ++ close(drv->sock); ++fail2: ++ wpa_driver_wext_deinit(drv->wext); ++fail: ++ free(drv); ++ return NULL; ++} ++ ++ ++static void wpa_driver_madwifi_deinit(void *priv) ++{ ++ struct wpa_driver_madwifi_data *drv = priv; ++ ++ if (wpa_driver_madwifi_set_wpa_ie(drv, NULL, 0) < 0) { ++ wpa_printf(MSG_DEBUG, "%s: failed to clear WPA IE", ++ __FUNCTION__); ++ } ++ if (set80211param(drv, IEEE80211_PARAM_ROAMING, 0, 1) < 0) { ++ wpa_printf(MSG_DEBUG, "%s: failed to enable driver-based " ++ "roaming", __FUNCTION__); ++ } ++ if (set80211param(drv, IEEE80211_PARAM_PRIVACY, 0, 1) < 0) { ++ wpa_printf(MSG_DEBUG, "%s: failed to disable forced Privacy " ++ "flag", __FUNCTION__); ++ } ++ if (set80211param(drv, IEEE80211_PARAM_WPA, 0, 1) < 0) { ++ wpa_printf(MSG_DEBUG, "%s: failed to disable WPA", ++ __FUNCTION__); ++ } ++ ++ wpa_driver_wext_deinit(drv->wext); ++ ++ close(drv->sock); ++ free(drv); ++} ++ ++ ++const struct wpa_driver_ops wpa_driver_madwifi_ng_ops = { ++ .name = "madwifi-ng", ++ .desc = "MADWIFI(-NG) 802.11 support (Atheros, etc.)", ++ .get_bssid = wpa_driver_madwifi_get_bssid, ++ .get_ssid = wpa_driver_madwifi_get_ssid, ++ .set_key = wpa_driver_madwifi_set_key, ++ .init = wpa_driver_madwifi_init, ++ .deinit = wpa_driver_madwifi_deinit, ++ .set_countermeasures = wpa_driver_madwifi_set_countermeasures, ++ .set_drop_unencrypted = wpa_driver_madwifi_set_drop_unencrypted, ++ .scan = wpa_driver_madwifi_scan, ++ .get_scan_results = wpa_driver_madwifi_get_scan_results, ++ .deauthenticate = wpa_driver_madwifi_deauthenticate, ++ .disassociate = wpa_driver_madwifi_disassociate, ++ .associate = wpa_driver_madwifi_associate, ++ .set_auth_alg = wpa_driver_madwifi_set_auth_alg, ++}; +diff -urNw wpasupplicant-0.4.8.orig/drivers.c wpasupplicant-0.4.8/drivers.c +--- wpasupplicant-0.4.8.orig/drivers.c 2006-05-31 11:40:30.976366646 +0200 ++++ wpasupplicant-0.4.8/drivers.c 2006-05-31 11:41:11.351292834 +0200 +@@ -27,6 +27,9 @@ + #ifdef CONFIG_DRIVER_MADWIFI + extern struct wpa_driver_ops wpa_driver_madwifi_ops; /* driver_madwifi.c */ + #endif /* CONFIG_DRIVER_MADWIFI */ ++#ifdef CONFIG_DRIVER_MADWIFI_NG ++extern struct wpa_driver_ops wpa_driver_madwifi_ng_ops; /* driver_madwifi_ng.c */ ++#endif /* CONFIG_DRIVER_MADWIFI_NG */ + #ifdef CONFIG_DRIVER_ATMEL + extern struct wpa_driver_ops wpa_driver_atmel_ops; /* driver_atmel.c */ + #endif /* CONFIG_DRIVER_ATMEL */ +@@ -71,6 +74,9 @@ + #ifdef CONFIG_DRIVER_MADWIFI + &wpa_driver_madwifi_ops, + #endif /* CONFIG_DRIVER_MADWIFI */ ++#ifdef CONFIG_DRIVER_MADWIFI_NG ++ &wpa_driver_madwifi_ng_ops, ++#endif /* CONFIG_DRIVER_MADWIFI_NG */ + #ifdef CONFIG_DRIVER_ATMEL + &wpa_driver_atmel_ops, + #endif /* CONFIG_DRIVER_ATMEL */ +diff -urNw wpasupplicant-0.4.8.orig/Makefile wpasupplicant-0.4.8/Makefile +--- wpasupplicant-0.4.8.orig/Makefile 2006-05-31 11:40:30.976366646 +0200 ++++ wpasupplicant-0.4.8/Makefile 2006-05-31 11:41:11.352292486 +0200 +@@ -82,6 +82,16 @@ + ifdef CONFIG_DRIVER_MADWIFI + CFLAGS += -DCONFIG_DRIVER_MADWIFI + OBJS_d += driver_madwifi.o ++driver_madwifi.o: driver_madwifi.c ++ $(CC) -c $(MADWIFI_CFLAGS) $(CPPFLAGS) $(CFLAGS) $< ++CONFIG_WIRELESS_EXTENSION=y ++endif ++ ++ifdef CONFIG_DRIVER_MADWIFI_NG ++CFLAGS += -DCONFIG_DRIVER_MADWIFI_NG ++OBJS_d += driver_madwifi_ng.o ++driver_madwifi_ng.o: driver_madwifi_ng.c ++ $(CC) -c $(MADWIFI_NG_CFLAGS) $(CPPFLAGS) $(CFLAGS) $< + CONFIG_WIRELESS_EXTENSION=y + endif +