1/* 2 * Testing driver interface for a simulated network driver 3 * Copyright (c) 2004-2010, Jouni Malinen <j@w1.fi> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License version 2 as 7 * published by the Free Software Foundation. 8 * 9 * Alternatively, this software may be distributed under the terms of BSD 10 * license. 11 * 12 * See README and COPYING for more details. 13 */ 14 15/* Make sure we get winsock2.h for Windows build to get sockaddr_storage */ 16#include "build_config.h" 17#ifdef CONFIG_NATIVE_WINDOWS 18#include <winsock2.h> 19#endif /* CONFIG_NATIVE_WINDOWS */ 20 21#include "utils/includes.h" 22 23#ifndef CONFIG_NATIVE_WINDOWS 24#include <sys/un.h> 25#include <dirent.h> 26#include <sys/stat.h> 27#define DRIVER_TEST_UNIX 28#endif /* CONFIG_NATIVE_WINDOWS */ 29 30#include "utils/common.h" 31#include "utils/eloop.h" 32#include "utils/list.h" 33#include "utils/trace.h" 34#include "common/ieee802_11_defs.h" 35#include "crypto/sha1.h" 36#include "l2_packet/l2_packet.h" 37#include "driver.h" 38 39 40struct test_client_socket { 41 struct test_client_socket *next; 42 u8 addr[ETH_ALEN]; 43 struct sockaddr_un un; 44 socklen_t unlen; 45 struct test_driver_bss *bss; 46}; 47 48struct test_driver_bss { 49 struct wpa_driver_test_data *drv; 50 struct dl_list list; 51 void *bss_ctx; 52 char ifname[IFNAMSIZ]; 53 u8 bssid[ETH_ALEN]; 54 u8 *ie; 55 size_t ielen; 56 u8 *wps_beacon_ie; 57 size_t wps_beacon_ie_len; 58 u8 *wps_probe_resp_ie; 59 size_t wps_probe_resp_ie_len; 60 u8 ssid[32]; 61 size_t ssid_len; 62 int privacy; 63}; 64 65struct wpa_driver_test_global { 66 int bss_add_used; 67 u8 req_addr[ETH_ALEN]; 68}; 69 70struct wpa_driver_test_data { 71 struct wpa_driver_test_global *global; 72 void *ctx; 73 WPA_TRACE_REF(ctx); 74 u8 own_addr[ETH_ALEN]; 75 int test_socket; 76#ifdef DRIVER_TEST_UNIX 77 struct sockaddr_un hostapd_addr; 78#endif /* DRIVER_TEST_UNIX */ 79 int hostapd_addr_set; 80 struct sockaddr_in hostapd_addr_udp; 81 int hostapd_addr_udp_set; 82 char *own_socket_path; 83 char *test_dir; 84#define MAX_SCAN_RESULTS 30 85 struct wpa_scan_res *scanres[MAX_SCAN_RESULTS]; 86 size_t num_scanres; 87 int use_associnfo; 88 u8 assoc_wpa_ie[80]; 89 size_t assoc_wpa_ie_len; 90 int use_mlme; 91 int associated; 92 u8 *probe_req_ie; 93 size_t probe_req_ie_len; 94 u8 probe_req_ssid[32]; 95 size_t probe_req_ssid_len; 96 int ibss; 97 int ap; 98 99 struct test_client_socket *cli; 100 struct dl_list bss; 101 int udp_port; 102 103 int alloc_iface_idx; 104 105 int probe_req_report; 106 unsigned int remain_on_channel_freq; 107 unsigned int remain_on_channel_duration; 108 109 int current_freq; 110}; 111 112 113static void wpa_driver_test_deinit(void *priv); 114static int wpa_driver_test_attach(struct wpa_driver_test_data *drv, 115 const char *dir, int ap); 116static void wpa_driver_test_close_test_socket( 117 struct wpa_driver_test_data *drv); 118static void test_remain_on_channel_timeout(void *eloop_ctx, void *timeout_ctx); 119 120 121static void test_driver_free_bss(struct test_driver_bss *bss) 122{ 123 os_free(bss->ie); 124 os_free(bss->wps_beacon_ie); 125 os_free(bss->wps_probe_resp_ie); 126 os_free(bss); 127} 128 129 130static void test_driver_free_bsses(struct wpa_driver_test_data *drv) 131{ 132 struct test_driver_bss *bss, *tmp; 133 134 dl_list_for_each_safe(bss, tmp, &drv->bss, struct test_driver_bss, 135 list) { 136 dl_list_del(&bss->list); 137 test_driver_free_bss(bss); 138 } 139} 140 141 142static struct test_client_socket * 143test_driver_get_cli(struct wpa_driver_test_data *drv, struct sockaddr_un *from, 144 socklen_t fromlen) 145{ 146 struct test_client_socket *cli = drv->cli; 147 148 while (cli) { 149 if (cli->unlen == fromlen && 150 strncmp(cli->un.sun_path, from->sun_path, 151 fromlen - sizeof(cli->un.sun_family)) == 0) 152 return cli; 153 cli = cli->next; 154 } 155 156 return NULL; 157} 158 159 160static int test_driver_send_eapol(void *priv, const u8 *addr, const u8 *data, 161 size_t data_len, int encrypt, 162 const u8 *own_addr) 163{ 164 struct test_driver_bss *dbss = priv; 165 struct wpa_driver_test_data *drv = dbss->drv; 166 struct test_client_socket *cli; 167 struct msghdr msg; 168 struct iovec io[3]; 169 struct l2_ethhdr eth; 170 171 if (drv->test_socket < 0) 172 return -1; 173 174 cli = drv->cli; 175 while (cli) { 176 if (memcmp(cli->addr, addr, ETH_ALEN) == 0) 177 break; 178 cli = cli->next; 179 } 180 181 if (!cli) { 182 wpa_printf(MSG_DEBUG, "%s: no destination client entry", 183 __func__); 184 return -1; 185 } 186 187 memcpy(eth.h_dest, addr, ETH_ALEN); 188 memcpy(eth.h_source, own_addr, ETH_ALEN); 189 eth.h_proto = host_to_be16(ETH_P_EAPOL); 190 191 io[0].iov_base = "EAPOL "; 192 io[0].iov_len = 6; 193 io[1].iov_base = ð 194 io[1].iov_len = sizeof(eth); 195 io[2].iov_base = (u8 *) data; 196 io[2].iov_len = data_len; 197 198 memset(&msg, 0, sizeof(msg)); 199 msg.msg_iov = io; 200 msg.msg_iovlen = 3; 201 msg.msg_name = &cli->un; 202 msg.msg_namelen = cli->unlen; 203 return sendmsg(drv->test_socket, &msg, 0); 204} 205 206 207static int test_driver_send_ether(void *priv, const u8 *dst, const u8 *src, 208 u16 proto, const u8 *data, size_t data_len) 209{ 210 struct test_driver_bss *dbss = priv; 211 struct wpa_driver_test_data *drv = dbss->drv; 212 struct msghdr msg; 213 struct iovec io[3]; 214 struct l2_ethhdr eth; 215 char desttxt[30]; 216 struct sockaddr_un addr; 217 struct dirent *dent; 218 DIR *dir; 219 int ret = 0, broadcast = 0, count = 0; 220 221 if (drv->test_socket < 0 || drv->test_dir == NULL) { 222 wpa_printf(MSG_DEBUG, "%s: invalid parameters (sock=%d " 223 "test_dir=%p)", 224 __func__, drv->test_socket, drv->test_dir); 225 return -1; 226 } 227 228 broadcast = memcmp(dst, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) == 0; 229 snprintf(desttxt, sizeof(desttxt), MACSTR, MAC2STR(dst)); 230 231 memcpy(eth.h_dest, dst, ETH_ALEN); 232 memcpy(eth.h_source, src, ETH_ALEN); 233 eth.h_proto = host_to_be16(proto); 234 235 io[0].iov_base = "ETHER "; 236 io[0].iov_len = 6; 237 io[1].iov_base = ð 238 io[1].iov_len = sizeof(eth); 239 io[2].iov_base = (u8 *) data; 240 io[2].iov_len = data_len; 241 242 memset(&msg, 0, sizeof(msg)); 243 msg.msg_iov = io; 244 msg.msg_iovlen = 3; 245 246 dir = opendir(drv->test_dir); 247 if (dir == NULL) { 248 perror("test_driver: opendir"); 249 return -1; 250 } 251 while ((dent = readdir(dir))) { 252#ifdef _DIRENT_HAVE_D_TYPE 253 /* Skip the file if it is not a socket. Also accept 254 * DT_UNKNOWN (0) in case the C library or underlying file 255 * system does not support d_type. */ 256 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN) 257 continue; 258#endif /* _DIRENT_HAVE_D_TYPE */ 259 if (strcmp(dent->d_name, ".") == 0 || 260 strcmp(dent->d_name, "..") == 0) 261 continue; 262 263 memset(&addr, 0, sizeof(addr)); 264 addr.sun_family = AF_UNIX; 265 snprintf(addr.sun_path, sizeof(addr.sun_path), "%s/%s", 266 drv->test_dir, dent->d_name); 267 268 if (strcmp(addr.sun_path, drv->own_socket_path) == 0) 269 continue; 270 if (!broadcast && strstr(dent->d_name, desttxt) == NULL) 271 continue; 272 273 wpa_printf(MSG_DEBUG, "%s: Send ether frame to %s", 274 __func__, dent->d_name); 275 276 msg.msg_name = &addr; 277 msg.msg_namelen = sizeof(addr); 278 ret = sendmsg(drv->test_socket, &msg, 0); 279 if (ret < 0) 280 perror("driver_test: sendmsg"); 281 count++; 282 } 283 closedir(dir); 284 285 if (!broadcast && count == 0) { 286 wpa_printf(MSG_DEBUG, "%s: Destination " MACSTR " not found", 287 __func__, MAC2STR(dst)); 288 return -1; 289 } 290 291 return ret; 292} 293 294 295static int wpa_driver_test_send_mlme(void *priv, const u8 *data, 296 size_t data_len) 297{ 298 struct test_driver_bss *dbss = priv; 299 struct wpa_driver_test_data *drv = dbss->drv; 300 struct msghdr msg; 301 struct iovec io[2]; 302 const u8 *dest; 303 struct sockaddr_un addr; 304 struct dirent *dent; 305 DIR *dir; 306 int broadcast; 307 int ret = 0; 308 struct ieee80211_hdr *hdr; 309 u16 fc; 310 char cmd[50]; 311 int freq; 312#ifdef HOSTAPD 313 char desttxt[30]; 314#endif /* HOSTAPD */ 315 union wpa_event_data event; 316 317 wpa_hexdump(MSG_MSGDUMP, "test_send_mlme", data, data_len); 318 if (drv->test_socket < 0 || data_len < 10) { 319 wpa_printf(MSG_DEBUG, "%s: invalid parameters (sock=%d len=%lu" 320 " test_dir=%p)", 321 __func__, drv->test_socket, 322 (unsigned long) data_len, 323 drv->test_dir); 324 return -1; 325 } 326 327 dest = data + 4; 328 broadcast = os_memcmp(dest, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) == 0; 329 330#ifdef HOSTAPD 331 snprintf(desttxt, sizeof(desttxt), MACSTR, MAC2STR(dest)); 332#endif /* HOSTAPD */ 333 334 if (drv->remain_on_channel_freq) 335 freq = drv->remain_on_channel_freq; 336 else 337 freq = drv->current_freq; 338 wpa_printf(MSG_DEBUG, "test_driver(%s): MLME TX on freq %d MHz", 339 dbss->ifname, freq); 340 os_snprintf(cmd, sizeof(cmd), "MLME freq=%d ", freq); 341 io[0].iov_base = cmd; 342 io[0].iov_len = os_strlen(cmd); 343 io[1].iov_base = (void *) data; 344 io[1].iov_len = data_len; 345 346 os_memset(&msg, 0, sizeof(msg)); 347 msg.msg_iov = io; 348 msg.msg_iovlen = 2; 349 350#ifdef HOSTAPD 351 if (drv->test_dir == NULL) { 352 wpa_printf(MSG_DEBUG, "%s: test_dir == NULL", __func__); 353 return -1; 354 } 355 356 dir = opendir(drv->test_dir); 357 if (dir == NULL) { 358 perror("test_driver: opendir"); 359 return -1; 360 } 361 while ((dent = readdir(dir))) { 362#ifdef _DIRENT_HAVE_D_TYPE 363 /* Skip the file if it is not a socket. Also accept 364 * DT_UNKNOWN (0) in case the C library or underlying file 365 * system does not support d_type. */ 366 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN) 367 continue; 368#endif /* _DIRENT_HAVE_D_TYPE */ 369 if (os_strcmp(dent->d_name, ".") == 0 || 370 os_strcmp(dent->d_name, "..") == 0) 371 continue; 372 373 os_memset(&addr, 0, sizeof(addr)); 374 addr.sun_family = AF_UNIX; 375 os_snprintf(addr.sun_path, sizeof(addr.sun_path), "%s/%s", 376 drv->test_dir, dent->d_name); 377 378 if (os_strcmp(addr.sun_path, drv->own_socket_path) == 0) 379 continue; 380 if (!broadcast && os_strstr(dent->d_name, desttxt) == NULL) 381 continue; 382 383 wpa_printf(MSG_DEBUG, "%s: Send management frame to %s", 384 __func__, dent->d_name); 385 386 msg.msg_name = &addr; 387 msg.msg_namelen = sizeof(addr); 388 ret = sendmsg(drv->test_socket, &msg, 0); 389 if (ret < 0) 390 perror("driver_test: sendmsg(test_socket)"); 391 } 392 closedir(dir); 393#else /* HOSTAPD */ 394 395 if (os_memcmp(dest, dbss->bssid, ETH_ALEN) == 0 || 396 drv->test_dir == NULL) { 397 if (drv->hostapd_addr_udp_set) { 398 msg.msg_name = &drv->hostapd_addr_udp; 399 msg.msg_namelen = sizeof(drv->hostapd_addr_udp); 400 } else { 401#ifdef DRIVER_TEST_UNIX 402 msg.msg_name = &drv->hostapd_addr; 403 msg.msg_namelen = sizeof(drv->hostapd_addr); 404#endif /* DRIVER_TEST_UNIX */ 405 } 406 } else if (broadcast) { 407 dir = opendir(drv->test_dir); 408 if (dir == NULL) 409 return -1; 410 while ((dent = readdir(dir))) { 411#ifdef _DIRENT_HAVE_D_TYPE 412 /* Skip the file if it is not a socket. 413 * Also accept DT_UNKNOWN (0) in case 414 * the C library or underlying file 415 * system does not support d_type. */ 416 if (dent->d_type != DT_SOCK && 417 dent->d_type != DT_UNKNOWN) 418 continue; 419#endif /* _DIRENT_HAVE_D_TYPE */ 420 if (os_strcmp(dent->d_name, ".") == 0 || 421 os_strcmp(dent->d_name, "..") == 0) 422 continue; 423 wpa_printf(MSG_DEBUG, "%s: Send broadcast MLME to %s", 424 __func__, dent->d_name); 425 os_memset(&addr, 0, sizeof(addr)); 426 addr.sun_family = AF_UNIX; 427 os_snprintf(addr.sun_path, sizeof(addr.sun_path), 428 "%s/%s", drv->test_dir, dent->d_name); 429 430 msg.msg_name = &addr; 431 msg.msg_namelen = sizeof(addr); 432 433 ret = sendmsg(drv->test_socket, &msg, 0); 434 if (ret < 0) 435 perror("driver_test: sendmsg(test_socket)"); 436 } 437 closedir(dir); 438 return ret; 439 } else { 440 struct stat st; 441 os_memset(&addr, 0, sizeof(addr)); 442 addr.sun_family = AF_UNIX; 443 os_snprintf(addr.sun_path, sizeof(addr.sun_path), 444 "%s/AP-" MACSTR, drv->test_dir, MAC2STR(dest)); 445 if (stat(addr.sun_path, &st) < 0) { 446 os_snprintf(addr.sun_path, sizeof(addr.sun_path), 447 "%s/STA-" MACSTR, 448 drv->test_dir, MAC2STR(dest)); 449 } 450 msg.msg_name = &addr; 451 msg.msg_namelen = sizeof(addr); 452 } 453 454 if (sendmsg(drv->test_socket, &msg, 0) < 0) { 455 perror("sendmsg(test_socket)"); 456 return -1; 457 } 458#endif /* HOSTAPD */ 459 460 hdr = (struct ieee80211_hdr *) data; 461 fc = le_to_host16(hdr->frame_control); 462 463 os_memset(&event, 0, sizeof(event)); 464 event.tx_status.type = WLAN_FC_GET_TYPE(fc); 465 event.tx_status.stype = WLAN_FC_GET_STYPE(fc); 466 event.tx_status.dst = hdr->addr1; 467 event.tx_status.data = data; 468 event.tx_status.data_len = data_len; 469 event.tx_status.ack = ret >= 0; 470 wpa_supplicant_event(drv->ctx, EVENT_TX_STATUS, &event); 471 472 return ret; 473} 474 475 476static void test_driver_scan(struct wpa_driver_test_data *drv, 477 struct sockaddr_un *from, socklen_t fromlen, 478 char *data) 479{ 480 char buf[512], *pos, *end; 481 int ret; 482 struct test_driver_bss *bss; 483 u8 sa[ETH_ALEN]; 484 u8 ie[512]; 485 size_t ielen; 486 union wpa_event_data event; 487 488 /* data: optional [ ' ' | STA-addr | ' ' | IEs(hex) ] */ 489 490 wpa_printf(MSG_DEBUG, "test_driver: SCAN"); 491 492 if (*data) { 493 if (*data != ' ' || 494 hwaddr_aton(data + 1, sa)) { 495 wpa_printf(MSG_DEBUG, "test_driver: Unexpected SCAN " 496 "command format"); 497 return; 498 } 499 500 data += 18; 501 while (*data == ' ') 502 data++; 503 ielen = os_strlen(data) / 2; 504 if (ielen > sizeof(ie)) 505 ielen = sizeof(ie); 506 if (hexstr2bin(data, ie, ielen) < 0) 507 ielen = 0; 508 509 wpa_printf(MSG_DEBUG, "test_driver: Scan from " MACSTR, 510 MAC2STR(sa)); 511 wpa_hexdump(MSG_MSGDUMP, "test_driver: scan IEs", ie, ielen); 512 513 os_memset(&event, 0, sizeof(event)); 514 event.rx_probe_req.sa = sa; 515 event.rx_probe_req.ie = ie; 516 event.rx_probe_req.ie_len = ielen; 517 wpa_supplicant_event(drv->ctx, EVENT_RX_PROBE_REQ, &event); 518 } 519 520 dl_list_for_each(bss, &drv->bss, struct test_driver_bss, list) { 521 pos = buf; 522 end = buf + sizeof(buf); 523 524 /* reply: SCANRESP BSSID SSID IEs */ 525 ret = snprintf(pos, end - pos, "SCANRESP " MACSTR " ", 526 MAC2STR(bss->bssid)); 527 if (ret < 0 || ret >= end - pos) 528 return; 529 pos += ret; 530 pos += wpa_snprintf_hex(pos, end - pos, 531 bss->ssid, bss->ssid_len); 532 ret = snprintf(pos, end - pos, " "); 533 if (ret < 0 || ret >= end - pos) 534 return; 535 pos += ret; 536 pos += wpa_snprintf_hex(pos, end - pos, bss->ie, bss->ielen); 537 pos += wpa_snprintf_hex(pos, end - pos, bss->wps_probe_resp_ie, 538 bss->wps_probe_resp_ie_len); 539 540 if (bss->privacy) { 541 ret = snprintf(pos, end - pos, " PRIVACY"); 542 if (ret < 0 || ret >= end - pos) 543 return; 544 pos += ret; 545 } 546 547 sendto(drv->test_socket, buf, pos - buf, 0, 548 (struct sockaddr *) from, fromlen); 549 } 550} 551 552 553static void test_driver_assoc(struct wpa_driver_test_data *drv, 554 struct sockaddr_un *from, socklen_t fromlen, 555 char *data) 556{ 557 struct test_client_socket *cli; 558 u8 ie[256], ssid[32]; 559 size_t ielen, ssid_len = 0; 560 char *pos, *pos2, cmd[50]; 561 struct test_driver_bss *bss, *tmp; 562 563 /* data: STA-addr SSID(hex) IEs(hex) */ 564 565 cli = os_zalloc(sizeof(*cli)); 566 if (cli == NULL) 567 return; 568 569 if (hwaddr_aton(data, cli->addr)) { 570 printf("test_socket: Invalid MAC address '%s' in ASSOC\n", 571 data); 572 os_free(cli); 573 return; 574 } 575 pos = data + 17; 576 while (*pos == ' ') 577 pos++; 578 pos2 = strchr(pos, ' '); 579 ielen = 0; 580 if (pos2) { 581 ssid_len = (pos2 - pos) / 2; 582 if (hexstr2bin(pos, ssid, ssid_len) < 0) { 583 wpa_printf(MSG_DEBUG, "%s: Invalid SSID", __func__); 584 os_free(cli); 585 return; 586 } 587 wpa_hexdump_ascii(MSG_DEBUG, "test_driver_assoc: SSID", 588 ssid, ssid_len); 589 590 pos = pos2 + 1; 591 ielen = strlen(pos) / 2; 592 if (ielen > sizeof(ie)) 593 ielen = sizeof(ie); 594 if (hexstr2bin(pos, ie, ielen) < 0) 595 ielen = 0; 596 } 597 598 bss = NULL; 599 dl_list_for_each(tmp, &drv->bss, struct test_driver_bss, list) { 600 if (tmp->ssid_len == ssid_len && 601 os_memcmp(tmp->ssid, ssid, ssid_len) == 0) { 602 bss = tmp; 603 break; 604 } 605 } 606 if (bss == NULL) { 607 wpa_printf(MSG_DEBUG, "%s: No matching SSID found from " 608 "configured BSSes", __func__); 609 os_free(cli); 610 return; 611 } 612 613 cli->bss = bss; 614 memcpy(&cli->un, from, sizeof(cli->un)); 615 cli->unlen = fromlen; 616 cli->next = drv->cli; 617 drv->cli = cli; 618 wpa_hexdump_ascii(MSG_DEBUG, "test_socket: ASSOC sun_path", 619 (const u8 *) cli->un.sun_path, 620 cli->unlen - sizeof(cli->un.sun_family)); 621 622 snprintf(cmd, sizeof(cmd), "ASSOCRESP " MACSTR " 0", 623 MAC2STR(bss->bssid)); 624 sendto(drv->test_socket, cmd, strlen(cmd), 0, 625 (struct sockaddr *) from, fromlen); 626 627 drv_event_assoc(bss->bss_ctx, cli->addr, ie, ielen); 628} 629 630 631static void test_driver_disassoc(struct wpa_driver_test_data *drv, 632 struct sockaddr_un *from, socklen_t fromlen) 633{ 634 struct test_client_socket *cli; 635 636 cli = test_driver_get_cli(drv, from, fromlen); 637 if (!cli) 638 return; 639 640 drv_event_disassoc(drv->ctx, cli->addr); 641} 642 643 644static void test_driver_eapol(struct wpa_driver_test_data *drv, 645 struct sockaddr_un *from, socklen_t fromlen, 646 u8 *data, size_t datalen) 647{ 648#ifdef HOSTAPD 649 struct test_client_socket *cli; 650#endif /* HOSTAPD */ 651 const u8 *src = NULL; 652 653 if (datalen > 14) { 654 /* Skip Ethernet header */ 655 src = data + ETH_ALEN; 656 wpa_printf(MSG_DEBUG, "test_driver: dst=" MACSTR " src=" 657 MACSTR " proto=%04x", 658 MAC2STR(data), MAC2STR(src), 659 WPA_GET_BE16(data + 2 * ETH_ALEN)); 660 data += 14; 661 datalen -= 14; 662 } 663 664#ifdef HOSTAPD 665 cli = test_driver_get_cli(drv, from, fromlen); 666 if (cli) { 667 drv_event_eapol_rx(cli->bss->bss_ctx, cli->addr, data, 668 datalen); 669 } else { 670 wpa_printf(MSG_DEBUG, "test_socket: EAPOL from unknown " 671 "client"); 672 } 673#else /* HOSTAPD */ 674 if (src) 675 drv_event_eapol_rx(drv->ctx, src, data, datalen); 676#endif /* HOSTAPD */ 677} 678 679 680static void test_driver_ether(struct wpa_driver_test_data *drv, 681 struct sockaddr_un *from, socklen_t fromlen, 682 u8 *data, size_t datalen) 683{ 684 struct l2_ethhdr *eth; 685 686 if (datalen < sizeof(*eth)) 687 return; 688 689 eth = (struct l2_ethhdr *) data; 690 wpa_printf(MSG_DEBUG, "test_driver: RX ETHER dst=" MACSTR " src=" 691 MACSTR " proto=%04x", 692 MAC2STR(eth->h_dest), MAC2STR(eth->h_source), 693 be_to_host16(eth->h_proto)); 694 695#ifdef CONFIG_IEEE80211R 696 if (be_to_host16(eth->h_proto) == ETH_P_RRB) { 697 union wpa_event_data ev; 698 os_memset(&ev, 0, sizeof(ev)); 699 ev.ft_rrb_rx.src = eth->h_source; 700 ev.ft_rrb_rx.data = data + sizeof(*eth); 701 ev.ft_rrb_rx.data_len = datalen - sizeof(*eth); 702 } 703#endif /* CONFIG_IEEE80211R */ 704} 705 706 707static void test_driver_mlme(struct wpa_driver_test_data *drv, 708 struct sockaddr_un *from, socklen_t fromlen, 709 u8 *data, size_t datalen) 710{ 711 struct ieee80211_hdr *hdr; 712 u16 fc; 713 union wpa_event_data event; 714 int freq = 0, own_freq; 715 struct test_driver_bss *bss; 716 717 bss = dl_list_first(&drv->bss, struct test_driver_bss, list); 718 719 if (datalen > 6 && os_memcmp(data, "freq=", 5) == 0) { 720 size_t pos; 721 for (pos = 5; pos < datalen; pos++) { 722 if (data[pos] == ' ') 723 break; 724 } 725 if (pos < datalen) { 726 freq = atoi((const char *) &data[5]); 727 wpa_printf(MSG_DEBUG, "test_driver(%s): MLME RX on " 728 "freq %d MHz", bss->ifname, freq); 729 pos++; 730 data += pos; 731 datalen -= pos; 732 } 733 } 734 735 if (drv->remain_on_channel_freq) 736 own_freq = drv->remain_on_channel_freq; 737 else 738 own_freq = drv->current_freq; 739 740 if (freq && own_freq && freq != own_freq) { 741 wpa_printf(MSG_DEBUG, "test_driver(%s): Ignore MLME RX on " 742 "another frequency %d MHz (own %d MHz)", 743 bss->ifname, freq, own_freq); 744 return; 745 } 746 747 hdr = (struct ieee80211_hdr *) data; 748 749 if (test_driver_get_cli(drv, from, fromlen) == NULL && datalen >= 16) { 750 struct test_client_socket *cli; 751 cli = os_zalloc(sizeof(*cli)); 752 if (cli == NULL) 753 return; 754 wpa_printf(MSG_DEBUG, "Adding client entry for " MACSTR, 755 MAC2STR(hdr->addr2)); 756 memcpy(cli->addr, hdr->addr2, ETH_ALEN); 757 memcpy(&cli->un, from, sizeof(cli->un)); 758 cli->unlen = fromlen; 759 cli->next = drv->cli; 760 drv->cli = cli; 761 } 762 763 wpa_hexdump(MSG_MSGDUMP, "test_driver_mlme: received frame", 764 data, datalen); 765 fc = le_to_host16(hdr->frame_control); 766 if (WLAN_FC_GET_TYPE(fc) != WLAN_FC_TYPE_MGMT) { 767 wpa_printf(MSG_ERROR, "%s: received non-mgmt frame", 768 __func__); 769 return; 770 } 771 772 os_memset(&event, 0, sizeof(event)); 773 event.rx_mgmt.frame = data; 774 event.rx_mgmt.frame_len = datalen; 775 wpa_supplicant_event(drv->ctx, EVENT_RX_MGMT, &event); 776} 777 778 779static void test_driver_receive_unix(int sock, void *eloop_ctx, void *sock_ctx) 780{ 781 struct wpa_driver_test_data *drv = eloop_ctx; 782 char buf[2000]; 783 int res; 784 struct sockaddr_un from; 785 socklen_t fromlen = sizeof(from); 786 787 res = recvfrom(sock, buf, sizeof(buf) - 1, 0, 788 (struct sockaddr *) &from, &fromlen); 789 if (res < 0) { 790 perror("recvfrom(test_socket)"); 791 return; 792 } 793 buf[res] = '\0'; 794 795 wpa_printf(MSG_DEBUG, "test_driver: received %u bytes", res); 796 797 if (strncmp(buf, "SCAN", 4) == 0) { 798 test_driver_scan(drv, &from, fromlen, buf + 4); 799 } else if (strncmp(buf, "ASSOC ", 6) == 0) { 800 test_driver_assoc(drv, &from, fromlen, buf + 6); 801 } else if (strcmp(buf, "DISASSOC") == 0) { 802 test_driver_disassoc(drv, &from, fromlen); 803 } else if (strncmp(buf, "EAPOL ", 6) == 0) { 804 test_driver_eapol(drv, &from, fromlen, (u8 *) buf + 6, 805 res - 6); 806 } else if (strncmp(buf, "ETHER ", 6) == 0) { 807 test_driver_ether(drv, &from, fromlen, (u8 *) buf + 6, 808 res - 6); 809 } else if (strncmp(buf, "MLME ", 5) == 0) { 810 test_driver_mlme(drv, &from, fromlen, (u8 *) buf + 5, res - 5); 811 } else { 812 wpa_hexdump_ascii(MSG_DEBUG, "Unknown test_socket command", 813 (u8 *) buf, res); 814 } 815} 816 817 818static int test_driver_set_generic_elem(void *priv, 819 const u8 *elem, size_t elem_len) 820{ 821 struct test_driver_bss *bss = priv; 822 823 os_free(bss->ie); 824 825 if (elem == NULL) { 826 bss->ie = NULL; 827 bss->ielen = 0; 828 return 0; 829 } 830 831 bss->ie = os_malloc(elem_len); 832 if (bss->ie == NULL) { 833 bss->ielen = 0; 834 return -1; 835 } 836 837 memcpy(bss->ie, elem, elem_len); 838 bss->ielen = elem_len; 839 return 0; 840} 841 842 843static int test_driver_set_ap_wps_ie(void *priv, const struct wpabuf *beacon, 844 const struct wpabuf *proberesp) 845{ 846 struct test_driver_bss *bss = priv; 847 848 if (beacon == NULL) 849 wpa_printf(MSG_DEBUG, "test_driver: Clear Beacon WPS IE"); 850 else 851 wpa_hexdump_buf(MSG_DEBUG, "test_driver: Beacon WPS IE", 852 beacon); 853 854 os_free(bss->wps_beacon_ie); 855 856 if (beacon == NULL) { 857 bss->wps_beacon_ie = NULL; 858 bss->wps_beacon_ie_len = 0; 859 } else { 860 bss->wps_beacon_ie = os_malloc(wpabuf_len(beacon)); 861 if (bss->wps_beacon_ie == NULL) { 862 bss->wps_beacon_ie_len = 0; 863 return -1; 864 } 865 866 os_memcpy(bss->wps_beacon_ie, wpabuf_head(beacon), 867 wpabuf_len(beacon)); 868 bss->wps_beacon_ie_len = wpabuf_len(beacon); 869 } 870 871 if (proberesp == NULL) 872 wpa_printf(MSG_DEBUG, "test_driver: Clear Probe Response WPS " 873 "IE"); 874 else 875 wpa_hexdump_buf(MSG_DEBUG, "test_driver: Probe Response WPS " 876 "IE", proberesp); 877 878 os_free(bss->wps_probe_resp_ie); 879 880 if (proberesp == NULL) { 881 bss->wps_probe_resp_ie = NULL; 882 bss->wps_probe_resp_ie_len = 0; 883 } else { 884 bss->wps_probe_resp_ie = os_malloc(wpabuf_len(proberesp)); 885 if (bss->wps_probe_resp_ie == NULL) { 886 bss->wps_probe_resp_ie_len = 0; 887 return -1; 888 } 889 890 os_memcpy(bss->wps_probe_resp_ie, wpabuf_head(proberesp), 891 wpabuf_len(proberesp)); 892 bss->wps_probe_resp_ie_len = wpabuf_len(proberesp); 893 } 894 895 return 0; 896} 897 898 899static int test_driver_sta_deauth(void *priv, const u8 *own_addr, 900 const u8 *addr, int reason) 901{ 902 struct test_driver_bss *dbss = priv; 903 struct wpa_driver_test_data *drv = dbss->drv; 904 struct test_client_socket *cli; 905 906 if (drv->test_socket < 0) 907 return -1; 908 909 cli = drv->cli; 910 while (cli) { 911 if (memcmp(cli->addr, addr, ETH_ALEN) == 0) 912 break; 913 cli = cli->next; 914 } 915 916 if (!cli) 917 return -1; 918 919 return sendto(drv->test_socket, "DEAUTH", 6, 0, 920 (struct sockaddr *) &cli->un, cli->unlen); 921} 922 923 924static int test_driver_sta_disassoc(void *priv, const u8 *own_addr, 925 const u8 *addr, int reason) 926{ 927 struct test_driver_bss *dbss = priv; 928 struct wpa_driver_test_data *drv = dbss->drv; 929 struct test_client_socket *cli; 930 931 if (drv->test_socket < 0) 932 return -1; 933 934 cli = drv->cli; 935 while (cli) { 936 if (memcmp(cli->addr, addr, ETH_ALEN) == 0) 937 break; 938 cli = cli->next; 939 } 940 941 if (!cli) 942 return -1; 943 944 return sendto(drv->test_socket, "DISASSOC", 8, 0, 945 (struct sockaddr *) &cli->un, cli->unlen); 946} 947 948 949static int test_driver_bss_add(void *priv, const char *ifname, const u8 *bssid, 950 void *bss_ctx, void **drv_priv) 951{ 952 struct test_driver_bss *dbss = priv; 953 struct wpa_driver_test_data *drv = dbss->drv; 954 struct test_driver_bss *bss; 955 956 wpa_printf(MSG_DEBUG, "%s(ifname=%s bssid=" MACSTR ")", 957 __func__, ifname, MAC2STR(bssid)); 958 959 bss = os_zalloc(sizeof(*bss)); 960 if (bss == NULL) 961 return -1; 962 963 bss->bss_ctx = bss_ctx; 964 bss->drv = drv; 965 os_strlcpy(bss->ifname, ifname, IFNAMSIZ); 966 os_memcpy(bss->bssid, bssid, ETH_ALEN); 967 968 dl_list_add(&drv->bss, &bss->list); 969 if (drv->global) { 970 drv->global->bss_add_used = 1; 971 os_memcpy(drv->global->req_addr, bssid, ETH_ALEN); 972 } 973 974 if (drv_priv) 975 *drv_priv = bss; 976 977 return 0; 978} 979 980 981static int test_driver_bss_remove(void *priv, const char *ifname) 982{ 983 struct test_driver_bss *dbss = priv; 984 struct wpa_driver_test_data *drv = dbss->drv; 985 struct test_driver_bss *bss; 986 struct test_client_socket *cli, *prev_c; 987 988 wpa_printf(MSG_DEBUG, "%s(ifname=%s)", __func__, ifname); 989 990 dl_list_for_each(bss, &drv->bss, struct test_driver_bss, list) { 991 if (strcmp(bss->ifname, ifname) != 0) 992 continue; 993 994 for (prev_c = NULL, cli = drv->cli; cli; 995 prev_c = cli, cli = cli->next) { 996 if (cli->bss != bss) 997 continue; 998 if (prev_c) 999 prev_c->next = cli->next; 1000 else 1001 drv->cli = cli->next; 1002 os_free(cli); 1003 break; 1004 } 1005 1006 dl_list_del(&bss->list); 1007 test_driver_free_bss(bss); 1008 return 0; 1009 } 1010 1011 return -1; 1012} 1013 1014 1015static int test_driver_if_add(void *priv, enum wpa_driver_if_type type, 1016 const char *ifname, const u8 *addr, 1017 void *bss_ctx, void **drv_priv, 1018 char *force_ifname, u8 *if_addr) 1019{ 1020 struct test_driver_bss *dbss = priv; 1021 struct wpa_driver_test_data *drv = dbss->drv; 1022 1023 wpa_printf(MSG_DEBUG, "%s(type=%d ifname=%s bss_ctx=%p)", 1024 __func__, type, ifname, bss_ctx); 1025 if (addr) 1026 os_memcpy(if_addr, addr, ETH_ALEN); 1027 else { 1028 drv->alloc_iface_idx++; 1029 if_addr[0] = 0x02; /* locally administered */ 1030 sha1_prf(drv->own_addr, ETH_ALEN, 1031 "hostapd test addr generation", 1032 (const u8 *) &drv->alloc_iface_idx, 1033 sizeof(drv->alloc_iface_idx), 1034 if_addr + 1, ETH_ALEN - 1); 1035 } 1036 if (type == WPA_IF_AP_BSS) 1037 return test_driver_bss_add(priv, ifname, if_addr, bss_ctx, 1038 drv_priv); 1039 return 0; 1040} 1041 1042 1043static int test_driver_if_remove(void *priv, enum wpa_driver_if_type type, 1044 const char *ifname) 1045{ 1046 wpa_printf(MSG_DEBUG, "%s(type=%d ifname=%s)", __func__, type, ifname); 1047 if (type == WPA_IF_AP_BSS) 1048 return test_driver_bss_remove(priv, ifname); 1049 return 0; 1050} 1051 1052 1053static int test_driver_valid_bss_mask(void *priv, const u8 *addr, 1054 const u8 *mask) 1055{ 1056 return 0; 1057} 1058 1059 1060static int test_driver_set_ssid(void *priv, const u8 *buf, int len) 1061{ 1062 struct test_driver_bss *bss = priv; 1063 1064 wpa_printf(MSG_DEBUG, "%s(ifname=%s)", __func__, bss->ifname); 1065 wpa_hexdump_ascii(MSG_DEBUG, "test_driver_set_ssid: SSID", buf, len); 1066 1067 if (len < 0 || (size_t) len > sizeof(bss->ssid)) 1068 return -1; 1069 1070 os_memcpy(bss->ssid, buf, len); 1071 bss->ssid_len = len; 1072 1073 return 0; 1074} 1075 1076 1077static int test_driver_set_privacy(void *priv, int enabled) 1078{ 1079 struct test_driver_bss *dbss = priv; 1080 1081 wpa_printf(MSG_DEBUG, "%s(enabled=%d)", __func__, enabled); 1082 dbss->privacy = enabled; 1083 1084 return 0; 1085} 1086 1087 1088static int test_driver_set_sta_vlan(void *priv, const u8 *addr, 1089 const char *ifname, int vlan_id) 1090{ 1091 wpa_printf(MSG_DEBUG, "%s(addr=" MACSTR " ifname=%s vlan_id=%d)", 1092 __func__, MAC2STR(addr), ifname, vlan_id); 1093 return 0; 1094} 1095 1096 1097static int test_driver_sta_add(void *priv, 1098 struct hostapd_sta_add_params *params) 1099{ 1100 struct test_driver_bss *bss = priv; 1101 struct wpa_driver_test_data *drv = bss->drv; 1102 struct test_client_socket *cli; 1103 1104 wpa_printf(MSG_DEBUG, "%s(ifname=%s addr=" MACSTR " aid=%d " 1105 "capability=0x%x listen_interval=%d)", 1106 __func__, bss->ifname, MAC2STR(params->addr), params->aid, 1107 params->capability, params->listen_interval); 1108 wpa_hexdump(MSG_DEBUG, "test_driver_sta_add - supp_rates", 1109 params->supp_rates, params->supp_rates_len); 1110 1111 cli = drv->cli; 1112 while (cli) { 1113 if (os_memcmp(cli->addr, params->addr, ETH_ALEN) == 0) 1114 break; 1115 cli = cli->next; 1116 } 1117 if (!cli) { 1118 wpa_printf(MSG_DEBUG, "%s: no matching client entry", 1119 __func__); 1120 return -1; 1121 } 1122 1123 cli->bss = bss; 1124 1125 return 0; 1126} 1127 1128 1129static struct wpa_driver_test_data * test_alloc_data(void *ctx, 1130 const char *ifname) 1131{ 1132 struct wpa_driver_test_data *drv; 1133 struct test_driver_bss *bss; 1134 1135 drv = os_zalloc(sizeof(struct wpa_driver_test_data)); 1136 if (drv == NULL) { 1137 wpa_printf(MSG_ERROR, "Could not allocate memory for test " 1138 "driver data"); 1139 return NULL; 1140 } 1141 1142 bss = os_zalloc(sizeof(struct test_driver_bss)); 1143 if (bss == NULL) { 1144 os_free(drv); 1145 return NULL; 1146 } 1147 1148 drv->ctx = ctx; 1149 wpa_trace_add_ref(drv, ctx, ctx); 1150 dl_list_init(&drv->bss); 1151 dl_list_add(&drv->bss, &bss->list); 1152 os_strlcpy(bss->ifname, ifname, IFNAMSIZ); 1153 bss->bss_ctx = ctx; 1154 bss->drv = drv; 1155 1156 /* Generate a MAC address to help testing with multiple STAs */ 1157 drv->own_addr[0] = 0x02; /* locally administered */ 1158 sha1_prf((const u8 *) ifname, os_strlen(ifname), 1159 "test mac addr generation", 1160 NULL, 0, drv->own_addr + 1, ETH_ALEN - 1); 1161 1162 return drv; 1163} 1164 1165 1166static void * test_driver_init(struct hostapd_data *hapd, 1167 struct wpa_init_params *params) 1168{ 1169 struct wpa_driver_test_data *drv; 1170 struct sockaddr_un addr_un; 1171 struct sockaddr_in addr_in; 1172 struct sockaddr *addr; 1173 socklen_t alen; 1174 struct test_driver_bss *bss; 1175 1176 drv = test_alloc_data(hapd, params->ifname); 1177 if (drv == NULL) 1178 return NULL; 1179 drv->ap = 1; 1180 bss = dl_list_first(&drv->bss, struct test_driver_bss, list); 1181 1182 bss->bss_ctx = hapd; 1183 os_memcpy(bss->bssid, drv->own_addr, ETH_ALEN); 1184 os_memcpy(params->own_addr, drv->own_addr, ETH_ALEN); 1185 1186 if (params->test_socket) { 1187 if (os_strlen(params->test_socket) >= 1188 sizeof(addr_un.sun_path)) { 1189 printf("Too long test_socket path\n"); 1190 wpa_driver_test_deinit(bss); 1191 return NULL; 1192 } 1193 if (strncmp(params->test_socket, "DIR:", 4) == 0) { 1194 size_t len = strlen(params->test_socket) + 30; 1195 drv->test_dir = os_strdup(params->test_socket + 4); 1196 drv->own_socket_path = os_malloc(len); 1197 if (drv->own_socket_path) { 1198 snprintf(drv->own_socket_path, len, 1199 "%s/AP-" MACSTR, 1200 params->test_socket + 4, 1201 MAC2STR(params->own_addr)); 1202 } 1203 } else if (strncmp(params->test_socket, "UDP:", 4) == 0) { 1204 drv->udp_port = atoi(params->test_socket + 4); 1205 } else { 1206 drv->own_socket_path = os_strdup(params->test_socket); 1207 } 1208 if (drv->own_socket_path == NULL && drv->udp_port == 0) { 1209 wpa_driver_test_deinit(bss); 1210 return NULL; 1211 } 1212 1213 drv->test_socket = socket(drv->udp_port ? PF_INET : PF_UNIX, 1214 SOCK_DGRAM, 0); 1215 if (drv->test_socket < 0) { 1216 perror("socket"); 1217 wpa_driver_test_deinit(bss); 1218 return NULL; 1219 } 1220 1221 if (drv->udp_port) { 1222 os_memset(&addr_in, 0, sizeof(addr_in)); 1223 addr_in.sin_family = AF_INET; 1224 addr_in.sin_port = htons(drv->udp_port); 1225 addr = (struct sockaddr *) &addr_in; 1226 alen = sizeof(addr_in); 1227 } else { 1228 os_memset(&addr_un, 0, sizeof(addr_un)); 1229 addr_un.sun_family = AF_UNIX; 1230 os_strlcpy(addr_un.sun_path, drv->own_socket_path, 1231 sizeof(addr_un.sun_path)); 1232 addr = (struct sockaddr *) &addr_un; 1233 alen = sizeof(addr_un); 1234 } 1235 if (bind(drv->test_socket, addr, alen) < 0) { 1236 perror("bind(PF_UNIX)"); 1237 close(drv->test_socket); 1238 if (drv->own_socket_path) 1239 unlink(drv->own_socket_path); 1240 wpa_driver_test_deinit(bss); 1241 return NULL; 1242 } 1243 eloop_register_read_sock(drv->test_socket, 1244 test_driver_receive_unix, drv, NULL); 1245 } else 1246 drv->test_socket = -1; 1247 1248 return bss; 1249} 1250 1251 1252static void wpa_driver_test_poll(void *eloop_ctx, void *timeout_ctx) 1253{ 1254 struct wpa_driver_test_data *drv = eloop_ctx; 1255 1256#ifdef DRIVER_TEST_UNIX 1257 if (drv->associated && drv->hostapd_addr_set) { 1258 struct stat st; 1259 if (stat(drv->hostapd_addr.sun_path, &st) < 0) { 1260 wpa_printf(MSG_DEBUG, "%s: lost connection to AP: %s", 1261 __func__, strerror(errno)); 1262 drv->associated = 0; 1263 wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL); 1264 } 1265 } 1266#endif /* DRIVER_TEST_UNIX */ 1267 1268 eloop_register_timeout(1, 0, wpa_driver_test_poll, drv, NULL); 1269} 1270 1271 1272static void wpa_driver_test_scan_timeout(void *eloop_ctx, void *timeout_ctx) 1273{ 1274 wpa_printf(MSG_DEBUG, "Scan timeout - try to get results"); 1275 wpa_supplicant_event(timeout_ctx, EVENT_SCAN_RESULTS, NULL); 1276} 1277 1278 1279#ifdef DRIVER_TEST_UNIX 1280static void wpa_driver_scan_dir(struct wpa_driver_test_data *drv, 1281 const char *path) 1282{ 1283 struct dirent *dent; 1284 DIR *dir; 1285 struct sockaddr_un addr; 1286 char cmd[512], *pos, *end; 1287 int ret; 1288 1289 dir = opendir(path); 1290 if (dir == NULL) 1291 return; 1292 1293 end = cmd + sizeof(cmd); 1294 pos = cmd; 1295 ret = os_snprintf(pos, end - pos, "SCAN " MACSTR, 1296 MAC2STR(drv->own_addr)); 1297 if (ret >= 0 && ret < end - pos) 1298 pos += ret; 1299 if (drv->probe_req_ie) { 1300 ret = os_snprintf(pos, end - pos, " "); 1301 if (ret >= 0 && ret < end - pos) 1302 pos += ret; 1303 pos += wpa_snprintf_hex(pos, end - pos, drv->probe_req_ie, 1304 drv->probe_req_ie_len); 1305 } 1306 if (drv->probe_req_ssid_len) { 1307 /* Add SSID IE */ 1308 ret = os_snprintf(pos, end - pos, "%02x%02x", 1309 WLAN_EID_SSID, 1310 (unsigned int) drv->probe_req_ssid_len); 1311 if (ret >= 0 && ret < end - pos) 1312 pos += ret; 1313 pos += wpa_snprintf_hex(pos, end - pos, drv->probe_req_ssid, 1314 drv->probe_req_ssid_len); 1315 } 1316 end[-1] = '\0'; 1317 1318 while ((dent = readdir(dir))) { 1319 if (os_strncmp(dent->d_name, "AP-", 3) != 0 && 1320 os_strncmp(dent->d_name, "STA-", 4) != 0) 1321 continue; 1322 if (drv->own_socket_path) { 1323 size_t olen, dlen; 1324 olen = os_strlen(drv->own_socket_path); 1325 dlen = os_strlen(dent->d_name); 1326 if (olen >= dlen && 1327 os_strcmp(dent->d_name, 1328 drv->own_socket_path + olen - dlen) == 0) 1329 continue; 1330 } 1331 wpa_printf(MSG_DEBUG, "%s: SCAN %s", __func__, dent->d_name); 1332 1333 os_memset(&addr, 0, sizeof(addr)); 1334 addr.sun_family = AF_UNIX; 1335 os_snprintf(addr.sun_path, sizeof(addr.sun_path), "%s/%s", 1336 path, dent->d_name); 1337 1338 if (sendto(drv->test_socket, cmd, os_strlen(cmd), 0, 1339 (struct sockaddr *) &addr, sizeof(addr)) < 0) { 1340 perror("sendto(test_socket)"); 1341 } 1342 } 1343 closedir(dir); 1344} 1345#endif /* DRIVER_TEST_UNIX */ 1346 1347 1348static int wpa_driver_test_scan(void *priv, 1349 struct wpa_driver_scan_params *params) 1350{ 1351 struct test_driver_bss *dbss = priv; 1352 struct wpa_driver_test_data *drv = dbss->drv; 1353 size_t i; 1354 1355 wpa_printf(MSG_DEBUG, "%s: priv=%p", __func__, priv); 1356 1357 os_free(drv->probe_req_ie); 1358 if (params->extra_ies) { 1359 drv->probe_req_ie = os_malloc(params->extra_ies_len); 1360 if (drv->probe_req_ie == NULL) { 1361 drv->probe_req_ie_len = 0; 1362 return -1; 1363 } 1364 os_memcpy(drv->probe_req_ie, params->extra_ies, 1365 params->extra_ies_len); 1366 drv->probe_req_ie_len = params->extra_ies_len; 1367 } else { 1368 drv->probe_req_ie = NULL; 1369 drv->probe_req_ie_len = 0; 1370 } 1371 1372 for (i = 0; i < params->num_ssids; i++) 1373 wpa_hexdump(MSG_DEBUG, "Scan SSID", 1374 params->ssids[i].ssid, params->ssids[i].ssid_len); 1375 drv->probe_req_ssid_len = 0; 1376 if (params->num_ssids) { 1377 os_memcpy(drv->probe_req_ssid, params->ssids[0].ssid, 1378 params->ssids[0].ssid_len); 1379 drv->probe_req_ssid_len = params->ssids[0].ssid_len; 1380 } 1381 wpa_hexdump(MSG_DEBUG, "Scan extra IE(s)", 1382 params->extra_ies, params->extra_ies_len); 1383 1384 drv->num_scanres = 0; 1385 1386#ifdef DRIVER_TEST_UNIX 1387 if (drv->test_socket >= 0 && drv->test_dir) 1388 wpa_driver_scan_dir(drv, drv->test_dir); 1389 1390 if (drv->test_socket >= 0 && drv->hostapd_addr_set && 1391 sendto(drv->test_socket, "SCAN", 4, 0, 1392 (struct sockaddr *) &drv->hostapd_addr, 1393 sizeof(drv->hostapd_addr)) < 0) { 1394 perror("sendto(test_socket)"); 1395 } 1396#endif /* DRIVER_TEST_UNIX */ 1397 1398 if (drv->test_socket >= 0 && drv->hostapd_addr_udp_set && 1399 sendto(drv->test_socket, "SCAN", 4, 0, 1400 (struct sockaddr *) &drv->hostapd_addr_udp, 1401 sizeof(drv->hostapd_addr_udp)) < 0) { 1402 perror("sendto(test_socket)"); 1403 } 1404 1405 eloop_cancel_timeout(wpa_driver_test_scan_timeout, drv, drv->ctx); 1406 eloop_register_timeout(1, 0, wpa_driver_test_scan_timeout, drv, 1407 drv->ctx); 1408 return 0; 1409} 1410 1411 1412static struct wpa_scan_results * wpa_driver_test_get_scan_results2(void *priv) 1413{ 1414 struct test_driver_bss *dbss = priv; 1415 struct wpa_driver_test_data *drv = dbss->drv; 1416 struct wpa_scan_results *res; 1417 size_t i; 1418 1419 res = os_zalloc(sizeof(*res)); 1420 if (res == NULL) 1421 return NULL; 1422 1423 res->res = os_zalloc(drv->num_scanres * sizeof(struct wpa_scan_res *)); 1424 if (res->res == NULL) { 1425 os_free(res); 1426 return NULL; 1427 } 1428 1429 for (i = 0; i < drv->num_scanres; i++) { 1430 struct wpa_scan_res *r; 1431 if (drv->scanres[i] == NULL) 1432 continue; 1433 r = os_malloc(sizeof(*r) + drv->scanres[i]->ie_len); 1434 if (r == NULL) 1435 break; 1436 os_memcpy(r, drv->scanres[i], 1437 sizeof(*r) + drv->scanres[i]->ie_len); 1438 res->res[res->num++] = r; 1439 } 1440 1441 return res; 1442} 1443 1444 1445static int wpa_driver_test_set_key(const char *ifname, void *priv, 1446 enum wpa_alg alg, const u8 *addr, 1447 int key_idx, int set_tx, 1448 const u8 *seq, size_t seq_len, 1449 const u8 *key, size_t key_len) 1450{ 1451 wpa_printf(MSG_DEBUG, "%s: ifname=%s priv=%p alg=%d key_idx=%d " 1452 "set_tx=%d", 1453 __func__, ifname, priv, alg, key_idx, set_tx); 1454 if (addr) 1455 wpa_printf(MSG_DEBUG, " addr=" MACSTR, MAC2STR(addr)); 1456 if (seq) 1457 wpa_hexdump(MSG_DEBUG, " seq", seq, seq_len); 1458 if (key) 1459 wpa_hexdump_key(MSG_DEBUG, " key", key, key_len); 1460 return 0; 1461} 1462 1463 1464static int wpa_driver_update_mode(struct wpa_driver_test_data *drv, int ap) 1465{ 1466 if (ap && !drv->ap) { 1467 wpa_driver_test_close_test_socket(drv); 1468 wpa_driver_test_attach(drv, drv->test_dir, 1); 1469 drv->ap = 1; 1470 } else if (!ap && drv->ap) { 1471 wpa_driver_test_close_test_socket(drv); 1472 wpa_driver_test_attach(drv, drv->test_dir, 0); 1473 drv->ap = 0; 1474 } 1475 1476 return 0; 1477} 1478 1479 1480static int wpa_driver_test_associate( 1481 void *priv, struct wpa_driver_associate_params *params) 1482{ 1483 struct test_driver_bss *dbss = priv; 1484 struct wpa_driver_test_data *drv = dbss->drv; 1485 wpa_printf(MSG_DEBUG, "%s: priv=%p freq=%d pairwise_suite=%d " 1486 "group_suite=%d key_mgmt_suite=%d auth_alg=%d mode=%d", 1487 __func__, priv, params->freq, params->pairwise_suite, 1488 params->group_suite, params->key_mgmt_suite, 1489 params->auth_alg, params->mode); 1490 if (params->bssid) { 1491 wpa_printf(MSG_DEBUG, " bssid=" MACSTR, 1492 MAC2STR(params->bssid)); 1493 } 1494 if (params->ssid) { 1495 wpa_hexdump_ascii(MSG_DEBUG, " ssid", 1496 params->ssid, params->ssid_len); 1497 } 1498 if (params->wpa_ie) { 1499 wpa_hexdump(MSG_DEBUG, " wpa_ie", 1500 params->wpa_ie, params->wpa_ie_len); 1501 drv->assoc_wpa_ie_len = params->wpa_ie_len; 1502 if (drv->assoc_wpa_ie_len > sizeof(drv->assoc_wpa_ie)) 1503 drv->assoc_wpa_ie_len = sizeof(drv->assoc_wpa_ie); 1504 os_memcpy(drv->assoc_wpa_ie, params->wpa_ie, 1505 drv->assoc_wpa_ie_len); 1506 } else 1507 drv->assoc_wpa_ie_len = 0; 1508 1509 wpa_driver_update_mode(drv, params->mode == IEEE80211_MODE_AP); 1510 1511 drv->ibss = params->mode == IEEE80211_MODE_IBSS; 1512 dbss->privacy = params->key_mgmt_suite & 1513 (WPA_KEY_MGMT_IEEE8021X | 1514 WPA_KEY_MGMT_PSK | 1515 WPA_KEY_MGMT_WPA_NONE | 1516 WPA_KEY_MGMT_FT_IEEE8021X | 1517 WPA_KEY_MGMT_FT_PSK | 1518 WPA_KEY_MGMT_IEEE8021X_SHA256 | 1519 WPA_KEY_MGMT_PSK_SHA256); 1520 if (params->wep_key_len[params->wep_tx_keyidx]) 1521 dbss->privacy = 1; 1522 1523#ifdef DRIVER_TEST_UNIX 1524 if (drv->test_dir && params->bssid && 1525 params->mode != IEEE80211_MODE_IBSS) { 1526 os_memset(&drv->hostapd_addr, 0, sizeof(drv->hostapd_addr)); 1527 drv->hostapd_addr.sun_family = AF_UNIX; 1528 os_snprintf(drv->hostapd_addr.sun_path, 1529 sizeof(drv->hostapd_addr.sun_path), 1530 "%s/AP-" MACSTR, 1531 drv->test_dir, MAC2STR(params->bssid)); 1532 drv->hostapd_addr_set = 1; 1533 } 1534#endif /* DRIVER_TEST_UNIX */ 1535 1536 if (params->mode == IEEE80211_MODE_AP) { 1537 os_memcpy(dbss->ssid, params->ssid, params->ssid_len); 1538 dbss->ssid_len = params->ssid_len; 1539 os_memcpy(dbss->bssid, drv->own_addr, ETH_ALEN); 1540 if (params->wpa_ie && params->wpa_ie_len) { 1541 dbss->ie = os_malloc(params->wpa_ie_len); 1542 if (dbss->ie) { 1543 os_memcpy(dbss->ie, params->wpa_ie, 1544 params->wpa_ie_len); 1545 dbss->ielen = params->wpa_ie_len; 1546 } 1547 } 1548 } else if (drv->test_socket >= 0 && 1549 (drv->hostapd_addr_set || drv->hostapd_addr_udp_set)) { 1550 char cmd[200], *pos, *end; 1551 int ret; 1552 end = cmd + sizeof(cmd); 1553 pos = cmd; 1554 ret = os_snprintf(pos, end - pos, "ASSOC " MACSTR " ", 1555 MAC2STR(drv->own_addr)); 1556 if (ret >= 0 && ret < end - pos) 1557 pos += ret; 1558 pos += wpa_snprintf_hex(pos, end - pos, params->ssid, 1559 params->ssid_len); 1560 ret = os_snprintf(pos, end - pos, " "); 1561 if (ret >= 0 && ret < end - pos) 1562 pos += ret; 1563 pos += wpa_snprintf_hex(pos, end - pos, params->wpa_ie, 1564 params->wpa_ie_len); 1565 end[-1] = '\0'; 1566#ifdef DRIVER_TEST_UNIX 1567 if (drv->hostapd_addr_set && 1568 sendto(drv->test_socket, cmd, os_strlen(cmd), 0, 1569 (struct sockaddr *) &drv->hostapd_addr, 1570 sizeof(drv->hostapd_addr)) < 0) { 1571 perror("sendto(test_socket)"); 1572 return -1; 1573 } 1574#endif /* DRIVER_TEST_UNIX */ 1575 if (drv->hostapd_addr_udp_set && 1576 sendto(drv->test_socket, cmd, os_strlen(cmd), 0, 1577 (struct sockaddr *) &drv->hostapd_addr_udp, 1578 sizeof(drv->hostapd_addr_udp)) < 0) { 1579 perror("sendto(test_socket)"); 1580 return -1; 1581 } 1582 1583 os_memcpy(dbss->ssid, params->ssid, params->ssid_len); 1584 dbss->ssid_len = params->ssid_len; 1585 } else { 1586 drv->associated = 1; 1587 if (params->mode == IEEE80211_MODE_IBSS) { 1588 os_memcpy(dbss->ssid, params->ssid, params->ssid_len); 1589 dbss->ssid_len = params->ssid_len; 1590 if (params->bssid) 1591 os_memcpy(dbss->bssid, params->bssid, 1592 ETH_ALEN); 1593 else { 1594 os_get_random(dbss->bssid, ETH_ALEN); 1595 dbss->bssid[0] &= ~0x01; 1596 dbss->bssid[0] |= 0x02; 1597 } 1598 } 1599 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, NULL); 1600 } 1601 1602 return 0; 1603} 1604 1605 1606static int wpa_driver_test_get_bssid(void *priv, u8 *bssid) 1607{ 1608 struct test_driver_bss *dbss = priv; 1609 os_memcpy(bssid, dbss->bssid, ETH_ALEN); 1610 return 0; 1611} 1612 1613 1614static int wpa_driver_test_get_ssid(void *priv, u8 *ssid) 1615{ 1616 struct test_driver_bss *dbss = priv; 1617 os_memcpy(ssid, dbss->ssid, 32); 1618 return dbss->ssid_len; 1619} 1620 1621 1622static int wpa_driver_test_send_disassoc(struct wpa_driver_test_data *drv) 1623{ 1624#ifdef DRIVER_TEST_UNIX 1625 if (drv->test_socket >= 0 && 1626 sendto(drv->test_socket, "DISASSOC", 8, 0, 1627 (struct sockaddr *) &drv->hostapd_addr, 1628 sizeof(drv->hostapd_addr)) < 0) { 1629 perror("sendto(test_socket)"); 1630 return -1; 1631 } 1632#endif /* DRIVER_TEST_UNIX */ 1633 if (drv->test_socket >= 0 && drv->hostapd_addr_udp_set && 1634 sendto(drv->test_socket, "DISASSOC", 8, 0, 1635 (struct sockaddr *) &drv->hostapd_addr_udp, 1636 sizeof(drv->hostapd_addr_udp)) < 0) { 1637 perror("sendto(test_socket)"); 1638 return -1; 1639 } 1640 return 0; 1641} 1642 1643 1644static int wpa_driver_test_deauthenticate(void *priv, const u8 *addr, 1645 int reason_code) 1646{ 1647 struct test_driver_bss *dbss = priv; 1648 struct wpa_driver_test_data *drv = dbss->drv; 1649 wpa_printf(MSG_DEBUG, "%s addr=" MACSTR " reason_code=%d", 1650 __func__, MAC2STR(addr), reason_code); 1651 os_memset(dbss->bssid, 0, ETH_ALEN); 1652 drv->associated = 0; 1653 wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL); 1654 return wpa_driver_test_send_disassoc(drv); 1655} 1656 1657 1658static int wpa_driver_test_disassociate(void *priv, const u8 *addr, 1659 int reason_code) 1660{ 1661 struct test_driver_bss *dbss = priv; 1662 struct wpa_driver_test_data *drv = dbss->drv; 1663 wpa_printf(MSG_DEBUG, "%s addr=" MACSTR " reason_code=%d", 1664 __func__, MAC2STR(addr), reason_code); 1665 os_memset(dbss->bssid, 0, ETH_ALEN); 1666 drv->associated = 0; 1667 wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL); 1668 return wpa_driver_test_send_disassoc(drv); 1669} 1670 1671 1672static const u8 * wpa_scan_get_ie(const struct wpa_scan_res *res, u8 ie) 1673{ 1674 const u8 *end, *pos; 1675 1676 pos = (const u8 *) (res + 1); 1677 end = pos + res->ie_len; 1678 1679 while (pos + 1 < end) { 1680 if (pos + 2 + pos[1] > end) 1681 break; 1682 if (pos[0] == ie) 1683 return pos; 1684 pos += 2 + pos[1]; 1685 } 1686 1687 return NULL; 1688} 1689 1690 1691static void wpa_driver_test_scanresp(struct wpa_driver_test_data *drv, 1692 struct sockaddr *from, 1693 socklen_t fromlen, 1694 const char *data) 1695{ 1696 struct wpa_scan_res *res; 1697 const char *pos, *pos2; 1698 size_t len; 1699 u8 *ie_pos, *ie_start, *ie_end; 1700#define MAX_IE_LEN 1000 1701 const u8 *ds_params; 1702 1703 wpa_printf(MSG_DEBUG, "test_driver: SCANRESP %s", data); 1704 if (drv->num_scanres >= MAX_SCAN_RESULTS) { 1705 wpa_printf(MSG_DEBUG, "test_driver: No room for the new scan " 1706 "result"); 1707 return; 1708 } 1709 1710 /* SCANRESP BSSID SSID IEs */ 1711 1712 res = os_zalloc(sizeof(*res) + MAX_IE_LEN); 1713 if (res == NULL) 1714 return; 1715 ie_start = ie_pos = (u8 *) (res + 1); 1716 ie_end = ie_pos + MAX_IE_LEN; 1717 1718 if (hwaddr_aton(data, res->bssid)) { 1719 wpa_printf(MSG_DEBUG, "test_driver: invalid BSSID in scanres"); 1720 os_free(res); 1721 return; 1722 } 1723 1724 pos = data + 17; 1725 while (*pos == ' ') 1726 pos++; 1727 pos2 = os_strchr(pos, ' '); 1728 if (pos2 == NULL) { 1729 wpa_printf(MSG_DEBUG, "test_driver: invalid SSID termination " 1730 "in scanres"); 1731 os_free(res); 1732 return; 1733 } 1734 len = (pos2 - pos) / 2; 1735 if (len > 32) 1736 len = 32; 1737 /* 1738 * Generate SSID IE from the SSID field since this IE is not included 1739 * in the main IE field. 1740 */ 1741 *ie_pos++ = WLAN_EID_SSID; 1742 *ie_pos++ = len; 1743 if (hexstr2bin(pos, ie_pos, len) < 0) { 1744 wpa_printf(MSG_DEBUG, "test_driver: invalid SSID in scanres"); 1745 os_free(res); 1746 return; 1747 } 1748 ie_pos += len; 1749 1750 pos = pos2 + 1; 1751 pos2 = os_strchr(pos, ' '); 1752 if (pos2 == NULL) 1753 len = os_strlen(pos) / 2; 1754 else 1755 len = (pos2 - pos) / 2; 1756 if ((int) len > ie_end - ie_pos) 1757 len = ie_end - ie_pos; 1758 if (hexstr2bin(pos, ie_pos, len) < 0) { 1759 wpa_printf(MSG_DEBUG, "test_driver: invalid IEs in scanres"); 1760 os_free(res); 1761 return; 1762 } 1763 ie_pos += len; 1764 res->ie_len = ie_pos - ie_start; 1765 1766 if (pos2) { 1767 pos = pos2 + 1; 1768 while (*pos == ' ') 1769 pos++; 1770 if (os_strstr(pos, "PRIVACY")) 1771 res->caps |= IEEE80211_CAP_PRIVACY; 1772 if (os_strstr(pos, "IBSS")) 1773 res->caps |= IEEE80211_CAP_IBSS; 1774 } 1775 1776 ds_params = wpa_scan_get_ie(res, WLAN_EID_DS_PARAMS); 1777 if (ds_params && ds_params[1] > 0) { 1778 if (ds_params[2] >= 1 && ds_params[2] <= 13) 1779 res->freq = 2407 + ds_params[2] * 5; 1780 } 1781 1782 os_free(drv->scanres[drv->num_scanres]); 1783 drv->scanres[drv->num_scanres++] = res; 1784} 1785 1786 1787static void wpa_driver_test_assocresp(struct wpa_driver_test_data *drv, 1788 struct sockaddr *from, 1789 socklen_t fromlen, 1790 const char *data) 1791{ 1792 struct test_driver_bss *bss; 1793 1794 bss = dl_list_first(&drv->bss, struct test_driver_bss, list); 1795 1796 /* ASSOCRESP BSSID <res> */ 1797 if (hwaddr_aton(data, bss->bssid)) { 1798 wpa_printf(MSG_DEBUG, "test_driver: invalid BSSID in " 1799 "assocresp"); 1800 } 1801 if (drv->use_associnfo) { 1802 union wpa_event_data event; 1803 os_memset(&event, 0, sizeof(event)); 1804 event.assoc_info.req_ies = drv->assoc_wpa_ie; 1805 event.assoc_info.req_ies_len = drv->assoc_wpa_ie_len; 1806 wpa_supplicant_event(drv->ctx, EVENT_ASSOCINFO, &event); 1807 } 1808 drv->associated = 1; 1809 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, NULL); 1810} 1811 1812 1813static void wpa_driver_test_disassoc(struct wpa_driver_test_data *drv, 1814 struct sockaddr *from, 1815 socklen_t fromlen) 1816{ 1817 drv->associated = 0; 1818 wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL); 1819} 1820 1821 1822static void wpa_driver_test_eapol(struct wpa_driver_test_data *drv, 1823 struct sockaddr *from, 1824 socklen_t fromlen, 1825 const u8 *data, size_t data_len) 1826{ 1827 const u8 *src; 1828 struct test_driver_bss *bss; 1829 1830 bss = dl_list_first(&drv->bss, struct test_driver_bss, list); 1831 1832 if (data_len > 14) { 1833 /* Skip Ethernet header */ 1834 src = data + ETH_ALEN; 1835 data += 14; 1836 data_len -= 14; 1837 } else 1838 src = bss->bssid; 1839 1840 drv_event_eapol_rx(drv->ctx, src, data, data_len); 1841} 1842 1843 1844static void wpa_driver_test_mlme(struct wpa_driver_test_data *drv, 1845 struct sockaddr *from, 1846 socklen_t fromlen, 1847 const u8 *data, size_t data_len) 1848{ 1849 int freq = 0, own_freq; 1850 union wpa_event_data event; 1851 struct test_driver_bss *bss; 1852 1853 bss = dl_list_first(&drv->bss, struct test_driver_bss, list); 1854 if (data_len > 6 && os_memcmp(data, "freq=", 5) == 0) { 1855 size_t pos; 1856 for (pos = 5; pos < data_len; pos++) { 1857 if (data[pos] == ' ') 1858 break; 1859 } 1860 if (pos < data_len) { 1861 freq = atoi((const char *) &data[5]); 1862 wpa_printf(MSG_DEBUG, "test_driver(%s): MLME RX on " 1863 "freq %d MHz", bss->ifname, freq); 1864 pos++; 1865 data += pos; 1866 data_len -= pos; 1867 } 1868 } 1869 1870 if (drv->remain_on_channel_freq) 1871 own_freq = drv->remain_on_channel_freq; 1872 else 1873 own_freq = drv->current_freq; 1874 1875 if (freq && own_freq && freq != own_freq) { 1876 wpa_printf(MSG_DEBUG, "test_driver(%s): Ignore MLME RX on " 1877 "another frequency %d MHz (own %d MHz)", 1878 bss->ifname, freq, own_freq); 1879 return; 1880 } 1881 1882 os_memset(&event, 0, sizeof(event)); 1883 event.mlme_rx.buf = data; 1884 event.mlme_rx.len = data_len; 1885 event.mlme_rx.freq = freq; 1886 wpa_supplicant_event(drv->ctx, EVENT_MLME_RX, &event); 1887 1888 if (drv->probe_req_report && data_len >= 24) { 1889 const struct ieee80211_mgmt *mgmt; 1890 u16 fc; 1891 1892 mgmt = (const struct ieee80211_mgmt *) data; 1893 fc = le_to_host16(mgmt->frame_control); 1894 if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT && 1895 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_PROBE_REQ) { 1896 os_memset(&event, 0, sizeof(event)); 1897 event.rx_probe_req.sa = mgmt->sa; 1898 event.rx_probe_req.ie = mgmt->u.probe_req.variable; 1899 event.rx_probe_req.ie_len = 1900 data_len - (mgmt->u.probe_req.variable - data); 1901 wpa_supplicant_event(drv->ctx, EVENT_RX_PROBE_REQ, 1902 &event); 1903 } 1904 } 1905} 1906 1907 1908static void wpa_driver_test_scan_cmd(struct wpa_driver_test_data *drv, 1909 struct sockaddr *from, 1910 socklen_t fromlen, 1911 const u8 *data, size_t data_len) 1912{ 1913 char buf[512], *pos, *end; 1914 int ret; 1915 struct test_driver_bss *bss; 1916 1917 bss = dl_list_first(&drv->bss, struct test_driver_bss, list); 1918 1919 /* data: optional [ STA-addr | ' ' | IEs(hex) ] */ 1920 1921 if (!drv->ibss) 1922 return; 1923 1924 pos = buf; 1925 end = buf + sizeof(buf); 1926 1927 /* reply: SCANRESP BSSID SSID IEs */ 1928 ret = snprintf(pos, end - pos, "SCANRESP " MACSTR " ", 1929 MAC2STR(bss->bssid)); 1930 if (ret < 0 || ret >= end - pos) 1931 return; 1932 pos += ret; 1933 pos += wpa_snprintf_hex(pos, end - pos, 1934 bss->ssid, bss->ssid_len); 1935 ret = snprintf(pos, end - pos, " "); 1936 if (ret < 0 || ret >= end - pos) 1937 return; 1938 pos += ret; 1939 pos += wpa_snprintf_hex(pos, end - pos, drv->assoc_wpa_ie, 1940 drv->assoc_wpa_ie_len); 1941 1942 if (bss->privacy) { 1943 ret = snprintf(pos, end - pos, " PRIVACY"); 1944 if (ret < 0 || ret >= end - pos) 1945 return; 1946 pos += ret; 1947 } 1948 1949 ret = snprintf(pos, end - pos, " IBSS"); 1950 if (ret < 0 || ret >= end - pos) 1951 return; 1952 pos += ret; 1953 1954 sendto(drv->test_socket, buf, pos - buf, 0, 1955 (struct sockaddr *) from, fromlen); 1956} 1957 1958 1959static void wpa_driver_test_receive_unix(int sock, void *eloop_ctx, 1960 void *sock_ctx) 1961{ 1962 struct wpa_driver_test_data *drv = eloop_ctx; 1963 char *buf; 1964 int res; 1965 struct sockaddr_storage from; 1966 socklen_t fromlen = sizeof(from); 1967 const size_t buflen = 2000; 1968 1969 if (drv->ap) { 1970 test_driver_receive_unix(sock, eloop_ctx, sock_ctx); 1971 return; 1972 } 1973 1974 buf = os_malloc(buflen); 1975 if (buf == NULL) 1976 return; 1977 res = recvfrom(sock, buf, buflen - 1, 0, 1978 (struct sockaddr *) &from, &fromlen); 1979 if (res < 0) { 1980 perror("recvfrom(test_socket)"); 1981 os_free(buf); 1982 return; 1983 } 1984 buf[res] = '\0'; 1985 1986 wpa_printf(MSG_DEBUG, "test_driver: received %u bytes", res); 1987 1988 if (os_strncmp(buf, "SCANRESP ", 9) == 0) { 1989 wpa_driver_test_scanresp(drv, (struct sockaddr *) &from, 1990 fromlen, buf + 9); 1991 } else if (os_strncmp(buf, "ASSOCRESP ", 10) == 0) { 1992 wpa_driver_test_assocresp(drv, (struct sockaddr *) &from, 1993 fromlen, buf + 10); 1994 } else if (os_strcmp(buf, "DISASSOC") == 0) { 1995 wpa_driver_test_disassoc(drv, (struct sockaddr *) &from, 1996 fromlen); 1997 } else if (os_strcmp(buf, "DEAUTH") == 0) { 1998 wpa_driver_test_disassoc(drv, (struct sockaddr *) &from, 1999 fromlen); 2000 } else if (os_strncmp(buf, "EAPOL ", 6) == 0) { 2001 wpa_driver_test_eapol(drv, (struct sockaddr *) &from, fromlen, 2002 (const u8 *) buf + 6, res - 6); 2003 } else if (os_strncmp(buf, "MLME ", 5) == 0) { 2004 wpa_driver_test_mlme(drv, (struct sockaddr *) &from, fromlen, 2005 (const u8 *) buf + 5, res - 5); 2006 } else if (os_strncmp(buf, "SCAN ", 5) == 0) { 2007 wpa_driver_test_scan_cmd(drv, (struct sockaddr *) &from, 2008 fromlen, 2009 (const u8 *) buf + 5, res - 5); 2010 } else { 2011 wpa_hexdump_ascii(MSG_DEBUG, "Unknown test_socket command", 2012 (u8 *) buf, res); 2013 } 2014 os_free(buf); 2015} 2016 2017 2018static void * wpa_driver_test_init2(void *ctx, const char *ifname, 2019 void *global_priv) 2020{ 2021 struct wpa_driver_test_data *drv; 2022 struct wpa_driver_test_global *global = global_priv; 2023 struct test_driver_bss *bss; 2024 2025 drv = test_alloc_data(ctx, ifname); 2026 if (drv == NULL) 2027 return NULL; 2028 bss = dl_list_first(&drv->bss, struct test_driver_bss, list); 2029 drv->global = global_priv; 2030 drv->test_socket = -1; 2031 2032 /* Set dummy BSSID and SSID for testing. */ 2033 bss->bssid[0] = 0x02; 2034 bss->bssid[1] = 0x00; 2035 bss->bssid[2] = 0x00; 2036 bss->bssid[3] = 0x00; 2037 bss->bssid[4] = 0x00; 2038 bss->bssid[5] = 0x01; 2039 os_memcpy(bss->ssid, "test", 5); 2040 bss->ssid_len = 4; 2041 2042 if (global->bss_add_used) { 2043 os_memcpy(drv->own_addr, global->req_addr, ETH_ALEN); 2044 global->bss_add_used = 0; 2045 } 2046 2047 eloop_register_timeout(1, 0, wpa_driver_test_poll, drv, NULL); 2048 2049 return bss; 2050} 2051 2052 2053static void wpa_driver_test_close_test_socket(struct wpa_driver_test_data *drv) 2054{ 2055 if (drv->test_socket >= 0) { 2056 eloop_unregister_read_sock(drv->test_socket); 2057 close(drv->test_socket); 2058 drv->test_socket = -1; 2059 } 2060 2061 if (drv->own_socket_path) { 2062 unlink(drv->own_socket_path); 2063 os_free(drv->own_socket_path); 2064 drv->own_socket_path = NULL; 2065 } 2066} 2067 2068 2069static void wpa_driver_test_deinit(void *priv) 2070{ 2071 struct test_driver_bss *dbss = priv; 2072 struct wpa_driver_test_data *drv = dbss->drv; 2073 struct test_client_socket *cli, *prev; 2074 int i; 2075 2076 cli = drv->cli; 2077 while (cli) { 2078 prev = cli; 2079 cli = cli->next; 2080 os_free(prev); 2081 } 2082 2083#ifdef HOSTAPD 2084 /* There should be only one BSS remaining at this point. */ 2085 if (dl_list_len(&drv->bss) != 1) 2086 wpa_printf(MSG_ERROR, "%s: %u remaining BSS entries", 2087 __func__, dl_list_len(&drv->bss)); 2088#endif /* HOSTAPD */ 2089 2090 test_driver_free_bsses(drv); 2091 2092 wpa_driver_test_close_test_socket(drv); 2093 eloop_cancel_timeout(wpa_driver_test_scan_timeout, drv, drv->ctx); 2094 eloop_cancel_timeout(wpa_driver_test_poll, drv, NULL); 2095 eloop_cancel_timeout(test_remain_on_channel_timeout, drv, NULL); 2096 os_free(drv->test_dir); 2097 for (i = 0; i < MAX_SCAN_RESULTS; i++) 2098 os_free(drv->scanres[i]); 2099 os_free(drv->probe_req_ie); 2100 wpa_trace_remove_ref(drv, ctx, drv->ctx); 2101 os_free(drv); 2102} 2103 2104 2105static int wpa_driver_test_attach(struct wpa_driver_test_data *drv, 2106 const char *dir, int ap) 2107{ 2108#ifdef DRIVER_TEST_UNIX 2109 static unsigned int counter = 0; 2110 struct sockaddr_un addr; 2111 size_t len; 2112 2113 os_free(drv->own_socket_path); 2114 if (dir) { 2115 len = os_strlen(dir) + 30; 2116 drv->own_socket_path = os_malloc(len); 2117 if (drv->own_socket_path == NULL) 2118 return -1; 2119 os_snprintf(drv->own_socket_path, len, "%s/%s-" MACSTR, 2120 dir, ap ? "AP" : "STA", MAC2STR(drv->own_addr)); 2121 } else { 2122 drv->own_socket_path = os_malloc(100); 2123 if (drv->own_socket_path == NULL) 2124 return -1; 2125 os_snprintf(drv->own_socket_path, 100, 2126 "/tmp/wpa_supplicant_test-%d-%d", 2127 getpid(), counter++); 2128 } 2129 2130 drv->test_socket = socket(PF_UNIX, SOCK_DGRAM, 0); 2131 if (drv->test_socket < 0) { 2132 perror("socket(PF_UNIX)"); 2133 os_free(drv->own_socket_path); 2134 drv->own_socket_path = NULL; 2135 return -1; 2136 } 2137 2138 os_memset(&addr, 0, sizeof(addr)); 2139 addr.sun_family = AF_UNIX; 2140 os_strlcpy(addr.sun_path, drv->own_socket_path, sizeof(addr.sun_path)); 2141 if (bind(drv->test_socket, (struct sockaddr *) &addr, 2142 sizeof(addr)) < 0) { 2143 perror("bind(PF_UNIX)"); 2144 close(drv->test_socket); 2145 unlink(drv->own_socket_path); 2146 os_free(drv->own_socket_path); 2147 drv->own_socket_path = NULL; 2148 return -1; 2149 } 2150 2151 eloop_register_read_sock(drv->test_socket, 2152 wpa_driver_test_receive_unix, drv, NULL); 2153 2154 return 0; 2155#else /* DRIVER_TEST_UNIX */ 2156 return -1; 2157#endif /* DRIVER_TEST_UNIX */ 2158} 2159 2160 2161static int wpa_driver_test_attach_udp(struct wpa_driver_test_data *drv, 2162 char *dst) 2163{ 2164 char *pos; 2165 2166 pos = os_strchr(dst, ':'); 2167 if (pos == NULL) 2168 return -1; 2169 *pos++ = '\0'; 2170 wpa_printf(MSG_DEBUG, "%s: addr=%s port=%s", __func__, dst, pos); 2171 2172 drv->test_socket = socket(PF_INET, SOCK_DGRAM, 0); 2173 if (drv->test_socket < 0) { 2174 perror("socket(PF_INET)"); 2175 return -1; 2176 } 2177 2178 os_memset(&drv->hostapd_addr_udp, 0, sizeof(drv->hostapd_addr_udp)); 2179 drv->hostapd_addr_udp.sin_family = AF_INET; 2180#if defined(CONFIG_NATIVE_WINDOWS) || defined(CONFIG_ANSI_C_EXTRA) 2181 { 2182 int a[4]; 2183 u8 *pos; 2184 sscanf(dst, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]); 2185 pos = (u8 *) &drv->hostapd_addr_udp.sin_addr; 2186 *pos++ = a[0]; 2187 *pos++ = a[1]; 2188 *pos++ = a[2]; 2189 *pos++ = a[3]; 2190 } 2191#else /* CONFIG_NATIVE_WINDOWS or CONFIG_ANSI_C_EXTRA */ 2192 inet_aton(dst, &drv->hostapd_addr_udp.sin_addr); 2193#endif /* CONFIG_NATIVE_WINDOWS or CONFIG_ANSI_C_EXTRA */ 2194 drv->hostapd_addr_udp.sin_port = htons(atoi(pos)); 2195 2196 drv->hostapd_addr_udp_set = 1; 2197 2198 eloop_register_read_sock(drv->test_socket, 2199 wpa_driver_test_receive_unix, drv, NULL); 2200 2201 return 0; 2202} 2203 2204 2205static int wpa_driver_test_set_param(void *priv, const char *param) 2206{ 2207 struct test_driver_bss *dbss = priv; 2208 struct wpa_driver_test_data *drv = dbss->drv; 2209 const char *pos; 2210 2211 wpa_printf(MSG_DEBUG, "%s: param='%s'", __func__, param); 2212 if (param == NULL) 2213 return 0; 2214 2215 wpa_driver_test_close_test_socket(drv); 2216 2217#ifdef DRIVER_TEST_UNIX 2218 pos = os_strstr(param, "test_socket="); 2219 if (pos) { 2220 const char *pos2; 2221 size_t len; 2222 2223 pos += 12; 2224 pos2 = os_strchr(pos, ' '); 2225 if (pos2) 2226 len = pos2 - pos; 2227 else 2228 len = os_strlen(pos); 2229 if (len > sizeof(drv->hostapd_addr.sun_path)) 2230 return -1; 2231 os_memset(&drv->hostapd_addr, 0, sizeof(drv->hostapd_addr)); 2232 drv->hostapd_addr.sun_family = AF_UNIX; 2233 os_memcpy(drv->hostapd_addr.sun_path, pos, len); 2234 drv->hostapd_addr_set = 1; 2235 } 2236#endif /* DRIVER_TEST_UNIX */ 2237 2238 pos = os_strstr(param, "test_dir="); 2239 if (pos) { 2240 char *end; 2241 os_free(drv->test_dir); 2242 drv->test_dir = os_strdup(pos + 9); 2243 if (drv->test_dir == NULL) 2244 return -1; 2245 end = os_strchr(drv->test_dir, ' '); 2246 if (end) 2247 *end = '\0'; 2248 if (wpa_driver_test_attach(drv, drv->test_dir, 0)) 2249 return -1; 2250 } else { 2251 pos = os_strstr(param, "test_udp="); 2252 if (pos) { 2253 char *dst, *epos; 2254 dst = os_strdup(pos + 9); 2255 if (dst == NULL) 2256 return -1; 2257 epos = os_strchr(dst, ' '); 2258 if (epos) 2259 *epos = '\0'; 2260 if (wpa_driver_test_attach_udp(drv, dst)) 2261 return -1; 2262 os_free(dst); 2263 } else if (wpa_driver_test_attach(drv, NULL, 0)) 2264 return -1; 2265 } 2266 2267 if (os_strstr(param, "use_associnfo=1")) { 2268 wpa_printf(MSG_DEBUG, "test_driver: Use AssocInfo events"); 2269 drv->use_associnfo = 1; 2270 } 2271 2272#ifdef CONFIG_CLIENT_MLME 2273 if (os_strstr(param, "use_mlme=1")) { 2274 wpa_printf(MSG_DEBUG, "test_driver: Use internal MLME"); 2275 drv->use_mlme = 1; 2276 } 2277#endif /* CONFIG_CLIENT_MLME */ 2278 2279 return 0; 2280} 2281 2282 2283static const u8 * wpa_driver_test_get_mac_addr(void *priv) 2284{ 2285 struct test_driver_bss *dbss = priv; 2286 struct wpa_driver_test_data *drv = dbss->drv; 2287 wpa_printf(MSG_DEBUG, "%s", __func__); 2288 return drv->own_addr; 2289} 2290 2291 2292static int wpa_driver_test_send_eapol(void *priv, const u8 *dest, u16 proto, 2293 const u8 *data, size_t data_len) 2294{ 2295 struct test_driver_bss *dbss = priv; 2296 struct wpa_driver_test_data *drv = dbss->drv; 2297 char *msg; 2298 size_t msg_len; 2299 struct l2_ethhdr eth; 2300 struct sockaddr *addr; 2301 socklen_t alen; 2302#ifdef DRIVER_TEST_UNIX 2303 struct sockaddr_un addr_un; 2304#endif /* DRIVER_TEST_UNIX */ 2305 2306 wpa_hexdump(MSG_MSGDUMP, "test_send_eapol TX frame", data, data_len); 2307 2308 os_memset(ð, 0, sizeof(eth)); 2309 os_memcpy(eth.h_dest, dest, ETH_ALEN); 2310 os_memcpy(eth.h_source, drv->own_addr, ETH_ALEN); 2311 eth.h_proto = host_to_be16(proto); 2312 2313 msg_len = 6 + sizeof(eth) + data_len; 2314 msg = os_malloc(msg_len); 2315 if (msg == NULL) 2316 return -1; 2317 os_memcpy(msg, "EAPOL ", 6); 2318 os_memcpy(msg + 6, ð, sizeof(eth)); 2319 os_memcpy(msg + 6 + sizeof(eth), data, data_len); 2320 2321 if (os_memcmp(dest, dbss->bssid, ETH_ALEN) == 0 || 2322 drv->test_dir == NULL) { 2323 if (drv->hostapd_addr_udp_set) { 2324 addr = (struct sockaddr *) &drv->hostapd_addr_udp; 2325 alen = sizeof(drv->hostapd_addr_udp); 2326 } else { 2327#ifdef DRIVER_TEST_UNIX 2328 addr = (struct sockaddr *) &drv->hostapd_addr; 2329 alen = sizeof(drv->hostapd_addr); 2330#else /* DRIVER_TEST_UNIX */ 2331 os_free(msg); 2332 return -1; 2333#endif /* DRIVER_TEST_UNIX */ 2334 } 2335 } else { 2336#ifdef DRIVER_TEST_UNIX 2337 struct stat st; 2338 os_memset(&addr_un, 0, sizeof(addr_un)); 2339 addr_un.sun_family = AF_UNIX; 2340 os_snprintf(addr_un.sun_path, sizeof(addr_un.sun_path), 2341 "%s/STA-" MACSTR, drv->test_dir, MAC2STR(dest)); 2342 if (stat(addr_un.sun_path, &st) < 0) { 2343 os_snprintf(addr_un.sun_path, sizeof(addr_un.sun_path), 2344 "%s/AP-" MACSTR, 2345 drv->test_dir, MAC2STR(dest)); 2346 } 2347 addr = (struct sockaddr *) &addr_un; 2348 alen = sizeof(addr_un); 2349#else /* DRIVER_TEST_UNIX */ 2350 os_free(msg); 2351 return -1; 2352#endif /* DRIVER_TEST_UNIX */ 2353 } 2354 2355 if (sendto(drv->test_socket, msg, msg_len, 0, addr, alen) < 0) { 2356 perror("sendmsg(test_socket)"); 2357 os_free(msg); 2358 return -1; 2359 } 2360 2361 os_free(msg); 2362 return 0; 2363} 2364 2365 2366static int wpa_driver_test_get_capa(void *priv, struct wpa_driver_capa *capa) 2367{ 2368 struct test_driver_bss *dbss = priv; 2369 struct wpa_driver_test_data *drv = dbss->drv; 2370 os_memset(capa, 0, sizeof(*capa)); 2371 capa->key_mgmt = WPA_DRIVER_CAPA_KEY_MGMT_WPA | 2372 WPA_DRIVER_CAPA_KEY_MGMT_WPA2 | 2373 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK | 2374 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK | 2375 WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE | 2376 WPA_DRIVER_CAPA_KEY_MGMT_FT | 2377 WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK; 2378 capa->enc = WPA_DRIVER_CAPA_ENC_WEP40 | 2379 WPA_DRIVER_CAPA_ENC_WEP104 | 2380 WPA_DRIVER_CAPA_ENC_TKIP | 2381 WPA_DRIVER_CAPA_ENC_CCMP; 2382 capa->auth = WPA_DRIVER_AUTH_OPEN | 2383 WPA_DRIVER_AUTH_SHARED | 2384 WPA_DRIVER_AUTH_LEAP; 2385 if (drv->use_mlme) 2386 capa->flags |= WPA_DRIVER_FLAGS_USER_SPACE_MLME; 2387 capa->flags |= WPA_DRIVER_FLAGS_AP; 2388 capa->max_scan_ssids = 2; 2389 capa->max_remain_on_chan = 60000; 2390 2391 return 0; 2392} 2393 2394 2395static int wpa_driver_test_mlme_setprotection(void *priv, const u8 *addr, 2396 int protect_type, 2397 int key_type) 2398{ 2399 wpa_printf(MSG_DEBUG, "%s: protect_type=%d key_type=%d", 2400 __func__, protect_type, key_type); 2401 2402 if (addr) { 2403 wpa_printf(MSG_DEBUG, "%s: addr=" MACSTR, 2404 __func__, MAC2STR(addr)); 2405 } 2406 2407 return 0; 2408} 2409 2410 2411static int wpa_driver_test_set_channel(void *priv, 2412 enum hostapd_hw_mode phymode, 2413 int chan, int freq) 2414{ 2415 struct test_driver_bss *dbss = priv; 2416 struct wpa_driver_test_data *drv = dbss->drv; 2417 wpa_printf(MSG_DEBUG, "%s: phymode=%d chan=%d freq=%d", 2418 __func__, phymode, chan, freq); 2419 drv->current_freq = freq; 2420 return 0; 2421} 2422 2423 2424static int wpa_driver_test_mlme_add_sta(void *priv, const u8 *addr, 2425 const u8 *supp_rates, 2426 size_t supp_rates_len) 2427{ 2428 wpa_printf(MSG_DEBUG, "%s: addr=" MACSTR, __func__, MAC2STR(addr)); 2429 return 0; 2430} 2431 2432 2433static int wpa_driver_test_mlme_remove_sta(void *priv, const u8 *addr) 2434{ 2435 wpa_printf(MSG_DEBUG, "%s: addr=" MACSTR, __func__, MAC2STR(addr)); 2436 return 0; 2437} 2438 2439 2440static int wpa_driver_test_set_ssid(void *priv, const u8 *ssid, 2441 size_t ssid_len) 2442{ 2443 wpa_printf(MSG_DEBUG, "%s", __func__); 2444 return 0; 2445} 2446 2447 2448static int wpa_driver_test_set_bssid(void *priv, const u8 *bssid) 2449{ 2450 wpa_printf(MSG_DEBUG, "%s: bssid=" MACSTR, __func__, MAC2STR(bssid)); 2451 return 0; 2452} 2453 2454 2455static void * wpa_driver_test_global_init(void) 2456{ 2457 struct wpa_driver_test_global *global; 2458 2459 global = os_zalloc(sizeof(*global)); 2460 return global; 2461} 2462 2463 2464static void wpa_driver_test_global_deinit(void *priv) 2465{ 2466 struct wpa_driver_test_global *global = priv; 2467 os_free(global); 2468} 2469 2470 2471static struct wpa_interface_info * 2472wpa_driver_test_get_interfaces(void *global_priv) 2473{ 2474 /* struct wpa_driver_test_global *global = priv; */ 2475 struct wpa_interface_info *iface; 2476 2477 iface = os_zalloc(sizeof(*iface)); 2478 if (iface == NULL) 2479 return iface; 2480 iface->ifname = os_strdup("sta0"); 2481 iface->desc = os_strdup("test interface 0"); 2482 iface->drv_name = "test"; 2483 iface->next = os_zalloc(sizeof(*iface)); 2484 if (iface->next) { 2485 iface->next->ifname = os_strdup("sta1"); 2486 iface->next->desc = os_strdup("test interface 1"); 2487 iface->next->drv_name = "test"; 2488 } 2489 2490 return iface; 2491} 2492 2493 2494static struct hostapd_hw_modes * 2495wpa_driver_test_get_hw_feature_data(void *priv, u16 *num_modes, u16 *flags) 2496{ 2497 struct hostapd_hw_modes *modes; 2498 size_t i; 2499 2500 *num_modes = 3; 2501 *flags = 0; 2502 modes = os_zalloc(*num_modes * sizeof(struct hostapd_hw_modes)); 2503 if (modes == NULL) 2504 return NULL; 2505 modes[0].mode = HOSTAPD_MODE_IEEE80211G; 2506 modes[0].num_channels = 11; 2507 modes[0].num_rates = 12; 2508 modes[0].channels = 2509 os_zalloc(11 * sizeof(struct hostapd_channel_data)); 2510 modes[0].rates = os_zalloc(modes[0].num_rates * sizeof(int)); 2511 if (modes[0].channels == NULL || modes[0].rates == NULL) 2512 goto fail; 2513 for (i = 0; i < 11; i++) { 2514 modes[0].channels[i].chan = i + 1; 2515 modes[0].channels[i].freq = 2412 + 5 * i; 2516 modes[0].channels[i].flag = 0; 2517 } 2518 modes[0].rates[0] = 10; 2519 modes[0].rates[1] = 20; 2520 modes[0].rates[2] = 55; 2521 modes[0].rates[3] = 110; 2522 modes[0].rates[4] = 60; 2523 modes[0].rates[5] = 90; 2524 modes[0].rates[6] = 120; 2525 modes[0].rates[7] = 180; 2526 modes[0].rates[8] = 240; 2527 modes[0].rates[9] = 360; 2528 modes[0].rates[10] = 480; 2529 modes[0].rates[11] = 540; 2530 2531 modes[1].mode = HOSTAPD_MODE_IEEE80211B; 2532 modes[1].num_channels = 11; 2533 modes[1].num_rates = 4; 2534 modes[1].channels = 2535 os_zalloc(11 * sizeof(struct hostapd_channel_data)); 2536 modes[1].rates = os_zalloc(modes[1].num_rates * sizeof(int)); 2537 if (modes[1].channels == NULL || modes[1].rates == NULL) 2538 goto fail; 2539 for (i = 0; i < 11; i++) { 2540 modes[1].channels[i].chan = i + 1; 2541 modes[1].channels[i].freq = 2412 + 5 * i; 2542 modes[1].channels[i].flag = 0; 2543 } 2544 modes[1].rates[0] = 10; 2545 modes[1].rates[1] = 20; 2546 modes[1].rates[2] = 55; 2547 modes[1].rates[3] = 110; 2548 2549 modes[2].mode = HOSTAPD_MODE_IEEE80211A; 2550 modes[2].num_channels = 1; 2551 modes[2].num_rates = 8; 2552 modes[2].channels = os_zalloc(sizeof(struct hostapd_channel_data)); 2553 modes[2].rates = os_zalloc(modes[2].num_rates * sizeof(int)); 2554 if (modes[2].channels == NULL || modes[2].rates == NULL) 2555 goto fail; 2556 modes[2].channels[0].chan = 60; 2557 modes[2].channels[0].freq = 5300; 2558 modes[2].channels[0].flag = 0; 2559 modes[2].rates[0] = 60; 2560 modes[2].rates[1] = 90; 2561 modes[2].rates[2] = 120; 2562 modes[2].rates[3] = 180; 2563 modes[2].rates[4] = 240; 2564 modes[2].rates[5] = 360; 2565 modes[2].rates[6] = 480; 2566 modes[2].rates[7] = 540; 2567 2568 return modes; 2569 2570fail: 2571 if (modes) { 2572 for (i = 0; i < *num_modes; i++) { 2573 os_free(modes[i].channels); 2574 os_free(modes[i].rates); 2575 } 2576 os_free(modes); 2577 } 2578 return NULL; 2579} 2580 2581 2582static int wpa_driver_test_set_freq(void *priv, 2583 struct hostapd_freq_params *freq) 2584{ 2585 struct test_driver_bss *dbss = priv; 2586 struct wpa_driver_test_data *drv = dbss->drv; 2587 wpa_printf(MSG_DEBUG, "test: set_freq %u MHz", freq->freq); 2588 drv->current_freq = freq->freq; 2589 return 0; 2590} 2591 2592 2593static int wpa_driver_test_send_action(void *priv, unsigned int freq, 2594 const u8 *dst, const u8 *src, 2595 const u8 *bssid, 2596 const u8 *data, size_t data_len) 2597{ 2598 struct test_driver_bss *dbss = priv; 2599 struct wpa_driver_test_data *drv = dbss->drv; 2600 int ret = -1; 2601 u8 *buf; 2602 struct ieee80211_hdr *hdr; 2603 2604 wpa_printf(MSG_DEBUG, "test: Send Action frame"); 2605 2606 if ((drv->remain_on_channel_freq && 2607 freq != drv->remain_on_channel_freq) || 2608 (drv->remain_on_channel_freq == 0 && 2609 freq != (unsigned int) drv->current_freq)) { 2610 wpa_printf(MSG_DEBUG, "test: Reject Action frame TX on " 2611 "unexpected channel: freq=%u MHz (current_freq=%u " 2612 "MHz, remain-on-channel freq=%u MHz)", 2613 freq, drv->current_freq, 2614 drv->remain_on_channel_freq); 2615 return -1; 2616 } 2617 2618 buf = os_zalloc(24 + data_len); 2619 if (buf == NULL) 2620 return ret; 2621 os_memcpy(buf + 24, data, data_len); 2622 hdr = (struct ieee80211_hdr *) buf; 2623 hdr->frame_control = 2624 IEEE80211_FC(WLAN_FC_TYPE_MGMT, WLAN_FC_STYPE_ACTION); 2625 os_memcpy(hdr->addr1, dst, ETH_ALEN); 2626 os_memcpy(hdr->addr2, src, ETH_ALEN); 2627 os_memcpy(hdr->addr3, bssid, ETH_ALEN); 2628 2629 ret = wpa_driver_test_send_mlme(priv, buf, 24 + data_len); 2630 os_free(buf); 2631 return ret; 2632} 2633 2634 2635static void test_remain_on_channel_timeout(void *eloop_ctx, void *timeout_ctx) 2636{ 2637 struct wpa_driver_test_data *drv = eloop_ctx; 2638 union wpa_event_data data; 2639 2640 wpa_printf(MSG_DEBUG, "test: Remain-on-channel timeout"); 2641 2642 os_memset(&data, 0, sizeof(data)); 2643 data.remain_on_channel.freq = drv->remain_on_channel_freq; 2644 data.remain_on_channel.duration = drv->remain_on_channel_duration; 2645 wpa_supplicant_event(drv->ctx, EVENT_CANCEL_REMAIN_ON_CHANNEL, &data); 2646 2647 drv->remain_on_channel_freq = 0; 2648} 2649 2650 2651static int wpa_driver_test_remain_on_channel(void *priv, unsigned int freq, 2652 unsigned int duration) 2653{ 2654 struct test_driver_bss *dbss = priv; 2655 struct wpa_driver_test_data *drv = dbss->drv; 2656 union wpa_event_data data; 2657 2658 wpa_printf(MSG_DEBUG, "%s(freq=%u, duration=%u)", 2659 __func__, freq, duration); 2660 if (drv->remain_on_channel_freq && 2661 drv->remain_on_channel_freq != freq) { 2662 wpa_printf(MSG_DEBUG, "test: Refuse concurrent " 2663 "remain_on_channel request"); 2664 return -1; 2665 } 2666 2667 drv->remain_on_channel_freq = freq; 2668 drv->remain_on_channel_duration = duration; 2669 eloop_cancel_timeout(test_remain_on_channel_timeout, drv, NULL); 2670 eloop_register_timeout(duration / 1000, (duration % 1000) * 1000, 2671 test_remain_on_channel_timeout, drv, NULL); 2672 2673 os_memset(&data, 0, sizeof(data)); 2674 data.remain_on_channel.freq = freq; 2675 data.remain_on_channel.duration = duration; 2676 wpa_supplicant_event(drv->ctx, EVENT_REMAIN_ON_CHANNEL, &data); 2677 2678 return 0; 2679} 2680 2681 2682static int wpa_driver_test_cancel_remain_on_channel(void *priv) 2683{ 2684 struct test_driver_bss *dbss = priv; 2685 struct wpa_driver_test_data *drv = dbss->drv; 2686 wpa_printf(MSG_DEBUG, "%s", __func__); 2687 if (!drv->remain_on_channel_freq) 2688 return -1; 2689 drv->remain_on_channel_freq = 0; 2690 eloop_cancel_timeout(test_remain_on_channel_timeout, drv, NULL); 2691 return 0; 2692} 2693 2694 2695static int wpa_driver_test_probe_req_report(void *priv, int report) 2696{ 2697 struct test_driver_bss *dbss = priv; 2698 struct wpa_driver_test_data *drv = dbss->drv; 2699 wpa_printf(MSG_DEBUG, "%s(report=%d)", __func__, report); 2700 drv->probe_req_report = report; 2701 return 0; 2702} 2703 2704 2705const struct wpa_driver_ops wpa_driver_test_ops = { 2706 "test", 2707 "wpa_supplicant test driver", 2708 .hapd_init = test_driver_init, 2709 .hapd_deinit = wpa_driver_test_deinit, 2710 .hapd_send_eapol = test_driver_send_eapol, 2711 .send_mlme = wpa_driver_test_send_mlme, 2712 .set_generic_elem = test_driver_set_generic_elem, 2713 .sta_deauth = test_driver_sta_deauth, 2714 .sta_disassoc = test_driver_sta_disassoc, 2715 .get_hw_feature_data = wpa_driver_test_get_hw_feature_data, 2716 .if_add = test_driver_if_add, 2717 .if_remove = test_driver_if_remove, 2718 .valid_bss_mask = test_driver_valid_bss_mask, 2719 .hapd_set_ssid = test_driver_set_ssid, 2720 .set_privacy = test_driver_set_privacy, 2721 .set_sta_vlan = test_driver_set_sta_vlan, 2722 .sta_add = test_driver_sta_add, 2723 .send_ether = test_driver_send_ether, 2724 .set_ap_wps_ie = test_driver_set_ap_wps_ie, 2725 .get_bssid = wpa_driver_test_get_bssid, 2726 .get_ssid = wpa_driver_test_get_ssid, 2727 .set_key = wpa_driver_test_set_key, 2728 .deinit = wpa_driver_test_deinit, 2729 .set_param = wpa_driver_test_set_param, 2730 .deauthenticate = wpa_driver_test_deauthenticate, 2731 .disassociate = wpa_driver_test_disassociate, 2732 .associate = wpa_driver_test_associate, 2733 .get_capa = wpa_driver_test_get_capa, 2734 .get_mac_addr = wpa_driver_test_get_mac_addr, 2735 .send_eapol = wpa_driver_test_send_eapol, 2736 .mlme_setprotection = wpa_driver_test_mlme_setprotection, 2737 .set_channel = wpa_driver_test_set_channel, 2738 .set_ssid = wpa_driver_test_set_ssid, 2739 .set_bssid = wpa_driver_test_set_bssid, 2740 .mlme_add_sta = wpa_driver_test_mlme_add_sta, 2741 .mlme_remove_sta = wpa_driver_test_mlme_remove_sta, 2742 .get_scan_results2 = wpa_driver_test_get_scan_results2, 2743 .global_init = wpa_driver_test_global_init, 2744 .global_deinit = wpa_driver_test_global_deinit, 2745 .init2 = wpa_driver_test_init2, 2746 .get_interfaces = wpa_driver_test_get_interfaces, 2747 .scan2 = wpa_driver_test_scan, 2748 .set_freq = wpa_driver_test_set_freq, 2749 .send_action = wpa_driver_test_send_action, 2750 .remain_on_channel = wpa_driver_test_remain_on_channel, 2751 .cancel_remain_on_channel = wpa_driver_test_cancel_remain_on_channel, 2752 .probe_req_report = wpa_driver_test_probe_req_report, 2753}; 2754