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