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