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