]> git.ipfire.org Git - thirdparty/hostap.git/blob - src/drivers/driver_bsd.c
projects / thirdparty / hostap.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add own_addr as a parameter to sta_deauth() and sta_disassoc()
[thirdparty/hostap.git] / src / drivers / driver_bsd.c
1 /*
2 * WPA Supplicant - driver interaction with BSD net80211 layer
3 * Copyright (c) 2004, Sam Leffler <sam@errno.com>
4 * Copyright (c) 2004, 2Wire, Inc
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 *
10 * Alternatively, this software may be distributed under the terms of BSD
11 * license.
12 *
13 * See README and COPYING for more details.
14 */
15
16 #include "includes.h"
17 #include <sys/ioctl.h>
18
19 #include "common.h"
20 #include "driver.h"
21 #include "eloop.h"
22 #include "ieee802_11_defs.h"
23
24 #include <net/if.h>
25
26 #ifdef __NetBSD__
27 #include <net/if_ether.h>
28 #define COMPAT_FREEBSD_NET80211
29 #else
30 #include <net/ethernet.h>
31 #endif
32
33 #include <net80211/ieee80211.h>
34 #include <net80211/ieee80211_crypto.h>
35 #include <net80211/ieee80211_ioctl.h>
36
37 /*
38 * Avoid conflicts with hostapd definitions by undefining couple of defines
39 * from net80211 header files.
40 */
41 #undef RSN_VERSION
42 #undef WPA_VERSION
43 #undef WPA_OUI_TYPE
44
45
46 #ifdef HOSTAPD
47
48 #include "l2_packet/l2_packet.h"
49 #include "../../hostapd/hostapd.h"
50 #include "../../hostapd/config.h"
51 #include "../../hostapd/eapol_sm.h"
52
53 struct bsd_driver_data {
54 struct hostapd_data *hapd; /* back pointer */
55
56 char iface[IFNAMSIZ + 1];
57 struct l2_packet_data *sock_xmit; /* raw packet xmit socket */
58 int ioctl_sock; /* socket for ioctl() use */
59 int wext_sock; /* socket for wireless events */
60 };
61
62 static int bsd_sta_deauth(void *priv, const u8 *own_addr, const u8 *addr,
63 int reason_code);
64
65 static int
66 set80211var(struct bsd_driver_data *drv, int op, const void *arg, int arg_len)
67 {
68 struct ieee80211req ireq;
69
70 memset(&ireq, 0, sizeof(ireq));
71 os_strlcpy(ireq.i_name, drv->iface, IFNAMSIZ);
72 ireq.i_type = op;
73 ireq.i_len = arg_len;
74 ireq.i_data = (void *) arg;
75
76 if (ioctl(drv->ioctl_sock, SIOCS80211, &ireq) < 0) {
77 perror("ioctl[SIOCS80211]");
78 return -1;
79 }
80 return 0;
81 }
82
83 static int
84 get80211var(struct bsd_driver_data *drv, int op, void *arg, int arg_len)
85 {
86 struct ieee80211req ireq;
87
88 memset(&ireq, 0, sizeof(ireq));
89 os_strlcpy(ireq.i_name, drv->iface, IFNAMSIZ);
90 ireq.i_type = op;
91 ireq.i_len = arg_len;
92 ireq.i_data = arg;
93
94 if (ioctl(drv->ioctl_sock, SIOCG80211, &ireq) < 0) {
95 perror("ioctl[SIOCG80211]");
96 return -1;
97 }
98 return ireq.i_len;
99 }
100
101 static int
102 set80211param(struct bsd_driver_data *drv, int op, int arg)
103 {
104 struct ieee80211req ireq;
105
106 memset(&ireq, 0, sizeof(ireq));
107 os_strlcpy(ireq.i_name, drv->iface, IFNAMSIZ);
108 ireq.i_type = op;
109 ireq.i_val = arg;
110
111 if (ioctl(drv->ioctl_sock, SIOCS80211, &ireq) < 0) {
112 perror("ioctl[SIOCS80211]");
113 return -1;
114 }
115 return 0;
116 }
117
118 static const char *
119 ether_sprintf(const u8 *addr)
120 {
121 static char buf[sizeof(MACSTR)];
122
123 if (addr != NULL)
124 snprintf(buf, sizeof(buf), MACSTR, MAC2STR(addr));
125 else
126 snprintf(buf, sizeof(buf), MACSTR, 0,0,0,0,0,0);
127 return buf;
128 }
129
130 /*
131 * Configure WPA parameters.
132 */
133 static int
134 bsd_configure_wpa(struct bsd_driver_data *drv)
135 {
136 static const char *ciphernames[] =
137 { "WEP", "TKIP", "AES-OCB", "AES-CCM", "CKIP", "NONE" };
138 struct hostapd_data *hapd = drv->hapd;
139 struct hostapd_bss_config *conf = hapd->conf;
140 int v;
141
142 switch (conf->wpa_group) {
143 case WPA_CIPHER_CCMP:
144 v = IEEE80211_CIPHER_AES_CCM;
145 break;
146 case WPA_CIPHER_TKIP:
147 v = IEEE80211_CIPHER_TKIP;
148 break;
149 case WPA_CIPHER_WEP104:
150 v = IEEE80211_CIPHER_WEP;
151 break;
152 case WPA_CIPHER_WEP40:
153 v = IEEE80211_CIPHER_WEP;
154 break;
155 case WPA_CIPHER_NONE:
156 v = IEEE80211_CIPHER_NONE;
157 break;
158 default:
159 printf("Unknown group key cipher %u\n",
160 conf->wpa_group);
161 return -1;
162 }
163 wpa_printf(MSG_DEBUG, "%s: group key cipher=%s (%u)",
164 __func__, ciphernames[v], v);
165 if (set80211param(drv, IEEE80211_IOC_MCASTCIPHER, v)) {
166 printf("Unable to set group key cipher to %u (%s)\n",
167 v, ciphernames[v]);
168 return -1;
169 }
170 if (v == IEEE80211_CIPHER_WEP) {
171 /* key length is done only for specific ciphers */
172 v = (conf->wpa_group == WPA_CIPHER_WEP104 ? 13 : 5);
173 if (set80211param(drv, IEEE80211_IOC_MCASTKEYLEN, v)) {
174 printf("Unable to set group key length to %u\n", v);
175 return -1;
176 }
177 }
178
179 v = 0;
180 if (conf->wpa_pairwise & WPA_CIPHER_CCMP)
181 v |= 1<<IEEE80211_CIPHER_AES_CCM;
182 if (conf->wpa_pairwise & WPA_CIPHER_TKIP)
183 v |= 1<<IEEE80211_CIPHER_TKIP;
184 if (conf->wpa_pairwise & WPA_CIPHER_NONE)
185 v |= 1<<IEEE80211_CIPHER_NONE;
186 wpa_printf(MSG_DEBUG, "%s: pairwise key ciphers=0x%x", __func__, v);
187 if (set80211param(drv, IEEE80211_IOC_UCASTCIPHERS, v)) {
188 printf("Unable to set pairwise key ciphers to 0x%x\n", v);
189 return -1;
190 }
191
192 wpa_printf(MSG_DEBUG, "%s: key management algorithms=0x%x",
193 __func__, conf->wpa_key_mgmt);
194 if (set80211param(drv, IEEE80211_IOC_KEYMGTALGS, conf->wpa_key_mgmt)) {
195 printf("Unable to set key management algorithms to 0x%x\n",
196 conf->wpa_key_mgmt);
197 return -1;
198 }
199
200 v = 0;
201 if (conf->rsn_preauth)
202 v |= BIT(0);
203 wpa_printf(MSG_DEBUG, "%s: rsn capabilities=0x%x",
204 __func__, conf->rsn_preauth);
205 if (set80211param(drv, IEEE80211_IOC_RSNCAPS, v)) {
206 printf("Unable to set RSN capabilities to 0x%x\n", v);
207 return -1;
208 }
209
210 wpa_printf(MSG_DEBUG, "%s: enable WPA= 0x%x", __func__, conf->wpa);
211 if (set80211param(drv, IEEE80211_IOC_WPA, conf->wpa)) {
212 printf("Unable to set WPA to %u\n", conf->wpa);
213 return -1;
214 }
215 return 0;
216 }
217
218
219 static int
220 bsd_set_iface_flags(void *priv, int dev_up)
221 {
222 struct bsd_driver_data *drv = priv;
223 struct ifreq ifr;
224
225 wpa_printf(MSG_DEBUG, "%s: dev_up=%d", __func__, dev_up);
226
227 if (drv->ioctl_sock < 0)
228 return -1;
229
230 memset(&ifr, 0, sizeof(ifr));
231 os_strlcpy(ifr.ifr_name, drv->iface, IFNAMSIZ);
232
233 if (ioctl(drv->ioctl_sock, SIOCGIFFLAGS, &ifr) != 0) {
234 perror("ioctl[SIOCGIFFLAGS]");
235 return -1;
236 }
237
238 if (dev_up)
239 ifr.ifr_flags |= IFF_UP;
240 else
241 ifr.ifr_flags &= ~IFF_UP;
242
243 if (ioctl(drv->ioctl_sock, SIOCSIFFLAGS, &ifr) != 0) {
244 perror("ioctl[SIOCSIFFLAGS]");
245 return -1;
246 }
247
248 if (dev_up) {
249 memset(&ifr, 0, sizeof(ifr));
250 os_strlcpy(ifr.ifr_name, drv->iface, IFNAMSIZ);
251 ifr.ifr_mtu = HOSTAPD_MTU;
252 if (ioctl(drv->ioctl_sock, SIOCSIFMTU, &ifr) != 0) {
253 perror("ioctl[SIOCSIFMTU]");
254 printf("Setting MTU failed - trying to survive with "
255 "current value\n");
256 }
257 }
258
259 return 0;
260 }
261
262 static int
263 bsd_set_ieee8021x(const char *ifname, void *priv, int enabled)
264 {
265 struct bsd_driver_data *drv = priv;
266 struct hostapd_data *hapd = drv->hapd;
267 struct hostapd_bss_config *conf = hapd->conf;
268
269 wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled);
270
271 if (!enabled) {
272 /* XXX restore state */
273 return set80211param(priv, IEEE80211_IOC_AUTHMODE,
274 IEEE80211_AUTH_AUTO);
275 }
276 if (!conf->wpa && !conf->ieee802_1x) {
277 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_DRIVER,
278 HOSTAPD_LEVEL_WARNING, "No 802.1X or WPA enabled!");
279 return -1;
280 }
281 if (conf->wpa && bsd_configure_wpa(drv) != 0) {
282 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_DRIVER,
283 HOSTAPD_LEVEL_WARNING, "Error configuring WPA state!");
284 return -1;
285 }
286 if (set80211param(priv, IEEE80211_IOC_AUTHMODE,
287 (conf->wpa ? IEEE80211_AUTH_WPA : IEEE80211_AUTH_8021X))) {
288 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_DRIVER,
289 HOSTAPD_LEVEL_WARNING, "Error enabling WPA/802.1X!");
290 return -1;
291 }
292 return bsd_set_iface_flags(priv, 1);
293 }
294
295 static int
296 bsd_set_privacy(const char *ifname, void *priv, int enabled)
297 {
298 struct bsd_driver_data *drv = priv;
299
300 wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled);
301
302 return set80211param(drv, IEEE80211_IOC_PRIVACY, enabled);
303 }
304
305 static int
306 bsd_set_sta_authorized(void *priv, const u8 *addr, int authorized)
307 {
308 struct bsd_driver_data *drv = priv;
309 struct ieee80211req_mlme mlme;
310
311 wpa_printf(MSG_DEBUG, "%s: addr=%s authorized=%d",
312 __func__, ether_sprintf(addr), authorized);
313
314 if (authorized)
315 mlme.im_op = IEEE80211_MLME_AUTHORIZE;
316 else
317 mlme.im_op = IEEE80211_MLME_UNAUTHORIZE;
318 mlme.im_reason = 0;
319 memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN);
320 return set80211var(drv, IEEE80211_IOC_MLME, &mlme, sizeof(mlme));
321 }
322
323 static int
324 bsd_sta_set_flags(void *priv, const u8 *addr, int total_flags, int flags_or,
325 int flags_and)
326 {
327 /* For now, only support setting Authorized flag */
328 if (flags_or & WLAN_STA_AUTHORIZED)
329 return bsd_set_sta_authorized(priv, addr, 1);
330 if (!(flags_and & WLAN_STA_AUTHORIZED))
331 return bsd_set_sta_authorized(priv, addr, 0);
332 return 0;
333 }
334
335 static int
336 bsd_del_key(void *priv, const u8 *addr, int key_idx)
337 {
338 struct bsd_driver_data *drv = priv;
339 struct ieee80211req_del_key wk;
340
341 wpa_printf(MSG_DEBUG, "%s: addr=%s key_idx=%d",
342 __func__, ether_sprintf(addr), key_idx);
343
344 memset(&wk, 0, sizeof(wk));
345 if (addr != NULL) {
346 memcpy(wk.idk_macaddr, addr, IEEE80211_ADDR_LEN);
347 wk.idk_keyix = (u_int8_t) IEEE80211_KEYIX_NONE; /* XXX */
348 } else {
349 wk.idk_keyix = key_idx;
350 }
351
352 return set80211var(drv, IEEE80211_IOC_DELKEY, &wk, sizeof(wk));
353 }
354
355 static int
356 bsd_set_key(const char *ifname, void *priv, wpa_alg alg,
357 const u8 *addr, int key_idx, int set_tx, const u8 *seq,
358 size_t seq_len, const u8 *key, size_t key_len)
359 {
360 struct bsd_driver_data *drv = priv;
361 struct ieee80211req_key wk;
362 u_int8_t cipher;
363
364 if (alg == WPA_ALG_NONE)
365 return bsd_del_key(drv, addr, key_idx);
366
367 wpa_printf(MSG_DEBUG, "%s: alg=%d addr=%s key_idx=%d",
368 __func__, alg, ether_sprintf(addr), key_idx);
369
370 if (alg == WPA_ALG_WEP)
371 cipher = IEEE80211_CIPHER_WEP;
372 else if (alg == WPA_ALG_TKIP)
373 cipher = IEEE80211_CIPHER_TKIP;
374 else if (alg == WPA_ALG_CCMP)
375 cipher = IEEE80211_CIPHER_AES_CCM;
376 else {
377 printf("%s: unknown/unsupported algorithm %d\n",
378 __func__, alg);
379 return -1;
380 }
381
382 if (key_len > sizeof(wk.ik_keydata)) {
383 printf("%s: key length %d too big\n", __func__, key_len);
384 return -3;
385 }
386
387 memset(&wk, 0, sizeof(wk));
388 wk.ik_type = cipher;
389 wk.ik_flags = IEEE80211_KEY_RECV | IEEE80211_KEY_XMIT;
390 if (addr == NULL) {
391 memset(wk.ik_macaddr, 0xff, IEEE80211_ADDR_LEN);
392 wk.ik_keyix = key_idx;
393 wk.ik_flags |= IEEE80211_KEY_DEFAULT;
394 } else {
395 memcpy(wk.ik_macaddr, addr, IEEE80211_ADDR_LEN);
396 wk.ik_keyix = IEEE80211_KEYIX_NONE;
397 }
398 wk.ik_keylen = key_len;
399 memcpy(wk.ik_keydata, key, key_len);
400
401 return set80211var(drv, IEEE80211_IOC_WPAKEY, &wk, sizeof(wk));
402 }
403
404
405 static int
406 bsd_get_seqnum(const char *ifname, void *priv, const u8 *addr, int idx,
407 u8 *seq)
408 {
409 struct bsd_driver_data *drv = priv;
410 struct ieee80211req_key wk;
411
412 wpa_printf(MSG_DEBUG, "%s: addr=%s idx=%d",
413 __func__, ether_sprintf(addr), idx);
414
415 memset(&wk, 0, sizeof(wk));
416 if (addr == NULL)
417 memset(wk.ik_macaddr, 0xff, IEEE80211_ADDR_LEN);
418 else
419 memcpy(wk.ik_macaddr, addr, IEEE80211_ADDR_LEN);
420 wk.ik_keyix = idx;
421
422 if (get80211var(drv, IEEE80211_IOC_WPAKEY, &wk, sizeof(wk)) < 0) {
423 printf("Failed to get encryption.\n");
424 return -1;
425 }
426
427 #ifdef WORDS_BIGENDIAN
428 {
429 /*
430 * wk.ik_keytsc is in host byte order (big endian), need to
431 * swap it to match with the byte order used in WPA.
432 */
433 int i;
434 u8 tmp[WPA_KEY_RSC_LEN];
435 memcpy(tmp, &wk.ik_keytsc, sizeof(wk.ik_keytsc));
436 for (i = 0; i < WPA_KEY_RSC_LEN; i++) {
437 seq[i] = tmp[WPA_KEY_RSC_LEN - i - 1];
438 }
439 }
440 #else /* WORDS_BIGENDIAN */
441 memcpy(seq, &wk.ik_keytsc, sizeof(wk.ik_keytsc));
442 #endif /* WORDS_BIGENDIAN */
443 return 0;
444 }
445
446
447 static int
448 bsd_flush(void *priv)
449 {
450 u8 allsta[IEEE80211_ADDR_LEN];
451
452 memset(allsta, 0xff, IEEE80211_ADDR_LEN);
453 return bsd_sta_deauth(priv, NULL, allsta, IEEE80211_REASON_AUTH_LEAVE);
454 }
455
456
457 static int
458 bsd_read_sta_driver_data(void *priv, struct hostap_sta_driver_data *data,
459 const u8 *addr)
460 {
461 struct bsd_driver_data *drv = priv;
462 struct ieee80211req_sta_stats stats;
463
464 memcpy(stats.is_u.macaddr, addr, IEEE80211_ADDR_LEN);
465 if (get80211var(drv, IEEE80211_IOC_STA_STATS, &stats, sizeof(stats)) > 0) {
466 /* XXX? do packets counts include non-data frames? */
467 data->rx_packets = stats.is_stats.ns_rx_data;
468 data->rx_bytes = stats.is_stats.ns_rx_bytes;
469 data->tx_packets = stats.is_stats.ns_tx_data;
470 data->tx_bytes = stats.is_stats.ns_tx_bytes;
471 }
472 return 0;
473 }
474
475 static int
476 bsd_set_opt_ie(const char *ifname, void *priv, const u8 *ie, size_t ie_len)
477 {
478 /*
479 * Do nothing; we setup parameters at startup that define the
480 * contents of the beacon information element.
481 */
482 return 0;
483 }
484
485 static int
486 bsd_sta_deauth(void *priv, const u8 *own_addr, const u8 *addr, int reason_code)
487 {
488 struct bsd_driver_data *drv = priv;
489 struct ieee80211req_mlme mlme;
490
491 wpa_printf(MSG_DEBUG, "%s: addr=%s reason_code=%d",
492 __func__, ether_sprintf(addr), reason_code);
493
494 mlme.im_op = IEEE80211_MLME_DEAUTH;
495 mlme.im_reason = reason_code;
496 memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN);
497 return set80211var(drv, IEEE80211_IOC_MLME, &mlme, sizeof(mlme));
498 }
499
500 static int
501 bsd_sta_disassoc(void *priv, const u8 *own_addr, const u8 *addr,
502 int reason_code)
503 {
504 struct bsd_driver_data *drv = priv;
505 struct ieee80211req_mlme mlme;
506
507 wpa_printf(MSG_DEBUG, "%s: addr=%s reason_code=%d",
508 __func__, ether_sprintf(addr), reason_code);
509
510 mlme.im_op = IEEE80211_MLME_DISASSOC;
511 mlme.im_reason = reason_code;
512 memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN);
513 return set80211var(drv, IEEE80211_IOC_MLME, &mlme, sizeof(mlme));
514 }
515
516 static int
517 bsd_new_sta(struct bsd_driver_data *drv, u8 addr[IEEE80211_ADDR_LEN])
518 {
519 struct hostapd_data *hapd = drv->hapd;
520 struct ieee80211req_wpaie ie;
521 int ielen = 0;
522 u8 *iebuf = NULL;
523
524 /*
525 * Fetch and validate any negotiated WPA/RSN parameters.
526 */
527 memset(&ie, 0, sizeof(ie));
528 memcpy(ie.wpa_macaddr, addr, IEEE80211_ADDR_LEN);
529 if (get80211var(drv, IEEE80211_IOC_WPAIE, &ie, sizeof(ie)) < 0) {
530 printf("Failed to get WPA/RSN information element.\n");
531 goto no_ie;
532 }
533 iebuf = ie.wpa_ie;
534 ielen = ie.wpa_ie[1];
535 if (ielen == 0)
536 iebuf = NULL;
537 else
538 ielen += 2;
539
540 no_ie:
541 return hostapd_notif_assoc(hapd, addr, iebuf, ielen);
542 }
543
544 #include <net/route.h>
545 #include <net80211/ieee80211_freebsd.h>
546
547 static void
548 bsd_wireless_event_receive(int sock, void *ctx, void *sock_ctx)
549 {
550 struct bsd_driver_data *drv = ctx;
551 struct hostapd_data *hapd = drv->hapd;
552 char buf[2048];
553 struct if_announcemsghdr *ifan;
554 struct rt_msghdr *rtm;
555 struct ieee80211_michael_event *mic;
556 struct ieee80211_join_event *join;
557 struct ieee80211_leave_event *leave;
558 int n;
559
560 n = read(sock, buf, sizeof(buf));
561 if (n < 0) {
562 if (errno != EINTR && errno != EAGAIN)
563 perror("read(PF_ROUTE)");
564 return;
565 }
566
567 rtm = (struct rt_msghdr *) buf;
568 if (rtm->rtm_version != RTM_VERSION) {
569 wpa_printf(MSG_DEBUG, "Routing message version %d not "
570 "understood\n", rtm->rtm_version);
571 return;
572 }
573 ifan = (struct if_announcemsghdr *) rtm;
574 switch (rtm->rtm_type) {
575 case RTM_IEEE80211:
576 switch (ifan->ifan_what) {
577 case RTM_IEEE80211_ASSOC:
578 case RTM_IEEE80211_REASSOC:
579 case RTM_IEEE80211_DISASSOC:
580 case RTM_IEEE80211_SCAN:
581 break;
582 case RTM_IEEE80211_LEAVE:
583 leave = (struct ieee80211_leave_event *) &ifan[1];
584 hostapd_notif_disassoc(drv->hapd, leave->iev_addr);
585 break;
586 case RTM_IEEE80211_JOIN:
587 #ifdef RTM_IEEE80211_REJOIN
588 case RTM_IEEE80211_REJOIN:
589 #endif
590 join = (struct ieee80211_join_event *) &ifan[1];
591 bsd_new_sta(drv, join->iev_addr);
592 break;
593 case RTM_IEEE80211_REPLAY:
594 /* ignore */
595 break;
596 case RTM_IEEE80211_MICHAEL:
597 mic = (struct ieee80211_michael_event *) &ifan[1];
598 wpa_printf(MSG_DEBUG,
599 "Michael MIC failure wireless event: "
600 "keyix=%u src_addr=" MACSTR, mic->iev_keyix,
601 MAC2STR(mic->iev_src));
602 hostapd_michael_mic_failure(hapd, mic->iev_src);
603 break;
604 }
605 break;
606 }
607 }
608
609 static int
610 bsd_wireless_event_init(struct bsd_driver_data *drv)
611 {
612 int s;
613
614 drv->wext_sock = -1;
615
616 s = socket(PF_ROUTE, SOCK_RAW, 0);
617 if (s < 0) {
618 perror("socket(PF_ROUTE,SOCK_RAW)");
619 return -1;
620 }
621 eloop_register_read_sock(s, bsd_wireless_event_receive, drv, NULL);
622 drv->wext_sock = s;
623
624 return 0;
625 }
626
627 static void
628 bsd_wireless_event_deinit(struct bsd_driver_data *drv)
629 {
630 if (drv->wext_sock < 0)
631 return;
632 eloop_unregister_read_sock(drv->wext_sock);
633 close(drv->wext_sock);
634 }
635
636
637 static int
638 bsd_send_eapol(void *priv, const u8 *addr, const u8 *data, size_t data_len,
639 int encrypt, const u8 *own_addr)
640 {
641 struct bsd_driver_data *drv = priv;
642 unsigned char buf[3000];
643 unsigned char *bp = buf;
644 struct l2_ethhdr *eth;
645 size_t len;
646 int status;
647
648 /*
649 * Prepend the Etherent header. If the caller left us
650 * space at the front we could just insert it but since
651 * we don't know we copy to a local buffer. Given the frequency
652 * and size of frames this probably doesn't matter.
653 */
654 len = data_len + sizeof(struct l2_ethhdr);
655 if (len > sizeof(buf)) {
656 bp = malloc(len);
657 if (bp == NULL) {
658 printf("EAPOL frame discarded, cannot malloc temp "
659 "buffer of size %u!\n", len);
660 return -1;
661 }
662 }
663 eth = (struct l2_ethhdr *) bp;
664 memcpy(eth->h_dest, addr, ETH_ALEN);
665 memcpy(eth->h_source, own_addr, ETH_ALEN);
666 eth->h_proto = htons(ETH_P_EAPOL);
667 memcpy(eth+1, data, data_len);
668
669 wpa_hexdump(MSG_MSGDUMP, "TX EAPOL", bp, len);
670
671 status = l2_packet_send(drv->sock_xmit, addr, ETH_P_EAPOL, bp, len);
672
673 if (bp != buf)
674 free(bp);
675 return status;
676 }
677
678 static void
679 handle_read(void *ctx, const u8 *src_addr, const u8 *buf, size_t len)
680 {
681 struct bsd_driver_data *drv = ctx;
682 hostapd_eapol_receive(drv->hapd, src_addr,
683 buf + sizeof(struct l2_ethhdr),
684 len - sizeof(struct l2_ethhdr));
685 }
686
687 static int
688 bsd_get_ssid(const char *ifname, void *priv, u8 *buf, int len)
689 {
690 struct bsd_driver_data *drv = priv;
691 int ssid_len = get80211var(drv, IEEE80211_IOC_SSID, buf, len);
692
693 wpa_printf(MSG_DEBUG, "%s: ssid=\"%.*s\"", __func__, ssid_len, buf);
694
695 return ssid_len;
696 }
697
698 static int
699 bsd_set_ssid(const char *ifname, void *priv, const u8 *buf, int len)
700 {
701 struct bsd_driver_data *drv = priv;
702
703 wpa_printf(MSG_DEBUG, "%s: ssid=\"%.*s\"", __func__, len, buf);
704
705 return set80211var(drv, IEEE80211_IOC_SSID, buf, len);
706 }
707
708 static void *
709 bsd_init(struct hostapd_data *hapd, struct wpa_init_params *params)
710 {
711 struct bsd_driver_data *drv;
712
713 drv = os_zalloc(sizeof(struct bsd_driver_data));
714 if (drv == NULL) {
715 printf("Could not allocate memory for bsd driver data\n");
716 goto bad;
717 }
718
719 drv->hapd = hapd;
720 drv->ioctl_sock = socket(PF_INET, SOCK_DGRAM, 0);
721 if (drv->ioctl_sock < 0) {
722 perror("socket[PF_INET,SOCK_DGRAM]");
723 goto bad;
724 }
725 memcpy(drv->iface, hapd->conf->iface, sizeof(drv->iface));
726
727 drv->sock_xmit = l2_packet_init(drv->iface, NULL, ETH_P_EAPOL,
728 handle_read, drv, 1);
729 if (drv->sock_xmit == NULL)
730 goto bad;
731 if (l2_packet_get_own_addr(drv->sock_xmit, hapd->own_addr))
732 goto bad;
733
734 bsd_set_iface_flags(drv, 0); /* mark down during setup */
735 if (bsd_wireless_event_init(drv))
736 goto bad;
737
738 return drv;
739 bad:
740 if (drv->sock_xmit != NULL)
741 l2_packet_deinit(drv->sock_xmit);
742 if (drv->ioctl_sock >= 0)
743 close(drv->ioctl_sock);
744 if (drv != NULL)
745 free(drv);
746 return NULL;
747 }
748
749
750 static void
751 bsd_deinit(void *priv)
752 {
753 struct bsd_driver_data *drv = priv;
754
755 bsd_wireless_event_deinit(drv);
756 (void) bsd_set_iface_flags(drv, 0);
757 if (drv->ioctl_sock >= 0)
758 close(drv->ioctl_sock);
759 if (drv->sock_xmit != NULL)
760 l2_packet_deinit(drv->sock_xmit);
761 free(drv);
762 }
763
764 const struct wpa_driver_ops wpa_driver_bsd_ops = {
765 .name = "bsd",
766 .hapd_init = bsd_init,
767 .hapd_deinit = bsd_deinit,
768 .set_ieee8021x = bsd_set_ieee8021x,
769 .set_privacy = bsd_set_privacy,
770 .hapd_set_key = bsd_set_key,
771 .get_seqnum = bsd_get_seqnum,
772 .flush = bsd_flush,
773 .set_generic_elem = bsd_set_opt_ie,
774 .sta_set_flags = bsd_sta_set_flags,
775 .read_sta_data = bsd_read_sta_driver_data,
776 .hapd_send_eapol = bsd_send_eapol,
777 .sta_disassoc = bsd_sta_disassoc,
778 .sta_deauth = bsd_sta_deauth,
779 .hapd_set_ssid = bsd_set_ssid,
780 .hapd_get_ssid = bsd_get_ssid,
781 };
782
783 #else /* HOSTAPD */
784
785 struct wpa_driver_bsd_data {
786 int sock; /* open socket for 802.11 ioctls */
787 int route; /* routing socket for events */
788 char ifname[IFNAMSIZ+1]; /* interface name */
789 unsigned int ifindex; /* interface index */
790 void *ctx;
791 int prev_roaming; /* roaming state to restore on deinit */
792 int prev_privacy; /* privacy state to restore on deinit */
793 int prev_wpa; /* wpa state to restore on deinit */
794 };
795
796 static int
797 set80211var(struct wpa_driver_bsd_data *drv, int op, const void *arg, int arg_len)
798 {
799 struct ieee80211req ireq;
800
801 os_memset(&ireq, 0, sizeof(ireq));
802 os_strlcpy(ireq.i_name, drv->ifname, IFNAMSIZ);
803 ireq.i_type = op;
804 ireq.i_len = arg_len;
805 ireq.i_data = (void *) arg;
806
807 if (ioctl(drv->sock, SIOCS80211, &ireq) < 0) {
808 fprintf(stderr, "ioctl[SIOCS80211, op %u, len %u]: %s\n",
809 op, arg_len, strerror(errno));
810 return -1;
811 }
812 return 0;
813 }
814
815 static int
816 get80211var(struct wpa_driver_bsd_data *drv, int op, void *arg, int arg_len)
817 {
818 struct ieee80211req ireq;
819
820 os_memset(&ireq, 0, sizeof(ireq));
821 os_strlcpy(ireq.i_name, drv->ifname, IFNAMSIZ);
822 ireq.i_type = op;
823 ireq.i_len = arg_len;
824 ireq.i_data = arg;
825
826 if (ioctl(drv->sock, SIOCG80211, &ireq) < 0) {
827 fprintf(stderr, "ioctl[SIOCG80211, op %u, len %u]: %s\n",
828 op, arg_len, strerror(errno));
829 return -1;
830 }
831 return ireq.i_len;
832 }
833
834 static int
835 set80211param(struct wpa_driver_bsd_data *drv, int op, int arg)
836 {
837 struct ieee80211req ireq;
838
839 os_memset(&ireq, 0, sizeof(ireq));
840 os_strlcpy(ireq.i_name, drv->ifname, IFNAMSIZ);
841 ireq.i_type = op;
842 ireq.i_val = arg;
843
844 if (ioctl(drv->sock, SIOCS80211, &ireq) < 0) {
845 fprintf(stderr, "ioctl[SIOCS80211, op %u, arg 0x%x]: %s\n",
846 op, arg, strerror(errno));
847 return -1;
848 }
849 return 0;
850 }
851
852 static int
853 get80211param(struct wpa_driver_bsd_data *drv, int op)
854 {
855 struct ieee80211req ireq;
856
857 os_memset(&ireq, 0, sizeof(ireq));
858 os_strlcpy(ireq.i_name, drv->ifname, IFNAMSIZ);
859 ireq.i_type = op;
860
861 if (ioctl(drv->sock, SIOCG80211, &ireq) < 0) {
862 fprintf(stderr, "ioctl[SIOCG80211, op %u]: %s\n",
863 op, strerror(errno));
864 return -1;
865 }
866 return ireq.i_val;
867 }
868
869 static int
870 getifflags(struct wpa_driver_bsd_data *drv, int *flags)
871 {
872 struct ifreq ifr;
873
874 os_memset(&ifr, 0, sizeof(ifr));
875 os_strlcpy(ifr.ifr_name, drv->ifname, sizeof(ifr.ifr_name));
876 if (ioctl(drv->sock, SIOCGIFFLAGS, (caddr_t)&ifr) < 0) {
877 perror("SIOCGIFFLAGS");
878 return errno;
879 }
880 *flags = ifr.ifr_flags & 0xffff;
881 return 0;
882 }
883
884 static int
885 setifflags(struct wpa_driver_bsd_data *drv, int flags)
886 {
887 struct ifreq ifr;
888
889 os_memset(&ifr, 0, sizeof(ifr));
890 os_strlcpy(ifr.ifr_name, drv->ifname, sizeof(ifr.ifr_name));
891 ifr.ifr_flags = flags & 0xffff;
892 if (ioctl(drv->sock, SIOCSIFFLAGS, (caddr_t)&ifr) < 0) {
893 perror("SIOCSIFFLAGS");
894 return errno;
895 }
896 return 0;
897 }
898
899 static int
900 wpa_driver_bsd_get_bssid(void *priv, u8 *bssid)
901 {
902 struct wpa_driver_bsd_data *drv = priv;
903
904 return get80211var(drv, IEEE80211_IOC_BSSID,
905 bssid, IEEE80211_ADDR_LEN) < 0 ? -1 : 0;
906 }
907
908 #if 0
909 static int
910 wpa_driver_bsd_set_bssid(void *priv, const char *bssid)
911 {
912 struct wpa_driver_bsd_data *drv = priv;
913
914 return set80211var(drv, IEEE80211_IOC_BSSID,
915 bssid, IEEE80211_ADDR_LEN);
916 }
917 #endif
918
919 static int
920 wpa_driver_bsd_get_ssid(void *priv, u8 *ssid)
921 {
922 struct wpa_driver_bsd_data *drv = priv;
923
924 return get80211var(drv, IEEE80211_IOC_SSID,
925 ssid, IEEE80211_NWID_LEN);
926 }
927
928 static int
929 wpa_driver_bsd_set_ssid(void *priv, const u8 *ssid,
930 size_t ssid_len)
931 {
932 struct wpa_driver_bsd_data *drv = priv;
933
934 return set80211var(drv, IEEE80211_IOC_SSID, ssid, ssid_len);
935 }
936
937 static int
938 wpa_driver_bsd_set_wpa_ie(struct wpa_driver_bsd_data *drv,
939 const u8 *wpa_ie, size_t wpa_ie_len)
940 {
941 return set80211var(drv, IEEE80211_IOC_OPTIE, wpa_ie, wpa_ie_len);
942 }
943
944 static int
945 wpa_driver_bsd_set_wpa_internal(void *priv, int wpa, int privacy)
946 {
947 struct wpa_driver_bsd_data *drv = priv;
948 int ret = 0;
949
950 wpa_printf(MSG_DEBUG, "%s: wpa=%d privacy=%d",
951 __FUNCTION__, wpa, privacy);
952
953 if (!wpa && wpa_driver_bsd_set_wpa_ie(drv, NULL, 0) < 0)
954 ret = -1;
955 if (set80211param(drv, IEEE80211_IOC_PRIVACY, privacy) < 0)
956 ret = -1;
957 if (set80211param(drv, IEEE80211_IOC_WPA, wpa) < 0)
958 ret = -1;
959
960 return ret;
961 }
962
963 static int
964 wpa_driver_bsd_set_wpa(void *priv, int enabled)
965 {
966 wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled);
967
968 return wpa_driver_bsd_set_wpa_internal(priv, enabled ? 3 : 0, enabled);
969 }
970
971 static int
972 wpa_driver_bsd_del_key(struct wpa_driver_bsd_data *drv, int key_idx,
973 const unsigned char *addr)
974 {
975 struct ieee80211req_del_key wk;
976
977 os_memset(&wk, 0, sizeof(wk));
978 if (addr != NULL &&
979 bcmp(addr, "\xff\xff\xff\xff\xff\xff", IEEE80211_ADDR_LEN) != 0) {
980 struct ether_addr ea;
981
982 os_memcpy(&ea, addr, IEEE80211_ADDR_LEN);
983 wpa_printf(MSG_DEBUG, "%s: addr=%s keyidx=%d",
984 __func__, ether_ntoa(&ea), key_idx);
985 os_memcpy(wk.idk_macaddr, addr, IEEE80211_ADDR_LEN);
986 wk.idk_keyix = (uint8_t) IEEE80211_KEYIX_NONE;
987 } else {
988 wpa_printf(MSG_DEBUG, "%s: keyidx=%d", __func__, key_idx);
989 wk.idk_keyix = key_idx;
990 }
991 return set80211var(drv, IEEE80211_IOC_DELKEY, &wk, sizeof(wk));
992 }
993
994 static int
995 wpa_driver_bsd_set_key(void *priv, wpa_alg alg,
996 const unsigned char *addr, int key_idx, int set_tx,
997 const u8 *seq, size_t seq_len,
998 const u8 *key, size_t key_len)
999 {
1000 struct wpa_driver_bsd_data *drv = priv;
1001 struct ieee80211req_key wk;
1002 struct ether_addr ea;
1003 char *alg_name;
1004 u_int8_t cipher;
1005
1006 if (alg == WPA_ALG_NONE)
1007 return wpa_driver_bsd_del_key(drv, key_idx, addr);
1008
1009 switch (alg) {
1010 case WPA_ALG_WEP:
1011 alg_name = "WEP";
1012 cipher = IEEE80211_CIPHER_WEP;
1013 break;
1014 case WPA_ALG_TKIP:
1015 alg_name = "TKIP";
1016 cipher = IEEE80211_CIPHER_TKIP;
1017 break;
1018 case WPA_ALG_CCMP:
1019 alg_name = "CCMP";
1020 cipher = IEEE80211_CIPHER_AES_CCM;
1021 break;
1022 default:
1023 wpa_printf(MSG_DEBUG, "%s: unknown/unsupported algorithm %d",
1024 __func__, alg);
1025 return -1;
1026 }
1027
1028 os_memcpy(&ea, addr, IEEE80211_ADDR_LEN);
1029 wpa_printf(MSG_DEBUG,
1030 "%s: alg=%s addr=%s key_idx=%d set_tx=%d seq_len=%zu key_len=%zu",
1031 __func__, alg_name, ether_ntoa(&ea), key_idx, set_tx,
1032 seq_len, key_len);
1033
1034 if (seq_len > sizeof(u_int64_t)) {
1035 wpa_printf(MSG_DEBUG, "%s: seq_len %zu too big",
1036 __func__, seq_len);
1037 return -2;
1038 }
1039 if (key_len > sizeof(wk.ik_keydata)) {
1040 wpa_printf(MSG_DEBUG, "%s: key length %zu too big",
1041 __func__, key_len);
1042 return -3;
1043 }
1044
1045 os_memset(&wk, 0, sizeof(wk));
1046 wk.ik_type = cipher;
1047 wk.ik_flags = IEEE80211_KEY_RECV;
1048 if (set_tx)
1049 wk.ik_flags |= IEEE80211_KEY_XMIT;
1050 os_memcpy(wk.ik_macaddr, addr, IEEE80211_ADDR_LEN);
1051 /*
1052 * Deduce whether group/global or unicast key by checking
1053 * the address (yech). Note also that we can only mark global
1054 * keys default; doing this for a unicast key is an error.
1055 */
1056 if (bcmp(addr, "\xff\xff\xff\xff\xff\xff", IEEE80211_ADDR_LEN) == 0) {
1057 wk.ik_flags |= IEEE80211_KEY_GROUP;
1058 wk.ik_keyix = key_idx;
1059 } else {
1060 wk.ik_keyix = (key_idx == 0 ? IEEE80211_KEYIX_NONE : key_idx);
1061 }
1062 if (wk.ik_keyix != IEEE80211_KEYIX_NONE && set_tx)
1063 wk.ik_flags |= IEEE80211_KEY_DEFAULT;
1064 wk.ik_keylen = key_len;
1065 os_memcpy(&wk.ik_keyrsc, seq, seq_len);
1066 os_memcpy(wk.ik_keydata, key, key_len);
1067
1068 return set80211var(drv, IEEE80211_IOC_WPAKEY, &wk, sizeof(wk));
1069 }
1070
1071 static int
1072 wpa_driver_bsd_set_countermeasures(void *priv, int enabled)
1073 {
1074 struct wpa_driver_bsd_data *drv = priv;
1075
1076 wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled);
1077 return set80211param(drv, IEEE80211_IOC_COUNTERMEASURES, enabled);
1078 }
1079
1080
1081 static int
1082 wpa_driver_bsd_set_drop_unencrypted(void *priv, int enabled)
1083 {
1084 struct wpa_driver_bsd_data *drv = priv;
1085
1086 wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled);
1087 return set80211param(drv, IEEE80211_IOC_DROPUNENCRYPTED, enabled);
1088 }
1089
1090 static int
1091 wpa_driver_bsd_deauthenticate(void *priv, const u8 *addr, int reason_code)
1092 {
1093 struct wpa_driver_bsd_data *drv = priv;
1094 struct ieee80211req_mlme mlme;
1095
1096 wpa_printf(MSG_DEBUG, "%s", __func__);
1097 os_memset(&mlme, 0, sizeof(mlme));
1098 mlme.im_op = IEEE80211_MLME_DEAUTH;
1099 mlme.im_reason = reason_code;
1100 os_memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN);
1101 return set80211var(drv, IEEE80211_IOC_MLME, &mlme, sizeof(mlme));
1102 }
1103
1104 static int
1105 wpa_driver_bsd_disassociate(void *priv, const u8 *addr, int reason_code)
1106 {
1107 struct wpa_driver_bsd_data *drv = priv;
1108 struct ieee80211req_mlme mlme;
1109
1110 wpa_printf(MSG_DEBUG, "%s", __func__);
1111 os_memset(&mlme, 0, sizeof(mlme));
1112 mlme.im_op = IEEE80211_MLME_DISASSOC;
1113 mlme.im_reason = reason_code;
1114 os_memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN);
1115 return set80211var(drv, IEEE80211_IOC_MLME, &mlme, sizeof(mlme));
1116 }
1117
1118 static int
1119 wpa_driver_bsd_associate(void *priv, struct wpa_driver_associate_params *params)
1120 {
1121 struct wpa_driver_bsd_data *drv = priv;
1122 struct ieee80211req_mlme mlme;
1123 int privacy;
1124
1125 wpa_printf(MSG_DEBUG,
1126 "%s: ssid '%.*s' wpa ie len %u pairwise %u group %u key mgmt %u"
1127 , __func__
1128 , params->ssid_len, params->ssid
1129 , params->wpa_ie_len
1130 , params->pairwise_suite
1131 , params->group_suite
1132 , params->key_mgmt_suite
1133 );
1134
1135 /* XXX error handling is wrong but unclear what to do... */
1136 if (wpa_driver_bsd_set_wpa_ie(drv, params->wpa_ie, params->wpa_ie_len) < 0)
1137 return -1;
1138 #ifndef NEW_FREEBSD_MLME_ASSOC
1139 if (wpa_driver_bsd_set_ssid(drv, params->ssid, params->ssid_len) < 0)
1140 return -1;
1141 #endif
1142
1143 privacy = !(params->pairwise_suite == CIPHER_NONE &&
1144 params->group_suite == CIPHER_NONE &&
1145 params->key_mgmt_suite == KEY_MGMT_NONE &&
1146 params->wpa_ie_len == 0);
1147 wpa_printf(MSG_DEBUG, "%s: set PRIVACY %u", __func__, privacy);
1148
1149 if (set80211param(drv, IEEE80211_IOC_PRIVACY, privacy) < 0)
1150 return -1;
1151
1152 if (params->wpa_ie_len &&
1153 set80211param(drv, IEEE80211_IOC_WPA,
1154 params->wpa_ie[0] == WLAN_EID_RSN ? 2 : 1) < 0)
1155 return -1;
1156
1157 os_memset(&mlme, 0, sizeof(mlme));
1158 mlme.im_op = IEEE80211_MLME_ASSOC;
1159 #ifdef NEW_FREEBSD_MLME_ASSOC
1160 if (params->ssid != NULL)
1161 os_memcpy(mlme.im_ssid, params->ssid, params->ssid_len);
1162 mlme.im_ssid_len = params->ssid_len;
1163 #endif
1164 if (params->bssid != NULL)
1165 os_memcpy(mlme.im_macaddr, params->bssid, IEEE80211_ADDR_LEN);
1166 if (set80211var(drv, IEEE80211_IOC_MLME, &mlme, sizeof(mlme)) < 0)
1167 return -1;
1168 return 0;
1169 }
1170
1171 static int
1172 wpa_driver_bsd_set_auth_alg(void *priv, int auth_alg)
1173 {
1174 struct wpa_driver_bsd_data *drv = priv;
1175 int authmode;
1176
1177 if ((auth_alg & AUTH_ALG_OPEN_SYSTEM) &&
1178 (auth_alg & AUTH_ALG_SHARED_KEY))
1179 authmode = IEEE80211_AUTH_AUTO;
1180 else if (auth_alg & AUTH_ALG_SHARED_KEY)
1181 authmode = IEEE80211_AUTH_SHARED;
1182 else
1183 authmode = IEEE80211_AUTH_OPEN;
1184
1185 return set80211param(drv, IEEE80211_IOC_AUTHMODE, authmode);
1186 }
1187
1188 static int
1189 wpa_driver_bsd_scan(void *priv, const u8 *ssid, size_t ssid_len)
1190 {
1191 struct wpa_driver_bsd_data *drv = priv;
1192 int flags;
1193
1194 /* NB: interface must be marked UP to do a scan */
1195 if (getifflags(drv, &flags) != 0 || setifflags(drv, flags | IFF_UP) != 0)
1196 return -1;
1197
1198 /* set desired ssid before scan */
1199 if (wpa_driver_bsd_set_ssid(drv, ssid, ssid_len) < 0)
1200 return -1;
1201
1202 /* NB: net80211 delivers a scan complete event so no need to poll */
1203 return set80211param(drv, IEEE80211_IOC_SCAN_REQ, 0);
1204 }
1205
1206 #include <net/route.h>
1207 #if __FreeBSD__
1208 #include <net80211/ieee80211_freebsd.h>
1209 #endif
1210 #if __NetBSD__
1211 #include <net80211/ieee80211_netbsd.h>
1212 #endif
1213
1214 static void
1215 wpa_driver_bsd_event_receive(int sock, void *ctx, void *sock_ctx)
1216 {
1217 struct wpa_driver_bsd_data *drv = sock_ctx;
1218 char buf[2048];
1219 struct if_announcemsghdr *ifan;
1220 struct if_msghdr *ifm;
1221 struct rt_msghdr *rtm;
1222 union wpa_event_data event;
1223 struct ieee80211_michael_event *mic;
1224 int n;
1225
1226 n = read(sock, buf, sizeof(buf));
1227 if (n < 0) {
1228 if (errno != EINTR && errno != EAGAIN)
1229 perror("read(PF_ROUTE)");
1230 return;
1231 }
1232
1233 rtm = (struct rt_msghdr *) buf;
1234 if (rtm->rtm_version != RTM_VERSION) {
1235 wpa_printf(MSG_DEBUG, "Routing message version %d not "
1236 "understood\n", rtm->rtm_version);
1237 return;
1238 }
1239 os_memset(&event, 0, sizeof(event));
1240 switch (rtm->rtm_type) {
1241 case RTM_IFANNOUNCE:
1242 ifan = (struct if_announcemsghdr *) rtm;
1243 if (ifan->ifan_index != drv->ifindex)
1244 break;
1245 strlcpy(event.interface_status.ifname, drv->ifname,
1246 sizeof(event.interface_status.ifname));
1247 switch (ifan->ifan_what) {
1248 case IFAN_DEPARTURE:
1249 event.interface_status.ievent = EVENT_INTERFACE_REMOVED;
1250 default:
1251 return;
1252 }
1253 wpa_printf(MSG_DEBUG, "RTM_IFANNOUNCE: Interface '%s' %s",
1254 event.interface_status.ifname,
1255 ifan->ifan_what == IFAN_DEPARTURE ?
1256 "removed" : "added");
1257 wpa_supplicant_event(ctx, EVENT_INTERFACE_STATUS, &event);
1258 break;
1259 case RTM_IEEE80211:
1260 ifan = (struct if_announcemsghdr *) rtm;
1261 if (ifan->ifan_index != drv->ifindex)
1262 break;
1263 switch (ifan->ifan_what) {
1264 case RTM_IEEE80211_ASSOC:
1265 case RTM_IEEE80211_REASSOC:
1266 wpa_supplicant_event(ctx, EVENT_ASSOC, NULL);
1267 break;
1268 case RTM_IEEE80211_DISASSOC:
1269 wpa_supplicant_event(ctx, EVENT_DISASSOC, NULL);
1270 break;
1271 case RTM_IEEE80211_SCAN:
1272 wpa_supplicant_event(ctx, EVENT_SCAN_RESULTS, NULL);
1273 break;
1274 case RTM_IEEE80211_REPLAY:
1275 /* ignore */
1276 break;
1277 case RTM_IEEE80211_MICHAEL:
1278 mic = (struct ieee80211_michael_event *) &ifan[1];
1279 wpa_printf(MSG_DEBUG,
1280 "Michael MIC failure wireless event: "
1281 "keyix=%u src_addr=" MACSTR, mic->iev_keyix,
1282 MAC2STR(mic->iev_src));
1283
1284 os_memset(&event, 0, sizeof(event));
1285 event.michael_mic_failure.unicast =
1286 !IEEE80211_IS_MULTICAST(mic->iev_dst);
1287 wpa_supplicant_event(ctx, EVENT_MICHAEL_MIC_FAILURE,
1288 &event);
1289 break;
1290 }
1291 break;
1292 case RTM_IFINFO:
1293 ifm = (struct if_msghdr *) rtm;
1294 if (ifm->ifm_index != drv->ifindex)
1295 break;
1296 if ((rtm->rtm_flags & RTF_UP) == 0) {
1297 strlcpy(event.interface_status.ifname, drv->ifname,
1298 sizeof(event.interface_status.ifname));
1299 event.interface_status.ievent = EVENT_INTERFACE_REMOVED;
1300 wpa_printf(MSG_DEBUG, "RTM_IFINFO: Interface '%s' DOWN",
1301 event.interface_status.ifname);
1302 wpa_supplicant_event(ctx, EVENT_INTERFACE_STATUS, &event);
1303 }
1304 break;
1305 }
1306 }
1307
1308 /* Compare function for sorting scan results. Return >0 if @b is consider
1309 * better. */
1310 static int
1311 wpa_scan_result_compar(const void *a, const void *b)
1312 {
1313 const struct wpa_scan_result *wa = a;
1314 const struct wpa_scan_result *wb = b;
1315
1316 /* WPA/WPA2 support preferred */
1317 if ((wb->wpa_ie_len || wb->rsn_ie_len) &&
1318 !(wa->wpa_ie_len || wa->rsn_ie_len))
1319 return 1;
1320 if (!(wb->wpa_ie_len || wb->rsn_ie_len) &&
1321 (wa->wpa_ie_len || wa->rsn_ie_len))
1322 return -1;
1323
1324 /* privacy support preferred */
1325 if ((wa->caps & IEEE80211_CAPINFO_PRIVACY) &&
1326 (wb->caps & IEEE80211_CAPINFO_PRIVACY) == 0)
1327 return 1;
1328 if ((wa->caps & IEEE80211_CAPINFO_PRIVACY) == 0 &&
1329 (wb->caps & IEEE80211_CAPINFO_PRIVACY))
1330 return -1;
1331
1332 /* best/max rate preferred if signal level close enough XXX */
1333 if (wa->maxrate != wb->maxrate && abs(wb->level - wa->level) < 5)
1334 return wb->maxrate - wa->maxrate;
1335
1336 /* use freq for channel preference */
1337
1338 /* all things being equal, use signal level */
1339 return wb->level - wa->level;
1340 }
1341
1342 static int
1343 getmaxrate(uint8_t rates[15], uint8_t nrates)
1344 {
1345 int i, maxrate = -1;
1346
1347 for (i = 0; i < nrates; i++) {
1348 int rate = rates[i] & IEEE80211_RATE_VAL;
1349 if (rate > maxrate)
1350 rate = maxrate;
1351 }
1352 return maxrate;
1353 }
1354
1355 /* unalligned little endian access */
1356 #define LE_READ_4(p) \
1357 ((u_int32_t) \
1358 ((((const u_int8_t *)(p))[0] ) | \
1359 (((const u_int8_t *)(p))[1] << 8) | \
1360 (((const u_int8_t *)(p))[2] << 16) | \
1361 (((const u_int8_t *)(p))[3] << 24)))
1362
1363 static int __inline
1364 iswpaoui(const u_int8_t *frm)
1365 {
1366 return frm[1] > 3 && LE_READ_4(frm+2) == ((WPA_OUI_TYPE<<24)|WPA_OUI);
1367 }
1368
1369 static int
1370 wpa_driver_bsd_get_scan_results(void *priv,
1371 struct wpa_scan_result *results,
1372 size_t max_size)
1373 {
1374 #define min(a,b) ((a)>(b)?(b):(a))
1375 struct wpa_driver_bsd_data *drv = priv;
1376 uint8_t buf[24*1024];
1377 uint8_t *cp, *vp;
1378 struct ieee80211req_scan_result *sr;
1379 struct wpa_scan_result *wsr;
1380 int len, ielen;
1381
1382 os_memset(results, 0, max_size * sizeof(struct wpa_scan_result));
1383
1384 len = get80211var(drv, IEEE80211_IOC_SCAN_RESULTS, buf, sizeof(buf));
1385 if (len < 0)
1386 return -1;
1387 cp = buf;
1388 wsr = results;
1389 while (len >= sizeof(struct ieee80211req_scan_result)) {
1390 sr = (struct ieee80211req_scan_result *) cp;
1391 os_memcpy(wsr->bssid, sr->isr_bssid, IEEE80211_ADDR_LEN);
1392 wsr->ssid_len = sr->isr_ssid_len;
1393 wsr->freq = sr->isr_freq;
1394 wsr->noise = sr->isr_noise;
1395 wsr->qual = sr->isr_rssi;
1396 wsr->level = 0; /* XXX? */
1397 wsr->caps = sr->isr_capinfo;
1398 wsr->maxrate = getmaxrate(sr->isr_rates, sr->isr_nrates);
1399 vp = (u_int8_t *)(sr+1);
1400 os_memcpy(wsr->ssid, vp, sr->isr_ssid_len);
1401 if (sr->isr_ie_len > 0) {
1402 vp += sr->isr_ssid_len;
1403 ielen = sr->isr_ie_len;
1404 while (ielen > 0) {
1405 switch (vp[0]) {
1406 case IEEE80211_ELEMID_VENDOR:
1407 if (!iswpaoui(vp))
1408 break;
1409 wsr->wpa_ie_len =
1410 min(2+vp[1], SSID_MAX_WPA_IE_LEN);
1411 os_memcpy(wsr->wpa_ie, vp,
1412 wsr->wpa_ie_len);
1413 break;
1414 case IEEE80211_ELEMID_RSN:
1415 wsr->rsn_ie_len =
1416 min(2+vp[1], SSID_MAX_WPA_IE_LEN);
1417 os_memcpy(wsr->rsn_ie, vp,
1418 wsr->rsn_ie_len);
1419 break;
1420 }
1421 ielen -= 2+vp[1];
1422 vp += 2+vp[1];
1423 }
1424 }
1425
1426 cp += sr->isr_len, len -= sr->isr_len;
1427 wsr++;
1428 }
1429 qsort(results, wsr - results, sizeof(struct wpa_scan_result),
1430 wpa_scan_result_compar);
1431
1432 wpa_printf(MSG_DEBUG, "Received %d bytes of scan results (%d BSSes)",
1433 len, wsr - results);
1434
1435 return wsr - results;
1436 #undef min
1437 }
1438
1439 static void *
1440 wpa_driver_bsd_init(void *ctx, const char *ifname)
1441 {
1442 #define GETPARAM(drv, param, v) \
1443 (((v) = get80211param(drv, param)) != -1)
1444 struct wpa_driver_bsd_data *drv;
1445
1446 drv = os_zalloc(sizeof(*drv));
1447 if (drv == NULL)
1448 return NULL;
1449 /*
1450 * NB: We require the interface name be mappable to an index.
1451 * This implies we do not support having wpa_supplicant
1452 * wait for an interface to appear. This seems ok; that
1453 * doesn't belong here; it's really the job of devd.
1454 */
1455 drv->ifindex = if_nametoindex(ifname);
1456 if (drv->ifindex == 0) {
1457 wpa_printf(MSG_DEBUG, "%s: interface %s does not exist",
1458 __func__, ifname);
1459 goto fail1;
1460 }
1461 drv->sock = socket(PF_INET, SOCK_DGRAM, 0);
1462 if (drv->sock < 0)
1463 goto fail1;
1464 drv->route = socket(PF_ROUTE, SOCK_RAW, 0);
1465 if (drv->route < 0)
1466 goto fail;
1467 eloop_register_read_sock(drv->route,
1468 wpa_driver_bsd_event_receive, ctx, drv);
1469
1470 drv->ctx = ctx;
1471 os_strlcpy(drv->ifname, ifname, sizeof(drv->ifname));
1472
1473 if (!GETPARAM(drv, IEEE80211_IOC_ROAMING, drv->prev_roaming)) {
1474 wpa_printf(MSG_DEBUG, "%s: failed to get roaming state: %s",
1475 __func__, strerror(errno));
1476 goto fail;
1477 }
1478 if (!GETPARAM(drv, IEEE80211_IOC_PRIVACY, drv->prev_privacy)) {
1479 wpa_printf(MSG_DEBUG, "%s: failed to get privacy state: %s",
1480 __func__, strerror(errno));
1481 goto fail;
1482 }
1483 if (!GETPARAM(drv, IEEE80211_IOC_WPA, drv->prev_wpa)) {
1484 wpa_printf(MSG_DEBUG, "%s: failed to get wpa state: %s",
1485 __func__, strerror(errno));
1486 goto fail;
1487 }
1488 if (set80211param(drv, IEEE80211_IOC_ROAMING, IEEE80211_ROAMING_MANUAL) < 0) {
1489 wpa_printf(MSG_DEBUG, "%s: failed to set wpa_supplicant-based "
1490 "roaming: %s", __func__, strerror(errno));
1491 goto fail;
1492 }
1493
1494 if (set80211param(drv, IEEE80211_IOC_WPA, 1+2) < 0) {
1495 wpa_printf(MSG_DEBUG, "%s: failed to enable WPA support %s",
1496 __func__, strerror(errno));
1497 goto fail;
1498 }
1499
1500 return drv;
1501 fail:
1502 close(drv->sock);
1503 fail1:
1504 os_free(drv);
1505 return NULL;
1506 #undef GETPARAM
1507 }
1508
1509 static void
1510 wpa_driver_bsd_deinit(void *priv)
1511 {
1512 struct wpa_driver_bsd_data *drv = priv;
1513 int flags;
1514
1515 eloop_unregister_read_sock(drv->route);
1516
1517 /* NB: mark interface down */
1518 if (getifflags(drv, &flags) == 0)
1519 (void) setifflags(drv, flags &~ IFF_UP);
1520
1521 wpa_driver_bsd_set_wpa_internal(drv, drv->prev_wpa, drv->prev_privacy);
1522 if (set80211param(drv, IEEE80211_IOC_ROAMING, drv->prev_roaming) < 0)
1523 wpa_printf(MSG_DEBUG, "%s: failed to restore roaming state",
1524 __func__);
1525
1526 (void) close(drv->route); /* ioctl socket */
1527 (void) close(drv->sock); /* event socket */
1528 os_free(drv);
1529 }
1530
1531
1532 const struct wpa_driver_ops wpa_driver_bsd_ops = {
1533 .name = "bsd",
1534 .desc = "BSD 802.11 support (Atheros, etc.)",
1535 .init = wpa_driver_bsd_init,
1536 .deinit = wpa_driver_bsd_deinit,
1537 .get_bssid = wpa_driver_bsd_get_bssid,
1538 .get_ssid = wpa_driver_bsd_get_ssid,
1539 .set_wpa = wpa_driver_bsd_set_wpa,
1540 .set_key = wpa_driver_bsd_set_key,
1541 .set_countermeasures = wpa_driver_bsd_set_countermeasures,
1542 .set_drop_unencrypted = wpa_driver_bsd_set_drop_unencrypted,
1543 .scan = wpa_driver_bsd_scan,
1544 .get_scan_results = wpa_driver_bsd_get_scan_results,
1545 .deauthenticate = wpa_driver_bsd_deauthenticate,
1546 .disassociate = wpa_driver_bsd_disassociate,
1547 .associate = wpa_driver_bsd_associate,
1548 .set_auth_alg = wpa_driver_bsd_set_auth_alg,
1549 };
1550
1551 #endif /* HOSTAPD */
Unnamed repository; edit this file 'description' to name the repository.