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