2 * WPA Supplicant - driver interaction with MADWIFI 802.11 driver
3 * Copyright (c) 2004, Sam Leffler <sam@errno.com>
4 * Copyright (c) 2004-2005, Jouni Malinen <j@w1.fi>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 * Alternatively, this software may be distributed under the terms of BSD
13 * See README and COPYING for more details.
15 * Please note that madwifi supports WPA configuration via Linux wireless
16 * extensions and if the kernel includes support for this, driver_wext.c should
17 * be used instead of this driver wrapper.
21 #include <sys/ioctl.h>
25 #include "driver_wext.h"
27 #include "ieee802_11_defs.h"
28 #include "wireless_copy.h"
31 * Avoid conflicts with wpa_supplicant definitions by undefining a definition.
35 #include <include/compat.h>
36 #include <net80211/ieee80211.h>
38 /* Assume this is built against BSD branch of madwifi driver. */
40 #include <net80211/_ieee80211.h>
41 #endif /* WME_NUM_AC */
42 #include <net80211/ieee80211_crypto.h>
43 #include <net80211/ieee80211_ioctl.h>
46 #ifdef IEEE80211_IOCTL_SETWMMPARAMS
47 /* Assume this is built against madwifi-ng */
49 #endif /* IEEE80211_IOCTL_SETWMMPARAMS */
51 struct wpa_driver_madwifi_data {
52 void *wext; /* private data for driver_wext */
54 char ifname[IFNAMSIZ + 1];
59 set80211priv(struct wpa_driver_madwifi_data *drv, int op, void *data, int len,
64 os_memset(&iwr, 0, sizeof(iwr));
65 os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
67 op != IEEE80211_IOCTL_SET_APPIEBUF) {
69 * Argument data fits inline; put it there.
71 os_memcpy(iwr.u.name, data, len);
74 * Argument data too big for inline transfer; setup a
75 * parameter block instead; the kernel will transfer
76 * the data for the driver.
78 iwr.u.data.pointer = data;
79 iwr.u.data.length = len;
82 if (ioctl(drv->sock, op, &iwr) < 0) {
85 int first = IEEE80211_IOCTL_SETPARAM;
86 int last = IEEE80211_IOCTL_KICKMAC;
87 static const char *opnames[] = {
88 "ioctl[IEEE80211_IOCTL_SETPARAM]",
89 "ioctl[IEEE80211_IOCTL_GETPARAM]",
90 "ioctl[IEEE80211_IOCTL_SETMODE]",
91 "ioctl[IEEE80211_IOCTL_GETMODE]",
92 "ioctl[IEEE80211_IOCTL_SETWMMPARAMS]",
93 "ioctl[IEEE80211_IOCTL_GETWMMPARAMS]",
94 "ioctl[IEEE80211_IOCTL_SETCHANLIST]",
95 "ioctl[IEEE80211_IOCTL_GETCHANLIST]",
96 "ioctl[IEEE80211_IOCTL_CHANSWITCH]",
98 "ioctl[IEEE80211_IOCTL_SET_APPIEBUF]",
99 "ioctl[IEEE80211_IOCTL_GETSCANRESULTS]",
101 "ioctl[IEEE80211_IOCTL_GETCHANINFO]",
102 "ioctl[IEEE80211_IOCTL_SETOPTIE]",
103 "ioctl[IEEE80211_IOCTL_GETOPTIE]",
104 "ioctl[IEEE80211_IOCTL_SETMLME]",
106 "ioctl[IEEE80211_IOCTL_SETKEY]",
108 "ioctl[IEEE80211_IOCTL_DELKEY]",
110 "ioctl[IEEE80211_IOCTL_ADDMAC]",
112 "ioctl[IEEE80211_IOCTL_DELMAC]",
114 "ioctl[IEEE80211_IOCTL_WDSMAC]",
116 "ioctl[IEEE80211_IOCTL_WDSDELMAC]",
118 "ioctl[IEEE80211_IOCTL_KICKMAC]",
120 #else /* MADWIFI_NG */
121 int first = IEEE80211_IOCTL_SETPARAM;
122 int last = IEEE80211_IOCTL_CHANLIST;
123 static const char *opnames[] = {
124 "ioctl[IEEE80211_IOCTL_SETPARAM]",
125 "ioctl[IEEE80211_IOCTL_GETPARAM]",
126 "ioctl[IEEE80211_IOCTL_SETKEY]",
127 "ioctl[IEEE80211_IOCTL_GETKEY]",
128 "ioctl[IEEE80211_IOCTL_DELKEY]",
130 "ioctl[IEEE80211_IOCTL_SETMLME]",
132 "ioctl[IEEE80211_IOCTL_SETOPTIE]",
133 "ioctl[IEEE80211_IOCTL_GETOPTIE]",
134 "ioctl[IEEE80211_IOCTL_ADDMAC]",
136 "ioctl[IEEE80211_IOCTL_DELMAC]",
138 "ioctl[IEEE80211_IOCTL_CHANLIST]",
140 #endif /* MADWIFI_NG */
141 int idx = op - first;
142 if (first <= op && op <= last &&
143 idx < (int) (sizeof(opnames) / sizeof(opnames[0]))
145 perror(opnames[idx]);
147 perror("ioctl[unknown???]");
155 set80211param(struct wpa_driver_madwifi_data *drv, int op, int arg,
160 os_memset(&iwr, 0, sizeof(iwr));
161 os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
163 os_memcpy(iwr.u.name+sizeof(u32), &arg, sizeof(arg));
165 if (ioctl(drv->sock, IEEE80211_IOCTL_SETPARAM, &iwr) < 0) {
167 perror("ioctl[IEEE80211_IOCTL_SETPARAM]");
174 wpa_driver_madwifi_set_wpa_ie(struct wpa_driver_madwifi_data *drv,
175 const u8 *wpa_ie, size_t wpa_ie_len)
179 os_memset(&iwr, 0, sizeof(iwr));
180 os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
181 /* NB: SETOPTIE is not fixed-size so must not be inlined */
182 iwr.u.data.pointer = (void *) wpa_ie;
183 iwr.u.data.length = wpa_ie_len;
185 if (ioctl(drv->sock, IEEE80211_IOCTL_SETOPTIE, &iwr) < 0) {
186 perror("ioctl[IEEE80211_IOCTL_SETOPTIE]");
193 wpa_driver_madwifi_del_key(struct wpa_driver_madwifi_data *drv, int key_idx,
196 struct ieee80211req_del_key wk;
198 wpa_printf(MSG_DEBUG, "%s: keyidx=%d", __FUNCTION__, key_idx);
199 os_memset(&wk, 0, sizeof(wk));
200 wk.idk_keyix = key_idx;
202 os_memcpy(wk.idk_macaddr, addr, IEEE80211_ADDR_LEN);
204 return set80211priv(drv, IEEE80211_IOCTL_DELKEY, &wk, sizeof(wk), 1);
208 wpa_driver_madwifi_set_key(void *priv, wpa_alg alg,
209 const u8 *addr, int key_idx, int set_tx,
210 const u8 *seq, size_t seq_len,
211 const u8 *key, size_t key_len)
213 struct wpa_driver_madwifi_data *drv = priv;
214 struct ieee80211req_key wk;
218 if (alg == WPA_ALG_NONE)
219 return wpa_driver_madwifi_del_key(drv, key_idx, addr);
223 if (addr == NULL || os_memcmp(addr, "\xff\xff\xff\xff\xff\xff",
226 * madwifi did not seem to like static WEP key
227 * configuration with IEEE80211_IOCTL_SETKEY, so use
228 * Linux wireless extensions ioctl for this.
230 return wpa_driver_wext_set_key(drv->wext, alg, addr,
236 cipher = IEEE80211_CIPHER_WEP;
240 cipher = IEEE80211_CIPHER_TKIP;
244 cipher = IEEE80211_CIPHER_AES_CCM;
247 wpa_printf(MSG_DEBUG, "%s: unknown/unsupported algorithm %d",
252 wpa_printf(MSG_DEBUG, "%s: alg=%s key_idx=%d set_tx=%d seq_len=%lu "
253 "key_len=%lu", __FUNCTION__, alg_name, key_idx, set_tx,
254 (unsigned long) seq_len, (unsigned long) key_len);
256 if (seq_len > sizeof(u_int64_t)) {
257 wpa_printf(MSG_DEBUG, "%s: seq_len %lu too big",
258 __FUNCTION__, (unsigned long) seq_len);
261 if (key_len > sizeof(wk.ik_keydata)) {
262 wpa_printf(MSG_DEBUG, "%s: key length %lu too big",
263 __FUNCTION__, (unsigned long) key_len);
267 os_memset(&wk, 0, sizeof(wk));
269 wk.ik_flags = IEEE80211_KEY_RECV;
271 os_memcmp(addr, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) == 0)
272 wk.ik_flags |= IEEE80211_KEY_GROUP;
274 wk.ik_flags |= IEEE80211_KEY_XMIT | IEEE80211_KEY_DEFAULT;
275 os_memcpy(wk.ik_macaddr, addr, IEEE80211_ADDR_LEN);
277 os_memset(wk.ik_macaddr, 0, IEEE80211_ADDR_LEN);
278 wk.ik_keyix = key_idx;
279 wk.ik_keylen = key_len;
280 #ifdef WORDS_BIGENDIAN
281 #define WPA_KEY_RSC_LEN 8
284 u8 tmp[WPA_KEY_RSC_LEN];
285 os_memset(tmp, 0, sizeof(tmp));
286 for (i = 0; i < seq_len; i++)
287 tmp[WPA_KEY_RSC_LEN - i - 1] = seq[i];
288 os_memcpy(&wk.ik_keyrsc, tmp, WPA_KEY_RSC_LEN);
290 #else /* WORDS_BIGENDIAN */
291 os_memcpy(&wk.ik_keyrsc, seq, seq_len);
292 #endif /* WORDS_BIGENDIAN */
293 os_memcpy(wk.ik_keydata, key, key_len);
295 return set80211priv(drv, IEEE80211_IOCTL_SETKEY, &wk, sizeof(wk), 1);
299 wpa_driver_madwifi_set_countermeasures(void *priv, int enabled)
301 struct wpa_driver_madwifi_data *drv = priv;
302 wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled);
303 return set80211param(drv, IEEE80211_PARAM_COUNTERMEASURES, enabled, 1);
308 wpa_driver_madwifi_set_drop_unencrypted(void *priv, int enabled)
310 struct wpa_driver_madwifi_data *drv = priv;
311 wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled);
312 return set80211param(drv, IEEE80211_PARAM_DROPUNENCRYPTED, enabled, 1);
316 wpa_driver_madwifi_deauthenticate(void *priv, const u8 *addr, int reason_code)
318 struct wpa_driver_madwifi_data *drv = priv;
319 struct ieee80211req_mlme mlme;
321 wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
322 mlme.im_op = IEEE80211_MLME_DEAUTH;
323 mlme.im_reason = reason_code;
324 os_memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN);
325 return set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme), 1);
329 wpa_driver_madwifi_disassociate(void *priv, const u8 *addr, int reason_code)
331 struct wpa_driver_madwifi_data *drv = priv;
332 struct ieee80211req_mlme mlme;
334 wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
335 mlme.im_op = IEEE80211_MLME_DISASSOC;
336 mlme.im_reason = reason_code;
337 os_memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN);
338 return set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme), 1);
342 wpa_driver_madwifi_associate(void *priv,
343 struct wpa_driver_associate_params *params)
345 struct wpa_driver_madwifi_data *drv = priv;
346 struct ieee80211req_mlme mlme;
347 int ret = 0, privacy = 1;
349 wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
352 * NB: Don't need to set the freq or cipher-related state as
353 * this is implied by the bssid which is used to locate
354 * the scanned node state which holds it. The ssid is
355 * needed to disambiguate an AP that broadcasts multiple
356 * ssid's but uses the same bssid.
358 /* XXX error handling is wrong but unclear what to do... */
359 if (wpa_driver_madwifi_set_wpa_ie(drv, params->wpa_ie,
360 params->wpa_ie_len) < 0)
363 if (params->pairwise_suite == CIPHER_NONE &&
364 params->group_suite == CIPHER_NONE &&
365 params->key_mgmt_suite == KEY_MGMT_NONE &&
366 params->wpa_ie_len == 0)
369 if (set80211param(drv, IEEE80211_PARAM_PRIVACY, privacy, 1) < 0)
372 if (params->wpa_ie_len &&
373 set80211param(drv, IEEE80211_PARAM_WPA,
374 params->wpa_ie[0] == WLAN_EID_RSN ? 2 : 1, 1) < 0)
377 if (params->bssid == NULL) {
378 /* ap_scan=2 mode - driver takes care of AP selection and
380 /* FIX: this does not seem to work; would probably need to
381 * change something in the driver */
382 if (set80211param(drv, IEEE80211_PARAM_ROAMING, 0, 1) < 0)
385 if (wpa_driver_wext_set_ssid(drv->wext, params->ssid,
386 params->ssid_len) < 0)
389 if (set80211param(drv, IEEE80211_PARAM_ROAMING, 2, 1) < 0)
391 if (wpa_driver_wext_set_ssid(drv->wext, params->ssid,
392 params->ssid_len) < 0)
394 os_memset(&mlme, 0, sizeof(mlme));
395 mlme.im_op = IEEE80211_MLME_ASSOC;
396 os_memcpy(mlme.im_macaddr, params->bssid, IEEE80211_ADDR_LEN);
397 if (set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme,
398 sizeof(mlme), 1) < 0) {
399 wpa_printf(MSG_DEBUG, "%s: SETMLME[ASSOC] failed",
409 wpa_driver_madwifi_set_auth_alg(void *priv, int auth_alg)
411 struct wpa_driver_madwifi_data *drv = priv;
414 if ((auth_alg & AUTH_ALG_OPEN_SYSTEM) &&
415 (auth_alg & AUTH_ALG_SHARED_KEY))
416 authmode = IEEE80211_AUTH_AUTO;
417 else if (auth_alg & AUTH_ALG_SHARED_KEY)
418 authmode = IEEE80211_AUTH_SHARED;
420 authmode = IEEE80211_AUTH_OPEN;
422 return set80211param(drv, IEEE80211_PARAM_AUTHMODE, authmode, 1);
426 wpa_driver_madwifi_scan(void *priv, const u8 *ssid, size_t ssid_len)
428 struct wpa_driver_madwifi_data *drv = priv;
432 os_memset(&iwr, 0, sizeof(iwr));
433 os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
435 /* set desired ssid before scan */
436 /* FIX: scan should not break the current association, so using
437 * set_ssid may not be the best way of doing this.. */
438 if (wpa_driver_wext_set_ssid(drv->wext, ssid, ssid_len) < 0)
441 if (ioctl(drv->sock, SIOCSIWSCAN, &iwr) < 0) {
442 perror("ioctl[SIOCSIWSCAN]");
447 * madwifi delivers a scan complete event so no need to poll, but
448 * register a backup timeout anyway to make sure that we recover even
449 * if the driver does not send this event for any reason. This timeout
450 * will only be used if the event is not delivered (event handler will
451 * cancel the timeout).
453 eloop_cancel_timeout(wpa_driver_wext_scan_timeout, drv->wext,
455 eloop_register_timeout(30, 0, wpa_driver_wext_scan_timeout, drv->wext,
461 static int wpa_driver_madwifi_get_bssid(void *priv, u8 *bssid)
463 struct wpa_driver_madwifi_data *drv = priv;
464 return wpa_driver_wext_get_bssid(drv->wext, bssid);
468 static int wpa_driver_madwifi_get_ssid(void *priv, u8 *ssid)
470 struct wpa_driver_madwifi_data *drv = priv;
471 return wpa_driver_wext_get_ssid(drv->wext, ssid);
475 static struct wpa_scan_results *
476 wpa_driver_madwifi_get_scan_results(void *priv)
478 struct wpa_driver_madwifi_data *drv = priv;
479 return wpa_driver_wext_get_scan_results(drv->wext);
483 static int wpa_driver_madwifi_set_operstate(void *priv, int state)
485 struct wpa_driver_madwifi_data *drv = priv;
486 return wpa_driver_wext_set_operstate(drv->wext, state);
490 static int wpa_driver_madwifi_set_probe_req_ie(void *priv, const u8 *ies,
493 struct ieee80211req_getset_appiebuf *probe_req_ie;
496 probe_req_ie = os_malloc(sizeof(*probe_req_ie) + ies_len);
497 if (probe_req_ie == NULL)
500 probe_req_ie->app_frmtype = IEEE80211_APPIE_FRAME_PROBE_REQ;
501 probe_req_ie->app_buflen = ies_len;
502 os_memcpy(probe_req_ie->app_buf, ies, ies_len);
504 ret = set80211priv(priv, IEEE80211_IOCTL_SET_APPIEBUF, probe_req_ie,
505 sizeof(struct ieee80211req_getset_appiebuf) +
508 os_free(probe_req_ie);
514 static void * wpa_driver_madwifi_init(void *ctx, const char *ifname)
516 struct wpa_driver_madwifi_data *drv;
518 drv = os_zalloc(sizeof(*drv));
521 drv->wext = wpa_driver_wext_init(ctx, ifname);
522 if (drv->wext == NULL)
526 os_strlcpy(drv->ifname, ifname, sizeof(drv->ifname));
527 drv->sock = socket(PF_INET, SOCK_DGRAM, 0);
531 if (set80211param(drv, IEEE80211_PARAM_ROAMING, 2, 1) < 0) {
532 wpa_printf(MSG_DEBUG, "%s: failed to set wpa_supplicant-based "
533 "roaming", __FUNCTION__);
537 if (set80211param(drv, IEEE80211_PARAM_WPA, 3, 1) < 0) {
538 wpa_printf(MSG_DEBUG, "%s: failed to enable WPA support",
548 wpa_driver_wext_deinit(drv->wext);
555 static void wpa_driver_madwifi_deinit(void *priv)
557 struct wpa_driver_madwifi_data *drv = priv;
559 if (wpa_driver_madwifi_set_wpa_ie(drv, NULL, 0) < 0) {
560 wpa_printf(MSG_DEBUG, "%s: failed to clear WPA IE",
563 if (set80211param(drv, IEEE80211_PARAM_ROAMING, 0, 1) < 0) {
564 wpa_printf(MSG_DEBUG, "%s: failed to enable driver-based "
565 "roaming", __FUNCTION__);
567 if (set80211param(drv, IEEE80211_PARAM_PRIVACY, 0, 1) < 0) {
568 wpa_printf(MSG_DEBUG, "%s: failed to disable forced Privacy "
569 "flag", __FUNCTION__);
571 if (set80211param(drv, IEEE80211_PARAM_WPA, 0, 1) < 0) {
572 wpa_printf(MSG_DEBUG, "%s: failed to disable WPA",
576 wpa_driver_wext_deinit(drv->wext);
583 const struct wpa_driver_ops wpa_driver_madwifi_ops = {
585 .desc = "MADWIFI 802.11 support (Atheros, etc.)",
586 .get_bssid = wpa_driver_madwifi_get_bssid,
587 .get_ssid = wpa_driver_madwifi_get_ssid,
588 .set_key = wpa_driver_madwifi_set_key,
589 .init = wpa_driver_madwifi_init,
590 .deinit = wpa_driver_madwifi_deinit,
591 .set_countermeasures = wpa_driver_madwifi_set_countermeasures,
592 .set_drop_unencrypted = wpa_driver_madwifi_set_drop_unencrypted,
593 .scan = wpa_driver_madwifi_scan,
594 .get_scan_results2 = wpa_driver_madwifi_get_scan_results,
595 .deauthenticate = wpa_driver_madwifi_deauthenticate,
596 .disassociate = wpa_driver_madwifi_disassociate,
597 .associate = wpa_driver_madwifi_associate,
598 .set_auth_alg = wpa_driver_madwifi_set_auth_alg,
599 .set_operstate = wpa_driver_madwifi_set_operstate,
600 .set_probe_req_ie = wpa_driver_madwifi_set_probe_req_ie,