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