src/drivers/driver_test.c

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