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