src/drivers/driver_test.c

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