2 * WPA Supplicant - testing driver interface
3 * Copyright (c) 2004-2008, Jouni Malinen <j@w1.fi>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
9 * Alternatively, this software may be distributed under the terms of BSD
12 * See README and COPYING for more details.
15 /* Make sure we get winsock2.h for Windows build to get sockaddr_storage */
16 #include "build_config.h"
17 #ifdef CONFIG_NATIVE_WINDOWS
19 #endif /* CONFIG_NATIVE_WINDOWS */
23 #ifndef CONFIG_NATIVE_WINDOWS
27 #define DRIVER_TEST_UNIX
28 #endif /* CONFIG_NATIVE_WINDOWS */
32 #include "l2_packet/l2_packet.h"
35 #include "ieee802_11_defs.h"
37 #include "../../hostapd/hostapd.h"
38 #include "../../hostapd/wpa.h"
39 #include "../../hostapd/hw_features.h"
42 struct test_client_socket
{
43 struct test_client_socket
*next
;
45 struct sockaddr_un un
;
47 struct test_driver_bss
*bss
;
50 struct test_driver_bss
{
51 struct test_driver_bss
*next
;
52 char ifname
[IFNAMSIZ
+ 1];
57 size_t wps_beacon_ie_len
;
58 u8
*wps_probe_resp_ie
;
59 size_t wps_probe_resp_ie_len
;
65 struct wpa_driver_test_global
{
69 struct wpa_driver_test_data
{
70 struct wpa_driver_test_global
*global
;
72 u8 own_addr
[ETH_ALEN
];
74 #ifdef DRIVER_TEST_UNIX
75 struct sockaddr_un hostapd_addr
;
76 #endif /* DRIVER_TEST_UNIX */
78 struct sockaddr_in hostapd_addr_udp
;
79 int hostapd_addr_udp_set
;
80 char *own_socket_path
;
85 #define MAX_SCAN_RESULTS 30
86 struct wpa_scan_res
*scanres
[MAX_SCAN_RESULTS
];
90 size_t assoc_wpa_ie_len
;
94 size_t probe_req_ie_len
;
98 struct hostapd_data
*hapd
;
99 struct test_client_socket
*cli
;
100 struct test_driver_bss
*bss
;
105 static void wpa_driver_test_deinit(void *priv
);
108 static void test_driver_free_bss(struct test_driver_bss
*bss
)
111 free(bss
->wps_beacon_ie
);
112 free(bss
->wps_probe_resp_ie
);
117 static struct test_client_socket
*
118 test_driver_get_cli(struct wpa_driver_test_data
*drv
, struct sockaddr_un
*from
,
121 struct test_client_socket
*cli
= drv
->cli
;
124 if (cli
->unlen
== fromlen
&&
125 strncmp(cli
->un
.sun_path
, from
->sun_path
,
126 fromlen
- sizeof(cli
->un
.sun_family
)) == 0)
135 static int test_driver_send_eapol(void *priv
, const u8
*addr
, const u8
*data
,
136 size_t data_len
, int encrypt
,
139 struct wpa_driver_test_data
*drv
= priv
;
140 struct test_client_socket
*cli
;
143 struct l2_ethhdr eth
;
145 if (drv
->test_socket
< 0)
150 if (memcmp(cli
->addr
, addr
, ETH_ALEN
) == 0)
156 wpa_printf(MSG_DEBUG
, "%s: no destination client entry",
161 memcpy(eth
.h_dest
, addr
, ETH_ALEN
);
162 memcpy(eth
.h_source
, own_addr
, ETH_ALEN
);
163 eth
.h_proto
= host_to_be16(ETH_P_EAPOL
);
165 io
[0].iov_base
= "EAPOL ";
167 io
[1].iov_base
= ð
;
168 io
[1].iov_len
= sizeof(eth
);
169 io
[2].iov_base
= (u8
*) data
;
170 io
[2].iov_len
= data_len
;
172 memset(&msg
, 0, sizeof(msg
));
175 msg
.msg_name
= &cli
->un
;
176 msg
.msg_namelen
= cli
->unlen
;
177 return sendmsg(drv
->test_socket
, &msg
, 0);
181 static int test_driver_send_ether(void *priv
, const u8
*dst
, const u8
*src
,
182 u16 proto
, const u8
*data
, size_t data_len
)
184 struct wpa_driver_test_data
*drv
= priv
;
187 struct l2_ethhdr eth
;
189 struct sockaddr_un addr
;
192 int ret
= 0, broadcast
= 0, count
= 0;
194 if (drv
->test_socket
< 0 || drv
->test_dir
== NULL
) {
195 wpa_printf(MSG_DEBUG
, "%s: invalid parameters (sock=%d "
197 __func__
, drv
->test_socket
, drv
->test_dir
);
201 broadcast
= memcmp(dst
, "\xff\xff\xff\xff\xff\xff", ETH_ALEN
) == 0;
202 snprintf(desttxt
, sizeof(desttxt
), MACSTR
, MAC2STR(dst
));
204 memcpy(eth
.h_dest
, dst
, ETH_ALEN
);
205 memcpy(eth
.h_source
, src
, ETH_ALEN
);
206 eth
.h_proto
= host_to_be16(proto
);
208 io
[0].iov_base
= "ETHER ";
210 io
[1].iov_base
= ð
;
211 io
[1].iov_len
= sizeof(eth
);
212 io
[2].iov_base
= (u8
*) data
;
213 io
[2].iov_len
= data_len
;
215 memset(&msg
, 0, sizeof(msg
));
219 dir
= opendir(drv
->test_dir
);
221 perror("test_driver: opendir");
224 while ((dent
= readdir(dir
))) {
225 #ifdef _DIRENT_HAVE_D_TYPE
226 /* Skip the file if it is not a socket. Also accept
227 * DT_UNKNOWN (0) in case the C library or underlying file
228 * system does not support d_type. */
229 if (dent
->d_type
!= DT_SOCK
&& dent
->d_type
!= DT_UNKNOWN
)
231 #endif /* _DIRENT_HAVE_D_TYPE */
232 if (strcmp(dent
->d_name
, ".") == 0 ||
233 strcmp(dent
->d_name
, "..") == 0)
236 memset(&addr
, 0, sizeof(addr
));
237 addr
.sun_family
= AF_UNIX
;
238 snprintf(addr
.sun_path
, sizeof(addr
.sun_path
), "%s/%s",
239 drv
->test_dir
, dent
->d_name
);
241 if (strcmp(addr
.sun_path
, drv
->own_socket_path
) == 0)
243 if (!broadcast
&& strstr(dent
->d_name
, desttxt
) == NULL
)
246 wpa_printf(MSG_DEBUG
, "%s: Send ether frame to %s",
247 __func__
, dent
->d_name
);
249 msg
.msg_name
= &addr
;
250 msg
.msg_namelen
= sizeof(addr
);
251 ret
= sendmsg(drv
->test_socket
, &msg
, 0);
253 perror("driver_test: sendmsg");
258 if (!broadcast
&& count
== 0) {
259 wpa_printf(MSG_DEBUG
, "%s: Destination " MACSTR
" not found",
260 __func__
, MAC2STR(dst
));
268 static int wpa_driver_test_send_mlme(void *priv
, const u8
*data
,
271 struct wpa_driver_test_data
*drv
= priv
;
275 struct sockaddr_un addr
;
282 struct ieee80211_hdr
*hdr
;
286 wpa_hexdump(MSG_MSGDUMP
, "test_send_mlme", data
, data_len
);
287 if (drv
->test_socket
< 0 || data_len
< 10) {
288 wpa_printf(MSG_DEBUG
, "%s: invalid parameters (sock=%d len=%lu"
290 __func__
, drv
->test_socket
,
291 (unsigned long) data_len
,
297 broadcast
= os_memcmp(dest
, "\xff\xff\xff\xff\xff\xff", ETH_ALEN
) == 0;
300 snprintf(desttxt
, sizeof(desttxt
), MACSTR
, MAC2STR(dest
));
303 io
[0].iov_base
= "MLME ";
305 io
[1].iov_base
= (void *) data
;
306 io
[1].iov_len
= data_len
;
308 os_memset(&msg
, 0, sizeof(msg
));
313 if (drv
->test_dir
== NULL
) {
314 wpa_printf(MSG_DEBUG
, "%s: test_dir == NULL", __func__
);
318 dir
= opendir(drv
->test_dir
);
320 perror("test_driver: opendir");
323 while ((dent
= readdir(dir
))) {
324 #ifdef _DIRENT_HAVE_D_TYPE
325 /* Skip the file if it is not a socket. Also accept
326 * DT_UNKNOWN (0) in case the C library or underlying file
327 * system does not support d_type. */
328 if (dent
->d_type
!= DT_SOCK
&& dent
->d_type
!= DT_UNKNOWN
)
330 #endif /* _DIRENT_HAVE_D_TYPE */
331 if (os_strcmp(dent
->d_name
, ".") == 0 ||
332 os_strcmp(dent
->d_name
, "..") == 0)
335 os_memset(&addr
, 0, sizeof(addr
));
336 addr
.sun_family
= AF_UNIX
;
337 os_snprintf(addr
.sun_path
, sizeof(addr
.sun_path
), "%s/%s",
338 drv
->test_dir
, dent
->d_name
);
340 if (os_strcmp(addr
.sun_path
, drv
->own_socket_path
) == 0)
342 if (!broadcast
&& os_strstr(dent
->d_name
, desttxt
) == NULL
)
345 wpa_printf(MSG_DEBUG
, "%s: Send management frame to %s",
346 __func__
, dent
->d_name
);
348 msg
.msg_name
= &addr
;
349 msg
.msg_namelen
= sizeof(addr
);
350 ret
= sendmsg(drv
->test_socket
, &msg
, 0);
352 perror("driver_test: sendmsg(test_socket)");
357 if (os_memcmp(dest
, drv
->bssid
, ETH_ALEN
) == 0 ||
358 drv
->test_dir
== NULL
) {
359 if (drv
->hostapd_addr_udp_set
) {
360 msg
.msg_name
= &drv
->hostapd_addr_udp
;
361 msg
.msg_namelen
= sizeof(drv
->hostapd_addr_udp
);
363 #ifdef DRIVER_TEST_UNIX
364 msg
.msg_name
= &drv
->hostapd_addr
;
365 msg
.msg_namelen
= sizeof(drv
->hostapd_addr
);
366 #endif /* DRIVER_TEST_UNIX */
368 } else if (broadcast
) {
369 dir
= opendir(drv
->test_dir
);
372 while ((dent
= readdir(dir
))) {
373 #ifdef _DIRENT_HAVE_D_TYPE
374 /* Skip the file if it is not a socket.
375 * Also accept DT_UNKNOWN (0) in case
376 * the C library or underlying file
377 * system does not support d_type. */
378 if (dent
->d_type
!= DT_SOCK
&&
379 dent
->d_type
!= DT_UNKNOWN
)
381 #endif /* _DIRENT_HAVE_D_TYPE */
382 if (os_strcmp(dent
->d_name
, ".") == 0 ||
383 os_strcmp(dent
->d_name
, "..") == 0)
385 wpa_printf(MSG_DEBUG
, "%s: Send broadcast MLME to %s",
386 __func__
, dent
->d_name
);
387 os_memset(&addr
, 0, sizeof(addr
));
388 addr
.sun_family
= AF_UNIX
;
389 os_snprintf(addr
.sun_path
, sizeof(addr
.sun_path
),
390 "%s/%s", drv
->test_dir
, dent
->d_name
);
392 msg
.msg_name
= &addr
;
393 msg
.msg_namelen
= sizeof(addr
);
395 ret
= sendmsg(drv
->test_socket
, &msg
, 0);
397 perror("driver_test: sendmsg(test_socket)");
403 os_memset(&addr
, 0, sizeof(addr
));
404 addr
.sun_family
= AF_UNIX
;
405 os_snprintf(addr
.sun_path
, sizeof(addr
.sun_path
),
406 "%s/AP-" MACSTR
, drv
->test_dir
, MAC2STR(dest
));
407 if (stat(addr
.sun_path
, &st
) < 0) {
408 os_snprintf(addr
.sun_path
, sizeof(addr
.sun_path
),
410 drv
->test_dir
, MAC2STR(dest
));
412 msg
.msg_name
= &addr
;
413 msg
.msg_namelen
= sizeof(addr
);
416 if (sendmsg(drv
->test_socket
, &msg
, 0) < 0) {
417 perror("sendmsg(test_socket)");
423 hdr
= (struct ieee80211_hdr
*) data
;
424 fc
= le_to_host16(hdr
->frame_control
);
425 hostapd_mgmt_tx_cb(drv
->hapd
, (u8
*) data
, data_len
,
426 WLAN_FC_GET_STYPE(fc
), ret
>= 0);
433 static void test_driver_scan(struct wpa_driver_test_data
*drv
,
434 struct sockaddr_un
*from
, socklen_t fromlen
,
437 char buf
[512], *pos
, *end
;
439 struct test_driver_bss
*bss
;
444 /* data: optional [ ' ' | STA-addr | ' ' | IEs(hex) ] */
446 wpa_printf(MSG_DEBUG
, "test_driver: SCAN");
450 hwaddr_aton(data
+ 1, sa
)) {
451 wpa_printf(MSG_DEBUG
, "test_driver: Unexpected SCAN "
459 ielen
= os_strlen(data
) / 2;
460 if (ielen
> sizeof(ie
))
462 if (hexstr2bin(data
, ie
, ielen
) < 0)
465 wpa_printf(MSG_DEBUG
, "test_driver: Scan from " MACSTR
,
467 wpa_hexdump(MSG_MSGDUMP
, "test_driver: scan IEs", ie
, ielen
);
470 hostapd_probe_req_rx(drv
->hapd
, sa
, ie
, ielen
);
474 for (bss
= drv
->bss
; bss
; bss
= bss
->next
) {
476 end
= buf
+ sizeof(buf
);
478 /* reply: SCANRESP BSSID SSID IEs */
479 ret
= snprintf(pos
, end
- pos
, "SCANRESP " MACSTR
" ",
480 MAC2STR(bss
->bssid
));
481 if (ret
< 0 || ret
>= end
- pos
)
484 pos
+= wpa_snprintf_hex(pos
, end
- pos
,
485 bss
->ssid
, bss
->ssid_len
);
486 ret
= snprintf(pos
, end
- pos
, " ");
487 if (ret
< 0 || ret
>= end
- pos
)
490 pos
+= wpa_snprintf_hex(pos
, end
- pos
, bss
->ie
, bss
->ielen
);
491 pos
+= wpa_snprintf_hex(pos
, end
- pos
, bss
->wps_probe_resp_ie
,
492 bss
->wps_probe_resp_ie_len
);
495 ret
= snprintf(pos
, end
- pos
, " PRIVACY");
496 if (ret
< 0 || ret
>= end
- pos
)
501 sendto(drv
->test_socket
, buf
, pos
- buf
, 0,
502 (struct sockaddr
*) from
, fromlen
);
507 static struct hostapd_data
*
508 test_driver_get_hapd(struct wpa_driver_test_data
*drv
,
509 struct test_driver_bss
*bss
)
511 struct hostapd_iface
*iface
= drv
->hapd
->iface
;
512 struct hostapd_data
*hapd
= NULL
;
516 wpa_printf(MSG_DEBUG
, "%s: bss == NULL", __func__
);
520 for (i
= 0; i
< iface
->num_bss
; i
++) {
521 hapd
= iface
->bss
[i
];
522 if (memcmp(hapd
->own_addr
, bss
->bssid
, ETH_ALEN
) == 0)
525 if (i
== iface
->num_bss
) {
526 wpa_printf(MSG_DEBUG
, "%s: no matching interface entry found "
527 "for BSSID " MACSTR
, __func__
, MAC2STR(bss
->bssid
));
535 static int test_driver_new_sta(struct wpa_driver_test_data
*drv
,
536 struct test_driver_bss
*bss
, const u8
*addr
,
537 const u8
*ie
, size_t ielen
)
539 struct hostapd_data
*hapd
;
541 hapd
= test_driver_get_hapd(drv
, bss
);
546 return hostapd_notif_assoc(hapd
, addr
, ie
, ielen
);
553 static void test_driver_assoc(struct wpa_driver_test_data
*drv
,
554 struct sockaddr_un
*from
, socklen_t fromlen
,
557 struct test_client_socket
*cli
;
558 u8 ie
[256], ssid
[32];
559 size_t ielen
, ssid_len
= 0;
560 char *pos
, *pos2
, cmd
[50];
561 struct test_driver_bss
*bss
;
563 /* data: STA-addr SSID(hex) IEs(hex) */
565 cli
= os_zalloc(sizeof(*cli
));
569 if (hwaddr_aton(data
, cli
->addr
)) {
570 printf("test_socket: Invalid MAC address '%s' in ASSOC\n",
578 pos2
= strchr(pos
, ' ');
581 ssid_len
= (pos2
- pos
) / 2;
582 if (hexstr2bin(pos
, ssid
, ssid_len
) < 0) {
583 wpa_printf(MSG_DEBUG
, "%s: Invalid SSID", __func__
);
587 wpa_hexdump_ascii(MSG_DEBUG
, "test_driver_assoc: SSID",
591 ielen
= strlen(pos
) / 2;
592 if (ielen
> sizeof(ie
))
594 if (hexstr2bin(pos
, ie
, ielen
) < 0)
598 for (bss
= drv
->bss
; bss
; bss
= bss
->next
) {
599 if (bss
->ssid_len
== ssid_len
&&
600 memcmp(bss
->ssid
, ssid
, ssid_len
) == 0)
604 wpa_printf(MSG_DEBUG
, "%s: No matching SSID found from "
605 "configured BSSes", __func__
);
611 memcpy(&cli
->un
, from
, sizeof(cli
->un
));
612 cli
->unlen
= fromlen
;
613 cli
->next
= drv
->cli
;
615 wpa_hexdump_ascii(MSG_DEBUG
, "test_socket: ASSOC sun_path",
616 (const u8
*) cli
->un
.sun_path
,
617 cli
->unlen
- sizeof(cli
->un
.sun_family
));
619 snprintf(cmd
, sizeof(cmd
), "ASSOCRESP " MACSTR
" 0",
620 MAC2STR(bss
->bssid
));
621 sendto(drv
->test_socket
, cmd
, strlen(cmd
), 0,
622 (struct sockaddr
*) from
, fromlen
);
624 if (test_driver_new_sta(drv
, bss
, cli
->addr
, ie
, ielen
) < 0) {
625 wpa_printf(MSG_DEBUG
, "test_driver: failed to add new STA");
630 static void test_driver_disassoc(struct wpa_driver_test_data
*drv
,
631 struct sockaddr_un
*from
, socklen_t fromlen
)
633 struct test_client_socket
*cli
;
635 cli
= test_driver_get_cli(drv
, from
, fromlen
);
640 hostapd_notif_disassoc(drv
->hapd
, cli
->addr
);
645 static void test_driver_eapol(struct wpa_driver_test_data
*drv
,
646 struct sockaddr_un
*from
, socklen_t fromlen
,
647 u8
*data
, size_t datalen
)
649 struct test_client_socket
*cli
;
651 /* Skip Ethernet header */
652 wpa_printf(MSG_DEBUG
, "test_driver: dst=" MACSTR
" src="
653 MACSTR
" proto=%04x",
654 MAC2STR(data
), MAC2STR(data
+ ETH_ALEN
),
655 WPA_GET_BE16(data
+ 2 * ETH_ALEN
));
659 cli
= test_driver_get_cli(drv
, from
, fromlen
);
661 struct hostapd_data
*hapd
;
662 hapd
= test_driver_get_hapd(drv
, cli
->bss
);
666 hostapd_eapol_receive(hapd
, cli
->addr
, data
, datalen
);
669 wpa_printf(MSG_DEBUG
, "test_socket: EAPOL from unknown "
675 static void test_driver_ether(struct wpa_driver_test_data
*drv
,
676 struct sockaddr_un
*from
, socklen_t fromlen
,
677 u8
*data
, size_t datalen
)
679 struct l2_ethhdr
*eth
;
681 if (datalen
< sizeof(*eth
))
684 eth
= (struct l2_ethhdr
*) data
;
685 wpa_printf(MSG_DEBUG
, "test_driver: RX ETHER dst=" MACSTR
" src="
686 MACSTR
" proto=%04x",
687 MAC2STR(eth
->h_dest
), MAC2STR(eth
->h_source
),
688 be_to_host16(eth
->h_proto
));
690 #ifdef CONFIG_IEEE80211R
691 if (be_to_host16(eth
->h_proto
) == ETH_P_RRB
) {
693 wpa_ft_rrb_rx(drv
->hapd
->wpa_auth
, eth
->h_source
,
694 data
+ sizeof(*eth
), datalen
- sizeof(*eth
));
697 #endif /* CONFIG_IEEE80211R */
701 static void test_driver_mlme(struct wpa_driver_test_data
*drv
,
702 struct sockaddr_un
*from
, socklen_t fromlen
,
703 u8
*data
, size_t datalen
)
705 struct ieee80211_hdr
*hdr
;
708 hdr
= (struct ieee80211_hdr
*) data
;
710 if (test_driver_get_cli(drv
, from
, fromlen
) == NULL
&& datalen
>= 16) {
711 struct test_client_socket
*cli
;
712 cli
= os_zalloc(sizeof(*cli
));
715 wpa_printf(MSG_DEBUG
, "Adding client entry for " MACSTR
,
716 MAC2STR(hdr
->addr2
));
717 memcpy(cli
->addr
, hdr
->addr2
, ETH_ALEN
);
718 memcpy(&cli
->un
, from
, sizeof(cli
->un
));
719 cli
->unlen
= fromlen
;
720 cli
->next
= drv
->cli
;
724 wpa_hexdump(MSG_MSGDUMP
, "test_driver_mlme: received frame",
726 fc
= le_to_host16(hdr
->frame_control
);
727 if (WLAN_FC_GET_TYPE(fc
) != WLAN_FC_TYPE_MGMT
) {
728 wpa_printf(MSG_ERROR
, "%s: received non-mgmt frame",
733 hostapd_mgmt_rx(drv
->hapd
, data
, datalen
, WLAN_FC_GET_STYPE(fc
), NULL
);
738 static void test_driver_receive_unix(int sock
, void *eloop_ctx
, void *sock_ctx
)
740 struct wpa_driver_test_data
*drv
= eloop_ctx
;
743 struct sockaddr_un from
;
744 socklen_t fromlen
= sizeof(from
);
746 res
= recvfrom(sock
, buf
, sizeof(buf
) - 1, 0,
747 (struct sockaddr
*) &from
, &fromlen
);
749 perror("recvfrom(test_socket)");
754 wpa_printf(MSG_DEBUG
, "test_driver: received %u bytes", res
);
756 if (strncmp(buf
, "SCAN", 4) == 0) {
757 test_driver_scan(drv
, &from
, fromlen
, buf
+ 4);
758 } else if (strncmp(buf
, "ASSOC ", 6) == 0) {
759 test_driver_assoc(drv
, &from
, fromlen
, buf
+ 6);
760 } else if (strcmp(buf
, "DISASSOC") == 0) {
761 test_driver_disassoc(drv
, &from
, fromlen
);
762 } else if (strncmp(buf
, "EAPOL ", 6) == 0) {
763 test_driver_eapol(drv
, &from
, fromlen
, (u8
*) buf
+ 6,
765 } else if (strncmp(buf
, "ETHER ", 6) == 0) {
766 test_driver_ether(drv
, &from
, fromlen
, (u8
*) buf
+ 6,
768 } else if (strncmp(buf
, "MLME ", 5) == 0) {
769 test_driver_mlme(drv
, &from
, fromlen
, (u8
*) buf
+ 5, res
- 5);
771 wpa_hexdump_ascii(MSG_DEBUG
, "Unknown test_socket command",
777 static struct test_driver_bss
*
778 test_driver_get_bss(struct wpa_driver_test_data
*drv
, const char *ifname
)
780 struct test_driver_bss
*bss
;
782 for (bss
= drv
->bss
; bss
; bss
= bss
->next
) {
783 if (strcmp(bss
->ifname
, ifname
) == 0)
790 static int test_driver_set_generic_elem(const char *ifname
, void *priv
,
791 const u8
*elem
, size_t elem_len
)
793 struct wpa_driver_test_data
*drv
= priv
;
794 struct test_driver_bss
*bss
;
796 bss
= test_driver_get_bss(drv
, ifname
);
808 bss
->ie
= malloc(elem_len
);
809 if (bss
->ie
== NULL
) {
814 memcpy(bss
->ie
, elem
, elem_len
);
815 bss
->ielen
= elem_len
;
820 static int test_driver_set_wps_beacon_ie(const char *ifname
, void *priv
,
821 const u8
*ie
, size_t len
)
823 struct wpa_driver_test_data
*drv
= priv
;
824 struct test_driver_bss
*bss
;
826 wpa_hexdump(MSG_DEBUG
, "test_driver: Beacon WPS IE", ie
, len
);
827 bss
= test_driver_get_bss(drv
, ifname
);
831 free(bss
->wps_beacon_ie
);
834 bss
->wps_beacon_ie
= NULL
;
835 bss
->wps_beacon_ie_len
= 0;
839 bss
->wps_beacon_ie
= malloc(len
);
840 if (bss
->wps_beacon_ie
== NULL
) {
841 bss
->wps_beacon_ie_len
= 0;
845 memcpy(bss
->wps_beacon_ie
, ie
, len
);
846 bss
->wps_beacon_ie_len
= len
;
851 static int test_driver_set_wps_probe_resp_ie(const char *ifname
, void *priv
,
852 const u8
*ie
, size_t len
)
854 struct wpa_driver_test_data
*drv
= priv
;
855 struct test_driver_bss
*bss
;
857 wpa_hexdump(MSG_DEBUG
, "test_driver: ProbeResp WPS IE", ie
, len
);
858 bss
= test_driver_get_bss(drv
, ifname
);
862 free(bss
->wps_probe_resp_ie
);
865 bss
->wps_probe_resp_ie
= NULL
;
866 bss
->wps_probe_resp_ie_len
= 0;
870 bss
->wps_probe_resp_ie
= malloc(len
);
871 if (bss
->wps_probe_resp_ie
== NULL
) {
872 bss
->wps_probe_resp_ie_len
= 0;
876 memcpy(bss
->wps_probe_resp_ie
, ie
, len
);
877 bss
->wps_probe_resp_ie_len
= len
;
882 static int test_driver_sta_deauth(void *priv
, const u8
*own_addr
,
883 const u8
*addr
, int reason
)
885 struct wpa_driver_test_data
*drv
= priv
;
886 struct test_client_socket
*cli
;
888 if (drv
->test_socket
< 0)
893 if (memcmp(cli
->addr
, addr
, ETH_ALEN
) == 0)
901 return sendto(drv
->test_socket
, "DEAUTH", 6, 0,
902 (struct sockaddr
*) &cli
->un
, cli
->unlen
);
906 static int test_driver_sta_disassoc(void *priv
, const u8
*own_addr
,
907 const u8
*addr
, int reason
)
909 struct wpa_driver_test_data
*drv
= priv
;
910 struct test_client_socket
*cli
;
912 if (drv
->test_socket
< 0)
917 if (memcmp(cli
->addr
, addr
, ETH_ALEN
) == 0)
925 return sendto(drv
->test_socket
, "DISASSOC", 8, 0,
926 (struct sockaddr
*) &cli
->un
, cli
->unlen
);
930 static int test_driver_bss_add(void *priv
, const char *ifname
, const u8
*bssid
)
932 struct wpa_driver_test_data
*drv
= priv
;
933 struct test_driver_bss
*bss
;
935 wpa_printf(MSG_DEBUG
, "%s(ifname=%s bssid=" MACSTR
")",
936 __func__
, ifname
, MAC2STR(bssid
));
938 bss
= os_zalloc(sizeof(*bss
));
942 os_strlcpy(bss
->ifname
, ifname
, IFNAMSIZ
);
943 memcpy(bss
->bssid
, bssid
, ETH_ALEN
);
945 bss
->next
= drv
->bss
;
952 static int test_driver_bss_remove(void *priv
, const char *ifname
)
954 struct wpa_driver_test_data
*drv
= priv
;
955 struct test_driver_bss
*bss
, *prev
;
956 struct test_client_socket
*cli
, *prev_c
;
958 wpa_printf(MSG_DEBUG
, "%s(ifname=%s)", __func__
, ifname
);
960 for (prev
= NULL
, bss
= drv
->bss
; bss
; prev
= bss
, bss
= bss
->next
) {
961 if (strcmp(bss
->ifname
, ifname
) != 0)
965 prev
->next
= bss
->next
;
967 drv
->bss
= bss
->next
;
969 for (prev_c
= NULL
, cli
= drv
->cli
; cli
;
970 prev_c
= cli
, cli
= cli
->next
) {
974 prev_c
->next
= cli
->next
;
976 drv
->cli
= cli
->next
;
981 test_driver_free_bss(bss
);
989 static int test_driver_if_add(const char *iface
, void *priv
,
990 enum hostapd_driver_if_type type
, char *ifname
,
993 wpa_printf(MSG_DEBUG
, "%s(iface=%s type=%d ifname=%s)",
994 __func__
, iface
, type
, ifname
);
999 static int test_driver_if_update(void *priv
, enum hostapd_driver_if_type type
,
1000 char *ifname
, const u8
*addr
)
1002 wpa_printf(MSG_DEBUG
, "%s(type=%d ifname=%s)", __func__
, type
, ifname
);
1007 static int test_driver_if_remove(void *priv
, enum hostapd_driver_if_type type
,
1008 const char *ifname
, const u8
*addr
)
1010 wpa_printf(MSG_DEBUG
, "%s(type=%d ifname=%s)", __func__
, type
, ifname
);
1015 static int test_driver_valid_bss_mask(void *priv
, const u8
*addr
,
1022 static int test_driver_set_ssid(const char *ifname
, void *priv
, const u8
*buf
,
1025 struct wpa_driver_test_data
*drv
= priv
;
1026 struct test_driver_bss
*bss
;
1028 wpa_printf(MSG_DEBUG
, "%s(ifname=%s)", __func__
, ifname
);
1029 wpa_hexdump_ascii(MSG_DEBUG
, "test_driver_set_ssid: SSID", buf
, len
);
1031 for (bss
= drv
->bss
; bss
; bss
= bss
->next
) {
1032 if (strcmp(bss
->ifname
, ifname
) != 0)
1035 if (len
< 0 || (size_t) len
> sizeof(bss
->ssid
))
1038 memcpy(bss
->ssid
, buf
, len
);
1039 bss
->ssid_len
= len
;
1048 static int test_driver_set_privacy(const char *ifname
, void *priv
, int enabled
)
1050 struct wpa_driver_test_data
*drv
= priv
;
1051 struct test_driver_bss
*bss
;
1053 wpa_printf(MSG_DEBUG
, "%s(ifname=%s enabled=%d)",
1054 __func__
, ifname
, enabled
);
1056 for (bss
= drv
->bss
; bss
; bss
= bss
->next
) {
1057 if (strcmp(bss
->ifname
, ifname
) != 0)
1060 bss
->privacy
= enabled
;
1069 static int test_driver_set_key(const char *iface
, void *priv
, wpa_alg alg
,
1070 const u8
*addr
, int key_idx
, int set_tx
,
1071 const u8
*seq
, size_t seq_len
,
1072 const u8
*key
, size_t key_len
)
1074 wpa_printf(MSG_DEBUG
, "%s(iface=%s alg=%d idx=%d set_tx=%d)",
1075 __func__
, iface
, alg
, key_idx
, set_tx
);
1077 wpa_printf(MSG_DEBUG
, " addr=" MACSTR
, MAC2STR(addr
));
1079 wpa_hexdump_key(MSG_DEBUG
, " key", key
, key_len
);
1084 static int test_driver_set_sta_vlan(void *priv
, const u8
*addr
,
1085 const char *ifname
, int vlan_id
)
1087 wpa_printf(MSG_DEBUG
, "%s(addr=" MACSTR
" ifname=%s vlan_id=%d)",
1088 __func__
, MAC2STR(addr
), ifname
, vlan_id
);
1093 static int test_driver_sta_add(const char *ifname
, void *priv
,
1094 struct hostapd_sta_add_params
*params
)
1096 struct wpa_driver_test_data
*drv
= priv
;
1097 struct test_client_socket
*cli
;
1098 struct test_driver_bss
*bss
;
1100 wpa_printf(MSG_DEBUG
, "%s(ifname=%s addr=" MACSTR
" aid=%d "
1101 "capability=0x%x flags=0x%x listen_interval=%d)",
1102 __func__
, ifname
, MAC2STR(params
->addr
), params
->aid
,
1103 params
->capability
, params
->flags
,
1104 params
->listen_interval
);
1105 wpa_hexdump(MSG_DEBUG
, "test_driver_sta_add - supp_rates",
1106 params
->supp_rates
, params
->supp_rates_len
);
1110 if (os_memcmp(cli
->addr
, params
->addr
, ETH_ALEN
) == 0)
1115 wpa_printf(MSG_DEBUG
, "%s: no matching client entry",
1120 for (bss
= drv
->bss
; bss
; bss
= bss
->next
) {
1121 if (strcmp(ifname
, bss
->ifname
) == 0)
1125 wpa_printf(MSG_DEBUG
, "%s: No matching interface found from "
1126 "configured BSSes", __func__
);
1136 static void * test_driver_init(struct hostapd_data
*hapd
,
1137 struct wpa_init_params
*params
)
1139 struct wpa_driver_test_data
*drv
;
1140 struct sockaddr_un addr_un
;
1141 struct sockaddr_in addr_in
;
1142 struct sockaddr
*addr
;
1145 drv
= os_zalloc(sizeof(struct wpa_driver_test_data
));
1147 printf("Could not allocate memory for test driver data\n");
1150 drv
->bss
= os_zalloc(sizeof(*drv
->bss
));
1151 if (drv
->bss
== NULL
) {
1152 printf("Could not allocate memory for test driver BSS data\n");
1159 /* Generate a MAC address to help testing with multiple APs */
1160 params
->own_addr
[0] = 0x02; /* locally administered */
1161 sha1_prf((const u8
*) params
->ifname
, strlen(params
->ifname
),
1162 "hostapd test bssid generation",
1163 params
->ssid
, params
->ssid_len
,
1164 params
->own_addr
+ 1, ETH_ALEN
- 1);
1166 os_strlcpy(drv
->bss
->ifname
, params
->ifname
, IFNAMSIZ
);
1167 memcpy(drv
->bss
->bssid
, params
->own_addr
, ETH_ALEN
);
1169 if (params
->test_socket
) {
1170 if (os_strlen(params
->test_socket
) >=
1171 sizeof(addr_un
.sun_path
)) {
1172 printf("Too long test_socket path\n");
1173 wpa_driver_test_deinit(drv
);
1176 if (strncmp(params
->test_socket
, "DIR:", 4) == 0) {
1177 size_t len
= strlen(params
->test_socket
) + 30;
1178 drv
->test_dir
= strdup(params
->test_socket
+ 4);
1179 drv
->own_socket_path
= malloc(len
);
1180 if (drv
->own_socket_path
) {
1181 snprintf(drv
->own_socket_path
, len
,
1183 params
->test_socket
+ 4,
1184 MAC2STR(params
->own_addr
));
1186 } else if (strncmp(params
->test_socket
, "UDP:", 4) == 0) {
1187 drv
->udp_port
= atoi(params
->test_socket
+ 4);
1189 drv
->own_socket_path
= strdup(params
->test_socket
);
1191 if (drv
->own_socket_path
== NULL
&& drv
->udp_port
== 0) {
1192 wpa_driver_test_deinit(drv
);
1196 drv
->test_socket
= socket(drv
->udp_port
? PF_INET
: PF_UNIX
,
1198 if (drv
->test_socket
< 0) {
1200 wpa_driver_test_deinit(drv
);
1204 if (drv
->udp_port
) {
1205 os_memset(&addr_in
, 0, sizeof(addr_in
));
1206 addr_in
.sin_family
= AF_INET
;
1207 addr_in
.sin_port
= htons(drv
->udp_port
);
1208 addr
= (struct sockaddr
*) &addr_in
;
1209 alen
= sizeof(addr_in
);
1211 os_memset(&addr_un
, 0, sizeof(addr_un
));
1212 addr_un
.sun_family
= AF_UNIX
;
1213 os_strlcpy(addr_un
.sun_path
, drv
->own_socket_path
,
1214 sizeof(addr_un
.sun_path
));
1215 addr
= (struct sockaddr
*) &addr_un
;
1216 alen
= sizeof(addr_un
);
1218 if (bind(drv
->test_socket
, addr
, alen
) < 0) {
1219 perror("bind(PF_UNIX)");
1220 close(drv
->test_socket
);
1221 if (drv
->own_socket_path
)
1222 unlink(drv
->own_socket_path
);
1223 wpa_driver_test_deinit(drv
);
1226 eloop_register_read_sock(drv
->test_socket
,
1227 test_driver_receive_unix
, drv
, NULL
);
1229 drv
->test_socket
= -1;
1235 static void wpa_driver_test_poll(void *eloop_ctx
, void *timeout_ctx
)
1237 struct wpa_driver_test_data
*drv
= eloop_ctx
;
1239 #ifdef DRIVER_TEST_UNIX
1240 if (drv
->associated
&& drv
->hostapd_addr_set
) {
1242 if (stat(drv
->hostapd_addr
.sun_path
, &st
) < 0) {
1243 wpa_printf(MSG_DEBUG
, "%s: lost connection to AP: %s",
1244 __func__
, strerror(errno
));
1245 drv
->associated
= 0;
1246 wpa_supplicant_event(drv
->ctx
, EVENT_DISASSOC
, NULL
);
1249 #endif /* DRIVER_TEST_UNIX */
1251 eloop_register_timeout(1, 0, wpa_driver_test_poll
, drv
, NULL
);
1255 static int wpa_driver_test_set_wpa(void *priv
, int enabled
)
1257 wpa_printf(MSG_DEBUG
, "%s: enabled=%d", __func__
, enabled
);
1262 static void wpa_driver_test_scan_timeout(void *eloop_ctx
, void *timeout_ctx
)
1264 wpa_printf(MSG_DEBUG
, "Scan timeout - try to get results");
1265 wpa_supplicant_event(timeout_ctx
, EVENT_SCAN_RESULTS
, NULL
);
1269 #ifdef DRIVER_TEST_UNIX
1270 static void wpa_driver_scan_dir(struct wpa_driver_test_data
*drv
,
1273 struct dirent
*dent
;
1275 struct sockaddr_un addr
;
1276 char cmd
[512], *pos
, *end
;
1279 dir
= opendir(path
);
1283 end
= cmd
+ sizeof(cmd
);
1285 ret
= os_snprintf(pos
, end
- pos
, "SCAN " MACSTR
,
1286 MAC2STR(drv
->own_addr
));
1287 if (ret
>= 0 && ret
< end
- pos
)
1289 if (drv
->probe_req_ie
) {
1290 ret
= os_snprintf(pos
, end
- pos
, " ");
1291 if (ret
>= 0 && ret
< end
- pos
)
1293 pos
+= wpa_snprintf_hex(pos
, end
- pos
, drv
->probe_req_ie
,
1294 drv
->probe_req_ie_len
);
1298 while ((dent
= readdir(dir
))) {
1299 if (os_strncmp(dent
->d_name
, "AP-", 3) != 0 &&
1300 os_strncmp(dent
->d_name
, "STA-", 4) != 0)
1302 if (drv
->own_socket_path
) {
1304 olen
= os_strlen(drv
->own_socket_path
);
1305 dlen
= os_strlen(dent
->d_name
);
1307 os_strcmp(dent
->d_name
,
1308 drv
->own_socket_path
+ olen
- dlen
) == 0)
1311 wpa_printf(MSG_DEBUG
, "%s: SCAN %s", __func__
, dent
->d_name
);
1313 os_memset(&addr
, 0, sizeof(addr
));
1314 addr
.sun_family
= AF_UNIX
;
1315 os_snprintf(addr
.sun_path
, sizeof(addr
.sun_path
), "%s/%s",
1316 path
, dent
->d_name
);
1318 if (sendto(drv
->test_socket
, cmd
, os_strlen(cmd
), 0,
1319 (struct sockaddr
*) &addr
, sizeof(addr
)) < 0) {
1320 perror("sendto(test_socket)");
1325 #endif /* DRIVER_TEST_UNIX */
1328 static int wpa_driver_test_scan(void *priv
,
1329 struct wpa_driver_scan_params
*params
)
1331 struct wpa_driver_test_data
*drv
= priv
;
1334 wpa_printf(MSG_DEBUG
, "%s: priv=%p", __func__
, priv
);
1335 for (i
= 0; i
< params
->num_ssids
; i
++)
1336 wpa_hexdump(MSG_DEBUG
, "Scan SSID",
1337 params
->ssids
[i
].ssid
, params
->ssids
[i
].ssid_len
);
1338 wpa_hexdump(MSG_DEBUG
, "Scan extra IE(s)",
1339 params
->extra_ies
, params
->extra_ies_len
);
1341 drv
->num_scanres
= 0;
1343 #ifdef DRIVER_TEST_UNIX
1344 if (drv
->test_socket
>= 0 && drv
->test_dir
)
1345 wpa_driver_scan_dir(drv
, drv
->test_dir
);
1347 if (drv
->test_socket
>= 0 && drv
->hostapd_addr_set
&&
1348 sendto(drv
->test_socket
, "SCAN", 4, 0,
1349 (struct sockaddr
*) &drv
->hostapd_addr
,
1350 sizeof(drv
->hostapd_addr
)) < 0) {
1351 perror("sendto(test_socket)");
1353 #endif /* DRIVER_TEST_UNIX */
1355 if (drv
->test_socket
>= 0 && drv
->hostapd_addr_udp_set
&&
1356 sendto(drv
->test_socket
, "SCAN", 4, 0,
1357 (struct sockaddr
*) &drv
->hostapd_addr_udp
,
1358 sizeof(drv
->hostapd_addr_udp
)) < 0) {
1359 perror("sendto(test_socket)");
1362 eloop_cancel_timeout(wpa_driver_test_scan_timeout
, drv
, drv
->ctx
);
1363 eloop_register_timeout(1, 0, wpa_driver_test_scan_timeout
, drv
,
1369 static struct wpa_scan_results
* wpa_driver_test_get_scan_results2(void *priv
)
1371 struct wpa_driver_test_data
*drv
= priv
;
1372 struct wpa_scan_results
*res
;
1375 res
= os_zalloc(sizeof(*res
));
1379 res
->res
= os_zalloc(drv
->num_scanres
* sizeof(struct wpa_scan_res
*));
1380 if (res
->res
== NULL
) {
1385 for (i
= 0; i
< drv
->num_scanres
; i
++) {
1386 struct wpa_scan_res
*r
;
1387 if (drv
->scanres
[i
] == NULL
)
1389 r
= os_malloc(sizeof(*r
) + drv
->scanres
[i
]->ie_len
);
1392 os_memcpy(r
, drv
->scanres
[i
],
1393 sizeof(*r
) + drv
->scanres
[i
]->ie_len
);
1394 res
->res
[res
->num
++] = r
;
1401 static int wpa_driver_test_set_key(void *priv
, wpa_alg alg
, const u8
*addr
,
1402 int key_idx
, int set_tx
,
1403 const u8
*seq
, size_t seq_len
,
1404 const u8
*key
, size_t key_len
)
1406 wpa_printf(MSG_DEBUG
, "%s: priv=%p alg=%d key_idx=%d set_tx=%d",
1407 __func__
, priv
, alg
, key_idx
, set_tx
);
1409 wpa_printf(MSG_DEBUG
, " addr=" MACSTR
, MAC2STR(addr
));
1412 wpa_hexdump(MSG_DEBUG
, " seq", seq
, seq_len
);
1415 wpa_hexdump(MSG_DEBUG
, " key", key
, key_len
);
1421 static int wpa_driver_test_associate(
1422 void *priv
, struct wpa_driver_associate_params
*params
)
1424 struct wpa_driver_test_data
*drv
= priv
;
1425 wpa_printf(MSG_DEBUG
, "%s: priv=%p freq=%d pairwise_suite=%d "
1426 "group_suite=%d key_mgmt_suite=%d auth_alg=%d mode=%d",
1427 __func__
, priv
, params
->freq
, params
->pairwise_suite
,
1428 params
->group_suite
, params
->key_mgmt_suite
,
1429 params
->auth_alg
, params
->mode
);
1430 if (params
->bssid
) {
1431 wpa_printf(MSG_DEBUG
, " bssid=" MACSTR
,
1432 MAC2STR(params
->bssid
));
1435 wpa_hexdump_ascii(MSG_DEBUG
, " ssid",
1436 params
->ssid
, params
->ssid_len
);
1438 if (params
->wpa_ie
) {
1439 wpa_hexdump(MSG_DEBUG
, " wpa_ie",
1440 params
->wpa_ie
, params
->wpa_ie_len
);
1441 drv
->assoc_wpa_ie_len
= params
->wpa_ie_len
;
1442 if (drv
->assoc_wpa_ie_len
> sizeof(drv
->assoc_wpa_ie
))
1443 drv
->assoc_wpa_ie_len
= sizeof(drv
->assoc_wpa_ie
);
1444 os_memcpy(drv
->assoc_wpa_ie
, params
->wpa_ie
,
1445 drv
->assoc_wpa_ie_len
);
1447 drv
->assoc_wpa_ie_len
= 0;
1449 drv
->ibss
= params
->mode
== IEEE80211_MODE_IBSS
;
1450 drv
->privacy
= params
->key_mgmt_suite
&
1451 (WPA_KEY_MGMT_IEEE8021X
|
1453 WPA_KEY_MGMT_WPA_NONE
|
1454 WPA_KEY_MGMT_FT_IEEE8021X
|
1455 WPA_KEY_MGMT_FT_PSK
|
1456 WPA_KEY_MGMT_IEEE8021X_SHA256
|
1457 WPA_KEY_MGMT_PSK_SHA256
);
1458 if (params
->wep_key_len
[params
->wep_tx_keyidx
])
1461 #ifdef DRIVER_TEST_UNIX
1462 if (drv
->test_dir
&& params
->bssid
&&
1463 params
->mode
!= IEEE80211_MODE_IBSS
) {
1464 os_memset(&drv
->hostapd_addr
, 0, sizeof(drv
->hostapd_addr
));
1465 drv
->hostapd_addr
.sun_family
= AF_UNIX
;
1466 os_snprintf(drv
->hostapd_addr
.sun_path
,
1467 sizeof(drv
->hostapd_addr
.sun_path
),
1469 drv
->test_dir
, MAC2STR(params
->bssid
));
1470 drv
->hostapd_addr_set
= 1;
1472 #endif /* DRIVER_TEST_UNIX */
1474 if (drv
->test_socket
>= 0 &&
1475 (drv
->hostapd_addr_set
|| drv
->hostapd_addr_udp_set
)) {
1476 char cmd
[200], *pos
, *end
;
1478 end
= cmd
+ sizeof(cmd
);
1480 ret
= os_snprintf(pos
, end
- pos
, "ASSOC " MACSTR
" ",
1481 MAC2STR(drv
->own_addr
));
1482 if (ret
>= 0 && ret
< end
- pos
)
1484 pos
+= wpa_snprintf_hex(pos
, end
- pos
, params
->ssid
,
1486 ret
= os_snprintf(pos
, end
- pos
, " ");
1487 if (ret
>= 0 && ret
< end
- pos
)
1489 pos
+= wpa_snprintf_hex(pos
, end
- pos
, params
->wpa_ie
,
1490 params
->wpa_ie_len
);
1492 #ifdef DRIVER_TEST_UNIX
1493 if (drv
->hostapd_addr_set
&&
1494 sendto(drv
->test_socket
, cmd
, os_strlen(cmd
), 0,
1495 (struct sockaddr
*) &drv
->hostapd_addr
,
1496 sizeof(drv
->hostapd_addr
)) < 0) {
1497 perror("sendto(test_socket)");
1500 #endif /* DRIVER_TEST_UNIX */
1501 if (drv
->hostapd_addr_udp_set
&&
1502 sendto(drv
->test_socket
, cmd
, os_strlen(cmd
), 0,
1503 (struct sockaddr
*) &drv
->hostapd_addr_udp
,
1504 sizeof(drv
->hostapd_addr_udp
)) < 0) {
1505 perror("sendto(test_socket)");
1509 os_memcpy(drv
->ssid
, params
->ssid
, params
->ssid_len
);
1510 drv
->ssid_len
= params
->ssid_len
;
1512 drv
->associated
= 1;
1513 if (params
->mode
== IEEE80211_MODE_IBSS
) {
1514 os_memcpy(drv
->ssid
, params
->ssid
, params
->ssid_len
);
1515 drv
->ssid_len
= params
->ssid_len
;
1517 os_memcpy(drv
->bssid
, params
->bssid
, ETH_ALEN
);
1519 os_get_random(drv
->bssid
, ETH_ALEN
);
1520 drv
->bssid
[0] &= ~0x01;
1521 drv
->bssid
[0] |= 0x02;
1524 wpa_supplicant_event(drv
->ctx
, EVENT_ASSOC
, NULL
);
1531 static int wpa_driver_test_get_bssid(void *priv
, u8
*bssid
)
1533 struct wpa_driver_test_data
*drv
= priv
;
1534 os_memcpy(bssid
, drv
->bssid
, ETH_ALEN
);
1539 static int wpa_driver_test_get_ssid(void *priv
, u8
*ssid
)
1541 struct wpa_driver_test_data
*drv
= priv
;
1542 os_memcpy(ssid
, drv
->ssid
, 32);
1543 return drv
->ssid_len
;
1547 static int wpa_driver_test_send_disassoc(struct wpa_driver_test_data
*drv
)
1549 #ifdef DRIVER_TEST_UNIX
1550 if (drv
->test_socket
>= 0 &&
1551 sendto(drv
->test_socket
, "DISASSOC", 8, 0,
1552 (struct sockaddr
*) &drv
->hostapd_addr
,
1553 sizeof(drv
->hostapd_addr
)) < 0) {
1554 perror("sendto(test_socket)");
1557 #endif /* DRIVER_TEST_UNIX */
1558 if (drv
->test_socket
>= 0 && drv
->hostapd_addr_udp_set
&&
1559 sendto(drv
->test_socket
, "DISASSOC", 8, 0,
1560 (struct sockaddr
*) &drv
->hostapd_addr_udp
,
1561 sizeof(drv
->hostapd_addr_udp
)) < 0) {
1562 perror("sendto(test_socket)");
1569 static int wpa_driver_test_deauthenticate(void *priv
, const u8
*addr
,
1572 struct wpa_driver_test_data
*drv
= priv
;
1573 wpa_printf(MSG_DEBUG
, "%s addr=" MACSTR
" reason_code=%d",
1574 __func__
, MAC2STR(addr
), reason_code
);
1575 os_memset(drv
->bssid
, 0, ETH_ALEN
);
1576 drv
->associated
= 0;
1577 wpa_supplicant_event(drv
->ctx
, EVENT_DISASSOC
, NULL
);
1578 return wpa_driver_test_send_disassoc(drv
);
1582 static int wpa_driver_test_disassociate(void *priv
, const u8
*addr
,
1585 struct wpa_driver_test_data
*drv
= priv
;
1586 wpa_printf(MSG_DEBUG
, "%s addr=" MACSTR
" reason_code=%d",
1587 __func__
, MAC2STR(addr
), reason_code
);
1588 os_memset(drv
->bssid
, 0, ETH_ALEN
);
1589 drv
->associated
= 0;
1590 wpa_supplicant_event(drv
->ctx
, EVENT_DISASSOC
, NULL
);
1591 return wpa_driver_test_send_disassoc(drv
);
1595 static void wpa_driver_test_scanresp(struct wpa_driver_test_data
*drv
,
1596 struct sockaddr
*from
,
1600 struct wpa_scan_res
*res
;
1601 const char *pos
, *pos2
;
1603 u8
*ie_pos
, *ie_start
, *ie_end
;
1604 #define MAX_IE_LEN 1000
1606 wpa_printf(MSG_DEBUG
, "test_driver: SCANRESP %s", data
);
1607 if (drv
->num_scanres
>= MAX_SCAN_RESULTS
) {
1608 wpa_printf(MSG_DEBUG
, "test_driver: No room for the new scan "
1613 /* SCANRESP BSSID SSID IEs */
1615 res
= os_zalloc(sizeof(*res
) + MAX_IE_LEN
);
1618 ie_start
= ie_pos
= (u8
*) (res
+ 1);
1619 ie_end
= ie_pos
+ MAX_IE_LEN
;
1621 if (hwaddr_aton(data
, res
->bssid
)) {
1622 wpa_printf(MSG_DEBUG
, "test_driver: invalid BSSID in scanres");
1630 pos2
= os_strchr(pos
, ' ');
1632 wpa_printf(MSG_DEBUG
, "test_driver: invalid SSID termination "
1637 len
= (pos2
- pos
) / 2;
1641 * Generate SSID IE from the SSID field since this IE is not included
1642 * in the main IE field.
1644 *ie_pos
++ = WLAN_EID_SSID
;
1646 if (hexstr2bin(pos
, ie_pos
, len
) < 0) {
1647 wpa_printf(MSG_DEBUG
, "test_driver: invalid SSID in scanres");
1654 pos2
= os_strchr(pos
, ' ');
1656 len
= os_strlen(pos
) / 2;
1658 len
= (pos2
- pos
) / 2;
1659 if ((int) len
> ie_end
- ie_pos
)
1660 len
= ie_end
- ie_pos
;
1661 if (hexstr2bin(pos
, ie_pos
, len
) < 0) {
1662 wpa_printf(MSG_DEBUG
, "test_driver: invalid IEs in scanres");
1667 res
->ie_len
= ie_pos
- ie_start
;
1673 if (os_strstr(pos
, "PRIVACY"))
1674 res
->caps
|= IEEE80211_CAP_PRIVACY
;
1675 if (os_strstr(pos
, "IBSS"))
1676 res
->caps
|= IEEE80211_CAP_IBSS
;
1679 os_free(drv
->scanres
[drv
->num_scanres
]);
1680 drv
->scanres
[drv
->num_scanres
++] = res
;
1684 static void wpa_driver_test_assocresp(struct wpa_driver_test_data
*drv
,
1685 struct sockaddr
*from
,
1689 /* ASSOCRESP BSSID <res> */
1690 if (hwaddr_aton(data
, drv
->bssid
)) {
1691 wpa_printf(MSG_DEBUG
, "test_driver: invalid BSSID in "
1694 if (drv
->use_associnfo
) {
1695 union wpa_event_data event
;
1696 os_memset(&event
, 0, sizeof(event
));
1697 event
.assoc_info
.req_ies
= drv
->assoc_wpa_ie
;
1698 event
.assoc_info
.req_ies_len
= drv
->assoc_wpa_ie_len
;
1699 wpa_supplicant_event(drv
->ctx
, EVENT_ASSOCINFO
, &event
);
1701 drv
->associated
= 1;
1702 wpa_supplicant_event(drv
->ctx
, EVENT_ASSOC
, NULL
);
1706 static void wpa_driver_test_disassoc(struct wpa_driver_test_data
*drv
,
1707 struct sockaddr
*from
,
1710 drv
->associated
= 0;
1711 wpa_supplicant_event(drv
->ctx
, EVENT_DISASSOC
, NULL
);
1715 static void wpa_driver_test_eapol(struct wpa_driver_test_data
*drv
,
1716 struct sockaddr
*from
,
1718 const u8
*data
, size_t data_len
)
1720 const u8
*src
= drv
->bssid
;
1722 if (data_len
> 14) {
1723 /* Skip Ethernet header */
1724 src
= data
+ ETH_ALEN
;
1729 wpa_supplicant_rx_eapol(drv
->ctx
, src
, data
, data_len
);
1730 #endif /* HOSTAPD */
1734 static void wpa_driver_test_mlme(struct wpa_driver_test_data
*drv
,
1735 struct sockaddr
*from
,
1737 const u8
*data
, size_t data_len
)
1739 #ifdef CONFIG_CLIENT_MLME
1740 struct ieee80211_rx_status rx_status
;
1741 os_memset(&rx_status
, 0, sizeof(rx_status
));
1742 wpa_supplicant_sta_rx(drv
->ctx
, data
, data_len
, &rx_status
);
1743 #endif /* CONFIG_CLIENT_MLME */
1747 static void wpa_driver_test_scan_cmd(struct wpa_driver_test_data
*drv
,
1748 struct sockaddr
*from
,
1750 const u8
*data
, size_t data_len
)
1752 char buf
[512], *pos
, *end
;
1755 /* data: optional [ STA-addr | ' ' | IEs(hex) ] */
1761 end
= buf
+ sizeof(buf
);
1763 /* reply: SCANRESP BSSID SSID IEs */
1764 ret
= snprintf(pos
, end
- pos
, "SCANRESP " MACSTR
" ",
1765 MAC2STR(drv
->bssid
));
1766 if (ret
< 0 || ret
>= end
- pos
)
1769 pos
+= wpa_snprintf_hex(pos
, end
- pos
,
1770 drv
->ssid
, drv
->ssid_len
);
1771 ret
= snprintf(pos
, end
- pos
, " ");
1772 if (ret
< 0 || ret
>= end
- pos
)
1775 pos
+= wpa_snprintf_hex(pos
, end
- pos
, drv
->assoc_wpa_ie
,
1776 drv
->assoc_wpa_ie_len
);
1779 ret
= snprintf(pos
, end
- pos
, " PRIVACY");
1780 if (ret
< 0 || ret
>= end
- pos
)
1785 ret
= snprintf(pos
, end
- pos
, " IBSS");
1786 if (ret
< 0 || ret
>= end
- pos
)
1790 sendto(drv
->test_socket
, buf
, pos
- buf
, 0,
1791 (struct sockaddr
*) from
, fromlen
);
1795 static void wpa_driver_test_receive_unix(int sock
, void *eloop_ctx
,
1798 struct wpa_driver_test_data
*drv
= eloop_ctx
;
1801 struct sockaddr_storage from
;
1802 socklen_t fromlen
= sizeof(from
);
1803 const size_t buflen
= 2000;
1805 buf
= os_malloc(buflen
);
1808 res
= recvfrom(sock
, buf
, buflen
- 1, 0,
1809 (struct sockaddr
*) &from
, &fromlen
);
1811 perror("recvfrom(test_socket)");
1817 wpa_printf(MSG_DEBUG
, "test_driver: received %u bytes", res
);
1819 if (os_strncmp(buf
, "SCANRESP ", 9) == 0) {
1820 wpa_driver_test_scanresp(drv
, (struct sockaddr
*) &from
,
1822 } else if (os_strncmp(buf
, "ASSOCRESP ", 10) == 0) {
1823 wpa_driver_test_assocresp(drv
, (struct sockaddr
*) &from
,
1825 } else if (os_strcmp(buf
, "DISASSOC") == 0) {
1826 wpa_driver_test_disassoc(drv
, (struct sockaddr
*) &from
,
1828 } else if (os_strcmp(buf
, "DEAUTH") == 0) {
1829 wpa_driver_test_disassoc(drv
, (struct sockaddr
*) &from
,
1831 } else if (os_strncmp(buf
, "EAPOL ", 6) == 0) {
1832 wpa_driver_test_eapol(drv
, (struct sockaddr
*) &from
, fromlen
,
1833 (const u8
*) buf
+ 6, res
- 6);
1834 } else if (os_strncmp(buf
, "MLME ", 5) == 0) {
1835 wpa_driver_test_mlme(drv
, (struct sockaddr
*) &from
, fromlen
,
1836 (const u8
*) buf
+ 5, res
- 5);
1837 } else if (os_strncmp(buf
, "SCAN ", 5) == 0) {
1838 wpa_driver_test_scan_cmd(drv
, (struct sockaddr
*) &from
,
1840 (const u8
*) buf
+ 5, res
- 5);
1842 wpa_hexdump_ascii(MSG_DEBUG
, "Unknown test_socket command",
1849 static void * wpa_driver_test_init2(void *ctx
, const char *ifname
,
1852 struct wpa_driver_test_data
*drv
;
1854 drv
= os_zalloc(sizeof(*drv
));
1857 drv
->global
= global_priv
;
1859 drv
->test_socket
= -1;
1861 /* Set dummy BSSID and SSID for testing. */
1862 drv
->bssid
[0] = 0x02;
1863 drv
->bssid
[1] = 0x00;
1864 drv
->bssid
[2] = 0x00;
1865 drv
->bssid
[3] = 0x00;
1866 drv
->bssid
[4] = 0x00;
1867 drv
->bssid
[5] = 0x01;
1868 os_memcpy(drv
->ssid
, "test", 5);
1871 /* Generate a MAC address to help testing with multiple STAs */
1872 drv
->own_addr
[0] = 0x02; /* locally administered */
1873 sha1_prf((const u8
*) ifname
, os_strlen(ifname
),
1874 "wpa_supplicant test mac addr generation",
1875 NULL
, 0, drv
->own_addr
+ 1, ETH_ALEN
- 1);
1876 eloop_register_timeout(1, 0, wpa_driver_test_poll
, drv
, NULL
);
1882 static void wpa_driver_test_close_test_socket(struct wpa_driver_test_data
*drv
)
1884 if (drv
->test_socket
>= 0) {
1885 eloop_unregister_read_sock(drv
->test_socket
);
1886 close(drv
->test_socket
);
1887 drv
->test_socket
= -1;
1890 if (drv
->own_socket_path
) {
1891 unlink(drv
->own_socket_path
);
1892 os_free(drv
->own_socket_path
);
1893 drv
->own_socket_path
= NULL
;
1898 static void wpa_driver_test_deinit(void *priv
)
1900 struct wpa_driver_test_data
*drv
= priv
;
1901 struct test_client_socket
*cli
, *prev
;
1902 struct test_driver_bss
*bss
, *prev_bss
;
1913 /* There should be only one BSS remaining at this point. */
1914 if (drv
->bss
== NULL
)
1915 wpa_printf(MSG_ERROR
, "%s: drv->bss == NULL", __func__
);
1916 else if (drv
->bss
->next
)
1917 wpa_printf(MSG_ERROR
, "%s: drv->bss->next != NULL", __func__
);
1918 #endif /* HOSTAPD */
1924 test_driver_free_bss(prev_bss
);
1927 wpa_driver_test_close_test_socket(drv
);
1928 eloop_cancel_timeout(wpa_driver_test_scan_timeout
, drv
, drv
->ctx
);
1929 eloop_cancel_timeout(wpa_driver_test_poll
, drv
, NULL
);
1930 os_free(drv
->test_dir
);
1931 for (i
= 0; i
< MAX_SCAN_RESULTS
; i
++)
1932 os_free(drv
->scanres
[i
]);
1933 os_free(drv
->probe_req_ie
);
1938 static int wpa_driver_test_attach(struct wpa_driver_test_data
*drv
,
1941 #ifdef DRIVER_TEST_UNIX
1942 static unsigned int counter
= 0;
1943 struct sockaddr_un addr
;
1946 os_free(drv
->own_socket_path
);
1948 len
= os_strlen(dir
) + 30;
1949 drv
->own_socket_path
= os_malloc(len
);
1950 if (drv
->own_socket_path
== NULL
)
1952 os_snprintf(drv
->own_socket_path
, len
, "%s/STA-" MACSTR
,
1953 dir
, MAC2STR(drv
->own_addr
));
1955 drv
->own_socket_path
= os_malloc(100);
1956 if (drv
->own_socket_path
== NULL
)
1958 os_snprintf(drv
->own_socket_path
, 100,
1959 "/tmp/wpa_supplicant_test-%d-%d",
1960 getpid(), counter
++);
1963 drv
->test_socket
= socket(PF_UNIX
, SOCK_DGRAM
, 0);
1964 if (drv
->test_socket
< 0) {
1965 perror("socket(PF_UNIX)");
1966 os_free(drv
->own_socket_path
);
1967 drv
->own_socket_path
= NULL
;
1971 os_memset(&addr
, 0, sizeof(addr
));
1972 addr
.sun_family
= AF_UNIX
;
1973 os_strlcpy(addr
.sun_path
, drv
->own_socket_path
, sizeof(addr
.sun_path
));
1974 if (bind(drv
->test_socket
, (struct sockaddr
*) &addr
,
1975 sizeof(addr
)) < 0) {
1976 perror("bind(PF_UNIX)");
1977 close(drv
->test_socket
);
1978 unlink(drv
->own_socket_path
);
1979 os_free(drv
->own_socket_path
);
1980 drv
->own_socket_path
= NULL
;
1984 eloop_register_read_sock(drv
->test_socket
,
1985 wpa_driver_test_receive_unix
, drv
, NULL
);
1988 #else /* DRIVER_TEST_UNIX */
1990 #endif /* DRIVER_TEST_UNIX */
1994 static int wpa_driver_test_attach_udp(struct wpa_driver_test_data
*drv
,
1999 pos
= os_strchr(dst
, ':');
2003 wpa_printf(MSG_DEBUG
, "%s: addr=%s port=%s", __func__
, dst
, pos
);
2005 drv
->test_socket
= socket(PF_INET
, SOCK_DGRAM
, 0);
2006 if (drv
->test_socket
< 0) {
2007 perror("socket(PF_INET)");
2011 os_memset(&drv
->hostapd_addr_udp
, 0, sizeof(drv
->hostapd_addr_udp
));
2012 drv
->hostapd_addr_udp
.sin_family
= AF_INET
;
2013 #if defined(CONFIG_NATIVE_WINDOWS) || defined(CONFIG_ANSI_C_EXTRA)
2017 sscanf(dst
, "%d.%d.%d.%d", &a
[0], &a
[1], &a
[2], &a
[3]);
2018 pos
= (u8
*) &drv
->hostapd_addr_udp
.sin_addr
;
2024 #else /* CONFIG_NATIVE_WINDOWS or CONFIG_ANSI_C_EXTRA */
2025 inet_aton(dst
, &drv
->hostapd_addr_udp
.sin_addr
);
2026 #endif /* CONFIG_NATIVE_WINDOWS or CONFIG_ANSI_C_EXTRA */
2027 drv
->hostapd_addr_udp
.sin_port
= htons(atoi(pos
));
2029 drv
->hostapd_addr_udp_set
= 1;
2031 eloop_register_read_sock(drv
->test_socket
,
2032 wpa_driver_test_receive_unix
, drv
, NULL
);
2038 static int wpa_driver_test_set_param(void *priv
, const char *param
)
2040 struct wpa_driver_test_data
*drv
= priv
;
2043 wpa_printf(MSG_DEBUG
, "%s: param='%s'", __func__
, param
);
2047 wpa_driver_test_close_test_socket(drv
);
2049 #ifdef DRIVER_TEST_UNIX
2050 pos
= os_strstr(param
, "test_socket=");
2056 pos2
= os_strchr(pos
, ' ');
2060 len
= os_strlen(pos
);
2061 if (len
> sizeof(drv
->hostapd_addr
.sun_path
))
2063 os_memset(&drv
->hostapd_addr
, 0, sizeof(drv
->hostapd_addr
));
2064 drv
->hostapd_addr
.sun_family
= AF_UNIX
;
2065 os_memcpy(drv
->hostapd_addr
.sun_path
, pos
, len
);
2066 drv
->hostapd_addr_set
= 1;
2068 #endif /* DRIVER_TEST_UNIX */
2070 pos
= os_strstr(param
, "test_dir=");
2073 os_free(drv
->test_dir
);
2074 drv
->test_dir
= os_strdup(pos
+ 9);
2075 if (drv
->test_dir
== NULL
)
2077 end
= os_strchr(drv
->test_dir
, ' ');
2080 if (wpa_driver_test_attach(drv
, drv
->test_dir
))
2083 pos
= os_strstr(param
, "test_udp=");
2086 dst
= os_strdup(pos
+ 9);
2089 epos
= os_strchr(dst
, ' ');
2092 if (wpa_driver_test_attach_udp(drv
, dst
))
2095 } else if (wpa_driver_test_attach(drv
, NULL
))
2099 if (os_strstr(param
, "use_associnfo=1")) {
2100 wpa_printf(MSG_DEBUG
, "test_driver: Use AssocInfo events");
2101 drv
->use_associnfo
= 1;
2104 #ifdef CONFIG_CLIENT_MLME
2105 if (os_strstr(param
, "use_mlme=1")) {
2106 wpa_printf(MSG_DEBUG
, "test_driver: Use internal MLME");
2109 #endif /* CONFIG_CLIENT_MLME */
2115 static const u8
* wpa_driver_test_get_mac_addr(void *priv
)
2117 struct wpa_driver_test_data
*drv
= priv
;
2118 wpa_printf(MSG_DEBUG
, "%s", __func__
);
2119 return drv
->own_addr
;
2123 static int wpa_driver_test_send_eapol(void *priv
, const u8
*dest
, u16 proto
,
2124 const u8
*data
, size_t data_len
)
2126 struct wpa_driver_test_data
*drv
= priv
;
2129 struct l2_ethhdr eth
;
2130 struct sockaddr
*addr
;
2132 #ifdef DRIVER_TEST_UNIX
2133 struct sockaddr_un addr_un
;
2134 #endif /* DRIVER_TEST_UNIX */
2136 wpa_hexdump(MSG_MSGDUMP
, "test_send_eapol TX frame", data
, data_len
);
2138 os_memset(ð
, 0, sizeof(eth
));
2139 os_memcpy(eth
.h_dest
, dest
, ETH_ALEN
);
2140 os_memcpy(eth
.h_source
, drv
->own_addr
, ETH_ALEN
);
2141 eth
.h_proto
= host_to_be16(proto
);
2143 msg_len
= 6 + sizeof(eth
) + data_len
;
2144 msg
= os_malloc(msg_len
);
2147 os_memcpy(msg
, "EAPOL ", 6);
2148 os_memcpy(msg
+ 6, ð
, sizeof(eth
));
2149 os_memcpy(msg
+ 6 + sizeof(eth
), data
, data_len
);
2151 if (os_memcmp(dest
, drv
->bssid
, ETH_ALEN
) == 0 ||
2152 drv
->test_dir
== NULL
) {
2153 if (drv
->hostapd_addr_udp_set
) {
2154 addr
= (struct sockaddr
*) &drv
->hostapd_addr_udp
;
2155 alen
= sizeof(drv
->hostapd_addr_udp
);
2157 #ifdef DRIVER_TEST_UNIX
2158 addr
= (struct sockaddr
*) &drv
->hostapd_addr
;
2159 alen
= sizeof(drv
->hostapd_addr
);
2160 #else /* DRIVER_TEST_UNIX */
2163 #endif /* DRIVER_TEST_UNIX */
2166 #ifdef DRIVER_TEST_UNIX
2168 os_memset(&addr_un
, 0, sizeof(addr_un
));
2169 addr_un
.sun_family
= AF_UNIX
;
2170 os_snprintf(addr_un
.sun_path
, sizeof(addr_un
.sun_path
),
2171 "%s/STA-" MACSTR
, drv
->test_dir
, MAC2STR(dest
));
2172 if (stat(addr_un
.sun_path
, &st
) < 0) {
2173 os_snprintf(addr_un
.sun_path
, sizeof(addr_un
.sun_path
),
2175 drv
->test_dir
, MAC2STR(dest
));
2177 addr
= (struct sockaddr
*) &addr_un
;
2178 alen
= sizeof(addr_un
);
2179 #else /* DRIVER_TEST_UNIX */
2182 #endif /* DRIVER_TEST_UNIX */
2185 if (sendto(drv
->test_socket
, msg
, msg_len
, 0, addr
, alen
) < 0) {
2186 perror("sendmsg(test_socket)");
2196 static int wpa_driver_test_get_capa(void *priv
, struct wpa_driver_capa
*capa
)
2198 struct wpa_driver_test_data
*drv
= priv
;
2199 os_memset(capa
, 0, sizeof(*capa
));
2200 capa
->key_mgmt
= WPA_DRIVER_CAPA_KEY_MGMT_WPA
|
2201 WPA_DRIVER_CAPA_KEY_MGMT_WPA2
|
2202 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK
|
2203 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK
|
2204 WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE
|
2205 WPA_DRIVER_CAPA_KEY_MGMT_FT
|
2206 WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK
;
2207 capa
->enc
= WPA_DRIVER_CAPA_ENC_WEP40
|
2208 WPA_DRIVER_CAPA_ENC_WEP104
|
2209 WPA_DRIVER_CAPA_ENC_TKIP
|
2210 WPA_DRIVER_CAPA_ENC_CCMP
;
2211 capa
->auth
= WPA_DRIVER_AUTH_OPEN
|
2212 WPA_DRIVER_AUTH_SHARED
|
2213 WPA_DRIVER_AUTH_LEAP
;
2215 capa
->flags
|= WPA_DRIVER_FLAGS_USER_SPACE_MLME
;
2216 capa
->flags
|= WPA_DRIVER_FLAGS_AP
;
2217 capa
->max_scan_ssids
= 2;
2223 static int wpa_driver_test_mlme_setprotection(void *priv
, const u8
*addr
,
2227 wpa_printf(MSG_DEBUG
, "%s: protect_type=%d key_type=%d",
2228 __func__
, protect_type
, key_type
);
2231 wpa_printf(MSG_DEBUG
, "%s: addr=" MACSTR
,
2232 __func__
, MAC2STR(addr
));
2239 static int wpa_driver_test_set_channel(void *priv
, hostapd_hw_mode phymode
,
2242 wpa_printf(MSG_DEBUG
, "%s: phymode=%d chan=%d freq=%d",
2243 __func__
, phymode
, chan
, freq
);
2248 static int wpa_driver_test_mlme_add_sta(void *priv
, const u8
*addr
,
2249 const u8
*supp_rates
,
2250 size_t supp_rates_len
)
2252 wpa_printf(MSG_DEBUG
, "%s: addr=" MACSTR
, __func__
, MAC2STR(addr
));
2257 static int wpa_driver_test_mlme_remove_sta(void *priv
, const u8
*addr
)
2259 wpa_printf(MSG_DEBUG
, "%s: addr=" MACSTR
, __func__
, MAC2STR(addr
));
2264 static int wpa_driver_test_set_ssid(void *priv
, const u8
*ssid
,
2267 wpa_printf(MSG_DEBUG
, "%s", __func__
);
2272 static int wpa_driver_test_set_bssid(void *priv
, const u8
*bssid
)
2274 wpa_printf(MSG_DEBUG
, "%s: bssid=" MACSTR
, __func__
, MAC2STR(bssid
));
2279 static int wpa_driver_test_set_probe_req_ie(void *priv
, const u8
*ies
,
2282 struct wpa_driver_test_data
*drv
= priv
;
2284 os_free(drv
->probe_req_ie
);
2286 drv
->probe_req_ie
= os_malloc(ies_len
);
2287 if (drv
->probe_req_ie
== NULL
) {
2288 drv
->probe_req_ie_len
= 0;
2291 os_memcpy(drv
->probe_req_ie
, ies
, ies_len
);
2292 drv
->probe_req_ie_len
= ies_len
;
2294 drv
->probe_req_ie
= NULL
;
2295 drv
->probe_req_ie_len
= 0;
2301 static void * wpa_driver_test_global_init(void)
2303 struct wpa_driver_test_global
*global
;
2305 global
= os_zalloc(sizeof(*global
));
2310 static void wpa_driver_test_global_deinit(void *priv
)
2312 struct wpa_driver_test_global
*global
= priv
;
2317 static struct wpa_interface_info
*
2318 wpa_driver_test_get_interfaces(void *global_priv
)
2320 /* struct wpa_driver_test_global *global = priv; */
2321 struct wpa_interface_info
*iface
;
2323 iface
= os_zalloc(sizeof(*iface
));
2326 iface
->ifname
= os_strdup("sta0");
2327 iface
->desc
= os_strdup("test interface 0");
2328 iface
->drv_name
= "test";
2329 iface
->next
= os_zalloc(sizeof(*iface
));
2331 iface
->next
->ifname
= os_strdup("sta1");
2332 iface
->next
->desc
= os_strdup("test interface 1");
2333 iface
->next
->drv_name
= "test";
2340 static struct hostapd_hw_modes
*
2341 wpa_driver_test_get_hw_feature_data(void *priv
, u16
*num_modes
, u16
*flags
)
2343 struct hostapd_hw_modes
*modes
;
2347 modes
= os_zalloc(*num_modes
* sizeof(struct hostapd_hw_modes
));
2350 modes
[0].mode
= HOSTAPD_MODE_IEEE80211G
;
2351 modes
[0].num_channels
= 1;
2352 modes
[0].num_rates
= 1;
2353 modes
[0].channels
= os_zalloc(sizeof(struct hostapd_channel_data
));
2354 modes
[0].rates
= os_zalloc(sizeof(struct hostapd_rate_data
));
2355 if (modes
[0].channels
== NULL
|| modes
[0].rates
== NULL
)
2357 modes
[0].channels
[0].chan
= 1;
2358 modes
[0].channels
[0].freq
= 2412;
2359 modes
[0].channels
[0].flag
= 0;
2360 modes
[0].rates
[0].rate
= 10;
2361 modes
[0].rates
[0].flags
= HOSTAPD_RATE_BASIC
| HOSTAPD_RATE_SUPPORTED
|
2362 HOSTAPD_RATE_CCK
| HOSTAPD_RATE_MANDATORY
;
2364 modes
[1].mode
= HOSTAPD_MODE_IEEE80211B
;
2365 modes
[1].num_channels
= 1;
2366 modes
[1].num_rates
= 1;
2367 modes
[1].channels
= os_zalloc(sizeof(struct hostapd_channel_data
));
2368 modes
[1].rates
= os_zalloc(sizeof(struct hostapd_rate_data
));
2369 if (modes
[1].channels
== NULL
|| modes
[1].rates
== NULL
)
2371 modes
[1].channels
[0].chan
= 1;
2372 modes
[1].channels
[0].freq
= 2412;
2373 modes
[1].channels
[0].flag
= 0;
2374 modes
[1].rates
[0].rate
= 10;
2375 modes
[1].rates
[0].flags
= HOSTAPD_RATE_BASIC
| HOSTAPD_RATE_SUPPORTED
|
2376 HOSTAPD_RATE_CCK
| HOSTAPD_RATE_MANDATORY
;
2378 modes
[2].mode
= HOSTAPD_MODE_IEEE80211A
;
2379 modes
[2].num_channels
= 1;
2380 modes
[2].num_rates
= 1;
2381 modes
[2].channels
= os_zalloc(sizeof(struct hostapd_channel_data
));
2382 modes
[2].rates
= os_zalloc(sizeof(struct hostapd_rate_data
));
2383 if (modes
[2].channels
== NULL
|| modes
[2].rates
== NULL
)
2385 modes
[2].channels
[0].chan
= 60;
2386 modes
[2].channels
[0].freq
= 5300;
2387 modes
[2].channels
[0].flag
= 0;
2388 modes
[2].rates
[0].rate
= 60;
2389 modes
[2].rates
[0].flags
= HOSTAPD_RATE_BASIC
| HOSTAPD_RATE_SUPPORTED
|
2390 HOSTAPD_RATE_MANDATORY
;
2397 for (i
= 0; i
< *num_modes
; i
++) {
2398 os_free(modes
[i
].channels
);
2399 os_free(modes
[i
].rates
);
2407 const struct wpa_driver_ops wpa_driver_test_ops
= {
2409 "wpa_supplicant test driver",
2410 .hapd_init
= test_driver_init
,
2411 .hapd_deinit
= wpa_driver_test_deinit
,
2412 .hapd_send_eapol
= test_driver_send_eapol
,
2413 .send_mlme
= wpa_driver_test_send_mlme
,
2414 .set_generic_elem
= test_driver_set_generic_elem
,
2415 .sta_deauth
= test_driver_sta_deauth
,
2416 .sta_disassoc
= test_driver_sta_disassoc
,
2417 .get_hw_feature_data
= wpa_driver_test_get_hw_feature_data
,
2418 .bss_add
= test_driver_bss_add
,
2419 .bss_remove
= test_driver_bss_remove
,
2420 .if_add
= test_driver_if_add
,
2421 .if_update
= test_driver_if_update
,
2422 .if_remove
= test_driver_if_remove
,
2423 .valid_bss_mask
= test_driver_valid_bss_mask
,
2424 .hapd_set_ssid
= test_driver_set_ssid
,
2425 .set_privacy
= test_driver_set_privacy
,
2426 .hapd_set_key
= test_driver_set_key
,
2427 .set_sta_vlan
= test_driver_set_sta_vlan
,
2428 .sta_add
= test_driver_sta_add
,
2429 .send_ether
= test_driver_send_ether
,
2430 .set_wps_beacon_ie
= test_driver_set_wps_beacon_ie
,
2431 .set_wps_probe_resp_ie
= test_driver_set_wps_probe_resp_ie
,
2432 .get_bssid
= wpa_driver_test_get_bssid
,
2433 .get_ssid
= wpa_driver_test_get_ssid
,
2434 .set_wpa
= wpa_driver_test_set_wpa
,
2435 .set_key
= wpa_driver_test_set_key
,
2436 .deinit
= wpa_driver_test_deinit
,
2437 .set_param
= wpa_driver_test_set_param
,
2438 .deauthenticate
= wpa_driver_test_deauthenticate
,
2439 .disassociate
= wpa_driver_test_disassociate
,
2440 .associate
= wpa_driver_test_associate
,
2441 .get_capa
= wpa_driver_test_get_capa
,
2442 .get_mac_addr
= wpa_driver_test_get_mac_addr
,
2443 .send_eapol
= wpa_driver_test_send_eapol
,
2444 .mlme_setprotection
= wpa_driver_test_mlme_setprotection
,
2445 .set_channel
= wpa_driver_test_set_channel
,
2446 .set_ssid
= wpa_driver_test_set_ssid
,
2447 .set_bssid
= wpa_driver_test_set_bssid
,
2448 .mlme_add_sta
= wpa_driver_test_mlme_add_sta
,
2449 .mlme_remove_sta
= wpa_driver_test_mlme_remove_sta
,
2450 .get_scan_results2
= wpa_driver_test_get_scan_results2
,
2451 .set_probe_req_ie
= wpa_driver_test_set_probe_req_ie
,
2452 .global_init
= wpa_driver_test_global_init
,
2453 .global_deinit
= wpa_driver_test_global_deinit
,
2454 .init2
= wpa_driver_test_init2
,
2455 .get_interfaces
= wpa_driver_test_get_interfaces
,
2456 .scan2
= wpa_driver_test_scan
,