1 /*
2 * hostapd / Driver interaction with Atheros driver
3 * Copyright (c) 2004, Sam Leffler <sam@errno.com>
4 * Copyright (c) 2004, Video54 Technologies
5 * Copyright (c) 2005-2007, Jouni Malinen <j@w1.fi>
6 * Copyright (c) 2009, Atheros Communications
7 *
8 * This software may be distributed under the terms of the BSD license.
9 * See README for more details.
10 */
11
12 #include "includes.h"
13 #include <net/if.h>
14 #include <sys/ioctl.h>
15
16 #include "common.h"
17 #include "eloop.h"
18 #include "common/ieee802_11_defs.h"
19 #include "l2_packet/l2_packet.h"
20 #include "p2p/p2p.h"
21
22 #include "common.h"
23 #ifndef _BYTE_ORDER
24 #ifdef WORDS_BIGENDIAN
25 #define _BYTE_ORDER _BIG_ENDIAN
26 #else
27 #define _BYTE_ORDER _LITTLE_ENDIAN
28 #endif
29 #endif /* _BYTE_ORDER */
30
31 /*
32 * Note, the ATH_WPS_IE setting must match with the driver build.. If the
33 * driver does not include this, the IEEE80211_IOCTL_GETWPAIE ioctl will fail.
34 */
35 #define ATH_WPS_IE
36
37 #include "ieee80211_external.h"
38
39
40 #ifdef CONFIG_WPS
41 #include <netpacket/packet.h>
42 #endif /* CONFIG_WPS */
43
44 #ifndef ETH_P_80211_RAW
45 #define ETH_P_80211_RAW 0x0019
46 #endif
47
48 #include "linux_wext.h"
49
50 #include "driver.h"
51 #include "eloop.h"
52 #include "priv_netlink.h"
53 #include "l2_packet/l2_packet.h"
54 #include "common/ieee802_11_defs.h"
55 #include "netlink.h"
56 #include "linux_ioctl.h"
57
58
59 struct atheros_driver_data {
60 struct hostapd_data *hapd; /* back pointer */
61
62 char iface[IFNAMSIZ + 1];
63 int ifindex;
64 struct l2_packet_data *sock_xmit; /* raw packet xmit socket */
65 struct l2_packet_data *sock_recv; /* raw packet recv socket */
66 int ioctl_sock; /* socket for ioctl() use */
67 struct netlink_data *netlink;
68 int we_version;
69 u8 acct_mac[ETH_ALEN];
70 struct hostap_sta_driver_data acct_data;
71
72 struct l2_packet_data *sock_raw; /* raw 802.11 management frames */
73 struct wpabuf *wpa_ie;
74 struct wpabuf *wps_beacon_ie;
75 struct wpabuf *wps_probe_resp_ie;
76 u8 own_addr[ETH_ALEN];
77 };
78
79 static int atheros_sta_deauth(void *priv, const u8 *own_addr, const u8 *addr,
80 int reason_code);
81 static int atheros_set_privacy(void *priv, int enabled);
82
athr_get_ioctl_name(int op)83 static const char * athr_get_ioctl_name(int op)
84 {
85 switch (op) {
86 case IEEE80211_IOCTL_SETPARAM:
87 return "SETPARAM";
88 case IEEE80211_IOCTL_GETPARAM:
89 return "GETPARAM";
90 case IEEE80211_IOCTL_SETKEY:
91 return "SETKEY";
92 case IEEE80211_IOCTL_SETWMMPARAMS:
93 return "SETWMMPARAMS";
94 case IEEE80211_IOCTL_DELKEY:
95 return "DELKEY";
96 case IEEE80211_IOCTL_GETWMMPARAMS:
97 return "GETWMMPARAMS";
98 case IEEE80211_IOCTL_SETMLME:
99 return "SETMLME";
100 case IEEE80211_IOCTL_GETCHANINFO:
101 return "GETCHANINFO";
102 case IEEE80211_IOCTL_SETOPTIE:
103 return "SETOPTIE";
104 case IEEE80211_IOCTL_GETOPTIE:
105 return "GETOPTIE";
106 case IEEE80211_IOCTL_ADDMAC:
107 return "ADDMAC";
108 case IEEE80211_IOCTL_DELMAC:
109 return "DELMAC";
110 case IEEE80211_IOCTL_GETCHANLIST:
111 return "GETCHANLIST";
112 case IEEE80211_IOCTL_SETCHANLIST:
113 return "SETCHANLIST";
114 case IEEE80211_IOCTL_KICKMAC:
115 return "KICKMAC";
116 case IEEE80211_IOCTL_CHANSWITCH:
117 return "CHANSWITCH";
118 case IEEE80211_IOCTL_GETMODE:
119 return "GETMODE";
120 case IEEE80211_IOCTL_SETMODE:
121 return "SETMODE";
122 case IEEE80211_IOCTL_GET_APPIEBUF:
123 return "GET_APPIEBUF";
124 case IEEE80211_IOCTL_SET_APPIEBUF:
125 return "SET_APPIEBUF";
126 case IEEE80211_IOCTL_SET_ACPARAMS:
127 return "SET_ACPARAMS";
128 case IEEE80211_IOCTL_FILTERFRAME:
129 return "FILTERFRAME";
130 case IEEE80211_IOCTL_SET_RTPARAMS:
131 return "SET_RTPARAMS";
132 case IEEE80211_IOCTL_SET_MEDENYENTRY:
133 return "SET_MEDENYENTRY";
134 case IEEE80211_IOCTL_GET_MACADDR:
135 return "GET_MACADDR";
136 case IEEE80211_IOCTL_SET_HBRPARAMS:
137 return "SET_HBRPARAMS";
138 case IEEE80211_IOCTL_SET_RXTIMEOUT:
139 return "SET_RXTIMEOUT";
140 case IEEE80211_IOCTL_STA_STATS:
141 return "STA_STATS";
142 case IEEE80211_IOCTL_GETWPAIE:
143 return "GETWPAIE";
144 default:
145 return "??";
146 }
147 }
148
149
athr_get_param_name(int op)150 static const char * athr_get_param_name(int op)
151 {
152 switch (op) {
153 case IEEE80211_IOC_MCASTCIPHER:
154 return "MCASTCIPHER";
155 case IEEE80211_PARAM_MCASTKEYLEN:
156 return "MCASTKEYLEN";
157 case IEEE80211_PARAM_UCASTCIPHERS:
158 return "UCASTCIPHERS";
159 case IEEE80211_PARAM_KEYMGTALGS:
160 return "KEYMGTALGS";
161 case IEEE80211_PARAM_RSNCAPS:
162 return "RSNCAPS";
163 case IEEE80211_PARAM_WPA:
164 return "WPA";
165 case IEEE80211_PARAM_AUTHMODE:
166 return "AUTHMODE";
167 case IEEE80211_PARAM_PRIVACY:
168 return "PRIVACY";
169 case IEEE80211_PARAM_COUNTERMEASURES:
170 return "COUNTERMEASURES";
171 default:
172 return "??";
173 }
174 }
175
176
177 static int
set80211priv(struct atheros_driver_data * drv,int op,void * data,int len)178 set80211priv(struct atheros_driver_data *drv, int op, void *data, int len)
179 {
180 struct iwreq iwr;
181 int do_inline = len < IFNAMSIZ;
182
183 /* Certain ioctls must use the non-inlined method */
184 if (op == IEEE80211_IOCTL_SET_APPIEBUF ||
185 op == IEEE80211_IOCTL_FILTERFRAME)
186 do_inline = 0;
187
188 memset(&iwr, 0, sizeof(iwr));
189 os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ);
190 if (do_inline) {
191 /*
192 * Argument data fits inline; put it there.
193 */
194 memcpy(iwr.u.name, data, len);
195 } else {
196 /*
197 * Argument data too big for inline transfer; setup a
198 * parameter block instead; the kernel will transfer
199 * the data for the driver.
200 */
201 iwr.u.data.pointer = data;
202 iwr.u.data.length = len;
203 }
204
205 if (ioctl(drv->ioctl_sock, op, &iwr) < 0) {
206 wpa_printf(MSG_DEBUG, "atheros: %s: %s: ioctl op=0x%x "
207 "(%s) len=%d failed: %d (%s)",
208 __func__, drv->iface, op,
209 athr_get_ioctl_name(op),
210 len, errno, strerror(errno));
211 return -1;
212 }
213 return 0;
214 }
215
216 static int
set80211param(struct atheros_driver_data * drv,int op,int arg)217 set80211param(struct atheros_driver_data *drv, int op, int arg)
218 {
219 struct iwreq iwr;
220
221 memset(&iwr, 0, sizeof(iwr));
222 os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ);
223 iwr.u.mode = op;
224 memcpy(iwr.u.name+sizeof(__u32), &arg, sizeof(arg));
225
226 if (ioctl(drv->ioctl_sock, IEEE80211_IOCTL_SETPARAM, &iwr) < 0) {
227 wpa_printf(MSG_INFO,
228 "%s: %s: Failed to set parameter (op %d (%s) arg %d): ioctl[IEEE80211_IOCTL_SETPARAM]: %s",
229 __func__, drv->iface, op, athr_get_param_name(op),
230 arg, strerror(errno));
231 return -1;
232 }
233 return 0;
234 }
235
236 #ifndef CONFIG_NO_STDOUT_DEBUG
237 static const char *
ether_sprintf(const u8 * addr)238 ether_sprintf(const u8 *addr)
239 {
240 static char buf[sizeof(MACSTR)];
241
242 if (addr != NULL)
243 snprintf(buf, sizeof(buf), MACSTR, MAC2STR(addr));
244 else
245 snprintf(buf, sizeof(buf), MACSTR, 0,0,0,0,0,0);
246 return buf;
247 }
248 #endif /* CONFIG_NO_STDOUT_DEBUG */
249
250 /*
251 * Configure WPA parameters.
252 */
253 static int
atheros_configure_wpa(struct atheros_driver_data * drv,struct wpa_bss_params * params)254 atheros_configure_wpa(struct atheros_driver_data *drv,
255 struct wpa_bss_params *params)
256 {
257 int v;
258
259 switch (params->wpa_group) {
260 case WPA_CIPHER_CCMP:
261 v = IEEE80211_CIPHER_AES_CCM;
262 break;
263 #ifdef ATH_GCM_SUPPORT
264 case WPA_CIPHER_CCMP_256:
265 v = IEEE80211_CIPHER_AES_CCM_256;
266 break;
267 case WPA_CIPHER_GCMP:
268 v = IEEE80211_CIPHER_AES_GCM;
269 break;
270 case WPA_CIPHER_GCMP_256:
271 v = IEEE80211_CIPHER_AES_GCM_256;
272 break;
273 #endif /* ATH_GCM_SUPPORT */
274 case WPA_CIPHER_TKIP:
275 v = IEEE80211_CIPHER_TKIP;
276 break;
277 case WPA_CIPHER_WEP104:
278 v = IEEE80211_CIPHER_WEP;
279 break;
280 case WPA_CIPHER_WEP40:
281 v = IEEE80211_CIPHER_WEP;
282 break;
283 case WPA_CIPHER_NONE:
284 v = IEEE80211_CIPHER_NONE;
285 break;
286 default:
287 wpa_printf(MSG_ERROR, "Unknown group key cipher %u",
288 params->wpa_group);
289 return -1;
290 }
291 wpa_printf(MSG_DEBUG, "%s: group key cipher=%d", __func__, v);
292 if (set80211param(drv, IEEE80211_PARAM_MCASTCIPHER, v)) {
293 wpa_printf(MSG_INFO, "Unable to set group key cipher to %u", v);
294 return -1;
295 }
296 if (v == IEEE80211_CIPHER_WEP) {
297 /* key length is done only for specific ciphers */
298 v = (params->wpa_group == WPA_CIPHER_WEP104 ? 13 : 5);
299 if (set80211param(drv, IEEE80211_PARAM_MCASTKEYLEN, v)) {
300 wpa_printf(MSG_INFO,
301 "Unable to set group key length to %u", v);
302 return -1;
303 }
304 }
305
306 v = 0;
307 if (params->wpa_pairwise & WPA_CIPHER_CCMP)
308 v |= 1<<IEEE80211_CIPHER_AES_CCM;
309 #ifdef ATH_GCM_SUPPORT
310 if (params->wpa_pairwise & WPA_CIPHER_CCMP_256)
311 v |= 1<<IEEE80211_CIPHER_AES_CCM_256;
312 if (params->wpa_pairwise & WPA_CIPHER_GCMP)
313 v |= 1<<IEEE80211_CIPHER_AES_GCM;
314 if (params->wpa_pairwise & WPA_CIPHER_GCMP_256)
315 v |= 1<<IEEE80211_CIPHER_AES_GCM_256;
316 #endif /* ATH_GCM_SUPPORT */
317 if (params->wpa_pairwise & WPA_CIPHER_TKIP)
318 v |= 1<<IEEE80211_CIPHER_TKIP;
319 if (params->wpa_pairwise & WPA_CIPHER_NONE)
320 v |= 1<<IEEE80211_CIPHER_NONE;
321 wpa_printf(MSG_DEBUG, "%s: pairwise key ciphers=0x%x", __func__, v);
322 if (set80211param(drv, IEEE80211_PARAM_UCASTCIPHERS, v)) {
323 wpa_printf(MSG_INFO,
324 "Unable to set pairwise key ciphers to 0x%x", v);
325 return -1;
326 }
327
328 wpa_printf(MSG_DEBUG, "%s: key management algorithms=0x%x",
329 __func__, params->wpa_key_mgmt);
330 if (set80211param(drv, IEEE80211_PARAM_KEYMGTALGS,
331 params->wpa_key_mgmt)) {
332 wpa_printf(MSG_INFO,
333 "Unable to set key management algorithms to 0x%x",
334 params->wpa_key_mgmt);
335 return -1;
336 }
337
338 v = 0;
339 if (params->rsn_preauth)
340 v |= BIT(0);
341 #ifdef CONFIG_IEEE80211W
342 if (params->ieee80211w != NO_MGMT_FRAME_PROTECTION) {
343 v |= BIT(7);
344 if (params->ieee80211w == MGMT_FRAME_PROTECTION_REQUIRED)
345 v |= BIT(6);
346 }
347 #endif /* CONFIG_IEEE80211W */
348
349 wpa_printf(MSG_DEBUG, "%s: rsn capabilities=0x%x", __func__, v);
350 if (set80211param(drv, IEEE80211_PARAM_RSNCAPS, v)) {
351 wpa_printf(MSG_INFO, "Unable to set RSN capabilities to 0x%x",
352 v);
353 return -1;
354 }
355
356 wpa_printf(MSG_DEBUG, "%s: enable WPA=0x%x", __func__, params->wpa);
357 if (set80211param(drv, IEEE80211_PARAM_WPA, params->wpa)) {
358 wpa_printf(MSG_INFO, "Unable to set WPA to %u", params->wpa);
359 return -1;
360 }
361 return 0;
362 }
363
364 static int
atheros_set_ieee8021x(void * priv,struct wpa_bss_params * params)365 atheros_set_ieee8021x(void *priv, struct wpa_bss_params *params)
366 {
367 struct atheros_driver_data *drv = priv;
368
369 wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, params->enabled);
370
371 if (!params->enabled) {
372 /* XXX restore state */
373 if (set80211param(priv, IEEE80211_PARAM_AUTHMODE,
374 IEEE80211_AUTH_AUTO) < 0)
375 return -1;
376 /* IEEE80211_AUTH_AUTO ends up enabling Privacy; clear that */
377 return atheros_set_privacy(drv, 0);
378 }
379 if (!params->wpa && !params->ieee802_1x) {
380 wpa_printf(MSG_WARNING, "No 802.1X or WPA enabled!");
381 return -1;
382 }
383 if (params->wpa && atheros_configure_wpa(drv, params) != 0) {
384 wpa_printf(MSG_WARNING, "Error configuring WPA state!");
385 return -1;
386 }
387 if (set80211param(priv, IEEE80211_PARAM_AUTHMODE,
388 (params->wpa ? IEEE80211_AUTH_WPA : IEEE80211_AUTH_8021X))) {
389 wpa_printf(MSG_WARNING, "Error enabling WPA/802.1X!");
390 return -1;
391 }
392
393 return 0;
394 }
395
396 static int
atheros_set_privacy(void * priv,int enabled)397 atheros_set_privacy(void *priv, int enabled)
398 {
399 struct atheros_driver_data *drv = priv;
400
401 wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled);
402
403 return set80211param(drv, IEEE80211_PARAM_PRIVACY, enabled);
404 }
405
406 static int
atheros_set_sta_authorized(void * priv,const u8 * addr,int authorized)407 atheros_set_sta_authorized(void *priv, const u8 *addr, int authorized)
408 {
409 struct atheros_driver_data *drv = priv;
410 struct ieee80211req_mlme mlme;
411 int ret;
412
413 wpa_printf(MSG_DEBUG, "%s: addr=%s authorized=%d",
414 __func__, ether_sprintf(addr), authorized);
415
416 if (authorized)
417 mlme.im_op = IEEE80211_MLME_AUTHORIZE;
418 else
419 mlme.im_op = IEEE80211_MLME_UNAUTHORIZE;
420 mlme.im_reason = 0;
421 memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN);
422 ret = set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme));
423 if (ret < 0) {
424 wpa_printf(MSG_DEBUG, "%s: Failed to %sauthorize STA " MACSTR,
425 __func__, authorized ? "" : "un", MAC2STR(addr));
426 }
427
428 return ret;
429 }
430
431 static int
atheros_sta_set_flags(void * priv,const u8 * addr,int total_flags,int flags_or,int flags_and)432 atheros_sta_set_flags(void *priv, const u8 *addr,
433 int total_flags, int flags_or, int flags_and)
434 {
435 /* For now, only support setting Authorized flag */
436 if (flags_or & WPA_STA_AUTHORIZED)
437 return atheros_set_sta_authorized(priv, addr, 1);
438 if (!(flags_and & WPA_STA_AUTHORIZED))
439 return atheros_set_sta_authorized(priv, addr, 0);
440 return 0;
441 }
442
443 static int
atheros_del_key(void * priv,const u8 * addr,int key_idx)444 atheros_del_key(void *priv, const u8 *addr, int key_idx)
445 {
446 struct atheros_driver_data *drv = priv;
447 struct ieee80211req_del_key wk;
448 int ret;
449
450 wpa_printf(MSG_DEBUG, "%s: addr=%s key_idx=%d",
451 __func__, ether_sprintf(addr), key_idx);
452
453 memset(&wk, 0, sizeof(wk));
454 if (addr != NULL) {
455 memcpy(wk.idk_macaddr, addr, IEEE80211_ADDR_LEN);
456 wk.idk_keyix = (u8) IEEE80211_KEYIX_NONE;
457 } else {
458 wk.idk_keyix = key_idx;
459 }
460
461 ret = set80211priv(drv, IEEE80211_IOCTL_DELKEY, &wk, sizeof(wk));
462 if (ret < 0) {
463 wpa_printf(MSG_DEBUG, "%s: Failed to delete key (addr %s"
464 " key_idx %d)", __func__, ether_sprintf(addr),
465 key_idx);
466 }
467
468 return ret;
469 }
470
471 static int
atheros_set_key(const char * ifname,void * priv,enum wpa_alg alg,const u8 * addr,int key_idx,int set_tx,const u8 * seq,size_t seq_len,const u8 * key,size_t key_len)472 atheros_set_key(const char *ifname, void *priv, enum wpa_alg alg,
473 const u8 *addr, int key_idx, int set_tx, const u8 *seq,
474 size_t seq_len, const u8 *key, size_t key_len)
475 {
476 struct atheros_driver_data *drv = priv;
477 struct ieee80211req_key wk;
478 u_int8_t cipher;
479 int ret;
480
481 if (alg == WPA_ALG_NONE)
482 return atheros_del_key(drv, addr, key_idx);
483
484 wpa_printf(MSG_DEBUG, "%s: alg=%d addr=%s key_idx=%d",
485 __func__, alg, ether_sprintf(addr), key_idx);
486
487 switch (alg) {
488 case WPA_ALG_WEP:
489 cipher = IEEE80211_CIPHER_WEP;
490 break;
491 case WPA_ALG_TKIP:
492 cipher = IEEE80211_CIPHER_TKIP;
493 break;
494 case WPA_ALG_CCMP:
495 cipher = IEEE80211_CIPHER_AES_CCM;
496 break;
497 #ifdef ATH_GCM_SUPPORT
498 case WPA_ALG_CCMP_256:
499 cipher = IEEE80211_CIPHER_AES_CCM_256;
500 break;
501 case WPA_ALG_GCMP:
502 cipher = IEEE80211_CIPHER_AES_GCM;
503 break;
504 case WPA_ALG_GCMP_256:
505 cipher = IEEE80211_CIPHER_AES_GCM_256;
506 break;
507 #endif /* ATH_GCM_SUPPORT */
508 #ifdef CONFIG_IEEE80211W
509 case WPA_ALG_IGTK:
510 cipher = IEEE80211_CIPHER_AES_CMAC;
511 break;
512 #ifdef ATH_GCM_SUPPORT
513 case WPA_ALG_BIP_CMAC_256:
514 cipher = IEEE80211_CIPHER_AES_CMAC_256;
515 break;
516 case WPA_ALG_BIP_GMAC_128:
517 cipher = IEEE80211_CIPHER_AES_GMAC;
518 break;
519 case WPA_ALG_BIP_GMAC_256:
520 cipher = IEEE80211_CIPHER_AES_GMAC_256;
521 break;
522 #endif /* ATH_GCM_SUPPORT */
523 #endif /* CONFIG_IEEE80211W */
524 default:
525 wpa_printf(MSG_INFO, "%s: unknown/unsupported algorithm %d",
526 __func__, alg);
527 return -1;
528 }
529
530 if (key_len > sizeof(wk.ik_keydata)) {
531 wpa_printf(MSG_INFO, "%s: key length %lu too big", __func__,
532 (unsigned long) key_len);
533 return -3;
534 }
535
536 memset(&wk, 0, sizeof(wk));
537 wk.ik_type = cipher;
538 wk.ik_flags = IEEE80211_KEY_RECV | IEEE80211_KEY_XMIT;
539 if (addr == NULL || is_broadcast_ether_addr(addr)) {
540 memset(wk.ik_macaddr, 0xff, IEEE80211_ADDR_LEN);
541 wk.ik_keyix = key_idx;
542 if (set_tx)
543 wk.ik_flags |= IEEE80211_KEY_DEFAULT;
544 } else {
545 memcpy(wk.ik_macaddr, addr, IEEE80211_ADDR_LEN);
546 wk.ik_keyix = IEEE80211_KEYIX_NONE;
547 }
548 wk.ik_keylen = key_len;
549 memcpy(wk.ik_keydata, key, key_len);
550
551 ret = set80211priv(drv, IEEE80211_IOCTL_SETKEY, &wk, sizeof(wk));
552 if (ret < 0) {
553 wpa_printf(MSG_DEBUG, "%s: Failed to set key (addr %s"
554 " key_idx %d alg %d key_len %lu set_tx %d)",
555 __func__, ether_sprintf(wk.ik_macaddr), key_idx,
556 alg, (unsigned long) key_len, set_tx);
557 }
558
559 return ret;
560 }
561
562
563 static int
atheros_get_seqnum(const char * ifname,void * priv,const u8 * addr,int idx,u8 * seq)564 atheros_get_seqnum(const char *ifname, void *priv, const u8 *addr, int idx,
565 u8 *seq)
566 {
567 struct atheros_driver_data *drv = priv;
568 struct ieee80211req_key wk;
569
570 wpa_printf(MSG_DEBUG, "%s: addr=%s idx=%d",
571 __func__, ether_sprintf(addr), idx);
572
573 memset(&wk, 0, sizeof(wk));
574 if (addr == NULL)
575 memset(wk.ik_macaddr, 0xff, IEEE80211_ADDR_LEN);
576 else
577 memcpy(wk.ik_macaddr, addr, IEEE80211_ADDR_LEN);
578 wk.ik_keyix = idx;
579
580 if (set80211priv(drv, IEEE80211_IOCTL_GETKEY, &wk, sizeof(wk))) {
581 wpa_printf(MSG_DEBUG, "%s: Failed to get encryption data "
582 "(addr " MACSTR " key_idx %d)",
583 __func__, MAC2STR(wk.ik_macaddr), idx);
584 return -1;
585 }
586
587 #ifdef WORDS_BIGENDIAN
588 {
589 /*
590 * wk.ik_keytsc is in host byte order (big endian), need to
591 * swap it to match with the byte order used in WPA.
592 */
593 int i;
594 #ifndef WPA_KEY_RSC_LEN
595 #define WPA_KEY_RSC_LEN 8
596 #endif
597 u8 tmp[WPA_KEY_RSC_LEN];
598 memcpy(tmp, &wk.ik_keytsc, sizeof(wk.ik_keytsc));
599 for (i = 0; i < WPA_KEY_RSC_LEN; i++) {
600 seq[i] = tmp[WPA_KEY_RSC_LEN - i - 1];
601 }
602 }
603 #else /* WORDS_BIGENDIAN */
604 memcpy(seq, &wk.ik_keytsc, sizeof(wk.ik_keytsc));
605 #endif /* WORDS_BIGENDIAN */
606 return 0;
607 }
608
609
610 static int
atheros_flush(void * priv)611 atheros_flush(void *priv)
612 {
613 u8 allsta[IEEE80211_ADDR_LEN];
614 memset(allsta, 0xff, IEEE80211_ADDR_LEN);
615 return atheros_sta_deauth(priv, NULL, allsta,
616 IEEE80211_REASON_AUTH_LEAVE);
617 }
618
619
620 static int
atheros_read_sta_driver_data(void * priv,struct hostap_sta_driver_data * data,const u8 * addr)621 atheros_read_sta_driver_data(void *priv, struct hostap_sta_driver_data *data,
622 const u8 *addr)
623 {
624 struct atheros_driver_data *drv = priv;
625 struct ieee80211req_sta_stats stats;
626
627 memset(data, 0, sizeof(*data));
628
629 /*
630 * Fetch statistics for station from the system.
631 */
632 memset(&stats, 0, sizeof(stats));
633 memcpy(stats.is_u.macaddr, addr, IEEE80211_ADDR_LEN);
634 if (set80211priv(drv, IEEE80211_IOCTL_STA_STATS,
635 &stats, sizeof(stats))) {
636 wpa_printf(MSG_DEBUG, "%s: Failed to fetch STA stats (addr "
637 MACSTR ")", __func__, MAC2STR(addr));
638 if (memcmp(addr, drv->acct_mac, ETH_ALEN) == 0) {
639 memcpy(data, &drv->acct_data, sizeof(*data));
640 return 0;
641 }
642
643 wpa_printf(MSG_INFO,
644 "Failed to get station stats information element");
645 return -1;
646 }
647
648 data->rx_packets = stats.is_stats.ns_rx_data;
649 data->rx_bytes = stats.is_stats.ns_rx_bytes;
650 data->tx_packets = stats.is_stats.ns_tx_data;
651 data->tx_bytes = stats.is_stats.ns_tx_bytes;
652 return 0;
653 }
654
655
656 static int
atheros_sta_clear_stats(void * priv,const u8 * addr)657 atheros_sta_clear_stats(void *priv, const u8 *addr)
658 {
659 struct atheros_driver_data *drv = priv;
660 struct ieee80211req_mlme mlme;
661 int ret;
662
663 wpa_printf(MSG_DEBUG, "%s: addr=%s", __func__, ether_sprintf(addr));
664
665 mlme.im_op = IEEE80211_MLME_CLEAR_STATS;
666 memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN);
667 ret = set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme,
668 sizeof(mlme));
669 if (ret < 0) {
670 wpa_printf(MSG_DEBUG, "%s: Failed to clear STA stats (addr "
671 MACSTR ")", __func__, MAC2STR(addr));
672 }
673
674 return ret;
675 }
676
677
678 static int
atheros_set_opt_ie(void * priv,const u8 * ie,size_t ie_len)679 atheros_set_opt_ie(void *priv, const u8 *ie, size_t ie_len)
680 {
681 struct atheros_driver_data *drv = priv;
682 u8 buf[512];
683 struct ieee80211req_getset_appiebuf *app_ie;
684
685 wpa_printf(MSG_DEBUG, "%s buflen = %lu", __func__,
686 (unsigned long) ie_len);
687 wpa_hexdump(MSG_DEBUG, "atheros: set_generic_elem", ie, ie_len);
688
689 wpabuf_free(drv->wpa_ie);
690 drv->wpa_ie = wpabuf_alloc_copy(ie, ie_len);
691
692 app_ie = (struct ieee80211req_getset_appiebuf *) buf;
693 os_memcpy(&(app_ie->app_buf[0]), ie, ie_len);
694 app_ie->app_buflen = ie_len;
695
696 app_ie->app_frmtype = IEEE80211_APPIE_FRAME_BEACON;
697
698 /* append WPS IE for Beacon */
699 if (drv->wps_beacon_ie != NULL) {
700 os_memcpy(&(app_ie->app_buf[ie_len]),
701 wpabuf_head(drv->wps_beacon_ie),
702 wpabuf_len(drv->wps_beacon_ie));
703 app_ie->app_buflen = ie_len + wpabuf_len(drv->wps_beacon_ie);
704 }
705 wpa_hexdump(MSG_DEBUG, "atheros: SET_APPIEBUF(Beacon)",
706 app_ie->app_buf, app_ie->app_buflen);
707 set80211priv(drv, IEEE80211_IOCTL_SET_APPIEBUF, app_ie,
708 sizeof(struct ieee80211req_getset_appiebuf) +
709 app_ie->app_buflen);
710
711 /* append WPS IE for Probe Response */
712 app_ie->app_frmtype = IEEE80211_APPIE_FRAME_PROBE_RESP;
713 if (drv->wps_probe_resp_ie != NULL) {
714 os_memcpy(&(app_ie->app_buf[ie_len]),
715 wpabuf_head(drv->wps_probe_resp_ie),
716 wpabuf_len(drv->wps_probe_resp_ie));
717 app_ie->app_buflen = ie_len +
718 wpabuf_len(drv->wps_probe_resp_ie);
719 } else
720 app_ie->app_buflen = ie_len;
721 wpa_hexdump(MSG_DEBUG, "atheros: SET_APPIEBUF(ProbeResp)",
722 app_ie->app_buf, app_ie->app_buflen);
723 set80211priv(drv, IEEE80211_IOCTL_SET_APPIEBUF, app_ie,
724 sizeof(struct ieee80211req_getset_appiebuf) +
725 app_ie->app_buflen);
726 return 0;
727 }
728
729 static int
atheros_sta_deauth(void * priv,const u8 * own_addr,const u8 * addr,int reason_code)730 atheros_sta_deauth(void *priv, const u8 *own_addr, const u8 *addr,
731 int reason_code)
732 {
733 struct atheros_driver_data *drv = priv;
734 struct ieee80211req_mlme mlme;
735 int ret;
736
737 wpa_printf(MSG_DEBUG, "%s: addr=%s reason_code=%d",
738 __func__, ether_sprintf(addr), reason_code);
739
740 mlme.im_op = IEEE80211_MLME_DEAUTH;
741 mlme.im_reason = reason_code;
742 memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN);
743 ret = set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme));
744 if (ret < 0) {
745 wpa_printf(MSG_DEBUG, "%s: Failed to deauth STA (addr " MACSTR
746 " reason %d)",
747 __func__, MAC2STR(addr), reason_code);
748 }
749
750 return ret;
751 }
752
753 static int
atheros_sta_disassoc(void * priv,const u8 * own_addr,const u8 * addr,int reason_code)754 atheros_sta_disassoc(void *priv, const u8 *own_addr, const u8 *addr,
755 int reason_code)
756 {
757 struct atheros_driver_data *drv = priv;
758 struct ieee80211req_mlme mlme;
759 int ret;
760
761 wpa_printf(MSG_DEBUG, "%s: addr=%s reason_code=%d",
762 __func__, ether_sprintf(addr), reason_code);
763
764 mlme.im_op = IEEE80211_MLME_DISASSOC;
765 mlme.im_reason = reason_code;
766 memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN);
767 ret = set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme));
768 if (ret < 0) {
769 wpa_printf(MSG_DEBUG, "%s: Failed to disassoc STA (addr "
770 MACSTR " reason %d)",
771 __func__, MAC2STR(addr), reason_code);
772 }
773
774 return ret;
775 }
776
atheros_set_qos_map(void * ctx,const u8 * qos_map_set,u8 qos_map_set_len)777 static int atheros_set_qos_map(void *ctx, const u8 *qos_map_set,
778 u8 qos_map_set_len)
779 {
780 #ifdef CONFIG_ATHEROS_QOS_MAP
781 struct atheros_driver_data *drv = ctx;
782 struct ieee80211req_athdbg req;
783 struct ieee80211_qos_map *qos_map = &req.data.qos_map;
784 struct iwreq iwr;
785 int i, up_start;
786
787 if (qos_map_set_len < 16 || qos_map_set_len > 58 ||
788 qos_map_set_len & 1) {
789 wpa_printf(MSG_ERROR, "Invalid QoS Map");
790 return -1;
791 } else {
792 memset(&req, 0, sizeof(struct ieee80211req_athdbg));
793 req.cmd = IEEE80211_DBGREQ_SETQOSMAPCONF;
794 os_memset(&iwr, 0, sizeof(iwr));
795 os_strlcpy(iwr.ifr_name, drv->iface, sizeof(iwr.ifr_name));
796 iwr.u.data.pointer = (void *) &req;
797 iwr.u.data.length = sizeof(struct ieee80211req_athdbg);
798 }
799
800 qos_map->valid = 1;
801 qos_map->num_dscp_except = (qos_map_set_len - 16) / 2;
802 if (qos_map->num_dscp_except) {
803 for (i = 0; i < qos_map->num_dscp_except; i++) {
804 qos_map->dscp_exception[i].dscp = qos_map_set[i * 2];
805 qos_map->dscp_exception[i].up = qos_map_set[i * 2 + 1];
806 }
807 }
808
809 up_start = qos_map_set_len - 16;
810 for (i = 0; i < IEEE80211_MAX_QOS_UP_RANGE; i++) {
811 qos_map->up[i].low = qos_map_set[up_start + (i * 2)];
812 qos_map->up[i].high = qos_map_set[up_start + (i * 2) + 1];
813 }
814
815 if (ioctl(drv->ioctl_sock, IEEE80211_IOCTL_DBGREQ, &iwr) < 0) {
816 wpa_printf(MSG_ERROR,
817 "%s: %s: Failed to set QoS Map: ioctl[IEEE80211_IOCTL_DBGREQ]: %s",
818 __func__, drv->iface, strerror(errno));
819 return -1;
820 }
821 #endif /* CONFIG_ATHEROS_QOS_MAP */
822
823 return 0;
824 }
825
826 #if defined(CONFIG_WPS) || defined(CONFIG_IEEE80211R) || defined(CONFIG_WNM) || defined(CONFIG_HS20)
atheros_raw_receive(void * ctx,const u8 * src_addr,const u8 * buf,size_t len)827 static void atheros_raw_receive(void *ctx, const u8 *src_addr, const u8 *buf,
828 size_t len)
829 {
830 struct atheros_driver_data *drv = ctx;
831 const struct ieee80211_mgmt *mgmt;
832 union wpa_event_data event;
833 u16 fc, stype;
834 int ielen;
835 const u8 *iebuf;
836
837 if (len < IEEE80211_HDRLEN)
838 return;
839
840 mgmt = (const struct ieee80211_mgmt *) buf;
841
842 fc = le_to_host16(mgmt->frame_control);
843
844 if (WLAN_FC_GET_TYPE(fc) != WLAN_FC_TYPE_MGMT)
845 return;
846
847 stype = WLAN_FC_GET_STYPE(fc);
848
849 wpa_printf(MSG_DEBUG, "%s: subtype 0x%x len %d", __func__, stype,
850 (int) len);
851
852 if (stype == WLAN_FC_STYPE_PROBE_REQ) {
853 if (len < IEEE80211_HDRLEN + sizeof(mgmt->u.probe_req))
854 return;
855
856 os_memset(&event, 0, sizeof(event));
857 event.rx_probe_req.sa = mgmt->sa;
858 event.rx_probe_req.da = mgmt->da;
859 event.rx_probe_req.bssid = mgmt->bssid;
860 event.rx_probe_req.ie = mgmt->u.probe_req.variable;
861 event.rx_probe_req.ie_len =
862 len - (IEEE80211_HDRLEN + sizeof(mgmt->u.probe_req));
863 wpa_supplicant_event(drv->hapd, EVENT_RX_PROBE_REQ, &event);
864 return;
865 }
866
867 if (os_memcmp(drv->own_addr, mgmt->bssid, ETH_ALEN) != 0) {
868 wpa_printf(MSG_DEBUG, "%s: BSSID does not match - ignore",
869 __func__);
870 return;
871 }
872
873 switch (stype) {
874 case WLAN_FC_STYPE_ASSOC_REQ:
875 if (len < IEEE80211_HDRLEN + sizeof(mgmt->u.assoc_req))
876 break;
877 ielen = len - (IEEE80211_HDRLEN + sizeof(mgmt->u.assoc_req));
878 iebuf = mgmt->u.assoc_req.variable;
879 drv_event_assoc(drv->hapd, mgmt->sa, iebuf, ielen, 0);
880 break;
881 case WLAN_FC_STYPE_REASSOC_REQ:
882 if (len < IEEE80211_HDRLEN + sizeof(mgmt->u.reassoc_req))
883 break;
884 ielen = len - (IEEE80211_HDRLEN + sizeof(mgmt->u.reassoc_req));
885 iebuf = mgmt->u.reassoc_req.variable;
886 drv_event_assoc(drv->hapd, mgmt->sa, iebuf, ielen, 1);
887 break;
888 case WLAN_FC_STYPE_ACTION:
889 os_memset(&event, 0, sizeof(event));
890 event.rx_mgmt.frame = buf;
891 event.rx_mgmt.frame_len = len;
892 wpa_supplicant_event(drv->hapd, EVENT_RX_MGMT, &event);
893 break;
894 case WLAN_FC_STYPE_AUTH:
895 if (len < IEEE80211_HDRLEN + sizeof(mgmt->u.auth))
896 break;
897 os_memset(&event, 0, sizeof(event));
898 os_memcpy(event.auth.peer, mgmt->sa, ETH_ALEN);
899 os_memcpy(event.auth.bssid, mgmt->bssid, ETH_ALEN);
900 event.auth.auth_type = le_to_host16(mgmt->u.auth.auth_alg);
901 event.auth.status_code =
902 le_to_host16(mgmt->u.auth.status_code);
903 event.auth.auth_transaction =
904 le_to_host16(mgmt->u.auth.auth_transaction);
905 event.auth.ies = mgmt->u.auth.variable;
906 event.auth.ies_len = len - IEEE80211_HDRLEN -
907 sizeof(mgmt->u.auth);
908 wpa_supplicant_event(drv->hapd, EVENT_AUTH, &event);
909 break;
910 default:
911 break;
912 }
913 }
914 #endif
915
atheros_receive_pkt(struct atheros_driver_data * drv)916 static int atheros_receive_pkt(struct atheros_driver_data *drv)
917 {
918 int ret = 0;
919 struct ieee80211req_set_filter filt;
920
921 wpa_printf(MSG_DEBUG, "%s Enter", __func__);
922 filt.app_filterype = 0;
923 #ifdef CONFIG_WPS
924 filt.app_filterype |= IEEE80211_FILTER_TYPE_PROBE_REQ;
925 #endif /* CONFIG_WPS */
926 #ifdef CONFIG_IEEE80211R
927 filt.app_filterype |= (IEEE80211_FILTER_TYPE_ASSOC_REQ |
928 IEEE80211_FILTER_TYPE_AUTH |
929 IEEE80211_FILTER_TYPE_ACTION);
930 #endif
931 #ifdef CONFIG_WNM
932 filt.app_filterype |= IEEE80211_FILTER_TYPE_ACTION;
933 #endif /* CONFIG_WNM */
934 #ifdef CONFIG_HS20
935 filt.app_filterype |= IEEE80211_FILTER_TYPE_ACTION;
936 #endif /* CONFIG_HS20 */
937 if (filt.app_filterype) {
938 ret = set80211priv(drv, IEEE80211_IOCTL_FILTERFRAME, &filt,
939 sizeof(struct ieee80211req_set_filter));
940 if (ret)
941 return ret;
942 }
943
944 #if defined(CONFIG_WPS) || defined(CONFIG_IEEE80211R)
945 drv->sock_raw = l2_packet_init(drv->iface, NULL, ETH_P_80211_RAW,
946 atheros_raw_receive, drv, 1);
947 if (drv->sock_raw == NULL)
948 return -1;
949 #endif /* CONFIG_WPS || CONFIG_IEEE80211R */
950 return ret;
951 }
952
atheros_reset_appfilter(struct atheros_driver_data * drv)953 static int atheros_reset_appfilter(struct atheros_driver_data *drv)
954 {
955 struct ieee80211req_set_filter filt;
956 filt.app_filterype = 0;
957 return set80211priv(drv, IEEE80211_IOCTL_FILTERFRAME, &filt,
958 sizeof(struct ieee80211req_set_filter));
959 }
960
961 #ifdef CONFIG_WPS
962 static int
atheros_set_wps_ie(void * priv,const u8 * ie,size_t len,u32 frametype)963 atheros_set_wps_ie(void *priv, const u8 *ie, size_t len, u32 frametype)
964 {
965 struct atheros_driver_data *drv = priv;
966 u8 buf[512];
967 struct ieee80211req_getset_appiebuf *beac_ie;
968
969 wpa_printf(MSG_DEBUG, "%s buflen = %lu frametype=%u", __func__,
970 (unsigned long) len, frametype);
971 wpa_hexdump(MSG_DEBUG, "atheros: IE", ie, len);
972
973 beac_ie = (struct ieee80211req_getset_appiebuf *) buf;
974 beac_ie->app_frmtype = frametype;
975 beac_ie->app_buflen = len;
976 os_memcpy(&(beac_ie->app_buf[0]), ie, len);
977
978 /* append the WPA/RSN IE if it is set already */
979 if (((frametype == IEEE80211_APPIE_FRAME_BEACON) ||
980 (frametype == IEEE80211_APPIE_FRAME_PROBE_RESP)) &&
981 (drv->wpa_ie != NULL)) {
982 wpa_hexdump_buf(MSG_DEBUG, "atheros: Append WPA/RSN IE",
983 drv->wpa_ie);
984 os_memcpy(&(beac_ie->app_buf[len]), wpabuf_head(drv->wpa_ie),
985 wpabuf_len(drv->wpa_ie));
986 beac_ie->app_buflen += wpabuf_len(drv->wpa_ie);
987 }
988
989 wpa_hexdump(MSG_DEBUG, "atheros: SET_APPIEBUF",
990 beac_ie->app_buf, beac_ie->app_buflen);
991 return set80211priv(drv, IEEE80211_IOCTL_SET_APPIEBUF, beac_ie,
992 sizeof(struct ieee80211req_getset_appiebuf) +
993 beac_ie->app_buflen);
994 }
995
996 static int
atheros_set_ap_wps_ie(void * priv,const struct wpabuf * beacon,const struct wpabuf * proberesp,const struct wpabuf * assocresp)997 atheros_set_ap_wps_ie(void *priv, const struct wpabuf *beacon,
998 const struct wpabuf *proberesp,
999 const struct wpabuf *assocresp)
1000 {
1001 struct atheros_driver_data *drv = priv;
1002
1003 wpa_hexdump_buf(MSG_DEBUG, "atheros: set_ap_wps_ie - beacon", beacon);
1004 wpa_hexdump_buf(MSG_DEBUG, "atheros: set_ap_wps_ie - proberesp",
1005 proberesp);
1006 wpa_hexdump_buf(MSG_DEBUG, "atheros: set_ap_wps_ie - assocresp",
1007 assocresp);
1008 wpabuf_free(drv->wps_beacon_ie);
1009 drv->wps_beacon_ie = beacon ? wpabuf_dup(beacon) : NULL;
1010 wpabuf_free(drv->wps_probe_resp_ie);
1011 drv->wps_probe_resp_ie = proberesp ? wpabuf_dup(proberesp) : NULL;
1012
1013 atheros_set_wps_ie(priv, assocresp ? wpabuf_head(assocresp) : NULL,
1014 assocresp ? wpabuf_len(assocresp) : 0,
1015 IEEE80211_APPIE_FRAME_ASSOC_RESP);
1016 if (atheros_set_wps_ie(priv, beacon ? wpabuf_head(beacon) : NULL,
1017 beacon ? wpabuf_len(beacon) : 0,
1018 IEEE80211_APPIE_FRAME_BEACON))
1019 return -1;
1020 return atheros_set_wps_ie(priv,
1021 proberesp ? wpabuf_head(proberesp) : NULL,
1022 proberesp ? wpabuf_len(proberesp): 0,
1023 IEEE80211_APPIE_FRAME_PROBE_RESP);
1024 }
1025 #else /* CONFIG_WPS */
1026 #define atheros_set_ap_wps_ie NULL
1027 #endif /* CONFIG_WPS */
1028
1029 #ifdef CONFIG_IEEE80211R
1030 static int
atheros_sta_auth(void * priv,const u8 * own_addr,const u8 * addr,u16 seq,u16 status_code,const u8 * ie,size_t len)1031 atheros_sta_auth(void *priv, const u8 *own_addr, const u8 *addr, u16 seq,
1032 u16 status_code, const u8 *ie, size_t len)
1033 {
1034 struct atheros_driver_data *drv = priv;
1035 struct ieee80211req_mlme mlme;
1036 int ret;
1037
1038 wpa_printf(MSG_DEBUG, "%s: addr=%s status_code=%d",
1039 __func__, ether_sprintf(addr), status_code);
1040
1041 mlme.im_op = IEEE80211_MLME_AUTH;
1042 mlme.im_reason = status_code;
1043 mlme.im_seq = seq;
1044 os_memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN);
1045 mlme.im_optie_len = len;
1046 if (len) {
1047 if (len < IEEE80211_MAX_OPT_IE) {
1048 os_memcpy(mlme.im_optie, ie, len);
1049 } else {
1050 wpa_printf(MSG_DEBUG, "%s: Not enough space to copy "
1051 "opt_ie STA (addr " MACSTR " reason %d, "
1052 "ie_len %d)",
1053 __func__, MAC2STR(addr), status_code,
1054 (int) len);
1055 return -1;
1056 }
1057 }
1058 ret = set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme));
1059 if (ret < 0) {
1060 wpa_printf(MSG_DEBUG, "%s: Failed to auth STA (addr " MACSTR
1061 " reason %d)",
1062 __func__, MAC2STR(addr), status_code);
1063 }
1064 return ret;
1065 }
1066
1067 static int
atheros_sta_assoc(void * priv,const u8 * own_addr,const u8 * addr,int reassoc,u16 status_code,const u8 * ie,size_t len)1068 atheros_sta_assoc(void *priv, const u8 *own_addr, const u8 *addr,
1069 int reassoc, u16 status_code, const u8 *ie, size_t len)
1070 {
1071 struct atheros_driver_data *drv = priv;
1072 struct ieee80211req_mlme mlme;
1073 int ret;
1074
1075 wpa_printf(MSG_DEBUG, "%s: addr=%s status_code=%d reassoc %d",
1076 __func__, ether_sprintf(addr), status_code, reassoc);
1077
1078 if (reassoc)
1079 mlme.im_op = IEEE80211_MLME_REASSOC;
1080 else
1081 mlme.im_op = IEEE80211_MLME_ASSOC;
1082 mlme.im_reason = status_code;
1083 os_memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN);
1084 mlme.im_optie_len = len;
1085 if (len) {
1086 if (len < IEEE80211_MAX_OPT_IE) {
1087 os_memcpy(mlme.im_optie, ie, len);
1088 } else {
1089 wpa_printf(MSG_DEBUG, "%s: Not enough space to copy "
1090 "opt_ie STA (addr " MACSTR " reason %d, "
1091 "ie_len %d)",
1092 __func__, MAC2STR(addr), status_code,
1093 (int) len);
1094 return -1;
1095 }
1096 }
1097 ret = set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme));
1098 if (ret < 0) {
1099 wpa_printf(MSG_DEBUG, "%s: Failed to assoc STA (addr " MACSTR
1100 " reason %d)",
1101 __func__, MAC2STR(addr), status_code);
1102 }
1103 return ret;
1104 }
1105 #endif /* CONFIG_IEEE80211R */
1106
1107 static void
atheros_new_sta(struct atheros_driver_data * drv,u8 addr[IEEE80211_ADDR_LEN])1108 atheros_new_sta(struct atheros_driver_data *drv, u8 addr[IEEE80211_ADDR_LEN])
1109 {
1110 struct hostapd_data *hapd = drv->hapd;
1111 struct ieee80211req_wpaie ie;
1112 int ielen = 0;
1113 u8 *iebuf = NULL;
1114
1115 /*
1116 * Fetch negotiated WPA/RSN parameters from the system.
1117 */
1118 memset(&ie, 0, sizeof(ie));
1119 memcpy(ie.wpa_macaddr, addr, IEEE80211_ADDR_LEN);
1120 if (set80211priv(drv, IEEE80211_IOCTL_GETWPAIE, &ie, sizeof(ie))) {
1121 /*
1122 * See ATH_WPS_IE comment in the beginning of the file for a
1123 * possible cause for the failure..
1124 */
1125 wpa_printf(MSG_DEBUG, "%s: Failed to get WPA/RSN IE: %s",
1126 __func__, strerror(errno));
1127 goto no_ie;
1128 }
1129 wpa_hexdump(MSG_MSGDUMP, "atheros req WPA IE",
1130 ie.wpa_ie, IEEE80211_MAX_OPT_IE);
1131 wpa_hexdump(MSG_MSGDUMP, "atheros req RSN IE",
1132 ie.rsn_ie, IEEE80211_MAX_OPT_IE);
1133 #ifdef ATH_WPS_IE
1134 wpa_hexdump(MSG_MSGDUMP, "atheros req WPS IE",
1135 ie.wps_ie, IEEE80211_MAX_OPT_IE);
1136 #endif /* ATH_WPS_IE */
1137 iebuf = ie.wpa_ie;
1138 /* atheros seems to return some random data if WPA/RSN IE is not set.
1139 * Assume the IE was not included if the IE type is unknown. */
1140 if (iebuf[0] != WLAN_EID_VENDOR_SPECIFIC)
1141 iebuf[1] = 0;
1142 if (iebuf[1] == 0 && ie.rsn_ie[1] > 0) {
1143 /* atheros-ng svn #1453 added rsn_ie. Use it, if wpa_ie was not
1144 * set. This is needed for WPA2. */
1145 iebuf = ie.rsn_ie;
1146 if (iebuf[0] != WLAN_EID_RSN)
1147 iebuf[1] = 0;
1148 }
1149
1150 ielen = iebuf[1];
1151
1152 #ifdef ATH_WPS_IE
1153 /* if WPS IE is present, preference is given to WPS */
1154 if (ie.wps_ie &&
1155 (ie.wps_ie[1] > 0 && (ie.wps_ie[0] == WLAN_EID_VENDOR_SPECIFIC))) {
1156 iebuf = ie.wps_ie;
1157 ielen = ie.wps_ie[1];
1158 }
1159 #endif /* ATH_WPS_IE */
1160
1161 if (ielen == 0)
1162 iebuf = NULL;
1163 else
1164 ielen += 2;
1165
1166 no_ie:
1167 drv_event_assoc(hapd, addr, iebuf, ielen, 0);
1168
1169 if (memcmp(addr, drv->acct_mac, ETH_ALEN) == 0) {
1170 /* Cached accounting data is not valid anymore. */
1171 memset(drv->acct_mac, 0, ETH_ALEN);
1172 memset(&drv->acct_data, 0, sizeof(drv->acct_data));
1173 }
1174 }
1175
1176 static void
atheros_wireless_event_wireless_custom(struct atheros_driver_data * drv,char * custom,char * end)1177 atheros_wireless_event_wireless_custom(struct atheros_driver_data *drv,
1178 char *custom, char *end)
1179 {
1180 wpa_printf(MSG_DEBUG, "Custom wireless event: '%s'", custom);
1181
1182 if (strncmp(custom, "MLME-MICHAELMICFAILURE.indication", 33) == 0) {
1183 char *pos;
1184 u8 addr[ETH_ALEN];
1185 pos = strstr(custom, "addr=");
1186 if (pos == NULL) {
1187 wpa_printf(MSG_DEBUG,
1188 "MLME-MICHAELMICFAILURE.indication "
1189 "without sender address ignored");
1190 return;
1191 }
1192 pos += 5;
1193 if (hwaddr_aton(pos, addr) == 0) {
1194 union wpa_event_data data;
1195 os_memset(&data, 0, sizeof(data));
1196 data.michael_mic_failure.unicast = 1;
1197 data.michael_mic_failure.src = addr;
1198 wpa_supplicant_event(drv->hapd,
1199 EVENT_MICHAEL_MIC_FAILURE, &data);
1200 } else {
1201 wpa_printf(MSG_DEBUG,
1202 "MLME-MICHAELMICFAILURE.indication "
1203 "with invalid MAC address");
1204 }
1205 } else if (strncmp(custom, "STA-TRAFFIC-STAT", 16) == 0) {
1206 char *key, *value;
1207 u32 val;
1208 key = custom;
1209 while ((key = strchr(key, '\n')) != NULL) {
1210 key++;
1211 value = strchr(key, '=');
1212 if (value == NULL)
1213 continue;
1214 *value++ = '\0';
1215 val = strtoul(value, NULL, 10);
1216 if (strcmp(key, "mac") == 0)
1217 hwaddr_aton(value, drv->acct_mac);
1218 else if (strcmp(key, "rx_packets") == 0)
1219 drv->acct_data.rx_packets = val;
1220 else if (strcmp(key, "tx_packets") == 0)
1221 drv->acct_data.tx_packets = val;
1222 else if (strcmp(key, "rx_bytes") == 0)
1223 drv->acct_data.rx_bytes = val;
1224 else if (strcmp(key, "tx_bytes") == 0)
1225 drv->acct_data.tx_bytes = val;
1226 key = value;
1227 }
1228 #ifdef CONFIG_WPS
1229 } else if (strncmp(custom, "PUSH-BUTTON.indication", 22) == 0) {
1230 /* Some atheros kernels send push button as a wireless event */
1231 /* PROBLEM! this event is received for ALL BSSs ...
1232 * so all are enabled for WPS... ugh.
1233 */
1234 wpa_supplicant_event(drv->hapd, EVENT_WPS_BUTTON_PUSHED, NULL);
1235 #endif /* CONFIG_WPS */
1236 #if defined(CONFIG_WPS) || defined(CONFIG_IEEE80211R) || defined(CONFIG_HS20)
1237 #define MGMT_FRAM_TAG_SIZE 30 /* hardcoded in driver */
1238 } else if (strncmp(custom, "Manage.prob_req ", 16) == 0) {
1239 /*
1240 * Atheros driver uses a hack to pass Probe Request frames as a
1241 * binary data in the custom wireless event. The old way (using
1242 * packet sniffing) didn't work when bridging.
1243 * Format: "Manage.prob_req <frame len>" | zero padding | frame
1244 */
1245 int len = atoi(custom + 16);
1246 if (len < 0 || custom + MGMT_FRAM_TAG_SIZE + len > end) {
1247 wpa_printf(MSG_DEBUG, "Invalid Manage.prob_req event "
1248 "length %d", len);
1249 return;
1250 }
1251 atheros_raw_receive(drv, NULL,
1252 (u8 *) custom + MGMT_FRAM_TAG_SIZE, len);
1253 } else if (strncmp(custom, "Manage.assoc_req ", 17) == 0) {
1254 /* Format: "Manage.assoc_req <frame len>" | zero padding |
1255 * frame */
1256 int len = atoi(custom + 17);
1257 if (len < 0 || custom + MGMT_FRAM_TAG_SIZE + len > end) {
1258 wpa_printf(MSG_DEBUG, "Invalid Manage.prob_req/"
1259 "assoc_req/auth event length %d", len);
1260 return;
1261 }
1262 atheros_raw_receive(drv, NULL,
1263 (u8 *) custom + MGMT_FRAM_TAG_SIZE, len);
1264 } else if (strncmp(custom, "Manage.action ", 14) == 0) {
1265 /* Format: "Manage.assoc_req <frame len>" | zero padding |
1266 * frame */
1267 int len = atoi(custom + 14);
1268 if (len < 0 || custom + MGMT_FRAM_TAG_SIZE + len > end) {
1269 wpa_printf(MSG_DEBUG, "Invalid Manage.prob_req/"
1270 "assoc_req/auth event length %d", len);
1271 return;
1272 }
1273 atheros_raw_receive(drv, NULL,
1274 (u8 *) custom + MGMT_FRAM_TAG_SIZE, len);
1275 } else if (strncmp(custom, "Manage.auth ", 12) == 0) {
1276 /* Format: "Manage.auth <frame len>" | zero padding | frame
1277 */
1278 int len = atoi(custom + 12);
1279 if (len < 0 || custom + MGMT_FRAM_TAG_SIZE + len > end) {
1280 wpa_printf(MSG_DEBUG, "Invalid Manage.prob_req/"
1281 "assoc_req/auth event length %d", len);
1282 return;
1283 }
1284 atheros_raw_receive(drv, NULL,
1285 (u8 *) custom + MGMT_FRAM_TAG_SIZE, len);
1286 #endif /* CONFIG_WPS or CONFIG_IEEE80211R */
1287 }
1288 }
1289
1290 /*
1291 * Handle size of data problem. WEXT only allows data of 256 bytes for custom
1292 * events, and p2p data can be much bigger. So the athr driver sends a small
1293 * event telling me to collect the big data with an ioctl.
1294 * On the first event, send all pending events to supplicant.
1295 */
fetch_pending_big_events(struct atheros_driver_data * drv)1296 static void fetch_pending_big_events(struct atheros_driver_data *drv)
1297 {
1298 union wpa_event_data event;
1299 const struct ieee80211_mgmt *mgmt;
1300 u8 tbuf[IW_PRIV_SIZE_MASK]; /* max size is 2047 bytes */
1301 u16 fc, stype;
1302 struct iwreq iwr;
1303 size_t data_len;
1304 u32 freq, frame_type;
1305
1306 while (1) {
1307 os_memset(&iwr, 0, sizeof(iwr));
1308 os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ);
1309
1310 iwr.u.data.pointer = (void *) tbuf;
1311 iwr.u.data.length = sizeof(tbuf);
1312 iwr.u.data.flags = IEEE80211_IOC_P2P_FETCH_FRAME;
1313
1314 if (ioctl(drv->ioctl_sock, IEEE80211_IOCTL_P2P_BIG_PARAM, &iwr)
1315 < 0) {
1316 if (errno == ENOSPC) {
1317 wpa_printf(MSG_DEBUG, "%s:%d exit",
1318 __func__, __LINE__);
1319 return;
1320 }
1321 wpa_printf(MSG_DEBUG, "athr: %s: P2P_BIG_PARAM["
1322 "P2P_FETCH_FRAME] failed: %s",
1323 __func__, strerror(errno));
1324 return;
1325 }
1326 data_len = iwr.u.data.length;
1327 wpa_hexdump(MSG_DEBUG, "athr: P2P_FETCH_FRAME data",
1328 (u8 *) tbuf, data_len);
1329 if (data_len < sizeof(freq) + sizeof(frame_type) + 24) {
1330 wpa_printf(MSG_DEBUG, "athr: frame too short");
1331 continue;
1332 }
1333 os_memcpy(&freq, tbuf, sizeof(freq));
1334 os_memcpy(&frame_type, &tbuf[sizeof(freq)],
1335 sizeof(frame_type));
1336 mgmt = (void *) &tbuf[sizeof(freq) + sizeof(frame_type)];
1337 data_len -= sizeof(freq) + sizeof(frame_type);
1338
1339 if (frame_type == IEEE80211_EV_RX_MGMT) {
1340 fc = le_to_host16(mgmt->frame_control);
1341 stype = WLAN_FC_GET_STYPE(fc);
1342
1343 wpa_printf(MSG_DEBUG, "athr: EV_RX_MGMT stype=%u "
1344 "freq=%u len=%u", stype, freq, (int) data_len);
1345
1346 if (stype == WLAN_FC_STYPE_ACTION) {
1347 os_memset(&event, 0, sizeof(event));
1348 event.rx_mgmt.frame = (const u8 *) mgmt;
1349 event.rx_mgmt.frame_len = data_len;
1350 wpa_supplicant_event(drv->hapd, EVENT_RX_MGMT,
1351 &event);
1352 continue;
1353 }
1354 } else {
1355 wpa_printf(MSG_DEBUG, "athr: %s unknown type %d",
1356 __func__, frame_type);
1357 continue;
1358 }
1359 }
1360 }
1361
1362 static void
atheros_wireless_event_atheros_custom(struct atheros_driver_data * drv,int opcode,char * buf,int len)1363 atheros_wireless_event_atheros_custom(struct atheros_driver_data *drv,
1364 int opcode, char *buf, int len)
1365 {
1366 switch (opcode) {
1367 case IEEE80211_EV_RX_MGMT:
1368 wpa_printf(MSG_DEBUG, "WEXT: EV_RX_MGMT");
1369 fetch_pending_big_events(drv);
1370 break;
1371 default:
1372 break;
1373 }
1374 }
1375
1376 static void
atheros_wireless_event_wireless(struct atheros_driver_data * drv,char * data,int len)1377 atheros_wireless_event_wireless(struct atheros_driver_data *drv,
1378 char *data, int len)
1379 {
1380 struct iw_event iwe_buf, *iwe = &iwe_buf;
1381 char *pos, *end, *custom, *buf;
1382
1383 pos = data;
1384 end = data + len;
1385
1386 while (pos + IW_EV_LCP_LEN <= end) {
1387 /* Event data may be unaligned, so make a local, aligned copy
1388 * before processing. */
1389 memcpy(&iwe_buf, pos, IW_EV_LCP_LEN);
1390 wpa_printf(MSG_MSGDUMP, "Wireless event: cmd=0x%x len=%d",
1391 iwe->cmd, iwe->len);
1392 if (iwe->len <= IW_EV_LCP_LEN)
1393 return;
1394
1395 custom = pos + IW_EV_POINT_LEN;
1396 if (drv->we_version > 18 &&
1397 (iwe->cmd == IWEVMICHAELMICFAILURE ||
1398 iwe->cmd == IWEVASSOCREQIE ||
1399 iwe->cmd == IWEVCUSTOM)) {
1400 /* WE-19 removed the pointer from struct iw_point */
1401 char *dpos = (char *) &iwe_buf.u.data.length;
1402 int dlen = dpos - (char *) &iwe_buf;
1403 memcpy(dpos, pos + IW_EV_LCP_LEN,
1404 sizeof(struct iw_event) - dlen);
1405 } else {
1406 memcpy(&iwe_buf, pos, sizeof(struct iw_event));
1407 custom += IW_EV_POINT_OFF;
1408 }
1409
1410 switch (iwe->cmd) {
1411 case IWEVEXPIRED:
1412 drv_event_disassoc(drv->hapd,
1413 (u8 *) iwe->u.addr.sa_data);
1414 break;
1415 case IWEVREGISTERED:
1416 atheros_new_sta(drv, (u8 *) iwe->u.addr.sa_data);
1417 break;
1418 case IWEVASSOCREQIE:
1419 /* Driver hack.. Use IWEVASSOCREQIE to bypass
1420 * IWEVCUSTOM size limitations. Need to handle this
1421 * just like IWEVCUSTOM.
1422 */
1423 case IWEVCUSTOM:
1424 if (custom + iwe->u.data.length > end)
1425 return;
1426 buf = malloc(iwe->u.data.length + 1);
1427 if (buf == NULL)
1428 return; /* XXX */
1429 memcpy(buf, custom, iwe->u.data.length);
1430 buf[iwe->u.data.length] = '\0';
1431
1432 if (iwe->u.data.flags != 0) {
1433 atheros_wireless_event_atheros_custom(
1434 drv, (int) iwe->u.data.flags,
1435 buf, len);
1436 } else {
1437 atheros_wireless_event_wireless_custom(
1438 drv, buf, buf + iwe->u.data.length);
1439 }
1440 free(buf);
1441 break;
1442 }
1443
1444 pos += iwe->len;
1445 }
1446 }
1447
1448
1449 static void
atheros_wireless_event_rtm_newlink(void * ctx,struct ifinfomsg * ifi,u8 * buf,size_t len)1450 atheros_wireless_event_rtm_newlink(void *ctx,
1451 struct ifinfomsg *ifi, u8 *buf, size_t len)
1452 {
1453 struct atheros_driver_data *drv = ctx;
1454 int attrlen, rta_len;
1455 struct rtattr *attr;
1456
1457 if (ifi->ifi_index != drv->ifindex)
1458 return;
1459
1460 attrlen = len;
1461 attr = (struct rtattr *) buf;
1462
1463 rta_len = RTA_ALIGN(sizeof(struct rtattr));
1464 while (RTA_OK(attr, attrlen)) {
1465 if (attr->rta_type == IFLA_WIRELESS) {
1466 atheros_wireless_event_wireless(
1467 drv, ((char *) attr) + rta_len,
1468 attr->rta_len - rta_len);
1469 }
1470 attr = RTA_NEXT(attr, attrlen);
1471 }
1472 }
1473
1474
1475 static int
atheros_get_we_version(struct atheros_driver_data * drv)1476 atheros_get_we_version(struct atheros_driver_data *drv)
1477 {
1478 struct iw_range *range;
1479 struct iwreq iwr;
1480 int minlen;
1481 size_t buflen;
1482
1483 drv->we_version = 0;
1484
1485 /*
1486 * Use larger buffer than struct iw_range in order to allow the
1487 * structure to grow in the future.
1488 */
1489 buflen = sizeof(struct iw_range) + 500;
1490 range = os_zalloc(buflen);
1491 if (range == NULL)
1492 return -1;
1493
1494 memset(&iwr, 0, sizeof(iwr));
1495 os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ);
1496 iwr.u.data.pointer = (caddr_t) range;
1497 iwr.u.data.length = buflen;
1498
1499 minlen = ((char *) &range->enc_capa) - (char *) range +
1500 sizeof(range->enc_capa);
1501
1502 if (ioctl(drv->ioctl_sock, SIOCGIWRANGE, &iwr) < 0) {
1503 wpa_printf(MSG_ERROR, "ioctl[SIOCGIWRANGE]: %s",
1504 strerror(errno));
1505 os_free(range);
1506 return -1;
1507 } else if (iwr.u.data.length >= minlen &&
1508 range->we_version_compiled >= 18) {
1509 wpa_printf(MSG_DEBUG, "SIOCGIWRANGE: WE(compiled)=%d "
1510 "WE(source)=%d enc_capa=0x%x",
1511 range->we_version_compiled,
1512 range->we_version_source,
1513 range->enc_capa);
1514 drv->we_version = range->we_version_compiled;
1515 }
1516
1517 os_free(range);
1518 return 0;
1519 }
1520
1521
1522 static int
atheros_wireless_event_init(struct atheros_driver_data * drv)1523 atheros_wireless_event_init(struct atheros_driver_data *drv)
1524 {
1525 struct netlink_config *cfg;
1526
1527 atheros_get_we_version(drv);
1528
1529 cfg = os_zalloc(sizeof(*cfg));
1530 if (cfg == NULL)
1531 return -1;
1532 cfg->ctx = drv;
1533 cfg->newlink_cb = atheros_wireless_event_rtm_newlink;
1534 drv->netlink = netlink_init(cfg);
1535 if (drv->netlink == NULL) {
1536 os_free(cfg);
1537 return -1;
1538 }
1539
1540 return 0;
1541 }
1542
1543
1544 static int
atheros_send_eapol(void * priv,const u8 * addr,const u8 * data,size_t data_len,int encrypt,const u8 * own_addr,u32 flags)1545 atheros_send_eapol(void *priv, const u8 *addr, const u8 *data, size_t data_len,
1546 int encrypt, const u8 *own_addr, u32 flags)
1547 {
1548 struct atheros_driver_data *drv = priv;
1549 unsigned char buf[3000];
1550 unsigned char *bp = buf;
1551 struct l2_ethhdr *eth;
1552 size_t len;
1553 int status;
1554
1555 /*
1556 * Prepend the Ethernet header. If the caller left us
1557 * space at the front we could just insert it but since
1558 * we don't know we copy to a local buffer. Given the frequency
1559 * and size of frames this probably doesn't matter.
1560 */
1561 len = data_len + sizeof(struct l2_ethhdr);
1562 if (len > sizeof(buf)) {
1563 bp = malloc(len);
1564 if (bp == NULL) {
1565 wpa_printf(MSG_INFO,
1566 "EAPOL frame discarded, cannot malloc temp buffer of size %lu!",
1567 (unsigned long) len);
1568 return -1;
1569 }
1570 }
1571 eth = (struct l2_ethhdr *) bp;
1572 memcpy(eth->h_dest, addr, ETH_ALEN);
1573 memcpy(eth->h_source, own_addr, ETH_ALEN);
1574 eth->h_proto = host_to_be16(ETH_P_EAPOL);
1575 memcpy(eth+1, data, data_len);
1576
1577 wpa_hexdump(MSG_MSGDUMP, "TX EAPOL", bp, len);
1578
1579 status = l2_packet_send(drv->sock_xmit, addr, ETH_P_EAPOL, bp, len);
1580
1581 if (bp != buf)
1582 free(bp);
1583 return status;
1584 }
1585
1586 static void
handle_read(void * ctx,const u8 * src_addr,const u8 * buf,size_t len)1587 handle_read(void *ctx, const u8 *src_addr, const u8 *buf, size_t len)
1588 {
1589 struct atheros_driver_data *drv = ctx;
1590 drv_event_eapol_rx(drv->hapd, src_addr, buf + sizeof(struct l2_ethhdr),
1591 len - sizeof(struct l2_ethhdr));
1592 }
1593
1594 static void *
atheros_init(struct hostapd_data * hapd,struct wpa_init_params * params)1595 atheros_init(struct hostapd_data *hapd, struct wpa_init_params *params)
1596 {
1597 struct atheros_driver_data *drv;
1598 struct ifreq ifr;
1599 struct iwreq iwr;
1600 char brname[IFNAMSIZ];
1601
1602 drv = os_zalloc(sizeof(struct atheros_driver_data));
1603 if (drv == NULL) {
1604 wpa_printf(MSG_INFO,
1605 "Could not allocate memory for atheros driver data");
1606 return NULL;
1607 }
1608
1609 drv->hapd = hapd;
1610 drv->ioctl_sock = socket(PF_INET, SOCK_DGRAM, 0);
1611 if (drv->ioctl_sock < 0) {
1612 wpa_printf(MSG_ERROR, "socket[PF_INET,SOCK_DGRAM]: %s",
1613 strerror(errno));
1614 goto bad;
1615 }
1616 memcpy(drv->iface, params->ifname, sizeof(drv->iface));
1617
1618 memset(&ifr, 0, sizeof(ifr));
1619 os_strlcpy(ifr.ifr_name, drv->iface, sizeof(ifr.ifr_name));
1620 if (ioctl(drv->ioctl_sock, SIOCGIFINDEX, &ifr) != 0) {
1621 wpa_printf(MSG_ERROR, "ioctl(SIOCGIFINDEX): %s",
1622 strerror(errno));
1623 goto bad;
1624 }
1625 drv->ifindex = ifr.ifr_ifindex;
1626
1627 drv->sock_xmit = l2_packet_init(drv->iface, NULL, ETH_P_EAPOL,
1628 handle_read, drv, 1);
1629 if (drv->sock_xmit == NULL)
1630 goto bad;
1631 if (l2_packet_get_own_addr(drv->sock_xmit, params->own_addr))
1632 goto bad;
1633 os_memcpy(drv->own_addr, params->own_addr, ETH_ALEN);
1634 if (params->bridge[0]) {
1635 wpa_printf(MSG_DEBUG, "Configure bridge %s for EAPOL traffic.",
1636 params->bridge[0]);
1637 drv->sock_recv = l2_packet_init(params->bridge[0], NULL,
1638 ETH_P_EAPOL, handle_read, drv,
1639 1);
1640 if (drv->sock_recv == NULL)
1641 goto bad;
1642 } else if (linux_br_get(brname, drv->iface) == 0) {
1643 wpa_printf(MSG_DEBUG, "Interface in bridge %s; configure for "
1644 "EAPOL receive", brname);
1645 drv->sock_recv = l2_packet_init(brname, NULL, ETH_P_EAPOL,
1646 handle_read, drv, 1);
1647 if (drv->sock_recv == NULL)
1648 goto bad;
1649 } else
1650 drv->sock_recv = drv->sock_xmit;
1651
1652 memset(&iwr, 0, sizeof(iwr));
1653 os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ);
1654
1655 iwr.u.mode = IW_MODE_MASTER;
1656
1657 if (ioctl(drv->ioctl_sock, SIOCSIWMODE, &iwr) < 0) {
1658 wpa_printf(MSG_ERROR,
1659 "Could not set interface to master mode! ioctl[SIOCSIWMODE]: %s",
1660 strerror(errno));
1661 goto bad;
1662 }
1663
1664 /* mark down during setup */
1665 linux_set_iface_flags(drv->ioctl_sock, drv->iface, 0);
1666 atheros_set_privacy(drv, 0); /* default to no privacy */
1667
1668 if (atheros_receive_pkt(drv))
1669 goto bad;
1670
1671 if (atheros_wireless_event_init(drv))
1672 goto bad;
1673
1674 return drv;
1675 bad:
1676 atheros_reset_appfilter(drv);
1677 if (drv->sock_raw)
1678 l2_packet_deinit(drv->sock_raw);
1679 if (drv->sock_recv != NULL && drv->sock_recv != drv->sock_xmit)
1680 l2_packet_deinit(drv->sock_recv);
1681 if (drv->sock_xmit != NULL)
1682 l2_packet_deinit(drv->sock_xmit);
1683 if (drv->ioctl_sock >= 0)
1684 close(drv->ioctl_sock);
1685 os_free(drv);
1686 return NULL;
1687 }
1688
1689
1690 static void
atheros_deinit(void * priv)1691 atheros_deinit(void *priv)
1692 {
1693 struct atheros_driver_data *drv = priv;
1694
1695 atheros_reset_appfilter(drv);
1696
1697 if (drv->wpa_ie || drv->wps_beacon_ie || drv->wps_probe_resp_ie) {
1698 wpabuf_free(drv->wpa_ie);
1699 wpabuf_free(drv->wps_beacon_ie);
1700 wpabuf_free(drv->wps_probe_resp_ie);
1701 atheros_set_opt_ie(priv, NULL, 0);
1702 }
1703 netlink_deinit(drv->netlink);
1704 (void) linux_set_iface_flags(drv->ioctl_sock, drv->iface, 0);
1705 if (drv->ioctl_sock >= 0)
1706 close(drv->ioctl_sock);
1707 if (drv->sock_recv != NULL && drv->sock_recv != drv->sock_xmit)
1708 l2_packet_deinit(drv->sock_recv);
1709 if (drv->sock_xmit != NULL)
1710 l2_packet_deinit(drv->sock_xmit);
1711 if (drv->sock_raw)
1712 l2_packet_deinit(drv->sock_raw);
1713 os_free(drv);
1714 }
1715
1716 static int
atheros_set_ssid(void * priv,const u8 * buf,int len)1717 atheros_set_ssid(void *priv, const u8 *buf, int len)
1718 {
1719 struct atheros_driver_data *drv = priv;
1720 struct iwreq iwr;
1721
1722 memset(&iwr, 0, sizeof(iwr));
1723 os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ);
1724 iwr.u.essid.flags = 1; /* SSID active */
1725 iwr.u.essid.pointer = (caddr_t) buf;
1726 iwr.u.essid.length = len + 1;
1727
1728 if (ioctl(drv->ioctl_sock, SIOCSIWESSID, &iwr) < 0) {
1729 wpa_printf(MSG_ERROR, "ioctl[SIOCSIWESSID,len=%d]: %s",
1730 len, strerror(errno));
1731 return -1;
1732 }
1733 return 0;
1734 }
1735
1736 static int
atheros_get_ssid(void * priv,u8 * buf,int len)1737 atheros_get_ssid(void *priv, u8 *buf, int len)
1738 {
1739 struct atheros_driver_data *drv = priv;
1740 struct iwreq iwr;
1741 int ret = 0;
1742
1743 memset(&iwr, 0, sizeof(iwr));
1744 os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ);
1745 iwr.u.essid.pointer = (caddr_t) buf;
1746 iwr.u.essid.length = (len > IW_ESSID_MAX_SIZE) ?
1747 IW_ESSID_MAX_SIZE : len;
1748
1749 if (ioctl(drv->ioctl_sock, SIOCGIWESSID, &iwr) < 0) {
1750 wpa_printf(MSG_ERROR, "ioctl[SIOCGIWESSID]: %s",
1751 strerror(errno));
1752 ret = -1;
1753 } else
1754 ret = iwr.u.essid.length;
1755
1756 return ret;
1757 }
1758
1759 static int
atheros_set_countermeasures(void * priv,int enabled)1760 atheros_set_countermeasures(void *priv, int enabled)
1761 {
1762 struct atheros_driver_data *drv = priv;
1763 wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled);
1764 return set80211param(drv, IEEE80211_PARAM_COUNTERMEASURES, enabled);
1765 }
1766
1767 static int
atheros_commit(void * priv)1768 atheros_commit(void *priv)
1769 {
1770 struct atheros_driver_data *drv = priv;
1771 return linux_set_iface_flags(drv->ioctl_sock, drv->iface, 1);
1772 }
1773
atheros_set_authmode(void * priv,int auth_algs)1774 static int atheros_set_authmode(void *priv, int auth_algs)
1775 {
1776 int authmode;
1777
1778 if ((auth_algs & WPA_AUTH_ALG_OPEN) &&
1779 (auth_algs & WPA_AUTH_ALG_SHARED))
1780 authmode = IEEE80211_AUTH_AUTO;
1781 else if (auth_algs & WPA_AUTH_ALG_OPEN)
1782 authmode = IEEE80211_AUTH_OPEN;
1783 else if (auth_algs & WPA_AUTH_ALG_SHARED)
1784 authmode = IEEE80211_AUTH_SHARED;
1785 else
1786 return -1;
1787
1788 return set80211param(priv, IEEE80211_PARAM_AUTHMODE, authmode);
1789 }
1790
atheros_set_ap(void * priv,struct wpa_driver_ap_params * params)1791 static int atheros_set_ap(void *priv, struct wpa_driver_ap_params *params)
1792 {
1793 /*
1794 * TODO: Use this to replace set_authmode, set_privacy, set_ieee8021x,
1795 * set_generic_elem, and hapd_set_ssid.
1796 */
1797
1798 wpa_printf(MSG_DEBUG, "atheros: set_ap - pairwise_ciphers=0x%x "
1799 "group_cipher=0x%x key_mgmt_suites=0x%x auth_algs=0x%x "
1800 "wpa_version=0x%x privacy=%d interworking=%d",
1801 params->pairwise_ciphers, params->group_cipher,
1802 params->key_mgmt_suites, params->auth_algs,
1803 params->wpa_version, params->privacy, params->interworking);
1804 wpa_hexdump_ascii(MSG_DEBUG, "atheros: SSID",
1805 params->ssid, params->ssid_len);
1806 if (params->hessid)
1807 wpa_printf(MSG_DEBUG, "atheros: HESSID " MACSTR,
1808 MAC2STR(params->hessid));
1809 wpa_hexdump_buf(MSG_DEBUG, "atheros: beacon_ies",
1810 params->beacon_ies);
1811 wpa_hexdump_buf(MSG_DEBUG, "atheros: proberesp_ies",
1812 params->proberesp_ies);
1813 wpa_hexdump_buf(MSG_DEBUG, "atheros: assocresp_ies",
1814 params->assocresp_ies);
1815
1816 #if defined(CONFIG_HS20) && (defined(IEEE80211_PARAM_OSEN) || defined(CONFIG_ATHEROS_OSEN))
1817 if (params->osen) {
1818 struct wpa_bss_params bss_params;
1819
1820 os_memset(&bss_params, 0, sizeof(struct wpa_bss_params));
1821 bss_params.enabled = 1;
1822 bss_params.wpa = 2;
1823 bss_params.wpa_pairwise = WPA_CIPHER_CCMP;
1824 bss_params.wpa_group = WPA_CIPHER_CCMP;
1825 bss_params.ieee802_1x = 1;
1826
1827 if (atheros_set_privacy(priv, 1) ||
1828 set80211param(priv, IEEE80211_PARAM_OSEN, 1))
1829 return -1;
1830
1831 return atheros_set_ieee8021x(priv, &bss_params);
1832 }
1833 #endif /* CONFIG_HS20 && IEEE80211_PARAM_OSEN */
1834
1835 return 0;
1836 }
1837
1838
1839 #ifdef CONFIG_IEEE80211R
1840
atheros_send_mgmt(void * priv,const u8 * frm,size_t data_len,int noack,unsigned int freq)1841 static int atheros_send_mgmt(void *priv, const u8 *frm, size_t data_len,
1842 int noack, unsigned int freq)
1843 {
1844 struct atheros_driver_data *drv = priv;
1845 u8 buf[1510];
1846 const struct ieee80211_mgmt *mgmt;
1847 struct ieee80211req_mgmtbuf *mgmt_frm;
1848
1849 mgmt = (const struct ieee80211_mgmt *) frm;
1850 wpa_printf(MSG_DEBUG, "%s frmlen = %lu " MACSTR, __func__,
1851 (unsigned long) data_len, MAC2STR(mgmt->da));
1852 mgmt_frm = (struct ieee80211req_mgmtbuf *) buf;
1853 memcpy(mgmt_frm->macaddr, (u8 *)mgmt->da, IEEE80211_ADDR_LEN);
1854 mgmt_frm->buflen = data_len;
1855 if (&mgmt_frm->buf[0] + data_len > buf + sizeof(buf)) {
1856 wpa_printf(MSG_INFO, "atheros: Too long frame for "
1857 "atheros_send_mgmt (%u)", (unsigned int) data_len);
1858 return -1;
1859 }
1860 os_memcpy(&mgmt_frm->buf[0], frm, data_len);
1861 return set80211priv(drv, IEEE80211_IOCTL_SEND_MGMT, mgmt_frm,
1862 sizeof(struct ieee80211req_mgmtbuf) + data_len);
1863 }
1864
1865
atheros_add_tspec(void * priv,const u8 * addr,u8 * tspec_ie,size_t tspec_ielen)1866 static int atheros_add_tspec(void *priv, const u8 *addr, u8 *tspec_ie,
1867 size_t tspec_ielen)
1868 {
1869 struct atheros_driver_data *drv = priv;
1870 int retv;
1871 struct ieee80211req_res req;
1872 struct ieee80211req_res_addts *addts = &req.u.addts;
1873
1874 wpa_printf(MSG_DEBUG, "%s", __func__);
1875 req.type = IEEE80211_RESREQ_ADDTS;
1876 os_memcpy(&req.macaddr[0], addr, IEEE80211_ADDR_LEN);
1877 os_memcpy(addts->tspecie, tspec_ie, tspec_ielen);
1878 retv = set80211priv(drv, IEEE80211_IOCTL_RES_REQ, &req,
1879 sizeof(struct ieee80211req_res));
1880 if (retv < 0) {
1881 wpa_printf(MSG_DEBUG, "%s IEEE80211_IOCTL_RES_REQ FAILED "
1882 "retv = %d", __func__, retv);
1883 return -1;
1884 }
1885 os_memcpy(tspec_ie, addts->tspecie, tspec_ielen);
1886 return addts->status;
1887 }
1888
1889
atheros_add_sta_node(void * priv,const u8 * addr,u16 auth_alg)1890 static int atheros_add_sta_node(void *priv, const u8 *addr, u16 auth_alg)
1891 {
1892 struct atheros_driver_data *drv = priv;
1893 struct ieee80211req_res req;
1894 struct ieee80211req_res_addnode *addnode = &req.u.addnode;
1895
1896 wpa_printf(MSG_DEBUG, "%s", __func__);
1897 req.type = IEEE80211_RESREQ_ADDNODE;
1898 os_memcpy(&req.macaddr[0], addr, IEEE80211_ADDR_LEN);
1899 addnode->auth_alg = auth_alg;
1900 return set80211priv(drv, IEEE80211_IOCTL_RES_REQ, &req,
1901 sizeof(struct ieee80211req_res));
1902 }
1903
1904 #endif /* CONFIG_IEEE80211R */
1905
1906
1907 /* Use only to set a big param, get will not work. */
1908 static int
set80211big(struct atheros_driver_data * drv,int op,const void * data,int len)1909 set80211big(struct atheros_driver_data *drv, int op, const void *data, int len)
1910 {
1911 struct iwreq iwr;
1912
1913 os_memset(&iwr, 0, sizeof(iwr));
1914 os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ);
1915
1916 iwr.u.data.pointer = (void *) data;
1917 iwr.u.data.length = len;
1918 iwr.u.data.flags = op;
1919 wpa_printf(MSG_DEBUG, "%s: op=0x%x=%d (%s) len=0x%x",
1920 __func__, op, op, athr_get_param_name(op), len);
1921
1922 if (ioctl(drv->ioctl_sock, IEEE80211_IOCTL_P2P_BIG_PARAM, &iwr) < 0) {
1923 wpa_printf(MSG_DEBUG, "%s: op=0x%x (%s) subop=0x%x=%d "
1924 "value=0x%x,0x%x failed: %d (%s)",
1925 __func__, op, athr_get_ioctl_name(op), iwr.u.mode,
1926 iwr.u.mode, iwr.u.data.length,
1927 iwr.u.data.flags, errno, strerror(errno));
1928 return -1;
1929 }
1930 return 0;
1931 }
1932
1933
atheros_send_action(void * priv,unsigned int freq,unsigned int wait,const u8 * dst,const u8 * src,const u8 * bssid,const u8 * data,size_t data_len,int no_cck)1934 static int atheros_send_action(void *priv, unsigned int freq,
1935 unsigned int wait,
1936 const u8 *dst, const u8 *src,
1937 const u8 *bssid,
1938 const u8 *data, size_t data_len, int no_cck)
1939 {
1940 struct atheros_driver_data *drv = priv;
1941 struct ieee80211_p2p_send_action *act;
1942 int res;
1943
1944 act = os_zalloc(sizeof(*act) + data_len);
1945 if (act == NULL)
1946 return -1;
1947 act->freq = freq;
1948 os_memcpy(act->dst_addr, dst, ETH_ALEN);
1949 os_memcpy(act->src_addr, src, ETH_ALEN);
1950 os_memcpy(act->bssid, bssid, ETH_ALEN);
1951 os_memcpy(act + 1, data, data_len);
1952 wpa_printf(MSG_DEBUG, "%s: freq=%d, wait=%u, dst=" MACSTR ", src="
1953 MACSTR ", bssid=" MACSTR,
1954 __func__, act->freq, wait, MAC2STR(act->dst_addr),
1955 MAC2STR(act->src_addr), MAC2STR(act->bssid));
1956 wpa_hexdump(MSG_MSGDUMP, "athr: act", (u8 *) act, sizeof(*act));
1957 wpa_hexdump(MSG_MSGDUMP, "athr: data", data, data_len);
1958
1959 res = set80211big(drv, IEEE80211_IOC_P2P_SEND_ACTION,
1960 act, sizeof(*act) + data_len);
1961 os_free(act);
1962 return res;
1963 }
1964
1965
1966 #if defined(CONFIG_WNM) && defined(IEEE80211_APPIE_FRAME_WNM)
athr_wnm_tfs(struct atheros_driver_data * drv,const u8 * peer,u8 * ie,u16 * len,enum wnm_oper oper)1967 static int athr_wnm_tfs(struct atheros_driver_data *drv, const u8* peer,
1968 u8 *ie, u16 *len, enum wnm_oper oper)
1969 {
1970 #define IEEE80211_APPIE_MAX 1024 /* max appie buffer size */
1971 u8 buf[IEEE80211_APPIE_MAX];
1972 struct ieee80211req_getset_appiebuf *tfs_ie;
1973 u16 val;
1974
1975 wpa_printf(MSG_DEBUG, "atheros: ifname=%s, WNM TFS IE oper=%d " MACSTR,
1976 drv->iface, oper, MAC2STR(peer));
1977
1978 switch (oper) {
1979 case WNM_SLEEP_TFS_REQ_IE_SET:
1980 if (*len > IEEE80211_APPIE_MAX -
1981 sizeof(struct ieee80211req_getset_appiebuf)) {
1982 wpa_printf(MSG_DEBUG, "TFS Req IE(s) too large");
1983 return -1;
1984 }
1985 tfs_ie = (struct ieee80211req_getset_appiebuf *) buf;
1986 tfs_ie->app_frmtype = IEEE80211_APPIE_FRAME_WNM;
1987 tfs_ie->app_buflen = ETH_ALEN + 2 + 2 + *len;
1988
1989 /* Command header for driver */
1990 os_memcpy(&(tfs_ie->app_buf[0]), peer, ETH_ALEN);
1991 val = oper;
1992 os_memcpy(&(tfs_ie->app_buf[0]) + ETH_ALEN, &val, 2);
1993 val = *len;
1994 os_memcpy(&(tfs_ie->app_buf[0]) + ETH_ALEN + 2, &val, 2);
1995
1996 /* copy the ie */
1997 os_memcpy(&(tfs_ie->app_buf[0]) + ETH_ALEN + 2 + 2, ie, *len);
1998
1999 if (set80211priv(drv, IEEE80211_IOCTL_SET_APPIEBUF, tfs_ie,
2000 IEEE80211_APPIE_MAX)) {
2001 wpa_printf(MSG_DEBUG, "%s: Failed to set WNM TFS IE: "
2002 "%s", __func__, strerror(errno));
2003 return -1;
2004 }
2005 break;
2006 case WNM_SLEEP_TFS_RESP_IE_ADD:
2007 tfs_ie = (struct ieee80211req_getset_appiebuf *) buf;
2008 tfs_ie->app_frmtype = IEEE80211_APPIE_FRAME_WNM;
2009 tfs_ie->app_buflen = IEEE80211_APPIE_MAX -
2010 sizeof(struct ieee80211req_getset_appiebuf);
2011 /* Command header for driver */
2012 os_memcpy(&(tfs_ie->app_buf[0]), peer, ETH_ALEN);
2013 val = oper;
2014 os_memcpy(&(tfs_ie->app_buf[0]) + ETH_ALEN, &val, 2);
2015 val = 0;
2016 os_memcpy(&(tfs_ie->app_buf[0]) + ETH_ALEN + 2, &val, 2);
2017
2018 if (set80211priv(drv, IEEE80211_IOCTL_GET_APPIEBUF, tfs_ie,
2019 IEEE80211_APPIE_MAX)) {
2020 wpa_printf(MSG_DEBUG, "%s: Failed to get WNM TFS IE: "
2021 "%s", __func__, strerror(errno));
2022 return -1;
2023 }
2024
2025 *len = tfs_ie->app_buflen;
2026 os_memcpy(ie, &(tfs_ie->app_buf[0]), *len);
2027 wpa_printf(MSG_DEBUG, "atheros: %c len=%d", tfs_ie->app_buf[0],
2028 *len);
2029 break;
2030 case WNM_SLEEP_TFS_RESP_IE_NONE:
2031 *len = 0;
2032 break;
2033 case WNM_SLEEP_TFS_IE_DEL:
2034 tfs_ie = (struct ieee80211req_getset_appiebuf *) buf;
2035 tfs_ie->app_frmtype = IEEE80211_APPIE_FRAME_WNM;
2036 tfs_ie->app_buflen = IEEE80211_APPIE_MAX -
2037 sizeof(struct ieee80211req_getset_appiebuf);
2038 /* Command header for driver */
2039 os_memcpy(&(tfs_ie->app_buf[0]), peer, ETH_ALEN);
2040 val = oper;
2041 os_memcpy(&(tfs_ie->app_buf[0]) + ETH_ALEN, &val, 2);
2042 val = 0;
2043 os_memcpy(&(tfs_ie->app_buf[0]) + ETH_ALEN + 2, &val, 2);
2044
2045 if (set80211priv(drv, IEEE80211_IOCTL_SET_APPIEBUF, tfs_ie,
2046 IEEE80211_APPIE_MAX)) {
2047 wpa_printf(MSG_DEBUG, "%s: Failed to set WNM TFS IE: "
2048 "%s", __func__, strerror(errno));
2049 return -1;
2050 }
2051 break;
2052 default:
2053 wpa_printf(MSG_DEBUG, "Unsupported TFS oper %d", oper);
2054 break;
2055 }
2056
2057 return 0;
2058 }
2059
2060
atheros_wnm_sleep(struct atheros_driver_data * drv,const u8 * peer,enum wnm_oper oper)2061 static int atheros_wnm_sleep(struct atheros_driver_data *drv,
2062 const u8 *peer, enum wnm_oper oper)
2063 {
2064 u8 *data, *pos;
2065 size_t dlen;
2066 int ret;
2067 u16 val;
2068
2069 wpa_printf(MSG_DEBUG, "atheros: WNM-Sleep Oper %d, " MACSTR,
2070 oper, MAC2STR(peer));
2071
2072 dlen = ETH_ALEN + 2 + 2;
2073 data = os_malloc(dlen);
2074 if (data == NULL)
2075 return -1;
2076
2077 /* Command header for driver */
2078 pos = data;
2079 os_memcpy(pos, peer, ETH_ALEN);
2080 pos += ETH_ALEN;
2081
2082 val = oper;
2083 os_memcpy(pos, &val, 2);
2084 pos += 2;
2085
2086 val = 0;
2087 os_memcpy(pos, &val, 2);
2088
2089 ret = atheros_set_wps_ie(drv, data, dlen, IEEE80211_APPIE_FRAME_WNM);
2090
2091 os_free(data);
2092
2093 return ret;
2094 }
2095
2096
atheros_wnm_oper(void * priv,enum wnm_oper oper,const u8 * peer,u8 * buf,u16 * buf_len)2097 static int atheros_wnm_oper(void *priv, enum wnm_oper oper, const u8 *peer,
2098 u8 *buf, u16 *buf_len)
2099 {
2100 struct atheros_driver_data *drv = priv;
2101
2102 switch (oper) {
2103 case WNM_SLEEP_ENTER_CONFIRM:
2104 case WNM_SLEEP_ENTER_FAIL:
2105 case WNM_SLEEP_EXIT_CONFIRM:
2106 case WNM_SLEEP_EXIT_FAIL:
2107 return atheros_wnm_sleep(drv, peer, oper);
2108 case WNM_SLEEP_TFS_REQ_IE_SET:
2109 case WNM_SLEEP_TFS_RESP_IE_ADD:
2110 case WNM_SLEEP_TFS_RESP_IE_NONE:
2111 case WNM_SLEEP_TFS_IE_DEL:
2112 return athr_wnm_tfs(drv, peer, buf, buf_len, oper);
2113 default:
2114 wpa_printf(MSG_DEBUG, "atheros: Unsupported WNM operation %d",
2115 oper);
2116 return -1;
2117 }
2118 }
2119 #endif /* CONFIG_WNM && IEEE80211_APPIE_FRAME_WNM */
2120
2121
2122 const struct wpa_driver_ops wpa_driver_atheros_ops = {
2123 .name = "atheros",
2124 .hapd_init = atheros_init,
2125 .hapd_deinit = atheros_deinit,
2126 .set_ieee8021x = atheros_set_ieee8021x,
2127 .set_privacy = atheros_set_privacy,
2128 .set_key = atheros_set_key,
2129 .get_seqnum = atheros_get_seqnum,
2130 .flush = atheros_flush,
2131 .set_generic_elem = atheros_set_opt_ie,
2132 .sta_set_flags = atheros_sta_set_flags,
2133 .read_sta_data = atheros_read_sta_driver_data,
2134 .hapd_send_eapol = atheros_send_eapol,
2135 .sta_disassoc = atheros_sta_disassoc,
2136 .sta_deauth = atheros_sta_deauth,
2137 .hapd_set_ssid = atheros_set_ssid,
2138 .hapd_get_ssid = atheros_get_ssid,
2139 .set_countermeasures = atheros_set_countermeasures,
2140 .sta_clear_stats = atheros_sta_clear_stats,
2141 .commit = atheros_commit,
2142 .set_ap_wps_ie = atheros_set_ap_wps_ie,
2143 .set_authmode = atheros_set_authmode,
2144 .set_ap = atheros_set_ap,
2145 #ifdef CONFIG_IEEE80211R
2146 .sta_assoc = atheros_sta_assoc,
2147 .sta_auth = atheros_sta_auth,
2148 .send_mlme = atheros_send_mgmt,
2149 .add_tspec = atheros_add_tspec,
2150 .add_sta_node = atheros_add_sta_node,
2151 #endif /* CONFIG_IEEE80211R */
2152 .send_action = atheros_send_action,
2153 #if defined(CONFIG_WNM) && defined(IEEE80211_APPIE_FRAME_WNM)
2154 .wnm_oper = atheros_wnm_oper,
2155 #endif /* CONFIG_WNM && IEEE80211_APPIE_FRAME_WNM */
2156 .set_qos_map = atheros_set_qos_map,
2157 };
2158