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