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