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