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