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