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