2 * Testing driver interface for a simulated network driver
3 * Copyright (c) 2004-2010, Jouni Malinen <j@w1.fi>
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
9 /* Make sure we get winsock2.h for Windows build to get sockaddr_storage */
10 #include "build_config.h"
11 #ifdef CONFIG_NATIVE_WINDOWS
13 #endif /* CONFIG_NATIVE_WINDOWS */
15 #include "utils/includes.h"
17 #ifndef CONFIG_NATIVE_WINDOWS
21 #define DRIVER_TEST_UNIX
22 #endif /* CONFIG_NATIVE_WINDOWS */
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"
36 struct test_client_socket
{
37 struct test_client_socket
*next
;
39 struct sockaddr_un un
;
41 struct test_driver_bss
*bss
;
44 struct test_driver_bss
{
45 struct wpa_driver_test_data
*drv
;
48 char ifname
[IFNAMSIZ
];
53 size_t wps_beacon_ie_len
;
54 u8
*wps_probe_resp_ie
;
55 size_t wps_probe_resp_ie_len
;
61 struct wpa_driver_test_global
{
63 u8 req_addr
[ETH_ALEN
];
66 struct wpa_driver_test_data
{
67 struct wpa_driver_test_global
*global
;
70 u8 own_addr
[ETH_ALEN
];
72 #ifdef DRIVER_TEST_UNIX
73 struct sockaddr_un hostapd_addr
;
74 #endif /* DRIVER_TEST_UNIX */
76 struct sockaddr_in hostapd_addr_udp
;
77 int hostapd_addr_udp_set
;
78 char *own_socket_path
;
80 #define MAX_SCAN_RESULTS 30
81 struct wpa_scan_res
*scanres
[MAX_SCAN_RESULTS
];
85 size_t assoc_wpa_ie_len
;
88 size_t probe_req_ie_len
;
89 u8 probe_req_ssid
[32];
90 size_t probe_req_ssid_len
;
94 struct test_client_socket
*cli
;
100 int probe_req_report
;
101 unsigned int remain_on_channel_freq
;
102 unsigned int remain_on_channel_duration
;
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
;
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
);
131 static void test_driver_free_bss(struct test_driver_bss
*bss
)
134 os_free(bss
->wps_beacon_ie
);
135 os_free(bss
->wps_probe_resp_ie
);
140 static void test_driver_free_bsses(struct wpa_driver_test_data
*drv
)
142 struct test_driver_bss
*bss
, *tmp
;
144 dl_list_for_each_safe(bss
, tmp
, &drv
->bss
, struct test_driver_bss
,
146 dl_list_del(&bss
->list
);
147 test_driver_free_bss(bss
);
152 static struct test_client_socket
*
153 test_driver_get_cli(struct wpa_driver_test_data
*drv
, struct sockaddr_un
*from
,
156 struct test_client_socket
*cli
= drv
->cli
;
159 if (cli
->unlen
== fromlen
&&
160 strncmp(cli
->un
.sun_path
, from
->sun_path
,
161 fromlen
- sizeof(cli
->un
.sun_family
)) == 0)
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
)
174 struct test_driver_bss
*dbss
= priv
;
175 struct wpa_driver_test_data
*drv
= dbss
->drv
;
176 struct test_client_socket
*cli
;
179 struct l2_ethhdr eth
;
181 if (drv
->test_socket
< 0)
186 if (memcmp(cli
->addr
, addr
, ETH_ALEN
) == 0)
192 wpa_printf(MSG_DEBUG
, "%s: no destination client entry",
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
);
201 io
[0].iov_base
= "EAPOL ";
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
;
208 memset(&msg
, 0, sizeof(msg
));
211 msg
.msg_name
= &cli
->un
;
212 msg
.msg_namelen
= cli
->unlen
;
213 return sendmsg(drv
->test_socket
, &msg
, 0);
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
)
220 struct test_driver_bss
*dbss
= priv
;
221 struct wpa_driver_test_data
*drv
= dbss
->drv
;
224 struct l2_ethhdr eth
;
226 struct sockaddr_un addr
;
229 int ret
= 0, broadcast
= 0, count
= 0;
231 if (drv
->test_socket
< 0 || drv
->test_dir
== NULL
) {
232 wpa_printf(MSG_DEBUG
, "%s: invalid parameters (sock=%d "
234 __func__
, drv
->test_socket
, drv
->test_dir
);
238 broadcast
= memcmp(dst
, "\xff\xff\xff\xff\xff\xff", ETH_ALEN
) == 0;
239 snprintf(desttxt
, sizeof(desttxt
), MACSTR
, MAC2STR(dst
));
241 memcpy(eth
.h_dest
, dst
, ETH_ALEN
);
242 memcpy(eth
.h_source
, src
, ETH_ALEN
);
243 eth
.h_proto
= host_to_be16(proto
);
245 io
[0].iov_base
= "ETHER ";
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
;
252 memset(&msg
, 0, sizeof(msg
));
256 dir
= opendir(drv
->test_dir
);
258 perror("test_driver: opendir");
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
)
268 #endif /* _DIRENT_HAVE_D_TYPE */
269 if (strcmp(dent
->d_name
, ".") == 0 ||
270 strcmp(dent
->d_name
, "..") == 0)
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
);
278 if (strcmp(addr
.sun_path
, drv
->own_socket_path
) == 0)
280 if (!broadcast
&& strstr(dent
->d_name
, desttxt
) == NULL
)
283 wpa_printf(MSG_DEBUG
, "%s: Send ether frame to %s",
284 __func__
, dent
->d_name
);
286 msg
.msg_name
= &addr
;
287 msg
.msg_namelen
= sizeof(addr
);
288 ret
= sendmsg(drv
->test_socket
, &msg
, 0);
290 perror("driver_test: sendmsg");
295 if (!broadcast
&& count
== 0) {
296 wpa_printf(MSG_DEBUG
, "%s: Destination " MACSTR
" not found",
297 __func__
, MAC2STR(dst
));
305 static int wpa_driver_test_send_mlme(void *priv
, const u8
*data
,
306 size_t data_len
, int noack
)
308 struct test_driver_bss
*dbss
= priv
;
309 struct wpa_driver_test_data
*drv
= dbss
->drv
;
313 struct sockaddr_un addr
;
318 struct ieee80211_hdr
*hdr
;
325 union wpa_event_data event
;
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"
331 __func__
, drv
->test_socket
,
332 (unsigned long) data_len
,
338 broadcast
= os_memcmp(dest
, "\xff\xff\xff\xff\xff\xff", ETH_ALEN
) == 0;
341 snprintf(desttxt
, sizeof(desttxt
), MACSTR
, MAC2STR(dest
));
344 if (drv
->remain_on_channel_freq
)
345 freq
= drv
->remain_on_channel_freq
;
347 freq
= drv
->current_freq
;
348 wpa_printf(MSG_DEBUG
, "test_driver(%s): MLME TX on freq %d MHz",
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
;
356 os_memset(&msg
, 0, sizeof(msg
));
361 if (drv
->test_dir
== NULL
) {
362 wpa_printf(MSG_DEBUG
, "%s: test_dir == NULL", __func__
);
366 dir
= opendir(drv
->test_dir
);
368 perror("test_driver: opendir");
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
)
378 #endif /* _DIRENT_HAVE_D_TYPE */
379 if (os_strcmp(dent
->d_name
, ".") == 0 ||
380 os_strcmp(dent
->d_name
, "..") == 0)
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
);
388 if (os_strcmp(addr
.sun_path
, drv
->own_socket_path
) == 0)
390 if (!broadcast
&& os_strstr(dent
->d_name
, desttxt
) == NULL
)
393 wpa_printf(MSG_DEBUG
, "%s: Send management frame to %s",
394 __func__
, dent
->d_name
);
396 msg
.msg_name
= &addr
;
397 msg
.msg_namelen
= sizeof(addr
);
398 ret
= sendmsg(drv
->test_socket
, &msg
, 0);
400 perror("driver_test: sendmsg(test_socket)");
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
);
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 */
416 } else if (broadcast
) {
417 dir
= opendir(drv
->test_dir
);
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
)
429 #endif /* _DIRENT_HAVE_D_TYPE */
430 if (os_strcmp(dent
->d_name
, ".") == 0 ||
431 os_strcmp(dent
->d_name
, "..") == 0)
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
);
440 msg
.msg_name
= &addr
;
441 msg
.msg_namelen
= sizeof(addr
);
443 ret
= sendmsg(drv
->test_socket
, &msg
, 0);
445 perror("driver_test: sendmsg(test_socket)");
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
),
458 drv
->test_dir
, MAC2STR(dest
));
460 msg
.msg_name
= &addr
;
461 msg
.msg_namelen
= sizeof(addr
);
464 if (sendmsg(drv
->test_socket
, &msg
, 0) < 0) {
465 perror("sendmsg(test_socket)");
470 hdr
= (struct ieee80211_hdr
*) data
;
471 fc
= le_to_host16(hdr
->frame_control
);
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
);
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");
492 if (os_memcmp(hdr
->addr1
, drv
->pending_action_dst
, ETH_ALEN
) !=
494 wpa_printf(MSG_DEBUG
, "P2P: Ignore Action TX status - "
495 "unknown destination address");
499 wpabuf_free(drv
->pending_action_tx
);
500 drv
->pending_action_tx
= NULL
;
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
,
508 #endif /* CONFIG_P2P */
514 static void test_driver_scan(struct wpa_driver_test_data
*drv
,
515 struct sockaddr_un
*from
, socklen_t fromlen
,
518 char buf
[512], *pos
, *end
;
520 struct test_driver_bss
*bss
;
524 union wpa_event_data event
;
526 /* data: optional [ ' ' | STA-addr | ' ' | IEs(hex) ] */
528 wpa_printf(MSG_DEBUG
, "test_driver: SCAN");
532 hwaddr_aton(data
+ 1, sa
)) {
533 wpa_printf(MSG_DEBUG
, "test_driver: Unexpected SCAN "
541 ielen
= os_strlen(data
) / 2;
542 if (ielen
> sizeof(ie
))
544 if (hexstr2bin(data
, ie
, ielen
) < 0)
547 wpa_printf(MSG_DEBUG
, "test_driver: Scan from " MACSTR
,
549 wpa_hexdump(MSG_MSGDUMP
, "test_driver: scan IEs", ie
, ielen
);
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
);
558 p2p_probe_req_rx(drv
->p2p
, sa
, NULL
, NULL
, ie
, ielen
);
559 #endif /* CONFIG_P2P */
562 dl_list_for_each(bss
, &drv
->bss
, struct test_driver_bss
, list
) {
564 end
= buf
+ sizeof(buf
);
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
)
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
)
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
);
583 ret
= snprintf(pos
, end
- pos
, " PRIVACY");
584 if (ret
< 0 || ret
>= end
- pos
)
589 sendto(drv
->test_socket
, buf
, pos
- buf
, 0,
590 (struct sockaddr
*) from
, fromlen
);
595 static void test_driver_assoc(struct wpa_driver_test_data
*drv
,
596 struct sockaddr_un
*from
, socklen_t fromlen
,
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
;
605 /* data: STA-addr SSID(hex) IEs(hex) */
607 cli
= os_zalloc(sizeof(*cli
));
611 if (hwaddr_aton(data
, cli
->addr
)) {
612 printf("test_socket: Invalid MAC address '%s' in ASSOC\n",
620 pos2
= strchr(pos
, ' ');
623 ssid_len
= (pos2
- pos
) / 2;
624 if (hexstr2bin(pos
, ssid
, ssid_len
) < 0) {
625 wpa_printf(MSG_DEBUG
, "%s: Invalid SSID", __func__
);
629 wpa_hexdump_ascii(MSG_DEBUG
, "test_driver_assoc: SSID",
633 ielen
= strlen(pos
) / 2;
634 if (ielen
> sizeof(ie
))
636 if (hexstr2bin(pos
, ie
, ielen
) < 0)
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) {
649 wpa_printf(MSG_DEBUG
, "%s: No matching SSID found from "
650 "configured BSSes", __func__
);
656 memcpy(&cli
->un
, from
, sizeof(cli
->un
));
657 cli
->unlen
= fromlen
;
658 cli
->next
= drv
->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
));
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
);
669 drv_event_assoc(bss
->bss_ctx
, cli
->addr
, ie
, ielen
, 0);
673 static void test_driver_disassoc(struct wpa_driver_test_data
*drv
,
674 struct sockaddr_un
*from
, socklen_t fromlen
)
676 struct test_client_socket
*cli
;
678 cli
= test_driver_get_cli(drv
, from
, fromlen
);
682 drv_event_disassoc(drv
->ctx
, cli
->addr
);
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
)
691 struct test_client_socket
*cli
;
693 const u8
*src
= NULL
;
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
));
707 cli
= test_driver_get_cli(drv
, from
, fromlen
);
709 drv_event_eapol_rx(cli
->bss
->bss_ctx
, cli
->addr
, data
,
712 wpa_printf(MSG_DEBUG
, "test_socket: EAPOL from unknown "
717 drv_event_eapol_rx(drv
->ctx
, src
, data
, datalen
);
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
)
726 struct l2_ethhdr
*eth
;
728 if (datalen
< sizeof(*eth
))
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
));
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
);
745 #endif /* CONFIG_IEEE80211R */
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
)
753 struct ieee80211_hdr
*hdr
;
755 union wpa_event_data event
;
756 int freq
= 0, own_freq
;
757 struct test_driver_bss
*bss
;
759 bss
= dl_list_first(&drv
->bss
, struct test_driver_bss
, list
);
761 if (datalen
> 6 && os_memcmp(data
, "freq=", 5) == 0) {
763 for (pos
= 5; pos
< datalen
; pos
++) {
764 if (data
[pos
] == ' ')
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
);
777 if (drv
->remain_on_channel_freq
)
778 own_freq
= drv
->remain_on_channel_freq
;
780 own_freq
= drv
->current_freq
;
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
);
789 hdr
= (struct ieee80211_hdr
*) data
;
791 if (test_driver_get_cli(drv
, from
, fromlen
) == NULL
&& datalen
>= 16) {
792 struct test_client_socket
*cli
;
793 cli
= os_zalloc(sizeof(*cli
));
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
;
805 wpa_hexdump(MSG_MSGDUMP
, "test_driver_mlme: received frame",
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",
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
);
821 static void test_driver_receive_unix(int sock
, void *eloop_ctx
, void *sock_ctx
)
823 struct wpa_driver_test_data
*drv
= eloop_ctx
;
826 struct sockaddr_un from
;
827 socklen_t fromlen
= sizeof(from
);
829 res
= recvfrom(sock
, buf
, sizeof(buf
) - 1, 0,
830 (struct sockaddr
*) &from
, &fromlen
);
832 perror("recvfrom(test_socket)");
837 wpa_printf(MSG_DEBUG
, "test_driver: received %u bytes", res
);
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,
848 } else if (strncmp(buf
, "ETHER ", 6) == 0) {
849 test_driver_ether(drv
, &from
, fromlen
, (u8
*) buf
+ 6,
851 } else if (strncmp(buf
, "MLME ", 5) == 0) {
852 test_driver_mlme(drv
, &from
, fromlen
, (u8
*) buf
+ 5, res
- 5);
854 wpa_hexdump_ascii(MSG_DEBUG
, "Unknown test_socket command",
860 static int test_driver_set_generic_elem(void *priv
,
861 const u8
*elem
, size_t elem_len
)
863 struct test_driver_bss
*bss
= priv
;
873 bss
->ie
= os_malloc(elem_len
);
874 if (bss
->ie
== NULL
) {
879 memcpy(bss
->ie
, elem
, elem_len
);
880 bss
->ielen
= elem_len
;
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
)
889 struct test_driver_bss
*bss
= priv
;
892 wpa_printf(MSG_DEBUG
, "test_driver: Clear Beacon WPS IE");
894 wpa_hexdump_buf(MSG_DEBUG
, "test_driver: Beacon WPS IE",
897 os_free(bss
->wps_beacon_ie
);
899 if (beacon
== NULL
) {
900 bss
->wps_beacon_ie
= NULL
;
901 bss
->wps_beacon_ie_len
= 0;
903 bss
->wps_beacon_ie
= os_malloc(wpabuf_len(beacon
));
904 if (bss
->wps_beacon_ie
== NULL
) {
905 bss
->wps_beacon_ie_len
= 0;
909 os_memcpy(bss
->wps_beacon_ie
, wpabuf_head(beacon
),
911 bss
->wps_beacon_ie_len
= wpabuf_len(beacon
);
914 if (proberesp
== NULL
)
915 wpa_printf(MSG_DEBUG
, "test_driver: Clear Probe Response WPS "
918 wpa_hexdump_buf(MSG_DEBUG
, "test_driver: Probe Response WPS "
921 os_free(bss
->wps_probe_resp_ie
);
923 if (proberesp
== NULL
) {
924 bss
->wps_probe_resp_ie
= NULL
;
925 bss
->wps_probe_resp_ie_len
= 0;
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;
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
);
942 static int test_driver_sta_deauth(void *priv
, const u8
*own_addr
,
943 const u8
*addr
, int reason
)
945 struct test_driver_bss
*dbss
= priv
;
946 struct wpa_driver_test_data
*drv
= dbss
->drv
;
947 struct test_client_socket
*cli
;
949 if (drv
->test_socket
< 0)
954 if (memcmp(cli
->addr
, addr
, ETH_ALEN
) == 0)
962 return sendto(drv
->test_socket
, "DEAUTH", 6, 0,
963 (struct sockaddr
*) &cli
->un
, cli
->unlen
);
967 static int test_driver_sta_disassoc(void *priv
, const u8
*own_addr
,
968 const u8
*addr
, int reason
)
970 struct test_driver_bss
*dbss
= priv
;
971 struct wpa_driver_test_data
*drv
= dbss
->drv
;
972 struct test_client_socket
*cli
;
974 if (drv
->test_socket
< 0)
979 if (memcmp(cli
->addr
, addr
, ETH_ALEN
) == 0)
987 return sendto(drv
->test_socket
, "DISASSOC", 8, 0,
988 (struct sockaddr
*) &cli
->un
, cli
->unlen
);
992 static int test_driver_bss_add(void *priv
, const char *ifname
, const u8
*bssid
,
993 void *bss_ctx
, void **drv_priv
)
995 struct test_driver_bss
*dbss
= priv
;
996 struct wpa_driver_test_data
*drv
= dbss
->drv
;
997 struct test_driver_bss
*bss
;
999 wpa_printf(MSG_DEBUG
, "%s(ifname=%s bssid=" MACSTR
")",
1000 __func__
, ifname
, MAC2STR(bssid
));
1002 bss
= os_zalloc(sizeof(*bss
));
1006 bss
->bss_ctx
= bss_ctx
;
1008 os_strlcpy(bss
->ifname
, ifname
, IFNAMSIZ
);
1009 os_memcpy(bss
->bssid
, bssid
, ETH_ALEN
);
1011 dl_list_add(&drv
->bss
, &bss
->list
);
1013 drv
->global
->bss_add_used
= 1;
1014 os_memcpy(drv
->global
->req_addr
, bssid
, ETH_ALEN
);
1024 static int test_driver_bss_remove(void *priv
, const char *ifname
)
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
;
1031 wpa_printf(MSG_DEBUG
, "%s(ifname=%s)", __func__
, ifname
);
1033 dl_list_for_each(bss
, &drv
->bss
, struct test_driver_bss
, list
) {
1034 if (strcmp(bss
->ifname
, ifname
) != 0)
1037 for (prev_c
= NULL
, cli
= drv
->cli
; cli
;
1038 prev_c
= cli
, cli
= cli
->next
) {
1039 if (cli
->bss
!= bss
)
1042 prev_c
->next
= cli
->next
;
1044 drv
->cli
= cli
->next
;
1049 dl_list_del(&bss
->list
);
1050 test_driver_free_bss(bss
);
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
,
1064 struct test_driver_bss
*dbss
= priv
;
1065 struct wpa_driver_test_data
*drv
= dbss
->drv
;
1067 wpa_printf(MSG_DEBUG
, "%s(type=%d ifname=%s bss_ctx=%p)",
1068 __func__
, type
, ifname
, bss_ctx
);
1070 os_memcpy(if_addr
, addr
, ETH_ALEN
);
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);
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
,
1088 static int test_driver_if_remove(void *priv
, enum wpa_driver_if_type type
,
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
);
1099 static int test_driver_set_ssid(void *priv
, const u8
*buf
, int len
)
1101 struct test_driver_bss
*bss
= priv
;
1103 wpa_printf(MSG_DEBUG
, "%s(ifname=%s)", __func__
, bss
->ifname
);
1106 wpa_hexdump_ascii(MSG_DEBUG
, "test_driver_set_ssid: SSID", buf
, len
);
1108 if ((size_t) len
> sizeof(bss
->ssid
))
1111 os_memcpy(bss
->ssid
, buf
, len
);
1112 bss
->ssid_len
= len
;
1118 static int test_driver_set_privacy(void *priv
, int enabled
)
1120 struct test_driver_bss
*dbss
= priv
;
1122 wpa_printf(MSG_DEBUG
, "%s(enabled=%d)", __func__
, enabled
);
1123 dbss
->privacy
= enabled
;
1129 static int test_driver_set_sta_vlan(void *priv
, const u8
*addr
,
1130 const char *ifname
, int vlan_id
)
1132 wpa_printf(MSG_DEBUG
, "%s(addr=" MACSTR
" ifname=%s vlan_id=%d)",
1133 __func__
, MAC2STR(addr
), ifname
, vlan_id
);
1138 static int test_driver_sta_add(void *priv
,
1139 struct hostapd_sta_add_params
*params
)
1141 struct test_driver_bss
*bss
= priv
;
1142 struct wpa_driver_test_data
*drv
= bss
->drv
;
1143 struct test_client_socket
*cli
;
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
);
1154 if (os_memcmp(cli
->addr
, params
->addr
, ETH_ALEN
) == 0)
1159 wpa_printf(MSG_DEBUG
, "%s: no matching client entry",
1170 static struct wpa_driver_test_data
* test_alloc_data(void *ctx
,
1173 struct wpa_driver_test_data
*drv
;
1174 struct test_driver_bss
*bss
;
1176 drv
= os_zalloc(sizeof(struct wpa_driver_test_data
));
1178 wpa_printf(MSG_ERROR
, "Could not allocate memory for test "
1183 bss
= os_zalloc(sizeof(struct test_driver_bss
));
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
);
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);
1207 static void * test_driver_init(struct hostapd_data
*hapd
,
1208 struct wpa_init_params
*params
)
1210 struct wpa_driver_test_data
*drv
;
1211 struct sockaddr_un addr_un
;
1212 struct sockaddr_in addr_in
;
1213 struct sockaddr
*addr
;
1215 struct test_driver_bss
*bss
;
1217 drv
= test_alloc_data(hapd
, params
->ifname
);
1221 bss
= dl_list_first(&drv
->bss
, struct test_driver_bss
, list
);
1222 drv
->global
= params
->global_priv
;
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
);
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
);
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
,
1242 params
->test_socket
+ 4,
1243 MAC2STR(params
->own_addr
));
1245 } else if (strncmp(params
->test_socket
, "UDP:", 4) == 0) {
1246 drv
->udp_port
= atoi(params
->test_socket
+ 4);
1248 drv
->own_socket_path
= os_strdup(params
->test_socket
);
1250 if (drv
->own_socket_path
== NULL
&& drv
->udp_port
== 0) {
1251 wpa_driver_test_deinit(bss
);
1255 drv
->test_socket
= socket(drv
->udp_port
? PF_INET
: PF_UNIX
,
1257 if (drv
->test_socket
< 0) {
1259 wpa_driver_test_deinit(bss
);
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
);
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
);
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
);
1285 eloop_register_read_sock(drv
->test_socket
,
1286 test_driver_receive_unix
, drv
, NULL
);
1288 drv
->test_socket
= -1;
1294 static void wpa_driver_test_poll(void *eloop_ctx
, void *timeout_ctx
)
1296 struct wpa_driver_test_data
*drv
= eloop_ctx
;
1298 #ifdef DRIVER_TEST_UNIX
1299 if (drv
->associated
&& drv
->hostapd_addr_set
) {
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
);
1308 #endif /* DRIVER_TEST_UNIX */
1310 eloop_register_timeout(1, 0, wpa_driver_test_poll
, drv
, NULL
);
1314 static void wpa_driver_test_scan_timeout(void *eloop_ctx
, void *timeout_ctx
)
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
) {
1321 for (i
= 0; i
< drv
->num_scanres
; i
++) {
1322 struct wpa_scan_res
*bss
= drv
->scanres
[i
];
1323 if (p2p_scan_res_handler(drv
->p2p
, bss
->bssid
,
1324 bss
->freq
, bss
->level
,
1325 (const u8
*) (bss
+ 1),
1329 p2p_scan_res_handled(drv
->p2p
);
1330 #endif /* CONFIG_P2P */
1333 wpa_supplicant_event(timeout_ctx
, EVENT_SCAN_RESULTS
, NULL
);
1337 #ifdef DRIVER_TEST_UNIX
1338 static void wpa_driver_scan_dir(struct wpa_driver_test_data
*drv
,
1341 struct dirent
*dent
;
1343 struct sockaddr_un addr
;
1344 char cmd
[512], *pos
, *end
;
1347 dir
= opendir(path
);
1351 end
= cmd
+ sizeof(cmd
);
1353 ret
= os_snprintf(pos
, end
- pos
, "SCAN " MACSTR
,
1354 MAC2STR(drv
->own_addr
));
1355 if (ret
>= 0 && ret
< end
- pos
)
1357 if (drv
->probe_req_ie
) {
1358 ret
= os_snprintf(pos
, end
- pos
, " ");
1359 if (ret
>= 0 && ret
< end
- pos
)
1361 pos
+= wpa_snprintf_hex(pos
, end
- pos
, drv
->probe_req_ie
,
1362 drv
->probe_req_ie_len
);
1364 if (drv
->probe_req_ssid_len
) {
1366 ret
= os_snprintf(pos
, end
- pos
, "%02x%02x",
1368 (unsigned int) drv
->probe_req_ssid_len
);
1369 if (ret
>= 0 && ret
< end
- pos
)
1371 pos
+= wpa_snprintf_hex(pos
, end
- pos
, drv
->probe_req_ssid
,
1372 drv
->probe_req_ssid_len
);
1376 while ((dent
= readdir(dir
))) {
1377 if (os_strncmp(dent
->d_name
, "AP-", 3) != 0 &&
1378 os_strncmp(dent
->d_name
, "STA-", 4) != 0)
1380 if (drv
->own_socket_path
) {
1382 olen
= os_strlen(drv
->own_socket_path
);
1383 dlen
= os_strlen(dent
->d_name
);
1385 os_strcmp(dent
->d_name
,
1386 drv
->own_socket_path
+ olen
- dlen
) == 0)
1389 wpa_printf(MSG_DEBUG
, "%s: SCAN %s", __func__
, dent
->d_name
);
1391 os_memset(&addr
, 0, sizeof(addr
));
1392 addr
.sun_family
= AF_UNIX
;
1393 os_snprintf(addr
.sun_path
, sizeof(addr
.sun_path
), "%s/%s",
1394 path
, dent
->d_name
);
1396 if (sendto(drv
->test_socket
, cmd
, os_strlen(cmd
), 0,
1397 (struct sockaddr
*) &addr
, sizeof(addr
)) < 0) {
1398 perror("sendto(test_socket)");
1403 #endif /* DRIVER_TEST_UNIX */
1406 static int wpa_driver_test_scan(void *priv
,
1407 struct wpa_driver_scan_params
*params
)
1409 struct test_driver_bss
*dbss
= priv
;
1410 struct wpa_driver_test_data
*drv
= dbss
->drv
;
1413 wpa_printf(MSG_DEBUG
, "%s: priv=%p", __func__
, priv
);
1415 os_free(drv
->probe_req_ie
);
1416 if (params
->extra_ies
) {
1417 drv
->probe_req_ie
= os_malloc(params
->extra_ies_len
);
1418 if (drv
->probe_req_ie
== NULL
) {
1419 drv
->probe_req_ie_len
= 0;
1422 os_memcpy(drv
->probe_req_ie
, params
->extra_ies
,
1423 params
->extra_ies_len
);
1424 drv
->probe_req_ie_len
= params
->extra_ies_len
;
1426 drv
->probe_req_ie
= NULL
;
1427 drv
->probe_req_ie_len
= 0;
1430 for (i
= 0; i
< params
->num_ssids
; i
++)
1431 wpa_hexdump(MSG_DEBUG
, "Scan SSID",
1432 params
->ssids
[i
].ssid
, params
->ssids
[i
].ssid_len
);
1433 drv
->probe_req_ssid_len
= 0;
1434 if (params
->num_ssids
) {
1435 os_memcpy(drv
->probe_req_ssid
, params
->ssids
[0].ssid
,
1436 params
->ssids
[0].ssid_len
);
1437 drv
->probe_req_ssid_len
= params
->ssids
[0].ssid_len
;
1439 wpa_hexdump(MSG_DEBUG
, "Scan extra IE(s)",
1440 params
->extra_ies
, params
->extra_ies_len
);
1442 drv
->num_scanres
= 0;
1444 #ifdef DRIVER_TEST_UNIX
1445 if (drv
->test_socket
>= 0 && drv
->test_dir
)
1446 wpa_driver_scan_dir(drv
, drv
->test_dir
);
1448 if (drv
->test_socket
>= 0 && drv
->hostapd_addr_set
&&
1449 sendto(drv
->test_socket
, "SCAN", 4, 0,
1450 (struct sockaddr
*) &drv
->hostapd_addr
,
1451 sizeof(drv
->hostapd_addr
)) < 0) {
1452 perror("sendto(test_socket)");
1454 #endif /* DRIVER_TEST_UNIX */
1456 if (drv
->test_socket
>= 0 && drv
->hostapd_addr_udp_set
&&
1457 sendto(drv
->test_socket
, "SCAN", 4, 0,
1458 (struct sockaddr
*) &drv
->hostapd_addr_udp
,
1459 sizeof(drv
->hostapd_addr_udp
)) < 0) {
1460 perror("sendto(test_socket)");
1463 eloop_cancel_timeout(wpa_driver_test_scan_timeout
, drv
, drv
->ctx
);
1464 eloop_register_timeout(1, 0, wpa_driver_test_scan_timeout
, drv
,
1470 static struct wpa_scan_results
* wpa_driver_test_get_scan_results2(void *priv
)
1472 struct test_driver_bss
*dbss
= priv
;
1473 struct wpa_driver_test_data
*drv
= dbss
->drv
;
1474 struct wpa_scan_results
*res
;
1477 res
= os_zalloc(sizeof(*res
));
1481 res
->res
= os_calloc(drv
->num_scanres
, sizeof(struct wpa_scan_res
*));
1482 if (res
->res
== NULL
) {
1487 for (i
= 0; i
< drv
->num_scanres
; i
++) {
1488 struct wpa_scan_res
*r
;
1489 if (drv
->scanres
[i
] == NULL
)
1491 r
= os_malloc(sizeof(*r
) + drv
->scanres
[i
]->ie_len
);
1494 os_memcpy(r
, drv
->scanres
[i
],
1495 sizeof(*r
) + drv
->scanres
[i
]->ie_len
);
1496 res
->res
[res
->num
++] = r
;
1503 static int wpa_driver_test_set_key(const char *ifname
, void *priv
,
1504 enum wpa_alg alg
, const u8
*addr
,
1505 int key_idx
, int set_tx
,
1506 const u8
*seq
, size_t seq_len
,
1507 const u8
*key
, size_t key_len
)
1509 wpa_printf(MSG_DEBUG
, "%s: ifname=%s priv=%p alg=%d key_idx=%d "
1511 __func__
, ifname
, priv
, alg
, key_idx
, set_tx
);
1513 wpa_printf(MSG_DEBUG
, " addr=" MACSTR
, MAC2STR(addr
));
1515 wpa_hexdump(MSG_DEBUG
, " seq", seq
, seq_len
);
1517 wpa_hexdump_key(MSG_DEBUG
, " key", key
, key_len
);
1522 static int wpa_driver_update_mode(struct wpa_driver_test_data
*drv
, int ap
)
1524 if (ap
&& !drv
->ap
) {
1525 wpa_driver_test_close_test_socket(drv
);
1526 wpa_driver_test_attach(drv
, drv
->test_dir
, 1);
1528 } else if (!ap
&& drv
->ap
) {
1529 wpa_driver_test_close_test_socket(drv
);
1530 wpa_driver_test_attach(drv
, drv
->test_dir
, 0);
1538 static int wpa_driver_test_associate(
1539 void *priv
, struct wpa_driver_associate_params
*params
)
1541 struct test_driver_bss
*dbss
= priv
;
1542 struct wpa_driver_test_data
*drv
= dbss
->drv
;
1543 wpa_printf(MSG_DEBUG
, "%s: priv=%p freq=%d pairwise_suite=%d "
1544 "group_suite=%d key_mgmt_suite=%d auth_alg=%d mode=%d",
1545 __func__
, priv
, params
->freq
, params
->pairwise_suite
,
1546 params
->group_suite
, params
->key_mgmt_suite
,
1547 params
->auth_alg
, params
->mode
);
1548 wpa_driver_update_mode(drv
, params
->mode
== IEEE80211_MODE_AP
);
1549 if (params
->bssid
) {
1550 wpa_printf(MSG_DEBUG
, " bssid=" MACSTR
,
1551 MAC2STR(params
->bssid
));
1554 wpa_hexdump_ascii(MSG_DEBUG
, " ssid",
1555 params
->ssid
, params
->ssid_len
);
1557 if (params
->wpa_ie
) {
1558 wpa_hexdump(MSG_DEBUG
, " wpa_ie",
1559 params
->wpa_ie
, params
->wpa_ie_len
);
1560 drv
->assoc_wpa_ie_len
= params
->wpa_ie_len
;
1561 if (drv
->assoc_wpa_ie_len
> sizeof(drv
->assoc_wpa_ie
))
1562 drv
->assoc_wpa_ie_len
= sizeof(drv
->assoc_wpa_ie
);
1563 os_memcpy(drv
->assoc_wpa_ie
, params
->wpa_ie
,
1564 drv
->assoc_wpa_ie_len
);
1566 drv
->assoc_wpa_ie_len
= 0;
1568 wpa_driver_update_mode(drv
, params
->mode
== IEEE80211_MODE_AP
);
1570 drv
->ibss
= params
->mode
== IEEE80211_MODE_IBSS
;
1571 dbss
->privacy
= params
->key_mgmt_suite
&
1572 (WPA_KEY_MGMT_IEEE8021X
|
1574 WPA_KEY_MGMT_WPA_NONE
|
1575 WPA_KEY_MGMT_FT_IEEE8021X
|
1576 WPA_KEY_MGMT_FT_PSK
|
1577 WPA_KEY_MGMT_IEEE8021X_SHA256
|
1578 WPA_KEY_MGMT_PSK_SHA256
);
1579 if (params
->wep_key_len
[params
->wep_tx_keyidx
])
1582 #ifdef DRIVER_TEST_UNIX
1583 if (drv
->test_dir
&& params
->bssid
&&
1584 params
->mode
!= IEEE80211_MODE_IBSS
) {
1585 os_memset(&drv
->hostapd_addr
, 0, sizeof(drv
->hostapd_addr
));
1586 drv
->hostapd_addr
.sun_family
= AF_UNIX
;
1587 os_snprintf(drv
->hostapd_addr
.sun_path
,
1588 sizeof(drv
->hostapd_addr
.sun_path
),
1590 drv
->test_dir
, MAC2STR(params
->bssid
));
1591 drv
->hostapd_addr_set
= 1;
1593 #endif /* DRIVER_TEST_UNIX */
1595 if (params
->mode
== IEEE80211_MODE_AP
) {
1596 os_memcpy(dbss
->ssid
, params
->ssid
, params
->ssid_len
);
1597 dbss
->ssid_len
= params
->ssid_len
;
1598 os_memcpy(dbss
->bssid
, drv
->own_addr
, ETH_ALEN
);
1599 if (params
->wpa_ie
&& params
->wpa_ie_len
) {
1600 dbss
->ie
= os_malloc(params
->wpa_ie_len
);
1602 os_memcpy(dbss
->ie
, params
->wpa_ie
,
1603 params
->wpa_ie_len
);
1604 dbss
->ielen
= params
->wpa_ie_len
;
1607 } else if (drv
->test_socket
>= 0 &&
1608 (drv
->hostapd_addr_set
|| drv
->hostapd_addr_udp_set
)) {
1609 char cmd
[200], *pos
, *end
;
1611 end
= cmd
+ sizeof(cmd
);
1613 ret
= os_snprintf(pos
, end
- pos
, "ASSOC " MACSTR
" ",
1614 MAC2STR(drv
->own_addr
));
1615 if (ret
>= 0 && ret
< end
- pos
)
1617 pos
+= wpa_snprintf_hex(pos
, end
- pos
, params
->ssid
,
1619 ret
= os_snprintf(pos
, end
- pos
, " ");
1620 if (ret
>= 0 && ret
< end
- pos
)
1622 pos
+= wpa_snprintf_hex(pos
, end
- pos
, params
->wpa_ie
,
1623 params
->wpa_ie_len
);
1625 #ifdef DRIVER_TEST_UNIX
1626 if (drv
->hostapd_addr_set
&&
1627 sendto(drv
->test_socket
, cmd
, os_strlen(cmd
), 0,
1628 (struct sockaddr
*) &drv
->hostapd_addr
,
1629 sizeof(drv
->hostapd_addr
)) < 0) {
1630 perror("sendto(test_socket)");
1633 #endif /* DRIVER_TEST_UNIX */
1634 if (drv
->hostapd_addr_udp_set
&&
1635 sendto(drv
->test_socket
, cmd
, os_strlen(cmd
), 0,
1636 (struct sockaddr
*) &drv
->hostapd_addr_udp
,
1637 sizeof(drv
->hostapd_addr_udp
)) < 0) {
1638 perror("sendto(test_socket)");
1642 os_memcpy(dbss
->ssid
, params
->ssid
, params
->ssid_len
);
1643 dbss
->ssid_len
= params
->ssid_len
;
1645 drv
->associated
= 1;
1646 if (params
->mode
== IEEE80211_MODE_IBSS
) {
1647 os_memcpy(dbss
->ssid
, params
->ssid
, params
->ssid_len
);
1648 dbss
->ssid_len
= params
->ssid_len
;
1650 os_memcpy(dbss
->bssid
, params
->bssid
,
1653 os_get_random(dbss
->bssid
, ETH_ALEN
);
1654 dbss
->bssid
[0] &= ~0x01;
1655 dbss
->bssid
[0] |= 0x02;
1658 wpa_supplicant_event(drv
->ctx
, EVENT_ASSOC
, NULL
);
1665 static int wpa_driver_test_get_bssid(void *priv
, u8
*bssid
)
1667 struct test_driver_bss
*dbss
= priv
;
1668 os_memcpy(bssid
, dbss
->bssid
, ETH_ALEN
);
1673 static int wpa_driver_test_get_ssid(void *priv
, u8
*ssid
)
1675 struct test_driver_bss
*dbss
= priv
;
1676 os_memcpy(ssid
, dbss
->ssid
, 32);
1677 return dbss
->ssid_len
;
1681 static int wpa_driver_test_send_disassoc(struct wpa_driver_test_data
*drv
)
1683 #ifdef DRIVER_TEST_UNIX
1684 if (drv
->test_socket
>= 0 &&
1685 sendto(drv
->test_socket
, "DISASSOC", 8, 0,
1686 (struct sockaddr
*) &drv
->hostapd_addr
,
1687 sizeof(drv
->hostapd_addr
)) < 0) {
1688 perror("sendto(test_socket)");
1691 #endif /* DRIVER_TEST_UNIX */
1692 if (drv
->test_socket
>= 0 && drv
->hostapd_addr_udp_set
&&
1693 sendto(drv
->test_socket
, "DISASSOC", 8, 0,
1694 (struct sockaddr
*) &drv
->hostapd_addr_udp
,
1695 sizeof(drv
->hostapd_addr_udp
)) < 0) {
1696 perror("sendto(test_socket)");
1703 static int wpa_driver_test_deauthenticate(void *priv
, const u8
*addr
,
1706 struct test_driver_bss
*dbss
= priv
;
1707 struct wpa_driver_test_data
*drv
= dbss
->drv
;
1708 wpa_printf(MSG_DEBUG
, "%s addr=" MACSTR
" reason_code=%d",
1709 __func__
, MAC2STR(addr
), reason_code
);
1710 os_memset(dbss
->bssid
, 0, ETH_ALEN
);
1711 drv
->associated
= 0;
1712 wpa_supplicant_event(drv
->ctx
, EVENT_DISASSOC
, NULL
);
1713 return wpa_driver_test_send_disassoc(drv
);
1717 static const u8
* wpa_scan_get_ie(const struct wpa_scan_res
*res
, u8 ie
)
1719 const u8
*end
, *pos
;
1721 pos
= (const u8
*) (res
+ 1);
1722 end
= pos
+ res
->ie_len
;
1724 while (pos
+ 1 < end
) {
1725 if (pos
+ 2 + pos
[1] > end
)
1736 static void wpa_driver_test_scanresp(struct wpa_driver_test_data
*drv
,
1737 struct sockaddr
*from
,
1741 struct wpa_scan_res
*res
;
1742 const char *pos
, *pos2
;
1744 u8
*ie_pos
, *ie_start
, *ie_end
;
1745 #define MAX_IE_LEN 1000
1746 const u8
*ds_params
;
1748 wpa_printf(MSG_DEBUG
, "test_driver: SCANRESP %s", data
);
1749 if (drv
->num_scanres
>= MAX_SCAN_RESULTS
) {
1750 wpa_printf(MSG_DEBUG
, "test_driver: No room for the new scan "
1755 /* SCANRESP BSSID SSID IEs */
1757 res
= os_zalloc(sizeof(*res
) + MAX_IE_LEN
);
1760 ie_start
= ie_pos
= (u8
*) (res
+ 1);
1761 ie_end
= ie_pos
+ MAX_IE_LEN
;
1763 if (hwaddr_aton(data
, res
->bssid
)) {
1764 wpa_printf(MSG_DEBUG
, "test_driver: invalid BSSID in scanres");
1772 pos2
= os_strchr(pos
, ' ');
1774 wpa_printf(MSG_DEBUG
, "test_driver: invalid SSID termination "
1779 len
= (pos2
- pos
) / 2;
1783 * Generate SSID IE from the SSID field since this IE is not included
1784 * in the main IE field.
1786 *ie_pos
++ = WLAN_EID_SSID
;
1788 if (hexstr2bin(pos
, ie_pos
, len
) < 0) {
1789 wpa_printf(MSG_DEBUG
, "test_driver: invalid SSID in scanres");
1796 pos2
= os_strchr(pos
, ' ');
1798 len
= os_strlen(pos
) / 2;
1800 len
= (pos2
- pos
) / 2;
1801 if ((int) len
> ie_end
- ie_pos
)
1802 len
= ie_end
- ie_pos
;
1803 if (hexstr2bin(pos
, ie_pos
, len
) < 0) {
1804 wpa_printf(MSG_DEBUG
, "test_driver: invalid IEs in scanres");
1809 res
->ie_len
= ie_pos
- ie_start
;
1815 if (os_strstr(pos
, "PRIVACY"))
1816 res
->caps
|= IEEE80211_CAP_PRIVACY
;
1817 if (os_strstr(pos
, "IBSS"))
1818 res
->caps
|= IEEE80211_CAP_IBSS
;
1821 ds_params
= wpa_scan_get_ie(res
, WLAN_EID_DS_PARAMS
);
1822 if (ds_params
&& ds_params
[1] > 0) {
1823 if (ds_params
[2] >= 1 && ds_params
[2] <= 13)
1824 res
->freq
= 2407 + ds_params
[2] * 5;
1827 os_free(drv
->scanres
[drv
->num_scanres
]);
1828 drv
->scanres
[drv
->num_scanres
++] = res
;
1832 static void wpa_driver_test_assocresp(struct wpa_driver_test_data
*drv
,
1833 struct sockaddr
*from
,
1837 struct test_driver_bss
*bss
;
1839 bss
= dl_list_first(&drv
->bss
, struct test_driver_bss
, list
);
1841 /* ASSOCRESP BSSID <res> */
1842 if (hwaddr_aton(data
, bss
->bssid
)) {
1843 wpa_printf(MSG_DEBUG
, "test_driver: invalid BSSID in "
1846 if (drv
->use_associnfo
) {
1847 union wpa_event_data event
;
1848 os_memset(&event
, 0, sizeof(event
));
1849 event
.assoc_info
.req_ies
= drv
->assoc_wpa_ie
;
1850 event
.assoc_info
.req_ies_len
= drv
->assoc_wpa_ie_len
;
1851 wpa_supplicant_event(drv
->ctx
, EVENT_ASSOCINFO
, &event
);
1853 drv
->associated
= 1;
1854 wpa_supplicant_event(drv
->ctx
, EVENT_ASSOC
, NULL
);
1858 static void wpa_driver_test_disassoc(struct wpa_driver_test_data
*drv
,
1859 struct sockaddr
*from
,
1862 drv
->associated
= 0;
1863 wpa_supplicant_event(drv
->ctx
, EVENT_DISASSOC
, NULL
);
1867 static void wpa_driver_test_eapol(struct wpa_driver_test_data
*drv
,
1868 struct sockaddr
*from
,
1870 const u8
*data
, size_t data_len
)
1873 struct test_driver_bss
*bss
;
1875 bss
= dl_list_first(&drv
->bss
, struct test_driver_bss
, list
);
1877 if (data_len
> 14) {
1878 /* Skip Ethernet header */
1879 src
= data
+ ETH_ALEN
;
1885 drv_event_eapol_rx(drv
->ctx
, src
, data
, data_len
);
1889 static void wpa_driver_test_mlme(struct wpa_driver_test_data
*drv
,
1890 struct sockaddr
*from
,
1892 const u8
*data
, size_t data_len
)
1894 int freq
= 0, own_freq
;
1895 union wpa_event_data event
;
1896 const struct ieee80211_mgmt
*mgmt
;
1898 struct test_driver_bss
*bss
;
1900 bss
= dl_list_first(&drv
->bss
, struct test_driver_bss
, list
);
1901 if (data_len
> 6 && os_memcmp(data
, "freq=", 5) == 0) {
1903 for (pos
= 5; pos
< data_len
; pos
++) {
1904 if (data
[pos
] == ' ')
1907 if (pos
< data_len
) {
1908 freq
= atoi((const char *) &data
[5]);
1909 wpa_printf(MSG_DEBUG
, "test_driver(%s): MLME RX on "
1910 "freq %d MHz", bss
->ifname
, freq
);
1917 if (drv
->remain_on_channel_freq
)
1918 own_freq
= drv
->remain_on_channel_freq
;
1920 own_freq
= drv
->current_freq
;
1922 if (freq
&& own_freq
&& freq
!= own_freq
) {
1923 wpa_printf(MSG_DEBUG
, "test_driver(%s): Ignore MLME RX on "
1924 "another frequency %d MHz (own %d MHz)",
1925 bss
->ifname
, freq
, own_freq
);
1929 os_memset(&event
, 0, sizeof(event
));
1930 event
.mlme_rx
.buf
= data
;
1931 event
.mlme_rx
.len
= data_len
;
1932 event
.mlme_rx
.freq
= freq
;
1933 wpa_supplicant_event(drv
->ctx
, EVENT_MLME_RX
, &event
);
1935 mgmt
= (const struct ieee80211_mgmt
*) data
;
1936 fc
= le_to_host16(mgmt
->frame_control
);
1938 if (drv
->probe_req_report
&& data_len
>= 24) {
1939 if (WLAN_FC_GET_TYPE(fc
) == WLAN_FC_TYPE_MGMT
&&
1940 WLAN_FC_GET_STYPE(fc
) == WLAN_FC_STYPE_PROBE_REQ
) {
1941 os_memset(&event
, 0, sizeof(event
));
1942 event
.rx_probe_req
.sa
= mgmt
->sa
;
1943 event
.rx_probe_req
.da
= mgmt
->da
;
1944 event
.rx_probe_req
.bssid
= mgmt
->bssid
;
1945 event
.rx_probe_req
.ie
= mgmt
->u
.probe_req
.variable
;
1946 event
.rx_probe_req
.ie_len
=
1947 data_len
- (mgmt
->u
.probe_req
.variable
- data
);
1948 wpa_supplicant_event(drv
->ctx
, EVENT_RX_PROBE_REQ
,
1952 p2p_probe_req_rx(drv
->p2p
, mgmt
->sa
,
1953 mgmt
->da
, mgmt
->bssid
,
1954 event
.rx_probe_req
.ie
,
1955 event
.rx_probe_req
.ie_len
);
1956 #endif /* CONFIG_P2P */
1962 WLAN_FC_GET_TYPE(fc
) == WLAN_FC_TYPE_MGMT
&&
1963 WLAN_FC_GET_STYPE(fc
) == WLAN_FC_STYPE_ACTION
) {
1965 hdr_len
= (const u8
*)
1966 &mgmt
->u
.action
.u
.vs_public_action
.action
- data
;
1967 p2p_rx_action(drv
->p2p
, mgmt
->da
, mgmt
->sa
, mgmt
->bssid
,
1968 mgmt
->u
.action
.category
,
1969 &mgmt
->u
.action
.u
.vs_public_action
.action
,
1970 data_len
- hdr_len
, freq
);
1972 #endif /* CONFIG_P2P */
1977 static void wpa_driver_test_scan_cmd(struct wpa_driver_test_data
*drv
,
1978 struct sockaddr
*from
,
1980 const u8
*data
, size_t data_len
)
1982 char buf
[512], *pos
, *end
;
1984 struct test_driver_bss
*bss
;
1986 bss
= dl_list_first(&drv
->bss
, struct test_driver_bss
, list
);
1988 /* data: optional [ STA-addr | ' ' | IEs(hex) ] */
1990 if (drv
->probe_req_report
&& drv
->p2p
&& data_len
) {
1991 const char *d
= (const char *) data
;
1996 if (hwaddr_aton(d
, sa
))
2001 ielen
= os_strlen(d
) / 2;
2002 if (ielen
> sizeof(ie
))
2004 if (hexstr2bin(d
, ie
, ielen
) < 0)
2006 drv
->probe_from
= from
;
2007 drv
->probe_from_len
= fromlen
;
2008 p2p_probe_req_rx(drv
->p2p
, sa
, NULL
, NULL
, ie
, ielen
);
2009 drv
->probe_from
= NULL
;
2011 #endif /* CONFIG_P2P */
2017 end
= buf
+ sizeof(buf
);
2019 /* reply: SCANRESP BSSID SSID IEs */
2020 ret
= snprintf(pos
, end
- pos
, "SCANRESP " MACSTR
" ",
2021 MAC2STR(bss
->bssid
));
2022 if (ret
< 0 || ret
>= end
- pos
)
2025 pos
+= wpa_snprintf_hex(pos
, end
- pos
,
2026 bss
->ssid
, bss
->ssid_len
);
2027 ret
= snprintf(pos
, end
- pos
, " ");
2028 if (ret
< 0 || ret
>= end
- pos
)
2031 pos
+= wpa_snprintf_hex(pos
, end
- pos
, drv
->assoc_wpa_ie
,
2032 drv
->assoc_wpa_ie_len
);
2035 ret
= snprintf(pos
, end
- pos
, " PRIVACY");
2036 if (ret
< 0 || ret
>= end
- pos
)
2041 ret
= snprintf(pos
, end
- pos
, " IBSS");
2042 if (ret
< 0 || ret
>= end
- pos
)
2046 sendto(drv
->test_socket
, buf
, pos
- buf
, 0,
2047 (struct sockaddr
*) from
, fromlen
);
2051 static void wpa_driver_test_receive_unix(int sock
, void *eloop_ctx
,
2054 struct wpa_driver_test_data
*drv
= eloop_ctx
;
2057 struct sockaddr_storage from
;
2058 socklen_t fromlen
= sizeof(from
);
2059 const size_t buflen
= 2000;
2062 test_driver_receive_unix(sock
, eloop_ctx
, sock_ctx
);
2066 buf
= os_malloc(buflen
);
2069 res
= recvfrom(sock
, buf
, buflen
- 1, 0,
2070 (struct sockaddr
*) &from
, &fromlen
);
2072 perror("recvfrom(test_socket)");
2078 wpa_printf(MSG_DEBUG
, "test_driver: received %u bytes", res
);
2080 if (os_strncmp(buf
, "SCANRESP ", 9) == 0) {
2081 wpa_driver_test_scanresp(drv
, (struct sockaddr
*) &from
,
2083 } else if (os_strncmp(buf
, "ASSOCRESP ", 10) == 0) {
2084 wpa_driver_test_assocresp(drv
, (struct sockaddr
*) &from
,
2086 } else if (os_strcmp(buf
, "DISASSOC") == 0) {
2087 wpa_driver_test_disassoc(drv
, (struct sockaddr
*) &from
,
2089 } else if (os_strcmp(buf
, "DEAUTH") == 0) {
2090 wpa_driver_test_disassoc(drv
, (struct sockaddr
*) &from
,
2092 } else if (os_strncmp(buf
, "EAPOL ", 6) == 0) {
2093 wpa_driver_test_eapol(drv
, (struct sockaddr
*) &from
, fromlen
,
2094 (const u8
*) buf
+ 6, res
- 6);
2095 } else if (os_strncmp(buf
, "MLME ", 5) == 0) {
2096 wpa_driver_test_mlme(drv
, (struct sockaddr
*) &from
, fromlen
,
2097 (const u8
*) buf
+ 5, res
- 5);
2098 } else if (os_strncmp(buf
, "SCAN ", 5) == 0) {
2099 wpa_driver_test_scan_cmd(drv
, (struct sockaddr
*) &from
,
2101 (const u8
*) buf
+ 5, res
- 5);
2103 wpa_hexdump_ascii(MSG_DEBUG
, "Unknown test_socket command",
2110 static void * wpa_driver_test_init2(void *ctx
, const char *ifname
,
2113 struct wpa_driver_test_data
*drv
;
2114 struct wpa_driver_test_global
*global
= global_priv
;
2115 struct test_driver_bss
*bss
;
2117 drv
= test_alloc_data(ctx
, ifname
);
2120 bss
= dl_list_first(&drv
->bss
, struct test_driver_bss
, list
);
2121 drv
->global
= global_priv
;
2122 drv
->test_socket
= -1;
2124 /* Set dummy BSSID and SSID for testing. */
2125 bss
->bssid
[0] = 0x02;
2126 bss
->bssid
[1] = 0x00;
2127 bss
->bssid
[2] = 0x00;
2128 bss
->bssid
[3] = 0x00;
2129 bss
->bssid
[4] = 0x00;
2130 bss
->bssid
[5] = 0x01;
2131 os_memcpy(bss
->ssid
, "test", 5);
2134 if (global
->bss_add_used
) {
2135 os_memcpy(drv
->own_addr
, global
->req_addr
, ETH_ALEN
);
2136 global
->bss_add_used
= 0;
2139 eloop_register_timeout(1, 0, wpa_driver_test_poll
, drv
, NULL
);
2145 static void wpa_driver_test_close_test_socket(struct wpa_driver_test_data
*drv
)
2147 if (drv
->test_socket
>= 0) {
2148 eloop_unregister_read_sock(drv
->test_socket
);
2149 close(drv
->test_socket
);
2150 drv
->test_socket
= -1;
2153 if (drv
->own_socket_path
) {
2154 unlink(drv
->own_socket_path
);
2155 os_free(drv
->own_socket_path
);
2156 drv
->own_socket_path
= NULL
;
2161 static void wpa_driver_test_deinit(void *priv
)
2163 struct test_driver_bss
*dbss
= priv
;
2164 struct wpa_driver_test_data
*drv
= dbss
->drv
;
2165 struct test_client_socket
*cli
, *prev
;
2170 p2p_deinit(drv
->p2p
);
2171 wpabuf_free(drv
->pending_action_tx
);
2172 #endif /* CONFIG_P2P */
2182 /* There should be only one BSS remaining at this point. */
2183 if (dl_list_len(&drv
->bss
) != 1)
2184 wpa_printf(MSG_ERROR
, "%s: %u remaining BSS entries",
2185 __func__
, dl_list_len(&drv
->bss
));
2186 #endif /* HOSTAPD */
2188 test_driver_free_bsses(drv
);
2190 wpa_driver_test_close_test_socket(drv
);
2191 eloop_cancel_timeout(wpa_driver_test_scan_timeout
, drv
, drv
->ctx
);
2192 eloop_cancel_timeout(wpa_driver_test_poll
, drv
, NULL
);
2193 eloop_cancel_timeout(test_remain_on_channel_timeout
, drv
, NULL
);
2194 os_free(drv
->test_dir
);
2195 for (i
= 0; i
< MAX_SCAN_RESULTS
; i
++)
2196 os_free(drv
->scanres
[i
]);
2197 os_free(drv
->probe_req_ie
);
2198 wpa_trace_remove_ref(drv
, ctx
, drv
->ctx
);
2203 static int wpa_driver_test_attach(struct wpa_driver_test_data
*drv
,
2204 const char *dir
, int ap
)
2206 #ifdef DRIVER_TEST_UNIX
2207 static unsigned int counter
= 0;
2208 struct sockaddr_un addr
;
2211 os_free(drv
->own_socket_path
);
2213 len
= os_strlen(dir
) + 30;
2214 drv
->own_socket_path
= os_malloc(len
);
2215 if (drv
->own_socket_path
== NULL
)
2217 os_snprintf(drv
->own_socket_path
, len
, "%s/%s-" MACSTR
,
2218 dir
, ap
? "AP" : "STA", MAC2STR(drv
->own_addr
));
2220 drv
->own_socket_path
= os_malloc(100);
2221 if (drv
->own_socket_path
== NULL
)
2223 os_snprintf(drv
->own_socket_path
, 100,
2224 "/tmp/wpa_supplicant_test-%d-%d",
2225 getpid(), counter
++);
2228 drv
->test_socket
= socket(PF_UNIX
, SOCK_DGRAM
, 0);
2229 if (drv
->test_socket
< 0) {
2230 perror("socket(PF_UNIX)");
2231 os_free(drv
->own_socket_path
);
2232 drv
->own_socket_path
= NULL
;
2236 os_memset(&addr
, 0, sizeof(addr
));
2237 addr
.sun_family
= AF_UNIX
;
2238 os_strlcpy(addr
.sun_path
, drv
->own_socket_path
, sizeof(addr
.sun_path
));
2239 if (bind(drv
->test_socket
, (struct sockaddr
*) &addr
,
2240 sizeof(addr
)) < 0) {
2241 perror("test-driver-attach: bind(PF_UNIX)");
2242 close(drv
->test_socket
);
2243 unlink(drv
->own_socket_path
);
2244 os_free(drv
->own_socket_path
);
2245 drv
->own_socket_path
= NULL
;
2249 eloop_register_read_sock(drv
->test_socket
,
2250 wpa_driver_test_receive_unix
, drv
, NULL
);
2253 #else /* DRIVER_TEST_UNIX */
2255 #endif /* DRIVER_TEST_UNIX */
2259 static int wpa_driver_test_attach_udp(struct wpa_driver_test_data
*drv
,
2264 pos
= os_strchr(dst
, ':');
2268 wpa_printf(MSG_DEBUG
, "%s: addr=%s port=%s", __func__
, dst
, pos
);
2270 drv
->test_socket
= socket(PF_INET
, SOCK_DGRAM
, 0);
2271 if (drv
->test_socket
< 0) {
2272 perror("socket(PF_INET)");
2276 os_memset(&drv
->hostapd_addr_udp
, 0, sizeof(drv
->hostapd_addr_udp
));
2277 drv
->hostapd_addr_udp
.sin_family
= AF_INET
;
2278 #if defined(CONFIG_NATIVE_WINDOWS) || defined(CONFIG_ANSI_C_EXTRA)
2282 sscanf(dst
, "%d.%d.%d.%d", &a
[0], &a
[1], &a
[2], &a
[3]);
2283 pos
= (u8
*) &drv
->hostapd_addr_udp
.sin_addr
;
2289 #else /* CONFIG_NATIVE_WINDOWS or CONFIG_ANSI_C_EXTRA */
2290 inet_aton(dst
, &drv
->hostapd_addr_udp
.sin_addr
);
2291 #endif /* CONFIG_NATIVE_WINDOWS or CONFIG_ANSI_C_EXTRA */
2292 drv
->hostapd_addr_udp
.sin_port
= htons(atoi(pos
));
2294 drv
->hostapd_addr_udp_set
= 1;
2296 eloop_register_read_sock(drv
->test_socket
,
2297 wpa_driver_test_receive_unix
, drv
, NULL
);
2303 static int wpa_driver_test_set_param(void *priv
, const char *param
)
2305 struct test_driver_bss
*dbss
= priv
;
2306 struct wpa_driver_test_data
*drv
= dbss
->drv
;
2309 wpa_printf(MSG_DEBUG
, "%s: param='%s'", __func__
, param
);
2313 wpa_driver_test_close_test_socket(drv
);
2315 #ifdef DRIVER_TEST_UNIX
2316 pos
= os_strstr(param
, "test_socket=");
2322 pos2
= os_strchr(pos
, ' ');
2326 len
= os_strlen(pos
);
2327 if (len
> sizeof(drv
->hostapd_addr
.sun_path
))
2329 os_memset(&drv
->hostapd_addr
, 0, sizeof(drv
->hostapd_addr
));
2330 drv
->hostapd_addr
.sun_family
= AF_UNIX
;
2331 os_memcpy(drv
->hostapd_addr
.sun_path
, pos
, len
);
2332 drv
->hostapd_addr_set
= 1;
2334 #endif /* DRIVER_TEST_UNIX */
2336 pos
= os_strstr(param
, "test_dir=");
2339 os_free(drv
->test_dir
);
2340 drv
->test_dir
= os_strdup(pos
+ 9);
2341 if (drv
->test_dir
== NULL
)
2343 end
= os_strchr(drv
->test_dir
, ' ');
2346 if (wpa_driver_test_attach(drv
, drv
->test_dir
, 0))
2349 pos
= os_strstr(param
, "test_udp=");
2352 dst
= os_strdup(pos
+ 9);
2355 epos
= os_strchr(dst
, ' ');
2358 if (wpa_driver_test_attach_udp(drv
, dst
))
2361 } else if (wpa_driver_test_attach(drv
, NULL
, 0))
2365 if (os_strstr(param
, "use_associnfo=1")) {
2366 wpa_printf(MSG_DEBUG
, "test_driver: Use AssocInfo events");
2367 drv
->use_associnfo
= 1;
2370 if (os_strstr(param
, "p2p_mgmt=1")) {
2371 wpa_printf(MSG_DEBUG
, "test_driver: Use internal P2P "
2373 if (wpa_driver_test_init_p2p(drv
) < 0)
2381 static const u8
* wpa_driver_test_get_mac_addr(void *priv
)
2383 struct test_driver_bss
*dbss
= priv
;
2384 struct wpa_driver_test_data
*drv
= dbss
->drv
;
2385 wpa_printf(MSG_DEBUG
, "%s", __func__
);
2386 return drv
->own_addr
;
2390 static int wpa_driver_test_send_eapol(void *priv
, const u8
*dest
, u16 proto
,
2391 const u8
*data
, size_t data_len
)
2393 struct test_driver_bss
*dbss
= priv
;
2394 struct wpa_driver_test_data
*drv
= dbss
->drv
;
2397 struct l2_ethhdr eth
;
2398 struct sockaddr
*addr
;
2400 #ifdef DRIVER_TEST_UNIX
2401 struct sockaddr_un addr_un
;
2402 #endif /* DRIVER_TEST_UNIX */
2404 wpa_hexdump(MSG_MSGDUMP
, "test_send_eapol TX frame", data
, data_len
);
2406 os_memset(ð
, 0, sizeof(eth
));
2407 os_memcpy(eth
.h_dest
, dest
, ETH_ALEN
);
2408 os_memcpy(eth
.h_source
, drv
->own_addr
, ETH_ALEN
);
2409 eth
.h_proto
= host_to_be16(proto
);
2411 msg_len
= 6 + sizeof(eth
) + data_len
;
2412 msg
= os_malloc(msg_len
);
2415 os_memcpy(msg
, "EAPOL ", 6);
2416 os_memcpy(msg
+ 6, ð
, sizeof(eth
));
2417 os_memcpy(msg
+ 6 + sizeof(eth
), data
, data_len
);
2419 if (os_memcmp(dest
, dbss
->bssid
, ETH_ALEN
) == 0 ||
2420 drv
->test_dir
== NULL
) {
2421 if (drv
->hostapd_addr_udp_set
) {
2422 addr
= (struct sockaddr
*) &drv
->hostapd_addr_udp
;
2423 alen
= sizeof(drv
->hostapd_addr_udp
);
2425 #ifdef DRIVER_TEST_UNIX
2426 addr
= (struct sockaddr
*) &drv
->hostapd_addr
;
2427 alen
= sizeof(drv
->hostapd_addr
);
2428 #else /* DRIVER_TEST_UNIX */
2431 #endif /* DRIVER_TEST_UNIX */
2434 #ifdef DRIVER_TEST_UNIX
2436 os_memset(&addr_un
, 0, sizeof(addr_un
));
2437 addr_un
.sun_family
= AF_UNIX
;
2438 os_snprintf(addr_un
.sun_path
, sizeof(addr_un
.sun_path
),
2439 "%s/STA-" MACSTR
, drv
->test_dir
, MAC2STR(dest
));
2440 if (stat(addr_un
.sun_path
, &st
) < 0) {
2441 os_snprintf(addr_un
.sun_path
, sizeof(addr_un
.sun_path
),
2443 drv
->test_dir
, MAC2STR(dest
));
2445 addr
= (struct sockaddr
*) &addr_un
;
2446 alen
= sizeof(addr_un
);
2447 #else /* DRIVER_TEST_UNIX */
2450 #endif /* DRIVER_TEST_UNIX */
2453 if (sendto(drv
->test_socket
, msg
, msg_len
, 0, addr
, alen
) < 0) {
2454 perror("sendmsg(test_socket)");
2464 static int wpa_driver_test_get_capa(void *priv
, struct wpa_driver_capa
*capa
)
2466 struct test_driver_bss
*dbss
= priv
;
2467 struct wpa_driver_test_data
*drv
= dbss
->drv
;
2468 os_memset(capa
, 0, sizeof(*capa
));
2469 capa
->key_mgmt
= WPA_DRIVER_CAPA_KEY_MGMT_WPA
|
2470 WPA_DRIVER_CAPA_KEY_MGMT_WPA2
|
2471 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK
|
2472 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK
|
2473 WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE
|
2474 WPA_DRIVER_CAPA_KEY_MGMT_FT
|
2475 WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK
;
2476 capa
->enc
= WPA_DRIVER_CAPA_ENC_WEP40
|
2477 WPA_DRIVER_CAPA_ENC_WEP104
|
2478 WPA_DRIVER_CAPA_ENC_TKIP
|
2479 WPA_DRIVER_CAPA_ENC_CCMP
;
2480 capa
->auth
= WPA_DRIVER_AUTH_OPEN
|
2481 WPA_DRIVER_AUTH_SHARED
|
2482 WPA_DRIVER_AUTH_LEAP
;
2484 capa
->flags
|= WPA_DRIVER_FLAGS_P2P_MGMT
;
2485 capa
->flags
|= WPA_DRIVER_FLAGS_AP
;
2486 capa
->flags
|= WPA_DRIVER_FLAGS_P2P_CONCURRENT
;
2487 capa
->flags
|= WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE
;
2488 capa
->flags
|= WPA_DRIVER_FLAGS_P2P_CAPABLE
;
2489 capa
->max_scan_ssids
= 2;
2490 capa
->max_remain_on_chan
= 60000;
2496 static int wpa_driver_test_mlme_setprotection(void *priv
, const u8
*addr
,
2500 wpa_printf(MSG_DEBUG
, "%s: protect_type=%d key_type=%d",
2501 __func__
, protect_type
, key_type
);
2504 wpa_printf(MSG_DEBUG
, "%s: addr=" MACSTR
,
2505 __func__
, MAC2STR(addr
));
2512 static void * wpa_driver_test_global_init(void)
2514 struct wpa_driver_test_global
*global
;
2516 global
= os_zalloc(sizeof(*global
));
2521 static void wpa_driver_test_global_deinit(void *priv
)
2523 struct wpa_driver_test_global
*global
= priv
;
2528 static struct wpa_interface_info
*
2529 wpa_driver_test_get_interfaces(void *global_priv
)
2531 /* struct wpa_driver_test_global *global = priv; */
2532 struct wpa_interface_info
*iface
;
2534 iface
= os_zalloc(sizeof(*iface
));
2537 iface
->ifname
= os_strdup("sta0");
2538 iface
->desc
= os_strdup("test interface 0");
2539 iface
->drv_name
= "test";
2540 iface
->next
= os_zalloc(sizeof(*iface
));
2542 iface
->next
->ifname
= os_strdup("sta1");
2543 iface
->next
->desc
= os_strdup("test interface 1");
2544 iface
->next
->drv_name
= "test";
2551 static struct hostapd_hw_modes
*
2552 wpa_driver_test_get_hw_feature_data(void *priv
, u16
*num_modes
, u16
*flags
)
2554 struct hostapd_hw_modes
*modes
;
2559 modes
= os_calloc(*num_modes
, sizeof(struct hostapd_hw_modes
));
2562 modes
[0].mode
= HOSTAPD_MODE_IEEE80211G
;
2563 modes
[0].num_channels
= 11;
2564 modes
[0].num_rates
= 12;
2565 modes
[0].channels
= os_calloc(11, sizeof(struct hostapd_channel_data
));
2566 modes
[0].rates
= os_calloc(modes
[0].num_rates
, sizeof(int));
2567 if (modes
[0].channels
== NULL
|| modes
[0].rates
== NULL
)
2569 for (i
= 0; i
< 11; i
++) {
2570 modes
[0].channels
[i
].chan
= i
+ 1;
2571 modes
[0].channels
[i
].freq
= 2412 + 5 * i
;
2572 modes
[0].channels
[i
].flag
= 0;
2574 modes
[0].rates
[0] = 10;
2575 modes
[0].rates
[1] = 20;
2576 modes
[0].rates
[2] = 55;
2577 modes
[0].rates
[3] = 110;
2578 modes
[0].rates
[4] = 60;
2579 modes
[0].rates
[5] = 90;
2580 modes
[0].rates
[6] = 120;
2581 modes
[0].rates
[7] = 180;
2582 modes
[0].rates
[8] = 240;
2583 modes
[0].rates
[9] = 360;
2584 modes
[0].rates
[10] = 480;
2585 modes
[0].rates
[11] = 540;
2587 modes
[1].mode
= HOSTAPD_MODE_IEEE80211B
;
2588 modes
[1].num_channels
= 11;
2589 modes
[1].num_rates
= 4;
2590 modes
[1].channels
= os_calloc(11, sizeof(struct hostapd_channel_data
));
2591 modes
[1].rates
= os_calloc(modes
[1].num_rates
, sizeof(int));
2592 if (modes
[1].channels
== NULL
|| modes
[1].rates
== NULL
)
2594 for (i
= 0; i
< 11; i
++) {
2595 modes
[1].channels
[i
].chan
= i
+ 1;
2596 modes
[1].channels
[i
].freq
= 2412 + 5 * i
;
2597 modes
[1].channels
[i
].flag
= 0;
2599 modes
[1].rates
[0] = 10;
2600 modes
[1].rates
[1] = 20;
2601 modes
[1].rates
[2] = 55;
2602 modes
[1].rates
[3] = 110;
2604 modes
[2].mode
= HOSTAPD_MODE_IEEE80211A
;
2605 modes
[2].num_channels
= 1;
2606 modes
[2].num_rates
= 8;
2607 modes
[2].channels
= os_calloc(1, sizeof(struct hostapd_channel_data
));
2608 modes
[2].rates
= os_calloc(modes
[2].num_rates
, sizeof(int));
2609 if (modes
[2].channels
== NULL
|| modes
[2].rates
== NULL
)
2611 modes
[2].channels
[0].chan
= 60;
2612 modes
[2].channels
[0].freq
= 5300;
2613 modes
[2].channels
[0].flag
= 0;
2614 modes
[2].rates
[0] = 60;
2615 modes
[2].rates
[1] = 90;
2616 modes
[2].rates
[2] = 120;
2617 modes
[2].rates
[3] = 180;
2618 modes
[2].rates
[4] = 240;
2619 modes
[2].rates
[5] = 360;
2620 modes
[2].rates
[6] = 480;
2621 modes
[2].rates
[7] = 540;
2627 for (i
= 0; i
< *num_modes
; i
++) {
2628 os_free(modes
[i
].channels
);
2629 os_free(modes
[i
].rates
);
2637 static int wpa_driver_test_set_freq(void *priv
,
2638 struct hostapd_freq_params
*freq
)
2640 struct test_driver_bss
*dbss
= priv
;
2641 struct wpa_driver_test_data
*drv
= dbss
->drv
;
2642 wpa_printf(MSG_DEBUG
, "test: set_freq %u MHz", freq
->freq
);
2643 drv
->current_freq
= freq
->freq
;
2648 static int wpa_driver_test_send_action(void *priv
, unsigned int freq
,
2650 const u8
*dst
, const u8
*src
,
2652 const u8
*data
, size_t data_len
,
2655 struct test_driver_bss
*dbss
= priv
;
2656 struct wpa_driver_test_data
*drv
= dbss
->drv
;
2659 struct ieee80211_hdr
*hdr
;
2661 wpa_printf(MSG_DEBUG
, "test: Send Action frame");
2663 if ((drv
->remain_on_channel_freq
&&
2664 freq
!= drv
->remain_on_channel_freq
) ||
2665 (drv
->remain_on_channel_freq
== 0 &&
2666 freq
!= (unsigned int) drv
->current_freq
)) {
2667 wpa_printf(MSG_DEBUG
, "test: Reject Action frame TX on "
2668 "unexpected channel: freq=%u MHz (current_freq=%u "
2669 "MHz, remain-on-channel freq=%u MHz)",
2670 freq
, drv
->current_freq
,
2671 drv
->remain_on_channel_freq
);
2675 buf
= os_zalloc(24 + data_len
);
2678 os_memcpy(buf
+ 24, data
, data_len
);
2679 hdr
= (struct ieee80211_hdr
*) buf
;
2680 hdr
->frame_control
=
2681 IEEE80211_FC(WLAN_FC_TYPE_MGMT
, WLAN_FC_STYPE_ACTION
);
2682 os_memcpy(hdr
->addr1
, dst
, ETH_ALEN
);
2683 os_memcpy(hdr
->addr2
, src
, ETH_ALEN
);
2684 os_memcpy(hdr
->addr3
, bssid
, ETH_ALEN
);
2686 ret
= wpa_driver_test_send_mlme(priv
, buf
, 24 + data_len
, 0);
2693 static void test_send_action_cb(void *eloop_ctx
, void *timeout_ctx
)
2695 struct wpa_driver_test_data
*drv
= eloop_ctx
;
2697 if (drv
->pending_action_tx
== NULL
)
2700 if (drv
->off_channel_freq
!= drv
->pending_action_freq
) {
2701 wpa_printf(MSG_DEBUG
, "P2P: Pending Action frame TX "
2702 "waiting for another freq=%u",
2703 drv
->pending_action_freq
);
2706 wpa_printf(MSG_DEBUG
, "P2P: Sending pending Action frame to "
2707 MACSTR
, MAC2STR(drv
->pending_action_dst
));
2708 wpa_driver_test_send_action(drv
, drv
->pending_action_freq
, 0,
2709 drv
->pending_action_dst
,
2710 drv
->pending_action_src
,
2711 drv
->pending_action_bssid
,
2712 wpabuf_head(drv
->pending_action_tx
),
2713 wpabuf_len(drv
->pending_action_tx
),
2714 drv
->pending_action_no_cck
);
2716 #endif /* CONFIG_P2P */
2719 static void test_remain_on_channel_timeout(void *eloop_ctx
, void *timeout_ctx
)
2721 struct wpa_driver_test_data
*drv
= eloop_ctx
;
2722 union wpa_event_data data
;
2724 wpa_printf(MSG_DEBUG
, "test: Remain-on-channel timeout");
2726 os_memset(&data
, 0, sizeof(data
));
2727 data
.remain_on_channel
.freq
= drv
->remain_on_channel_freq
;
2728 data
.remain_on_channel
.duration
= drv
->remain_on_channel_duration
;
2731 drv
->off_channel_freq
= 0;
2733 drv
->remain_on_channel_freq
= 0;
2735 wpa_supplicant_event(drv
->ctx
, EVENT_CANCEL_REMAIN_ON_CHANNEL
, &data
);
2739 static int wpa_driver_test_remain_on_channel(void *priv
, unsigned int freq
,
2740 unsigned int duration
)
2742 struct test_driver_bss
*dbss
= priv
;
2743 struct wpa_driver_test_data
*drv
= dbss
->drv
;
2744 union wpa_event_data data
;
2746 wpa_printf(MSG_DEBUG
, "%s(freq=%u, duration=%u)",
2747 __func__
, freq
, duration
);
2748 if (drv
->remain_on_channel_freq
&&
2749 drv
->remain_on_channel_freq
!= freq
) {
2750 wpa_printf(MSG_DEBUG
, "test: Refuse concurrent "
2751 "remain_on_channel request");
2755 drv
->remain_on_channel_freq
= freq
;
2756 drv
->remain_on_channel_duration
= duration
;
2757 eloop_cancel_timeout(test_remain_on_channel_timeout
, drv
, NULL
);
2758 eloop_register_timeout(duration
/ 1000, (duration
% 1000) * 1000,
2759 test_remain_on_channel_timeout
, drv
, NULL
);
2761 os_memset(&data
, 0, sizeof(data
));
2762 data
.remain_on_channel
.freq
= freq
;
2763 data
.remain_on_channel
.duration
= duration
;
2764 wpa_supplicant_event(drv
->ctx
, EVENT_REMAIN_ON_CHANNEL
, &data
);
2768 drv
->off_channel_freq
= drv
->remain_on_channel_freq
;
2769 test_send_action_cb(drv
, NULL
);
2770 if (drv
->off_channel_freq
== drv
->pending_listen_freq
) {
2771 p2p_listen_cb(drv
->p2p
, drv
->pending_listen_freq
,
2772 drv
->pending_listen_duration
);
2773 drv
->pending_listen_freq
= 0;
2776 #endif /* CONFIG_P2P */
2782 static int wpa_driver_test_cancel_remain_on_channel(void *priv
)
2784 struct test_driver_bss
*dbss
= priv
;
2785 struct wpa_driver_test_data
*drv
= dbss
->drv
;
2786 wpa_printf(MSG_DEBUG
, "%s", __func__
);
2787 if (!drv
->remain_on_channel_freq
)
2789 drv
->remain_on_channel_freq
= 0;
2790 eloop_cancel_timeout(test_remain_on_channel_timeout
, drv
, NULL
);
2795 static int wpa_driver_test_probe_req_report(void *priv
, int report
)
2797 struct test_driver_bss
*dbss
= priv
;
2798 struct wpa_driver_test_data
*drv
= dbss
->drv
;
2799 wpa_printf(MSG_DEBUG
, "%s(report=%d)", __func__
, report
);
2800 drv
->probe_req_report
= report
;
2807 static int wpa_driver_test_p2p_find(void *priv
, unsigned int timeout
, int type
)
2809 struct test_driver_bss
*dbss
= priv
;
2810 struct wpa_driver_test_data
*drv
= dbss
->drv
;
2811 wpa_printf(MSG_DEBUG
, "%s(timeout=%u)", __func__
, timeout
);
2814 return p2p_find(drv
->p2p
, timeout
, type
, 0, NULL
, NULL
, 0);
2818 static int wpa_driver_test_p2p_stop_find(void *priv
)
2820 struct test_driver_bss
*dbss
= priv
;
2821 struct wpa_driver_test_data
*drv
= dbss
->drv
;
2822 wpa_printf(MSG_DEBUG
, "%s", __func__
);
2825 p2p_stop_find(drv
->p2p
);
2830 static int wpa_driver_test_p2p_listen(void *priv
, unsigned int timeout
)
2832 struct test_driver_bss
*dbss
= priv
;
2833 struct wpa_driver_test_data
*drv
= dbss
->drv
;
2834 wpa_printf(MSG_DEBUG
, "%s(timeout=%u)", __func__
, timeout
);
2837 return p2p_listen(drv
->p2p
, timeout
);
2841 static int wpa_driver_test_p2p_connect(void *priv
, const u8
*peer_addr
,
2842 int wps_method
, int go_intent
,
2843 const u8
*own_interface_addr
,
2844 unsigned int force_freq
,
2845 int persistent_group
)
2847 struct test_driver_bss
*dbss
= priv
;
2848 struct wpa_driver_test_data
*drv
= dbss
->drv
;
2849 wpa_printf(MSG_DEBUG
, "%s(peer_addr=" MACSTR
" wps_method=%d "
2851 "own_interface_addr=" MACSTR
" force_freq=%u "
2852 "persistent_group=%d)",
2853 __func__
, MAC2STR(peer_addr
), wps_method
, go_intent
,
2854 MAC2STR(own_interface_addr
), force_freq
, persistent_group
);
2857 return p2p_connect(drv
->p2p
, peer_addr
, wps_method
, go_intent
,
2858 own_interface_addr
, force_freq
, persistent_group
,
2863 static int wpa_driver_test_wps_success_cb(void *priv
, const u8
*peer_addr
)
2865 struct test_driver_bss
*dbss
= priv
;
2866 struct wpa_driver_test_data
*drv
= dbss
->drv
;
2867 wpa_printf(MSG_DEBUG
, "%s(peer_addr=" MACSTR
")",
2868 __func__
, MAC2STR(peer_addr
));
2871 p2p_wps_success_cb(drv
->p2p
, peer_addr
);
2876 static int wpa_driver_test_p2p_group_formation_failed(void *priv
)
2878 struct test_driver_bss
*dbss
= priv
;
2879 struct wpa_driver_test_data
*drv
= dbss
->drv
;
2880 wpa_printf(MSG_DEBUG
, "%s", __func__
);
2883 p2p_group_formation_failed(drv
->p2p
);
2888 static int wpa_driver_test_p2p_set_params(void *priv
,
2889 const struct p2p_params
*params
)
2891 struct test_driver_bss
*dbss
= priv
;
2892 struct wpa_driver_test_data
*drv
= dbss
->drv
;
2893 wpa_printf(MSG_DEBUG
, "%s", __func__
);
2896 if (p2p_set_dev_name(drv
->p2p
, params
->dev_name
) < 0 ||
2897 p2p_set_pri_dev_type(drv
->p2p
, params
->pri_dev_type
) < 0 ||
2898 p2p_set_sec_dev_types(drv
->p2p
, params
->sec_dev_type
,
2899 params
->num_sec_dev_types
) < 0)
2905 static int test_p2p_scan(void *ctx
, enum p2p_scan_type type
, int freq
,
2906 unsigned int num_req_dev_types
,
2907 const u8
*req_dev_types
, const u8
*dev_id
, u16 pw_id
)
2909 struct wpa_driver_test_data
*drv
= ctx
;
2910 struct wpa_driver_scan_params params
;
2912 struct wpabuf
*wps_ie
, *ies
;
2913 int social_channels
[] = { 2412, 2437, 2462, 0, 0 };
2916 wpa_printf(MSG_DEBUG
, "%s(type=%d freq=%d)",
2917 __func__
, type
, freq
);
2919 os_memset(¶ms
, 0, sizeof(params
));
2921 /* P2P Wildcard SSID */
2922 params
.num_ssids
= 1;
2923 params
.ssids
[0].ssid
= (u8
*) P2P_WILDCARD_SSID
;
2924 params
.ssids
[0].ssid_len
= P2P_WILDCARD_SSID_LEN
;
2926 #if 0 /* TODO: WPS IE */
2927 wpa_s
->wps
->dev
.p2p
= 1;
2928 wps_ie
= wps_build_probe_req_ie(pw_id
, &wpa_s
->wps
->dev
,
2929 wpa_s
->wps
->uuid
, WPS_REQ_ENROLLEE
);
2931 wps_ie
= wpabuf_alloc(1);
2936 ielen
= p2p_scan_ie_buf_len(drv
->p2p
);
2937 ies
= wpabuf_alloc(wpabuf_len(wps_ie
) + ielen
);
2939 wpabuf_free(wps_ie
);
2942 wpabuf_put_buf(ies
, wps_ie
);
2943 wpabuf_free(wps_ie
);
2945 p2p_scan_ie(drv
->p2p
, ies
, dev_id
);
2947 params
.extra_ies
= wpabuf_head(ies
);
2948 params
.extra_ies_len
= wpabuf_len(ies
);
2951 case P2P_SCAN_SOCIAL
:
2952 params
.freqs
= social_channels
;
2956 case P2P_SCAN_SOCIAL_PLUS_ONE
:
2957 social_channels
[3] = freq
;
2958 params
.freqs
= social_channels
;
2962 drv
->pending_p2p_scan
= 1;
2963 ret
= wpa_driver_test_scan(drv
, ¶ms
);
2971 static int test_send_action(void *ctx
, unsigned int freq
, const u8
*dst
,
2972 const u8
*src
, const u8
*bssid
, const u8
*buf
,
2973 size_t len
, unsigned int wait_time
)
2975 struct wpa_driver_test_data
*drv
= ctx
;
2977 wpa_printf(MSG_DEBUG
, "%s(freq=%u dst=" MACSTR
" src=" MACSTR
2978 " bssid=" MACSTR
" len=%d",
2979 __func__
, freq
, MAC2STR(dst
), MAC2STR(src
), MAC2STR(bssid
),
2982 wpa_printf(MSG_WARNING
, "P2P: No frequency specified for "
2987 if (drv
->pending_action_tx
) {
2988 wpa_printf(MSG_DEBUG
, "P2P: Dropped pending Action frame TX "
2989 "to " MACSTR
, MAC2STR(drv
->pending_action_dst
));
2990 wpabuf_free(drv
->pending_action_tx
);
2992 drv
->pending_action_tx
= wpabuf_alloc(len
);
2993 if (drv
->pending_action_tx
== NULL
)
2995 wpabuf_put_data(drv
->pending_action_tx
, buf
, len
);
2996 os_memcpy(drv
->pending_action_src
, src
, ETH_ALEN
);
2997 os_memcpy(drv
->pending_action_dst
, dst
, ETH_ALEN
);
2998 os_memcpy(drv
->pending_action_bssid
, bssid
, ETH_ALEN
);
2999 drv
->pending_action_freq
= freq
;
3000 drv
->pending_action_no_cck
= 1;
3002 if (drv
->off_channel_freq
== freq
) {
3003 /* Already on requested channel; send immediately */
3004 /* TODO: Would there ever be need to extend the current
3005 * duration on the channel? */
3006 eloop_cancel_timeout(test_send_action_cb
, drv
, NULL
);
3007 eloop_register_timeout(0, 0, test_send_action_cb
, drv
, NULL
);
3011 wpa_printf(MSG_DEBUG
, "P2P: Schedule Action frame to be transmitted "
3012 "once the driver gets to the requested channel");
3013 if (wpa_driver_test_remain_on_channel(drv
, freq
, wait_time
) < 0) {
3014 wpa_printf(MSG_DEBUG
, "P2P: Failed to request driver "
3015 "to remain on channel (%u MHz) for Action "
3024 static void test_send_action_done(void *ctx
)
3026 wpa_printf(MSG_DEBUG
, "%s", __func__
);
3031 static void test_go_neg_completed(void *ctx
, struct p2p_go_neg_results
*res
)
3033 struct wpa_driver_test_data
*drv
= ctx
;
3034 union wpa_event_data event
;
3035 wpa_printf(MSG_DEBUG
, "%s", __func__
);
3036 os_memset(&event
, 0, sizeof(event
));
3037 event
.p2p_go_neg_completed
.res
= res
;
3038 wpa_supplicant_event(drv
->ctx
, EVENT_P2P_GO_NEG_COMPLETED
, &event
);
3042 static void test_go_neg_req_rx(void *ctx
, const u8
*src
, u16 dev_passwd_id
)
3044 struct wpa_driver_test_data
*drv
= ctx
;
3045 union wpa_event_data event
;
3046 wpa_printf(MSG_DEBUG
, "%s(src=" MACSTR
")", __func__
, MAC2STR(src
));
3047 os_memset(&event
, 0, sizeof(event
));
3048 event
.p2p_go_neg_req_rx
.src
= src
;
3049 event
.p2p_go_neg_req_rx
.dev_passwd_id
= dev_passwd_id
;
3050 wpa_supplicant_event(drv
->ctx
, EVENT_P2P_GO_NEG_REQ_RX
, &event
);
3054 static void test_dev_found(void *ctx
, const u8
*addr
,
3055 const struct p2p_peer_info
*info
, int new_device
)
3057 struct wpa_driver_test_data
*drv
= ctx
;
3058 union wpa_event_data event
;
3059 char devtype
[WPS_DEV_TYPE_BUFSIZE
];
3060 wpa_printf(MSG_DEBUG
, "%s(" MACSTR
" p2p_dev_addr=" MACSTR
3061 " pri_dev_type=%s name='%s' config_methods=0x%x "
3062 "dev_capab=0x%x group_capab=0x%x)",
3063 __func__
, MAC2STR(addr
), MAC2STR(info
->p2p_device_addr
),
3064 wps_dev_type_bin2str(info
->pri_dev_type
, devtype
,
3066 info
->device_name
, info
->config_methods
, info
->dev_capab
,
3069 os_memset(&event
, 0, sizeof(event
));
3070 event
.p2p_dev_found
.addr
= addr
;
3071 event
.p2p_dev_found
.dev_addr
= info
->p2p_device_addr
;
3072 event
.p2p_dev_found
.pri_dev_type
= info
->pri_dev_type
;
3073 event
.p2p_dev_found
.dev_name
= info
->device_name
;
3074 event
.p2p_dev_found
.config_methods
= info
->config_methods
;
3075 event
.p2p_dev_found
.dev_capab
= info
->dev_capab
;
3076 event
.p2p_dev_found
.group_capab
= info
->group_capab
;
3077 wpa_supplicant_event(drv
->ctx
, EVENT_P2P_DEV_FOUND
, &event
);
3081 static int test_start_listen(void *ctx
, unsigned int freq
,
3082 unsigned int duration
,
3083 const struct wpabuf
*probe_resp_ie
)
3085 struct wpa_driver_test_data
*drv
= ctx
;
3087 wpa_printf(MSG_DEBUG
, "%s(freq=%u duration=%u)",
3088 __func__
, freq
, duration
);
3090 if (wpa_driver_test_probe_req_report(drv
, 1) < 0)
3093 drv
->pending_listen_freq
= freq
;
3094 drv
->pending_listen_duration
= duration
;
3096 if (wpa_driver_test_remain_on_channel(drv
, freq
, duration
) < 0) {
3097 drv
->pending_listen_freq
= 0;
3105 static void test_stop_listen(void *ctx
)
3107 wpa_printf(MSG_DEBUG
, "%s", __func__
);
3112 static int test_send_probe_resp(void *ctx
, const struct wpabuf
*buf
)
3114 struct wpa_driver_test_data
*drv
= ctx
;
3115 char resp
[512], *pos
, *end
;
3117 const struct ieee80211_mgmt
*mgmt
;
3118 const u8
*ie
, *ie_end
;
3120 wpa_printf(MSG_DEBUG
, "%s", __func__
);
3121 wpa_hexdump_buf(MSG_MSGDUMP
, "Probe Response", buf
);
3122 if (wpabuf_len(buf
) < 24)
3124 if (!drv
->probe_from
) {
3125 wpa_printf(MSG_DEBUG
, "%s: probe_from not set", __func__
);
3130 end
= resp
+ sizeof(resp
);
3132 mgmt
= wpabuf_head(buf
);
3134 /* reply: SCANRESP BSSID SSID IEs */
3135 ret
= os_snprintf(pos
, end
- pos
, "SCANRESP " MACSTR
" ",
3136 MAC2STR(mgmt
->bssid
));
3137 if (ret
< 0 || ret
>= end
- pos
)
3141 ie
= mgmt
->u
.probe_resp
.variable
;
3142 ie_end
= wpabuf_head_u8(buf
) + wpabuf_len(buf
);
3143 if (ie_end
- ie
< 2 || ie
[0] != WLAN_EID_SSID
||
3144 ie
+ 2 + ie
[1] > ie_end
)
3146 pos
+= wpa_snprintf_hex(pos
, end
- pos
, ie
+ 2, ie
[1]);
3148 ret
= os_snprintf(pos
, end
- pos
, " ");
3149 if (ret
< 0 || ret
>= end
- pos
)
3152 pos
+= wpa_snprintf_hex(pos
, end
- pos
, ie
, ie_end
- ie
);
3154 sendto(drv
->test_socket
, resp
, pos
- resp
, 0,
3155 drv
->probe_from
, drv
->probe_from_len
);
3161 static void test_sd_request(void *ctx
, int freq
, const u8
*sa
, u8 dialog_token
,
3162 u16 update_indic
, const u8
*tlvs
, size_t tlvs_len
)
3164 wpa_printf(MSG_DEBUG
, "%s", __func__
);
3169 static void test_sd_response(void *ctx
, const u8
*sa
, u16 update_indic
,
3170 const u8
*tlvs
, size_t tlvs_len
)
3172 wpa_printf(MSG_DEBUG
, "%s", __func__
);
3177 static void test_prov_disc_req(void *ctx
, const u8
*peer
, u16 config_methods
,
3178 const u8
*dev_addr
, const u8
*pri_dev_type
,
3179 const char *dev_name
, u16 supp_config_methods
,
3180 u8 dev_capab
, u8 group_capab
,
3181 const u8
*group_id
, size_t group_id_len
)
3183 wpa_printf(MSG_DEBUG
, "%s(peer=" MACSTR
" config_methods=0x%x)",
3184 __func__
, MAC2STR(peer
), config_methods
);
3189 static void test_prov_disc_resp(void *ctx
, const u8
*peer
, u16 config_methods
)
3191 wpa_printf(MSG_DEBUG
, "%s(peer=" MACSTR
" config_methods=0x%x)",
3192 __func__
, MAC2STR(peer
), config_methods
);
3196 #endif /* CONFIG_P2P */
3199 static int wpa_driver_test_init_p2p(struct wpa_driver_test_data
*drv
)
3202 struct p2p_config p2p
;
3206 os_memset(&p2p
, 0, sizeof(p2p
));
3207 p2p
.msg_ctx
= drv
->ctx
;
3209 p2p
.p2p_scan
= test_p2p_scan
;
3210 p2p
.send_action
= test_send_action
;
3211 p2p
.send_action_done
= test_send_action_done
;
3212 p2p
.go_neg_completed
= test_go_neg_completed
;
3213 p2p
.go_neg_req_rx
= test_go_neg_req_rx
;
3214 p2p
.dev_found
= test_dev_found
;
3215 p2p
.start_listen
= test_start_listen
;
3216 p2p
.stop_listen
= test_stop_listen
;
3217 p2p
.send_probe_resp
= test_send_probe_resp
;
3218 p2p
.sd_request
= test_sd_request
;
3219 p2p
.sd_response
= test_sd_response
;
3220 p2p
.prov_disc_req
= test_prov_disc_req
;
3221 p2p
.prov_disc_resp
= test_prov_disc_resp
;
3223 os_memcpy(p2p
.dev_addr
, drv
->own_addr
, ETH_ALEN
);
3225 p2p
.reg_class
= 12; /* TODO: change depending on location */
3227 * Pick one of the social channels randomly as the listen
3230 os_get_random((u8
*) &r
, sizeof(r
));
3231 p2p
.channel
= 1 + (r
% 3) * 5;
3233 /* TODO: change depending on location */
3234 p2p
.op_reg_class
= 12;
3236 * For initial tests, pick the operation channel randomly.
3237 * TODO: Use scan results (etc.) to select the best channel.
3239 p2p
.op_channel
= 1 + r
% 11;
3241 os_memcpy(p2p
.country
, "US ", 3);
3243 /* FIX: fetch available channels from the driver */
3244 p2p
.channels
.reg_classes
= 1;
3245 p2p
.channels
.reg_class
[0].reg_class
= 12; /* US/12 = 2.4 GHz band */
3246 p2p
.channels
.reg_class
[0].channels
= 11;
3247 for (i
= 0; i
< 11; i
++)
3248 p2p
.channels
.reg_class
[0].channel
[i
] = i
+ 1;
3250 p2p
.max_peers
= 100;
3252 drv
->p2p
= p2p_init(&p2p
);
3253 if (drv
->p2p
== NULL
)
3256 #else /* CONFIG_P2P */
3257 wpa_printf(MSG_INFO
, "driver_test: P2P support not included");
3259 #endif /* CONFIG_P2P */
3263 const struct wpa_driver_ops wpa_driver_test_ops
= {
3265 "wpa_supplicant test driver",
3266 .hapd_init
= test_driver_init
,
3267 .hapd_deinit
= wpa_driver_test_deinit
,
3268 .hapd_send_eapol
= test_driver_send_eapol
,
3269 .send_mlme
= wpa_driver_test_send_mlme
,
3270 .set_generic_elem
= test_driver_set_generic_elem
,
3271 .sta_deauth
= test_driver_sta_deauth
,
3272 .sta_disassoc
= test_driver_sta_disassoc
,
3273 .get_hw_feature_data
= wpa_driver_test_get_hw_feature_data
,
3274 .if_add
= test_driver_if_add
,
3275 .if_remove
= test_driver_if_remove
,
3276 .hapd_set_ssid
= test_driver_set_ssid
,
3277 .set_privacy
= test_driver_set_privacy
,
3278 .set_sta_vlan
= test_driver_set_sta_vlan
,
3279 .sta_add
= test_driver_sta_add
,
3280 .send_ether
= test_driver_send_ether
,
3281 .set_ap_wps_ie
= test_driver_set_ap_wps_ie
,
3282 .get_bssid
= wpa_driver_test_get_bssid
,
3283 .get_ssid
= wpa_driver_test_get_ssid
,
3284 .set_key
= wpa_driver_test_set_key
,
3285 .deinit
= wpa_driver_test_deinit
,
3286 .set_param
= wpa_driver_test_set_param
,
3287 .deauthenticate
= wpa_driver_test_deauthenticate
,
3288 .associate
= wpa_driver_test_associate
,
3289 .get_capa
= wpa_driver_test_get_capa
,
3290 .get_mac_addr
= wpa_driver_test_get_mac_addr
,
3291 .send_eapol
= wpa_driver_test_send_eapol
,
3292 .mlme_setprotection
= wpa_driver_test_mlme_setprotection
,
3293 .get_scan_results2
= wpa_driver_test_get_scan_results2
,
3294 .global_init
= wpa_driver_test_global_init
,
3295 .global_deinit
= wpa_driver_test_global_deinit
,
3296 .init2
= wpa_driver_test_init2
,
3297 .get_interfaces
= wpa_driver_test_get_interfaces
,
3298 .scan2
= wpa_driver_test_scan
,
3299 .set_freq
= wpa_driver_test_set_freq
,
3300 .send_action
= wpa_driver_test_send_action
,
3301 .remain_on_channel
= wpa_driver_test_remain_on_channel
,
3302 .cancel_remain_on_channel
= wpa_driver_test_cancel_remain_on_channel
,
3303 .probe_req_report
= wpa_driver_test_probe_req_report
,
3305 .p2p_find
= wpa_driver_test_p2p_find
,
3306 .p2p_stop_find
= wpa_driver_test_p2p_stop_find
,
3307 .p2p_listen
= wpa_driver_test_p2p_listen
,
3308 .p2p_connect
= wpa_driver_test_p2p_connect
,
3309 .wps_success_cb
= wpa_driver_test_wps_success_cb
,
3310 .p2p_group_formation_failed
=
3311 wpa_driver_test_p2p_group_formation_failed
,
3312 .p2p_set_params
= wpa_driver_test_p2p_set_params
,
3313 #endif /* CONFIG_P2P */