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