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