driver_test.c revision 1f69aa52ea2e0a73ac502565df8c666ee49cab6a
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 "p2p/p2p.h" 38#include "wps/wps.h" 39#include "driver.h" 40 41 42struct test_client_socket { 43 struct test_client_socket *next; 44 u8 addr[ETH_ALEN]; 45 struct sockaddr_un un; 46 socklen_t unlen; 47 struct test_driver_bss *bss; 48}; 49 50struct test_driver_bss { 51 struct wpa_driver_test_data *drv; 52 struct dl_list list; 53 void *bss_ctx; 54 char ifname[IFNAMSIZ]; 55 u8 bssid[ETH_ALEN]; 56 u8 *ie; 57 size_t ielen; 58 u8 *wps_beacon_ie; 59 size_t wps_beacon_ie_len; 60 u8 *wps_probe_resp_ie; 61 size_t wps_probe_resp_ie_len; 62 u8 ssid[32]; 63 size_t ssid_len; 64 int privacy; 65}; 66 67struct wpa_driver_test_global { 68 int bss_add_used; 69 u8 req_addr[ETH_ALEN]; 70}; 71 72struct wpa_driver_test_data { 73 struct wpa_driver_test_global *global; 74 void *ctx; 75 WPA_TRACE_REF(ctx); 76 u8 own_addr[ETH_ALEN]; 77 int test_socket; 78#ifdef DRIVER_TEST_UNIX 79 struct sockaddr_un hostapd_addr; 80#endif /* DRIVER_TEST_UNIX */ 81 int hostapd_addr_set; 82 struct sockaddr_in hostapd_addr_udp; 83 int hostapd_addr_udp_set; 84 char *own_socket_path; 85 char *test_dir; 86#define MAX_SCAN_RESULTS 30 87 struct wpa_scan_res *scanres[MAX_SCAN_RESULTS]; 88 size_t num_scanres; 89 int use_associnfo; 90 u8 assoc_wpa_ie[80]; 91 size_t assoc_wpa_ie_len; 92 int associated; 93 u8 *probe_req_ie; 94 size_t probe_req_ie_len; 95 u8 probe_req_ssid[32]; 96 size_t probe_req_ssid_len; 97 int ibss; 98 int ap; 99 100 struct test_client_socket *cli; 101 struct dl_list bss; 102 int udp_port; 103 104 int alloc_iface_idx; 105 106 int probe_req_report; 107 unsigned int remain_on_channel_freq; 108 unsigned int remain_on_channel_duration; 109 110 int current_freq; 111 112 struct p2p_data *p2p; 113 unsigned int off_channel_freq; 114 struct wpabuf *pending_action_tx; 115 u8 pending_action_src[ETH_ALEN]; 116 u8 pending_action_dst[ETH_ALEN]; 117 u8 pending_action_bssid[ETH_ALEN]; 118 unsigned int pending_action_freq; 119 unsigned int pending_action_no_cck; 120 unsigned int pending_listen_freq; 121 unsigned int pending_listen_duration; 122 int pending_p2p_scan; 123 struct sockaddr *probe_from; 124 socklen_t probe_from_len; 125}; 126 127 128static void wpa_driver_test_deinit(void *priv); 129static int wpa_driver_test_attach(struct wpa_driver_test_data *drv, 130 const char *dir, int ap); 131static void wpa_driver_test_close_test_socket( 132 struct wpa_driver_test_data *drv); 133static void test_remain_on_channel_timeout(void *eloop_ctx, void *timeout_ctx); 134static int wpa_driver_test_init_p2p(struct wpa_driver_test_data *drv); 135 136 137static void test_driver_free_bss(struct test_driver_bss *bss) 138{ 139 os_free(bss->ie); 140 os_free(bss->wps_beacon_ie); 141 os_free(bss->wps_probe_resp_ie); 142 os_free(bss); 143} 144 145 146static void test_driver_free_bsses(struct wpa_driver_test_data *drv) 147{ 148 struct test_driver_bss *bss, *tmp; 149 150 dl_list_for_each_safe(bss, tmp, &drv->bss, struct test_driver_bss, 151 list) { 152 dl_list_del(&bss->list); 153 test_driver_free_bss(bss); 154 } 155} 156 157 158static struct test_client_socket * 159test_driver_get_cli(struct wpa_driver_test_data *drv, struct sockaddr_un *from, 160 socklen_t fromlen) 161{ 162 struct test_client_socket *cli = drv->cli; 163 164 while (cli) { 165 if (cli->unlen == fromlen && 166 strncmp(cli->un.sun_path, from->sun_path, 167 fromlen - sizeof(cli->un.sun_family)) == 0) 168 return cli; 169 cli = cli->next; 170 } 171 172 return NULL; 173} 174 175 176static int test_driver_send_eapol(void *priv, const u8 *addr, const u8 *data, 177 size_t data_len, int encrypt, 178 const u8 *own_addr, u32 flags) 179{ 180 struct test_driver_bss *dbss = priv; 181 struct wpa_driver_test_data *drv = dbss->drv; 182 struct test_client_socket *cli; 183 struct msghdr msg; 184 struct iovec io[3]; 185 struct l2_ethhdr eth; 186 187 if (drv->test_socket < 0) 188 return -1; 189 190 cli = drv->cli; 191 while (cli) { 192 if (memcmp(cli->addr, addr, ETH_ALEN) == 0) 193 break; 194 cli = cli->next; 195 } 196 197 if (!cli) { 198 wpa_printf(MSG_DEBUG, "%s: no destination client entry", 199 __func__); 200 return -1; 201 } 202 203 memcpy(eth.h_dest, addr, ETH_ALEN); 204 memcpy(eth.h_source, own_addr, ETH_ALEN); 205 eth.h_proto = host_to_be16(ETH_P_EAPOL); 206 207 io[0].iov_base = "EAPOL "; 208 io[0].iov_len = 6; 209 io[1].iov_base = ð 210 io[1].iov_len = sizeof(eth); 211 io[2].iov_base = (u8 *) data; 212 io[2].iov_len = data_len; 213 214 memset(&msg, 0, sizeof(msg)); 215 msg.msg_iov = io; 216 msg.msg_iovlen = 3; 217 msg.msg_name = &cli->un; 218 msg.msg_namelen = cli->unlen; 219 return sendmsg(drv->test_socket, &msg, 0); 220} 221 222 223static int test_driver_send_ether(void *priv, const u8 *dst, const u8 *src, 224 u16 proto, const u8 *data, size_t data_len) 225{ 226 struct test_driver_bss *dbss = priv; 227 struct wpa_driver_test_data *drv = dbss->drv; 228 struct msghdr msg; 229 struct iovec io[3]; 230 struct l2_ethhdr eth; 231 char desttxt[30]; 232 struct sockaddr_un addr; 233 struct dirent *dent; 234 DIR *dir; 235 int ret = 0, broadcast = 0, count = 0; 236 237 if (drv->test_socket < 0 || drv->test_dir == NULL) { 238 wpa_printf(MSG_DEBUG, "%s: invalid parameters (sock=%d " 239 "test_dir=%p)", 240 __func__, drv->test_socket, drv->test_dir); 241 return -1; 242 } 243 244 broadcast = memcmp(dst, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) == 0; 245 snprintf(desttxt, sizeof(desttxt), MACSTR, MAC2STR(dst)); 246 247 memcpy(eth.h_dest, dst, ETH_ALEN); 248 memcpy(eth.h_source, src, ETH_ALEN); 249 eth.h_proto = host_to_be16(proto); 250 251 io[0].iov_base = "ETHER "; 252 io[0].iov_len = 6; 253 io[1].iov_base = ð 254 io[1].iov_len = sizeof(eth); 255 io[2].iov_base = (u8 *) data; 256 io[2].iov_len = data_len; 257 258 memset(&msg, 0, sizeof(msg)); 259 msg.msg_iov = io; 260 msg.msg_iovlen = 3; 261 262 dir = opendir(drv->test_dir); 263 if (dir == NULL) { 264 perror("test_driver: opendir"); 265 return -1; 266 } 267 while ((dent = readdir(dir))) { 268#ifdef _DIRENT_HAVE_D_TYPE 269 /* Skip the file if it is not a socket. Also accept 270 * DT_UNKNOWN (0) in case the C library or underlying file 271 * system does not support d_type. */ 272 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN) 273 continue; 274#endif /* _DIRENT_HAVE_D_TYPE */ 275 if (strcmp(dent->d_name, ".") == 0 || 276 strcmp(dent->d_name, "..") == 0) 277 continue; 278 279 memset(&addr, 0, sizeof(addr)); 280 addr.sun_family = AF_UNIX; 281 snprintf(addr.sun_path, sizeof(addr.sun_path), "%s/%s", 282 drv->test_dir, dent->d_name); 283 284 if (strcmp(addr.sun_path, drv->own_socket_path) == 0) 285 continue; 286 if (!broadcast && strstr(dent->d_name, desttxt) == NULL) 287 continue; 288 289 wpa_printf(MSG_DEBUG, "%s: Send ether frame to %s", 290 __func__, dent->d_name); 291 292 msg.msg_name = &addr; 293 msg.msg_namelen = sizeof(addr); 294 ret = sendmsg(drv->test_socket, &msg, 0); 295 if (ret < 0) 296 perror("driver_test: sendmsg"); 297 count++; 298 } 299 closedir(dir); 300 301 if (!broadcast && count == 0) { 302 wpa_printf(MSG_DEBUG, "%s: Destination " MACSTR " not found", 303 __func__, MAC2STR(dst)); 304 return -1; 305 } 306 307 return ret; 308} 309 310 311static int wpa_driver_test_send_mlme(void *priv, const u8 *data, 312 size_t data_len, int noack) 313{ 314 struct test_driver_bss *dbss = priv; 315 struct wpa_driver_test_data *drv = dbss->drv; 316 struct msghdr msg; 317 struct iovec io[2]; 318 const u8 *dest; 319 struct sockaddr_un addr; 320 struct dirent *dent; 321 DIR *dir; 322 int broadcast; 323 int ret = 0; 324 struct ieee80211_hdr *hdr; 325 u16 fc; 326 char cmd[50]; 327 int freq; 328#ifdef HOSTAPD 329 char desttxt[30]; 330#endif /* HOSTAPD */ 331 union wpa_event_data event; 332 333 wpa_hexdump(MSG_MSGDUMP, "test_send_mlme", data, data_len); 334 if (drv->test_socket < 0 || data_len < 10) { 335 wpa_printf(MSG_DEBUG, "%s: invalid parameters (sock=%d len=%lu" 336 " test_dir=%p)", 337 __func__, drv->test_socket, 338 (unsigned long) data_len, 339 drv->test_dir); 340 return -1; 341 } 342 343 dest = data + 4; 344 broadcast = os_memcmp(dest, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) == 0; 345 346#ifdef HOSTAPD 347 snprintf(desttxt, sizeof(desttxt), MACSTR, MAC2STR(dest)); 348#endif /* HOSTAPD */ 349 350 if (drv->remain_on_channel_freq) 351 freq = drv->remain_on_channel_freq; 352 else 353 freq = drv->current_freq; 354 wpa_printf(MSG_DEBUG, "test_driver(%s): MLME TX on freq %d MHz", 355 dbss->ifname, freq); 356 os_snprintf(cmd, sizeof(cmd), "MLME freq=%d ", freq); 357 io[0].iov_base = cmd; 358 io[0].iov_len = os_strlen(cmd); 359 io[1].iov_base = (void *) data; 360 io[1].iov_len = data_len; 361 362 os_memset(&msg, 0, sizeof(msg)); 363 msg.msg_iov = io; 364 msg.msg_iovlen = 2; 365 366#ifdef HOSTAPD 367 if (drv->test_dir == NULL) { 368 wpa_printf(MSG_DEBUG, "%s: test_dir == NULL", __func__); 369 return -1; 370 } 371 372 dir = opendir(drv->test_dir); 373 if (dir == NULL) { 374 perror("test_driver: opendir"); 375 return -1; 376 } 377 while ((dent = readdir(dir))) { 378#ifdef _DIRENT_HAVE_D_TYPE 379 /* Skip the file if it is not a socket. Also accept 380 * DT_UNKNOWN (0) in case the C library or underlying file 381 * system does not support d_type. */ 382 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN) 383 continue; 384#endif /* _DIRENT_HAVE_D_TYPE */ 385 if (os_strcmp(dent->d_name, ".") == 0 || 386 os_strcmp(dent->d_name, "..") == 0) 387 continue; 388 389 os_memset(&addr, 0, sizeof(addr)); 390 addr.sun_family = AF_UNIX; 391 os_snprintf(addr.sun_path, sizeof(addr.sun_path), "%s/%s", 392 drv->test_dir, dent->d_name); 393 394 if (os_strcmp(addr.sun_path, drv->own_socket_path) == 0) 395 continue; 396 if (!broadcast && os_strstr(dent->d_name, desttxt) == NULL) 397 continue; 398 399 wpa_printf(MSG_DEBUG, "%s: Send management frame to %s", 400 __func__, dent->d_name); 401 402 msg.msg_name = &addr; 403 msg.msg_namelen = sizeof(addr); 404 ret = sendmsg(drv->test_socket, &msg, 0); 405 if (ret < 0) 406 perror("driver_test: sendmsg(test_socket)"); 407 } 408 closedir(dir); 409#else /* HOSTAPD */ 410 411 if (os_memcmp(dest, dbss->bssid, ETH_ALEN) == 0 || 412 drv->test_dir == NULL) { 413 if (drv->hostapd_addr_udp_set) { 414 msg.msg_name = &drv->hostapd_addr_udp; 415 msg.msg_namelen = sizeof(drv->hostapd_addr_udp); 416 } else { 417#ifdef DRIVER_TEST_UNIX 418 msg.msg_name = &drv->hostapd_addr; 419 msg.msg_namelen = sizeof(drv->hostapd_addr); 420#endif /* DRIVER_TEST_UNIX */ 421 } 422 } else if (broadcast) { 423 dir = opendir(drv->test_dir); 424 if (dir == NULL) 425 return -1; 426 while ((dent = readdir(dir))) { 427#ifdef _DIRENT_HAVE_D_TYPE 428 /* Skip the file if it is not a socket. 429 * Also accept DT_UNKNOWN (0) in case 430 * the C library or underlying file 431 * system does not support d_type. */ 432 if (dent->d_type != DT_SOCK && 433 dent->d_type != DT_UNKNOWN) 434 continue; 435#endif /* _DIRENT_HAVE_D_TYPE */ 436 if (os_strcmp(dent->d_name, ".") == 0 || 437 os_strcmp(dent->d_name, "..") == 0) 438 continue; 439 wpa_printf(MSG_DEBUG, "%s: Send broadcast MLME to %s", 440 __func__, dent->d_name); 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/%s", drv->test_dir, dent->d_name); 445 446 msg.msg_name = &addr; 447 msg.msg_namelen = sizeof(addr); 448 449 ret = sendmsg(drv->test_socket, &msg, 0); 450 if (ret < 0) 451 perror("driver_test: sendmsg(test_socket)"); 452 } 453 closedir(dir); 454 return ret; 455 } else { 456 struct stat st; 457 os_memset(&addr, 0, sizeof(addr)); 458 addr.sun_family = AF_UNIX; 459 os_snprintf(addr.sun_path, sizeof(addr.sun_path), 460 "%s/AP-" MACSTR, drv->test_dir, MAC2STR(dest)); 461 if (stat(addr.sun_path, &st) < 0) { 462 os_snprintf(addr.sun_path, sizeof(addr.sun_path), 463 "%s/STA-" MACSTR, 464 drv->test_dir, MAC2STR(dest)); 465 } 466 msg.msg_name = &addr; 467 msg.msg_namelen = sizeof(addr); 468 } 469 470 if (sendmsg(drv->test_socket, &msg, 0) < 0) { 471 perror("sendmsg(test_socket)"); 472 return -1; 473 } 474#endif /* HOSTAPD */ 475 476 hdr = (struct ieee80211_hdr *) data; 477 fc = le_to_host16(hdr->frame_control); 478 479 os_memset(&event, 0, sizeof(event)); 480 event.tx_status.type = WLAN_FC_GET_TYPE(fc); 481 event.tx_status.stype = WLAN_FC_GET_STYPE(fc); 482 event.tx_status.dst = hdr->addr1; 483 event.tx_status.data = data; 484 event.tx_status.data_len = data_len; 485 event.tx_status.ack = ret >= 0; 486 wpa_supplicant_event(drv->ctx, EVENT_TX_STATUS, &event); 487 488#ifdef CONFIG_P2P 489 if (drv->p2p && 490 WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT && 491 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_ACTION) { 492 if (drv->pending_action_tx == NULL) { 493 wpa_printf(MSG_DEBUG, "P2P: Ignore Action TX status - " 494 "no pending operation"); 495 return ret; 496 } 497 498 if (os_memcmp(hdr->addr1, drv->pending_action_dst, ETH_ALEN) != 499 0) { 500 wpa_printf(MSG_DEBUG, "P2P: Ignore Action TX status - " 501 "unknown destination address"); 502 return ret; 503 } 504 505 wpabuf_free(drv->pending_action_tx); 506 drv->pending_action_tx = NULL; 507 508 p2p_send_action_cb(drv->p2p, drv->pending_action_freq, 509 drv->pending_action_dst, 510 drv->pending_action_src, 511 drv->pending_action_bssid, 512 ret >= 0); 513 } 514#endif /* CONFIG_P2P */ 515 516 return ret; 517} 518 519 520static void test_driver_scan(struct wpa_driver_test_data *drv, 521 struct sockaddr_un *from, socklen_t fromlen, 522 char *data) 523{ 524 char buf[512], *pos, *end; 525 int ret; 526 struct test_driver_bss *bss; 527 u8 sa[ETH_ALEN]; 528 u8 ie[512]; 529 size_t ielen; 530 union wpa_event_data event; 531 532 /* data: optional [ ' ' | STA-addr | ' ' | IEs(hex) ] */ 533 534 wpa_printf(MSG_DEBUG, "test_driver: SCAN"); 535 536 if (*data) { 537 if (*data != ' ' || 538 hwaddr_aton(data + 1, sa)) { 539 wpa_printf(MSG_DEBUG, "test_driver: Unexpected SCAN " 540 "command format"); 541 return; 542 } 543 544 data += 18; 545 while (*data == ' ') 546 data++; 547 ielen = os_strlen(data) / 2; 548 if (ielen > sizeof(ie)) 549 ielen = sizeof(ie); 550 if (hexstr2bin(data, ie, ielen) < 0) 551 ielen = 0; 552 553 wpa_printf(MSG_DEBUG, "test_driver: Scan from " MACSTR, 554 MAC2STR(sa)); 555 wpa_hexdump(MSG_MSGDUMP, "test_driver: scan IEs", ie, ielen); 556 557 os_memset(&event, 0, sizeof(event)); 558 event.rx_probe_req.sa = sa; 559 event.rx_probe_req.ie = ie; 560 event.rx_probe_req.ie_len = ielen; 561 wpa_supplicant_event(drv->ctx, EVENT_RX_PROBE_REQ, &event); 562#ifdef CONFIG_P2P 563 if (drv->p2p) 564 p2p_probe_req_rx(drv->p2p, sa, NULL, NULL, ie, ielen); 565#endif /* CONFIG_P2P */ 566 } 567 568 dl_list_for_each(bss, &drv->bss, struct test_driver_bss, list) { 569 pos = buf; 570 end = buf + sizeof(buf); 571 572 /* reply: SCANRESP BSSID SSID IEs */ 573 ret = snprintf(pos, end - pos, "SCANRESP " MACSTR " ", 574 MAC2STR(bss->bssid)); 575 if (ret < 0 || ret >= end - pos) 576 return; 577 pos += ret; 578 pos += wpa_snprintf_hex(pos, end - pos, 579 bss->ssid, bss->ssid_len); 580 ret = snprintf(pos, end - pos, " "); 581 if (ret < 0 || ret >= end - pos) 582 return; 583 pos += ret; 584 pos += wpa_snprintf_hex(pos, end - pos, bss->ie, bss->ielen); 585 pos += wpa_snprintf_hex(pos, end - pos, bss->wps_probe_resp_ie, 586 bss->wps_probe_resp_ie_len); 587 588 if (bss->privacy) { 589 ret = snprintf(pos, end - pos, " PRIVACY"); 590 if (ret < 0 || ret >= end - pos) 591 return; 592 pos += ret; 593 } 594 595 sendto(drv->test_socket, buf, pos - buf, 0, 596 (struct sockaddr *) from, fromlen); 597 } 598} 599 600 601static void test_driver_assoc(struct wpa_driver_test_data *drv, 602 struct sockaddr_un *from, socklen_t fromlen, 603 char *data) 604{ 605 struct test_client_socket *cli; 606 u8 ie[256], ssid[32]; 607 size_t ielen, ssid_len = 0; 608 char *pos, *pos2, cmd[50]; 609 struct test_driver_bss *bss, *tmp; 610 611 /* data: STA-addr SSID(hex) IEs(hex) */ 612 613 cli = os_zalloc(sizeof(*cli)); 614 if (cli == NULL) 615 return; 616 617 if (hwaddr_aton(data, cli->addr)) { 618 printf("test_socket: Invalid MAC address '%s' in ASSOC\n", 619 data); 620 os_free(cli); 621 return; 622 } 623 pos = data + 17; 624 while (*pos == ' ') 625 pos++; 626 pos2 = strchr(pos, ' '); 627 ielen = 0; 628 if (pos2) { 629 ssid_len = (pos2 - pos) / 2; 630 if (hexstr2bin(pos, ssid, ssid_len) < 0) { 631 wpa_printf(MSG_DEBUG, "%s: Invalid SSID", __func__); 632 os_free(cli); 633 return; 634 } 635 wpa_hexdump_ascii(MSG_DEBUG, "test_driver_assoc: SSID", 636 ssid, ssid_len); 637 638 pos = pos2 + 1; 639 ielen = strlen(pos) / 2; 640 if (ielen > sizeof(ie)) 641 ielen = sizeof(ie); 642 if (hexstr2bin(pos, ie, ielen) < 0) 643 ielen = 0; 644 } 645 646 bss = NULL; 647 dl_list_for_each(tmp, &drv->bss, struct test_driver_bss, list) { 648 if (tmp->ssid_len == ssid_len && 649 os_memcmp(tmp->ssid, ssid, ssid_len) == 0) { 650 bss = tmp; 651 break; 652 } 653 } 654 if (bss == NULL) { 655 wpa_printf(MSG_DEBUG, "%s: No matching SSID found from " 656 "configured BSSes", __func__); 657 os_free(cli); 658 return; 659 } 660 661 cli->bss = bss; 662 memcpy(&cli->un, from, sizeof(cli->un)); 663 cli->unlen = fromlen; 664 cli->next = drv->cli; 665 drv->cli = cli; 666 wpa_hexdump_ascii(MSG_DEBUG, "test_socket: ASSOC sun_path", 667 (const u8 *) cli->un.sun_path, 668 cli->unlen - sizeof(cli->un.sun_family)); 669 670 snprintf(cmd, sizeof(cmd), "ASSOCRESP " MACSTR " 0", 671 MAC2STR(bss->bssid)); 672 sendto(drv->test_socket, cmd, strlen(cmd), 0, 673 (struct sockaddr *) from, fromlen); 674 675 drv_event_assoc(bss->bss_ctx, cli->addr, ie, ielen, 0); 676} 677 678 679static void test_driver_disassoc(struct wpa_driver_test_data *drv, 680 struct sockaddr_un *from, socklen_t fromlen) 681{ 682 struct test_client_socket *cli; 683 684 cli = test_driver_get_cli(drv, from, fromlen); 685 if (!cli) 686 return; 687 688 drv_event_disassoc(drv->ctx, cli->addr); 689} 690 691 692static void test_driver_eapol(struct wpa_driver_test_data *drv, 693 struct sockaddr_un *from, socklen_t fromlen, 694 u8 *data, size_t datalen) 695{ 696#ifdef HOSTAPD 697 struct test_client_socket *cli; 698#endif /* HOSTAPD */ 699 const u8 *src = NULL; 700 701 if (datalen > 14) { 702 /* Skip Ethernet header */ 703 src = data + ETH_ALEN; 704 wpa_printf(MSG_DEBUG, "test_driver: dst=" MACSTR " src=" 705 MACSTR " proto=%04x", 706 MAC2STR(data), MAC2STR(src), 707 WPA_GET_BE16(data + 2 * ETH_ALEN)); 708 data += 14; 709 datalen -= 14; 710 } 711 712#ifdef HOSTAPD 713 cli = test_driver_get_cli(drv, from, fromlen); 714 if (cli) { 715 drv_event_eapol_rx(cli->bss->bss_ctx, cli->addr, data, 716 datalen); 717 } else { 718 wpa_printf(MSG_DEBUG, "test_socket: EAPOL from unknown " 719 "client"); 720 } 721#else /* HOSTAPD */ 722 if (src) 723 drv_event_eapol_rx(drv->ctx, src, data, datalen); 724#endif /* HOSTAPD */ 725} 726 727 728static void test_driver_ether(struct wpa_driver_test_data *drv, 729 struct sockaddr_un *from, socklen_t fromlen, 730 u8 *data, size_t datalen) 731{ 732 struct l2_ethhdr *eth; 733 734 if (datalen < sizeof(*eth)) 735 return; 736 737 eth = (struct l2_ethhdr *) data; 738 wpa_printf(MSG_DEBUG, "test_driver: RX ETHER dst=" MACSTR " src=" 739 MACSTR " proto=%04x", 740 MAC2STR(eth->h_dest), MAC2STR(eth->h_source), 741 be_to_host16(eth->h_proto)); 742 743#ifdef CONFIG_IEEE80211R 744 if (be_to_host16(eth->h_proto) == ETH_P_RRB) { 745 union wpa_event_data ev; 746 os_memset(&ev, 0, sizeof(ev)); 747 ev.ft_rrb_rx.src = eth->h_source; 748 ev.ft_rrb_rx.data = data + sizeof(*eth); 749 ev.ft_rrb_rx.data_len = datalen - sizeof(*eth); 750 } 751#endif /* CONFIG_IEEE80211R */ 752} 753 754 755static void test_driver_mlme(struct wpa_driver_test_data *drv, 756 struct sockaddr_un *from, socklen_t fromlen, 757 u8 *data, size_t datalen) 758{ 759 struct ieee80211_hdr *hdr; 760 u16 fc; 761 union wpa_event_data event; 762 int freq = 0, own_freq; 763 struct test_driver_bss *bss; 764 765 bss = dl_list_first(&drv->bss, struct test_driver_bss, list); 766 767 if (datalen > 6 && os_memcmp(data, "freq=", 5) == 0) { 768 size_t pos; 769 for (pos = 5; pos < datalen; pos++) { 770 if (data[pos] == ' ') 771 break; 772 } 773 if (pos < datalen) { 774 freq = atoi((const char *) &data[5]); 775 wpa_printf(MSG_DEBUG, "test_driver(%s): MLME RX on " 776 "freq %d MHz", bss->ifname, freq); 777 pos++; 778 data += pos; 779 datalen -= pos; 780 } 781 } 782 783 if (drv->remain_on_channel_freq) 784 own_freq = drv->remain_on_channel_freq; 785 else 786 own_freq = drv->current_freq; 787 788 if (freq && own_freq && freq != own_freq) { 789 wpa_printf(MSG_DEBUG, "test_driver(%s): Ignore MLME RX on " 790 "another frequency %d MHz (own %d MHz)", 791 bss->ifname, freq, own_freq); 792 return; 793 } 794 795 hdr = (struct ieee80211_hdr *) data; 796 797 if (test_driver_get_cli(drv, from, fromlen) == NULL && datalen >= 16) { 798 struct test_client_socket *cli; 799 cli = os_zalloc(sizeof(*cli)); 800 if (cli == NULL) 801 return; 802 wpa_printf(MSG_DEBUG, "Adding client entry for " MACSTR, 803 MAC2STR(hdr->addr2)); 804 memcpy(cli->addr, hdr->addr2, ETH_ALEN); 805 memcpy(&cli->un, from, sizeof(cli->un)); 806 cli->unlen = fromlen; 807 cli->next = drv->cli; 808 drv->cli = cli; 809 } 810 811 wpa_hexdump(MSG_MSGDUMP, "test_driver_mlme: received frame", 812 data, datalen); 813 fc = le_to_host16(hdr->frame_control); 814 if (WLAN_FC_GET_TYPE(fc) != WLAN_FC_TYPE_MGMT) { 815 wpa_printf(MSG_ERROR, "%s: received non-mgmt frame", 816 __func__); 817 return; 818 } 819 820 os_memset(&event, 0, sizeof(event)); 821 event.rx_mgmt.frame = data; 822 event.rx_mgmt.frame_len = datalen; 823 wpa_supplicant_event(drv->ctx, EVENT_RX_MGMT, &event); 824} 825 826 827static void test_driver_receive_unix(int sock, void *eloop_ctx, void *sock_ctx) 828{ 829 struct wpa_driver_test_data *drv = eloop_ctx; 830 char buf[2000]; 831 int res; 832 struct sockaddr_un from; 833 socklen_t fromlen = sizeof(from); 834 835 res = recvfrom(sock, buf, sizeof(buf) - 1, 0, 836 (struct sockaddr *) &from, &fromlen); 837 if (res < 0) { 838 perror("recvfrom(test_socket)"); 839 return; 840 } 841 buf[res] = '\0'; 842 843 wpa_printf(MSG_DEBUG, "test_driver: received %u bytes", res); 844 845 if (strncmp(buf, "SCAN", 4) == 0) { 846 test_driver_scan(drv, &from, fromlen, buf + 4); 847 } else if (strncmp(buf, "ASSOC ", 6) == 0) { 848 test_driver_assoc(drv, &from, fromlen, buf + 6); 849 } else if (strcmp(buf, "DISASSOC") == 0) { 850 test_driver_disassoc(drv, &from, fromlen); 851 } else if (strncmp(buf, "EAPOL ", 6) == 0) { 852 test_driver_eapol(drv, &from, fromlen, (u8 *) buf + 6, 853 res - 6); 854 } else if (strncmp(buf, "ETHER ", 6) == 0) { 855 test_driver_ether(drv, &from, fromlen, (u8 *) buf + 6, 856 res - 6); 857 } else if (strncmp(buf, "MLME ", 5) == 0) { 858 test_driver_mlme(drv, &from, fromlen, (u8 *) buf + 5, res - 5); 859 } else { 860 wpa_hexdump_ascii(MSG_DEBUG, "Unknown test_socket command", 861 (u8 *) buf, res); 862 } 863} 864 865 866static int test_driver_set_generic_elem(void *priv, 867 const u8 *elem, size_t elem_len) 868{ 869 struct test_driver_bss *bss = priv; 870 871 os_free(bss->ie); 872 873 if (elem == NULL) { 874 bss->ie = NULL; 875 bss->ielen = 0; 876 return 0; 877 } 878 879 bss->ie = os_malloc(elem_len); 880 if (bss->ie == NULL) { 881 bss->ielen = 0; 882 return -1; 883 } 884 885 memcpy(bss->ie, elem, elem_len); 886 bss->ielen = elem_len; 887 return 0; 888} 889 890 891static int test_driver_set_ap_wps_ie(void *priv, const struct wpabuf *beacon, 892 const struct wpabuf *proberesp, 893 const struct wpabuf *assocresp) 894{ 895 struct test_driver_bss *bss = priv; 896 897 if (beacon == NULL) 898 wpa_printf(MSG_DEBUG, "test_driver: Clear Beacon WPS IE"); 899 else 900 wpa_hexdump_buf(MSG_DEBUG, "test_driver: Beacon WPS IE", 901 beacon); 902 903 os_free(bss->wps_beacon_ie); 904 905 if (beacon == NULL) { 906 bss->wps_beacon_ie = NULL; 907 bss->wps_beacon_ie_len = 0; 908 } else { 909 bss->wps_beacon_ie = os_malloc(wpabuf_len(beacon)); 910 if (bss->wps_beacon_ie == NULL) { 911 bss->wps_beacon_ie_len = 0; 912 return -1; 913 } 914 915 os_memcpy(bss->wps_beacon_ie, wpabuf_head(beacon), 916 wpabuf_len(beacon)); 917 bss->wps_beacon_ie_len = wpabuf_len(beacon); 918 } 919 920 if (proberesp == NULL) 921 wpa_printf(MSG_DEBUG, "test_driver: Clear Probe Response WPS " 922 "IE"); 923 else 924 wpa_hexdump_buf(MSG_DEBUG, "test_driver: Probe Response WPS " 925 "IE", proberesp); 926 927 os_free(bss->wps_probe_resp_ie); 928 929 if (proberesp == NULL) { 930 bss->wps_probe_resp_ie = NULL; 931 bss->wps_probe_resp_ie_len = 0; 932 } else { 933 bss->wps_probe_resp_ie = os_malloc(wpabuf_len(proberesp)); 934 if (bss->wps_probe_resp_ie == NULL) { 935 bss->wps_probe_resp_ie_len = 0; 936 return -1; 937 } 938 939 os_memcpy(bss->wps_probe_resp_ie, wpabuf_head(proberesp), 940 wpabuf_len(proberesp)); 941 bss->wps_probe_resp_ie_len = wpabuf_len(proberesp); 942 } 943 944 return 0; 945} 946 947 948static int test_driver_sta_deauth(void *priv, const u8 *own_addr, 949 const u8 *addr, int reason) 950{ 951 struct test_driver_bss *dbss = priv; 952 struct wpa_driver_test_data *drv = dbss->drv; 953 struct test_client_socket *cli; 954 955 if (drv->test_socket < 0) 956 return -1; 957 958 cli = drv->cli; 959 while (cli) { 960 if (memcmp(cli->addr, addr, ETH_ALEN) == 0) 961 break; 962 cli = cli->next; 963 } 964 965 if (!cli) 966 return -1; 967 968 return sendto(drv->test_socket, "DEAUTH", 6, 0, 969 (struct sockaddr *) &cli->un, cli->unlen); 970} 971 972 973static int test_driver_sta_disassoc(void *priv, const u8 *own_addr, 974 const u8 *addr, int reason) 975{ 976 struct test_driver_bss *dbss = priv; 977 struct wpa_driver_test_data *drv = dbss->drv; 978 struct test_client_socket *cli; 979 980 if (drv->test_socket < 0) 981 return -1; 982 983 cli = drv->cli; 984 while (cli) { 985 if (memcmp(cli->addr, addr, ETH_ALEN) == 0) 986 break; 987 cli = cli->next; 988 } 989 990 if (!cli) 991 return -1; 992 993 return sendto(drv->test_socket, "DISASSOC", 8, 0, 994 (struct sockaddr *) &cli->un, cli->unlen); 995} 996 997 998static int test_driver_bss_add(void *priv, const char *ifname, const u8 *bssid, 999 void *bss_ctx, void **drv_priv) 1000{ 1001 struct test_driver_bss *dbss = priv; 1002 struct wpa_driver_test_data *drv = dbss->drv; 1003 struct test_driver_bss *bss; 1004 1005 wpa_printf(MSG_DEBUG, "%s(ifname=%s bssid=" MACSTR ")", 1006 __func__, ifname, MAC2STR(bssid)); 1007 1008 bss = os_zalloc(sizeof(*bss)); 1009 if (bss == NULL) 1010 return -1; 1011 1012 bss->bss_ctx = bss_ctx; 1013 bss->drv = drv; 1014 os_strlcpy(bss->ifname, ifname, IFNAMSIZ); 1015 os_memcpy(bss->bssid, bssid, ETH_ALEN); 1016 1017 dl_list_add(&drv->bss, &bss->list); 1018 if (drv->global) { 1019 drv->global->bss_add_used = 1; 1020 os_memcpy(drv->global->req_addr, bssid, ETH_ALEN); 1021 } 1022 1023 if (drv_priv) 1024 *drv_priv = bss; 1025 1026 return 0; 1027} 1028 1029 1030static int test_driver_bss_remove(void *priv, const char *ifname) 1031{ 1032 struct test_driver_bss *dbss = priv; 1033 struct wpa_driver_test_data *drv = dbss->drv; 1034 struct test_driver_bss *bss; 1035 struct test_client_socket *cli, *prev_c; 1036 1037 wpa_printf(MSG_DEBUG, "%s(ifname=%s)", __func__, ifname); 1038 1039 dl_list_for_each(bss, &drv->bss, struct test_driver_bss, list) { 1040 if (strcmp(bss->ifname, ifname) != 0) 1041 continue; 1042 1043 for (prev_c = NULL, cli = drv->cli; cli; 1044 prev_c = cli, cli = cli->next) { 1045 if (cli->bss != bss) 1046 continue; 1047 if (prev_c) 1048 prev_c->next = cli->next; 1049 else 1050 drv->cli = cli->next; 1051 os_free(cli); 1052 break; 1053 } 1054 1055 dl_list_del(&bss->list); 1056 test_driver_free_bss(bss); 1057 return 0; 1058 } 1059 1060 return -1; 1061} 1062 1063 1064static int test_driver_if_add(void *priv, enum wpa_driver_if_type type, 1065 const char *ifname, const u8 *addr, 1066 void *bss_ctx, void **drv_priv, 1067 char *force_ifname, u8 *if_addr, 1068 const char *bridge) 1069{ 1070 struct test_driver_bss *dbss = priv; 1071 struct wpa_driver_test_data *drv = dbss->drv; 1072 1073 wpa_printf(MSG_DEBUG, "%s(type=%d ifname=%s bss_ctx=%p)", 1074 __func__, type, ifname, bss_ctx); 1075 if (addr) 1076 os_memcpy(if_addr, addr, ETH_ALEN); 1077 else { 1078 drv->alloc_iface_idx++; 1079 if_addr[0] = 0x02; /* locally administered */ 1080 sha1_prf(drv->own_addr, ETH_ALEN, 1081 "hostapd test addr generation", 1082 (const u8 *) &drv->alloc_iface_idx, 1083 sizeof(drv->alloc_iface_idx), 1084 if_addr + 1, ETH_ALEN - 1); 1085 } 1086 if (type == WPA_IF_AP_BSS || type == WPA_IF_P2P_GO || 1087 type == WPA_IF_P2P_CLIENT || type == WPA_IF_P2P_GROUP) 1088 return test_driver_bss_add(priv, ifname, if_addr, bss_ctx, 1089 drv_priv); 1090 return 0; 1091} 1092 1093 1094static int test_driver_if_remove(void *priv, enum wpa_driver_if_type type, 1095 const char *ifname) 1096{ 1097 wpa_printf(MSG_DEBUG, "%s(type=%d ifname=%s)", __func__, type, ifname); 1098 if (type == WPA_IF_AP_BSS || type == WPA_IF_P2P_GO || 1099 type == WPA_IF_P2P_CLIENT || type == WPA_IF_P2P_GROUP) 1100 return test_driver_bss_remove(priv, ifname); 1101 return 0; 1102} 1103 1104 1105static int test_driver_set_ssid(void *priv, const u8 *buf, int len) 1106{ 1107 struct test_driver_bss *bss = priv; 1108 1109 wpa_printf(MSG_DEBUG, "%s(ifname=%s)", __func__, bss->ifname); 1110 if (len < 0) 1111 return -1; 1112 wpa_hexdump_ascii(MSG_DEBUG, "test_driver_set_ssid: SSID", buf, len); 1113 1114 if ((size_t) len > sizeof(bss->ssid)) 1115 return -1; 1116 1117 os_memcpy(bss->ssid, buf, len); 1118 bss->ssid_len = len; 1119 1120 return 0; 1121} 1122 1123 1124static int test_driver_set_privacy(void *priv, int enabled) 1125{ 1126 struct test_driver_bss *dbss = priv; 1127 1128 wpa_printf(MSG_DEBUG, "%s(enabled=%d)", __func__, enabled); 1129 dbss->privacy = enabled; 1130 1131 return 0; 1132} 1133 1134 1135static int test_driver_set_sta_vlan(void *priv, const u8 *addr, 1136 const char *ifname, int vlan_id) 1137{ 1138 wpa_printf(MSG_DEBUG, "%s(addr=" MACSTR " ifname=%s vlan_id=%d)", 1139 __func__, MAC2STR(addr), ifname, vlan_id); 1140 return 0; 1141} 1142 1143 1144static int test_driver_sta_add(void *priv, 1145 struct hostapd_sta_add_params *params) 1146{ 1147 struct test_driver_bss *bss = priv; 1148 struct wpa_driver_test_data *drv = bss->drv; 1149 struct test_client_socket *cli; 1150 1151 wpa_printf(MSG_DEBUG, "%s(ifname=%s addr=" MACSTR " aid=%d " 1152 "capability=0x%x listen_interval=%d)", 1153 __func__, bss->ifname, MAC2STR(params->addr), params->aid, 1154 params->capability, params->listen_interval); 1155 wpa_hexdump(MSG_DEBUG, "test_driver_sta_add - supp_rates", 1156 params->supp_rates, params->supp_rates_len); 1157 1158 cli = drv->cli; 1159 while (cli) { 1160 if (os_memcmp(cli->addr, params->addr, ETH_ALEN) == 0) 1161 break; 1162 cli = cli->next; 1163 } 1164 if (!cli) { 1165 wpa_printf(MSG_DEBUG, "%s: no matching client entry", 1166 __func__); 1167 return -1; 1168 } 1169 1170 cli->bss = bss; 1171 1172 return 0; 1173} 1174 1175 1176static struct wpa_driver_test_data * test_alloc_data(void *ctx, 1177 const char *ifname) 1178{ 1179 struct wpa_driver_test_data *drv; 1180 struct test_driver_bss *bss; 1181 1182 drv = os_zalloc(sizeof(struct wpa_driver_test_data)); 1183 if (drv == NULL) { 1184 wpa_printf(MSG_ERROR, "Could not allocate memory for test " 1185 "driver data"); 1186 return NULL; 1187 } 1188 1189 bss = os_zalloc(sizeof(struct test_driver_bss)); 1190 if (bss == NULL) { 1191 os_free(drv); 1192 return NULL; 1193 } 1194 1195 drv->ctx = ctx; 1196 wpa_trace_add_ref(drv, ctx, ctx); 1197 dl_list_init(&drv->bss); 1198 dl_list_add(&drv->bss, &bss->list); 1199 os_strlcpy(bss->ifname, ifname, IFNAMSIZ); 1200 bss->bss_ctx = ctx; 1201 bss->drv = drv; 1202 1203 /* Generate a MAC address to help testing with multiple STAs */ 1204 drv->own_addr[0] = 0x02; /* locally administered */ 1205 sha1_prf((const u8 *) ifname, os_strlen(ifname), 1206 "test mac addr generation", 1207 NULL, 0, drv->own_addr + 1, ETH_ALEN - 1); 1208 1209 return drv; 1210} 1211 1212 1213static void * test_driver_init(struct hostapd_data *hapd, 1214 struct wpa_init_params *params) 1215{ 1216 struct wpa_driver_test_data *drv; 1217 struct sockaddr_un addr_un; 1218 struct sockaddr_in addr_in; 1219 struct sockaddr *addr; 1220 socklen_t alen; 1221 struct test_driver_bss *bss; 1222 1223 drv = test_alloc_data(hapd, params->ifname); 1224 if (drv == NULL) 1225 return NULL; 1226 drv->ap = 1; 1227 bss = dl_list_first(&drv->bss, struct test_driver_bss, list); 1228 drv->global = params->global_priv; 1229 1230 bss->bss_ctx = hapd; 1231 os_memcpy(bss->bssid, drv->own_addr, ETH_ALEN); 1232 os_memcpy(params->own_addr, drv->own_addr, ETH_ALEN); 1233 1234 if (params->test_socket) { 1235 if (os_strlen(params->test_socket) >= 1236 sizeof(addr_un.sun_path)) { 1237 printf("Too long test_socket path\n"); 1238 wpa_driver_test_deinit(bss); 1239 return NULL; 1240 } 1241 if (strncmp(params->test_socket, "DIR:", 4) == 0) { 1242 size_t len = strlen(params->test_socket) + 30; 1243 drv->test_dir = os_strdup(params->test_socket + 4); 1244 drv->own_socket_path = os_malloc(len); 1245 if (drv->own_socket_path) { 1246 snprintf(drv->own_socket_path, len, 1247 "%s/AP-" MACSTR, 1248 params->test_socket + 4, 1249 MAC2STR(params->own_addr)); 1250 } 1251 } else if (strncmp(params->test_socket, "UDP:", 4) == 0) { 1252 drv->udp_port = atoi(params->test_socket + 4); 1253 } else { 1254 drv->own_socket_path = os_strdup(params->test_socket); 1255 } 1256 if (drv->own_socket_path == NULL && drv->udp_port == 0) { 1257 wpa_driver_test_deinit(bss); 1258 return NULL; 1259 } 1260 1261 drv->test_socket = socket(drv->udp_port ? PF_INET : PF_UNIX, 1262 SOCK_DGRAM, 0); 1263 if (drv->test_socket < 0) { 1264 perror("socket"); 1265 wpa_driver_test_deinit(bss); 1266 return NULL; 1267 } 1268 1269 if (drv->udp_port) { 1270 os_memset(&addr_in, 0, sizeof(addr_in)); 1271 addr_in.sin_family = AF_INET; 1272 addr_in.sin_port = htons(drv->udp_port); 1273 addr = (struct sockaddr *) &addr_in; 1274 alen = sizeof(addr_in); 1275 } else { 1276 os_memset(&addr_un, 0, sizeof(addr_un)); 1277 addr_un.sun_family = AF_UNIX; 1278 os_strlcpy(addr_un.sun_path, drv->own_socket_path, 1279 sizeof(addr_un.sun_path)); 1280 addr = (struct sockaddr *) &addr_un; 1281 alen = sizeof(addr_un); 1282 } 1283 if (bind(drv->test_socket, addr, alen) < 0) { 1284 perror("bind(PF_UNIX)"); 1285 close(drv->test_socket); 1286 if (drv->own_socket_path) 1287 unlink(drv->own_socket_path); 1288 wpa_driver_test_deinit(bss); 1289 return NULL; 1290 } 1291 eloop_register_read_sock(drv->test_socket, 1292 test_driver_receive_unix, drv, NULL); 1293 } else 1294 drv->test_socket = -1; 1295 1296 return bss; 1297} 1298 1299 1300static void wpa_driver_test_poll(void *eloop_ctx, void *timeout_ctx) 1301{ 1302 struct wpa_driver_test_data *drv = eloop_ctx; 1303 1304#ifdef DRIVER_TEST_UNIX 1305 if (drv->associated && drv->hostapd_addr_set) { 1306 struct stat st; 1307 if (stat(drv->hostapd_addr.sun_path, &st) < 0) { 1308 wpa_printf(MSG_DEBUG, "%s: lost connection to AP: %s", 1309 __func__, strerror(errno)); 1310 drv->associated = 0; 1311 wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL); 1312 } 1313 } 1314#endif /* DRIVER_TEST_UNIX */ 1315 1316 eloop_register_timeout(1, 0, wpa_driver_test_poll, drv, NULL); 1317} 1318 1319 1320static void wpa_driver_test_scan_timeout(void *eloop_ctx, void *timeout_ctx) 1321{ 1322 struct wpa_driver_test_data *drv = eloop_ctx; 1323 wpa_printf(MSG_DEBUG, "Scan timeout - try to get results"); 1324 if (drv->pending_p2p_scan && drv->p2p) { 1325#ifdef CONFIG_P2P 1326 size_t i; 1327 for (i = 0; i < drv->num_scanres; i++) { 1328 struct wpa_scan_res *bss = drv->scanres[i]; 1329 if (p2p_scan_res_handler(drv->p2p, bss->bssid, 1330 bss->freq, bss->level, 1331 (const u8 *) (bss + 1), 1332 bss->ie_len) > 0) 1333 return; 1334 } 1335 p2p_scan_res_handled(drv->p2p); 1336#endif /* CONFIG_P2P */ 1337 return; 1338 } 1339 wpa_supplicant_event(timeout_ctx, EVENT_SCAN_RESULTS, NULL); 1340} 1341 1342 1343#ifdef DRIVER_TEST_UNIX 1344static void wpa_driver_scan_dir(struct wpa_driver_test_data *drv, 1345 const char *path) 1346{ 1347 struct dirent *dent; 1348 DIR *dir; 1349 struct sockaddr_un addr; 1350 char cmd[512], *pos, *end; 1351 int ret; 1352 1353 dir = opendir(path); 1354 if (dir == NULL) 1355 return; 1356 1357 end = cmd + sizeof(cmd); 1358 pos = cmd; 1359 ret = os_snprintf(pos, end - pos, "SCAN " MACSTR, 1360 MAC2STR(drv->own_addr)); 1361 if (ret >= 0 && ret < end - pos) 1362 pos += ret; 1363 if (drv->probe_req_ie) { 1364 ret = os_snprintf(pos, end - pos, " "); 1365 if (ret >= 0 && ret < end - pos) 1366 pos += ret; 1367 pos += wpa_snprintf_hex(pos, end - pos, drv->probe_req_ie, 1368 drv->probe_req_ie_len); 1369 } 1370 if (drv->probe_req_ssid_len) { 1371 /* Add SSID IE */ 1372 ret = os_snprintf(pos, end - pos, "%02x%02x", 1373 WLAN_EID_SSID, 1374 (unsigned int) drv->probe_req_ssid_len); 1375 if (ret >= 0 && ret < end - pos) 1376 pos += ret; 1377 pos += wpa_snprintf_hex(pos, end - pos, drv->probe_req_ssid, 1378 drv->probe_req_ssid_len); 1379 } 1380 end[-1] = '\0'; 1381 1382 while ((dent = readdir(dir))) { 1383 if (os_strncmp(dent->d_name, "AP-", 3) != 0 && 1384 os_strncmp(dent->d_name, "STA-", 4) != 0) 1385 continue; 1386 if (drv->own_socket_path) { 1387 size_t olen, dlen; 1388 olen = os_strlen(drv->own_socket_path); 1389 dlen = os_strlen(dent->d_name); 1390 if (olen >= dlen && 1391 os_strcmp(dent->d_name, 1392 drv->own_socket_path + olen - dlen) == 0) 1393 continue; 1394 } 1395 wpa_printf(MSG_DEBUG, "%s: SCAN %s", __func__, dent->d_name); 1396 1397 os_memset(&addr, 0, sizeof(addr)); 1398 addr.sun_family = AF_UNIX; 1399 os_snprintf(addr.sun_path, sizeof(addr.sun_path), "%s/%s", 1400 path, dent->d_name); 1401 1402 if (sendto(drv->test_socket, cmd, os_strlen(cmd), 0, 1403 (struct sockaddr *) &addr, sizeof(addr)) < 0) { 1404 perror("sendto(test_socket)"); 1405 } 1406 } 1407 closedir(dir); 1408} 1409#endif /* DRIVER_TEST_UNIX */ 1410 1411 1412static int wpa_driver_test_scan(void *priv, 1413 struct wpa_driver_scan_params *params) 1414{ 1415 struct test_driver_bss *dbss = priv; 1416 struct wpa_driver_test_data *drv = dbss->drv; 1417 size_t i; 1418 1419 wpa_printf(MSG_DEBUG, "%s: priv=%p", __func__, priv); 1420 1421 os_free(drv->probe_req_ie); 1422 if (params->extra_ies) { 1423 drv->probe_req_ie = os_malloc(params->extra_ies_len); 1424 if (drv->probe_req_ie == NULL) { 1425 drv->probe_req_ie_len = 0; 1426 return -1; 1427 } 1428 os_memcpy(drv->probe_req_ie, params->extra_ies, 1429 params->extra_ies_len); 1430 drv->probe_req_ie_len = params->extra_ies_len; 1431 } else { 1432 drv->probe_req_ie = NULL; 1433 drv->probe_req_ie_len = 0; 1434 } 1435 1436 for (i = 0; i < params->num_ssids; i++) 1437 wpa_hexdump(MSG_DEBUG, "Scan SSID", 1438 params->ssids[i].ssid, params->ssids[i].ssid_len); 1439 drv->probe_req_ssid_len = 0; 1440 if (params->num_ssids) { 1441 os_memcpy(drv->probe_req_ssid, params->ssids[0].ssid, 1442 params->ssids[0].ssid_len); 1443 drv->probe_req_ssid_len = params->ssids[0].ssid_len; 1444 } 1445 wpa_hexdump(MSG_DEBUG, "Scan extra IE(s)", 1446 params->extra_ies, params->extra_ies_len); 1447 1448 drv->num_scanres = 0; 1449 1450#ifdef DRIVER_TEST_UNIX 1451 if (drv->test_socket >= 0 && drv->test_dir) 1452 wpa_driver_scan_dir(drv, drv->test_dir); 1453 1454 if (drv->test_socket >= 0 && drv->hostapd_addr_set && 1455 sendto(drv->test_socket, "SCAN", 4, 0, 1456 (struct sockaddr *) &drv->hostapd_addr, 1457 sizeof(drv->hostapd_addr)) < 0) { 1458 perror("sendto(test_socket)"); 1459 } 1460#endif /* DRIVER_TEST_UNIX */ 1461 1462 if (drv->test_socket >= 0 && drv->hostapd_addr_udp_set && 1463 sendto(drv->test_socket, "SCAN", 4, 0, 1464 (struct sockaddr *) &drv->hostapd_addr_udp, 1465 sizeof(drv->hostapd_addr_udp)) < 0) { 1466 perror("sendto(test_socket)"); 1467 } 1468 1469 eloop_cancel_timeout(wpa_driver_test_scan_timeout, drv, drv->ctx); 1470 eloop_register_timeout(1, 0, wpa_driver_test_scan_timeout, drv, 1471 drv->ctx); 1472 return 0; 1473} 1474 1475 1476static struct wpa_scan_results * wpa_driver_test_get_scan_results2(void *priv) 1477{ 1478 struct test_driver_bss *dbss = priv; 1479 struct wpa_driver_test_data *drv = dbss->drv; 1480 struct wpa_scan_results *res; 1481 size_t i; 1482 1483 res = os_zalloc(sizeof(*res)); 1484 if (res == NULL) 1485 return NULL; 1486 1487 res->res = os_zalloc(drv->num_scanres * sizeof(struct wpa_scan_res *)); 1488 if (res->res == NULL) { 1489 os_free(res); 1490 return NULL; 1491 } 1492 1493 for (i = 0; i < drv->num_scanres; i++) { 1494 struct wpa_scan_res *r; 1495 if (drv->scanres[i] == NULL) 1496 continue; 1497 r = os_malloc(sizeof(*r) + drv->scanres[i]->ie_len); 1498 if (r == NULL) 1499 break; 1500 os_memcpy(r, drv->scanres[i], 1501 sizeof(*r) + drv->scanres[i]->ie_len); 1502 res->res[res->num++] = r; 1503 } 1504 1505 return res; 1506} 1507 1508 1509static int wpa_driver_test_set_key(const char *ifname, void *priv, 1510 enum wpa_alg alg, const u8 *addr, 1511 int key_idx, int set_tx, 1512 const u8 *seq, size_t seq_len, 1513 const u8 *key, size_t key_len) 1514{ 1515 wpa_printf(MSG_DEBUG, "%s: ifname=%s priv=%p alg=%d key_idx=%d " 1516 "set_tx=%d", 1517 __func__, ifname, priv, alg, key_idx, set_tx); 1518 if (addr) 1519 wpa_printf(MSG_DEBUG, " addr=" MACSTR, MAC2STR(addr)); 1520 if (seq) 1521 wpa_hexdump(MSG_DEBUG, " seq", seq, seq_len); 1522 if (key) 1523 wpa_hexdump_key(MSG_DEBUG, " key", key, key_len); 1524 return 0; 1525} 1526 1527 1528static int wpa_driver_update_mode(struct wpa_driver_test_data *drv, int ap) 1529{ 1530 if (ap && !drv->ap) { 1531 wpa_driver_test_close_test_socket(drv); 1532 wpa_driver_test_attach(drv, drv->test_dir, 1); 1533 drv->ap = 1; 1534 } else if (!ap && drv->ap) { 1535 wpa_driver_test_close_test_socket(drv); 1536 wpa_driver_test_attach(drv, drv->test_dir, 0); 1537 drv->ap = 0; 1538 } 1539 1540 return 0; 1541} 1542 1543 1544static int wpa_driver_test_associate( 1545 void *priv, struct wpa_driver_associate_params *params) 1546{ 1547 struct test_driver_bss *dbss = priv; 1548 struct wpa_driver_test_data *drv = dbss->drv; 1549 wpa_printf(MSG_DEBUG, "%s: priv=%p freq=%d pairwise_suite=%d " 1550 "group_suite=%d key_mgmt_suite=%d auth_alg=%d mode=%d", 1551 __func__, priv, params->freq, params->pairwise_suite, 1552 params->group_suite, params->key_mgmt_suite, 1553 params->auth_alg, params->mode); 1554 wpa_driver_update_mode(drv, params->mode == IEEE80211_MODE_AP); 1555 if (params->bssid) { 1556 wpa_printf(MSG_DEBUG, " bssid=" MACSTR, 1557 MAC2STR(params->bssid)); 1558 } 1559 if (params->ssid) { 1560 wpa_hexdump_ascii(MSG_DEBUG, " ssid", 1561 params->ssid, params->ssid_len); 1562 } 1563 if (params->wpa_ie) { 1564 wpa_hexdump(MSG_DEBUG, " wpa_ie", 1565 params->wpa_ie, params->wpa_ie_len); 1566 drv->assoc_wpa_ie_len = params->wpa_ie_len; 1567 if (drv->assoc_wpa_ie_len > sizeof(drv->assoc_wpa_ie)) 1568 drv->assoc_wpa_ie_len = sizeof(drv->assoc_wpa_ie); 1569 os_memcpy(drv->assoc_wpa_ie, params->wpa_ie, 1570 drv->assoc_wpa_ie_len); 1571 } else 1572 drv->assoc_wpa_ie_len = 0; 1573 1574 wpa_driver_update_mode(drv, params->mode == IEEE80211_MODE_AP); 1575 1576 drv->ibss = params->mode == IEEE80211_MODE_IBSS; 1577 dbss->privacy = params->key_mgmt_suite & 1578 (WPA_KEY_MGMT_IEEE8021X | 1579 WPA_KEY_MGMT_PSK | 1580 WPA_KEY_MGMT_WPA_NONE | 1581 WPA_KEY_MGMT_FT_IEEE8021X | 1582 WPA_KEY_MGMT_FT_PSK | 1583 WPA_KEY_MGMT_IEEE8021X_SHA256 | 1584 WPA_KEY_MGMT_PSK_SHA256); 1585 if (params->wep_key_len[params->wep_tx_keyidx]) 1586 dbss->privacy = 1; 1587 1588#ifdef DRIVER_TEST_UNIX 1589 if (drv->test_dir && params->bssid && 1590 params->mode != IEEE80211_MODE_IBSS) { 1591 os_memset(&drv->hostapd_addr, 0, sizeof(drv->hostapd_addr)); 1592 drv->hostapd_addr.sun_family = AF_UNIX; 1593 os_snprintf(drv->hostapd_addr.sun_path, 1594 sizeof(drv->hostapd_addr.sun_path), 1595 "%s/AP-" MACSTR, 1596 drv->test_dir, MAC2STR(params->bssid)); 1597 drv->hostapd_addr_set = 1; 1598 } 1599#endif /* DRIVER_TEST_UNIX */ 1600 1601 if (params->mode == IEEE80211_MODE_AP) { 1602 os_memcpy(dbss->ssid, params->ssid, params->ssid_len); 1603 dbss->ssid_len = params->ssid_len; 1604 os_memcpy(dbss->bssid, drv->own_addr, ETH_ALEN); 1605 if (params->wpa_ie && params->wpa_ie_len) { 1606 dbss->ie = os_malloc(params->wpa_ie_len); 1607 if (dbss->ie) { 1608 os_memcpy(dbss->ie, params->wpa_ie, 1609 params->wpa_ie_len); 1610 dbss->ielen = params->wpa_ie_len; 1611 } 1612 } 1613 } else if (drv->test_socket >= 0 && 1614 (drv->hostapd_addr_set || drv->hostapd_addr_udp_set)) { 1615 char cmd[200], *pos, *end; 1616 int ret; 1617 end = cmd + sizeof(cmd); 1618 pos = cmd; 1619 ret = os_snprintf(pos, end - pos, "ASSOC " MACSTR " ", 1620 MAC2STR(drv->own_addr)); 1621 if (ret >= 0 && ret < end - pos) 1622 pos += ret; 1623 pos += wpa_snprintf_hex(pos, end - pos, params->ssid, 1624 params->ssid_len); 1625 ret = os_snprintf(pos, end - pos, " "); 1626 if (ret >= 0 && ret < end - pos) 1627 pos += ret; 1628 pos += wpa_snprintf_hex(pos, end - pos, params->wpa_ie, 1629 params->wpa_ie_len); 1630 end[-1] = '\0'; 1631#ifdef DRIVER_TEST_UNIX 1632 if (drv->hostapd_addr_set && 1633 sendto(drv->test_socket, cmd, os_strlen(cmd), 0, 1634 (struct sockaddr *) &drv->hostapd_addr, 1635 sizeof(drv->hostapd_addr)) < 0) { 1636 perror("sendto(test_socket)"); 1637 return -1; 1638 } 1639#endif /* DRIVER_TEST_UNIX */ 1640 if (drv->hostapd_addr_udp_set && 1641 sendto(drv->test_socket, cmd, os_strlen(cmd), 0, 1642 (struct sockaddr *) &drv->hostapd_addr_udp, 1643 sizeof(drv->hostapd_addr_udp)) < 0) { 1644 perror("sendto(test_socket)"); 1645 return -1; 1646 } 1647 1648 os_memcpy(dbss->ssid, params->ssid, params->ssid_len); 1649 dbss->ssid_len = params->ssid_len; 1650 } else { 1651 drv->associated = 1; 1652 if (params->mode == IEEE80211_MODE_IBSS) { 1653 os_memcpy(dbss->ssid, params->ssid, params->ssid_len); 1654 dbss->ssid_len = params->ssid_len; 1655 if (params->bssid) 1656 os_memcpy(dbss->bssid, params->bssid, 1657 ETH_ALEN); 1658 else { 1659 os_get_random(dbss->bssid, ETH_ALEN); 1660 dbss->bssid[0] &= ~0x01; 1661 dbss->bssid[0] |= 0x02; 1662 } 1663 } 1664 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, NULL); 1665 } 1666 1667 return 0; 1668} 1669 1670 1671static int wpa_driver_test_get_bssid(void *priv, u8 *bssid) 1672{ 1673 struct test_driver_bss *dbss = priv; 1674 os_memcpy(bssid, dbss->bssid, ETH_ALEN); 1675 return 0; 1676} 1677 1678 1679static int wpa_driver_test_get_ssid(void *priv, u8 *ssid) 1680{ 1681 struct test_driver_bss *dbss = priv; 1682 os_memcpy(ssid, dbss->ssid, 32); 1683 return dbss->ssid_len; 1684} 1685 1686 1687static int wpa_driver_test_send_disassoc(struct wpa_driver_test_data *drv) 1688{ 1689#ifdef DRIVER_TEST_UNIX 1690 if (drv->test_socket >= 0 && 1691 sendto(drv->test_socket, "DISASSOC", 8, 0, 1692 (struct sockaddr *) &drv->hostapd_addr, 1693 sizeof(drv->hostapd_addr)) < 0) { 1694 perror("sendto(test_socket)"); 1695 return -1; 1696 } 1697#endif /* DRIVER_TEST_UNIX */ 1698 if (drv->test_socket >= 0 && drv->hostapd_addr_udp_set && 1699 sendto(drv->test_socket, "DISASSOC", 8, 0, 1700 (struct sockaddr *) &drv->hostapd_addr_udp, 1701 sizeof(drv->hostapd_addr_udp)) < 0) { 1702 perror("sendto(test_socket)"); 1703 return -1; 1704 } 1705 return 0; 1706} 1707 1708 1709static int wpa_driver_test_deauthenticate(void *priv, const u8 *addr, 1710 int reason_code) 1711{ 1712 struct test_driver_bss *dbss = priv; 1713 struct wpa_driver_test_data *drv = dbss->drv; 1714 wpa_printf(MSG_DEBUG, "%s addr=" MACSTR " reason_code=%d", 1715 __func__, MAC2STR(addr), reason_code); 1716 os_memset(dbss->bssid, 0, ETH_ALEN); 1717 drv->associated = 0; 1718 wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL); 1719 return wpa_driver_test_send_disassoc(drv); 1720} 1721 1722 1723static int wpa_driver_test_disassociate(void *priv, const u8 *addr, 1724 int reason_code) 1725{ 1726 struct test_driver_bss *dbss = priv; 1727 struct wpa_driver_test_data *drv = dbss->drv; 1728 wpa_printf(MSG_DEBUG, "%s addr=" MACSTR " reason_code=%d", 1729 __func__, MAC2STR(addr), reason_code); 1730 os_memset(dbss->bssid, 0, ETH_ALEN); 1731 drv->associated = 0; 1732 wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL); 1733 return wpa_driver_test_send_disassoc(drv); 1734} 1735 1736 1737static const u8 * wpa_scan_get_ie(const struct wpa_scan_res *res, u8 ie) 1738{ 1739 const u8 *end, *pos; 1740 1741 pos = (const u8 *) (res + 1); 1742 end = pos + res->ie_len; 1743 1744 while (pos + 1 < end) { 1745 if (pos + 2 + pos[1] > end) 1746 break; 1747 if (pos[0] == ie) 1748 return pos; 1749 pos += 2 + pos[1]; 1750 } 1751 1752 return NULL; 1753} 1754 1755 1756static void wpa_driver_test_scanresp(struct wpa_driver_test_data *drv, 1757 struct sockaddr *from, 1758 socklen_t fromlen, 1759 const char *data) 1760{ 1761 struct wpa_scan_res *res; 1762 const char *pos, *pos2; 1763 size_t len; 1764 u8 *ie_pos, *ie_start, *ie_end; 1765#define MAX_IE_LEN 1000 1766 const u8 *ds_params; 1767 1768 wpa_printf(MSG_DEBUG, "test_driver: SCANRESP %s", data); 1769 if (drv->num_scanres >= MAX_SCAN_RESULTS) { 1770 wpa_printf(MSG_DEBUG, "test_driver: No room for the new scan " 1771 "result"); 1772 return; 1773 } 1774 1775 /* SCANRESP BSSID SSID IEs */ 1776 1777 res = os_zalloc(sizeof(*res) + MAX_IE_LEN); 1778 if (res == NULL) 1779 return; 1780 ie_start = ie_pos = (u8 *) (res + 1); 1781 ie_end = ie_pos + MAX_IE_LEN; 1782 1783 if (hwaddr_aton(data, res->bssid)) { 1784 wpa_printf(MSG_DEBUG, "test_driver: invalid BSSID in scanres"); 1785 os_free(res); 1786 return; 1787 } 1788 1789 pos = data + 17; 1790 while (*pos == ' ') 1791 pos++; 1792 pos2 = os_strchr(pos, ' '); 1793 if (pos2 == NULL) { 1794 wpa_printf(MSG_DEBUG, "test_driver: invalid SSID termination " 1795 "in scanres"); 1796 os_free(res); 1797 return; 1798 } 1799 len = (pos2 - pos) / 2; 1800 if (len > 32) 1801 len = 32; 1802 /* 1803 * Generate SSID IE from the SSID field since this IE is not included 1804 * in the main IE field. 1805 */ 1806 *ie_pos++ = WLAN_EID_SSID; 1807 *ie_pos++ = len; 1808 if (hexstr2bin(pos, ie_pos, len) < 0) { 1809 wpa_printf(MSG_DEBUG, "test_driver: invalid SSID in scanres"); 1810 os_free(res); 1811 return; 1812 } 1813 ie_pos += len; 1814 1815 pos = pos2 + 1; 1816 pos2 = os_strchr(pos, ' '); 1817 if (pos2 == NULL) 1818 len = os_strlen(pos) / 2; 1819 else 1820 len = (pos2 - pos) / 2; 1821 if ((int) len > ie_end - ie_pos) 1822 len = ie_end - ie_pos; 1823 if (hexstr2bin(pos, ie_pos, len) < 0) { 1824 wpa_printf(MSG_DEBUG, "test_driver: invalid IEs in scanres"); 1825 os_free(res); 1826 return; 1827 } 1828 ie_pos += len; 1829 res->ie_len = ie_pos - ie_start; 1830 1831 if (pos2) { 1832 pos = pos2 + 1; 1833 while (*pos == ' ') 1834 pos++; 1835 if (os_strstr(pos, "PRIVACY")) 1836 res->caps |= IEEE80211_CAP_PRIVACY; 1837 if (os_strstr(pos, "IBSS")) 1838 res->caps |= IEEE80211_CAP_IBSS; 1839 } 1840 1841 ds_params = wpa_scan_get_ie(res, WLAN_EID_DS_PARAMS); 1842 if (ds_params && ds_params[1] > 0) { 1843 if (ds_params[2] >= 1 && ds_params[2] <= 13) 1844 res->freq = 2407 + ds_params[2] * 5; 1845 } 1846 1847 os_free(drv->scanres[drv->num_scanres]); 1848 drv->scanres[drv->num_scanres++] = res; 1849} 1850 1851 1852static void wpa_driver_test_assocresp(struct wpa_driver_test_data *drv, 1853 struct sockaddr *from, 1854 socklen_t fromlen, 1855 const char *data) 1856{ 1857 struct test_driver_bss *bss; 1858 1859 bss = dl_list_first(&drv->bss, struct test_driver_bss, list); 1860 1861 /* ASSOCRESP BSSID <res> */ 1862 if (hwaddr_aton(data, bss->bssid)) { 1863 wpa_printf(MSG_DEBUG, "test_driver: invalid BSSID in " 1864 "assocresp"); 1865 } 1866 if (drv->use_associnfo) { 1867 union wpa_event_data event; 1868 os_memset(&event, 0, sizeof(event)); 1869 event.assoc_info.req_ies = drv->assoc_wpa_ie; 1870 event.assoc_info.req_ies_len = drv->assoc_wpa_ie_len; 1871 wpa_supplicant_event(drv->ctx, EVENT_ASSOCINFO, &event); 1872 } 1873 drv->associated = 1; 1874 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, NULL); 1875} 1876 1877 1878static void wpa_driver_test_disassoc(struct wpa_driver_test_data *drv, 1879 struct sockaddr *from, 1880 socklen_t fromlen) 1881{ 1882 drv->associated = 0; 1883 wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL); 1884} 1885 1886 1887static void wpa_driver_test_eapol(struct wpa_driver_test_data *drv, 1888 struct sockaddr *from, 1889 socklen_t fromlen, 1890 const u8 *data, size_t data_len) 1891{ 1892 const u8 *src; 1893 struct test_driver_bss *bss; 1894 1895 bss = dl_list_first(&drv->bss, struct test_driver_bss, list); 1896 1897 if (data_len > 14) { 1898 /* Skip Ethernet header */ 1899 src = data + ETH_ALEN; 1900 data += 14; 1901 data_len -= 14; 1902 } else 1903 src = bss->bssid; 1904 1905 drv_event_eapol_rx(drv->ctx, src, data, data_len); 1906} 1907 1908 1909static void wpa_driver_test_mlme(struct wpa_driver_test_data *drv, 1910 struct sockaddr *from, 1911 socklen_t fromlen, 1912 const u8 *data, size_t data_len) 1913{ 1914 int freq = 0, own_freq; 1915 union wpa_event_data event; 1916 const struct ieee80211_mgmt *mgmt; 1917 u16 fc; 1918 struct test_driver_bss *bss; 1919 1920 bss = dl_list_first(&drv->bss, struct test_driver_bss, list); 1921 if (data_len > 6 && os_memcmp(data, "freq=", 5) == 0) { 1922 size_t pos; 1923 for (pos = 5; pos < data_len; pos++) { 1924 if (data[pos] == ' ') 1925 break; 1926 } 1927 if (pos < data_len) { 1928 freq = atoi((const char *) &data[5]); 1929 wpa_printf(MSG_DEBUG, "test_driver(%s): MLME RX on " 1930 "freq %d MHz", bss->ifname, freq); 1931 pos++; 1932 data += pos; 1933 data_len -= pos; 1934 } 1935 } 1936 1937 if (drv->remain_on_channel_freq) 1938 own_freq = drv->remain_on_channel_freq; 1939 else 1940 own_freq = drv->current_freq; 1941 1942 if (freq && own_freq && freq != own_freq) { 1943 wpa_printf(MSG_DEBUG, "test_driver(%s): Ignore MLME RX on " 1944 "another frequency %d MHz (own %d MHz)", 1945 bss->ifname, freq, own_freq); 1946 return; 1947 } 1948 1949 os_memset(&event, 0, sizeof(event)); 1950 event.mlme_rx.buf = data; 1951 event.mlme_rx.len = data_len; 1952 event.mlme_rx.freq = freq; 1953 wpa_supplicant_event(drv->ctx, EVENT_MLME_RX, &event); 1954 1955 mgmt = (const struct ieee80211_mgmt *) data; 1956 fc = le_to_host16(mgmt->frame_control); 1957 1958 if (drv->probe_req_report && data_len >= 24) { 1959 if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT && 1960 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_PROBE_REQ) { 1961 os_memset(&event, 0, sizeof(event)); 1962 event.rx_probe_req.sa = mgmt->sa; 1963 event.rx_probe_req.da = mgmt->da; 1964 event.rx_probe_req.bssid = mgmt->bssid; 1965 event.rx_probe_req.ie = mgmt->u.probe_req.variable; 1966 event.rx_probe_req.ie_len = 1967 data_len - (mgmt->u.probe_req.variable - data); 1968 wpa_supplicant_event(drv->ctx, EVENT_RX_PROBE_REQ, 1969 &event); 1970#ifdef CONFIG_P2P 1971 if (drv->p2p) 1972 p2p_probe_req_rx(drv->p2p, mgmt->sa, 1973 mgmt->da, mgmt->bssid, 1974 event.rx_probe_req.ie, 1975 event.rx_probe_req.ie_len); 1976#endif /* CONFIG_P2P */ 1977 } 1978 } 1979 1980#ifdef CONFIG_P2P 1981 if (drv->p2p && 1982 WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT && 1983 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_ACTION) { 1984 size_t hdr_len; 1985 hdr_len = (const u8 *) 1986 &mgmt->u.action.u.vs_public_action.action - data; 1987 p2p_rx_action(drv->p2p, mgmt->da, mgmt->sa, mgmt->bssid, 1988 mgmt->u.action.category, 1989 &mgmt->u.action.u.vs_public_action.action, 1990 data_len - hdr_len, freq); 1991 } 1992#endif /* CONFIG_P2P */ 1993 1994} 1995 1996 1997static void wpa_driver_test_scan_cmd(struct wpa_driver_test_data *drv, 1998 struct sockaddr *from, 1999 socklen_t fromlen, 2000 const u8 *data, size_t data_len) 2001{ 2002 char buf[512], *pos, *end; 2003 int ret; 2004 struct test_driver_bss *bss; 2005 2006 bss = dl_list_first(&drv->bss, struct test_driver_bss, list); 2007 2008 /* data: optional [ STA-addr | ' ' | IEs(hex) ] */ 2009#ifdef CONFIG_P2P 2010 if (drv->probe_req_report && drv->p2p && data_len) { 2011 const char *d = (const char *) data; 2012 u8 sa[ETH_ALEN]; 2013 u8 ie[512]; 2014 size_t ielen; 2015 2016 if (hwaddr_aton(d, sa)) 2017 return; 2018 d += 18; 2019 while (*d == ' ') 2020 d++; 2021 ielen = os_strlen(d) / 2; 2022 if (ielen > sizeof(ie)) 2023 ielen = sizeof(ie); 2024 if (hexstr2bin(d, ie, ielen) < 0) 2025 ielen = 0; 2026 drv->probe_from = from; 2027 drv->probe_from_len = fromlen; 2028 p2p_probe_req_rx(drv->p2p, sa, NULL, NULL, ie, ielen); 2029 drv->probe_from = NULL; 2030 } 2031#endif /* CONFIG_P2P */ 2032 2033 if (!drv->ibss) 2034 return; 2035 2036 pos = buf; 2037 end = buf + sizeof(buf); 2038 2039 /* reply: SCANRESP BSSID SSID IEs */ 2040 ret = snprintf(pos, end - pos, "SCANRESP " MACSTR " ", 2041 MAC2STR(bss->bssid)); 2042 if (ret < 0 || ret >= end - pos) 2043 return; 2044 pos += ret; 2045 pos += wpa_snprintf_hex(pos, end - pos, 2046 bss->ssid, bss->ssid_len); 2047 ret = snprintf(pos, end - pos, " "); 2048 if (ret < 0 || ret >= end - pos) 2049 return; 2050 pos += ret; 2051 pos += wpa_snprintf_hex(pos, end - pos, drv->assoc_wpa_ie, 2052 drv->assoc_wpa_ie_len); 2053 2054 if (bss->privacy) { 2055 ret = snprintf(pos, end - pos, " PRIVACY"); 2056 if (ret < 0 || ret >= end - pos) 2057 return; 2058 pos += ret; 2059 } 2060 2061 ret = snprintf(pos, end - pos, " IBSS"); 2062 if (ret < 0 || ret >= end - pos) 2063 return; 2064 pos += ret; 2065 2066 sendto(drv->test_socket, buf, pos - buf, 0, 2067 (struct sockaddr *) from, fromlen); 2068} 2069 2070 2071static void wpa_driver_test_receive_unix(int sock, void *eloop_ctx, 2072 void *sock_ctx) 2073{ 2074 struct wpa_driver_test_data *drv = eloop_ctx; 2075 char *buf; 2076 int res; 2077 struct sockaddr_storage from; 2078 socklen_t fromlen = sizeof(from); 2079 const size_t buflen = 2000; 2080 2081 if (drv->ap) { 2082 test_driver_receive_unix(sock, eloop_ctx, sock_ctx); 2083 return; 2084 } 2085 2086 buf = os_malloc(buflen); 2087 if (buf == NULL) 2088 return; 2089 res = recvfrom(sock, buf, buflen - 1, 0, 2090 (struct sockaddr *) &from, &fromlen); 2091 if (res < 0) { 2092 perror("recvfrom(test_socket)"); 2093 os_free(buf); 2094 return; 2095 } 2096 buf[res] = '\0'; 2097 2098 wpa_printf(MSG_DEBUG, "test_driver: received %u bytes", res); 2099 2100 if (os_strncmp(buf, "SCANRESP ", 9) == 0) { 2101 wpa_driver_test_scanresp(drv, (struct sockaddr *) &from, 2102 fromlen, buf + 9); 2103 } else if (os_strncmp(buf, "ASSOCRESP ", 10) == 0) { 2104 wpa_driver_test_assocresp(drv, (struct sockaddr *) &from, 2105 fromlen, buf + 10); 2106 } else if (os_strcmp(buf, "DISASSOC") == 0) { 2107 wpa_driver_test_disassoc(drv, (struct sockaddr *) &from, 2108 fromlen); 2109 } else if (os_strcmp(buf, "DEAUTH") == 0) { 2110 wpa_driver_test_disassoc(drv, (struct sockaddr *) &from, 2111 fromlen); 2112 } else if (os_strncmp(buf, "EAPOL ", 6) == 0) { 2113 wpa_driver_test_eapol(drv, (struct sockaddr *) &from, fromlen, 2114 (const u8 *) buf + 6, res - 6); 2115 } else if (os_strncmp(buf, "MLME ", 5) == 0) { 2116 wpa_driver_test_mlme(drv, (struct sockaddr *) &from, fromlen, 2117 (const u8 *) buf + 5, res - 5); 2118 } else if (os_strncmp(buf, "SCAN ", 5) == 0) { 2119 wpa_driver_test_scan_cmd(drv, (struct sockaddr *) &from, 2120 fromlen, 2121 (const u8 *) buf + 5, res - 5); 2122 } else { 2123 wpa_hexdump_ascii(MSG_DEBUG, "Unknown test_socket command", 2124 (u8 *) buf, res); 2125 } 2126 os_free(buf); 2127} 2128 2129 2130static void * wpa_driver_test_init2(void *ctx, const char *ifname, 2131 void *global_priv) 2132{ 2133 struct wpa_driver_test_data *drv; 2134 struct wpa_driver_test_global *global = global_priv; 2135 struct test_driver_bss *bss; 2136 2137 drv = test_alloc_data(ctx, ifname); 2138 if (drv == NULL) 2139 return NULL; 2140 bss = dl_list_first(&drv->bss, struct test_driver_bss, list); 2141 drv->global = global_priv; 2142 drv->test_socket = -1; 2143 2144 /* Set dummy BSSID and SSID for testing. */ 2145 bss->bssid[0] = 0x02; 2146 bss->bssid[1] = 0x00; 2147 bss->bssid[2] = 0x00; 2148 bss->bssid[3] = 0x00; 2149 bss->bssid[4] = 0x00; 2150 bss->bssid[5] = 0x01; 2151 os_memcpy(bss->ssid, "test", 5); 2152 bss->ssid_len = 4; 2153 2154 if (global->bss_add_used) { 2155 os_memcpy(drv->own_addr, global->req_addr, ETH_ALEN); 2156 global->bss_add_used = 0; 2157 } 2158 2159 eloop_register_timeout(1, 0, wpa_driver_test_poll, drv, NULL); 2160 2161 return bss; 2162} 2163 2164 2165static void wpa_driver_test_close_test_socket(struct wpa_driver_test_data *drv) 2166{ 2167 if (drv->test_socket >= 0) { 2168 eloop_unregister_read_sock(drv->test_socket); 2169 close(drv->test_socket); 2170 drv->test_socket = -1; 2171 } 2172 2173 if (drv->own_socket_path) { 2174 unlink(drv->own_socket_path); 2175 os_free(drv->own_socket_path); 2176 drv->own_socket_path = NULL; 2177 } 2178} 2179 2180 2181static void wpa_driver_test_deinit(void *priv) 2182{ 2183 struct test_driver_bss *dbss = priv; 2184 struct wpa_driver_test_data *drv = dbss->drv; 2185 struct test_client_socket *cli, *prev; 2186 int i; 2187 2188#ifdef CONFIG_P2P 2189 if (drv->p2p) 2190 p2p_deinit(drv->p2p); 2191 wpabuf_free(drv->pending_action_tx); 2192#endif /* CONFIG_P2P */ 2193 2194 cli = drv->cli; 2195 while (cli) { 2196 prev = cli; 2197 cli = cli->next; 2198 os_free(prev); 2199 } 2200 2201#ifdef HOSTAPD 2202 /* There should be only one BSS remaining at this point. */ 2203 if (dl_list_len(&drv->bss) != 1) 2204 wpa_printf(MSG_ERROR, "%s: %u remaining BSS entries", 2205 __func__, dl_list_len(&drv->bss)); 2206#endif /* HOSTAPD */ 2207 2208 test_driver_free_bsses(drv); 2209 2210 wpa_driver_test_close_test_socket(drv); 2211 eloop_cancel_timeout(wpa_driver_test_scan_timeout, drv, drv->ctx); 2212 eloop_cancel_timeout(wpa_driver_test_poll, drv, NULL); 2213 eloop_cancel_timeout(test_remain_on_channel_timeout, drv, NULL); 2214 os_free(drv->test_dir); 2215 for (i = 0; i < MAX_SCAN_RESULTS; i++) 2216 os_free(drv->scanres[i]); 2217 os_free(drv->probe_req_ie); 2218 wpa_trace_remove_ref(drv, ctx, drv->ctx); 2219 os_free(drv); 2220} 2221 2222 2223static int wpa_driver_test_attach(struct wpa_driver_test_data *drv, 2224 const char *dir, int ap) 2225{ 2226#ifdef DRIVER_TEST_UNIX 2227 static unsigned int counter = 0; 2228 struct sockaddr_un addr; 2229 size_t len; 2230 2231 os_free(drv->own_socket_path); 2232 if (dir) { 2233 len = os_strlen(dir) + 30; 2234 drv->own_socket_path = os_malloc(len); 2235 if (drv->own_socket_path == NULL) 2236 return -1; 2237 os_snprintf(drv->own_socket_path, len, "%s/%s-" MACSTR, 2238 dir, ap ? "AP" : "STA", MAC2STR(drv->own_addr)); 2239 } else { 2240 drv->own_socket_path = os_malloc(100); 2241 if (drv->own_socket_path == NULL) 2242 return -1; 2243 os_snprintf(drv->own_socket_path, 100, 2244 "/tmp/wpa_supplicant_test-%d-%d", 2245 getpid(), counter++); 2246 } 2247 2248 drv->test_socket = socket(PF_UNIX, SOCK_DGRAM, 0); 2249 if (drv->test_socket < 0) { 2250 perror("socket(PF_UNIX)"); 2251 os_free(drv->own_socket_path); 2252 drv->own_socket_path = NULL; 2253 return -1; 2254 } 2255 2256 os_memset(&addr, 0, sizeof(addr)); 2257 addr.sun_family = AF_UNIX; 2258 os_strlcpy(addr.sun_path, drv->own_socket_path, sizeof(addr.sun_path)); 2259 if (bind(drv->test_socket, (struct sockaddr *) &addr, 2260 sizeof(addr)) < 0) { 2261 perror("bind(PF_UNIX)"); 2262 close(drv->test_socket); 2263 unlink(drv->own_socket_path); 2264 os_free(drv->own_socket_path); 2265 drv->own_socket_path = NULL; 2266 return -1; 2267 } 2268 2269 eloop_register_read_sock(drv->test_socket, 2270 wpa_driver_test_receive_unix, drv, NULL); 2271 2272 return 0; 2273#else /* DRIVER_TEST_UNIX */ 2274 return -1; 2275#endif /* DRIVER_TEST_UNIX */ 2276} 2277 2278 2279static int wpa_driver_test_attach_udp(struct wpa_driver_test_data *drv, 2280 char *dst) 2281{ 2282 char *pos; 2283 2284 pos = os_strchr(dst, ':'); 2285 if (pos == NULL) 2286 return -1; 2287 *pos++ = '\0'; 2288 wpa_printf(MSG_DEBUG, "%s: addr=%s port=%s", __func__, dst, pos); 2289 2290 drv->test_socket = socket(PF_INET, SOCK_DGRAM, 0); 2291 if (drv->test_socket < 0) { 2292 perror("socket(PF_INET)"); 2293 return -1; 2294 } 2295 2296 os_memset(&drv->hostapd_addr_udp, 0, sizeof(drv->hostapd_addr_udp)); 2297 drv->hostapd_addr_udp.sin_family = AF_INET; 2298#if defined(CONFIG_NATIVE_WINDOWS) || defined(CONFIG_ANSI_C_EXTRA) 2299 { 2300 int a[4]; 2301 u8 *pos; 2302 sscanf(dst, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]); 2303 pos = (u8 *) &drv->hostapd_addr_udp.sin_addr; 2304 *pos++ = a[0]; 2305 *pos++ = a[1]; 2306 *pos++ = a[2]; 2307 *pos++ = a[3]; 2308 } 2309#else /* CONFIG_NATIVE_WINDOWS or CONFIG_ANSI_C_EXTRA */ 2310 inet_aton(dst, &drv->hostapd_addr_udp.sin_addr); 2311#endif /* CONFIG_NATIVE_WINDOWS or CONFIG_ANSI_C_EXTRA */ 2312 drv->hostapd_addr_udp.sin_port = htons(atoi(pos)); 2313 2314 drv->hostapd_addr_udp_set = 1; 2315 2316 eloop_register_read_sock(drv->test_socket, 2317 wpa_driver_test_receive_unix, drv, NULL); 2318 2319 return 0; 2320} 2321 2322 2323static int wpa_driver_test_set_param(void *priv, const char *param) 2324{ 2325 struct test_driver_bss *dbss = priv; 2326 struct wpa_driver_test_data *drv = dbss->drv; 2327 const char *pos; 2328 2329 wpa_printf(MSG_DEBUG, "%s: param='%s'", __func__, param); 2330 if (param == NULL) 2331 return 0; 2332 2333 wpa_driver_test_close_test_socket(drv); 2334 2335#ifdef DRIVER_TEST_UNIX 2336 pos = os_strstr(param, "test_socket="); 2337 if (pos) { 2338 const char *pos2; 2339 size_t len; 2340 2341 pos += 12; 2342 pos2 = os_strchr(pos, ' '); 2343 if (pos2) 2344 len = pos2 - pos; 2345 else 2346 len = os_strlen(pos); 2347 if (len > sizeof(drv->hostapd_addr.sun_path)) 2348 return -1; 2349 os_memset(&drv->hostapd_addr, 0, sizeof(drv->hostapd_addr)); 2350 drv->hostapd_addr.sun_family = AF_UNIX; 2351 os_memcpy(drv->hostapd_addr.sun_path, pos, len); 2352 drv->hostapd_addr_set = 1; 2353 } 2354#endif /* DRIVER_TEST_UNIX */ 2355 2356 pos = os_strstr(param, "test_dir="); 2357 if (pos) { 2358 char *end; 2359 os_free(drv->test_dir); 2360 drv->test_dir = os_strdup(pos + 9); 2361 if (drv->test_dir == NULL) 2362 return -1; 2363 end = os_strchr(drv->test_dir, ' '); 2364 if (end) 2365 *end = '\0'; 2366 if (wpa_driver_test_attach(drv, drv->test_dir, 0)) 2367 return -1; 2368 } else { 2369 pos = os_strstr(param, "test_udp="); 2370 if (pos) { 2371 char *dst, *epos; 2372 dst = os_strdup(pos + 9); 2373 if (dst == NULL) 2374 return -1; 2375 epos = os_strchr(dst, ' '); 2376 if (epos) 2377 *epos = '\0'; 2378 if (wpa_driver_test_attach_udp(drv, dst)) 2379 return -1; 2380 os_free(dst); 2381 } else if (wpa_driver_test_attach(drv, NULL, 0)) 2382 return -1; 2383 } 2384 2385 if (os_strstr(param, "use_associnfo=1")) { 2386 wpa_printf(MSG_DEBUG, "test_driver: Use AssocInfo events"); 2387 drv->use_associnfo = 1; 2388 } 2389 2390 if (os_strstr(param, "p2p_mgmt=1")) { 2391 wpa_printf(MSG_DEBUG, "test_driver: Use internal P2P " 2392 "management"); 2393 if (wpa_driver_test_init_p2p(drv) < 0) 2394 return -1; 2395 } 2396 2397 return 0; 2398} 2399 2400 2401static const u8 * wpa_driver_test_get_mac_addr(void *priv) 2402{ 2403 struct test_driver_bss *dbss = priv; 2404 struct wpa_driver_test_data *drv = dbss->drv; 2405 wpa_printf(MSG_DEBUG, "%s", __func__); 2406 return drv->own_addr; 2407} 2408 2409 2410static int wpa_driver_test_send_eapol(void *priv, const u8 *dest, u16 proto, 2411 const u8 *data, size_t data_len) 2412{ 2413 struct test_driver_bss *dbss = priv; 2414 struct wpa_driver_test_data *drv = dbss->drv; 2415 char *msg; 2416 size_t msg_len; 2417 struct l2_ethhdr eth; 2418 struct sockaddr *addr; 2419 socklen_t alen; 2420#ifdef DRIVER_TEST_UNIX 2421 struct sockaddr_un addr_un; 2422#endif /* DRIVER_TEST_UNIX */ 2423 2424 wpa_hexdump(MSG_MSGDUMP, "test_send_eapol TX frame", data, data_len); 2425 2426 os_memset(ð, 0, sizeof(eth)); 2427 os_memcpy(eth.h_dest, dest, ETH_ALEN); 2428 os_memcpy(eth.h_source, drv->own_addr, ETH_ALEN); 2429 eth.h_proto = host_to_be16(proto); 2430 2431 msg_len = 6 + sizeof(eth) + data_len; 2432 msg = os_malloc(msg_len); 2433 if (msg == NULL) 2434 return -1; 2435 os_memcpy(msg, "EAPOL ", 6); 2436 os_memcpy(msg + 6, ð, sizeof(eth)); 2437 os_memcpy(msg + 6 + sizeof(eth), data, data_len); 2438 2439 if (os_memcmp(dest, dbss->bssid, ETH_ALEN) == 0 || 2440 drv->test_dir == NULL) { 2441 if (drv->hostapd_addr_udp_set) { 2442 addr = (struct sockaddr *) &drv->hostapd_addr_udp; 2443 alen = sizeof(drv->hostapd_addr_udp); 2444 } else { 2445#ifdef DRIVER_TEST_UNIX 2446 addr = (struct sockaddr *) &drv->hostapd_addr; 2447 alen = sizeof(drv->hostapd_addr); 2448#else /* DRIVER_TEST_UNIX */ 2449 os_free(msg); 2450 return -1; 2451#endif /* DRIVER_TEST_UNIX */ 2452 } 2453 } else { 2454#ifdef DRIVER_TEST_UNIX 2455 struct stat st; 2456 os_memset(&addr_un, 0, sizeof(addr_un)); 2457 addr_un.sun_family = AF_UNIX; 2458 os_snprintf(addr_un.sun_path, sizeof(addr_un.sun_path), 2459 "%s/STA-" MACSTR, drv->test_dir, MAC2STR(dest)); 2460 if (stat(addr_un.sun_path, &st) < 0) { 2461 os_snprintf(addr_un.sun_path, sizeof(addr_un.sun_path), 2462 "%s/AP-" MACSTR, 2463 drv->test_dir, MAC2STR(dest)); 2464 } 2465 addr = (struct sockaddr *) &addr_un; 2466 alen = sizeof(addr_un); 2467#else /* DRIVER_TEST_UNIX */ 2468 os_free(msg); 2469 return -1; 2470#endif /* DRIVER_TEST_UNIX */ 2471 } 2472 2473 if (sendto(drv->test_socket, msg, msg_len, 0, addr, alen) < 0) { 2474 perror("sendmsg(test_socket)"); 2475 os_free(msg); 2476 return -1; 2477 } 2478 2479 os_free(msg); 2480 return 0; 2481} 2482 2483 2484static int wpa_driver_test_get_capa(void *priv, struct wpa_driver_capa *capa) 2485{ 2486 struct test_driver_bss *dbss = priv; 2487 struct wpa_driver_test_data *drv = dbss->drv; 2488 os_memset(capa, 0, sizeof(*capa)); 2489 capa->key_mgmt = WPA_DRIVER_CAPA_KEY_MGMT_WPA | 2490 WPA_DRIVER_CAPA_KEY_MGMT_WPA2 | 2491 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK | 2492 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK | 2493 WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE | 2494 WPA_DRIVER_CAPA_KEY_MGMT_FT | 2495 WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK; 2496 capa->enc = WPA_DRIVER_CAPA_ENC_WEP40 | 2497 WPA_DRIVER_CAPA_ENC_WEP104 | 2498 WPA_DRIVER_CAPA_ENC_TKIP | 2499 WPA_DRIVER_CAPA_ENC_CCMP; 2500 capa->auth = WPA_DRIVER_AUTH_OPEN | 2501 WPA_DRIVER_AUTH_SHARED | 2502 WPA_DRIVER_AUTH_LEAP; 2503 if (drv->p2p) 2504 capa->flags |= WPA_DRIVER_FLAGS_P2P_MGMT; 2505 capa->flags |= WPA_DRIVER_FLAGS_AP; 2506 capa->flags |= WPA_DRIVER_FLAGS_P2P_CONCURRENT; 2507 capa->flags |= WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE; 2508 capa->flags |= WPA_DRIVER_FLAGS_P2P_CAPABLE; 2509 capa->max_scan_ssids = 2; 2510 capa->max_remain_on_chan = 60000; 2511 2512 return 0; 2513} 2514 2515 2516static int wpa_driver_test_mlme_setprotection(void *priv, const u8 *addr, 2517 int protect_type, 2518 int key_type) 2519{ 2520 wpa_printf(MSG_DEBUG, "%s: protect_type=%d key_type=%d", 2521 __func__, protect_type, key_type); 2522 2523 if (addr) { 2524 wpa_printf(MSG_DEBUG, "%s: addr=" MACSTR, 2525 __func__, MAC2STR(addr)); 2526 } 2527 2528 return 0; 2529} 2530 2531 2532static void * wpa_driver_test_global_init(void) 2533{ 2534 struct wpa_driver_test_global *global; 2535 2536 global = os_zalloc(sizeof(*global)); 2537 return global; 2538} 2539 2540 2541static void wpa_driver_test_global_deinit(void *priv) 2542{ 2543 struct wpa_driver_test_global *global = priv; 2544 os_free(global); 2545} 2546 2547 2548static struct wpa_interface_info * 2549wpa_driver_test_get_interfaces(void *global_priv) 2550{ 2551 /* struct wpa_driver_test_global *global = priv; */ 2552 struct wpa_interface_info *iface; 2553 2554 iface = os_zalloc(sizeof(*iface)); 2555 if (iface == NULL) 2556 return iface; 2557 iface->ifname = os_strdup("sta0"); 2558 iface->desc = os_strdup("test interface 0"); 2559 iface->drv_name = "test"; 2560 iface->next = os_zalloc(sizeof(*iface)); 2561 if (iface->next) { 2562 iface->next->ifname = os_strdup("sta1"); 2563 iface->next->desc = os_strdup("test interface 1"); 2564 iface->next->drv_name = "test"; 2565 } 2566 2567 return iface; 2568} 2569 2570 2571static struct hostapd_hw_modes * 2572wpa_driver_test_get_hw_feature_data(void *priv, u16 *num_modes, u16 *flags) 2573{ 2574 struct hostapd_hw_modes *modes; 2575 size_t i; 2576 2577 *num_modes = 3; 2578 *flags = 0; 2579 modes = os_zalloc(*num_modes * sizeof(struct hostapd_hw_modes)); 2580 if (modes == NULL) 2581 return NULL; 2582 modes[0].mode = HOSTAPD_MODE_IEEE80211G; 2583 modes[0].num_channels = 11; 2584 modes[0].num_rates = 12; 2585 modes[0].channels = 2586 os_zalloc(11 * sizeof(struct hostapd_channel_data)); 2587 modes[0].rates = os_zalloc(modes[0].num_rates * sizeof(int)); 2588 if (modes[0].channels == NULL || modes[0].rates == NULL) 2589 goto fail; 2590 for (i = 0; i < 11; i++) { 2591 modes[0].channels[i].chan = i + 1; 2592 modes[0].channels[i].freq = 2412 + 5 * i; 2593 modes[0].channels[i].flag = 0; 2594 } 2595 modes[0].rates[0] = 10; 2596 modes[0].rates[1] = 20; 2597 modes[0].rates[2] = 55; 2598 modes[0].rates[3] = 110; 2599 modes[0].rates[4] = 60; 2600 modes[0].rates[5] = 90; 2601 modes[0].rates[6] = 120; 2602 modes[0].rates[7] = 180; 2603 modes[0].rates[8] = 240; 2604 modes[0].rates[9] = 360; 2605 modes[0].rates[10] = 480; 2606 modes[0].rates[11] = 540; 2607 2608 modes[1].mode = HOSTAPD_MODE_IEEE80211B; 2609 modes[1].num_channels = 11; 2610 modes[1].num_rates = 4; 2611 modes[1].channels = 2612 os_zalloc(11 * sizeof(struct hostapd_channel_data)); 2613 modes[1].rates = os_zalloc(modes[1].num_rates * sizeof(int)); 2614 if (modes[1].channels == NULL || modes[1].rates == NULL) 2615 goto fail; 2616 for (i = 0; i < 11; i++) { 2617 modes[1].channels[i].chan = i + 1; 2618 modes[1].channels[i].freq = 2412 + 5 * i; 2619 modes[1].channels[i].flag = 0; 2620 } 2621 modes[1].rates[0] = 10; 2622 modes[1].rates[1] = 20; 2623 modes[1].rates[2] = 55; 2624 modes[1].rates[3] = 110; 2625 2626 modes[2].mode = HOSTAPD_MODE_IEEE80211A; 2627 modes[2].num_channels = 1; 2628 modes[2].num_rates = 8; 2629 modes[2].channels = os_zalloc(sizeof(struct hostapd_channel_data)); 2630 modes[2].rates = os_zalloc(modes[2].num_rates * sizeof(int)); 2631 if (modes[2].channels == NULL || modes[2].rates == NULL) 2632 goto fail; 2633 modes[2].channels[0].chan = 60; 2634 modes[2].channels[0].freq = 5300; 2635 modes[2].channels[0].flag = 0; 2636 modes[2].rates[0] = 60; 2637 modes[2].rates[1] = 90; 2638 modes[2].rates[2] = 120; 2639 modes[2].rates[3] = 180; 2640 modes[2].rates[4] = 240; 2641 modes[2].rates[5] = 360; 2642 modes[2].rates[6] = 480; 2643 modes[2].rates[7] = 540; 2644 2645 return modes; 2646 2647fail: 2648 if (modes) { 2649 for (i = 0; i < *num_modes; i++) { 2650 os_free(modes[i].channels); 2651 os_free(modes[i].rates); 2652 } 2653 os_free(modes); 2654 } 2655 return NULL; 2656} 2657 2658 2659static int wpa_driver_test_set_freq(void *priv, 2660 struct hostapd_freq_params *freq) 2661{ 2662 struct test_driver_bss *dbss = priv; 2663 struct wpa_driver_test_data *drv = dbss->drv; 2664 wpa_printf(MSG_DEBUG, "test: set_freq %u MHz", freq->freq); 2665 drv->current_freq = freq->freq; 2666 return 0; 2667} 2668 2669 2670static int wpa_driver_test_send_action(void *priv, unsigned int freq, 2671 unsigned int wait, 2672 const u8 *dst, const u8 *src, 2673 const u8 *bssid, 2674 const u8 *data, size_t data_len, 2675 int no_cck) 2676{ 2677 struct test_driver_bss *dbss = priv; 2678 struct wpa_driver_test_data *drv = dbss->drv; 2679 int ret = -1; 2680 u8 *buf; 2681 struct ieee80211_hdr *hdr; 2682 2683 wpa_printf(MSG_DEBUG, "test: Send Action frame"); 2684 2685 if ((drv->remain_on_channel_freq && 2686 freq != drv->remain_on_channel_freq) || 2687 (drv->remain_on_channel_freq == 0 && 2688 freq != (unsigned int) drv->current_freq)) { 2689 wpa_printf(MSG_DEBUG, "test: Reject Action frame TX on " 2690 "unexpected channel: freq=%u MHz (current_freq=%u " 2691 "MHz, remain-on-channel freq=%u MHz)", 2692 freq, drv->current_freq, 2693 drv->remain_on_channel_freq); 2694 return -1; 2695 } 2696 2697 buf = os_zalloc(24 + data_len); 2698 if (buf == NULL) 2699 return ret; 2700 os_memcpy(buf + 24, data, data_len); 2701 hdr = (struct ieee80211_hdr *) buf; 2702 hdr->frame_control = 2703 IEEE80211_FC(WLAN_FC_TYPE_MGMT, WLAN_FC_STYPE_ACTION); 2704 os_memcpy(hdr->addr1, dst, ETH_ALEN); 2705 os_memcpy(hdr->addr2, src, ETH_ALEN); 2706 os_memcpy(hdr->addr3, bssid, ETH_ALEN); 2707 2708 ret = wpa_driver_test_send_mlme(priv, buf, 24 + data_len, 0); 2709 os_free(buf); 2710 return ret; 2711} 2712 2713 2714#ifdef CONFIG_P2P 2715static void test_send_action_cb(void *eloop_ctx, void *timeout_ctx) 2716{ 2717 struct wpa_driver_test_data *drv = eloop_ctx; 2718 2719 if (drv->pending_action_tx == NULL) 2720 return; 2721 2722 if (drv->off_channel_freq != drv->pending_action_freq) { 2723 wpa_printf(MSG_DEBUG, "P2P: Pending Action frame TX " 2724 "waiting for another freq=%u", 2725 drv->pending_action_freq); 2726 return; 2727 } 2728 wpa_printf(MSG_DEBUG, "P2P: Sending pending Action frame to " 2729 MACSTR, MAC2STR(drv->pending_action_dst)); 2730 wpa_driver_test_send_action(drv, drv->pending_action_freq, 0, 2731 drv->pending_action_dst, 2732 drv->pending_action_src, 2733 drv->pending_action_bssid, 2734 wpabuf_head(drv->pending_action_tx), 2735 wpabuf_len(drv->pending_action_tx), 2736 drv->pending_action_no_cck); 2737} 2738#endif /* CONFIG_P2P */ 2739 2740 2741static void test_remain_on_channel_timeout(void *eloop_ctx, void *timeout_ctx) 2742{ 2743 struct wpa_driver_test_data *drv = eloop_ctx; 2744 union wpa_event_data data; 2745 2746 wpa_printf(MSG_DEBUG, "test: Remain-on-channel timeout"); 2747 2748 os_memset(&data, 0, sizeof(data)); 2749 data.remain_on_channel.freq = drv->remain_on_channel_freq; 2750 data.remain_on_channel.duration = drv->remain_on_channel_duration; 2751 2752 if (drv->p2p) 2753 drv->off_channel_freq = 0; 2754 2755 drv->remain_on_channel_freq = 0; 2756 2757 wpa_supplicant_event(drv->ctx, EVENT_CANCEL_REMAIN_ON_CHANNEL, &data); 2758} 2759 2760 2761static int wpa_driver_test_remain_on_channel(void *priv, unsigned int freq, 2762 unsigned int duration) 2763{ 2764 struct test_driver_bss *dbss = priv; 2765 struct wpa_driver_test_data *drv = dbss->drv; 2766 union wpa_event_data data; 2767 2768 wpa_printf(MSG_DEBUG, "%s(freq=%u, duration=%u)", 2769 __func__, freq, duration); 2770 if (drv->remain_on_channel_freq && 2771 drv->remain_on_channel_freq != freq) { 2772 wpa_printf(MSG_DEBUG, "test: Refuse concurrent " 2773 "remain_on_channel request"); 2774 return -1; 2775 } 2776 2777 drv->remain_on_channel_freq = freq; 2778 drv->remain_on_channel_duration = duration; 2779 eloop_cancel_timeout(test_remain_on_channel_timeout, drv, NULL); 2780 eloop_register_timeout(duration / 1000, (duration % 1000) * 1000, 2781 test_remain_on_channel_timeout, drv, NULL); 2782 2783 os_memset(&data, 0, sizeof(data)); 2784 data.remain_on_channel.freq = freq; 2785 data.remain_on_channel.duration = duration; 2786 wpa_supplicant_event(drv->ctx, EVENT_REMAIN_ON_CHANNEL, &data); 2787 2788#ifdef CONFIG_P2P 2789 if (drv->p2p) { 2790 drv->off_channel_freq = drv->remain_on_channel_freq; 2791 test_send_action_cb(drv, NULL); 2792 if (drv->off_channel_freq == drv->pending_listen_freq) { 2793 p2p_listen_cb(drv->p2p, drv->pending_listen_freq, 2794 drv->pending_listen_duration); 2795 drv->pending_listen_freq = 0; 2796 } 2797 } 2798#endif /* CONFIG_P2P */ 2799 2800 return 0; 2801} 2802 2803 2804static int wpa_driver_test_cancel_remain_on_channel(void *priv) 2805{ 2806 struct test_driver_bss *dbss = priv; 2807 struct wpa_driver_test_data *drv = dbss->drv; 2808 wpa_printf(MSG_DEBUG, "%s", __func__); 2809 if (!drv->remain_on_channel_freq) 2810 return -1; 2811 drv->remain_on_channel_freq = 0; 2812 eloop_cancel_timeout(test_remain_on_channel_timeout, drv, NULL); 2813 return 0; 2814} 2815 2816 2817static int wpa_driver_test_probe_req_report(void *priv, int report) 2818{ 2819 struct test_driver_bss *dbss = priv; 2820 struct wpa_driver_test_data *drv = dbss->drv; 2821 wpa_printf(MSG_DEBUG, "%s(report=%d)", __func__, report); 2822 drv->probe_req_report = report; 2823 return 0; 2824} 2825 2826 2827#ifdef CONFIG_P2P 2828 2829static int wpa_driver_test_p2p_find(void *priv, unsigned int timeout, int type) 2830{ 2831 struct wpa_driver_test_data *drv = priv; 2832 wpa_printf(MSG_DEBUG, "%s(timeout=%u)", __func__, timeout); 2833 if (!drv->p2p) 2834 return -1; 2835 return p2p_find(drv->p2p, timeout, type, 0, NULL); 2836} 2837 2838 2839static int wpa_driver_test_p2p_stop_find(void *priv) 2840{ 2841 struct wpa_driver_test_data *drv = priv; 2842 wpa_printf(MSG_DEBUG, "%s", __func__); 2843 if (!drv->p2p) 2844 return -1; 2845 p2p_stop_find(drv->p2p); 2846 return 0; 2847} 2848 2849 2850static int wpa_driver_test_p2p_listen(void *priv, unsigned int timeout) 2851{ 2852 struct wpa_driver_test_data *drv = priv; 2853 wpa_printf(MSG_DEBUG, "%s(timeout=%u)", __func__, timeout); 2854 if (!drv->p2p) 2855 return -1; 2856 return p2p_listen(drv->p2p, timeout); 2857} 2858 2859 2860static int wpa_driver_test_p2p_connect(void *priv, const u8 *peer_addr, 2861 int wps_method, int go_intent, 2862 const u8 *own_interface_addr, 2863 unsigned int force_freq, 2864 int persistent_group) 2865{ 2866 struct wpa_driver_test_data *drv = priv; 2867 wpa_printf(MSG_DEBUG, "%s(peer_addr=" MACSTR " wps_method=%d " 2868 "go_intent=%d " 2869 "own_interface_addr=" MACSTR " force_freq=%u " 2870 "persistent_group=%d)", 2871 __func__, MAC2STR(peer_addr), wps_method, go_intent, 2872 MAC2STR(own_interface_addr), force_freq, persistent_group); 2873 if (!drv->p2p) 2874 return -1; 2875 return p2p_connect(drv->p2p, peer_addr, wps_method, go_intent, 2876 own_interface_addr, force_freq, persistent_group); 2877} 2878 2879 2880static int wpa_driver_test_wps_success_cb(void *priv, const u8 *peer_addr) 2881{ 2882 struct wpa_driver_test_data *drv = priv; 2883 wpa_printf(MSG_DEBUG, "%s(peer_addr=" MACSTR ")", 2884 __func__, MAC2STR(peer_addr)); 2885 if (!drv->p2p) 2886 return -1; 2887 p2p_wps_success_cb(drv->p2p, peer_addr); 2888 return 0; 2889} 2890 2891 2892static int wpa_driver_test_p2p_group_formation_failed(void *priv) 2893{ 2894 struct wpa_driver_test_data *drv = priv; 2895 wpa_printf(MSG_DEBUG, "%s", __func__); 2896 if (!drv->p2p) 2897 return -1; 2898 p2p_group_formation_failed(drv->p2p); 2899 return 0; 2900} 2901 2902 2903static int wpa_driver_test_p2p_set_params(void *priv, 2904 const struct p2p_params *params) 2905{ 2906 struct wpa_driver_test_data *drv = priv; 2907 wpa_printf(MSG_DEBUG, "%s", __func__); 2908 if (!drv->p2p) 2909 return -1; 2910 if (p2p_set_dev_name(drv->p2p, params->dev_name) < 0 || 2911 p2p_set_pri_dev_type(drv->p2p, params->pri_dev_type) < 0 || 2912 p2p_set_sec_dev_types(drv->p2p, params->sec_dev_type, 2913 params->num_sec_dev_types) < 0) 2914 return -1; 2915 return 0; 2916} 2917 2918 2919static int test_p2p_scan(void *ctx, enum p2p_scan_type type, int freq, 2920 unsigned int num_req_dev_types, 2921 const u8 *req_dev_types) 2922{ 2923 struct wpa_driver_test_data *drv = ctx; 2924 struct wpa_driver_scan_params params; 2925 int ret; 2926 struct wpabuf *wps_ie, *ies; 2927 int social_channels[] = { 2412, 2437, 2462, 0, 0 }; 2928 size_t ielen; 2929 2930 wpa_printf(MSG_DEBUG, "%s(type=%d freq=%d)", 2931 __func__, type, freq); 2932 2933 os_memset(¶ms, 0, sizeof(params)); 2934 2935 /* P2P Wildcard SSID */ 2936 params.num_ssids = 1; 2937 params.ssids[0].ssid = (u8 *) P2P_WILDCARD_SSID; 2938 params.ssids[0].ssid_len = P2P_WILDCARD_SSID_LEN; 2939 2940#if 0 /* TODO: WPS IE */ 2941 wpa_s->wps->dev.p2p = 1; 2942 wps_ie = wps_build_probe_req_ie(0, &wpa_s->wps->dev, wpa_s->wps->uuid, 2943 WPS_REQ_ENROLLEE); 2944#else 2945 wps_ie = wpabuf_alloc(1); 2946#endif 2947 if (wps_ie == NULL) 2948 return -1; 2949 2950 ielen = p2p_scan_ie_buf_len(drv->p2p); 2951 ies = wpabuf_alloc(wpabuf_len(wps_ie) + ielen); 2952 if (ies == NULL) { 2953 wpabuf_free(wps_ie); 2954 return -1; 2955 } 2956 wpabuf_put_buf(ies, wps_ie); 2957 wpabuf_free(wps_ie); 2958 2959 p2p_scan_ie(drv->p2p, ies); 2960 2961 params.extra_ies = wpabuf_head(ies); 2962 params.extra_ies_len = wpabuf_len(ies); 2963 2964 switch (type) { 2965 case P2P_SCAN_SOCIAL: 2966 params.freqs = social_channels; 2967 break; 2968 case P2P_SCAN_FULL: 2969 break; 2970 case P2P_SCAN_SPECIFIC: 2971 social_channels[0] = freq; 2972 social_channels[1] = 0; 2973 params.freqs = social_channels; 2974 break; 2975 case P2P_SCAN_SOCIAL_PLUS_ONE: 2976 social_channels[3] = freq; 2977 params.freqs = social_channels; 2978 break; 2979 } 2980 2981 drv->pending_p2p_scan = 1; 2982 ret = wpa_driver_test_scan(drv, ¶ms); 2983 2984 wpabuf_free(ies); 2985 2986 return ret; 2987} 2988 2989 2990static int test_send_action(void *ctx, unsigned int freq, const u8 *dst, 2991 const u8 *src, const u8 *bssid, const u8 *buf, 2992 size_t len, unsigned int wait_time) 2993{ 2994 struct wpa_driver_test_data *drv = ctx; 2995 2996 wpa_printf(MSG_DEBUG, "%s(freq=%u dst=" MACSTR " src=" MACSTR 2997 " bssid=" MACSTR " len=%d", 2998 __func__, freq, MAC2STR(dst), MAC2STR(src), MAC2STR(bssid), 2999 (int) len); 3000 if (freq <= 0) { 3001 wpa_printf(MSG_WARNING, "P2P: No frequency specified for " 3002 "action frame TX"); 3003 return -1; 3004 } 3005 3006 if (drv->pending_action_tx) { 3007 wpa_printf(MSG_DEBUG, "P2P: Dropped pending Action frame TX " 3008 "to " MACSTR, MAC2STR(drv->pending_action_dst)); 3009 wpabuf_free(drv->pending_action_tx); 3010 } 3011 drv->pending_action_tx = wpabuf_alloc(len); 3012 if (drv->pending_action_tx == NULL) 3013 return -1; 3014 wpabuf_put_data(drv->pending_action_tx, buf, len); 3015 os_memcpy(drv->pending_action_src, src, ETH_ALEN); 3016 os_memcpy(drv->pending_action_dst, dst, ETH_ALEN); 3017 os_memcpy(drv->pending_action_bssid, bssid, ETH_ALEN); 3018 drv->pending_action_freq = freq; 3019 drv->pending_action_no_cck = 1; 3020 3021 if (drv->off_channel_freq == freq) { 3022 /* Already on requested channel; send immediately */ 3023 /* TODO: Would there ever be need to extend the current 3024 * duration on the channel? */ 3025 eloop_cancel_timeout(test_send_action_cb, drv, NULL); 3026 eloop_register_timeout(0, 0, test_send_action_cb, drv, NULL); 3027 return 0; 3028 } 3029 3030 wpa_printf(MSG_DEBUG, "P2P: Schedule Action frame to be transmitted " 3031 "once the driver gets to the requested channel"); 3032 if (wpa_driver_test_remain_on_channel(drv, freq, wait_time) < 0) { 3033 wpa_printf(MSG_DEBUG, "P2P: Failed to request driver " 3034 "to remain on channel (%u MHz) for Action " 3035 "Frame TX", freq); 3036 return -1; 3037 } 3038 3039 return 0; 3040} 3041 3042 3043static void test_send_action_done(void *ctx) 3044{ 3045 wpa_printf(MSG_DEBUG, "%s", __func__); 3046 /* TODO */ 3047} 3048 3049 3050static void test_go_neg_completed(void *ctx, struct p2p_go_neg_results *res) 3051{ 3052 struct wpa_driver_test_data *drv = ctx; 3053 union wpa_event_data event; 3054 wpa_printf(MSG_DEBUG, "%s", __func__); 3055 os_memset(&event, 0, sizeof(event)); 3056 event.p2p_go_neg_completed.res = res; 3057 wpa_supplicant_event(drv->ctx, EVENT_P2P_GO_NEG_COMPLETED, &event); 3058} 3059 3060 3061static void test_go_neg_req_rx(void *ctx, const u8 *src, u16 dev_passwd_id) 3062{ 3063 struct wpa_driver_test_data *drv = ctx; 3064 union wpa_event_data event; 3065 wpa_printf(MSG_DEBUG, "%s(src=" MACSTR ")", __func__, MAC2STR(src)); 3066 os_memset(&event, 0, sizeof(event)); 3067 event.p2p_go_neg_req_rx.src = src; 3068 event.p2p_go_neg_req_rx.dev_passwd_id = dev_passwd_id; 3069 wpa_supplicant_event(drv->ctx, EVENT_P2P_GO_NEG_REQ_RX, &event); 3070} 3071 3072 3073static void test_dev_found(void *ctx, const u8 *addr, 3074 const struct p2p_peer_info *info, int new_device) 3075{ 3076 struct wpa_driver_test_data *drv = ctx; 3077 union wpa_event_data event; 3078 char devtype[WPS_DEV_TYPE_BUFSIZE]; 3079 wpa_printf(MSG_DEBUG, "%s(" MACSTR " p2p_dev_addr=" MACSTR 3080 " pri_dev_type=%s name='%s' config_methods=0x%x " 3081 "dev_capab=0x%x group_capab=0x%x)", 3082 __func__, MAC2STR(addr), MAC2STR(info->p2p_device_addr), 3083 wps_dev_type_bin2str(info->pri_dev_type, devtype, 3084 sizeof(devtype)), 3085 info->device_name, info->config_methods, info->dev_capab, 3086 info->group_capab); 3087 3088 os_memset(&event, 0, sizeof(event)); 3089 event.p2p_dev_found.addr = addr; 3090 event.p2p_dev_found.dev_addr = info->p2p_device_addr; 3091 event.p2p_dev_found.pri_dev_type = info->pri_dev_type; 3092 event.p2p_dev_found.dev_name = info->device_name; 3093 event.p2p_dev_found.config_methods = info->config_methods; 3094 event.p2p_dev_found.dev_capab = info->dev_capab; 3095 event.p2p_dev_found.group_capab = info->group_capab; 3096 wpa_supplicant_event(drv->ctx, EVENT_P2P_DEV_FOUND, &event); 3097} 3098 3099 3100static int test_start_listen(void *ctx, unsigned int freq, 3101 unsigned int duration, 3102 const struct wpabuf *probe_resp_ie) 3103{ 3104 struct wpa_driver_test_data *drv = ctx; 3105 3106 wpa_printf(MSG_DEBUG, "%s(freq=%u duration=%u)", 3107 __func__, freq, duration); 3108 3109 if (wpa_driver_test_probe_req_report(drv, 1) < 0) 3110 return -1; 3111 3112 drv->pending_listen_freq = freq; 3113 drv->pending_listen_duration = duration; 3114 3115 if (wpa_driver_test_remain_on_channel(drv, freq, duration) < 0) { 3116 drv->pending_listen_freq = 0; 3117 return -1; 3118 } 3119 3120 return 0; 3121} 3122 3123 3124static void test_stop_listen(void *ctx) 3125{ 3126 wpa_printf(MSG_DEBUG, "%s", __func__); 3127 /* TODO */ 3128} 3129 3130 3131static int test_send_probe_resp(void *ctx, const struct wpabuf *buf) 3132{ 3133 struct wpa_driver_test_data *drv = ctx; 3134 char resp[512], *pos, *end; 3135 int ret; 3136 const struct ieee80211_mgmt *mgmt; 3137 const u8 *ie, *ie_end; 3138 3139 wpa_printf(MSG_DEBUG, "%s", __func__); 3140 wpa_hexdump_buf(MSG_MSGDUMP, "Probe Response", buf); 3141 if (wpabuf_len(buf) < 24) 3142 return -1; 3143 if (!drv->probe_from) { 3144 wpa_printf(MSG_DEBUG, "%s: probe_from not set", __func__); 3145 return -1; 3146 } 3147 3148 pos = resp; 3149 end = resp + sizeof(resp); 3150 3151 mgmt = wpabuf_head(buf); 3152 3153 /* reply: SCANRESP BSSID SSID IEs */ 3154 ret = os_snprintf(pos, end - pos, "SCANRESP " MACSTR " ", 3155 MAC2STR(mgmt->bssid)); 3156 if (ret < 0 || ret >= end - pos) 3157 return -1; 3158 pos += ret; 3159 3160 ie = mgmt->u.probe_resp.variable; 3161 ie_end = wpabuf_head_u8(buf) + wpabuf_len(buf); 3162 if (ie_end - ie < 2 || ie[0] != WLAN_EID_SSID || 3163 ie + 2 + ie[1] > ie_end) 3164 return -1; 3165 pos += wpa_snprintf_hex(pos, end - pos, ie + 2, ie[1]); 3166 3167 ret = os_snprintf(pos, end - pos, " "); 3168 if (ret < 0 || ret >= end - pos) 3169 return -1; 3170 pos += ret; 3171 pos += wpa_snprintf_hex(pos, end - pos, ie, ie_end - ie); 3172 3173 sendto(drv->test_socket, resp, pos - resp, 0, 3174 drv->probe_from, drv->probe_from_len); 3175 3176 return 0; 3177} 3178 3179 3180static void test_sd_request(void *ctx, int freq, const u8 *sa, u8 dialog_token, 3181 u16 update_indic, const u8 *tlvs, size_t tlvs_len) 3182{ 3183 wpa_printf(MSG_DEBUG, "%s", __func__); 3184 /* TODO */ 3185} 3186 3187 3188static void test_sd_response(void *ctx, const u8 *sa, u16 update_indic, 3189 const u8 *tlvs, size_t tlvs_len) 3190{ 3191 wpa_printf(MSG_DEBUG, "%s", __func__); 3192 /* TODO */ 3193} 3194 3195 3196static void test_prov_disc_req(void *ctx, const u8 *peer, u16 config_methods, 3197 const u8 *dev_addr, const u8 *pri_dev_type, 3198 const char *dev_name, u16 supp_config_methods, 3199 u8 dev_capab, u8 group_capab, 3200 const u8 *group_id, size_t group_id_len) 3201{ 3202 wpa_printf(MSG_DEBUG, "%s(peer=" MACSTR " config_methods=0x%x)", 3203 __func__, MAC2STR(peer), config_methods); 3204 /* TODO */ 3205} 3206 3207 3208static void test_prov_disc_resp(void *ctx, const u8 *peer, u16 config_methods) 3209{ 3210 wpa_printf(MSG_DEBUG, "%s(peer=" MACSTR " config_methods=0x%x)", 3211 __func__, MAC2STR(peer), config_methods); 3212 /* TODO */ 3213} 3214 3215#endif /* CONFIG_P2P */ 3216 3217 3218static int wpa_driver_test_init_p2p(struct wpa_driver_test_data *drv) 3219{ 3220#ifdef CONFIG_P2P 3221 struct p2p_config p2p; 3222 unsigned int r; 3223 int i; 3224 3225 os_memset(&p2p, 0, sizeof(p2p)); 3226 p2p.msg_ctx = drv->ctx; 3227 p2p.cb_ctx = drv; 3228 p2p.p2p_scan = test_p2p_scan; 3229 p2p.send_action = test_send_action; 3230 p2p.send_action_done = test_send_action_done; 3231 p2p.go_neg_completed = test_go_neg_completed; 3232 p2p.go_neg_req_rx = test_go_neg_req_rx; 3233 p2p.dev_found = test_dev_found; 3234 p2p.start_listen = test_start_listen; 3235 p2p.stop_listen = test_stop_listen; 3236 p2p.send_probe_resp = test_send_probe_resp; 3237 p2p.sd_request = test_sd_request; 3238 p2p.sd_response = test_sd_response; 3239 p2p.prov_disc_req = test_prov_disc_req; 3240 p2p.prov_disc_resp = test_prov_disc_resp; 3241 3242 os_memcpy(p2p.dev_addr, drv->own_addr, ETH_ALEN); 3243 3244 p2p.reg_class = 12; /* TODO: change depending on location */ 3245 /* 3246 * Pick one of the social channels randomly as the listen 3247 * channel. 3248 */ 3249 os_get_random((u8 *) &r, sizeof(r)); 3250 p2p.channel = 1 + (r % 3) * 5; 3251 3252 /* TODO: change depending on location */ 3253 p2p.op_reg_class = 12; 3254 /* 3255 * For initial tests, pick the operation channel randomly. 3256 * TODO: Use scan results (etc.) to select the best channel. 3257 */ 3258 p2p.op_channel = 1 + r % 11; 3259 3260 os_memcpy(p2p.country, "US ", 3); 3261 3262 /* FIX: fetch available channels from the driver */ 3263 p2p.channels.reg_classes = 1; 3264 p2p.channels.reg_class[0].reg_class = 12; /* US/12 = 2.4 GHz band */ 3265 p2p.channels.reg_class[0].channels = 11; 3266 for (i = 0; i < 11; i++) 3267 p2p.channels.reg_class[0].channel[i] = i + 1; 3268 3269 p2p.max_peers = 100; 3270 3271 drv->p2p = p2p_init(&p2p); 3272 if (drv->p2p == NULL) 3273 return -1; 3274 return 0; 3275#else /* CONFIG_P2P */ 3276 wpa_printf(MSG_INFO, "driver_test: P2P support not included"); 3277 return -1; 3278#endif /* CONFIG_P2P */ 3279} 3280 3281 3282const struct wpa_driver_ops wpa_driver_test_ops = { 3283 "test", 3284 "wpa_supplicant test driver", 3285 .hapd_init = test_driver_init, 3286 .hapd_deinit = wpa_driver_test_deinit, 3287 .hapd_send_eapol = test_driver_send_eapol, 3288 .send_mlme = wpa_driver_test_send_mlme, 3289 .set_generic_elem = test_driver_set_generic_elem, 3290 .sta_deauth = test_driver_sta_deauth, 3291 .sta_disassoc = test_driver_sta_disassoc, 3292 .get_hw_feature_data = wpa_driver_test_get_hw_feature_data, 3293 .if_add = test_driver_if_add, 3294 .if_remove = test_driver_if_remove, 3295 .hapd_set_ssid = test_driver_set_ssid, 3296 .set_privacy = test_driver_set_privacy, 3297 .set_sta_vlan = test_driver_set_sta_vlan, 3298 .sta_add = test_driver_sta_add, 3299 .send_ether = test_driver_send_ether, 3300 .set_ap_wps_ie = test_driver_set_ap_wps_ie, 3301 .get_bssid = wpa_driver_test_get_bssid, 3302 .get_ssid = wpa_driver_test_get_ssid, 3303 .set_key = wpa_driver_test_set_key, 3304 .deinit = wpa_driver_test_deinit, 3305 .set_param = wpa_driver_test_set_param, 3306 .deauthenticate = wpa_driver_test_deauthenticate, 3307 .disassociate = wpa_driver_test_disassociate, 3308 .associate = wpa_driver_test_associate, 3309 .get_capa = wpa_driver_test_get_capa, 3310 .get_mac_addr = wpa_driver_test_get_mac_addr, 3311 .send_eapol = wpa_driver_test_send_eapol, 3312 .mlme_setprotection = wpa_driver_test_mlme_setprotection, 3313 .get_scan_results2 = wpa_driver_test_get_scan_results2, 3314 .global_init = wpa_driver_test_global_init, 3315 .global_deinit = wpa_driver_test_global_deinit, 3316 .init2 = wpa_driver_test_init2, 3317 .get_interfaces = wpa_driver_test_get_interfaces, 3318 .scan2 = wpa_driver_test_scan, 3319 .set_freq = wpa_driver_test_set_freq, 3320 .send_action = wpa_driver_test_send_action, 3321 .remain_on_channel = wpa_driver_test_remain_on_channel, 3322 .cancel_remain_on_channel = wpa_driver_test_cancel_remain_on_channel, 3323 .probe_req_report = wpa_driver_test_probe_req_report, 3324#ifdef CONFIG_P2P 3325 .p2p_find = wpa_driver_test_p2p_find, 3326 .p2p_stop_find = wpa_driver_test_p2p_stop_find, 3327 .p2p_listen = wpa_driver_test_p2p_listen, 3328 .p2p_connect = wpa_driver_test_p2p_connect, 3329 .wps_success_cb = wpa_driver_test_wps_success_cb, 3330 .p2p_group_formation_failed = 3331 wpa_driver_test_p2p_group_formation_failed, 3332 .p2p_set_params = wpa_driver_test_p2p_set_params, 3333#endif /* CONFIG_P2P */ 3334}; 3335