1125 lines
27 KiB
C
1125 lines
27 KiB
C
/*
|
|
* Sigma Control API DUT (wlantest)
|
|
* Copyright (c) 2010-2011, Atheros Communications, Inc.
|
|
* Copyright (c) 2011-2013, Qualcomm Atheros, Inc.
|
|
* All Rights Reserved.
|
|
* Licensed under the Clear BSD license. See README for more details.
|
|
*/
|
|
|
|
#include "sigma_dut.h"
|
|
#include <sys/un.h>
|
|
#include "wlantest_ctrl.h"
|
|
|
|
|
|
#ifndef ETH_ALEN
|
|
#define ETH_ALEN 6
|
|
#endif
|
|
|
|
int hwaddr_aton(const char *txt, unsigned char *addr);
|
|
|
|
|
|
static u8 * attr_get(u8 *buf, size_t buflen, enum wlantest_ctrl_attr attr,
|
|
size_t *len)
|
|
{
|
|
u8 *pos = buf;
|
|
|
|
while (pos + 8 <= buf + buflen) {
|
|
enum wlantest_ctrl_attr a;
|
|
size_t alen;
|
|
a = WPA_GET_BE32(pos);
|
|
pos += 4;
|
|
alen = WPA_GET_BE32(pos);
|
|
pos += 4;
|
|
if (pos + alen > buf + buflen)
|
|
return NULL;
|
|
if (a == attr) {
|
|
*len = alen;
|
|
return pos;
|
|
}
|
|
pos += alen;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static u8 * attr_hdr_add(u8 *pos, u8 *end, enum wlantest_ctrl_attr attr,
|
|
size_t len)
|
|
{
|
|
if (pos == NULL || end - pos < (int) (8 + len))
|
|
return NULL;
|
|
WPA_PUT_BE32(pos, attr);
|
|
pos += 4;
|
|
WPA_PUT_BE32(pos, len);
|
|
pos += 4;
|
|
return pos;
|
|
}
|
|
|
|
|
|
static u8 * attr_add_str(u8 *pos, u8 *end, enum wlantest_ctrl_attr attr,
|
|
const char *str)
|
|
{
|
|
size_t len = strlen(str);
|
|
|
|
if (pos == NULL || end - pos < (int) (8 + len))
|
|
return NULL;
|
|
WPA_PUT_BE32(pos, attr);
|
|
pos += 4;
|
|
WPA_PUT_BE32(pos, len);
|
|
pos += 4;
|
|
memcpy(pos, str, len);
|
|
pos += len;
|
|
return pos;
|
|
}
|
|
|
|
|
|
static u8 * attr_add_be32(u8 *pos, u8 *end, enum wlantest_ctrl_attr attr,
|
|
u32 val)
|
|
{
|
|
if (pos == NULL || end - pos < 12)
|
|
return NULL;
|
|
WPA_PUT_BE32(pos, attr);
|
|
pos += 4;
|
|
WPA_PUT_BE32(pos, 4);
|
|
pos += 4;
|
|
WPA_PUT_BE32(pos, val);
|
|
pos += 4;
|
|
return pos;
|
|
}
|
|
|
|
|
|
static int open_wlantest(void)
|
|
{
|
|
int s;
|
|
struct sockaddr_un addr;
|
|
|
|
s = socket(AF_UNIX, SOCK_SEQPACKET, 0);
|
|
if (s < 0) {
|
|
perror("socket");
|
|
return -1;
|
|
}
|
|
|
|
memset(&addr, 0, sizeof(addr));
|
|
addr.sun_family = AF_UNIX;
|
|
strncpy(addr.sun_path + 1, WLANTEST_SOCK_NAME,
|
|
sizeof(addr.sun_path) - 1);
|
|
if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
|
|
perror("connect");
|
|
close(s);
|
|
return -1;
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
|
|
static int cmd_send_and_recv(int s, const u8 *cmd, size_t cmd_len,
|
|
u8 *resp, size_t max_resp_len)
|
|
{
|
|
int res;
|
|
enum wlantest_ctrl_cmd cmd_resp;
|
|
|
|
if (send(s, cmd, cmd_len, 0) < 0)
|
|
return -1;
|
|
res = recv(s, resp, max_resp_len, 0);
|
|
if (res < 4)
|
|
return -1;
|
|
|
|
cmd_resp = WPA_GET_BE32(resp);
|
|
if (cmd_resp == WLANTEST_CTRL_SUCCESS)
|
|
return res;
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
static int cmd_simple(int s, enum wlantest_ctrl_cmd cmd)
|
|
{
|
|
u8 buf[4];
|
|
int res;
|
|
WPA_PUT_BE32(buf, cmd);
|
|
res = cmd_send_and_recv(s, buf, sizeof(buf), buf, sizeof(buf));
|
|
return res < 0 ? -1 : 0;
|
|
}
|
|
|
|
|
|
static int run_wlantest_simple(struct sigma_dut *dut, struct sigma_conn *conn,
|
|
enum wlantest_ctrl_cmd cmd)
|
|
{
|
|
int s, ret;
|
|
|
|
s = open_wlantest();
|
|
if (s < 0) {
|
|
send_resp(dut, conn, SIGMA_ERROR, "errorCode,wlantest not "
|
|
"available");
|
|
return 0;
|
|
}
|
|
|
|
ret = cmd_simple(s, cmd);
|
|
close(s);
|
|
|
|
return ret < 0 ? -2 : 1;
|
|
}
|
|
|
|
|
|
static int cmd_wlantest_version(struct sigma_dut *dut, struct sigma_conn *conn,
|
|
struct sigma_cmd *cmd)
|
|
{
|
|
int s;
|
|
u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
|
|
u8 buf[4];
|
|
char *version;
|
|
size_t len;
|
|
int rlen;
|
|
char *rbuf;
|
|
|
|
s = open_wlantest();
|
|
if (s < 0) {
|
|
send_resp(dut, conn, SIGMA_ERROR, "errorCode,wlantest not "
|
|
"available");
|
|
return 0;
|
|
}
|
|
|
|
WPA_PUT_BE32(buf, WLANTEST_CTRL_VERSION);
|
|
rlen = cmd_send_and_recv(s, buf, sizeof(buf), resp, sizeof(resp));
|
|
close(s);
|
|
if (rlen < 0)
|
|
return -2;
|
|
|
|
version = (char *) attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_VERSION,
|
|
&len);
|
|
if (version == NULL)
|
|
return -2;
|
|
|
|
rbuf = malloc(9 + len);
|
|
if (rbuf == NULL)
|
|
return -2;
|
|
memcpy(rbuf, "version,", 8);
|
|
memcpy(rbuf + 8, version, len);
|
|
rbuf[8 + len] = '\0';
|
|
send_resp(dut, conn, SIGMA_COMPLETE, rbuf);
|
|
free(rbuf);
|
|
return 0;
|
|
}
|
|
|
|
|
|
int cmd_wlantest_set_channel(struct sigma_dut *dut, struct sigma_conn *conn,
|
|
struct sigma_cmd *cmd)
|
|
{
|
|
char buf[100];
|
|
const char *chan;
|
|
|
|
if (dut->sniffer_ifname == NULL) {
|
|
send_resp(dut, conn, SIGMA_ERROR, "errorCode,Sniffer "
|
|
"interface not available");
|
|
return 0;
|
|
}
|
|
|
|
chan = get_param(cmd, "channel");
|
|
if (chan == NULL)
|
|
return -1;
|
|
|
|
snprintf(buf, sizeof(buf), "iw dev %s set type monitor",
|
|
dut->sniffer_ifname);
|
|
if (system(buf) != 0) {
|
|
snprintf(buf, sizeof(buf), "ifconfig %s down",
|
|
dut->sniffer_ifname);
|
|
if (system(buf) != 0) {
|
|
sigma_dut_print(dut, DUT_MSG_INFO,
|
|
"Failed to run '%s'", buf);
|
|
return -2;
|
|
}
|
|
|
|
snprintf(buf, sizeof(buf), "iw dev %s set type monitor",
|
|
dut->sniffer_ifname);
|
|
if (system(buf) != 0) {
|
|
sigma_dut_print(dut, DUT_MSG_INFO,
|
|
"Failed to run '%s'", buf);
|
|
return -2;
|
|
}
|
|
}
|
|
|
|
snprintf(buf, sizeof(buf), "iw dev %s set channel %d HT20",
|
|
dut->sniffer_ifname, atoi(chan));
|
|
if (system(buf) != 0) {
|
|
sigma_dut_print(dut, DUT_MSG_INFO, "Failed to run '%s'", buf);
|
|
return -2;
|
|
}
|
|
|
|
snprintf(buf, sizeof(buf), "ifconfig %s up", dut->sniffer_ifname);
|
|
if (system(buf) != 0) {
|
|
sigma_dut_print(dut, DUT_MSG_INFO, "Failed to run '%s'", buf);
|
|
return -2;
|
|
}
|
|
|
|
dut->mode = SIGMA_MODE_SNIFFER;
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
static int cmd_wlantest_flush(struct sigma_dut *dut, struct sigma_conn *conn,
|
|
struct sigma_cmd *cmd)
|
|
{
|
|
return run_wlantest_simple(dut, conn, WLANTEST_CTRL_FLUSH);
|
|
}
|
|
|
|
|
|
int cmd_wlantest_send_frame(struct sigma_dut *dut, struct sigma_conn *conn,
|
|
struct sigma_cmd *cmd)
|
|
{
|
|
u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
|
|
u8 buf[100], *end, *pos;
|
|
int rlen;
|
|
enum wlantest_inject_frame frame;
|
|
enum wlantest_inject_protection prot;
|
|
const char *val;
|
|
int s;
|
|
|
|
/* wlantest_send_frame,PMFFrameType,disassoc,PMFProtected,Unprotected,sender,AP,bssid,00:11:22:33:44:55,stationID,00:66:77:88:99:aa */
|
|
|
|
if (dut->mode == SIGMA_MODE_STATION) {
|
|
sigma_dut_print(dut, DUT_MSG_DEBUG, "Convert "
|
|
"wlantest_send_frame to sta_send_frame");
|
|
return cmd_sta_send_frame(dut, conn, cmd);
|
|
}
|
|
|
|
if (dut->mode == SIGMA_MODE_AP) {
|
|
sigma_dut_print(dut, DUT_MSG_DEBUG, "Convert "
|
|
"wlantest_send_frame to ap_send_frame");
|
|
return cmd_ap_send_frame(dut, conn, cmd);
|
|
}
|
|
|
|
pos = buf;
|
|
end = buf + sizeof(buf);
|
|
WPA_PUT_BE32(pos, WLANTEST_CTRL_INJECT);
|
|
pos += 4;
|
|
|
|
val = get_param(cmd, "Type");
|
|
if (val == NULL)
|
|
val = get_param(cmd, "PMFFrameType");
|
|
if (val == NULL)
|
|
return -1;
|
|
if (strcasecmp(val, "disassoc") == 0)
|
|
frame = WLANTEST_FRAME_DISASSOC;
|
|
else if (strcasecmp(val, "deauth") == 0)
|
|
frame = WLANTEST_FRAME_DEAUTH;
|
|
else if (strcasecmp(val, "saquery") == 0)
|
|
frame = WLANTEST_FRAME_SAQUERYREQ;
|
|
else if (strcasecmp(val, "auth") == 0)
|
|
frame = WLANTEST_FRAME_AUTH;
|
|
else if (strcasecmp(val, "assocreq") == 0)
|
|
frame = WLANTEST_FRAME_ASSOCREQ;
|
|
else if (strcasecmp(val, "reassocreq") == 0)
|
|
frame = WLANTEST_FRAME_REASSOCREQ;
|
|
else {
|
|
send_resp(dut, conn, SIGMA_ERROR, "errorCode,Unsupported "
|
|
"PMFFrameType");
|
|
return 0;
|
|
}
|
|
pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_FRAME, frame);
|
|
|
|
val = get_param(cmd, "Protected");
|
|
if (val == NULL)
|
|
val = get_param(cmd, "PMFProtected");
|
|
if (val == NULL)
|
|
return -1;
|
|
if (strcasecmp(val, "CorrectKey") == 0)
|
|
prot = WLANTEST_INJECT_PROTECTED;
|
|
else if (strcasecmp(val, "IncorrectKey") == 0)
|
|
prot = WLANTEST_INJECT_INCORRECT_KEY;
|
|
else if (strcasecmp(val, "Unprotected") == 0)
|
|
prot = WLANTEST_INJECT_UNPROTECTED;
|
|
else {
|
|
send_resp(dut, conn, SIGMA_ERROR, "errorCode,Unsupported "
|
|
"PMFProtected");
|
|
return 0;
|
|
}
|
|
pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_PROTECTION, prot);
|
|
|
|
val = get_param(cmd, "sender");
|
|
if (val == NULL)
|
|
return -1;
|
|
if (strcasecmp(val, "ap") == 0) {
|
|
pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_SENDER_AP,
|
|
1);
|
|
} else if (strcasecmp(val, "sta") == 0) {
|
|
pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_SENDER_AP,
|
|
0);
|
|
} else {
|
|
send_resp(dut, conn, SIGMA_ERROR, "errorCode,Unsupported "
|
|
"sender");
|
|
return 0;
|
|
}
|
|
|
|
val = get_param(cmd, "bssid");
|
|
if (val == NULL)
|
|
return -1;
|
|
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
|
|
if (hwaddr_aton(val, pos) < 0) {
|
|
send_resp(dut, conn, SIGMA_INVALID, "errorCode,Invalid bssid");
|
|
return 0;
|
|
}
|
|
pos += ETH_ALEN;
|
|
|
|
val = get_param(cmd, "stationID");
|
|
if (val == NULL)
|
|
return -1;
|
|
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
|
|
if (hwaddr_aton(val, pos) < 0) {
|
|
send_resp(dut, conn, SIGMA_INVALID,
|
|
"errorCode,Invalid stationID");
|
|
return 0;
|
|
}
|
|
pos += ETH_ALEN;
|
|
|
|
s = open_wlantest();
|
|
if (s < 0) {
|
|
send_resp(dut, conn, SIGMA_ERROR, "errorCode,wlantest not "
|
|
"available");
|
|
return 0;
|
|
}
|
|
rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
|
|
close(s);
|
|
if (rlen < 0)
|
|
return -2;
|
|
return 1;
|
|
}
|
|
|
|
|
|
static int cmd_wlantest_add_passphrase(struct sigma_dut *dut,
|
|
struct sigma_conn *conn,
|
|
struct sigma_cmd *cmd)
|
|
{
|
|
u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
|
|
u8 buf[100], *end, *pos;
|
|
int rlen;
|
|
const char *val;
|
|
int s;
|
|
|
|
pos = buf;
|
|
end = buf + sizeof(buf);
|
|
WPA_PUT_BE32(pos, WLANTEST_CTRL_ADD_PASSPHRASE);
|
|
pos += 4;
|
|
|
|
val = get_param(cmd, "passphrase");
|
|
if (val) {
|
|
if (strlen(val) < 8 || strlen(val) > 63)
|
|
return -1;
|
|
pos = attr_add_str(pos, end, WLANTEST_ATTR_PASSPHRASE, val);
|
|
} else {
|
|
val = get_param(cmd, "wepkey");
|
|
if (!val)
|
|
return -1;
|
|
pos = attr_add_str(pos, end, WLANTEST_ATTR_WEPKEY, val);
|
|
}
|
|
val = get_param(cmd, "bssid");
|
|
if (val) {
|
|
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
|
|
if (hwaddr_aton(val, pos) < 0) {
|
|
send_resp(dut, conn, SIGMA_INVALID,
|
|
"errorCode,Invalid bssid");
|
|
return 0;
|
|
}
|
|
pos += ETH_ALEN;
|
|
}
|
|
|
|
s = open_wlantest();
|
|
if (s < 0) {
|
|
send_resp(dut, conn, SIGMA_ERROR, "errorCode,wlantest not "
|
|
"available");
|
|
return 0;
|
|
}
|
|
rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
|
|
close(s);
|
|
if (rlen < 0)
|
|
return -2;
|
|
return 1;
|
|
}
|
|
|
|
|
|
static int cmd_wlantest_clear_sta_counters(struct sigma_dut *dut,
|
|
struct sigma_conn *conn,
|
|
struct sigma_cmd *cmd)
|
|
{
|
|
u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
|
|
u8 buf[100], *end, *pos;
|
|
int rlen;
|
|
const char *val;
|
|
int s;
|
|
|
|
pos = buf;
|
|
end = buf + sizeof(buf);
|
|
WPA_PUT_BE32(pos, WLANTEST_CTRL_CLEAR_STA_COUNTERS);
|
|
pos += 4;
|
|
|
|
val = get_param(cmd, "bssid");
|
|
if (val == NULL)
|
|
return -1;
|
|
if (val) {
|
|
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
|
|
if (hwaddr_aton(val, pos) < 0) {
|
|
send_resp(dut, conn, SIGMA_INVALID,
|
|
"errorCode,Invalid bssid");
|
|
return 0;
|
|
}
|
|
pos += ETH_ALEN;
|
|
}
|
|
|
|
val = get_param(cmd, "stationID");
|
|
if (val == NULL)
|
|
return -1;
|
|
if (val) {
|
|
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
|
|
if (hwaddr_aton(val, pos) < 0) {
|
|
send_resp(dut, conn, SIGMA_INVALID,
|
|
"errorCode,Invalid stationID");
|
|
return 0;
|
|
}
|
|
pos += ETH_ALEN;
|
|
}
|
|
|
|
s = open_wlantest();
|
|
if (s < 0) {
|
|
send_resp(dut, conn, SIGMA_ERROR, "errorCode,wlantest not "
|
|
"available");
|
|
return 0;
|
|
}
|
|
rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
|
|
close(s);
|
|
if (rlen < 0)
|
|
return -2;
|
|
return 1;
|
|
}
|
|
|
|
|
|
static int cmd_wlantest_clear_bss_counters(struct sigma_dut *dut,
|
|
struct sigma_conn *conn,
|
|
struct sigma_cmd *cmd)
|
|
{
|
|
u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
|
|
u8 buf[100], *end, *pos;
|
|
int rlen;
|
|
const char *val;
|
|
int s;
|
|
|
|
pos = buf;
|
|
end = buf + sizeof(buf);
|
|
WPA_PUT_BE32(pos, WLANTEST_CTRL_CLEAR_BSS_COUNTERS);
|
|
pos += 4;
|
|
|
|
val = get_param(cmd, "bssid");
|
|
if (val == NULL)
|
|
return -1;
|
|
if (val) {
|
|
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
|
|
if (hwaddr_aton(val, pos) < 0) {
|
|
send_resp(dut, conn, SIGMA_INVALID,
|
|
"errorCode,Invalid bssid");
|
|
return 0;
|
|
}
|
|
pos += ETH_ALEN;
|
|
}
|
|
|
|
s = open_wlantest();
|
|
if (s < 0) {
|
|
send_resp(dut, conn, SIGMA_ERROR, "errorCode,wlantest not "
|
|
"available");
|
|
return 0;
|
|
}
|
|
rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
|
|
close(s);
|
|
if (rlen < 0)
|
|
return -2;
|
|
return 1;
|
|
}
|
|
|
|
|
|
static int cmd_wlantest_clear_tdls_counters(struct sigma_dut *dut,
|
|
struct sigma_conn *conn,
|
|
struct sigma_cmd *cmd)
|
|
{
|
|
u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
|
|
u8 buf[100], *end, *pos;
|
|
int rlen;
|
|
const char *val;
|
|
int s;
|
|
|
|
pos = buf;
|
|
end = buf + sizeof(buf);
|
|
WPA_PUT_BE32(pos, WLANTEST_CTRL_CLEAR_TDLS_COUNTERS);
|
|
pos += 4;
|
|
|
|
val = get_param(cmd, "bssid");
|
|
if (val == NULL)
|
|
return -1;
|
|
if (val) {
|
|
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
|
|
if (hwaddr_aton(val, pos) < 0) {
|
|
send_resp(dut, conn, SIGMA_INVALID,
|
|
"errorCode,Invalid bssid");
|
|
return 0;
|
|
}
|
|
pos += ETH_ALEN;
|
|
}
|
|
|
|
val = get_param(cmd, "stationID");
|
|
if (val == NULL)
|
|
return -1;
|
|
if (val) {
|
|
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
|
|
if (hwaddr_aton(val, pos) < 0) {
|
|
send_resp(dut, conn, SIGMA_INVALID,
|
|
"errorCode,Invalid stationID");
|
|
return 0;
|
|
}
|
|
pos += ETH_ALEN;
|
|
}
|
|
|
|
val = get_param(cmd, "stationID2");
|
|
if (val == NULL)
|
|
return -1;
|
|
if (val) {
|
|
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA2_ADDR,
|
|
ETH_ALEN);
|
|
if (hwaddr_aton(val, pos) < 0) {
|
|
send_resp(dut, conn, SIGMA_INVALID,
|
|
"errorCode,Invalid stationID2");
|
|
return 0;
|
|
}
|
|
pos += ETH_ALEN;
|
|
}
|
|
|
|
s = open_wlantest();
|
|
if (s < 0) {
|
|
send_resp(dut, conn, SIGMA_ERROR, "errorCode,wlantest not "
|
|
"available");
|
|
return 0;
|
|
}
|
|
rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
|
|
close(s);
|
|
if (rlen < 0)
|
|
return -2;
|
|
return 1;
|
|
}
|
|
|
|
|
|
struct sta_counters {
|
|
const char *name;
|
|
enum wlantest_sta_counter num;
|
|
};
|
|
|
|
static const struct sta_counters sta_counters[] = {
|
|
{ "auth_tx", WLANTEST_STA_COUNTER_AUTH_TX },
|
|
{ "auth_rx", WLANTEST_STA_COUNTER_AUTH_RX },
|
|
{ "assocreq_tx", WLANTEST_STA_COUNTER_ASSOCREQ_TX },
|
|
{ "reassocreq_tx", WLANTEST_STA_COUNTER_REASSOCREQ_TX },
|
|
{ "ptk_learned", WLANTEST_STA_COUNTER_PTK_LEARNED },
|
|
{ "valid_deauth_tx", WLANTEST_STA_COUNTER_VALID_DEAUTH_TX },
|
|
{ "valid_deauth_rx", WLANTEST_STA_COUNTER_VALID_DEAUTH_RX },
|
|
{ "invalid_deauth_tx", WLANTEST_STA_COUNTER_INVALID_DEAUTH_TX },
|
|
{ "invalid_deauth_rx", WLANTEST_STA_COUNTER_INVALID_DEAUTH_RX },
|
|
{ "valid_disassoc_tx", WLANTEST_STA_COUNTER_VALID_DISASSOC_TX },
|
|
{ "valid_disassoc_rx", WLANTEST_STA_COUNTER_VALID_DISASSOC_RX },
|
|
{ "invalid_disassoc_tx", WLANTEST_STA_COUNTER_INVALID_DISASSOC_TX },
|
|
{ "invalid_disassoc_rx", WLANTEST_STA_COUNTER_INVALID_DISASSOC_RX },
|
|
{ "valid_saqueryreq_tx", WLANTEST_STA_COUNTER_VALID_SAQUERYREQ_TX },
|
|
{ "valid_saqueryreq_rx", WLANTEST_STA_COUNTER_VALID_SAQUERYREQ_RX },
|
|
{ "invalid_saqueryreq_tx",
|
|
WLANTEST_STA_COUNTER_INVALID_SAQUERYREQ_TX },
|
|
{ "invalid_saqueryreq_rx",
|
|
WLANTEST_STA_COUNTER_INVALID_SAQUERYREQ_RX },
|
|
{ "valid_saqueryresp_tx", WLANTEST_STA_COUNTER_VALID_SAQUERYRESP_TX },
|
|
{ "valid_saqueryresp_rx", WLANTEST_STA_COUNTER_VALID_SAQUERYRESP_RX },
|
|
{ "invalid_saqueryresp_tx",
|
|
WLANTEST_STA_COUNTER_INVALID_SAQUERYRESP_TX },
|
|
{ "invalid_saqueryresp_rx",
|
|
WLANTEST_STA_COUNTER_INVALID_SAQUERYRESP_RX },
|
|
{ "ping_ok", WLANTEST_STA_COUNTER_PING_OK },
|
|
{ "assocresp_comeback", WLANTEST_STA_COUNTER_ASSOCRESP_COMEBACK },
|
|
{ "reassocresp_comeback", WLANTEST_STA_COUNTER_REASSOCRESP_COMEBACK },
|
|
{ "ping_ok_first_assoc", WLANTEST_STA_COUNTER_PING_OK_FIRST_ASSOC },
|
|
{ "valid_deauth_rx_ack", WLANTEST_STA_COUNTER_VALID_DEAUTH_RX_ACK },
|
|
{ "valid_disassoc_rx_ack",
|
|
WLANTEST_STA_COUNTER_VALID_DISASSOC_RX_ACK },
|
|
{ "invalid_deauth_rx_ack",
|
|
WLANTEST_STA_COUNTER_INVALID_DEAUTH_RX_ACK },
|
|
{ "invalid_disassoc_rx_ack",
|
|
WLANTEST_STA_COUNTER_INVALID_DISASSOC_RX_ACK },
|
|
{ "deauth_rx_asleep", WLANTEST_STA_COUNTER_DEAUTH_RX_ASLEEP },
|
|
{ "deauth_rx_awake", WLANTEST_STA_COUNTER_DEAUTH_RX_AWAKE },
|
|
{ "disassoc_rx_asleep", WLANTEST_STA_COUNTER_DISASSOC_RX_ASLEEP },
|
|
{ "disassoc_rx_awake", WLANTEST_STA_COUNTER_DISASSOC_RX_AWAKE },
|
|
{ "prot_data_tx", WLANTEST_STA_COUNTER_PROT_DATA_TX },
|
|
{ "deauth_rx_rc6", WLANTEST_STA_COUNTER_DEAUTH_RX_RC6 },
|
|
{ "deauth_rx_rc7", WLANTEST_STA_COUNTER_DEAUTH_RX_RC7 },
|
|
{ "disassoc_rx_rc6", WLANTEST_STA_COUNTER_DISASSOC_RX_RC6 },
|
|
{ "disassoc_rx_rc7", WLANTEST_STA_COUNTER_DISASSOC_RX_RC7 },
|
|
{ NULL, 0 }
|
|
};
|
|
|
|
static int cmd_wlantest_get_sta_counter(struct sigma_dut *dut,
|
|
struct sigma_conn *conn,
|
|
struct sigma_cmd *cmd)
|
|
{
|
|
u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
|
|
u8 buf[100], *end, *pos;
|
|
int rlen;
|
|
const char *val;
|
|
int s, i;
|
|
char ret[100];
|
|
size_t len;
|
|
|
|
pos = buf;
|
|
end = buf + sizeof(buf);
|
|
WPA_PUT_BE32(pos, WLANTEST_CTRL_GET_STA_COUNTER);
|
|
pos += 4;
|
|
|
|
val = get_param(cmd, "bssid");
|
|
if (val == NULL)
|
|
return -1;
|
|
if (val) {
|
|
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
|
|
if (hwaddr_aton(val, pos) < 0) {
|
|
send_resp(dut, conn, SIGMA_INVALID,
|
|
"errorCode,Invalid bssid");
|
|
return 0;
|
|
}
|
|
pos += ETH_ALEN;
|
|
}
|
|
|
|
val = get_param(cmd, "stationID");
|
|
if (val == NULL)
|
|
return -1;
|
|
if (val) {
|
|
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
|
|
if (hwaddr_aton(val, pos) < 0) {
|
|
send_resp(dut, conn, SIGMA_INVALID,
|
|
"errorCode,Invalid stationID");
|
|
return 0;
|
|
}
|
|
pos += ETH_ALEN;
|
|
}
|
|
|
|
val = get_param(cmd, "field");
|
|
if (val == NULL)
|
|
return -1;
|
|
for (i = 0; sta_counters[i].name; i++) {
|
|
if (strcasecmp(sta_counters[i].name, val) == 0)
|
|
break;
|
|
}
|
|
if (sta_counters[i].name == NULL) {
|
|
send_resp(dut, conn, SIGMA_INVALID, "errorCode,Invalid field");
|
|
return 0;
|
|
}
|
|
pos = attr_add_be32(pos, end, WLANTEST_ATTR_STA_COUNTER,
|
|
sta_counters[i].num);
|
|
|
|
s = open_wlantest();
|
|
if (s < 0) {
|
|
send_resp(dut, conn, SIGMA_ERROR, "errorCode,wlantest not "
|
|
"available");
|
|
return 0;
|
|
}
|
|
rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
|
|
close(s);
|
|
|
|
|
|
pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_COUNTER, &len);
|
|
if (pos == NULL || len != 4)
|
|
return -2;
|
|
snprintf(ret, sizeof(ret), "counter,%u", WPA_GET_BE32(pos));
|
|
send_resp(dut, conn, SIGMA_COMPLETE, ret);
|
|
return 0;
|
|
}
|
|
|
|
|
|
struct bss_counters {
|
|
const char *name;
|
|
enum wlantest_bss_counter num;
|
|
};
|
|
|
|
static const struct bss_counters bss_counters[] = {
|
|
{ "valid_bip_mmie", WLANTEST_BSS_COUNTER_VALID_BIP_MMIE },
|
|
{ "invalid_bip_mmie", WLANTEST_BSS_COUNTER_INVALID_BIP_MMIE },
|
|
{ "missing_bip_mmie", WLANTEST_BSS_COUNTER_MISSING_BIP_MMIE },
|
|
{ "bip_deauth", WLANTEST_BSS_COUNTER_BIP_DEAUTH },
|
|
{ "bip_disassoc", WLANTEST_BSS_COUNTER_BIP_DISASSOC },
|
|
{ NULL, 0 }
|
|
};
|
|
|
|
static int cmd_wlantest_get_bss_counter(struct sigma_dut *dut,
|
|
struct sigma_conn *conn,
|
|
struct sigma_cmd *cmd)
|
|
{
|
|
u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
|
|
u8 buf[100], *end, *pos;
|
|
int rlen;
|
|
const char *val;
|
|
int s, i;
|
|
char ret[100];
|
|
size_t len;
|
|
|
|
pos = buf;
|
|
end = buf + sizeof(buf);
|
|
WPA_PUT_BE32(pos, WLANTEST_CTRL_GET_BSS_COUNTER);
|
|
pos += 4;
|
|
|
|
val = get_param(cmd, "bssid");
|
|
if (val == NULL)
|
|
return -1;
|
|
if (val) {
|
|
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
|
|
if (hwaddr_aton(val, pos) < 0) {
|
|
send_resp(dut, conn, SIGMA_INVALID,
|
|
"errorCode,Invalid bssid");
|
|
return 0;
|
|
}
|
|
pos += ETH_ALEN;
|
|
}
|
|
|
|
val = get_param(cmd, "field");
|
|
if (val == NULL)
|
|
return -1;
|
|
for (i = 0; bss_counters[i].name; i++) {
|
|
if (strcasecmp(bss_counters[i].name, val) == 0)
|
|
break;
|
|
}
|
|
if (bss_counters[i].name == NULL) {
|
|
send_resp(dut, conn, SIGMA_INVALID, "errorCode,Invalid field");
|
|
return 0;
|
|
}
|
|
pos = attr_add_be32(pos, end, WLANTEST_ATTR_BSS_COUNTER,
|
|
bss_counters[i].num);
|
|
|
|
s = open_wlantest();
|
|
if (s < 0) {
|
|
send_resp(dut, conn, SIGMA_ERROR, "errorCode,wlantest not "
|
|
"available");
|
|
return 0;
|
|
}
|
|
rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
|
|
close(s);
|
|
|
|
pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_COUNTER, &len);
|
|
if (pos == NULL || len != 4)
|
|
return -2;
|
|
snprintf(ret, sizeof(ret), "counter,%u", WPA_GET_BE32(pos));
|
|
send_resp(dut, conn, SIGMA_COMPLETE, ret);
|
|
return 0;
|
|
}
|
|
|
|
|
|
struct tdls_counters {
|
|
const char *name;
|
|
enum wlantest_tdls_counter num;
|
|
};
|
|
|
|
static const struct tdls_counters tdls_counters[] = {
|
|
{ "valid_direct_link", WLANTEST_TDLS_COUNTER_VALID_DIRECT_LINK },
|
|
{ "invalid_direct_link", WLANTEST_TDLS_COUNTER_INVALID_DIRECT_LINK },
|
|
{ "valid_ap_path", WLANTEST_TDLS_COUNTER_VALID_AP_PATH },
|
|
{ "invalid_ap_path", WLANTEST_TDLS_COUNTER_INVALID_AP_PATH },
|
|
{ "setup_req", WLANTEST_TDLS_COUNTER_SETUP_REQ },
|
|
{ "setup_resp_ok", WLANTEST_TDLS_COUNTER_SETUP_RESP_OK },
|
|
{ "setup_resp_fail", WLANTEST_TDLS_COUNTER_SETUP_RESP_FAIL },
|
|
{ "setup_conf_ok", WLANTEST_TDLS_COUNTER_SETUP_CONF_OK },
|
|
{ "setup_conf_fail", WLANTEST_TDLS_COUNTER_SETUP_CONF_FAIL },
|
|
{ "teardown", WLANTEST_TDLS_COUNTER_TEARDOWN },
|
|
{ NULL, 0 }
|
|
};
|
|
|
|
static int cmd_wlantest_get_tdls_counter(struct sigma_dut *dut,
|
|
struct sigma_conn *conn,
|
|
struct sigma_cmd *cmd)
|
|
{
|
|
u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
|
|
u8 buf[100], *end, *pos;
|
|
int rlen;
|
|
const char *val;
|
|
int s, i;
|
|
char ret[100];
|
|
size_t len;
|
|
|
|
pos = buf;
|
|
end = buf + sizeof(buf);
|
|
WPA_PUT_BE32(pos, WLANTEST_CTRL_GET_TDLS_COUNTER);
|
|
pos += 4;
|
|
|
|
val = get_param(cmd, "bssid");
|
|
if (val == NULL)
|
|
return -1;
|
|
if (val) {
|
|
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
|
|
if (hwaddr_aton(val, pos) < 0) {
|
|
send_resp(dut, conn, SIGMA_INVALID,
|
|
"errorCode,Invalid bssid");
|
|
return 0;
|
|
}
|
|
pos += ETH_ALEN;
|
|
}
|
|
|
|
val = get_param(cmd, "stationID");
|
|
if (val == NULL)
|
|
return -1;
|
|
if (val) {
|
|
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
|
|
if (hwaddr_aton(val, pos) < 0) {
|
|
send_resp(dut, conn, SIGMA_INVALID,
|
|
"errorCode,Invalid stationID");
|
|
return 0;
|
|
}
|
|
pos += ETH_ALEN;
|
|
}
|
|
|
|
val = get_param(cmd, "stationID2");
|
|
if (val == NULL)
|
|
return -1;
|
|
if (val) {
|
|
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA2_ADDR,
|
|
ETH_ALEN);
|
|
if (hwaddr_aton(val, pos) < 0) {
|
|
send_resp(dut, conn, SIGMA_INVALID,
|
|
"errorCode,Invalid stationID");
|
|
return 0;
|
|
}
|
|
pos += ETH_ALEN;
|
|
}
|
|
|
|
val = get_param(cmd, "field");
|
|
if (val == NULL)
|
|
return -1;
|
|
for (i = 0; tdls_counters[i].name; i++) {
|
|
if (strcasecmp(tdls_counters[i].name, val) == 0)
|
|
break;
|
|
}
|
|
if (tdls_counters[i].name == NULL) {
|
|
send_resp(dut, conn, SIGMA_INVALID, "errorCode,Invalid field");
|
|
return 0;
|
|
}
|
|
pos = attr_add_be32(pos, end, WLANTEST_ATTR_TDLS_COUNTER,
|
|
tdls_counters[i].num);
|
|
|
|
s = open_wlantest();
|
|
if (s < 0) {
|
|
send_resp(dut, conn, SIGMA_ERROR, "errorCode,wlantest not "
|
|
"available");
|
|
return 0;
|
|
}
|
|
rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
|
|
close(s);
|
|
|
|
|
|
pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_COUNTER, &len);
|
|
if (pos == NULL || len != 4)
|
|
return -2;
|
|
snprintf(ret, sizeof(ret), "counter,%u", WPA_GET_BE32(pos));
|
|
send_resp(dut, conn, SIGMA_COMPLETE, ret);
|
|
return 0;
|
|
}
|
|
|
|
|
|
struct sta_infos {
|
|
const char *name;
|
|
enum wlantest_sta_info num;
|
|
};
|
|
|
|
static const struct sta_infos sta_infos[] = {
|
|
{ "proto", WLANTEST_STA_INFO_PROTO },
|
|
{ "pairwise", WLANTEST_STA_INFO_PAIRWISE },
|
|
{ "key_mgmt", WLANTEST_STA_INFO_KEY_MGMT },
|
|
{ "rsn_capab", WLANTEST_STA_INFO_RSN_CAPAB },
|
|
{ "state", WLANTEST_STA_INFO_STATE },
|
|
{ NULL, 0 }
|
|
};
|
|
|
|
static int cmd_wlantest_info_sta(struct sigma_dut *dut,
|
|
struct sigma_conn *conn,
|
|
struct sigma_cmd *cmd)
|
|
{
|
|
u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
|
|
u8 buf[100], *end, *pos;
|
|
int rlen;
|
|
const char *val;
|
|
int s, i;
|
|
char ret[120];
|
|
size_t len;
|
|
char info[100];
|
|
|
|
pos = buf;
|
|
end = buf + sizeof(buf);
|
|
WPA_PUT_BE32(pos, WLANTEST_CTRL_INFO_STA);
|
|
pos += 4;
|
|
|
|
val = get_param(cmd, "bssid");
|
|
if (val == NULL)
|
|
return -1;
|
|
if (val) {
|
|
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
|
|
if (hwaddr_aton(val, pos) < 0) {
|
|
send_resp(dut, conn, SIGMA_INVALID,
|
|
"errorCode,Invalid bssid");
|
|
return 0;
|
|
}
|
|
pos += ETH_ALEN;
|
|
}
|
|
|
|
val = get_param(cmd, "stationID");
|
|
if (val == NULL)
|
|
return -1;
|
|
if (val) {
|
|
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
|
|
if (hwaddr_aton(val, pos) < 0) {
|
|
send_resp(dut, conn, SIGMA_INVALID,
|
|
"errorCode,Invalid stationID");
|
|
return 0;
|
|
}
|
|
pos += ETH_ALEN;
|
|
}
|
|
|
|
val = get_param(cmd, "field");
|
|
if (val == NULL)
|
|
return -1;
|
|
for (i = 0; sta_infos[i].name; i++) {
|
|
if (strcasecmp(sta_infos[i].name, val) == 0)
|
|
break;
|
|
}
|
|
if (sta_infos[i].name == NULL) {
|
|
send_resp(dut, conn, SIGMA_INVALID, "errorCode,Invalid field");
|
|
return 0;
|
|
}
|
|
pos = attr_add_be32(pos, end, WLANTEST_ATTR_STA_INFO,
|
|
sta_infos[i].num);
|
|
|
|
s = open_wlantest();
|
|
if (s < 0) {
|
|
send_resp(dut, conn, SIGMA_ERROR, "errorCode,wlantest not "
|
|
"available");
|
|
return 0;
|
|
}
|
|
rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
|
|
close(s);
|
|
|
|
|
|
pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_INFO, &len);
|
|
if (pos == NULL)
|
|
return -2;
|
|
if (len >= sizeof(info))
|
|
len = sizeof(info) - 1;
|
|
memcpy(info, pos, len);
|
|
info[len] = '\0';
|
|
snprintf(ret, sizeof(ret), "info,%s", info);
|
|
send_resp(dut, conn, SIGMA_COMPLETE, ret);
|
|
return 0;
|
|
}
|
|
|
|
|
|
struct bss_infos {
|
|
const char *name;
|
|
enum wlantest_bss_info num;
|
|
};
|
|
|
|
static const struct bss_infos bss_infos[] = {
|
|
{ "proto", WLANTEST_BSS_INFO_PROTO },
|
|
{ "pairwise", WLANTEST_BSS_INFO_PAIRWISE },
|
|
{ "group", WLANTEST_BSS_INFO_GROUP },
|
|
{ "group_mgmt", WLANTEST_BSS_INFO_GROUP_MGMT },
|
|
{ "key_mgmt", WLANTEST_BSS_INFO_KEY_MGMT },
|
|
{ "rsn_capab", WLANTEST_BSS_INFO_RSN_CAPAB },
|
|
{ NULL, 0 }
|
|
};
|
|
|
|
static int cmd_wlantest_info_bss(struct sigma_dut *dut,
|
|
struct sigma_conn *conn,
|
|
struct sigma_cmd *cmd)
|
|
{
|
|
u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
|
|
u8 buf[100], *end, *pos;
|
|
int rlen;
|
|
const char *val;
|
|
int s, i;
|
|
char ret[120];
|
|
size_t len;
|
|
char info[100];
|
|
|
|
pos = buf;
|
|
end = buf + sizeof(buf);
|
|
WPA_PUT_BE32(pos, WLANTEST_CTRL_INFO_BSS);
|
|
pos += 4;
|
|
|
|
val = get_param(cmd, "bssid");
|
|
if (val == NULL)
|
|
return -1;
|
|
if (val) {
|
|
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
|
|
if (hwaddr_aton(val, pos) < 0) {
|
|
send_resp(dut, conn, SIGMA_INVALID,
|
|
"errorCode,Invalid bssid");
|
|
return 0;
|
|
}
|
|
pos += ETH_ALEN;
|
|
}
|
|
|
|
val = get_param(cmd, "field");
|
|
if (val == NULL)
|
|
return -1;
|
|
for (i = 0; bss_infos[i].name; i++) {
|
|
if (strcasecmp(bss_infos[i].name, val) == 0)
|
|
break;
|
|
}
|
|
if (bss_infos[i].name == NULL) {
|
|
send_resp(dut, conn, SIGMA_INVALID, "errorCode,Invalid field");
|
|
return 0;
|
|
}
|
|
pos = attr_add_be32(pos, end, WLANTEST_ATTR_BSS_INFO,
|
|
bss_infos[i].num);
|
|
|
|
s = open_wlantest();
|
|
if (s < 0) {
|
|
send_resp(dut, conn, SIGMA_ERROR, "errorCode,wlantest not "
|
|
"available");
|
|
return 0;
|
|
}
|
|
rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
|
|
close(s);
|
|
|
|
|
|
pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_INFO, &len);
|
|
if (pos == NULL)
|
|
return -2;
|
|
if (len >= sizeof(info))
|
|
len = sizeof(info) - 1;
|
|
memcpy(info, pos, len);
|
|
info[len] = '\0';
|
|
snprintf(ret, sizeof(ret), "info,%s", info);
|
|
send_resp(dut, conn, SIGMA_COMPLETE, ret);
|
|
return 0;
|
|
}
|
|
|
|
|
|
void wlantest_register_cmds(void)
|
|
{
|
|
sigma_dut_reg_cmd("wlantest_version", NULL, cmd_wlantest_version);
|
|
sigma_dut_reg_cmd("wlantest_set_channel", NULL,
|
|
cmd_wlantest_set_channel);
|
|
sigma_dut_reg_cmd("wlantest_flush", NULL, cmd_wlantest_flush);
|
|
sigma_dut_reg_cmd("wlantest_send_frame", NULL,
|
|
cmd_wlantest_send_frame);
|
|
sigma_dut_reg_cmd("wlantest_add_passphrase", NULL,
|
|
cmd_wlantest_add_passphrase);
|
|
sigma_dut_reg_cmd("wlantest_clear_sta_counters", NULL,
|
|
cmd_wlantest_clear_sta_counters);
|
|
sigma_dut_reg_cmd("wlantest_clear_bss_counters", NULL,
|
|
cmd_wlantest_clear_bss_counters);
|
|
sigma_dut_reg_cmd("wlantest_clear_tdls_counters", NULL,
|
|
cmd_wlantest_clear_tdls_counters);
|
|
sigma_dut_reg_cmd("wlantest_get_sta_counter", NULL,
|
|
cmd_wlantest_get_sta_counter);
|
|
sigma_dut_reg_cmd("wlantest_get_bss_counter", NULL,
|
|
cmd_wlantest_get_bss_counter);
|
|
sigma_dut_reg_cmd("wlantest_get_tdls_counter", NULL,
|
|
cmd_wlantest_get_tdls_counter);
|
|
sigma_dut_reg_cmd("wlantest_info_sta", NULL, cmd_wlantest_info_sta);
|
|
sigma_dut_reg_cmd("wlantest_info_bss", NULL, cmd_wlantest_info_bss);
|
|
}
|