libeap/src/drivers/driver_bsd.c

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