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