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 dure we get winsock2.h for Windows build to get sockaddr_storage */
  16 #include "build_config.h"
  17 #ifdef CONFIG_NATIVE_WINDOWS
  18 #include <winsock2.h>
  19 #endif /* CONFIG_NATIVE_WINDOWS */
  20
  21 #include "includes.h"
  22
  23 #ifndef CONFIG_NATIVE_WINDOWS
  24 #include <sys/un.h>
  25 #include <dirent.h>
  26 #include <sys/stat.h>
  27 #define DRIVER_TEST_UNIX
  28 #endif /* CONFIG_NATIVE_WINDOWS */
  29
  30 #include "common.h"
  31 #include "driver.h"
  32 #include "l2_packet/l2_packet.h"
  33 #include "eloop.h"
  34 #include "sha1.h"
  35 #include "ieee802_11_defs.h"
  36
  37
  38 struct wpa_driver_test_global {
  39         int dummy;
  40 };
  41
  42 struct wpa_driver_test_data {
  43         struct wpa_driver_test_global *global;
  44         void *ctx;
  45         u8 own_addr[ETH_ALEN];
  46         int test_socket;
  47 #ifdef DRIVER_TEST_UNIX
  48         struct sockaddr_un hostapd_addr;
  49 #endif /* DRIVER_TEST_UNIX */
  50         int hostapd_addr_set;
  51         struct sockaddr_in hostapd_addr_udp;
  52         int hostapd_addr_udp_set;
  53         char *own_socket_path;
  54         char *test_dir;
  55         u8 bssid[ETH_ALEN];
  56         u8 ssid[32];
  57         size_t ssid_len;
  58 #define MAX_SCAN_RESULTS 30
  59         struct wpa_scan_res *scanres[MAX_SCAN_RESULTS];
  60         size_t num_scanres;
  61         int use_associnfo;
  62         u8 assoc_wpa_ie[80];
  63         size_t assoc_wpa_ie_len;
  64         int use_mlme;
  65         int associated;
  66         u8 *probe_req_ie;
  67         size_t probe_req_ie_len;
  68         int ibss;
  69         int privacy;
  70 };
  71
  72
  73 static void wpa_driver_test_poll(void *eloop_ctx, void *timeout_ctx)
  74 {
  75         struct wpa_driver_test_data *drv = eloop_ctx;
  76
  77 #ifdef DRIVER_TEST_UNIX
  78         if (drv->associated && drv->hostapd_addr_set) {
  79                 struct stat st;
  80                 if (stat(drv->hostapd_addr.sun_path, &st) < 0) {
  81                         wpa_printf(MSG_DEBUG, "%s: lost connection to AP: %s",
  82                                    __func__, strerror(errno));
  83                         drv->associated = 0;
  84                         wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL);
  85                 }
  86         }
  87 #endif /* DRIVER_TEST_UNIX */
  88
  89         eloop_register_timeout(1, 0, wpa_driver_test_poll, drv, NULL);
  90 }
  91
  92
  93 static int wpa_driver_test_set_wpa(void *priv, int enabled)
  94 {
  95         wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled);
  96         return 0;
  97 }
  98
  99
 100 static void wpa_driver_test_scan_timeout(void *eloop_ctx, void *timeout_ctx)
 101 {
 102         wpa_printf(MSG_DEBUG, "Scan timeout - try to get results");
 103         wpa_supplicant_event(timeout_ctx, EVENT_SCAN_RESULTS, NULL);
 104 }
 105
 106
 107 #ifdef DRIVER_TEST_UNIX
 108 static void wpa_driver_scan_dir(struct wpa_driver_test_data *drv,
 109                                 const char *path)
 110 {
 111         struct dirent *dent;
 112         DIR *dir;
 113         struct sockaddr_un addr;
 114         char cmd[512], *pos, *end;
 115         int ret;
 116
 117         dir = opendir(path);
 118         if (dir == NULL)
 119                 return;
 120
 121         end = cmd + sizeof(cmd);
 122         pos = cmd;
 123         ret = os_snprintf(pos, end - pos, "SCAN " MACSTR,
 124                           MAC2STR(drv->own_addr));
 125         if (ret >= 0 && ret < end - pos)
 126                 pos += ret;
 127         if (drv->probe_req_ie) {
 128                 ret = os_snprintf(pos, end - pos, " ");
 129                 if (ret >= 0 && ret < end - pos)
 130                         pos += ret;
 131                 pos += wpa_snprintf_hex(pos, end - pos, drv->probe_req_ie,
 132                                         drv->probe_req_ie_len);
 133         }
 134         end[-1] = '\0';
 135
 136         while ((dent = readdir(dir))) {
 137                 if (os_strncmp(dent->d_name, "AP-", 3) != 0 &&
 138                     os_strncmp(dent->d_name, "STA-", 4) != 0)
 139                         continue;
 140                 if (drv->own_socket_path) {
 141                         size_t olen, dlen;
 142                         olen = os_strlen(drv->own_socket_path);
 143                         dlen = os_strlen(dent->d_name);
 144                         if (olen >= dlen &&
 145                             os_strcmp(dent->d_name,
 146                                       drv->own_socket_path + olen - dlen) == 0)
 147                                 continue;
 148                 }
 149                 wpa_printf(MSG_DEBUG, "%s: SCAN %s", __func__, dent->d_name);
 150
 151                 os_memset(&addr, 0, sizeof(addr));
 152                 addr.sun_family = AF_UNIX;
 153                 os_snprintf(addr.sun_path, sizeof(addr.sun_path), "%s/%s",
 154                             path, dent->d_name);
 155
 156                 if (sendto(drv->test_socket, cmd, os_strlen(cmd), 0,
 157                            (struct sockaddr *) &addr, sizeof(addr)) < 0) {
 158                         perror("sendto(test_socket)");
 159                 }
 160         }
 161         closedir(dir);
 162 }
 163 #endif /* DRIVER_TEST_UNIX */
 164
 165
 166 static int wpa_driver_test_scan(void *priv, const u8 *ssid, size_t ssid_len)
 167 {
 168         struct wpa_driver_test_data *drv = priv;
 169         wpa_printf(MSG_DEBUG, "%s: priv=%p", __func__, priv);
 170
 171         drv->num_scanres = 0;
 172
 173 #ifdef DRIVER_TEST_UNIX
 174         if (drv->test_socket >= 0 && drv->test_dir)
 175                 wpa_driver_scan_dir(drv, drv->test_dir);
 176
 177         if (drv->test_socket >= 0 && drv->hostapd_addr_set &&
 178             sendto(drv->test_socket, "SCAN", 4, 0,
 179                    (struct sockaddr *) &drv->hostapd_addr,
 180                    sizeof(drv->hostapd_addr)) < 0) {
 181                 perror("sendto(test_socket)");
 182         }
 183 #endif /* DRIVER_TEST_UNIX */
 184
 185         if (drv->test_socket >= 0 && drv->hostapd_addr_udp_set &&
 186             sendto(drv->test_socket, "SCAN", 4, 0,
 187                    (struct sockaddr *) &drv->hostapd_addr_udp,
 188                    sizeof(drv->hostapd_addr_udp)) < 0) {
 189                 perror("sendto(test_socket)");
 190         }
 191
 192         eloop_cancel_timeout(wpa_driver_test_scan_timeout, drv, drv->ctx);
 193         eloop_register_timeout(1, 0, wpa_driver_test_scan_timeout, drv,
 194                                drv->ctx);
 195         return 0;
 196 }
 197
 198
 199 static struct wpa_scan_results * wpa_driver_test_get_scan_results2(void *priv)
 200 {
 201         struct wpa_driver_test_data *drv = priv;
 202         struct wpa_scan_results *res;
 203         size_t i;
 204
 205         res = os_zalloc(sizeof(*res));
 206         if (res == NULL)
 207                 return NULL;
 208
 209         res->res = os_zalloc(drv->num_scanres * sizeof(struct wpa_scan_res *));
 210         if (res->res == NULL) {
 211                 os_free(res);
 212                 return NULL;
 213         }
 214
 215         for (i = 0; i < drv->num_scanres; i++) {
 216                 struct wpa_scan_res *r;
 217                 if (drv->scanres[i] == NULL)
 218                         continue;
 219                 r = os_malloc(sizeof(*r) + drv->scanres[i]->ie_len);
 220                 if (r == NULL)
 221                         break;
 222                 os_memcpy(r, drv->scanres[i],
 223                           sizeof(*r) + drv->scanres[i]->ie_len);
 224                 res->res[res->num++] = r;
 225         }
 226
 227         return res;
 228 }
 229
 230
 231 static int wpa_driver_test_set_key(void *priv, wpa_alg alg, const u8 *addr,
 232                                    int key_idx, int set_tx,
 233                                    const u8 *seq, size_t seq_len,
 234                                    const u8 *key, size_t key_len)
 235 {
 236         wpa_printf(MSG_DEBUG, "%s: priv=%p alg=%d key_idx=%d set_tx=%d",
 237                    __func__, priv, alg, key_idx, set_tx);
 238         if (addr) {
 239                 wpa_printf(MSG_DEBUG, "   addr=" MACSTR, MAC2STR(addr));
 240         }
 241         if (seq) {
 242                 wpa_hexdump(MSG_DEBUG, "   seq", seq, seq_len);
 243         }
 244         if (key) {
 245                 wpa_hexdump(MSG_DEBUG, "   key", key, key_len);
 246         }
 247         return 0;
 248 }
 249
 250
 251 static int wpa_driver_test_associate(
 252         void *priv, struct wpa_driver_associate_params *params)
 253 {
 254         struct wpa_driver_test_data *drv = priv;
 255         wpa_printf(MSG_DEBUG, "%s: priv=%p freq=%d pairwise_suite=%d "
 256                    "group_suite=%d key_mgmt_suite=%d auth_alg=%d mode=%d",
 257                    __func__, priv, params->freq, params->pairwise_suite,
 258                    params->group_suite, params->key_mgmt_suite,
 259                    params->auth_alg, params->mode);
 260         if (params->bssid) {
 261                 wpa_printf(MSG_DEBUG, "   bssid=" MACSTR,
 262                            MAC2STR(params->bssid));
 263         }
 264         if (params->ssid) {
 265                 wpa_hexdump_ascii(MSG_DEBUG, "   ssid",
 266                                   params->ssid, params->ssid_len);
 267         }
 268         if (params->wpa_ie) {
 269                 wpa_hexdump(MSG_DEBUG, "   wpa_ie",
 270                             params->wpa_ie, params->wpa_ie_len);
 271                 drv->assoc_wpa_ie_len = params->wpa_ie_len;
 272                 if (drv->assoc_wpa_ie_len > sizeof(drv->assoc_wpa_ie))
 273                         drv->assoc_wpa_ie_len = sizeof(drv->assoc_wpa_ie);
 274                 os_memcpy(drv->assoc_wpa_ie, params->wpa_ie,
 275                           drv->assoc_wpa_ie_len);
 276         } else
 277                 drv->assoc_wpa_ie_len = 0;
 278
 279         drv->ibss = params->mode == IEEE80211_MODE_IBSS;
 280         drv->privacy = params->key_mgmt_suite &
 281                 (WPA_KEY_MGMT_IEEE8021X |
 282                  WPA_KEY_MGMT_PSK |
 283                  WPA_KEY_MGMT_WPA_NONE |
 284                  WPA_KEY_MGMT_FT_IEEE8021X |
 285                  WPA_KEY_MGMT_FT_PSK |
 286                  WPA_KEY_MGMT_IEEE8021X_SHA256 |
 287                  WPA_KEY_MGMT_PSK_SHA256);
 288         if (params->wep_key_len[params->wep_tx_keyidx])
 289                 drv->privacy = 1;
 290
 291 #ifdef DRIVER_TEST_UNIX
 292         if (drv->test_dir && params->bssid &&
 293             params->mode != IEEE80211_MODE_IBSS) {
 294                 os_memset(&drv->hostapd_addr, 0, sizeof(drv->hostapd_addr));
 295                 drv->hostapd_addr.sun_family = AF_UNIX;
 296                 os_snprintf(drv->hostapd_addr.sun_path,
 297                             sizeof(drv->hostapd_addr.sun_path),
 298                             "%s/AP-" MACSTR,
 299                             drv->test_dir, MAC2STR(params->bssid));
 300                 drv->hostapd_addr_set = 1;
 301         }
 302 #endif /* DRIVER_TEST_UNIX */
 303
 304         if (drv->test_socket >= 0 &&
 305             (drv->hostapd_addr_set || drv->hostapd_addr_udp_set)) {
 306                 char cmd[200], *pos, *end;
 307                 int ret;
 308                 end = cmd + sizeof(cmd);
 309                 pos = cmd;
 310                 ret = os_snprintf(pos, end - pos, "ASSOC " MACSTR " ",
 311                                   MAC2STR(drv->own_addr));
 312                 if (ret >= 0 && ret < end - pos)
 313                         pos += ret;
 314                 pos += wpa_snprintf_hex(pos, end - pos, params->ssid,
 315                                         params->ssid_len);
 316                 ret = os_snprintf(pos, end - pos, " ");
 317                 if (ret >= 0 && ret < end - pos)
 318                         pos += ret;
 319                 pos += wpa_snprintf_hex(pos, end - pos, params->wpa_ie,
 320                                         params->wpa_ie_len);
 321                 end[-1] = '\0';
 322 #ifdef DRIVER_TEST_UNIX
 323                 if (drv->hostapd_addr_set &&
 324                     sendto(drv->test_socket, cmd, os_strlen(cmd), 0,
 325                            (struct sockaddr *) &drv->hostapd_addr,
 326                            sizeof(drv->hostapd_addr)) < 0) {
 327                         perror("sendto(test_socket)");
 328                         return -1;
 329                 }
 330 #endif /* DRIVER_TEST_UNIX */
 331                 if (drv->hostapd_addr_udp_set &&
 332                     sendto(drv->test_socket, cmd, os_strlen(cmd), 0,
 333                            (struct sockaddr *) &drv->hostapd_addr_udp,
 334                            sizeof(drv->hostapd_addr_udp)) < 0) {
 335                         perror("sendto(test_socket)");
 336                         return -1;
 337                 }
 338
 339                 os_memcpy(drv->ssid, params->ssid, params->ssid_len);
 340                 drv->ssid_len = params->ssid_len;
 341         } else {
 342                 drv->associated = 1;
 343                 if (params->mode == IEEE80211_MODE_IBSS) {
 344                         os_memcpy(drv->ssid, params->ssid, params->ssid_len);
 345                         drv->ssid_len = params->ssid_len;
 346                         if (params->bssid)
 347                                 os_memcpy(drv->bssid, params->bssid, ETH_ALEN);
 348                         else {
 349                                 os_get_random(drv->bssid, ETH_ALEN);
 350                                 drv->bssid[0] &= ~0x01;
 351                                 drv->bssid[0] |= 0x02;
 352                         }
 353                 }
 354                 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, NULL);
 355         }
 356
 357         return 0;
 358 }
 359
 360
 361 static int wpa_driver_test_get_bssid(void *priv, u8 *bssid)
 362 {
 363         struct wpa_driver_test_data *drv = priv;
 364         os_memcpy(bssid, drv->bssid, ETH_ALEN);
 365         return 0;
 366 }
 367
 368
 369 static int wpa_driver_test_get_ssid(void *priv, u8 *ssid)
 370 {
 371         struct wpa_driver_test_data *drv = priv;
 372         os_memcpy(ssid, drv->ssid, 32);
 373         return drv->ssid_len;
 374 }
 375
 376
 377 static int wpa_driver_test_send_disassoc(struct wpa_driver_test_data *drv)
 378 {
 379 #ifdef DRIVER_TEST_UNIX
 380         if (drv->test_socket >= 0 &&
 381             sendto(drv->test_socket, "DISASSOC", 8, 0,
 382                    (struct sockaddr *) &drv->hostapd_addr,
 383                    sizeof(drv->hostapd_addr)) < 0) {
 384                 perror("sendto(test_socket)");
 385                 return -1;
 386         }
 387 #endif /* DRIVER_TEST_UNIX */
 388         if (drv->test_socket >= 0 && drv->hostapd_addr_udp_set &&
 389             sendto(drv->test_socket, "DISASSOC", 8, 0,
 390                    (struct sockaddr *) &drv->hostapd_addr_udp,
 391                    sizeof(drv->hostapd_addr_udp)) < 0) {
 392                 perror("sendto(test_socket)");
 393                 return -1;
 394         }
 395         return 0;
 396 }
 397
 398
 399 static int wpa_driver_test_deauthenticate(void *priv, const u8 *addr,
 400                                           int reason_code)
 401 {
 402         struct wpa_driver_test_data *drv = priv;
 403         wpa_printf(MSG_DEBUG, "%s addr=" MACSTR " reason_code=%d",
 404                    __func__, MAC2STR(addr), reason_code);
 405         os_memset(drv->bssid, 0, ETH_ALEN);
 406         drv->associated = 0;
 407         wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL);
 408         return wpa_driver_test_send_disassoc(drv);
 409 }
 410
 411
 412 static int wpa_driver_test_disassociate(void *priv, const u8 *addr,
 413                                         int reason_code)
 414 {
 415         struct wpa_driver_test_data *drv = priv;
 416         wpa_printf(MSG_DEBUG, "%s addr=" MACSTR " reason_code=%d",
 417                    __func__, MAC2STR(addr), reason_code);
 418         os_memset(drv->bssid, 0, ETH_ALEN);
 419         drv->associated = 0;
 420         wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL);
 421         return wpa_driver_test_send_disassoc(drv);
 422 }
 423
 424
 425 static void wpa_driver_test_scanresp(struct wpa_driver_test_data *drv,
 426                                      struct sockaddr *from,
 427                                      socklen_t fromlen,
 428                                      const char *data)
 429 {
 430         struct wpa_scan_res *res;
 431         const char *pos, *pos2;
 432         size_t len;
 433         u8 *ie_pos, *ie_start, *ie_end;
 434 #define MAX_IE_LEN 1000
 435
 436         wpa_printf(MSG_DEBUG, "test_driver: SCANRESP %s", data);
 437         if (drv->num_scanres >= MAX_SCAN_RESULTS) {
 438                 wpa_printf(MSG_DEBUG, "test_driver: No room for the new scan "
 439                            "result");
 440                 return;
 441         }
 442
 443         /* SCANRESP BSSID SSID IEs */
 444
 445         res = os_zalloc(sizeof(*res) + MAX_IE_LEN);
 446         if (res == NULL)
 447                 return;
 448         ie_start = ie_pos = (u8 *) (res + 1);
 449         ie_end = ie_pos + MAX_IE_LEN;
 450
 451         if (hwaddr_aton(data, res->bssid)) {
 452                 wpa_printf(MSG_DEBUG, "test_driver: invalid BSSID in scanres");
 453                 os_free(res);
 454                 return;
 455         }
 456
 457         pos = data + 17;
 458         while (*pos == ' ')
 459                 pos++;
 460         pos2 = os_strchr(pos, ' ');
 461         if (pos2 == NULL) {
 462                 wpa_printf(MSG_DEBUG, "test_driver: invalid SSID termination "
 463                            "in scanres");
 464                 os_free(res);
 465                 return;
 466         }
 467         len = (pos2 - pos) / 2;
 468         if (len > 32)
 469                 len = 32;
 470         /*
 471          * Generate SSID IE from the SSID field since this IE is not included
 472          * in the main IE field.
 473          */
 474         *ie_pos++ = WLAN_EID_SSID;
 475         *ie_pos++ = len;
 476         if (hexstr2bin(pos, ie_pos, len) < 0) {
 477                 wpa_printf(MSG_DEBUG, "test_driver: invalid SSID in scanres");
 478                 os_free(res);
 479                 return;
 480         }
 481         ie_pos += len;
 482
 483         pos = pos2 + 1;
 484         pos2 = os_strchr(pos, ' ');
 485         if (pos2 == NULL)
 486                 len = os_strlen(pos) / 2;
 487         else
 488                 len = (pos2 - pos) / 2;
 489         if ((int) len > ie_end - ie_pos)
 490                 len = ie_end - ie_pos;
 491         if (hexstr2bin(pos, ie_pos, len) < 0) {
 492                 wpa_printf(MSG_DEBUG, "test_driver: invalid IEs in scanres");
 493                 os_free(res);
 494                 return;
 495         }
 496         ie_pos += len;
 497         res->ie_len = ie_pos - ie_start;
 498
 499         if (pos2) {
 500                 pos = pos2 + 1;
 501                 while (*pos == ' ')
 502                         pos++;
 503                 if (os_strstr(pos, "PRIVACY"))
 504                         res->caps |= IEEE80211_CAP_PRIVACY;
 505                 if (os_strstr(pos, "IBSS"))
 506                         res->caps |= IEEE80211_CAP_IBSS;
 507         }
 508
 509         os_free(drv->scanres[drv->num_scanres]);
 510         drv->scanres[drv->num_scanres++] = res;
 511 }
 512
 513
 514 static void wpa_driver_test_assocresp(struct wpa_driver_test_data *drv,
 515                                       struct sockaddr *from,
 516                                       socklen_t fromlen,
 517                                       const char *data)
 518 {
 519         /* ASSOCRESP BSSID <res> */
 520         if (hwaddr_aton(data, drv->bssid)) {
 521                 wpa_printf(MSG_DEBUG, "test_driver: invalid BSSID in "
 522                            "assocresp");
 523         }
 524         if (drv->use_associnfo) {
 525                 union wpa_event_data event;
 526                 os_memset(&event, 0, sizeof(event));
 527                 event.assoc_info.req_ies = drv->assoc_wpa_ie;
 528                 event.assoc_info.req_ies_len = drv->assoc_wpa_ie_len;
 529                 wpa_supplicant_event(drv->ctx, EVENT_ASSOCINFO, &event);
 530         }
 531         drv->associated = 1;
 532         wpa_supplicant_event(drv->ctx, EVENT_ASSOC, NULL);
 533 }
 534
 535
 536 static void wpa_driver_test_disassoc(struct wpa_driver_test_data *drv,
 537                                      struct sockaddr *from,
 538                                      socklen_t fromlen)
 539 {
 540         drv->associated = 0;
 541         wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL);
 542 }
 543
 544
 545 static void wpa_driver_test_eapol(struct wpa_driver_test_data *drv,
 546                                   struct sockaddr *from,
 547                                   socklen_t fromlen,
 548                                   const u8 *data, size_t data_len)
 549 {
 550         const u8 *src = drv->bssid;
 551
 552         if (data_len > 14) {
 553                 /* Skip Ethernet header */
 554                 src = data + ETH_ALEN;
 555                 data += 14;
 556                 data_len -= 14;
 557         }
 558         wpa_supplicant_rx_eapol(drv->ctx, src, data, data_len);
 559 }
 560
 561
 562 static void wpa_driver_test_mlme(struct wpa_driver_test_data *drv,
 563                                  struct sockaddr *from,
 564                                  socklen_t fromlen,
 565                                  const u8 *data, size_t data_len)
 566 {
 567 #ifdef CONFIG_CLIENT_MLME
 568         struct ieee80211_rx_status rx_status;
 569         os_memset(&rx_status, 0, sizeof(rx_status));
 570         wpa_supplicant_sta_rx(drv->ctx, data, data_len, &rx_status);
 571 #endif /* CONFIG_CLIENT_MLME */
 572 }
 573
 574
 575 static void wpa_driver_test_scan_cmd(struct wpa_driver_test_data *drv,
 576                                      struct sockaddr *from,
 577                                      socklen_t fromlen,
 578                                      const u8 *data, size_t data_len)
 579 {
 580         char buf[512], *pos, *end;
 581         int ret;
 582
 583         /* data: optional [ STA-addr | ' ' | IEs(hex) ] */
 584
 585         if (!drv->ibss)
 586                 return;
 587
 588         pos = buf;
 589         end = buf + sizeof(buf);
 590
 591         /* reply: SCANRESP BSSID SSID IEs */
 592         ret = snprintf(pos, end - pos, "SCANRESP " MACSTR " ",
 593                        MAC2STR(drv->bssid));
 594         if (ret < 0 || ret >= end - pos)
 595                 return;
 596         pos += ret;
 597         pos += wpa_snprintf_hex(pos, end - pos,
 598                                 drv->ssid, drv->ssid_len);
 599         ret = snprintf(pos, end - pos, " ");
 600         if (ret < 0 || ret >= end - pos)
 601                 return;
 602         pos += ret;
 603         pos += wpa_snprintf_hex(pos, end - pos, drv->assoc_wpa_ie,
 604                                 drv->assoc_wpa_ie_len);
 605
 606         if (drv->privacy) {
 607                 ret = snprintf(pos, end - pos, " PRIVACY");
 608                 if (ret < 0 || ret >= end - pos)
 609                         return;
 610                 pos += ret;
 611         }
 612
 613         ret = snprintf(pos, end - pos, " IBSS");
 614         if (ret < 0 || ret >= end - pos)
 615                 return;
 616         pos += ret;
 617
 618         sendto(drv->test_socket, buf, pos - buf, 0,
 619                (struct sockaddr *) from, fromlen);
 620 }
 621
 622
 623 static void wpa_driver_test_receive_unix(int sock, void *eloop_ctx,
 624                                          void *sock_ctx)
 625 {
 626         struct wpa_driver_test_data *drv = eloop_ctx;
 627         char *buf;
 628         int res;
 629         struct sockaddr_storage from;
 630         socklen_t fromlen = sizeof(from);
 631         const size_t buflen = 2000;
 632
 633         buf = os_malloc(buflen);
 634         if (buf == NULL)
 635                 return;
 636         res = recvfrom(sock, buf, buflen - 1, 0,
 637                        (struct sockaddr *) &from, &fromlen);
 638         if (res < 0) {
 639                 perror("recvfrom(test_socket)");
 640                 os_free(buf);
 641                 return;
 642         }
 643         buf[res] = '\0';
 644
 645         wpa_printf(MSG_DEBUG, "test_driver: received %u bytes", res);
 646
 647         if (os_strncmp(buf, "SCANRESP ", 9) == 0) {
 648                 wpa_driver_test_scanresp(drv, (struct sockaddr *) &from,
 649                                          fromlen, buf + 9);
 650         } else if (os_strncmp(buf, "ASSOCRESP ", 10) == 0) {
 651                 wpa_driver_test_assocresp(drv, (struct sockaddr *) &from,
 652                                           fromlen, buf + 10);
 653         } else if (os_strcmp(buf, "DISASSOC") == 0) {
 654                 wpa_driver_test_disassoc(drv, (struct sockaddr *) &from,
 655                                          fromlen);
 656         } else if (os_strcmp(buf, "DEAUTH") == 0) {
 657                 wpa_driver_test_disassoc(drv, (struct sockaddr *) &from,
 658                                          fromlen);
 659         } else if (os_strncmp(buf, "EAPOL ", 6) == 0) {
 660                 wpa_driver_test_eapol(drv, (struct sockaddr *) &from, fromlen,
 661                                       (const u8 *) buf + 6, res - 6);
 662         } else if (os_strncmp(buf, "MLME ", 5) == 0) {
 663                 wpa_driver_test_mlme(drv, (struct sockaddr *) &from, fromlen,
 664                                      (const u8 *) buf + 5, res - 5);
 665         } else if (os_strncmp(buf, "SCAN ", 5) == 0) {
 666                 wpa_driver_test_scan_cmd(drv, (struct sockaddr *) &from,
 667                                          fromlen,
 668                                          (const u8 *) buf + 5, res - 5);
 669         } else {
 670                 wpa_hexdump_ascii(MSG_DEBUG, "Unknown test_socket command",
 671                                   (u8 *) buf, res);
 672         }
 673         os_free(buf);
 674 }
 675
 676
 677 static void * wpa_driver_test_init2(void *ctx, const char *ifname,
 678                                     void *global_priv)
 679 {
 680         struct wpa_driver_test_data *drv;
 681
 682         drv = os_zalloc(sizeof(*drv));
 683         if (drv == NULL)
 684                 return NULL;
 685         drv->global = global_priv;
 686         drv->ctx = ctx;
 687         drv->test_socket = -1;
 688
 689         /* Set dummy BSSID and SSID for testing. */
 690         drv->bssid[0] = 0x02;
 691         drv->bssid[1] = 0x00;
 692         drv->bssid[2] = 0x00;
 693         drv->bssid[3] = 0x00;
 694         drv->bssid[4] = 0x00;
 695         drv->bssid[5] = 0x01;
 696         os_memcpy(drv->ssid, "test", 5);
 697         drv->ssid_len = 4;
 698
 699         /* Generate a MAC address to help testing with multiple STAs */
 700         drv->own_addr[0] = 0x02; /* locally administered */
 701         sha1_prf((const u8 *) ifname, os_strlen(ifname),
 702                  "wpa_supplicant test mac addr generation",
 703                  NULL, 0, drv->own_addr + 1, ETH_ALEN - 1);
 704         eloop_register_timeout(1, 0, wpa_driver_test_poll, drv, NULL);
 705
 706         return drv;
 707 }
 708
 709
 710 static void wpa_driver_test_close_test_socket(struct wpa_driver_test_data *drv)
 711 {
 712         if (drv->test_socket >= 0) {
 713                 eloop_unregister_read_sock(drv->test_socket);
 714                 close(drv->test_socket);
 715                 drv->test_socket = -1;
 716         }
 717
 718         if (drv->own_socket_path) {
 719                 unlink(drv->own_socket_path);
 720                 os_free(drv->own_socket_path);
 721                 drv->own_socket_path = NULL;
 722         }
 723 }
 724
 725
 726 static void wpa_driver_test_deinit(void *priv)
 727 {
 728         struct wpa_driver_test_data *drv = priv;
 729         int i;
 730         wpa_driver_test_close_test_socket(drv);
 731         eloop_cancel_timeout(wpa_driver_test_scan_timeout, drv, drv->ctx);
 732         eloop_cancel_timeout(wpa_driver_test_poll, drv, NULL);
 733         os_free(drv->test_dir);
 734         for (i = 0; i < MAX_SCAN_RESULTS; i++)
 735                 os_free(drv->scanres[i]);
 736         os_free(drv->probe_req_ie);
 737         os_free(drv);
 738 }
 739
 740
 741 static int wpa_driver_test_attach(struct wpa_driver_test_data *drv,
 742                                   const char *dir)
 743 {
 744 #ifdef DRIVER_TEST_UNIX
 745         static unsigned int counter = 0;
 746         struct sockaddr_un addr;
 747         size_t len;
 748
 749         os_free(drv->own_socket_path);
 750         if (dir) {
 751                 len = os_strlen(dir) + 30;
 752                 drv->own_socket_path = os_malloc(len);
 753                 if (drv->own_socket_path == NULL)
 754                         return -1;
 755                 os_snprintf(drv->own_socket_path, len, "%s/STA-" MACSTR,
 756                             dir, MAC2STR(drv->own_addr));
 757         } else {
 758                 drv->own_socket_path = os_malloc(100);
 759                 if (drv->own_socket_path == NULL)
 760                         return -1;
 761                 os_snprintf(drv->own_socket_path, 100,
 762                             "/tmp/wpa_supplicant_test-%d-%d",
 763                             getpid(), counter++);
 764         }
 765
 766         drv->test_socket = socket(PF_UNIX, SOCK_DGRAM, 0);
 767         if (drv->test_socket < 0) {
 768                 perror("socket(PF_UNIX)");
 769                 os_free(drv->own_socket_path);
 770                 drv->own_socket_path = NULL;
 771                 return -1;
 772         }
 773
 774         os_memset(&addr, 0, sizeof(addr));
 775         addr.sun_family = AF_UNIX;
 776         os_strlcpy(addr.sun_path, drv->own_socket_path, sizeof(addr.sun_path));
 777         if (bind(drv->test_socket, (struct sockaddr *) &addr,
 778                  sizeof(addr)) < 0) {
 779                 perror("bind(PF_UNIX)");
 780                 close(drv->test_socket);
 781                 unlink(drv->own_socket_path);
 782                 os_free(drv->own_socket_path);
 783                 drv->own_socket_path = NULL;
 784                 return -1;
 785         }
 786
 787         eloop_register_read_sock(drv->test_socket,
 788                                  wpa_driver_test_receive_unix, drv, NULL);
 789
 790         return 0;
 791 #else /* DRIVER_TEST_UNIX */
 792         return -1;
 793 #endif /* DRIVER_TEST_UNIX */
 794 }
 795
 796
 797 static int wpa_driver_test_attach_udp(struct wpa_driver_test_data *drv,
 798                                       char *dst)
 799 {
 800         char *pos;
 801
 802         pos = os_strchr(dst, ':');
 803         if (pos == NULL)
 804                 return -1;
 805         *pos++ = '\0';
 806         wpa_printf(MSG_DEBUG, "%s: addr=%s port=%s", __func__, dst, pos);
 807
 808         drv->test_socket = socket(PF_INET, SOCK_DGRAM, 0);
 809         if (drv->test_socket < 0) {
 810                 perror("socket(PF_INET)");
 811                 return -1;
 812         }
 813
 814         os_memset(&drv->hostapd_addr_udp, 0, sizeof(drv->hostapd_addr_udp));
 815         drv->hostapd_addr_udp.sin_family = AF_INET;
 816 #if defined(CONFIG_NATIVE_WINDOWS) || defined(CONFIG_ANSI_C_EXTRA)
 817         {
 818                 int a[4];
 819                 u8 *pos;
 820                 sscanf(dst, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]);
 821                 pos = (u8 *) &drv->hostapd_addr_udp.sin_addr;
 822                 *pos++ = a[0];
 823                 *pos++ = a[1];
 824                 *pos++ = a[2];
 825                 *pos++ = a[3];
 826         }
 827 #else /* CONFIG_NATIVE_WINDOWS or CONFIG_ANSI_C_EXTRA */
 828         inet_aton(dst, &drv->hostapd_addr_udp.sin_addr);
 829 #endif /* CONFIG_NATIVE_WINDOWS or CONFIG_ANSI_C_EXTRA */
 830         drv->hostapd_addr_udp.sin_port = htons(atoi(pos));
 831
 832         drv->hostapd_addr_udp_set = 1;
 833
 834         eloop_register_read_sock(drv->test_socket,
 835                                  wpa_driver_test_receive_unix, drv, NULL);
 836
 837         return 0;
 838 }
 839
 840
 841 static int wpa_driver_test_set_param(void *priv, const char *param)
 842 {
 843         struct wpa_driver_test_data *drv = priv;
 844         const char *pos;
 845
 846         wpa_printf(MSG_DEBUG, "%s: param='%s'", __func__, param);
 847         if (param == NULL)
 848                 return 0;
 849
 850         wpa_driver_test_close_test_socket(drv);
 851
 852 #ifdef DRIVER_TEST_UNIX
 853         pos = os_strstr(param, "test_socket=");
 854         if (pos) {
 855                 const char *pos2;
 856                 size_t len;
 857
 858                 pos += 12;
 859                 pos2 = os_strchr(pos, ' ');
 860                 if (pos2)
 861                         len = pos2 - pos;
 862                 else
 863                         len = os_strlen(pos);
 864                 if (len > sizeof(drv->hostapd_addr.sun_path))
 865                         return -1;
 866                 os_memset(&drv->hostapd_addr, 0, sizeof(drv->hostapd_addr));
 867                 drv->hostapd_addr.sun_family = AF_UNIX;
 868                 os_memcpy(drv->hostapd_addr.sun_path, pos, len);
 869                 drv->hostapd_addr_set = 1;
 870         }
 871 #endif /* DRIVER_TEST_UNIX */
 872
 873         pos = os_strstr(param, "test_dir=");
 874         if (pos) {
 875                 char *end;
 876                 os_free(drv->test_dir);
 877                 drv->test_dir = os_strdup(pos + 9);
 878                 if (drv->test_dir == NULL)
 879                         return -1;
 880                 end = os_strchr(drv->test_dir, ' ');
 881                 if (end)
 882                         *end = '\0';
 883                 if (wpa_driver_test_attach(drv, drv->test_dir))
 884                         return -1;
 885         } else {
 886                 pos = os_strstr(param, "test_udp=");
 887                 if (pos) {
 888                         char *dst, *epos;
 889                         dst = os_strdup(pos + 9);
 890                         if (dst == NULL)
 891                                 return -1;
 892                         epos = os_strchr(dst, ' ');
 893                         if (epos)
 894                                 *epos = '\0';
 895                         if (wpa_driver_test_attach_udp(drv, dst))
 896                                 return -1;
 897                         os_free(dst);
 898                 } else if (wpa_driver_test_attach(drv, NULL))
 899                         return -1;
 900         }
 901
 902         if (os_strstr(param, "use_associnfo=1")) {
 903                 wpa_printf(MSG_DEBUG, "test_driver: Use AssocInfo events");
 904                 drv->use_associnfo = 1;
 905         }
 906
 907 #ifdef CONFIG_CLIENT_MLME
 908         if (os_strstr(param, "use_mlme=1")) {
 909                 wpa_printf(MSG_DEBUG, "test_driver: Use internal MLME");
 910                 drv->use_mlme = 1;
 911         }
 912 #endif /* CONFIG_CLIENT_MLME */
 913
 914         return 0;
 915 }
 916
 917
 918 static const u8 * wpa_driver_test_get_mac_addr(void *priv)
 919 {
 920         struct wpa_driver_test_data *drv = priv;
 921         wpa_printf(MSG_DEBUG, "%s", __func__);
 922         return drv->own_addr;
 923 }
 924
 925
 926 static int wpa_driver_test_send_eapol(void *priv, const u8 *dest, u16 proto,
 927                                       const u8 *data, size_t data_len)
 928 {
 929         struct wpa_driver_test_data *drv = priv;
 930         char *msg;
 931         size_t msg_len;
 932         struct l2_ethhdr eth;
 933         struct sockaddr *addr;
 934         socklen_t alen;
 935 #ifdef DRIVER_TEST_UNIX
 936         struct sockaddr_un addr_un;
 937 #endif /* DRIVER_TEST_UNIX */
 938
 939         wpa_hexdump(MSG_MSGDUMP, "test_send_eapol TX frame", data, data_len);
 940
 941         os_memset(&eth, 0, sizeof(eth));
 942         os_memcpy(eth.h_dest, dest, ETH_ALEN);
 943         os_memcpy(eth.h_source, drv->own_addr, ETH_ALEN);
 944         eth.h_proto = host_to_be16(proto);
 945
 946         msg_len = 6 + sizeof(eth) + data_len;
 947         msg = os_malloc(msg_len);
 948         if (msg == NULL)
 949                 return -1;
 950         os_memcpy(msg, "EAPOL ", 6);
 951         os_memcpy(msg + 6, &eth, sizeof(eth));
 952         os_memcpy(msg + 6 + sizeof(eth), data, data_len);
 953
 954         if (os_memcmp(dest, drv->bssid, ETH_ALEN) == 0 ||
 955             drv->test_dir == NULL) {
 956                 if (drv->hostapd_addr_udp_set) {
 957                         addr = (struct sockaddr *) &drv->hostapd_addr_udp;
 958                         alen = sizeof(drv->hostapd_addr_udp);
 959                 } else {
 960 #ifdef DRIVER_TEST_UNIX
 961                         addr = (struct sockaddr *) &drv->hostapd_addr;
 962                         alen = sizeof(drv->hostapd_addr);
 963 #else /* DRIVER_TEST_UNIX */
 964                         os_free(msg);
 965                         return -1;
 966 #endif /* DRIVER_TEST_UNIX */
 967                 }
 968         } else {
 969 #ifdef DRIVER_TEST_UNIX
 970                 struct stat st;
 971                 os_memset(&addr_un, 0, sizeof(addr_un));
 972                 addr_un.sun_family = AF_UNIX;
 973                 os_snprintf(addr_un.sun_path, sizeof(addr_un.sun_path),
 974                             "%s/STA-" MACSTR, drv->test_dir, MAC2STR(dest));
 975                 if (stat(addr_un.sun_path, &st) < 0) {
 976                         os_snprintf(addr_un.sun_path, sizeof(addr_un.sun_path),
 977                                     "%s/AP-" MACSTR,
 978                                     drv->test_dir, MAC2STR(dest));
 979                 }
 980                 addr = (struct sockaddr *) &addr_un;
 981                 alen = sizeof(addr_un);
 982 #else /* DRIVER_TEST_UNIX */
 983                 os_free(msg);
 984                 return -1;
 985 #endif /* DRIVER_TEST_UNIX */
 986         }
 987
 988         if (sendto(drv->test_socket, msg, msg_len, 0, addr, alen) < 0) {
 989                 perror("sendmsg(test_socket)");
 990                 os_free(msg);
 991                 return -1;
 992         }
 993
 994         os_free(msg);
 995         return 0;
 996 }
 997
 998
 999 static int wpa_driver_test_get_capa(void *priv, struct wpa_driver_capa *capa)
1000 {
1001         struct wpa_driver_test_data *drv = priv;
1002         os_memset(capa, 0, sizeof(*capa));
1003         capa->key_mgmt = WPA_DRIVER_CAPA_KEY_MGMT_WPA |
1004                 WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
1005                 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK |
1006                 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK |
1007                 WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE |
1008                 WPA_DRIVER_CAPA_KEY_MGMT_FT |
1009                 WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK;
1010         capa->enc = WPA_DRIVER_CAPA_ENC_WEP40 |
1011                 WPA_DRIVER_CAPA_ENC_WEP104 |
1012                 WPA_DRIVER_CAPA_ENC_TKIP |
1013                 WPA_DRIVER_CAPA_ENC_CCMP;
1014         capa->auth = WPA_DRIVER_AUTH_OPEN |
1015                 WPA_DRIVER_AUTH_SHARED |
1016                 WPA_DRIVER_AUTH_LEAP;
1017         if (drv->use_mlme)
1018                 capa->flags |= WPA_DRIVER_FLAGS_USER_SPACE_MLME;
1019
1020         return 0;
1021 }
1022
1023
1024 static int wpa_driver_test_mlme_setprotection(void *priv, const u8 *addr,
1025                                               int protect_type,
1026                                               int key_type)
1027 {
1028         wpa_printf(MSG_DEBUG, "%s: protect_type=%d key_type=%d",
1029                    __func__, protect_type, key_type);
1030
1031         if (addr) {
1032                 wpa_printf(MSG_DEBUG, "%s: addr=" MACSTR,
1033                            __func__, MAC2STR(addr));
1034         }
1035
1036         return 0;
1037 }
1038
1039
1040 #ifdef CONFIG_CLIENT_MLME
1041 static struct wpa_hw_modes *
1042 wpa_driver_test_get_hw_feature_data(void *priv, u16 *num_modes, u16 *flags)
1043 {
1044         struct wpa_hw_modes *modes;
1045
1046         *num_modes = 1;
1047         *flags = 0;
1048         modes = os_zalloc(*num_modes * sizeof(struct wpa_hw_modes));
1049         if (modes == NULL)
1050                 return NULL;
1051         modes[0].mode = WPA_MODE_IEEE80211G;
1052         modes[0].num_channels = 1;
1053         modes[0].num_rates = 1;
1054         modes[0].channels = os_zalloc(sizeof(struct wpa_channel_data));
1055         modes[0].rates = os_zalloc(sizeof(struct wpa_rate_data));
1056         if (modes[0].channels == NULL || modes[0].rates == NULL) {
1057                 wpa_supplicant_sta_free_hw_features(modes, *num_modes);
1058                 return NULL;
1059         }
1060         modes[0].channels[0].chan = 1;
1061         modes[0].channels[0].freq = 2412;
1062         modes[0].channels[0].flag = WPA_CHAN_W_SCAN | WPA_CHAN_W_ACTIVE_SCAN;
1063         modes[0].rates[0].rate = 10;
1064         modes[0].rates[0].flags = WPA_RATE_BASIC | WPA_RATE_SUPPORTED |
1065                 WPA_RATE_CCK | WPA_RATE_MANDATORY;
1066
1067         return modes;
1068 }
1069
1070
1071 static int wpa_driver_test_set_channel(void *priv, wpa_hw_mode phymode,
1072                                        int chan, int freq)
1073 {
1074         wpa_printf(MSG_DEBUG, "%s: phymode=%d chan=%d freq=%d",
1075                    __func__, phymode, chan, freq);
1076         return 0;
1077 }
1078
1079
1080 static int wpa_driver_test_send_mlme(void *priv, const u8 *data,
1081                                      size_t data_len)
1082 {
1083         struct wpa_driver_test_data *drv = priv;
1084         struct msghdr msg;
1085         struct iovec io[2];
1086         struct sockaddr_un addr;
1087         const u8 *dest;
1088         struct dirent *dent;
1089         DIR *dir;
1090
1091         wpa_hexdump(MSG_MSGDUMP, "test_send_mlme", data, data_len);
1092         if (data_len < 10)
1093                 return -1;
1094         dest = data + 4;
1095
1096         io[0].iov_base = "MLME ";
1097         io[0].iov_len = 5;
1098         io[1].iov_base = (u8 *) data;
1099         io[1].iov_len = data_len;
1100
1101         os_memset(&msg, 0, sizeof(msg));
1102         msg.msg_iov = io;
1103         msg.msg_iovlen = 2;
1104         if (os_memcmp(dest, drv->bssid, ETH_ALEN) == 0 ||
1105             drv->test_dir == NULL) {
1106                 if (drv->hostapd_addr_udp_set) {
1107                         msg.msg_name = &drv->hostapd_addr_udp;
1108                         msg.msg_namelen = sizeof(drv->hostapd_addr_udp);
1109                 } else {
1110 #ifdef DRIVER_TEST_UNIX
1111                         msg.msg_name = &drv->hostapd_addr;
1112                         msg.msg_namelen = sizeof(drv->hostapd_addr);
1113 #endif /* DRIVER_TEST_UNIX */
1114                 }
1115         } else if (os_memcmp(dest, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) == 0)
1116         {
1117                 dir = opendir(drv->test_dir);
1118                 if (dir == NULL)
1119                         return -1;
1120                 while ((dent = readdir(dir))) {
1121 #ifdef _DIRENT_HAVE_D_TYPE
1122                         /* Skip the file if it is not a socket.
1123                          * Also accept DT_UNKNOWN (0) in case
1124                          * the C library or underlying file
1125                          * system does not support d_type. */
1126                         if (dent->d_type != DT_SOCK &&
1127                             dent->d_type != DT_UNKNOWN)
1128                                 continue;
1129 #endif /* _DIRENT_HAVE_D_TYPE */
1130                         if (os_strcmp(dent->d_name, ".") == 0 ||
1131                             os_strcmp(dent->d_name, "..") == 0)
1132                                 continue;
1133                         wpa_printf(MSG_DEBUG, "%s: Send broadcast MLME to %s",
1134                                    __func__, dent->d_name);
1135                         os_memset(&addr, 0, sizeof(addr));
1136                         addr.sun_family = AF_UNIX;
1137                         os_snprintf(addr.sun_path, sizeof(addr.sun_path),
1138                                     "%s/%s", drv->test_dir, dent->d_name);
1139
1140                         msg.msg_name = &addr;
1141                         msg.msg_namelen = sizeof(addr);
1142
1143                         if (sendmsg(drv->test_socket, &msg, 0) < 0)
1144                                 perror("sendmsg(test_socket)");
1145                 }
1146                 closedir(dir);
1147                 return 0;
1148         } else {
1149                 struct stat st;
1150                 os_memset(&addr, 0, sizeof(addr));
1151                 addr.sun_family = AF_UNIX;
1152                 os_snprintf(addr.sun_path, sizeof(addr.sun_path),
1153                             "%s/AP-" MACSTR, drv->test_dir, MAC2STR(dest));
1154                 if (stat(addr.sun_path, &st) < 0) {
1155                         os_snprintf(addr.sun_path, sizeof(addr.sun_path),
1156                                     "%s/STA-" MACSTR,
1157                                     drv->test_dir, MAC2STR(dest));
1158                 }
1159                 msg.msg_name = &addr;
1160                 msg.msg_namelen = sizeof(addr);
1161         }
1162
1163         if (sendmsg(drv->test_socket, &msg, 0) < 0) {
1164                 perror("sendmsg(test_socket)");
1165                 return -1;
1166         }
1167
1168         return 0;
1169 }
1170
1171
1172 static int wpa_driver_test_mlme_add_sta(void *priv, const u8 *addr,
1173                                         const u8 *supp_rates,
1174                                         size_t supp_rates_len)
1175 {
1176         wpa_printf(MSG_DEBUG, "%s: addr=" MACSTR, __func__, MAC2STR(addr));
1177         return 0;
1178 }
1179
1180
1181 static int wpa_driver_test_mlme_remove_sta(void *priv, const u8 *addr)
1182 {
1183         wpa_printf(MSG_DEBUG, "%s: addr=" MACSTR, __func__, MAC2STR(addr));
1184         return 0;
1185 }
1186
1187
1188 static int wpa_driver_test_set_ssid(void *priv, const u8 *ssid,
1189                                     size_t ssid_len)
1190 {
1191         wpa_printf(MSG_DEBUG, "%s", __func__);
1192         return 0;
1193 }
1194
1195
1196 static int wpa_driver_test_set_bssid(void *priv, const u8 *bssid)
1197 {
1198         wpa_printf(MSG_DEBUG, "%s: bssid=" MACSTR, __func__, MAC2STR(bssid));
1199         return 0;
1200 }
1201 #endif /* CONFIG_CLIENT_MLME */
1202
1203
1204 static int wpa_driver_test_set_probe_req_ie(void *priv, const u8 *ies,
1205                                             size_t ies_len)
1206 {
1207         struct wpa_driver_test_data *drv = priv;
1208
1209         os_free(drv->probe_req_ie);
1210         if (ies) {
1211                 drv->probe_req_ie = os_malloc(ies_len);
1212                 if (drv->probe_req_ie == NULL) {
1213                         drv->probe_req_ie_len = 0;
1214                         return -1;
1215                 }
1216                 os_memcpy(drv->probe_req_ie, ies, ies_len);
1217                 drv->probe_req_ie_len = ies_len;
1218         } else {
1219                 drv->probe_req_ie = NULL;
1220                 drv->probe_req_ie_len = 0;
1221         }
1222         return 0;
1223 }
1224
1225
1226 static void * wpa_driver_test_global_init(void)
1227 {
1228         struct wpa_driver_test_global *global;
1229
1230         global = os_zalloc(sizeof(*global));
1231         return global;
1232 }
1233
1234
1235 static void wpa_driver_test_global_deinit(void *priv)
1236 {
1237         struct wpa_driver_test_global *global = priv;
1238         os_free(global);
1239 }
1240
1241
1242 static struct wpa_interface_info *
1243 wpa_driver_test_get_interfaces(void *global_priv)
1244 {
1245         /* struct wpa_driver_test_global *global = priv; */
1246         struct wpa_interface_info *iface;
1247
1248         iface = os_zalloc(sizeof(*iface));
1249         if (iface == NULL)
1250                 return iface;
1251         iface->ifname = os_strdup("sta0");
1252         iface->desc = os_strdup("test interface 0");
1253         iface->drv_name = "test";
1254         iface->next = os_zalloc(sizeof(*iface));
1255         if (iface->next) {
1256                 iface->next->ifname = os_strdup("sta1");
1257                 iface->next->desc = os_strdup("test interface 1");
1258                 iface->next->drv_name = "test";
1259         }
1260
1261         return iface;
1262 }
1263
1264
1265 const struct wpa_driver_ops wpa_driver_test_ops = {
1266         "test",
1267         "wpa_supplicant test driver",
1268         wpa_driver_test_get_bssid,
1269         wpa_driver_test_get_ssid,
1270         wpa_driver_test_set_wpa,
1271         wpa_driver_test_set_key,
1272         NULL /* init */,
1273         wpa_driver_test_deinit,
1274         wpa_driver_test_set_param,
1275         NULL /* set_countermeasures */,
1276         NULL /* set_drop_unencrypted */,
1277         wpa_driver_test_scan,
1278         NULL /* get_scan_results */,
1279         wpa_driver_test_deauthenticate,
1280         wpa_driver_test_disassociate,
1281         wpa_driver_test_associate,
1282         NULL /* set_auth_alg */,
1283         NULL /* add_pmkid */,
1284         NULL /* remove_pmkid */,
1285         NULL /* flush_pmkid */,
1286         wpa_driver_test_get_capa,
1287         NULL /* poll */,
1288         NULL /* get_ifname */,
1289         wpa_driver_test_get_mac_addr,
1290         wpa_driver_test_send_eapol,
1291         NULL /* set_operstate */,
1292         wpa_driver_test_mlme_setprotection,
1293 #ifdef CONFIG_CLIENT_MLME
1294         wpa_driver_test_get_hw_feature_data,
1295         wpa_driver_test_set_channel,
1296         wpa_driver_test_set_ssid,
1297         wpa_driver_test_set_bssid,
1298         wpa_driver_test_send_mlme,
1299         wpa_driver_test_mlme_add_sta,
1300         wpa_driver_test_mlme_remove_sta,
1301 #else /* CONFIG_CLIENT_MLME */
1302         NULL /* get_hw_feature_data */,
1303         NULL /* set_channel */,
1304         NULL /* set_ssid */,
1305         NULL /* set_bssid */,
1306         NULL /* send_mlme */,
1307         NULL /* mlme_add_sta */,
1308         NULL /* mlme_remove_sta */,
1309 #endif /* CONFIG_CLIENT_MLME */
1310         NULL /* update_ft_ies */,
1311         NULL /* send_ft_action */,
1312         wpa_driver_test_get_scan_results2,
1313         wpa_driver_test_set_probe_req_ie,
1314         NULL /* set_mode */,
1315         NULL /* set_country */,
1316         wpa_driver_test_global_init,
1317         wpa_driver_test_global_deinit,
1318         wpa_driver_test_init2,
1319         wpa_driver_test_get_interfaces
1320 };