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