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