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