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