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