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