/*
* wlantest control interface
- * Copyright (c) 2010, Jouni Malinen <j@w1.fi>
+ * Copyright (c) 2010-2015, Jouni Malinen <j@w1.fi>
*
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * Alternatively, this software may be distributed under the terms of BSD
- * license.
- *
- * See README and COPYING for more details.
+ * This software may be distributed under the terms of the BSD license.
+ * See README for more details.
*/
#include "utils/includes.h"
#include "utils/common.h"
#include "utils/eloop.h"
+#include "common/defs.h"
#include "common/version.h"
#include "common/ieee802_11_defs.h"
#include "wlantest.h"
}
+static struct wlantest_bss * ctrl_get_bss(struct wlantest *wt, int sock,
+ u8 *cmd, size_t clen)
+{
+ struct wlantest_bss *bss;
+ u8 *pos;
+ size_t len;
+
+ pos = attr_get(cmd, clen, WLANTEST_ATTR_BSSID, &len);
+ if (pos == NULL || len != ETH_ALEN) {
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
+ return NULL;
+ }
+
+ bss = bss_find(wt, pos);
+ if (bss == NULL) {
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_FAILURE);
+ return NULL;
+ }
+
+ return bss;
+}
+
+
+static struct wlantest_sta * ctrl_get_sta(struct wlantest *wt, int sock,
+ u8 *cmd, size_t clen,
+ struct wlantest_bss *bss)
+{
+ struct wlantest_sta *sta;
+ u8 *pos;
+ size_t len;
+
+ if (bss == NULL)
+ return NULL;
+
+ pos = attr_get(cmd, clen, WLANTEST_ATTR_STA_ADDR, &len);
+ if (pos == NULL || len != ETH_ALEN) {
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
+ return NULL;
+ }
+
+ sta = sta_find(bss, pos);
+ if (sta == NULL) {
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_FAILURE);
+ return NULL;
+ }
+
+ return sta;
+}
+
+
+static struct wlantest_sta * ctrl_get_sta2(struct wlantest *wt, int sock,
+ u8 *cmd, size_t clen,
+ struct wlantest_bss *bss)
+{
+ struct wlantest_sta *sta;
+ u8 *pos;
+ size_t len;
+
+ if (bss == NULL)
+ return NULL;
+
+ pos = attr_get(cmd, clen, WLANTEST_ATTR_STA2_ADDR, &len);
+ if (pos == NULL || len != ETH_ALEN) {
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
+ return NULL;
+ }
+
+ sta = sta_find(bss, pos);
+ if (sta == NULL) {
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_FAILURE);
+ return NULL;
+ }
+
+ return sta;
+}
+
+
static void ctrl_list_bss(struct wlantest *wt, int sock)
{
u8 buf[WLANTEST_CTRL_MAX_RESP_LEN], *pos, *len;
static void ctrl_list_sta(struct wlantest *wt, int sock, u8 *cmd, size_t clen)
{
u8 buf[WLANTEST_CTRL_MAX_RESP_LEN], *pos, *len;
- u8 *bssid;
- size_t bssid_len;
struct wlantest_bss *bss;
struct wlantest_sta *sta;
- bssid = attr_get(cmd, clen, WLANTEST_ATTR_BSSID, &bssid_len);
- if (bssid == NULL || bssid_len != ETH_ALEN) {
- ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
+ bss = ctrl_get_bss(wt, sock, cmd, clen);
+ if (bss == NULL)
return;
- }
-
- bss = bss_get(wt, bssid);
- if (bss == NULL) {
- ctrl_send_simple(wt, sock, WLANTEST_CTRL_FAILURE);
- return;
- }
pos = buf;
WPA_PUT_BE32(pos, WLANTEST_CTRL_SUCCESS);
static void ctrl_clear_sta_counters(struct wlantest *wt, int sock, u8 *cmd,
size_t clen)
{
- u8 *addr;
- size_t addr_len;
struct wlantest_bss *bss;
struct wlantest_sta *sta;
- addr = attr_get(cmd, clen, WLANTEST_ATTR_BSSID, &addr_len);
- if (addr == NULL || addr_len != ETH_ALEN) {
- ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
- return;
- }
-
- bss = bss_get(wt, addr);
- if (bss == NULL) {
- ctrl_send_simple(wt, sock, WLANTEST_CTRL_FAILURE);
- return;
- }
-
- addr = attr_get(cmd, clen, WLANTEST_ATTR_STA_ADDR, &addr_len);
- if (addr == NULL || addr_len != ETH_ALEN) {
- ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
- return;
- }
-
- sta = sta_get(bss, addr);
+ bss = ctrl_get_bss(wt, sock, cmd, clen);
+ sta = ctrl_get_sta(wt, sock, cmd, clen, bss);
if (sta == NULL) {
ctrl_send_simple(wt, sock, WLANTEST_CTRL_FAILURE);
return;
}
os_memset(sta->counters, 0, sizeof(sta->counters));
+ os_memset(sta->tx_tid, 0, sizeof(sta->tx_tid));
+ os_memset(sta->rx_tid, 0, sizeof(sta->rx_tid));
ctrl_send_simple(wt, sock, WLANTEST_CTRL_SUCCESS);
}
static void ctrl_clear_bss_counters(struct wlantest *wt, int sock, u8 *cmd,
size_t clen)
{
- u8 *addr;
- size_t addr_len;
struct wlantest_bss *bss;
- addr = attr_get(cmd, clen, WLANTEST_ATTR_BSSID, &addr_len);
- if (addr == NULL || addr_len != ETH_ALEN) {
- ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
+ bss = ctrl_get_bss(wt, sock, cmd, clen);
+ if (bss == NULL) {
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_FAILURE);
return;
}
- bss = bss_get(wt, addr);
- if (bss == NULL) {
+ os_memset(bss->counters, 0, sizeof(bss->counters));
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_SUCCESS);
+}
+
+
+static void ctrl_clear_tdls_counters(struct wlantest *wt, int sock, u8 *cmd,
+ size_t clen)
+{
+ struct wlantest_bss *bss;
+ struct wlantest_sta *sta;
+ struct wlantest_sta *sta2;
+ struct wlantest_tdls *tdls;
+
+ bss = ctrl_get_bss(wt, sock, cmd, clen);
+ sta = ctrl_get_sta(wt, sock, cmd, clen, bss);
+ sta2 = ctrl_get_sta2(wt, sock, cmd, clen, bss);
+ if (sta == NULL || sta2 == NULL) {
ctrl_send_simple(wt, sock, WLANTEST_CTRL_FAILURE);
return;
}
- os_memset(bss->counters, 0, sizeof(bss->counters));
+ dl_list_for_each(tdls, &bss->tdls, struct wlantest_tdls, list) {
+ if ((tdls->init == sta && tdls->resp == sta2) ||
+ (tdls->init == sta2 && tdls->resp == sta))
+ os_memset(tdls->counters, 0, sizeof(tdls->counters));
+ }
ctrl_send_simple(wt, sock, WLANTEST_CTRL_SUCCESS);
}
u32 counter;
u8 buf[4 + 12], *end, *pos;
- addr = attr_get(cmd, clen, WLANTEST_ATTR_BSSID, &addr_len);
- if (addr == NULL || addr_len != ETH_ALEN) {
- ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
- return;
- }
-
- bss = bss_get(wt, addr);
- if (bss == NULL) {
- ctrl_send_simple(wt, sock, WLANTEST_CTRL_FAILURE);
- return;
- }
-
- addr = attr_get(cmd, clen, WLANTEST_ATTR_STA_ADDR, &addr_len);
- if (addr == NULL || addr_len != ETH_ALEN) {
- ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
- return;
- }
-
- sta = sta_get(bss, addr);
- if (sta == NULL) {
- ctrl_send_simple(wt, sock, WLANTEST_CTRL_FAILURE);
+ bss = ctrl_get_bss(wt, sock, cmd, clen);
+ sta = ctrl_get_sta(wt, sock, cmd, clen, bss);
+ if (sta == NULL)
return;
- }
addr = attr_get(cmd, clen, WLANTEST_ATTR_STA_COUNTER, &addr_len);
if (addr == NULL || addr_len != 4) {
u32 counter;
u8 buf[4 + 12], *end, *pos;
- addr = attr_get(cmd, clen, WLANTEST_ATTR_BSSID, &addr_len);
- if (addr == NULL || addr_len != ETH_ALEN) {
+ bss = ctrl_get_bss(wt, sock, cmd, clen);
+ if (bss == NULL)
+ return;
+
+ addr = attr_get(cmd, clen, WLANTEST_ATTR_BSS_COUNTER, &addr_len);
+ if (addr == NULL || addr_len != 4) {
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
+ return;
+ }
+ counter = WPA_GET_BE32(addr);
+ if (counter >= NUM_WLANTEST_BSS_COUNTER) {
ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
return;
}
- bss = bss_get(wt, addr);
- if (bss == NULL) {
+ pos = buf;
+ end = buf + sizeof(buf);
+ WPA_PUT_BE32(pos, WLANTEST_CTRL_SUCCESS);
+ pos += 4;
+ pos = attr_add_be32(pos, end, WLANTEST_ATTR_COUNTER,
+ bss->counters[counter]);
+ ctrl_send(wt, sock, buf, pos - buf);
+}
+
+
+static void ctrl_get_tdls_counter(struct wlantest *wt, int sock, u8 *cmd,
+ size_t clen)
+{
+ u8 *addr;
+ size_t addr_len;
+ struct wlantest_bss *bss;
+ struct wlantest_sta *sta;
+ struct wlantest_sta *sta2;
+ struct wlantest_tdls *tdls;
+ u32 counter;
+ u8 buf[4 + 12], *end, *pos;
+ int found = 0;
+
+ bss = ctrl_get_bss(wt, sock, cmd, clen);
+ sta = ctrl_get_sta(wt, sock, cmd, clen, bss);
+ sta2 = ctrl_get_sta2(wt, sock, cmd, clen, bss);
+ if (sta == NULL || sta2 == NULL) {
ctrl_send_simple(wt, sock, WLANTEST_CTRL_FAILURE);
return;
}
- addr = attr_get(cmd, clen, WLANTEST_ATTR_BSS_COUNTER, &addr_len);
+ addr = attr_get(cmd, clen, WLANTEST_ATTR_TDLS_COUNTER, &addr_len);
if (addr == NULL || addr_len != 4) {
ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
return;
}
counter = WPA_GET_BE32(addr);
- if (counter >= NUM_WLANTEST_BSS_COUNTER) {
+ if (counter >= NUM_WLANTEST_TDLS_COUNTER) {
ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
return;
}
+ dl_list_for_each(tdls, &bss->tdls, struct wlantest_tdls, list) {
+ if (tdls->init == sta && tdls->resp == sta2) {
+ found = 1;
+ break;
+ }
+ }
+
+ if (!found) {
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_FAILURE);
+ return;
+ }
+
pos = buf;
end = buf + sizeof(buf);
WPA_PUT_BE32(pos, WLANTEST_CTRL_SUCCESS);
pos += 4;
pos = attr_add_be32(pos, end, WLANTEST_ATTR_COUNTER,
- bss->counters[counter]);
+ tdls->counters[counter]);
ctrl_send(wt, sock, buf, pos - buf);
}
return;
}
- bss = bss_get(wt, bssid);
+ bss = bss_find(wt, bssid);
if (bss == NULL) {
wpa_printf(MSG_INFO, "BSS not found for inject command");
ctrl_send_simple(wt, sock, WLANTEST_CTRL_FAILURE);
return;
} sta = NULL;
} else {
- sta = sta_get(bss, sta_addr);
+ sta = sta_find(bss, sta_addr);
if (sta == NULL) {
wpa_printf(MSG_INFO, "Station not found for inject "
"command");
u8 *bssid;
passphrase = attr_get(cmd, clen, WLANTEST_ATTR_PASSPHRASE, &len);
- if (passphrase == NULL || len < 8 || len > 63) {
+ if (passphrase == NULL) {
+ u8 *wepkey;
+ char *key;
+ enum wlantest_ctrl_cmd res;
+
+ wepkey = attr_get(cmd, clen, WLANTEST_ATTR_WEPKEY, &len);
+ if (wepkey == NULL) {
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
+ return;
+ }
+ key = os_zalloc(len + 1);
+ if (key == NULL) {
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_FAILURE);
+ return;
+ }
+ os_memcpy(key, wepkey, len);
+ if (add_wep(wt, key) < 0)
+ res = WLANTEST_CTRL_FAILURE;
+ else
+ res = WLANTEST_CTRL_SUCCESS;
+ os_free(key);
+ ctrl_send_simple(wt, sock, res);
+ return;
+ }
+
+ if (len < 8 || len > 63) {
ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
return;
}
}
}
- if (p)
+ if (p) {
+ struct wlantest_bss *bss;
dl_list_add(&wt->passphrase, &p->list);
+ dl_list_for_each(bss, &wt->bss, struct wlantest_bss, list) {
+ if (bssid &&
+ os_memcmp(p->bssid, bss->bssid, ETH_ALEN) != 0)
+ continue;
+ bss_add_pmk_from_passphrase(bss, p->passphrase);
+ }
+ }
ctrl_send_simple(wt, sock, WLANTEST_CTRL_SUCCESS);
}
+static void info_print_proto(char *buf, size_t len, int proto)
+{
+ char *pos, *end;
+
+ if (proto == 0) {
+ os_snprintf(buf, len, "OPEN");
+ return;
+ }
+
+ pos = buf;
+ end = buf + len;
+
+ if (proto & WPA_PROTO_WPA)
+ pos += os_snprintf(pos, end - pos, "%sWPA",
+ pos == buf ? "" : " ");
+ if (proto & WPA_PROTO_RSN)
+ pos += os_snprintf(pos, end - pos, "%sWPA2",
+ pos == buf ? "" : " ");
+}
+
+
+static void info_print_cipher(char *buf, size_t len, int cipher)
+{
+ char *pos, *end;
+
+ if (cipher == 0) {
+ os_snprintf(buf, len, "N/A");
+ return;
+ }
+
+ pos = buf;
+ end = buf + len;
+
+ if (cipher & WPA_CIPHER_NONE)
+ pos += os_snprintf(pos, end - pos, "%sNONE",
+ pos == buf ? "" : " ");
+ if (cipher & WPA_CIPHER_WEP40)
+ pos += os_snprintf(pos, end - pos, "%sWEP40",
+ pos == buf ? "" : " ");
+ if (cipher & WPA_CIPHER_WEP104)
+ pos += os_snprintf(pos, end - pos, "%sWEP104",
+ pos == buf ? "" : " ");
+ if (cipher & WPA_CIPHER_TKIP)
+ pos += os_snprintf(pos, end - pos, "%sTKIP",
+ pos == buf ? "" : " ");
+ if (cipher & WPA_CIPHER_CCMP)
+ pos += os_snprintf(pos, end - pos, "%sCCMP",
+ pos == buf ? "" : " ");
+ if (cipher & WPA_CIPHER_AES_128_CMAC)
+ pos += os_snprintf(pos, end - pos, "%sBIP",
+ pos == buf ? "" : " ");
+ if (cipher & WPA_CIPHER_BIP_GMAC_128)
+ pos += os_snprintf(pos, end - pos, "%sBIP-GMAC-128",
+ pos == buf ? "" : " ");
+ if (cipher & WPA_CIPHER_BIP_GMAC_256)
+ pos += os_snprintf(pos, end - pos, "%sBIP-GMAC-256",
+ pos == buf ? "" : " ");
+ if (cipher & WPA_CIPHER_BIP_CMAC_256)
+ pos += os_snprintf(pos, end - pos, "%sBIP-CMAC-256",
+ pos == buf ? "" : " ");
+}
+
+
+static void info_print_key_mgmt(char *buf, size_t len, int key_mgmt)
+{
+ char *pos, *end;
+
+ if (key_mgmt == 0) {
+ os_snprintf(buf, len, "N/A");
+ return;
+ }
+
+ pos = buf;
+ end = buf + len;
+
+ if (key_mgmt & WPA_KEY_MGMT_IEEE8021X)
+ pos += os_snprintf(pos, end - pos, "%sEAP",
+ pos == buf ? "" : " ");
+ if (key_mgmt & WPA_KEY_MGMT_PSK)
+ pos += os_snprintf(pos, end - pos, "%sPSK",
+ pos == buf ? "" : " ");
+ if (key_mgmt & WPA_KEY_MGMT_WPA_NONE)
+ pos += os_snprintf(pos, end - pos, "%sWPA-NONE",
+ pos == buf ? "" : " ");
+ if (key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X)
+ pos += os_snprintf(pos, end - pos, "%sFT-EAP",
+ pos == buf ? "" : " ");
+ if (key_mgmt & WPA_KEY_MGMT_FT_PSK)
+ pos += os_snprintf(pos, end - pos, "%sFT-PSK",
+ pos == buf ? "" : " ");
+ if (key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256)
+ pos += os_snprintf(pos, end - pos, "%sEAP-SHA256",
+ pos == buf ? "" : " ");
+ if (key_mgmt & WPA_KEY_MGMT_PSK_SHA256)
+ pos += os_snprintf(pos, end - pos, "%sPSK-SHA256",
+ pos == buf ? "" : " ");
+ if (key_mgmt & WPA_KEY_MGMT_IEEE8021X_SUITE_B)
+ pos += os_snprintf(pos, end - pos, "%sEAP-SUITE-B",
+ pos == buf ? "" : " ");
+ if (key_mgmt & WPA_KEY_MGMT_IEEE8021X_SUITE_B_192)
+ pos += os_snprintf(pos, end - pos, "%sEAP-SUITE-B-192",
+ pos == buf ? "" : " ");
+}
+
+
+static void info_print_rsn_capab(char *buf, size_t len, int capab)
+{
+ char *pos, *end;
+
+ pos = buf;
+ end = buf + len;
+
+ if (capab & WPA_CAPABILITY_PREAUTH)
+ pos += os_snprintf(pos, end - pos, "%sPREAUTH",
+ pos == buf ? "" : " ");
+ if (capab & WPA_CAPABILITY_NO_PAIRWISE)
+ pos += os_snprintf(pos, end - pos, "%sNO_PAIRWISE",
+ pos == buf ? "" : " ");
+ if (capab & WPA_CAPABILITY_MFPR)
+ pos += os_snprintf(pos, end - pos, "%sMFPR",
+ pos == buf ? "" : " ");
+ if (capab & WPA_CAPABILITY_MFPC)
+ pos += os_snprintf(pos, end - pos, "%sMFPC",
+ pos == buf ? "" : " ");
+ if (capab & WPA_CAPABILITY_PEERKEY_ENABLED)
+ pos += os_snprintf(pos, end - pos, "%sPEERKEY",
+ pos == buf ? "" : " ");
+}
+
+
+static void info_print_state(char *buf, size_t len, int state)
+{
+ switch (state) {
+ case STATE1:
+ os_strlcpy(buf, "NOT-AUTH", len);
+ break;
+ case STATE2:
+ os_strlcpy(buf, "AUTH", len);
+ break;
+ case STATE3:
+ os_strlcpy(buf, "AUTH+ASSOC", len);
+ break;
+ }
+}
+
+
+static void info_print_gtk(char *buf, size_t len, struct wlantest_sta *sta)
+{
+ size_t pos;
+
+ pos = os_snprintf(buf, len, "IDX=%d,GTK=", sta->gtk_idx);
+ wpa_snprintf_hex(buf + pos, len - pos, sta->gtk, sta->gtk_len);
+}
+
+
+static void ctrl_info_sta(struct wlantest *wt, int sock, u8 *cmd, size_t clen)
+{
+ u8 *addr;
+ size_t addr_len;
+ struct wlantest_bss *bss;
+ struct wlantest_sta *sta;
+ enum wlantest_sta_info info;
+ u8 buf[4 + 108], *end, *pos;
+ char resp[100];
+
+ bss = ctrl_get_bss(wt, sock, cmd, clen);
+ sta = ctrl_get_sta(wt, sock, cmd, clen, bss);
+ if (sta == NULL)
+ return;
+
+ addr = attr_get(cmd, clen, WLANTEST_ATTR_STA_INFO, &addr_len);
+ if (addr == NULL || addr_len != 4) {
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
+ return;
+ }
+ info = WPA_GET_BE32(addr);
+
+ resp[0] = '\0';
+ switch (info) {
+ case WLANTEST_STA_INFO_PROTO:
+ info_print_proto(resp, sizeof(resp), sta->proto);
+ break;
+ case WLANTEST_STA_INFO_PAIRWISE:
+ info_print_cipher(resp, sizeof(resp), sta->pairwise_cipher);
+ break;
+ case WLANTEST_STA_INFO_KEY_MGMT:
+ info_print_key_mgmt(resp, sizeof(resp), sta->key_mgmt);
+ break;
+ case WLANTEST_STA_INFO_RSN_CAPAB:
+ info_print_rsn_capab(resp, sizeof(resp), sta->rsn_capab);
+ break;
+ case WLANTEST_STA_INFO_STATE:
+ info_print_state(resp, sizeof(resp), sta->state);
+ break;
+ case WLANTEST_STA_INFO_GTK:
+ info_print_gtk(resp, sizeof(resp), sta);
+ break;
+ default:
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
+ return;
+ }
+
+ pos = buf;
+ end = buf + sizeof(buf);
+ WPA_PUT_BE32(pos, WLANTEST_CTRL_SUCCESS);
+ pos += 4;
+ pos = attr_add_str(pos, end, WLANTEST_ATTR_INFO, resp);
+ ctrl_send(wt, sock, buf, pos - buf);
+}
+
+
+static void ctrl_info_bss(struct wlantest *wt, int sock, u8 *cmd, size_t clen)
+{
+ u8 *addr;
+ size_t addr_len;
+ struct wlantest_bss *bss;
+ enum wlantest_bss_info info;
+ u8 buf[4 + 108], *end, *pos;
+ char resp[100];
+
+ bss = ctrl_get_bss(wt, sock, cmd, clen);
+ if (bss == NULL)
+ return;
+
+ addr = attr_get(cmd, clen, WLANTEST_ATTR_BSS_INFO, &addr_len);
+ if (addr == NULL || addr_len != 4) {
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
+ return;
+ }
+ info = WPA_GET_BE32(addr);
+
+ resp[0] = '\0';
+ switch (info) {
+ case WLANTEST_BSS_INFO_PROTO:
+ info_print_proto(resp, sizeof(resp), bss->proto);
+ break;
+ case WLANTEST_BSS_INFO_PAIRWISE:
+ info_print_cipher(resp, sizeof(resp), bss->pairwise_cipher);
+ break;
+ case WLANTEST_BSS_INFO_GROUP:
+ info_print_cipher(resp, sizeof(resp), bss->group_cipher);
+ break;
+ case WLANTEST_BSS_INFO_GROUP_MGMT:
+ info_print_cipher(resp, sizeof(resp), bss->mgmt_group_cipher);
+ break;
+ case WLANTEST_BSS_INFO_KEY_MGMT:
+ info_print_key_mgmt(resp, sizeof(resp), bss->key_mgmt);
+ break;
+ case WLANTEST_BSS_INFO_RSN_CAPAB:
+ info_print_rsn_capab(resp, sizeof(resp), bss->rsn_capab);
+ break;
+ default:
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
+ return;
+ }
+
+ pos = buf;
+ end = buf + sizeof(buf);
+ WPA_PUT_BE32(pos, WLANTEST_CTRL_SUCCESS);
+ pos += 4;
+ pos = attr_add_str(pos, end, WLANTEST_ATTR_INFO, resp);
+ ctrl_send(wt, sock, buf, pos - buf);
+}
+
+
+static void ctrl_send_(struct wlantest *wt, int sock, u8 *cmd, size_t clen)
+{
+ struct wlantest_bss *bss;
+ struct wlantest_sta *sta;
+ u8 *bssid, *sta_addr;
+ int prot;
+ u8 *frame;
+ size_t frame_len;
+ int ret = 0;
+ struct ieee80211_hdr *hdr;
+ u16 fc;
+
+ frame = attr_get(cmd, clen, WLANTEST_ATTR_FRAME, &frame_len);
+ prot = attr_get_int(cmd, clen, WLANTEST_ATTR_INJECT_PROTECTION);
+ if (frame == NULL || frame_len < 24 || prot < 0) {
+ wpa_printf(MSG_INFO, "Invalid send command parameters");
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
+ return;
+ }
+
+ hdr = (struct ieee80211_hdr *) frame;
+ fc = le_to_host16(hdr->frame_control);
+ switch (WLAN_FC_GET_TYPE(fc)) {
+ case WLAN_FC_TYPE_MGMT:
+ bssid = hdr->addr3;
+ if (os_memcmp(hdr->addr2, hdr->addr3, ETH_ALEN) == 0)
+ sta_addr = hdr->addr1;
+ else
+ sta_addr = hdr->addr2;
+ break;
+ case WLAN_FC_TYPE_DATA:
+ switch (fc & (WLAN_FC_TODS | WLAN_FC_FROMDS)) {
+ case 0:
+ bssid = hdr->addr3;
+ sta_addr = hdr->addr2;
+ break;
+ case WLAN_FC_TODS:
+ bssid = hdr->addr1;
+ sta_addr = hdr->addr2;
+ break;
+ case WLAN_FC_FROMDS:
+ bssid = hdr->addr2;
+ sta_addr = hdr->addr1;
+ break;
+ default:
+ wpa_printf(MSG_INFO, "Unsupported inject frame");
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_FAILURE);
+ return;
+ }
+ break;
+ default:
+ wpa_printf(MSG_INFO, "Unsupported inject frame");
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_FAILURE);
+ return;
+ }
+
+ bss = bss_find(wt, bssid);
+ if (bss == NULL && prot != WLANTEST_INJECT_UNPROTECTED) {
+ wpa_printf(MSG_INFO, "Unknown BSSID");
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_FAILURE);
+ return;
+ }
+
+ if (bss)
+ sta = sta_find(bss, sta_addr);
+ else
+ sta = NULL;
+ if (sta == NULL && prot != WLANTEST_INJECT_UNPROTECTED) {
+ wpa_printf(MSG_INFO, "Unknown STA address");
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_FAILURE);
+ return;
+ }
+
+ ret = wlantest_inject(wt, bss, sta, frame, frame_len, prot);
+
+ if (ret)
+ wpa_printf(MSG_INFO, "Failed to inject frame");
+ else
+ wpa_printf(MSG_INFO, "Frame injected successfully");
+ ctrl_send_simple(wt, sock, ret == 0 ? WLANTEST_CTRL_SUCCESS :
+ WLANTEST_CTRL_FAILURE);
+}
+
+
+static void ctrl_relog(struct wlantest *wt, int sock)
+{
+ int res = wlantest_relog(wt);
+ ctrl_send_simple(wt, sock, res ? WLANTEST_CTRL_FAILURE :
+ WLANTEST_CTRL_SUCCESS);
+}
+
+
+static void ctrl_get_tx_tid(struct wlantest *wt, int sock, u8 *cmd, size_t clen)
+{
+ u8 *addr;
+ size_t addr_len;
+ struct wlantest_bss *bss;
+ struct wlantest_sta *sta;
+ u32 counter;
+ u8 buf[4 + 12], *end, *pos;
+
+ bss = ctrl_get_bss(wt, sock, cmd, clen);
+ sta = ctrl_get_sta(wt, sock, cmd, clen, bss);
+ if (sta == NULL)
+ return;
+
+ addr = attr_get(cmd, clen, WLANTEST_ATTR_TID, &addr_len);
+ if (addr == NULL || addr_len != 4) {
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
+ return;
+ }
+ counter = WPA_GET_BE32(addr);
+ if (counter >= 16 + 1) {
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
+ return;
+ }
+
+ pos = buf;
+ end = buf + sizeof(buf);
+ WPA_PUT_BE32(pos, WLANTEST_CTRL_SUCCESS);
+ pos += 4;
+ pos = attr_add_be32(pos, end, WLANTEST_ATTR_COUNTER,
+ sta->tx_tid[counter]);
+ ctrl_send(wt, sock, buf, pos - buf);
+}
+
+
+static void ctrl_get_rx_tid(struct wlantest *wt, int sock, u8 *cmd, size_t clen)
+{
+ u8 *addr;
+ size_t addr_len;
+ struct wlantest_bss *bss;
+ struct wlantest_sta *sta;
+ u32 counter;
+ u8 buf[4 + 12], *end, *pos;
+
+ bss = ctrl_get_bss(wt, sock, cmd, clen);
+ sta = ctrl_get_sta(wt, sock, cmd, clen, bss);
+ if (sta == NULL)
+ return;
+
+ addr = attr_get(cmd, clen, WLANTEST_ATTR_TID, &addr_len);
+ if (addr == NULL || addr_len != 4) {
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
+ return;
+ }
+ counter = WPA_GET_BE32(addr);
+ if (counter >= 16 + 1) {
+ ctrl_send_simple(wt, sock, WLANTEST_CTRL_INVALID_CMD);
+ return;
+ }
+
+ pos = buf;
+ end = buf + sizeof(buf);
+ WPA_PUT_BE32(pos, WLANTEST_CTRL_SUCCESS);
+ pos += 4;
+ pos = attr_add_be32(pos, end, WLANTEST_ATTR_COUNTER,
+ sta->rx_tid[counter]);
+ ctrl_send(wt, sock, buf, pos - buf);
+}
+
+
static void ctrl_read(int sock, void *eloop_ctx, void *sock_ctx)
{
struct wlantest *wt = eloop_ctx;
case WLANTEST_CTRL_CLEAR_BSS_COUNTERS:
ctrl_clear_bss_counters(wt, sock, buf + 4, len - 4);
break;
+ case WLANTEST_CTRL_CLEAR_TDLS_COUNTERS:
+ ctrl_clear_tdls_counters(wt, sock, buf + 4, len - 4);
+ break;
case WLANTEST_CTRL_GET_STA_COUNTER:
ctrl_get_sta_counter(wt, sock, buf + 4, len - 4);
break;
case WLANTEST_CTRL_GET_BSS_COUNTER:
ctrl_get_bss_counter(wt, sock, buf + 4, len - 4);
break;
+ case WLANTEST_CTRL_GET_TDLS_COUNTER:
+ ctrl_get_tdls_counter(wt, sock, buf + 4, len - 4);
+ break;
case WLANTEST_CTRL_INJECT:
ctrl_inject(wt, sock, buf + 4, len - 4);
break;
case WLANTEST_CTRL_ADD_PASSPHRASE:
ctrl_add_passphrase(wt, sock, buf + 4, len - 4);
break;
+ case WLANTEST_CTRL_INFO_STA:
+ ctrl_info_sta(wt, sock, buf + 4, len - 4);
+ break;
+ case WLANTEST_CTRL_INFO_BSS:
+ ctrl_info_bss(wt, sock, buf + 4, len - 4);
+ break;
+ case WLANTEST_CTRL_SEND:
+ ctrl_send_(wt, sock, buf + 4, len - 4);
+ break;
+ case WLANTEST_CTRL_RELOG:
+ ctrl_relog(wt, sock);
+ break;
+ case WLANTEST_CTRL_GET_TX_TID:
+ ctrl_get_tx_tid(wt, sock, buf + 4, len - 4);
+ break;
+ case WLANTEST_CTRL_GET_RX_TID:
+ ctrl_get_rx_tid(wt, sock, buf + 4, len - 4);
+ break;
default:
ctrl_send_simple(wt, sock, WLANTEST_CTRL_UNKNOWN_CMD);
break;