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