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