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