git.maemo.org Git - wpasupplicant/blob - src/drivers/driver_atheros.c

   1 /*
   2  * hostapd / Driver interaction with Atheros driver
   3  * Copyright (c) 2004, Sam Leffler <sam@errno.com>
   4  * Copyright (c) 2004, Video54 Technologies
   5  * Copyright (c) 2005-2007, Jouni Malinen <j@w1.fi>
   6  * Copyright (c) 2009, Atheros Communications
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  *
  12  * Alternatively, this software may be distributed under the terms of BSD
  13  * license.
  14  *
  15  * See README and COPYING for more details.
  16  */
  17
  18 #include "includes.h"
  19 #include <net/if.h>
  20 #include <sys/ioctl.h>
  21
  22 #include "common.h"
  23 #ifndef _BYTE_ORDER
  24 #ifdef WORDS_BIGENDIAN
  25 #define _BYTE_ORDER _BIG_ENDIAN
  26 #else
  27 #define _BYTE_ORDER _LITTLE_ENDIAN
  28 #endif
  29 #endif /* _BYTE_ORDER */
  30
  31 #include <net80211/ieee80211.h>
  32 #include <net80211/_ieee80211.h>
  33 #include <net80211/ieee80211_crypto.h>
  34
  35 /*
  36  * Note, the ATH_WPS_IE setting must match with the driver build.. If the
  37  * driver does not include this, the IEEE80211_IOCTL_GETWPAIE ioctl will fail.
  38  */
  39 #define ATH_WPS_IE
  40 #include <net80211/ieee80211_ioctl.h>
  41
  42 #ifdef CONFIG_WPS
  43 #ifdef IEEE80211_IOCTL_FILTERFRAME
  44 #include <netpacket/packet.h>
  45
  46 #ifndef ETH_P_80211_RAW
  47 #define ETH_P_80211_RAW 0x0019
  48 #endif
  49 #endif /* IEEE80211_IOCTL_FILTERFRAME */
  50 #endif /* CONFIG_WPS */
  51
  52 /*
  53  * Avoid conflicts with hostapd definitions by undefining couple of defines
  54  * from madwifi header files.
  55  */
  56 #undef WPA_OUI_TYPE
  57 #undef WME_OUI_TYPE
  58
  59 #include "wireless_copy.h"
  60
  61 #include "../hostapd/hostapd.h"
  62 #include "../hostapd/config.h"
  63 #include "../hostapd/sta_flags.h"
  64 #include "driver.h"
  65 #include "eloop.h"
  66 #include "priv_netlink.h"
  67 #include "l2_packet/l2_packet.h"
  68
  69 #include "../hostapd/wps_hostapd.h"
  70 #include "ieee802_11_defs.h"
  71
  72
  73 struct madwifi_driver_data {
  74         struct hostapd_data *hapd;              /* back pointer */
  75
  76         char    iface[IFNAMSIZ + 1];
  77         int     ifindex;
  78         struct l2_packet_data *sock_xmit;       /* raw packet xmit socket */
  79         struct l2_packet_data *sock_recv;       /* raw packet recv socket */
  80         int     ioctl_sock;                     /* socket for ioctl() use */
  81         int     wext_sock;                      /* socket for wireless events */
  82         int     we_version;
  83         u8      acct_mac[ETH_ALEN];
  84         struct hostap_sta_driver_data acct_data;
  85
  86         struct l2_packet_data *sock_raw; /* raw 802.11 management frames */
  87 };
  88
  89 static int madwifi_sta_deauth(void *priv, const u8 *own_addr, const u8 *addr,
  90                               int reason_code);
  91
  92 static int
  93 set80211priv(struct madwifi_driver_data *drv, int op, void *data, int len)
  94 {
  95         struct iwreq iwr;
  96         int do_inline = len < IFNAMSIZ;
  97
  98         /* Certain ioctls must use the non-inlined method */
  99         if (op == IEEE80211_IOCTL_SET_APPIEBUF ||
 100             op == IEEE80211_IOCTL_FILTERFRAME)
 101                 do_inline = 0;
 102
 103         memset(&iwr, 0, sizeof(iwr));
 104         os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ);
 105         if (do_inline) {
 106                 /*
 107                  * Argument data fits inline; put it there.
 108                  */
 109                 memcpy(iwr.u.name, data, len);
 110         } else {
 111                 /*
 112                  * Argument data too big for inline transfer; setup a
 113                  * parameter block instead; the kernel will transfer
 114                  * the data for the driver.
 115                  */
 116                 iwr.u.data.pointer = data;
 117                 iwr.u.data.length = len;
 118         }
 119
 120         if (ioctl(drv->ioctl_sock, op, &iwr) < 0) {
 121                 int first = IEEE80211_IOCTL_SETPARAM;
 122                 static const char *opnames[] = {
 123                         "ioctl[IEEE80211_IOCTL_SETPARAM]",
 124                         "ioctl[IEEE80211_IOCTL_GETPARAM]",
 125                         "ioctl[IEEE80211_IOCTL_SETKEY]",
 126                         "ioctl[IEEE80211_IOCTL_SETWMMPARAMS]",
 127                         "ioctl[IEEE80211_IOCTL_DELKEY]",
 128                         "ioctl[IEEE80211_IOCTL_GETWMMPARAMS]",
 129                         "ioctl[IEEE80211_IOCTL_SETMLME]",
 130                         "ioctl[IEEE80211_IOCTL_GETCHANINFO]",
 131                         "ioctl[IEEE80211_IOCTL_SETOPTIE]",
 132                         "ioctl[IEEE80211_IOCTL_GETOPTIE]",
 133                         "ioctl[IEEE80211_IOCTL_ADDMAC]",
 134                         "ioctl[IEEE80211_IOCTL_DELMAC]",
 135                         "ioctl[IEEE80211_IOCTL_GETCHANLIST]",
 136                         "ioctl[IEEE80211_IOCTL_SETCHANLIST]",
 137                         "ioctl[IEEE80211_IOCTL_KICKMAC]",
 138                         "ioctl[IEEE80211_IOCTL_CHANSWITCH]",
 139                         "ioctl[IEEE80211_IOCTL_GETMODE]",
 140                         "ioctl[IEEE80211_IOCTL_SETMODE]",
 141                         "ioctl[IEEE80211_IOCTL_GET_APPIEBUF]",
 142                         "ioctl[IEEE80211_IOCTL_SET_APPIEBUF]",
 143                         NULL,
 144                         "ioctl[IEEE80211_IOCTL_FILTERFRAME]",
 145                 };
 146                 int idx = op - first;
 147                 if (first <= op &&
 148                     idx < (int) (sizeof(opnames) / sizeof(opnames[0])) &&
 149                     opnames[idx])
 150                         perror(opnames[idx]);
 151                 else {
 152                         perror("ioctl[unknown???]");
 153                         wpa_printf(MSG_DEBUG, "Failed ioctl: 0x%x", op);
 154                 }
 155                 return -1;
 156         }
 157         return 0;
 158 }
 159
 160 static int
 161 set80211param(struct madwifi_driver_data *drv, int op, int arg)
 162 {
 163         struct iwreq iwr;
 164
 165         memset(&iwr, 0, sizeof(iwr));
 166         os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ);
 167         iwr.u.mode = op;
 168         memcpy(iwr.u.name+sizeof(__u32), &arg, sizeof(arg));
 169
 170         if (ioctl(drv->ioctl_sock, IEEE80211_IOCTL_SETPARAM, &iwr) < 0) {
 171                 perror("ioctl[IEEE80211_IOCTL_SETPARAM]");
 172                 wpa_printf(MSG_DEBUG, "%s: Failed to set parameter (op %d "
 173                            "arg %d)", __func__, op, arg);
 174                 return -1;
 175         }
 176         return 0;
 177 }
 178
 179 #ifndef CONFIG_NO_STDOUT_DEBUG
 180 static const char *
 181 ether_sprintf(const u8 *addr)
 182 {
 183         static char buf[sizeof(MACSTR)];
 184
 185         if (addr != NULL)
 186                 snprintf(buf, sizeof(buf), MACSTR, MAC2STR(addr));
 187         else
 188                 snprintf(buf, sizeof(buf), MACSTR, 0,0,0,0,0,0);
 189         return buf;
 190 }
 191 #endif /* CONFIG_NO_STDOUT_DEBUG */
 192
 193 /*
 194  * Configure WPA parameters.
 195  */
 196 static int
 197 madwifi_configure_wpa(struct madwifi_driver_data *drv)
 198 {
 199         struct hostapd_data *hapd = drv->hapd;
 200         struct hostapd_bss_config *conf = hapd->conf;
 201         int v;
 202
 203         switch (conf->wpa_group) {
 204         case WPA_CIPHER_CCMP:
 205                 v = IEEE80211_CIPHER_AES_CCM;
 206                 break;
 207         case WPA_CIPHER_TKIP:
 208                 v = IEEE80211_CIPHER_TKIP;
 209                 break;
 210         case WPA_CIPHER_WEP104:
 211                 v = IEEE80211_CIPHER_WEP;
 212                 break;
 213         case WPA_CIPHER_WEP40:
 214                 v = IEEE80211_CIPHER_WEP;
 215                 break;
 216         case WPA_CIPHER_NONE:
 217                 v = IEEE80211_CIPHER_NONE;
 218                 break;
 219         default:
 220                 wpa_printf(MSG_ERROR, "Unknown group key cipher %u",
 221                            conf->wpa_group);
 222                 return -1;
 223         }
 224         wpa_printf(MSG_DEBUG, "%s: group key cipher=%d", __func__, v);
 225         if (set80211param(drv, IEEE80211_PARAM_MCASTCIPHER, v)) {
 226                 printf("Unable to set group key cipher to %u\n", v);
 227                 return -1;
 228         }
 229         if (v == IEEE80211_CIPHER_WEP) {
 230                 /* key length is done only for specific ciphers */
 231                 v = (conf->wpa_group == WPA_CIPHER_WEP104 ? 13 : 5);
 232                 if (set80211param(drv, IEEE80211_PARAM_MCASTKEYLEN, v)) {
 233                         printf("Unable to set group key length to %u\n", v);
 234                         return -1;
 235                 }
 236         }
 237
 238         v = 0;
 239         if (conf->wpa_pairwise & WPA_CIPHER_CCMP)
 240                 v |= 1<<IEEE80211_CIPHER_AES_CCM;
 241         if (conf->wpa_pairwise & WPA_CIPHER_TKIP)
 242                 v |= 1<<IEEE80211_CIPHER_TKIP;
 243         if (conf->wpa_pairwise & WPA_CIPHER_NONE)
 244                 v |= 1<<IEEE80211_CIPHER_NONE;
 245         wpa_printf(MSG_DEBUG, "%s: pairwise key ciphers=0x%x", __func__, v);
 246         if (set80211param(drv, IEEE80211_PARAM_UCASTCIPHERS, v)) {
 247                 printf("Unable to set pairwise key ciphers to 0x%x\n", v);
 248                 return -1;
 249         }
 250
 251         wpa_printf(MSG_DEBUG, "%s: key management algorithms=0x%x",
 252                    __func__, conf->wpa_key_mgmt);
 253         if (set80211param(drv, IEEE80211_PARAM_KEYMGTALGS, conf->wpa_key_mgmt)) {
 254                 printf("Unable to set key management algorithms to 0x%x\n",
 255                         conf->wpa_key_mgmt);
 256                 return -1;
 257         }
 258
 259         v = 0;
 260         if (conf->rsn_preauth)
 261                 v |= BIT(0);
 262         wpa_printf(MSG_DEBUG, "%s: rsn capabilities=0x%x",
 263                    __func__, conf->rsn_preauth);
 264         if (set80211param(drv, IEEE80211_PARAM_RSNCAPS, v)) {
 265                 printf("Unable to set RSN capabilities to 0x%x\n", v);
 266                 return -1;
 267         }
 268
 269         wpa_printf(MSG_DEBUG, "%s: enable WPA=0x%x", __func__, conf->wpa);
 270         if (set80211param(drv, IEEE80211_PARAM_WPA, conf->wpa)) {
 271                 printf("Unable to set WPA to %u\n", conf->wpa);
 272                 return -1;
 273         }
 274         return 0;
 275 }
 276
 277
 278 static int
 279 madwifi_set_iface_flags(void *priv, int dev_up)
 280 {
 281         struct madwifi_driver_data *drv = priv;
 282         struct ifreq ifr;
 283
 284         wpa_printf(MSG_DEBUG, "%s: dev_up=%d", __func__, dev_up);
 285
 286         if (drv->ioctl_sock < 0)
 287                 return -1;
 288
 289         memset(&ifr, 0, sizeof(ifr));
 290         os_strlcpy(ifr.ifr_name, drv->iface, IFNAMSIZ);
 291
 292         if (ioctl(drv->ioctl_sock, SIOCGIFFLAGS, &ifr) != 0) {
 293                 perror("ioctl[SIOCGIFFLAGS]");
 294                 return -1;
 295         }
 296
 297         if (dev_up)
 298                 ifr.ifr_flags |= IFF_UP;
 299         else
 300                 ifr.ifr_flags &= ~IFF_UP;
 301
 302         if (ioctl(drv->ioctl_sock, SIOCSIFFLAGS, &ifr) != 0) {
 303                 perror("ioctl[SIOCSIFFLAGS]");
 304                 return -1;
 305         }
 306
 307         if (dev_up) {
 308                 memset(&ifr, 0, sizeof(ifr));
 309                 os_strlcpy(ifr.ifr_name, drv->iface, IFNAMSIZ);
 310                 ifr.ifr_mtu = HOSTAPD_MTU;
 311                 if (ioctl(drv->ioctl_sock, SIOCSIFMTU, &ifr) != 0) {
 312                         perror("ioctl[SIOCSIFMTU]");
 313                         printf("Setting MTU failed - trying to survive with "
 314                                "current value\n");
 315                 }
 316         }
 317
 318         return 0;
 319 }
 320
 321 static int
 322 madwifi_set_ieee8021x(const char *ifname, void *priv, int enabled)
 323 {
 324         struct madwifi_driver_data *drv = priv;
 325         struct hostapd_data *hapd = drv->hapd;
 326         struct hostapd_bss_config *conf = hapd->conf;
 327
 328         wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled);
 329
 330         if (!enabled) {
 331                 /* XXX restore state */
 332                 return set80211param(priv, IEEE80211_PARAM_AUTHMODE,
 333                         IEEE80211_AUTH_AUTO);
 334         }
 335         if (!conf->wpa && !conf->ieee802_1x) {
 336                 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_DRIVER,
 337                         HOSTAPD_LEVEL_WARNING, "No 802.1X or WPA enabled!");
 338                 return -1;
 339         }
 340         if (conf->wpa && madwifi_configure_wpa(drv) != 0) {
 341                 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_DRIVER,
 342                         HOSTAPD_LEVEL_WARNING, "Error configuring WPA state!");
 343                 return -1;
 344         }
 345         if (set80211param(priv, IEEE80211_PARAM_AUTHMODE,
 346                 (conf->wpa ?  IEEE80211_AUTH_WPA : IEEE80211_AUTH_8021X))) {
 347                 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_DRIVER,
 348                         HOSTAPD_LEVEL_WARNING, "Error enabling WPA/802.1X!");
 349                 return -1;
 350         }
 351
 352         return 0;
 353 }
 354
 355 static int
 356 madwifi_set_privacy(const char *ifname, void *priv, int enabled)
 357 {
 358         struct madwifi_driver_data *drv = priv;
 359
 360         wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled);
 361
 362         return set80211param(drv, IEEE80211_PARAM_PRIVACY, enabled);
 363 }
 364
 365 static int
 366 madwifi_set_sta_authorized(void *priv, const u8 *addr, int authorized)
 367 {
 368         struct madwifi_driver_data *drv = priv;
 369         struct ieee80211req_mlme mlme;
 370         int ret;
 371
 372         wpa_printf(MSG_DEBUG, "%s: addr=%s authorized=%d",
 373                    __func__, ether_sprintf(addr), authorized);
 374
 375         if (authorized)
 376                 mlme.im_op = IEEE80211_MLME_AUTHORIZE;
 377         else
 378                 mlme.im_op = IEEE80211_MLME_UNAUTHORIZE;
 379         mlme.im_reason = 0;
 380         memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN);
 381         ret = set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme));
 382         if (ret < 0) {
 383                 wpa_printf(MSG_DEBUG, "%s: Failed to %sauthorize STA " MACSTR,
 384                            __func__, authorized ? "" : "un", MAC2STR(addr));
 385         }
 386
 387         return ret;
 388 }
 389
 390 static int
 391 madwifi_sta_set_flags(void *priv, const u8 *addr, int total_flags,
 392                       int flags_or, int flags_and)
 393 {
 394         /* For now, only support setting Authorized flag */
 395         if (flags_or & WLAN_STA_AUTHORIZED)
 396                 return madwifi_set_sta_authorized(priv, addr, 1);
 397         if (!(flags_and & WLAN_STA_AUTHORIZED))
 398                 return madwifi_set_sta_authorized(priv, addr, 0);
 399         return 0;
 400 }
 401
 402 static int
 403 madwifi_del_key(void *priv, const u8 *addr, int key_idx)
 404 {
 405         struct madwifi_driver_data *drv = priv;
 406         struct ieee80211req_del_key wk;
 407         int ret;
 408
 409         wpa_printf(MSG_DEBUG, "%s: addr=%s key_idx=%d",
 410                    __func__, ether_sprintf(addr), key_idx);
 411
 412         memset(&wk, 0, sizeof(wk));
 413         if (addr != NULL) {
 414                 memcpy(wk.idk_macaddr, addr, IEEE80211_ADDR_LEN);
 415                 wk.idk_keyix = (u8) IEEE80211_KEYIX_NONE;
 416         } else {
 417                 wk.idk_keyix = key_idx;
 418         }
 419
 420         ret = set80211priv(drv, IEEE80211_IOCTL_DELKEY, &wk, sizeof(wk));
 421         if (ret < 0) {
 422                 wpa_printf(MSG_DEBUG, "%s: Failed to delete key (addr %s"
 423                            " key_idx %d)", __func__, ether_sprintf(addr),
 424                            key_idx);
 425         }
 426
 427         return ret;
 428 }
 429
 430 static int
 431 madwifi_set_key(const char *ifname, void *priv, wpa_alg alg, const u8 *addr,
 432                 int key_idx, int set_tx, const u8 *seq, size_t seq_len,
 433                 const u8 *key, size_t key_len)
 434 {
 435         struct madwifi_driver_data *drv = priv;
 436         struct ieee80211req_key wk;
 437         u_int8_t cipher;
 438         int ret;
 439
 440         if (alg == WPA_ALG_NONE)
 441                 return madwifi_del_key(drv, addr, key_idx);
 442
 443         wpa_printf(MSG_DEBUG, "%s: alg=%d addr=%s key_idx=%d",
 444                    __func__, alg, ether_sprintf(addr), key_idx);
 445
 446         switch (alg) {
 447         case WPA_ALG_WEP:
 448                 cipher = IEEE80211_CIPHER_WEP;
 449                 break;
 450         case WPA_ALG_TKIP:
 451                 cipher = IEEE80211_CIPHER_TKIP;
 452                 break;
 453         case WPA_ALG_CCMP:
 454                 cipher = IEEE80211_CIPHER_AES_CCM;
 455                 break;
 456         default:
 457                 printf("%s: unknown/unsupported algorithm %d\n",
 458                         __func__, alg);
 459                 return -1;
 460         }
 461
 462         if (key_len > sizeof(wk.ik_keydata)) {
 463                 printf("%s: key length %lu too big\n", __func__,
 464                        (unsigned long) key_len);
 465                 return -3;
 466         }
 467
 468         memset(&wk, 0, sizeof(wk));
 469         wk.ik_type = cipher;
 470         wk.ik_flags = IEEE80211_KEY_RECV | IEEE80211_KEY_XMIT;
 471         if (addr == NULL) {
 472                 memset(wk.ik_macaddr, 0xff, IEEE80211_ADDR_LEN);
 473                 wk.ik_keyix = key_idx;
 474                 wk.ik_flags |= IEEE80211_KEY_DEFAULT;
 475         } else {
 476                 memcpy(wk.ik_macaddr, addr, IEEE80211_ADDR_LEN);
 477                 wk.ik_keyix = IEEE80211_KEYIX_NONE;
 478         }
 479         wk.ik_keylen = key_len;
 480         memcpy(wk.ik_keydata, key, key_len);
 481
 482         ret = set80211priv(drv, IEEE80211_IOCTL_SETKEY, &wk, sizeof(wk));
 483         if (ret < 0) {
 484                 wpa_printf(MSG_DEBUG, "%s: Failed to set key (addr %s"
 485                            " key_idx %d alg %d key_len %lu set_tx %d)",
 486                            __func__, ether_sprintf(wk.ik_macaddr), key_idx,
 487                            alg, (unsigned long) key_len, set_tx);
 488         }
 489
 490         return ret;
 491 }
 492
 493
 494 static int
 495 madwifi_get_seqnum(const char *ifname, void *priv, const u8 *addr, int idx,
 496                    u8 *seq)
 497 {
 498         struct madwifi_driver_data *drv = priv;
 499         struct ieee80211req_key wk;
 500
 501         wpa_printf(MSG_DEBUG, "%s: addr=%s idx=%d",
 502                    __func__, ether_sprintf(addr), idx);
 503
 504         memset(&wk, 0, sizeof(wk));
 505         if (addr == NULL)
 506                 memset(wk.ik_macaddr, 0xff, IEEE80211_ADDR_LEN);
 507         else
 508                 memcpy(wk.ik_macaddr, addr, IEEE80211_ADDR_LEN);
 509         wk.ik_keyix = idx;
 510
 511         if (set80211priv(drv, IEEE80211_IOCTL_GETKEY, &wk, sizeof(wk))) {
 512                 wpa_printf(MSG_DEBUG, "%s: Failed to get encryption data "
 513                            "(addr " MACSTR " key_idx %d)",
 514                            __func__, MAC2STR(wk.ik_macaddr), idx);
 515                 return -1;
 516         }
 517
 518 #ifdef WORDS_BIGENDIAN
 519         {
 520                 /*
 521                  * wk.ik_keytsc is in host byte order (big endian), need to
 522                  * swap it to match with the byte order used in WPA.
 523                  */
 524                 int i;
 525                 u8 tmp[WPA_KEY_RSC_LEN];
 526                 memcpy(tmp, &wk.ik_keytsc, sizeof(wk.ik_keytsc));
 527                 for (i = 0; i < WPA_KEY_RSC_LEN; i++) {
 528                         seq[i] = tmp[WPA_KEY_RSC_LEN - i - 1];
 529                 }
 530         }
 531 #else /* WORDS_BIGENDIAN */
 532         memcpy(seq, &wk.ik_keytsc, sizeof(wk.ik_keytsc));
 533 #endif /* WORDS_BIGENDIAN */
 534         return 0;
 535 }
 536
 537
 538 static int
 539 madwifi_flush(void *priv)
 540 {
 541         u8 allsta[IEEE80211_ADDR_LEN];
 542         memset(allsta, 0xff, IEEE80211_ADDR_LEN);
 543         return madwifi_sta_deauth(priv, NULL, allsta,
 544                                   IEEE80211_REASON_AUTH_LEAVE);
 545 }
 546
 547
 548 static int
 549 madwifi_read_sta_driver_data(void *priv, struct hostap_sta_driver_data *data,
 550                              const u8 *addr)
 551 {
 552         struct madwifi_driver_data *drv = priv;
 553         struct ieee80211req_sta_stats stats;
 554
 555         memset(data, 0, sizeof(*data));
 556
 557         /*
 558          * Fetch statistics for station from the system.
 559          */
 560         memset(&stats, 0, sizeof(stats));
 561         memcpy(stats.is_u.macaddr, addr, IEEE80211_ADDR_LEN);
 562         if (set80211priv(drv, IEEE80211_IOCTL_STA_STATS,
 563                          &stats, sizeof(stats))) {
 564                 wpa_printf(MSG_DEBUG, "%s: Failed to fetch STA stats (addr "
 565                            MACSTR ")", __func__, MAC2STR(addr));
 566                 if (memcmp(addr, drv->acct_mac, ETH_ALEN) == 0) {
 567                         memcpy(data, &drv->acct_data, sizeof(*data));
 568                         return 0;
 569                 }
 570
 571                 printf("Failed to get station stats information element.\n");
 572                 return -1;
 573         }
 574
 575         data->rx_packets = stats.is_stats.ns_rx_data;
 576         data->rx_bytes = stats.is_stats.ns_rx_bytes;
 577         data->tx_packets = stats.is_stats.ns_tx_data;
 578         data->tx_bytes = stats.is_stats.ns_tx_bytes;
 579         return 0;
 580 }
 581
 582
 583 static int
 584 madwifi_sta_clear_stats(void *priv, const u8 *addr)
 585 {
 586         struct madwifi_driver_data *drv = priv;
 587         struct ieee80211req_mlme mlme;
 588         int ret;
 589
 590         wpa_printf(MSG_DEBUG, "%s: addr=%s", __func__, ether_sprintf(addr));
 591
 592         mlme.im_op = IEEE80211_MLME_CLEAR_STATS;
 593         memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN);
 594         ret = set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme,
 595                            sizeof(mlme));
 596         if (ret < 0) {
 597                 wpa_printf(MSG_DEBUG, "%s: Failed to clear STA stats (addr "
 598                            MACSTR ")", __func__, MAC2STR(addr));
 599         }
 600
 601         return ret;
 602 }
 603
 604
 605 static int
 606 madwifi_set_opt_ie(const char *ifname, void *priv, const u8 *ie, size_t ie_len)
 607 {
 608         /*
 609          * Do nothing; we setup parameters at startup that define the
 610          * contents of the beacon information element.
 611          */
 612         return 0;
 613 }
 614
 615 static int
 616 madwifi_sta_deauth(void *priv, const u8 *own_addr, const u8 *addr,
 617                    int reason_code)
 618 {
 619         struct madwifi_driver_data *drv = priv;
 620         struct ieee80211req_mlme mlme;
 621         int ret;
 622
 623         wpa_printf(MSG_DEBUG, "%s: addr=%s reason_code=%d",
 624                    __func__, ether_sprintf(addr), reason_code);
 625
 626         mlme.im_op = IEEE80211_MLME_DEAUTH;
 627         mlme.im_reason = reason_code;
 628         memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN);
 629         ret = set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme));
 630         if (ret < 0) {
 631                 wpa_printf(MSG_DEBUG, "%s: Failed to deauth STA (addr " MACSTR
 632                            " reason %d)",
 633                            __func__, MAC2STR(addr), reason_code);
 634         }
 635
 636         return ret;
 637 }
 638
 639 static int
 640 madwifi_sta_disassoc(void *priv, const u8 *own_addr, const u8 *addr,
 641                      int reason_code)
 642 {
 643         struct madwifi_driver_data *drv = priv;
 644         struct ieee80211req_mlme mlme;
 645         int ret;
 646
 647         wpa_printf(MSG_DEBUG, "%s: addr=%s reason_code=%d",
 648                    __func__, ether_sprintf(addr), reason_code);
 649
 650         mlme.im_op = IEEE80211_MLME_DISASSOC;
 651         mlme.im_reason = reason_code;
 652         memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN);
 653         ret = set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme));
 654         if (ret < 0) {
 655                 wpa_printf(MSG_DEBUG, "%s: Failed to disassoc STA (addr "
 656                            MACSTR " reason %d)",
 657                            __func__, MAC2STR(addr), reason_code);
 658         }
 659
 660         return ret;
 661 }
 662
 663 #ifdef CONFIG_WPS
 664 static void madwifi_raw_receive(void *ctx, const u8 *src_addr, const u8 *buf,
 665                                 size_t len)
 666 {
 667         struct madwifi_driver_data *drv = ctx;
 668         const struct ieee80211_mgmt *mgmt;
 669         const u8 *end, *ie;
 670         u16 fc;
 671         size_t ie_len;
 672
 673         /* Send Probe Request information to WPS processing */
 674
 675         if (len < IEEE80211_HDRLEN + sizeof(mgmt->u.probe_req))
 676                 return;
 677         mgmt = (const struct ieee80211_mgmt *) buf;
 678
 679         fc = le_to_host16(mgmt->frame_control);
 680         if (WLAN_FC_GET_TYPE(fc) != WLAN_FC_TYPE_MGMT ||
 681             WLAN_FC_GET_STYPE(fc) != WLAN_FC_STYPE_PROBE_REQ)
 682                 return;
 683
 684         end = buf + len;
 685         ie = mgmt->u.probe_req.variable;
 686         ie_len = len - (IEEE80211_HDRLEN + sizeof(mgmt->u.probe_req));
 687
 688         hostapd_probe_req_rx(drv->hapd, mgmt->sa, ie, ie_len);
 689 }
 690 #endif /* CONFIG_WPS */
 691
 692 static int madwifi_receive_probe_req(struct madwifi_driver_data *drv)
 693 {
 694         int ret = 0;
 695 #ifdef CONFIG_WPS
 696         struct ieee80211req_set_filter filt;
 697
 698         wpa_printf(MSG_DEBUG, "%s Enter", __func__);
 699         filt.app_filterype = IEEE80211_FILTER_TYPE_PROBE_REQ;
 700
 701         ret = set80211priv(drv, IEEE80211_IOCTL_FILTERFRAME, &filt,
 702                            sizeof(struct ieee80211req_set_filter));
 703         if (ret)
 704                 return ret;
 705
 706         drv->sock_raw = l2_packet_init(drv->iface, NULL, ETH_P_80211_RAW,
 707                                        madwifi_raw_receive, drv, 1);
 708         if (drv->sock_raw == NULL)
 709                 return -1;
 710 #endif /* CONFIG_WPS */
 711         return ret;
 712 }
 713
 714 #ifdef CONFIG_WPS
 715 static int
 716 madwifi_set_wps_ie(void *priv, const u8 *ie, size_t len, u32 frametype)
 717 {
 718         struct madwifi_driver_data *drv = priv;
 719         u8 buf[256];
 720         struct ieee80211req_getset_appiebuf *beac_ie;
 721
 722         wpa_printf(MSG_DEBUG, "%s buflen = %lu", __func__,
 723                    (unsigned long) len);
 724
 725         beac_ie = (struct ieee80211req_getset_appiebuf *) buf;
 726         beac_ie->app_frmtype = frametype;
 727         beac_ie->app_buflen = len;
 728         memcpy(&(beac_ie->app_buf[0]), ie, len);
 729
 730         return set80211priv(drv, IEEE80211_IOCTL_SET_APPIEBUF, beac_ie,
 731                             sizeof(struct ieee80211req_getset_appiebuf) + len);
 732 }
 733
 734 static int
 735 madwifi_set_wps_beacon_ie(const char *ifname, void *priv, const u8 *ie,
 736                           size_t len)
 737 {
 738         return madwifi_set_wps_ie(priv, ie, len, IEEE80211_APPIE_FRAME_BEACON);
 739 }
 740
 741 static int
 742 madwifi_set_wps_probe_resp_ie(const char *ifname, void *priv, const u8 *ie,
 743                               size_t len)
 744 {
 745         return madwifi_set_wps_ie(priv, ie, len,
 746                                   IEEE80211_APPIE_FRAME_PROBE_RESP);
 747 }
 748 #else /* CONFIG_WPS */
 749 #define madwifi_set_wps_beacon_ie NULL
 750 #define madwifi_set_wps_probe_resp_ie NULL
 751 #endif /* CONFIG_WPS */
 752
 753 static int
 754 madwifi_new_sta(struct madwifi_driver_data *drv, u8 addr[IEEE80211_ADDR_LEN])
 755 {
 756         struct hostapd_data *hapd = drv->hapd;
 757         struct ieee80211req_wpaie ie;
 758         int ielen = 0, res;
 759         u8 *iebuf = NULL;
 760
 761         /*
 762          * Fetch negotiated WPA/RSN parameters from the system.
 763          */
 764         memset(&ie, 0, sizeof(ie));
 765         memcpy(ie.wpa_macaddr, addr, IEEE80211_ADDR_LEN);
 766         if (set80211priv(drv, IEEE80211_IOCTL_GETWPAIE, &ie, sizeof(ie))) {
 767                 /*
 768                  * See ATH_WPS_IE comment in the beginning of the file for a
 769                  * possible cause for the failure..
 770                  */
 771                 wpa_printf(MSG_DEBUG, "%s: Failed to get WPA/RSN IE: %s",
 772                            __func__, strerror(errno));
 773                 goto no_ie;
 774         }
 775         wpa_hexdump(MSG_MSGDUMP, "madwifi req WPA IE",
 776                     ie.wpa_ie, IEEE80211_MAX_OPT_IE);
 777         wpa_hexdump(MSG_MSGDUMP, "madwifi req RSN IE",
 778                     ie.rsn_ie, IEEE80211_MAX_OPT_IE);
 779         iebuf = ie.wpa_ie;
 780         /* madwifi seems to return some random data if WPA/RSN IE is not set.
 781          * Assume the IE was not included if the IE type is unknown. */
 782         if (iebuf[0] != WLAN_EID_VENDOR_SPECIFIC)
 783                 iebuf[1] = 0;
 784         if (iebuf[1] == 0 && ie.rsn_ie[1] > 0) {
 785                 /* madwifi-ng svn #1453 added rsn_ie. Use it, if wpa_ie was not
 786                  * set. This is needed for WPA2. */
 787                 iebuf = ie.rsn_ie;
 788                 if (iebuf[0] != WLAN_EID_RSN)
 789                         iebuf[1] = 0;
 790         }
 791
 792         ielen = iebuf[1];
 793         if (ielen == 0)
 794                 iebuf = NULL;
 795         else
 796                 ielen += 2;
 797
 798 no_ie:
 799         res = hostapd_notif_assoc(hapd, addr, iebuf, ielen);
 800
 801         if (memcmp(addr, drv->acct_mac, ETH_ALEN) == 0) {
 802                 /* Cached accounting data is not valid anymore. */
 803                 memset(drv->acct_mac, 0, ETH_ALEN);
 804                 memset(&drv->acct_data, 0, sizeof(drv->acct_data));
 805         }
 806
 807         return res;
 808 }
 809
 810 static void
 811 madwifi_wireless_event_wireless_custom(struct madwifi_driver_data *drv,
 812                                        char *custom, char *end)
 813 {
 814         wpa_printf(MSG_DEBUG, "Custom wireless event: '%s'", custom);
 815
 816         if (strncmp(custom, "MLME-MICHAELMICFAILURE.indication", 33) == 0) {
 817                 char *pos;
 818                 u8 addr[ETH_ALEN];
 819                 pos = strstr(custom, "addr=");
 820                 if (pos == NULL) {
 821                         wpa_printf(MSG_DEBUG,
 822                                    "MLME-MICHAELMICFAILURE.indication "
 823                                    "without sender address ignored");
 824                         return;
 825                 }
 826                 pos += 5;
 827                 if (hwaddr_aton(pos, addr) == 0) {
 828                         hostapd_michael_mic_failure(drv->hapd, addr);
 829                 } else {
 830                         wpa_printf(MSG_DEBUG,
 831                                    "MLME-MICHAELMICFAILURE.indication "
 832                                    "with invalid MAC address");
 833                 }
 834         } else if (strncmp(custom, "STA-TRAFFIC-STAT", 16) == 0) {
 835                 char *key, *value;
 836                 u32 val;
 837                 key = custom;
 838                 while ((key = strchr(key, '\n')) != NULL) {
 839                         key++;
 840                         value = strchr(key, '=');
 841                         if (value == NULL)
 842                                 continue;
 843                         *value++ = '\0';
 844                         val = strtoul(value, NULL, 10);
 845                         if (strcmp(key, "mac") == 0)
 846                                 hwaddr_aton(value, drv->acct_mac);
 847                         else if (strcmp(key, "rx_packets") == 0)
 848                                 drv->acct_data.rx_packets = val;
 849                         else if (strcmp(key, "tx_packets") == 0)
 850                                 drv->acct_data.tx_packets = val;
 851                         else if (strcmp(key, "rx_bytes") == 0)
 852                                 drv->acct_data.rx_bytes = val;
 853                         else if (strcmp(key, "tx_bytes") == 0)
 854                                 drv->acct_data.tx_bytes = val;
 855                         key = value;
 856                 }
 857 #ifdef CONFIG_WPS
 858         } else if (strncmp(custom, "PUSH-BUTTON.indication", 22) == 0) {
 859                 /* Some atheros kernels send push button as a wireless event */
 860                 /* PROBLEM! this event is received for ALL BSSs ...
 861                  * so all are enabled for WPS... ugh.
 862                  */
 863                 hostapd_wps_button_pushed(drv->hapd);
 864         } else if (strncmp(custom, "Manage.prob_req ", 16) == 0) {
 865                 /*
 866                  * Atheros driver uses a hack to pass Probe Request frames as a
 867                  * binary data in the custom wireless event. The old way (using
 868                  * packet sniffing) didn't work when bridging.
 869                  * Format: "Manage.prob_req <frame len>" | zero padding | frame
 870                  */
 871 #define WPS_FRAM_TAG_SIZE 30 /* hardcoded in driver */
 872                 int len = atoi(custom + 16);
 873                 if (len < 0 || custom + WPS_FRAM_TAG_SIZE + len > end) {
 874                         wpa_printf(MSG_DEBUG, "Invalid Manage.prob_req event "
 875                                    "length %d", len);
 876                         return;
 877                 }
 878                 madwifi_raw_receive(drv, NULL,
 879                                     (u8 *) custom + WPS_FRAM_TAG_SIZE, len);
 880 #endif /* CONFIG_WPS */
 881         }
 882 }
 883
 884 static void
 885 madwifi_wireless_event_wireless(struct madwifi_driver_data *drv,
 886                                 char *data, int len)
 887 {
 888         struct iw_event iwe_buf, *iwe = &iwe_buf;
 889         char *pos, *end, *custom, *buf;
 890
 891         pos = data;
 892         end = data + len;
 893
 894         while (pos + IW_EV_LCP_LEN <= end) {
 895                 /* Event data may be unaligned, so make a local, aligned copy
 896                  * before processing. */
 897                 memcpy(&iwe_buf, pos, IW_EV_LCP_LEN);
 898                 wpa_printf(MSG_MSGDUMP, "Wireless event: cmd=0x%x len=%d",
 899                            iwe->cmd, iwe->len);
 900                 if (iwe->len <= IW_EV_LCP_LEN)
 901                         return;
 902
 903                 custom = pos + IW_EV_POINT_LEN;
 904                 if (drv->we_version > 18 &&
 905                     (iwe->cmd == IWEVMICHAELMICFAILURE ||
 906                      iwe->cmd == IWEVASSOCREQIE ||
 907                      iwe->cmd == IWEVCUSTOM)) {
 908                         /* WE-19 removed the pointer from struct iw_point */
 909                         char *dpos = (char *) &iwe_buf.u.data.length;
 910                         int dlen = dpos - (char *) &iwe_buf;
 911                         memcpy(dpos, pos + IW_EV_LCP_LEN,
 912                                sizeof(struct iw_event) - dlen);
 913                 } else {
 914                         memcpy(&iwe_buf, pos, sizeof(struct iw_event));
 915                         custom += IW_EV_POINT_OFF;
 916                 }
 917
 918                 switch (iwe->cmd) {
 919                 case IWEVEXPIRED:
 920                         hostapd_notif_disassoc(drv->hapd,
 921                                                (u8 *) iwe->u.addr.sa_data);
 922                         break;
 923                 case IWEVREGISTERED:
 924                         madwifi_new_sta(drv, (u8 *) iwe->u.addr.sa_data);
 925                         break;
 926                 case IWEVASSOCREQIE:
 927                         /* Driver hack.. Use IWEVASSOCREQIE to bypass
 928                          * IWEVCUSTOM size limitations. Need to handle this
 929                          * just like IWEVCUSTOM.
 930                          */
 931                 case IWEVCUSTOM:
 932                         if (custom + iwe->u.data.length > end)
 933                                 return;
 934                         buf = malloc(iwe->u.data.length + 1);
 935                         if (buf == NULL)
 936                                 return;         /* XXX */
 937                         memcpy(buf, custom, iwe->u.data.length);
 938                         buf[iwe->u.data.length] = '\0';
 939                         madwifi_wireless_event_wireless_custom(
 940                                 drv, buf, buf + iwe->u.data.length);
 941                         free(buf);
 942                         break;
 943                 }
 944
 945                 pos += iwe->len;
 946         }
 947 }
 948
 949
 950 static void
 951 madwifi_wireless_event_rtm_newlink(struct madwifi_driver_data *drv,
 952                                                struct nlmsghdr *h, int len)
 953 {
 954         struct ifinfomsg *ifi;
 955         int attrlen, nlmsg_len, rta_len;
 956         struct rtattr * attr;
 957
 958         if (len < (int) sizeof(*ifi))
 959                 return;
 960
 961         ifi = NLMSG_DATA(h);
 962
 963         if (ifi->ifi_index != drv->ifindex)
 964                 return;
 965
 966         nlmsg_len = NLMSG_ALIGN(sizeof(struct ifinfomsg));
 967
 968         attrlen = h->nlmsg_len - nlmsg_len;
 969         if (attrlen < 0)
 970                 return;
 971
 972         attr = (struct rtattr *) (((char *) ifi) + nlmsg_len);
 973
 974         rta_len = RTA_ALIGN(sizeof(struct rtattr));
 975         while (RTA_OK(attr, attrlen)) {
 976                 if (attr->rta_type == IFLA_WIRELESS) {
 977                         madwifi_wireless_event_wireless(
 978                                 drv, ((char *) attr) + rta_len,
 979                                 attr->rta_len - rta_len);
 980                 }
 981                 attr = RTA_NEXT(attr, attrlen);
 982         }
 983 }
 984
 985
 986 static void
 987 madwifi_wireless_event_receive(int sock, void *eloop_ctx, void *sock_ctx)
 988 {
 989         char buf[256];
 990         int left;
 991         struct sockaddr_nl from;
 992         socklen_t fromlen;
 993         struct nlmsghdr *h;
 994         struct madwifi_driver_data *drv = eloop_ctx;
 995
 996         fromlen = sizeof(from);
 997         left = recvfrom(sock, buf, sizeof(buf), MSG_DONTWAIT,
 998                         (struct sockaddr *) &from, &fromlen);
 999         if (left < 0) {
1000                 if (errno != EINTR && errno != EAGAIN)
1001                         perror("recvfrom(netlink)");
1002                 return;
1003         }
1004
1005         h = (struct nlmsghdr *) buf;
1006         while (left >= (int) sizeof(*h)) {
1007                 int len, plen;
1008
1009                 len = h->nlmsg_len;
1010                 plen = len - sizeof(*h);
1011                 if (len > left || plen < 0) {
1012                         printf("Malformed netlink message: "
1013                                "len=%d left=%d plen=%d\n",
1014                                len, left, plen);
1015                         break;
1016                 }
1017
1018                 switch (h->nlmsg_type) {
1019                 case RTM_NEWLINK:
1020                         madwifi_wireless_event_rtm_newlink(drv, h, plen);
1021                         break;
1022                 }
1023
1024                 len = NLMSG_ALIGN(len);
1025                 left -= len;
1026                 h = (struct nlmsghdr *) ((char *) h + len);
1027         }
1028
1029         if (left > 0) {
1030                 printf("%d extra bytes in the end of netlink message\n", left);
1031         }
1032 }
1033
1034
1035 static int
1036 madwifi_get_we_version(struct madwifi_driver_data *drv)
1037 {
1038         struct iw_range *range;
1039         struct iwreq iwr;
1040         int minlen;
1041         size_t buflen;
1042
1043         drv->we_version = 0;
1044
1045         /*
1046          * Use larger buffer than struct iw_range in order to allow the
1047          * structure to grow in the future.
1048          */
1049         buflen = sizeof(struct iw_range) + 500;
1050         range = os_zalloc(buflen);
1051         if (range == NULL)
1052                 return -1;
1053
1054         memset(&iwr, 0, sizeof(iwr));
1055         os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ);
1056         iwr.u.data.pointer = (caddr_t) range;
1057         iwr.u.data.length = buflen;
1058
1059         minlen = ((char *) &range->enc_capa) - (char *) range +
1060                 sizeof(range->enc_capa);
1061
1062         if (ioctl(drv->ioctl_sock, SIOCGIWRANGE, &iwr) < 0) {
1063                 perror("ioctl[SIOCGIWRANGE]");
1064                 free(range);
1065                 return -1;
1066         } else if (iwr.u.data.length >= minlen &&
1067                    range->we_version_compiled >= 18) {
1068                 wpa_printf(MSG_DEBUG, "SIOCGIWRANGE: WE(compiled)=%d "
1069                            "WE(source)=%d enc_capa=0x%x",
1070                            range->we_version_compiled,
1071                            range->we_version_source,
1072                            range->enc_capa);
1073                 drv->we_version = range->we_version_compiled;
1074         }
1075
1076         free(range);
1077         return 0;
1078 }
1079
1080
1081 static int
1082 madwifi_wireless_event_init(struct madwifi_driver_data *drv)
1083 {
1084         int s;
1085         struct sockaddr_nl local;
1086
1087         madwifi_get_we_version(drv);
1088
1089         drv->wext_sock = -1;
1090
1091         s = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
1092         if (s < 0) {
1093                 perror("socket(PF_NETLINK,SOCK_RAW,NETLINK_ROUTE)");
1094                 return -1;
1095         }
1096
1097         memset(&local, 0, sizeof(local));
1098         local.nl_family = AF_NETLINK;
1099         local.nl_groups = RTMGRP_LINK;
1100         if (bind(s, (struct sockaddr *) &local, sizeof(local)) < 0) {
1101                 perror("bind(netlink)");
1102                 close(s);
1103                 return -1;
1104         }
1105
1106         eloop_register_read_sock(s, madwifi_wireless_event_receive, drv, NULL);
1107         drv->wext_sock = s;
1108
1109         return 0;
1110 }
1111
1112
1113 static void
1114 madwifi_wireless_event_deinit(struct madwifi_driver_data *drv)
1115 {
1116         if (drv->wext_sock < 0)
1117                 return;
1118         eloop_unregister_read_sock(drv->wext_sock);
1119         close(drv->wext_sock);
1120 }
1121
1122
1123 static int
1124 madwifi_send_eapol(void *priv, const u8 *addr, const u8 *data, size_t data_len,
1125                    int encrypt, const u8 *own_addr)
1126 {
1127         struct madwifi_driver_data *drv = priv;
1128         unsigned char buf[3000];
1129         unsigned char *bp = buf;
1130         struct l2_ethhdr *eth;
1131         size_t len;
1132         int status;
1133
1134         /*
1135          * Prepend the Ethernet header.  If the caller left us
1136          * space at the front we could just insert it but since
1137          * we don't know we copy to a local buffer.  Given the frequency
1138          * and size of frames this probably doesn't matter.
1139          */
1140         len = data_len + sizeof(struct l2_ethhdr);
1141         if (len > sizeof(buf)) {
1142                 bp = malloc(len);
1143                 if (bp == NULL) {
1144                         printf("EAPOL frame discarded, cannot malloc temp "
1145                                "buffer of size %lu!\n", (unsigned long) len);
1146                         return -1;
1147                 }
1148         }
1149         eth = (struct l2_ethhdr *) bp;
1150         memcpy(eth->h_dest, addr, ETH_ALEN);
1151         memcpy(eth->h_source, own_addr, ETH_ALEN);
1152         eth->h_proto = host_to_be16(ETH_P_EAPOL);
1153         memcpy(eth+1, data, data_len);
1154
1155         wpa_hexdump(MSG_MSGDUMP, "TX EAPOL", bp, len);
1156
1157         status = l2_packet_send(drv->sock_xmit, addr, ETH_P_EAPOL, bp, len);
1158
1159         if (bp != buf)
1160                 free(bp);
1161         return status;
1162 }
1163
1164 static void
1165 handle_read(void *ctx, const u8 *src_addr, const u8 *buf, size_t len)
1166 {
1167         struct madwifi_driver_data *drv = ctx;
1168         hostapd_eapol_receive(drv->hapd, src_addr,
1169                               buf + sizeof(struct l2_ethhdr),
1170                               len - sizeof(struct l2_ethhdr));
1171 }
1172
1173 static void *
1174 madwifi_init(struct hostapd_data *hapd, struct wpa_init_params *params)
1175 {
1176         struct madwifi_driver_data *drv;
1177         struct ifreq ifr;
1178         struct iwreq iwr;
1179
1180         drv = os_zalloc(sizeof(struct madwifi_driver_data));
1181         if (drv == NULL) {
1182                 printf("Could not allocate memory for madwifi driver data\n");
1183                 return NULL;
1184         }
1185
1186         drv->hapd = hapd;
1187         drv->ioctl_sock = socket(PF_INET, SOCK_DGRAM, 0);
1188         if (drv->ioctl_sock < 0) {
1189                 perror("socket[PF_INET,SOCK_DGRAM]");
1190                 goto bad;
1191         }
1192         memcpy(drv->iface, params->ifname, sizeof(drv->iface));
1193
1194         memset(&ifr, 0, sizeof(ifr));
1195         os_strlcpy(ifr.ifr_name, drv->iface, sizeof(ifr.ifr_name));
1196         if (ioctl(drv->ioctl_sock, SIOCGIFINDEX, &ifr) != 0) {
1197                 perror("ioctl(SIOCGIFINDEX)");
1198                 goto bad;
1199         }
1200         drv->ifindex = ifr.ifr_ifindex;
1201
1202         drv->sock_xmit = l2_packet_init(drv->iface, NULL, ETH_P_EAPOL,
1203                                         handle_read, drv, 1);
1204         if (drv->sock_xmit == NULL)
1205                 goto bad;
1206         if (l2_packet_get_own_addr(drv->sock_xmit, params->own_addr))
1207                 goto bad;
1208         if (params->bridge[0]) {
1209                 wpa_printf(MSG_DEBUG, "Configure bridge %s for EAPOL traffic.",
1210                            params->bridge[0]);
1211                 drv->sock_recv = l2_packet_init(params->bridge[0], NULL,
1212                                                 ETH_P_EAPOL, handle_read, drv,
1213                                                 1);
1214                 if (drv->sock_recv == NULL)
1215                         goto bad;
1216         } else
1217                 drv->sock_recv = drv->sock_xmit;
1218
1219         memset(&iwr, 0, sizeof(iwr));
1220         os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ);
1221
1222         iwr.u.mode = IW_MODE_MASTER;
1223
1224         if (ioctl(drv->ioctl_sock, SIOCSIWMODE, &iwr) < 0) {
1225                 perror("ioctl[SIOCSIWMODE]");
1226                 printf("Could not set interface to master mode!\n");
1227                 goto bad;
1228         }
1229
1230         madwifi_set_iface_flags(drv, 0);        /* mark down during setup */
1231         madwifi_set_privacy(drv->iface, drv, 0); /* default to no privacy */
1232
1233         madwifi_receive_probe_req(drv);
1234
1235         if (madwifi_wireless_event_init(drv))
1236                 goto bad;
1237
1238         return drv;
1239 bad:
1240         if (drv->sock_xmit != NULL)
1241                 l2_packet_deinit(drv->sock_xmit);
1242         if (drv->ioctl_sock >= 0)
1243                 close(drv->ioctl_sock);
1244         if (drv != NULL)
1245                 free(drv);
1246         return NULL;
1247 }
1248
1249
1250 static void
1251 madwifi_deinit(void *priv)
1252 {
1253         struct madwifi_driver_data *drv = priv;
1254
1255         madwifi_wireless_event_deinit(drv);
1256         (void) madwifi_set_iface_flags(drv, 0);
1257         if (drv->ioctl_sock >= 0)
1258                 close(drv->ioctl_sock);
1259         if (drv->sock_recv != NULL && drv->sock_recv != drv->sock_xmit)
1260                 l2_packet_deinit(drv->sock_recv);
1261         if (drv->sock_xmit != NULL)
1262                 l2_packet_deinit(drv->sock_xmit);
1263         if (drv->sock_raw)
1264                 l2_packet_deinit(drv->sock_raw);
1265         free(drv);
1266 }
1267
1268 static int
1269 madwifi_set_ssid(const char *ifname, void *priv, const u8 *buf, int len)
1270 {
1271         struct madwifi_driver_data *drv = priv;
1272         struct iwreq iwr;
1273
1274         memset(&iwr, 0, sizeof(iwr));
1275         os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ);
1276         iwr.u.essid.flags = 1; /* SSID active */
1277         iwr.u.essid.pointer = (caddr_t) buf;
1278         iwr.u.essid.length = len + 1;
1279
1280         if (ioctl(drv->ioctl_sock, SIOCSIWESSID, &iwr) < 0) {
1281                 perror("ioctl[SIOCSIWESSID]");
1282                 printf("len=%d\n", len);
1283                 return -1;
1284         }
1285         return 0;
1286 }
1287
1288 static int
1289 madwifi_get_ssid(const char *ifname, void *priv, u8 *buf, int len)
1290 {
1291         struct madwifi_driver_data *drv = priv;
1292         struct iwreq iwr;
1293         int ret = 0;
1294
1295         memset(&iwr, 0, sizeof(iwr));
1296         os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ);
1297         iwr.u.essid.pointer = (caddr_t) buf;
1298         iwr.u.essid.length = len;
1299
1300         if (ioctl(drv->ioctl_sock, SIOCGIWESSID, &iwr) < 0) {
1301                 perror("ioctl[SIOCGIWESSID]");
1302                 ret = -1;
1303         } else
1304                 ret = iwr.u.essid.length;
1305
1306         return ret;
1307 }
1308
1309 static int
1310 madwifi_set_countermeasures(void *priv, int enabled)
1311 {
1312         struct madwifi_driver_data *drv = priv;
1313         wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled);
1314         return set80211param(drv, IEEE80211_PARAM_COUNTERMEASURES, enabled);
1315 }
1316
1317 static int
1318 madwifi_commit(void *priv)
1319 {
1320         return madwifi_set_iface_flags(priv, 1);
1321 }
1322
1323 const struct wpa_driver_ops wpa_driver_atheros_ops = {
1324         .name                   = "atheros",
1325         .hapd_init              = madwifi_init,
1326         .deinit                 = madwifi_deinit,
1327         .set_ieee8021x          = madwifi_set_ieee8021x,
1328         .set_privacy            = madwifi_set_privacy,
1329         .hapd_set_key           = madwifi_set_key,
1330         .get_seqnum             = madwifi_get_seqnum,
1331         .flush                  = madwifi_flush,
1332         .set_generic_elem       = madwifi_set_opt_ie,
1333         .sta_set_flags          = madwifi_sta_set_flags,
1334         .read_sta_data          = madwifi_read_sta_driver_data,
1335         .hapd_send_eapol        = madwifi_send_eapol,
1336         .sta_disassoc           = madwifi_sta_disassoc,
1337         .sta_deauth             = madwifi_sta_deauth,
1338         .hapd_set_ssid          = madwifi_set_ssid,
1339         .hapd_get_ssid          = madwifi_get_ssid,
1340         .set_countermeasures    = madwifi_set_countermeasures,
1341         .sta_clear_stats        = madwifi_sta_clear_stats,
1342         .commit                 = madwifi_commit,
1343         .set_wps_beacon_ie      = madwifi_set_wps_beacon_ie,
1344         .set_wps_probe_resp_ie  = madwifi_set_wps_probe_resp_ie,
1345 };