vcs.maemo.org Git - wpasupplicant/blob - 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
  38 #ifdef HOSTAPD
  39
  40 #include "../../hostapd/hostapd.h"
  41 #include "../../hostapd/config.h"
  42 #include "../../hostapd/wpa.h"
  43 #include "../../hostapd/hw_features.h"
  44 #include "../../hostapd/wps_hostapd.h"
  45
  46
  47 struct test_client_socket {
  48         struct test_client_socket *next;
  49         u8 addr[ETH_ALEN];
  50         struct sockaddr_un un;
  51         socklen_t unlen;
  52         struct test_driver_bss *bss;
  53 };
  54
  55 struct test_driver_bss {
  56         struct test_driver_bss *next;
  57         char ifname[IFNAMSIZ + 1];
  58         u8 bssid[ETH_ALEN];
  59         u8 *ie;
  60         size_t ielen;
  61         u8 *wps_beacon_ie;
  62         size_t wps_beacon_ie_len;
  63         u8 *wps_probe_resp_ie;
  64         size_t wps_probe_resp_ie_len;
  65         u8 ssid[32];
  66         size_t ssid_len;
  67         int privacy;
  68 };
  69
  70 struct test_driver_data {
  71         struct hostapd_data *hapd;
  72         struct test_client_socket *cli;
  73         int test_socket;
  74         struct test_driver_bss *bss;
  75         char *socket_dir;
  76         char *own_socket_path;
  77         int udp_port;
  78 };
  79
  80
  81 static void test_driver_free_bss(struct test_driver_bss *bss)
  82 {
  83         free(bss->ie);
  84         free(bss->wps_beacon_ie);
  85         free(bss->wps_probe_resp_ie);
  86         free(bss);
  87 }
  88
  89
  90 static void test_driver_free_priv(struct test_driver_data *drv)
  91 {
  92         struct test_driver_bss *bss, *prev;
  93
  94         if (drv == NULL)
  95                 return;
  96
  97         bss = drv->bss;
  98         while (bss) {
  99                 prev = bss;
 100                 bss = bss->next;
 101                 test_driver_free_bss(prev);
 102         }
 103         free(drv->own_socket_path);
 104         free(drv->socket_dir);
 105         free(drv);
 106 }
 107
 108
 109 static struct test_client_socket *
 110 test_driver_get_cli(struct test_driver_data *drv, struct sockaddr_un *from,
 111                     socklen_t fromlen)
 112 {
 113         struct test_client_socket *cli = drv->cli;
 114
 115         while (cli) {
 116                 if (cli->unlen == fromlen &&
 117                     strncmp(cli->un.sun_path, from->sun_path,
 118                             fromlen - sizeof(cli->un.sun_family)) == 0)
 119                         return cli;
 120                 cli = cli->next;
 121         }
 122
 123         return NULL;
 124 }
 125
 126
 127 static int test_driver_send_eapol(void *priv, const u8 *addr, const u8 *data,
 128                                   size_t data_len, int encrypt,
 129                                   const u8 *own_addr)
 130 {
 131         struct test_driver_data *drv = priv;
 132         struct test_client_socket *cli;
 133         struct msghdr msg;
 134         struct iovec io[3];
 135         struct l2_ethhdr eth;
 136
 137         if (drv->test_socket < 0)
 138                 return -1;
 139
 140         cli = drv->cli;
 141         while (cli) {
 142                 if (memcmp(cli->addr, addr, ETH_ALEN) == 0)
 143                         break;
 144                 cli = cli->next;
 145         }
 146
 147         if (!cli) {
 148                 wpa_printf(MSG_DEBUG, "%s: no destination client entry",
 149                            __func__);
 150                 return -1;
 151         }
 152
 153         memcpy(eth.h_dest, addr, ETH_ALEN);
 154         memcpy(eth.h_source, own_addr, ETH_ALEN);
 155         eth.h_proto = host_to_be16(ETH_P_EAPOL);
 156
 157         io[0].iov_base = "EAPOL ";
 158         io[0].iov_len = 6;
 159         io[1].iov_base = &eth;
 160         io[1].iov_len = sizeof(eth);
 161         io[2].iov_base = (u8 *) data;
 162         io[2].iov_len = data_len;
 163
 164         memset(&msg, 0, sizeof(msg));
 165         msg.msg_iov = io;
 166         msg.msg_iovlen = 3;
 167         msg.msg_name = &cli->un;
 168         msg.msg_namelen = cli->unlen;
 169         return sendmsg(drv->test_socket, &msg, 0);
 170 }
 171
 172
 173 static int test_driver_send_ether(void *priv, const u8 *dst, const u8 *src,
 174                                   u16 proto, const u8 *data, size_t data_len)
 175 {
 176         struct test_driver_data *drv = priv;
 177         struct msghdr msg;
 178         struct iovec io[3];
 179         struct l2_ethhdr eth;
 180         char desttxt[30];
 181         struct sockaddr_un addr;
 182         struct dirent *dent;
 183         DIR *dir;
 184         int ret = 0, broadcast = 0, count = 0;
 185
 186         if (drv->test_socket < 0 || drv->socket_dir == NULL) {
 187                 wpa_printf(MSG_DEBUG, "%s: invalid parameters (sock=%d "
 188                            "socket_dir=%p)",
 189                            __func__, drv->test_socket, drv->socket_dir);
 190                 return -1;
 191         }
 192
 193         broadcast = memcmp(dst, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) == 0;
 194         snprintf(desttxt, sizeof(desttxt), MACSTR, MAC2STR(dst));
 195
 196         memcpy(eth.h_dest, dst, ETH_ALEN);
 197         memcpy(eth.h_source, src, ETH_ALEN);
 198         eth.h_proto = host_to_be16(proto);
 199
 200         io[0].iov_base = "ETHER ";
 201         io[0].iov_len = 6;
 202         io[1].iov_base = &eth;
 203         io[1].iov_len = sizeof(eth);
 204         io[2].iov_base = (u8 *) data;
 205         io[2].iov_len = data_len;
 206
 207         memset(&msg, 0, sizeof(msg));
 208         msg.msg_iov = io;
 209         msg.msg_iovlen = 3;
 210
 211         dir = opendir(drv->socket_dir);
 212         if (dir == NULL) {
 213                 perror("test_driver: opendir");
 214                 return -1;
 215         }
 216         while ((dent = readdir(dir))) {
 217 #ifdef _DIRENT_HAVE_D_TYPE
 218                 /* Skip the file if it is not a socket. Also accept
 219                  * DT_UNKNOWN (0) in case the C library or underlying file
 220                  * system does not support d_type. */
 221                 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN)
 222                         continue;
 223 #endif /* _DIRENT_HAVE_D_TYPE */
 224                 if (strcmp(dent->d_name, ".") == 0 ||
 225                     strcmp(dent->d_name, "..") == 0)
 226                         continue;
 227
 228                 memset(&addr, 0, sizeof(addr));
 229                 addr.sun_family = AF_UNIX;
 230                 snprintf(addr.sun_path, sizeof(addr.sun_path), "%s/%s",
 231                          drv->socket_dir, dent->d_name);
 232
 233                 if (strcmp(addr.sun_path, drv->own_socket_path) == 0)
 234                         continue;
 235                 if (!broadcast && strstr(dent->d_name, desttxt) == NULL)
 236                         continue;
 237
 238                 wpa_printf(MSG_DEBUG, "%s: Send ether frame to %s",
 239                            __func__, dent->d_name);
 240
 241                 msg.msg_name = &addr;
 242                 msg.msg_namelen = sizeof(addr);
 243                 ret = sendmsg(drv->test_socket, &msg, 0);
 244                 if (ret < 0)
 245                         perror("driver_test: sendmsg");
 246                 count++;
 247         }
 248         closedir(dir);
 249
 250         if (!broadcast && count == 0) {
 251                 wpa_printf(MSG_DEBUG, "%s: Destination " MACSTR " not found",
 252                            __func__, MAC2STR(dst));
 253                 return -1;
 254         }
 255
 256         return ret;
 257 }
 258
 259
 260 static int test_driver_send_mgmt_frame(void *priv, const void *buf,
 261                                        size_t len, int flags)
 262 {
 263         struct test_driver_data *drv = priv;
 264         struct msghdr msg;
 265         struct iovec io[2];
 266         const u8 *dest;
 267         int ret = 0, broadcast = 0;
 268         char desttxt[30];
 269         struct sockaddr_un addr;
 270         struct dirent *dent;
 271         DIR *dir;
 272         struct ieee80211_hdr *hdr;
 273         u16 fc;
 274
 275         if (drv->test_socket < 0 || len < 10 || drv->socket_dir == NULL) {
 276                 wpa_printf(MSG_DEBUG, "%s: invalid parameters (sock=%d len=%lu"
 277                            " socket_dir=%p)",
 278                            __func__, drv->test_socket, (unsigned long) len,
 279                            drv->socket_dir);
 280                 return -1;
 281         }
 282
 283         dest = buf;
 284         dest += 4;
 285         broadcast = memcmp(dest, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) == 0;
 286         snprintf(desttxt, sizeof(desttxt), MACSTR, MAC2STR(dest));
 287
 288         io[0].iov_base = "MLME ";
 289         io[0].iov_len = 5;
 290         io[1].iov_base = (void *) buf;
 291         io[1].iov_len = len;
 292
 293         memset(&msg, 0, sizeof(msg));
 294         msg.msg_iov = io;
 295         msg.msg_iovlen = 2;
 296
 297         dir = opendir(drv->socket_dir);
 298         if (dir == NULL) {
 299                 perror("test_driver: opendir");
 300                 return -1;
 301         }
 302         while ((dent = readdir(dir))) {
 303 #ifdef _DIRENT_HAVE_D_TYPE
 304                 /* Skip the file if it is not a socket. Also accept
 305                  * DT_UNKNOWN (0) in case the C library or underlying file
 306                  * system does not support d_type. */
 307                 if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN)
 308                         continue;
 309 #endif /* _DIRENT_HAVE_D_TYPE */
 310                 if (strcmp(dent->d_name, ".") == 0 ||
 311                     strcmp(dent->d_name, "..") == 0)
 312                         continue;
 313
 314                 memset(&addr, 0, sizeof(addr));
 315                 addr.sun_family = AF_UNIX;
 316                 snprintf(addr.sun_path, sizeof(addr.sun_path), "%s/%s",
 317                          drv->socket_dir, dent->d_name);
 318
 319                 if (strcmp(addr.sun_path, drv->own_socket_path) == 0)
 320                         continue;
 321                 if (!broadcast && strstr(dent->d_name, desttxt) == NULL)
 322                         continue;
 323
 324                 wpa_printf(MSG_DEBUG, "%s: Send management frame to %s",
 325                            __func__, dent->d_name);
 326
 327                 msg.msg_name = &addr;
 328                 msg.msg_namelen = sizeof(addr);
 329                 ret = sendmsg(drv->test_socket, &msg, 0);
 330                 if (ret < 0)
 331                         perror("driver_test: sendmsg");
 332         }
 333         closedir(dir);
 334
 335         hdr = (struct ieee80211_hdr *) buf;
 336         fc = le_to_host16(hdr->frame_control);
 337         hostapd_mgmt_tx_cb(drv->hapd, (u8 *) buf, len, WLAN_FC_GET_STYPE(fc),
 338                            ret >= 0);
 339
 340         return ret;
 341 }
 342
 343
 344 static void test_driver_scan(struct test_driver_data *drv,
 345                              struct sockaddr_un *from, socklen_t fromlen,
 346                              char *data)
 347 {
 348         char buf[512], *pos, *end;
 349         int ret;
 350         struct test_driver_bss *bss;
 351         u8 sa[ETH_ALEN];
 352         u8 ie[512];
 353         size_t ielen;
 354
 355         /* data: optional [ ' ' | STA-addr | ' ' | IEs(hex) ] */
 356
 357         wpa_printf(MSG_DEBUG, "test_driver: SCAN");
 358
 359         if (*data) {
 360                 if (*data != ' ' ||
 361                     hwaddr_aton(data + 1, sa)) {
 362                         wpa_printf(MSG_DEBUG, "test_driver: Unexpected SCAN "
 363                                    "command format");
 364                         return;
 365                 }
 366
 367                 data += 18;
 368                 while (*data == ' ')
 369                         data++;
 370                 ielen = os_strlen(data) / 2;
 371                 if (ielen > sizeof(ie))
 372                         ielen = sizeof(ie);
 373                 if (hexstr2bin(data, ie, ielen) < 0)
 374                         ielen = 0;
 375
 376                 wpa_printf(MSG_DEBUG, "test_driver: Scan from " MACSTR,
 377                            MAC2STR(sa));
 378                 wpa_hexdump(MSG_MSGDUMP, "test_driver: scan IEs", ie, ielen);
 379
 380                 hostapd_wps_probe_req_rx(drv->hapd, sa, ie, ielen);
 381         }
 382
 383         for (bss = drv->bss; bss; bss = bss->next) {
 384                 pos = buf;
 385                 end = buf + sizeof(buf);
 386
 387                 /* reply: SCANRESP BSSID SSID IEs */
 388                 ret = snprintf(pos, end - pos, "SCANRESP " MACSTR " ",
 389                                MAC2STR(bss->bssid));
 390                 if (ret < 0 || ret >= end - pos)
 391                         return;
 392                 pos += ret;
 393                 pos += wpa_snprintf_hex(pos, end - pos,
 394                                         bss->ssid, bss->ssid_len);
 395                 ret = snprintf(pos, end - pos, " ");
 396                 if (ret < 0 || ret >= end - pos)
 397                         return;
 398                 pos += ret;
 399                 pos += wpa_snprintf_hex(pos, end - pos, bss->ie, bss->ielen);
 400                 pos += wpa_snprintf_hex(pos, end - pos, bss->wps_probe_resp_ie,
 401                                         bss->wps_probe_resp_ie_len);
 402
 403                 if (bss->privacy) {
 404                         ret = snprintf(pos, end - pos, " PRIVACY");
 405                         if (ret < 0 || ret >= end - pos)
 406                                 return;
 407                         pos += ret;
 408                 }
 409
 410                 sendto(drv->test_socket, buf, pos - buf, 0,
 411                        (struct sockaddr *) from, fromlen);
 412         }
 413 }
 414
 415
 416 static struct hostapd_data * test_driver_get_hapd(struct test_driver_data *drv,
 417                                                   struct test_driver_bss *bss)
 418 {
 419         struct hostapd_iface *iface = drv->hapd->iface;
 420         struct hostapd_data *hapd = NULL;
 421         size_t i;
 422
 423         if (bss == NULL) {
 424                 wpa_printf(MSG_DEBUG, "%s: bss == NULL", __func__);
 425                 return NULL;
 426         }
 427
 428         for (i = 0; i < iface->num_bss; i++) {
 429                 hapd = iface->bss[i];
 430                 if (memcmp(hapd->own_addr, bss->bssid, ETH_ALEN) == 0)
 431                         break;
 432         }
 433         if (i == iface->num_bss) {
 434                 wpa_printf(MSG_DEBUG, "%s: no matching interface entry found "
 435                            "for BSSID " MACSTR, __func__, MAC2STR(bss->bssid));
 436                 return NULL;
 437         }
 438
 439         return hapd;
 440 }
 441
 442
 443 static int test_driver_new_sta(struct test_driver_data *drv,
 444                                struct test_driver_bss *bss, const u8 *addr,
 445                                const u8 *ie, size_t ielen)
 446 {
 447         struct hostapd_data *hapd;
 448
 449         hapd = test_driver_get_hapd(drv, bss);
 450         if (hapd == NULL)
 451                 return -1;
 452
 453         return hostapd_notif_assoc(hapd, addr, ie, ielen);
 454 }
 455
 456
 457 static void test_driver_assoc(struct test_driver_data *drv,
 458                               struct sockaddr_un *from, socklen_t fromlen,
 459                               char *data)
 460 {
 461         struct test_client_socket *cli;
 462         u8 ie[256], ssid[32];
 463         size_t ielen, ssid_len = 0;
 464         char *pos, *pos2, cmd[50];
 465         struct test_driver_bss *bss;
 466
 467         /* data: STA-addr SSID(hex) IEs(hex) */
 468
 469         cli = os_zalloc(sizeof(*cli));
 470         if (cli == NULL)
 471                 return;
 472
 473         if (hwaddr_aton(data, cli->addr)) {
 474                 printf("test_socket: Invalid MAC address '%s' in ASSOC\n",
 475                        data);
 476                 free(cli);
 477                 return;
 478         }
 479         pos = data + 17;
 480         while (*pos == ' ')
 481                 pos++;
 482         pos2 = strchr(pos, ' ');
 483         ielen = 0;
 484         if (pos2) {
 485                 ssid_len = (pos2 - pos) / 2;
 486                 if (hexstr2bin(pos, ssid, ssid_len) < 0) {
 487                         wpa_printf(MSG_DEBUG, "%s: Invalid SSID", __func__);
 488                         free(cli);
 489                         return;
 490                 }
 491                 wpa_hexdump_ascii(MSG_DEBUG, "test_driver_assoc: SSID",
 492                                   ssid, ssid_len);
 493
 494                 pos = pos2 + 1;
 495                 ielen = strlen(pos) / 2;
 496                 if (ielen > sizeof(ie))
 497                         ielen = sizeof(ie);
 498                 if (hexstr2bin(pos, ie, ielen) < 0)
 499                         ielen = 0;
 500         }
 501
 502         for (bss = drv->bss; bss; bss = bss->next) {
 503                 if (bss->ssid_len == ssid_len &&
 504                     memcmp(bss->ssid, ssid, ssid_len) == 0)
 505                         break;
 506         }
 507         if (bss == NULL) {
 508                 wpa_printf(MSG_DEBUG, "%s: No matching SSID found from "
 509                            "configured BSSes", __func__);
 510                 free(cli);
 511                 return;
 512         }
 513
 514         cli->bss = bss;
 515         memcpy(&cli->un, from, sizeof(cli->un));
 516         cli->unlen = fromlen;
 517         cli->next = drv->cli;
 518         drv->cli = cli;
 519         wpa_hexdump_ascii(MSG_DEBUG, "test_socket: ASSOC sun_path",
 520                           (const u8 *) cli->un.sun_path,
 521                           cli->unlen - sizeof(cli->un.sun_family));
 522
 523         snprintf(cmd, sizeof(cmd), "ASSOCRESP " MACSTR " 0",
 524                  MAC2STR(bss->bssid));
 525         sendto(drv->test_socket, cmd, strlen(cmd), 0,
 526                (struct sockaddr *) from, fromlen);
 527
 528         if (test_driver_new_sta(drv, bss, cli->addr, ie, ielen) < 0) {
 529                 wpa_printf(MSG_DEBUG, "test_driver: failed to add new STA");
 530         }
 531 }
 532
 533
 534 static void test_driver_disassoc(struct test_driver_data *drv,
 535                                  struct sockaddr_un *from, socklen_t fromlen)
 536 {
 537         struct test_client_socket *cli;
 538
 539         cli = test_driver_get_cli(drv, from, fromlen);
 540         if (!cli)
 541                 return;
 542
 543         hostapd_notif_disassoc(drv->hapd, cli->addr);
 544 }
 545
 546
 547 static void test_driver_eapol(struct test_driver_data *drv,
 548                               struct sockaddr_un *from, socklen_t fromlen,
 549                               u8 *data, size_t datalen)
 550 {
 551         struct test_client_socket *cli;
 552         if (datalen > 14) {
 553                 /* Skip Ethernet header */
 554                 wpa_printf(MSG_DEBUG, "test_driver: dst=" MACSTR " src="
 555                            MACSTR " proto=%04x",
 556                            MAC2STR(data), MAC2STR(data + ETH_ALEN),
 557                            WPA_GET_BE16(data + 2 * ETH_ALEN));
 558                 data += 14;
 559                 datalen -= 14;
 560         }
 561         cli = test_driver_get_cli(drv, from, fromlen);
 562         if (cli) {
 563                 struct hostapd_data *hapd;
 564                 hapd = test_driver_get_hapd(drv, cli->bss);
 565                 if (hapd == NULL)
 566                         return;
 567                 hostapd_eapol_receive(hapd, cli->addr, data, datalen);
 568         } else {
 569                 wpa_printf(MSG_DEBUG, "test_socket: EAPOL from unknown "
 570                            "client");
 571         }
 572 }
 573
 574
 575 static void test_driver_ether(struct test_driver_data *drv,
 576                               struct sockaddr_un *from, socklen_t fromlen,
 577                               u8 *data, size_t datalen)
 578 {
 579         struct l2_ethhdr *eth;
 580
 581         if (datalen < sizeof(*eth))
 582                 return;
 583
 584         eth = (struct l2_ethhdr *) data;
 585         wpa_printf(MSG_DEBUG, "test_driver: RX ETHER dst=" MACSTR " src="
 586                    MACSTR " proto=%04x",
 587                    MAC2STR(eth->h_dest), MAC2STR(eth->h_source),
 588                    be_to_host16(eth->h_proto));
 589
 590 #ifdef CONFIG_IEEE80211R
 591         if (be_to_host16(eth->h_proto) == ETH_P_RRB) {
 592                 wpa_ft_rrb_rx(drv->hapd->wpa_auth, eth->h_source,
 593                               data + sizeof(*eth), datalen - sizeof(*eth));
 594         }
 595 #endif /* CONFIG_IEEE80211R */
 596 }
 597
 598
 599 static void test_driver_mlme(struct test_driver_data *drv,
 600                              struct sockaddr_un *from, socklen_t fromlen,
 601                              u8 *data, size_t datalen)
 602 {
 603         struct ieee80211_hdr *hdr;
 604         u16 fc;
 605
 606         hdr = (struct ieee80211_hdr *) data;
 607
 608         if (test_driver_get_cli(drv, from, fromlen) == NULL && datalen >= 16) {
 609                 struct test_client_socket *cli;
 610                 cli = os_zalloc(sizeof(*cli));
 611                 if (cli == NULL)
 612                         return;
 613                 wpa_printf(MSG_DEBUG, "Adding client entry for " MACSTR,
 614                            MAC2STR(hdr->addr2));
 615                 memcpy(cli->addr, hdr->addr2, ETH_ALEN);
 616                 memcpy(&cli->un, from, sizeof(cli->un));
 617                 cli->unlen = fromlen;
 618                 cli->next = drv->cli;
 619                 drv->cli = cli;
 620         }
 621
 622         wpa_hexdump(MSG_MSGDUMP, "test_driver_mlme: received frame",
 623                     data, datalen);
 624         fc = le_to_host16(hdr->frame_control);
 625         if (WLAN_FC_GET_TYPE(fc) != WLAN_FC_TYPE_MGMT) {
 626                 wpa_printf(MSG_ERROR, "%s: received non-mgmt frame",
 627                            __func__);
 628                 return;
 629         }
 630         hostapd_mgmt_rx(drv->hapd, data, datalen, WLAN_FC_GET_STYPE(fc), NULL);
 631 }
 632
 633
 634 static void test_driver_receive_unix(int sock, void *eloop_ctx, void *sock_ctx)
 635 {
 636         struct test_driver_data *drv = eloop_ctx;
 637         char buf[2000];
 638         int res;
 639         struct sockaddr_un from;
 640         socklen_t fromlen = sizeof(from);
 641
 642         res = recvfrom(sock, buf, sizeof(buf) - 1, 0,
 643                        (struct sockaddr *) &from, &fromlen);
 644         if (res < 0) {
 645                 perror("recvfrom(test_socket)");
 646                 return;
 647         }
 648         buf[res] = '\0';
 649
 650         wpa_printf(MSG_DEBUG, "test_driver: received %u bytes", res);
 651
 652         if (strncmp(buf, "SCAN", 4) == 0) {
 653                 test_driver_scan(drv, &from, fromlen, buf + 4);
 654         } else if (strncmp(buf, "ASSOC ", 6) == 0) {
 655                 test_driver_assoc(drv, &from, fromlen, buf + 6);
 656         } else if (strcmp(buf, "DISASSOC") == 0) {
 657                 test_driver_disassoc(drv, &from, fromlen);
 658         } else if (strncmp(buf, "EAPOL ", 6) == 0) {
 659                 test_driver_eapol(drv, &from, fromlen, (u8 *) buf + 6,
 660                                   res - 6);
 661         } else if (strncmp(buf, "ETHER ", 6) == 0) {
 662                 test_driver_ether(drv, &from, fromlen, (u8 *) buf + 6,
 663                                   res - 6);
 664         } else if (strncmp(buf, "MLME ", 5) == 0) {
 665                 test_driver_mlme(drv, &from, fromlen, (u8 *) buf + 5, res - 5);
 666         } else {
 667                 wpa_hexdump_ascii(MSG_DEBUG, "Unknown test_socket command",
 668                                   (u8 *) buf, res);
 669         }
 670 }
 671
 672
 673 static struct test_driver_bss *
 674 test_driver_get_bss(struct test_driver_data *drv, const char *ifname)
 675 {
 676         struct test_driver_bss *bss;
 677
 678         for (bss = drv->bss; bss; bss = bss->next) {
 679                 if (strcmp(bss->ifname, ifname) == 0)
 680                         return bss;
 681         }
 682         return NULL;
 683 }
 684
 685
 686 static int test_driver_set_generic_elem(const char *ifname, void *priv,
 687                                         const u8 *elem, size_t elem_len)
 688 {
 689         struct test_driver_data *drv = priv;
 690         struct test_driver_bss *bss;
 691
 692         bss = test_driver_get_bss(drv, ifname);
 693         if (bss == NULL)
 694                 return -1;
 695
 696         free(bss->ie);
 697
 698         if (elem == NULL) {
 699                 bss->ie = NULL;
 700                 bss->ielen = 0;
 701                 return 0;
 702         }
 703
 704         bss->ie = malloc(elem_len);
 705         if (bss->ie == NULL) {
 706                 bss->ielen = 0;
 707                 return -1;
 708         }
 709
 710         memcpy(bss->ie, elem, elem_len);
 711         bss->ielen = elem_len;
 712         return 0;
 713 }
 714
 715
 716 static int test_driver_set_wps_beacon_ie(const char *ifname, void *priv,
 717                                          const u8 *ie, size_t len)
 718 {
 719         struct test_driver_data *drv = priv;
 720         struct test_driver_bss *bss;
 721
 722         wpa_hexdump(MSG_DEBUG, "test_driver: Beacon WPS IE", ie, len);
 723         bss = test_driver_get_bss(drv, ifname);
 724         if (bss == NULL)
 725                 return -1;
 726
 727         free(bss->wps_beacon_ie);
 728
 729         if (ie == NULL) {
 730                 bss->wps_beacon_ie = NULL;
 731                 bss->wps_beacon_ie_len = 0;
 732                 return 0;
 733         }
 734
 735         bss->wps_beacon_ie = malloc(len);
 736         if (bss->wps_beacon_ie == NULL) {
 737                 bss->wps_beacon_ie_len = 0;
 738                 return -1;
 739         }
 740
 741         memcpy(bss->wps_beacon_ie, ie, len);
 742         bss->wps_beacon_ie_len = len;
 743         return 0;
 744 }
 745
 746
 747 static int test_driver_set_wps_probe_resp_ie(const char *ifname, void *priv,
 748                                              const u8 *ie, size_t len)
 749 {
 750         struct test_driver_data *drv = priv;
 751         struct test_driver_bss *bss;
 752
 753         wpa_hexdump(MSG_DEBUG, "test_driver: ProbeResp WPS IE", ie, len);
 754         bss = test_driver_get_bss(drv, ifname);
 755         if (bss == NULL)
 756                 return -1;
 757
 758         free(bss->wps_probe_resp_ie);
 759
 760         if (ie == NULL) {
 761                 bss->wps_probe_resp_ie = NULL;
 762                 bss->wps_probe_resp_ie_len = 0;
 763                 return 0;
 764         }
 765
 766         bss->wps_probe_resp_ie = malloc(len);
 767         if (bss->wps_probe_resp_ie == NULL) {
 768                 bss->wps_probe_resp_ie_len = 0;
 769                 return -1;
 770         }
 771
 772         memcpy(bss->wps_probe_resp_ie, ie, len);
 773         bss->wps_probe_resp_ie_len = len;
 774         return 0;
 775 }
 776
 777
 778 static int test_driver_sta_deauth(void *priv, const u8 *addr, int reason)
 779 {
 780         struct test_driver_data *drv = priv;
 781         struct test_client_socket *cli;
 782
 783         if (drv->test_socket < 0)
 784                 return -1;
 785
 786         cli = drv->cli;
 787         while (cli) {
 788                 if (memcmp(cli->addr, addr, ETH_ALEN) == 0)
 789                         break;
 790                 cli = cli->next;
 791         }
 792
 793         if (!cli)
 794                 return -1;
 795
 796         return sendto(drv->test_socket, "DEAUTH", 6, 0,
 797                       (struct sockaddr *) &cli->un, cli->unlen);
 798 }
 799
 800
 801 static int test_driver_sta_disassoc(void *priv, const u8 *addr, int reason)
 802 {
 803         struct test_driver_data *drv = priv;
 804         struct test_client_socket *cli;
 805
 806         if (drv->test_socket < 0)
 807                 return -1;
 808
 809         cli = drv->cli;
 810         while (cli) {
 811                 if (memcmp(cli->addr, addr, ETH_ALEN) == 0)
 812                         break;
 813                 cli = cli->next;
 814         }
 815
 816         if (!cli)
 817                 return -1;
 818
 819         return sendto(drv->test_socket, "DISASSOC", 8, 0,
 820                       (struct sockaddr *) &cli->un, cli->unlen);
 821 }
 822
 823
 824 static struct hostapd_hw_modes *
 825 test_driver_get_hw_feature_data(void *priv, u16 *num_modes, u16 *flags)
 826 {
 827         struct hostapd_hw_modes *modes;
 828
 829         *num_modes = 3;
 830         *flags = 0;
 831         modes = os_zalloc(*num_modes * sizeof(struct hostapd_hw_modes));
 832         if (modes == NULL)
 833                 return NULL;
 834         modes[0].mode = HOSTAPD_MODE_IEEE80211G;
 835         modes[0].num_channels = 1;
 836         modes[0].num_rates = 1;
 837         modes[0].channels = os_zalloc(sizeof(struct hostapd_channel_data));
 838         modes[0].rates = os_zalloc(sizeof(struct hostapd_rate_data));
 839         if (modes[0].channels == NULL || modes[0].rates == NULL) {
 840                 hostapd_free_hw_features(modes, *num_modes);
 841                 return NULL;
 842         }
 843         modes[0].channels[0].chan = 1;
 844         modes[0].channels[0].freq = 2412;
 845         modes[0].channels[0].flag = 0;
 846         modes[0].rates[0].rate = 10;
 847         modes[0].rates[0].flags = HOSTAPD_RATE_BASIC | HOSTAPD_RATE_SUPPORTED |
 848                 HOSTAPD_RATE_CCK | HOSTAPD_RATE_MANDATORY;
 849
 850         modes[1].mode = HOSTAPD_MODE_IEEE80211B;
 851         modes[1].num_channels = 1;
 852         modes[1].num_rates = 1;
 853         modes[1].channels = os_zalloc(sizeof(struct hostapd_channel_data));
 854         modes[1].rates = os_zalloc(sizeof(struct hostapd_rate_data));
 855         if (modes[1].channels == NULL || modes[1].rates == NULL) {
 856                 hostapd_free_hw_features(modes, *num_modes);
 857                 return NULL;
 858         }
 859         modes[1].channels[0].chan = 1;
 860         modes[1].channels[0].freq = 2412;
 861         modes[1].channels[0].flag = 0;
 862         modes[1].rates[0].rate = 10;
 863         modes[1].rates[0].flags = HOSTAPD_RATE_BASIC | HOSTAPD_RATE_SUPPORTED |
 864                 HOSTAPD_RATE_CCK | HOSTAPD_RATE_MANDATORY;
 865
 866         modes[2].mode = HOSTAPD_MODE_IEEE80211A;
 867         modes[2].num_channels = 1;
 868         modes[2].num_rates = 1;
 869         modes[2].channels = os_zalloc(sizeof(struct hostapd_channel_data));
 870         modes[2].rates = os_zalloc(sizeof(struct hostapd_rate_data));
 871         if (modes[2].channels == NULL || modes[2].rates == NULL) {
 872                 hostapd_free_hw_features(modes, *num_modes);
 873                 return NULL;
 874         }
 875         modes[2].channels[0].chan = 60;
 876         modes[2].channels[0].freq = 5300;
 877         modes[2].channels[0].flag = 0;
 878         modes[2].rates[0].rate = 60;
 879         modes[2].rates[0].flags = HOSTAPD_RATE_BASIC | HOSTAPD_RATE_SUPPORTED |
 880                 HOSTAPD_RATE_MANDATORY;
 881
 882         return modes;
 883 }
 884
 885
 886 static int test_driver_bss_add(void *priv, const char *ifname, const u8 *bssid)
 887 {
 888         struct test_driver_data *drv = priv;
 889         struct test_driver_bss *bss;
 890
 891         wpa_printf(MSG_DEBUG, "%s(ifname=%s bssid=" MACSTR ")",
 892                    __func__, ifname, MAC2STR(bssid));
 893
 894         bss = os_zalloc(sizeof(*bss));
 895         if (bss == NULL)
 896                 return -1;
 897
 898         os_strlcpy(bss->ifname, ifname, IFNAMSIZ);
 899         memcpy(bss->bssid, bssid, ETH_ALEN);
 900
 901         bss->next = drv->bss;
 902         drv->bss = bss;
 903
 904         return 0;
 905 }
 906
 907
 908 static int test_driver_bss_remove(void *priv, const char *ifname)
 909 {
 910         struct test_driver_data *drv = priv;
 911         struct test_driver_bss *bss, *prev;
 912         struct test_client_socket *cli, *prev_c;
 913
 914         wpa_printf(MSG_DEBUG, "%s(ifname=%s)", __func__, ifname);
 915
 916         for (prev = NULL, bss = drv->bss; bss; prev = bss, bss = bss->next) {
 917                 if (strcmp(bss->ifname, ifname) != 0)
 918                         continue;
 919
 920                 if (prev)
 921                         prev->next = bss->next;
 922                 else
 923                         drv->bss = bss->next;
 924
 925                 for (prev_c = NULL, cli = drv->cli; cli;
 926                      prev_c = cli, cli = cli->next) {
 927                         if (cli->bss != bss)
 928                                 continue;
 929                         if (prev_c)
 930                                 prev_c->next = cli->next;
 931                         else
 932                                 drv->cli = cli->next;
 933                         free(cli);
 934                         break;
 935                 }
 936
 937                 test_driver_free_bss(bss);
 938                 return 0;
 939         }
 940
 941         return -1;
 942 }
 943
 944
 945 static int test_driver_if_add(const char *iface, void *priv,
 946                               enum hostapd_driver_if_type type, char *ifname,
 947                               const u8 *addr)
 948 {
 949         wpa_printf(MSG_DEBUG, "%s(iface=%s type=%d ifname=%s)",
 950                    __func__, iface, type, ifname);
 951         return 0;
 952 }
 953
 954
 955 static int test_driver_if_update(void *priv, enum hostapd_driver_if_type type,
 956                                  char *ifname, const u8 *addr)
 957 {
 958         wpa_printf(MSG_DEBUG, "%s(type=%d ifname=%s)", __func__, type, ifname);
 959         return 0;
 960 }
 961
 962
 963 static int test_driver_if_remove(void *priv, enum hostapd_driver_if_type type,
 964                                  const char *ifname, const u8 *addr)
 965 {
 966         wpa_printf(MSG_DEBUG, "%s(type=%d ifname=%s)", __func__, type, ifname);
 967         return 0;
 968 }
 969
 970
 971 static int test_driver_valid_bss_mask(void *priv, const u8 *addr,
 972                                       const u8 *mask)
 973 {
 974         return 0;
 975 }
 976
 977
 978 static int test_driver_set_ssid(const char *ifname, void *priv, const u8 *buf,
 979                                 int len)
 980 {
 981         struct test_driver_data *drv = priv;
 982         struct test_driver_bss *bss;
 983
 984         wpa_printf(MSG_DEBUG, "%s(ifname=%s)", __func__, ifname);
 985         wpa_hexdump_ascii(MSG_DEBUG, "test_driver_set_ssid: SSID", buf, len);
 986
 987         for (bss = drv->bss; bss; bss = bss->next) {
 988                 if (strcmp(bss->ifname, ifname) != 0)
 989                         continue;
 990
 991                 if (len < 0 || (size_t) len > sizeof(bss->ssid))
 992                         return -1;
 993
 994                 memcpy(bss->ssid, buf, len);
 995                 bss->ssid_len = len;
 996
 997                 return 0;
 998         }
 999
1000         return -1;
1001 }
1002
1003
1004 static int test_driver_set_privacy(const char *ifname, void *priv, int enabled)
1005 {
1006         struct test_driver_data *drv = priv;
1007         struct test_driver_bss *bss;
1008
1009         wpa_printf(MSG_DEBUG, "%s(ifname=%s enabled=%d)",
1010                    __func__, ifname, enabled);
1011
1012         for (bss = drv->bss; bss; bss = bss->next) {
1013                 if (strcmp(bss->ifname, ifname) != 0)
1014                         continue;
1015
1016                 bss->privacy = enabled;
1017
1018                 return 0;
1019         }
1020
1021         return -1;
1022 }
1023
1024
1025 static int test_driver_set_key(const char *iface, void *priv, wpa_alg alg,
1026                                const u8 *addr, int key_idx, int set_tx,
1027                                const u8 *seq, size_t seq_len,
1028                                const u8 *key, size_t key_len)
1029 {
1030         wpa_printf(MSG_DEBUG, "%s(iface=%s alg=%d idx=%d set_tx=%d)",
1031                    __func__, iface, alg, key_idx, set_tx);
1032         if (addr)
1033                 wpa_printf(MSG_DEBUG, "   addr=" MACSTR, MAC2STR(addr));
1034         if (key)
1035                 wpa_hexdump_key(MSG_DEBUG, "   key", key, key_len);
1036         return 0;
1037 }
1038
1039
1040 static int test_driver_set_sta_vlan(void *priv, const u8 *addr,
1041                                     const char *ifname, int vlan_id)
1042 {
1043         wpa_printf(MSG_DEBUG, "%s(addr=" MACSTR " ifname=%s vlan_id=%d)",
1044                    __func__, MAC2STR(addr), ifname, vlan_id);
1045         return 0;
1046 }
1047
1048
1049 static int test_driver_sta_add(const char *ifname, void *priv,
1050                                struct hostapd_sta_add_params *params)
1051 {
1052         struct test_driver_data *drv = priv;
1053         struct test_client_socket *cli;
1054         struct test_driver_bss *bss;
1055
1056         wpa_printf(MSG_DEBUG, "%s(ifname=%s addr=" MACSTR " aid=%d "
1057                    "capability=0x%x flags=0x%x listen_interval=%d)",
1058                    __func__, ifname, MAC2STR(params->addr), params->aid,
1059                    params->capability, params->flags,
1060                    params->listen_interval);
1061         wpa_hexdump(MSG_DEBUG, "test_driver_sta_add - supp_rates",
1062                     params->supp_rates, params->supp_rates_len);
1063
1064         cli = drv->cli;
1065         while (cli) {
1066                 if (os_memcmp(cli->addr, params->addr, ETH_ALEN) == 0)
1067                         break;
1068                 cli = cli->next;
1069         }
1070         if (!cli) {
1071                 wpa_printf(MSG_DEBUG, "%s: no matching client entry",
1072                            __func__);
1073                 return -1;
1074         }
1075
1076         for (bss = drv->bss; bss; bss = bss->next) {
1077                 if (strcmp(ifname, bss->ifname) == 0)
1078                         break;
1079         }
1080         if (bss == NULL) {
1081                 wpa_printf(MSG_DEBUG, "%s: No matching interface found from "
1082                            "configured BSSes", __func__);
1083                 return -1;
1084         }
1085
1086         cli->bss = bss;
1087
1088         return 0;
1089 }
1090
1091
1092 static void * test_driver_init(struct hostapd_data *hapd)
1093 {
1094         struct test_driver_data *drv;
1095         struct sockaddr_un addr_un;
1096         struct sockaddr_in addr_in;
1097         struct sockaddr *addr;
1098         socklen_t alen;
1099
1100         drv = os_zalloc(sizeof(struct test_driver_data));
1101         if (drv == NULL) {
1102                 printf("Could not allocate memory for test driver data\n");
1103                 return NULL;
1104         }
1105         drv->bss = os_zalloc(sizeof(*drv->bss));
1106         if (drv->bss == NULL) {
1107                 printf("Could not allocate memory for test driver BSS data\n");
1108                 free(drv);
1109                 return NULL;
1110         }
1111
1112         drv->hapd = hapd;
1113
1114         /* Generate a MAC address to help testing with multiple APs */
1115         hapd->own_addr[0] = 0x02; /* locally administered */
1116         sha1_prf((const u8 *) hapd->conf->iface, strlen(hapd->conf->iface),
1117                  "hostapd test bssid generation",
1118                  (const u8 *) hapd->conf->ssid.ssid, hapd->conf->ssid.ssid_len,
1119                  hapd->own_addr + 1, ETH_ALEN - 1);
1120
1121         os_strlcpy(drv->bss->ifname, hapd->conf->iface, IFNAMSIZ);
1122         memcpy(drv->bss->bssid, hapd->own_addr, ETH_ALEN);
1123
1124         if (hapd->conf->test_socket) {
1125                 if (strlen(hapd->conf->test_socket) >=
1126                     sizeof(addr_un.sun_path)) {
1127                         printf("Too long test_socket path\n");
1128                         test_driver_free_priv(drv);
1129                         return NULL;
1130                 }
1131                 if (strncmp(hapd->conf->test_socket, "DIR:", 4) == 0) {
1132                         size_t len = strlen(hapd->conf->test_socket) + 30;
1133                         drv->socket_dir = strdup(hapd->conf->test_socket + 4);
1134                         drv->own_socket_path = malloc(len);
1135                         if (drv->own_socket_path) {
1136                                 snprintf(drv->own_socket_path, len,
1137                                          "%s/AP-" MACSTR,
1138                                          hapd->conf->test_socket + 4,
1139                                          MAC2STR(hapd->own_addr));
1140                         }
1141                 } else if (strncmp(hapd->conf->test_socket, "UDP:", 4) == 0) {
1142                         drv->udp_port = atoi(hapd->conf->test_socket + 4);
1143                 } else {
1144                         drv->own_socket_path = strdup(hapd->conf->test_socket);
1145                 }
1146                 if (drv->own_socket_path == NULL && drv->udp_port == 0) {
1147                         test_driver_free_priv(drv);
1148                         return NULL;
1149                 }
1150
1151                 drv->test_socket = socket(drv->udp_port ? PF_INET : PF_UNIX,
1152                                           SOCK_DGRAM, 0);
1153                 if (drv->test_socket < 0) {
1154                         perror("socket");
1155                         test_driver_free_priv(drv);
1156                         return NULL;
1157                 }
1158
1159                 if (drv->udp_port) {
1160                         os_memset(&addr_in, 0, sizeof(addr_in));
1161                         addr_in.sin_family = AF_INET;
1162                         addr_in.sin_port = htons(drv->udp_port);
1163                         addr = (struct sockaddr *) &addr_in;
1164                         alen = sizeof(addr_in);
1165                 } else {
1166                         os_memset(&addr_un, 0, sizeof(addr_un));
1167                         addr_un.sun_family = AF_UNIX;
1168                         os_strlcpy(addr_un.sun_path, drv->own_socket_path,
1169                                    sizeof(addr_un.sun_path));
1170                         addr = (struct sockaddr *) &addr_un;
1171                         alen = sizeof(addr_un);
1172                 }
1173                 if (bind(drv->test_socket, addr, alen) < 0) {
1174                         perror("bind(PF_UNIX)");
1175                         close(drv->test_socket);
1176                         if (drv->own_socket_path)
1177                                 unlink(drv->own_socket_path);
1178                         test_driver_free_priv(drv);
1179                         return NULL;
1180                 }
1181                 eloop_register_read_sock(drv->test_socket,
1182                                          test_driver_receive_unix, drv, NULL);
1183         } else
1184                 drv->test_socket = -1;
1185
1186         return drv;
1187 }
1188
1189
1190 static void test_driver_deinit(void *priv)
1191 {
1192         struct test_driver_data *drv = priv;
1193         struct test_client_socket *cli, *prev;
1194
1195         cli = drv->cli;
1196         while (cli) {
1197                 prev = cli;
1198                 cli = cli->next;
1199                 free(prev);
1200         }
1201
1202         if (drv->test_socket >= 0) {
1203                 eloop_unregister_read_sock(drv->test_socket);
1204                 close(drv->test_socket);
1205                 if (drv->own_socket_path)
1206                         unlink(drv->own_socket_path);
1207         }
1208
1209         /* There should be only one BSS remaining at this point. */
1210         if (drv->bss == NULL)
1211                 wpa_printf(MSG_ERROR, "%s: drv->bss == NULL", __func__);
1212         else if (drv->bss->next)
1213                 wpa_printf(MSG_ERROR, "%s: drv->bss->next != NULL", __func__);
1214
1215         test_driver_free_priv(drv);
1216 }
1217
1218
1219 const struct wpa_driver_ops wpa_driver_test_ops = {
1220         .name = "test",
1221         .hapd_init = test_driver_init,
1222         .hapd_deinit = test_driver_deinit,
1223         .hapd_send_eapol = test_driver_send_eapol,
1224         .send_mgmt_frame = test_driver_send_mgmt_frame,
1225         .set_generic_elem = test_driver_set_generic_elem,
1226         .sta_deauth = test_driver_sta_deauth,
1227         .sta_disassoc = test_driver_sta_disassoc,
1228         .get_hw_feature_data = test_driver_get_hw_feature_data,
1229         .bss_add = test_driver_bss_add,
1230         .bss_remove = test_driver_bss_remove,
1231         .if_add = test_driver_if_add,
1232         .if_update = test_driver_if_update,
1233         .if_remove = test_driver_if_remove,
1234         .valid_bss_mask = test_driver_valid_bss_mask,
1235         .hapd_set_ssid = test_driver_set_ssid,
1236         .set_privacy = test_driver_set_privacy,
1237         .hapd_set_key = test_driver_set_key,
1238         .set_sta_vlan = test_driver_set_sta_vlan,
1239         .sta_add = test_driver_sta_add,
1240         .send_ether = test_driver_send_ether,
1241         .set_wps_beacon_ie = test_driver_set_wps_beacon_ie,
1242         .set_wps_probe_resp_ie = test_driver_set_wps_probe_resp_ie,
1243 };
1244
1245 #else /* HOSTAPD */
1246
1247 struct wpa_driver_test_global {
1248         int dummy;
1249 };
1250
1251 struct wpa_driver_test_data {
1252         struct wpa_driver_test_global *global;
1253         void *ctx;
1254         u8 own_addr[ETH_ALEN];
1255         int test_socket;
1256 #ifdef DRIVER_TEST_UNIX
1257         struct sockaddr_un hostapd_addr;
1258 #endif /* DRIVER_TEST_UNIX */
1259         int hostapd_addr_set;
1260         struct sockaddr_in hostapd_addr_udp;
1261         int hostapd_addr_udp_set;
1262         char *own_socket_path;
1263         char *test_dir;
1264         u8 bssid[ETH_ALEN];
1265         u8 ssid[32];
1266         size_t ssid_len;
1267 #define MAX_SCAN_RESULTS 30
1268         struct wpa_scan_res *scanres[MAX_SCAN_RESULTS];
1269         size_t num_scanres;
1270         int use_associnfo;
1271         u8 assoc_wpa_ie[80];
1272         size_t assoc_wpa_ie_len;
1273         int use_mlme;
1274         int associated;
1275         u8 *probe_req_ie;
1276         size_t probe_req_ie_len;
1277         int ibss;
1278         int privacy;
1279 };
1280
1281
1282 static void wpa_driver_test_poll(void *eloop_ctx, void *timeout_ctx)
1283 {
1284         struct wpa_driver_test_data *drv = eloop_ctx;
1285
1286 #ifdef DRIVER_TEST_UNIX
1287         if (drv->associated && drv->hostapd_addr_set) {
1288                 struct stat st;
1289                 if (stat(drv->hostapd_addr.sun_path, &st) < 0) {
1290                         wpa_printf(MSG_DEBUG, "%s: lost connection to AP: %s",
1291                                    __func__, strerror(errno));
1292                         drv->associated = 0;
1293                         wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL);
1294                 }
1295         }
1296 #endif /* DRIVER_TEST_UNIX */
1297
1298         eloop_register_timeout(1, 0, wpa_driver_test_poll, drv, NULL);
1299 }
1300
1301
1302 static int wpa_driver_test_set_wpa(void *priv, int enabled)
1303 {
1304         wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled);
1305         return 0;
1306 }
1307
1308
1309 static void wpa_driver_test_scan_timeout(void *eloop_ctx, void *timeout_ctx)
1310 {
1311         wpa_printf(MSG_DEBUG, "Scan timeout - try to get results");
1312         wpa_supplicant_event(timeout_ctx, EVENT_SCAN_RESULTS, NULL);
1313 }
1314
1315
1316 #ifdef DRIVER_TEST_UNIX
1317 static void wpa_driver_scan_dir(struct wpa_driver_test_data *drv,
1318                                 const char *path)
1319 {
1320         struct dirent *dent;
1321         DIR *dir;
1322         struct sockaddr_un addr;
1323         char cmd[512], *pos, *end;
1324         int ret;
1325
1326         dir = opendir(path);
1327         if (dir == NULL)
1328                 return;
1329
1330         end = cmd + sizeof(cmd);
1331         pos = cmd;
1332         ret = os_snprintf(pos, end - pos, "SCAN " MACSTR,
1333                           MAC2STR(drv->own_addr));
1334         if (ret >= 0 && ret < end - pos)
1335                 pos += ret;
1336         if (drv->probe_req_ie) {
1337                 ret = os_snprintf(pos, end - pos, " ");
1338                 if (ret >= 0 && ret < end - pos)
1339                         pos += ret;
1340                 pos += wpa_snprintf_hex(pos, end - pos, drv->probe_req_ie,
1341                                         drv->probe_req_ie_len);
1342         }
1343         end[-1] = '\0';
1344
1345         while ((dent = readdir(dir))) {
1346                 if (os_strncmp(dent->d_name, "AP-", 3) != 0 &&
1347                     os_strncmp(dent->d_name, "STA-", 4) != 0)
1348                         continue;
1349                 if (drv->own_socket_path) {
1350                         size_t olen, dlen;
1351                         olen = os_strlen(drv->own_socket_path);
1352                         dlen = os_strlen(dent->d_name);
1353                         if (olen >= dlen &&
1354                             os_strcmp(dent->d_name,
1355                                       drv->own_socket_path + olen - dlen) == 0)
1356                                 continue;
1357                 }
1358                 wpa_printf(MSG_DEBUG, "%s: SCAN %s", __func__, dent->d_name);
1359
1360                 os_memset(&addr, 0, sizeof(addr));
1361                 addr.sun_family = AF_UNIX;
1362                 os_snprintf(addr.sun_path, sizeof(addr.sun_path), "%s/%s",
1363                             path, dent->d_name);
1364
1365                 if (sendto(drv->test_socket, cmd, os_strlen(cmd), 0,
1366                            (struct sockaddr *) &addr, sizeof(addr)) < 0) {
1367                         perror("sendto(test_socket)");
1368                 }
1369         }
1370         closedir(dir);
1371 }
1372 #endif /* DRIVER_TEST_UNIX */
1373
1374
1375 static int wpa_driver_test_scan(void *priv,
1376                                 struct wpa_driver_scan_params *params)
1377 {
1378         struct wpa_driver_test_data *drv = priv;
1379         size_t i;
1380
1381         wpa_printf(MSG_DEBUG, "%s: priv=%p", __func__, priv);
1382         for (i = 0; i < params->num_ssids; i++)
1383                 wpa_hexdump(MSG_DEBUG, "Scan SSID",
1384                             params->ssids[i].ssid, params->ssids[i].ssid_len);
1385         wpa_hexdump(MSG_DEBUG, "Scan extra IE(s)",
1386                     params->extra_ies, params->extra_ies_len);
1387
1388         drv->num_scanres = 0;
1389
1390 #ifdef DRIVER_TEST_UNIX
1391         if (drv->test_socket >= 0 && drv->test_dir)
1392                 wpa_driver_scan_dir(drv, drv->test_dir);
1393
1394         if (drv->test_socket >= 0 && drv->hostapd_addr_set &&
1395             sendto(drv->test_socket, "SCAN", 4, 0,
1396                    (struct sockaddr *) &drv->hostapd_addr,
1397                    sizeof(drv->hostapd_addr)) < 0) {
1398                 perror("sendto(test_socket)");
1399         }
1400 #endif /* DRIVER_TEST_UNIX */
1401
1402         if (drv->test_socket >= 0 && drv->hostapd_addr_udp_set &&
1403             sendto(drv->test_socket, "SCAN", 4, 0,
1404                    (struct sockaddr *) &drv->hostapd_addr_udp,
1405                    sizeof(drv->hostapd_addr_udp)) < 0) {
1406                 perror("sendto(test_socket)");
1407         }
1408
1409         eloop_cancel_timeout(wpa_driver_test_scan_timeout, drv, drv->ctx);
1410         eloop_register_timeout(1, 0, wpa_driver_test_scan_timeout, drv,
1411                                drv->ctx);
1412         return 0;
1413 }
1414
1415
1416 static struct wpa_scan_results * wpa_driver_test_get_scan_results2(void *priv)
1417 {
1418         struct wpa_driver_test_data *drv = priv;
1419         struct wpa_scan_results *res;
1420         size_t i;
1421
1422         res = os_zalloc(sizeof(*res));
1423         if (res == NULL)
1424                 return NULL;
1425
1426         res->res = os_zalloc(drv->num_scanres * sizeof(struct wpa_scan_res *));
1427         if (res->res == NULL) {
1428                 os_free(res);
1429                 return NULL;
1430         }
1431
1432         for (i = 0; i < drv->num_scanres; i++) {
1433                 struct wpa_scan_res *r;
1434                 if (drv->scanres[i] == NULL)
1435                         continue;
1436                 r = os_malloc(sizeof(*r) + drv->scanres[i]->ie_len);
1437                 if (r == NULL)
1438                         break;
1439                 os_memcpy(r, drv->scanres[i],
1440                           sizeof(*r) + drv->scanres[i]->ie_len);
1441                 res->res[res->num++] = r;
1442         }
1443
1444         return res;
1445 }
1446
1447
1448 static int wpa_driver_test_set_key(void *priv, wpa_alg alg, const u8 *addr,
1449                                    int key_idx, int set_tx,
1450                                    const u8 *seq, size_t seq_len,
1451                                    const u8 *key, size_t key_len)
1452 {
1453         wpa_printf(MSG_DEBUG, "%s: priv=%p alg=%d key_idx=%d set_tx=%d",
1454                    __func__, priv, alg, key_idx, set_tx);
1455         if (addr) {
1456                 wpa_printf(MSG_DEBUG, "   addr=" MACSTR, MAC2STR(addr));
1457         }
1458         if (seq) {
1459                 wpa_hexdump(MSG_DEBUG, "   seq", seq, seq_len);
1460         }
1461         if (key) {
1462                 wpa_hexdump(MSG_DEBUG, "   key", key, key_len);
1463         }
1464         return 0;
1465 }
1466
1467
1468 static int wpa_driver_test_associate(
1469         void *priv, struct wpa_driver_associate_params *params)
1470 {
1471         struct wpa_driver_test_data *drv = priv;
1472         wpa_printf(MSG_DEBUG, "%s: priv=%p freq=%d pairwise_suite=%d "
1473                    "group_suite=%d key_mgmt_suite=%d auth_alg=%d mode=%d",
1474                    __func__, priv, params->freq, params->pairwise_suite,
1475                    params->group_suite, params->key_mgmt_suite,
1476                    params->auth_alg, params->mode);
1477         if (params->bssid) {
1478                 wpa_printf(MSG_DEBUG, "   bssid=" MACSTR,
1479                            MAC2STR(params->bssid));
1480         }
1481         if (params->ssid) {
1482                 wpa_hexdump_ascii(MSG_DEBUG, "   ssid",
1483                                   params->ssid, params->ssid_len);
1484         }
1485         if (params->wpa_ie) {
1486                 wpa_hexdump(MSG_DEBUG, "   wpa_ie",
1487                             params->wpa_ie, params->wpa_ie_len);
1488                 drv->assoc_wpa_ie_len = params->wpa_ie_len;
1489                 if (drv->assoc_wpa_ie_len > sizeof(drv->assoc_wpa_ie))
1490                         drv->assoc_wpa_ie_len = sizeof(drv->assoc_wpa_ie);
1491                 os_memcpy(drv->assoc_wpa_ie, params->wpa_ie,
1492                           drv->assoc_wpa_ie_len);
1493         } else
1494                 drv->assoc_wpa_ie_len = 0;
1495
1496         drv->ibss = params->mode == IEEE80211_MODE_IBSS;
1497         drv->privacy = params->key_mgmt_suite &
1498                 (WPA_KEY_MGMT_IEEE8021X |
1499                  WPA_KEY_MGMT_PSK |
1500                  WPA_KEY_MGMT_WPA_NONE |
1501                  WPA_KEY_MGMT_FT_IEEE8021X |
1502                  WPA_KEY_MGMT_FT_PSK |
1503                  WPA_KEY_MGMT_IEEE8021X_SHA256 |
1504                  WPA_KEY_MGMT_PSK_SHA256);
1505         if (params->wep_key_len[params->wep_tx_keyidx])
1506                 drv->privacy = 1;
1507
1508 #ifdef DRIVER_TEST_UNIX
1509         if (drv->test_dir && params->bssid &&
1510             params->mode != IEEE80211_MODE_IBSS) {
1511                 os_memset(&drv->hostapd_addr, 0, sizeof(drv->hostapd_addr));
1512                 drv->hostapd_addr.sun_family = AF_UNIX;
1513                 os_snprintf(drv->hostapd_addr.sun_path,
1514                             sizeof(drv->hostapd_addr.sun_path),
1515                             "%s/AP-" MACSTR,
1516                             drv->test_dir, MAC2STR(params->bssid));
1517                 drv->hostapd_addr_set = 1;
1518         }
1519 #endif /* DRIVER_TEST_UNIX */
1520
1521         if (drv->test_socket >= 0 &&
1522             (drv->hostapd_addr_set || drv->hostapd_addr_udp_set)) {
1523                 char cmd[200], *pos, *end;
1524                 int ret;
1525                 end = cmd + sizeof(cmd);
1526                 pos = cmd;
1527                 ret = os_snprintf(pos, end - pos, "ASSOC " MACSTR " ",
1528                                   MAC2STR(drv->own_addr));
1529                 if (ret >= 0 && ret < end - pos)
1530                         pos += ret;
1531                 pos += wpa_snprintf_hex(pos, end - pos, params->ssid,
1532                                         params->ssid_len);
1533                 ret = os_snprintf(pos, end - pos, " ");
1534                 if (ret >= 0 && ret < end - pos)
1535                         pos += ret;
1536                 pos += wpa_snprintf_hex(pos, end - pos, params->wpa_ie,
1537                                         params->wpa_ie_len);
1538                 end[-1] = '\0';
1539 #ifdef DRIVER_TEST_UNIX
1540                 if (drv->hostapd_addr_set &&
1541                     sendto(drv->test_socket, cmd, os_strlen(cmd), 0,
1542                            (struct sockaddr *) &drv->hostapd_addr,
1543                            sizeof(drv->hostapd_addr)) < 0) {
1544                         perror("sendto(test_socket)");
1545                         return -1;
1546                 }
1547 #endif /* DRIVER_TEST_UNIX */
1548                 if (drv->hostapd_addr_udp_set &&
1549                     sendto(drv->test_socket, cmd, os_strlen(cmd), 0,
1550                            (struct sockaddr *) &drv->hostapd_addr_udp,
1551                            sizeof(drv->hostapd_addr_udp)) < 0) {
1552                         perror("sendto(test_socket)");
1553                         return -1;
1554                 }
1555
1556                 os_memcpy(drv->ssid, params->ssid, params->ssid_len);
1557                 drv->ssid_len = params->ssid_len;
1558         } else {
1559                 drv->associated = 1;
1560                 if (params->mode == IEEE80211_MODE_IBSS) {
1561                         os_memcpy(drv->ssid, params->ssid, params->ssid_len);
1562                         drv->ssid_len = params->ssid_len;
1563                         if (params->bssid)
1564                                 os_memcpy(drv->bssid, params->bssid, ETH_ALEN);
1565                         else {
1566                                 os_get_random(drv->bssid, ETH_ALEN);
1567                                 drv->bssid[0] &= ~0x01;
1568                                 drv->bssid[0] |= 0x02;
1569                         }
1570                 }
1571                 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, NULL);
1572         }
1573
1574         return 0;
1575 }
1576
1577
1578 static int wpa_driver_test_get_bssid(void *priv, u8 *bssid)
1579 {
1580         struct wpa_driver_test_data *drv = priv;
1581         os_memcpy(bssid, drv->bssid, ETH_ALEN);
1582         return 0;
1583 }
1584
1585
1586 static int wpa_driver_test_get_ssid(void *priv, u8 *ssid)
1587 {
1588         struct wpa_driver_test_data *drv = priv;
1589         os_memcpy(ssid, drv->ssid, 32);
1590         return drv->ssid_len;
1591 }
1592
1593
1594 static int wpa_driver_test_send_disassoc(struct wpa_driver_test_data *drv)
1595 {
1596 #ifdef DRIVER_TEST_UNIX
1597         if (drv->test_socket >= 0 &&
1598             sendto(drv->test_socket, "DISASSOC", 8, 0,
1599                    (struct sockaddr *) &drv->hostapd_addr,
1600                    sizeof(drv->hostapd_addr)) < 0) {
1601                 perror("sendto(test_socket)");
1602                 return -1;
1603         }
1604 #endif /* DRIVER_TEST_UNIX */
1605         if (drv->test_socket >= 0 && drv->hostapd_addr_udp_set &&
1606             sendto(drv->test_socket, "DISASSOC", 8, 0,
1607                    (struct sockaddr *) &drv->hostapd_addr_udp,
1608                    sizeof(drv->hostapd_addr_udp)) < 0) {
1609                 perror("sendto(test_socket)");
1610                 return -1;
1611         }
1612         return 0;
1613 }
1614
1615
1616 static int wpa_driver_test_deauthenticate(void *priv, const u8 *addr,
1617                                           int reason_code)
1618 {
1619         struct wpa_driver_test_data *drv = priv;
1620         wpa_printf(MSG_DEBUG, "%s addr=" MACSTR " reason_code=%d",
1621                    __func__, MAC2STR(addr), reason_code);
1622         os_memset(drv->bssid, 0, ETH_ALEN);
1623         drv->associated = 0;
1624         wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL);
1625         return wpa_driver_test_send_disassoc(drv);
1626 }
1627
1628
1629 static int wpa_driver_test_disassociate(void *priv, const u8 *addr,
1630                                         int reason_code)
1631 {
1632         struct wpa_driver_test_data *drv = priv;
1633         wpa_printf(MSG_DEBUG, "%s addr=" MACSTR " reason_code=%d",
1634                    __func__, MAC2STR(addr), reason_code);
1635         os_memset(drv->bssid, 0, ETH_ALEN);
1636         drv->associated = 0;
1637         wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL);
1638         return wpa_driver_test_send_disassoc(drv);
1639 }
1640
1641
1642 static void wpa_driver_test_scanresp(struct wpa_driver_test_data *drv,
1643                                      struct sockaddr *from,
1644                                      socklen_t fromlen,
1645                                      const char *data)
1646 {
1647         struct wpa_scan_res *res;
1648         const char *pos, *pos2;
1649         size_t len;
1650         u8 *ie_pos, *ie_start, *ie_end;
1651 #define MAX_IE_LEN 1000
1652
1653         wpa_printf(MSG_DEBUG, "test_driver: SCANRESP %s", data);
1654         if (drv->num_scanres >= MAX_SCAN_RESULTS) {
1655                 wpa_printf(MSG_DEBUG, "test_driver: No room for the new scan "
1656                            "result");
1657                 return;
1658         }
1659
1660         /* SCANRESP BSSID SSID IEs */
1661
1662         res = os_zalloc(sizeof(*res) + MAX_IE_LEN);
1663         if (res == NULL)
1664                 return;
1665         ie_start = ie_pos = (u8 *) (res + 1);
1666         ie_end = ie_pos + MAX_IE_LEN;
1667
1668         if (hwaddr_aton(data, res->bssid)) {
1669                 wpa_printf(MSG_DEBUG, "test_driver: invalid BSSID in scanres");
1670                 os_free(res);
1671                 return;
1672         }
1673
1674         pos = data + 17;
1675         while (*pos == ' ')
1676                 pos++;
1677         pos2 = os_strchr(pos, ' ');
1678         if (pos2 == NULL) {
1679                 wpa_printf(MSG_DEBUG, "test_driver: invalid SSID termination "
1680                            "in scanres");
1681                 os_free(res);
1682                 return;
1683         }
1684         len = (pos2 - pos) / 2;
1685         if (len > 32)
1686                 len = 32;
1687         /*
1688          * Generate SSID IE from the SSID field since this IE is not included
1689          * in the main IE field.
1690          */
1691         *ie_pos++ = WLAN_EID_SSID;
1692         *ie_pos++ = len;
1693         if (hexstr2bin(pos, ie_pos, len) < 0) {
1694                 wpa_printf(MSG_DEBUG, "test_driver: invalid SSID in scanres");
1695                 os_free(res);
1696                 return;
1697         }
1698         ie_pos += len;
1699
1700         pos = pos2 + 1;
1701         pos2 = os_strchr(pos, ' ');
1702         if (pos2 == NULL)
1703                 len = os_strlen(pos) / 2;
1704         else
1705                 len = (pos2 - pos) / 2;
1706         if ((int) len > ie_end - ie_pos)
1707                 len = ie_end - ie_pos;
1708         if (hexstr2bin(pos, ie_pos, len) < 0) {
1709                 wpa_printf(MSG_DEBUG, "test_driver: invalid IEs in scanres");
1710                 os_free(res);
1711                 return;
1712         }
1713         ie_pos += len;
1714         res->ie_len = ie_pos - ie_start;
1715
1716         if (pos2) {
1717                 pos = pos2 + 1;
1718                 while (*pos == ' ')
1719                         pos++;
1720                 if (os_strstr(pos, "PRIVACY"))
1721                         res->caps |= IEEE80211_CAP_PRIVACY;
1722                 if (os_strstr(pos, "IBSS"))
1723                         res->caps |= IEEE80211_CAP_IBSS;
1724         }
1725
1726         os_free(drv->scanres[drv->num_scanres]);
1727         drv->scanres[drv->num_scanres++] = res;
1728 }
1729
1730
1731 static void wpa_driver_test_assocresp(struct wpa_driver_test_data *drv,
1732                                       struct sockaddr *from,
1733                                       socklen_t fromlen,
1734                                       const char *data)
1735 {
1736         /* ASSOCRESP BSSID <res> */
1737         if (hwaddr_aton(data, drv->bssid)) {
1738                 wpa_printf(MSG_DEBUG, "test_driver: invalid BSSID in "
1739                            "assocresp");
1740         }
1741         if (drv->use_associnfo) {
1742                 union wpa_event_data event;
1743                 os_memset(&event, 0, sizeof(event));
1744                 event.assoc_info.req_ies = drv->assoc_wpa_ie;
1745                 event.assoc_info.req_ies_len = drv->assoc_wpa_ie_len;
1746                 wpa_supplicant_event(drv->ctx, EVENT_ASSOCINFO, &event);
1747         }
1748         drv->associated = 1;
1749         wpa_supplicant_event(drv->ctx, EVENT_ASSOC, NULL);
1750 }
1751
1752
1753 static void wpa_driver_test_disassoc(struct wpa_driver_test_data *drv,
1754                                      struct sockaddr *from,
1755                                      socklen_t fromlen)
1756 {
1757         drv->associated = 0;
1758         wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL);
1759 }
1760
1761
1762 static void wpa_driver_test_eapol(struct wpa_driver_test_data *drv,
1763                                   struct sockaddr *from,
1764                                   socklen_t fromlen,
1765                                   const u8 *data, size_t data_len)
1766 {
1767         const u8 *src = drv->bssid;
1768
1769         if (data_len > 14) {
1770                 /* Skip Ethernet header */
1771                 src = data + ETH_ALEN;
1772                 data += 14;
1773                 data_len -= 14;
1774         }
1775         wpa_supplicant_rx_eapol(drv->ctx, src, data, data_len);
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->max_scan_ssids = 2;
2237
2238         return 0;
2239 }
2240
2241
2242 static int wpa_driver_test_mlme_setprotection(void *priv, const u8 *addr,
2243                                               int protect_type,
2244                                               int key_type)
2245 {
2246         wpa_printf(MSG_DEBUG, "%s: protect_type=%d key_type=%d",
2247                    __func__, protect_type, key_type);
2248
2249         if (addr) {
2250                 wpa_printf(MSG_DEBUG, "%s: addr=" MACSTR,
2251                            __func__, MAC2STR(addr));
2252         }
2253
2254         return 0;
2255 }
2256
2257
2258 #ifdef CONFIG_CLIENT_MLME
2259 static struct hostapd_hw_modes *
2260 wpa_driver_test_get_hw_feature_data(void *priv, u16 *num_modes, u16 *flags)
2261 {
2262         struct hostapd_hw_modes *modes;
2263
2264         *num_modes = 1;
2265         *flags = 0;
2266         modes = os_zalloc(*num_modes * sizeof(struct hostapd_hw_modes));
2267         if (modes == NULL)
2268                 return NULL;
2269         modes[0].mode = HOSTAPD_MODE_IEEE80211G;
2270         modes[0].num_channels = 1;
2271         modes[0].num_rates = 1;
2272         modes[0].channels = os_zalloc(sizeof(struct hostapd_channel_data));
2273         modes[0].rates = os_zalloc(sizeof(struct hostapd_rate_data));
2274         if (modes[0].channels == NULL || modes[0].rates == NULL) {
2275                 wpa_supplicant_sta_free_hw_features(modes, *num_modes);
2276                 return NULL;
2277         }
2278         modes[0].channels[0].chan = 1;
2279         modes[0].channels[0].freq = 2412;
2280         modes[0].channels[0].flag = 0;
2281         modes[0].rates[0].rate = 10;
2282         modes[0].rates[0].flags = HOSTAPD_RATE_BASIC | HOSTAPD_RATE_SUPPORTED |
2283                 HOSTAPD_RATE_CCK | HOSTAPD_RATE_MANDATORY;
2284
2285         return modes;
2286 }
2287
2288
2289 static int wpa_driver_test_set_channel(void *priv, hostapd_hw_mode phymode,
2290                                        int chan, int freq)
2291 {
2292         wpa_printf(MSG_DEBUG, "%s: phymode=%d chan=%d freq=%d",
2293                    __func__, phymode, chan, freq);
2294         return 0;
2295 }
2296
2297
2298 static int wpa_driver_test_send_mlme(void *priv, const u8 *data,
2299                                      size_t data_len)
2300 {
2301         struct wpa_driver_test_data *drv = priv;
2302         struct msghdr msg;
2303         struct iovec io[2];
2304         struct sockaddr_un addr;
2305         const u8 *dest;
2306         struct dirent *dent;
2307         DIR *dir;
2308
2309         wpa_hexdump(MSG_MSGDUMP, "test_send_mlme", data, data_len);
2310         if (data_len < 10)
2311                 return -1;
2312         dest = data + 4;
2313
2314         io[0].iov_base = "MLME ";
2315         io[0].iov_len = 5;
2316         io[1].iov_base = (u8 *) data;
2317         io[1].iov_len = data_len;
2318
2319         os_memset(&msg, 0, sizeof(msg));
2320         msg.msg_iov = io;
2321         msg.msg_iovlen = 2;
2322         if (os_memcmp(dest, drv->bssid, ETH_ALEN) == 0 ||
2323             drv->test_dir == NULL) {
2324                 if (drv->hostapd_addr_udp_set) {
2325                         msg.msg_name = &drv->hostapd_addr_udp;
2326                         msg.msg_namelen = sizeof(drv->hostapd_addr_udp);
2327                 } else {
2328 #ifdef DRIVER_TEST_UNIX
2329                         msg.msg_name = &drv->hostapd_addr;
2330                         msg.msg_namelen = sizeof(drv->hostapd_addr);
2331 #endif /* DRIVER_TEST_UNIX */
2332                 }
2333         } else if (os_memcmp(dest, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) == 0)
2334         {
2335                 dir = opendir(drv->test_dir);
2336                 if (dir == NULL)
2337                         return -1;
2338                 while ((dent = readdir(dir))) {
2339 #ifdef _DIRENT_HAVE_D_TYPE
2340                         /* Skip the file if it is not a socket.
2341                          * Also accept DT_UNKNOWN (0) in case
2342                          * the C library or underlying file
2343                          * system does not support d_type. */
2344                         if (dent->d_type != DT_SOCK &&
2345                             dent->d_type != DT_UNKNOWN)
2346                                 continue;
2347 #endif /* _DIRENT_HAVE_D_TYPE */
2348                         if (os_strcmp(dent->d_name, ".") == 0 ||
2349                             os_strcmp(dent->d_name, "..") == 0)
2350                                 continue;
2351                         wpa_printf(MSG_DEBUG, "%s: Send broadcast MLME to %s",
2352                                    __func__, dent->d_name);
2353                         os_memset(&addr, 0, sizeof(addr));
2354                         addr.sun_family = AF_UNIX;
2355                         os_snprintf(addr.sun_path, sizeof(addr.sun_path),
2356                                     "%s/%s", drv->test_dir, dent->d_name);
2357
2358                         msg.msg_name = &addr;
2359                         msg.msg_namelen = sizeof(addr);
2360
2361                         if (sendmsg(drv->test_socket, &msg, 0) < 0)
2362                                 perror("sendmsg(test_socket)");
2363                 }
2364                 closedir(dir);
2365                 return 0;
2366         } else {
2367                 struct stat st;
2368                 os_memset(&addr, 0, sizeof(addr));
2369                 addr.sun_family = AF_UNIX;
2370                 os_snprintf(addr.sun_path, sizeof(addr.sun_path),
2371                             "%s/AP-" MACSTR, drv->test_dir, MAC2STR(dest));
2372                 if (stat(addr.sun_path, &st) < 0) {
2373                         os_snprintf(addr.sun_path, sizeof(addr.sun_path),
2374                                     "%s/STA-" MACSTR,
2375                                     drv->test_dir, MAC2STR(dest));
2376                 }
2377                 msg.msg_name = &addr;
2378                 msg.msg_namelen = sizeof(addr);
2379         }
2380
2381         if (sendmsg(drv->test_socket, &msg, 0) < 0) {
2382                 perror("sendmsg(test_socket)");
2383                 return -1;
2384         }
2385
2386         return 0;
2387 }
2388
2389
2390 static int wpa_driver_test_mlme_add_sta(void *priv, const u8 *addr,
2391                                         const u8 *supp_rates,
2392                                         size_t supp_rates_len)
2393 {
2394         wpa_printf(MSG_DEBUG, "%s: addr=" MACSTR, __func__, MAC2STR(addr));
2395         return 0;
2396 }
2397
2398
2399 static int wpa_driver_test_mlme_remove_sta(void *priv, const u8 *addr)
2400 {
2401         wpa_printf(MSG_DEBUG, "%s: addr=" MACSTR, __func__, MAC2STR(addr));
2402         return 0;
2403 }
2404
2405
2406 static int wpa_driver_test_set_ssid(void *priv, const u8 *ssid,
2407                                     size_t ssid_len)
2408 {
2409         wpa_printf(MSG_DEBUG, "%s", __func__);
2410         return 0;
2411 }
2412
2413
2414 static int wpa_driver_test_set_bssid(void *priv, const u8 *bssid)
2415 {
2416         wpa_printf(MSG_DEBUG, "%s: bssid=" MACSTR, __func__, MAC2STR(bssid));
2417         return 0;
2418 }
2419 #endif /* CONFIG_CLIENT_MLME */
2420
2421
2422 static int wpa_driver_test_set_probe_req_ie(void *priv, const u8 *ies,
2423                                             size_t ies_len)
2424 {
2425         struct wpa_driver_test_data *drv = priv;
2426
2427         os_free(drv->probe_req_ie);
2428         if (ies) {
2429                 drv->probe_req_ie = os_malloc(ies_len);
2430                 if (drv->probe_req_ie == NULL) {
2431                         drv->probe_req_ie_len = 0;
2432                         return -1;
2433                 }
2434                 os_memcpy(drv->probe_req_ie, ies, ies_len);
2435                 drv->probe_req_ie_len = ies_len;
2436         } else {
2437                 drv->probe_req_ie = NULL;
2438                 drv->probe_req_ie_len = 0;
2439         }
2440         return 0;
2441 }
2442
2443
2444 static void * wpa_driver_test_global_init(void)
2445 {
2446         struct wpa_driver_test_global *global;
2447
2448         global = os_zalloc(sizeof(*global));
2449         return global;
2450 }
2451
2452
2453 static void wpa_driver_test_global_deinit(void *priv)
2454 {
2455         struct wpa_driver_test_global *global = priv;
2456         os_free(global);
2457 }
2458
2459
2460 static struct wpa_interface_info *
2461 wpa_driver_test_get_interfaces(void *global_priv)
2462 {
2463         /* struct wpa_driver_test_global *global = priv; */
2464         struct wpa_interface_info *iface;
2465
2466         iface = os_zalloc(sizeof(*iface));
2467         if (iface == NULL)
2468                 return iface;
2469         iface->ifname = os_strdup("sta0");
2470         iface->desc = os_strdup("test interface 0");
2471         iface->drv_name = "test";
2472         iface->next = os_zalloc(sizeof(*iface));
2473         if (iface->next) {
2474                 iface->next->ifname = os_strdup("sta1");
2475                 iface->next->desc = os_strdup("test interface 1");
2476                 iface->next->drv_name = "test";
2477         }
2478
2479         return iface;
2480 }
2481
2482
2483 const struct wpa_driver_ops wpa_driver_test_ops = {
2484         "test",
2485         "wpa_supplicant test driver",
2486         wpa_driver_test_get_bssid,
2487         wpa_driver_test_get_ssid,
2488         wpa_driver_test_set_wpa,
2489         wpa_driver_test_set_key,
2490         NULL /* init */,
2491         wpa_driver_test_deinit,
2492         wpa_driver_test_set_param,
2493         NULL /* set_countermeasures */,
2494         NULL /* set_drop_unencrypted */,
2495         NULL /* scan */,
2496         NULL /* get_scan_results */,
2497         wpa_driver_test_deauthenticate,
2498         wpa_driver_test_disassociate,
2499         wpa_driver_test_associate,
2500         NULL /* set_auth_alg */,
2501         NULL /* add_pmkid */,
2502         NULL /* remove_pmkid */,
2503         NULL /* flush_pmkid */,
2504         wpa_driver_test_get_capa,
2505         NULL /* poll */,
2506         NULL /* get_ifname */,
2507         wpa_driver_test_get_mac_addr,
2508         wpa_driver_test_send_eapol,
2509         NULL /* set_operstate */,
2510         wpa_driver_test_mlme_setprotection,
2511 #ifdef CONFIG_CLIENT_MLME
2512         wpa_driver_test_get_hw_feature_data,
2513         wpa_driver_test_set_channel,
2514         wpa_driver_test_set_ssid,
2515         wpa_driver_test_set_bssid,
2516         wpa_driver_test_send_mlme,
2517         wpa_driver_test_mlme_add_sta,
2518         wpa_driver_test_mlme_remove_sta,
2519 #else /* CONFIG_CLIENT_MLME */
2520         NULL /* get_hw_feature_data */,
2521         NULL /* set_channel */,
2522         NULL /* set_ssid */,
2523         NULL /* set_bssid */,
2524         NULL /* send_mlme */,
2525         NULL /* mlme_add_sta */,
2526         NULL /* mlme_remove_sta */,
2527 #endif /* CONFIG_CLIENT_MLME */
2528         NULL /* update_ft_ies */,
2529         NULL /* send_ft_action */,
2530         wpa_driver_test_get_scan_results2,
2531         wpa_driver_test_set_probe_req_ie,
2532         NULL /* set_mode */,
2533         NULL /* set_country */,
2534         wpa_driver_test_global_init,
2535         wpa_driver_test_global_deinit,
2536         wpa_driver_test_init2,
2537         wpa_driver_test_get_interfaces,
2538         wpa_driver_test_scan,
2539         NULL /* authenticate */,
2540         NULL /* set_beacon */,
2541         NULL /* set_beacon_int */,
2542         NULL /* hapd_init */,
2543         NULL /* init_bssid */,
2544         NULL /* hapd_deinit */,
2545         NULL /* set_ieee8021x */,
2546         NULL /* set_privacy */,
2547         NULL /* hapd_set_key */,
2548         NULL /* get_seqnum */,
2549         NULL /* get_seqnum_igtk */,
2550         NULL /* flush */,
2551         NULL /* set_generic_elem */,
2552         NULL /* read_sta_data */,
2553         NULL /* hapd_send_eapol */,
2554         NULL /* sta_deauth */,
2555         NULL /* sta_disassoc */,
2556         NULL /* sta_remove */,
2557         NULL /* hapd_get_ssid */,
2558         NULL /* hapd_set_ssid */,
2559         NULL /* hapd_set_countermeasures */,
2560         NULL /* send_mgmt_frame */,
2561         NULL /* sta_add */,
2562         NULL /* get_inact_sec */,
2563         NULL /* sta_clear_stats */,
2564         NULL /* set_freq */,
2565         NULL /* set_rts */,
2566         NULL /* set_frag */,
2567         NULL /* set_retry */,
2568         NULL /* sta_set_flags */,
2569         NULL /* set_rate_sets */,
2570         NULL /* hapd_set_country */,
2571         NULL /* set_ieee80211d */,
2572         NULL /* hapd_set_beacon */,
2573         NULL /* set_internal_bridge */,
2574         NULL /* hapd_set_beacon_int */,
2575         NULL /* set_broadcast_ssid */,
2576         NULL /* set_cts_protect */,
2577         NULL /* set_preamble */,
2578         NULL /* set_short_slot_time */,
2579         NULL /* set_tx_queue_params */,
2580         NULL /* bss_add */,
2581         NULL /* bss_remove */,
2582         NULL /* valid_bss_mask */,
2583         NULL /* passive_scan */,
2584         NULL /* hapd_get_hw_feature_data */,
2585         NULL /* if_add */,
2586         NULL /* if_update */,
2587         NULL /* if_remove */,
2588         NULL /* set_sta_vlan */,
2589         NULL /* commit */,
2590         NULL /* send_ether */,
2591         NULL /* set_radius_acl_auth */,
2592         NULL /* set_radius_acl_expire */,
2593         NULL /* set_ht_params */,
2594         NULL /* set_wps_beacon_ie */,
2595         NULL /* set_wps_probe_resp_ie */,
2596         NULL /* get_neighbor_bss */
2597 };
2598
2599 #endif /* HOSTAPD */