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