1209139Srpaulo/* 2209139Srpaulo * WPA Supplicant - driver interaction with BSD net80211 layer 3209139Srpaulo * Copyright (c) 2004, Sam Leffler <sam@errno.com> 4214501Srpaulo * Copyright (c) 2004, 2Wire, Inc 5209139Srpaulo * 6252190Srpaulo * This software may be distributed under the terms of the BSD license. 7252190Srpaulo * See README for more details. 8209139Srpaulo */ 9209139Srpaulo 10209139Srpaulo#include "includes.h" 11209139Srpaulo#include <sys/ioctl.h> 12252190Srpaulo#include <sys/sysctl.h> 13209139Srpaulo 14209139Srpaulo#include "common.h" 15209139Srpaulo#include "driver.h" 16209139Srpaulo#include "eloop.h" 17214501Srpaulo#include "common/ieee802_11_defs.h" 18252190Srpaulo#include "common/wpa_common.h" 19209139Srpaulo 20209139Srpaulo#include <net/if.h> 21214501Srpaulo#include <net/if_media.h> 22209139Srpaulo 23209139Srpaulo#ifdef __NetBSD__ 24209139Srpaulo#include <net/if_ether.h> 25209139Srpaulo#else 26209139Srpaulo#include <net/ethernet.h> 27209139Srpaulo#endif 28214501Srpaulo#include <net/route.h> 29209139Srpaulo 30214501Srpaulo#ifdef __DragonFly__ 31214501Srpaulo#include <netproto/802_11/ieee80211_ioctl.h> 32214501Srpaulo#include <netproto/802_11/ieee80211_dragonfly.h> 33214501Srpaulo#else /* __DragonFly__ */ 34214501Srpaulo#ifdef __GLIBC__ 35214501Srpaulo#include <netinet/ether.h> 36214501Srpaulo#endif /* __GLIBC__ */ 37209139Srpaulo#include <net80211/ieee80211.h> 38214501Srpaulo#include <net80211/ieee80211_ioctl.h> 39209139Srpaulo#include <net80211/ieee80211_crypto.h> 40214501Srpaulo#endif /* __DragonFly__ || __GLIBC__ */ 41214501Srpaulo#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) 42214501Srpaulo#include <net80211/ieee80211_freebsd.h> 43214501Srpaulo#endif 44214501Srpaulo#if __NetBSD__ 45214501Srpaulo#include <net80211/ieee80211_netbsd.h> 46214501Srpaulo#endif 47209139Srpaulo 48214501Srpaulo#include "l2_packet/l2_packet.h" 49214501Srpaulo 50214501Srpaulostruct bsd_driver_data { 51214501Srpaulo struct hostapd_data *hapd; /* back pointer */ 52214501Srpaulo 53209139Srpaulo int sock; /* open socket for 802.11 ioctls */ 54214501Srpaulo struct l2_packet_data *sock_xmit;/* raw packet xmit socket */ 55209139Srpaulo int route; /* routing socket for events */ 56209139Srpaulo char ifname[IFNAMSIZ+1]; /* interface name */ 57209139Srpaulo unsigned int ifindex; /* interface index */ 58209139Srpaulo void *ctx; 59214501Srpaulo struct wpa_driver_capa capa; /* driver capability */ 60214501Srpaulo int is_ap; /* Access point mode */ 61214501Srpaulo int prev_roaming; /* roaming state to restore on deinit */ 62214501Srpaulo int prev_privacy; /* privacy state to restore on deinit */ 63214501Srpaulo int prev_wpa; /* wpa state to restore on deinit */ 64252726Srpaulo enum ieee80211_opmode opmode; /* operation mode */ 65209139Srpaulo}; 66209139Srpaulo 67214501Srpaulo/* Generic functions for hostapd and wpa_supplicant */ 68214501Srpaulo 69252726Srpaulostatic enum ieee80211_opmode 70252726Srpauloget80211opmode(struct bsd_driver_data *drv) 71252726Srpaulo{ 72252726Srpaulo struct ifmediareq ifmr; 73252726Srpaulo 74252726Srpaulo (void) memset(&ifmr, 0, sizeof(ifmr)); 75252726Srpaulo (void) strncpy(ifmr.ifm_name, drv->ifname, sizeof(ifmr.ifm_name)); 76252726Srpaulo 77252726Srpaulo if (ioctl(drv->sock, SIOCGIFMEDIA, (caddr_t)&ifmr) >= 0) { 78252726Srpaulo if (ifmr.ifm_current & IFM_IEEE80211_ADHOC) { 79252726Srpaulo if (ifmr.ifm_current & IFM_FLAG0) 80252726Srpaulo return IEEE80211_M_AHDEMO; 81252726Srpaulo else 82252726Srpaulo return IEEE80211_M_IBSS; 83252726Srpaulo } 84252726Srpaulo if (ifmr.ifm_current & IFM_IEEE80211_HOSTAP) 85252726Srpaulo return IEEE80211_M_HOSTAP; 86252726Srpaulo if (ifmr.ifm_current & IFM_IEEE80211_MONITOR) 87252726Srpaulo return IEEE80211_M_MONITOR; 88252726Srpaulo if (ifmr.ifm_current & IFM_IEEE80211_MBSS) 89252726Srpaulo return IEEE80211_M_MBSS; 90252726Srpaulo } 91252726Srpaulo return IEEE80211_M_STA; 92252726Srpaulo} 93252726Srpaulo 94252726Srpaulo 95209139Srpaulostatic int 96214501Srpaulobsd_set80211(void *priv, int op, int val, const void *arg, int arg_len) 97209139Srpaulo{ 98214501Srpaulo struct bsd_driver_data *drv = priv; 99209139Srpaulo struct ieee80211req ireq; 100209139Srpaulo 101209139Srpaulo os_memset(&ireq, 0, sizeof(ireq)); 102214501Srpaulo os_strlcpy(ireq.i_name, drv->ifname, sizeof(ireq.i_name)); 103209139Srpaulo ireq.i_type = op; 104214501Srpaulo ireq.i_val = val; 105214501Srpaulo ireq.i_data = (void *) arg; 106209139Srpaulo ireq.i_len = arg_len; 107209139Srpaulo 108209139Srpaulo if (ioctl(drv->sock, SIOCS80211, &ireq) < 0) { 109214501Srpaulo wpa_printf(MSG_ERROR, "ioctl[SIOCS80211, op=%u, val=%u, " 110214501Srpaulo "arg_len=%u]: %s", op, val, arg_len, 111214501Srpaulo strerror(errno)); 112209139Srpaulo return -1; 113209139Srpaulo } 114209139Srpaulo return 0; 115209139Srpaulo} 116209139Srpaulo 117209139Srpaulostatic int 118214501Srpaulobsd_get80211(void *priv, struct ieee80211req *ireq, int op, void *arg, 119214501Srpaulo int arg_len) 120209139Srpaulo{ 121214501Srpaulo struct bsd_driver_data *drv = priv; 122209139Srpaulo 123214501Srpaulo os_memset(ireq, 0, sizeof(*ireq)); 124214501Srpaulo os_strlcpy(ireq->i_name, drv->ifname, sizeof(ireq->i_name)); 125214501Srpaulo ireq->i_type = op; 126214501Srpaulo ireq->i_len = arg_len; 127214501Srpaulo ireq->i_data = arg; 128209139Srpaulo 129214501Srpaulo if (ioctl(drv->sock, SIOCG80211, ireq) < 0) { 130214501Srpaulo wpa_printf(MSG_ERROR, "ioctl[SIOCS80211, op=%u, " 131214501Srpaulo "arg_len=%u]: %s", op, arg_len, strerror(errno)); 132209139Srpaulo return -1; 133209139Srpaulo } 134214501Srpaulo return 0; 135209139Srpaulo} 136209139Srpaulo 137209139Srpaulostatic int 138214501Srpauloget80211var(struct bsd_driver_data *drv, int op, void *arg, int arg_len) 139209139Srpaulo{ 140209139Srpaulo struct ieee80211req ireq; 141209139Srpaulo 142214501Srpaulo if (bsd_get80211(drv, &ireq, op, arg, arg_len) < 0) 143209139Srpaulo return -1; 144214501Srpaulo return ireq.i_len; 145209139Srpaulo} 146209139Srpaulo 147209139Srpaulostatic int 148214501Srpauloset80211var(struct bsd_driver_data *drv, int op, const void *arg, int arg_len) 149209139Srpaulo{ 150214501Srpaulo return bsd_set80211(drv, op, 0, arg, arg_len); 151214501Srpaulo} 152209139Srpaulo 153214501Srpaulostatic int 154214501Srpauloset80211param(struct bsd_driver_data *drv, int op, int arg) 155214501Srpaulo{ 156214501Srpaulo return bsd_set80211(drv, op, arg, NULL, 0); 157209139Srpaulo} 158209139Srpaulo 159209139Srpaulostatic int 160214501Srpaulobsd_get_ssid(void *priv, u8 *ssid, int len) 161209139Srpaulo{ 162214501Srpaulo struct bsd_driver_data *drv = priv; 163214501Srpaulo#ifdef SIOCG80211NWID 164214501Srpaulo struct ieee80211_nwid nwid; 165209139Srpaulo struct ifreq ifr; 166209139Srpaulo 167209139Srpaulo os_memset(&ifr, 0, sizeof(ifr)); 168209139Srpaulo os_strlcpy(ifr.ifr_name, drv->ifname, sizeof(ifr.ifr_name)); 169214501Srpaulo ifr.ifr_data = (void *)&nwid; 170214501Srpaulo if (ioctl(drv->sock, SIOCG80211NWID, &ifr) < 0 || 171214501Srpaulo nwid.i_len > IEEE80211_NWID_LEN) 172214501Srpaulo return -1; 173214501Srpaulo os_memcpy(ssid, nwid.i_nwid, nwid.i_len); 174214501Srpaulo return nwid.i_len; 175214501Srpaulo#else 176214501Srpaulo return get80211var(drv, IEEE80211_IOC_SSID, ssid, IEEE80211_NWID_LEN); 177214501Srpaulo#endif 178209139Srpaulo} 179209139Srpaulo 180209139Srpaulostatic int 181214501Srpaulobsd_set_ssid(void *priv, const u8 *ssid, int ssid_len) 182209139Srpaulo{ 183214501Srpaulo struct bsd_driver_data *drv = priv; 184214501Srpaulo#ifdef SIOCS80211NWID 185214501Srpaulo struct ieee80211_nwid nwid; 186209139Srpaulo struct ifreq ifr; 187209139Srpaulo 188214501Srpaulo os_memcpy(nwid.i_nwid, ssid, ssid_len); 189214501Srpaulo nwid.i_len = ssid_len; 190209139Srpaulo os_memset(&ifr, 0, sizeof(ifr)); 191209139Srpaulo os_strlcpy(ifr.ifr_name, drv->ifname, sizeof(ifr.ifr_name)); 192214501Srpaulo ifr.ifr_data = (void *)&nwid; 193214501Srpaulo return ioctl(drv->sock, SIOCS80211NWID, &ifr); 194214501Srpaulo#else 195214501Srpaulo return set80211var(drv, IEEE80211_IOC_SSID, ssid, ssid_len); 196214501Srpaulo#endif 197209139Srpaulo} 198209139Srpaulo 199209139Srpaulostatic int 200214501Srpaulobsd_get_if_media(void *priv) 201209139Srpaulo{ 202214501Srpaulo struct bsd_driver_data *drv = priv; 203214501Srpaulo struct ifmediareq ifmr; 204209139Srpaulo 205214501Srpaulo os_memset(&ifmr, 0, sizeof(ifmr)); 206214501Srpaulo os_strlcpy(ifmr.ifm_name, drv->ifname, sizeof(ifmr.ifm_name)); 207209139Srpaulo 208214501Srpaulo if (ioctl(drv->sock, SIOCGIFMEDIA, &ifmr) < 0) { 209214501Srpaulo wpa_printf(MSG_ERROR, "%s: SIOCGIFMEDIA %s", __func__, 210214501Srpaulo strerror(errno)); 211214501Srpaulo return -1; 212214501Srpaulo } 213209139Srpaulo 214214501Srpaulo return ifmr.ifm_current; 215209139Srpaulo} 216209139Srpaulo 217209139Srpaulostatic int 218214501Srpaulobsd_set_if_media(void *priv, int media) 219209139Srpaulo{ 220214501Srpaulo struct bsd_driver_data *drv = priv; 221214501Srpaulo struct ifreq ifr; 222209139Srpaulo 223214501Srpaulo os_memset(&ifr, 0, sizeof(ifr)); 224214501Srpaulo os_strlcpy(ifr.ifr_name, drv->ifname, sizeof(ifr.ifr_name)); 225214501Srpaulo ifr.ifr_media = media; 226209139Srpaulo 227214501Srpaulo if (ioctl(drv->sock, SIOCSIFMEDIA, &ifr) < 0) { 228214501Srpaulo wpa_printf(MSG_ERROR, "%s: SIOCSIFMEDIA %s", __func__, 229214501Srpaulo strerror(errno)); 230214501Srpaulo return -1; 231214501Srpaulo } 232209139Srpaulo 233214501Srpaulo return 0; 234209139Srpaulo} 235209139Srpaulo 236209139Srpaulostatic int 237214501Srpaulobsd_set_mediaopt(void *priv, uint32_t mask, uint32_t mode) 238209139Srpaulo{ 239214501Srpaulo int media = bsd_get_if_media(priv); 240214501Srpaulo 241214501Srpaulo if (media < 0) 242214501Srpaulo return -1; 243214501Srpaulo media &= ~mask; 244214501Srpaulo media |= mode; 245214501Srpaulo if (bsd_set_if_media(priv, media) < 0) 246214501Srpaulo return -1; 247214501Srpaulo return 0; 248209139Srpaulo} 249209139Srpaulo 250209139Srpaulostatic int 251214501Srpaulobsd_del_key(void *priv, const u8 *addr, int key_idx) 252209139Srpaulo{ 253214501Srpaulo struct ieee80211req_del_key wk; 254209139Srpaulo 255214501Srpaulo os_memset(&wk, 0, sizeof(wk)); 256214501Srpaulo if (addr == NULL) { 257214501Srpaulo wpa_printf(MSG_DEBUG, "%s: key_idx=%d", __func__, key_idx); 258214501Srpaulo wk.idk_keyix = key_idx; 259214501Srpaulo } else { 260214501Srpaulo wpa_printf(MSG_DEBUG, "%s: addr=" MACSTR, __func__, 261214501Srpaulo MAC2STR(addr)); 262214501Srpaulo os_memcpy(wk.idk_macaddr, addr, IEEE80211_ADDR_LEN); 263214501Srpaulo wk.idk_keyix = (u_int8_t) IEEE80211_KEYIX_NONE; /* XXX */ 264214501Srpaulo } 265209139Srpaulo 266214501Srpaulo return set80211var(priv, IEEE80211_IOC_DELKEY, &wk, sizeof(wk)); 267209139Srpaulo} 268209139Srpaulo 269209139Srpaulostatic int 270214501Srpaulobsd_send_mlme_param(void *priv, const u8 op, const u16 reason, const u8 *addr) 271209139Srpaulo{ 272214501Srpaulo struct ieee80211req_mlme mlme; 273209139Srpaulo 274214501Srpaulo os_memset(&mlme, 0, sizeof(mlme)); 275214501Srpaulo mlme.im_op = op; 276214501Srpaulo mlme.im_reason = reason; 277214501Srpaulo os_memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN); 278214501Srpaulo return set80211var(priv, IEEE80211_IOC_MLME, &mlme, sizeof(mlme)); 279209139Srpaulo} 280209139Srpaulo 281209139Srpaulostatic int 282214501Srpaulobsd_ctrl_iface(void *priv, int enable) 283209139Srpaulo{ 284214501Srpaulo struct bsd_driver_data *drv = priv; 285214501Srpaulo struct ifreq ifr; 286209139Srpaulo 287214501Srpaulo os_memset(&ifr, 0, sizeof(ifr)); 288214501Srpaulo os_strlcpy(ifr.ifr_name, drv->ifname, sizeof(ifr.ifr_name)); 289209139Srpaulo 290214501Srpaulo if (ioctl(drv->sock, SIOCGIFFLAGS, &ifr) < 0) { 291214501Srpaulo perror("ioctl[SIOCGIFFLAGS]"); 292214501Srpaulo return -1; 293209139Srpaulo } 294214501Srpaulo 295252726Srpaulo if (enable) { 296252726Srpaulo if (ifr.ifr_flags & IFF_UP) 297252726Srpaulo return 0; 298214501Srpaulo ifr.ifr_flags |= IFF_UP; 299252726Srpaulo } else { 300252726Srpaulo if (!(ifr.ifr_flags & IFF_UP)) 301252726Srpaulo return 0; 302214501Srpaulo ifr.ifr_flags &= ~IFF_UP; 303252726Srpaulo } 304214501Srpaulo 305214501Srpaulo if (ioctl(drv->sock, SIOCSIFFLAGS, &ifr) < 0) { 306214501Srpaulo perror("ioctl[SIOCSIFFLAGS]"); 307214501Srpaulo return -1; 308214501Srpaulo } 309214501Srpaulo 310214501Srpaulo return 0; 311209139Srpaulo} 312209139Srpaulo 313209139Srpaulostatic int 314252726Srpaulobsd_commit(void *priv) 315252726Srpaulo{ 316252726Srpaulo return bsd_ctrl_iface(priv, 1); 317252726Srpaulo} 318252726Srpaulo 319252726Srpaulostatic int 320214501Srpaulobsd_set_key(const char *ifname, void *priv, enum wpa_alg alg, 321214501Srpaulo const unsigned char *addr, int key_idx, int set_tx, const u8 *seq, 322214501Srpaulo size_t seq_len, const u8 *key, size_t key_len) 323209139Srpaulo{ 324209139Srpaulo struct ieee80211req_key wk; 325252726Srpaulo struct bsd_driver_data *drv = priv; 326209139Srpaulo 327214501Srpaulo wpa_printf(MSG_DEBUG, "%s: alg=%d addr=%p key_idx=%d set_tx=%d " 328214501Srpaulo "seq_len=%zu key_len=%zu", __func__, alg, addr, key_idx, 329214501Srpaulo set_tx, seq_len, key_len); 330209139Srpaulo 331214501Srpaulo if (alg == WPA_ALG_NONE) { 332214501Srpaulo#ifndef HOSTAPD 333252190Srpaulo if (addr == NULL || is_broadcast_ether_addr(addr)) 334214501Srpaulo return bsd_del_key(priv, NULL, key_idx); 335214501Srpaulo else 336214501Srpaulo#endif /* HOSTAPD */ 337214501Srpaulo return bsd_del_key(priv, addr, key_idx); 338214501Srpaulo } 339214501Srpaulo 340214501Srpaulo os_memset(&wk, 0, sizeof(wk)); 341209139Srpaulo switch (alg) { 342209139Srpaulo case WPA_ALG_WEP: 343214501Srpaulo wk.ik_type = IEEE80211_CIPHER_WEP; 344209139Srpaulo break; 345209139Srpaulo case WPA_ALG_TKIP: 346214501Srpaulo wk.ik_type = IEEE80211_CIPHER_TKIP; 347209139Srpaulo break; 348209139Srpaulo case WPA_ALG_CCMP: 349214501Srpaulo wk.ik_type = IEEE80211_CIPHER_AES_CCM; 350209139Srpaulo break; 351209139Srpaulo default: 352214501Srpaulo wpa_printf(MSG_ERROR, "%s: unknown alg=%d", __func__, alg); 353209139Srpaulo return -1; 354209139Srpaulo } 355209139Srpaulo 356209139Srpaulo wk.ik_flags = IEEE80211_KEY_RECV; 357209139Srpaulo if (set_tx) 358209139Srpaulo wk.ik_flags |= IEEE80211_KEY_XMIT; 359214501Srpaulo 360214501Srpaulo if (addr == NULL) { 361214501Srpaulo os_memset(wk.ik_macaddr, 0xff, IEEE80211_ADDR_LEN); 362209139Srpaulo wk.ik_keyix = key_idx; 363209139Srpaulo } else { 364214501Srpaulo os_memcpy(wk.ik_macaddr, addr, IEEE80211_ADDR_LEN); 365214501Srpaulo /* 366214501Srpaulo * Deduce whether group/global or unicast key by checking 367214501Srpaulo * the address (yech). Note also that we can only mark global 368214501Srpaulo * keys default; doing this for a unicast key is an error. 369214501Srpaulo */ 370252190Srpaulo if (is_broadcast_ether_addr(addr)) { 371214501Srpaulo wk.ik_flags |= IEEE80211_KEY_GROUP; 372214501Srpaulo wk.ik_keyix = key_idx; 373214501Srpaulo } else { 374214501Srpaulo wk.ik_keyix = key_idx == 0 ? IEEE80211_KEYIX_NONE : 375214501Srpaulo key_idx; 376214501Srpaulo } 377209139Srpaulo } 378209139Srpaulo if (wk.ik_keyix != IEEE80211_KEYIX_NONE && set_tx) 379209139Srpaulo wk.ik_flags |= IEEE80211_KEY_DEFAULT; 380252726Srpaulo#ifndef HOSTAPD 381252726Srpaulo /* 382252726Srpaulo * Ignore replay failures in IBSS and AHDEMO mode. 383252726Srpaulo */ 384252726Srpaulo if (drv->opmode == IEEE80211_M_IBSS || 385252726Srpaulo drv->opmode == IEEE80211_M_AHDEMO) 386252726Srpaulo wk.ik_flags |= IEEE80211_KEY_NOREPLAY; 387252726Srpaulo#endif 388209139Srpaulo wk.ik_keylen = key_len; 389252190Srpaulo if (seq) { 390252190Srpaulo#ifdef WORDS_BIGENDIAN 391252190Srpaulo /* 392252190Srpaulo * wk.ik_keyrsc is in host byte order (big endian), need to 393252190Srpaulo * swap it to match with the byte order used in WPA. 394252190Srpaulo */ 395252190Srpaulo int i; 396252190Srpaulo u8 *keyrsc = (u8 *) &wk.ik_keyrsc; 397252190Srpaulo for (i = 0; i < seq_len; i++) 398252190Srpaulo keyrsc[WPA_KEY_RSC_LEN - i - 1] = seq[i]; 399252190Srpaulo#else /* WORDS_BIGENDIAN */ 400252190Srpaulo os_memcpy(&wk.ik_keyrsc, seq, seq_len); 401252190Srpaulo#endif /* WORDS_BIGENDIAN */ 402252190Srpaulo } 403209139Srpaulo os_memcpy(wk.ik_keydata, key, key_len); 404209139Srpaulo 405214501Srpaulo return set80211var(priv, IEEE80211_IOC_WPAKEY, &wk, sizeof(wk)); 406209139Srpaulo} 407209139Srpaulo 408209139Srpaulostatic int 409214501Srpaulobsd_configure_wpa(void *priv, struct wpa_bss_params *params) 410209139Srpaulo{ 411214501Srpaulo#ifndef IEEE80211_IOC_APPIE 412214501Srpaulo static const char *ciphernames[] = 413214501Srpaulo { "WEP", "TKIP", "AES-OCB", "AES-CCM", "CKIP", "NONE" }; 414214501Srpaulo int v; 415209139Srpaulo 416214501Srpaulo switch (params->wpa_group) { 417214501Srpaulo case WPA_CIPHER_CCMP: 418214501Srpaulo v = IEEE80211_CIPHER_AES_CCM; 419214501Srpaulo break; 420214501Srpaulo case WPA_CIPHER_TKIP: 421214501Srpaulo v = IEEE80211_CIPHER_TKIP; 422214501Srpaulo break; 423214501Srpaulo case WPA_CIPHER_WEP104: 424214501Srpaulo v = IEEE80211_CIPHER_WEP; 425214501Srpaulo break; 426214501Srpaulo case WPA_CIPHER_WEP40: 427214501Srpaulo v = IEEE80211_CIPHER_WEP; 428214501Srpaulo break; 429214501Srpaulo case WPA_CIPHER_NONE: 430214501Srpaulo v = IEEE80211_CIPHER_NONE; 431214501Srpaulo break; 432214501Srpaulo default: 433214501Srpaulo printf("Unknown group key cipher %u\n", 434214501Srpaulo params->wpa_group); 435214501Srpaulo return -1; 436214501Srpaulo } 437214501Srpaulo wpa_printf(MSG_DEBUG, "%s: group key cipher=%s (%u)", 438214501Srpaulo __func__, ciphernames[v], v); 439214501Srpaulo if (set80211param(priv, IEEE80211_IOC_MCASTCIPHER, v)) { 440214501Srpaulo printf("Unable to set group key cipher to %u (%s)\n", 441214501Srpaulo v, ciphernames[v]); 442214501Srpaulo return -1; 443214501Srpaulo } 444214501Srpaulo if (v == IEEE80211_CIPHER_WEP) { 445214501Srpaulo /* key length is done only for specific ciphers */ 446214501Srpaulo v = (params->wpa_group == WPA_CIPHER_WEP104 ? 13 : 5); 447214501Srpaulo if (set80211param(priv, IEEE80211_IOC_MCASTKEYLEN, v)) { 448214501Srpaulo printf("Unable to set group key length to %u\n", v); 449214501Srpaulo return -1; 450214501Srpaulo } 451214501Srpaulo } 452214501Srpaulo 453214501Srpaulo v = 0; 454214501Srpaulo if (params->wpa_pairwise & WPA_CIPHER_CCMP) 455214501Srpaulo v |= 1<<IEEE80211_CIPHER_AES_CCM; 456214501Srpaulo if (params->wpa_pairwise & WPA_CIPHER_TKIP) 457214501Srpaulo v |= 1<<IEEE80211_CIPHER_TKIP; 458214501Srpaulo if (params->wpa_pairwise & WPA_CIPHER_NONE) 459214501Srpaulo v |= 1<<IEEE80211_CIPHER_NONE; 460214501Srpaulo wpa_printf(MSG_DEBUG, "%s: pairwise key ciphers=0x%x", __func__, v); 461214501Srpaulo if (set80211param(priv, IEEE80211_IOC_UCASTCIPHERS, v)) { 462214501Srpaulo printf("Unable to set pairwise key ciphers to 0x%x\n", v); 463214501Srpaulo return -1; 464214501Srpaulo } 465214501Srpaulo 466214501Srpaulo wpa_printf(MSG_DEBUG, "%s: key management algorithms=0x%x", 467214501Srpaulo __func__, params->wpa_key_mgmt); 468214501Srpaulo if (set80211param(priv, IEEE80211_IOC_KEYMGTALGS, 469214501Srpaulo params->wpa_key_mgmt)) { 470214501Srpaulo printf("Unable to set key management algorithms to 0x%x\n", 471214501Srpaulo params->wpa_key_mgmt); 472214501Srpaulo return -1; 473214501Srpaulo } 474214501Srpaulo 475214501Srpaulo v = 0; 476214501Srpaulo if (params->rsn_preauth) 477214501Srpaulo v |= BIT(0); 478214501Srpaulo wpa_printf(MSG_DEBUG, "%s: rsn capabilities=0x%x", 479214501Srpaulo __func__, params->rsn_preauth); 480214501Srpaulo if (set80211param(priv, IEEE80211_IOC_RSNCAPS, v)) { 481214501Srpaulo printf("Unable to set RSN capabilities to 0x%x\n", v); 482214501Srpaulo return -1; 483214501Srpaulo } 484214501Srpaulo#endif /* IEEE80211_IOC_APPIE */ 485214501Srpaulo 486214501Srpaulo wpa_printf(MSG_DEBUG, "%s: enable WPA= 0x%x", __func__, params->wpa); 487214501Srpaulo if (set80211param(priv, IEEE80211_IOC_WPA, params->wpa)) { 488214501Srpaulo printf("Unable to set WPA to %u\n", params->wpa); 489214501Srpaulo return -1; 490214501Srpaulo } 491214501Srpaulo return 0; 492214501Srpaulo} 493214501Srpaulo 494214501Srpaulostatic int 495214501Srpaulobsd_set_ieee8021x(void *priv, struct wpa_bss_params *params) 496214501Srpaulo{ 497214501Srpaulo wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, params->enabled); 498214501Srpaulo 499214501Srpaulo if (!params->enabled) { 500214501Srpaulo /* XXX restore state */ 501214501Srpaulo return set80211param(priv, IEEE80211_IOC_AUTHMODE, 502214501Srpaulo IEEE80211_AUTH_AUTO); 503214501Srpaulo } 504214501Srpaulo if (!params->wpa && !params->ieee802_1x) { 505214501Srpaulo wpa_printf(MSG_ERROR, "%s: No 802.1X or WPA enabled", 506214501Srpaulo __func__); 507214501Srpaulo return -1; 508214501Srpaulo } 509214501Srpaulo if (params->wpa && bsd_configure_wpa(priv, params) != 0) { 510214501Srpaulo wpa_printf(MSG_ERROR, "%s: Failed to configure WPA state", 511214501Srpaulo __func__); 512214501Srpaulo return -1; 513214501Srpaulo } 514214501Srpaulo if (set80211param(priv, IEEE80211_IOC_AUTHMODE, 515214501Srpaulo (params->wpa ? IEEE80211_AUTH_WPA : IEEE80211_AUTH_8021X))) { 516214501Srpaulo wpa_printf(MSG_ERROR, "%s: Failed to enable WPA/802.1X", 517214501Srpaulo __func__); 518214501Srpaulo return -1; 519214501Srpaulo } 520214501Srpaulo return bsd_ctrl_iface(priv, 1); 521214501Srpaulo} 522214501Srpaulo 523214501Srpaulostatic int 524214501Srpaulobsd_set_sta_authorized(void *priv, const u8 *addr, 525214501Srpaulo int total_flags, int flags_or, int flags_and) 526214501Srpaulo{ 527214501Srpaulo int authorized = -1; 528214501Srpaulo 529214501Srpaulo /* For now, only support setting Authorized flag */ 530214501Srpaulo if (flags_or & WPA_STA_AUTHORIZED) 531214501Srpaulo authorized = 1; 532214501Srpaulo if (!(flags_and & WPA_STA_AUTHORIZED)) 533214501Srpaulo authorized = 0; 534214501Srpaulo 535214501Srpaulo if (authorized < 0) 536214501Srpaulo return 0; 537214501Srpaulo 538214501Srpaulo return bsd_send_mlme_param(priv, authorized ? 539214501Srpaulo IEEE80211_MLME_AUTHORIZE : 540214501Srpaulo IEEE80211_MLME_UNAUTHORIZE, 0, addr); 541214501Srpaulo} 542214501Srpaulo 543214501Srpaulostatic void 544214501Srpaulobsd_new_sta(void *priv, void *ctx, u8 addr[IEEE80211_ADDR_LEN]) 545214501Srpaulo{ 546214501Srpaulo struct ieee80211req_wpaie ie; 547214501Srpaulo int ielen = 0; 548214501Srpaulo u8 *iebuf = NULL; 549214501Srpaulo 550214501Srpaulo /* 551214501Srpaulo * Fetch and validate any negotiated WPA/RSN parameters. 552214501Srpaulo */ 553214501Srpaulo memset(&ie, 0, sizeof(ie)); 554214501Srpaulo memcpy(ie.wpa_macaddr, addr, IEEE80211_ADDR_LEN); 555214501Srpaulo if (get80211var(priv, IEEE80211_IOC_WPAIE, &ie, sizeof(ie)) < 0) { 556214501Srpaulo printf("Failed to get WPA/RSN information element.\n"); 557214501Srpaulo goto no_ie; 558214501Srpaulo } 559214501Srpaulo iebuf = ie.wpa_ie; 560214501Srpaulo ielen = ie.wpa_ie[1]; 561214501Srpaulo if (ielen == 0) 562214501Srpaulo iebuf = NULL; 563214501Srpaulo else 564214501Srpaulo ielen += 2; 565214501Srpaulo 566214501Srpaulono_ie: 567252190Srpaulo drv_event_assoc(ctx, addr, iebuf, ielen, 0); 568214501Srpaulo} 569214501Srpaulo 570214501Srpaulostatic int 571214501Srpaulobsd_send_eapol(void *priv, const u8 *addr, const u8 *data, size_t data_len, 572252190Srpaulo int encrypt, const u8 *own_addr, u32 flags) 573214501Srpaulo{ 574214501Srpaulo struct bsd_driver_data *drv = priv; 575214501Srpaulo 576214501Srpaulo wpa_hexdump(MSG_MSGDUMP, "TX EAPOL", data, data_len); 577214501Srpaulo 578214501Srpaulo return l2_packet_send(drv->sock_xmit, addr, ETH_P_EAPOL, data, 579214501Srpaulo data_len); 580214501Srpaulo} 581214501Srpaulo 582214501Srpaulostatic int 583252190Srpaulobsd_set_freq(void *priv, struct hostapd_freq_params *freq) 584214501Srpaulo{ 585214501Srpaulo struct bsd_driver_data *drv = priv; 586214501Srpaulo#ifdef SIOCS80211CHANNEL 587214501Srpaulo struct ieee80211chanreq creq; 588214501Srpaulo#endif /* SIOCS80211CHANNEL */ 589214501Srpaulo u32 mode; 590252190Srpaulo int channel = freq->channel; 591214501Srpaulo 592252190Srpaulo if (channel < 14) { 593252190Srpaulo mode = 594252190Srpaulo#ifdef CONFIG_IEEE80211N 595252190Srpaulo freq->ht_enabled ? IFM_IEEE80211_11NG : 596252190Srpaulo#endif /* CONFIG_IEEE80211N */ 597252190Srpaulo IFM_IEEE80211_11G; 598252190Srpaulo } else if (channel == 14) { 599214501Srpaulo mode = IFM_IEEE80211_11B; 600252190Srpaulo } else { 601252190Srpaulo mode = 602252190Srpaulo#ifdef CONFIG_IEEE80211N 603252190Srpaulo freq->ht_enabled ? IFM_IEEE80211_11NA : 604252190Srpaulo#endif /* CONFIG_IEEE80211N */ 605252190Srpaulo IFM_IEEE80211_11A; 606252190Srpaulo } 607214501Srpaulo if (bsd_set_mediaopt(drv, IFM_MMASK, mode) < 0) { 608214501Srpaulo wpa_printf(MSG_ERROR, "%s: failed to set modulation mode", 609214501Srpaulo __func__); 610214501Srpaulo return -1; 611214501Srpaulo } 612214501Srpaulo 613214501Srpaulo#ifdef SIOCS80211CHANNEL 614214501Srpaulo os_memset(&creq, 0, sizeof(creq)); 615214501Srpaulo os_strlcpy(creq.i_name, drv->ifname, sizeof(creq.i_name)); 616252190Srpaulo creq.i_channel = (u_int16_t)channel; 617214501Srpaulo return ioctl(drv->sock, SIOCS80211CHANNEL, &creq); 618214501Srpaulo#else /* SIOCS80211CHANNEL */ 619214501Srpaulo return set80211param(priv, IEEE80211_IOC_CHANNEL, channel); 620214501Srpaulo#endif /* SIOCS80211CHANNEL */ 621214501Srpaulo} 622214501Srpaulo 623214501Srpaulostatic int 624214501Srpaulobsd_set_opt_ie(void *priv, const u8 *ie, size_t ie_len) 625214501Srpaulo{ 626214501Srpaulo#ifdef IEEE80211_IOC_APPIE 627214501Srpaulo wpa_printf(MSG_DEBUG, "%s: set WPA+RSN ie (len %lu)", __func__, 628214501Srpaulo (unsigned long)ie_len); 629214501Srpaulo return bsd_set80211(priv, IEEE80211_IOC_APPIE, IEEE80211_APPIE_WPA, 630214501Srpaulo ie, ie_len); 631214501Srpaulo#endif /* IEEE80211_IOC_APPIE */ 632214501Srpaulo return 0; 633214501Srpaulo} 634214501Srpaulo 635252190Srpaulostatic int 636252190Srpaulortbuf_len(void) 637252190Srpaulo{ 638252190Srpaulo size_t len; 639214501Srpaulo 640252190Srpaulo int mib[6] = {CTL_NET, AF_ROUTE, 0, AF_INET, NET_RT_DUMP, 0}; 641252190Srpaulo 642252190Srpaulo if (sysctl(mib, 6, NULL, &len, NULL, 0) < 0) { 643252190Srpaulo wpa_printf(MSG_WARNING, "%s failed: %s\n", __func__, 644252190Srpaulo strerror(errno)); 645252190Srpaulo len = 2048; 646252190Srpaulo } 647252190Srpaulo 648252190Srpaulo return len; 649252190Srpaulo} 650252190Srpaulo 651214501Srpaulo#ifdef HOSTAPD 652214501Srpaulo 653214501Srpaulo/* 654214501Srpaulo * Avoid conflicts with hostapd definitions by undefining couple of defines 655214501Srpaulo * from net80211 header files. 656214501Srpaulo */ 657214501Srpaulo#undef RSN_VERSION 658214501Srpaulo#undef WPA_VERSION 659214501Srpaulo#undef WPA_OUI_TYPE 660214501Srpaulo 661214501Srpaulostatic int bsd_sta_deauth(void *priv, const u8 *own_addr, const u8 *addr, 662214501Srpaulo int reason_code); 663214501Srpaulo 664214501Srpaulostatic const char * 665214501Srpauloether_sprintf(const u8 *addr) 666214501Srpaulo{ 667214501Srpaulo static char buf[sizeof(MACSTR)]; 668214501Srpaulo 669214501Srpaulo if (addr != NULL) 670214501Srpaulo snprintf(buf, sizeof(buf), MACSTR, MAC2STR(addr)); 671214501Srpaulo else 672214501Srpaulo snprintf(buf, sizeof(buf), MACSTR, 0,0,0,0,0,0); 673214501Srpaulo return buf; 674214501Srpaulo} 675214501Srpaulo 676214501Srpaulostatic int 677214501Srpaulobsd_set_privacy(void *priv, int enabled) 678214501Srpaulo{ 679209139Srpaulo wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled); 680214501Srpaulo 681214501Srpaulo return set80211param(priv, IEEE80211_IOC_PRIVACY, enabled); 682209139Srpaulo} 683209139Srpaulo 684214501Srpaulostatic int 685214501Srpaulobsd_get_seqnum(const char *ifname, void *priv, const u8 *addr, int idx, 686214501Srpaulo u8 *seq) 687214501Srpaulo{ 688214501Srpaulo struct ieee80211req_key wk; 689209139Srpaulo 690214501Srpaulo wpa_printf(MSG_DEBUG, "%s: addr=%s idx=%d", 691214501Srpaulo __func__, ether_sprintf(addr), idx); 692214501Srpaulo 693214501Srpaulo memset(&wk, 0, sizeof(wk)); 694214501Srpaulo if (addr == NULL) 695214501Srpaulo memset(wk.ik_macaddr, 0xff, IEEE80211_ADDR_LEN); 696214501Srpaulo else 697214501Srpaulo memcpy(wk.ik_macaddr, addr, IEEE80211_ADDR_LEN); 698214501Srpaulo wk.ik_keyix = idx; 699214501Srpaulo 700214501Srpaulo if (get80211var(priv, IEEE80211_IOC_WPAKEY, &wk, sizeof(wk)) < 0) { 701214501Srpaulo printf("Failed to get encryption.\n"); 702214501Srpaulo return -1; 703214501Srpaulo } 704214501Srpaulo 705214501Srpaulo#ifdef WORDS_BIGENDIAN 706214501Srpaulo { 707214501Srpaulo /* 708214501Srpaulo * wk.ik_keytsc is in host byte order (big endian), need to 709214501Srpaulo * swap it to match with the byte order used in WPA. 710214501Srpaulo */ 711214501Srpaulo int i; 712214501Srpaulo u8 tmp[WPA_KEY_RSC_LEN]; 713214501Srpaulo memcpy(tmp, &wk.ik_keytsc, sizeof(wk.ik_keytsc)); 714214501Srpaulo for (i = 0; i < WPA_KEY_RSC_LEN; i++) { 715214501Srpaulo seq[i] = tmp[WPA_KEY_RSC_LEN - i - 1]; 716214501Srpaulo } 717214501Srpaulo } 718214501Srpaulo#else /* WORDS_BIGENDIAN */ 719214501Srpaulo memcpy(seq, &wk.ik_keytsc, sizeof(wk.ik_keytsc)); 720214501Srpaulo#endif /* WORDS_BIGENDIAN */ 721214501Srpaulo return 0; 722214501Srpaulo} 723214501Srpaulo 724214501Srpaulo 725214501Srpaulostatic int 726214501Srpaulobsd_flush(void *priv) 727214501Srpaulo{ 728214501Srpaulo u8 allsta[IEEE80211_ADDR_LEN]; 729214501Srpaulo 730214501Srpaulo memset(allsta, 0xff, IEEE80211_ADDR_LEN); 731214501Srpaulo return bsd_sta_deauth(priv, NULL, allsta, IEEE80211_REASON_AUTH_LEAVE); 732214501Srpaulo} 733214501Srpaulo 734214501Srpaulo 735209139Srpaulostatic int 736214501Srpaulobsd_read_sta_driver_data(void *priv, struct hostap_sta_driver_data *data, 737214501Srpaulo const u8 *addr) 738209139Srpaulo{ 739214501Srpaulo struct ieee80211req_sta_stats stats; 740209139Srpaulo 741214501Srpaulo memcpy(stats.is_u.macaddr, addr, IEEE80211_ADDR_LEN); 742214501Srpaulo if (get80211var(priv, IEEE80211_IOC_STA_STATS, &stats, sizeof(stats)) 743214501Srpaulo > 0) { 744214501Srpaulo /* XXX? do packets counts include non-data frames? */ 745214501Srpaulo data->rx_packets = stats.is_stats.ns_rx_data; 746214501Srpaulo data->rx_bytes = stats.is_stats.ns_rx_bytes; 747214501Srpaulo data->tx_packets = stats.is_stats.ns_tx_data; 748214501Srpaulo data->tx_bytes = stats.is_stats.ns_tx_bytes; 749214501Srpaulo } 750214501Srpaulo return 0; 751214501Srpaulo} 752214501Srpaulo 753214501Srpaulostatic int 754214501Srpaulobsd_sta_deauth(void *priv, const u8 *own_addr, const u8 *addr, int reason_code) 755214501Srpaulo{ 756214501Srpaulo return bsd_send_mlme_param(priv, IEEE80211_MLME_DEAUTH, reason_code, 757214501Srpaulo addr); 758214501Srpaulo} 759214501Srpaulo 760214501Srpaulostatic int 761214501Srpaulobsd_sta_disassoc(void *priv, const u8 *own_addr, const u8 *addr, 762214501Srpaulo int reason_code) 763214501Srpaulo{ 764214501Srpaulo return bsd_send_mlme_param(priv, IEEE80211_MLME_DISASSOC, reason_code, 765214501Srpaulo addr); 766214501Srpaulo} 767214501Srpaulo 768214501Srpaulostatic void 769214501Srpaulobsd_wireless_event_receive(int sock, void *ctx, void *sock_ctx) 770214501Srpaulo{ 771214501Srpaulo struct bsd_driver_data *drv = ctx; 772252190Srpaulo char *buf; 773214501Srpaulo struct if_announcemsghdr *ifan; 774214501Srpaulo struct rt_msghdr *rtm; 775214501Srpaulo struct ieee80211_michael_event *mic; 776214501Srpaulo struct ieee80211_join_event *join; 777214501Srpaulo struct ieee80211_leave_event *leave; 778252190Srpaulo int n, len; 779214501Srpaulo union wpa_event_data data; 780214501Srpaulo 781252190Srpaulo len = rtbuf_len(); 782252190Srpaulo 783252190Srpaulo buf = os_malloc(len); 784252190Srpaulo if (buf == NULL) { 785252190Srpaulo wpa_printf(MSG_ERROR, "%s os_malloc() failed\n", __func__); 786252190Srpaulo return; 787252190Srpaulo } 788252190Srpaulo 789252190Srpaulo n = read(sock, buf, len); 790214501Srpaulo if (n < 0) { 791214501Srpaulo if (errno != EINTR && errno != EAGAIN) 792252190Srpaulo wpa_printf(MSG_ERROR, "%s read() failed: %s\n", 793252190Srpaulo __func__, strerror(errno)); 794252190Srpaulo os_free(buf); 795214501Srpaulo return; 796214501Srpaulo } 797214501Srpaulo 798214501Srpaulo rtm = (struct rt_msghdr *) buf; 799214501Srpaulo if (rtm->rtm_version != RTM_VERSION) { 800252190Srpaulo wpa_printf(MSG_DEBUG, "Invalid routing message version=%d", 801252190Srpaulo rtm->rtm_version); 802252190Srpaulo os_free(buf); 803214501Srpaulo return; 804214501Srpaulo } 805214501Srpaulo ifan = (struct if_announcemsghdr *) rtm; 806214501Srpaulo switch (rtm->rtm_type) { 807214501Srpaulo case RTM_IEEE80211: 808214501Srpaulo switch (ifan->ifan_what) { 809214501Srpaulo case RTM_IEEE80211_ASSOC: 810214501Srpaulo case RTM_IEEE80211_REASSOC: 811214501Srpaulo case RTM_IEEE80211_DISASSOC: 812214501Srpaulo case RTM_IEEE80211_SCAN: 813214501Srpaulo break; 814214501Srpaulo case RTM_IEEE80211_LEAVE: 815214501Srpaulo leave = (struct ieee80211_leave_event *) &ifan[1]; 816214501Srpaulo drv_event_disassoc(drv->hapd, leave->iev_addr); 817214501Srpaulo break; 818214501Srpaulo case RTM_IEEE80211_JOIN: 819214501Srpaulo#ifdef RTM_IEEE80211_REJOIN 820214501Srpaulo case RTM_IEEE80211_REJOIN: 821214501Srpaulo#endif 822214501Srpaulo join = (struct ieee80211_join_event *) &ifan[1]; 823214501Srpaulo bsd_new_sta(drv, drv->hapd, join->iev_addr); 824214501Srpaulo break; 825214501Srpaulo case RTM_IEEE80211_REPLAY: 826214501Srpaulo /* ignore */ 827214501Srpaulo break; 828214501Srpaulo case RTM_IEEE80211_MICHAEL: 829214501Srpaulo mic = (struct ieee80211_michael_event *) &ifan[1]; 830214501Srpaulo wpa_printf(MSG_DEBUG, 831214501Srpaulo "Michael MIC failure wireless event: " 832214501Srpaulo "keyix=%u src_addr=" MACSTR, mic->iev_keyix, 833214501Srpaulo MAC2STR(mic->iev_src)); 834214501Srpaulo os_memset(&data, 0, sizeof(data)); 835214501Srpaulo data.michael_mic_failure.unicast = 1; 836214501Srpaulo data.michael_mic_failure.src = mic->iev_src; 837214501Srpaulo wpa_supplicant_event(drv->hapd, 838214501Srpaulo EVENT_MICHAEL_MIC_FAILURE, &data); 839214501Srpaulo break; 840214501Srpaulo } 841214501Srpaulo break; 842214501Srpaulo } 843252190Srpaulo os_free(buf); 844214501Srpaulo} 845214501Srpaulo 846214501Srpaulostatic void 847214501Srpaulohandle_read(void *ctx, const u8 *src_addr, const u8 *buf, size_t len) 848214501Srpaulo{ 849214501Srpaulo struct bsd_driver_data *drv = ctx; 850214501Srpaulo drv_event_eapol_rx(drv->hapd, src_addr, buf, len); 851214501Srpaulo} 852214501Srpaulo 853214501Srpaulostatic void * 854214501Srpaulobsd_init(struct hostapd_data *hapd, struct wpa_init_params *params) 855214501Srpaulo{ 856214501Srpaulo struct bsd_driver_data *drv; 857214501Srpaulo 858214501Srpaulo drv = os_zalloc(sizeof(struct bsd_driver_data)); 859214501Srpaulo if (drv == NULL) { 860214501Srpaulo printf("Could not allocate memory for bsd driver data\n"); 861214501Srpaulo goto bad; 862214501Srpaulo } 863214501Srpaulo 864214501Srpaulo drv->hapd = hapd; 865214501Srpaulo drv->sock = socket(PF_INET, SOCK_DGRAM, 0); 866214501Srpaulo if (drv->sock < 0) { 867214501Srpaulo perror("socket[PF_INET,SOCK_DGRAM]"); 868214501Srpaulo goto bad; 869214501Srpaulo } 870214501Srpaulo os_strlcpy(drv->ifname, params->ifname, sizeof(drv->ifname)); 871214501Srpaulo 872214501Srpaulo drv->sock_xmit = l2_packet_init(drv->ifname, NULL, ETH_P_EAPOL, 873214501Srpaulo handle_read, drv, 0); 874214501Srpaulo if (drv->sock_xmit == NULL) 875214501Srpaulo goto bad; 876214501Srpaulo if (l2_packet_get_own_addr(drv->sock_xmit, params->own_addr)) 877214501Srpaulo goto bad; 878214501Srpaulo 879214501Srpaulo /* mark down during setup */ 880214501Srpaulo if (bsd_ctrl_iface(drv, 0) < 0) 881214501Srpaulo goto bad; 882214501Srpaulo 883214501Srpaulo drv->route = socket(PF_ROUTE, SOCK_RAW, 0); 884214501Srpaulo if (drv->route < 0) { 885214501Srpaulo perror("socket(PF_ROUTE,SOCK_RAW)"); 886214501Srpaulo goto bad; 887214501Srpaulo } 888214501Srpaulo eloop_register_read_sock(drv->route, bsd_wireless_event_receive, drv, 889214501Srpaulo NULL); 890214501Srpaulo 891214501Srpaulo if (bsd_set_mediaopt(drv, IFM_OMASK, IFM_IEEE80211_HOSTAP) < 0) { 892214501Srpaulo wpa_printf(MSG_ERROR, "%s: failed to set operation mode", 893214501Srpaulo __func__); 894214501Srpaulo goto bad; 895214501Srpaulo } 896214501Srpaulo 897214501Srpaulo return drv; 898214501Srpaulobad: 899214501Srpaulo if (drv->sock_xmit != NULL) 900214501Srpaulo l2_packet_deinit(drv->sock_xmit); 901214501Srpaulo if (drv->sock >= 0) 902214501Srpaulo close(drv->sock); 903214501Srpaulo if (drv != NULL) 904214501Srpaulo os_free(drv); 905214501Srpaulo return NULL; 906214501Srpaulo} 907214501Srpaulo 908214501Srpaulo 909214501Srpaulostatic void 910214501Srpaulobsd_deinit(void *priv) 911214501Srpaulo{ 912214501Srpaulo struct bsd_driver_data *drv = priv; 913214501Srpaulo 914214501Srpaulo if (drv->route >= 0) { 915214501Srpaulo eloop_unregister_read_sock(drv->route); 916214501Srpaulo close(drv->route); 917214501Srpaulo } 918214501Srpaulo bsd_ctrl_iface(drv, 0); 919214501Srpaulo if (drv->sock >= 0) 920214501Srpaulo close(drv->sock); 921214501Srpaulo if (drv->sock_xmit != NULL) 922214501Srpaulo l2_packet_deinit(drv->sock_xmit); 923214501Srpaulo os_free(drv); 924214501Srpaulo} 925214501Srpaulo 926214501Srpaulo#else /* HOSTAPD */ 927214501Srpaulo 928214501Srpaulostatic int 929214501Srpauloget80211param(struct bsd_driver_data *drv, int op) 930214501Srpaulo{ 931214501Srpaulo struct ieee80211req ireq; 932214501Srpaulo 933214501Srpaulo if (bsd_get80211(drv, &ireq, op, NULL, 0) < 0) 934214501Srpaulo return -1; 935214501Srpaulo return ireq.i_val; 936214501Srpaulo} 937214501Srpaulo 938214501Srpaulostatic int 939214501Srpaulowpa_driver_bsd_get_bssid(void *priv, u8 *bssid) 940214501Srpaulo{ 941214501Srpaulo struct bsd_driver_data *drv = priv; 942214501Srpaulo#ifdef SIOCG80211BSSID 943214501Srpaulo struct ieee80211_bssid bs; 944214501Srpaulo 945214501Srpaulo os_strlcpy(bs.i_name, drv->ifname, sizeof(bs.i_name)); 946214501Srpaulo if (ioctl(drv->sock, SIOCG80211BSSID, &bs) < 0) 947214501Srpaulo return -1; 948214501Srpaulo os_memcpy(bssid, bs.i_bssid, sizeof(bs.i_bssid)); 949214501Srpaulo return 0; 950214501Srpaulo#else 951214501Srpaulo return get80211var(drv, IEEE80211_IOC_BSSID, 952214501Srpaulo bssid, IEEE80211_ADDR_LEN) < 0 ? -1 : 0; 953214501Srpaulo#endif 954214501Srpaulo} 955214501Srpaulo 956214501Srpaulostatic int 957214501Srpaulowpa_driver_bsd_get_ssid(void *priv, u8 *ssid) 958214501Srpaulo{ 959214501Srpaulo struct bsd_driver_data *drv = priv; 960214501Srpaulo return bsd_get_ssid(drv, ssid, 0); 961214501Srpaulo} 962214501Srpaulo 963214501Srpaulostatic int 964214501Srpaulowpa_driver_bsd_set_wpa_ie(struct bsd_driver_data *drv, const u8 *wpa_ie, 965214501Srpaulo size_t wpa_ie_len) 966214501Srpaulo{ 967214501Srpaulo#ifdef IEEE80211_IOC_APPIE 968214501Srpaulo return bsd_set_opt_ie(drv, wpa_ie, wpa_ie_len); 969214501Srpaulo#else /* IEEE80211_IOC_APPIE */ 970214501Srpaulo return set80211var(drv, IEEE80211_IOC_OPTIE, wpa_ie, wpa_ie_len); 971214501Srpaulo#endif /* IEEE80211_IOC_APPIE */ 972214501Srpaulo} 973214501Srpaulo 974214501Srpaulostatic int 975214501Srpaulowpa_driver_bsd_set_wpa_internal(void *priv, int wpa, int privacy) 976214501Srpaulo{ 977214501Srpaulo int ret = 0; 978214501Srpaulo 979214501Srpaulo wpa_printf(MSG_DEBUG, "%s: wpa=%d privacy=%d", 980214501Srpaulo __FUNCTION__, wpa, privacy); 981214501Srpaulo 982214501Srpaulo if (!wpa && wpa_driver_bsd_set_wpa_ie(priv, NULL, 0) < 0) 983214501Srpaulo ret = -1; 984214501Srpaulo if (set80211param(priv, IEEE80211_IOC_PRIVACY, privacy) < 0) 985214501Srpaulo ret = -1; 986214501Srpaulo if (set80211param(priv, IEEE80211_IOC_WPA, wpa) < 0) 987214501Srpaulo ret = -1; 988214501Srpaulo 989214501Srpaulo return ret; 990214501Srpaulo} 991214501Srpaulo 992214501Srpaulostatic int 993214501Srpaulowpa_driver_bsd_set_wpa(void *priv, int enabled) 994214501Srpaulo{ 995214501Srpaulo wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled); 996214501Srpaulo 997214501Srpaulo return wpa_driver_bsd_set_wpa_internal(priv, enabled ? 3 : 0, enabled); 998214501Srpaulo} 999214501Srpaulo 1000214501Srpaulostatic int 1001214501Srpaulowpa_driver_bsd_set_countermeasures(void *priv, int enabled) 1002214501Srpaulo{ 1003209139Srpaulo wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled); 1004214501Srpaulo return set80211param(priv, IEEE80211_IOC_COUNTERMEASURES, enabled); 1005209139Srpaulo} 1006209139Srpaulo 1007214501Srpaulo 1008209139Srpaulostatic int 1009214501Srpaulowpa_driver_bsd_set_drop_unencrypted(void *priv, int enabled) 1010214501Srpaulo{ 1011214501Srpaulo wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled); 1012214501Srpaulo return set80211param(priv, IEEE80211_IOC_DROPUNENCRYPTED, enabled); 1013214501Srpaulo} 1014214501Srpaulo 1015214501Srpaulostatic int 1016209139Srpaulowpa_driver_bsd_deauthenticate(void *priv, const u8 *addr, int reason_code) 1017209139Srpaulo{ 1018214501Srpaulo return bsd_send_mlme_param(priv, IEEE80211_MLME_DEAUTH, reason_code, 1019214501Srpaulo addr); 1020209139Srpaulo} 1021209139Srpaulo 1022209139Srpaulostatic int 1023214501Srpaulowpa_driver_bsd_set_auth_alg(void *priv, int auth_alg) 1024214501Srpaulo{ 1025214501Srpaulo int authmode; 1026214501Srpaulo 1027214501Srpaulo if ((auth_alg & WPA_AUTH_ALG_OPEN) && 1028214501Srpaulo (auth_alg & WPA_AUTH_ALG_SHARED)) 1029214501Srpaulo authmode = IEEE80211_AUTH_AUTO; 1030214501Srpaulo else if (auth_alg & WPA_AUTH_ALG_SHARED) 1031214501Srpaulo authmode = IEEE80211_AUTH_SHARED; 1032214501Srpaulo else 1033214501Srpaulo authmode = IEEE80211_AUTH_OPEN; 1034214501Srpaulo 1035214501Srpaulo return set80211param(priv, IEEE80211_IOC_AUTHMODE, authmode); 1036209139Srpaulo} 1037209139Srpaulo 1038214501Srpaulostatic void 1039214501Srpaulohandle_read(void *ctx, const u8 *src_addr, const u8 *buf, size_t len) 1040214501Srpaulo{ 1041214501Srpaulo struct bsd_driver_data *drv = ctx; 1042214501Srpaulo 1043214501Srpaulo drv_event_eapol_rx(drv->ctx, src_addr, buf, len); 1044214501Srpaulo} 1045214501Srpaulo 1046209139Srpaulostatic int 1047209139Srpaulowpa_driver_bsd_associate(void *priv, struct wpa_driver_associate_params *params) 1048209139Srpaulo{ 1049214501Srpaulo struct bsd_driver_data *drv = priv; 1050209139Srpaulo struct ieee80211req_mlme mlme; 1051214501Srpaulo u32 mode; 1052209139Srpaulo int privacy; 1053214501Srpaulo int ret = 0; 1054209139Srpaulo 1055209139Srpaulo wpa_printf(MSG_DEBUG, 1056209139Srpaulo "%s: ssid '%.*s' wpa ie len %u pairwise %u group %u key mgmt %u" 1057209139Srpaulo , __func__ 1058214501Srpaulo , (unsigned int) params->ssid_len, params->ssid 1059214501Srpaulo , (unsigned int) params->wpa_ie_len 1060209139Srpaulo , params->pairwise_suite 1061209139Srpaulo , params->group_suite 1062209139Srpaulo , params->key_mgmt_suite 1063209139Srpaulo ); 1064209139Srpaulo 1065214501Srpaulo switch (params->mode) { 1066214501Srpaulo case IEEE80211_MODE_INFRA: 1067214501Srpaulo mode = 0 /* STA */; 1068214501Srpaulo break; 1069214501Srpaulo case IEEE80211_MODE_IBSS: 1070214501Srpaulo mode = IFM_IEEE80211_IBSS; 1071214501Srpaulo break; 1072214501Srpaulo case IEEE80211_MODE_AP: 1073214501Srpaulo mode = IFM_IEEE80211_HOSTAP; 1074214501Srpaulo break; 1075214501Srpaulo default: 1076214501Srpaulo wpa_printf(MSG_ERROR, "%s: unknown operation mode", __func__); 1077214501Srpaulo return -1; 1078214501Srpaulo } 1079214501Srpaulo if (bsd_set_mediaopt(drv, IFM_OMASK, mode) < 0) { 1080214501Srpaulo wpa_printf(MSG_ERROR, "%s: failed to set operation mode", 1081214501Srpaulo __func__); 1082214501Srpaulo return -1; 1083214501Srpaulo } 1084214501Srpaulo 1085214501Srpaulo if (params->mode == IEEE80211_MODE_AP) { 1086214501Srpaulo drv->sock_xmit = l2_packet_init(drv->ifname, NULL, ETH_P_EAPOL, 1087214501Srpaulo handle_read, drv, 0); 1088214501Srpaulo if (drv->sock_xmit == NULL) 1089214501Srpaulo return -1; 1090214501Srpaulo drv->is_ap = 1; 1091214501Srpaulo return 0; 1092214501Srpaulo } 1093214501Srpaulo 1094214501Srpaulo if (wpa_driver_bsd_set_drop_unencrypted(drv, params->drop_unencrypted) 1095214501Srpaulo < 0) 1096214501Srpaulo ret = -1; 1097214501Srpaulo if (wpa_driver_bsd_set_auth_alg(drv, params->auth_alg) < 0) 1098214501Srpaulo ret = -1; 1099209139Srpaulo /* XXX error handling is wrong but unclear what to do... */ 1100209139Srpaulo if (wpa_driver_bsd_set_wpa_ie(drv, params->wpa_ie, params->wpa_ie_len) < 0) 1101209139Srpaulo return -1; 1102209139Srpaulo 1103209139Srpaulo privacy = !(params->pairwise_suite == CIPHER_NONE && 1104209139Srpaulo params->group_suite == CIPHER_NONE && 1105209139Srpaulo params->key_mgmt_suite == KEY_MGMT_NONE && 1106209139Srpaulo params->wpa_ie_len == 0); 1107209139Srpaulo wpa_printf(MSG_DEBUG, "%s: set PRIVACY %u", __func__, privacy); 1108209139Srpaulo 1109209139Srpaulo if (set80211param(drv, IEEE80211_IOC_PRIVACY, privacy) < 0) 1110209139Srpaulo return -1; 1111209139Srpaulo 1112209139Srpaulo if (params->wpa_ie_len && 1113209139Srpaulo set80211param(drv, IEEE80211_IOC_WPA, 1114209139Srpaulo params->wpa_ie[0] == WLAN_EID_RSN ? 2 : 1) < 0) 1115209139Srpaulo return -1; 1116209139Srpaulo 1117209139Srpaulo os_memset(&mlme, 0, sizeof(mlme)); 1118209139Srpaulo mlme.im_op = IEEE80211_MLME_ASSOC; 1119209139Srpaulo if (params->ssid != NULL) 1120209139Srpaulo os_memcpy(mlme.im_ssid, params->ssid, params->ssid_len); 1121209139Srpaulo mlme.im_ssid_len = params->ssid_len; 1122209139Srpaulo if (params->bssid != NULL) 1123209139Srpaulo os_memcpy(mlme.im_macaddr, params->bssid, IEEE80211_ADDR_LEN); 1124209139Srpaulo if (set80211var(drv, IEEE80211_IOC_MLME, &mlme, sizeof(mlme)) < 0) 1125209139Srpaulo return -1; 1126214501Srpaulo return ret; 1127209139Srpaulo} 1128209139Srpaulo 1129209139Srpaulostatic int 1130214501Srpaulowpa_driver_bsd_scan(void *priv, struct wpa_driver_scan_params *params) 1131209139Srpaulo{ 1132214501Srpaulo struct bsd_driver_data *drv = priv; 1133214501Srpaulo#ifdef IEEE80211_IOC_SCAN_MAX_SSID 1134214501Srpaulo struct ieee80211_scan_req sr; 1135214501Srpaulo int i; 1136214501Srpaulo#endif /* IEEE80211_IOC_SCAN_MAX_SSID */ 1137209139Srpaulo 1138214501Srpaulo if (bsd_set_mediaopt(drv, IFM_OMASK, 0 /* STA */) < 0) { 1139214501Srpaulo wpa_printf(MSG_ERROR, "%s: failed to set operation mode", 1140214501Srpaulo __func__); 1141214501Srpaulo return -1; 1142214501Srpaulo } 1143209139Srpaulo 1144214501Srpaulo if (set80211param(drv, IEEE80211_IOC_ROAMING, 1145214501Srpaulo IEEE80211_ROAMING_MANUAL) < 0) { 1146214501Srpaulo wpa_printf(MSG_ERROR, "%s: failed to set " 1147214501Srpaulo "wpa_supplicant-based roaming: %s", __func__, 1148214501Srpaulo strerror(errno)); 1149214501Srpaulo return -1; 1150214501Srpaulo } 1151209139Srpaulo 1152214501Srpaulo if (wpa_driver_bsd_set_wpa(drv, 1) < 0) { 1153214501Srpaulo wpa_printf(MSG_ERROR, "%s: failed to set wpa: %s", __func__, 1154214501Srpaulo strerror(errno)); 1155214501Srpaulo return -1; 1156214501Srpaulo } 1157209139Srpaulo 1158209139Srpaulo /* NB: interface must be marked UP to do a scan */ 1159214501Srpaulo if (bsd_ctrl_iface(drv, 1) < 0) 1160209139Srpaulo return -1; 1161209139Srpaulo 1162214501Srpaulo#ifdef IEEE80211_IOC_SCAN_MAX_SSID 1163214501Srpaulo os_memset(&sr, 0, sizeof(sr)); 1164214501Srpaulo sr.sr_flags = IEEE80211_IOC_SCAN_ACTIVE | IEEE80211_IOC_SCAN_ONCE | 1165214501Srpaulo IEEE80211_IOC_SCAN_NOJOIN; 1166214501Srpaulo sr.sr_duration = IEEE80211_IOC_SCAN_FOREVER; 1167214501Srpaulo if (params->num_ssids > 0) { 1168214501Srpaulo sr.sr_nssid = params->num_ssids; 1169214501Srpaulo#if 0 1170214501Srpaulo /* Boundary check is done by upper layer */ 1171214501Srpaulo if (sr.sr_nssid > IEEE80211_IOC_SCAN_MAX_SSID) 1172214501Srpaulo sr.sr_nssid = IEEE80211_IOC_SCAN_MAX_SSID; 1173214501Srpaulo#endif 1174214501Srpaulo 1175214501Srpaulo /* NB: check scan cache first */ 1176214501Srpaulo sr.sr_flags |= IEEE80211_IOC_SCAN_CHECK; 1177214501Srpaulo } 1178214501Srpaulo for (i = 0; i < sr.sr_nssid; i++) { 1179214501Srpaulo sr.sr_ssid[i].len = params->ssids[i].ssid_len; 1180214501Srpaulo os_memcpy(sr.sr_ssid[i].ssid, params->ssids[i].ssid, 1181214501Srpaulo sr.sr_ssid[i].len); 1182214501Srpaulo } 1183214501Srpaulo 1184214501Srpaulo /* NB: net80211 delivers a scan complete event so no need to poll */ 1185214501Srpaulo return set80211var(drv, IEEE80211_IOC_SCAN_REQ, &sr, sizeof(sr)); 1186214501Srpaulo#else /* IEEE80211_IOC_SCAN_MAX_SSID */ 1187209139Srpaulo /* set desired ssid before scan */ 1188214501Srpaulo if (bsd_set_ssid(drv, params->ssids[0].ssid, 1189214501Srpaulo params->ssids[0].ssid_len) < 0) 1190209139Srpaulo return -1; 1191209139Srpaulo 1192209139Srpaulo /* NB: net80211 delivers a scan complete event so no need to poll */ 1193209139Srpaulo return set80211param(drv, IEEE80211_IOC_SCAN_REQ, 0); 1194214501Srpaulo#endif /* IEEE80211_IOC_SCAN_MAX_SSID */ 1195209139Srpaulo} 1196209139Srpaulo 1197209139Srpaulostatic void 1198209139Srpaulowpa_driver_bsd_event_receive(int sock, void *ctx, void *sock_ctx) 1199209139Srpaulo{ 1200214501Srpaulo struct bsd_driver_data *drv = sock_ctx; 1201252190Srpaulo char *buf; 1202209139Srpaulo struct if_announcemsghdr *ifan; 1203209139Srpaulo struct if_msghdr *ifm; 1204209139Srpaulo struct rt_msghdr *rtm; 1205209139Srpaulo union wpa_event_data event; 1206209139Srpaulo struct ieee80211_michael_event *mic; 1207214501Srpaulo struct ieee80211_leave_event *leave; 1208214501Srpaulo struct ieee80211_join_event *join; 1209252190Srpaulo int n, len; 1210209139Srpaulo 1211252190Srpaulo len = rtbuf_len(); 1212252190Srpaulo 1213252190Srpaulo buf = os_malloc(len); 1214252190Srpaulo if (buf == NULL) { 1215252190Srpaulo wpa_printf(MSG_ERROR, "%s os_malloc() failed\n", __func__); 1216252190Srpaulo return; 1217252190Srpaulo } 1218252190Srpaulo 1219252190Srpaulo n = read(sock, buf, len); 1220209139Srpaulo if (n < 0) { 1221209139Srpaulo if (errno != EINTR && errno != EAGAIN) 1222252190Srpaulo wpa_printf(MSG_ERROR, "%s read() failed: %s\n", 1223252190Srpaulo __func__, strerror(errno)); 1224252190Srpaulo os_free(buf); 1225209139Srpaulo return; 1226209139Srpaulo } 1227209139Srpaulo 1228209139Srpaulo rtm = (struct rt_msghdr *) buf; 1229209139Srpaulo if (rtm->rtm_version != RTM_VERSION) { 1230252190Srpaulo wpa_printf(MSG_DEBUG, "Invalid routing message version=%d", 1231252190Srpaulo rtm->rtm_version); 1232252190Srpaulo os_free(buf); 1233209139Srpaulo return; 1234209139Srpaulo } 1235209139Srpaulo os_memset(&event, 0, sizeof(event)); 1236209139Srpaulo switch (rtm->rtm_type) { 1237209139Srpaulo case RTM_IFANNOUNCE: 1238209139Srpaulo ifan = (struct if_announcemsghdr *) rtm; 1239209139Srpaulo if (ifan->ifan_index != drv->ifindex) 1240209139Srpaulo break; 1241214501Srpaulo os_strlcpy(event.interface_status.ifname, drv->ifname, 1242214501Srpaulo sizeof(event.interface_status.ifname)); 1243209139Srpaulo switch (ifan->ifan_what) { 1244209139Srpaulo case IFAN_DEPARTURE: 1245209139Srpaulo event.interface_status.ievent = EVENT_INTERFACE_REMOVED; 1246209139Srpaulo default: 1247252190Srpaulo os_free(buf); 1248209139Srpaulo return; 1249209139Srpaulo } 1250209139Srpaulo wpa_printf(MSG_DEBUG, "RTM_IFANNOUNCE: Interface '%s' %s", 1251209139Srpaulo event.interface_status.ifname, 1252209139Srpaulo ifan->ifan_what == IFAN_DEPARTURE ? 1253209139Srpaulo "removed" : "added"); 1254209139Srpaulo wpa_supplicant_event(ctx, EVENT_INTERFACE_STATUS, &event); 1255209139Srpaulo break; 1256209139Srpaulo case RTM_IEEE80211: 1257209139Srpaulo ifan = (struct if_announcemsghdr *) rtm; 1258209139Srpaulo if (ifan->ifan_index != drv->ifindex) 1259209139Srpaulo break; 1260209139Srpaulo switch (ifan->ifan_what) { 1261209139Srpaulo case RTM_IEEE80211_ASSOC: 1262209139Srpaulo case RTM_IEEE80211_REASSOC: 1263214501Srpaulo if (drv->is_ap) 1264214501Srpaulo break; 1265209139Srpaulo wpa_supplicant_event(ctx, EVENT_ASSOC, NULL); 1266209139Srpaulo break; 1267209139Srpaulo case RTM_IEEE80211_DISASSOC: 1268214501Srpaulo if (drv->is_ap) 1269214501Srpaulo break; 1270209139Srpaulo wpa_supplicant_event(ctx, EVENT_DISASSOC, NULL); 1271209139Srpaulo break; 1272209139Srpaulo case RTM_IEEE80211_SCAN: 1273214501Srpaulo if (drv->is_ap) 1274214501Srpaulo break; 1275209139Srpaulo wpa_supplicant_event(ctx, EVENT_SCAN_RESULTS, NULL); 1276209139Srpaulo break; 1277214501Srpaulo case RTM_IEEE80211_LEAVE: 1278214501Srpaulo leave = (struct ieee80211_leave_event *) &ifan[1]; 1279214501Srpaulo drv_event_disassoc(ctx, leave->iev_addr); 1280214501Srpaulo break; 1281214501Srpaulo case RTM_IEEE80211_JOIN: 1282214501Srpaulo#ifdef RTM_IEEE80211_REJOIN 1283214501Srpaulo case RTM_IEEE80211_REJOIN: 1284214501Srpaulo#endif 1285214501Srpaulo join = (struct ieee80211_join_event *) &ifan[1]; 1286214501Srpaulo bsd_new_sta(drv, ctx, join->iev_addr); 1287214501Srpaulo break; 1288209139Srpaulo case RTM_IEEE80211_REPLAY: 1289209139Srpaulo /* ignore */ 1290209139Srpaulo break; 1291209139Srpaulo case RTM_IEEE80211_MICHAEL: 1292209139Srpaulo mic = (struct ieee80211_michael_event *) &ifan[1]; 1293209139Srpaulo wpa_printf(MSG_DEBUG, 1294209139Srpaulo "Michael MIC failure wireless event: " 1295209139Srpaulo "keyix=%u src_addr=" MACSTR, mic->iev_keyix, 1296209139Srpaulo MAC2STR(mic->iev_src)); 1297209139Srpaulo 1298209139Srpaulo os_memset(&event, 0, sizeof(event)); 1299209139Srpaulo event.michael_mic_failure.unicast = 1300209139Srpaulo !IEEE80211_IS_MULTICAST(mic->iev_dst); 1301209139Srpaulo wpa_supplicant_event(ctx, EVENT_MICHAEL_MIC_FAILURE, 1302209139Srpaulo &event); 1303209139Srpaulo break; 1304209139Srpaulo } 1305209139Srpaulo break; 1306209139Srpaulo case RTM_IFINFO: 1307209139Srpaulo ifm = (struct if_msghdr *) rtm; 1308209139Srpaulo if (ifm->ifm_index != drv->ifindex) 1309209139Srpaulo break; 1310209139Srpaulo if ((rtm->rtm_flags & RTF_UP) == 0) { 1311214501Srpaulo os_strlcpy(event.interface_status.ifname, drv->ifname, 1312214501Srpaulo sizeof(event.interface_status.ifname)); 1313209139Srpaulo event.interface_status.ievent = EVENT_INTERFACE_REMOVED; 1314209139Srpaulo wpa_printf(MSG_DEBUG, "RTM_IFINFO: Interface '%s' DOWN", 1315209139Srpaulo event.interface_status.ifname); 1316209139Srpaulo wpa_supplicant_event(ctx, EVENT_INTERFACE_STATUS, &event); 1317209139Srpaulo } 1318209139Srpaulo break; 1319209139Srpaulo } 1320252190Srpaulo os_free(buf); 1321209139Srpaulo} 1322209139Srpaulo 1323214501Srpaulostatic void 1324214501Srpaulowpa_driver_bsd_add_scan_entry(struct wpa_scan_results *res, 1325214501Srpaulo struct ieee80211req_scan_result *sr) 1326209139Srpaulo{ 1327214501Srpaulo struct wpa_scan_res *result, **tmp; 1328214501Srpaulo size_t extra_len; 1329214501Srpaulo u8 *pos; 1330209139Srpaulo 1331214501Srpaulo extra_len = 2 + sr->isr_ssid_len; 1332214501Srpaulo extra_len += 2 + sr->isr_nrates; 1333214501Srpaulo extra_len += 3; /* ERP IE */ 1334214501Srpaulo extra_len += sr->isr_ie_len; 1335209139Srpaulo 1336214501Srpaulo result = os_zalloc(sizeof(*result) + extra_len); 1337214501Srpaulo if (result == NULL) 1338214501Srpaulo return; 1339214501Srpaulo os_memcpy(result->bssid, sr->isr_bssid, ETH_ALEN); 1340214501Srpaulo result->freq = sr->isr_freq; 1341214501Srpaulo result->beacon_int = sr->isr_intval; 1342214501Srpaulo result->caps = sr->isr_capinfo; 1343214501Srpaulo result->qual = sr->isr_rssi; 1344214501Srpaulo result->noise = sr->isr_noise; 1345252726Srpaulo /* 1346252726Srpaulo * the rssi value reported by the kernel is in 0.5dB steps relative to 1347252726Srpaulo * the reported noise floor. see ieee80211_node.h for details. 1348252726Srpaulo */ 1349252726Srpaulo result->level = sr->isr_rssi / 2 + sr->isr_noise; 1350209139Srpaulo 1351214501Srpaulo pos = (u8 *)(result + 1); 1352209139Srpaulo 1353214501Srpaulo *pos++ = WLAN_EID_SSID; 1354214501Srpaulo *pos++ = sr->isr_ssid_len; 1355214501Srpaulo os_memcpy(pos, sr + 1, sr->isr_ssid_len); 1356214501Srpaulo pos += sr->isr_ssid_len; 1357209139Srpaulo 1358214501Srpaulo /* 1359214501Srpaulo * Deal all rates as supported rate. 1360214501Srpaulo * Because net80211 doesn't report extended supported rate or not. 1361214501Srpaulo */ 1362214501Srpaulo *pos++ = WLAN_EID_SUPP_RATES; 1363214501Srpaulo *pos++ = sr->isr_nrates; 1364214501Srpaulo os_memcpy(pos, sr->isr_rates, sr->isr_nrates); 1365214501Srpaulo pos += sr->isr_nrates; 1366214501Srpaulo 1367214501Srpaulo *pos++ = WLAN_EID_ERP_INFO; 1368214501Srpaulo *pos++ = 1; 1369214501Srpaulo *pos++ = sr->isr_erp; 1370214501Srpaulo 1371214501Srpaulo os_memcpy(pos, (u8 *)(sr + 1) + sr->isr_ssid_len, sr->isr_ie_len); 1372214501Srpaulo pos += sr->isr_ie_len; 1373214501Srpaulo 1374214501Srpaulo result->ie_len = pos - (u8 *)(result + 1); 1375214501Srpaulo 1376252190Srpaulo tmp = os_realloc_array(res->res, res->num + 1, 1377252190Srpaulo sizeof(struct wpa_scan_res *)); 1378214501Srpaulo if (tmp == NULL) { 1379214501Srpaulo os_free(result); 1380214501Srpaulo return; 1381214501Srpaulo } 1382214501Srpaulo tmp[res->num++] = result; 1383214501Srpaulo res->res = tmp; 1384209139Srpaulo} 1385209139Srpaulo 1386214501Srpaulostruct wpa_scan_results * 1387214501Srpaulowpa_driver_bsd_get_scan_results2(void *priv) 1388209139Srpaulo{ 1389214501Srpaulo struct ieee80211req_scan_result *sr; 1390214501Srpaulo struct wpa_scan_results *res; 1391214501Srpaulo int len, rest; 1392214501Srpaulo uint8_t buf[24*1024], *pos; 1393209139Srpaulo 1394214501Srpaulo len = get80211var(priv, IEEE80211_IOC_SCAN_RESULTS, buf, 24*1024); 1395214501Srpaulo if (len < 0) 1396214501Srpaulo return NULL; 1397214501Srpaulo 1398214501Srpaulo res = os_zalloc(sizeof(*res)); 1399214501Srpaulo if (res == NULL) 1400214501Srpaulo return NULL; 1401214501Srpaulo 1402214501Srpaulo pos = buf; 1403214501Srpaulo rest = len; 1404214501Srpaulo while (rest >= sizeof(struct ieee80211req_scan_result)) { 1405214501Srpaulo sr = (struct ieee80211req_scan_result *)pos; 1406214501Srpaulo wpa_driver_bsd_add_scan_entry(res, sr); 1407214501Srpaulo pos += sr->isr_len; 1408214501Srpaulo rest -= sr->isr_len; 1409209139Srpaulo } 1410209139Srpaulo 1411214501Srpaulo wpa_printf(MSG_DEBUG, "Received %d bytes of scan results (%lu BSSes)", 1412214501Srpaulo len, (unsigned long)res->num); 1413209139Srpaulo 1414214501Srpaulo return res; 1415209139Srpaulo} 1416209139Srpaulo 1417214501Srpaulostatic int wpa_driver_bsd_capa(struct bsd_driver_data *drv) 1418209139Srpaulo{ 1419214501Srpaulo#ifdef IEEE80211_IOC_DEVCAPS 1420214501Srpaulo/* kernel definitions copied from net80211/ieee80211_var.h */ 1421214501Srpaulo#define IEEE80211_CIPHER_WEP 0 1422214501Srpaulo#define IEEE80211_CIPHER_TKIP 1 1423214501Srpaulo#define IEEE80211_CIPHER_AES_CCM 3 1424214501Srpaulo#define IEEE80211_CRYPTO_WEP (1<<IEEE80211_CIPHER_WEP) 1425214501Srpaulo#define IEEE80211_CRYPTO_TKIP (1<<IEEE80211_CIPHER_TKIP) 1426214501Srpaulo#define IEEE80211_CRYPTO_AES_CCM (1<<IEEE80211_CIPHER_AES_CCM) 1427214501Srpaulo#define IEEE80211_C_HOSTAP 0x00000400 /* CAPABILITY: HOSTAP avail */ 1428214501Srpaulo#define IEEE80211_C_WPA1 0x00800000 /* CAPABILITY: WPA1 avail */ 1429214501Srpaulo#define IEEE80211_C_WPA2 0x01000000 /* CAPABILITY: WPA2 avail */ 1430214501Srpaulo struct ieee80211_devcaps_req devcaps; 1431209139Srpaulo 1432214501Srpaulo if (get80211var(drv, IEEE80211_IOC_DEVCAPS, &devcaps, 1433214501Srpaulo sizeof(devcaps)) < 0) { 1434214501Srpaulo wpa_printf(MSG_ERROR, "failed to IEEE80211_IOC_DEVCAPS: %s", 1435214501Srpaulo strerror(errno)); 1436209139Srpaulo return -1; 1437209139Srpaulo } 1438209139Srpaulo 1439214501Srpaulo wpa_printf(MSG_DEBUG, "%s: drivercaps=0x%08x,cryptocaps=0x%08x", 1440214501Srpaulo __func__, devcaps.dc_drivercaps, devcaps.dc_cryptocaps); 1441209139Srpaulo 1442214501Srpaulo if (devcaps.dc_drivercaps & IEEE80211_C_WPA1) 1443214501Srpaulo drv->capa.key_mgmt = WPA_DRIVER_CAPA_KEY_MGMT_WPA | 1444214501Srpaulo WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK; 1445214501Srpaulo if (devcaps.dc_drivercaps & IEEE80211_C_WPA2) 1446214501Srpaulo drv->capa.key_mgmt = WPA_DRIVER_CAPA_KEY_MGMT_WPA2 | 1447214501Srpaulo WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK; 1448214501Srpaulo 1449264390Srpaulo#ifdef __FreeBSD__ 1450264390Srpaulo drv->capa.enc |= WPA_DRIVER_CAPA_ENC_WEP40 | 1451264390Srpaulo WPA_DRIVER_CAPA_ENC_WEP104 | 1452264390Srpaulo WPA_DRIVER_CAPA_ENC_TKIP | 1453264390Srpaulo WPA_DRIVER_CAPA_ENC_CCMP; 1454264390Srpaulo#else 1455264390Srpaulo /* 1456264390Srpaulo * XXX 1457264390Srpaulo * FreeBSD exports hardware cryptocaps. These have no meaning for wpa 1458264390Srpaulo * since net80211 performs software crypto. 1459264390Srpaulo */ 1460214501Srpaulo if (devcaps.dc_cryptocaps & IEEE80211_CRYPTO_WEP) 1461214501Srpaulo drv->capa.enc |= WPA_DRIVER_CAPA_ENC_WEP40 | 1462214501Srpaulo WPA_DRIVER_CAPA_ENC_WEP104; 1463214501Srpaulo if (devcaps.dc_cryptocaps & IEEE80211_CRYPTO_TKIP) 1464214501Srpaulo drv->capa.enc |= WPA_DRIVER_CAPA_ENC_TKIP; 1465214501Srpaulo if (devcaps.dc_cryptocaps & IEEE80211_CRYPTO_AES_CCM) 1466214501Srpaulo drv->capa.enc |= WPA_DRIVER_CAPA_ENC_CCMP; 1467264390Srpaulo#endif 1468214501Srpaulo 1469214501Srpaulo if (devcaps.dc_drivercaps & IEEE80211_C_HOSTAP) 1470214501Srpaulo drv->capa.flags |= WPA_DRIVER_FLAGS_AP; 1471214501Srpaulo#undef IEEE80211_CIPHER_WEP 1472214501Srpaulo#undef IEEE80211_CIPHER_TKIP 1473214501Srpaulo#undef IEEE80211_CIPHER_AES_CCM 1474214501Srpaulo#undef IEEE80211_CRYPTO_WEP 1475214501Srpaulo#undef IEEE80211_CRYPTO_TKIP 1476214501Srpaulo#undef IEEE80211_CRYPTO_AES_CCM 1477214501Srpaulo#undef IEEE80211_C_HOSTAP 1478214501Srpaulo#undef IEEE80211_C_WPA1 1479214501Srpaulo#undef IEEE80211_C_WPA2 1480214501Srpaulo#else /* IEEE80211_IOC_DEVCAPS */ 1481214501Srpaulo /* For now, assume TKIP, CCMP, WPA, WPA2 are supported */ 1482214501Srpaulo drv->capa.key_mgmt = WPA_DRIVER_CAPA_KEY_MGMT_WPA | 1483214501Srpaulo WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK | 1484214501Srpaulo WPA_DRIVER_CAPA_KEY_MGMT_WPA2 | 1485214501Srpaulo WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK; 1486214501Srpaulo drv->capa.enc = WPA_DRIVER_CAPA_ENC_WEP40 | 1487214501Srpaulo WPA_DRIVER_CAPA_ENC_WEP104 | 1488214501Srpaulo WPA_DRIVER_CAPA_ENC_TKIP | 1489214501Srpaulo WPA_DRIVER_CAPA_ENC_CCMP; 1490214501Srpaulo drv->capa.flags |= WPA_DRIVER_FLAGS_AP; 1491214501Srpaulo#endif /* IEEE80211_IOC_DEVCAPS */ 1492214501Srpaulo#ifdef IEEE80211_IOC_SCAN_MAX_SSID 1493214501Srpaulo drv->capa.max_scan_ssids = IEEE80211_IOC_SCAN_MAX_SSID; 1494214501Srpaulo#else /* IEEE80211_IOC_SCAN_MAX_SSID */ 1495214501Srpaulo drv->capa.max_scan_ssids = 1; 1496214501Srpaulo#endif /* IEEE80211_IOC_SCAN_MAX_SSID */ 1497214501Srpaulo drv->capa.auth = WPA_DRIVER_AUTH_OPEN | 1498214501Srpaulo WPA_DRIVER_AUTH_SHARED | 1499214501Srpaulo WPA_DRIVER_AUTH_LEAP; 1500214501Srpaulo return 0; 1501209139Srpaulo} 1502209139Srpaulo 1503209139Srpaulostatic void * 1504209139Srpaulowpa_driver_bsd_init(void *ctx, const char *ifname) 1505209139Srpaulo{ 1506209139Srpaulo#define GETPARAM(drv, param, v) \ 1507209139Srpaulo (((v) = get80211param(drv, param)) != -1) 1508214501Srpaulo struct bsd_driver_data *drv; 1509209139Srpaulo 1510209139Srpaulo drv = os_zalloc(sizeof(*drv)); 1511209139Srpaulo if (drv == NULL) 1512209139Srpaulo return NULL; 1513209139Srpaulo /* 1514209139Srpaulo * NB: We require the interface name be mappable to an index. 1515209139Srpaulo * This implies we do not support having wpa_supplicant 1516209139Srpaulo * wait for an interface to appear. This seems ok; that 1517209139Srpaulo * doesn't belong here; it's really the job of devd. 1518209139Srpaulo */ 1519209139Srpaulo drv->ifindex = if_nametoindex(ifname); 1520209139Srpaulo if (drv->ifindex == 0) { 1521209139Srpaulo wpa_printf(MSG_DEBUG, "%s: interface %s does not exist", 1522209139Srpaulo __func__, ifname); 1523209139Srpaulo goto fail1; 1524209139Srpaulo } 1525209139Srpaulo drv->sock = socket(PF_INET, SOCK_DGRAM, 0); 1526209139Srpaulo if (drv->sock < 0) 1527209139Srpaulo goto fail1; 1528252726Srpaulo 1529252726Srpaulo os_strlcpy(drv->ifname, ifname, sizeof(drv->ifname)); 1530252726Srpaulo /* Down interface during setup. */ 1531252726Srpaulo if (bsd_ctrl_iface(drv, 0) < 0) 1532252726Srpaulo goto fail; 1533252726Srpaulo 1534209139Srpaulo drv->route = socket(PF_ROUTE, SOCK_RAW, 0); 1535209139Srpaulo if (drv->route < 0) 1536209139Srpaulo goto fail; 1537209139Srpaulo eloop_register_read_sock(drv->route, 1538209139Srpaulo wpa_driver_bsd_event_receive, ctx, drv); 1539209139Srpaulo 1540209139Srpaulo drv->ctx = ctx; 1541209139Srpaulo 1542209139Srpaulo if (!GETPARAM(drv, IEEE80211_IOC_ROAMING, drv->prev_roaming)) { 1543209139Srpaulo wpa_printf(MSG_DEBUG, "%s: failed to get roaming state: %s", 1544209139Srpaulo __func__, strerror(errno)); 1545209139Srpaulo goto fail; 1546209139Srpaulo } 1547209139Srpaulo if (!GETPARAM(drv, IEEE80211_IOC_PRIVACY, drv->prev_privacy)) { 1548209139Srpaulo wpa_printf(MSG_DEBUG, "%s: failed to get privacy state: %s", 1549209139Srpaulo __func__, strerror(errno)); 1550209139Srpaulo goto fail; 1551209139Srpaulo } 1552209139Srpaulo if (!GETPARAM(drv, IEEE80211_IOC_WPA, drv->prev_wpa)) { 1553209139Srpaulo wpa_printf(MSG_DEBUG, "%s: failed to get wpa state: %s", 1554209139Srpaulo __func__, strerror(errno)); 1555209139Srpaulo goto fail; 1556209139Srpaulo } 1557209139Srpaulo 1558214501Srpaulo if (wpa_driver_bsd_capa(drv)) 1559209139Srpaulo goto fail; 1560209139Srpaulo 1561252726Srpaulo drv->opmode = get80211opmode(drv); 1562252726Srpaulo 1563209139Srpaulo return drv; 1564209139Srpaulofail: 1565209139Srpaulo close(drv->sock); 1566209139Srpaulofail1: 1567209139Srpaulo os_free(drv); 1568209139Srpaulo return NULL; 1569209139Srpaulo#undef GETPARAM 1570209139Srpaulo} 1571209139Srpaulo 1572209139Srpaulostatic void 1573209139Srpaulowpa_driver_bsd_deinit(void *priv) 1574209139Srpaulo{ 1575214501Srpaulo struct bsd_driver_data *drv = priv; 1576209139Srpaulo 1577214501Srpaulo wpa_driver_bsd_set_wpa(drv, 0); 1578209139Srpaulo eloop_unregister_read_sock(drv->route); 1579209139Srpaulo 1580209139Srpaulo /* NB: mark interface down */ 1581214501Srpaulo bsd_ctrl_iface(drv, 0); 1582209139Srpaulo 1583209139Srpaulo wpa_driver_bsd_set_wpa_internal(drv, drv->prev_wpa, drv->prev_privacy); 1584209139Srpaulo if (set80211param(drv, IEEE80211_IOC_ROAMING, drv->prev_roaming) < 0) 1585209139Srpaulo wpa_printf(MSG_DEBUG, "%s: failed to restore roaming state", 1586209139Srpaulo __func__); 1587209139Srpaulo 1588214501Srpaulo if (drv->sock_xmit != NULL) 1589214501Srpaulo l2_packet_deinit(drv->sock_xmit); 1590209139Srpaulo (void) close(drv->route); /* ioctl socket */ 1591209139Srpaulo (void) close(drv->sock); /* event socket */ 1592209139Srpaulo os_free(drv); 1593209139Srpaulo} 1594209139Srpaulo 1595214501Srpaulostatic int 1596214501Srpaulowpa_driver_bsd_get_capa(void *priv, struct wpa_driver_capa *capa) 1597214501Srpaulo{ 1598214501Srpaulo struct bsd_driver_data *drv = priv; 1599209139Srpaulo 1600214501Srpaulo os_memcpy(capa, &drv->capa, sizeof(*capa)); 1601214501Srpaulo return 0; 1602214501Srpaulo} 1603214501Srpaulo#endif /* HOSTAPD */ 1604214501Srpaulo 1605214501Srpaulo 1606209139Srpauloconst struct wpa_driver_ops wpa_driver_bsd_ops = { 1607209139Srpaulo .name = "bsd", 1608214501Srpaulo .desc = "BSD 802.11 support", 1609214501Srpaulo#ifdef HOSTAPD 1610214501Srpaulo .hapd_init = bsd_init, 1611214501Srpaulo .hapd_deinit = bsd_deinit, 1612214501Srpaulo .set_privacy = bsd_set_privacy, 1613214501Srpaulo .get_seqnum = bsd_get_seqnum, 1614214501Srpaulo .flush = bsd_flush, 1615214501Srpaulo .read_sta_data = bsd_read_sta_driver_data, 1616214501Srpaulo .sta_disassoc = bsd_sta_disassoc, 1617214501Srpaulo .sta_deauth = bsd_sta_deauth, 1618252726Srpaulo .sta_set_flags = bsd_set_sta_authorized, 1619252726Srpaulo .commit = bsd_commit, 1620214501Srpaulo#else /* HOSTAPD */ 1621209139Srpaulo .init = wpa_driver_bsd_init, 1622209139Srpaulo .deinit = wpa_driver_bsd_deinit, 1623209139Srpaulo .get_bssid = wpa_driver_bsd_get_bssid, 1624209139Srpaulo .get_ssid = wpa_driver_bsd_get_ssid, 1625209139Srpaulo .set_countermeasures = wpa_driver_bsd_set_countermeasures, 1626214501Srpaulo .scan2 = wpa_driver_bsd_scan, 1627214501Srpaulo .get_scan_results2 = wpa_driver_bsd_get_scan_results2, 1628209139Srpaulo .deauthenticate = wpa_driver_bsd_deauthenticate, 1629209139Srpaulo .associate = wpa_driver_bsd_associate, 1630214501Srpaulo .get_capa = wpa_driver_bsd_get_capa, 1631214501Srpaulo#endif /* HOSTAPD */ 1632252190Srpaulo .set_freq = bsd_set_freq, 1633214501Srpaulo .set_key = bsd_set_key, 1634214501Srpaulo .set_ieee8021x = bsd_set_ieee8021x, 1635214501Srpaulo .hapd_set_ssid = bsd_set_ssid, 1636214501Srpaulo .hapd_get_ssid = bsd_get_ssid, 1637214501Srpaulo .hapd_send_eapol = bsd_send_eapol, 1638214501Srpaulo .set_generic_elem = bsd_set_opt_ie, 1639209139Srpaulo}; 1640