2 * Testing driver interface for a simulated network driver
3 * Copyright (c) 2004-2009, 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"
34 #include "crypto/sha1.h"
35 #include "common/ieee802_11_defs.h"
38 struct test_client_socket
{
39 struct test_client_socket
*next
;
41 struct sockaddr_un un
;
43 struct test_driver_bss
*bss
;
46 struct test_driver_bss
{
47 struct test_driver_bss
*next
;
49 char ifname
[IFNAMSIZ
+ 1];
54 size_t wps_beacon_ie_len
;
55 u8
*wps_probe_resp_ie
;
56 size_t wps_probe_resp_ie_len
;
62 struct wpa_driver_test_global
{
66 struct wpa_driver_test_data
{
67 struct wpa_driver_test_global
*global
;
69 u8 own_addr
[ETH_ALEN
];
71 #ifdef DRIVER_TEST_UNIX
72 struct sockaddr_un hostapd_addr
;
73 #endif /* DRIVER_TEST_UNIX */
75 struct sockaddr_in hostapd_addr_udp
;
76 int hostapd_addr_udp_set
;
77 char *own_socket_path
;
82 #define MAX_SCAN_RESULTS 30
83 struct wpa_scan_res
*scanres
[MAX_SCAN_RESULTS
];
87 size_t assoc_wpa_ie_len
;
91 size_t probe_req_ie_len
;
96 struct test_client_socket
*cli
;
97 struct test_driver_bss
*bss
;
102 static void wpa_driver_test_deinit(void *priv
);
103 static int wpa_driver_test_attach(struct wpa_driver_test_data
*drv
,
104 const char *dir
, int ap
);
105 static void wpa_driver_test_close_test_socket(
106 struct wpa_driver_test_data
*drv
);
109 void ap_mgmt_rx(void *ctx
, u8
*buf
, size_t len
, u16 stype
,
110 struct hostapd_frame_info
*fi
);
111 void ap_mgmt_tx_cb(void *ctx
, u8
*buf
, size_t len
, u16 stype
, int ok
);
113 #else /* CONFIG_AP */
115 static inline void ap_mgmt_rx(void *ctx
, u8
*buf
, size_t len
, u16 stype
,
116 struct hostapd_frame_info
*fi
)
120 static inline void ap_mgmt_tx_cb(void *ctx
, u8
*buf
, size_t len
, u16 stype
,
125 #endif /* CONFIG_AP */
128 static void test_driver_free_bss(struct test_driver_bss
*bss
)
131 os_free(bss
->wps_beacon_ie
);
132 os_free(bss
->wps_probe_resp_ie
);
137 static void test_driver_free_bsses(struct wpa_driver_test_data
*drv
)
139 struct test_driver_bss
*bss
, *prev_bss
;
145 test_driver_free_bss(prev_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
,
174 struct wpa_driver_test_data
*drv
= priv
;
175 struct test_client_socket
*cli
;
178 struct l2_ethhdr eth
;
180 if (drv
->test_socket
< 0)
185 if (memcmp(cli
->addr
, addr
, ETH_ALEN
) == 0)
191 wpa_printf(MSG_DEBUG
, "%s: no destination client entry",
196 memcpy(eth
.h_dest
, addr
, ETH_ALEN
);
197 memcpy(eth
.h_source
, own_addr
, ETH_ALEN
);
198 eth
.h_proto
= host_to_be16(ETH_P_EAPOL
);
200 io
[0].iov_base
= "EAPOL ";
202 io
[1].iov_base
= ð
;
203 io
[1].iov_len
= sizeof(eth
);
204 io
[2].iov_base
= (u8
*) data
;
205 io
[2].iov_len
= data_len
;
207 memset(&msg
, 0, sizeof(msg
));
210 msg
.msg_name
= &cli
->un
;
211 msg
.msg_namelen
= cli
->unlen
;
212 return sendmsg(drv
->test_socket
, &msg
, 0);
216 static int test_driver_send_ether(void *priv
, const u8
*dst
, const u8
*src
,
217 u16 proto
, const u8
*data
, size_t data_len
)
219 struct wpa_driver_test_data
*drv
= priv
;
222 struct l2_ethhdr eth
;
224 struct sockaddr_un addr
;
227 int ret
= 0, broadcast
= 0, count
= 0;
229 if (drv
->test_socket
< 0 || drv
->test_dir
== NULL
) {
230 wpa_printf(MSG_DEBUG
, "%s: invalid parameters (sock=%d "
232 __func__
, drv
->test_socket
, drv
->test_dir
);
236 broadcast
= memcmp(dst
, "\xff\xff\xff\xff\xff\xff", ETH_ALEN
) == 0;
237 snprintf(desttxt
, sizeof(desttxt
), MACSTR
, MAC2STR(dst
));
239 memcpy(eth
.h_dest
, dst
, ETH_ALEN
);
240 memcpy(eth
.h_source
, src
, ETH_ALEN
);
241 eth
.h_proto
= host_to_be16(proto
);
243 io
[0].iov_base
= "ETHER ";
245 io
[1].iov_base
= ð
;
246 io
[1].iov_len
= sizeof(eth
);
247 io
[2].iov_base
= (u8
*) data
;
248 io
[2].iov_len
= data_len
;
250 memset(&msg
, 0, sizeof(msg
));
254 dir
= opendir(drv
->test_dir
);
256 perror("test_driver: opendir");
259 while ((dent
= readdir(dir
))) {
260 #ifdef _DIRENT_HAVE_D_TYPE
261 /* Skip the file if it is not a socket. Also accept
262 * DT_UNKNOWN (0) in case the C library or underlying file
263 * system does not support d_type. */
264 if (dent
->d_type
!= DT_SOCK
&& dent
->d_type
!= DT_UNKNOWN
)
266 #endif /* _DIRENT_HAVE_D_TYPE */
267 if (strcmp(dent
->d_name
, ".") == 0 ||
268 strcmp(dent
->d_name
, "..") == 0)
271 memset(&addr
, 0, sizeof(addr
));
272 addr
.sun_family
= AF_UNIX
;
273 snprintf(addr
.sun_path
, sizeof(addr
.sun_path
), "%s/%s",
274 drv
->test_dir
, dent
->d_name
);
276 if (strcmp(addr
.sun_path
, drv
->own_socket_path
) == 0)
278 if (!broadcast
&& strstr(dent
->d_name
, desttxt
) == NULL
)
281 wpa_printf(MSG_DEBUG
, "%s: Send ether frame to %s",
282 __func__
, dent
->d_name
);
284 msg
.msg_name
= &addr
;
285 msg
.msg_namelen
= sizeof(addr
);
286 ret
= sendmsg(drv
->test_socket
, &msg
, 0);
288 perror("driver_test: sendmsg");
293 if (!broadcast
&& count
== 0) {
294 wpa_printf(MSG_DEBUG
, "%s: Destination " MACSTR
" not found",
295 __func__
, MAC2STR(dst
));
303 static int wpa_driver_test_send_mlme(void *priv
, const u8
*data
,
306 struct wpa_driver_test_data
*drv
= priv
;
310 struct sockaddr_un addr
;
315 struct ieee80211_hdr
*hdr
;
320 union wpa_event_data event
;
322 wpa_hexdump(MSG_MSGDUMP
, "test_send_mlme", data
, data_len
);
323 if (drv
->test_socket
< 0 || data_len
< 10) {
324 wpa_printf(MSG_DEBUG
, "%s: invalid parameters (sock=%d len=%lu"
326 __func__
, drv
->test_socket
,
327 (unsigned long) data_len
,
333 broadcast
= os_memcmp(dest
, "\xff\xff\xff\xff\xff\xff", ETH_ALEN
) == 0;
336 snprintf(desttxt
, sizeof(desttxt
), MACSTR
, MAC2STR(dest
));
339 io
[0].iov_base
= "MLME ";
341 io
[1].iov_base
= (void *) data
;
342 io
[1].iov_len
= data_len
;
344 os_memset(&msg
, 0, sizeof(msg
));
349 if (drv
->test_dir
== NULL
) {
350 wpa_printf(MSG_DEBUG
, "%s: test_dir == NULL", __func__
);
354 dir
= opendir(drv
->test_dir
);
356 perror("test_driver: opendir");
359 while ((dent
= readdir(dir
))) {
360 #ifdef _DIRENT_HAVE_D_TYPE
361 /* Skip the file if it is not a socket. Also accept
362 * DT_UNKNOWN (0) in case the C library or underlying file
363 * system does not support d_type. */
364 if (dent
->d_type
!= DT_SOCK
&& dent
->d_type
!= DT_UNKNOWN
)
366 #endif /* _DIRENT_HAVE_D_TYPE */
367 if (os_strcmp(dent
->d_name
, ".") == 0 ||
368 os_strcmp(dent
->d_name
, "..") == 0)
371 os_memset(&addr
, 0, sizeof(addr
));
372 addr
.sun_family
= AF_UNIX
;
373 os_snprintf(addr
.sun_path
, sizeof(addr
.sun_path
), "%s/%s",
374 drv
->test_dir
, dent
->d_name
);
376 if (os_strcmp(addr
.sun_path
, drv
->own_socket_path
) == 0)
378 if (!broadcast
&& os_strstr(dent
->d_name
, desttxt
) == NULL
)
381 wpa_printf(MSG_DEBUG
, "%s: Send management frame to %s",
382 __func__
, dent
->d_name
);
384 msg
.msg_name
= &addr
;
385 msg
.msg_namelen
= sizeof(addr
);
386 ret
= sendmsg(drv
->test_socket
, &msg
, 0);
388 perror("driver_test: sendmsg(test_socket)");
393 if (os_memcmp(dest
, drv
->bssid
, ETH_ALEN
) == 0 ||
394 drv
->test_dir
== NULL
) {
395 if (drv
->hostapd_addr_udp_set
) {
396 msg
.msg_name
= &drv
->hostapd_addr_udp
;
397 msg
.msg_namelen
= sizeof(drv
->hostapd_addr_udp
);
399 #ifdef DRIVER_TEST_UNIX
400 msg
.msg_name
= &drv
->hostapd_addr
;
401 msg
.msg_namelen
= sizeof(drv
->hostapd_addr
);
402 #endif /* DRIVER_TEST_UNIX */
404 } else if (broadcast
) {
405 dir
= opendir(drv
->test_dir
);
408 while ((dent
= readdir(dir
))) {
409 #ifdef _DIRENT_HAVE_D_TYPE
410 /* Skip the file if it is not a socket.
411 * Also accept DT_UNKNOWN (0) in case
412 * the C library or underlying file
413 * system does not support d_type. */
414 if (dent
->d_type
!= DT_SOCK
&&
415 dent
->d_type
!= DT_UNKNOWN
)
417 #endif /* _DIRENT_HAVE_D_TYPE */
418 if (os_strcmp(dent
->d_name
, ".") == 0 ||
419 os_strcmp(dent
->d_name
, "..") == 0)
421 wpa_printf(MSG_DEBUG
, "%s: Send broadcast MLME to %s",
422 __func__
, dent
->d_name
);
423 os_memset(&addr
, 0, sizeof(addr
));
424 addr
.sun_family
= AF_UNIX
;
425 os_snprintf(addr
.sun_path
, sizeof(addr
.sun_path
),
426 "%s/%s", drv
->test_dir
, dent
->d_name
);
428 msg
.msg_name
= &addr
;
429 msg
.msg_namelen
= sizeof(addr
);
431 ret
= sendmsg(drv
->test_socket
, &msg
, 0);
433 perror("driver_test: sendmsg(test_socket)");
439 os_memset(&addr
, 0, sizeof(addr
));
440 addr
.sun_family
= AF_UNIX
;
441 os_snprintf(addr
.sun_path
, sizeof(addr
.sun_path
),
442 "%s/AP-" MACSTR
, drv
->test_dir
, MAC2STR(dest
));
443 if (stat(addr
.sun_path
, &st
) < 0) {
444 os_snprintf(addr
.sun_path
, sizeof(addr
.sun_path
),
446 drv
->test_dir
, MAC2STR(dest
));
448 msg
.msg_name
= &addr
;
449 msg
.msg_namelen
= sizeof(addr
);
452 if (sendmsg(drv
->test_socket
, &msg
, 0) < 0) {
453 perror("sendmsg(test_socket)");
458 hdr
= (struct ieee80211_hdr
*) data
;
459 fc
= le_to_host16(hdr
->frame_control
);
461 os_memset(&event
, 0, sizeof(event
));
462 event
.tx_status
.type
= WLAN_FC_GET_TYPE(fc
);
463 event
.tx_status
.stype
= WLAN_FC_GET_STYPE(fc
);
464 event
.tx_status
.dst
= hdr
->addr1
;
465 event
.tx_status
.data
= data
;
466 event
.tx_status
.data_len
= data_len
;
467 event
.tx_status
.ack
= ret
>= 0;
468 wpa_supplicant_event(drv
->ctx
, EVENT_TX_STATUS
, &event
);
474 static void test_driver_scan(struct wpa_driver_test_data
*drv
,
475 struct sockaddr_un
*from
, socklen_t fromlen
,
478 char buf
[512], *pos
, *end
;
480 struct test_driver_bss
*bss
;
485 /* data: optional [ ' ' | STA-addr | ' ' | IEs(hex) ] */
487 wpa_printf(MSG_DEBUG
, "test_driver: SCAN");
491 hwaddr_aton(data
+ 1, sa
)) {
492 wpa_printf(MSG_DEBUG
, "test_driver: Unexpected SCAN "
500 ielen
= os_strlen(data
) / 2;
501 if (ielen
> sizeof(ie
))
503 if (hexstr2bin(data
, ie
, ielen
) < 0)
506 wpa_printf(MSG_DEBUG
, "test_driver: Scan from " MACSTR
,
508 wpa_hexdump(MSG_MSGDUMP
, "test_driver: scan IEs", ie
, ielen
);
511 hostapd_probe_req_rx(drv
->ctx
, sa
, ie
, ielen
);
515 for (bss
= drv
->bss
; bss
; bss
= bss
->next
) {
517 end
= buf
+ sizeof(buf
);
519 /* reply: SCANRESP BSSID SSID IEs */
520 ret
= snprintf(pos
, end
- pos
, "SCANRESP " MACSTR
" ",
521 MAC2STR(bss
->bssid
));
522 if (ret
< 0 || ret
>= end
- pos
)
525 pos
+= wpa_snprintf_hex(pos
, end
- pos
,
526 bss
->ssid
, bss
->ssid_len
);
527 ret
= snprintf(pos
, end
- pos
, " ");
528 if (ret
< 0 || ret
>= end
- pos
)
531 pos
+= wpa_snprintf_hex(pos
, end
- pos
, bss
->ie
, bss
->ielen
);
532 pos
+= wpa_snprintf_hex(pos
, end
- pos
, bss
->wps_probe_resp_ie
,
533 bss
->wps_probe_resp_ie_len
);
536 ret
= snprintf(pos
, end
- pos
, " PRIVACY");
537 if (ret
< 0 || ret
>= end
- pos
)
542 sendto(drv
->test_socket
, buf
, pos
- buf
, 0,
543 (struct sockaddr
*) from
, fromlen
);
548 static void test_driver_assoc(struct wpa_driver_test_data
*drv
,
549 struct sockaddr_un
*from
, socklen_t fromlen
,
552 struct test_client_socket
*cli
;
553 u8 ie
[256], ssid
[32];
554 size_t ielen
, ssid_len
= 0;
555 char *pos
, *pos2
, cmd
[50];
556 struct test_driver_bss
*bss
;
558 /* data: STA-addr SSID(hex) IEs(hex) */
560 cli
= os_zalloc(sizeof(*cli
));
564 if (hwaddr_aton(data
, cli
->addr
)) {
565 printf("test_socket: Invalid MAC address '%s' in ASSOC\n",
573 pos2
= strchr(pos
, ' ');
576 ssid_len
= (pos2
- pos
) / 2;
577 if (hexstr2bin(pos
, ssid
, ssid_len
) < 0) {
578 wpa_printf(MSG_DEBUG
, "%s: Invalid SSID", __func__
);
582 wpa_hexdump_ascii(MSG_DEBUG
, "test_driver_assoc: SSID",
586 ielen
= strlen(pos
) / 2;
587 if (ielen
> sizeof(ie
))
589 if (hexstr2bin(pos
, ie
, ielen
) < 0)
593 for (bss
= drv
->bss
; bss
; bss
= bss
->next
) {
594 if (bss
->ssid_len
== ssid_len
&&
595 memcmp(bss
->ssid
, ssid
, ssid_len
) == 0)
599 wpa_printf(MSG_DEBUG
, "%s: No matching SSID found from "
600 "configured BSSes", __func__
);
606 memcpy(&cli
->un
, from
, sizeof(cli
->un
));
607 cli
->unlen
= fromlen
;
608 cli
->next
= drv
->cli
;
610 wpa_hexdump_ascii(MSG_DEBUG
, "test_socket: ASSOC sun_path",
611 (const u8
*) cli
->un
.sun_path
,
612 cli
->unlen
- sizeof(cli
->un
.sun_family
));
614 snprintf(cmd
, sizeof(cmd
), "ASSOCRESP " MACSTR
" 0",
615 MAC2STR(bss
->bssid
));
616 sendto(drv
->test_socket
, cmd
, strlen(cmd
), 0,
617 (struct sockaddr
*) from
, fromlen
);
620 if (hostapd_notif_assoc(bss
->bss_ctx
, cli
->addr
, ie
, ielen
) < 0)
621 wpa_printf(MSG_DEBUG
, "test_driver: failed to add new STA");
626 static void test_driver_disassoc(struct wpa_driver_test_data
*drv
,
627 struct sockaddr_un
*from
, socklen_t fromlen
)
629 struct test_client_socket
*cli
;
631 cli
= test_driver_get_cli(drv
, from
, fromlen
);
636 hostapd_notif_disassoc(drv
->ctx
, cli
->addr
);
641 static void test_driver_eapol(struct wpa_driver_test_data
*drv
,
642 struct sockaddr_un
*from
, socklen_t fromlen
,
643 u8
*data
, size_t datalen
)
646 struct test_client_socket
*cli
;
648 const u8
*src
= NULL
;
651 /* Skip Ethernet header */
652 src
= data
+ ETH_ALEN
;
653 wpa_printf(MSG_DEBUG
, "test_driver: dst=" MACSTR
" src="
654 MACSTR
" proto=%04x",
655 MAC2STR(data
), MAC2STR(src
),
656 WPA_GET_BE16(data
+ 2 * ETH_ALEN
));
661 cli
= test_driver_get_cli(drv
, from
, fromlen
);
663 hostapd_eapol_receive(cli
->bss
->bss_ctx
, cli
->addr
, data
,
666 wpa_printf(MSG_DEBUG
, "test_socket: EAPOL from unknown "
671 wpa_supplicant_rx_eapol(drv
->ctx
, src
, data
, datalen
);
676 static void test_driver_ether(struct wpa_driver_test_data
*drv
,
677 struct sockaddr_un
*from
, socklen_t fromlen
,
678 u8
*data
, size_t datalen
)
680 struct l2_ethhdr
*eth
;
682 if (datalen
< sizeof(*eth
))
685 eth
= (struct l2_ethhdr
*) data
;
686 wpa_printf(MSG_DEBUG
, "test_driver: RX ETHER dst=" MACSTR
" src="
687 MACSTR
" proto=%04x",
688 MAC2STR(eth
->h_dest
), MAC2STR(eth
->h_source
),
689 be_to_host16(eth
->h_proto
));
691 #ifdef CONFIG_IEEE80211R
692 if (be_to_host16(eth
->h_proto
) == ETH_P_RRB
) {
693 union wpa_event_data ev
;
694 os_memset(&ev
, 0, sizeof(ev
));
695 ev
.ft_rrb_rx
.src
= eth
->h_source
;
696 ev
.ft_rrb_rx
.data
= data
+ sizeof(*eth
);
697 ev
.ft_rrb_rx
.data_len
= datalen
- sizeof(*eth
);
699 #endif /* CONFIG_IEEE80211R */
703 static void test_driver_mlme(struct wpa_driver_test_data
*drv
,
704 struct sockaddr_un
*from
, socklen_t fromlen
,
705 u8
*data
, size_t datalen
)
707 struct ieee80211_hdr
*hdr
;
709 union wpa_event_data event
;
711 hdr
= (struct ieee80211_hdr
*) data
;
713 if (test_driver_get_cli(drv
, from
, fromlen
) == NULL
&& datalen
>= 16) {
714 struct test_client_socket
*cli
;
715 cli
= os_zalloc(sizeof(*cli
));
718 wpa_printf(MSG_DEBUG
, "Adding client entry for " MACSTR
,
719 MAC2STR(hdr
->addr2
));
720 memcpy(cli
->addr
, hdr
->addr2
, ETH_ALEN
);
721 memcpy(&cli
->un
, from
, sizeof(cli
->un
));
722 cli
->unlen
= fromlen
;
723 cli
->next
= drv
->cli
;
727 wpa_hexdump(MSG_MSGDUMP
, "test_driver_mlme: received frame",
729 fc
= le_to_host16(hdr
->frame_control
);
730 if (WLAN_FC_GET_TYPE(fc
) != WLAN_FC_TYPE_MGMT
) {
731 wpa_printf(MSG_ERROR
, "%s: received non-mgmt frame",
736 os_memset(&event
, 0, sizeof(event
));
737 event
.rx_mgmt
.frame
= data
;
738 event
.rx_mgmt
.frame_len
= datalen
;
739 wpa_supplicant_event(drv
->ctx
, EVENT_RX_MGMT
, &event
);
743 static void test_driver_receive_unix(int sock
, void *eloop_ctx
, void *sock_ctx
)
745 struct wpa_driver_test_data
*drv
= eloop_ctx
;
748 struct sockaddr_un from
;
749 socklen_t fromlen
= sizeof(from
);
751 res
= recvfrom(sock
, buf
, sizeof(buf
) - 1, 0,
752 (struct sockaddr
*) &from
, &fromlen
);
754 perror("recvfrom(test_socket)");
759 wpa_printf(MSG_DEBUG
, "test_driver: received %u bytes", res
);
761 if (strncmp(buf
, "SCAN", 4) == 0) {
762 test_driver_scan(drv
, &from
, fromlen
, buf
+ 4);
763 } else if (strncmp(buf
, "ASSOC ", 6) == 0) {
764 test_driver_assoc(drv
, &from
, fromlen
, buf
+ 6);
765 } else if (strcmp(buf
, "DISASSOC") == 0) {
766 test_driver_disassoc(drv
, &from
, fromlen
);
767 } else if (strncmp(buf
, "EAPOL ", 6) == 0) {
768 test_driver_eapol(drv
, &from
, fromlen
, (u8
*) buf
+ 6,
770 } else if (strncmp(buf
, "ETHER ", 6) == 0) {
771 test_driver_ether(drv
, &from
, fromlen
, (u8
*) buf
+ 6,
773 } else if (strncmp(buf
, "MLME ", 5) == 0) {
774 test_driver_mlme(drv
, &from
, fromlen
, (u8
*) buf
+ 5, res
- 5);
776 wpa_hexdump_ascii(MSG_DEBUG
, "Unknown test_socket command",
782 static struct test_driver_bss
*
783 test_driver_get_bss(struct wpa_driver_test_data
*drv
, const char *ifname
)
785 struct test_driver_bss
*bss
;
787 for (bss
= drv
->bss
; bss
; bss
= bss
->next
) {
788 if (strcmp(bss
->ifname
, ifname
) == 0)
795 static int test_driver_set_generic_elem(const char *ifname
, void *priv
,
796 const u8
*elem
, size_t elem_len
)
798 struct wpa_driver_test_data
*drv
= priv
;
799 struct test_driver_bss
*bss
;
801 bss
= test_driver_get_bss(drv
, ifname
);
813 bss
->ie
= os_malloc(elem_len
);
814 if (bss
->ie
== NULL
) {
819 memcpy(bss
->ie
, elem
, elem_len
);
820 bss
->ielen
= elem_len
;
825 static int test_driver_set_wps_beacon_ie(const char *ifname
, void *priv
,
826 const u8
*ie
, size_t len
)
828 struct wpa_driver_test_data
*drv
= priv
;
829 struct test_driver_bss
*bss
;
831 wpa_hexdump(MSG_DEBUG
, "test_driver: Beacon WPS IE", ie
, len
);
832 bss
= test_driver_get_bss(drv
, ifname
);
836 os_free(bss
->wps_beacon_ie
);
839 bss
->wps_beacon_ie
= NULL
;
840 bss
->wps_beacon_ie_len
= 0;
844 bss
->wps_beacon_ie
= os_malloc(len
);
845 if (bss
->wps_beacon_ie
== NULL
) {
846 bss
->wps_beacon_ie_len
= 0;
850 memcpy(bss
->wps_beacon_ie
, ie
, len
);
851 bss
->wps_beacon_ie_len
= len
;
856 static int test_driver_set_wps_probe_resp_ie(const char *ifname
, void *priv
,
857 const u8
*ie
, size_t len
)
859 struct wpa_driver_test_data
*drv
= priv
;
860 struct test_driver_bss
*bss
;
862 wpa_hexdump(MSG_DEBUG
, "test_driver: ProbeResp WPS IE", ie
, len
);
863 bss
= test_driver_get_bss(drv
, ifname
);
867 os_free(bss
->wps_probe_resp_ie
);
870 bss
->wps_probe_resp_ie
= NULL
;
871 bss
->wps_probe_resp_ie_len
= 0;
875 bss
->wps_probe_resp_ie
= os_malloc(len
);
876 if (bss
->wps_probe_resp_ie
== NULL
) {
877 bss
->wps_probe_resp_ie_len
= 0;
881 memcpy(bss
->wps_probe_resp_ie
, ie
, len
);
882 bss
->wps_probe_resp_ie_len
= len
;
887 static int test_driver_sta_deauth(void *priv
, const u8
*own_addr
,
888 const u8
*addr
, int reason
)
890 struct wpa_driver_test_data
*drv
= priv
;
891 struct test_client_socket
*cli
;
893 if (drv
->test_socket
< 0)
898 if (memcmp(cli
->addr
, addr
, ETH_ALEN
) == 0)
906 return sendto(drv
->test_socket
, "DEAUTH", 6, 0,
907 (struct sockaddr
*) &cli
->un
, cli
->unlen
);
911 static int test_driver_sta_disassoc(void *priv
, const u8
*own_addr
,
912 const u8
*addr
, int reason
)
914 struct wpa_driver_test_data
*drv
= priv
;
915 struct test_client_socket
*cli
;
917 if (drv
->test_socket
< 0)
922 if (memcmp(cli
->addr
, addr
, ETH_ALEN
) == 0)
930 return sendto(drv
->test_socket
, "DISASSOC", 8, 0,
931 (struct sockaddr
*) &cli
->un
, cli
->unlen
);
935 static int test_driver_bss_add(void *priv
, const char *ifname
, const u8
*bssid
,
938 struct wpa_driver_test_data
*drv
= priv
;
939 struct test_driver_bss
*bss
;
941 wpa_printf(MSG_DEBUG
, "%s(ifname=%s bssid=" MACSTR
")",
942 __func__
, ifname
, MAC2STR(bssid
));
944 bss
= os_zalloc(sizeof(*bss
));
948 bss
->bss_ctx
= bss_ctx
;
949 os_strlcpy(bss
->ifname
, ifname
, IFNAMSIZ
);
950 memcpy(bss
->bssid
, bssid
, ETH_ALEN
);
952 bss
->next
= drv
->bss
;
959 static int test_driver_bss_remove(void *priv
, const char *ifname
)
961 struct wpa_driver_test_data
*drv
= priv
;
962 struct test_driver_bss
*bss
, *prev
;
963 struct test_client_socket
*cli
, *prev_c
;
965 wpa_printf(MSG_DEBUG
, "%s(ifname=%s)", __func__
, ifname
);
967 for (prev
= NULL
, bss
= drv
->bss
; bss
; prev
= bss
, bss
= bss
->next
) {
968 if (strcmp(bss
->ifname
, ifname
) != 0)
972 prev
->next
= bss
->next
;
974 drv
->bss
= bss
->next
;
976 for (prev_c
= NULL
, cli
= drv
->cli
; cli
;
977 prev_c
= cli
, cli
= cli
->next
) {
981 prev_c
->next
= cli
->next
;
983 drv
->cli
= cli
->next
;
988 test_driver_free_bss(bss
);
996 static int test_driver_if_add(const char *iface
, void *priv
,
997 enum wpa_driver_if_type type
, const char *ifname
,
998 const u8
*addr
, void *bss_ctx
)
1000 wpa_printf(MSG_DEBUG
, "%s(iface=%s type=%d ifname=%s bss_ctx=%p)",
1001 __func__
, iface
, type
, ifname
, bss_ctx
);
1002 if (type
== WPA_IF_AP_BSS
)
1003 return test_driver_bss_add(priv
, ifname
, addr
, bss_ctx
);
1008 static int test_driver_if_remove(void *priv
, enum wpa_driver_if_type type
,
1011 wpa_printf(MSG_DEBUG
, "%s(type=%d ifname=%s)", __func__
, type
, ifname
);
1012 if (type
== WPA_IF_AP_BSS
)
1013 return test_driver_bss_remove(priv
, ifname
);
1018 static int test_driver_valid_bss_mask(void *priv
, const u8
*addr
,
1025 static int test_driver_set_ssid(const char *ifname
, void *priv
, const u8
*buf
,
1028 struct wpa_driver_test_data
*drv
= priv
;
1029 struct test_driver_bss
*bss
;
1031 wpa_printf(MSG_DEBUG
, "%s(ifname=%s)", __func__
, ifname
);
1032 wpa_hexdump_ascii(MSG_DEBUG
, "test_driver_set_ssid: SSID", buf
, len
);
1034 for (bss
= drv
->bss
; bss
; bss
= bss
->next
) {
1035 if (strcmp(bss
->ifname
, ifname
) != 0)
1038 if (len
< 0 || (size_t) len
> sizeof(bss
->ssid
))
1041 memcpy(bss
->ssid
, buf
, len
);
1042 bss
->ssid_len
= len
;
1051 static int test_driver_set_privacy(const char *ifname
, void *priv
, int enabled
)
1053 struct wpa_driver_test_data
*drv
= priv
;
1054 struct test_driver_bss
*bss
;
1056 wpa_printf(MSG_DEBUG
, "%s(ifname=%s enabled=%d)",
1057 __func__
, ifname
, enabled
);
1059 for (bss
= drv
->bss
; bss
; bss
= bss
->next
) {
1060 if (strcmp(bss
->ifname
, ifname
) != 0)
1063 bss
->privacy
= enabled
;
1072 static int test_driver_set_sta_vlan(void *priv
, const u8
*addr
,
1073 const char *ifname
, int vlan_id
)
1075 wpa_printf(MSG_DEBUG
, "%s(addr=" MACSTR
" ifname=%s vlan_id=%d)",
1076 __func__
, MAC2STR(addr
), ifname
, vlan_id
);
1081 static int test_driver_sta_add(const char *ifname
, void *priv
,
1082 struct hostapd_sta_add_params
*params
)
1084 struct wpa_driver_test_data
*drv
= priv
;
1085 struct test_client_socket
*cli
;
1086 struct test_driver_bss
*bss
;
1088 wpa_printf(MSG_DEBUG
, "%s(ifname=%s addr=" MACSTR
" aid=%d "
1089 "capability=0x%x listen_interval=%d)",
1090 __func__
, ifname
, MAC2STR(params
->addr
), params
->aid
,
1091 params
->capability
, params
->listen_interval
);
1092 wpa_hexdump(MSG_DEBUG
, "test_driver_sta_add - supp_rates",
1093 params
->supp_rates
, params
->supp_rates_len
);
1097 if (os_memcmp(cli
->addr
, params
->addr
, ETH_ALEN
) == 0)
1102 wpa_printf(MSG_DEBUG
, "%s: no matching client entry",
1107 for (bss
= drv
->bss
; bss
; bss
= bss
->next
) {
1108 if (strcmp(ifname
, bss
->ifname
) == 0)
1112 wpa_printf(MSG_DEBUG
, "%s: No matching interface found from "
1113 "configured BSSes", __func__
);
1123 static void * test_driver_init(struct hostapd_data
*hapd
,
1124 struct wpa_init_params
*params
)
1126 struct wpa_driver_test_data
*drv
;
1127 struct sockaddr_un addr_un
;
1128 struct sockaddr_in addr_in
;
1129 struct sockaddr
*addr
;
1132 drv
= os_zalloc(sizeof(struct wpa_driver_test_data
));
1134 printf("Could not allocate memory for test driver data\n");
1138 drv
->bss
= os_zalloc(sizeof(*drv
->bss
));
1139 if (drv
->bss
== NULL
) {
1140 printf("Could not allocate memory for test driver BSS data\n");
1146 drv
->bss
->bss_ctx
= hapd
;
1148 /* Generate a MAC address to help testing with multiple APs */
1149 params
->own_addr
[0] = 0x02; /* locally administered */
1150 sha1_prf((const u8
*) params
->ifname
, strlen(params
->ifname
),
1151 "hostapd test bssid generation",
1152 params
->ssid
, params
->ssid_len
,
1153 params
->own_addr
+ 1, ETH_ALEN
- 1);
1155 os_strlcpy(drv
->bss
->ifname
, params
->ifname
, IFNAMSIZ
);
1156 memcpy(drv
->bss
->bssid
, params
->own_addr
, ETH_ALEN
);
1158 if (params
->test_socket
) {
1159 if (os_strlen(params
->test_socket
) >=
1160 sizeof(addr_un
.sun_path
)) {
1161 printf("Too long test_socket path\n");
1162 wpa_driver_test_deinit(drv
);
1165 if (strncmp(params
->test_socket
, "DIR:", 4) == 0) {
1166 size_t len
= strlen(params
->test_socket
) + 30;
1167 drv
->test_dir
= os_strdup(params
->test_socket
+ 4);
1168 drv
->own_socket_path
= os_malloc(len
);
1169 if (drv
->own_socket_path
) {
1170 snprintf(drv
->own_socket_path
, len
,
1172 params
->test_socket
+ 4,
1173 MAC2STR(params
->own_addr
));
1175 } else if (strncmp(params
->test_socket
, "UDP:", 4) == 0) {
1176 drv
->udp_port
= atoi(params
->test_socket
+ 4);
1178 drv
->own_socket_path
= os_strdup(params
->test_socket
);
1180 if (drv
->own_socket_path
== NULL
&& drv
->udp_port
== 0) {
1181 wpa_driver_test_deinit(drv
);
1185 drv
->test_socket
= socket(drv
->udp_port
? PF_INET
: PF_UNIX
,
1187 if (drv
->test_socket
< 0) {
1189 wpa_driver_test_deinit(drv
);
1193 if (drv
->udp_port
) {
1194 os_memset(&addr_in
, 0, sizeof(addr_in
));
1195 addr_in
.sin_family
= AF_INET
;
1196 addr_in
.sin_port
= htons(drv
->udp_port
);
1197 addr
= (struct sockaddr
*) &addr_in
;
1198 alen
= sizeof(addr_in
);
1200 os_memset(&addr_un
, 0, sizeof(addr_un
));
1201 addr_un
.sun_family
= AF_UNIX
;
1202 os_strlcpy(addr_un
.sun_path
, drv
->own_socket_path
,
1203 sizeof(addr_un
.sun_path
));
1204 addr
= (struct sockaddr
*) &addr_un
;
1205 alen
= sizeof(addr_un
);
1207 if (bind(drv
->test_socket
, addr
, alen
) < 0) {
1208 perror("bind(PF_UNIX)");
1209 close(drv
->test_socket
);
1210 if (drv
->own_socket_path
)
1211 unlink(drv
->own_socket_path
);
1212 wpa_driver_test_deinit(drv
);
1215 eloop_register_read_sock(drv
->test_socket
,
1216 test_driver_receive_unix
, drv
, NULL
);
1218 drv
->test_socket
= -1;
1224 static void wpa_driver_test_poll(void *eloop_ctx
, void *timeout_ctx
)
1226 struct wpa_driver_test_data
*drv
= eloop_ctx
;
1228 #ifdef DRIVER_TEST_UNIX
1229 if (drv
->associated
&& drv
->hostapd_addr_set
) {
1231 if (stat(drv
->hostapd_addr
.sun_path
, &st
) < 0) {
1232 wpa_printf(MSG_DEBUG
, "%s: lost connection to AP: %s",
1233 __func__
, strerror(errno
));
1234 drv
->associated
= 0;
1235 wpa_supplicant_event(drv
->ctx
, EVENT_DISASSOC
, NULL
);
1238 #endif /* DRIVER_TEST_UNIX */
1240 eloop_register_timeout(1, 0, wpa_driver_test_poll
, drv
, NULL
);
1244 static void wpa_driver_test_scan_timeout(void *eloop_ctx
, void *timeout_ctx
)
1246 wpa_printf(MSG_DEBUG
, "Scan timeout - try to get results");
1247 wpa_supplicant_event(timeout_ctx
, EVENT_SCAN_RESULTS
, NULL
);
1251 #ifdef DRIVER_TEST_UNIX
1252 static void wpa_driver_scan_dir(struct wpa_driver_test_data
*drv
,
1255 struct dirent
*dent
;
1257 struct sockaddr_un addr
;
1258 char cmd
[512], *pos
, *end
;
1261 dir
= opendir(path
);
1265 end
= cmd
+ sizeof(cmd
);
1267 ret
= os_snprintf(pos
, end
- pos
, "SCAN " MACSTR
,
1268 MAC2STR(drv
->own_addr
));
1269 if (ret
>= 0 && ret
< end
- pos
)
1271 if (drv
->probe_req_ie
) {
1272 ret
= os_snprintf(pos
, end
- pos
, " ");
1273 if (ret
>= 0 && ret
< end
- pos
)
1275 pos
+= wpa_snprintf_hex(pos
, end
- pos
, drv
->probe_req_ie
,
1276 drv
->probe_req_ie_len
);
1280 while ((dent
= readdir(dir
))) {
1281 if (os_strncmp(dent
->d_name
, "AP-", 3) != 0 &&
1282 os_strncmp(dent
->d_name
, "STA-", 4) != 0)
1284 if (drv
->own_socket_path
) {
1286 olen
= os_strlen(drv
->own_socket_path
);
1287 dlen
= os_strlen(dent
->d_name
);
1289 os_strcmp(dent
->d_name
,
1290 drv
->own_socket_path
+ olen
- dlen
) == 0)
1293 wpa_printf(MSG_DEBUG
, "%s: SCAN %s", __func__
, dent
->d_name
);
1295 os_memset(&addr
, 0, sizeof(addr
));
1296 addr
.sun_family
= AF_UNIX
;
1297 os_snprintf(addr
.sun_path
, sizeof(addr
.sun_path
), "%s/%s",
1298 path
, dent
->d_name
);
1300 if (sendto(drv
->test_socket
, cmd
, os_strlen(cmd
), 0,
1301 (struct sockaddr
*) &addr
, sizeof(addr
)) < 0) {
1302 perror("sendto(test_socket)");
1307 #endif /* DRIVER_TEST_UNIX */
1310 static int wpa_driver_test_scan(void *priv
,
1311 struct wpa_driver_scan_params
*params
)
1313 struct wpa_driver_test_data
*drv
= priv
;
1316 wpa_printf(MSG_DEBUG
, "%s: priv=%p", __func__
, priv
);
1318 os_free(drv
->probe_req_ie
);
1319 if (params
->extra_ies
) {
1320 drv
->probe_req_ie
= os_malloc(params
->extra_ies_len
);
1321 if (drv
->probe_req_ie
== NULL
) {
1322 drv
->probe_req_ie_len
= 0;
1325 os_memcpy(drv
->probe_req_ie
, params
->extra_ies
,
1326 params
->extra_ies_len
);
1327 drv
->probe_req_ie_len
= params
->extra_ies_len
;
1329 drv
->probe_req_ie
= NULL
;
1330 drv
->probe_req_ie_len
= 0;
1333 for (i
= 0; i
< params
->num_ssids
; i
++)
1334 wpa_hexdump(MSG_DEBUG
, "Scan SSID",
1335 params
->ssids
[i
].ssid
, params
->ssids
[i
].ssid_len
);
1336 wpa_hexdump(MSG_DEBUG
, "Scan extra IE(s)",
1337 params
->extra_ies
, params
->extra_ies_len
);
1339 drv
->num_scanres
= 0;
1341 #ifdef DRIVER_TEST_UNIX
1342 if (drv
->test_socket
>= 0 && drv
->test_dir
)
1343 wpa_driver_scan_dir(drv
, drv
->test_dir
);
1345 if (drv
->test_socket
>= 0 && drv
->hostapd_addr_set
&&
1346 sendto(drv
->test_socket
, "SCAN", 4, 0,
1347 (struct sockaddr
*) &drv
->hostapd_addr
,
1348 sizeof(drv
->hostapd_addr
)) < 0) {
1349 perror("sendto(test_socket)");
1351 #endif /* DRIVER_TEST_UNIX */
1353 if (drv
->test_socket
>= 0 && drv
->hostapd_addr_udp_set
&&
1354 sendto(drv
->test_socket
, "SCAN", 4, 0,
1355 (struct sockaddr
*) &drv
->hostapd_addr_udp
,
1356 sizeof(drv
->hostapd_addr_udp
)) < 0) {
1357 perror("sendto(test_socket)");
1360 eloop_cancel_timeout(wpa_driver_test_scan_timeout
, drv
, drv
->ctx
);
1361 eloop_register_timeout(1, 0, wpa_driver_test_scan_timeout
, drv
,
1367 static struct wpa_scan_results
* wpa_driver_test_get_scan_results2(void *priv
)
1369 struct wpa_driver_test_data
*drv
= priv
;
1370 struct wpa_scan_results
*res
;
1373 res
= os_zalloc(sizeof(*res
));
1377 res
->res
= os_zalloc(drv
->num_scanres
* sizeof(struct wpa_scan_res
*));
1378 if (res
->res
== NULL
) {
1383 for (i
= 0; i
< drv
->num_scanres
; i
++) {
1384 struct wpa_scan_res
*r
;
1385 if (drv
->scanres
[i
] == NULL
)
1387 r
= os_malloc(sizeof(*r
) + drv
->scanres
[i
]->ie_len
);
1390 os_memcpy(r
, drv
->scanres
[i
],
1391 sizeof(*r
) + drv
->scanres
[i
]->ie_len
);
1392 res
->res
[res
->num
++] = r
;
1399 static int wpa_driver_test_set_key(const char *ifname
, void *priv
, wpa_alg alg
,
1400 const u8
*addr
, int key_idx
, int set_tx
,
1401 const u8
*seq
, size_t seq_len
,
1402 const u8
*key
, size_t key_len
)
1404 wpa_printf(MSG_DEBUG
, "%s: ifname=%s priv=%p alg=%d key_idx=%d "
1406 __func__
, ifname
, priv
, alg
, key_idx
, set_tx
);
1408 wpa_printf(MSG_DEBUG
, " addr=" MACSTR
, MAC2STR(addr
));
1410 wpa_hexdump(MSG_DEBUG
, " seq", seq
, seq_len
);
1412 wpa_hexdump_key(MSG_DEBUG
, " key", key
, key_len
);
1417 static int wpa_driver_update_mode(struct wpa_driver_test_data
*drv
, int ap
)
1419 if (ap
&& !drv
->ap
) {
1420 wpa_driver_test_close_test_socket(drv
);
1421 wpa_driver_test_attach(drv
, drv
->test_dir
, 1);
1423 } else if (!ap
&& drv
->ap
) {
1424 wpa_driver_test_close_test_socket(drv
);
1425 wpa_driver_test_attach(drv
, drv
->test_dir
, 0);
1433 static int wpa_driver_test_associate(
1434 void *priv
, struct wpa_driver_associate_params
*params
)
1436 struct wpa_driver_test_data
*drv
= priv
;
1437 wpa_printf(MSG_DEBUG
, "%s: priv=%p freq=%d pairwise_suite=%d "
1438 "group_suite=%d key_mgmt_suite=%d auth_alg=%d mode=%d",
1439 __func__
, priv
, params
->freq
, params
->pairwise_suite
,
1440 params
->group_suite
, params
->key_mgmt_suite
,
1441 params
->auth_alg
, params
->mode
);
1442 if (params
->bssid
) {
1443 wpa_printf(MSG_DEBUG
, " bssid=" MACSTR
,
1444 MAC2STR(params
->bssid
));
1447 wpa_hexdump_ascii(MSG_DEBUG
, " ssid",
1448 params
->ssid
, params
->ssid_len
);
1450 if (params
->wpa_ie
) {
1451 wpa_hexdump(MSG_DEBUG
, " wpa_ie",
1452 params
->wpa_ie
, params
->wpa_ie_len
);
1453 drv
->assoc_wpa_ie_len
= params
->wpa_ie_len
;
1454 if (drv
->assoc_wpa_ie_len
> sizeof(drv
->assoc_wpa_ie
))
1455 drv
->assoc_wpa_ie_len
= sizeof(drv
->assoc_wpa_ie
);
1456 os_memcpy(drv
->assoc_wpa_ie
, params
->wpa_ie
,
1457 drv
->assoc_wpa_ie_len
);
1459 drv
->assoc_wpa_ie_len
= 0;
1461 wpa_driver_update_mode(drv
, params
->mode
== IEEE80211_MODE_AP
);
1463 drv
->ibss
= params
->mode
== IEEE80211_MODE_IBSS
;
1464 drv
->privacy
= params
->key_mgmt_suite
&
1465 (WPA_KEY_MGMT_IEEE8021X
|
1467 WPA_KEY_MGMT_WPA_NONE
|
1468 WPA_KEY_MGMT_FT_IEEE8021X
|
1469 WPA_KEY_MGMT_FT_PSK
|
1470 WPA_KEY_MGMT_IEEE8021X_SHA256
|
1471 WPA_KEY_MGMT_PSK_SHA256
);
1472 if (params
->wep_key_len
[params
->wep_tx_keyidx
])
1475 #ifdef DRIVER_TEST_UNIX
1476 if (drv
->test_dir
&& params
->bssid
&&
1477 params
->mode
!= IEEE80211_MODE_IBSS
) {
1478 os_memset(&drv
->hostapd_addr
, 0, sizeof(drv
->hostapd_addr
));
1479 drv
->hostapd_addr
.sun_family
= AF_UNIX
;
1480 os_snprintf(drv
->hostapd_addr
.sun_path
,
1481 sizeof(drv
->hostapd_addr
.sun_path
),
1483 drv
->test_dir
, MAC2STR(params
->bssid
));
1484 drv
->hostapd_addr_set
= 1;
1486 #endif /* DRIVER_TEST_UNIX */
1488 if (params
->mode
== IEEE80211_MODE_AP
) {
1489 struct test_driver_bss
*bss
;
1490 os_memcpy(drv
->ssid
, params
->ssid
, params
->ssid_len
);
1491 drv
->ssid_len
= params
->ssid_len
;
1493 test_driver_free_bsses(drv
);
1494 bss
= drv
->bss
= os_zalloc(sizeof(*drv
->bss
));
1497 os_memcpy(bss
->bssid
, drv
->own_addr
, ETH_ALEN
);
1498 os_memcpy(bss
->ssid
, params
->ssid
, params
->ssid_len
);
1499 bss
->ssid_len
= params
->ssid_len
;
1500 bss
->privacy
= drv
->privacy
;
1501 if (params
->wpa_ie
&& params
->wpa_ie_len
) {
1502 bss
->ie
= os_malloc(params
->wpa_ie_len
);
1504 os_memcpy(bss
->ie
, params
->wpa_ie
,
1505 params
->wpa_ie_len
);
1506 bss
->ielen
= params
->wpa_ie_len
;
1509 } else if (drv
->test_socket
>= 0 &&
1510 (drv
->hostapd_addr_set
|| drv
->hostapd_addr_udp_set
)) {
1511 char cmd
[200], *pos
, *end
;
1513 end
= cmd
+ sizeof(cmd
);
1515 ret
= os_snprintf(pos
, end
- pos
, "ASSOC " MACSTR
" ",
1516 MAC2STR(drv
->own_addr
));
1517 if (ret
>= 0 && ret
< end
- pos
)
1519 pos
+= wpa_snprintf_hex(pos
, end
- pos
, params
->ssid
,
1521 ret
= os_snprintf(pos
, end
- pos
, " ");
1522 if (ret
>= 0 && ret
< end
- pos
)
1524 pos
+= wpa_snprintf_hex(pos
, end
- pos
, params
->wpa_ie
,
1525 params
->wpa_ie_len
);
1527 #ifdef DRIVER_TEST_UNIX
1528 if (drv
->hostapd_addr_set
&&
1529 sendto(drv
->test_socket
, cmd
, os_strlen(cmd
), 0,
1530 (struct sockaddr
*) &drv
->hostapd_addr
,
1531 sizeof(drv
->hostapd_addr
)) < 0) {
1532 perror("sendto(test_socket)");
1535 #endif /* DRIVER_TEST_UNIX */
1536 if (drv
->hostapd_addr_udp_set
&&
1537 sendto(drv
->test_socket
, cmd
, os_strlen(cmd
), 0,
1538 (struct sockaddr
*) &drv
->hostapd_addr_udp
,
1539 sizeof(drv
->hostapd_addr_udp
)) < 0) {
1540 perror("sendto(test_socket)");
1544 os_memcpy(drv
->ssid
, params
->ssid
, params
->ssid_len
);
1545 drv
->ssid_len
= params
->ssid_len
;
1547 drv
->associated
= 1;
1548 if (params
->mode
== IEEE80211_MODE_IBSS
) {
1549 os_memcpy(drv
->ssid
, params
->ssid
, params
->ssid_len
);
1550 drv
->ssid_len
= params
->ssid_len
;
1552 os_memcpy(drv
->bssid
, params
->bssid
, ETH_ALEN
);
1554 os_get_random(drv
->bssid
, ETH_ALEN
);
1555 drv
->bssid
[0] &= ~0x01;
1556 drv
->bssid
[0] |= 0x02;
1559 wpa_supplicant_event(drv
->ctx
, EVENT_ASSOC
, NULL
);
1566 static int wpa_driver_test_get_bssid(void *priv
, u8
*bssid
)
1568 struct wpa_driver_test_data
*drv
= priv
;
1569 os_memcpy(bssid
, drv
->bssid
, ETH_ALEN
);
1574 static int wpa_driver_test_get_ssid(void *priv
, u8
*ssid
)
1576 struct wpa_driver_test_data
*drv
= priv
;
1577 os_memcpy(ssid
, drv
->ssid
, 32);
1578 return drv
->ssid_len
;
1582 static int wpa_driver_test_send_disassoc(struct wpa_driver_test_data
*drv
)
1584 #ifdef DRIVER_TEST_UNIX
1585 if (drv
->test_socket
>= 0 &&
1586 sendto(drv
->test_socket
, "DISASSOC", 8, 0,
1587 (struct sockaddr
*) &drv
->hostapd_addr
,
1588 sizeof(drv
->hostapd_addr
)) < 0) {
1589 perror("sendto(test_socket)");
1592 #endif /* DRIVER_TEST_UNIX */
1593 if (drv
->test_socket
>= 0 && drv
->hostapd_addr_udp_set
&&
1594 sendto(drv
->test_socket
, "DISASSOC", 8, 0,
1595 (struct sockaddr
*) &drv
->hostapd_addr_udp
,
1596 sizeof(drv
->hostapd_addr_udp
)) < 0) {
1597 perror("sendto(test_socket)");
1604 static int wpa_driver_test_deauthenticate(void *priv
, const u8
*addr
,
1607 struct wpa_driver_test_data
*drv
= priv
;
1608 wpa_printf(MSG_DEBUG
, "%s addr=" MACSTR
" reason_code=%d",
1609 __func__
, MAC2STR(addr
), reason_code
);
1610 os_memset(drv
->bssid
, 0, ETH_ALEN
);
1611 drv
->associated
= 0;
1612 wpa_supplicant_event(drv
->ctx
, EVENT_DISASSOC
, NULL
);
1613 return wpa_driver_test_send_disassoc(drv
);
1617 static int wpa_driver_test_disassociate(void *priv
, const u8
*addr
,
1620 struct wpa_driver_test_data
*drv
= priv
;
1621 wpa_printf(MSG_DEBUG
, "%s addr=" MACSTR
" reason_code=%d",
1622 __func__
, MAC2STR(addr
), reason_code
);
1623 os_memset(drv
->bssid
, 0, ETH_ALEN
);
1624 drv
->associated
= 0;
1625 wpa_supplicant_event(drv
->ctx
, EVENT_DISASSOC
, NULL
);
1626 return wpa_driver_test_send_disassoc(drv
);
1630 static void wpa_driver_test_scanresp(struct wpa_driver_test_data
*drv
,
1631 struct sockaddr
*from
,
1635 struct wpa_scan_res
*res
;
1636 const char *pos
, *pos2
;
1638 u8
*ie_pos
, *ie_start
, *ie_end
;
1639 #define MAX_IE_LEN 1000
1641 wpa_printf(MSG_DEBUG
, "test_driver: SCANRESP %s", data
);
1642 if (drv
->num_scanres
>= MAX_SCAN_RESULTS
) {
1643 wpa_printf(MSG_DEBUG
, "test_driver: No room for the new scan "
1648 /* SCANRESP BSSID SSID IEs */
1650 res
= os_zalloc(sizeof(*res
) + MAX_IE_LEN
);
1653 ie_start
= ie_pos
= (u8
*) (res
+ 1);
1654 ie_end
= ie_pos
+ MAX_IE_LEN
;
1656 if (hwaddr_aton(data
, res
->bssid
)) {
1657 wpa_printf(MSG_DEBUG
, "test_driver: invalid BSSID in scanres");
1665 pos2
= os_strchr(pos
, ' ');
1667 wpa_printf(MSG_DEBUG
, "test_driver: invalid SSID termination "
1672 len
= (pos2
- pos
) / 2;
1676 * Generate SSID IE from the SSID field since this IE is not included
1677 * in the main IE field.
1679 *ie_pos
++ = WLAN_EID_SSID
;
1681 if (hexstr2bin(pos
, ie_pos
, len
) < 0) {
1682 wpa_printf(MSG_DEBUG
, "test_driver: invalid SSID in scanres");
1689 pos2
= os_strchr(pos
, ' ');
1691 len
= os_strlen(pos
) / 2;
1693 len
= (pos2
- pos
) / 2;
1694 if ((int) len
> ie_end
- ie_pos
)
1695 len
= ie_end
- ie_pos
;
1696 if (hexstr2bin(pos
, ie_pos
, len
) < 0) {
1697 wpa_printf(MSG_DEBUG
, "test_driver: invalid IEs in scanres");
1702 res
->ie_len
= ie_pos
- ie_start
;
1708 if (os_strstr(pos
, "PRIVACY"))
1709 res
->caps
|= IEEE80211_CAP_PRIVACY
;
1710 if (os_strstr(pos
, "IBSS"))
1711 res
->caps
|= IEEE80211_CAP_IBSS
;
1714 os_free(drv
->scanres
[drv
->num_scanres
]);
1715 drv
->scanres
[drv
->num_scanres
++] = res
;
1719 static void wpa_driver_test_assocresp(struct wpa_driver_test_data
*drv
,
1720 struct sockaddr
*from
,
1724 /* ASSOCRESP BSSID <res> */
1725 if (hwaddr_aton(data
, drv
->bssid
)) {
1726 wpa_printf(MSG_DEBUG
, "test_driver: invalid BSSID in "
1729 if (drv
->use_associnfo
) {
1730 union wpa_event_data event
;
1731 os_memset(&event
, 0, sizeof(event
));
1732 event
.assoc_info
.req_ies
= drv
->assoc_wpa_ie
;
1733 event
.assoc_info
.req_ies_len
= drv
->assoc_wpa_ie_len
;
1734 wpa_supplicant_event(drv
->ctx
, EVENT_ASSOCINFO
, &event
);
1736 drv
->associated
= 1;
1737 wpa_supplicant_event(drv
->ctx
, EVENT_ASSOC
, NULL
);
1741 static void wpa_driver_test_disassoc(struct wpa_driver_test_data
*drv
,
1742 struct sockaddr
*from
,
1745 drv
->associated
= 0;
1746 wpa_supplicant_event(drv
->ctx
, EVENT_DISASSOC
, NULL
);
1750 static void wpa_driver_test_eapol(struct wpa_driver_test_data
*drv
,
1751 struct sockaddr
*from
,
1753 const u8
*data
, size_t data_len
)
1755 const u8
*src
= drv
->bssid
;
1757 if (data_len
> 14) {
1758 /* Skip Ethernet header */
1759 src
= data
+ ETH_ALEN
;
1764 wpa_supplicant_rx_eapol(drv
->ctx
, src
, data
, data_len
);
1765 #endif /* HOSTAPD */
1769 static void wpa_driver_test_mlme(struct wpa_driver_test_data
*drv
,
1770 struct sockaddr
*from
,
1772 const u8
*data
, size_t data_len
)
1774 #ifdef CONFIG_CLIENT_MLME
1775 struct ieee80211_rx_status rx_status
;
1776 os_memset(&rx_status
, 0, sizeof(rx_status
));
1777 wpa_supplicant_sta_rx(drv
->ctx
, data
, data_len
, &rx_status
);
1778 #endif /* CONFIG_CLIENT_MLME */
1782 static void wpa_driver_test_scan_cmd(struct wpa_driver_test_data
*drv
,
1783 struct sockaddr
*from
,
1785 const u8
*data
, size_t data_len
)
1787 char buf
[512], *pos
, *end
;
1790 /* data: optional [ STA-addr | ' ' | IEs(hex) ] */
1796 end
= buf
+ sizeof(buf
);
1798 /* reply: SCANRESP BSSID SSID IEs */
1799 ret
= snprintf(pos
, end
- pos
, "SCANRESP " MACSTR
" ",
1800 MAC2STR(drv
->bssid
));
1801 if (ret
< 0 || ret
>= end
- pos
)
1804 pos
+= wpa_snprintf_hex(pos
, end
- pos
,
1805 drv
->ssid
, drv
->ssid_len
);
1806 ret
= snprintf(pos
, end
- pos
, " ");
1807 if (ret
< 0 || ret
>= end
- pos
)
1810 pos
+= wpa_snprintf_hex(pos
, end
- pos
, drv
->assoc_wpa_ie
,
1811 drv
->assoc_wpa_ie_len
);
1814 ret
= snprintf(pos
, end
- pos
, " PRIVACY");
1815 if (ret
< 0 || ret
>= end
- pos
)
1820 ret
= snprintf(pos
, end
- pos
, " IBSS");
1821 if (ret
< 0 || ret
>= end
- pos
)
1825 sendto(drv
->test_socket
, buf
, pos
- buf
, 0,
1826 (struct sockaddr
*) from
, fromlen
);
1830 static void wpa_driver_test_receive_unix(int sock
, void *eloop_ctx
,
1833 struct wpa_driver_test_data
*drv
= eloop_ctx
;
1836 struct sockaddr_storage from
;
1837 socklen_t fromlen
= sizeof(from
);
1838 const size_t buflen
= 2000;
1841 test_driver_receive_unix(sock
, eloop_ctx
, sock_ctx
);
1845 buf
= os_malloc(buflen
);
1848 res
= recvfrom(sock
, buf
, buflen
- 1, 0,
1849 (struct sockaddr
*) &from
, &fromlen
);
1851 perror("recvfrom(test_socket)");
1857 wpa_printf(MSG_DEBUG
, "test_driver: received %u bytes", res
);
1859 if (os_strncmp(buf
, "SCANRESP ", 9) == 0) {
1860 wpa_driver_test_scanresp(drv
, (struct sockaddr
*) &from
,
1862 } else if (os_strncmp(buf
, "ASSOCRESP ", 10) == 0) {
1863 wpa_driver_test_assocresp(drv
, (struct sockaddr
*) &from
,
1865 } else if (os_strcmp(buf
, "DISASSOC") == 0) {
1866 wpa_driver_test_disassoc(drv
, (struct sockaddr
*) &from
,
1868 } else if (os_strcmp(buf
, "DEAUTH") == 0) {
1869 wpa_driver_test_disassoc(drv
, (struct sockaddr
*) &from
,
1871 } else if (os_strncmp(buf
, "EAPOL ", 6) == 0) {
1872 wpa_driver_test_eapol(drv
, (struct sockaddr
*) &from
, fromlen
,
1873 (const u8
*) buf
+ 6, res
- 6);
1874 } else if (os_strncmp(buf
, "MLME ", 5) == 0) {
1875 wpa_driver_test_mlme(drv
, (struct sockaddr
*) &from
, fromlen
,
1876 (const u8
*) buf
+ 5, res
- 5);
1877 } else if (os_strncmp(buf
, "SCAN ", 5) == 0) {
1878 wpa_driver_test_scan_cmd(drv
, (struct sockaddr
*) &from
,
1880 (const u8
*) buf
+ 5, res
- 5);
1882 wpa_hexdump_ascii(MSG_DEBUG
, "Unknown test_socket command",
1889 static void * wpa_driver_test_init2(void *ctx
, const char *ifname
,
1892 struct wpa_driver_test_data
*drv
;
1894 drv
= os_zalloc(sizeof(*drv
));
1897 drv
->global
= global_priv
;
1899 drv
->test_socket
= -1;
1901 /* Set dummy BSSID and SSID for testing. */
1902 drv
->bssid
[0] = 0x02;
1903 drv
->bssid
[1] = 0x00;
1904 drv
->bssid
[2] = 0x00;
1905 drv
->bssid
[3] = 0x00;
1906 drv
->bssid
[4] = 0x00;
1907 drv
->bssid
[5] = 0x01;
1908 os_memcpy(drv
->ssid
, "test", 5);
1911 /* Generate a MAC address to help testing with multiple STAs */
1912 drv
->own_addr
[0] = 0x02; /* locally administered */
1913 sha1_prf((const u8
*) ifname
, os_strlen(ifname
),
1914 "wpa_supplicant test mac addr generation",
1915 NULL
, 0, drv
->own_addr
+ 1, ETH_ALEN
- 1);
1916 eloop_register_timeout(1, 0, wpa_driver_test_poll
, drv
, NULL
);
1922 static void wpa_driver_test_close_test_socket(struct wpa_driver_test_data
*drv
)
1924 if (drv
->test_socket
>= 0) {
1925 eloop_unregister_read_sock(drv
->test_socket
);
1926 close(drv
->test_socket
);
1927 drv
->test_socket
= -1;
1930 if (drv
->own_socket_path
) {
1931 unlink(drv
->own_socket_path
);
1932 os_free(drv
->own_socket_path
);
1933 drv
->own_socket_path
= NULL
;
1938 static void wpa_driver_test_deinit(void *priv
)
1940 struct wpa_driver_test_data
*drv
= priv
;
1941 struct test_client_socket
*cli
, *prev
;
1952 /* There should be only one BSS remaining at this point. */
1953 if (drv
->bss
== NULL
)
1954 wpa_printf(MSG_ERROR
, "%s: drv->bss == NULL", __func__
);
1955 else if (drv
->bss
->next
)
1956 wpa_printf(MSG_ERROR
, "%s: drv->bss->next != NULL", __func__
);
1957 #endif /* HOSTAPD */
1959 test_driver_free_bsses(drv
);
1961 wpa_driver_test_close_test_socket(drv
);
1962 eloop_cancel_timeout(wpa_driver_test_scan_timeout
, drv
, drv
->ctx
);
1963 eloop_cancel_timeout(wpa_driver_test_poll
, drv
, NULL
);
1964 os_free(drv
->test_dir
);
1965 for (i
= 0; i
< MAX_SCAN_RESULTS
; i
++)
1966 os_free(drv
->scanres
[i
]);
1967 os_free(drv
->probe_req_ie
);
1972 static int wpa_driver_test_attach(struct wpa_driver_test_data
*drv
,
1973 const char *dir
, int ap
)
1975 #ifdef DRIVER_TEST_UNIX
1976 static unsigned int counter
= 0;
1977 struct sockaddr_un addr
;
1980 os_free(drv
->own_socket_path
);
1982 len
= os_strlen(dir
) + 30;
1983 drv
->own_socket_path
= os_malloc(len
);
1984 if (drv
->own_socket_path
== NULL
)
1986 os_snprintf(drv
->own_socket_path
, len
, "%s/%s-" MACSTR
,
1987 dir
, ap
? "AP" : "STA", MAC2STR(drv
->own_addr
));
1989 drv
->own_socket_path
= os_malloc(100);
1990 if (drv
->own_socket_path
== NULL
)
1992 os_snprintf(drv
->own_socket_path
, 100,
1993 "/tmp/wpa_supplicant_test-%d-%d",
1994 getpid(), counter
++);
1997 drv
->test_socket
= socket(PF_UNIX
, SOCK_DGRAM
, 0);
1998 if (drv
->test_socket
< 0) {
1999 perror("socket(PF_UNIX)");
2000 os_free(drv
->own_socket_path
);
2001 drv
->own_socket_path
= NULL
;
2005 os_memset(&addr
, 0, sizeof(addr
));
2006 addr
.sun_family
= AF_UNIX
;
2007 os_strlcpy(addr
.sun_path
, drv
->own_socket_path
, sizeof(addr
.sun_path
));
2008 if (bind(drv
->test_socket
, (struct sockaddr
*) &addr
,
2009 sizeof(addr
)) < 0) {
2010 perror("bind(PF_UNIX)");
2011 close(drv
->test_socket
);
2012 unlink(drv
->own_socket_path
);
2013 os_free(drv
->own_socket_path
);
2014 drv
->own_socket_path
= NULL
;
2018 eloop_register_read_sock(drv
->test_socket
,
2019 wpa_driver_test_receive_unix
, drv
, NULL
);
2022 #else /* DRIVER_TEST_UNIX */
2024 #endif /* DRIVER_TEST_UNIX */
2028 static int wpa_driver_test_attach_udp(struct wpa_driver_test_data
*drv
,
2033 pos
= os_strchr(dst
, ':');
2037 wpa_printf(MSG_DEBUG
, "%s: addr=%s port=%s", __func__
, dst
, pos
);
2039 drv
->test_socket
= socket(PF_INET
, SOCK_DGRAM
, 0);
2040 if (drv
->test_socket
< 0) {
2041 perror("socket(PF_INET)");
2045 os_memset(&drv
->hostapd_addr_udp
, 0, sizeof(drv
->hostapd_addr_udp
));
2046 drv
->hostapd_addr_udp
.sin_family
= AF_INET
;
2047 #if defined(CONFIG_NATIVE_WINDOWS) || defined(CONFIG_ANSI_C_EXTRA)
2051 sscanf(dst
, "%d.%d.%d.%d", &a
[0], &a
[1], &a
[2], &a
[3]);
2052 pos
= (u8
*) &drv
->hostapd_addr_udp
.sin_addr
;
2058 #else /* CONFIG_NATIVE_WINDOWS or CONFIG_ANSI_C_EXTRA */
2059 inet_aton(dst
, &drv
->hostapd_addr_udp
.sin_addr
);
2060 #endif /* CONFIG_NATIVE_WINDOWS or CONFIG_ANSI_C_EXTRA */
2061 drv
->hostapd_addr_udp
.sin_port
= htons(atoi(pos
));
2063 drv
->hostapd_addr_udp_set
= 1;
2065 eloop_register_read_sock(drv
->test_socket
,
2066 wpa_driver_test_receive_unix
, drv
, NULL
);
2072 static int wpa_driver_test_set_param(void *priv
, const char *param
)
2074 struct wpa_driver_test_data
*drv
= priv
;
2077 wpa_printf(MSG_DEBUG
, "%s: param='%s'", __func__
, param
);
2081 wpa_driver_test_close_test_socket(drv
);
2083 #ifdef DRIVER_TEST_UNIX
2084 pos
= os_strstr(param
, "test_socket=");
2090 pos2
= os_strchr(pos
, ' ');
2094 len
= os_strlen(pos
);
2095 if (len
> sizeof(drv
->hostapd_addr
.sun_path
))
2097 os_memset(&drv
->hostapd_addr
, 0, sizeof(drv
->hostapd_addr
));
2098 drv
->hostapd_addr
.sun_family
= AF_UNIX
;
2099 os_memcpy(drv
->hostapd_addr
.sun_path
, pos
, len
);
2100 drv
->hostapd_addr_set
= 1;
2102 #endif /* DRIVER_TEST_UNIX */
2104 pos
= os_strstr(param
, "test_dir=");
2107 os_free(drv
->test_dir
);
2108 drv
->test_dir
= os_strdup(pos
+ 9);
2109 if (drv
->test_dir
== NULL
)
2111 end
= os_strchr(drv
->test_dir
, ' ');
2114 if (wpa_driver_test_attach(drv
, drv
->test_dir
, 0))
2117 pos
= os_strstr(param
, "test_udp=");
2120 dst
= os_strdup(pos
+ 9);
2123 epos
= os_strchr(dst
, ' ');
2126 if (wpa_driver_test_attach_udp(drv
, dst
))
2129 } else if (wpa_driver_test_attach(drv
, NULL
, 0))
2133 if (os_strstr(param
, "use_associnfo=1")) {
2134 wpa_printf(MSG_DEBUG
, "test_driver: Use AssocInfo events");
2135 drv
->use_associnfo
= 1;
2138 #ifdef CONFIG_CLIENT_MLME
2139 if (os_strstr(param
, "use_mlme=1")) {
2140 wpa_printf(MSG_DEBUG
, "test_driver: Use internal MLME");
2143 #endif /* CONFIG_CLIENT_MLME */
2149 static const u8
* wpa_driver_test_get_mac_addr(void *priv
)
2151 struct wpa_driver_test_data
*drv
= priv
;
2152 wpa_printf(MSG_DEBUG
, "%s", __func__
);
2153 return drv
->own_addr
;
2157 static int wpa_driver_test_send_eapol(void *priv
, const u8
*dest
, u16 proto
,
2158 const u8
*data
, size_t data_len
)
2160 struct wpa_driver_test_data
*drv
= priv
;
2163 struct l2_ethhdr eth
;
2164 struct sockaddr
*addr
;
2166 #ifdef DRIVER_TEST_UNIX
2167 struct sockaddr_un addr_un
;
2168 #endif /* DRIVER_TEST_UNIX */
2170 wpa_hexdump(MSG_MSGDUMP
, "test_send_eapol TX frame", data
, data_len
);
2172 os_memset(ð
, 0, sizeof(eth
));
2173 os_memcpy(eth
.h_dest
, dest
, ETH_ALEN
);
2174 os_memcpy(eth
.h_source
, drv
->own_addr
, ETH_ALEN
);
2175 eth
.h_proto
= host_to_be16(proto
);
2177 msg_len
= 6 + sizeof(eth
) + data_len
;
2178 msg
= os_malloc(msg_len
);
2181 os_memcpy(msg
, "EAPOL ", 6);
2182 os_memcpy(msg
+ 6, ð
, sizeof(eth
));
2183 os_memcpy(msg
+ 6 + sizeof(eth
), data
, data_len
);
2185 if (os_memcmp(dest
, drv
->bssid
, ETH_ALEN
) == 0 ||
2186 drv
->test_dir
== NULL
) {
2187 if (drv
->hostapd_addr_udp_set
) {
2188 addr
= (struct sockaddr
*) &drv
->hostapd_addr_udp
;
2189 alen
= sizeof(drv
->hostapd_addr_udp
);
2191 #ifdef DRIVER_TEST_UNIX
2192 addr
= (struct sockaddr
*) &drv
->hostapd_addr
;
2193 alen
= sizeof(drv
->hostapd_addr
);
2194 #else /* DRIVER_TEST_UNIX */
2197 #endif /* DRIVER_TEST_UNIX */
2200 #ifdef DRIVER_TEST_UNIX
2202 os_memset(&addr_un
, 0, sizeof(addr_un
));
2203 addr_un
.sun_family
= AF_UNIX
;
2204 os_snprintf(addr_un
.sun_path
, sizeof(addr_un
.sun_path
),
2205 "%s/STA-" MACSTR
, drv
->test_dir
, MAC2STR(dest
));
2206 if (stat(addr_un
.sun_path
, &st
) < 0) {
2207 os_snprintf(addr_un
.sun_path
, sizeof(addr_un
.sun_path
),
2209 drv
->test_dir
, MAC2STR(dest
));
2211 addr
= (struct sockaddr
*) &addr_un
;
2212 alen
= sizeof(addr_un
);
2213 #else /* DRIVER_TEST_UNIX */
2216 #endif /* DRIVER_TEST_UNIX */
2219 if (sendto(drv
->test_socket
, msg
, msg_len
, 0, addr
, alen
) < 0) {
2220 perror("sendmsg(test_socket)");
2230 static int wpa_driver_test_get_capa(void *priv
, struct wpa_driver_capa
*capa
)
2232 struct wpa_driver_test_data
*drv
= priv
;
2233 os_memset(capa
, 0, sizeof(*capa
));
2234 capa
->key_mgmt
= WPA_DRIVER_CAPA_KEY_MGMT_WPA
|
2235 WPA_DRIVER_CAPA_KEY_MGMT_WPA2
|
2236 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK
|
2237 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK
|
2238 WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE
|
2239 WPA_DRIVER_CAPA_KEY_MGMT_FT
|
2240 WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK
;
2241 capa
->enc
= WPA_DRIVER_CAPA_ENC_WEP40
|
2242 WPA_DRIVER_CAPA_ENC_WEP104
|
2243 WPA_DRIVER_CAPA_ENC_TKIP
|
2244 WPA_DRIVER_CAPA_ENC_CCMP
;
2245 capa
->auth
= WPA_DRIVER_AUTH_OPEN
|
2246 WPA_DRIVER_AUTH_SHARED
|
2247 WPA_DRIVER_AUTH_LEAP
;
2249 capa
->flags
|= WPA_DRIVER_FLAGS_USER_SPACE_MLME
;
2250 capa
->flags
|= WPA_DRIVER_FLAGS_AP
;
2251 capa
->max_scan_ssids
= 2;
2257 static int wpa_driver_test_mlme_setprotection(void *priv
, const u8
*addr
,
2261 wpa_printf(MSG_DEBUG
, "%s: protect_type=%d key_type=%d",
2262 __func__
, protect_type
, key_type
);
2265 wpa_printf(MSG_DEBUG
, "%s: addr=" MACSTR
,
2266 __func__
, MAC2STR(addr
));
2273 static int wpa_driver_test_set_channel(void *priv
, hostapd_hw_mode phymode
,
2276 wpa_printf(MSG_DEBUG
, "%s: phymode=%d chan=%d freq=%d",
2277 __func__
, phymode
, chan
, freq
);
2282 static int wpa_driver_test_mlme_add_sta(void *priv
, const u8
*addr
,
2283 const u8
*supp_rates
,
2284 size_t supp_rates_len
)
2286 wpa_printf(MSG_DEBUG
, "%s: addr=" MACSTR
, __func__
, MAC2STR(addr
));
2291 static int wpa_driver_test_mlme_remove_sta(void *priv
, const u8
*addr
)
2293 wpa_printf(MSG_DEBUG
, "%s: addr=" MACSTR
, __func__
, MAC2STR(addr
));
2298 static int wpa_driver_test_set_ssid(void *priv
, const u8
*ssid
,
2301 wpa_printf(MSG_DEBUG
, "%s", __func__
);
2306 static int wpa_driver_test_set_bssid(void *priv
, const u8
*bssid
)
2308 wpa_printf(MSG_DEBUG
, "%s: bssid=" MACSTR
, __func__
, MAC2STR(bssid
));
2313 static void * wpa_driver_test_global_init(void)
2315 struct wpa_driver_test_global
*global
;
2317 global
= os_zalloc(sizeof(*global
));
2322 static void wpa_driver_test_global_deinit(void *priv
)
2324 struct wpa_driver_test_global
*global
= priv
;
2329 static struct wpa_interface_info
*
2330 wpa_driver_test_get_interfaces(void *global_priv
)
2332 /* struct wpa_driver_test_global *global = priv; */
2333 struct wpa_interface_info
*iface
;
2335 iface
= os_zalloc(sizeof(*iface
));
2338 iface
->ifname
= os_strdup("sta0");
2339 iface
->desc
= os_strdup("test interface 0");
2340 iface
->drv_name
= "test";
2341 iface
->next
= os_zalloc(sizeof(*iface
));
2343 iface
->next
->ifname
= os_strdup("sta1");
2344 iface
->next
->desc
= os_strdup("test interface 1");
2345 iface
->next
->drv_name
= "test";
2352 static struct hostapd_hw_modes
*
2353 wpa_driver_test_get_hw_feature_data(void *priv
, u16
*num_modes
, u16
*flags
)
2355 struct hostapd_hw_modes
*modes
;
2359 modes
= os_zalloc(*num_modes
* sizeof(struct hostapd_hw_modes
));
2362 modes
[0].mode
= HOSTAPD_MODE_IEEE80211G
;
2363 modes
[0].num_channels
= 1;
2364 modes
[0].num_rates
= 1;
2365 modes
[0].channels
= os_zalloc(sizeof(struct hostapd_channel_data
));
2366 modes
[0].rates
= os_zalloc(sizeof(int));
2367 if (modes
[0].channels
== NULL
|| modes
[0].rates
== NULL
)
2369 modes
[0].channels
[0].chan
= 1;
2370 modes
[0].channels
[0].freq
= 2412;
2371 modes
[0].channels
[0].flag
= 0;
2372 modes
[0].rates
[0] = 10;
2374 modes
[1].mode
= HOSTAPD_MODE_IEEE80211B
;
2375 modes
[1].num_channels
= 1;
2376 modes
[1].num_rates
= 1;
2377 modes
[1].channels
= os_zalloc(sizeof(struct hostapd_channel_data
));
2378 modes
[1].rates
= os_zalloc(sizeof(int));
2379 if (modes
[1].channels
== NULL
|| modes
[1].rates
== NULL
)
2381 modes
[1].channels
[0].chan
= 1;
2382 modes
[1].channels
[0].freq
= 2412;
2383 modes
[1].channels
[0].flag
= 0;
2384 modes
[1].rates
[0] = 10;
2386 modes
[2].mode
= HOSTAPD_MODE_IEEE80211A
;
2387 modes
[2].num_channels
= 1;
2388 modes
[2].num_rates
= 1;
2389 modes
[2].channels
= os_zalloc(sizeof(struct hostapd_channel_data
));
2390 modes
[2].rates
= os_zalloc(sizeof(int));
2391 if (modes
[2].channels
== NULL
|| modes
[2].rates
== NULL
)
2393 modes
[2].channels
[0].chan
= 60;
2394 modes
[2].channels
[0].freq
= 5300;
2395 modes
[2].channels
[0].flag
= 0;
2396 modes
[2].rates
[0] = 60;
2403 for (i
= 0; i
< *num_modes
; i
++) {
2404 os_free(modes
[i
].channels
);
2405 os_free(modes
[i
].rates
);
2413 const struct wpa_driver_ops wpa_driver_test_ops
= {
2415 "wpa_supplicant test driver",
2416 .hapd_init
= test_driver_init
,
2417 .hapd_deinit
= wpa_driver_test_deinit
,
2418 .hapd_send_eapol
= test_driver_send_eapol
,
2419 .send_mlme
= wpa_driver_test_send_mlme
,
2420 .set_generic_elem
= test_driver_set_generic_elem
,
2421 .sta_deauth
= test_driver_sta_deauth
,
2422 .sta_disassoc
= test_driver_sta_disassoc
,
2423 .get_hw_feature_data
= wpa_driver_test_get_hw_feature_data
,
2424 .if_add
= test_driver_if_add
,
2425 .if_remove
= test_driver_if_remove
,
2426 .valid_bss_mask
= test_driver_valid_bss_mask
,
2427 .hapd_set_ssid
= test_driver_set_ssid
,
2428 .set_privacy
= test_driver_set_privacy
,
2429 .set_sta_vlan
= test_driver_set_sta_vlan
,
2430 .sta_add
= test_driver_sta_add
,
2431 .send_ether
= test_driver_send_ether
,
2432 .set_wps_beacon_ie
= test_driver_set_wps_beacon_ie
,
2433 .set_wps_probe_resp_ie
= test_driver_set_wps_probe_resp_ie
,
2434 .get_bssid
= wpa_driver_test_get_bssid
,
2435 .get_ssid
= wpa_driver_test_get_ssid
,
2436 .set_key
= wpa_driver_test_set_key
,
2437 .deinit
= wpa_driver_test_deinit
,
2438 .set_param
= wpa_driver_test_set_param
,
2439 .deauthenticate
= wpa_driver_test_deauthenticate
,
2440 .disassociate
= wpa_driver_test_disassociate
,
2441 .associate
= wpa_driver_test_associate
,
2442 .get_capa
= wpa_driver_test_get_capa
,
2443 .get_mac_addr
= wpa_driver_test_get_mac_addr
,
2444 .send_eapol
= wpa_driver_test_send_eapol
,
2445 .mlme_setprotection
= wpa_driver_test_mlme_setprotection
,
2446 .set_channel
= wpa_driver_test_set_channel
,
2447 .set_ssid
= wpa_driver_test_set_ssid
,
2448 .set_bssid
= wpa_driver_test_set_bssid
,
2449 .mlme_add_sta
= wpa_driver_test_mlme_add_sta
,
2450 .mlme_remove_sta
= wpa_driver_test_mlme_remove_sta
,
2451 .get_scan_results2
= wpa_driver_test_get_scan_results2
,
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
,