src/drivers/driver_bsd.c

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