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