2 * WPA Supplicant - testing driver interface
3 * Copyright (c) 2004-2007, 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.
22 #include "l2_packet/l2_packet.h"
25 #include "ieee802_11_defs.h"
28 struct wpa_driver_test_data
{
30 u8 own_addr
[ETH_ALEN
];
32 struct sockaddr_un hostapd_addr
;
34 char *own_socket_path
;
39 #define MAX_SCAN_RESULTS 30
40 struct wpa_scan_res
*scanres
[MAX_SCAN_RESULTS
];
44 size_t assoc_wpa_ie_len
;
50 static void wpa_driver_test_poll(void *eloop_ctx
, void *timeout_ctx
)
52 struct wpa_driver_test_data
*drv
= eloop_ctx
;
54 if (drv
->associated
&& drv
->hostapd_addr_set
) {
56 if (stat(drv
->hostapd_addr
.sun_path
, &st
) < 0) {
57 wpa_printf(MSG_DEBUG
, "%s: lost connection to AP: %s",
58 __func__
, strerror(errno
));
60 wpa_supplicant_event(drv
->ctx
, EVENT_DISASSOC
, NULL
);
64 eloop_register_timeout(1, 0, wpa_driver_test_poll
, drv
, NULL
);
68 static int wpa_driver_test_set_wpa(void *priv
, int enabled
)
70 wpa_printf(MSG_DEBUG
, "%s: enabled=%d", __func__
, enabled
);
75 static void wpa_driver_test_scan_timeout(void *eloop_ctx
, void *timeout_ctx
)
77 wpa_printf(MSG_DEBUG
, "Scan timeout - try to get results");
78 wpa_supplicant_event(timeout_ctx
, EVENT_SCAN_RESULTS
, NULL
);
82 static void wpa_driver_scan_dir(struct wpa_driver_test_data
*drv
,
87 struct sockaddr_un addr
;
93 while ((dent
= readdir(dir
))) {
94 if (os_strncmp(dent
->d_name
, "AP-", 3) != 0)
96 wpa_printf(MSG_DEBUG
, "%s: SCAN %s", __func__
, dent
->d_name
);
98 os_memset(&addr
, 0, sizeof(addr
));
99 addr
.sun_family
= AF_UNIX
;
100 os_snprintf(addr
.sun_path
, sizeof(addr
.sun_path
), "%s/%s",
103 if (sendto(drv
->test_socket
, "SCAN", 4, 0,
104 (struct sockaddr
*) &addr
, sizeof(addr
)) < 0) {
105 perror("sendto(test_socket)");
112 static int wpa_driver_test_scan(void *priv
, const u8
*ssid
, size_t ssid_len
)
114 struct wpa_driver_test_data
*drv
= priv
;
115 wpa_printf(MSG_DEBUG
, "%s: priv=%p", __func__
, priv
);
117 drv
->num_scanres
= 0;
119 if (drv
->test_socket
>= 0 && drv
->test_dir
)
120 wpa_driver_scan_dir(drv
, drv
->test_dir
);
122 if (drv
->test_socket
>= 0 && drv
->hostapd_addr_set
&&
123 sendto(drv
->test_socket
, "SCAN", 4, 0,
124 (struct sockaddr
*) &drv
->hostapd_addr
,
125 sizeof(drv
->hostapd_addr
)) < 0) {
126 perror("sendto(test_socket)");
129 eloop_cancel_timeout(wpa_driver_test_scan_timeout
, drv
, drv
->ctx
);
130 eloop_register_timeout(1, 0, wpa_driver_test_scan_timeout
, drv
,
136 static struct wpa_scan_results
* wpa_driver_test_get_scan_results2(void *priv
)
138 struct wpa_driver_test_data
*drv
= priv
;
139 struct wpa_scan_results
*res
;
142 res
= os_zalloc(sizeof(*res
));
146 res
->res
= os_zalloc(drv
->num_scanres
* sizeof(struct wpa_scan_res
*));
147 if (res
->res
== NULL
) {
152 for (i
= 0; i
< drv
->num_scanres
; i
++) {
153 struct wpa_scan_res
*r
;
154 if (drv
->scanres
[i
] == NULL
)
156 r
= os_malloc(sizeof(*r
) + drv
->scanres
[i
]->ie_len
);
159 os_memcpy(r
, drv
->scanres
[i
],
160 sizeof(*r
) + drv
->scanres
[i
]->ie_len
);
161 res
->res
[res
->num
++] = r
;
168 static int wpa_driver_test_set_key(void *priv
, wpa_alg alg
, const u8
*addr
,
169 int key_idx
, int set_tx
,
170 const u8
*seq
, size_t seq_len
,
171 const u8
*key
, size_t key_len
)
173 wpa_printf(MSG_DEBUG
, "%s: priv=%p alg=%d key_idx=%d set_tx=%d",
174 __func__
, priv
, alg
, key_idx
, set_tx
);
176 wpa_printf(MSG_DEBUG
, " addr=" MACSTR
, MAC2STR(addr
));
179 wpa_hexdump(MSG_DEBUG
, " seq", seq
, seq_len
);
182 wpa_hexdump(MSG_DEBUG
, " key", key
, key_len
);
188 static int wpa_driver_test_associate(
189 void *priv
, struct wpa_driver_associate_params
*params
)
191 struct wpa_driver_test_data
*drv
= priv
;
192 wpa_printf(MSG_DEBUG
, "%s: priv=%p freq=%d pairwise_suite=%d "
193 "group_suite=%d key_mgmt_suite=%d auth_alg=%d mode=%d",
194 __func__
, priv
, params
->freq
, params
->pairwise_suite
,
195 params
->group_suite
, params
->key_mgmt_suite
,
196 params
->auth_alg
, params
->mode
);
198 wpa_printf(MSG_DEBUG
, " bssid=" MACSTR
,
199 MAC2STR(params
->bssid
));
202 wpa_hexdump_ascii(MSG_DEBUG
, " ssid",
203 params
->ssid
, params
->ssid_len
);
205 if (params
->wpa_ie
) {
206 wpa_hexdump(MSG_DEBUG
, " wpa_ie",
207 params
->wpa_ie
, params
->wpa_ie_len
);
208 drv
->assoc_wpa_ie_len
= params
->wpa_ie_len
;
209 if (drv
->assoc_wpa_ie_len
> sizeof(drv
->assoc_wpa_ie
))
210 drv
->assoc_wpa_ie_len
= sizeof(drv
->assoc_wpa_ie
);
211 os_memcpy(drv
->assoc_wpa_ie
, params
->wpa_ie
,
212 drv
->assoc_wpa_ie_len
);
214 drv
->assoc_wpa_ie_len
= 0;
216 if (drv
->test_dir
&& params
->bssid
) {
217 os_memset(&drv
->hostapd_addr
, 0, sizeof(drv
->hostapd_addr
));
218 drv
->hostapd_addr
.sun_family
= AF_UNIX
;
219 os_snprintf(drv
->hostapd_addr
.sun_path
,
220 sizeof(drv
->hostapd_addr
.sun_path
),
222 drv
->test_dir
, MAC2STR(params
->bssid
));
223 drv
->hostapd_addr_set
= 1;
226 if (drv
->test_socket
>= 0 && drv
->hostapd_addr_set
) {
227 char cmd
[200], *pos
, *end
;
229 end
= cmd
+ sizeof(cmd
);
231 ret
= os_snprintf(pos
, end
- pos
, "ASSOC " MACSTR
" ",
232 MAC2STR(drv
->own_addr
));
233 if (ret
>= 0 && ret
< end
- pos
)
235 pos
+= wpa_snprintf_hex(pos
, end
- pos
, params
->ssid
,
237 ret
= os_snprintf(pos
, end
- pos
, " ");
238 if (ret
>= 0 && ret
< end
- pos
)
240 pos
+= wpa_snprintf_hex(pos
, end
- pos
, params
->wpa_ie
,
243 if (sendto(drv
->test_socket
, cmd
, os_strlen(cmd
), 0,
244 (struct sockaddr
*) &drv
->hostapd_addr
,
245 sizeof(drv
->hostapd_addr
)) < 0) {
246 perror("sendto(test_socket)");
250 os_memcpy(drv
->ssid
, params
->ssid
, params
->ssid_len
);
251 drv
->ssid_len
= params
->ssid_len
;
254 wpa_supplicant_event(drv
->ctx
, EVENT_ASSOC
, NULL
);
261 static int wpa_driver_test_get_bssid(void *priv
, u8
*bssid
)
263 struct wpa_driver_test_data
*drv
= priv
;
264 os_memcpy(bssid
, drv
->bssid
, ETH_ALEN
);
269 static int wpa_driver_test_get_ssid(void *priv
, u8
*ssid
)
271 struct wpa_driver_test_data
*drv
= priv
;
272 os_memcpy(ssid
, drv
->ssid
, 32);
273 return drv
->ssid_len
;
277 static int wpa_driver_test_send_disassoc(struct wpa_driver_test_data
*drv
)
279 if (drv
->test_socket
>= 0 &&
280 sendto(drv
->test_socket
, "DISASSOC", 8, 0,
281 (struct sockaddr
*) &drv
->hostapd_addr
,
282 sizeof(drv
->hostapd_addr
)) < 0) {
283 perror("sendto(test_socket)");
290 static int wpa_driver_test_deauthenticate(void *priv
, const u8
*addr
,
293 struct wpa_driver_test_data
*drv
= priv
;
294 wpa_printf(MSG_DEBUG
, "%s addr=" MACSTR
" reason_code=%d",
295 __func__
, MAC2STR(addr
), reason_code
);
296 os_memset(drv
->bssid
, 0, ETH_ALEN
);
298 wpa_supplicant_event(drv
->ctx
, EVENT_DISASSOC
, NULL
);
299 return wpa_driver_test_send_disassoc(drv
);
303 static int wpa_driver_test_disassociate(void *priv
, const u8
*addr
,
306 struct wpa_driver_test_data
*drv
= priv
;
307 wpa_printf(MSG_DEBUG
, "%s addr=" MACSTR
" reason_code=%d",
308 __func__
, MAC2STR(addr
), reason_code
);
309 os_memset(drv
->bssid
, 0, ETH_ALEN
);
311 wpa_supplicant_event(drv
->ctx
, EVENT_DISASSOC
, NULL
);
312 return wpa_driver_test_send_disassoc(drv
);
316 static void wpa_driver_test_scanresp(struct wpa_driver_test_data
*drv
,
317 struct sockaddr_un
*from
,
321 struct wpa_scan_res
*res
;
322 const char *pos
, *pos2
;
324 u8
*ie_pos
, *ie_start
, *ie_end
;
325 #define MAX_IE_LEN 1000
327 wpa_printf(MSG_DEBUG
, "test_driver: SCANRESP %s", data
);
328 if (drv
->num_scanres
>= MAX_SCAN_RESULTS
) {
329 wpa_printf(MSG_DEBUG
, "test_driver: No room for the new scan "
334 /* SCANRESP BSSID SSID IEs */
336 res
= os_zalloc(sizeof(*res
) + MAX_IE_LEN
);
339 ie_start
= ie_pos
= (u8
*) (res
+ 1);
340 ie_end
= ie_pos
+ MAX_IE_LEN
;
342 if (hwaddr_aton(data
, res
->bssid
)) {
343 wpa_printf(MSG_DEBUG
, "test_driver: invalid BSSID in scanres");
351 pos2
= os_strchr(pos
, ' ');
353 wpa_printf(MSG_DEBUG
, "test_driver: invalid SSID termination "
358 len
= (pos2
- pos
) / 2;
362 * Generate SSID IE from the SSID field since this IE is not included
363 * in the main IE field.
365 *ie_pos
++ = WLAN_EID_SSID
;
367 if (hexstr2bin(pos
, ie_pos
, len
) < 0) {
368 wpa_printf(MSG_DEBUG
, "test_driver: invalid SSID in scanres");
375 pos2
= os_strchr(pos
, ' ');
377 len
= os_strlen(pos
) / 2;
379 len
= (pos2
- pos
) / 2;
380 if ((int) len
> ie_end
- ie_pos
)
381 len
= ie_end
- ie_pos
;
382 if (hexstr2bin(pos
, ie_pos
, len
) < 0) {
383 wpa_printf(MSG_DEBUG
, "test_driver: invalid IEs in scanres");
388 res
->ie_len
= ie_pos
- ie_start
;
394 if (os_strncmp(pos
, "PRIVACY", 7) == 0)
395 res
->caps
|= IEEE80211_CAP_PRIVACY
;
398 os_free(drv
->scanres
[drv
->num_scanres
]);
399 drv
->scanres
[drv
->num_scanres
++] = res
;
403 static void wpa_driver_test_assocresp(struct wpa_driver_test_data
*drv
,
404 struct sockaddr_un
*from
,
408 /* ASSOCRESP BSSID <res> */
409 if (hwaddr_aton(data
, drv
->bssid
)) {
410 wpa_printf(MSG_DEBUG
, "test_driver: invalid BSSID in "
413 if (drv
->use_associnfo
) {
414 union wpa_event_data event
;
415 os_memset(&event
, 0, sizeof(event
));
416 event
.assoc_info
.req_ies
= drv
->assoc_wpa_ie
;
417 event
.assoc_info
.req_ies_len
= drv
->assoc_wpa_ie_len
;
418 wpa_supplicant_event(drv
->ctx
, EVENT_ASSOCINFO
, &event
);
421 wpa_supplicant_event(drv
->ctx
, EVENT_ASSOC
, NULL
);
425 static void wpa_driver_test_disassoc(struct wpa_driver_test_data
*drv
,
426 struct sockaddr_un
*from
,
430 wpa_supplicant_event(drv
->ctx
, EVENT_DISASSOC
, NULL
);
434 static void wpa_driver_test_eapol(struct wpa_driver_test_data
*drv
,
435 struct sockaddr_un
*from
,
437 const u8
*data
, size_t data_len
)
439 const u8
*src
= drv
->bssid
;
442 /* Skip Ethernet header */
443 src
= data
+ ETH_ALEN
;
447 wpa_supplicant_rx_eapol(drv
->ctx
, src
, data
, data_len
);
451 static void wpa_driver_test_mlme(struct wpa_driver_test_data
*drv
,
452 struct sockaddr_un
*from
,
454 const u8
*data
, size_t data_len
)
456 #ifdef CONFIG_CLIENT_MLME
457 struct ieee80211_rx_status rx_status
;
458 os_memset(&rx_status
, 0, sizeof(rx_status
));
459 wpa_supplicant_sta_rx(drv
->ctx
, data
, data_len
, &rx_status
);
460 #endif /* CONFIG_CLIENT_MLME */
464 static void wpa_driver_test_receive_unix(int sock
, void *eloop_ctx
,
467 struct wpa_driver_test_data
*drv
= eloop_ctx
;
470 struct sockaddr_un from
;
471 socklen_t fromlen
= sizeof(from
);
472 const size_t buflen
= 2000;
474 buf
= os_malloc(buflen
);
477 res
= recvfrom(sock
, buf
, buflen
- 1, 0,
478 (struct sockaddr
*) &from
, &fromlen
);
480 perror("recvfrom(test_socket)");
486 wpa_printf(MSG_DEBUG
, "test_driver: received %u bytes", res
);
488 if (os_strncmp(buf
, "SCANRESP ", 9) == 0) {
489 wpa_driver_test_scanresp(drv
, &from
, fromlen
, buf
+ 9);
490 } else if (os_strncmp(buf
, "ASSOCRESP ", 10) == 0) {
491 wpa_driver_test_assocresp(drv
, &from
, fromlen
, buf
+ 10);
492 } else if (os_strcmp(buf
, "DISASSOC") == 0) {
493 wpa_driver_test_disassoc(drv
, &from
, fromlen
);
494 } else if (os_strcmp(buf
, "DEAUTH") == 0) {
495 wpa_driver_test_disassoc(drv
, &from
, fromlen
);
496 } else if (os_strncmp(buf
, "EAPOL ", 6) == 0) {
497 wpa_driver_test_eapol(drv
, &from
, fromlen
,
498 (const u8
*) buf
+ 6, res
- 6);
499 } else if (os_strncmp(buf
, "MLME ", 5) == 0) {
500 wpa_driver_test_mlme(drv
, &from
, fromlen
,
501 (const u8
*) buf
+ 5, res
- 5);
503 wpa_hexdump_ascii(MSG_DEBUG
, "Unknown test_socket command",
510 static void * wpa_driver_test_init(void *ctx
, const char *ifname
)
512 struct wpa_driver_test_data
*drv
;
514 drv
= os_zalloc(sizeof(*drv
));
518 drv
->test_socket
= -1;
520 /* Set dummy BSSID and SSID for testing. */
521 drv
->bssid
[0] = 0x02;
522 drv
->bssid
[1] = 0x00;
523 drv
->bssid
[2] = 0x00;
524 drv
->bssid
[3] = 0x00;
525 drv
->bssid
[4] = 0x00;
526 drv
->bssid
[5] = 0x01;
527 os_memcpy(drv
->ssid
, "test", 5);
530 /* Generate a MAC address to help testing with multiple STAs */
531 drv
->own_addr
[0] = 0x02; /* locally administered */
532 sha1_prf((const u8
*) ifname
, os_strlen(ifname
),
533 "wpa_supplicant test mac addr generation",
534 NULL
, 0, drv
->own_addr
+ 1, ETH_ALEN
- 1);
535 eloop_register_timeout(1, 0, wpa_driver_test_poll
, drv
, NULL
);
541 static void wpa_driver_test_close_test_socket(struct wpa_driver_test_data
*drv
)
543 if (drv
->test_socket
>= 0) {
544 eloop_unregister_read_sock(drv
->test_socket
);
545 close(drv
->test_socket
);
546 drv
->test_socket
= -1;
549 if (drv
->own_socket_path
) {
550 unlink(drv
->own_socket_path
);
551 os_free(drv
->own_socket_path
);
552 drv
->own_socket_path
= NULL
;
557 static void wpa_driver_test_deinit(void *priv
)
559 struct wpa_driver_test_data
*drv
= priv
;
561 wpa_driver_test_close_test_socket(drv
);
562 eloop_cancel_timeout(wpa_driver_test_scan_timeout
, drv
, drv
->ctx
);
563 eloop_cancel_timeout(wpa_driver_test_poll
, drv
, NULL
);
564 os_free(drv
->test_dir
);
565 for (i
= 0; i
< MAX_SCAN_RESULTS
; i
++)
566 os_free(drv
->scanres
[i
]);
571 static int wpa_driver_test_attach(struct wpa_driver_test_data
*drv
,
574 static unsigned int counter
= 0;
575 struct sockaddr_un addr
;
578 os_free(drv
->own_socket_path
);
580 len
= os_strlen(dir
) + 30;
581 drv
->own_socket_path
= os_malloc(len
);
582 if (drv
->own_socket_path
== NULL
)
584 os_snprintf(drv
->own_socket_path
, len
, "%s/STA-" MACSTR
,
585 dir
, MAC2STR(drv
->own_addr
));
587 drv
->own_socket_path
= os_malloc(100);
588 if (drv
->own_socket_path
== NULL
)
590 os_snprintf(drv
->own_socket_path
, 100,
591 "/tmp/wpa_supplicant_test-%d-%d",
592 getpid(), counter
++);
595 drv
->test_socket
= socket(PF_UNIX
, SOCK_DGRAM
, 0);
596 if (drv
->test_socket
< 0) {
597 perror("socket(PF_UNIX)");
598 os_free(drv
->own_socket_path
);
599 drv
->own_socket_path
= NULL
;
603 os_memset(&addr
, 0, sizeof(addr
));
604 addr
.sun_family
= AF_UNIX
;
605 os_strlcpy(addr
.sun_path
, drv
->own_socket_path
, sizeof(addr
.sun_path
));
606 if (bind(drv
->test_socket
, (struct sockaddr
*) &addr
,
608 perror("bind(PF_UNIX)");
609 close(drv
->test_socket
);
610 unlink(drv
->own_socket_path
);
611 os_free(drv
->own_socket_path
);
612 drv
->own_socket_path
= NULL
;
616 eloop_register_read_sock(drv
->test_socket
,
617 wpa_driver_test_receive_unix
, drv
, NULL
);
623 static int wpa_driver_test_set_param(void *priv
, const char *param
)
625 struct wpa_driver_test_data
*drv
= priv
;
626 const char *pos
, *pos2
;
629 wpa_printf(MSG_DEBUG
, "%s: param='%s'", __func__
, param
);
633 wpa_driver_test_close_test_socket(drv
);
634 pos
= os_strstr(param
, "test_socket=");
637 pos2
= os_strchr(pos
, ' ');
641 len
= os_strlen(pos
);
642 if (len
> sizeof(drv
->hostapd_addr
.sun_path
))
644 os_memset(&drv
->hostapd_addr
, 0, sizeof(drv
->hostapd_addr
));
645 drv
->hostapd_addr
.sun_family
= AF_UNIX
;
646 os_memcpy(drv
->hostapd_addr
.sun_path
, pos
, len
);
647 drv
->hostapd_addr_set
= 1;
650 pos
= os_strstr(param
, "test_dir=");
653 os_free(drv
->test_dir
);
654 drv
->test_dir
= os_strdup(pos
+ 9);
655 if (drv
->test_dir
== NULL
)
657 end
= os_strchr(drv
->test_dir
, ' ');
660 wpa_driver_test_attach(drv
, drv
->test_dir
);
662 wpa_driver_test_attach(drv
, NULL
);
664 if (os_strstr(param
, "use_associnfo=1")) {
665 wpa_printf(MSG_DEBUG
, "test_driver: Use AssocInfo events");
666 drv
->use_associnfo
= 1;
669 #ifdef CONFIG_CLIENT_MLME
670 if (os_strstr(param
, "use_mlme=1")) {
671 wpa_printf(MSG_DEBUG
, "test_driver: Use internal MLME");
674 #endif /* CONFIG_CLIENT_MLME */
680 static const u8
* wpa_driver_test_get_mac_addr(void *priv
)
682 struct wpa_driver_test_data
*drv
= priv
;
683 wpa_printf(MSG_DEBUG
, "%s", __func__
);
684 return drv
->own_addr
;
688 static int wpa_driver_test_send_eapol(void *priv
, const u8
*dest
, u16 proto
,
689 const u8
*data
, size_t data_len
)
691 struct wpa_driver_test_data
*drv
= priv
;
694 struct l2_ethhdr eth
;
695 struct sockaddr_un addr
;
697 wpa_hexdump(MSG_MSGDUMP
, "test_send_eapol TX frame", data
, data_len
);
699 os_memset(ð
, 0, sizeof(eth
));
700 os_memcpy(eth
.h_dest
, dest
, ETH_ALEN
);
701 os_memcpy(eth
.h_source
, drv
->own_addr
, ETH_ALEN
);
702 eth
.h_proto
= host_to_be16(proto
);
704 io
[0].iov_base
= "EAPOL ";
706 io
[1].iov_base
= (u8
*) ð
;
707 io
[1].iov_len
= sizeof(eth
);
708 io
[2].iov_base
= (u8
*) data
;
709 io
[2].iov_len
= data_len
;
711 os_memset(&msg
, 0, sizeof(msg
));
714 if (os_memcmp(dest
, drv
->bssid
, ETH_ALEN
) == 0 ||
715 drv
->test_dir
== NULL
) {
716 msg
.msg_name
= &drv
->hostapd_addr
;
717 msg
.msg_namelen
= sizeof(drv
->hostapd_addr
);
720 os_memset(&addr
, 0, sizeof(addr
));
721 addr
.sun_family
= AF_UNIX
;
722 os_snprintf(addr
.sun_path
, sizeof(addr
.sun_path
),
723 "%s/STA-" MACSTR
, drv
->test_dir
, MAC2STR(dest
));
724 if (stat(addr
.sun_path
, &st
) < 0) {
725 os_snprintf(addr
.sun_path
, sizeof(addr
.sun_path
),
727 drv
->test_dir
, MAC2STR(dest
));
729 msg
.msg_name
= &addr
;
730 msg
.msg_namelen
= sizeof(addr
);
733 if (sendmsg(drv
->test_socket
, &msg
, 0) < 0) {
734 perror("sendmsg(test_socket)");
742 static int wpa_driver_test_get_capa(void *priv
, struct wpa_driver_capa
*capa
)
744 struct wpa_driver_test_data
*drv
= priv
;
745 os_memset(capa
, 0, sizeof(*capa
));
746 capa
->key_mgmt
= WPA_DRIVER_CAPA_KEY_MGMT_WPA
|
747 WPA_DRIVER_CAPA_KEY_MGMT_WPA2
|
748 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK
|
749 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK
|
750 WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE
|
751 WPA_DRIVER_CAPA_KEY_MGMT_FT
|
752 WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK
;
753 capa
->enc
= WPA_DRIVER_CAPA_ENC_WEP40
|
754 WPA_DRIVER_CAPA_ENC_WEP104
|
755 WPA_DRIVER_CAPA_ENC_TKIP
|
756 WPA_DRIVER_CAPA_ENC_CCMP
;
757 capa
->auth
= WPA_DRIVER_AUTH_OPEN
|
758 WPA_DRIVER_AUTH_SHARED
|
759 WPA_DRIVER_AUTH_LEAP
;
761 capa
->flags
|= WPA_DRIVER_FLAGS_USER_SPACE_MLME
;
767 static int wpa_driver_test_mlme_setprotection(void *priv
, const u8
*addr
,
771 wpa_printf(MSG_DEBUG
, "%s: protect_type=%d key_type=%d",
772 __func__
, protect_type
, key_type
);
775 wpa_printf(MSG_DEBUG
, "%s: addr=" MACSTR
,
776 __func__
, MAC2STR(addr
));
783 #ifdef CONFIG_CLIENT_MLME
784 static struct wpa_hw_modes
*
785 wpa_driver_test_get_hw_feature_data(void *priv
, u16
*num_modes
, u16
*flags
)
787 struct wpa_hw_modes
*modes
;
791 modes
= os_zalloc(*num_modes
* sizeof(struct wpa_hw_modes
));
794 modes
[0].mode
= WPA_MODE_IEEE80211G
;
795 modes
[0].num_channels
= 1;
796 modes
[0].num_rates
= 1;
797 modes
[0].channels
= os_zalloc(sizeof(struct wpa_channel_data
));
798 modes
[0].rates
= os_zalloc(sizeof(struct wpa_rate_data
));
799 if (modes
[0].channels
== NULL
|| modes
[0].rates
== NULL
) {
800 wpa_supplicant_sta_free_hw_features(modes
, *num_modes
);
803 modes
[0].channels
[0].chan
= 1;
804 modes
[0].channels
[0].freq
= 2412;
805 modes
[0].channels
[0].flag
= WPA_CHAN_W_SCAN
| WPA_CHAN_W_ACTIVE_SCAN
;
806 modes
[0].rates
[0].rate
= 10;
807 modes
[0].rates
[0].flags
= WPA_RATE_BASIC
| WPA_RATE_SUPPORTED
|
808 WPA_RATE_CCK
| WPA_RATE_MANDATORY
;
814 int wpa_driver_test_set_channel(void *priv
, wpa_hw_mode phymode
, int chan
,
817 wpa_printf(MSG_DEBUG
, "%s: phymode=%d chan=%d freq=%d",
818 __func__
, phymode
, chan
, freq
);
823 static int wpa_driver_test_send_mlme(void *priv
, const u8
*data
,
826 struct wpa_driver_test_data
*drv
= priv
;
829 struct sockaddr_un addr
;
834 wpa_hexdump(MSG_MSGDUMP
, "test_send_mlme", data
, data_len
);
839 io
[0].iov_base
= "MLME ";
841 io
[1].iov_base
= (u8
*) data
;
842 io
[1].iov_len
= data_len
;
844 os_memset(&msg
, 0, sizeof(msg
));
847 if (os_memcmp(dest
, drv
->bssid
, ETH_ALEN
) == 0 ||
848 drv
->test_dir
== NULL
) {
849 msg
.msg_name
= &drv
->hostapd_addr
;
850 msg
.msg_namelen
= sizeof(drv
->hostapd_addr
);
851 } else if (os_memcmp(dest
, "\xff\xff\xff\xff\xff\xff", ETH_ALEN
) == 0)
853 dir
= opendir(drv
->test_dir
);
856 while ((dent
= readdir(dir
))) {
857 #ifdef _DIRENT_HAVE_D_TYPE
858 /* Skip the file if it is not a socket.
859 * Also accept DT_UNKNOWN (0) in case
860 * the C library or underlying file
861 * system does not support d_type. */
862 if (dent
->d_type
!= DT_SOCK
&&
863 dent
->d_type
!= DT_UNKNOWN
)
865 #endif /* _DIRENT_HAVE_D_TYPE */
866 if (os_strcmp(dent
->d_name
, ".") == 0 ||
867 os_strcmp(dent
->d_name
, "..") == 0)
869 wpa_printf(MSG_DEBUG
, "%s: Send broadcast MLME to %s",
870 __func__
, dent
->d_name
);
871 os_memset(&addr
, 0, sizeof(addr
));
872 addr
.sun_family
= AF_UNIX
;
873 os_snprintf(addr
.sun_path
, sizeof(addr
.sun_path
),
874 "%s/%s", drv
->test_dir
, dent
->d_name
);
876 msg
.msg_name
= &addr
;
877 msg
.msg_namelen
= sizeof(addr
);
879 if (sendmsg(drv
->test_socket
, &msg
, 0) < 0)
880 perror("sendmsg(test_socket)");
886 os_memset(&addr
, 0, sizeof(addr
));
887 addr
.sun_family
= AF_UNIX
;
888 os_snprintf(addr
.sun_path
, sizeof(addr
.sun_path
),
889 "%s/AP-" MACSTR
, drv
->test_dir
, MAC2STR(dest
));
890 if (stat(addr
.sun_path
, &st
) < 0) {
891 os_snprintf(addr
.sun_path
, sizeof(addr
.sun_path
),
893 drv
->test_dir
, MAC2STR(dest
));
895 msg
.msg_name
= &addr
;
896 msg
.msg_namelen
= sizeof(addr
);
899 if (sendmsg(drv
->test_socket
, &msg
, 0) < 0) {
900 perror("sendmsg(test_socket)");
908 static int wpa_driver_test_mlme_add_sta(void *priv
, const u8
*addr
,
909 const u8
*supp_rates
,
910 size_t supp_rates_len
)
912 wpa_printf(MSG_DEBUG
, "%s: addr=" MACSTR
, __func__
, MAC2STR(addr
));
917 static int wpa_driver_test_mlme_remove_sta(void *priv
, const u8
*addr
)
919 wpa_printf(MSG_DEBUG
, "%s: addr=" MACSTR
, __func__
, MAC2STR(addr
));
924 int wpa_driver_test_set_ssid(void *priv
, const u8
*ssid
, size_t ssid_len
)
926 wpa_printf(MSG_DEBUG
, "%s", __func__
);
931 int wpa_driver_test_set_bssid(void *priv
, const u8
*bssid
)
933 wpa_printf(MSG_DEBUG
, "%s: bssid=" MACSTR
, __func__
, MAC2STR(bssid
));
936 #endif /* CONFIG_CLIENT_MLME */
939 const struct wpa_driver_ops wpa_driver_test_ops
= {
941 "wpa_supplicant test driver",
942 wpa_driver_test_get_bssid
,
943 wpa_driver_test_get_ssid
,
944 wpa_driver_test_set_wpa
,
945 wpa_driver_test_set_key
,
946 wpa_driver_test_init
,
947 wpa_driver_test_deinit
,
948 wpa_driver_test_set_param
,
949 NULL
/* set_countermeasures */,
950 NULL
/* set_drop_unencrypted */,
951 wpa_driver_test_scan
,
952 NULL
/* get_scan_results */,
953 wpa_driver_test_deauthenticate
,
954 wpa_driver_test_disassociate
,
955 wpa_driver_test_associate
,
956 NULL
/* set_auth_alg */,
957 NULL
/* add_pmkid */,
958 NULL
/* remove_pmkid */,
959 NULL
/* flush_pmkid */,
960 wpa_driver_test_get_capa
,
962 NULL
/* get_ifname */,
963 wpa_driver_test_get_mac_addr
,
964 wpa_driver_test_send_eapol
,
965 NULL
/* set_operstate */,
966 wpa_driver_test_mlme_setprotection
,
967 #ifdef CONFIG_CLIENT_MLME
968 wpa_driver_test_get_hw_feature_data
,
969 wpa_driver_test_set_channel
,
970 wpa_driver_test_set_ssid
,
971 wpa_driver_test_set_bssid
,
972 wpa_driver_test_send_mlme
,
973 wpa_driver_test_mlme_add_sta
,
974 wpa_driver_test_mlme_remove_sta
,
975 #else /* CONFIG_CLIENT_MLME */
976 NULL
/* get_hw_feature_data */,
977 NULL
/* set_channel */,
979 NULL
/* set_bssid */,
980 NULL
/* send_mlme */,
981 NULL
/* mlme_add_sta */,
982 NULL
/* mlme_remove_sta */,
983 #endif /* CONFIG_CLIENT_MLME */
984 NULL
/* update_ft_ies */,
985 NULL
/* send_ft_action */,
986 wpa_driver_test_get_scan_results2
,
987 NULL
/* set_probe_req_ie */,