Lines Matching refs:drv
45 struct wpa_driver_test_data *drv;
123 static int wpa_driver_test_attach(struct wpa_driver_test_data *drv,
126 struct wpa_driver_test_data *drv);
128 static int wpa_driver_test_init_p2p(struct wpa_driver_test_data *drv);
140 static void test_driver_free_bsses(struct wpa_driver_test_data *drv)
144 dl_list_for_each_safe(bss, tmp, &drv->bss, struct test_driver_bss,
153 test_driver_get_cli(struct wpa_driver_test_data *drv, struct sockaddr_un *from,
156 struct test_client_socket *cli = drv->cli;
175 struct wpa_driver_test_data *drv = dbss->drv;
181 if (drv->test_socket < 0)
184 cli = drv->cli;
213 return sendmsg(drv->test_socket, &msg, 0);
221 struct wpa_driver_test_data *drv = dbss->drv;
231 if (drv->test_socket < 0 || drv->test_dir == NULL) {
234 __func__, drv->test_socket, drv->test_dir);
256 dir = opendir(drv->test_dir);
276 drv->test_dir, dent->d_name);
278 if (strcmp(addr.sun_path, drv->own_socket_path) == 0)
288 ret = sendmsg(drv->test_socket, &msg, 0);
309 struct wpa_driver_test_data *drv = dbss->drv;
328 if (drv->test_socket < 0 || data_len < 10) {
331 __func__, drv->test_socket,
333 drv->test_dir);
344 if (drv->remain_on_channel_freq)
345 freq = drv->remain_on_channel_freq;
347 freq = drv->current_freq;
361 if (drv->test_dir == NULL) {
366 dir = opendir(drv->test_dir);
386 drv->test_dir, dent->d_name);
388 if (os_strcmp(addr.sun_path, drv->own_socket_path) == 0)
398 ret = sendmsg(drv->test_socket, &msg, 0);
406 drv->test_dir == NULL) {
407 if (drv->hostapd_addr_udp_set) {
408 msg.msg_name = &drv->hostapd_addr_udp;
409 msg.msg_namelen = sizeof(drv->hostapd_addr_udp);
412 msg.msg_name = &drv->hostapd_addr;
413 msg.msg_namelen = sizeof(drv->hostapd_addr);
417 dir = opendir(drv->test_dir);
438 "%s/%s", drv->test_dir, dent->d_name);
443 ret = sendmsg(drv->test_socket, &msg, 0);
454 "%s/AP-" MACSTR, drv->test_dir, MAC2STR(dest));
458 drv->test_dir, MAC2STR(dest));
464 if (sendmsg(drv->test_socket, &msg, 0) < 0) {
480 wpa_supplicant_event(drv->ctx, EVENT_TX_STATUS, &event);
483 if (drv->p2p &&
486 if (drv->pending_action_tx == NULL) {
492 if (os_memcmp(hdr->addr1, drv->pending_action_dst, ETH_ALEN) !=
499 wpabuf_free(drv->pending_action_tx);
500 drv->pending_action_tx = NULL;
502 p2p_send_action_cb(drv->p2p, drv->pending_action_freq,
503 drv->pending_action_dst,
504 drv->pending_action_src,
505 drv->pending_action_bssid,
514 static void test_driver_scan(struct wpa_driver_test_data *drv,
555 wpa_supplicant_event(drv->ctx, EVENT_RX_PROBE_REQ, &event);
557 if (drv->p2p)
558 p2p_probe_req_rx(drv->p2p, sa, NULL, NULL, ie, ielen);
562 dl_list_for_each(bss, &drv->bss, struct test_driver_bss, list) {
589 sendto(drv->test_socket, buf, pos - buf, 0,
595 static void test_driver_assoc(struct wpa_driver_test_data *drv,
641 dl_list_for_each(tmp, &drv->bss, struct test_driver_bss, list) {
658 cli->next = drv->cli;
659 drv->cli = cli;
666 sendto(drv->test_socket, cmd, strlen(cmd), 0,
673 static void test_driver_disassoc(struct wpa_driver_test_data *drv,
678 cli = test_driver_get_cli(drv, from, fromlen);
682 drv_event_disassoc(drv->ctx, cli->addr);
686 static void test_driver_eapol(struct wpa_driver_test_data *drv,
707 cli = test_driver_get_cli(drv, from, fromlen);
717 drv_event_eapol_rx(drv->ctx, src, data, datalen);
722 static void test_driver_ether(struct wpa_driver_test_data *drv,
749 static void test_driver_mlme(struct wpa_driver_test_data *drv,
759 bss = dl_list_first(&drv->bss, struct test_driver_bss, list);
777 if (drv->remain_on_channel_freq)
778 own_freq = drv->remain_on_channel_freq;
780 own_freq = drv->current_freq;
791 if (test_driver_get_cli(drv, from, fromlen) == NULL && datalen >= 16) {
801 cli->next = drv->cli;
802 drv->cli = cli;
817 wpa_supplicant_event(drv->ctx, EVENT_RX_MGMT, &event);
823 struct wpa_driver_test_data *drv = eloop_ctx;
840 test_driver_scan(drv, &from, fromlen, buf + 4);
842 test_driver_assoc(drv, &from, fromlen, buf + 6);
844 test_driver_disassoc(drv, &from, fromlen);
846 test_driver_eapol(drv, &from, fromlen, (u8 *) buf + 6,
849 test_driver_ether(drv, &from, fromlen, (u8 *) buf + 6,
852 test_driver_mlme(drv, &from, fromlen, (u8 *) buf + 5, res - 5);
946 struct wpa_driver_test_data *drv = dbss->drv;
949 if (drv->test_socket < 0)
952 cli = drv->cli;
962 return sendto(drv->test_socket, "DEAUTH", 6, 0,
971 struct wpa_driver_test_data *drv = dbss->drv;
974 if (drv->test_socket < 0)
977 cli = drv->cli;
987 return sendto(drv->test_socket, "DISASSOC", 8, 0,
996 struct wpa_driver_test_data *drv = dbss->drv;
1007 bss->drv = drv;
1011 dl_list_add(&drv->bss, &bss->list);
1012 if (drv->global) {
1013 drv->global->bss_add_used = 1;
1014 os_memcpy(drv->global->req_addr, bssid, ETH_ALEN);
1027 struct wpa_driver_test_data *drv = dbss->drv;
1033 dl_list_for_each(bss, &drv->bss, struct test_driver_bss, list) {
1037 for (prev_c = NULL, cli = drv->cli; cli;
1044 drv->cli = cli->next;
1065 struct wpa_driver_test_data *drv = dbss->drv;
1072 drv->alloc_iface_idx++;
1074 sha1_prf(drv->own_addr, ETH_ALEN,
1076 (const u8 *) &drv->alloc_iface_idx,
1077 sizeof(drv->alloc_iface_idx),
1142 struct wpa_driver_test_data *drv = bss->drv;
1152 cli = drv->cli;
1173 struct wpa_driver_test_data *drv;
1176 drv = os_zalloc(sizeof(struct wpa_driver_test_data));
1177 if (drv == NULL) {
1185 os_free(drv);
1189 drv->ctx = ctx;
1190 wpa_trace_add_ref(drv, ctx, ctx);
1191 dl_list_init(&drv->bss);
1192 dl_list_add(&drv->bss, &bss->list);
1195 bss->drv = drv;
1198 drv->own_addr[0] = 0x02; /* locally administered */
1201 NULL, 0, drv->own_addr + 1, ETH_ALEN - 1);
1203 return drv;
1210 struct wpa_driver_test_data *drv;
1217 drv = test_alloc_data(hapd, params->ifname);
1218 if (drv == NULL)
1220 drv->ap = 1;
1221 bss = dl_list_first(&drv->bss, struct test_driver_bss, list);
1222 drv->global = params->global_priv;
1225 os_memcpy(bss->bssid, drv->own_addr, ETH_ALEN);
1226 os_memcpy(params->own_addr, drv->own_addr, ETH_ALEN);
1237 drv->test_dir = os_strdup(params->test_socket + 4);
1238 drv->own_socket_path = os_malloc(len);
1239 if (drv->own_socket_path) {
1240 snprintf(drv->own_socket_path, len,
1246 drv->udp_port = atoi(params->test_socket + 4);
1248 drv->own_socket_path = os_strdup(params->test_socket);
1250 if (drv->own_socket_path == NULL && drv->udp_port == 0) {
1255 drv->test_socket = socket(drv->udp_port ? PF_INET : PF_UNIX,
1257 if (drv->test_socket < 0) {
1263 if (drv->udp_port) {
1266 addr_in.sin_port = htons(drv->udp_port);
1272 os_strlcpy(addr_un.sun_path, drv->own_socket_path,
1277 if (bind(drv->test_socket, addr, alen) < 0) {
1279 close(drv->test_socket);
1280 if (drv->own_socket_path)
1281 unlink(drv->own_socket_path);
1285 eloop_register_read_sock(drv->test_socket,
1286 test_driver_receive_unix, drv, NULL);
1288 drv->test_socket = -1;
1296 struct wpa_driver_test_data *drv = eloop_ctx;
1299 if (drv->associated && drv->hostapd_addr_set) {
1301 if (stat(drv->hostapd_addr.sun_path, &st) < 0) {
1304 drv->associated = 0;
1305 wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL);
1310 eloop_register_timeout(1, 0, wpa_driver_test_poll, drv, NULL);
1316 struct wpa_driver_test_data *drv = eloop_ctx;
1318 if (drv->pending_p2p_scan && drv->p2p) {
1323 for (i = 0; i < drv->num_scanres; i++) {
1324 struct wpa_scan_res *bss = drv->scanres[i];
1325 if (p2p_scan_res_handler(drv->p2p, bss->bssid,
1331 p2p_scan_res_handled(drv->p2p);
1340 static void wpa_driver_scan_dir(struct wpa_driver_test_data *drv,
1356 MAC2STR(drv->own_addr));
1359 if (drv->probe_req_ie) {
1363 pos += wpa_snprintf_hex(pos, end - pos, drv->probe_req_ie,
1364 drv->probe_req_ie_len);
1366 if (drv->probe_req_ssid_len) {
1370 (unsigned int) drv->probe_req_ssid_len);
1373 pos += wpa_snprintf_hex(pos, end - pos, drv->probe_req_ssid,
1374 drv->probe_req_ssid_len);
1382 if (drv->own_socket_path) {
1384 olen = os_strlen(drv->own_socket_path);
1388 drv->own_socket_path + olen - dlen) == 0)
1398 if (sendto(drv->test_socket, cmd, os_strlen(cmd), 0,
1412 struct wpa_driver_test_data *drv = dbss->drv;
1417 os_free(drv->probe_req_ie);
1419 drv->probe_req_ie = os_malloc(params->extra_ies_len);
1420 if (drv->probe_req_ie == NULL) {
1421 drv->probe_req_ie_len = 0;
1424 os_memcpy(drv->probe_req_ie, params->extra_ies,
1426 drv->probe_req_ie_len = params->extra_ies_len;
1428 drv->probe_req_ie = NULL;
1429 drv->probe_req_ie_len = 0;
1435 drv->probe_req_ssid_len = 0;
1437 os_memcpy(drv->probe_req_ssid, params->ssids[0].ssid,
1439 drv->probe_req_ssid_len = params->ssids[0].ssid_len;
1444 drv->num_scanres = 0;
1447 if (drv->test_socket >= 0 && drv->test_dir)
1448 wpa_driver_scan_dir(drv, drv->test_dir);
1450 if (drv->test_socket >= 0 && drv->hostapd_addr_set &&
1451 sendto(drv->test_socket, "SCAN", 4, 0,
1452 (struct sockaddr *) &drv->hostapd_addr,
1453 sizeof(drv->hostapd_addr)) < 0) {
1458 if (drv->test_socket >= 0 && drv->hostapd_addr_udp_set &&
1459 sendto(drv->test_socket, "SCAN", 4, 0,
1460 (struct sockaddr *) &drv->hostapd_addr_udp,
1461 sizeof(drv->hostapd_addr_udp)) < 0) {
1465 eloop_cancel_timeout(wpa_driver_test_scan_timeout, drv, drv->ctx);
1466 eloop_register_timeout(1, 0, wpa_driver_test_scan_timeout, drv,
1467 drv->ctx);
1475 struct wpa_driver_test_data *drv = dbss->drv;
1483 res->res = os_calloc(drv->num_scanres, sizeof(struct wpa_scan_res *));
1489 for (i = 0; i < drv->num_scanres; i++) {
1491 if (drv->scanres[i] == NULL)
1493 r = os_malloc(sizeof(*r) + drv->scanres[i]->ie_len);
1496 os_memcpy(r, drv->scanres[i],
1497 sizeof(*r) + drv->scanres[i]->ie_len);
1524 static int wpa_driver_update_mode(struct wpa_driver_test_data *drv, int ap)
1526 if (ap && !drv->ap) {
1527 wpa_driver_test_close_test_socket(drv);
1528 wpa_driver_test_attach(drv, drv->test_dir, 1);
1529 drv->ap = 1;
1530 } else if (!ap && drv->ap) {
1531 wpa_driver_test_close_test_socket(drv);
1532 wpa_driver_test_attach(drv, drv->test_dir, 0);
1533 drv->ap = 0;
1544 struct wpa_driver_test_data *drv = dbss->drv;
1550 wpa_driver_update_mode(drv, params->mode == IEEE80211_MODE_AP);
1562 drv->assoc_wpa_ie_len = params->wpa_ie_len;
1563 if (drv->assoc_wpa_ie_len > sizeof(drv->assoc_wpa_ie))
1564 drv->assoc_wpa_ie_len = sizeof(drv->assoc_wpa_ie);
1565 os_memcpy(drv->assoc_wpa_ie, params->wpa_ie,
1566 drv->assoc_wpa_ie_len);
1568 drv->assoc_wpa_ie_len = 0;
1570 wpa_driver_update_mode(drv, params->mode == IEEE80211_MODE_AP);
1572 drv->ibss = params->mode == IEEE80211_MODE_IBSS;
1585 if (drv->test_dir && params->bssid &&
1587 os_memset(&drv->hostapd_addr, 0, sizeof(drv->hostapd_addr));
1588 drv->hostapd_addr.sun_family = AF_UNIX;
1589 os_snprintf(drv->hostapd_addr.sun_path,
1590 sizeof(drv->hostapd_addr.sun_path),
1592 drv->test_dir, MAC2STR(params->bssid));
1593 drv->hostapd_addr_set = 1;
1600 os_memcpy(dbss->bssid, drv->own_addr, ETH_ALEN);
1609 } else if (drv->test_socket >= 0 &&
1610 (drv->hostapd_addr_set || drv->hostapd_addr_udp_set)) {
1616 MAC2STR(drv->own_addr));
1628 if (drv->hostapd_addr_set &&
1629 sendto(drv->test_socket, cmd, os_strlen(cmd), 0,
1630 (struct sockaddr *) &drv->hostapd_addr,
1631 sizeof(drv->hostapd_addr)) < 0) {
1636 if (drv->hostapd_addr_udp_set &&
1637 sendto(drv->test_socket, cmd, os_strlen(cmd), 0,
1638 (struct sockaddr *) &drv->hostapd_addr_udp,
1639 sizeof(drv->hostapd_addr_udp)) < 0) {
1647 drv->associated = 1;
1660 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, NULL);
1683 static int wpa_driver_test_send_disassoc(struct wpa_driver_test_data *drv)
1686 if (drv->test_socket >= 0 &&
1687 sendto(drv->test_socket, "DISASSOC", 8, 0,
1688 (struct sockaddr *) &drv->hostapd_addr,
1689 sizeof(drv->hostapd_addr)) < 0) {
1694 if (drv->test_socket >= 0 && drv->hostapd_addr_udp_set &&
1695 sendto(drv->test_socket, "DISASSOC", 8, 0,
1696 (struct sockaddr *) &drv->hostapd_addr_udp,
1697 sizeof(drv->hostapd_addr_udp)) < 0) {
1709 struct wpa_driver_test_data *drv = dbss->drv;
1713 drv->associated = 0;
1714 wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL);
1715 return wpa_driver_test_send_disassoc(drv);
1738 static void wpa_driver_test_scanresp(struct wpa_driver_test_data *drv,
1751 if (drv->num_scanres >= MAX_SCAN_RESULTS) {
1829 os_free(drv->scanres[drv->num_scanres]);
1830 drv->scanres[drv->num_scanres++] = res;
1834 static void wpa_driver_test_assocresp(struct wpa_driver_test_data *drv,
1841 bss = dl_list_first(&drv->bss, struct test_driver_bss, list);
1848 if (drv->use_associnfo) {
1851 event.assoc_info.req_ies = drv->assoc_wpa_ie;
1852 event.assoc_info.req_ies_len = drv->assoc_wpa_ie_len;
1853 wpa_supplicant_event(drv->ctx, EVENT_ASSOCINFO, &event);
1855 drv->associated = 1;
1856 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, NULL);
1860 static void wpa_driver_test_disassoc(struct wpa_driver_test_data *drv,
1864 drv->associated = 0;
1865 wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL);
1869 static void wpa_driver_test_eapol(struct wpa_driver_test_data *drv,
1877 bss = dl_list_first(&drv->bss, struct test_driver_bss, list);
1887 drv_event_eapol_rx(drv->ctx, src, data, data_len);
1891 static void wpa_driver_test_mlme(struct wpa_driver_test_data *drv,
1902 bss = dl_list_first(&drv->bss, struct test_driver_bss, list);
1919 if (drv->remain_on_channel_freq)
1920 own_freq = drv
1922 own_freq = drv->current_freq;
1935 wpa_supplicant_event(drv->ctx, EVENT_MLME_RX, &event);
1940 if (drv->probe_req_report && data_len >= 24) {
1950 wpa_supplicant_event(drv->ctx, EVENT_RX_PROBE_REQ,
1953 if (drv->p2p)
1954 p2p_probe_req_rx(drv->p2p, mgmt->sa,
1963 if (drv->p2p &&
1969 p2p_rx_action(drv->p2p, mgmt->da, mgmt->sa, mgmt->bssid,
1979 static void wpa_driver_test_scan_cmd(struct wpa_driver_test_data *drv,
1988 bss = dl_list_first(&drv->bss, struct test_driver_bss, list);
1992 if (drv->probe_req_report && drv->p2p && data_len) {
2008 drv->probe_from = from;
2009 drv->probe_from_len = fromlen;
2010 p2p_probe_req_rx(drv->p2p, sa, NULL, NULL, ie, ielen);
2011 drv->probe_from = NULL;
2015 if (!drv->ibss)
2033 pos += wpa_snprintf_hex(pos, end - pos, drv->assoc_wpa_ie,
2034 drv->assoc_wpa_ie_len);
2048 sendto(drv->test_socket, buf, pos - buf, 0,
2056 struct wpa_driver_test_data *drv = eloop_ctx;
2063 if (drv->ap) {
2083 wpa_driver_test_scanresp(drv, (struct sockaddr *) &from,
2086 wpa_driver_test_assocresp(drv, (struct sockaddr *) &from,
2089 wpa_driver_test_disassoc(drv, (struct sockaddr *) &from,
2092 wpa_driver_test_disassoc(drv, (struct sockaddr *) &from,
2095 wpa_driver_test_eapol(drv, (struct sockaddr *) &from, fromlen,
2098 wpa_driver_test_mlme(drv, (struct sockaddr *) &from, fromlen,
2101 wpa_driver_test_scan_cmd(drv, (struct sockaddr *) &from,
2115 struct wpa_driver_test_data *drv;
2119 drv = test_alloc_data(ctx, ifname);
2120 if (drv == NULL)
2122 bss = dl_list_first(&drv->bss, struct test_driver_bss, list);
2123 drv->global = global_priv;
2124 drv->test_socket = -1;
2137 os_memcpy(drv->own_addr, global->req_addr, ETH_ALEN);
2141 eloop_register_timeout(1, 0, wpa_driver_test_poll, drv, NULL);
2147 static void wpa_driver_test_close_test_socket(struct wpa_driver_test_data *drv)
2149 if (drv->test_socket >= 0) {
2150 eloop_unregister_read_sock(drv->test_socket);
2151 close(drv->test_socket);
2152 drv->test_socket = -1;
2155 if (drv->own_socket_path) {
2156 unlink(drv->own_socket_path);
2157 os_free(drv->own_socket_path);
2158 drv->own_socket_path = NULL;
2166 struct wpa_driver_test_data *drv = dbss->drv;
2171 if (drv->p2p)
2172 p2p_deinit(drv->p2p);
2173 wpabuf_free(drv->pending_action_tx);
2176 cli = drv->cli;
2185 if (dl_list_len(&drv->bss) != 1)
2187 __func__, dl_list_len(&drv->bss));
2190 test_driver_free_bsses(drv);
2192 wpa_driver_test_close_test_socket(drv);
2193 eloop_cancel_timeout(wpa_driver_test_scan_timeout, drv, drv->ctx);
2194 eloop_cancel_timeout(wpa_driver_test_poll, drv, NULL);
2195 eloop_cancel_timeout(test_remain_on_channel_timeout, drv, NULL);
2196 os_free(drv->test_dir);
2198 os_free(drv->scanres[i]);
2199 os_free(drv->probe_req_ie);
2200 wpa_trace_remove_ref(drv, ctx, drv->ctx);
2201 os_free(drv);
2205 static int wpa_driver_test_attach(struct wpa_driver_test_data *drv,
2213 os_free(drv->own_socket_path);
2216 drv->own_socket_path = os_malloc(len);
2217 if (drv->own_socket_path == NULL)
2219 os_snprintf(drv->own_socket_path, len, "%s/%s-" MACSTR,
2220 dir, ap ? "AP" : "STA", MAC2STR(drv->own_addr));
2222 drv->own_socket_path = os_malloc(100);
2223 if (drv->own_socket_path == NULL)
2225 os_snprintf(drv->own_socket_path, 100,
2230 drv->test_socket = socket(PF_UNIX, SOCK_DGRAM, 0);
2231 if (drv->test_socket < 0) {
2233 os_free(drv->own_socket_path);
2234 drv->own_socket_path = NULL;
2240 os_strlcpy(addr.sun_path, drv->own_socket_path, sizeof(addr.sun_path));
2241 if (bind(drv->test_socket, (struct sockaddr *) &addr,
2244 close(drv->test_socket);
2245 unlink(drv->own_socket_path);
2246 os_free(drv->own_socket_path);
2247 drv->own_socket_path = NULL;
2251 eloop_register_read_sock(drv->test_socket,
2252 wpa_driver_test_receive_unix, drv, NULL);
2261 static int wpa_driver_test_attach_udp(struct wpa_driver_test_data *drv,
2272 drv->test_socket = socket(PF_INET, SOCK_DGRAM, 0);
2273 if (drv->test_socket < 0) {
2278 os_memset(&drv->hostapd_addr_udp, 0, sizeof(drv->hostapd_addr_udp));
2279 drv->hostapd_addr_udp.sin_family = AF_INET;
2285 pos = (u8 *) &drv->hostapd_addr_udp.sin_addr;
2292 inet_aton(dst, &drv->hostapd_addr_udp.sin_addr);
2294 drv->hostapd_addr_udp.sin_port = htons(atoi(pos));
2296 drv->hostapd_addr_udp_set = 1;
2298 eloop_register_read_sock(drv->test_socket,
2299 wpa_driver_test_receive_unix, drv, NULL);
2308 struct wpa_driver_test_data *drv = dbss->drv;
2315 wpa_driver_test_close_test_socket(drv);
2329 if (len > sizeof(drv->hostapd_addr.sun_path))
2331 os_memset(&drv->hostapd_addr, 0, sizeof(drv->hostapd_addr));
2332 drv->hostapd_addr.sun_family = AF_UNIX;
2333 os_memcpy(drv->hostapd_addr.sun_path, pos, len);
2334 drv->hostapd_addr_set = 1;
2341 os_free(drv->test_dir);
2342 drv->test_dir = os_strdup(pos + 9);
2343 if (drv->test_dir == NULL)
2345 end = os_strchr(drv->test_dir, ' ');
2348 if (wpa_driver_test_attach(drv, drv->test_dir, 0))
2360 if (wpa_driver_test_attach_udp(drv, dst))
2363 } else if (wpa_driver_test_attach(drv, NULL, 0))
2369 drv->use_associnfo = 1;
2375 if (wpa_driver_test_init_p2p(drv) < 0)
2386 struct wpa_driver_test_data *drv = dbss->drv;
2388 return drv->own_addr;
2396 struct wpa_driver_test_data *drv = dbss->drv;
2410 os_memcpy(eth.h_source, drv->own_addr, ETH_ALEN);
2422 drv->test_dir == NULL) {
2423 if (drv->hostapd_addr_udp_set) {
2424 addr = (struct sockaddr *) &drv->hostapd_addr_udp;
2425 alen = sizeof(drv->hostapd_addr_udp);
2428 addr = (struct sockaddr *) &drv->hostapd_addr;
2429 alen = sizeof(drv->hostapd_addr);
2441 "%s/STA-" MACSTR, drv->test_dir, MAC2STR(dest));
2445 drv->test_dir, MAC2STR(dest));
2455 if (sendto(drv->test_socket, msg, msg_len, 0, addr, alen) < 0) {
2469 struct wpa_driver_test_data *drv = dbss->drv;
2485 if (drv->p2p)
2643 struct wpa_driver_test_data *drv = dbss->drv;
2645 drv->current_freq = freq->freq;
2658 struct wpa_driver_test_data *drv = dbss->drv;
2665 if ((drv->remain_on_channel_freq &&
2666 freq != drv->remain_on_channel_freq) ||
2667 (drv->remain_on_channel_freq == 0 &&
2668 freq != (unsigned int) drv->current_freq)) {
2672 freq, drv->current_freq,
2673 drv->remain_on_channel_freq);
2697 struct wpa_driver_test_data *drv = eloop_ctx;
2699 if (drv->pending_action_tx == NULL)
2702 if (drv->off_channel_freq != drv->pending_action_freq) {
2705 drv->pending_action_freq);
2709 MACSTR, MAC2STR(drv->pending_action_dst));
2710 wpa_driver_test_send_action(drv, drv->pending_action_freq, 0,
2711 drv->pending_action_dst,
2712 drv->pending_action_src,
2713 drv->pending_action_bssid,
2714 wpabuf_head(drv->pending_action_tx),
2715 wpabuf_len(drv->pending_action_tx),
2716 drv->pending_action_no_cck);
2723 struct wpa_driver_test_data *drv = eloop_ctx;
2729 data.remain_on_channel.freq = drv->remain_on_channel_freq;
2730 data.remain_on_channel.duration = drv->remain_on_channel_duration;
2732 if (drv->p2p)
2733 drv->off_channel_freq = 0;
2735 drv->remain_on_channel_freq = 0;
2737 wpa_supplicant_event(drv->ctx, EVENT_CANCEL_REMAIN_ON_CHANNEL, &data);
2745 struct wpa_driver_test_data *drv = dbss->drv;
2750 if (drv->remain_on_channel_freq &&
2751 drv->remain_on_channel_freq != freq) {
2757 drv->remain_on_channel_freq = freq;
2758 drv->remain_on_channel_duration = duration;
2759 eloop_cancel_timeout(test_remain_on_channel_timeout, drv, NULL);
2761 test_remain_on_channel_timeout, drv, NULL);
2766 wpa_supplicant_event(drv->ctx, EVENT_REMAIN_ON_CHANNEL, &data);
2769 if (drv->p2p) {
2770 drv->off_channel_freq = drv->remain_on_channel_freq;
2771 test_send_action_cb(drv, NULL);
2772 if (drv->off_channel_freq == drv->pending_listen_freq) {
2773 p2p_listen_cb(drv->p2p, drv->pending_listen_freq,
2774 drv->pending_listen_duration);
2775 drv->pending_listen_freq = 0;
2787 struct wpa_driver_test_data *drv = dbss->drv;
2789 if (!drv->remain_on_channel_freq)
2791 drv->remain_on_channel_freq = 0;
2792 eloop_cancel_timeout(test_remain_on_channel_timeout, drv, NULL);
2800 struct wpa_driver_test_data *drv = dbss->drv;
2802 drv->probe_req_report = report;
2812 struct wpa_driver_test_data *drv = dbss->drv;
2814 if (!drv->p2p)
2816 return p2p_find(drv->p2p, timeout, type, 0, NULL, NULL, 0);
2823 struct wpa_driver_test_data *drv = dbss->drv;
2825 if (!drv->p2p)
2827 p2p_stop_find(drv->p2p);
2835 struct wpa_driver_test_data *drv = dbss->drv;
2837 if (!drv->p2p)
2839 return p2p_listen(drv->p2p, timeout);
2850 struct wpa_driver_test_data *drv = dbss->drv;
2857 if (!drv->p2p)
2859 return p2p_connect(drv->p2p, peer_addr, wps_method, go_intent,
2868 struct wpa_driver_test_data *drv = dbss->drv;
2871 if (!drv->p2p)
2873 p2p_wps_success_cb(drv->p2p, peer_addr);
2881 struct wpa_driver_test_data *drv = dbss->drv;
2883 if (!drv->p2p)
2885 p2p_group_formation_failed(drv->p2p);
2894 struct wpa_driver_test_data *drv = dbss->drv;
2896 if (!drv->p2p)
2898 if (p2p_set_dev_name(drv->p2p, params->dev_name) < 0 ||
2899 p2p_set_pri_dev_type(drv->p2p, params->pri_dev_type) < 0 ||
2900 p2p_set_sec_dev_types(drv->p2p, params->sec_dev_type,
2911 struct wpa_driver_test_data *drv = ctx;
2938 ielen = p2p_scan_ie_buf_len(drv->p2p);
2947 p2p_scan_ie(drv->p2p, ies, dev_id);
2964 drv->pending_p2p_scan = 1;
2965 ret = wpa_driver_test_scan(drv, ¶ms);
2977 struct wpa_driver_test_data *drv = ctx;
2989 if (drv->pending_action_tx) {
2991 "to " MACSTR, MAC2STR(drv->pending_action_dst));
2992 wpabuf_free(drv->pending_action_tx);
2994 drv->pending_action_tx = wpabuf_alloc(len);
2995 if (drv->pending_action_tx == NULL)
2997 wpabuf_put_data(drv->pending_action_tx, buf, len);
2998 os_memcpy(drv->pending_action_src, src, ETH_ALEN);
2999 os_memcpy(drv->pending_action_dst, dst, ETH_ALEN);
3000 os_memcpy(drv->pending_action_bssid, bssid, ETH_ALEN);
3001 drv->pending_action_freq = freq;
3002 drv->pending_action_no_cck = 1;
3004 if (drv->off_channel_freq == freq) {
3008 eloop_cancel_timeout(test_send_action_cb, drv, NULL);
3009 eloop_register_timeout(0, 0, test_send_action_cb, drv, NULL);
3015 if (wpa_driver_test_remain_on_channel(drv, freq, wait_time) < 0) {
3035 struct wpa_driver_test_data *drv = ctx;
3040 wpa_supplicant_event(drv->ctx, EVENT_P2P_GO_NEG_COMPLETED, &event);
3046 struct wpa_driver_test_data *drv = ctx;
3052 wpa_supplicant_event(drv->ctx, EVENT_P2P_GO_NEG_REQ_RX, &event);
3059 struct wpa_driver_test_data *drv = ctx;
3079 wpa_supplicant_event(drv->ctx, EVENT_P2P_DEV_FOUND, &event);
3087 struct wpa_driver_test_data *drv = ctx;
3092 if (wpa_driver_test_probe_req_report(drv, 1) < 0)
3095 drv->pending_listen_freq = freq;
3096 drv->pending_listen_duration = duration;
3098 if (wpa_driver_test_remain_on_channel(drv, freq, duration) < 0) {
3099 drv->pending_listen_freq = 0;
3116 struct wpa_driver_test_data *drv = ctx;
3126 if (!drv->probe_from) {
3156 sendto(drv->test_socket, resp, pos - resp, 0,
3157 drv->probe_from, drv->probe_from_len);
3207 static int wpa_driver_test_init_p2p(struct wpa_driver_test_data *drv)
3215 p2p.cb_ctx = drv;
3231 os_memcpy(p2p.dev_addr, drv->own_addr, ETH_ALEN);
3260 drv->p2p = p2p_init(&p2p);
3261 if (drv->p2p == NULL)
