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