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