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