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