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