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