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