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