?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Allow Probe Request callbacks to terminate iteration
[hostap-gosc2009.git] / src / drivers / driver_test.c
blob3bfa6d485fb001292f4a42c45d00148f668450df
1 /*
2 * Testing driver interface for a simulated network driver
3 * Copyright (c) 2004-2009, Jouni Malinen <j@w1.fi>
4 *
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.
8 *
9 * Alternatively, this software may be distributed under the terms of BSD
10 * license.
11 *
12 * See README and COPYING for more details.
13 */
14
15 /* Make sure we get winsock2.h for Windows build to get sockaddr_storage */
16 #include "build_config.h"
17 #ifdef CONFIG_NATIVE_WINDOWS
18 #include <winsock2.h>
19 #endif /* CONFIG_NATIVE_WINDOWS */
20
21 #include "utils/includes.h"
22
23 #ifndef CONFIG_NATIVE_WINDOWS
24 #include <sys/un.h>
25 #include <dirent.h>
26 #include <sys/stat.h>
27 #define DRIVER_TEST_UNIX
28 #endif /* CONFIG_NATIVE_WINDOWS */
29
30 #include "utils/common.h"
31 #include "utils/eloop.h"
32 #include "utils/trace.h"
33 #include "common/ieee802_11_defs.h"
34 #include "crypto/sha1.h"
35 #include "l2_packet/l2_packet.h"
36 #include "driver.h"
37
38
39 struct test_client_socket {
40 struct test_client_socket *next;
41 u8 addr[ETH_ALEN];
42 struct sockaddr_un un;
43 socklen_t unlen;
44 struct test_driver_bss *bss;
45 };
46
47 struct test_driver_bss {
48 struct test_driver_bss *next;
49 void *bss_ctx;
50 char ifname[IFNAMSIZ + 1];
51 u8 bssid[ETH_ALEN];
52 u8 *ie;
53 size_t ielen;
54 u8 *wps_beacon_ie;
55 size_t wps_beacon_ie_len;
56 u8 *wps_probe_resp_ie;
57 size_t wps_probe_resp_ie_len;
58 u8 ssid[32];
59 size_t ssid_len;
60 int privacy;
61 };
62
63 struct wpa_driver_test_global {
64 int dummy;
65 };
66
67 struct wpa_driver_test_data {
68 struct wpa_driver_test_global *global;
69 void *ctx;
70 WPA_TRACE_REF(ctx);
71 char ifname[IFNAMSIZ + 1];
72 u8 own_addr[ETH_ALEN];
73 int test_socket;
74 #ifdef DRIVER_TEST_UNIX
75 struct sockaddr_un hostapd_addr;
76 #endif /* DRIVER_TEST_UNIX */
77 int hostapd_addr_set;
78 struct sockaddr_in hostapd_addr_udp;
79 int hostapd_addr_udp_set;
80 char *own_socket_path;
81 char *test_dir;
82 u8 bssid[ETH_ALEN];
83 u8 ssid[32];
84 size_t ssid_len;
85 #define MAX_SCAN_RESULTS 30
86 struct wpa_scan_res *scanres[MAX_SCAN_RESULTS];
87 size_t num_scanres;
88 int use_associnfo;
89 u8 assoc_wpa_ie[80];
90 size_t assoc_wpa_ie_len;
91 int use_mlme;
92 int associated;
93 u8 *probe_req_ie;
94 size_t probe_req_ie_len;
95 int ibss;
96 int privacy;
97 int ap;
98
99 struct test_client_socket *cli;
100 struct test_driver_bss *bss;
101 int udp_port;
102 };
103
104
105 static void wpa_driver_test_deinit(void *priv);
106 static int wpa_driver_test_attach(struct wpa_driver_test_data *drv,
107 const char *dir, int ap);
108 static void wpa_driver_test_close_test_socket(
109 struct wpa_driver_test_data *drv);
110
111 #ifdef CONFIG_AP
112 void ap_mgmt_rx(void *ctx, u8 *buf, size_t len, u16 stype,
113 struct hostapd_frame_info *fi);
114 void ap_mgmt_tx_cb(void *ctx, u8 *buf, size_t len, u16 stype, int ok);
115
116 #else /* CONFIG_AP */
117 #ifndef HOSTAPD
118 static inline void ap_mgmt_rx(void *ctx, u8 *buf, size_t len, u16 stype,
119 struct hostapd_frame_info *fi)
120 {
121 }
122
123 static inline void ap_mgmt_tx_cb(void *ctx, u8 *buf, size_t len, u16 stype,
124 int ok)
125 {
126 }
127 #endif /* HOSTAPD */
128 #endif /* CONFIG_AP */
129
130
131 static void test_driver_free_bss(struct test_driver_bss *bss)
132 {
133 os_free(bss->ie);
134 os_free(bss->wps_beacon_ie);
135 os_free(bss->wps_probe_resp_ie);
136 os_free(bss);
137 }
138
139
140 static void test_driver_free_bsses(struct wpa_driver_test_data *drv)
141 {
142 struct test_driver_bss *bss, *prev_bss;
143
144 bss = drv->bss;
145 while (bss) {
146 prev_bss = bss;
147 bss = bss->next;
148 test_driver_free_bss(prev_bss);
149 }
150
151 drv->bss = NULL;
152 }
153
154
155 static struct test_client_socket *
156 test_driver_get_cli(struct wpa_driver_test_data *drv, struct sockaddr_un *from,
157 socklen_t fromlen)
158 {
159 struct test_client_socket *cli = drv->cli;
160
161 while (cli) {
162 if (cli->unlen == fromlen &&
163 strncmp(cli->un.sun_path, from->sun_path,
164 fromlen - sizeof(cli->un.sun_family)) == 0)
165 return cli;
166 cli = cli->next;
167 }
168
169 return NULL;
170 }
171
172
173 static int test_driver_send_eapol(void *priv, const u8 *addr, const u8 *data,
174 size_t data_len, int encrypt,
175 const u8 *own_addr)
176 {
177 struct wpa_driver_test_data *drv = priv;
178 struct test_client_socket *cli;
179 struct msghdr msg;
180 struct iovec io[3];
181 struct l2_ethhdr eth;
182
183 if (drv->test_socket < 0)
184 return -1;
185
186 cli = drv->cli;
187 while (cli) {
188 if (memcmp(cli->addr, addr, ETH_ALEN) == 0)
189 break;
190 cli = cli->next;
191 }
192
193 if (!cli) {
194 wpa_printf(MSG_DEBUG, "%s: no destination client entry",
195 __func__);
196 return -1;
197 }
198
199 memcpy(eth.h_dest, addr, ETH_ALEN);
200 memcpy(eth.h_source, own_addr, ETH_ALEN);
201 eth.h_proto = host_to_be16(ETH_P_EAPOL);
202
203 io[0].iov_base = "EAPOL ";
204 io[0].iov_len = 6;
205 io[1].iov_base = &eth;
206 io[1].iov_len = sizeof(eth);
207 io[2].iov_base = (u8 *) data;
208 io[2].iov_len = data_len;
209
210 memset(&msg, 0, sizeof(msg));
211 msg.msg_iov = io;
212 msg.msg_iovlen = 3;
213 msg.msg_name = &cli->un;
214 msg.msg_namelen = cli->unlen;
215 return sendmsg(drv->test_socket, &msg, 0);
216 }
217
218
219 static int test_driver_send_ether(void *priv, const u8 *dst, const u8 *src,
220 u16 proto, const u8 *data, size_t data_len)
221 {
222 struct wpa_driver_test_data *drv = priv;
223 struct msghdr msg;
224 struct iovec io[3];
225 struct l2_ethhdr eth;
226 char desttxt[30];
227 struct sockaddr_un addr;
228 struct dirent *dent;
229 DIR *dir;
230 int ret = 0, broadcast = 0, count = 0;
231
232 if (drv->test_socket < 0 || drv->test_dir == NULL) {
233 wpa_printf(MSG_DEBUG, "%s: invalid parameters (sock=%d "
234 "test_dir=%p)",
235 __func__, drv->test_socket, drv->test_dir);
236 return -1;
237 }
238
239 broadcast = memcmp(dst, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) == 0;
240 snprintf(desttxt, sizeof(desttxt), MACSTR, MAC2STR(dst));
241
242 memcpy(eth.h_dest, dst, ETH_ALEN);
243 memcpy(eth.h_source, src, ETH_ALEN);
244 eth.h_proto = host_to_be16(proto);
245
246 io[0].iov_base = "ETHER ";
247 io[0].iov_len = 6;
248 io[1].iov_base = &eth;
249 io[1].iov_len = sizeof(eth);
250 io[2].iov_base = (u8 *) data;
251 io[2].iov_len = data_len;
252
253 memset(&msg, 0, sizeof(msg));
254 msg.msg_iov = io;
255 msg.msg_iovlen = 3;
256
257 dir = opendir(drv->test_dir);
258 if (dir == NULL) {
259 perror("test_driver: opendir");
260 return -1;
261 }
262 while ((dent = readdir(dir))) {
263 #ifdef _DIRENT_HAVE_D_TYPE
264 /* Skip the file if it is not a socket. Also accept
265 * DT_UNKNOWN (0) in case the C library or underlying file
266 * system does not support d_type. */
267 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN)
268 continue;
269 #endif /* _DIRENT_HAVE_D_TYPE */
270 if (strcmp(dent->d_name, ".") == 0 ||
271 strcmp(dent->d_name, "..") == 0)
272 continue;
273
274 memset(&addr, 0, sizeof(addr));
275 addr.sun_family = AF_UNIX;
276 snprintf(addr.sun_path, sizeof(addr.sun_path), "%s/%s",
277 drv->test_dir, dent->d_name);
278
279 if (strcmp(addr.sun_path, drv->own_socket_path) == 0)
280 continue;
281 if (!broadcast && strstr(dent->d_name, desttxt) == NULL)
282 continue;
283
284 wpa_printf(MSG_DEBUG, "%s: Send ether frame to %s",
285 __func__, dent->d_name);
286
287 msg.msg_name = &addr;
288 msg.msg_namelen = sizeof(addr);
289 ret = sendmsg(drv->test_socket, &msg, 0);
290 if (ret < 0)
291 perror("driver_test: sendmsg");
292 count++;
293 }
294 closedir(dir);
295
296 if (!broadcast && count == 0) {
297 wpa_printf(MSG_DEBUG, "%s: Destination " MACSTR " not found",
298 __func__, MAC2STR(dst));
299 return -1;
300 }
301
302 return ret;
303 }
304
305
306 static int wpa_driver_test_send_mlme(void *priv, const u8 *data,
307 size_t data_len)
308 {
309 struct wpa_driver_test_data *drv = priv;
310 struct msghdr msg;
311 struct iovec io[2];
312 const u8 *dest;
313 struct sockaddr_un addr;
314 struct dirent *dent;
315 DIR *dir;
316 int broadcast;
317 int ret = 0;
318 struct ieee80211_hdr *hdr;
319 u16 fc;
320 #ifdef HOSTAPD
321 char desttxt[30];
322 #endif /* HOSTAPD */
323 union wpa_event_data event;
324
325 wpa_hexdump(MSG_MSGDUMP, "test_send_mlme", data, data_len);
326 if (drv->test_socket < 0 || data_len < 10) {
327 wpa_printf(MSG_DEBUG, "%s: invalid parameters (sock=%d len=%lu"
328 " test_dir=%p)",
329 __func__, drv->test_socket,
330 (unsigned long) data_len,
331 drv->test_dir);
332 return -1;
333 }
334
335 dest = data + 4;
336 broadcast = os_memcmp(dest, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) == 0;
337
338 #ifdef HOSTAPD
339 snprintf(desttxt, sizeof(desttxt), MACSTR, MAC2STR(dest));
340 #endif /* HOSTAPD */
341
342 io[0].iov_base = "MLME ";
343 io[0].iov_len = 5;
344 io[1].iov_base = (void *) data;
345 io[1].iov_len = data_len;
346
347 os_memset(&msg, 0, sizeof(msg));
348 msg.msg_iov = io;
349 msg.msg_iovlen = 2;
350
351 #ifdef HOSTAPD
352 if (drv->test_dir == NULL) {
353 wpa_printf(MSG_DEBUG, "%s: test_dir == NULL", __func__);
354 return -1;
355 }
356
357 dir = opendir(drv->test_dir);
358 if (dir == NULL) {
359 perror("test_driver: opendir");
360 return -1;
361 }
362 while ((dent = readdir(dir))) {
363 #ifdef _DIRENT_HAVE_D_TYPE
364 /* Skip the file if it is not a socket. Also accept
365 * DT_UNKNOWN (0) in case the C library or underlying file
366 * system does not support d_type. */
367 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN)
368 continue;
369 #endif /* _DIRENT_HAVE_D_TYPE */
370 if (os_strcmp(dent->d_name, ".") == 0 ||
371 os_strcmp(dent->d_name, "..") == 0)
372 continue;
373
374 os_memset(&addr, 0, sizeof(addr));
375 addr.sun_family = AF_UNIX;
376 os_snprintf(addr.sun_path, sizeof(addr.sun_path), "%s/%s",
377 drv->test_dir, dent->d_name);
378
379 if (os_strcmp(addr.sun_path, drv->own_socket_path) == 0)
380 continue;
381 if (!broadcast && os_strstr(dent->d_name, desttxt) == NULL)
382 continue;
383
384 wpa_printf(MSG_DEBUG, "%s: Send management frame to %s",
385 __func__, dent->d_name);
386
387 msg.msg_name = &addr;
388 msg.msg_namelen = sizeof(addr);
389 ret = sendmsg(drv->test_socket, &msg, 0);
390 if (ret < 0)
391 perror("driver_test: sendmsg(test_socket)");
392 }
393 closedir(dir);
394 #else /* HOSTAPD */
395
396 if (os_memcmp(dest, drv->bssid, ETH_ALEN) == 0 ||
397 drv->test_dir == NULL) {
398 if (drv->hostapd_addr_udp_set) {
399 msg.msg_name = &drv->hostapd_addr_udp;
400 msg.msg_namelen = sizeof(drv->hostapd_addr_udp);
401 } else {
402 #ifdef DRIVER_TEST_UNIX
403 msg.msg_name = &drv->hostapd_addr;
404 msg.msg_namelen = sizeof(drv->hostapd_addr);
405 #endif /* DRIVER_TEST_UNIX */
406 }
407 } else if (broadcast) {
408 dir = opendir(drv->test_dir);
409 if (dir == NULL)
410 return -1;
411 while ((dent = readdir(dir))) {
412 #ifdef _DIRENT_HAVE_D_TYPE
413 /* Skip the file if it is not a socket.
414 * Also accept DT_UNKNOWN (0) in case
415 * the C library or underlying file
416 * system does not support d_type. */
417 if (dent->d_type != DT_SOCK &&
418 dent->d_type != DT_UNKNOWN)
419 continue;
420 #endif /* _DIRENT_HAVE_D_TYPE */
421 if (os_strcmp(dent->d_name, ".") == 0 ||
422 os_strcmp(dent->d_name, "..") == 0)
423 continue;
424 wpa_printf(MSG_DEBUG, "%s: Send broadcast MLME to %s",
425 __func__, dent->d_name);
426 os_memset(&addr, 0, sizeof(addr));
427 addr.sun_family = AF_UNIX;
428 os_snprintf(addr.sun_path, sizeof(addr.sun_path),
429 "%s/%s", drv->test_dir, dent->d_name);
430
431 msg.msg_name = &addr;
432 msg.msg_namelen = sizeof(addr);
433
434 ret = sendmsg(drv->test_socket, &msg, 0);
435 if (ret < 0)
436 perror("driver_test: sendmsg(test_socket)");
437 }
438 closedir(dir);
439 return ret;
440 } else {
441 struct stat st;
442 os_memset(&addr, 0, sizeof(addr));
443 addr.sun_family = AF_UNIX;
444 os_snprintf(addr.sun_path, sizeof(addr.sun_path),
445 "%s/AP-" MACSTR, drv->test_dir, MAC2STR(dest));
446 if (stat(addr.sun_path, &st) < 0) {
447 os_snprintf(addr.sun_path, sizeof(addr.sun_path),
448 "%s/STA-" MACSTR,
449 drv->test_dir, MAC2STR(dest));
450 }
451 msg.msg_name = &addr;
452 msg.msg_namelen = sizeof(addr);
453 }
454
455 if (sendmsg(drv->test_socket, &msg, 0) < 0) {
456 perror("sendmsg(test_socket)");
457 return -1;
458 }
459 #endif /* HOSTAPD */
460
461 hdr = (struct ieee80211_hdr *) data;
462 fc = le_to_host16(hdr->frame_control);
463
464 os_memset(&event, 0, sizeof(event));
465 event.tx_status.type = WLAN_FC_GET_TYPE(fc);
466 event.tx_status.stype = WLAN_FC_GET_STYPE(fc);
467 event.tx_status.dst = hdr->addr1;
468 event.tx_status.data = data;
469 event.tx_status.data_len = data_len;
470 event.tx_status.ack = ret >= 0;
471 wpa_supplicant_event(drv->ctx, EVENT_TX_STATUS, &event);
472
473 return ret;
474 }
475
476
477 static void test_driver_scan(struct wpa_driver_test_data *drv,
478 struct sockaddr_un *from, socklen_t fromlen,
479 char *data)
480 {
481 char buf[512], *pos, *end;
482 int ret;
483 struct test_driver_bss *bss;
484 u8 sa[ETH_ALEN];
485 u8 ie[512];
486 size_t ielen;
487
488 /* data: optional [ ' ' | STA-addr | ' ' | IEs(hex) ] */
489
490 wpa_printf(MSG_DEBUG, "test_driver: SCAN");
491
492 if (*data) {
493 if (*data != ' ' ||
494 hwaddr_aton(data + 1, sa)) {
495 wpa_printf(MSG_DEBUG, "test_driver: Unexpected SCAN "
496 "command format");
497 return;
498 }
499
500 data += 18;
501 while (*data == ' ')
502 data++;
503 ielen = os_strlen(data) / 2;
504 if (ielen > sizeof(ie))
505 ielen = sizeof(ie);
506 if (hexstr2bin(data, ie, ielen) < 0)
507 ielen = 0;
508
509 wpa_printf(MSG_DEBUG, "test_driver: Scan from " MACSTR,
510 MAC2STR(sa));
511 wpa_hexdump(MSG_MSGDUMP, "test_driver: scan IEs", ie, ielen);
512
513 #ifdef HOSTAPD
514 hostapd_probe_req_rx(drv->ctx, sa, ie, ielen);
515 #endif /* HOSTAPD */
516 }
517
518 for (bss = drv->bss; bss; bss = bss->next) {
519 pos = buf;
520 end = buf + sizeof(buf);
521
522 /* reply: SCANRESP BSSID SSID IEs */
523 ret = snprintf(pos, end - pos, "SCANRESP " MACSTR " ",
524 MAC2STR(bss->bssid));
525 if (ret < 0 || ret >= end - pos)
526 return;
527 pos += ret;
528 pos += wpa_snprintf_hex(pos, end - pos,
529 bss->ssid, bss->ssid_len);
530 ret = snprintf(pos, end - pos, " ");
531 if (ret < 0 || ret >= end - pos)
532 return;
533 pos += ret;
534 pos += wpa_snprintf_hex(pos, end - pos, bss->ie, bss->ielen);
535 pos += wpa_snprintf_hex(pos, end - pos, bss->wps_probe_resp_ie,
536 bss->wps_probe_resp_ie_len);
537
538 if (bss->privacy) {
539 ret = snprintf(pos, end - pos, " PRIVACY");
540 if (ret < 0 || ret >= end - pos)
541 return;
542 pos += ret;
543 }
544
545 sendto(drv->test_socket, buf, pos - buf, 0,
546 (struct sockaddr *) from, fromlen);
547 }
548 }
549
550
551 static void test_driver_assoc(struct wpa_driver_test_data *drv,
552 struct sockaddr_un *from, socklen_t fromlen,
553 char *data)
554 {
555 struct test_client_socket *cli;
556 u8 ie[256], ssid[32];
557 size_t ielen, ssid_len = 0;
558 char *pos, *pos2, cmd[50];
559 struct test_driver_bss *bss;
560
561 /* data: STA-addr SSID(hex) IEs(hex) */
562
563 cli = os_zalloc(sizeof(*cli));
564 if (cli == NULL)
565 return;
566
567 if (hwaddr_aton(data, cli->addr)) {
568 printf("test_socket: Invalid MAC address '%s' in ASSOC\n",
569 data);
570 os_free(cli);
571 return;
572 }
573 pos = data + 17;
574 while (*pos == ' ')
575 pos++;
576 pos2 = strchr(pos, ' ');
577 ielen = 0;
578 if (pos2) {
579 ssid_len = (pos2 - pos) / 2;
580 if (hexstr2bin(pos, ssid, ssid_len) < 0) {
581 wpa_printf(MSG_DEBUG, "%s: Invalid SSID", __func__);
582 os_free(cli);
583 return;
584 }
585 wpa_hexdump_ascii(MSG_DEBUG, "test_driver_assoc: SSID",
586 ssid, ssid_len);
587
588 pos = pos2 + 1;
589 ielen = strlen(pos) / 2;
590 if (ielen > sizeof(ie))
591 ielen = sizeof(ie);
592 if (hexstr2bin(pos, ie, ielen) < 0)
593 ielen = 0;
594 }
595
596 for (bss = drv->bss; bss; bss = bss->next) {
597 if (bss->ssid_len == ssid_len &&
598 memcmp(bss->ssid, ssid, ssid_len) == 0)
599 break;
600 }
601 if (bss == NULL) {
602 wpa_printf(MSG_DEBUG, "%s: No matching SSID found from "
603 "configured BSSes", __func__);
604 os_free(cli);
605 return;
606 }
607
608 cli->bss = bss;
609 memcpy(&cli->un, from, sizeof(cli->un));
610 cli->unlen = fromlen;
611 cli->next = drv->cli;
612 drv->cli = cli;
613 wpa_hexdump_ascii(MSG_DEBUG, "test_socket: ASSOC sun_path",
614 (const u8 *) cli->un.sun_path,
615 cli->unlen - sizeof(cli->un.sun_family));
616
617 snprintf(cmd, sizeof(cmd), "ASSOCRESP " MACSTR " 0",
618 MAC2STR(bss->bssid));
619 sendto(drv->test_socket, cmd, strlen(cmd), 0,
620 (struct sockaddr *) from, fromlen);
621
622 #ifdef HOSTAPD
623 if (hostapd_notif_assoc(bss->bss_ctx, cli->addr, ie, ielen) < 0)
624 wpa_printf(MSG_DEBUG, "test_driver: failed to add new STA");
625 #endif /* HOSTAPD */
626 }
627
628
629 static void test_driver_disassoc(struct wpa_driver_test_data *drv,
630 struct sockaddr_un *from, socklen_t fromlen)
631 {
632 struct test_client_socket *cli;
633
634 cli = test_driver_get_cli(drv, from, fromlen);
635 if (!cli)
636 return;
637
638 #ifdef HOSTAPD
639 hostapd_notif_disassoc(drv->ctx, cli->addr);
640 #endif /* HOSTAPD */
641 }
642
643
644 static void test_driver_eapol(struct wpa_driver_test_data *drv,
645 struct sockaddr_un *from, socklen_t fromlen,
646 u8 *data, size_t datalen)
647 {
648 #ifdef HOSTAPD
649 struct test_client_socket *cli;
650 #endif /* HOSTAPD */
651 const u8 *src = NULL;
652
653 if (datalen > 14) {
654 /* Skip Ethernet header */
655 src = data + ETH_ALEN;
656 wpa_printf(MSG_DEBUG, "test_driver: dst=" MACSTR " src="
657 MACSTR " proto=%04x",
658 MAC2STR(data), MAC2STR(src),
659 WPA_GET_BE16(data + 2 * ETH_ALEN));
660 data += 14;
661 datalen -= 14;
662 }
663 #ifdef HOSTAPD
664 cli = test_driver_get_cli(drv, from, fromlen);
665 if (cli) {
666 hostapd_eapol_receive(cli->bss->bss_ctx, cli->addr, data,
667 datalen);
668 } else {
669 wpa_printf(MSG_DEBUG, "test_socket: EAPOL from unknown "
670 "client");
671 }
672 #else /* HOSTAPD */
673 if (src)
674 wpa_supplicant_rx_eapol(drv->ctx, src, data, datalen);
675 #endif /* HOSTAPD */
676 }
677
678
679 static void test_driver_ether(struct wpa_driver_test_data *drv,
680 struct sockaddr_un *from, socklen_t fromlen,
681 u8 *data, size_t datalen)
682 {
683 struct l2_ethhdr *eth;
684
685 if (datalen < sizeof(*eth))
686 return;
687
688 eth = (struct l2_ethhdr *) data;
689 wpa_printf(MSG_DEBUG, "test_driver: RX ETHER dst=" MACSTR " src="
690 MACSTR " proto=%04x",
691 MAC2STR(eth->h_dest), MAC2STR(eth->h_source),
692 be_to_host16(eth->h_proto));
693
694 #ifdef CONFIG_IEEE80211R
695 if (be_to_host16(eth->h_proto) == ETH_P_RRB) {
696 union wpa_event_data ev;
697 os_memset(&ev, 0, sizeof(ev));
698 ev.ft_rrb_rx.src = eth->h_source;
699 ev.ft_rrb_rx.data = data + sizeof(*eth);
700 ev.ft_rrb_rx.data_len = datalen - sizeof(*eth);
701 }
702 #endif /* CONFIG_IEEE80211R */
703 }
704
705
706 static void test_driver_mlme(struct wpa_driver_test_data *drv,
707 struct sockaddr_un *from, socklen_t fromlen,
708 u8 *data, size_t datalen)
709 {
710 struct ieee80211_hdr *hdr;
711 u16 fc;
712 union wpa_event_data event;
713
714 hdr = (struct ieee80211_hdr *) data;
715
716 if (test_driver_get_cli(drv, from, fromlen) == NULL && datalen >= 16) {
717 struct test_client_socket *cli;
718 cli = os_zalloc(sizeof(*cli));
719 if (cli == NULL)
720 return;
721 wpa_printf(MSG_DEBUG, "Adding client entry for " MACSTR,
722 MAC2STR(hdr->addr2));
723 memcpy(cli->addr, hdr->addr2, ETH_ALEN);
724 memcpy(&cli->un, from, sizeof(cli->un));
725 cli->unlen = fromlen;
726 cli->next = drv->cli;
727 drv->cli = cli;
728 }
729
730 wpa_hexdump(MSG_MSGDUMP, "test_driver_mlme: received frame",
731 data, datalen);
732 fc = le_to_host16(hdr->frame_control);
733 if (WLAN_FC_GET_TYPE(fc) != WLAN_FC_TYPE_MGMT) {
734 wpa_printf(MSG_ERROR, "%s: received non-mgmt frame",
735 __func__);
736 return;
737 }
738
739 os_memset(&event, 0, sizeof(event));
740 event.rx_mgmt.frame = data;
741 event.rx_mgmt.frame_len = datalen;
742 wpa_supplicant_event(drv->ctx, EVENT_RX_MGMT, &event);
743 }
744
745
746 static void test_driver_receive_unix(int sock, void *eloop_ctx, void *sock_ctx)
747 {
748 struct wpa_driver_test_data *drv = eloop_ctx;
749 char buf[2000];
750 int res;
751 struct sockaddr_un from;
752 socklen_t fromlen = sizeof(from);
753
754 res = recvfrom(sock, buf, sizeof(buf) - 1, 0,
755 (struct sockaddr *) &from, &fromlen);
756 if (res < 0) {
757 perror("recvfrom(test_socket)");
758 return;
759 }
760 buf[res] = '\0';
761
762 wpa_printf(MSG_DEBUG, "test_driver: received %u bytes", res);
763
764 if (strncmp(buf, "SCAN", 4) == 0) {
765 test_driver_scan(drv, &from, fromlen, buf + 4);
766 } else if (strncmp(buf, "ASSOC ", 6) == 0) {
767 test_driver_assoc(drv, &from, fromlen, buf + 6);
768 } else if (strcmp(buf, "DISASSOC") == 0) {
769 test_driver_disassoc(drv, &from, fromlen);
770 } else if (strncmp(buf, "EAPOL ", 6) == 0) {
771 test_driver_eapol(drv, &from, fromlen, (u8 *) buf + 6,
772 res - 6);
773 } else if (strncmp(buf, "ETHER ", 6) == 0) {
774 test_driver_ether(drv, &from, fromlen, (u8 *) buf + 6,
775 res - 6);
776 } else if (strncmp(buf, "MLME ", 5) == 0) {
777 test_driver_mlme(drv, &from, fromlen, (u8 *) buf + 5, res - 5);
778 } else {
779 wpa_hexdump_ascii(MSG_DEBUG, "Unknown test_socket command",
780 (u8 *) buf, res);
781 }
782 }
783
784
785 static struct test_driver_bss *
786 test_driver_get_bss(struct wpa_driver_test_data *drv, const char *ifname)
787 {
788 struct test_driver_bss *bss;
789
790 for (bss = drv->bss; bss; bss = bss->next) {
791 if (os_strcmp(bss->ifname, ifname) == 0)
792 return bss;
793 }
794 return NULL;
795 }
796
797
798 static int test_driver_set_generic_elem(const char *ifname, void *priv,
799 const u8 *elem, size_t elem_len)
800 {
801 struct wpa_driver_test_data *drv = priv;
802 struct test_driver_bss *bss;
803
804 bss = test_driver_get_bss(drv, ifname);
805 if (bss == NULL)
806 return -1;
807
808 os_free(bss->ie);
809
810 if (elem == NULL) {
811 bss->ie = NULL;
812 bss->ielen = 0;
813 return 0;
814 }
815
816 bss->ie = os_malloc(elem_len);
817 if (bss->ie == NULL) {
818 bss->ielen = 0;
819 return -1;
820 }
821
822 memcpy(bss->ie, elem, elem_len);
823 bss->ielen = elem_len;
824 return 0;
825 }
826
827
828 static int test_driver_set_ap_wps_ie(const char *ifname, void *priv,
829 const struct wpabuf *beacon,
830 const struct wpabuf *proberesp)
831 {
832 struct wpa_driver_test_data *drv = priv;
833 struct test_driver_bss *bss;
834
835 bss = test_driver_get_bss(drv, ifname);
836 if (bss == NULL)
837 return -1;
838
839 if (beacon == NULL)
840 wpa_printf(MSG_DEBUG, "test_driver: Clear Beacon WPS IE");
841 else
842 wpa_hexdump_buf(MSG_DEBUG, "test_driver: Beacon WPS IE",
843 beacon);
844
845 os_free(bss->wps_beacon_ie);
846
847 if (beacon == NULL) {
848 bss->wps_beacon_ie = NULL;
849 bss->wps_beacon_ie_len = 0;
850 } else {
851 bss->wps_beacon_ie = os_malloc(wpabuf_len(beacon));
852 if (bss->wps_beacon_ie == NULL) {
853 bss->wps_beacon_ie_len = 0;
854 return -1;
855 }
856
857 os_memcpy(bss->wps_beacon_ie, wpabuf_head(beacon),
858 wpabuf_len(beacon));
859 bss->wps_beacon_ie_len = wpabuf_len(beacon);
860 }
861
862 if (proberesp == NULL)
863 wpa_printf(MSG_DEBUG, "test_driver: Clear Probe Response WPS "
864 "IE");
865 else
866 wpa_hexdump_buf(MSG_DEBUG, "test_driver: Probe Response WPS "
867 "IE", proberesp);
868
869 os_free(bss->wps_probe_resp_ie);
870
871 if (proberesp == NULL) {
872 bss->wps_probe_resp_ie = NULL;
873 bss->wps_probe_resp_ie_len = 0;
874 } else {
875 bss->wps_probe_resp_ie = os_malloc(wpabuf_len(proberesp));
876 if (bss->wps_probe_resp_ie == NULL) {
877 bss->wps_probe_resp_ie_len = 0;
878 return -1;
879 }
880
881 os_memcpy(bss->wps_probe_resp_ie, wpabuf_head(proberesp),
882 wpabuf_len(proberesp));
883 bss->wps_probe_resp_ie_len = wpabuf_len(proberesp);
884 }
885
886 return 0;
887 }
888
889
890 static int test_driver_sta_deauth(void *priv, const u8 *own_addr,
891 const u8 *addr, int reason)
892 {
893 struct wpa_driver_test_data *drv = priv;
894 struct test_client_socket *cli;
895
896 if (drv->test_socket < 0)
897 return -1;
898
899 cli = drv->cli;
900 while (cli) {
901 if (memcmp(cli->addr, addr, ETH_ALEN) == 0)
902 break;
903 cli = cli->next;
904 }
905
906 if (!cli)
907 return -1;
908
909 return sendto(drv->test_socket, "DEAUTH", 6, 0,
910 (struct sockaddr *) &cli->un, cli->unlen);
911 }
912
913
914 static int test_driver_sta_disassoc(void *priv, const u8 *own_addr,
915 const u8 *addr, int reason)
916 {
917 struct wpa_driver_test_data *drv = priv;
918 struct test_client_socket *cli;
919
920 if (drv->test_socket < 0)
921 return -1;
922
923 cli = drv->cli;
924 while (cli) {
925 if (memcmp(cli->addr, addr, ETH_ALEN) == 0)
926 break;
927 cli = cli->next;
928 }
929
930 if (!cli)
931 return -1;
932
933 return sendto(drv->test_socket, "DISASSOC", 8, 0,
934 (struct sockaddr *) &cli->un, cli->unlen);
935 }
936
937
938 static int test_driver_bss_add(void *priv, const char *ifname, const u8 *bssid,
939 void *bss_ctx)
940 {
941 struct wpa_driver_test_data *drv = priv;
942 struct test_driver_bss *bss;
943
944 wpa_printf(MSG_DEBUG, "%s(ifname=%s bssid=" MACSTR ")",
945 __func__, ifname, MAC2STR(bssid));
946
947 bss = os_zalloc(sizeof(*bss));
948 if (bss == NULL)
949 return -1;
950
951 bss->bss_ctx = bss_ctx;
952 os_strlcpy(bss->ifname, ifname, IFNAMSIZ);
953 memcpy(bss->bssid, bssid, ETH_ALEN);
954
955 bss->next = drv->bss;
956 drv->bss = bss;
957
958 return 0;
959 }
960
961
962 static int test_driver_bss_remove(void *priv, const char *ifname)
963 {
964 struct wpa_driver_test_data *drv = priv;
965 struct test_driver_bss *bss, *prev;
966 struct test_client_socket *cli, *prev_c;
967
968 wpa_printf(MSG_DEBUG, "%s(ifname=%s)", __func__, ifname);
969
970 for (prev = NULL, bss = drv->bss; bss; prev = bss, bss = bss->next) {
971 if (strcmp(bss->ifname, ifname) != 0)
972 continue;
973
974 if (prev)
975 prev->next = bss->next;
976 else
977 drv->bss = bss->next;
978
979 for (prev_c = NULL, cli = drv->cli; cli;
980 prev_c = cli, cli = cli->next) {
981 if (cli->bss != bss)
982 continue;
983 if (prev_c)
984 prev_c->next = cli->next;
985 else
986 drv->cli = cli->next;
987 os_free(cli);
988 break;
989 }
990
991 test_driver_free_bss(bss);
992 return 0;
993 }
994
995 return -1;
996 }
997
998
999 static int test_driver_if_add(const char *iface, void *priv,
1000 enum wpa_driver_if_type type, const char *ifname,
1001 const u8 *addr, void *bss_ctx)
1002 {
1003 wpa_printf(MSG_DEBUG, "%s(iface=%s type=%d ifname=%s bss_ctx=%p)",
1004 __func__, iface, type, ifname, bss_ctx);
1005 if (type == WPA_IF_AP_BSS)
1006 return test_driver_bss_add(priv, ifname, addr, bss_ctx);
1007 return 0;
1008 }
1009
1010
1011 static int test_driver_if_remove(void *priv, enum wpa_driver_if_type type,
1012 const char *ifname)
1013 {
1014 wpa_printf(MSG_DEBUG, "%s(type=%d ifname=%s)", __func__, type, ifname);
1015 if (type == WPA_IF_AP_BSS)
1016 return test_driver_bss_remove(priv, ifname);
1017 return 0;
1018 }
1019
1020
1021 static int test_driver_valid_bss_mask(void *priv, const u8 *addr,
1022 const u8 *mask)
1023 {
1024 return 0;
1025 }
1026
1027
1028 static int test_driver_set_ssid(const char *ifname, void *priv, const u8 *buf,
1029 int len)
1030 {
1031 struct wpa_driver_test_data *drv = priv;
1032 struct test_driver_bss *bss;
1033
1034 wpa_printf(MSG_DEBUG, "%s(ifname=%s)", __func__, ifname);
1035 wpa_hexdump_ascii(MSG_DEBUG, "test_driver_set_ssid: SSID", buf, len);
1036
1037 bss = test_driver_get_bss(drv, ifname);
1038 if (bss == NULL) {
1039 wpa_printf(MSG_DEBUG, "%s(ifname=%s): failed to find BSS data",
1040 __func__, ifname);
1041 return -1;
1042 }
1043
1044 if (len < 0 || (size_t) len > sizeof(bss->ssid))
1045 return -1;
1046
1047 os_memcpy(bss->ssid, buf, len);
1048 bss->ssid_len = len;
1049
1050 return 0;
1051 }
1052
1053
1054 static int test_driver_set_privacy(const char *ifname, void *priv, int enabled)
1055 {
1056 struct wpa_driver_test_data *drv = priv;
1057 struct test_driver_bss *bss;
1058
1059 wpa_printf(MSG_DEBUG, "%s(ifname=%s enabled=%d)",
1060 __func__, ifname, enabled);
1061
1062 bss = test_driver_get_bss(drv, ifname);
1063 if (bss == NULL)
1064 return -1;
1065
1066 bss->privacy = enabled;
1067
1068 return 0;
1069 }
1070
1071
1072 static int test_driver_set_sta_vlan(void *priv, const u8 *addr,
1073 const char *ifname, int vlan_id)
1074 {
1075 wpa_printf(MSG_DEBUG, "%s(addr=" MACSTR " ifname=%s vlan_id=%d)",
1076 __func__, MAC2STR(addr), ifname, vlan_id);
1077 return 0;
1078 }
1079
1080
1081 static int test_driver_sta_add(const char *ifname, void *priv,
1082 struct hostapd_sta_add_params *params)
1083 {
1084 struct wpa_driver_test_data *drv = priv;
1085 struct test_client_socket *cli;
1086 struct test_driver_bss *bss;
1087
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);
1094
1095 cli = drv->cli;
1096 while (cli) {
1097 if (os_memcmp(cli->addr, params->addr, ETH_ALEN) == 0)
1098 break;
1099 cli = cli->next;
1100 }
1101 if (!cli) {
1102 wpa_printf(MSG_DEBUG, "%s: no matching client entry",
1103 __func__);
1104 return -1;
1105 }
1106
1107 bss = test_driver_get_bss(drv, ifname);
1108 if (bss == NULL) {
1109 wpa_printf(MSG_DEBUG, "%s: No matching interface found from "
1110 "configured BSSes", __func__);
1111 return -1;
1112 }
1113
1114 cli->bss = bss;
1115
1116 return 0;
1117 }
1118
1119
1120 static struct wpa_driver_test_data * test_alloc_data(void *ctx,
1121 const char *ifname)
1122 {
1123 struct wpa_driver_test_data *drv;
1124
1125 drv = os_zalloc(sizeof(struct wpa_driver_test_data));
1126 if (drv == NULL) {
1127 wpa_printf(MSG_ERROR, "Could not allocate memory for test "
1128 "driver data");
1129 return NULL;
1130 }
1131
1132 drv->ctx = ctx;
1133 wpa_trace_add_ref(drv, ctx, ctx);
1134 os_strlcpy(drv->ifname, ifname, IFNAMSIZ);
1135
1136 /* Generate a MAC address to help testing with multiple STAs */
1137 drv->own_addr[0] = 0x02; /* locally administered */
1138 sha1_prf((const u8 *) ifname, os_strlen(ifname),
1139 "test mac addr generation",
1140 NULL, 0, drv->own_addr + 1, ETH_ALEN - 1);
1141
1142 return drv;
1143 }
1144
1145
1146 static void * test_driver_init(struct hostapd_data *hapd,
1147 struct wpa_init_params *params)
1148 {
1149 struct wpa_driver_test_data *drv;
1150 struct sockaddr_un addr_un;
1151 struct sockaddr_in addr_in;
1152 struct sockaddr *addr;
1153 socklen_t alen;
1154
1155 drv = test_alloc_data(hapd, params->ifname);
1156 if (drv == NULL)
1157 return NULL;
1158 drv->ap = 1;
1159 drv->bss = os_zalloc(sizeof(*drv->bss));
1160 if (drv->bss == NULL) {
1161 wpa_printf(MSG_ERROR, "Could not allocate memory for test "
1162 "driver BSS data");
1163 os_free(drv);
1164 return NULL;
1165 }
1166
1167 drv->bss->bss_ctx = hapd;
1168 os_strlcpy(drv->bss->ifname, params->ifname, IFNAMSIZ);
1169 os_memcpy(drv->bss->bssid, drv->own_addr, ETH_ALEN);
1170 os_memcpy(params->own_addr, drv->own_addr, ETH_ALEN);
1171
1172 if (params->test_socket) {
1173 if (os_strlen(params->test_socket) >=
1174 sizeof(addr_un.sun_path)) {
1175 printf("Too long test_socket path\n");
1176 wpa_driver_test_deinit(drv);
1177 return NULL;
1178 }
1179 if (strncmp(params->test_socket, "DIR:", 4) == 0) {
1180 size_t len = strlen(params->test_socket) + 30;
1181 drv->test_dir = os_strdup(params->test_socket + 4);
1182 drv->own_socket_path = os_malloc(len);
1183 if (drv->own_socket_path) {
1184 snprintf(drv->own_socket_path, len,
1185 "%s/AP-" MACSTR,
1186 params->test_socket + 4,
1187 MAC2STR(params->own_addr));
1188 }
1189 } else if (strncmp(params->test_socket, "UDP:", 4) == 0) {
1190 drv->udp_port = atoi(params->test_socket + 4);
1191 } else {
1192 drv->own_socket_path = os_strdup(params->test_socket);
1193 }
1194 if (drv->own_socket_path == NULL && drv->udp_port == 0) {
1195 wpa_driver_test_deinit(drv);
1196 return NULL;
1197 }
1198
1199 drv->test_socket = socket(drv->udp_port ? PF_INET : PF_UNIX,
1200 SOCK_DGRAM, 0);
1201 if (drv->test_socket < 0) {
1202 perror("socket");
1203 wpa_driver_test_deinit(drv);
1204 return NULL;
1205 }
1206
1207 if (drv->udp_port) {
1208 os_memset(&addr_in, 0, sizeof(addr_in));
1209 addr_in.sin_family = AF_INET;
1210 addr_in.sin_port = htons(drv->udp_port);
1211 addr = (struct sockaddr *) &addr_in;
1212 alen = sizeof(addr_in);
1213 } else {
1214 os_memset(&addr_un, 0, sizeof(addr_un));
1215 addr_un.sun_family = AF_UNIX;
1216 os_strlcpy(addr_un.sun_path, drv->own_socket_path,
1217 sizeof(addr_un.sun_path));
1218 addr = (struct sockaddr *) &addr_un;
1219 alen = sizeof(addr_un);
1220 }
1221 if (bind(drv->test_socket, addr, alen) < 0) {
1222 perror("bind(PF_UNIX)");
1223 close(drv->test_socket);
1224 if (drv->own_socket_path)
1225 unlink(drv->own_socket_path);
1226 wpa_driver_test_deinit(drv);
1227 return NULL;
1228 }
1229 eloop_register_read_sock(drv->test_socket,
1230 test_driver_receive_unix, drv, NULL);
1231 } else
1232 drv->test_socket = -1;
1233
1234 return drv;
1235 }
1236
1237
1238 static void wpa_driver_test_poll(void *eloop_ctx, void *timeout_ctx)
1239 {
1240 struct wpa_driver_test_data *drv = eloop_ctx;
1241
1242 #ifdef DRIVER_TEST_UNIX
1243 if (drv->associated && drv->hostapd_addr_set) {
1244 struct stat st;
1245 if (stat(drv->hostapd_addr.sun_path, &st) < 0) {
1246 wpa_printf(MSG_DEBUG, "%s: lost connection to AP: %s",
1247 __func__, strerror(errno));
1248 drv->associated = 0;
1249 wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL);
1250 }
1251 }
1252 #endif /* DRIVER_TEST_UNIX */
1253
1254 eloop_register_timeout(1, 0, wpa_driver_test_poll, drv, NULL);
1255 }
1256
1257
1258 static void wpa_driver_test_scan_timeout(void *eloop_ctx, void *timeout_ctx)
1259 {
1260 wpa_printf(MSG_DEBUG, "Scan timeout - try to get results");
1261 wpa_supplicant_event(timeout_ctx, EVENT_SCAN_RESULTS, NULL);
1262 }
1263
1264
1265 #ifdef DRIVER_TEST_UNIX
1266 static void wpa_driver_scan_dir(struct wpa_driver_test_data *drv,
1267 const char *path)
1268 {
1269 struct dirent *dent;
1270 DIR *dir;
1271 struct sockaddr_un addr;
1272 char cmd[512], *pos, *end;
1273 int ret;
1274
1275 dir = opendir(path);
1276 if (dir == NULL)
1277 return;
1278
1279 end = cmd + sizeof(cmd);
1280 pos = cmd;
1281 ret = os_snprintf(pos, end - pos, "SCAN " MACSTR,
1282 MAC2STR(drv->own_addr));
1283 if (ret >= 0 && ret < end - pos)
1284 pos += ret;
1285 if (drv->probe_req_ie) {
1286 ret = os_snprintf(pos, end - pos, " ");
1287 if (ret >= 0 && ret < end - pos)
1288 pos += ret;
1289 pos += wpa_snprintf_hex(pos, end - pos, drv->probe_req_ie,
1290 drv->probe_req_ie_len);
1291 }
1292 end[-1] = '\0';
1293
1294 while ((dent = readdir(dir))) {
1295 if (os_strncmp(dent->d_name, "AP-", 3) != 0 &&
1296 os_strncmp(dent->d_name, "STA-", 4) != 0)
1297 continue;
1298 if (drv->own_socket_path) {
1299 size_t olen, dlen;
1300 olen = os_strlen(drv->own_socket_path);
1301 dlen = os_strlen(dent->d_name);
1302 if (olen >= dlen &&
1303 os_strcmp(dent->d_name,
1304 drv->own_socket_path + olen - dlen) == 0)
1305 continue;
1306 }
1307 wpa_printf(MSG_DEBUG, "%s: SCAN %s", __func__, dent->d_name);
1308
1309 os_memset(&addr, 0, sizeof(addr));
1310 addr.sun_family = AF_UNIX;
1311 os_snprintf(addr.sun_path, sizeof(addr.sun_path), "%s/%s",
1312 path, dent->d_name);
1313
1314 if (sendto(drv->test_socket, cmd, os_strlen(cmd), 0,
1315 (struct sockaddr *) &addr, sizeof(addr)) < 0) {
1316 perror("sendto(test_socket)");
1317 }
1318 }
1319 closedir(dir);
1320 }
1321 #endif /* DRIVER_TEST_UNIX */
1322
1323
1324 static int wpa_driver_test_scan(void *priv,
1325 struct wpa_driver_scan_params *params)
1326 {
1327 struct wpa_driver_test_data *drv = priv;
1328 size_t i;
1329
1330 wpa_printf(MSG_DEBUG, "%s: priv=%p", __func__, priv);
1331
1332 os_free(drv->probe_req_ie);
1333 if (params->extra_ies) {
1334 drv->probe_req_ie = os_malloc(params->extra_ies_len);
1335 if (drv->probe_req_ie == NULL) {
1336 drv->probe_req_ie_len = 0;
1337 return -1;
1338 }
1339 os_memcpy(drv->probe_req_ie, params->extra_ies,
1340 params->extra_ies_len);
1341 drv->probe_req_ie_len = params->extra_ies_len;
1342 } else {
1343 drv->probe_req_ie = NULL;
1344 drv->probe_req_ie_len = 0;
1345 }
1346
1347 for (i = 0; i < params->num_ssids; i++)
1348 wpa_hexdump(MSG_DEBUG, "Scan SSID",
1349 params->ssids[i].ssid, params->ssids[i].ssid_len);
1350 wpa_hexdump(MSG_DEBUG, "Scan extra IE(s)",
1351 params->extra_ies, params->extra_ies_len);
1352
1353 drv->num_scanres = 0;
1354
1355 #ifdef DRIVER_TEST_UNIX
1356 if (drv->test_socket >= 0 && drv->test_dir)
1357 wpa_driver_scan_dir(drv, drv->test_dir);
1358
1359 if (drv->test_socket >= 0 && drv->hostapd_addr_set &&
1360 sendto(drv->test_socket, "SCAN", 4, 0,
1361 (struct sockaddr *) &drv->hostapd_addr,
1362 sizeof(drv->hostapd_addr)) < 0) {
1363 perror("sendto(test_socket)");
1364 }
1365 #endif /* DRIVER_TEST_UNIX */
1366
1367 if (drv->test_socket >= 0 && drv->hostapd_addr_udp_set &&
1368 sendto(drv->test_socket, "SCAN", 4, 0,
1369 (struct sockaddr *) &drv->hostapd_addr_udp,
1370 sizeof(drv->hostapd_addr_udp)) < 0) {
1371 perror("sendto(test_socket)");
1372 }
1373
1374 eloop_cancel_timeout(wpa_driver_test_scan_timeout, drv, drv->ctx);
1375 eloop_register_timeout(1, 0, wpa_driver_test_scan_timeout, drv,
1376 drv->ctx);
1377 return 0;
1378 }
1379
1380
1381 static struct wpa_scan_results * wpa_driver_test_get_scan_results2(void *priv)
1382 {
1383 struct wpa_driver_test_data *drv = priv;
1384 struct wpa_scan_results *res;
1385 size_t i;
1386
1387 res = os_zalloc(sizeof(*res));
1388 if (res == NULL)
1389 return NULL;
1390
1391 res->res = os_zalloc(drv->num_scanres * sizeof(struct wpa_scan_res *));
1392 if (res->res == NULL) {
1393 os_free(res);
1394 return NULL;
1395 }
1396
1397 for (i = 0; i < drv->num_scanres; i++) {
1398 struct wpa_scan_res *r;
1399 if (drv->scanres[i] == NULL)
1400 continue;
1401 r = os_malloc(sizeof(*r) + drv->scanres[i]->ie_len);
1402 if (r == NULL)
1403 break;
1404 os_memcpy(r, drv->scanres[i],
1405 sizeof(*r) + drv->scanres[i]->ie_len);
1406 res->res[res->num++] = r;
1407 }
1408
1409 return res;
1410 }
1411
1412
1413 static int wpa_driver_test_set_key(const char *ifname, void *priv,
1414 enum wpa_alg alg, const u8 *addr,
1415 int key_idx, int set_tx,
1416 const u8 *seq, size_t seq_len,
1417 const u8 *key, size_t key_len)
1418 {
1419 wpa_printf(MSG_DEBUG, "%s: ifname=%s priv=%p alg=%d key_idx=%d "
1420 "set_tx=%d",
1421 __func__, ifname, priv, alg, key_idx, set_tx);
1422 if (addr)
1423 wpa_printf(MSG_DEBUG, " addr=" MACSTR, MAC2STR(addr));
1424 if (seq)
1425 wpa_hexdump(MSG_DEBUG, " seq", seq, seq_len);
1426 if (key)
1427 wpa_hexdump_key(MSG_DEBUG, " key", key, key_len);
1428 return 0;
1429 }
1430
1431
1432 static int wpa_driver_update_mode(struct wpa_driver_test_data *drv, int ap)
1433 {
1434 if (ap && !drv->ap) {
1435 wpa_driver_test_close_test_socket(drv);
1436 wpa_driver_test_attach(drv, drv->test_dir, 1);
1437 drv->ap = 1;
1438 } else if (!ap && drv->ap) {
1439 wpa_driver_test_close_test_socket(drv);
1440 wpa_driver_test_attach(drv, drv->test_dir, 0);
1441 drv->ap = 0;
1442 }
1443
1444 return 0;
1445 }
1446
1447
1448 static int wpa_driver_test_associate(
1449 void *priv, struct wpa_driver_associate_params *params)
1450 {
1451 struct wpa_driver_test_data *drv = priv;
1452 wpa_printf(MSG_DEBUG, "%s: priv=%p freq=%d pairwise_suite=%d "
1453 "group_suite=%d key_mgmt_suite=%d auth_alg=%d mode=%d",
1454 __func__, priv, params->freq, params->pairwise_suite,
1455 params->group_suite, params->key_mgmt_suite,
1456 params->auth_alg, params->mode);
1457 if (params->bssid) {
1458 wpa_printf(MSG_DEBUG, " bssid=" MACSTR,
1459 MAC2STR(params->bssid));
1460 }
1461 if (params->ssid) {
1462 wpa_hexdump_ascii(MSG_DEBUG, " ssid",
1463 params->ssid, params->ssid_len);
1464 }
1465 if (params->wpa_ie) {
1466 wpa_hexdump(MSG_DEBUG, " wpa_ie",
1467 params->wpa_ie, params->wpa_ie_len);
1468 drv->assoc_wpa_ie_len = params->wpa_ie_len;
1469 if (drv->assoc_wpa_ie_len > sizeof(drv->assoc_wpa_ie))
1470 drv->assoc_wpa_ie_len = sizeof(drv->assoc_wpa_ie);
1471 os_memcpy(drv->assoc_wpa_ie, params->wpa_ie,
1472 drv->assoc_wpa_ie_len);
1473 } else
1474 drv->assoc_wpa_ie_len = 0;
1475
1476 wpa_driver_update_mode(drv, params->mode == IEEE80211_MODE_AP);
1477
1478 drv->ibss = params->mode == IEEE80211_MODE_IBSS;
1479 drv->privacy = params->key_mgmt_suite &
1480 (WPA_KEY_MGMT_IEEE8021X |
1481 WPA_KEY_MGMT_PSK |
1482 WPA_KEY_MGMT_WPA_NONE |
1483 WPA_KEY_MGMT_FT_IEEE8021X |
1484 WPA_KEY_MGMT_FT_PSK |
1485 WPA_KEY_MGMT_IEEE8021X_SHA256 |
1486 WPA_KEY_MGMT_PSK_SHA256);
1487 if (params->wep_key_len[params->wep_tx_keyidx])
1488 drv->privacy = 1;
1489
1490 #ifdef DRIVER_TEST_UNIX
1491 if (drv->test_dir && params->bssid &&
1492 params->mode != IEEE80211_MODE_IBSS) {
1493 os_memset(&drv->hostapd_addr, 0, sizeof(drv->hostapd_addr));
1494 drv->hostapd_addr.sun_family = AF_UNIX;
1495 os_snprintf(drv->hostapd_addr.sun_path,
1496 sizeof(drv->hostapd_addr.sun_path),
1497 "%s/AP-" MACSTR,
1498 drv->test_dir, MAC2STR(params->bssid));
1499 drv->hostapd_addr_set = 1;
1500 }
1501 #endif /* DRIVER_TEST_UNIX */
1502
1503 if (params->mode == IEEE80211_MODE_AP) {
1504 struct test_driver_bss *bss;
1505 os_memcpy(drv->ssid, params->ssid, params->ssid_len);
1506 drv->ssid_len = params->ssid_len;
1507
1508 test_driver_free_bsses(drv);
1509 bss = drv->bss = os_zalloc(sizeof(*drv->bss));
1510 if (bss == NULL)
1511 return -1;
1512 os_strlcpy(bss->ifname, drv->ifname, IFNAMSIZ);
1513 os_memcpy(bss->bssid, drv->own_addr, ETH_ALEN);
1514 os_memcpy(bss->ssid, params->ssid, params->ssid_len);
1515 bss->ssid_len = params->ssid_len;
1516 bss->privacy = drv->privacy;
1517 if (params->wpa_ie && params->wpa_ie_len) {
1518 bss->ie = os_malloc(params->wpa_ie_len);
1519 if (bss->ie) {
1520 os_memcpy(bss->ie, params->wpa_ie,
1521 params->wpa_ie_len);
1522 bss->ielen = params->wpa_ie_len;
1523 }
1524 }
1525 } else if (drv->test_socket >= 0 &&
1526 (drv->hostapd_addr_set || drv->hostapd_addr_udp_set)) {
1527 char cmd[200], *pos, *end;
1528 int ret;
1529 end = cmd + sizeof(cmd);
1530 pos = cmd;
1531 ret = os_snprintf(pos, end - pos, "ASSOC " MACSTR " ",
1532 MAC2STR(drv->own_addr));
1533 if (ret >= 0 && ret < end - pos)
1534 pos += ret;
1535 pos += wpa_snprintf_hex(pos, end - pos, params->ssid,
1536 params->ssid_len);
1537 ret = os_snprintf(pos, end - pos, " ");
1538 if (ret >= 0 && ret < end - pos)
1539 pos += ret;
1540 pos += wpa_snprintf_hex(pos, end - pos, params->wpa_ie,
1541 params->wpa_ie_len);
1542 end[-1] = '\0';
1543 #ifdef DRIVER_TEST_UNIX
1544 if (drv->hostapd_addr_set &&
1545 sendto(drv->test_socket, cmd, os_strlen(cmd), 0,
1546 (struct sockaddr *) &drv->hostapd_addr,
1547 sizeof(drv->hostapd_addr)) < 0) {
1548 perror("sendto(test_socket)");
1549 return -1;
1550 }
1551 #endif /* DRIVER_TEST_UNIX */
1552 if (drv->hostapd_addr_udp_set &&
1553 sendto(drv->test_socket, cmd, os_strlen(cmd), 0,
1554 (struct sockaddr *) &drv->hostapd_addr_udp,
1555 sizeof(drv->hostapd_addr_udp)) < 0) {
1556 perror("sendto(test_socket)");
1557 return -1;
1558 }
1559
1560 os_memcpy(drv->ssid, params->ssid, params->ssid_len);
1561 drv->ssid_len = params->ssid_len;
1562 } else {
1563 drv->associated = 1;
1564 if (params->mode == IEEE80211_MODE_IBSS) {
1565 os_memcpy(drv->ssid, params->ssid, params->ssid_len);
1566 drv->ssid_len = params->ssid_len;
1567 if (params->bssid)
1568 os_memcpy(drv->bssid, params->bssid, ETH_ALEN);
1569 else {
1570 os_get_random(drv->bssid, ETH_ALEN);
1571 drv->bssid[0] &= ~0x01;
1572 drv->bssid[0] |= 0x02;
1573 }
1574 }
1575 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, NULL);
1576 }
1577
1578 return 0;
1579 }
1580
1581
1582 static int wpa_driver_test_get_bssid(void *priv, u8 *bssid)
1583 {
1584 struct wpa_driver_test_data *drv = priv;
1585 os_memcpy(bssid, drv->bssid, ETH_ALEN);
1586 return 0;
1587 }
1588
1589
1590 static int wpa_driver_test_get_ssid(void *priv, u8 *ssid)
1591 {
1592 struct wpa_driver_test_data *drv = priv;
1593 os_memcpy(ssid, drv->ssid, 32);
1594 return drv->ssid_len;
1595 }
1596
1597
1598 static int wpa_driver_test_send_disassoc(struct wpa_driver_test_data *drv)
1599 {
1600 #ifdef DRIVER_TEST_UNIX
1601 if (drv->test_socket >= 0 &&
1602 sendto(drv->test_socket, "DISASSOC", 8, 0,
1603 (struct sockaddr *) &drv->hostapd_addr,
1604 sizeof(drv->hostapd_addr)) < 0) {
1605 perror("sendto(test_socket)");
1606 return -1;
1607 }
1608 #endif /* DRIVER_TEST_UNIX */
1609 if (drv->test_socket >= 0 && drv->hostapd_addr_udp_set &&
1610 sendto(drv->test_socket, "DISASSOC", 8, 0,
1611 (struct sockaddr *) &drv->hostapd_addr_udp,
1612 sizeof(drv->hostapd_addr_udp)) < 0) {
1613 perror("sendto(test_socket)");
1614 return -1;
1615 }
1616 return 0;
1617 }
1618
1619
1620 static int wpa_driver_test_deauthenticate(void *priv, const u8 *addr,
1621 int reason_code)
1622 {
1623 struct wpa_driver_test_data *drv = priv;
1624 wpa_printf(MSG_DEBUG, "%s addr=" MACSTR " reason_code=%d",
1625 __func__, MAC2STR(addr), reason_code);
1626 os_memset(drv->bssid, 0, ETH_ALEN);
1627 drv->associated = 0;
1628 wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL);
1629 return wpa_driver_test_send_disassoc(drv);
1630 }
1631
1632
1633 static int wpa_driver_test_disassociate(void *priv, const u8 *addr,
1634 int reason_code)
1635 {
1636 struct wpa_driver_test_data *drv = priv;
1637 wpa_printf(MSG_DEBUG, "%s addr=" MACSTR " reason_code=%d",
1638 __func__, MAC2STR(addr), reason_code);
1639 os_memset(drv->bssid, 0, ETH_ALEN);
1640 drv->associated = 0;
1641 wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL);
1642 return wpa_driver_test_send_disassoc(drv);
1643 }
1644
1645
1646 static void wpa_driver_test_scanresp(struct wpa_driver_test_data *drv,
1647 struct sockaddr *from,
1648 socklen_t fromlen,
1649 const char *data)
1650 {
1651 struct wpa_scan_res *res;
1652 const char *pos, *pos2;
1653 size_t len;
1654 u8 *ie_pos, *ie_start, *ie_end;
1655 #define MAX_IE_LEN 1000
1656
1657 wpa_printf(MSG_DEBUG, "test_driver: SCANRESP %s", data);
1658 if (drv->num_scanres >= MAX_SCAN_RESULTS) {
1659 wpa_printf(MSG_DEBUG, "test_driver: No room for the new scan "
1660 "result");
1661 return;
1662 }
1663
1664 /* SCANRESP BSSID SSID IEs */
1665
1666 res = os_zalloc(sizeof(*res) + MAX_IE_LEN);
1667 if (res == NULL)
1668 return;
1669 ie_start = ie_pos = (u8 *) (res + 1);
1670 ie_end = ie_pos + MAX_IE_LEN;
1671
1672 if (hwaddr_aton(data, res->bssid)) {
1673 wpa_printf(MSG_DEBUG, "test_driver: invalid BSSID in scanres");
1674 os_free(res);
1675 return;
1676 }
1677
1678 pos = data + 17;
1679 while (*pos == ' ')
1680 pos++;
1681 pos2 = os_strchr(pos, ' ');
1682 if (pos2 == NULL) {
1683 wpa_printf(MSG_DEBUG, "test_driver: invalid SSID termination "
1684 "in scanres");
1685 os_free(res);
1686 return;
1687 }
1688 len = (pos2 - pos) / 2;
1689 if (len > 32)
1690 len = 32;
1691 /*
1692 * Generate SSID IE from the SSID field since this IE is not included
1693 * in the main IE field.
1694 */
1695 *ie_pos++ = WLAN_EID_SSID;
1696 *ie_pos++ = len;
1697 if (hexstr2bin(pos, ie_pos, len) < 0) {
1698 wpa_printf(MSG_DEBUG, "test_driver: invalid SSID in scanres");
1699 os_free(res);
1700 return;
1701 }
1702 ie_pos += len;
1703
1704 pos = pos2 + 1;
1705 pos2 = os_strchr(pos, ' ');
1706 if (pos2 == NULL)
1707 len = os_strlen(pos) / 2;
1708 else
1709 len = (pos2 - pos) / 2;
1710 if ((int) len > ie_end - ie_pos)
1711 len = ie_end - ie_pos;
1712 if (hexstr2bin(pos, ie_pos, len) < 0) {
1713 wpa_printf(MSG_DEBUG, "test_driver: invalid IEs in scanres");
1714 os_free(res);
1715 return;
1716 }
1717 ie_pos += len;
1718 res->ie_len = ie_pos - ie_start;
1719
1720 if (pos2) {
1721 pos = pos2 + 1;
1722 while (*pos == ' ')
1723 pos++;
1724 if (os_strstr(pos, "PRIVACY"))
1725 res->caps |= IEEE80211_CAP_PRIVACY;
1726 if (os_strstr(pos, "IBSS"))
1727 res->caps |= IEEE80211_CAP_IBSS;
1728 }
1729
1730 os_free(drv->scanres[drv->num_scanres]);
1731 drv->scanres[drv->num_scanres++] = res;
1732 }
1733
1734
1735 static void wpa_driver_test_assocresp(struct wpa_driver_test_data *drv,
1736 struct sockaddr *from,
1737 socklen_t fromlen,
1738 const char *data)
1739 {
1740 /* ASSOCRESP BSSID <res> */
1741 if (hwaddr_aton(data, drv->bssid)) {
1742 wpa_printf(MSG_DEBUG, "test_driver: invalid BSSID in "
1743 "assocresp");
1744 }
1745 if (drv->use_associnfo) {
1746 union wpa_event_data event;
1747 os_memset(&event, 0, sizeof(event));
1748 event.assoc_info.req_ies = drv->assoc_wpa_ie;
1749 event.assoc_info.req_ies_len = drv->assoc_wpa_ie_len;
1750 wpa_supplicant_event(drv->ctx, EVENT_ASSOCINFO, &event);
1751 }
1752 drv->associated = 1;
1753 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, NULL);
1754 }
1755
1756
1757 static void wpa_driver_test_disassoc(struct wpa_driver_test_data *drv,
1758 struct sockaddr *from,
1759 socklen_t fromlen)
1760 {
1761 drv->associated = 0;
1762 wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL);
1763 }
1764
1765
1766 static void wpa_driver_test_eapol(struct wpa_driver_test_data *drv,
1767 struct sockaddr *from,
1768 socklen_t fromlen,
1769 const u8 *data, size_t data_len)
1770 {
1771 const u8 *src = drv->bssid;
1772
1773 if (data_len > 14) {
1774 /* Skip Ethernet header */
1775 src = data + ETH_ALEN;
1776 data += 14;
1777 data_len -= 14;
1778 }
1779 #ifndef HOSTAPD
1780 wpa_supplicant_rx_eapol(drv->ctx, src, data, data_len);
1781 #endif /* HOSTAPD */
1782 }
1783
1784
1785 static void wpa_driver_test_mlme(struct wpa_driver_test_data *drv,
1786 struct sockaddr *from,
1787 socklen_t fromlen,
1788 const u8 *data, size_t data_len)
1789 {
1790 #ifdef CONFIG_CLIENT_MLME
1791 struct ieee80211_rx_status rx_status;
1792 os_memset(&rx_status, 0, sizeof(rx_status));
1793 wpa_supplicant_sta_rx(drv->ctx, data, data_len, &rx_status);
1794 #endif /* CONFIG_CLIENT_MLME */
1795 }
1796
1797
1798 static void wpa_driver_test_scan_cmd(struct wpa_driver_test_data *drv,
1799 struct sockaddr *from,
1800 socklen_t fromlen,
1801 const u8 *data, size_t data_len)
1802 {
1803 char buf[512], *pos, *end;
1804 int ret;
1805
1806 /* data: optional [ STA-addr | ' ' | IEs(hex) ] */
1807
1808 if (!drv->ibss)
1809 return;
1810
1811 pos = buf;
1812 end = buf + sizeof(buf);
1813
1814 /* reply: SCANRESP BSSID SSID IEs */
1815 ret = snprintf(pos, end - pos, "SCANRESP " MACSTR " ",
1816 MAC2STR(drv->bssid));
1817 if (ret < 0 || ret >= end - pos)
1818 return;
1819 pos += ret;
1820 pos += wpa_snprintf_hex(pos, end - pos,
1821 drv->ssid, drv->ssid_len);
1822 ret = snprintf(pos, end - pos, " ");
1823 if (ret < 0 || ret >= end - pos)
1824 return;
1825 pos += ret;
1826 pos += wpa_snprintf_hex(pos, end - pos, drv->assoc_wpa_ie,
1827 drv->assoc_wpa_ie_len);
1828
1829 if (drv->privacy) {
1830 ret = snprintf(pos, end - pos, " PRIVACY");
1831 if (ret < 0 || ret >= end - pos)
1832 return;
1833 pos += ret;
1834 }
1835
1836 ret = snprintf(pos, end - pos, " IBSS");
1837 if (ret < 0 || ret >= end - pos)
1838 return;
1839 pos += ret;
1840
1841 sendto(drv->test_socket, buf, pos - buf, 0,
1842 (struct sockaddr *) from, fromlen);
1843 }
1844
1845
1846 static void wpa_driver_test_receive_unix(int sock, void *eloop_ctx,
1847 void *sock_ctx)
1848 {
1849 struct wpa_driver_test_data *drv = eloop_ctx;
1850 char *buf;
1851 int res;
1852 struct sockaddr_storage from;
1853 socklen_t fromlen = sizeof(from);
1854 const size_t buflen = 2000;
1855
1856 if (drv->ap) {
1857 test_driver_receive_unix(sock, eloop_ctx, sock_ctx);
1858 return;
1859 }
1860
1861 buf = os_malloc(buflen);
1862 if (buf == NULL)
1863 return;
1864 res = recvfrom(sock, buf, buflen - 1, 0,
1865 (struct sockaddr *) &from, &fromlen);
1866 if (res < 0) {
1867 perror("recvfrom(test_socket)");
1868 os_free(buf);
1869 return;
1870 }
1871 buf[res] = '\0';
1872
1873 wpa_printf(MSG_DEBUG, "test_driver: received %u bytes", res);
1874
1875 if (os_strncmp(buf, "SCANRESP ", 9) == 0) {
1876 wpa_driver_test_scanresp(drv, (struct sockaddr *) &from,
1877 fromlen, buf + 9);
1878 } else if (os_strncmp(buf, "ASSOCRESP ", 10) == 0) {
1879 wpa_driver_test_assocresp(drv, (struct sockaddr *) &from,
1880 fromlen, buf + 10);
1881 } else if (os_strcmp(buf, "DISASSOC") == 0) {
1882 wpa_driver_test_disassoc(drv, (struct sockaddr *) &from,
1883 fromlen);
1884 } else if (os_strcmp(buf, "DEAUTH") == 0) {
1885 wpa_driver_test_disassoc(drv, (struct sockaddr *) &from,
1886 fromlen);
1887 } else if (os_strncmp(buf, "EAPOL ", 6) == 0) {
1888 wpa_driver_test_eapol(drv, (struct sockaddr *) &from, fromlen,
1889 (const u8 *) buf + 6, res - 6);
1890 } else if (os_strncmp(buf, "MLME ", 5) == 0) {
1891 wpa_driver_test_mlme(drv, (struct sockaddr *) &from, fromlen,
1892 (const u8 *) buf + 5, res - 5);
1893 } else if (os_strncmp(buf, "SCAN ", 5) == 0) {
1894 wpa_driver_test_scan_cmd(drv, (struct sockaddr *) &from,
1895 fromlen,
1896 (const u8 *) buf + 5, res - 5);
1897 } else {
1898 wpa_hexdump_ascii(MSG_DEBUG, "Unknown test_socket command",
1899 (u8 *) buf, res);
1900 }
1901 os_free(buf);
1902 }
1903
1904
1905 static void * wpa_driver_test_init2(void *ctx, const char *ifname,
1906 void *global_priv)
1907 {
1908 struct wpa_driver_test_data *drv;
1909
1910 drv = test_alloc_data(ctx, ifname);
1911 if (drv == NULL)
1912 return NULL;
1913 drv->global = global_priv;
1914 drv->test_socket = -1;
1915
1916 /* Set dummy BSSID and SSID for testing. */
1917 drv->bssid[0] = 0x02;
1918 drv->bssid[1] = 0x00;
1919 drv->bssid[2] = 0x00;
1920 drv->bssid[3] = 0x00;
1921 drv->bssid[4] = 0x00;
1922 drv->bssid[5] = 0x01;
1923 os_memcpy(drv->ssid, "test", 5);
1924 drv->ssid_len = 4;
1925
1926 eloop_register_timeout(1, 0, wpa_driver_test_poll, drv, NULL);
1927
1928 return drv;
1929 }
1930
1931
1932 static void wpa_driver_test_close_test_socket(struct wpa_driver_test_data *drv)
1933 {
1934 if (drv->test_socket >= 0) {
1935 eloop_unregister_read_sock(drv->test_socket);
1936 close(drv->test_socket);
1937 drv->test_socket = -1;
1938 }
1939
1940 if (drv->own_socket_path) {
1941 unlink(drv->own_socket_path);
1942 os_free(drv->own_socket_path);
1943 drv->own_socket_path = NULL;
1944 }
1945 }
1946
1947
1948 static void wpa_driver_test_deinit(void *priv)
1949 {
1950 struct wpa_driver_test_data *drv = priv;
1951 struct test_client_socket *cli, *prev;
1952 int i;
1953
1954 cli = drv->cli;
1955 while (cli) {
1956 prev = cli;
1957 cli = cli->next;
1958 os_free(prev);
1959 }
1960
1961 #ifdef HOSTAPD
1962 /* There should be only one BSS remaining at this point. */
1963 if (drv->bss == NULL)
1964 wpa_printf(MSG_ERROR, "%s: drv->bss == NULL", __func__);
1965 else if (drv->bss->next)
1966 wpa_printf(MSG_ERROR, "%s: drv->bss->next != NULL", __func__);
1967 #endif /* HOSTAPD */
1968
1969 test_driver_free_bsses(drv);
1970
1971 wpa_driver_test_close_test_socket(drv);
1972 eloop_cancel_timeout(wpa_driver_test_scan_timeout, drv, drv->ctx);
1973 eloop_cancel_timeout(wpa_driver_test_poll, drv, NULL);
1974 os_free(drv->test_dir);
1975 for (i = 0; i < MAX_SCAN_RESULTS; i++)
1976 os_free(drv->scanres[i]);
1977 os_free(drv->probe_req_ie);
1978 wpa_trace_remove_ref(drv, ctx, drv->ctx);
1979 os_free(drv);
1980 }
1981
1982
1983 static int wpa_driver_test_attach(struct wpa_driver_test_data *drv,
1984 const char *dir, int ap)
1985 {
1986 #ifdef DRIVER_TEST_UNIX
1987 static unsigned int counter = 0;
1988 struct sockaddr_un addr;
1989 size_t len;
1990
1991 os_free(drv->own_socket_path);
1992 if (dir) {
1993 len = os_strlen(dir) + 30;
1994 drv->own_socket_path = os_malloc(len);
1995 if (drv->own_socket_path == NULL)
1996 return -1;
1997 os_snprintf(drv->own_socket_path, len, "%s/%s-" MACSTR,
1998 dir, ap ? "AP" : "STA", MAC2STR(drv->own_addr));
1999 } else {
2000 drv->own_socket_path = os_malloc(100);
2001 if (drv->own_socket_path == NULL)
2002 return -1;
2003 os_snprintf(drv->own_socket_path, 100,
2004 "/tmp/wpa_supplicant_test-%d-%d",
2005 getpid(), counter++);
2006 }
2007
2008 drv->test_socket = socket(PF_UNIX, SOCK_DGRAM, 0);
2009 if (drv->test_socket < 0) {
2010 perror("socket(PF_UNIX)");
2011 os_free(drv->own_socket_path);
2012 drv->own_socket_path = NULL;
2013 return -1;
2014 }
2015
2016 os_memset(&addr, 0, sizeof(addr));
2017 addr.sun_family = AF_UNIX;
2018 os_strlcpy(addr.sun_path, drv->own_socket_path, sizeof(addr.sun_path));
2019 if (bind(drv->test_socket, (struct sockaddr *) &addr,
2020 sizeof(addr)) < 0) {
2021 perror("bind(PF_UNIX)");
2022 close(drv->test_socket);
2023 unlink(drv->own_socket_path);
2024 os_free(drv->own_socket_path);
2025 drv->own_socket_path = NULL;
2026 return -1;
2027 }
2028
2029 eloop_register_read_sock(drv->test_socket,
2030 wpa_driver_test_receive_unix, drv, NULL);
2031
2032 return 0;
2033 #else /* DRIVER_TEST_UNIX */
2034 return -1;
2035 #endif /* DRIVER_TEST_UNIX */
2036 }
2037
2038
2039 static int wpa_driver_test_attach_udp(struct wpa_driver_test_data *drv,
2040 char *dst)
2041 {
2042 char *pos;
2043
2044 pos = os_strchr(dst, ':');
2045 if (pos == NULL)
2046 return -1;
2047 *pos++ = '\0';
2048 wpa_printf(MSG_DEBUG, "%s: addr=%s port=%s", __func__, dst, pos);
2049
2050 drv->test_socket = socket(PF_INET, SOCK_DGRAM, 0);
2051 if (drv->test_socket < 0) {
2052 perror("socket(PF_INET)");
2053 return -1;
2054 }
2055
2056 os_memset(&drv->hostapd_addr_udp, 0, sizeof(drv->hostapd_addr_udp));
2057 drv->hostapd_addr_udp.sin_family = AF_INET;
2058 #if defined(CONFIG_NATIVE_WINDOWS) || defined(CONFIG_ANSI_C_EXTRA)
2059 {
2060 int a[4];
2061 u8 *pos;
2062 sscanf(dst, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]);
2063 pos = (u8 *) &drv->hostapd_addr_udp.sin_addr;
2064 *pos++ = a[0];
2065 *pos++ = a[1];
2066 *pos++ = a[2];
2067 *pos++ = a[3];
2068 }
2069 #else /* CONFIG_NATIVE_WINDOWS or CONFIG_ANSI_C_EXTRA */
2070 inet_aton(dst, &drv->hostapd_addr_udp.sin_addr);
2071 #endif /* CONFIG_NATIVE_WINDOWS or CONFIG_ANSI_C_EXTRA */
2072 drv->hostapd_addr_udp.sin_port = htons(atoi(pos));
2073
2074 drv->hostapd_addr_udp_set = 1;
2075
2076 eloop_register_read_sock(drv->test_socket,
2077 wpa_driver_test_receive_unix, drv, NULL);
2078
2079 return 0;
2080 }
2081
2082
2083 static int wpa_driver_test_set_param(void *priv, const char *param)
2084 {
2085 struct wpa_driver_test_data *drv = priv;
2086 const char *pos;
2087
2088 wpa_printf(MSG_DEBUG, "%s: param='%s'", __func__, param);
2089 if (param == NULL)
2090 return 0;
2091
2092 wpa_driver_test_close_test_socket(drv);
2093
2094 #ifdef DRIVER_TEST_UNIX
2095 pos = os_strstr(param, "test_socket=");
2096 if (pos) {
2097 const char *pos2;
2098 size_t len;
2099
2100 pos += 12;
2101 pos2 = os_strchr(pos, ' ');
2102 if (pos2)
2103 len = pos2 - pos;
2104 else
2105 len = os_strlen(pos);
2106 if (len > sizeof(drv->hostapd_addr.sun_path))
2107 return -1;
2108 os_memset(&drv->hostapd_addr, 0, sizeof(drv->hostapd_addr));
2109 drv->hostapd_addr.sun_family = AF_UNIX;
2110 os_memcpy(drv->hostapd_addr.sun_path, pos, len);
2111 drv->hostapd_addr_set = 1;
2112 }
2113 #endif /* DRIVER_TEST_UNIX */
2114
2115 pos = os_strstr(param, "test_dir=");
2116 if (pos) {
2117 char *end;
2118 os_free(drv->test_dir);
2119 drv->test_dir = os_strdup(pos + 9);
2120 if (drv->test_dir == NULL)
2121 return -1;
2122 end = os_strchr(drv->test_dir, ' ');
2123 if (end)
2124 *end = '\0';
2125 if (wpa_driver_test_attach(drv, drv->test_dir, 0))
2126 return -1;
2127 } else {
2128 pos = os_strstr(param, "test_udp=");
2129 if (pos) {
2130 char *dst, *epos;
2131 dst = os_strdup(pos + 9);
2132 if (dst == NULL)
2133 return -1;
2134 epos = os_strchr(dst, ' ');
2135 if (epos)
2136 *epos = '\0';
2137 if (wpa_driver_test_attach_udp(drv, dst))
2138 return -1;
2139 os_free(dst);
2140 } else if (wpa_driver_test_attach(drv, NULL, 0))
2141 return -1;
2142 }
2143
2144 if (os_strstr(param, "use_associnfo=1")) {
2145 wpa_printf(MSG_DEBUG, "test_driver: Use AssocInfo events");
2146 drv->use_associnfo = 1;
2147 }
2148
2149 #ifdef CONFIG_CLIENT_MLME
2150 if (os_strstr(param, "use_mlme=1")) {
2151 wpa_printf(MSG_DEBUG, "test_driver: Use internal MLME");
2152 drv->use_mlme = 1;
2153 }
2154 #endif /* CONFIG_CLIENT_MLME */
2155
2156 return 0;
2157 }
2158
2159
2160 static const u8 * wpa_driver_test_get_mac_addr(void *priv)
2161 {
2162 struct wpa_driver_test_data *drv = priv;
2163 wpa_printf(MSG_DEBUG, "%s", __func__);
2164 return drv->own_addr;
2165 }
2166
2167
2168 static int wpa_driver_test_send_eapol(void *priv, const u8 *dest, u16 proto,
2169 const u8 *data, size_t data_len)
2170 {
2171 struct wpa_driver_test_data *drv = priv;
2172 char *msg;
2173 size_t msg_len;
2174 struct l2_ethhdr eth;
2175 struct sockaddr *addr;
2176 socklen_t alen;
2177 #ifdef DRIVER_TEST_UNIX
2178 struct sockaddr_un addr_un;
2179 #endif /* DRIVER_TEST_UNIX */
2180
2181 wpa_hexdump(MSG_MSGDUMP, "test_send_eapol TX frame", data, data_len);
2182
2183 os_memset(&eth, 0, sizeof(eth));
2184 os_memcpy(eth.h_dest, dest, ETH_ALEN);
2185 os_memcpy(eth.h_source, drv->own_addr, ETH_ALEN);
2186 eth.h_proto = host_to_be16(proto);
2187
2188 msg_len = 6 + sizeof(eth) + data_len;
2189 msg = os_malloc(msg_len);
2190 if (msg == NULL)
2191 return -1;
2192 os_memcpy(msg, "EAPOL ", 6);
2193 os_memcpy(msg + 6, &eth, sizeof(eth));
2194 os_memcpy(msg + 6 + sizeof(eth), data, data_len);
2195
2196 if (os_memcmp(dest, drv->bssid, ETH_ALEN) == 0 ||
2197 drv->test_dir == NULL) {
2198 if (drv->hostapd_addr_udp_set) {
2199 addr = (struct sockaddr *) &drv->hostapd_addr_udp;
2200 alen = sizeof(drv->hostapd_addr_udp);
2201 } else {
2202 #ifdef DRIVER_TEST_UNIX
2203 addr = (struct sockaddr *) &drv->hostapd_addr;
2204 alen = sizeof(drv->hostapd_addr);
2205 #else /* DRIVER_TEST_UNIX */
2206 os_free(msg);
2207 return -1;
2208 #endif /* DRIVER_TEST_UNIX */
2209 }
2210 } else {
2211 #ifdef DRIVER_TEST_UNIX
2212 struct stat st;
2213 os_memset(&addr_un, 0, sizeof(addr_un));
2214 addr_un.sun_family = AF_UNIX;
2215 os_snprintf(addr_un.sun_path, sizeof(addr_un.sun_path),
2216 "%s/STA-" MACSTR, drv->test_dir, MAC2STR(dest));
2217 if (stat(addr_un.sun_path, &st) < 0) {
2218 os_snprintf(addr_un.sun_path, sizeof(addr_un.sun_path),
2219 "%s/AP-" MACSTR,
2220 drv->test_dir, MAC2STR(dest));
2221 }
2222 addr = (struct sockaddr *) &addr_un;
2223 alen = sizeof(addr_un);
2224 #else /* DRIVER_TEST_UNIX */
2225 os_free(msg);
2226 return -1;
2227 #endif /* DRIVER_TEST_UNIX */
2228 }
2229
2230 if (sendto(drv->test_socket, msg, msg_len, 0, addr, alen) < 0) {
2231 perror("sendmsg(test_socket)");
2232 os_free(msg);
2233 return -1;
2234 }
2235
2236 os_free(msg);
2237 return 0;
2238 }
2239
2240
2241 static int wpa_driver_test_get_capa(void *priv, struct wpa_driver_capa *capa)
2242 {
2243 struct wpa_driver_test_data *drv = priv;
2244 os_memset(capa, 0, sizeof(*capa));
2245 capa->key_mgmt = WPA_DRIVER_CAPA_KEY_MGMT_WPA |
2246 WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
2247 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK |
2248 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK |
2249 WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE |
2250 WPA_DRIVER_CAPA_KEY_MGMT_FT |
2251 WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK;
2252 capa->enc = WPA_DRIVER_CAPA_ENC_WEP40 |
2253 WPA_DRIVER_CAPA_ENC_WEP104 |
2254 WPA_DRIVER_CAPA_ENC_TKIP |
2255 WPA_DRIVER_CAPA_ENC_CCMP;
2256 capa->auth = WPA_DRIVER_AUTH_OPEN |
2257 WPA_DRIVER_AUTH_SHARED |
2258 WPA_DRIVER_AUTH_LEAP;
2259 if (drv->use_mlme)
2260 capa->flags |= WPA_DRIVER_FLAGS_USER_SPACE_MLME;
2261 capa->flags |= WPA_DRIVER_FLAGS_AP;
2262 capa->max_scan_ssids = 2;
2263
2264 return 0;
2265 }
2266
2267
2268 static int wpa_driver_test_mlme_setprotection(void *priv, const u8 *addr,
2269 int protect_type,
2270 int key_type)
2271 {
2272 wpa_printf(MSG_DEBUG, "%s: protect_type=%d key_type=%d",
2273 __func__, protect_type, key_type);
2274
2275 if (addr) {
2276 wpa_printf(MSG_DEBUG, "%s: addr=" MACSTR,
2277 __func__, MAC2STR(addr));
2278 }
2279
2280 return 0;
2281 }
2282
2283
2284 static int wpa_driver_test_set_channel(void *priv,
2285 enum hostapd_hw_mode phymode,
2286 int chan, int freq)
2287 {
2288 wpa_printf(MSG_DEBUG, "%s: phymode=%d chan=%d freq=%d",
2289 __func__, phymode, chan, freq);
2290 return 0;
2291 }
2292
2293
2294 static int wpa_driver_test_mlme_add_sta(void *priv, const u8 *addr,
2295 const u8 *supp_rates,
2296 size_t supp_rates_len)
2297 {
2298 wpa_printf(MSG_DEBUG, "%s: addr=" MACSTR, __func__, MAC2STR(addr));
2299 return 0;
2300 }
2301
2302
2303 static int wpa_driver_test_mlme_remove_sta(void *priv, const u8 *addr)
2304 {
2305 wpa_printf(MSG_DEBUG, "%s: addr=" MACSTR, __func__, MAC2STR(addr));
2306 return 0;
2307 }
2308
2309
2310 static int wpa_driver_test_set_ssid(void *priv, const u8 *ssid,
2311 size_t ssid_len)
2312 {
2313 wpa_printf(MSG_DEBUG, "%s", __func__);
2314 return 0;
2315 }
2316
2317
2318 static int wpa_driver_test_set_bssid(void *priv, const u8 *bssid)
2319 {
2320 wpa_printf(MSG_DEBUG, "%s: bssid=" MACSTR, __func__, MAC2STR(bssid));
2321 return 0;
2322 }
2323
2324
2325 static void * wpa_driver_test_global_init(void)
2326 {
2327 struct wpa_driver_test_global *global;
2328
2329 global = os_zalloc(sizeof(*global));
2330 return global;
2331 }
2332
2333
2334 static void wpa_driver_test_global_deinit(void *priv)
2335 {
2336 struct wpa_driver_test_global *global = priv;
2337 os_free(global);
2338 }
2339
2340
2341 static struct wpa_interface_info *
2342 wpa_driver_test_get_interfaces(void *global_priv)
2343 {
2344 /* struct wpa_driver_test_global *global = priv; */
2345 struct wpa_interface_info *iface;
2346
2347 iface = os_zalloc(sizeof(*iface));
2348 if (iface == NULL)
2349 return iface;
2350 iface->ifname = os_strdup("sta0");
2351 iface->desc = os_strdup("test interface 0");
2352 iface->drv_name = "test";
2353 iface->next = os_zalloc(sizeof(*iface));
2354 if (iface->next) {
2355 iface->next->ifname = os_strdup("sta1");
2356 iface->next->desc = os_strdup("test interface 1");
2357 iface->next->drv_name = "test";
2358 }
2359
2360 return iface;
2361 }
2362
2363
2364 static struct hostapd_hw_modes *
2365 wpa_driver_test_get_hw_feature_data(void *priv, u16 *num_modes, u16 *flags)
2366 {
2367 struct hostapd_hw_modes *modes;
2368
2369 *num_modes = 3;
2370 *flags = 0;
2371 modes = os_zalloc(*num_modes * sizeof(struct hostapd_hw_modes));
2372 if (modes == NULL)
2373 return NULL;
2374 modes[0].mode = HOSTAPD_MODE_IEEE80211G;
2375 modes[0].num_channels = 1;
2376 modes[0].num_rates = 1;
2377 modes[0].channels = os_zalloc(sizeof(struct hostapd_channel_data));
2378 modes[0].rates = os_zalloc(sizeof(int));
2379 if (modes[0].channels == NULL || modes[0].rates == NULL)
2380 goto fail;
2381 modes[0].channels[0].chan = 1;
2382 modes[0].channels[0].freq = 2412;
2383 modes[0].channels[0].flag = 0;
2384 modes[0].rates[0] = 10;
2385
2386 modes[1].mode = HOSTAPD_MODE_IEEE80211B;
2387 modes[1].num_channels = 1;
2388 modes[1].num_rates = 1;
2389 modes[1].channels = os_zalloc(sizeof(struct hostapd_channel_data));
2390 modes[1].rates = os_zalloc(sizeof(int));
2391 if (modes[1].channels == NULL || modes[1].rates == NULL)
2392 goto fail;
2393 modes[1].channels[0].chan = 1;
2394 modes[1].channels[0].freq = 2412;
2395 modes[1].channels[0].flag = 0;
2396 modes[1].rates[0] = 10;
2397
2398 modes[2].mode = HOSTAPD_MODE_IEEE80211A;
2399 modes[2].num_channels = 1;
2400 modes[2].num_rates = 1;
2401 modes[2].channels = os_zalloc(sizeof(struct hostapd_channel_data));
2402 modes[2].rates = os_zalloc(sizeof(int));
2403 if (modes[2].channels == NULL || modes[2].rates == NULL)
2404 goto fail;
2405 modes[2].channels[0].chan = 60;
2406 modes[2].channels[0].freq = 5300;
2407 modes[2].channels[0].flag = 0;
2408 modes[2].rates[0] = 60;
2409
2410 return modes;
2411
2412 fail:
2413 if (modes) {
2414 size_t i;
2415 for (i = 0; i < *num_modes; i++) {
2416 os_free(modes[i].channels);
2417 os_free(modes[i].rates);
2418 }
2419 os_free(modes);
2420 }
2421 return NULL;
2422 }
2423
2424
2425 const struct wpa_driver_ops wpa_driver_test_ops = {
2426 "test",
2427 "wpa_supplicant test driver",
2428 .hapd_init = test_driver_init,
2429 .hapd_deinit = wpa_driver_test_deinit,
2430 .hapd_send_eapol = test_driver_send_eapol,
2431 .send_mlme = wpa_driver_test_send_mlme,
2432 .set_generic_elem = test_driver_set_generic_elem,
2433 .sta_deauth = test_driver_sta_deauth,
2434 .sta_disassoc = test_driver_sta_disassoc,
2435 .get_hw_feature_data = wpa_driver_test_get_hw_feature_data,
2436 .if_add = test_driver_if_add,
2437 .if_remove = test_driver_if_remove,
2438 .valid_bss_mask = test_driver_valid_bss_mask,
2439 .hapd_set_ssid = test_driver_set_ssid,
2440 .set_privacy = test_driver_set_privacy,
2441 .set_sta_vlan = test_driver_set_sta_vlan,
2442 .sta_add = test_driver_sta_add,
2443 .send_ether = test_driver_send_ether,
2444 .set_ap_wps_ie = test_driver_set_ap_wps_ie,
2445 .get_bssid = wpa_driver_test_get_bssid,
2446 .get_ssid = wpa_driver_test_get_ssid,
2447 .set_key = wpa_driver_test_set_key,
2448 .deinit = wpa_driver_test_deinit,
2449 .set_param = wpa_driver_test_set_param,
2450 .deauthenticate = wpa_driver_test_deauthenticate,
2451 .disassociate = wpa_driver_test_disassociate,
2452 .associate = wpa_driver_test_associate,
2453 .get_capa = wpa_driver_test_get_capa,
2454 .get_mac_addr = wpa_driver_test_get_mac_addr,
2455 .send_eapol = wpa_driver_test_send_eapol,
2456 .mlme_setprotection = wpa_driver_test_mlme_setprotection,
2457 .set_channel = wpa_driver_test_set_channel,
2458 .set_ssid = wpa_driver_test_set_ssid,
2459 .set_bssid = wpa_driver_test_set_bssid,
2460 .mlme_add_sta = wpa_driver_test_mlme_add_sta,
2461 .mlme_remove_sta = wpa_driver_test_mlme_remove_sta,
2462 .get_scan_results2 = wpa_driver_test_get_scan_results2,
2463 .global_init = wpa_driver_test_global_init,
2464 .global_deinit = wpa_driver_test_global_deinit,
2465 .init2 = wpa_driver_test_init2,
2466 .get_interfaces = wpa_driver_test_get_interfaces,
2467 .scan2 = wpa_driver_test_scan,
2468 };