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