blob: 03200d50b97d6a6f9777ee6ec7dc2a1d39b40fdf [file] [log] [blame]
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001/*
2 * Sigma Control API DUT (station/AP)
3 * Copyright (c) 2010-2011, Atheros Communications, Inc.
Jouni Malinen9d7e31d2017-12-22 18:55:04 +02004 * Copyright (c) 2011-2017, Qualcomm Atheros, Inc.
Jouni Malinenc12ea4a2018-01-05 21:07:10 +02005 * Copyright (c) 2018, The Linux Foundation
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006 * All Rights Reserved.
7 * Licensed under the Clear BSD license. See README for more details.
8 */
9
10#include "sigma_dut.h"
11#include <sys/ioctl.h>
12#include <sys/stat.h>
Jouni Malinen82905202018-04-29 17:20:10 +030013#include <sys/wait.h>
Alexei Avshalom Lazara90032d2019-05-02 13:34:02 +030014#include <ctype.h>
Jouni Malinencd4e3c32015-10-29 12:39:56 +020015#ifdef __linux__
Lior Davidcc88b562017-01-03 18:52:09 +020016#include <regex.h>
17#include <dirent.h>
Jouni Malinencd4e3c32015-10-29 12:39:56 +020018#include <sys/time.h>
19#include <netpacket/packet.h>
20#include <linux/if_ether.h>
21#ifdef ANDROID
22#include <cutils/properties.h>
23#include <android/log.h>
24#include "keystore_get.h"
25#else /* ANDROID */
26#include <ifaddrs.h>
27#endif /* ANDROID */
28#include <netdb.h>
29#endif /* __linux__ */
30#ifdef __QNXNTO__
31#include <net/if_dl.h>
32#endif /* __QNXNTO__ */
33#include "wpa_ctrl.h"
34#include "wpa_helpers.h"
Amarnath Hullur Subramanyam9c381f52017-03-17 00:04:41 -070035#include "miracast.h"
Kiran Kumar Lokere29c1bb02018-10-08 17:41:02 -070036#include "qca-vendor_copy.h"
Jouni Malinencd4e3c32015-10-29 12:39:56 +020037
38/* Temporary files for sta_send_addba */
39#define VI_QOS_TMP_FILE "/tmp/vi-qos.tmp"
40#define VI_QOS_FILE "/tmp/vi-qos.txt"
41#define VI_QOS_REFFILE "/etc/vi-qos.txt"
42
43/*
44 * MTU for Ethernet need to take into account 8-byte SNAP header
45 * to be added when encapsulating Ethernet frame into 802.11
46 */
47#ifndef IEEE80211_MAX_DATA_LEN_DMG
48#define IEEE80211_MAX_DATA_LEN_DMG 7920
49#endif
50#ifndef IEEE80211_SNAP_LEN_DMG
51#define IEEE80211_SNAP_LEN_DMG 8
52#endif
53
Ashwini Patil00402582017-04-13 12:29:39 +053054#define NON_PREF_CH_LIST_SIZE 100
Ashwini Patil5acd7382017-04-13 15:55:04 +053055#define NEIGHBOR_REPORT_SIZE 1000
56#define DEFAULT_NEIGHBOR_BSSID_INFO "17"
57#define DEFAULT_NEIGHBOR_PHY_TYPE "1"
Ashwini Patil00402582017-04-13 12:29:39 +053058
Alexei Avshalom Lazara90032d2019-05-02 13:34:02 +030059#define WIL_DEFAULT_BI 100
60
61/* default remain on channel time for transmitting frames (milliseconds) */
62#define WIL_TRANSMIT_FRAME_DEFAULT_ROC 500
63#define IEEE80211_P2P_ATTR_DEVICE_ID 3
64#define IEEE80211_P2P_ATTR_GROUP_ID 15
65
66/* describes tagged bytes in template frame file */
67struct template_frame_tag {
68 int num;
69 int offset;
70 size_t len;
71};
72
Jouni Malinencd4e3c32015-10-29 12:39:56 +020073extern char *sigma_wpas_ctrl;
74extern char *sigma_cert_path;
75extern enum driver_type wifi_chip_type;
76extern char *sigma_radio_ifname[];
77
Lior David0fe101e2017-03-09 16:09:50 +020078#ifdef __linux__
79#define WIL_WMI_MAX_PAYLOAD 248
Alexei Avshalom Lazarbc180dc2018-12-18 16:01:14 +020080#define WIL_WMI_ESE_CFG_CMDID 0xa01
Lior David0fe101e2017-03-09 16:09:50 +020081#define WIL_WMI_BF_TRIG_CMDID 0x83a
Alexei Avshalom Lazarb094bf02018-12-18 16:00:53 +020082#define WIL_WMI_UNIT_TEST_CMDID 0x900
Alexei Avshalom Lazara90032d2019-05-02 13:34:02 +030083#define WIL_WMI_P2P_CFG_CMDID 0x910
84#define WIL_WMI_START_LISTEN_CMDID 0x914
85#define WIL_WMI_DISCOVERY_STOP_CMDID 0x917
Lior David0fe101e2017-03-09 16:09:50 +020086
87struct wil_wmi_header {
88 uint8_t mid;
89 uint8_t reserved;
90 uint16_t cmd;
91 uint32_t ts;
92} __attribute__((packed));
93
94enum wil_wmi_bf_trig_type {
95 WIL_WMI_SLS,
96 WIL_WMI_BRP_RX,
97 WIL_WMI_BRP_TX,
98};
99
100struct wil_wmi_bf_trig_cmd {
101 /* enum wil_wmi_bf_trig_type */
102 uint32_t bf_type;
103 /* cid when type == WMI_BRP_RX */
104 uint32_t sta_id;
105 uint32_t reserved;
106 /* mac address when type = WIL_WMI_SLS */
107 uint8_t dest_mac[6];
108} __attribute__((packed));
Alexei Avshalom Lazarb094bf02018-12-18 16:00:53 +0200109
Alexei Avshalom Lazarbc180dc2018-12-18 16:01:14 +0200110enum wil_wmi_sched_scheme_advertisment {
111 WIL_WMI_ADVERTISE_ESE_DISABLED,
112 WIL_WMI_ADVERTISE_ESE_IN_BEACON,
113 WIL_WMI_ADVERTISE_ESE_IN_ANNOUNCE_FRAME,
114};
115
116enum wil_wmi_ese_slot_type {
117 WIL_WMI_ESE_SP,
118 WIL_WMI_ESE_CBAP,
119 WIL_WMI_ESE_ANNOUNCE_NO_ACK,
120};
121
122struct wil_wmi_ese_slot {
123 /* offset from start of BI in microseconds */
124 uint32_t tbtt_offset;
125 uint8_t flags;
126 /* enum wil_wmi_ese_slot_type */
127 uint8_t slot_type;
128 /* duration in microseconds */
129 uint16_t duration;
130 /* frame exchange sequence duration, microseconds */
131 uint16_t tx_op;
132 /* time between 2 blocks for periodic allocation(microseconds) */
133 uint16_t period;
134 /* number of blocks in periodic allocation */
135 uint8_t num_blocks;
136 /* for semi-active allocations */
137 uint8_t idle_period;
138 uint8_t src_aid;
139 uint8_t dst_aid;
140 uint32_t reserved;
141} __attribute__((packed));
142
143#define WIL_WMI_MAX_ESE_SLOTS 4
144struct wil_wmi_ese_cfg {
145 uint8_t serial_num;
146 /* wil_wmi_sched_scheme_advertisment */
147 uint8_t ese_advertisment;
148 uint16_t flags;
149 uint8_t num_allocs;
150 uint8_t reserved[3];
151 uint64_t start_tbtt;
152 /* allocations list */
153 struct wil_wmi_ese_slot slots[WIL_WMI_MAX_ESE_SLOTS];
154} __attribute__((packed));
155
Alexei Avshalom Lazaraad97b02018-12-18 16:01:23 +0200156#define WIL_WMI_UT_FORCE_MCS 6
157struct wil_wmi_force_mcs {
158 /* WIL_WMI_UT_HW_SYSAPI */
159 uint16_t module_id;
160 /* WIL_WMI_UT_FORCE_MCS */
161 uint16_t subtype_id;
162 /* cid (ignored in oob_mode, affects all stations) */
163 uint32_t cid;
164 /* 1 to force MCS, 0 to restore default behavior */
165 uint32_t force_enable;
166 /* MCS index, 0-12 */
167 uint32_t mcs;
168} __attribute__((packed));
169
Alexei Avshalom Lazarb094bf02018-12-18 16:00:53 +0200170#define WIL_WMI_UT_HW_SYSAPI 10
171#define WIL_WMI_UT_FORCE_RSN_IE 0x29
172struct wil_wmi_force_rsn_ie {
173 /* WIL_WMI_UT_HW_SYSAPI */
174 uint16_t module_id;
175 /* WIL_WMI_UT_FORCE_RSN_IE */
176 uint16_t subtype_id;
177 /* 0 = no change, 1 = remove if exists, 2 = add if does not exist */
178 uint32_t state;
179} __attribute__((packed));
Alexei Avshalom Lazara90032d2019-05-02 13:34:02 +0300180
181enum wil_wmi_discovery_mode {
182 WMI_DISCOVERY_MODE_NON_OFFLOAD,
183 WMI_DISCOVERY_MODE_OFFLOAD,
184 WMI_DISCOVERY_MODE_PEER2PEER,
185};
186
187struct wil_wmi_p2p_cfg_cmd {
188 /* enum wil_wmi_discovery_mode */
189 uint8_t discovery_mode;
190 /* 0-based (wireless channel - 1) */
191 uint8_t channel;
192 /* set to WIL_DEFAULT_BI */
193 uint16_t bcon_interval;
194} __attribute__((packed));
Lior David0fe101e2017-03-09 16:09:50 +0200195#endif /* __linux__ */
Jouni Malinencd4e3c32015-10-29 12:39:56 +0200196
197#ifdef ANDROID
198
199static int add_ipv6_rule(struct sigma_dut *dut, const char *ifname);
200
201#define ANDROID_KEYSTORE_GET 'g'
202#define ANDROID_KEYSTORE_GET_PUBKEY 'b'
203
204static int android_keystore_get(char cmd, const char *key, unsigned char *val)
205{
Jouni Malinencd4e3c32015-10-29 12:39:56 +0200206 /* Android 4.3 changed keystore design, so need to use keystore_get() */
207#ifndef KEYSTORE_MESSAGE_SIZE
208#define KEYSTORE_MESSAGE_SIZE 65535
209#endif /* KEYSTORE_MESSAGE_SIZE */
210
211 ssize_t len;
212 uint8_t *value = NULL;
213
214 __android_log_print(ANDROID_LOG_DEBUG, "sigma_dut",
215 "keystore command '%c' key '%s' --> keystore_get",
216 cmd, key);
217
218 len = keystore_get(key, strlen(key), &value);
219 if (len < 0) {
220 __android_log_print(ANDROID_LOG_DEBUG, "sigma_dut",
221 "keystore_get() failed");
222 return -1;
223 }
224
225 if (len > KEYSTORE_MESSAGE_SIZE)
226 len = KEYSTORE_MESSAGE_SIZE;
227 memcpy(val, value, len);
228 free(value);
229 return len;
Jouni Malinencd4e3c32015-10-29 12:39:56 +0200230}
231#endif /* ANDROID */
232
233
Vinita S. Maloo0fcb57d2020-04-24 14:03:56 +0530234#ifdef NL80211_SUPPORT
235static int nl80211_sta_set_power_save(struct sigma_dut *dut,
236 const char *intf,
237 enum nl80211_ps_state ps_state)
238{
239 struct nl_msg *msg;
240 int ifindex, ret;
241
242 ifindex = if_nametoindex(intf);
243 if (ifindex == 0) {
244 sigma_dut_print(dut, DUT_MSG_ERROR,
245 "%s: Index for interface %s not found",
246 __func__, intf);
247 return -1;
248 }
249
250 msg = nl80211_drv_msg(dut, dut->nl_ctx, ifindex, 0,
251 NL80211_CMD_SET_POWER_SAVE);
252 if (!msg) {
253 sigma_dut_print(dut, DUT_MSG_ERROR,
254 "%s: err in creating nl80211 msg", __func__);
255 return -1;
256 }
257
258 if (nla_put_u32(msg, NL80211_ATTR_PS_STATE, ps_state)) {
259 sigma_dut_print(dut, DUT_MSG_ERROR,
260 "%s: err in populating nl80211 msg", __func__);
261 nlmsg_free(msg);
262 return -1;
263 }
264
265 ret = send_and_recv_msgs(dut, dut->nl_ctx, msg, NULL, NULL);
266 if (ret) {
267 sigma_dut_print(dut, DUT_MSG_ERROR,
268 "%s: err in send_and_recv_msgs, ret=%d (%s)",
269 __func__, ret, strerror(-ret));
270 return -1;
271 }
272
273 return 0;
274}
275#endif /* NL80211_SUPPORT */
276
277
Vinita S. Malooa8b62722020-04-23 01:45:41 +0530278static int set_power_save_wcn(struct sigma_dut *dut, const char *intf, int ps)
279{
280 char buf[100];
Vinita S. Maloo0fcb57d2020-04-24 14:03:56 +0530281#ifdef NL80211_SUPPORT
282 enum nl80211_ps_state ps_state;
283
284 ps_state = ps == 1 ? NL80211_PS_ENABLED : NL80211_PS_DISABLED;
285 if (nl80211_sta_set_power_save(dut, intf, ps_state) == 0)
286 return 0;
287#endif /* NL80211_SUPPORT */
Vinita S. Malooa8b62722020-04-23 01:45:41 +0530288
289 snprintf(buf, sizeof(buf), "iwpriv %s setPower %d", intf, ps);
290 if (system(buf) != 0) {
291 sigma_dut_print(dut, DUT_MSG_ERROR,
292 "iwpriv setPower %d failed", ps);
293 return -1;
294 }
295 return 0;
296}
297
298
Jouni Malinencd4e3c32015-10-29 12:39:56 +0200299int set_ps(const char *intf, struct sigma_dut *dut, int enabled)
300{
301#ifdef __linux__
302 char buf[100];
303
304 if (wifi_chip_type == DRIVER_WCN) {
305 if (enabled) {
Vinita S. Malooa8b62722020-04-23 01:45:41 +0530306 if (set_power_save_wcn(dut, intf, 1) < 0) {
Purushottam Kushwaha304561d2019-12-23 16:57:18 +0530307 snprintf(buf, sizeof(buf),
308 "iwpriv wlan0 dump 906");
309 if (system(buf) != 0)
310 goto set_power_save;
311 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +0200312 } else {
Vinita S. Malooa8b62722020-04-23 01:45:41 +0530313 if (set_power_save_wcn(dut, intf, 2) < 0) {
Purushottam Kushwaha304561d2019-12-23 16:57:18 +0530314 snprintf(buf, sizeof(buf),
315 "iwpriv wlan0 dump 905");
316 if (system(buf) != 0)
317 goto set_power_save;
318 snprintf(buf, sizeof(buf),
319 "iwpriv wlan0 dump 912");
320 if (system(buf) != 0)
321 goto set_power_save;
322 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +0200323 }
324
325 return 0;
326 }
327
Pradeep Reddy POTTETI625b3702016-09-20 17:09:58 +0530328set_power_save:
Jouni Malinencd4e3c32015-10-29 12:39:56 +0200329 snprintf(buf, sizeof(buf), "./iw dev %s set power_save %s",
330 intf, enabled ? "on" : "off");
331 if (system(buf) != 0) {
332 snprintf(buf, sizeof(buf), "iw dev %s set power_save %s",
333 intf, enabled ? "on" : "off");
Pradeep Reddy POTTETI625b3702016-09-20 17:09:58 +0530334 if (system(buf) != 0) {
335 sigma_dut_print(dut, DUT_MSG_ERROR,
336 "Failed to set power save %s",
337 enabled ? "on" : "off");
Jouni Malinencd4e3c32015-10-29 12:39:56 +0200338 return -1;
Pradeep Reddy POTTETI625b3702016-09-20 17:09:58 +0530339 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +0200340 }
341
342 return 0;
343#else /* __linux__ */
344 return -1;
345#endif /* __linux__ */
346}
347
348
Lior Davidcc88b562017-01-03 18:52:09 +0200349#ifdef __linux__
Lior David0fe101e2017-03-09 16:09:50 +0200350
Lior Davidcc88b562017-01-03 18:52:09 +0200351static int wil6210_get_debugfs_dir(struct sigma_dut *dut, char *path,
352 size_t len)
353{
354 DIR *dir, *wil_dir;
355 struct dirent *entry;
356 int ret = -1;
357 const char *root_path = "/sys/kernel/debug/ieee80211";
358
359 dir = opendir(root_path);
360 if (!dir)
361 return -2;
362
363 while ((entry = readdir(dir))) {
364 if (strcmp(entry->d_name, ".") == 0 ||
365 strcmp(entry->d_name, "..") == 0)
366 continue;
367
368 if (snprintf(path, len, "%s/%s/wil6210",
369 root_path, entry->d_name) >= (int) len) {
370 ret = -3;
371 break;
372 }
373
374 wil_dir = opendir(path);
375 if (wil_dir) {
376 closedir(wil_dir);
377 ret = 0;
378 break;
379 }
380 }
381
382 closedir(dir);
383 return ret;
384}
Lior David0fe101e2017-03-09 16:09:50 +0200385
386
387static int wil6210_wmi_send(struct sigma_dut *dut, uint16_t command,
388 void *payload, uint16_t length)
389{
390 struct {
391 struct wil_wmi_header hdr;
392 char payload[WIL_WMI_MAX_PAYLOAD];
393 } __attribute__((packed)) cmd;
394 char buf[128], fname[128];
395 size_t towrite, written;
396 FILE *f;
Jouni Malinen3aa72862019-05-29 23:14:51 +0300397 int res;
Lior David0fe101e2017-03-09 16:09:50 +0200398
399 if (length > WIL_WMI_MAX_PAYLOAD) {
400 sigma_dut_print(dut, DUT_MSG_ERROR,
401 "payload too large(%u, max %u)",
402 length, WIL_WMI_MAX_PAYLOAD);
403 return -1;
404 }
405
406 memset(&cmd.hdr, 0, sizeof(cmd.hdr));
407 cmd.hdr.cmd = command;
408 memcpy(cmd.payload, payload, length);
409
410 if (wil6210_get_debugfs_dir(dut, buf, sizeof(buf))) {
411 sigma_dut_print(dut, DUT_MSG_ERROR,
412 "failed to get wil6210 debugfs dir");
413 return -1;
414 }
415
Jouni Malinen3aa72862019-05-29 23:14:51 +0300416 res = snprintf(fname, sizeof(fname), "%s/wmi_send", buf);
417 if (res < 0 || res >= sizeof(fname))
418 return -1;
Lior David0fe101e2017-03-09 16:09:50 +0200419 f = fopen(fname, "wb");
420 if (!f) {
421 sigma_dut_print(dut, DUT_MSG_ERROR,
422 "failed to open: %s", fname);
423 return -1;
424 }
425
426 towrite = sizeof(cmd.hdr) + length;
427 written = fwrite(&cmd, 1, towrite, f);
428 fclose(f);
429 if (written != towrite) {
430 sigma_dut_print(dut, DUT_MSG_ERROR,
431 "failed to send wmi %u", command);
432 return -1;
433 }
434
435 return 0;
436}
437
438
439static int wil6210_get_sta_info_field(struct sigma_dut *dut, const char *bssid,
440 const char *pattern, unsigned int *field)
441{
442 char buf[128], fname[128];
443 FILE *f;
444 regex_t re;
445 regmatch_t m[2];
Jouni Malinen3aa72862019-05-29 23:14:51 +0300446 int rc, ret = -1, res;
Lior David0fe101e2017-03-09 16:09:50 +0200447
448 if (wil6210_get_debugfs_dir(dut, buf, sizeof(buf))) {
449 sigma_dut_print(dut, DUT_MSG_ERROR,
450 "failed to get wil6210 debugfs dir");
451 return -1;
452 }
453
Jouni Malinen3aa72862019-05-29 23:14:51 +0300454 res = snprintf(fname, sizeof(fname), "%s/stations", buf);
455 if (res < 0 || res >= sizeof(fname))
456 return -1;
Lior David0fe101e2017-03-09 16:09:50 +0200457 f = fopen(fname, "r");
458 if (!f) {
459 sigma_dut_print(dut, DUT_MSG_ERROR,
460 "failed to open: %s", fname);
461 return -1;
462 }
463
464 if (regcomp(&re, pattern, REG_EXTENDED)) {
465 sigma_dut_print(dut, DUT_MSG_ERROR,
466 "regcomp failed: %s", pattern);
467 goto out;
468 }
469
470 /*
471 * find the entry for the mac address
472 * line is of the form: [n] 11:22:33:44:55:66 state AID aid
473 */
474 while (fgets(buf, sizeof(buf), f)) {
475 if (strcasestr(buf, bssid)) {
476 /* extract the field (CID/AID/state) */
477 rc = regexec(&re, buf, 2, m, 0);
478 if (!rc && (m[1].rm_so >= 0)) {
479 buf[m[1].rm_eo] = 0;
480 *field = atoi(&buf[m[1].rm_so]);
481 ret = 0;
482 break;
483 }
484 }
485 }
486
487 regfree(&re);
488 if (ret)
489 sigma_dut_print(dut, DUT_MSG_ERROR,
490 "could not extract field");
491
492out:
493 fclose(f);
494
495 return ret;
496}
497
498
499static int wil6210_get_cid(struct sigma_dut *dut, const char *bssid,
500 unsigned int *cid)
501{
502 const char *pattern = "\\[([0-9]+)\\]";
503
504 return wil6210_get_sta_info_field(dut, bssid, pattern, cid);
505}
506
507
508static int wil6210_send_brp_rx(struct sigma_dut *dut, const char *mac,
509 int l_rx)
510{
Rakesh Sunki556237d2017-03-30 14:49:31 -0700511 struct wil_wmi_bf_trig_cmd cmd;
Lior David0fe101e2017-03-09 16:09:50 +0200512 unsigned int cid;
513
Rakesh Sunki556237d2017-03-30 14:49:31 -0700514 memset(&cmd, 0, sizeof(cmd));
515
Lior David0fe101e2017-03-09 16:09:50 +0200516 if (wil6210_get_cid(dut, mac, &cid))
517 return -1;
518
519 cmd.bf_type = WIL_WMI_BRP_RX;
520 cmd.sta_id = cid;
521 /* training length (l_rx) is ignored, FW always uses length 16 */
522 return wil6210_wmi_send(dut, WIL_WMI_BF_TRIG_CMDID,
523 &cmd, sizeof(cmd));
524}
525
526
527static int wil6210_send_sls(struct sigma_dut *dut, const char *mac)
528{
Rakesh Sunki556237d2017-03-30 14:49:31 -0700529 struct wil_wmi_bf_trig_cmd cmd;
530
531 memset(&cmd, 0, sizeof(cmd));
Lior David0fe101e2017-03-09 16:09:50 +0200532
533 if (parse_mac_address(dut, mac, (unsigned char *)&cmd.dest_mac))
534 return -1;
535
536 cmd.bf_type = WIL_WMI_SLS;
537 return wil6210_wmi_send(dut, WIL_WMI_BF_TRIG_CMDID,
538 &cmd, sizeof(cmd));
539}
540
Alexei Avshalom Lazarb094bf02018-12-18 16:00:53 +0200541
Alexei Avshalom Lazarbc180dc2018-12-18 16:01:14 +0200542int wil6210_set_ese(struct sigma_dut *dut, int count,
543 struct sigma_ese_alloc *allocs)
544{
545 struct wil_wmi_ese_cfg cmd = { };
546 int i;
547
548 if (count == 0 || count > WIL_WMI_MAX_ESE_SLOTS)
549 return -1;
550
551 if (dut->ap_bcnint <= 0) {
552 sigma_dut_print(dut, DUT_MSG_ERROR,
553 "invalid beacon interval(%d), check test",
554 dut->ap_bcnint);
555 return -1;
556 }
557
558 cmd.ese_advertisment = WIL_WMI_ADVERTISE_ESE_IN_BEACON;
559 cmd.flags = 0x1d;
560 cmd.num_allocs = count;
561 for (i = 0; i < count; i++) {
562 /*
563 * Convert percent from BI (BI specified in milliseconds)
564 * to absolute duration in microseconds.
565 */
566 cmd.slots[i].duration =
567 (allocs[i].percent_bi * dut->ap_bcnint * 1000) / 100;
568 switch (allocs[i].type) {
569 case ESE_CBAP:
570 cmd.slots[i].slot_type = WIL_WMI_ESE_CBAP;
571 break;
572 case ESE_SP:
573 cmd.slots[i].slot_type = WIL_WMI_ESE_SP;
574 break;
575 default:
576 sigma_dut_print(dut, DUT_MSG_ERROR,
577 "invalid slot type(%d) at index %d",
578 allocs[i].type, i);
579 return -1;
580 }
581 cmd.slots[i].src_aid = allocs[i].src_aid;
582 cmd.slots[i].dst_aid = allocs[i].dst_aid;
583 sigma_dut_print(dut, DUT_MSG_INFO,
584 "slot %d, duration %u, type %d, srcAID %u dstAID %u",
585 i, cmd.slots[i].duration,
586 cmd.slots[i].slot_type, cmd.slots[i].src_aid,
587 cmd.slots[i].dst_aid);
588 }
589
590 return wil6210_wmi_send(dut, WIL_WMI_ESE_CFG_CMDID, &cmd, sizeof(cmd));
591}
592
593
Alexei Avshalom Lazaraad97b02018-12-18 16:01:23 +0200594int wil6210_set_force_mcs(struct sigma_dut *dut, int force, int mcs)
595{
596 struct wil_wmi_force_mcs cmd = { };
597
598 cmd.module_id = WIL_WMI_UT_HW_SYSAPI;
599 cmd.subtype_id = WIL_WMI_UT_FORCE_MCS;
600 cmd.force_enable = (uint32_t) force;
601 cmd.mcs = (uint32_t) mcs;
602
603 return wil6210_wmi_send(dut, WIL_WMI_UNIT_TEST_CMDID,
604 &cmd, sizeof(cmd));
605}
606
607
Alexei Avshalom Lazarb094bf02018-12-18 16:00:53 +0200608static int wil6210_force_rsn_ie(struct sigma_dut *dut, int state)
609{
610 struct wil_wmi_force_rsn_ie cmd = { };
611
612 cmd.module_id = WIL_WMI_UT_HW_SYSAPI;
613 cmd.subtype_id = WIL_WMI_UT_FORCE_RSN_IE;
614 cmd.state = (uint32_t) state;
615
616 return wil6210_wmi_send(dut, WIL_WMI_UNIT_TEST_CMDID,
617 &cmd, sizeof(cmd));
618}
619
Alexei Avshalom Lazara90032d2019-05-02 13:34:02 +0300620
621/*
622 * this function is also used to configure generic remain-on-channel
623 */
624static int wil6210_p2p_cfg(struct sigma_dut *dut, int freq)
625{
626 struct wil_wmi_p2p_cfg_cmd cmd = { };
627 int channel = freq_to_channel(freq);
628
629 if (channel < 0)
630 return -1;
631 cmd.discovery_mode = WMI_DISCOVERY_MODE_NON_OFFLOAD;
632 cmd.channel = channel - 1;
633 cmd.bcon_interval = WIL_DEFAULT_BI;
634 cmd.discovery_mode = WMI_DISCOVERY_MODE_PEER2PEER;
635
636 return wil6210_wmi_send(dut, WIL_WMI_P2P_CFG_CMDID,
637 &cmd, sizeof(cmd));
638}
639
640
641static int wil6210_remain_on_channel(struct sigma_dut *dut, int freq)
642{
643 int ret = wil6210_p2p_cfg(dut, freq);
644
645 if (ret)
646 return ret;
647
648 ret = wil6210_wmi_send(dut, WIL_WMI_START_LISTEN_CMDID, NULL, 0);
649 if (!ret) {
650 /*
651 * wait a bit to allow FW to setup the radio
652 * especially important if we switch channels
653 */
654 usleep(500000);
655 }
656
657 return ret;
658}
659
660
661static int wil6210_stop_discovery(struct sigma_dut *dut)
662{
663 return wil6210_wmi_send(dut, WIL_WMI_DISCOVERY_STOP_CMDID, NULL, 0);
664}
665
666
667static int wil6210_transmit_frame(struct sigma_dut *dut, int freq,
668 int wait_duration,
669 const char *frame, size_t frame_len)
670{
671 char buf[128], fname[128];
672 FILE *f;
Jouni Malinen3aa72862019-05-29 23:14:51 +0300673 int res = 0, r;
Alexei Avshalom Lazara90032d2019-05-02 13:34:02 +0300674 size_t written;
675
676 if (wil6210_get_debugfs_dir(dut, buf, sizeof(buf))) {
677 sigma_dut_print(dut, DUT_MSG_ERROR,
678 "failed to get wil6210 debugfs dir");
679 return -1;
680 }
Jouni Malinen3aa72862019-05-29 23:14:51 +0300681 r = snprintf(fname, sizeof(fname), "%s/tx_mgmt", buf);
682 if (r < 0 || r >= sizeof(fname))
683 return -1;
Alexei Avshalom Lazara90032d2019-05-02 13:34:02 +0300684
685 if (wil6210_remain_on_channel(dut, freq)) {
686 sigma_dut_print(dut, DUT_MSG_ERROR,
687 "failed to listen on channel");
688 return -1;
689 }
690
691 f = fopen(fname, "wb");
692 if (!f) {
693 sigma_dut_print(dut, DUT_MSG_ERROR,
694 "failed to open: %s", fname);
695 res = -1;
696 goto out_stop;
697 }
698 written = fwrite(frame, 1, frame_len, f);
699 fclose(f);
700
701 if (written != frame_len) {
702 sigma_dut_print(dut, DUT_MSG_ERROR,
703 "failed to transmit frame (got %zd, expected %zd)",
704 written, frame_len);
705 res = -1;
706 goto out_stop;
707 }
708
709 usleep(wait_duration * 1000);
710
711out_stop:
712 wil6210_stop_discovery(dut);
713 return res;
714}
715
716
717static int find_template_frame_tag(struct template_frame_tag *tags,
718 int total_tags, int tag_num)
719{
720 int i;
721
722 for (i = 0; i < total_tags; i++) {
723 if (tag_num == tags[i].num)
724 return i;
725 }
726
727 return -1;
728}
729
730
731static int replace_p2p_attribute(struct sigma_dut *dut, char *buf, size_t len,
732 int id, const char *value, size_t val_len)
733{
734 struct wfa_p2p_attribute *attr = (struct wfa_p2p_attribute *) buf;
735
736 if (len < 3 + val_len) {
737 sigma_dut_print(dut, DUT_MSG_ERROR,
738 "not enough space to replace P2P attribute");
739 return -1;
740 }
741
742 if (attr->len != val_len) {
743 sigma_dut_print(dut, DUT_MSG_ERROR,
744 "attribute length mismatch (need %zu have %hu)",
745 val_len, attr->len);
746 return -1;
747 }
748
749 if (attr->id != id) {
750 sigma_dut_print(dut, DUT_MSG_ERROR,
751 "incorrect attribute id (expected %d actual %d)",
752 id, attr->id);
753 return -1;
754 }
755
756 memcpy(attr->variable, value, val_len);
757
758 return 0;
759}
760
761
762static int parse_template_frame_file(struct sigma_dut *dut, const char *fname,
763 char *buf, size_t *length,
764 struct template_frame_tag *tags,
765 size_t *num_tags)
766{
767 char line[512];
768 FILE *f;
769 size_t offset = 0, tag_index = 0;
770 int num, index;
771 int in_tag = 0, tag_num = 0, tag_offset = 0;
772
773 if (*length < sizeof(struct ieee80211_hdr_3addr)) {
774 sigma_dut_print(dut, DUT_MSG_ERROR,
775 "supplied buffer is too small");
776 return -1;
777 }
778
779 f = fopen(fname, "r");
780 if (!f) {
781 sigma_dut_print(dut, DUT_MSG_ERROR,
782 "failed to open template file %s", fname);
783 return -1;
784 }
785
786 /*
787 * template file format: lines beginning with # are comments and
788 * ignored.
789 * It is possible to tag bytes in the frame to make it easy
790 * to replace fields in the template, espcially if they appear
791 * in variable-sized sections (such as IEs)
792 * This is done by a line beginning with $NUM where NUM is an integer
793 * tag number. It can be followed by space(s) and comment.
794 * The next line is considered the tagged bytes. The parser will fill
795 * the tag number, offset and length of the tagged bytes.
796 * rest of the lines contain frame bytes as sequence of hex digits,
797 * 2 digits for each byte. Spaces are allowed between bytes.
798 * On bytes lines only hex digits and spaces are allowed
799 */
800 while (!feof(f)) {
801 if (!fgets(line, sizeof(line), f))
802 break;
803 index = 0;
804 while (isspace((unsigned char) line[index]))
805 index++;
806 if (!line[index] || line[index] == '#')
807 continue;
808 if (line[index] == '$') {
809 if (tags) {
810 index++;
811 tag_num = strtol(&line[index], NULL, 0);
812 tag_offset = offset;
813 in_tag = 1;
814 }
815 continue;
816 }
817 while (line[index]) {
818 if (isspace((unsigned char) line[index])) {
819 index++;
820 continue;
821 }
822 num = hex_byte(&line[index]);
823 if (num < 0)
824 break;
825 buf[offset++] = num;
826 if (offset == *length)
827 goto out;
828 index += 2;
829 }
830
831 if (in_tag) {
832 if (tag_index < *num_tags) {
833 tags[tag_index].num = tag_num;
834 tags[tag_index].offset = tag_offset;
835 tags[tag_index].len = offset - tag_offset;
836 tag_index++;
837 } else {
838 sigma_dut_print(dut, DUT_MSG_INFO,
839 "too many tags, tag ignored");
840 }
841 in_tag = 0;
842 }
843 }
844
845 if (num_tags)
846 *num_tags = tag_index;
847out:
848 fclose(f);
849 if (offset < sizeof(struct ieee80211_hdr_3addr)) {
850 sigma_dut_print(dut, DUT_MSG_ERROR,
851 "template frame is too small");
852 return -1;
853 }
854
855 *length = offset;
856 return 0;
857}
858
Lior Davidcc88b562017-01-03 18:52:09 +0200859#endif /* __linux__ */
860
861
Jouni Malinencd4e3c32015-10-29 12:39:56 +0200862static void static_ip_file(int proto, const char *addr, const char *mask,
863 const char *gw)
864{
865 if (proto) {
866 FILE *f = fopen("static-ip", "w");
867 if (f) {
868 fprintf(f, "%d %s %s %s\n", proto, addr,
869 mask ? mask : "N/A",
870 gw ? gw : "N/A");
871 fclose(f);
872 }
873 } else {
874 unlink("static-ip");
875 }
876}
877
878
879static int send_neighbor_request(struct sigma_dut *dut, const char *intf,
880 const char *ssid)
881{
882#ifdef __linux__
883 char buf[100];
884
885 snprintf(buf, sizeof(buf), "iwpriv %s neighbor %s",
886 intf, ssid);
887 sigma_dut_print(dut, DUT_MSG_INFO, "Request: %s", buf);
888
889 if (system(buf) != 0) {
890 sigma_dut_print(dut, DUT_MSG_ERROR,
891 "iwpriv neighbor request failed");
892 return -1;
893 }
894
895 sigma_dut_print(dut, DUT_MSG_INFO, "iwpriv neighbor request send");
896
897 return 0;
898#else /* __linux__ */
899 return -1;
900#endif /* __linux__ */
901}
902
903
904static int send_trans_mgmt_query(struct sigma_dut *dut, const char *intf,
Ashwini Patil5acd7382017-04-13 15:55:04 +0530905 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +0200906{
Ashwini Patil5acd7382017-04-13 15:55:04 +0530907 const char *val;
908 int reason_code = 0;
909 char buf[1024];
910
Jouni Malinencd4e3c32015-10-29 12:39:56 +0200911 /*
912 * In the earlier builds we used WNM_QUERY and in later
913 * builds used WNM_BSS_QUERY.
914 */
915
Ashwini Patil5acd7382017-04-13 15:55:04 +0530916 val = get_param(cmd, "BTMQuery_Reason_Code");
917 if (val)
918 reason_code = atoi(val);
919
920 val = get_param(cmd, "Cand_List");
921 if (val && atoi(val) == 1 && dut->btm_query_cand_list) {
922 snprintf(buf, sizeof(buf), "WNM_BSS_QUERY %d%s", reason_code,
923 dut->btm_query_cand_list);
924 free(dut->btm_query_cand_list);
925 dut->btm_query_cand_list = NULL;
926 } else {
927 snprintf(buf, sizeof(buf), "WNM_BSS_QUERY %d", reason_code);
928 }
929
930 if (wpa_command(intf, buf) != 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +0200931 sigma_dut_print(dut, DUT_MSG_ERROR,
932 "transition management query failed");
933 return -1;
934 }
935
936 sigma_dut_print(dut, DUT_MSG_DEBUG,
937 "transition management query sent");
938
939 return 0;
940}
941
942
943int is_ip_addr(const char *str)
944{
945 const char *pos = str;
946 struct in_addr addr;
947
948 while (*pos) {
949 if (*pos != '.' && (*pos < '0' || *pos > '9'))
950 return 0;
951 pos++;
952 }
953
954 return inet_aton(str, &addr);
955}
956
957
Jouni Malinencd4e3c32015-10-29 12:39:56 +0200958int get_ip_config(struct sigma_dut *dut, const char *ifname, char *buf,
959 size_t buf_len)
960{
vamsi krishnaa11d0732018-05-16 12:19:48 +0530961 char tmp[256];
Jouni Malinencd4e3c32015-10-29 12:39:56 +0200962 char ip[16], mask[15], dns[16], sec_dns[16];
963 int is_dhcp = 0;
964 int s;
965#ifdef ANDROID
966 char prop[PROPERTY_VALUE_MAX];
vamsi krishnaa11d0732018-05-16 12:19:48 +0530967#else /* ANDROID */
968 FILE *f;
969#ifdef __linux__
970 const char *str_ps;
971#endif /* __linux__ */
Jouni Malinencd4e3c32015-10-29 12:39:56 +0200972#endif /* ANDROID */
973
974 ip[0] = '\0';
975 mask[0] = '\0';
976 dns[0] = '\0';
977 sec_dns[0] = '\0';
978
979 s = socket(PF_INET, SOCK_DGRAM, 0);
980 if (s >= 0) {
981 struct ifreq ifr;
982 struct sockaddr_in saddr;
983
984 memset(&ifr, 0, sizeof(ifr));
Peng Xub8fc5cc2017-05-10 17:27:28 -0700985 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
Jouni Malinencd4e3c32015-10-29 12:39:56 +0200986 if (ioctl(s, SIOCGIFADDR, &ifr) < 0) {
987 sigma_dut_print(dut, DUT_MSG_INFO, "Failed to get "
988 "%s IP address: %s",
989 ifname, strerror(errno));
990 } else {
991 memcpy(&saddr, &ifr.ifr_addr,
992 sizeof(struct sockaddr_in));
Peng Xub8fc5cc2017-05-10 17:27:28 -0700993 strlcpy(ip, inet_ntoa(saddr.sin_addr), sizeof(ip));
Jouni Malinencd4e3c32015-10-29 12:39:56 +0200994 }
995
996 if (ioctl(s, SIOCGIFNETMASK, &ifr) == 0) {
997 memcpy(&saddr, &ifr.ifr_addr,
998 sizeof(struct sockaddr_in));
Peng Xub8fc5cc2017-05-10 17:27:28 -0700999 strlcpy(mask, inet_ntoa(saddr.sin_addr), sizeof(mask));
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001000 }
1001 close(s);
1002 }
1003
1004#ifdef ANDROID
1005 snprintf(tmp, sizeof(tmp), "dhcp.%s.pid", ifname);
1006 if (property_get(tmp, prop, NULL) != 0 && atoi(prop) > 0) {
1007 snprintf(tmp, sizeof(tmp), "dhcp.%s.result", ifname);
1008 if (property_get(tmp, prop, NULL) != 0 &&
1009 strcmp(prop, "ok") == 0) {
1010 snprintf(tmp, sizeof(tmp), "dhcp.%s.ipaddress",
1011 ifname);
1012 if (property_get(tmp, prop, NULL) != 0 &&
1013 strcmp(ip, prop) == 0)
1014 is_dhcp = 1;
1015 }
1016 }
1017
1018 snprintf(tmp, sizeof(tmp), "dhcp.%s.dns1", ifname);
Peng Xub8fc5cc2017-05-10 17:27:28 -07001019 if (property_get(tmp, prop, NULL) != 0)
1020 strlcpy(dns, prop, sizeof(dns));
1021 else if (property_get("net.dns1", prop, NULL) != 0)
1022 strlcpy(dns, prop, sizeof(dns));
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001023
1024 snprintf(tmp, sizeof(tmp), "dhcp.%s.dns2", ifname);
Peng Xub8fc5cc2017-05-10 17:27:28 -07001025 if (property_get(tmp, prop, NULL) != 0)
1026 strlcpy(sec_dns, prop, sizeof(sec_dns));
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001027#else /* ANDROID */
1028#ifdef __linux__
Jouni Malinen016ae6c2019-11-04 17:00:01 +02001029 if (get_driver_type(dut) == DRIVER_OPENWRT)
Sarvepalli, Rajesh Babua76c6442016-03-18 20:34:26 +05301030 str_ps = "ps -w";
1031 else
1032 str_ps = "ps ax";
1033 snprintf(tmp, sizeof(tmp),
1034 "%s | grep dhclient | grep -v grep | grep -q %s",
1035 str_ps, ifname);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001036 if (system(tmp) == 0)
1037 is_dhcp = 1;
1038 else {
Sarvepalli, Rajesh Babua76c6442016-03-18 20:34:26 +05301039 snprintf(tmp, sizeof(tmp),
1040 "%s | grep udhcpc | grep -v grep | grep -q %s",
1041 str_ps, ifname);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001042 if (system(tmp) == 0)
1043 is_dhcp = 1;
1044 else {
Sarvepalli, Rajesh Babua76c6442016-03-18 20:34:26 +05301045 snprintf(tmp, sizeof(tmp),
1046 "%s | grep dhcpcd | grep -v grep | grep -q %s",
1047 str_ps, ifname);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001048 if (system(tmp) == 0)
1049 is_dhcp = 1;
1050 }
1051 }
1052#endif /* __linux__ */
1053
1054 f = fopen("/etc/resolv.conf", "r");
1055 if (f) {
vamsi krishnaa11d0732018-05-16 12:19:48 +05301056 char *pos, *pos2;
1057
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001058 while (fgets(tmp, sizeof(tmp), f)) {
1059 if (strncmp(tmp, "nameserver", 10) != 0)
1060 continue;
1061 pos = tmp + 10;
1062 while (*pos == ' ' || *pos == '\t')
1063 pos++;
1064 pos2 = pos;
1065 while (*pos2) {
1066 if (*pos2 == '\n' || *pos2 == '\r') {
1067 *pos2 = '\0';
1068 break;
1069 }
1070 pos2++;
1071 }
Peng Xub8fc5cc2017-05-10 17:27:28 -07001072 if (!dns[0])
1073 strlcpy(dns, pos, sizeof(dns));
1074 else if (!sec_dns[0])
1075 strlcpy(sec_dns, pos, sizeof(sec_dns));
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001076 }
1077 fclose(f);
1078 }
1079#endif /* ANDROID */
1080
1081 snprintf(buf, buf_len, "dhcp,%d,ip,%s,mask,%s,primary-dns,%s",
1082 is_dhcp, ip, mask, dns);
1083 buf[buf_len - 1] = '\0';
1084
1085 return 0;
1086}
1087
1088
1089
1090
1091int get_ipv6_config(struct sigma_dut *dut, const char *ifname, char *buf,
1092 size_t buf_len)
1093{
1094#ifdef __linux__
1095#ifdef ANDROID
1096 char cmd[200], result[1000], *pos, *end;
1097 FILE *f;
1098 size_t len;
1099
1100 snprintf(cmd, sizeof(cmd), "ip addr show dev %s scope global", ifname);
1101 f = popen(cmd, "r");
1102 if (f == NULL)
1103 return -1;
1104 len = fread(result, 1, sizeof(result) - 1, f);
1105 pclose(f);
1106 if (len == 0)
1107 return -1;
1108 result[len] = '\0';
1109 sigma_dut_print(dut, DUT_MSG_DEBUG, "%s result: %s\n", cmd, result);
1110
1111 pos = strstr(result, "inet6 ");
1112 if (pos == NULL)
1113 return -1;
1114 pos += 6;
1115 end = strchr(pos, ' ');
1116 if (end)
1117 *end = '\0';
1118 end = strchr(pos, '/');
1119 if (end)
1120 *end = '\0';
1121 snprintf(buf, buf_len, "ip,%s", pos);
1122 buf[buf_len - 1] = '\0';
1123 return 0;
1124#else /* ANDROID */
1125 struct ifaddrs *ifaddr, *ifa;
1126 int res, found = 0;
1127 char host[NI_MAXHOST];
1128
1129 if (getifaddrs(&ifaddr) < 0) {
1130 perror("getifaddrs");
1131 return -1;
1132 }
1133
1134 for (ifa = ifaddr; ifa; ifa = ifa->ifa_next) {
1135 if (strcasecmp(ifname, ifa->ifa_name) != 0)
1136 continue;
1137 if (ifa->ifa_addr == NULL ||
1138 ifa->ifa_addr->sa_family != AF_INET6)
1139 continue;
1140
1141 res = getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in6),
1142 host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
1143 if (res != 0) {
1144 sigma_dut_print(dut, DUT_MSG_DEBUG, "getnameinfo: %s",
1145 gai_strerror(res));
1146 continue;
1147 }
1148 if (strncmp(host, "fe80::", 6) == 0)
1149 continue; /* skip link-local */
1150
1151 sigma_dut_print(dut, DUT_MSG_DEBUG, "ifaddr: %s", host);
1152 found = 1;
1153 break;
1154 }
1155
1156 freeifaddrs(ifaddr);
1157
1158 if (found) {
1159 char *pos;
1160 pos = strchr(host, '%');
1161 if (pos)
1162 *pos = '\0';
1163 snprintf(buf, buf_len, "ip,%s", host);
1164 buf[buf_len - 1] = '\0';
1165 return 0;
1166 }
1167
1168#endif /* ANDROID */
1169#endif /* __linux__ */
1170 return -1;
1171}
1172
1173
Jouni Malinenf7222712019-06-13 01:50:21 +03001174static enum sigma_cmd_result cmd_sta_get_ip_config(struct sigma_dut *dut,
1175 struct sigma_conn *conn,
1176 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001177{
1178 const char *intf = get_param(cmd, "Interface");
1179 const char *ifname;
1180 char buf[200];
1181 const char *val;
1182 int type = 1;
1183
1184 if (intf == NULL)
1185 return -1;
1186
Jouni Malinen016ae6c2019-11-04 17:00:01 +02001187 if (strcmp(intf, get_main_ifname(dut)) == 0)
1188 ifname = get_station_ifname(dut);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001189 else
1190 ifname = intf;
1191
1192 /*
1193 * UCC may assume the IP address to be available immediately after
1194 * association without trying to run sta_get_ip_config multiple times.
1195 * Sigma CAPI does not specify this command as a block command that
1196 * would wait for the address to become available, but to pass tests
1197 * more reliably, it looks like such a wait may be needed here.
1198 */
1199 if (wait_ip_addr(dut, ifname, 15) < 0) {
1200 sigma_dut_print(dut, DUT_MSG_INFO, "Could not get IP address "
1201 "for sta_get_ip_config");
1202 /*
1203 * Try to continue anyway since many UCC tests do not really
1204 * care about the return value from here..
1205 */
1206 }
1207
1208 val = get_param(cmd, "Type");
1209 if (val)
1210 type = atoi(val);
1211 if (type == 2 || dut->last_set_ip_config_ipv6) {
1212 int i;
1213
1214 /*
1215 * Since we do not have proper wait for IPv6 addresses, use a
1216 * fixed two second delay here as a workaround for UCC script
1217 * assuming IPv6 address is available when this command returns.
1218 * Some scripts did not use Type,2 properly for IPv6, so include
1219 * also the cases where the previous sta_set_ip_config indicated
1220 * use of IPv6.
1221 */
1222 sigma_dut_print(dut, DUT_MSG_INFO, "Wait up to extra ten seconds in sta_get_ip_config for IPv6 address");
1223 for (i = 0; i < 10; i++) {
1224 sleep(1);
1225 if (get_ipv6_config(dut, ifname, buf, sizeof(buf)) == 0)
1226 {
1227 sigma_dut_print(dut, DUT_MSG_INFO, "Found IPv6 address");
1228 send_resp(dut, conn, SIGMA_COMPLETE, buf);
1229#ifdef ANDROID
1230 sigma_dut_print(dut, DUT_MSG_INFO,
1231 "Adding IPv6 rule on Android");
1232 add_ipv6_rule(dut, intf);
1233#endif /* ANDROID */
1234
1235 return 0;
1236 }
1237 }
1238 }
1239 if (type == 1) {
1240 if (get_ip_config(dut, ifname, buf, sizeof(buf)) < 0)
1241 return -2;
1242 } else if (type == 2) {
1243 if (get_ipv6_config(dut, ifname, buf, sizeof(buf)) < 0)
1244 return -2;
1245 } else {
1246 send_resp(dut, conn, SIGMA_ERROR,
1247 "errorCode,Unsupported address type");
1248 return 0;
1249 }
1250
1251 send_resp(dut, conn, SIGMA_COMPLETE, buf);
1252 return 0;
1253}
1254
1255
1256static void kill_dhcp_client(struct sigma_dut *dut, const char *ifname)
1257{
1258#ifdef __linux__
1259 char buf[200];
1260 char path[128];
1261 struct stat s;
1262
1263#ifdef ANDROID
1264 snprintf(path, sizeof(path), "/data/misc/dhcp/dhcpcd-%s.pid", ifname);
1265#else /* ANDROID */
1266 snprintf(path, sizeof(path), "/var/run/dhclient-%s.pid", ifname);
1267#endif /* ANDROID */
1268 if (stat(path, &s) == 0) {
1269 snprintf(buf, sizeof(buf), "kill `cat %s`", path);
1270 sigma_dut_print(dut, DUT_MSG_INFO,
1271 "Kill previous DHCP client: %s", buf);
1272 if (system(buf) != 0)
1273 sigma_dut_print(dut, DUT_MSG_INFO,
1274 "Failed to kill DHCP client");
1275 unlink(path);
1276 sleep(1);
1277 } else {
1278 snprintf(path, sizeof(path), "/var/run/dhcpcd-%s.pid", ifname);
1279
1280 if (stat(path, &s) == 0) {
1281 snprintf(buf, sizeof(buf), "kill `cat %s`", path);
1282 sigma_dut_print(dut, DUT_MSG_INFO,
1283 "Kill previous DHCP client: %s", buf);
1284 if (system(buf) != 0)
1285 sigma_dut_print(dut, DUT_MSG_INFO,
1286 "Failed to kill DHCP client");
1287 unlink(path);
1288 sleep(1);
1289 }
1290 }
1291#endif /* __linux__ */
1292}
1293
1294
1295static int start_dhcp_client(struct sigma_dut *dut, const char *ifname)
1296{
1297#ifdef __linux__
1298 char buf[200];
1299
1300#ifdef ANDROID
Purushottam Kushwaha46d64262016-08-23 17:57:53 +05301301 if (access("/system/bin/dhcpcd", F_OK) != -1) {
1302 snprintf(buf, sizeof(buf),
1303 "/system/bin/dhcpcd -b %s", ifname);
1304 } else if (access("/system/bin/dhcptool", F_OK) != -1) {
1305 snprintf(buf, sizeof(buf), "/system/bin/dhcptool %s &", ifname);
Ankita Bajaj8454e5d2019-04-05 16:04:55 +05301306 } else if (access("/vendor/bin/dhcpcd", F_OK) != -1) {
1307 snprintf(buf, sizeof(buf), "/vendor/bin/dhcpcd -b %s", ifname);
1308 } else if (access("/vendor/bin/dhcptool", F_OK) != -1) {
1309 snprintf(buf, sizeof(buf), "/vendor/bin/dhcptool %s", ifname);
Purushottam Kushwaha46d64262016-08-23 17:57:53 +05301310 } else {
1311 sigma_dut_print(dut, DUT_MSG_ERROR,
1312 "DHCP client program missing");
1313 return 0;
1314 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001315#else /* ANDROID */
1316 snprintf(buf, sizeof(buf),
1317 "dhclient -nw -pf /var/run/dhclient-%s.pid %s",
1318 ifname, ifname);
1319#endif /* ANDROID */
1320 sigma_dut_print(dut, DUT_MSG_INFO, "Start DHCP client: %s", buf);
1321 if (system(buf) != 0) {
1322 snprintf(buf, sizeof(buf), "dhcpcd -t 0 %s &", ifname);
1323 if (system(buf) != 0) {
1324 sigma_dut_print(dut, DUT_MSG_INFO,
1325 "Failed to start DHCP client");
1326#ifndef ANDROID
1327 return -1;
1328#endif /* ANDROID */
1329 }
1330 }
1331#endif /* __linux__ */
1332
1333 return 0;
1334}
1335
1336
1337static int clear_ip_addr(struct sigma_dut *dut, const char *ifname)
1338{
1339#ifdef __linux__
1340 char buf[200];
1341
1342 snprintf(buf, sizeof(buf), "ip addr flush dev %s", ifname);
1343 if (system(buf) != 0) {
1344 sigma_dut_print(dut, DUT_MSG_INFO,
1345 "Failed to clear IP addresses");
1346 return -1;
1347 }
1348#endif /* __linux__ */
1349
1350 return 0;
1351}
1352
1353
1354#ifdef ANDROID
1355static int add_ipv6_rule(struct sigma_dut *dut, const char *ifname)
1356{
1357 char cmd[200], *result, *pos;
1358 FILE *fp;
Pradeep Reddy POTTETIf58a1fe2016-10-13 17:22:03 +05301359 int tableid;
1360 size_t len, result_len = 1000;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001361
1362 snprintf(cmd, sizeof(cmd), "ip -6 route list table all | grep %s",
1363 ifname);
1364 fp = popen(cmd, "r");
1365 if (fp == NULL)
1366 return -1;
1367
1368 result = malloc(result_len);
Pradeep Reddy POTTETI673d85c2016-07-26 19:08:07 +05301369 if (result == NULL) {
1370 fclose(fp);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001371 return -1;
Pradeep Reddy POTTETI673d85c2016-07-26 19:08:07 +05301372 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001373
Pradeep Reddy POTTETIf58a1fe2016-10-13 17:22:03 +05301374 len = fread(result, 1, result_len - 1, fp);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001375 fclose(fp);
1376
1377 if (len == 0) {
1378 free(result);
1379 return -1;
1380 }
Pradeep Reddy POTTETIf58a1fe2016-10-13 17:22:03 +05301381 result[len] = '\0';
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001382
1383 pos = strstr(result, "table ");
1384 if (pos == NULL) {
1385 free(result);
1386 return -1;
1387 }
1388
1389 pos += strlen("table ");
1390 tableid = atoi(pos);
1391 if (tableid != 0) {
1392 if (system("ip -6 rule del prio 22000") != 0) {
1393 /* ignore any error */
1394 }
1395 snprintf(cmd, sizeof(cmd),
1396 "ip -6 rule add from all lookup %d prio 22000",
1397 tableid);
1398 if (system(cmd) != 0) {
1399 sigma_dut_print(dut, DUT_MSG_INFO,
1400 "Failed to run %s", cmd);
1401 free(result);
1402 return -1;
1403 }
1404 } else {
1405 sigma_dut_print(dut, DUT_MSG_INFO,
1406 "No Valid Table Id found %s", pos);
1407 free(result);
1408 return -1;
1409 }
1410 free(result);
1411
1412 return 0;
1413}
1414#endif /* ANDROID */
1415
1416
Ankita Bajaj1bde7942018-01-09 19:15:01 +05301417int set_ipv4_addr(struct sigma_dut *dut, const char *ifname,
1418 const char *ip, const char *mask)
1419{
1420 char buf[200];
1421
1422 snprintf(buf, sizeof(buf), "ifconfig %s %s netmask %s",
1423 ifname, ip, mask);
1424 return system(buf) == 0;
1425}
1426
1427
1428int set_ipv4_gw(struct sigma_dut *dut, const char *gw)
1429{
1430 char buf[200];
1431
1432 if (!is_ip_addr(gw)) {
1433 sigma_dut_print(dut, DUT_MSG_DEBUG, "Invalid gw addr - %s", gw);
1434 return -1;
1435 }
1436
1437 snprintf(buf, sizeof(buf), "route add default gw %s", gw);
1438 if (!dut->no_ip_addr_set && system(buf) != 0) {
1439 snprintf(buf, sizeof(buf), "ip ro re default via %s",
1440 gw);
1441 if (system(buf) != 0)
1442 return 0;
1443 }
1444
1445 return 1;
1446}
1447
1448
Jouni Malinenf7222712019-06-13 01:50:21 +03001449static enum sigma_cmd_result cmd_sta_set_ip_config(struct sigma_dut *dut,
1450 struct sigma_conn *conn,
1451 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001452{
1453 const char *intf = get_param(cmd, "Interface");
1454 const char *ifname;
1455 char buf[200];
1456 const char *val, *ip, *mask, *gw;
1457 int type = 1;
1458
1459 if (intf == NULL)
1460 return -1;
1461
Jouni Malinen016ae6c2019-11-04 17:00:01 +02001462 if (strcmp(intf, get_main_ifname(dut)) == 0)
1463 ifname = get_station_ifname(dut);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001464 else
1465 ifname = intf;
1466
1467 if (if_nametoindex(ifname) == 0) {
1468 send_resp(dut, conn, SIGMA_ERROR,
1469 "ErrorCode,Unknown interface");
1470 return 0;
1471 }
1472
1473 val = get_param(cmd, "Type");
1474 if (val) {
1475 type = atoi(val);
Ankita Bajaj1bde7942018-01-09 19:15:01 +05301476 if (type < 1 || type > 3) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001477 send_resp(dut, conn, SIGMA_ERROR,
1478 "ErrorCode,Unsupported address type");
1479 return 0;
1480 }
1481 }
1482
1483 dut->last_set_ip_config_ipv6 = 0;
1484
1485 val = get_param(cmd, "dhcp");
1486 if (val && (strcmp(val, "1") == 0 || strcasecmp(val, "true") == 0)) {
1487 static_ip_file(0, NULL, NULL, NULL);
1488#ifdef __linux__
1489 if (type == 2) {
1490 dut->last_set_ip_config_ipv6 = 1;
1491 sigma_dut_print(dut, DUT_MSG_INFO, "Using IPv6 "
1492 "stateless address autoconfiguration");
1493#ifdef ANDROID
1494 /*
1495 * This sleep is required as the assignment in case of
1496 * Android is taking time and is done by the kernel.
1497 * The subsequent ping for IPv6 is impacting HS20 test
1498 * case.
1499 */
1500 sleep(2);
1501 add_ipv6_rule(dut, intf);
1502#endif /* ANDROID */
1503 /* Assume this happens by default */
1504 return 1;
1505 }
Ankita Bajaj1bde7942018-01-09 19:15:01 +05301506 if (type != 3) {
1507 kill_dhcp_client(dut, ifname);
1508 if (start_dhcp_client(dut, ifname) < 0)
1509 return -2;
1510 } else {
1511 sigma_dut_print(dut, DUT_MSG_DEBUG,
1512 "Using FILS HLP DHCPv4 Rapid Commit");
1513 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001514
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001515 return 1;
1516#endif /* __linux__ */
1517 return -2;
1518 }
1519
1520 ip = get_param(cmd, "ip");
Pradeep Reddy POTTETIb18c5652016-01-18 12:45:37 +05301521 if (!ip) {
1522 send_resp(dut, conn, SIGMA_INVALID,
1523 "ErrorCode,Missing IP address");
1524 return 0;
1525 }
1526
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001527 mask = get_param(cmd, "mask");
Pradeep Reddy POTTETIb18c5652016-01-18 12:45:37 +05301528 if (!mask) {
1529 send_resp(dut, conn, SIGMA_INVALID,
1530 "ErrorCode,Missing subnet mask");
1531 return 0;
1532 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001533
1534 if (type == 2) {
1535 int net = atoi(mask);
1536
1537 if ((net < 0 && net > 64) || !is_ipv6_addr(ip))
1538 return -1;
1539
1540 if (dut->no_ip_addr_set) {
1541 snprintf(buf, sizeof(buf),
1542 "sysctl net.ipv6.conf.%s.disable_ipv6=1",
1543 ifname);
1544 sigma_dut_print(dut, DUT_MSG_DEBUG, "Run: %s", buf);
1545 if (system(buf) != 0) {
1546 sigma_dut_print(dut, DUT_MSG_DEBUG,
1547 "Failed to disable IPv6 address before association");
1548 }
1549 } else {
Veerendranath Jakkam176181c2020-05-16 00:19:21 +05301550 if (set_ipv6_addr(dut, ip, mask, ifname) != 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001551 send_resp(dut, conn, SIGMA_ERROR,
1552 "ErrorCode,Failed to set IPv6 address");
1553 return 0;
1554 }
1555 }
1556
1557 dut->last_set_ip_config_ipv6 = 1;
1558 static_ip_file(6, ip, mask, NULL);
1559 return 1;
1560 } else if (type == 1) {
Pradeep Reddy POTTETIb18c5652016-01-18 12:45:37 +05301561 if (!is_ip_addr(ip) || !is_ip_addr(mask))
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001562 return -1;
1563 }
1564
1565 kill_dhcp_client(dut, ifname);
1566
1567 if (!dut->no_ip_addr_set) {
Ankita Bajaj1bde7942018-01-09 19:15:01 +05301568 if (!set_ipv4_addr(dut, ifname, ip, mask)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001569 send_resp(dut, conn, SIGMA_ERROR,
1570 "ErrorCode,Failed to set IP address");
1571 return 0;
1572 }
1573 }
1574
1575 gw = get_param(cmd, "defaultGateway");
1576 if (gw) {
Ankita Bajaj1bde7942018-01-09 19:15:01 +05301577 if (set_ipv4_gw(dut, gw) < 1) {
1578 send_resp(dut, conn, SIGMA_ERROR,
1579 "ErrorCode,Failed to set default gateway");
1580 return 0;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001581 }
1582 }
1583
1584 val = get_param(cmd, "primary-dns");
1585 if (val) {
1586 /* TODO */
1587 sigma_dut_print(dut, DUT_MSG_INFO, "Ignored primary-dns %s "
1588 "setting", val);
1589 }
1590
1591 val = get_param(cmd, "secondary-dns");
1592 if (val) {
1593 /* TODO */
1594 sigma_dut_print(dut, DUT_MSG_INFO, "Ignored secondary-dns %s "
1595 "setting", val);
1596 }
1597
1598 static_ip_file(4, ip, mask, gw);
1599
1600 return 1;
1601}
1602
1603
Jouni Malinenf7222712019-06-13 01:50:21 +03001604static enum sigma_cmd_result cmd_sta_get_info(struct sigma_dut *dut,
1605 struct sigma_conn *conn,
1606 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001607{
1608 /* const char *intf = get_param(cmd, "Interface"); */
1609 /* TODO: could report more details here */
1610 send_resp(dut, conn, SIGMA_COMPLETE, "vendor,Atheros");
1611 return 0;
1612}
1613
1614
Jouni Malinenf7222712019-06-13 01:50:21 +03001615static enum sigma_cmd_result cmd_sta_get_mac_address(struct sigma_dut *dut,
1616 struct sigma_conn *conn,
1617 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001618{
1619 /* const char *intf = get_param(cmd, "Interface"); */
1620 char addr[20], resp[50];
1621
Ankita Bajaj0d5825b2017-10-25 16:20:17 +05301622 if (dut->dev_role == DEVROLE_STA_CFON)
1623 return sta_cfon_get_mac_address(dut, conn, cmd);
1624
Jouni Malinen9540e012019-11-05 17:08:42 +02001625 start_sta_mode(dut);
Jouni Malinen016ae6c2019-11-04 17:00:01 +02001626 if (get_wpa_status(get_station_ifname(dut), "address",
1627 addr, sizeof(addr)) < 0)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001628 return -2;
1629
1630 snprintf(resp, sizeof(resp), "mac,%s", addr);
1631 send_resp(dut, conn, SIGMA_COMPLETE, resp);
1632 return 0;
1633}
1634
1635
Jouni Malinenf7222712019-06-13 01:50:21 +03001636static enum sigma_cmd_result cmd_sta_is_connected(struct sigma_dut *dut,
1637 struct sigma_conn *conn,
1638 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001639{
1640 /* const char *intf = get_param(cmd, "Interface"); */
1641 int connected = 0;
1642 char result[32];
Jouni Malinen016ae6c2019-11-04 17:00:01 +02001643 if (get_wpa_status(get_station_ifname(dut), "wpa_state", result,
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001644 sizeof(result)) < 0) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02001645 sigma_dut_print(dut, DUT_MSG_INFO,
1646 "Could not get interface %s status",
1647 get_station_ifname(dut));
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001648 return -2;
1649 }
1650
1651 sigma_dut_print(dut, DUT_MSG_DEBUG, "wpa_state=%s", result);
1652 if (strncmp(result, "COMPLETED", 9) == 0)
1653 connected = 1;
1654
1655 if (connected)
1656 send_resp(dut, conn, SIGMA_COMPLETE, "connected,1");
1657 else
1658 send_resp(dut, conn, SIGMA_COMPLETE, "connected,0");
1659
1660 return 0;
1661}
1662
1663
Jouni Malinenf7222712019-06-13 01:50:21 +03001664static enum sigma_cmd_result
1665cmd_sta_verify_ip_connection(struct sigma_dut *dut, struct sigma_conn *conn,
1666 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001667{
1668 /* const char *intf = get_param(cmd, "Interface"); */
1669 const char *dst, *timeout;
1670 int wait_time = 90;
1671 char buf[100];
1672 int res;
1673
1674 dst = get_param(cmd, "destination");
1675 if (dst == NULL || !is_ip_addr(dst))
1676 return -1;
1677
1678 timeout = get_param(cmd, "timeout");
1679 if (timeout) {
1680 wait_time = atoi(timeout);
1681 if (wait_time < 1)
1682 wait_time = 1;
1683 }
1684
1685 /* TODO: force renewal of IP lease if DHCP is enabled */
1686
1687 snprintf(buf, sizeof(buf), "ping %s -c 3 -W %d", dst, wait_time);
1688 res = system(buf);
1689 sigma_dut_print(dut, DUT_MSG_DEBUG, "ping returned: %d", res);
1690 if (res == 0)
1691 send_resp(dut, conn, SIGMA_COMPLETE, "connected,1");
1692 else if (res == 256)
1693 send_resp(dut, conn, SIGMA_COMPLETE, "connected,0");
1694 else
1695 return -2;
1696
1697 return 0;
1698}
1699
1700
Jouni Malinenf7222712019-06-13 01:50:21 +03001701static enum sigma_cmd_result cmd_sta_get_bssid(struct sigma_dut *dut,
1702 struct sigma_conn *conn,
1703 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001704{
1705 /* const char *intf = get_param(cmd, "Interface"); */
1706 char bssid[20], resp[50];
1707
Jouni Malinen016ae6c2019-11-04 17:00:01 +02001708 if (get_wpa_status(get_station_ifname(dut), "bssid",
1709 bssid, sizeof(bssid)) < 0)
Peng Xub8fc5cc2017-05-10 17:27:28 -07001710 strlcpy(bssid, "00:00:00:00:00:00", sizeof(bssid));
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001711
1712 snprintf(resp, sizeof(resp), "bssid,%s", bssid);
1713 send_resp(dut, conn, SIGMA_COMPLETE, resp);
1714 return 0;
1715}
1716
1717
1718#ifdef __SAMSUNG__
1719static int add_use_network(const char *ifname)
1720{
1721 char buf[100];
1722
1723 snprintf(buf, sizeof(buf), "USE_NETWORK ON");
1724 wpa_command(ifname, buf);
1725 return 0;
1726}
1727#endif /* __SAMSUNG__ */
1728
1729
1730static int add_network_common(struct sigma_dut *dut, struct sigma_conn *conn,
1731 const char *ifname, struct sigma_cmd *cmd)
1732{
1733 const char *ssid = get_param(cmd, "ssid");
1734 int id;
1735 const char *val;
1736
1737 if (ssid == NULL)
1738 return -1;
1739
1740 start_sta_mode(dut);
1741
1742#ifdef __SAMSUNG__
1743 add_use_network(ifname);
1744#endif /* __SAMSUNG__ */
1745
1746 id = add_network(ifname);
1747 if (id < 0)
1748 return -2;
1749 sigma_dut_print(dut, DUT_MSG_DEBUG, "Adding network %d", id);
1750
1751 if (set_network_quoted(ifname, id, "ssid", ssid) < 0)
1752 return -2;
1753
1754 dut->infra_network_id = id;
1755 snprintf(dut->infra_ssid, sizeof(dut->infra_ssid), "%s", ssid);
1756
1757 val = get_param(cmd, "program");
1758 if (!val)
1759 val = get_param(cmd, "prog");
1760 if (val && strcasecmp(val, "hs2") == 0) {
1761 char buf[100];
1762 snprintf(buf, sizeof(buf), "ENABLE_NETWORK %d no-connect", id);
1763 wpa_command(ifname, buf);
1764
1765 val = get_param(cmd, "prefer");
1766 if (val && atoi(val) > 0)
1767 set_network(ifname, id, "priority", "1");
1768 }
1769
1770 return id;
1771}
1772
1773
Jouni Malinenf7222712019-06-13 01:50:21 +03001774static enum sigma_cmd_result cmd_sta_set_encryption(struct sigma_dut *dut,
1775 struct sigma_conn *conn,
1776 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001777{
1778 const char *intf = get_param(cmd, "Interface");
1779 const char *ssid = get_param(cmd, "ssid");
1780 const char *type = get_param(cmd, "encpType");
1781 const char *ifname;
1782 char buf[200];
1783 int id;
1784
1785 if (intf == NULL || ssid == NULL)
1786 return -1;
1787
Jouni Malinen016ae6c2019-11-04 17:00:01 +02001788 if (strcmp(intf, get_main_ifname(dut)) == 0)
1789 ifname = get_station_ifname(dut);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001790 else
1791 ifname = intf;
1792
1793 id = add_network_common(dut, conn, ifname, cmd);
1794 if (id < 0)
1795 return id;
1796
1797 if (set_network(ifname, id, "key_mgmt", "NONE") < 0)
1798 return -2;
1799
1800 if (type && strcasecmp(type, "wep") == 0) {
1801 const char *val;
1802 int i;
1803
1804 val = get_param(cmd, "activeKey");
1805 if (val) {
1806 int keyid;
1807 keyid = atoi(val);
1808 if (keyid < 1 || keyid > 4)
1809 return -1;
1810 snprintf(buf, sizeof(buf), "%d", keyid - 1);
1811 if (set_network(ifname, id, "wep_tx_keyidx", buf) < 0)
1812 return -2;
1813 }
1814
1815 for (i = 0; i < 4; i++) {
1816 snprintf(buf, sizeof(buf), "key%d", i + 1);
1817 val = get_param(cmd, buf);
1818 if (val == NULL)
1819 continue;
1820 snprintf(buf, sizeof(buf), "wep_key%d", i);
1821 if (set_network(ifname, id, buf, val) < 0)
1822 return -2;
1823 }
1824 }
1825
1826 return 1;
1827}
1828
1829
Jouni Malinene4fde732019-03-25 22:29:37 +02001830static int set_akm_suites(struct sigma_dut *dut, const char *ifname,
1831 int id, const char *val)
1832{
1833 char key_mgmt[200], *end, *pos;
1834 const char *in_pos = val;
1835
Jouni Malinen8179fee2019-03-28 03:19:47 +02001836 dut->akm_values = 0;
Jouni Malinene4fde732019-03-25 22:29:37 +02001837 pos = key_mgmt;
1838 end = pos + sizeof(key_mgmt);
1839 while (*in_pos) {
1840 int res, akm = atoi(in_pos);
1841 const char *str;
1842
Jouni Malinen8179fee2019-03-28 03:19:47 +02001843 if (akm >= 0 && akm < 32)
1844 dut->akm_values |= 1 << akm;
1845
Jouni Malinene4fde732019-03-25 22:29:37 +02001846 switch (akm) {
1847 case AKM_WPA_EAP:
1848 str = "WPA-EAP";
1849 break;
1850 case AKM_WPA_PSK:
1851 str = "WPA-PSK";
1852 break;
1853 case AKM_FT_EAP:
1854 str = "FT-EAP";
1855 break;
1856 case AKM_FT_PSK:
1857 str = "FT-PSK";
1858 break;
1859 case AKM_EAP_SHA256:
1860 str = "WPA-EAP-SHA256";
1861 break;
1862 case AKM_PSK_SHA256:
1863 str = "WPA-PSK-SHA256";
1864 break;
1865 case AKM_SAE:
1866 str = "SAE";
1867 break;
1868 case AKM_FT_SAE:
1869 str = "FT-SAE";
1870 break;
1871 case AKM_SUITE_B:
1872 str = "WPA-EAP-SUITE-B-192";
1873 break;
1874 case AKM_FT_SUITE_B:
1875 str = "FT-EAP-SHA384";
1876 break;
1877 case AKM_FILS_SHA256:
1878 str = "FILS-SHA256";
1879 break;
1880 case AKM_FILS_SHA384:
1881 str = "FILS-SHA384";
1882 break;
1883 case AKM_FT_FILS_SHA256:
1884 str = "FT-FILS-SHA256";
1885 break;
1886 case AKM_FT_FILS_SHA384:
1887 str = "FT-FILS-SHA384";
1888 break;
1889 default:
1890 sigma_dut_print(dut, DUT_MSG_ERROR,
1891 "Unsupported AKMSuitetype %d", akm);
1892 return -1;
1893 }
1894
1895 res = snprintf(pos, end - pos, "%s%s",
1896 pos == key_mgmt ? "" : " ", str);
1897 if (res < 0 || res >= end - pos)
1898 return -1;
1899 pos += res;
1900
1901 in_pos = strchr(in_pos, ';');
1902 if (!in_pos)
1903 break;
1904 while (*in_pos == ';')
1905 in_pos++;
1906 }
1907 sigma_dut_print(dut, DUT_MSG_DEBUG, "AKMSuiteType %s --> %s",
1908 val, key_mgmt);
1909 return set_network(ifname, id, "key_mgmt", key_mgmt);
1910}
1911
1912
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001913static int set_wpa_common(struct sigma_dut *dut, struct sigma_conn *conn,
1914 const char *ifname, struct sigma_cmd *cmd)
1915{
1916 const char *val;
1917 int id;
Jouni Malinenad395a22017-09-01 21:13:46 +03001918 int cipher_set = 0;
Jouni Malinen47dcc952017-10-09 16:43:24 +03001919 int owe;
Sunil Duttc75a1e62018-01-11 20:47:50 +05301920 int suite_b = 0;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001921
1922 id = add_network_common(dut, conn, ifname, cmd);
1923 if (id < 0)
1924 return id;
1925
Jouni Malinen47dcc952017-10-09 16:43:24 +03001926 val = get_param(cmd, "Type");
1927 owe = val && strcasecmp(val, "OWE") == 0;
1928
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001929 val = get_param(cmd, "keyMgmtType");
Jouni Malinen47dcc952017-10-09 16:43:24 +03001930 if (!val && owe)
1931 val = "OWE";
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001932 if (val == NULL) {
Jouni Malinene4fde732019-03-25 22:29:37 +02001933 /* keyMgmtType is being replaced with AKMSuiteType, so ignore
1934 * this missing parameter and assume proto=WPA2. */
1935 if (set_network(ifname, id, "proto", "WPA2") < 0)
1936 return ERROR_SEND_STATUS;
1937 } else if (strcasecmp(val, "wpa") == 0 ||
1938 strcasecmp(val, "wpa-psk") == 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001939 if (set_network(ifname, id, "proto", "WPA") < 0)
1940 return -2;
1941 } else if (strcasecmp(val, "wpa2") == 0 ||
1942 strcasecmp(val, "wpa2-psk") == 0 ||
1943 strcasecmp(val, "wpa2-ft") == 0 ||
1944 strcasecmp(val, "wpa2-sha256") == 0) {
1945 if (set_network(ifname, id, "proto", "WPA2") < 0)
1946 return -2;
Pradeep Reddy POTTETI6d04b3b2016-11-15 14:51:26 +05301947 } else if (strcasecmp(val, "wpa2-wpa-psk") == 0 ||
1948 strcasecmp(val, "wpa2-wpa-ent") == 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001949 if (set_network(ifname, id, "proto", "WPA WPA2") < 0)
1950 return -2;
Jouni Malinenad395a22017-09-01 21:13:46 +03001951 } else if (strcasecmp(val, "SuiteB") == 0) {
Sunil Duttc75a1e62018-01-11 20:47:50 +05301952 suite_b = 1;
Jouni Malinenad395a22017-09-01 21:13:46 +03001953 if (set_network(ifname, id, "proto", "WPA2") < 0)
1954 return -2;
Jouni Malinen47dcc952017-10-09 16:43:24 +03001955 } else if (strcasecmp(val, "OWE") == 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02001956 } else {
1957 send_resp(dut, conn, SIGMA_INVALID, "errorCode,Unrecognized keyMgmtType value");
1958 return 0;
1959 }
1960
1961 val = get_param(cmd, "encpType");
Jouni Malinenad395a22017-09-01 21:13:46 +03001962 if (val) {
1963 cipher_set = 1;
1964 if (strcasecmp(val, "tkip") == 0) {
1965 if (set_network(ifname, id, "pairwise", "TKIP") < 0)
1966 return -2;
1967 } else if (strcasecmp(val, "aes-ccmp") == 0) {
1968 if (set_network(ifname, id, "pairwise", "CCMP") < 0)
1969 return -2;
1970 } else if (strcasecmp(val, "aes-ccmp-tkip") == 0) {
1971 if (set_network(ifname, id, "pairwise",
1972 "CCMP TKIP") < 0)
1973 return -2;
1974 } else if (strcasecmp(val, "aes-gcmp") == 0) {
1975 if (set_network(ifname, id, "pairwise", "GCMP") < 0)
1976 return -2;
1977 if (set_network(ifname, id, "group", "GCMP") < 0)
1978 return -2;
1979 } else {
1980 send_resp(dut, conn, SIGMA_ERROR,
1981 "errorCode,Unrecognized encpType value");
1982 return 0;
1983 }
1984 }
1985
1986 val = get_param(cmd, "PairwiseCipher");
1987 if (val) {
1988 cipher_set = 1;
1989 /* TODO: Support space separated list */
1990 if (strcasecmp(val, "AES-GCMP-256") == 0) {
1991 if (set_network(ifname, id, "pairwise", "GCMP-256") < 0)
1992 return -2;
1993 } else if (strcasecmp(val, "AES-CCMP-256") == 0) {
1994 if (set_network(ifname, id, "pairwise",
1995 "CCMP-256") < 0)
1996 return -2;
1997 } else if (strcasecmp(val, "AES-GCMP-128") == 0) {
1998 if (set_network(ifname, id, "pairwise", "GCMP") < 0)
1999 return -2;
2000 } else if (strcasecmp(val, "AES-CCMP-128") == 0) {
2001 if (set_network(ifname, id, "pairwise", "CCMP") < 0)
2002 return -2;
2003 } else {
2004 send_resp(dut, conn, SIGMA_ERROR,
2005 "errorCode,Unrecognized PairwiseCipher value");
2006 return 0;
2007 }
2008 }
2009
Jouni Malinen47dcc952017-10-09 16:43:24 +03002010 if (!cipher_set && !owe) {
Jouni Malinenad395a22017-09-01 21:13:46 +03002011 send_resp(dut, conn, SIGMA_ERROR,
2012 "errorCode,Missing encpType and PairwiseCipher");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002013 return 0;
2014 }
Jouni Malinenad395a22017-09-01 21:13:46 +03002015
2016 val = get_param(cmd, "GroupCipher");
2017 if (val) {
2018 if (strcasecmp(val, "AES-GCMP-256") == 0) {
2019 if (set_network(ifname, id, "group", "GCMP-256") < 0)
2020 return -2;
2021 } else if (strcasecmp(val, "AES-CCMP-256") == 0) {
2022 if (set_network(ifname, id, "group", "CCMP-256") < 0)
2023 return -2;
2024 } else if (strcasecmp(val, "AES-GCMP-128") == 0) {
2025 if (set_network(ifname, id, "group", "GCMP") < 0)
2026 return -2;
2027 } else if (strcasecmp(val, "AES-CCMP-128") == 0) {
2028 if (set_network(ifname, id, "group", "CCMP") < 0)
2029 return -2;
2030 } else {
2031 send_resp(dut, conn, SIGMA_ERROR,
2032 "errorCode,Unrecognized GroupCipher value");
2033 return 0;
2034 }
2035 }
2036
Jouni Malinen7b239522017-09-14 21:37:18 +03002037 val = get_param(cmd, "GroupMgntCipher");
Jouni Malinenad395a22017-09-01 21:13:46 +03002038 if (val) {
Jouni Malinene8898cb2017-09-26 17:55:26 +03002039 const char *cipher;
2040
2041 if (strcasecmp(val, "BIP-GMAC-256") == 0) {
2042 cipher = "BIP-GMAC-256";
2043 } else if (strcasecmp(val, "BIP-CMAC-256") == 0) {
2044 cipher = "BIP-CMAC-256";
2045 } else if (strcasecmp(val, "BIP-GMAC-128") == 0) {
2046 cipher = "BIP-GMAC-128";
2047 } else if (strcasecmp(val, "BIP-CMAC-128") == 0) {
2048 cipher = "AES-128-CMAC";
2049 } else {
2050 send_resp(dut, conn, SIGMA_INVALID,
2051 "errorCode,Unsupported GroupMgntCipher");
2052 return 0;
2053 }
2054 if (set_network(ifname, id, "group_mgmt", cipher) < 0) {
2055 send_resp(dut, conn, SIGMA_INVALID,
2056 "errorCode,Failed to set GroupMgntCipher");
2057 return 0;
2058 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002059 }
2060
Jouni Malinene4fde732019-03-25 22:29:37 +02002061 val = get_param(cmd, "AKMSuiteType");
2062 if (val && set_akm_suites(dut, ifname, id, val) < 0)
2063 return ERROR_SEND_STATUS;
2064
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002065 dut->sta_pmf = STA_PMF_DISABLED;
vamsi krishnaf39bc1e2017-08-23 17:37:53 +05302066
2067 if (dut->program == PROGRAM_OCE) {
2068 dut->sta_pmf = STA_PMF_OPTIONAL;
2069 if (set_network(ifname, id, "ieee80211w", "1") < 0)
2070 return -2;
2071 }
2072
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002073 val = get_param(cmd, "PMF");
2074 if (val) {
2075 if (strcasecmp(val, "Required") == 0 ||
2076 strcasecmp(val, "Forced_Required") == 0) {
2077 dut->sta_pmf = STA_PMF_REQUIRED;
2078 if (set_network(ifname, id, "ieee80211w", "2") < 0)
2079 return -2;
2080 } else if (strcasecmp(val, "Optional") == 0) {
2081 dut->sta_pmf = STA_PMF_OPTIONAL;
2082 if (set_network(ifname, id, "ieee80211w", "1") < 0)
2083 return -2;
2084 } else if (strcasecmp(val, "Disabled") == 0 ||
Kiran Kumar Lokere07da3b22018-12-16 22:42:49 -08002085 strcasecmp(val, "Disable") == 0 ||
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002086 strcasecmp(val, "Forced_Disabled") == 0) {
2087 dut->sta_pmf = STA_PMF_DISABLED;
2088 } else {
2089 send_resp(dut, conn, SIGMA_INVALID, "errorCode,Unrecognized PMF value");
2090 return 0;
2091 }
Sunil Duttc75a1e62018-01-11 20:47:50 +05302092 } else if (owe || suite_b) {
Jouni Malinen1287cd72018-01-04 17:08:01 +02002093 dut->sta_pmf = STA_PMF_REQUIRED;
2094 if (set_network(ifname, id, "ieee80211w", "2") < 0)
2095 return -2;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002096 }
2097
Jouni Malinen0165c7f2020-03-26 11:51:58 +02002098 val = get_param(cmd, "BeaconProtection");
Veerendranath Jakkamc1f71b62021-01-23 03:09:51 +05302099 if (val)
2100 dut->beacon_prot = atoi(val);
2101 if (dut->beacon_prot && set_network(ifname, id, "beacon_prot", "1") < 0)
Jouni Malinen0165c7f2020-03-26 11:51:58 +02002102 return ERROR_SEND_STATUS;
2103
Veerendranath Jakkam54fd51c2020-12-21 01:36:04 +05302104 if (dut->ocvc && set_network(ifname, id, "ocv", "1") < 0)
2105 return ERROR_SEND_STATUS;
2106
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002107 return id;
2108}
2109
2110
Jouni Malinenf7222712019-06-13 01:50:21 +03002111static enum sigma_cmd_result cmd_sta_set_psk(struct sigma_dut *dut,
2112 struct sigma_conn *conn,
2113 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002114{
2115 const char *intf = get_param(cmd, "Interface");
Jouni Malinen992a81e2017-08-22 13:57:47 +03002116 const char *type = get_param(cmd, "Type");
Jouni Malinen1287cd72018-01-04 17:08:01 +02002117 const char *pmf = get_param(cmd, "PMF");
Alexei Avshalom Lazard596b512018-12-18 16:00:59 +02002118 const char *network_mode = get_param(cmd, "network_mode");
Jouni Malinene4fde732019-03-25 22:29:37 +02002119 const char *akm = get_param(cmd, "AKMSuiteType");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002120 const char *ifname, *val, *alg;
2121 int id;
Jouni Malinen4b3769d2019-10-10 16:20:29 +03002122 char buf[50];
Jouni Malinen11e55212019-11-22 21:46:59 +02002123 int sae_pwe = -1;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002124
2125 if (intf == NULL)
2126 return -1;
2127
Jouni Malinen016ae6c2019-11-04 17:00:01 +02002128 if (strcmp(intf, get_main_ifname(dut)) == 0)
2129 ifname = get_station_ifname(dut);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002130 else
2131 ifname = intf;
2132
2133 id = set_wpa_common(dut, conn, ifname, cmd);
2134 if (id < 0)
2135 return id;
2136
2137 val = get_param(cmd, "keyMgmtType");
2138 alg = get_param(cmd, "micAlg");
2139
Jouni Malinen992a81e2017-08-22 13:57:47 +03002140 if (type && strcasecmp(type, "SAE") == 0) {
Jouni Malinene4fde732019-03-25 22:29:37 +02002141 if (!akm && val && strcasecmp(val, "wpa2-ft") == 0) {
Jouni Malinen992a81e2017-08-22 13:57:47 +03002142 if (set_network(ifname, id, "key_mgmt", "FT-SAE") < 0)
2143 return -2;
Jouni Malinene4fde732019-03-25 22:29:37 +02002144 } else if (!akm) {
Jouni Malinen992a81e2017-08-22 13:57:47 +03002145 if (set_network(ifname, id, "key_mgmt", "SAE") < 0)
2146 return -2;
2147 }
2148 if (wpa_command(ifname, "SET sae_groups ") != 0) {
2149 sigma_dut_print(dut, DUT_MSG_ERROR,
2150 "Failed to clear sae_groups to default");
2151 return -2;
2152 }
Jouni Malinen1287cd72018-01-04 17:08:01 +02002153 if (!pmf) {
2154 dut->sta_pmf = STA_PMF_REQUIRED;
2155 if (set_network(ifname, id, "ieee80211w", "2") < 0)
2156 return -2;
2157 }
Jouni Malinen0ab50f42017-08-31 01:34:59 +03002158 } else if (type && strcasecmp(type, "PSK-SAE") == 0) {
2159 if (val && strcasecmp(val, "wpa2-ft") == 0) {
2160 if (set_network(ifname, id, "key_mgmt",
2161 "FT-SAE FT-PSK") < 0)
2162 return -2;
Jouni Malinen3b73d872019-06-12 03:13:25 +03002163 } else if (!akm) {
Jouni Malinen0ab50f42017-08-31 01:34:59 +03002164 if (set_network(ifname, id, "key_mgmt",
2165 "SAE WPA-PSK") < 0)
2166 return -2;
2167 }
2168 if (wpa_command(ifname, "SET sae_groups ") != 0) {
2169 sigma_dut_print(dut, DUT_MSG_ERROR,
2170 "Failed to clear sae_groups to default");
2171 return -2;
2172 }
Jouni Malinen1287cd72018-01-04 17:08:01 +02002173 if (!pmf) {
2174 dut->sta_pmf = STA_PMF_OPTIONAL;
2175 if (set_network(ifname, id, "ieee80211w", "1") < 0)
2176 return -2;
2177 }
Jouni Malinen992a81e2017-08-22 13:57:47 +03002178 } else if (alg && strcasecmp(alg, "SHA-256") == 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002179 if (set_network(ifname, id, "key_mgmt", "WPA-PSK-SHA256") < 0)
2180 return -2;
2181 } else if (alg && strcasecmp(alg, "SHA-1") == 0) {
2182 if (set_network(ifname, id, "key_mgmt", "WPA-PSK") < 0)
2183 return -2;
Ashwini Patil6dbf7b02017-03-20 13:42:11 +05302184 } else if (val && strcasecmp(val, "wpa2-ft") == 0) {
2185 if (set_network(ifname, id, "key_mgmt", "FT-PSK") < 0)
2186 return -2;
Jouni Malinen3b73d872019-06-12 03:13:25 +03002187 } else if (!akm &&
2188 ((val && strcasecmp(val, "wpa2-sha256") == 0) ||
2189 dut->sta_pmf == STA_PMF_REQUIRED)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002190 if (set_network(ifname, id, "key_mgmt",
2191 "WPA-PSK WPA-PSK-SHA256") < 0)
2192 return -2;
Jouni Malinen77ff3f02019-03-28 03:45:40 +02002193 } else if (!akm && dut->sta_pmf == STA_PMF_OPTIONAL) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002194 if (set_network(ifname, id, "key_mgmt",
2195 "WPA-PSK WPA-PSK-SHA256") < 0)
2196 return -2;
Jouni Malinen77ff3f02019-03-28 03:45:40 +02002197 } else if (!akm) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002198 if (set_network(ifname, id, "key_mgmt", "WPA-PSK") < 0)
2199 return -2;
2200 }
2201
2202 val = get_param(cmd, "passPhrase");
2203 if (val == NULL)
2204 return -1;
Jouni Malinen2126f422017-10-11 23:24:33 +03002205 if (type && strcasecmp(type, "SAE") == 0) {
2206 if (set_network_quoted(ifname, id, "sae_password", val) < 0)
2207 return -2;
2208 } else {
2209 if (set_network_quoted(ifname, id, "psk", val) < 0)
2210 return -2;
2211 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002212
Jouni Malinen78d10c42019-03-25 22:34:32 +02002213 val = get_param(cmd, "PasswordId");
2214 if (val && set_network_quoted(ifname, id, "sae_password_id", val) < 0)
2215 return ERROR_SEND_STATUS;
2216
Jouni Malinen992a81e2017-08-22 13:57:47 +03002217 val = get_param(cmd, "ECGroupID");
2218 if (val) {
Jouni Malinenb54f0df2019-12-12 01:57:29 +02002219 snprintf(buf, sizeof(buf), "SET sae_groups %s", val);
Jouni Malinen992a81e2017-08-22 13:57:47 +03002220 if (wpa_command(ifname, buf) != 0) {
2221 sigma_dut_print(dut, DUT_MSG_ERROR,
2222 "Failed to clear sae_groups");
2223 return -2;
2224 }
2225 }
2226
Jouni Malinen68143132017-09-02 02:34:08 +03002227 val = get_param(cmd, "InvalidSAEElement");
2228 if (val) {
2229 free(dut->sae_commit_override);
2230 dut->sae_commit_override = strdup(val);
2231 }
2232
Jouni Malinen4b3769d2019-10-10 16:20:29 +03002233 val = get_param(cmd, "PMKID_Include");
2234 if (val) {
2235 snprintf(buf, sizeof(buf), "SET sae_pmkid_in_assoc %d",
2236 get_enable_disable(val));
2237 wpa_command(intf, buf);
2238 }
2239
Jouni Malineneeb43d32019-12-06 17:40:07 +02002240 val = get_param(cmd, "IgnoreH2E_RSNXE_BSSMemSel");
2241 if (val) {
2242 snprintf(buf, sizeof(buf), "SET ignore_sae_h2e_only %d",
2243 get_enable_disable(val));
2244 wpa_command(intf, buf);
2245 }
2246
Jouni Malinenf2348d22019-12-07 11:52:55 +02002247 val = get_param(cmd, "ECGroupID_RGE");
2248 if (val) {
2249 snprintf(buf, sizeof(buf), "SET extra_sae_rejected_groups %s",
2250 val);
2251 wpa_command(intf, buf);
2252 }
2253
Jouni Malinen99e55022019-12-07 13:59:41 +02002254 val = get_param(cmd, "RSNXE_Content");
2255 if (val) {
2256 const char *param;
2257
2258 if (strncasecmp(val, "AssocReq:", 9) == 0) {
2259 val += 9;
2260 param = "rsnxe_override_assoc";
2261 } else if (strncasecmp(val, "EapolM2:", 8) == 0) {
2262 val += 8;
2263 param = "rsnxe_override_eapol";
2264 } else {
2265 send_resp(dut, conn, SIGMA_ERROR,
2266 "errorCode,Unsupported RSNXE_Content value");
2267 return STATUS_SENT_ERROR;
2268 }
2269 snprintf(buf, sizeof(buf), "SET %s %s", param, val);
2270 wpa_command(intf, buf);
2271 }
2272
Jouni Malinen11e55212019-11-22 21:46:59 +02002273 val = get_param(cmd, "sae_pwe");
2274 if (val) {
2275 if (strcasecmp(val, "h2e") == 0) {
2276 dut->sae_pwe = SAE_PWE_H2E;
Jouni Malinen7244a412019-12-07 11:54:10 +02002277 } else if (strcasecmp(val, "loop") == 0 ||
2278 strcasecmp(val, "looping") == 0) {
Jouni Malinen11e55212019-11-22 21:46:59 +02002279 dut->sae_pwe = SAE_PWE_LOOP;
2280 } else {
2281 send_resp(dut, conn, SIGMA_ERROR,
2282 "errorCode,Unsupported sae_pwe value");
2283 return STATUS_SENT_ERROR;
2284 }
2285 }
Vinita S. Maloo6d7454f2020-04-02 15:03:26 +05302286
2287 val = get_param(cmd, "Clear_RSNXE");
2288 if (val && strcmp(val, "1") == 0 &&
2289 (wpa_command(intf, "SET rsnxe_override_assoc ") ||
2290 wpa_command(intf, "SET rsnxe_override_eapol "))) {
2291 send_resp(dut, conn, SIGMA_ERROR,
2292 "errorCode,Failed to clear RSNXE");
Jouni Malinenb11498c2020-08-03 11:05:53 +03002293 return STATUS_SENT_ERROR;
Vinita S. Maloo6d7454f2020-04-02 15:03:26 +05302294 }
2295
Jouni Malinenc0078772020-03-04 21:23:16 +02002296 if (dut->sae_pwe == SAE_PWE_LOOP && get_param(cmd, "PasswordId"))
2297 sae_pwe = 3;
2298 else if (dut->sae_pwe == SAE_PWE_LOOP)
Jouni Malinen11e55212019-11-22 21:46:59 +02002299 sae_pwe = 0;
2300 else if (dut->sae_pwe == SAE_PWE_H2E)
2301 sae_pwe = 1;
2302 else if (dut->sae_h2e_default)
2303 sae_pwe = 2;
2304 snprintf(buf, sizeof(buf), "SET sae_pwe %d", sae_pwe);
2305 if (sae_pwe >= 0 && wpa_command(ifname, buf) != 0)
2306 return ERROR_SEND_STATUS;
2307
Veerendranath Jakkam0316be12020-06-23 20:11:41 +05302308 val = get_param(cmd, "sae_pk");
2309 if (val && strcmp(val, "0") == 0 &&
2310 set_network(ifname, id, "sae_pk", "2") < 0)
2311 return ERROR_SEND_STATUS;
2312
Veerendranath Jakkama9177042020-08-10 00:14:03 +05302313 val = get_param(cmd, "sae_pk_only");
2314 if (val && strcmp(val, "1") == 0 &&
2315 set_network(ifname, id, "sae_pk", "1") < 0)
2316 return ERROR_SEND_STATUS;
2317
Alexei Avshalom Lazard596b512018-12-18 16:00:59 +02002318 if (dut->program == PROGRAM_60GHZ && network_mode &&
2319 strcasecmp(network_mode, "PBSS") == 0 &&
2320 set_network(ifname, id, "pbss", "1") < 0)
2321 return -2;
2322
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002323 return 1;
2324}
2325
2326
Jouni Malinen8ac93452019-08-14 15:19:13 +03002327static enum sigma_cmd_result set_trust_root_system(struct sigma_dut *dut,
2328 struct sigma_conn *conn,
2329 const char *ifname, int id)
2330{
2331 char buf[200];
2332
2333 snprintf(buf, sizeof(buf), "%s/certs", sigma_cert_path);
2334 if (!file_exists(buf))
2335 strlcpy(buf, "/system/etc/security/cacerts", sizeof(buf));
2336 if (!file_exists(buf))
2337 strlcpy(buf, "/etc/ssl/certs", sizeof(buf));
2338 if (!file_exists(buf)) {
2339 char msg[300];
2340
2341 snprintf(msg, sizeof(msg),
2342 "ErrorCode,trustedRootCA system store (%s) not found",
2343 buf);
2344 send_resp(dut, conn, SIGMA_ERROR, msg);
2345 return STATUS_SENT_ERROR;
2346 }
2347
2348 if (set_network_quoted(ifname, id, "ca_path", buf) < 0)
2349 return ERROR_SEND_STATUS;
2350
2351 return SUCCESS_SEND_STATUS;
2352}
2353
2354
2355static enum sigma_cmd_result set_trust_root(struct sigma_dut *dut,
2356 struct sigma_conn *conn,
2357 const char *ifname, int id,
2358 const char *val)
2359{
2360 char buf[200];
2361#ifdef ANDROID
2362 unsigned char kvalue[KEYSTORE_MESSAGE_SIZE];
2363 int length;
2364#endif /* ANDROID */
2365
2366 if (strcmp(val, "DEFAULT") == 0)
2367 return set_trust_root_system(dut, conn, ifname, id);
2368
2369#ifdef ANDROID
2370 snprintf(buf, sizeof(buf), "CACERT_%s", val);
2371 length = android_keystore_get(ANDROID_KEYSTORE_GET, buf, kvalue);
2372 if (length > 0) {
2373 sigma_dut_print(dut, DUT_MSG_INFO, "Use Android keystore [%s]",
2374 buf);
2375 snprintf(buf, sizeof(buf), "keystore://CACERT_%s", val);
2376 goto ca_cert_selected;
2377 }
2378#endif /* ANDROID */
2379
2380 snprintf(buf, sizeof(buf), "%s/%s", sigma_cert_path, val);
2381#ifdef __linux__
2382 if (!file_exists(buf)) {
2383 char msg[300];
2384
2385 snprintf(msg, sizeof(msg),
2386 "ErrorCode,trustedRootCA file (%s) not found", buf);
2387 send_resp(dut, conn, SIGMA_ERROR, msg);
2388 return STATUS_SENT_ERROR;
2389 }
2390#endif /* __linux__ */
2391#ifdef ANDROID
2392ca_cert_selected:
2393#endif /* ANDROID */
2394 if (set_network_quoted(ifname, id, "ca_cert", buf) < 0)
2395 return ERROR_SEND_STATUS;
2396
2397 return SUCCESS_SEND_STATUS;
2398}
2399
2400
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002401static int set_eap_common(struct sigma_dut *dut, struct sigma_conn *conn,
Bala Krishna Bhamidipati73d7af02016-03-24 12:27:56 +05302402 const char *ifname, int username_identity,
2403 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002404{
Jouni Malinenb4d56ba2019-08-23 18:17:44 +03002405 const char *val, *alg, *akm, *trust_root, *domain, *domain_suffix;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002406 int id;
Jouni Malinen53264f62019-05-03 13:04:40 +03002407 char buf[200], buf2[300];
Jouni Malinen8179fee2019-03-28 03:19:47 +02002408 int erp = 0;
Jouni Malinen8ac93452019-08-14 15:19:13 +03002409 enum sigma_cmd_result res;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002410
2411 id = set_wpa_common(dut, conn, ifname, cmd);
2412 if (id < 0)
2413 return id;
2414
2415 val = get_param(cmd, "keyMgmtType");
2416 alg = get_param(cmd, "micAlg");
vamsi krishnaf39bc1e2017-08-23 17:37:53 +05302417 akm = get_param(cmd, "AKMSuiteType");
Jouni Malinenb4d56ba2019-08-23 18:17:44 +03002418 trust_root = get_param(cmd, "trustedRootCA");
2419 domain = get_param(cmd, "Domain");
2420 domain_suffix = get_param(cmd, "DomainSuffix");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002421
Jouni Malinenad395a22017-09-01 21:13:46 +03002422 if (val && strcasecmp(val, "SuiteB") == 0) {
2423 if (set_network(ifname, id, "key_mgmt", "WPA-EAP-SUITE-B-192") <
2424 0)
2425 return -2;
2426 } else if (alg && strcasecmp(alg, "SHA-256") == 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002427 if (set_network(ifname, id, "key_mgmt", "WPA-EAP-SHA256") < 0)
2428 return -2;
2429 } else if (alg && strcasecmp(alg, "SHA-1") == 0) {
2430 if (set_network(ifname, id, "key_mgmt", "WPA-EAP") < 0)
2431 return -2;
2432 } else if (val && strcasecmp(val, "wpa2-ft") == 0) {
2433 if (set_network(ifname, id, "key_mgmt", "FT-EAP") < 0)
2434 return -2;
Jouni Malinend6a9d692019-03-28 03:01:24 +02002435 } else if (!akm &&
2436 ((val && strcasecmp(val, "wpa2-sha256") == 0) ||
2437 dut->sta_pmf == STA_PMF_REQUIRED)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002438 if (set_network(ifname, id, "key_mgmt",
2439 "WPA-EAP WPA-EAP-SHA256") < 0)
2440 return -2;
vamsi krishnaf39bc1e2017-08-23 17:37:53 +05302441 } else if (akm && atoi(akm) == 14) {
2442 if (dut->sta_pmf == STA_PMF_OPTIONAL ||
2443 dut->sta_pmf == STA_PMF_REQUIRED) {
2444 if (set_network(ifname, id, "key_mgmt",
2445 "WPA-EAP-SHA256 FILS-SHA256") < 0)
2446 return -2;
2447 } else {
2448 if (set_network(ifname, id, "key_mgmt",
2449 "WPA-EAP FILS-SHA256") < 0)
2450 return -2;
2451 }
2452
Jouni Malinen8179fee2019-03-28 03:19:47 +02002453 erp = 1;
vamsi krishnaf39bc1e2017-08-23 17:37:53 +05302454 } else if (akm && atoi(akm) == 15) {
2455 if (dut->sta_pmf == STA_PMF_OPTIONAL ||
2456 dut->sta_pmf == STA_PMF_REQUIRED) {
2457 if (set_network(ifname, id, "key_mgmt",
2458 "WPA-EAP-SHA256 FILS-SHA384") < 0)
2459 return -2;
2460 } else {
2461 if (set_network(ifname, id, "key_mgmt",
2462 "WPA-EAP FILS-SHA384") < 0)
2463 return -2;
2464 }
2465
Jouni Malinen8179fee2019-03-28 03:19:47 +02002466 erp = 1;
Jouni Malinend6a9d692019-03-28 03:01:24 +02002467 } else if (!akm && dut->sta_pmf == STA_PMF_OPTIONAL) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002468 if (set_network(ifname, id, "key_mgmt",
2469 "WPA-EAP WPA-EAP-SHA256") < 0)
2470 return -2;
Jouni Malinend6a9d692019-03-28 03:01:24 +02002471 } else if (!akm) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002472 if (set_network(ifname, id, "key_mgmt", "WPA-EAP") < 0)
2473 return -2;
2474 }
2475
Jouni Malinenb4d56ba2019-08-23 18:17:44 +03002476 if (trust_root) {
2477 if (strcmp(trust_root, "DEFAULT") == 0 && !domain &&
2478 !domain_suffix) {
2479 send_resp(dut, conn, SIGMA_ERROR,
2480 "errorCode,trustRootCA DEFAULT used without specifying Domain or DomainSuffix");
2481 return STATUS_SENT_ERROR;
2482 }
2483 res = set_trust_root(dut, conn, ifname, id, trust_root);
Jouni Malinen8ac93452019-08-14 15:19:13 +03002484 if (res != SUCCESS_SEND_STATUS)
2485 return res;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002486 }
2487
Jouni Malinen53264f62019-05-03 13:04:40 +03002488 val = get_param(cmd, "ServerCert");
2489 if (val) {
2490 FILE *f;
2491 char *result = NULL, *pos;
2492
2493 snprintf(buf, sizeof(buf), "%s/%s.sha256", sigma_cert_path,
2494 val);
2495 f = fopen(buf, "r");
2496 if (f) {
2497 result = fgets(buf, sizeof(buf), f);
2498 fclose(f);
2499 }
2500 if (!result) {
2501 snprintf(buf2, sizeof(buf2),
2502 "ErrorCode,ServerCert hash could not be read from %s",
2503 buf);
2504 send_resp(dut, conn, SIGMA_ERROR, buf2);
2505 return STATUS_SENT_ERROR;
2506 }
2507 pos = strchr(buf, '\n');
2508 if (pos)
2509 *pos = '\0';
Jouni Malinen0572a742020-10-08 13:53:25 +03002510 pos = strchr(buf, '\r');
2511 if (pos)
2512 *pos = '\0';
Jouni Malinen53264f62019-05-03 13:04:40 +03002513 snprintf(buf2, sizeof(buf2), "hash://server/sha256/%s", buf);
2514 if (set_network_quoted(ifname, id, "ca_cert", buf2) < 0)
2515 return ERROR_SEND_STATUS;
Jouni Malinen29108dc2019-06-13 23:42:11 +03002516
2517 snprintf(buf, sizeof(buf), "%s/%s.tod", sigma_cert_path, val);
2518 if (file_exists(buf)) {
2519 sigma_dut_print(dut, DUT_MSG_DEBUG,
2520 "TOD policy enabled for the configured ServerCert hash");
2521 dut->sta_tod_policy = 1;
2522 }
Jouni Malinen53264f62019-05-03 13:04:40 +03002523 }
2524
Jouni Malinenb4d56ba2019-08-23 18:17:44 +03002525 if (domain &&
2526 set_network_quoted(ifname, id, "domain_match", domain) < 0)
Jouni Malinen96f84b02019-05-03 12:32:56 +03002527 return ERROR_SEND_STATUS;
2528
Jouni Malinenb4d56ba2019-08-23 18:17:44 +03002529 if (domain_suffix &&
2530 set_network_quoted(ifname, id, "domain_suffix_match",
2531 domain_suffix) < 0)
Jouni Malinen96f84b02019-05-03 12:32:56 +03002532 return ERROR_SEND_STATUS;
2533
Bala Krishna Bhamidipati73d7af02016-03-24 12:27:56 +05302534 if (username_identity) {
2535 val = get_param(cmd, "username");
2536 if (val) {
2537 if (set_network_quoted(ifname, id, "identity", val) < 0)
2538 return -2;
2539 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002540
Bala Krishna Bhamidipati73d7af02016-03-24 12:27:56 +05302541 val = get_param(cmd, "password");
2542 if (val) {
2543 if (set_network_quoted(ifname, id, "password", val) < 0)
2544 return -2;
2545 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002546 }
2547
Jouni Malinen8179fee2019-03-28 03:19:47 +02002548 if (dut->akm_values &
2549 ((1 << AKM_FILS_SHA256) |
2550 (1 << AKM_FILS_SHA384) |
2551 (1 << AKM_FT_FILS_SHA256) |
2552 (1 << AKM_FT_FILS_SHA384)))
2553 erp = 1;
2554 if (erp && set_network(ifname, id, "erp", "1") < 0)
2555 return ERROR_SEND_STATUS;
2556
Jouni Malinen134fe3c2019-06-12 04:16:49 +03002557 dut->sta_associate_wait_connect = 1;
2558
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002559 return id;
2560}
2561
2562
Jouni Malinen5eabb2a2017-10-03 18:17:30 +03002563static int set_tls_cipher(const char *ifname, int id, const char *cipher)
2564{
2565 const char *val;
2566
2567 if (!cipher)
2568 return 0;
2569
2570 if (strcasecmp(cipher, "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384") == 0)
2571 val = "ECDHE-ECDSA-AES256-GCM-SHA384";
2572 else if (strcasecmp(cipher,
2573 "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384") == 0)
2574 val = "ECDHE-RSA-AES256-GCM-SHA384";
2575 else if (strcasecmp(cipher, "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384") == 0)
2576 val = "DHE-RSA-AES256-GCM-SHA384";
2577 else if (strcasecmp(cipher,
2578 "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256") == 0)
2579 val = "ECDHE-ECDSA-AES128-GCM-SHA256";
2580 else
2581 return -1;
2582
2583 /* Need to clear phase1="tls_suiteb=1" to allow cipher enforcement */
2584 set_network_quoted(ifname, id, "phase1", "");
2585
2586 return set_network_quoted(ifname, id, "openssl_ciphers", val);
2587}
2588
2589
Jouni Malinenf7222712019-06-13 01:50:21 +03002590static enum sigma_cmd_result cmd_sta_set_eaptls(struct sigma_dut *dut,
2591 struct sigma_conn *conn,
2592 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002593{
2594 const char *intf = get_param(cmd, "Interface");
2595 const char *ifname, *val;
2596 int id;
2597 char buf[200];
2598#ifdef ANDROID
2599 unsigned char kvalue[KEYSTORE_MESSAGE_SIZE];
2600 int length;
2601 int jb_or_newer = 0;
2602 char prop[PROPERTY_VALUE_MAX];
2603#endif /* ANDROID */
2604
2605 if (intf == NULL)
2606 return -1;
2607
Jouni Malinen016ae6c2019-11-04 17:00:01 +02002608 if (strcmp(intf, get_main_ifname(dut)) == 0)
2609 ifname = get_station_ifname(dut);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002610 else
2611 ifname = intf;
2612
Bala Krishna Bhamidipati73d7af02016-03-24 12:27:56 +05302613 id = set_eap_common(dut, conn, ifname, 1, cmd);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002614 if (id < 0)
2615 return id;
2616
2617 if (set_network(ifname, id, "eap", "TLS") < 0)
2618 return -2;
2619
Pradeep Reddy POTTETI9f6c2132016-05-05 16:28:19 +05302620 if (!get_param(cmd, "username") &&
2621 set_network_quoted(ifname, id, "identity",
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002622 "wifi-user@wifilabs.local") < 0)
2623 return -2;
2624
2625 val = get_param(cmd, "clientCertificate");
2626 if (val == NULL)
2627 return -1;
2628#ifdef ANDROID
2629 snprintf(buf, sizeof(buf), "USRPKEY_%s", val);
2630 length = android_keystore_get(ANDROID_KEYSTORE_GET, buf, kvalue);
2631 if (length < 0) {
2632 /*
2633 * JB started reporting keystore type mismatches, so retry with
2634 * the GET_PUBKEY command if the generic GET fails.
2635 */
2636 length = android_keystore_get(ANDROID_KEYSTORE_GET_PUBKEY,
2637 buf, kvalue);
2638 }
2639
2640 if (property_get("ro.build.version.release", prop, NULL) != 0) {
2641 sigma_dut_print(dut, DUT_MSG_DEBUG, "Android release %s", prop);
2642 if (strncmp(prop, "4.0", 3) != 0)
2643 jb_or_newer = 1;
2644 } else
2645 jb_or_newer = 1; /* assume newer */
2646
2647 if (jb_or_newer && length > 0) {
2648 sigma_dut_print(dut, DUT_MSG_INFO,
2649 "Use Android keystore [%s]", buf);
2650 if (set_network(ifname, id, "engine", "1") < 0)
2651 return -2;
2652 if (set_network_quoted(ifname, id, "engine_id", "keystore") < 0)
2653 return -2;
2654 snprintf(buf, sizeof(buf), "USRPKEY_%s", val);
2655 if (set_network_quoted(ifname, id, "key_id", buf) < 0)
2656 return -2;
2657 snprintf(buf, sizeof(buf), "keystore://USRCERT_%s", val);
2658 if (set_network_quoted(ifname, id, "client_cert", buf) < 0)
2659 return -2;
2660 return 1;
2661 } else if (length > 0) {
2662 sigma_dut_print(dut, DUT_MSG_INFO,
2663 "Use Android keystore [%s]", buf);
2664 snprintf(buf, sizeof(buf), "keystore://USRPKEY_%s", val);
2665 if (set_network_quoted(ifname, id, "private_key", buf) < 0)
2666 return -2;
2667 snprintf(buf, sizeof(buf), "keystore://USRCERT_%s", val);
2668 if (set_network_quoted(ifname, id, "client_cert", buf) < 0)
2669 return -2;
2670 return 1;
2671 }
2672#endif /* ANDROID */
2673
2674 snprintf(buf, sizeof(buf), "%s/%s", sigma_cert_path, val);
2675#ifdef __linux__
2676 if (!file_exists(buf)) {
2677 char msg[300];
2678 snprintf(msg, sizeof(msg), "ErrorCode,clientCertificate file "
2679 "(%s) not found", buf);
2680 send_resp(dut, conn, SIGMA_ERROR, msg);
2681 return -3;
2682 }
2683#endif /* __linux__ */
2684 if (set_network_quoted(ifname, id, "private_key", buf) < 0)
2685 return -2;
2686 if (set_network_quoted(ifname, id, "client_cert", buf) < 0)
2687 return -2;
2688
2689 if (set_network_quoted(ifname, id, "private_key_passwd", "wifi") < 0)
2690 return -2;
2691
Jouni Malinen5eabb2a2017-10-03 18:17:30 +03002692 val = get_param(cmd, "keyMgmtType");
2693 if (val && strcasecmp(val, "SuiteB") == 0) {
2694 val = get_param(cmd, "CertType");
2695 if (val && strcasecmp(val, "RSA") == 0) {
2696 if (set_network_quoted(ifname, id, "phase1",
2697 "tls_suiteb=1") < 0)
2698 return -2;
2699 } else {
2700 if (set_network_quoted(ifname, id, "openssl_ciphers",
2701 "SUITEB192") < 0)
2702 return -2;
2703 }
2704
2705 val = get_param(cmd, "TLSCipher");
2706 if (set_tls_cipher(ifname, id, val) < 0) {
2707 send_resp(dut, conn, SIGMA_ERROR,
2708 "ErrorCode,Unsupported TLSCipher value");
2709 return -3;
2710 }
2711 }
2712
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002713 return 1;
2714}
2715
2716
Jouni Malinenf7222712019-06-13 01:50:21 +03002717static enum sigma_cmd_result cmd_sta_set_eapttls(struct sigma_dut *dut,
2718 struct sigma_conn *conn,
2719 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002720{
2721 const char *intf = get_param(cmd, "Interface");
2722 const char *ifname;
2723 int id;
2724
2725 if (intf == NULL)
2726 return -1;
2727
Jouni Malinen016ae6c2019-11-04 17:00:01 +02002728 if (strcmp(intf, get_main_ifname(dut)) == 0)
2729 ifname = get_station_ifname(dut);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002730 else
2731 ifname = intf;
2732
Bala Krishna Bhamidipati73d7af02016-03-24 12:27:56 +05302733 id = set_eap_common(dut, conn, ifname, 1, cmd);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002734 if (id < 0)
2735 return id;
2736
2737 if (set_network(ifname, id, "eap", "TTLS") < 0) {
2738 send_resp(dut, conn, SIGMA_ERROR,
2739 "errorCode,Failed to set TTLS method");
2740 return 0;
2741 }
2742
2743 if (set_network_quoted(ifname, id, "phase2", "auth=MSCHAPV2") < 0) {
2744 send_resp(dut, conn, SIGMA_ERROR,
2745 "errorCode,Failed to set MSCHAPv2 for TTLS Phase 2");
2746 return 0;
2747 }
2748
2749 return 1;
2750}
2751
2752
Jouni Malinenf7222712019-06-13 01:50:21 +03002753static enum sigma_cmd_result cmd_sta_set_eapsim(struct sigma_dut *dut,
2754 struct sigma_conn *conn,
2755 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002756{
2757 const char *intf = get_param(cmd, "Interface");
2758 const char *ifname;
2759 int id;
2760
2761 if (intf == NULL)
2762 return -1;
2763
Jouni Malinen016ae6c2019-11-04 17:00:01 +02002764 if (strcmp(intf, get_main_ifname(dut)) == 0)
2765 ifname = get_station_ifname(dut);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002766 else
2767 ifname = intf;
2768
Bala Krishna Bhamidipati73d7af02016-03-24 12:27:56 +05302769 id = set_eap_common(dut, conn, ifname, !dut->sim_no_username, cmd);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002770 if (id < 0)
2771 return id;
2772
2773 if (set_network(ifname, id, "eap", "SIM") < 0)
2774 return -2;
2775
2776 return 1;
2777}
2778
2779
Jouni Malinenf7222712019-06-13 01:50:21 +03002780static enum sigma_cmd_result cmd_sta_set_peap(struct sigma_dut *dut,
2781 struct sigma_conn *conn,
2782 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002783{
2784 const char *intf = get_param(cmd, "Interface");
2785 const char *ifname, *val;
2786 int id;
2787 char buf[100];
2788
2789 if (intf == NULL)
2790 return -1;
2791
Jouni Malinen016ae6c2019-11-04 17:00:01 +02002792 if (strcmp(intf, get_main_ifname(dut)) == 0)
2793 ifname = get_station_ifname(dut);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002794 else
2795 ifname = intf;
2796
Bala Krishna Bhamidipati73d7af02016-03-24 12:27:56 +05302797 id = set_eap_common(dut, conn, ifname, 1, cmd);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002798 if (id < 0)
2799 return id;
2800
2801 if (set_network(ifname, id, "eap", "PEAP") < 0)
2802 return -2;
2803
2804 val = get_param(cmd, "innerEAP");
2805 if (val) {
2806 if (strcasecmp(val, "MSCHAPv2") == 0) {
2807 if (set_network_quoted(ifname, id, "phase2",
2808 "auth=MSCHAPV2") < 0)
2809 return -2;
2810 } else if (strcasecmp(val, "GTC") == 0) {
2811 if (set_network_quoted(ifname, id, "phase2",
2812 "auth=GTC") < 0)
2813 return -2;
2814 } else
2815 return -1;
2816 }
2817
2818 val = get_param(cmd, "peapVersion");
2819 if (val) {
2820 int ver = atoi(val);
2821 if (ver < 0 || ver > 1)
2822 return -1;
2823 snprintf(buf, sizeof(buf), "peapver=%d", ver);
2824 if (set_network_quoted(ifname, id, "phase1", buf) < 0)
2825 return -2;
2826 }
2827
2828 return 1;
2829}
2830
2831
Jouni Malinenf7222712019-06-13 01:50:21 +03002832static enum sigma_cmd_result cmd_sta_set_eapfast(struct sigma_dut *dut,
2833 struct sigma_conn *conn,
2834 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002835{
2836 const char *intf = get_param(cmd, "Interface");
2837 const char *ifname, *val;
2838 int id;
2839 char buf[100];
2840
2841 if (intf == NULL)
2842 return -1;
2843
Jouni Malinen016ae6c2019-11-04 17:00:01 +02002844 if (strcmp(intf, get_main_ifname(dut)) == 0)
2845 ifname = get_station_ifname(dut);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002846 else
2847 ifname = intf;
2848
Bala Krishna Bhamidipati73d7af02016-03-24 12:27:56 +05302849 id = set_eap_common(dut, conn, ifname, 1, cmd);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002850 if (id < 0)
2851 return id;
2852
2853 if (set_network(ifname, id, "eap", "FAST") < 0)
2854 return -2;
2855
2856 val = get_param(cmd, "innerEAP");
2857 if (val) {
2858 if (strcasecmp(val, "MSCHAPV2") == 0) {
2859 if (set_network_quoted(ifname, id, "phase2",
2860 "auth=MSCHAPV2") < 0)
2861 return -2;
2862 } else if (strcasecmp(val, "GTC") == 0) {
2863 if (set_network_quoted(ifname, id, "phase2",
2864 "auth=GTC") < 0)
2865 return -2;
2866 } else
2867 return -1;
2868 }
2869
2870 val = get_param(cmd, "validateServer");
2871 if (val) {
2872 /* TODO */
2873 sigma_dut_print(dut, DUT_MSG_INFO, "Ignored EAP-FAST "
2874 "validateServer=%s", val);
2875 }
2876
2877 val = get_param(cmd, "pacFile");
2878 if (val) {
2879 snprintf(buf, sizeof(buf), "blob://%s", val);
2880 if (set_network_quoted(ifname, id, "pac_file", buf) < 0)
2881 return -2;
2882 }
2883
2884 if (set_network_quoted(ifname, id, "phase1", "fast_provisioning=2") <
2885 0)
2886 return -2;
2887
2888 return 1;
2889}
2890
2891
Jouni Malinenf7222712019-06-13 01:50:21 +03002892static enum sigma_cmd_result cmd_sta_set_eapaka(struct sigma_dut *dut,
2893 struct sigma_conn *conn,
2894 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002895{
2896 const char *intf = get_param(cmd, "Interface");
Purushottam Kushwahacdd8cb12019-10-04 11:33:59 +05302897 const char *username = get_param(cmd, "Username");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002898 const char *ifname;
2899 int id;
2900
2901 if (intf == NULL)
2902 return -1;
2903
Jouni Malinen016ae6c2019-11-04 17:00:01 +02002904 if (strcmp(intf, get_main_ifname(dut)) == 0)
2905 ifname = get_station_ifname(dut);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002906 else
2907 ifname = intf;
2908
Bala Krishna Bhamidipati73d7af02016-03-24 12:27:56 +05302909 id = set_eap_common(dut, conn, ifname, !dut->sim_no_username, cmd);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002910 if (id < 0)
2911 return id;
2912
Purushottam Kushwahacdd8cb12019-10-04 11:33:59 +05302913 /* RFC 5448: EAP-AKA' MUST use the leading character "6" (ASCII 36
2914 * hexadecimal).
2915 */
2916 if (username && username[0] == '6') {
2917 if (set_network(ifname, id, "eap", "AKA'") < 0)
2918 return -2;
2919 } else if (set_network(ifname, id, "eap", "AKA") < 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002920 return -2;
Purushottam Kushwahacdd8cb12019-10-04 11:33:59 +05302921 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002922
2923 return 1;
2924}
2925
2926
Jouni Malinenf7222712019-06-13 01:50:21 +03002927static enum sigma_cmd_result cmd_sta_set_eapakaprime(struct sigma_dut *dut,
2928 struct sigma_conn *conn,
2929 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002930{
2931 const char *intf = get_param(cmd, "Interface");
2932 const char *ifname;
2933 int id;
2934
2935 if (intf == NULL)
2936 return -1;
2937
Jouni Malinen016ae6c2019-11-04 17:00:01 +02002938 if (strcmp(intf, get_main_ifname(dut)) == 0)
2939 ifname = get_station_ifname(dut);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002940 else
2941 ifname = intf;
2942
Bala Krishna Bhamidipati73d7af02016-03-24 12:27:56 +05302943 id = set_eap_common(dut, conn, ifname, !dut->sim_no_username, cmd);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002944 if (id < 0)
2945 return id;
2946
2947 if (set_network(ifname, id, "eap", "AKA'") < 0)
2948 return -2;
2949
2950 return 1;
2951}
2952
2953
2954static int sta_set_open(struct sigma_dut *dut, struct sigma_conn *conn,
2955 struct sigma_cmd *cmd)
2956{
2957 const char *intf = get_param(cmd, "Interface");
Alexei Avshalom Lazard596b512018-12-18 16:00:59 +02002958 const char *network_mode = get_param(cmd, "network_mode");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002959 const char *ifname;
2960 int id;
2961
Jouni Malinen016ae6c2019-11-04 17:00:01 +02002962 if (strcmp(intf, get_main_ifname(dut)) == 0)
2963 ifname = get_station_ifname(dut);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002964 else
2965 ifname = intf;
2966
2967 id = add_network_common(dut, conn, ifname, cmd);
2968 if (id < 0)
2969 return id;
2970
2971 if (set_network(ifname, id, "key_mgmt", "NONE") < 0)
2972 return -2;
2973
Alexei Avshalom Lazard596b512018-12-18 16:00:59 +02002974 if (dut->program == PROGRAM_60GHZ && network_mode &&
2975 strcasecmp(network_mode, "PBSS") == 0 &&
2976 set_network(ifname, id, "pbss", "1") < 0)
2977 return -2;
2978
Jouni Malinencd4e3c32015-10-29 12:39:56 +02002979 return 1;
2980}
2981
2982
Jouni Malinen8e3f8812020-10-05 10:02:03 +03002983static enum sigma_cmd_result sta_set_owe(struct sigma_dut *dut,
2984 struct sigma_conn *conn,
2985 struct sigma_cmd *cmd)
Jouni Malinen47dcc952017-10-09 16:43:24 +03002986{
2987 const char *intf = get_param(cmd, "Interface");
2988 const char *ifname, *val;
2989 int id;
2990
2991 if (intf == NULL)
Jouni Malinen8e3f8812020-10-05 10:02:03 +03002992 return INVALID_SEND_STATUS;
Jouni Malinen47dcc952017-10-09 16:43:24 +03002993
Jouni Malinen016ae6c2019-11-04 17:00:01 +02002994 if (strcmp(intf, get_main_ifname(dut)) == 0)
2995 ifname = get_station_ifname(dut);
Jouni Malinen47dcc952017-10-09 16:43:24 +03002996 else
2997 ifname = intf;
2998
2999 id = set_wpa_common(dut, conn, ifname, cmd);
3000 if (id < 0)
3001 return id;
3002
3003 if (set_network(ifname, id, "key_mgmt", "OWE") < 0)
Jouni Malinen8e3f8812020-10-05 10:02:03 +03003004 return ERROR_SEND_STATUS;
Jouni Malinen47dcc952017-10-09 16:43:24 +03003005
Hu Wangdd5eed22020-07-16 12:18:03 +08003006 if (dut->owe_ptk_workaround &&
3007 set_network(ifname, id, "owe_ptk_workaround", "1") < 0) {
3008 sigma_dut_print(dut, DUT_MSG_ERROR,
3009 "Failed to set owe_ptk_workaround to 1");
Jouni Malinen8e3f8812020-10-05 10:02:03 +03003010 return ERROR_SEND_STATUS;
Hu Wangdd5eed22020-07-16 12:18:03 +08003011 }
3012
Jouni Malinen47dcc952017-10-09 16:43:24 +03003013 val = get_param(cmd, "ECGroupID");
Jouni Malinenfac9cad2017-10-10 18:35:55 +03003014 if (val && strcmp(val, "0") == 0) {
3015 if (wpa_command(ifname,
3016 "VENDOR_ELEM_ADD 13 ff23200000783590fb7440e03d5b3b33911f86affdcc6b4411b707846ac4ff08ddc8831ccd") != 0) {
3017 sigma_dut_print(dut, DUT_MSG_ERROR,
3018 "Failed to set OWE DH Param element override");
Jouni Malinen8e3f8812020-10-05 10:02:03 +03003019 return ERROR_SEND_STATUS;
Jouni Malinenfac9cad2017-10-10 18:35:55 +03003020 }
Hu Wangdd5eed22020-07-16 12:18:03 +08003021 } else if (val && set_network(ifname, id, "owe_group", val) < 0) {
Jouni Malinen47dcc952017-10-09 16:43:24 +03003022 sigma_dut_print(dut, DUT_MSG_ERROR,
Hu Wang6010ce72020-03-05 19:33:53 +08003023 "Failed to set owe_group");
Jouni Malinen8e3f8812020-10-05 10:02:03 +03003024 return ERROR_SEND_STATUS;
Jouni Malinen47dcc952017-10-09 16:43:24 +03003025 }
3026
Jouni Malinen8e3f8812020-10-05 10:02:03 +03003027 return SUCCESS_SEND_STATUS;
Jouni Malinen47dcc952017-10-09 16:43:24 +03003028}
3029
3030
Jouni Malinenf7222712019-06-13 01:50:21 +03003031static enum sigma_cmd_result cmd_sta_set_security(struct sigma_dut *dut,
3032 struct sigma_conn *conn,
3033 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003034{
3035 const char *type = get_param(cmd, "Type");
3036
3037 if (type == NULL) {
3038 send_resp(dut, conn, SIGMA_ERROR,
3039 "ErrorCode,Missing Type argument");
3040 return 0;
3041 }
3042
3043 if (strcasecmp(type, "OPEN") == 0)
3044 return sta_set_open(dut, conn, cmd);
Jouni Malinen47dcc952017-10-09 16:43:24 +03003045 if (strcasecmp(type, "OWE") == 0)
3046 return sta_set_owe(dut, conn, cmd);
Jouni Malinen992a81e2017-08-22 13:57:47 +03003047 if (strcasecmp(type, "PSK") == 0 ||
Jouni Malinen0ab50f42017-08-31 01:34:59 +03003048 strcasecmp(type, "PSK-SAE") == 0 ||
Jouni Malinen992a81e2017-08-22 13:57:47 +03003049 strcasecmp(type, "SAE") == 0)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003050 return cmd_sta_set_psk(dut, conn, cmd);
3051 if (strcasecmp(type, "EAPTLS") == 0)
3052 return cmd_sta_set_eaptls(dut, conn, cmd);
3053 if (strcasecmp(type, "EAPTTLS") == 0)
3054 return cmd_sta_set_eapttls(dut, conn, cmd);
3055 if (strcasecmp(type, "EAPPEAP") == 0)
3056 return cmd_sta_set_peap(dut, conn, cmd);
3057 if (strcasecmp(type, "EAPSIM") == 0)
3058 return cmd_sta_set_eapsim(dut, conn, cmd);
3059 if (strcasecmp(type, "EAPFAST") == 0)
3060 return cmd_sta_set_eapfast(dut, conn, cmd);
3061 if (strcasecmp(type, "EAPAKA") == 0)
3062 return cmd_sta_set_eapaka(dut, conn, cmd);
3063 if (strcasecmp(type, "EAPAKAPRIME") == 0)
3064 return cmd_sta_set_eapakaprime(dut, conn, cmd);
Amarnath Hullur Subramanyam81b11cd2018-01-30 19:07:17 -08003065 if (strcasecmp(type, "wep") == 0)
3066 return cmd_sta_set_encryption(dut, conn, cmd);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003067
3068 send_resp(dut, conn, SIGMA_ERROR,
3069 "ErrorCode,Unsupported Type value");
3070 return 0;
3071}
3072
3073
3074int ath6kl_client_uapsd(struct sigma_dut *dut, const char *intf, int uapsd)
3075{
3076#ifdef __linux__
3077 /* special handling for ath6kl */
3078 char path[128], fname[128], *pos;
3079 ssize_t res;
3080 FILE *f;
3081
Jouni Malinene39cd562019-05-29 23:39:56 +03003082 res = snprintf(fname, sizeof(fname), "/sys/class/net/%s/phy80211",
3083 intf);
3084 if (res < 0 || res >= sizeof(fname))
3085 return 0;
3086 res = readlink(fname, path, sizeof(path));
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003087 if (res < 0)
3088 return 0; /* not ath6kl */
3089
3090 if (res >= (int) sizeof(path))
3091 res = sizeof(path) - 1;
3092 path[res] = '\0';
3093 pos = strrchr(path, '/');
3094 if (pos == NULL)
3095 pos = path;
3096 else
3097 pos++;
Jouni Malinen77dda642020-01-07 11:21:55 +02003098 res = snprintf(fname, sizeof(fname),
3099 "/sys/kernel/debug/ieee80211/%s/ath6kl/"
3100 "create_qos", pos);
3101 if (res < 0 || res >= sizeof(fname) || !file_exists(fname))
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003102 return 0; /* not ath6kl */
3103
3104 if (uapsd) {
3105 f = fopen(fname, "w");
3106 if (f == NULL)
3107 return -1;
3108
3109 sigma_dut_print(dut, DUT_MSG_DEBUG, "Use ath6kl create_qos");
3110 fprintf(f, "4 2 2 1 2 9999999 9999999 9999999 7777777 0 4 "
3111 "45000 200 56789000 56789000 5678900 0 0 9999999 "
3112 "20000 0\n");
3113 fclose(f);
3114 } else {
Jouni Malinen77dda642020-01-07 11:21:55 +02003115 res = snprintf(fname, sizeof(fname),
3116 "/sys/kernel/debug/ieee80211/%s/ath6kl/"
3117 "delete_qos", pos);
3118 if (res < 0 || res >= sizeof(fname))
3119 return -1;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003120
3121 f = fopen(fname, "w");
3122 if (f == NULL)
3123 return -1;
3124
3125 sigma_dut_print(dut, DUT_MSG_DEBUG, "Use ath6kl delete_qos");
3126 fprintf(f, "2 4\n");
3127 fclose(f);
3128 }
3129#endif /* __linux__ */
3130
3131 return 0;
3132}
3133
3134
Jouni Malinenf7222712019-06-13 01:50:21 +03003135static enum sigma_cmd_result cmd_sta_set_uapsd(struct sigma_dut *dut,
3136 struct sigma_conn *conn,
3137 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003138{
3139 const char *intf = get_param(cmd, "Interface");
3140 /* const char *ssid = get_param(cmd, "ssid"); */
3141 const char *val;
3142 int max_sp_len = 4;
3143 int ac_be = 1, ac_bk = 1, ac_vi = 1, ac_vo = 1;
3144 char buf[100];
3145 int ret1, ret2;
3146
3147 val = get_param(cmd, "maxSPLength");
3148 if (val) {
3149 max_sp_len = atoi(val);
3150 if (max_sp_len != 0 && max_sp_len != 1 && max_sp_len != 2 &&
3151 max_sp_len != 4)
3152 return -1;
3153 }
3154
3155 val = get_param(cmd, "acBE");
3156 if (val)
3157 ac_be = atoi(val);
3158
3159 val = get_param(cmd, "acBK");
3160 if (val)
3161 ac_bk = atoi(val);
3162
3163 val = get_param(cmd, "acVI");
3164 if (val)
3165 ac_vi = atoi(val);
3166
3167 val = get_param(cmd, "acVO");
3168 if (val)
3169 ac_vo = atoi(val);
3170
3171 dut->client_uapsd = ac_be || ac_bk || ac_vi || ac_vo;
3172
3173 snprintf(buf, sizeof(buf), "P2P_SET client_apsd %d,%d,%d,%d;%d",
3174 ac_be, ac_bk, ac_vi, ac_vo, max_sp_len);
3175 ret1 = wpa_command(intf, buf);
3176
3177 snprintf(buf, sizeof(buf), "SET uapsd %d,%d,%d,%d;%d",
3178 ac_be, ac_bk, ac_vi, ac_vo, max_sp_len);
3179 ret2 = wpa_command(intf, buf);
3180
3181 if (ret1 && ret2) {
3182 sigma_dut_print(dut, DUT_MSG_INFO, "Failed to set client mode "
3183 "UAPSD parameters.");
3184 return -2;
3185 }
3186
3187 if (ath6kl_client_uapsd(dut, intf, dut->client_uapsd) < 0) {
3188 send_resp(dut, conn, SIGMA_ERROR,
3189 "ErrorCode,Failed to set ath6kl QoS parameters");
3190 return 0;
3191 }
3192
3193 return 1;
3194}
3195
3196
Jouni Malinenf7222712019-06-13 01:50:21 +03003197static enum sigma_cmd_result cmd_sta_set_wmm(struct sigma_dut *dut,
3198 struct sigma_conn *conn,
3199 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003200{
3201 char buf[1000];
3202 const char *intf = get_param(cmd, "Interface");
3203 const char *grp = get_param(cmd, "Group");
3204 const char *act = get_param(cmd, "Action");
3205 const char *tid = get_param(cmd, "Tid");
3206 const char *dir = get_param(cmd, "Direction");
3207 const char *psb = get_param(cmd, "Psb");
3208 const char *up = get_param(cmd, "Up");
3209 const char *fixed = get_param(cmd, "Fixed");
3210 const char *size = get_param(cmd, "Size");
3211 const char *msize = get_param(cmd, "Maxsize");
3212 const char *minsi = get_param(cmd, "Min_srvc_intrvl");
3213 const char *maxsi = get_param(cmd, "Max_srvc_intrvl");
3214 const char *inact = get_param(cmd, "Inactivity");
3215 const char *sus = get_param(cmd, "Suspension");
3216 const char *mindr = get_param(cmd, "Mindatarate");
3217 const char *meandr = get_param(cmd, "Meandatarate");
3218 const char *peakdr = get_param(cmd, "Peakdatarate");
3219 const char *phyrate = get_param(cmd, "Phyrate");
3220 const char *burstsize = get_param(cmd, "Burstsize");
3221 const char *sba = get_param(cmd, "Sba");
3222 int direction;
3223 int handle;
Peng Xu93319622017-10-04 17:58:16 -07003224 float sba_fv = 0;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003225 int fixed_int;
3226 int psb_ts;
3227
3228 if (intf == NULL || grp == NULL || act == NULL )
3229 return -1;
3230
3231 if (strcasecmp(act, "addts") == 0) {
3232 if (tid == NULL || dir == NULL || psb == NULL ||
3233 up == NULL || fixed == NULL || size == NULL)
3234 return -1;
3235
3236 /*
3237 * Note: Sigma CAPI spec lists uplink, downlink, and bidi as the
3238 * possible values, but WMM-AC and V-E test scripts use "UP,
3239 * "DOWN", and "BIDI".
3240 */
3241 if (strcasecmp(dir, "uplink") == 0 ||
3242 strcasecmp(dir, "up") == 0) {
3243 direction = 0;
3244 } else if (strcasecmp(dir, "downlink") == 0 ||
3245 strcasecmp(dir, "down") == 0) {
3246 direction = 1;
3247 } else if (strcasecmp(dir, "bidi") == 0) {
3248 direction = 2;
3249 } else {
3250 sigma_dut_print(dut, DUT_MSG_ERROR,
3251 "Direction %s not supported", dir);
3252 return -1;
3253 }
3254
3255 if (strcasecmp(psb, "legacy") == 0) {
3256 psb_ts = 0;
3257 } else if (strcasecmp(psb, "uapsd") == 0) {
3258 psb_ts = 1;
3259 } else {
3260 sigma_dut_print(dut, DUT_MSG_ERROR,
3261 "PSB %s not supported", psb);
3262 return -1;
3263 }
3264
3265 if (atoi(tid) < 0 || atoi(tid) > 7) {
3266 sigma_dut_print(dut, DUT_MSG_ERROR,
3267 "TID %s not supported", tid);
3268 return -1;
3269 }
3270
3271 if (strcasecmp(fixed, "true") == 0) {
3272 fixed_int = 1;
3273 } else {
3274 fixed_int = 0;
3275 }
3276
Peng Xu93319622017-10-04 17:58:16 -07003277 if (sba)
3278 sba_fv = atof(sba);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003279
3280 dut->dialog_token++;
3281 handle = 7000 + dut->dialog_token;
3282
3283 /*
3284 * size: convert to hex
3285 * maxsi: convert to hex
3286 * mindr: convert to hex
3287 * meandr: convert to hex
3288 * peakdr: convert to hex
3289 * burstsize: convert to hex
3290 * phyrate: convert to hex
3291 * sba: convert to hex with modification
3292 * minsi: convert to integer
3293 * sus: convert to integer
3294 * inact: convert to integer
3295 * maxsi: convert to integer
3296 */
3297
3298 /*
3299 * The Nominal MSDU Size field is 2 octets long and contains an
3300 * unsigned integer that specifies the nominal size, in octets,
3301 * of MSDUs belonging to the traffic under this traffic
3302 * specification and is defined in Figure 16. If the Fixed
3303 * subfield is set to 1, then the size of the MSDU is fixed and
3304 * is indicated by the Size Subfield. If the Fixed subfield is
3305 * set to 0, then the size of the MSDU might not be fixed and
3306 * the Size indicates the nominal MSDU size.
3307 *
3308 * The Surplus Bandwidth Allowance Factor field is 2 octets long
3309 * and specifies the excess allocation of time (and bandwidth)
3310 * over and above the stated rates required to transport an MSDU
3311 * belonging to the traffic in this TSPEC. This field is
3312 * represented as an unsigned binary number with an implicit
3313 * binary point after the leftmost 3 bits. For example, an SBA
3314 * of 1.75 is represented as 0x3800. This field is included to
3315 * account for retransmissions. As such, the value of this field
3316 * must be greater than unity.
3317 */
3318
3319 snprintf(buf, sizeof(buf),
3320 "iwpriv %s addTspec %d %s %d %d %s 0x%X"
3321 " 0x%X 0x%X 0x%X"
3322 " 0x%X 0x%X 0x%X"
3323 " 0x%X %d %d %d %d"
3324 " %d %d",
3325 intf, handle, tid, direction, psb_ts, up,
3326 (unsigned int) ((fixed_int << 15) | atoi(size)),
3327 msize ? atoi(msize) : 0,
3328 mindr ? atoi(mindr) : 0,
3329 meandr ? atoi(meandr) : 0,
3330 peakdr ? atoi(peakdr) : 0,
3331 burstsize ? atoi(burstsize) : 0,
3332 phyrate ? atoi(phyrate) : 0,
3333 sba ? ((unsigned int) (((int) sba_fv << 13) |
3334 (int)((sba_fv - (int) sba_fv) *
3335 8192))) : 0,
3336 minsi ? atoi(minsi) : 0,
3337 sus ? atoi(sus) : 0,
3338 0, 0,
3339 inact ? atoi(inact) : 0,
3340 maxsi ? atoi(maxsi) : 0);
3341
3342 if (system(buf) != 0) {
3343 sigma_dut_print(dut, DUT_MSG_ERROR,
3344 "iwpriv addtspec request failed");
3345 send_resp(dut, conn, SIGMA_ERROR,
3346 "errorCode,Failed to execute addTspec command");
3347 return 0;
3348 }
3349
3350 sigma_dut_print(dut, DUT_MSG_INFO,
3351 "iwpriv addtspec request send");
3352
3353 /* Mapping handle to a TID */
3354 dut->tid_to_handle[atoi(tid)] = handle;
3355 } else if (strcasecmp(act, "delts") == 0) {
3356 if (tid == NULL)
3357 return -1;
3358
3359 if (atoi(tid) < 0 || atoi(tid) > 7) {
3360 sigma_dut_print(dut, DUT_MSG_ERROR,
3361 "TID %s not supported", tid);
3362 send_resp(dut, conn, SIGMA_ERROR,
3363 "errorCode,Unsupported TID");
3364 return 0;
3365 }
3366
3367 handle = dut->tid_to_handle[atoi(tid)];
3368
3369 if (handle < 7000 || handle > 7255) {
3370 /* Invalid handle ie no mapping for that TID */
3371 sigma_dut_print(dut, DUT_MSG_ERROR,
3372 "handle-> %d not found", handle);
3373 }
3374
3375 snprintf(buf, sizeof(buf), "iwpriv %s delTspec %d",
3376 intf, handle);
3377
3378 if (system(buf) != 0) {
3379 sigma_dut_print(dut, DUT_MSG_ERROR,
3380 "iwpriv deltspec request failed");
3381 send_resp(dut, conn, SIGMA_ERROR,
3382 "errorCode,Failed to execute delTspec command");
3383 return 0;
3384 }
3385
3386 sigma_dut_print(dut, DUT_MSG_INFO,
3387 "iwpriv deltspec request send");
3388
3389 dut->tid_to_handle[atoi(tid)] = 0;
3390 } else {
3391 sigma_dut_print(dut, DUT_MSG_ERROR,
3392 "Action type %s not supported", act);
3393 send_resp(dut, conn, SIGMA_ERROR,
3394 "errorCode,Unsupported Action");
3395 return 0;
3396 }
3397
3398 return 1;
3399}
3400
3401
vamsi krishna52e16f92017-08-29 12:37:34 +05303402static int find_network(struct sigma_dut *dut, const char *ssid)
3403{
3404 char list[4096];
3405 char *pos;
3406
3407 sigma_dut_print(dut, DUT_MSG_DEBUG,
3408 "Search for profile based on SSID: '%s'", ssid);
Jouni Malinen016ae6c2019-11-04 17:00:01 +02003409 if (wpa_command_resp(get_station_ifname(dut), "LIST_NETWORKS",
vamsi krishna52e16f92017-08-29 12:37:34 +05303410 list, sizeof(list)) < 0)
3411 return -1;
3412 pos = strstr(list, ssid);
3413 if (!pos || pos == list || pos[-1] != '\t' || pos[strlen(ssid)] != '\t')
3414 return -1;
3415
3416 while (pos > list && pos[-1] != '\n')
3417 pos--;
3418 dut->infra_network_id = atoi(pos);
3419 snprintf(dut->infra_ssid, sizeof(dut->infra_ssid), "%s", ssid);
3420 return 0;
3421}
3422
3423
Mohammad Asaad Akram50848402020-05-28 14:10:24 +05303424/**
3425 * enum qca_sta_helper_config_params - This helper enum defines the config
3426 * parameters which can be delivered to sta.
3427 */
3428enum qca_sta_helper_config_params {
3429 /* For the attribute QCA_WLAN_VENDOR_ATTR_CONFIG_RSN_IE */
3430 STA_SET_RSNIE,
3431
3432 /* For the attribute QCA_WLAN_VENDOR_ATTR_CONFIG_LDPC */
3433 STA_SET_LDPC,
3434
3435 /* For the attribute QCA_WLAN_VENDOR_ATTR_CONFIG_TX_STBC */
3436 STA_SET_TX_STBC,
3437
3438 /* For the attribute QCA_WLAN_VENDOR_ATTR_CONFIG_RX_STBC */
3439 STA_SET_RX_STBC,
3440
3441 /* For the attribute QCA_WLAN_VENDOR_ATTR_CONFIG_TX_MSDU_AGGREGATION */
3442 STA_SET_TX_MSDU,
3443
3444 /* For the attribute QCA_WLAN_VENDOR_ATTR_CONFIG_RX_MSDU_AGGREGATION */
3445 STA_SET_RX_MSDU,
3446};
3447
3448
3449static int sta_config_params(struct sigma_dut *dut, const char *intf,
3450 enum qca_sta_helper_config_params config_cmd,
3451 int value)
Sunil Dutt44595082018-02-12 19:41:45 +05303452{
Mohammad Asaad Akram50848402020-05-28 14:10:24 +05303453#ifdef NL80211_SUPPORT
Sunil Dutt44595082018-02-12 19:41:45 +05303454 struct nl_msg *msg;
3455 int ret;
3456 struct nlattr *params;
3457 int ifindex;
3458
Mohammad Asaad Akram50848402020-05-28 14:10:24 +05303459 ifindex = if_nametoindex(intf);
3460 if (ifindex == 0) {
3461 sigma_dut_print(dut, DUT_MSG_ERROR,
3462 "%s: Interface %s does not exist",
3463 __func__, intf);
3464 return -1;
3465 }
3466
Sunil Dutt44595082018-02-12 19:41:45 +05303467 if (!(msg = nl80211_drv_msg(dut, dut->nl_ctx, ifindex, 0,
3468 NL80211_CMD_VENDOR)) ||
3469 nla_put_u32(msg, NL80211_ATTR_IFINDEX, ifindex) ||
3470 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
3471 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
3472 QCA_NL80211_VENDOR_SUBCMD_SET_WIFI_CONFIGURATION) ||
Mohammad Asaad Akram50848402020-05-28 14:10:24 +05303473 !(params = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA)))
3474 goto fail;
3475
3476 switch (config_cmd) {
3477 case STA_SET_RSNIE:
3478 if (nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_CONFIG_RSN_IE, value))
3479 goto fail;
3480 break;
3481 case STA_SET_LDPC:
3482 if (nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_CONFIG_LDPC, value))
3483 goto fail;
3484 break;
3485 case STA_SET_TX_STBC:
3486 if (nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_CONFIG_TX_STBC, value))
3487 goto fail;
3488 break;
3489 case STA_SET_RX_STBC:
3490 if (nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_CONFIG_RX_STBC, value))
3491 goto fail;
3492 break;
3493 case STA_SET_TX_MSDU:
3494 if (nla_put_u8(msg,
3495 QCA_WLAN_VENDOR_ATTR_CONFIG_TX_MSDU_AGGREGATION,
3496 value))
3497 goto fail;
3498 break;
3499 case STA_SET_RX_MSDU:
3500 if (nla_put_u8(msg,
3501 QCA_WLAN_VENDOR_ATTR_CONFIG_RX_MSDU_AGGREGATION,
3502 value))
3503 goto fail;
3504 break;
Sunil Dutt44595082018-02-12 19:41:45 +05303505 }
3506 nla_nest_end(msg, params);
3507
3508 ret = send_and_recv_msgs(dut, dut->nl_ctx, msg, NULL, NULL);
3509 if (ret) {
3510 sigma_dut_print(dut, DUT_MSG_ERROR,
3511 "%s: err in send_and_recv_msgs, ret=%d",
3512 __func__, ret);
3513 return ret;
3514 }
3515
3516 return 0;
Mohammad Asaad Akram50848402020-05-28 14:10:24 +05303517
3518fail:
3519 sigma_dut_print(dut, DUT_MSG_ERROR,
3520 "%s: err in adding vendor_cmd and vendor_data",
3521 __func__);
3522 nlmsg_free(msg);
Sunil Dutt44595082018-02-12 19:41:45 +05303523#endif /* NL80211_SUPPORT */
Mohammad Asaad Akram50848402020-05-28 14:10:24 +05303524 return -1;
3525}
Sunil Dutt44595082018-02-12 19:41:45 +05303526
3527
Jouni Malinenf7222712019-06-13 01:50:21 +03003528static enum sigma_cmd_result cmd_sta_associate(struct sigma_dut *dut,
3529 struct sigma_conn *conn,
3530 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003531{
Mohammad Asaad Akram50848402020-05-28 14:10:24 +05303532#ifdef NL80211_SUPPORT
3533 const char *intf = get_param(cmd, "Interface");
3534#endif /* NL80211_SUPPORT */
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003535 const char *ssid = get_param(cmd, "ssid");
3536 const char *wps_param = get_param(cmd, "WPS");
3537 const char *bssid = get_param(cmd, "bssid");
Jouni Malinen46a19b62017-06-23 14:31:27 +03003538 const char *chan = get_param(cmd, "channel");
Alexei Avshalom Lazard596b512018-12-18 16:00:59 +02003539 const char *network_mode = get_param(cmd, "network_mode");
Veerendranath Jakkama082e342020-05-16 00:19:21 +05303540 const char *ifname = get_station_ifname(dut);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003541 int wps = 0;
Jouni Malinen3c367e82017-06-23 17:01:47 +03003542 char buf[1000], extra[50];
Jouni Malinen134fe3c2019-06-12 04:16:49 +03003543 int e;
3544 enum sigma_cmd_result ret = SUCCESS_SEND_STATUS;
3545 struct wpa_ctrl *ctrl = NULL;
3546 int num_network_not_found = 0;
3547 int num_disconnected = 0;
3548 int tod = -1;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003549
3550 if (ssid == NULL)
3551 return -1;
3552
Jouni Malinen37d5c692019-08-19 16:56:55 +03003553 dut->server_cert_tod = 0;
3554
Jouni Malinen3c367e82017-06-23 17:01:47 +03003555 if (dut->rsne_override) {
Sunil Dutt44595082018-02-12 19:41:45 +05303556#ifdef NL80211_SUPPORT
Jouni Malinen016ae6c2019-11-04 17:00:01 +02003557 if (get_driver_type(dut) == DRIVER_WCN) {
Mohammad Asaad Akram50848402020-05-28 14:10:24 +05303558 sta_config_params(dut, intf, STA_SET_RSNIE, 1);
Sunil Dutt44595082018-02-12 19:41:45 +05303559 dut->config_rsnie = 1;
3560 }
3561#endif /* NL80211_SUPPORT */
Jouni Malinen3c367e82017-06-23 17:01:47 +03003562 snprintf(buf, sizeof(buf), "TEST_ASSOC_IE %s",
3563 dut->rsne_override);
Jouni Malinen016ae6c2019-11-04 17:00:01 +02003564 if (wpa_command(get_station_ifname(dut), buf) < 0) {
Jouni Malinen3c367e82017-06-23 17:01:47 +03003565 send_resp(dut, conn, SIGMA_ERROR,
3566 "ErrorCode,Failed to set DEV_CONFIGURE_IE RSNE override");
3567 return 0;
3568 }
3569 }
3570
Jouni Malinen68143132017-09-02 02:34:08 +03003571 if (dut->sae_commit_override) {
3572 snprintf(buf, sizeof(buf), "SET sae_commit_override %s",
3573 dut->sae_commit_override);
Jouni Malinen016ae6c2019-11-04 17:00:01 +02003574 if (wpa_command(get_station_ifname(dut), buf) < 0) {
Jouni Malinen68143132017-09-02 02:34:08 +03003575 send_resp(dut, conn, SIGMA_ERROR,
3576 "ErrorCode,Failed to set SAE commit override");
3577 return 0;
3578 }
3579 }
Ankita Bajaj1bde7942018-01-09 19:15:01 +05303580#ifdef ANDROID
3581 if (dut->fils_hlp)
3582 process_fils_hlp(dut);
3583#endif /* ANDROID */
Jouni Malinen68143132017-09-02 02:34:08 +03003584
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003585 if (wps_param &&
3586 (strcmp(wps_param, "1") == 0 || strcasecmp(wps_param, "On") == 0))
3587 wps = 1;
3588
3589 if (wps) {
Alexei Avshalom Lazard596b512018-12-18 16:00:59 +02003590 if (dut->program == PROGRAM_60GHZ && network_mode &&
3591 strcasecmp(network_mode, "PBSS") == 0 &&
Jouni Malinen016ae6c2019-11-04 17:00:01 +02003592 set_network(get_station_ifname(dut), dut->infra_network_id,
Alexei Avshalom Lazard596b512018-12-18 16:00:59 +02003593 "pbss", "1") < 0)
3594 return -2;
3595
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003596 if (dut->wps_method == WFA_CS_WPS_NOT_READY) {
3597 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,WPS "
3598 "parameters not yet set");
3599 return 0;
3600 }
3601 if (dut->wps_method == WFA_CS_WPS_PBC) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02003602 if (wpa_command(get_station_ifname(dut), "WPS_PBC") < 0)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003603 return -2;
3604 } else {
3605 snprintf(buf, sizeof(buf), "WPS_PIN any %s",
3606 dut->wps_pin);
Jouni Malinen016ae6c2019-11-04 17:00:01 +02003607 if (wpa_command(get_station_ifname(dut), buf) < 0)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003608 return -2;
3609 }
3610 } else {
vamsi krishna52e16f92017-08-29 12:37:34 +05303611 if (strcmp(ssid, dut->infra_ssid) == 0) {
3612 sigma_dut_print(dut, DUT_MSG_DEBUG,
3613 "sta_associate for the most recently added network");
3614 } else if (find_network(dut, ssid) < 0) {
3615 sigma_dut_print(dut, DUT_MSG_DEBUG,
3616 "sta_associate for a previously stored network profile");
3617 send_resp(dut, conn, SIGMA_ERROR,
3618 "ErrorCode,Profile not found");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003619 return 0;
3620 }
3621
3622 if (bssid &&
Jouni Malinen016ae6c2019-11-04 17:00:01 +02003623 set_network(get_station_ifname(dut), dut->infra_network_id,
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003624 "bssid", bssid) < 0) {
3625 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,"
3626 "Invalid bssid argument");
3627 return 0;
3628 }
3629
Veerendranath Jakkama082e342020-05-16 00:19:21 +05303630 if ((dut->program == PROGRAM_WPA3 &&
3631 dut->sta_associate_wait_connect) ||
3632 dut->program == PROGRAM_QM) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02003633 ctrl = open_wpa_mon(get_station_ifname(dut));
Jouni Malinen134fe3c2019-06-12 04:16:49 +03003634 if (!ctrl)
3635 return ERROR_SEND_STATUS;
3636 }
3637
Jouni Malinen46a19b62017-06-23 14:31:27 +03003638 extra[0] = '\0';
3639 if (chan)
3640 snprintf(extra, sizeof(extra), " freq=%u",
Alexei Avshalom Lazar093569f2018-11-13 14:08:17 +02003641 channel_to_freq(dut, atoi(chan)));
Jouni Malinen46a19b62017-06-23 14:31:27 +03003642 snprintf(buf, sizeof(buf), "SELECT_NETWORK %d%s",
3643 dut->infra_network_id, extra);
Jouni Malinen016ae6c2019-11-04 17:00:01 +02003644 if (wpa_command(get_station_ifname(dut), buf) < 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003645 sigma_dut_print(dut, DUT_MSG_INFO, "Failed to select "
3646 "network id %d on %s",
3647 dut->infra_network_id,
Jouni Malinen016ae6c2019-11-04 17:00:01 +02003648 get_station_ifname(dut));
Jouni Malinen134fe3c2019-06-12 04:16:49 +03003649 ret = ERROR_SEND_STATUS;
3650 goto done;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003651 }
3652 }
3653
Jouni Malinen134fe3c2019-06-12 04:16:49 +03003654 if (!ctrl)
3655 return SUCCESS_SEND_STATUS;
3656
3657 /* Wait for connection result to be able to store server certificate
3658 * hash for trust root override testing
3659 * (dev_exec_action,ServerCertTrust). */
3660
3661 for (e = 0; e < 20; e++) {
3662 const char *events[] = {
3663 "CTRL-EVENT-EAP-PEER-CERT",
3664 "CTRL-EVENT-EAP-TLS-CERT-ERROR",
3665 "CTRL-EVENT-DISCONNECTED",
3666 "CTRL-EVENT-CONNECTED",
3667 "CTRL-EVENT-NETWORK-NOT-FOUND",
3668 NULL
3669 };
3670 char buf[1024];
3671 int res;
3672
3673 res = get_wpa_cli_events(dut, ctrl, events, buf, sizeof(buf));
3674 if (res < 0) {
Jouni Malinenf1f16642019-11-15 21:19:04 +02003675 send_resp(dut, conn, SIGMA_COMPLETE,
3676 "Result,Association did not complete");
Jouni Malinen134fe3c2019-06-12 04:16:49 +03003677 ret = STATUS_SENT_ERROR;
3678 break;
3679 }
3680 sigma_dut_print(dut, DUT_MSG_DEBUG, "Connection event: %s",
3681 buf);
3682
3683 if (strstr(buf, "CTRL-EVENT-EAP-PEER-CERT") &&
3684 strstr(buf, " depth=0")) {
3685 char *pos = strstr(buf, " hash=");
3686
3687 if (pos) {
3688 char *end;
3689
Jouni Malinen34b19cb2019-08-16 16:37:17 +03003690 if (strstr(buf, " tod=1"))
3691 tod = 1;
3692 else if (strstr(buf, " tod=2"))
3693 tod = 2;
3694 else
3695 tod = 0;
Jouni Malinen134fe3c2019-06-12 04:16:49 +03003696 sigma_dut_print(dut, DUT_MSG_DEBUG,
3697 "Server certificate TOD policy: %d",
3698 tod);
Jouni Malinen37d5c692019-08-19 16:56:55 +03003699 dut->server_cert_tod = tod;
Jouni Malinen134fe3c2019-06-12 04:16:49 +03003700
3701 pos += 6;
3702 end = strchr(pos, ' ');
3703 if (end)
3704 *end = '\0';
3705 strlcpy(dut->server_cert_hash, pos,
3706 sizeof(dut->server_cert_hash));
3707 sigma_dut_print(dut, DUT_MSG_DEBUG,
3708 "Server certificate hash: %s",
3709 dut->server_cert_hash);
3710 }
3711 }
3712
3713 if (strstr(buf, "CTRL-EVENT-EAP-TLS-CERT-ERROR")) {
3714 send_resp(dut, conn, SIGMA_COMPLETE,
3715 "Result,TLS server certificate validation failed");
3716 ret = STATUS_SENT_ERROR;
3717 break;
3718 }
3719
3720 if (strstr(buf, "CTRL-EVENT-NETWORK-NOT-FOUND")) {
3721 num_network_not_found++;
3722
3723 if (num_network_not_found > 2) {
3724 send_resp(dut, conn, SIGMA_COMPLETE,
3725 "Result,Network not found");
3726 ret = STATUS_SENT_ERROR;
3727 break;
3728 }
3729 }
3730
3731 if (strstr(buf, "CTRL-EVENT-DISCONNECTED")) {
3732 num_disconnected++;
3733
3734 if (num_disconnected > 2) {
3735 send_resp(dut, conn, SIGMA_COMPLETE,
3736 "Result,Connection failed");
3737 ret = STATUS_SENT_ERROR;
3738 break;
3739 }
3740 }
3741
3742 if (strstr(buf, "CTRL-EVENT-CONNECTED")) {
3743 if (tod >= 0) {
3744 sigma_dut_print(dut, DUT_MSG_DEBUG,
3745 "Network profile TOD policy update: %d -> %d",
3746 dut->sta_tod_policy, tod);
3747 dut->sta_tod_policy = tod;
3748 }
Veerendranath Jakkama082e342020-05-16 00:19:21 +05303749 if (dut->program == PROGRAM_QM) {
3750 unsigned char iface_mac_addr[ETH_ALEN];
3751 char ipv6[100];
3752
3753 if (get_hwaddr(ifname, iface_mac_addr) < 0) {
3754 sigma_dut_print(dut, DUT_MSG_ERROR,
3755 "%s: get_hwaddr %s failed",
3756 __func__, ifname);
3757 ret = ERROR_SEND_STATUS;
3758 break;
3759 }
3760
3761 convert_mac_addr_to_ipv6_lladdr(iface_mac_addr,
3762 ipv6,
3763 sizeof(ipv6));
3764
3765 if (set_ipv6_addr(dut, ipv6, "64", ifname) !=
3766 0) {
3767 ret = ERROR_SEND_STATUS;
3768 break;
3769 }
3770 }
Jouni Malinen134fe3c2019-06-12 04:16:49 +03003771 break;
3772 }
3773 }
3774done:
3775 if (ctrl) {
3776 wpa_ctrl_detach(ctrl);
3777 wpa_ctrl_close(ctrl);
3778 }
3779 return ret;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02003780}
3781
3782
3783static int run_hs20_osu(struct sigma_dut *dut, const char *params)
3784{
3785 char buf[500], cmd[200];
3786 int res;
3787
3788 /* Use hs20-osu-client file at the current dir, if found; otherwise use
3789 * default path */
3790 res = snprintf(cmd, sizeof(cmd),
3791 "%s -w \"%s\" -r hs20-osu-client.res %s%s -dddKt -f Logs/hs20-osu-client.txt",
3792 file_exists("./hs20-osu-client") ?
3793 "./hs20-osu-client" : "hs20-osu-client",
3794 sigma_wpas_ctrl,
3795 dut->summary_log ? "-s " : "",
3796 dut->summary_log ? dut->summary_log : "");
3797 if (res < 0 || res >= (int) sizeof(cmd))
3798 return -1;
3799
3800 res = snprintf(buf, sizeof(buf), "%s %s", cmd, params);
3801 if (res < 0 || res >= (int) sizeof(buf))
3802 return -1;
3803 sigma_dut_print(dut, DUT_MSG_DEBUG, "Run: %s", buf);
3804
3805 if (system(buf) != 0) {
3806 sigma_dut_print(dut, DUT_MSG_ERROR, "Failed to run: %s", buf);
3807 return -1;
3808 }
3809 sigma_dut_print(dut, DUT_MSG_DEBUG,
3810 "Completed hs20-osu-client operation");
3811
3812 return 0;
3813}
3814
3815
3816static int download_ppsmo(struct sigma_dut *dut,
3817 struct sigma_conn *conn,
3818 const char *intf,
3819 struct sigma_cmd *cmd)
3820{
3821 const char *name, *path, *val;
3822 char url[500], buf[600], fbuf[100];
3823 char *fqdn = NULL;
3824
3825 name = get_param(cmd, "FileName");
3826 path = get_param(cmd, "FilePath");
3827 if (name == NULL || path == NULL)
3828 return -1;
3829
3830 if (strcasecmp(path, "VendorSpecific") == 0) {
3831 snprintf(url, sizeof(url), "PPS/%s", name);
3832 sigma_dut_print(dut, DUT_MSG_INFO, "Use pre-configured PPS MO "
3833 "from the device (%s)", url);
3834 if (!file_exists(url)) {
3835 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Requested "
3836 "PPS MO file does not exist");
3837 return 0;
3838 }
3839 snprintf(buf, sizeof(buf), "cp %s pps-tnds.xml", url);
3840 if (system(buf) != 0) {
3841 send_resp(dut, conn, SIGMA_ERROR,
3842 "errorCode,Failed to copy PPS MO");
3843 return 0;
3844 }
3845 } else if (strncasecmp(path, "http:", 5) != 0 &&
3846 strncasecmp(path, "https:", 6) != 0) {
3847 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,"
3848 "Unsupported FilePath value");
3849 return 0;
3850 } else {
3851 snprintf(url, sizeof(url), "%s/%s", path, name);
3852 sigma_dut_print(dut, DUT_MSG_INFO, "Downloading PPS MO from %s",
3853 url);
3854 snprintf(buf, sizeof(buf), "wget -T 10 -t 3 -O pps-tnds.xml '%s'", url);
3855 remove("pps-tnds.xml");
3856 if (system(buf) != 0) {
3857 send_resp(dut, conn, SIGMA_ERROR,
3858 "errorCode,Failed to download PPS MO");
3859 return 0;
3860 }
3861 }
3862
3863 if (run_hs20_osu(dut, "from_tnds pps-tnds.xml pps.xml") < 0) {
3864 send_resp(dut, conn, SIGMA_ERROR,
3865 "errorCode,Failed to parse downloaded PPSMO");
3866 return 0;
3867 }
3868 unlink("pps-tnds.xml");
3869
3870 val = get_param(cmd, "managementTreeURI");
3871 if (val) {
3872 const char *pos, *end;
3873 sigma_dut_print(dut, DUT_MSG_DEBUG, "managementTreeURI: %s",
3874 val);
3875 if (strncmp(val, "./Wi-Fi/", 8) != 0) {
3876 send_resp(dut, conn, SIGMA_ERROR,
3877 "errorCode,Invalid managementTreeURI prefix");
3878 return 0;
3879 }
3880 pos = val + 8;
3881 end = strchr(pos, '/');
3882 if (end == NULL ||
3883 strcmp(end, "/PerProviderSubscription") != 0) {
3884 send_resp(dut, conn, SIGMA_ERROR,
3885 "errorCode,Invalid managementTreeURI postfix");
3886 return 0;
3887 }
3888 if (end - pos >= (int) sizeof(fbuf)) {
3889 send_resp(dut, conn, SIGMA_ERROR,
3890 "errorCode,Too long FQDN in managementTreeURI");
3891 return 0;
3892 }
3893 memcpy(fbuf, pos, end - pos);
3894 fbuf[end - pos] = '\0';
3895 fqdn = fbuf;
3896 sigma_dut_print(dut, DUT_MSG_INFO,
3897 "FQDN from managementTreeURI: %s", fqdn);
3898 } else if (run_hs20_osu(dut, "get_fqdn pps.xml") == 0) {
3899 FILE *f = fopen("pps-fqdn", "r");
3900 if (f) {
3901 if (fgets(fbuf, sizeof(fbuf), f)) {
3902 fbuf[sizeof(fbuf) - 1] = '\0';
3903 fqdn = fbuf;
3904 sigma_dut_print(dut, DUT_MSG_DEBUG,
3905 "Use FQDN %s", fqdn);
3906 }
3907 fclose(f);
3908 }
3909 }
3910
3911 if (fqdn == NULL) {
3912 send_resp(dut, conn, SIGMA_ERROR,
3913 "errorCode,No FQDN specified");
3914 return 0;
3915 }
3916
3917 mkdir("SP", S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
3918 snprintf(buf, sizeof(buf), "SP/%s", fqdn);
3919 mkdir(buf, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
3920
3921 snprintf(buf, sizeof(buf), "SP/%s/pps.xml", fqdn);
3922 if (rename("pps.xml", buf) < 0) {
3923 send_resp(dut, conn, SIGMA_ERROR,
3924 "errorCode,Could not move PPS MO");
3925 return 0;
3926 }
3927
3928 if (strcasecmp(path, "VendorSpecific") == 0) {
3929 snprintf(buf, sizeof(buf), "cp Certs/ca.pem SP/%s/ca.pem",
3930 fqdn);
3931 if (system(buf)) {
3932 send_resp(dut, conn, SIGMA_ERROR,
3933 "errorCode,Failed to copy OSU CA cert");
3934 return 0;
3935 }
3936
3937 snprintf(buf, sizeof(buf),
3938 "cp Certs/aaa-ca.pem SP/%s/aaa-ca.pem",
3939 fqdn);
3940 if (system(buf)) {
3941 send_resp(dut, conn, SIGMA_ERROR,
3942 "errorCode,Failed to copy AAA CA cert");
3943 return 0;
3944 }
3945 } else {
3946 snprintf(buf, sizeof(buf),
3947 "dl_osu_ca SP/%s/pps.xml SP/%s/ca.pem",
3948 fqdn, fqdn);
3949 if (run_hs20_osu(dut, buf) < 0) {
3950 send_resp(dut, conn, SIGMA_ERROR,
3951 "errorCode,Failed to download OSU CA cert");
3952 return 0;
3953 }
3954
3955 snprintf(buf, sizeof(buf),
3956 "dl_aaa_ca SP/%s/pps.xml SP/%s/aaa-ca.pem",
3957 fqdn, fqdn);
3958 if (run_hs20_osu(dut, buf) < 0) {
3959 sigma_dut_print(dut, DUT_MSG_INFO,
3960 "Failed to download AAA CA cert");
3961 }
3962 }
3963
3964 if (file_exists("next-client-cert.pem")) {
3965 snprintf(buf, sizeof(buf), "SP/%s/client-cert.pem", fqdn);
3966 if (rename("next-client-cert.pem", buf) < 0) {
3967 send_resp(dut, conn, SIGMA_ERROR,
3968 "errorCode,Could not move client certificate");
3969 return 0;
3970 }
3971 }
3972
3973 if (file_exists("next-client-key.pem")) {
3974 snprintf(buf, sizeof(buf), "SP/%s/client-key.pem", fqdn);
3975 if (rename("next-client-key.pem", buf) < 0) {
3976 send_resp(dut, conn, SIGMA_ERROR,
3977 "errorCode,Could not move client key");
3978 return 0;
3979 }
3980 }
3981
3982 snprintf(buf, sizeof(buf), "set_pps SP/%s/pps.xml", fqdn);
3983 if (run_hs20_osu(dut, buf) < 0) {
3984 send_resp(dut, conn, SIGMA_ERROR,
3985 "errorCode,Failed to configure credential from "
3986 "PPSMO");
3987 return 0;
3988 }
3989
3990 return 1;
3991}
3992
3993
3994static int download_cert(struct sigma_dut *dut,
3995 struct sigma_conn *conn,
3996 const char *intf,
3997 struct sigma_cmd *cmd)
3998{
3999 const char *name, *path;
4000 char url[500], buf[600];
4001
4002 name = get_param(cmd, "FileName");
4003 path = get_param(cmd, "FilePath");
4004 if (name == NULL || path == NULL)
4005 return -1;
4006
4007 if (strcasecmp(path, "VendorSpecific") == 0) {
4008 snprintf(url, sizeof(url), "Certs/%s-cert.pem", name);
4009 sigma_dut_print(dut, DUT_MSG_INFO, "Use pre-configured client "
4010 "certificate from the device (%s)", url);
4011 if (!file_exists(url)) {
4012 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Requested "
4013 "certificate file does not exist");
4014 return 0;
4015 }
4016 snprintf(buf, sizeof(buf), "cp %s next-client-cert.pem", url);
4017 if (system(buf) != 0) {
4018 send_resp(dut, conn, SIGMA_ERROR,
4019 "errorCode,Failed to copy client "
4020 "certificate");
4021 return 0;
4022 }
4023
4024 snprintf(url, sizeof(url), "Certs/%s-key.pem", name);
4025 sigma_dut_print(dut, DUT_MSG_INFO, "Use pre-configured client "
4026 "private key from the device (%s)", url);
4027 if (!file_exists(url)) {
4028 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Requested "
4029 "private key file does not exist");
4030 return 0;
4031 }
4032 snprintf(buf, sizeof(buf), "cp %s next-client-key.pem", url);
4033 if (system(buf) != 0) {
4034 send_resp(dut, conn, SIGMA_ERROR,
4035 "errorCode,Failed to copy client key");
4036 return 0;
4037 }
4038 } else if (strncasecmp(path, "http:", 5) != 0 &&
4039 strncasecmp(path, "https:", 6) != 0) {
4040 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,"
4041 "Unsupported FilePath value");
4042 return 0;
4043 } else {
4044 snprintf(url, sizeof(url), "%s/%s.pem", path, name);
4045 sigma_dut_print(dut, DUT_MSG_INFO, "Downloading client "
4046 "certificate/key from %s", url);
4047 snprintf(buf, sizeof(buf),
4048 "wget -T 10 -t 3 -O next-client-cert.pem '%s'", url);
4049 if (system(buf) != 0) {
4050 send_resp(dut, conn, SIGMA_ERROR,
4051 "errorCode,Failed to download client "
4052 "certificate");
4053 return 0;
4054 }
4055
4056 if (system("cp next-client-cert.pem next-client-key.pem") != 0)
4057 {
4058 send_resp(dut, conn, SIGMA_ERROR,
4059 "errorCode,Failed to copy client key");
4060 return 0;
4061 }
4062 }
4063
4064 return 1;
4065}
4066
4067
Alexei Avshalom Lazar33f700c2018-12-18 16:00:39 +02004068static int cmd_sta_preset_testparameters_60ghz(struct sigma_dut *dut,
4069 struct sigma_conn *conn,
4070 struct sigma_cmd *cmd)
4071{
4072 const char *val;
4073 const char *intf = get_param(cmd, "interface");
4074
4075 if (!intf)
4076 return -1;
4077
4078 val = get_param(cmd, "WscIEFragment");
4079 if (val && strcasecmp(val, "enable") == 0) {
4080 sigma_dut_print(dut, DUT_MSG_DEBUG,
4081 "Enable WSC IE fragmentation");
4082
4083 dut->wsc_fragment = 1;
4084 /* set long attributes to force fragmentation */
4085 if (wpa_command(intf, "SET device_name "
4086 WPS_LONG_DEVICE_NAME) < 0)
4087 return -2;
4088 if (wpa_command(intf, "SET manufacturer "
4089 WPS_LONG_MANUFACTURER) < 0)
4090 return -2;
4091 if (wpa_command(intf, "SET model_name "
4092 WPS_LONG_MODEL_NAME) < 0)
4093 return -2;
4094 if (wpa_command(intf, "SET model_number "
4095 WPS_LONG_MODEL_NUMBER) < 0)
4096 return -2;
4097 if (wpa_command(intf, "SET serial_number "
4098 WPS_LONG_SERIAL_NUMBER) < 0)
4099 return -2;
4100 }
4101
Alexei Avshalom Lazarb094bf02018-12-18 16:00:53 +02004102 val = get_param(cmd, "RSN_IE");
4103 if (val) {
4104 if (strcasecmp(val, "disable") == 0)
4105 dut->force_rsn_ie = FORCE_RSN_IE_REMOVE;
4106 else if (strcasecmp(val, "enable") == 0)
4107 dut->force_rsn_ie = FORCE_RSN_IE_ADD;
4108 }
4109
Alexei Avshalom Lazar744ae8a2019-01-31 17:26:46 +02004110 val = get_param(cmd, "WpsVersion");
4111 if (val)
4112 dut->wps_forced_version = get_wps_forced_version(dut, val);
4113
Alexei Avshalom Lazar2eccf4d2019-01-31 10:03:59 +02004114 val = get_param(cmd, "WscEAPFragment");
4115 if (val && strcasecmp(val, "enable") == 0)
4116 dut->eap_fragment = 1;
4117
Alexei Avshalom Lazar33f700c2018-12-18 16:00:39 +02004118 return 1;
4119}
4120
4121
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004122static int cmd_sta_preset_testparameters_hs2_r2(struct sigma_dut *dut,
4123 struct sigma_conn *conn,
4124 const char *intf,
4125 struct sigma_cmd *cmd)
4126{
4127 const char *val;
4128
4129 val = get_param(cmd, "FileType");
4130 if (val && strcasecmp(val, "PPSMO") == 0)
4131 return download_ppsmo(dut, conn, intf, cmd);
4132 if (val && strcasecmp(val, "CERT") == 0)
4133 return download_cert(dut, conn, intf, cmd);
4134 if (val) {
4135 send_resp(dut, conn, SIGMA_ERROR,
4136 "ErrorCode,Unsupported FileType");
4137 return 0;
4138 }
4139
4140 return 1;
4141}
4142
4143
Ankita Bajaja2cb5672017-10-25 16:08:28 +05304144static int cmd_sta_preset_testparameters_oce(struct sigma_dut *dut,
4145 struct sigma_conn *conn,
4146 const char *intf,
4147 struct sigma_cmd *cmd)
4148{
4149 const char *val;
Ankita Bajaj1bde7942018-01-09 19:15:01 +05304150 char buf[1000];
4151 char text[20];
4152 unsigned char addr[ETH_ALEN];
Ankita Bajaja2cb5672017-10-25 16:08:28 +05304153
4154 val = get_param(cmd, "OCESupport");
4155 if (val && strcasecmp(val, "Disable") == 0) {
4156 if (wpa_command(intf, "SET oce 0") < 0) {
4157 send_resp(dut, conn, SIGMA_ERROR,
4158 "ErrorCode,Failed to disable OCE");
4159 return 0;
4160 }
4161 } else if (val && strcasecmp(val, "Enable") == 0) {
4162 if (wpa_command(intf, "SET oce 1") < 0) {
4163 send_resp(dut, conn, SIGMA_ERROR,
4164 "ErrorCode,Failed to enable OCE");
4165 return 0;
4166 }
4167 }
4168
vamsi krishnaa2799492017-12-05 14:28:01 +05304169 val = get_param(cmd, "FILScap");
4170 if (val && (atoi(val) == 1)) {
4171 if (wpa_command(intf, "SET disable_fils 0") < 0) {
4172 send_resp(dut, conn, SIGMA_ERROR,
4173 "ErrorCode,Failed to enable FILS");
4174 return 0;
4175 }
4176 } else if (val && (atoi(val) == 0)) {
4177 if (wpa_command(intf, "SET disable_fils 1") < 0) {
4178 send_resp(dut, conn, SIGMA_ERROR,
4179 "ErrorCode,Failed to disable FILS");
4180 return 0;
4181 }
4182 }
4183
Ankita Bajaj1bde7942018-01-09 19:15:01 +05304184 val = get_param(cmd, "FILSHLP");
4185 if (val && strcasecmp(val, "Enable") == 0) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02004186 if (get_wpa_status(get_station_ifname(dut), "address", text,
Ankita Bajaj1bde7942018-01-09 19:15:01 +05304187 sizeof(text)) < 0)
4188 return -2;
4189 hwaddr_aton(text, addr);
4190 snprintf(buf, sizeof(buf),
4191 "FILS_HLP_REQ_ADD ff:ff:ff:ff:ff:ff "
4192 "080045100140000040004011399e00000000ffffffff00440043"
4193 "012cb30001010600fd4f46410000000000000000000000000000"
4194 "000000000000"
4195 "%02x%02x%02x%02x%02x%02x"
4196 "0000000000000000000000000000000000000000000000000000"
4197 "0000000000000000000000000000000000000000000000000000"
4198 "0000000000000000000000000000000000000000000000000000"
4199 "0000000000000000000000000000000000000000000000000000"
4200 "0000000000000000000000000000000000000000000000000000"
4201 "0000000000000000000000000000000000000000000000000000"
4202 "0000000000000000000000000000000000000000000000000000"
4203 "0000000000000000000000000000000000000000638253633501"
4204 "013d0701000af549d29b390205dc3c12616e64726f69642d6468"
4205 "63702d382e302e30370a0103060f1a1c333a3b2b5000ff00",
4206 addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
4207 if (wpa_command(intf, buf)) {
4208 send_resp(dut, conn, SIGMA_ERROR,
4209 "ErrorCode,Failed to add HLP");
4210 return 0;
4211 }
4212 dut->fils_hlp = 1;
4213 }
4214
Ankita Bajaja2cb5672017-10-25 16:08:28 +05304215 return 1;
4216}
4217
4218
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004219static void ath_sta_set_noack(struct sigma_dut *dut, const char *intf,
4220 const char *val)
4221{
4222 int counter = 0;
4223 char token[50];
4224 char *result;
Pradeep Reddy POTTETIdbf7d712016-04-28 18:42:07 +05304225 char *saveptr;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004226
Peng Xub8fc5cc2017-05-10 17:27:28 -07004227 strlcpy(token, val, sizeof(token));
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004228 token[sizeof(token) - 1] = '\0';
Pradeep Reddy POTTETIdbf7d712016-04-28 18:42:07 +05304229 result = strtok_r(token, ":", &saveptr);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004230 while (result) {
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07004231 if (strcmp(result, "disable") == 0)
4232 run_iwpriv(dut, intf, "noackpolicy %d 1 0", counter);
4233 else
4234 run_iwpriv(dut, intf, "noackpolicy %d 1 1", counter);
Pradeep Reddy POTTETIdbf7d712016-04-28 18:42:07 +05304235 result = strtok_r(NULL, ":", &saveptr);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004236 counter++;
4237 }
4238}
4239
4240
4241static void ath_sta_set_rts(struct sigma_dut *dut, const char *intf,
4242 const char *val)
4243{
4244 char buf[100];
4245
4246 snprintf(buf, sizeof(buf), "iwconfig %s rts %s", intf, val);
4247 if (system(buf) != 0) {
4248 sigma_dut_print(dut, DUT_MSG_ERROR, "iwconfig RTS failed");
4249 }
4250}
4251
4252
4253static void ath_sta_set_wmm(struct sigma_dut *dut, const char *intf,
4254 const char *val)
4255{
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004256 if (strcasecmp(val, "off") == 0) {
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07004257 run_iwpriv(dut, intf, "wmm 0");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004258 }
4259}
4260
4261
Amarnath Hullur Subramanyam75214d22018-02-04 19:17:11 -08004262static int wcn_sta_set_wmm(struct sigma_dut *dut, const char *intf,
4263 const char *val)
4264{
4265#ifdef NL80211_SUPPORT
Amarnath Hullur Subramanyam75214d22018-02-04 19:17:11 -08004266 int wmmenable = 1;
4267
4268 if (val &&
4269 (strcasecmp(val, "off") == 0 || strcmp(val, "0") == 0))
4270 wmmenable = 0;
4271
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05304272 return wcn_wifi_test_config_set_u8(
4273 dut, intf, QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_WMM_ENABLE,
4274 wmmenable);
Amarnath Hullur Subramanyam75214d22018-02-04 19:17:11 -08004275#else /* NL80211_SUPPORT */
4276 sigma_dut_print(dut, DUT_MSG_ERROR,
4277 "WMM cannot be changed without NL80211_SUPPORT defined");
4278 return -1;
4279#endif /* NL80211_SUPPORT */
4280}
4281
4282
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004283static void ath_sta_set_sgi(struct sigma_dut *dut, const char *intf,
4284 const char *val)
4285{
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004286 int sgi20;
4287
4288 sgi20 = strcmp(val, "1") == 0 || strcasecmp(val, "Enable") == 0;
4289
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07004290 run_iwpriv(dut, intf, "shortgi %d", sgi20);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004291}
4292
4293
4294static void ath_sta_set_11nrates(struct sigma_dut *dut, const char *intf,
4295 const char *val)
4296{
Pradeep Reddy POTTETI67376b72016-10-25 20:08:17 +05304297 int rate_code, v;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004298
4299 /* Disable Tx Beam forming when using a fixed rate */
4300 ath_disable_txbf(dut, intf);
4301
Pradeep Reddy POTTETI67376b72016-10-25 20:08:17 +05304302 v = atoi(val);
4303 if (v < 0 || v > 32) {
4304 sigma_dut_print(dut, DUT_MSG_ERROR,
4305 "Invalid Fixed MCS rate: %d", v);
4306 return;
4307 }
4308 rate_code = 0x80 + v;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004309
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07004310 run_iwpriv(dut, intf, "set11NRates 0x%x", rate_code);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004311
4312 /* Channel width gets messed up, fix this */
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07004313 run_iwpriv(dut, intf, "chwidth %d", dut->chwidth);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004314}
4315
4316
Amarnath Hullur Subramanyamd5bb5732018-02-22 15:50:38 -08004317static void iwpriv_sta_set_amsdu(struct sigma_dut *dut, const char *intf,
4318 const char *val)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004319{
4320 char buf[60];
Mohammad Asaad Akram50848402020-05-28 14:10:24 +05304321 int ret;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004322
4323 if (strcmp(val, "1") == 0 || strcasecmp(val, "Enable") == 0)
4324 snprintf(buf, sizeof(buf), "iwpriv %s amsdu 2", intf);
4325 else
4326 snprintf(buf, sizeof(buf), "iwpriv %s amsdu 1", intf);
4327
Mohammad Asaad Akram50848402020-05-28 14:10:24 +05304328 ret = system(buf);
4329#ifdef NL80211_SUPPORT
4330 if (ret) {
4331 int value = (strcasecmp(val, "Enable") == 0) ? 2 : 1;
4332
4333 ret = sta_config_params(dut, intf, STA_SET_TX_MSDU, value);
4334 ret |= sta_config_params(dut, intf, STA_SET_RX_MSDU, value);
4335 }
4336#endif /* NL80211_SUPPORT */
4337 if (ret)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004338 sigma_dut_print(dut, DUT_MSG_ERROR, "iwpriv amsdu failed");
4339}
4340
4341
Deepak Dhamdhere80356cb2016-03-28 16:48:32 -07004342static int iwpriv_sta_set_ampdu(struct sigma_dut *dut, const char *intf,
4343 int ampdu)
4344{
4345 char buf[60];
Amarnath Hullur Subramanyam63c590a2018-03-07 15:26:21 -08004346 int maxaggregation = 63;
Deepak Dhamdhere80356cb2016-03-28 16:48:32 -07004347
Amarnath Hullur Subramanyam63c590a2018-03-07 15:26:21 -08004348 if (ampdu)
4349 ampdu = maxaggregation;
Deepak Dhamdhere80356cb2016-03-28 16:48:32 -07004350 snprintf(buf, sizeof(buf), "iwpriv %s ampdu %d", intf, ampdu);
4351 if (system(buf) != 0) {
4352 sigma_dut_print(dut, DUT_MSG_ERROR, "iwpriv ampdu failed");
4353 return -1;
4354 }
4355
4356 return 0;
4357}
4358
4359
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004360static void ath_sta_set_stbc(struct sigma_dut *dut, const char *intf,
4361 const char *val)
4362{
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07004363 run_iwpriv(dut, intf, "tx_stbc %s", val);
4364 run_iwpriv(dut, intf, "rx_stbc %s", val);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004365}
4366
4367
4368static int wcn_sta_set_cts_width(struct sigma_dut *dut, const char *intf,
4369 const char *val)
4370{
4371 char buf[60];
4372
Peng Xucc317ed2017-05-18 16:44:37 -07004373 if (strcmp(val, "160") == 0) {
4374 snprintf(buf, sizeof(buf), "iwpriv %s cts_cbw 5", intf);
4375 } else if (strcmp(val, "80") == 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004376 snprintf(buf, sizeof(buf), "iwpriv %s cts_cbw 3", intf);
4377 } else if (strcmp(val, "40") == 0) {
4378 snprintf(buf, sizeof(buf), "iwpriv %s cts_cbw 2", intf);
4379 } else if (strcmp(val, "20") == 0) {
4380 snprintf(buf, sizeof(buf), "iwpriv %s cts_cbw 1", intf);
4381 } else if (strcasecmp(val, "Auto") == 0) {
4382 buf[0] = '\0';
4383 } else {
4384 sigma_dut_print(dut, DUT_MSG_ERROR,
4385 "WIDTH/CTS_WIDTH value not supported");
4386 return -1;
4387 }
4388
4389 if (buf[0] != '\0' && system(buf) != 0) {
4390 sigma_dut_print(dut, DUT_MSG_ERROR,
4391 "Failed to set WIDTH/CTS_WIDTH");
4392 return -1;
4393 }
4394
4395 return 0;
4396}
4397
4398
4399int ath_set_width(struct sigma_dut *dut, struct sigma_conn *conn,
4400 const char *intf, const char *val)
4401{
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004402 if (strcasecmp(val, "Auto") == 0) {
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07004403 run_iwpriv(dut, intf, "chwidth 0");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004404 dut->chwidth = 0;
4405 } else if (strcasecmp(val, "20") == 0) {
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07004406 run_iwpriv(dut, intf, "chwidth 0");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004407 dut->chwidth = 0;
4408 } else if (strcasecmp(val, "40") == 0) {
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07004409 run_iwpriv(dut, intf, "chwidth 1");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004410 dut->chwidth = 1;
4411 } else if (strcasecmp(val, "80") == 0) {
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07004412 run_iwpriv(dut, intf, "chwidth 2");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004413 dut->chwidth = 2;
4414 } else if (strcasecmp(val, "160") == 0) {
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07004415 run_iwpriv(dut, intf, "chwidth 3");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004416 dut->chwidth = 3;
4417 } else {
4418 send_resp(dut, conn, SIGMA_ERROR,
4419 "ErrorCode,WIDTH not supported");
4420 return -1;
4421 }
4422
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004423 return 0;
4424}
4425
4426
4427static int wcn_sta_set_sp_stream(struct sigma_dut *dut, const char *intf,
4428 const char *val)
4429{
4430 char buf[60];
Arif Hussainac6c5112018-05-25 17:34:00 -07004431 int sta_nss;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004432
Amarnath Hullur Subramanyamd5374fa2018-02-25 19:00:24 -08004433 if (strcmp(val, "1SS") == 0 || strcmp(val, "1") == 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004434 snprintf(buf, sizeof(buf), "iwpriv %s nss 1", intf);
Arif Hussainac6c5112018-05-25 17:34:00 -07004435 sta_nss = 1;
Amarnath Hullur Subramanyamd5374fa2018-02-25 19:00:24 -08004436 } else if (strcmp(val, "2SS") == 0 || strcmp(val, "2") == 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004437 snprintf(buf, sizeof(buf), "iwpriv %s nss 2", intf);
Arif Hussainac6c5112018-05-25 17:34:00 -07004438 sta_nss = 2;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004439 } else {
4440 sigma_dut_print(dut, DUT_MSG_ERROR,
4441 "SP_STREAM value not supported");
4442 return -1;
4443 }
4444
4445 if (system(buf) != 0) {
4446 sigma_dut_print(dut, DUT_MSG_ERROR,
4447 "Failed to set SP_STREAM");
4448 return -1;
4449 }
4450
Arif Hussainac6c5112018-05-25 17:34:00 -07004451 dut->sta_nss = sta_nss;
4452
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004453 return 0;
4454}
4455
4456
Pradeep Reddy POTTETI4a1f6b32016-11-23 13:15:21 +05304457static void wcn_sta_set_stbc(struct sigma_dut *dut, const char *intf,
4458 const char *val)
4459{
4460 char buf[60];
Mohammad Asaad Akram50848402020-05-28 14:10:24 +05304461 int ret;
Pradeep Reddy POTTETI4a1f6b32016-11-23 13:15:21 +05304462
4463 snprintf(buf, sizeof(buf), "iwpriv %s tx_stbc %s", intf, val);
Mohammad Asaad Akram50848402020-05-28 14:10:24 +05304464 ret = system(buf);
4465#ifdef NL80211_SUPPORT
4466 if (ret)
4467 ret = sta_config_params(dut, intf, STA_SET_TX_STBC,
4468 strcmp(val, "0") == 0 ? 0 : 1);
4469#endif /* NL80211_SUPPORT */
4470 if (ret)
Pradeep Reddy POTTETI4a1f6b32016-11-23 13:15:21 +05304471 sigma_dut_print(dut, DUT_MSG_ERROR, "iwpriv tx_stbc failed");
4472
4473 snprintf(buf, sizeof(buf), "iwpriv %s rx_stbc %s", intf, val);
Mohammad Asaad Akram50848402020-05-28 14:10:24 +05304474 ret = system(buf);
4475#ifdef NL80211_SUPPORT
4476 if (ret)
4477 ret = sta_config_params(dut, intf, STA_SET_RX_STBC,
4478 strcmp(val, "0") == 0 ? 0 : 1);
4479#endif /* NL80211_SUPPORT */
4480 if (ret)
Pradeep Reddy POTTETI4a1f6b32016-11-23 13:15:21 +05304481 sigma_dut_print(dut, DUT_MSG_ERROR, "iwpriv rx_stbc failed");
4482}
4483
4484
Ashwini Patil68d02cd2017-01-10 15:39:16 +05304485static int mbo_set_cellular_data_capa(struct sigma_dut *dut,
4486 struct sigma_conn *conn,
4487 const char *intf, int capa)
4488{
4489 char buf[32];
4490
4491 if (capa > 0 && capa < 4) {
4492 snprintf(buf, sizeof(buf), "SET mbo_cell_capa %d", capa);
4493 if (wpa_command(intf, buf) < 0) {
4494 send_resp(dut, conn, SIGMA_ERROR,
4495 "ErrorCode, Failed to set cellular data capability");
4496 return 0;
4497 }
4498 return 1;
4499 }
4500
4501 sigma_dut_print(dut, DUT_MSG_ERROR,
4502 "Invalid Cellular data capability: %d", capa);
4503 send_resp(dut, conn, SIGMA_INVALID,
4504 "ErrorCode,Invalid cellular data capability");
4505 return 0;
4506}
4507
4508
Ashwini Patil9183fdb2017-04-13 16:58:25 +05304509static int mbo_set_roaming(struct sigma_dut *dut, struct sigma_conn *conn,
4510 const char *intf, const char *val)
4511{
4512 if (strcasecmp(val, "Disable") == 0) {
4513 if (wpa_command(intf, "SET roaming 0") < 0) {
4514 send_resp(dut, conn, SIGMA_ERROR,
4515 "ErrorCode,Failed to disable roaming");
4516 return 0;
4517 }
4518 return 1;
4519 }
4520
4521 if (strcasecmp(val, "Enable") == 0) {
4522 if (wpa_command(intf, "SET roaming 1") < 0) {
4523 send_resp(dut, conn, SIGMA_ERROR,
4524 "ErrorCode,Failed to enable roaming");
4525 return 0;
4526 }
4527 return 1;
4528 }
4529
4530 sigma_dut_print(dut, DUT_MSG_ERROR,
4531 "Invalid value provided for roaming: %s", val);
4532 send_resp(dut, conn, SIGMA_INVALID,
4533 "ErrorCode,Unknown value provided for Roaming");
4534 return 0;
4535}
4536
4537
Ashwini Patila75de5a2017-04-13 16:35:05 +05304538static int mbo_set_assoc_disallow(struct sigma_dut *dut,
4539 struct sigma_conn *conn,
4540 const char *intf, const char *val)
4541{
4542 if (strcasecmp(val, "Disable") == 0) {
4543 if (wpa_command(intf, "SET ignore_assoc_disallow 1") < 0) {
4544 send_resp(dut, conn, SIGMA_ERROR,
4545 "ErrorCode,Failed to disable Assoc_disallow");
4546 return 0;
4547 }
4548 return 1;
4549 }
4550
4551 if (strcasecmp(val, "Enable") == 0) {
4552 if (wpa_command(intf, "SET ignore_assoc_disallow 0") < 0) {
4553 send_resp(dut, conn, SIGMA_ERROR,
4554 "ErrorCode,Failed to enable Assoc_disallow");
4555 return 0;
4556 }
4557 return 1;
4558 }
4559
4560 sigma_dut_print(dut, DUT_MSG_ERROR,
4561 "Invalid value provided for Assoc_disallow: %s", val);
4562 send_resp(dut, conn, SIGMA_INVALID,
4563 "ErrorCode,Unknown value provided for Assoc_disallow");
4564 return 0;
4565}
4566
4567
Ashwini Patilc63161e2017-04-13 16:30:23 +05304568static int mbo_set_bss_trans_req(struct sigma_dut *dut, struct sigma_conn *conn,
4569 const char *intf, const char *val)
4570{
4571 if (strcasecmp(val, "Reject") == 0) {
4572 if (wpa_command(intf, "SET reject_btm_req_reason 1") < 0) {
4573 send_resp(dut, conn, SIGMA_ERROR,
4574 "ErrorCode,Failed to Reject BTM Request");
4575 return 0;
4576 }
4577 return 1;
4578 }
4579
4580 if (strcasecmp(val, "Accept") == 0) {
4581 if (wpa_command(intf, "SET reject_btm_req_reason 0") < 0) {
4582 send_resp(dut, conn, SIGMA_ERROR,
4583 "ErrorCode,Failed to Accept BTM Request");
4584 return 0;
4585 }
4586 return 1;
4587 }
4588
4589 sigma_dut_print(dut, DUT_MSG_ERROR,
4590 "Invalid value provided for BSS_Transition: %s", val);
4591 send_resp(dut, conn, SIGMA_INVALID,
4592 "ErrorCode,Unknown value provided for BSS_Transition");
4593 return 0;
4594}
4595
4596
Ashwini Patil00402582017-04-13 12:29:39 +05304597static int mbo_set_non_pref_ch_list(struct sigma_dut *dut,
4598 struct sigma_conn *conn,
4599 const char *intf,
4600 struct sigma_cmd *cmd)
4601{
4602 const char *ch, *pref, *op_class, *reason;
4603 char buf[120];
4604 int len, ret;
4605
4606 pref = get_param(cmd, "Ch_Pref");
4607 if (!pref)
4608 return 1;
4609
4610 if (strcasecmp(pref, "clear") == 0) {
4611 free(dut->non_pref_ch_list);
4612 dut->non_pref_ch_list = NULL;
4613 } else {
4614 op_class = get_param(cmd, "Ch_Op_Class");
4615 if (!op_class) {
4616 send_resp(dut, conn, SIGMA_INVALID,
4617 "ErrorCode,Ch_Op_Class not provided");
4618 return 0;
4619 }
4620
4621 ch = get_param(cmd, "Ch_Pref_Num");
4622 if (!ch) {
4623 send_resp(dut, conn, SIGMA_INVALID,
4624 "ErrorCode,Ch_Pref_Num not provided");
4625 return 0;
4626 }
4627
4628 reason = get_param(cmd, "Ch_Reason_Code");
4629 if (!reason) {
4630 send_resp(dut, conn, SIGMA_INVALID,
4631 "ErrorCode,Ch_Reason_Code not provided");
4632 return 0;
4633 }
4634
4635 if (!dut->non_pref_ch_list) {
4636 dut->non_pref_ch_list =
4637 calloc(1, NON_PREF_CH_LIST_SIZE);
4638 if (!dut->non_pref_ch_list) {
4639 send_resp(dut, conn, SIGMA_ERROR,
4640 "ErrorCode,Failed to allocate memory for non_pref_ch_list");
4641 return 0;
4642 }
4643 }
4644 len = strlen(dut->non_pref_ch_list);
4645 ret = snprintf(dut->non_pref_ch_list + len,
4646 NON_PREF_CH_LIST_SIZE - len,
4647 " %s:%s:%s:%s", op_class, ch, pref, reason);
4648 if (ret > 0 && ret < NON_PREF_CH_LIST_SIZE - len) {
4649 sigma_dut_print(dut, DUT_MSG_DEBUG, "non_pref_list: %s",
4650 dut->non_pref_ch_list);
4651 } else {
4652 sigma_dut_print(dut, DUT_MSG_ERROR,
4653 "snprintf failed for non_pref_list, ret = %d",
4654 ret);
4655 send_resp(dut, conn, SIGMA_ERROR,
4656 "ErrorCode,snprintf failed");
4657 free(dut->non_pref_ch_list);
4658 dut->non_pref_ch_list = NULL;
4659 return 0;
4660 }
4661 }
4662
4663 ret = snprintf(buf, sizeof(buf), "SET non_pref_chan%s",
4664 dut->non_pref_ch_list ? dut->non_pref_ch_list : " ");
4665 if (ret < 0 || ret >= (int) sizeof(buf)) {
4666 sigma_dut_print(dut, DUT_MSG_DEBUG,
4667 "snprintf failed for set non_pref_chan, ret: %d",
4668 ret);
4669 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,snprint failed");
4670 return 0;
4671 }
4672
4673 if (wpa_command(intf, buf) < 0) {
4674 send_resp(dut, conn, SIGMA_ERROR,
4675 "ErrorCode,Failed to set non-preferred channel list");
4676 return 0;
4677 }
4678
4679 return 1;
4680}
4681
4682
Amarnath Hullur Subramanyam474a17d2018-02-22 18:45:54 -08004683#ifdef NL80211_SUPPORT
Amarnath Hullur Subramanyamae8a2d92018-03-01 06:32:21 -08004684
Kiran Kumar Lokeree5ed4422018-12-18 18:25:02 -08004685static int sta_set_he_htc_supp(struct sigma_dut *dut, const char *intf,
4686 uint8_t cfg)
4687{
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05304688 return wcn_wifi_test_config_set_u8(
4689 dut, intf, QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_HE_HTC_HE_SUPP,
4690 cfg);
Kiran Kumar Lokeree5ed4422018-12-18 18:25:02 -08004691}
4692
4693
Amarnath Hullur Subramanyam474a17d2018-02-22 18:45:54 -08004694static int sta_set_he_fragmentation(struct sigma_dut *dut, const char *intf,
4695 enum he_fragmentation_val frag)
4696{
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05304697 return wcn_wifi_test_config_set_u8(
4698 dut, intf,
4699 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_HE_FRAGMENTATION, frag);
Amarnath Hullur Subramanyam474a17d2018-02-22 18:45:54 -08004700}
Amarnath Hullur Subramanyamae8a2d92018-03-01 06:32:21 -08004701
4702
Kiran Kumar Lokere26c0f862020-01-22 11:15:59 -08004703int wcn_set_he_ltf(struct sigma_dut *dut, const char *intf,
4704 enum qca_wlan_he_ltf_cfg ltf)
Subhani Shaik8e7a3052018-04-24 14:03:00 -07004705{
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05304706 return wcn_wifi_test_config_set_u8(
4707 dut, intf, QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_HE_LTF, ltf);
Subhani Shaik8e7a3052018-04-24 14:03:00 -07004708}
4709
4710
Amarnath Hullur Subramanyamae8a2d92018-03-01 06:32:21 -08004711static int nlvendor_sta_set_noack(struct sigma_dut *dut, const char *intf,
4712 int noack, enum qca_wlan_ac_type ac)
4713{
4714 struct nl_msg *msg;
4715 int ret = 0;
4716 struct nlattr *params;
4717 int ifindex;
4718
4719 ifindex = if_nametoindex(intf);
4720 if (ifindex == 0) {
4721 sigma_dut_print(dut, DUT_MSG_ERROR,
4722 "%s: Index for interface %s failed",
4723 __func__, intf);
4724 return -1;
4725 }
4726
4727 if (!(msg = nl80211_drv_msg(dut, dut->nl_ctx, ifindex, 0,
4728 NL80211_CMD_VENDOR)) ||
4729 nla_put_u32(msg, NL80211_ATTR_IFINDEX, ifindex) ||
4730 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
4731 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
4732 QCA_NL80211_VENDOR_SUBCMD_WIFI_TEST_CONFIGURATION) ||
4733 !(params = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA)) ||
4734 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_ENABLE_NO_ACK,
4735 noack) ||
4736 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_NO_ACK_AC,
4737 ac)) {
4738 sigma_dut_print(dut, DUT_MSG_ERROR,
4739 "%s: err in adding vendor_cmd and vendor_data",
4740 __func__);
4741 nlmsg_free(msg);
4742 return -1;
4743 }
4744 nla_nest_end(msg, params);
4745
4746 ret = send_and_recv_msgs(dut, dut->nl_ctx, msg, NULL, NULL);
4747 if (ret) {
4748 sigma_dut_print(dut, DUT_MSG_ERROR,
4749 "%s: err in send_and_recv_msgs, ret=%d",
4750 __func__, ret);
4751 }
4752 return ret;
4753}
4754
4755
4756static void wcn_sta_set_noack(struct sigma_dut *dut, const char *intf,
4757 const char *val)
4758{
4759 int noack, ret;
4760 char token[100];
4761 char *result;
4762 char *saveptr;
4763 enum qca_wlan_ac_type ac = QCA_WLAN_AC_BE;
4764
4765 strlcpy(token, val, sizeof(token));
4766 token[sizeof(token) - 1] = '\0';
4767 result = strtok_r(token, ":", &saveptr);
4768 while (result) {
4769 noack = strcasecmp(result, "Disable") != 0;
4770 ret = nlvendor_sta_set_noack(dut, intf, noack, ac);
4771 if (ret) {
4772 sigma_dut_print(dut, DUT_MSG_ERROR,
4773 "nlvendor_sta_set_noack failed for ac:%d, ret:%d",
4774 ac, ret);
4775 }
4776 result = strtok_r(NULL, ":", &saveptr);
4777 ac++;
4778 }
4779}
4780
Vinita S. Maloo7462e812020-05-22 15:16:04 +05304781
4782static int nlvendor_sta_set_phymode(struct sigma_dut *dut, const char *intf,
4783 enum qca_wlan_vendor_phy_mode val)
4784{
4785 struct nl_msg *msg;
4786 struct nlattr *params;
4787 int ifindex, ret;
4788
4789 ifindex = if_nametoindex(intf);
4790 if (ifindex == 0) {
4791 sigma_dut_print(dut, DUT_MSG_ERROR,
4792 "%s: Index for interface %s not found",
4793 __func__, intf);
4794 return -1;
4795 }
4796
4797 msg = nl80211_drv_msg(dut, dut->nl_ctx, ifindex, 0,
4798 NL80211_CMD_VENDOR);
4799 if (!msg) {
4800 sigma_dut_print(dut, DUT_MSG_ERROR,
4801 "%s: err in adding vendor_cmd", __func__);
4802 return -1;
4803 }
4804
4805 if (nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
4806 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
4807 QCA_NL80211_VENDOR_SUBCMD_SET_WIFI_CONFIGURATION)) {
4808 sigma_dut_print(dut, DUT_MSG_ERROR,
4809 "%s: err in adding vendor_attr", __func__);
4810 nlmsg_free(msg);
4811 return -1;
4812 }
4813
4814 params = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
4815 if (!params || nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_CONFIG_PHY_MODE,
4816 val)) {
4817 sigma_dut_print(dut, DUT_MSG_ERROR,
4818 "%s: err in adding vendor_data", __func__);
4819 nlmsg_free(msg);
4820 return -1;
4821 }
4822
4823 nla_nest_end(msg, params);
4824 ret = send_and_recv_msgs(dut, dut->nl_ctx, msg, NULL, NULL);
4825 if (ret) {
4826 sigma_dut_print(dut, DUT_MSG_ERROR,
4827 "%s: err in send_and_recv_msgs, ret=%d (%s)",
4828 __func__, ret, strerror(-ret));
4829 return ret;
4830 }
4831
4832 return 0;
4833}
4834
4835
4836static enum qca_wlan_vendor_phy_mode get_qca_vendor_phymode(const char *val)
4837{
4838 if (strcmp(val, "11a") == 0) {
4839 /* IEEE80211_MODE_11A */
4840 return QCA_WLAN_VENDOR_PHY_MODE_11A;
4841 }
4842
4843 if (strcmp(val, "11g") == 0) {
4844 /* IEEE80211_MODE_11G */
4845 return QCA_WLAN_VENDOR_PHY_MODE_11G;
4846 }
4847
4848 if (strcmp(val, "11b") == 0) {
4849 /* IEEE80211_MODE_11B */
4850 return QCA_WLAN_VENDOR_PHY_MODE_11B;
4851 }
4852
4853 if (strcmp(val, "11n") == 0 ||
4854 strcmp(val, "11nl") == 0 ||
4855 strcmp(val, "11nl(nabg)") == 0) {
4856 /* IEEE80211_MODE_11AGN */
4857 return QCA_WLAN_VENDOR_PHY_MODE_11AGN;
4858 }
4859
4860 if (strcmp(val, "11ng") == 0) {
4861 /* IEEE80211_MODE_11NG_HT40 */
4862 return QCA_WLAN_VENDOR_PHY_MODE_11NG_HT40;
4863 }
4864
4865 if (strcmp(val, "AC") == 0 ||
4866 strcasecmp(val, "11AC") == 0) {
4867 /* IEEE80211_MODE_11AC_VHT80 */
4868 return QCA_WLAN_VENDOR_PHY_MODE_11AC_VHT80;
4869 }
4870
4871 if (strcmp(val, "11na") == 0 ||
4872 strcasecmp(val, "11an") == 0) {
4873 /* IEEE80211_MODE_11NA_HT40 */
4874 return QCA_WLAN_VENDOR_PHY_MODE_11NA_HT40;
4875 }
4876
4877 if (strcmp(val, "11ax") == 0 ||
4878 strcmp(val, "auto") == 0) {
4879 /* IEEE80211_MODE_AUTO */
4880 return QCA_WLAN_VENDOR_PHY_MODE_AUTO;
4881 }
4882
4883 return -1;
4884}
4885
Amarnath Hullur Subramanyam474a17d2018-02-22 18:45:54 -08004886#endif /* NL80211_SUPPORT */
4887
4888
Vinita S. Maloo13a5cf72020-05-22 14:45:06 +05304889static int get_phymode(const char *val)
4890{
4891 if (strcmp(val, "11a") == 0)
4892 return 1; /* IEEE80211_MODE_11A */
4893 if (strcmp(val, "11g") == 0)
4894 return 3; /* IEEE80211_MODE_11G */
4895 if (strcmp(val, "11b") == 0)
4896 return 2; /* IEEE80211_MODE_11B */
4897 if (strcmp(val, "11n") == 0 ||
4898 strcmp(val, "11nl") == 0 ||
4899 strcmp(val, "11nl(nabg)") == 0)
4900 return 22; /* IEEE80211_MODE_11AGN */
4901 if (strcmp(val, "11ng") == 0)
4902 return 13; /* IEEE80211_MODE_11NG_HT40 */
4903 if (strcmp(val, "AC") == 0 ||
4904 strcasecmp(val, "11AC") == 0)
4905 return 19; /* IEEE80211_MODE_11AC_VHT80 */
4906 if (strcmp(val, "11na") == 0 ||
4907 strcasecmp(val, "11an") == 0)
4908 return 14; /* IEEE80211_MODE_11NA_HT40 */
4909 if (strcmp(val, "11ax") == 0 ||
4910 strcmp(val, "auto") == 0)
4911 return 0; /* IEEE80211_MODE_AUTO */
4912 return -1;
4913}
4914
4915
4916static void sta_set_phymode(struct sigma_dut *dut, const char *intf,
4917 const char *val)
4918{
4919 char buf[100];
4920 int len, phymode;
Vinita S. Maloo7462e812020-05-22 15:16:04 +05304921#ifdef NL80211_SUPPORT
4922 enum qca_wlan_vendor_phy_mode qca_phymode;
4923
4924 qca_phymode = get_qca_vendor_phymode(val);
4925 if (qca_phymode == -1) {
4926 sigma_dut_print(dut, DUT_MSG_DEBUG,
4927 "Ignoring mode change for mode: %s",
4928 val);
4929 return;
4930 }
4931
4932 if (nlvendor_sta_set_phymode(dut, intf, qca_phymode) == 0)
4933 return;
4934#endif /* NL80211_SUPPORT */
Vinita S. Maloo13a5cf72020-05-22 14:45:06 +05304935
4936 phymode = get_phymode(val);
4937 if (phymode == -1) {
4938 sigma_dut_print(dut, DUT_MSG_DEBUG,
4939 "Ignoring mode change for mode: %s",
4940 val);
4941 return;
4942 }
4943
4944 len = snprintf(buf, sizeof(buf), "iwpriv %s setphymode %d", intf,
4945 phymode);
4946 if (len < 0 || len >= sizeof(buf)) {
4947 sigma_dut_print(dut, DUT_MSG_ERROR,
4948 "Failed to set phymode");
4949 return;
4950 }
4951
4952 if (system(buf) != 0)
4953 sigma_dut_print(dut, DUT_MSG_ERROR,
4954 "iwpriv setting of phymode failed");
4955}
4956
4957
Jouni Malinenf7222712019-06-13 01:50:21 +03004958static enum sigma_cmd_result
4959cmd_sta_preset_testparameters(struct sigma_dut *dut, struct sigma_conn *conn,
4960 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004961{
4962 const char *intf = get_param(cmd, "Interface");
4963 const char *val;
4964
Jouni Malinen6a7c9b42019-08-20 00:15:59 +03004965 val = get_param(cmd, "FT_DS");
4966 if (val) {
4967 if (strcasecmp(val, "Enable") == 0) {
4968 dut->sta_ft_ds = 1;
4969 } else if (strcasecmp(val, "Disable") == 0) {
4970 dut->sta_ft_ds = 0;
4971 } else {
4972 send_resp(dut, conn, SIGMA_ERROR,
4973 "errorCode,Unsupported value for FT_DS");
4974 return STATUS_SENT_ERROR;
4975 }
4976 }
4977
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004978 val = get_param(cmd, "Program");
Jouni Malinen1f6ae642018-06-07 23:56:13 +03004979 if (val && (strcasecmp(val, "HS2-R2") == 0 ||
4980 strcasecmp(val, "HS2-R3") == 0))
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004981 return cmd_sta_preset_testparameters_hs2_r2(dut, conn, intf,
4982 cmd);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02004983
priyadharshini gowthamand66913a2016-07-29 15:11:17 -07004984 if (val && strcasecmp(val, "LOC") == 0)
4985 return loc_cmd_sta_preset_testparameters(dut, conn, cmd);
Alexei Avshalom Lazareee9ab02018-12-24 16:27:48 +02004986 if (val && strcasecmp(val, "60GHZ") == 0) {
4987 val = get_param(cmd, "WPS");
4988 if (val && strcasecmp(val, "disable") == 0) {
4989 dut->wps_disable = 1;
4990 sigma_dut_print(dut, DUT_MSG_INFO, "WPS disabled");
4991 } else {
4992 /* wps_disable can have other value from the previous
4993 * test, so make sure it has the correct value.
4994 */
4995 dut->wps_disable = 0;
4996 }
4997
4998 val = get_param(cmd, "P2P");
4999 if (val && strcasecmp(val, "disable") == 0)
5000 sigma_dut_print(dut, DUT_MSG_INFO, "P2P disabled");
5001 }
priyadharshini gowthamand66913a2016-07-29 15:11:17 -07005002
Alexei Avshalom Lazar33f700c2018-12-18 16:00:39 +02005003 if (dut->program == PROGRAM_WPS && dut->band == WPS_BAND_60G)
5004 return cmd_sta_preset_testparameters_60ghz(dut, conn, cmd);
5005
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005006#ifdef ANDROID_NAN
5007 if (val && strcasecmp(val, "NAN") == 0)
5008 return nan_cmd_sta_preset_testparameters(dut, conn, cmd);
5009#endif /* ANDROID_NAN */
Amarnath Hullur Subramanyam9c381f52017-03-17 00:04:41 -07005010#ifdef MIRACAST
5011 if (val && (strcasecmp(val, "WFD") == 0 ||
5012 strcasecmp(val, "DisplayR2") == 0))
5013 return miracast_preset_testparameters(dut, conn, cmd);
5014#endif /* MIRACAST */
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005015
Kiran Kumar Lokeredd086642020-06-04 00:29:26 -07005016 if (val &&
5017 (strcasecmp(val, "MBO") == 0 || strcasecmp(val, "HE") == 0)) {
Ashwini Patil68d02cd2017-01-10 15:39:16 +05305018 val = get_param(cmd, "Cellular_Data_Cap");
5019 if (val &&
5020 mbo_set_cellular_data_capa(dut, conn, intf, atoi(val)) == 0)
5021 return 0;
Ashwini Patil00402582017-04-13 12:29:39 +05305022
5023 val = get_param(cmd, "Ch_Pref");
5024 if (val && mbo_set_non_pref_ch_list(dut, conn, intf, cmd) == 0)
5025 return 0;
5026
Ashwini Patilc63161e2017-04-13 16:30:23 +05305027 val = get_param(cmd, "BSS_Transition");
5028 if (val && mbo_set_bss_trans_req(dut, conn, intf, val) == 0)
5029 return 0;
5030
Ashwini Patila75de5a2017-04-13 16:35:05 +05305031 val = get_param(cmd, "Assoc_Disallow");
5032 if (val && mbo_set_assoc_disallow(dut, conn, intf, val) == 0)
5033 return 0;
5034
Ashwini Patil9183fdb2017-04-13 16:58:25 +05305035 val = get_param(cmd, "Roaming");
5036 if (val && mbo_set_roaming(dut, conn, intf, val) == 0)
5037 return 0;
5038
Ashwini Patil68d02cd2017-01-10 15:39:16 +05305039 return 1;
5040 }
5041
Ankita Bajaja2cb5672017-10-25 16:08:28 +05305042 if (val && strcasecmp(val, "OCE") == 0)
5043 return cmd_sta_preset_testparameters_oce(dut, conn, intf, cmd);
5044
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005045#if 0
5046 val = get_param(cmd, "Supplicant");
5047 if (val && strcasecmp(val, "Default") != 0) {
5048 send_resp(dut, conn, SIGMA_ERROR,
5049 "ErrorCode,Only default(Vendor) supplicant "
5050 "supported");
5051 return 0;
5052 }
5053#endif
5054
5055 val = get_param(cmd, "RTS");
5056 if (val) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005057 switch (get_driver_type(dut)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005058 case DRIVER_ATHEROS:
5059 ath_sta_set_rts(dut, intf, val);
5060 break;
5061 default:
5062#if 0
5063 send_resp(dut, conn, SIGMA_ERROR,
5064 "ErrorCode,Setting RTS not supported");
5065 return 0;
5066#else
5067 sigma_dut_print(dut, DUT_MSG_DEBUG,
5068 "Setting RTS not supported");
5069 break;
5070#endif
5071 }
5072 }
5073
5074#if 0
5075 val = get_param(cmd, "FRGMNT");
5076 if (val) {
5077 /* TODO */
5078 send_resp(dut, conn, SIGMA_ERROR,
5079 "ErrorCode,Setting FRGMNT not supported");
5080 return 0;
5081 }
5082#endif
5083
5084#if 0
5085 val = get_param(cmd, "Preamble");
5086 if (val) {
5087 /* TODO: Long/Short */
5088 send_resp(dut, conn, SIGMA_ERROR,
5089 "ErrorCode,Setting Preamble not supported");
5090 return 0;
5091 }
5092#endif
5093
5094 val = get_param(cmd, "Mode");
5095 if (val) {
5096 if (strcmp(val, "11b") == 0 ||
5097 strcmp(val, "11g") == 0 ||
5098 strcmp(val, "11a") == 0 ||
5099 strcmp(val, "11n") == 0 ||
5100 strcmp(val, "11ng") == 0 ||
5101 strcmp(val, "11nl") == 0 ||
5102 strcmp(val, "11nl(nabg)") == 0 ||
5103 strcmp(val, "AC") == 0 ||
5104 strcmp(val, "11AC") == 0 ||
5105 strcmp(val, "11ac") == 0 ||
5106 strcmp(val, "11na") == 0 ||
Amarnath Hullur Subramanyamb0db2712018-01-30 19:40:35 -08005107 strcmp(val, "11an") == 0 ||
5108 strcmp(val, "11ax") == 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005109 /* STA supports all modes by default */
5110 } else {
5111 send_resp(dut, conn, SIGMA_ERROR,
5112 "ErrorCode,Setting Mode not supported");
5113 return 0;
5114 }
Amarnath Hullur Subramanyam97d0e532018-01-31 02:53:02 -08005115
5116 /* Change the mode only in case of testbed for HE program
5117 * and for 11a and 11g modes only. */
5118 if (dut->program == PROGRAM_HE &&
5119 dut->device_type == STA_testbed) {
Vinita S. Maloo13a5cf72020-05-22 14:45:06 +05305120 sta_set_phymode(dut, intf, val);
Amarnath Hullur Subramanyam97d0e532018-01-31 02:53:02 -08005121 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005122 }
5123
5124 val = get_param(cmd, "wmm");
5125 if (val) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005126 switch (get_driver_type(dut)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005127 case DRIVER_ATHEROS:
5128 ath_sta_set_wmm(dut, intf, val);
5129 break;
Amarnath Hullur Subramanyam75214d22018-02-04 19:17:11 -08005130 case DRIVER_WCN:
5131 wcn_sta_set_wmm(dut, intf, val);
5132 break;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005133 default:
5134 sigma_dut_print(dut, DUT_MSG_DEBUG,
5135 "Setting wmm not supported");
5136 break;
5137 }
5138 }
5139
5140 val = get_param(cmd, "Powersave");
5141 if (val) {
5142 if (strcmp(val, "0") == 0 || strcasecmp(val, "off") == 0) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005143 if (get_driver_type(dut) == DRIVER_WCN) {
Vinita S. Malooa8b62722020-04-23 01:45:41 +05305144 if (set_power_save_wcn(dut, intf, 2) < 0)
Kiran Kumar Lokered6149ff2018-12-05 20:20:41 -08005145 return 0;
Kiran Kumar Lokered6149ff2018-12-05 20:20:41 -08005146 }
5147
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005148 if (wpa_command(get_station_ifname(dut),
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005149 "P2P_SET ps 0") < 0)
5150 return -2;
5151 /* Make sure test modes are disabled */
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005152 wpa_command(get_station_ifname(dut), "P2P_SET ps 98");
5153 wpa_command(get_station_ifname(dut), "P2P_SET ps 96");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005154 } else if (strcmp(val, "1") == 0 ||
5155 strcasecmp(val, "PSPoll") == 0 ||
5156 strcasecmp(val, "on") == 0) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005157 if (get_driver_type(dut) == DRIVER_WCN) {
Vinita S. Malooa8b62722020-04-23 01:45:41 +05305158 if (set_power_save_wcn(dut, intf, 1) < 0)
Kiran Kumar Lokered6149ff2018-12-05 20:20:41 -08005159 return 0;
Kiran Kumar Lokered6149ff2018-12-05 20:20:41 -08005160 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005161 /* Disable default power save mode */
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005162 wpa_command(get_station_ifname(dut), "P2P_SET ps 0");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005163 /* Enable PS-Poll test mode */
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005164 if (wpa_command(get_station_ifname(dut),
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005165 "P2P_SET ps 97") < 0 ||
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005166 wpa_command(get_station_ifname(dut),
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005167 "P2P_SET ps 99") < 0)
5168 return -2;
5169 } else if (strcmp(val, "2") == 0 ||
5170 strcasecmp(val, "Fast") == 0) {
5171 /* TODO */
5172 send_resp(dut, conn, SIGMA_ERROR,
5173 "ErrorCode,Powersave=Fast not supported");
5174 return 0;
5175 } else if (strcmp(val, "3") == 0 ||
5176 strcasecmp(val, "PSNonPoll") == 0) {
5177 /* Make sure test modes are disabled */
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005178 wpa_command(get_station_ifname(dut), "P2P_SET ps 98");
5179 wpa_command(get_station_ifname(dut), "P2P_SET ps 96");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005180
5181 /* Enable default power save mode */
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005182 if (wpa_command(get_station_ifname(dut),
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005183 "P2P_SET ps 1") < 0)
5184 return -2;
5185 } else
5186 return -1;
5187 }
5188
5189 val = get_param(cmd, "NoAck");
5190 if (val) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005191 switch (get_driver_type(dut)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005192 case DRIVER_ATHEROS:
5193 ath_sta_set_noack(dut, intf, val);
5194 break;
Amarnath Hullur Subramanyamae8a2d92018-03-01 06:32:21 -08005195#ifdef NL80211_SUPPORT
5196 case DRIVER_WCN:
5197 wcn_sta_set_noack(dut, intf, val);
5198 break;
5199#endif /* NL80211_SUPPORT */
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005200 default:
5201 send_resp(dut, conn, SIGMA_ERROR,
5202 "ErrorCode,Setting NoAck not supported");
5203 return 0;
5204 }
5205 }
5206
5207 val = get_param(cmd, "IgnoreChswitchProhibit");
5208 if (val) {
5209 /* TODO: Enabled/disabled */
5210 if (strcasecmp(val, "Enabled") == 0) {
5211 send_resp(dut, conn, SIGMA_ERROR,
5212 "ErrorCode,Enabling IgnoreChswitchProhibit "
5213 "not supported");
5214 return 0;
5215 }
5216 }
5217
5218 val = get_param(cmd, "TDLS");
5219 if (val) {
5220 if (strcasecmp(val, "Disabled") == 0) {
5221 if (wpa_command(intf, "SET tdls_disabled 1")) {
5222 send_resp(dut, conn, SIGMA_ERROR,
5223 "ErrorCode,Failed to disable TDLS");
5224 return 0;
5225 }
5226 } else if (strcasecmp(val, "Enabled") == 0) {
5227 if (wpa_command(intf, "SET tdls_disabled 0")) {
5228 send_resp(dut, conn, SIGMA_ERROR,
5229 "ErrorCode,Failed to enable TDLS");
5230 return 0;
5231 }
5232 } else {
5233 send_resp(dut, conn, SIGMA_ERROR,
5234 "ErrorCode,Unsupported TDLS value");
5235 return 0;
5236 }
5237 }
5238
5239 val = get_param(cmd, "TDLSmode");
5240 if (val) {
5241 if (strcasecmp(val, "Default") == 0) {
5242 wpa_command(intf, "SET tdls_testing 0");
5243 } else if (strcasecmp(val, "APProhibit") == 0) {
5244 if (wpa_command(intf, "SET tdls_testing 0x400")) {
5245 send_resp(dut, conn, SIGMA_ERROR,
5246 "ErrorCode,Failed to enable ignore "
5247 "APProhibit TDLS mode");
5248 return 0;
5249 }
5250 } else if (strcasecmp(val, "HiLoMac") == 0) {
5251 /* STA should respond with TDLS setup req for a TDLS
5252 * setup req */
5253 if (wpa_command(intf, "SET tdls_testing 0x80")) {
5254 send_resp(dut, conn, SIGMA_ERROR,
5255 "ErrorCode,Failed to enable HiLoMac "
5256 "TDLS mode");
5257 return 0;
5258 }
5259 } else if (strcasecmp(val, "WeakSecurity") == 0) {
5260 /*
5261 * Since all security modes are enabled by default when
5262 * Sigma control is used, there is no need to do
5263 * anything here.
5264 */
5265 } else if (strcasecmp(val, "ExistLink") == 0) {
5266 /*
5267 * Since we allow new TDLS Setup Request even if there
5268 * is an existing link, nothing needs to be done for
5269 * this.
5270 */
5271 } else {
5272 /* TODO:
5273 * ExistLink: STA should send TDLS setup req even if
5274 * direct link already exists
5275 */
5276 send_resp(dut, conn, SIGMA_ERROR,
5277 "ErrorCode,Unsupported TDLSmode value");
5278 return 0;
5279 }
5280 }
5281
5282 val = get_param(cmd, "FakePubKey");
5283 if (val && atoi(val) && wpa_command(intf, "SET wps_corrupt_pkhash 1")) {
5284 send_resp(dut, conn, SIGMA_ERROR,
5285 "ErrorCode,Failed to enable FakePubKey");
5286 return 0;
5287 }
5288
Amarnath Hullur Subramanyamae1042b2018-02-22 21:52:52 -08005289#ifdef NL80211_SUPPORT
5290 val = get_param(cmd, "FrgmntSupport");
5291 if (val) {
5292 if (strcasecmp(val, "Enable") == 0) {
5293 if (sta_set_he_fragmentation(dut, intf,
5294 HE_FRAG_LEVEL1)) {
5295 send_resp(dut, conn, SIGMA_ERROR,
5296 "ErrorCode,Failed to enable HE Fragmentation");
5297 return 0;
5298 }
5299 } else if (strcasecmp(val, "Disable") == 0) {
5300 if (sta_set_he_fragmentation(dut, intf,
5301 HE_FRAG_DISABLE)) {
5302 send_resp(dut, conn, SIGMA_ERROR,
5303 "ErrorCode,Failed to disable HE Fragmentation");
5304 return 0;
5305 }
5306 }
5307 }
5308#endif /* NL80211_SUPPORT */
5309
Vinita S. Maloo8a4779c2020-06-22 19:32:37 +05305310 val = get_param(cmd, "IncludeMSCSDescriptor");
5311 if (val && strcasecmp(val, "1") == 0) {
5312 char buf[128];
5313 int len;
5314
5315 len = snprintf(buf, sizeof(buf),
Veerendranath Jakkam62cde372020-08-19 18:03:06 +05305316 "MSCS add up_bitmap=F0 up_limit=7 stream_timeout=60000 frame_classifier=045F%032x",
Vinita S. Maloo8a4779c2020-06-22 19:32:37 +05305317 0);
5318
5319 if (len < 0 || len >= sizeof(buf)) {
5320 sigma_dut_print(dut, DUT_MSG_ERROR,
5321 "Failed to build MSCS Descriptor IE");
5322 return ERROR_SEND_STATUS;
5323 }
5324
5325 if (wpa_command(intf, buf) != 0) {
5326 send_resp(dut, conn, SIGMA_ERROR,
5327 "ErrorCode,Failed to include MSCS descriptor");
5328 return STATUS_SENT_ERROR;
5329 }
5330 }
5331
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005332 return 1;
5333}
5334
5335
5336static const char * ath_get_radio_name(const char *radio_name)
5337{
5338 if (radio_name == NULL)
5339 return "wifi0";
5340 if (strcmp(radio_name, "wifi1") == 0)
5341 return "wifi1";
5342 if (strcmp(radio_name, "wifi2") == 0)
5343 return "wifi2";
5344 return "wifi0";
5345}
5346
5347
5348static void ath_sta_set_txsp_stream(struct sigma_dut *dut, const char *intf,
5349 const char *val)
5350{
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005351 unsigned int vht_mcsmap = 0;
5352 int txchainmask = 0;
5353 const char *basedev = ath_get_radio_name(sigma_radio_ifname[0]);
5354
5355 if (strcasecmp(val, "1") == 0 || strcasecmp(val, "1SS") == 0) {
5356 if (dut->testbed_flag_txsp == 1) {
5357 vht_mcsmap = 0xfffc;
5358 dut->testbed_flag_txsp = 0;
5359 } else {
5360 vht_mcsmap = 0xfffe;
5361 }
5362 txchainmask = 1;
5363 } else if (strcasecmp(val, "2") == 0 || strcasecmp(val, "2SS") == 0) {
5364 if (dut->testbed_flag_txsp == 1) {
5365 vht_mcsmap = 0xfff0;
5366 dut->testbed_flag_txsp = 0;
5367 } else {
5368 vht_mcsmap = 0xfffa;
5369 }
5370 txchainmask = 3;
5371 } else if (strcasecmp(val, "3") == 0 || strcasecmp(val, "3SS") == 0) {
5372 if (dut->testbed_flag_txsp == 1) {
5373 vht_mcsmap = 0xffc0;
5374 dut->testbed_flag_txsp = 0;
5375 } else {
5376 vht_mcsmap = 0xffea;
5377 }
5378 txchainmask = 7;
5379 } else if (strcasecmp(val, "4") == 0 || strcasecmp(val, "4SS") == 0) {
5380 if (dut->testbed_flag_txsp == 1) {
5381 vht_mcsmap = 0xff00;
5382 dut->testbed_flag_txsp = 0;
5383 } else {
5384 vht_mcsmap = 0xffaa;
5385 }
5386 txchainmask = 15;
5387 } else {
5388 if (dut->testbed_flag_txsp == 1) {
5389 vht_mcsmap = 0xffc0;
5390 dut->testbed_flag_txsp = 0;
5391 } else {
5392 vht_mcsmap = 0xffea;
5393 }
5394 }
5395
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07005396 if (txchainmask)
5397 run_iwpriv(dut, basedev, "txchainmask %d", txchainmask);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005398
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07005399 run_iwpriv(dut, intf, "vht_mcsmap 0x%04x", vht_mcsmap);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005400}
5401
5402
5403static void ath_sta_set_rxsp_stream(struct sigma_dut *dut, const char *intf,
5404 const char *val)
5405{
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005406 unsigned int vht_mcsmap = 0;
5407 int rxchainmask = 0;
5408 const char *basedev = ath_get_radio_name(sigma_radio_ifname[0]);
5409
5410 if (strcasecmp(val, "1") == 0 || strcasecmp(val, "1SS") == 0) {
5411 if (dut->testbed_flag_rxsp == 1) {
5412 vht_mcsmap = 0xfffc;
5413 dut->testbed_flag_rxsp = 0;
5414 } else {
5415 vht_mcsmap = 0xfffe;
5416 }
5417 rxchainmask = 1;
5418 } else if (strcasecmp(val, "2") == 0 || strcasecmp(val, "2SS") == 0) {
5419 if (dut->testbed_flag_rxsp == 1) {
5420 vht_mcsmap = 0xfff0;
5421 dut->testbed_flag_rxsp = 0;
5422 } else {
5423 vht_mcsmap = 0xfffa;
5424 }
5425 rxchainmask = 3;
5426 } else if (strcasecmp(val, "3") == 0 || strcasecmp(val, "3SS") == 0) {
5427 if (dut->testbed_flag_rxsp == 1) {
5428 vht_mcsmap = 0xffc0;
5429 dut->testbed_flag_rxsp = 0;
5430 } else {
5431 vht_mcsmap = 0xffea;
5432 }
5433 rxchainmask = 7;
5434 } else if (strcasecmp(val, "4") == 0 || strcasecmp(val, "4SS") == 0) {
5435 if (dut->testbed_flag_rxsp == 1) {
5436 vht_mcsmap = 0xff00;
5437 dut->testbed_flag_rxsp = 0;
5438 } else {
5439 vht_mcsmap = 0xffaa;
5440 }
5441 rxchainmask = 15;
5442 } else {
5443 if (dut->testbed_flag_rxsp == 1) {
5444 vht_mcsmap = 0xffc0;
5445 dut->testbed_flag_rxsp = 0;
5446 } else {
5447 vht_mcsmap = 0xffea;
5448 }
5449 }
5450
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07005451 if (rxchainmask)
5452 run_iwpriv(dut, basedev, "rxchainmask %d", rxchainmask);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005453
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07005454 run_iwpriv(dut, intf, "vht_mcsmap 0x%04x", vht_mcsmap);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005455}
5456
5457
5458void ath_set_zero_crc(struct sigma_dut *dut, const char *val)
5459{
5460 if (strcasecmp(val, "enable") == 0) {
5461 if (system("athdiag --set --address=0x2a204 --and=0xbfffffff")
5462 != 0) {
5463 sigma_dut_print(dut, DUT_MSG_ERROR,
5464 "Disable BB_VHTSIGB_CRC_CALC failed");
5465 }
5466
5467 if (system("athdiag --set --address=0x2a204 --or=0x80000000")
5468 != 0) {
5469 sigma_dut_print(dut, DUT_MSG_ERROR,
5470 "Enable FORCE_VHT_SIGB_CRC_VALUE_ZERO failed");
5471 }
5472 } else {
5473 if (system("athdiag --set --address=0x2a204 --and=0x7fffffff")
5474 != 0) {
5475 sigma_dut_print(dut, DUT_MSG_ERROR,
5476 "Disable FORCE_VHT_SIGB_CRC_VALUE_ZERO failed");
5477 }
5478
5479 if (system("athdiag --set --address=0x2a204 --or=0x40000000")
5480 != 0) {
5481 sigma_dut_print(dut, DUT_MSG_ERROR,
5482 "Enable BB_VHTSIGB_CRC_CALC failed");
5483 }
5484 }
5485}
5486
5487
Amarnath Hullur Subramanyamebfe6b62018-01-31 03:04:17 -08005488static int wcn_sta_set_width(struct sigma_dut *dut, const char *intf,
5489 const char *val)
5490{
5491 char buf[60];
5492
5493 if (strcmp(val, "20") == 0) {
5494 snprintf(buf, sizeof(buf), "iwpriv %s chwidth 0", intf);
5495 dut->chwidth = 0;
5496 } else if (strcmp(val, "40") == 0) {
5497 snprintf(buf, sizeof(buf), "iwpriv %s chwidth 1", intf);
5498 dut->chwidth = 1;
5499 } else if (strcmp(val, "80") == 0) {
5500 snprintf(buf, sizeof(buf), "iwpriv %s chwidth 2", intf);
5501 dut->chwidth = 2;
Sunil Duttb1cccac2018-05-22 21:03:12 +05305502 } else if (strcasecmp(val, "Auto") == 0) {
Amarnath Hullur Subramanyamebfe6b62018-01-31 03:04:17 -08005503 buf[0] = '\0';
5504 } else {
5505 sigma_dut_print(dut, DUT_MSG_ERROR, "WIDTH %s not supported",
5506 val);
5507 return -1;
5508 }
5509
5510 if (buf[0] != '\0' && system(buf) != 0) {
5511 sigma_dut_print(dut, DUT_MSG_ERROR, "iwpriv chwidth failed");
5512 return -1;
5513 }
5514
5515 return 0;
5516}
5517
5518
Amarnath Hullur Subramanyamd8a9db92018-02-02 18:53:14 -08005519static int nlvendor_sta_set_addba_reject(struct sigma_dut *dut,
5520 const char *intf, int addbareject)
5521{
5522#ifdef NL80211_SUPPORT
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05305523 return wcn_wifi_test_config_set_u8(
5524 dut, intf,
5525 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_ACCEPT_ADDBA_REQ,
5526 !addbareject);
Amarnath Hullur Subramanyamd8a9db92018-02-02 18:53:14 -08005527#else /* NL80211_SUPPORT */
5528 sigma_dut_print(dut, DUT_MSG_ERROR,
5529 "ADDBA_REJECT cannot be set without NL80211_SUPPORT defined");
5530 return -1;
5531#endif /* NL80211_SUPPORT */
5532}
5533
5534
5535static int sta_set_addba_reject(struct sigma_dut *dut, const char *intf,
5536 int addbareject)
5537{
5538 int ret;
5539
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005540 switch (get_driver_type(dut)) {
Amarnath Hullur Subramanyamd8a9db92018-02-02 18:53:14 -08005541 case DRIVER_WCN:
5542 ret = nlvendor_sta_set_addba_reject(dut, intf, addbareject);
5543 if (ret) {
5544 sigma_dut_print(dut, DUT_MSG_ERROR,
5545 "nlvendor_sta_set_addba_reject failed, ret:%d",
5546 ret);
5547 return ret;
5548 }
5549 break;
5550 default:
5551 sigma_dut_print(dut, DUT_MSG_ERROR,
5552 "errorCode,Unsupported ADDBA_REJECT with the current driver");
5553 ret = -1;
5554 break;
5555 }
5556
5557 return ret;
5558}
5559
5560
Amarnath Hullur Subramanyam1f65a672018-03-07 14:50:29 -08005561static int nlvendor_config_send_addba(struct sigma_dut *dut, const char *intf,
5562 int enable)
Amarnath Hullur Subramanyam9745b3c2018-02-04 21:27:57 -08005563{
5564#ifdef NL80211_SUPPORT
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05305565 return wcn_wifi_test_config_set_u8(
5566 dut, intf, QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_SEND_ADDBA_REQ,
5567 enable);
Amarnath Hullur Subramanyam9745b3c2018-02-04 21:27:57 -08005568#else /* NL80211_SUPPORT */
5569 sigma_dut_print(dut, DUT_MSG_ERROR,
5570 "Disable addba not possible without NL80211_SUPPORT defined");
5571 return -1;
5572#endif /* NL80211_SUPPORT */
5573}
5574
5575
Veerendranath Jakkamadcd6202019-04-17 12:32:21 +05305576#ifdef NL80211_SUPPORT
5577static int nl80211_sta_set_rts(struct sigma_dut *dut, const char *intf, int val)
5578{
5579 struct nl_msg *msg;
5580 int ret = 0;
5581 int ifindex;
5582
5583 ifindex = if_nametoindex(intf);
5584 if (ifindex == 0) {
5585 sigma_dut_print(dut, DUT_MSG_ERROR,
5586 "%s: Index for interface %s failed",
5587 __func__, intf);
5588 return -1;
5589 }
5590
5591 if (!(msg = nl80211_drv_msg(dut, dut->nl_ctx, ifindex, 0,
5592 NL80211_CMD_SET_WIPHY)) ||
5593 nla_put_u32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD, val)) {
5594 sigma_dut_print(dut, DUT_MSG_ERROR,
5595 "%s: err in adding RTS threshold",
5596 __func__);
5597 nlmsg_free(msg);
5598 return -1;
5599 }
5600
5601 ret = send_and_recv_msgs(dut, dut->nl_ctx, msg, NULL, NULL);
5602 if (ret) {
5603 sigma_dut_print(dut, DUT_MSG_ERROR,
5604 "%s: err in send_and_recv_msgs, ret=%d",
5605 __func__, ret);
5606 }
5607 return ret;
5608}
5609#endif /* NL80211_SUPPORT */
5610
5611
5612static int sta_set_rts(struct sigma_dut *dut, const char *intf, int val)
5613{
5614 char buf[100];
5615
5616#ifdef NL80211_SUPPORT
5617 if (nl80211_sta_set_rts(dut, intf, val) == 0)
5618 return 0;
5619 sigma_dut_print(dut, DUT_MSG_DEBUG,
5620 "Fall back to using iwconfig for setting RTS threshold");
5621#endif /* NL80211_SUPPORT */
5622
5623 snprintf(buf, sizeof(buf), "iwconfig %s rts %d", intf, val);
5624 if (system(buf) != 0) {
5625 sigma_dut_print(dut, DUT_MSG_ERROR,
5626 "Failed to set RTS threshold %d", val);
5627 return -1;
5628 }
5629 return 0;
5630}
5631
5632
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005633static enum sigma_cmd_result
5634cmd_sta_set_wireless_common(const char *intf, struct sigma_dut *dut,
5635 struct sigma_conn *conn, struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005636{
5637 const char *val;
Amarnath Hullur Subramanyamd8a9db92018-02-02 18:53:14 -08005638 int ampdu = -1, addbareject = -1;
Jouni Malinen3aa72862019-05-29 23:14:51 +03005639 char buf[128];
5640 int res;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005641
5642 val = get_param(cmd, "40_INTOLERANT");
5643 if (val) {
5644 if (strcmp(val, "1") == 0 || strcasecmp(val, "Enable") == 0) {
5645 /* TODO: iwpriv ht40intol through wpa_supplicant */
5646 send_resp(dut, conn, SIGMA_ERROR,
5647 "ErrorCode,40_INTOLERANT not supported");
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005648 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005649 }
5650 }
5651
5652 val = get_param(cmd, "ADDBA_REJECT");
5653 if (val) {
5654 if (strcmp(val, "1") == 0 || strcasecmp(val, "Enable") == 0) {
5655 /* reject any ADDBA with status "decline" */
5656 ampdu = 0;
Amarnath Hullur Subramanyamd8a9db92018-02-02 18:53:14 -08005657 addbareject = 1;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005658 } else {
5659 /* accept ADDBA */
5660 ampdu = 1;
Amarnath Hullur Subramanyamd8a9db92018-02-02 18:53:14 -08005661 addbareject = 0;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005662 }
5663 }
5664
Amarnath Hullur Subramanyamd8a9db92018-02-02 18:53:14 -08005665 if (addbareject >= 0 &&
5666 sta_set_addba_reject(dut, intf, addbareject) < 0) {
5667 send_resp(dut, conn, SIGMA_ERROR,
5668 "ErrorCode,set addba_reject failed");
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005669 return STATUS_SENT_ERROR;
Amarnath Hullur Subramanyamd8a9db92018-02-02 18:53:14 -08005670 }
5671
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005672 val = get_param(cmd, "AMPDU");
5673 if (val) {
5674 if (strcmp(val, "1") == 0 || strcasecmp(val, "Enable") == 0) {
5675 /* enable AMPDU Aggregation */
5676 if (ampdu == 0) {
5677 send_resp(dut, conn, SIGMA_ERROR,
5678 "ErrorCode,Mismatch in "
5679 "addba_reject/ampdu - "
5680 "not supported");
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005681 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005682 }
5683 ampdu = 1;
5684 } else {
5685 /* disable AMPDU Aggregation */
5686 if (ampdu == 1) {
5687 send_resp(dut, conn, SIGMA_ERROR,
5688 "ErrorCode,Mismatch in "
5689 "addba_reject/ampdu - "
5690 "not supported");
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005691 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005692 }
5693 ampdu = 0;
5694 }
5695 }
5696
5697 if (ampdu >= 0) {
Amarnath Hullur Subramanyam9745b3c2018-02-04 21:27:57 -08005698 int ret;
5699
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005700 sigma_dut_print(dut, DUT_MSG_DEBUG, "%s A-MPDU aggregation",
5701 ampdu ? "Enabling" : "Disabling");
5702 snprintf(buf, sizeof(buf), "SET ampdu %d", ampdu);
Deepak Dhamdhere80356cb2016-03-28 16:48:32 -07005703 if (wpa_command(intf, buf) < 0 &&
5704 iwpriv_sta_set_ampdu(dut, intf, ampdu) < 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005705 send_resp(dut, conn, SIGMA_ERROR,
5706 "ErrorCode,set aggr failed");
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005707 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005708 }
Amarnath Hullur Subramanyam9745b3c2018-02-04 21:27:57 -08005709
5710 if (ampdu == 0) {
5711 /* Disable sending of addba using nl vendor command */
Amarnath Hullur Subramanyam1f65a672018-03-07 14:50:29 -08005712 ret = nlvendor_config_send_addba(dut, intf, 0);
Amarnath Hullur Subramanyam9745b3c2018-02-04 21:27:57 -08005713 if (ret) {
5714 sigma_dut_print(dut, DUT_MSG_ERROR,
5715 "Failed to disable addba, ret:%d",
5716 ret);
5717 }
5718 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005719 }
5720
5721 val = get_param(cmd, "AMSDU");
5722 if (val) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005723 switch (get_driver_type(dut)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005724 case DRIVER_ATHEROS:
Amarnath Hullur Subramanyamd5bb5732018-02-22 15:50:38 -08005725 case DRIVER_WCN:
5726 iwpriv_sta_set_amsdu(dut, intf, val);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005727 break;
5728 default:
5729 if (strcmp(val, "1") == 0 ||
5730 strcasecmp(val, "Enable") == 0) {
5731 /* Enable AMSDU Aggregation */
5732 send_resp(dut, conn, SIGMA_ERROR,
5733 "ErrorCode,AMSDU aggregation not supported");
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005734 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005735 }
5736 break;
5737 }
5738 }
5739
5740 val = get_param(cmd, "STBC_RX");
5741 if (val) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005742 switch (get_driver_type(dut)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005743 case DRIVER_ATHEROS:
5744 ath_sta_set_stbc(dut, intf, val);
5745 break;
Pradeep Reddy POTTETI4a1f6b32016-11-23 13:15:21 +05305746 case DRIVER_WCN:
5747 wcn_sta_set_stbc(dut, intf, val);
5748 break;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005749 default:
5750 send_resp(dut, conn, SIGMA_ERROR,
5751 "ErrorCode,STBC_RX not supported");
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005752 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005753 }
5754 }
5755
5756 val = get_param(cmd, "WIDTH");
5757 if (val) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005758 switch (get_driver_type(dut)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005759 case DRIVER_WCN:
Amarnath Hullur Subramanyamebfe6b62018-01-31 03:04:17 -08005760 if (wcn_sta_set_width(dut, intf, val) < 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005761 send_resp(dut, conn, SIGMA_ERROR,
5762 "ErrorCode,Failed to set WIDTH");
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005763 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005764 }
5765 break;
5766 case DRIVER_ATHEROS:
5767 if (ath_set_width(dut, conn, intf, val) < 0)
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005768 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005769 break;
5770 default:
5771 sigma_dut_print(dut, DUT_MSG_ERROR,
5772 "Setting WIDTH not supported");
5773 break;
5774 }
5775 }
5776
5777 val = get_param(cmd, "SMPS");
5778 if (val) {
5779 /* TODO: Dynamic/0, Static/1, No Limit/2 */
5780 send_resp(dut, conn, SIGMA_ERROR,
5781 "ErrorCode,SMPS not supported");
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005782 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005783 }
5784
5785 val = get_param(cmd, "TXSP_STREAM");
5786 if (val) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005787 switch (get_driver_type(dut)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005788 case DRIVER_WCN:
5789 if (wcn_sta_set_sp_stream(dut, intf, val) < 0) {
5790 send_resp(dut, conn, SIGMA_ERROR,
5791 "ErrorCode,Failed to set TXSP_STREAM");
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005792 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005793 }
5794 break;
5795 case DRIVER_ATHEROS:
5796 ath_sta_set_txsp_stream(dut, intf, val);
5797 break;
5798 default:
5799 sigma_dut_print(dut, DUT_MSG_ERROR,
5800 "Setting TXSP_STREAM not supported");
5801 break;
5802 }
5803 }
5804
5805 val = get_param(cmd, "RXSP_STREAM");
5806 if (val) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005807 switch (get_driver_type(dut)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005808 case DRIVER_WCN:
5809 if (wcn_sta_set_sp_stream(dut, intf, val) < 0) {
5810 send_resp(dut, conn, SIGMA_ERROR,
5811 "ErrorCode,Failed to set RXSP_STREAM");
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005812 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005813 }
5814 break;
5815 case DRIVER_ATHEROS:
5816 ath_sta_set_rxsp_stream(dut, intf, val);
5817 break;
5818 default:
5819 sigma_dut_print(dut, DUT_MSG_ERROR,
5820 "Setting RXSP_STREAM not supported");
5821 break;
5822 }
5823 }
5824
5825 val = get_param(cmd, "DYN_BW_SGNL");
5826 if (val) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005827 switch (get_driver_type(dut)) {
Priyadharshini Gowthaman818afef2015-11-09 13:28:15 -08005828 case DRIVER_WCN:
Peng Xuc59afd32016-11-21 15:01:11 -08005829 if (strcasecmp(val, "enable") == 0) {
5830 snprintf(buf, sizeof(buf),
5831 "iwpriv %s cwmenable 1", intf);
5832 if (system(buf) != 0) {
5833 sigma_dut_print(dut, DUT_MSG_ERROR,
5834 "iwpriv cwmenable 1 failed");
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005835 return ERROR_SEND_STATUS;
Peng Xuc59afd32016-11-21 15:01:11 -08005836 }
5837 } else if (strcasecmp(val, "disable") == 0) {
5838 snprintf(buf, sizeof(buf),
5839 "iwpriv %s cwmenable 0", intf);
5840 if (system(buf) != 0) {
5841 sigma_dut_print(dut, DUT_MSG_ERROR,
5842 "iwpriv cwmenable 0 failed");
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005843 return ERROR_SEND_STATUS;
Peng Xuc59afd32016-11-21 15:01:11 -08005844 }
5845 } else {
5846 sigma_dut_print(dut, DUT_MSG_ERROR,
5847 "Unsupported DYN_BW_SGL");
5848 }
5849
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005850 snprintf(buf, sizeof(buf), "iwpriv %s cts_cbw 3", intf);
5851 if (system(buf) != 0) {
5852 sigma_dut_print(dut, DUT_MSG_ERROR,
5853 "Failed to set cts_cbw in DYN_BW_SGNL");
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005854 return ERROR_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005855 }
Priyadharshini Gowthaman818afef2015-11-09 13:28:15 -08005856 break;
5857 case DRIVER_ATHEROS:
Priyadharshini Gowthaman8c5b9a42019-07-31 14:38:48 -07005858 novap_reset(dut, intf, 1);
Priyadharshini Gowthaman818afef2015-11-09 13:28:15 -08005859 ath_config_dyn_bw_sig(dut, intf, val);
5860 break;
5861 default:
5862 sigma_dut_print(dut, DUT_MSG_ERROR,
5863 "Failed to set DYN_BW_SGNL");
5864 break;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005865 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005866 }
5867
5868 val = get_param(cmd, "RTS_FORCE");
5869 if (val) {
Priyadharshini Gowthaman8c5b9a42019-07-31 14:38:48 -07005870 novap_reset(dut, intf, 1);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005871 if (strcasecmp(val, "Enable") == 0) {
Veerendranath Jakkamadcd6202019-04-17 12:32:21 +05305872 if (sta_set_rts(dut, intf, 64) != 0) {
Priyadharshini Gowthamanabdb2122015-11-17 11:52:19 +02005873 sigma_dut_print(dut, DUT_MSG_ERROR,
5874 "Failed to set RTS_FORCE 64");
5875 }
Jouni Malinen3aa72862019-05-29 23:14:51 +03005876 res = snprintf(buf, sizeof(buf),
5877 "wifitool %s beeliner_fw_test 100 1",
5878 intf);
5879 if (res < 0 || res >= sizeof(buf) || system(buf) != 0) {
priyadharshini gowthaman270870e2015-12-09 10:10:23 -08005880 sigma_dut_print(dut, DUT_MSG_ERROR,
5881 "wifitool beeliner_fw_test 100 1 failed");
5882 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005883 } else if (strcasecmp(val, "Disable") == 0) {
Veerendranath Jakkamadcd6202019-04-17 12:32:21 +05305884 if (sta_set_rts(dut, intf, 2347) != 0) {
Priyadharshini Gowthamanabdb2122015-11-17 11:52:19 +02005885 sigma_dut_print(dut, DUT_MSG_ERROR,
5886 "Failed to set RTS_FORCE 2347");
5887 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005888 } else {
5889 send_resp(dut, conn, SIGMA_ERROR,
5890 "ErrorCode,RTS_FORCE value not supported");
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005891 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005892 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005893 }
5894
5895 val = get_param(cmd, "CTS_WIDTH");
5896 if (val) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005897 switch (get_driver_type(dut)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005898 case DRIVER_WCN:
5899 if (wcn_sta_set_cts_width(dut, intf, val) < 0) {
5900 send_resp(dut, conn, SIGMA_ERROR,
5901 "ErrorCode,Failed to set CTS_WIDTH");
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005902 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005903 }
5904 break;
5905 case DRIVER_ATHEROS:
5906 ath_set_cts_width(dut, intf, val);
5907 break;
5908 default:
5909 sigma_dut_print(dut, DUT_MSG_ERROR,
5910 "Setting CTS_WIDTH not supported");
5911 break;
5912 }
5913 }
5914
5915 val = get_param(cmd, "BW_SGNL");
5916 if (val) {
5917 if (strcasecmp(val, "Enable") == 0) {
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07005918 run_iwpriv(dut, intf, "cwmenable 1");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005919 } else if (strcasecmp(val, "Disable") == 0) {
5920 /* TODO: Disable */
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005921 } else {
5922 send_resp(dut, conn, SIGMA_ERROR,
5923 "ErrorCode,BW_SGNL value not supported");
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005924 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005925 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005926 }
5927
5928 val = get_param(cmd, "Band");
5929 if (val) {
5930 if (strcmp(val, "2.4") == 0 || strcmp(val, "5") == 0) {
5931 /* STA supports all bands by default */
5932 } else {
5933 send_resp(dut, conn, SIGMA_ERROR,
5934 "ErrorCode,Unsupported Band");
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005935 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005936 }
5937 }
5938
5939 val = get_param(cmd, "zero_crc");
5940 if (val) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005941 switch (get_driver_type(dut)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005942 case DRIVER_ATHEROS:
5943 ath_set_zero_crc(dut, val);
5944 break;
5945 default:
5946 break;
5947 }
5948 }
5949
Jouni Malinen3d96a1e2021-06-09 16:45:06 +03005950 return SUCCESS_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005951}
5952
5953
Alexei Avshalom Lazaraad97b02018-12-18 16:01:23 +02005954static int sta_set_force_mcs(struct sigma_dut *dut, int force, int mcs)
5955{
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005956 switch (get_driver_type(dut)) {
Alexei Avshalom Lazaraad97b02018-12-18 16:01:23 +02005957#ifdef __linux__
5958 case DRIVER_WIL6210:
5959 return wil6210_set_force_mcs(dut, force, mcs);
5960#endif /* __linux__ */
5961 default:
5962 sigma_dut_print(dut, DUT_MSG_ERROR,
5963 "Unsupported sta_set_force_mcs with the current driver");
5964 return -1;
5965 }
5966}
5967
5968
Alexei Avshalom Lazarb094bf02018-12-18 16:00:53 +02005969static int sta_60g_force_rsn_ie(struct sigma_dut *dut, int state)
5970{
Jouni Malinen016ae6c2019-11-04 17:00:01 +02005971 switch (get_driver_type(dut)) {
Alexei Avshalom Lazarb094bf02018-12-18 16:00:53 +02005972#ifdef __linux__
5973 case DRIVER_WIL6210:
5974 return wil6210_force_rsn_ie(dut, state);
5975#endif /* __linux__ */
5976 default:
5977 sigma_dut_print(dut, DUT_MSG_ERROR,
5978 "Unsupported sta_60g_force_rsn_ie with the current driver");
5979 return -1;
5980 }
5981}
5982
5983
Jouni Malinencd4e3c32015-10-29 12:39:56 +02005984static int sta_set_60g_common(struct sigma_dut *dut, struct sigma_conn *conn,
5985 struct sigma_cmd *cmd)
5986{
5987 const char *val;
5988 char buf[100];
5989
5990 val = get_param(cmd, "MSDUSize");
5991 if (val) {
5992 int mtu;
5993
5994 dut->amsdu_size = atoi(val);
5995 if (dut->amsdu_size > IEEE80211_MAX_DATA_LEN_DMG ||
5996 dut->amsdu_size < IEEE80211_SNAP_LEN_DMG) {
5997 sigma_dut_print(dut, DUT_MSG_ERROR,
5998 "MSDUSize %d is above max %d or below min %d",
5999 dut->amsdu_size,
6000 IEEE80211_MAX_DATA_LEN_DMG,
6001 IEEE80211_SNAP_LEN_DMG);
6002 dut->amsdu_size = 0;
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006003 return ERROR_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006004 }
6005
6006 mtu = dut->amsdu_size - IEEE80211_SNAP_LEN_DMG;
6007 sigma_dut_print(dut, DUT_MSG_DEBUG,
6008 "Setting amsdu_size to %d", mtu);
6009 snprintf(buf, sizeof(buf), "ifconfig %s mtu %d",
Jouni Malinen016ae6c2019-11-04 17:00:01 +02006010 get_station_ifname(dut), mtu);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006011
6012 if (system(buf) != 0) {
6013 sigma_dut_print(dut, DUT_MSG_ERROR, "Failed to set %s",
6014 buf);
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006015 return ERROR_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006016 }
6017 }
6018
6019 val = get_param(cmd, "BAckRcvBuf");
6020 if (val) {
6021 dut->back_rcv_buf = atoi(val);
6022 if (dut->back_rcv_buf == 0) {
6023 sigma_dut_print(dut, DUT_MSG_ERROR,
6024 "Failed to convert %s or value is 0",
6025 val);
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006026 return ERROR_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006027 }
6028
6029 sigma_dut_print(dut, DUT_MSG_DEBUG,
6030 "Setting BAckRcvBuf to %s", val);
6031 }
6032
Alexei Avshalom Lazaraad97b02018-12-18 16:01:23 +02006033 val = get_param(cmd, "MCS_FixedRate");
6034 if (val) {
6035 if (sta_set_force_mcs(dut, 1, atoi(val))) {
6036 sigma_dut_print(dut, DUT_MSG_ERROR,
6037 "Failed to force MCS");
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006038 return ERROR_SEND_STATUS;
Alexei Avshalom Lazaraad97b02018-12-18 16:01:23 +02006039 }
6040 }
6041
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006042 return SUCCESS_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006043}
6044
6045
6046static int sta_pcp_start(struct sigma_dut *dut, struct sigma_conn *conn,
6047 struct sigma_cmd *cmd)
6048{
6049 int net_id;
Jouni Malinen016ae6c2019-11-04 17:00:01 +02006050 const char *ifname;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006051 const char *val;
6052 char buf[100];
6053
6054 dut->mode = SIGMA_MODE_STATION;
Jouni Malinen016ae6c2019-11-04 17:00:01 +02006055 ifname = get_main_ifname(dut);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006056 if (wpa_command(ifname, "PING") != 0) {
6057 sigma_dut_print(dut, DUT_MSG_ERROR, "Supplicant not running");
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006058 return ERROR_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006059 }
6060
6061 wpa_command(ifname, "FLUSH");
6062 net_id = add_network_common(dut, conn, ifname, cmd);
6063 if (net_id < 0) {
6064 sigma_dut_print(dut, DUT_MSG_ERROR, "Failed to add network");
6065 return net_id;
6066 }
6067
6068 /* TODO: mode=2 for the AP; in the future, replace for mode PCP */
6069 if (set_network(ifname, net_id, "mode", "2") < 0) {
6070 sigma_dut_print(dut, DUT_MSG_ERROR,
6071 "Failed to set supplicant network mode");
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006072 return ERROR_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006073 }
6074
Alexei Avshalom Lazard596b512018-12-18 16:00:59 +02006075 if (set_network(ifname, net_id, "pbss", "1") < 0)
6076 return -2;
6077
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006078 sigma_dut_print(dut, DUT_MSG_DEBUG,
Alexei Avshalom Lazarfd9f1352018-11-13 14:07:58 +02006079 "Supplicant set network with mode 2. network_id %d",
6080 net_id);
6081
6082 if (set_network(ifname, net_id, "wps_disabled", "0") < 0) {
6083 sigma_dut_print(dut, DUT_MSG_INFO,
6084 "Failed to set supplicant to WPS ENABLE");
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006085 return ERROR_SEND_STATUS;
Alexei Avshalom Lazarfd9f1352018-11-13 14:07:58 +02006086 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006087
6088 val = get_param(cmd, "Security");
6089 if (val && strcasecmp(val, "OPEN") == 0) {
6090 dut->ap_key_mgmt = AP_OPEN;
6091 if (set_network(ifname, net_id, "key_mgmt", "NONE") < 0) {
6092 sigma_dut_print(dut, DUT_MSG_ERROR,
6093 "Failed to set supplicant to %s security",
6094 val);
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006095 return ERROR_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006096 }
6097 } else if (val && strcasecmp(val, "WPA2-PSK") == 0) {
6098 dut->ap_key_mgmt = AP_WPA2_PSK;
6099 if (set_network(ifname, net_id, "key_mgmt", "WPA-PSK") < 0) {
6100 sigma_dut_print(dut, DUT_MSG_ERROR,
6101 "Failed to set supplicant to %s security",
6102 val);
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006103 return ERROR_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006104 }
6105
6106 if (set_network(ifname, net_id, "proto", "RSN") < 0) {
6107 sigma_dut_print(dut, DUT_MSG_ERROR,
6108 "Failed to set supplicant to proto RSN");
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006109 return ERROR_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006110 }
6111 } else if (val) {
6112 sigma_dut_print(dut, DUT_MSG_ERROR,
6113 "Requested Security %s is not supported on 60GHz",
6114 val);
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006115 return INVALID_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006116 }
6117
6118 val = get_param(cmd, "Encrypt");
6119 if (val && strcasecmp(val, "AES-GCMP") == 0) {
6120 if (set_network(ifname, net_id, "pairwise", "GCMP") < 0) {
6121 sigma_dut_print(dut, DUT_MSG_ERROR,
6122 "Failed to set supplicant to pairwise GCMP");
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006123 return ERROR_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006124 }
6125 if (set_network(ifname, net_id, "group", "GCMP") < 0) {
6126 sigma_dut_print(dut, DUT_MSG_ERROR,
6127 "Failed to set supplicant to group GCMP");
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006128 return ERROR_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006129 }
6130 } else if (val) {
6131 sigma_dut_print(dut, DUT_MSG_ERROR,
6132 "Requested Encrypt %s is not supported on 60 GHz",
6133 val);
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006134 return INVALID_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006135 }
6136
6137 val = get_param(cmd, "PSK");
6138 if (val && set_network_quoted(ifname, net_id, "psk", val) < 0) {
6139 sigma_dut_print(dut, DUT_MSG_ERROR, "Failed to set psk %s",
6140 val);
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006141 return ERROR_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006142 }
6143
6144 /* Convert 60G channel to freq */
6145 switch (dut->ap_channel) {
6146 case 1:
6147 val = "58320";
6148 break;
6149 case 2:
6150 val = "60480";
6151 break;
6152 case 3:
6153 val = "62640";
6154 break;
6155 default:
6156 sigma_dut_print(dut, DUT_MSG_ERROR,
6157 "Failed to configure channel %d. Not supported",
6158 dut->ap_channel);
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006159 return ERROR_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006160 }
6161
6162 if (set_network(ifname, net_id, "frequency", val) < 0) {
6163 sigma_dut_print(dut, DUT_MSG_ERROR,
6164 "Failed to set supplicant network frequency");
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006165 return ERROR_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006166 }
6167
Alexei Avshalom Lazar2eccf4d2019-01-31 10:03:59 +02006168 if (dut->eap_fragment) {
6169 sigma_dut_print(dut, DUT_MSG_DEBUG,
6170 "Set EAP fragment size to 128 bytes.");
6171 if (set_network(ifname, net_id, "fragment_size", "128") < 0)
6172 return ERROR_SEND_STATUS;
6173 }
6174
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006175 sigma_dut_print(dut, DUT_MSG_DEBUG,
6176 "Supplicant set network with frequency");
6177
6178 snprintf(buf, sizeof(buf), "SELECT_NETWORK %d", net_id);
6179 if (wpa_command(ifname, buf) < 0) {
6180 sigma_dut_print(dut, DUT_MSG_INFO,
6181 "Failed to select network id %d on %s",
6182 net_id, ifname);
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006183 return ERROR_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006184 }
6185
6186 sigma_dut_print(dut, DUT_MSG_DEBUG, "Selected network");
6187
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006188 return SUCCESS_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006189}
6190
6191
Lior David67543f52017-01-03 19:04:22 +02006192static int wil6210_set_abft_len(struct sigma_dut *dut, int abft_len)
6193{
6194 char buf[128], fname[128];
6195 FILE *f;
Jouni Malinen3aa72862019-05-29 23:14:51 +03006196 int res;
Lior David67543f52017-01-03 19:04:22 +02006197
6198 if (wil6210_get_debugfs_dir(dut, buf, sizeof(buf))) {
6199 sigma_dut_print(dut, DUT_MSG_ERROR,
6200 "failed to get wil6210 debugfs dir");
6201 return -1;
6202 }
6203
Jouni Malinen3aa72862019-05-29 23:14:51 +03006204 res = snprintf(fname, sizeof(fname), "%s/abft_len", buf);
6205 if (res < 0 || res >= sizeof(fname))
6206 return -1;
Lior David67543f52017-01-03 19:04:22 +02006207 f = fopen(fname, "w");
6208 if (!f) {
6209 sigma_dut_print(dut, DUT_MSG_ERROR,
6210 "failed to open: %s", fname);
6211 return -1;
6212 }
6213
6214 fprintf(f, "%d\n", abft_len);
6215 fclose(f);
6216
6217 return 0;
6218}
6219
6220
Alexei Avshalom Lazar49498b82019-01-31 15:16:32 +02006221int sta_set_60g_abft_len(struct sigma_dut *dut, struct sigma_conn *conn,
6222 int abft_len)
Lior David67543f52017-01-03 19:04:22 +02006223{
Jouni Malinen016ae6c2019-11-04 17:00:01 +02006224 switch (get_driver_type(dut)) {
Lior David67543f52017-01-03 19:04:22 +02006225 case DRIVER_WIL6210:
6226 return wil6210_set_abft_len(dut, abft_len);
6227 default:
6228 sigma_dut_print(dut, DUT_MSG_ERROR,
6229 "set abft_len not supported");
6230 return -1;
6231 }
6232}
6233
6234
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006235static int sta_set_60g_pcp(struct sigma_dut *dut, struct sigma_conn *conn,
6236 struct sigma_cmd *cmd)
6237{
6238 const char *val;
Lior David67543f52017-01-03 19:04:22 +02006239 unsigned int abft_len = 1; /* default is one slot */
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006240
6241 if (dut->dev_role != DEVROLE_PCP) {
6242 send_resp(dut, conn, SIGMA_INVALID,
6243 "ErrorCode,Invalid DevRole");
6244 return 0;
6245 }
6246
6247 val = get_param(cmd, "SSID");
6248 if (val) {
6249 if (strlen(val) > sizeof(dut->ap_ssid) - 1) {
6250 send_resp(dut, conn, SIGMA_INVALID,
6251 "ErrorCode,Invalid SSID");
6252 return -1;
6253 }
6254
Peng Xub8fc5cc2017-05-10 17:27:28 -07006255 strlcpy(dut->ap_ssid, val, sizeof(dut->ap_ssid));
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006256 }
6257
6258 val = get_param(cmd, "CHANNEL");
6259 if (val) {
6260 const char *pos;
6261
6262 dut->ap_channel = atoi(val);
6263 pos = strchr(val, ';');
6264 if (pos) {
6265 pos++;
6266 dut->ap_channel_1 = atoi(pos);
6267 }
6268 }
6269
6270 switch (dut->ap_channel) {
6271 case 1:
6272 case 2:
6273 case 3:
6274 break;
6275 default:
6276 sigma_dut_print(dut, DUT_MSG_ERROR,
6277 "Channel %d is not supported", dut->ap_channel);
6278 send_resp(dut, conn, SIGMA_ERROR,
6279 "Requested channel is not supported");
6280 return -1;
6281 }
6282
6283 val = get_param(cmd, "BCNINT");
6284 if (val)
6285 dut->ap_bcnint = atoi(val);
6286
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006287 val = get_param(cmd, "AllocType");
6288 if (val) {
6289 send_resp(dut, conn, SIGMA_ERROR,
6290 "ErrorCode,AllocType is not supported yet");
6291 return -1;
6292 }
6293
6294 val = get_param(cmd, "PercentBI");
6295 if (val) {
6296 send_resp(dut, conn, SIGMA_ERROR,
6297 "ErrorCode,PercentBI is not supported yet");
6298 return -1;
6299 }
6300
6301 val = get_param(cmd, "CBAPOnly");
6302 if (val) {
6303 send_resp(dut, conn, SIGMA_ERROR,
6304 "ErrorCode,CBAPOnly is not supported yet");
6305 return -1;
6306 }
6307
6308 val = get_param(cmd, "AMPDU");
6309 if (val) {
6310 if (strcasecmp(val, "Enable") == 0)
6311 dut->ap_ampdu = 1;
6312 else if (strcasecmp(val, "Disable") == 0)
6313 dut->ap_ampdu = 2;
6314 else {
6315 send_resp(dut, conn, SIGMA_ERROR,
6316 "ErrorCode,AMPDU value is not Enable nor Disabled");
6317 return -1;
6318 }
6319 }
6320
6321 val = get_param(cmd, "AMSDU");
6322 if (val) {
6323 if (strcasecmp(val, "Enable") == 0)
6324 dut->ap_amsdu = 1;
6325 else if (strcasecmp(val, "Disable") == 0)
6326 dut->ap_amsdu = 2;
6327 }
6328
6329 val = get_param(cmd, "NumMSDU");
6330 if (val) {
6331 send_resp(dut, conn, SIGMA_ERROR,
6332 "ErrorCode, NumMSDU is not supported yet");
6333 return -1;
6334 }
6335
6336 val = get_param(cmd, "ABFTLRang");
6337 if (val) {
6338 sigma_dut_print(dut, DUT_MSG_DEBUG,
Lior David67543f52017-01-03 19:04:22 +02006339 "ABFTLRang parameter %s", val);
6340 if (strcmp(val, "Gt1") == 0)
6341 abft_len = 2; /* 2 slots in this case */
6342 }
6343
6344 if (sta_set_60g_abft_len(dut, conn, abft_len)) {
6345 send_resp(dut, conn, SIGMA_ERROR,
6346 "ErrorCode, Can't set ABFT length");
6347 return -1;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006348 }
6349
6350 if (sta_pcp_start(dut, conn, cmd) < 0) {
6351 send_resp(dut, conn, SIGMA_ERROR,
6352 "ErrorCode, Can't start PCP role");
6353 return -1;
6354 }
6355
6356 return sta_set_60g_common(dut, conn, cmd);
6357}
6358
6359
6360static int sta_set_60g_sta(struct sigma_dut *dut, struct sigma_conn *conn,
6361 struct sigma_cmd *cmd)
6362{
6363 const char *val = get_param(cmd, "DiscoveryMode");
6364
6365 if (dut->dev_role != DEVROLE_STA) {
6366 send_resp(dut, conn, SIGMA_INVALID,
6367 "ErrorCode,Invalid DevRole");
6368 return 0;
6369 }
6370
6371 if (val) {
6372 sigma_dut_print(dut, DUT_MSG_DEBUG, "Discovery: %s", val);
6373 /* Ignore Discovery mode till Driver expose API. */
6374#if 0
6375 if (strcasecmp(val, "1") == 0) {
6376 send_resp(dut, conn, SIGMA_INVALID,
6377 "ErrorCode,DiscoveryMode 1 not supported");
6378 return 0;
6379 }
6380
6381 if (strcasecmp(val, "0") == 0) {
6382 /* OK */
6383 } else {
6384 send_resp(dut, conn, SIGMA_INVALID,
6385 "ErrorCode,DiscoveryMode not supported");
6386 return 0;
6387 }
6388#endif
6389 }
6390
6391 if (start_sta_mode(dut) != 0)
Jouni Malinen0e29cf22019-02-19 01:13:21 +02006392 return ERROR_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006393 return sta_set_60g_common(dut, conn, cmd);
6394}
6395
6396
Jouni Malinenf7222712019-06-13 01:50:21 +03006397static enum sigma_cmd_result cmd_sta_disconnect(struct sigma_dut *dut,
6398 struct sigma_conn *conn,
6399 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006400{
6401 const char *intf = get_param(cmd, "Interface");
Jouni Malinened77e672018-01-10 16:45:13 +02006402 const char *val = get_param(cmd, "maintain_profile");
vamsi krishnad605c422017-09-20 14:56:31 +05306403
Jouni Malinened77e672018-01-10 16:45:13 +02006404 if (dut->program == PROGRAM_OCE ||
Amarnath Hullur Subramanyamebeda9e2018-01-31 03:21:48 -08006405 dut->program == PROGRAM_HE ||
Jouni Malinened77e672018-01-10 16:45:13 +02006406 (val && atoi(val) == 1)) {
vamsi krishnad605c422017-09-20 14:56:31 +05306407 wpa_command(intf, "DISCONNECT");
6408 return 1;
6409 }
6410
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006411 disconnect_station(dut);
6412 /* Try to ignore old scan results to avoid HS 2.0R2 test case failures
6413 * due to cached results. */
6414 wpa_command(intf, "SET ignore_old_scan_res 1");
6415 wpa_command(intf, "BSS_FLUSH");
6416 return 1;
6417}
6418
6419
Jouni Malinenf7222712019-06-13 01:50:21 +03006420static enum sigma_cmd_result cmd_sta_reassoc(struct sigma_dut *dut,
6421 struct sigma_conn *conn,
6422 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006423{
6424 const char *intf = get_param(cmd, "Interface");
6425 const char *bssid = get_param(cmd, "bssid");
6426 const char *val = get_param(cmd, "CHANNEL");
Kiran Kumar Lokere94a86b52020-06-03 23:25:19 -07006427 const char *freq_val = get_param(cmd, "ChnlFreq");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006428 struct wpa_ctrl *ctrl;
Srinivas Dasari0ebedb12018-02-14 17:03:51 +05306429 char buf[1000];
Sunil Duttd30ce092018-01-11 23:56:29 +05306430 char result[32];
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006431 int res;
6432 int chan = 0;
Kiran Kumar Lokere94a86b52020-06-03 23:25:19 -07006433 int freq = 0;
Jouni Malinen6a7c9b42019-08-20 00:15:59 +03006434 enum sigma_cmd_result status = STATUS_SENT;
Sunil Duttd30ce092018-01-11 23:56:29 +05306435 int fastreassoc = 1;
Jouni Malinen6a7c9b42019-08-20 00:15:59 +03006436 int ft_ds = 0;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006437
6438 if (bssid == NULL) {
6439 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Missing bssid "
6440 "argument");
Jouni Malinen6a7c9b42019-08-20 00:15:59 +03006441 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006442 }
6443
6444 if (val)
6445 chan = atoi(val);
6446
Kiran Kumar Lokere94a86b52020-06-03 23:25:19 -07006447 if (freq_val)
6448 freq = atoi(freq_val);
6449
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006450 if (wifi_chip_type != DRIVER_WCN && wifi_chip_type != DRIVER_AR6003) {
6451 /* The current network may be from sta_associate or
6452 * sta_hs2_associate
6453 */
6454 if (set_network(intf, dut->infra_network_id, "bssid", bssid) <
6455 0 ||
6456 set_network(intf, 0, "bssid", bssid) < 0)
Jouni Malinen6a7c9b42019-08-20 00:15:59 +03006457 return ERROR_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006458 }
6459
6460 ctrl = open_wpa_mon(intf);
6461 if (ctrl == NULL) {
6462 sigma_dut_print(dut, DUT_MSG_ERROR, "Failed to open "
6463 "wpa_supplicant monitor connection");
Jouni Malinen6a7c9b42019-08-20 00:15:59 +03006464 return ERROR_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006465 }
6466
Jouni Malinen016ae6c2019-11-04 17:00:01 +02006467 if (get_wpa_status(get_station_ifname(dut), "wpa_state", result,
Sunil Duttd30ce092018-01-11 23:56:29 +05306468 sizeof(result)) < 0 ||
6469 strncmp(result, "COMPLETED", 9) != 0) {
6470 sigma_dut_print(dut, DUT_MSG_DEBUG,
6471 "sta_reassoc: Not connected");
6472 fastreassoc = 0;
Jouni Malinen6a7c9b42019-08-20 00:15:59 +03006473 } else if (dut->sta_ft_ds) {
6474 sigma_dut_print(dut, DUT_MSG_DEBUG,
6475 "sta_reassoc: Use FT-over-DS");
6476 ft_ds = 1;
Sunil Duttd30ce092018-01-11 23:56:29 +05306477 }
6478
Srinivas Dasari0ebedb12018-02-14 17:03:51 +05306479 if (dut->rsne_override) {
6480#ifdef NL80211_SUPPORT
Jouni Malinen016ae6c2019-11-04 17:00:01 +02006481 if (get_driver_type(dut) == DRIVER_WCN &&
6482 dut->config_rsnie == 0) {
Mohammad Asaad Akram50848402020-05-28 14:10:24 +05306483 sta_config_params(dut, intf, STA_SET_RSNIE, 1);
Srinivas Dasari0ebedb12018-02-14 17:03:51 +05306484 dut->config_rsnie = 1;
6485 }
6486#endif /* NL80211_SUPPORT */
6487 snprintf(buf, sizeof(buf), "TEST_ASSOC_IE %s",
6488 dut->rsne_override);
6489 if (wpa_command(intf, buf) < 0) {
6490 send_resp(dut, conn, SIGMA_ERROR,
6491 "ErrorCode,Failed to set DEV_CONFIGURE_IE RSNE override");
6492 return 0;
6493 }
6494 }
6495
Jouni Malinen6a7c9b42019-08-20 00:15:59 +03006496 if (ft_ds) {
Kiran Kumar Lokere94a86b52020-06-03 23:25:19 -07006497 if (chan || freq) {
6498 if (!freq)
6499 freq = channel_to_freq(dut, chan);
Jouni Malinen6a7c9b42019-08-20 00:15:59 +03006500 if (!freq) {
6501 sigma_dut_print(dut, DUT_MSG_ERROR,
6502 "Invalid channel number provided: %d",
6503 chan);
6504 send_resp(dut, conn, SIGMA_INVALID,
6505 "ErrorCode,Invalid channel number");
6506 goto close_mon_conn;
6507 }
6508 res = snprintf(buf, sizeof(buf),
6509 "SCAN TYPE=ONLY freq=%d", freq);
6510 } else {
6511 res = snprintf(buf, sizeof(buf), "SCAN TYPE=ONLY");
6512 }
6513 if (res < 0 || res >= (int) sizeof(buf)) {
6514 send_resp(dut, conn, SIGMA_ERROR,
6515 "ErrorCode,snprintf failed");
6516 goto close_mon_conn;
6517 }
6518 if (wpa_command(intf, buf) < 0) {
6519 sigma_dut_print(dut, DUT_MSG_INFO,
6520 "Failed to start scan");
6521 send_resp(dut, conn, SIGMA_ERROR,
6522 "ErrorCode,scan failed");
6523 goto close_mon_conn;
6524 }
6525
6526 res = get_wpa_cli_event(dut, ctrl, "CTRL-EVENT-SCAN-RESULTS",
6527 buf, sizeof(buf));
6528 if (res < 0) {
6529 sigma_dut_print(dut, DUT_MSG_INFO,
6530 "Scan did not complete");
6531 send_resp(dut, conn, SIGMA_ERROR,
6532 "ErrorCode,scan did not complete");
6533 goto close_mon_conn;
6534 }
6535
6536 res = snprintf(buf, sizeof(buf), "FT_DS %s", bssid);
6537 if (res > 0 && res < (int) sizeof(buf))
6538 res = wpa_command(intf, buf);
6539
6540 if (res < 0 || res >= (int) sizeof(buf)) {
6541 send_resp(dut, conn, SIGMA_ERROR,
6542 "errorCode,FT_DS command failed");
6543 status = STATUS_SENT_ERROR;
6544 goto close_mon_conn;
6545 }
6546 } else if (wifi_chip_type == DRIVER_WCN && fastreassoc) {
Kiran Kumar Lokere94a86b52020-06-03 23:25:19 -07006547 if (chan || freq) {
6548 if (!freq)
6549 freq = channel_to_freq(dut, chan);
Ashwini Patil4c8158f2017-05-25 12:49:21 +05306550 if (!freq) {
6551 sigma_dut_print(dut, DUT_MSG_ERROR,
6552 "Invalid channel number provided: %d",
6553 chan);
6554 send_resp(dut, conn, SIGMA_INVALID,
6555 "ErrorCode,Invalid channel number");
6556 goto close_mon_conn;
6557 }
6558 res = snprintf(buf, sizeof(buf),
6559 "SCAN TYPE=ONLY freq=%d", freq);
6560 } else {
6561 res = snprintf(buf, sizeof(buf), "SCAN TYPE=ONLY");
6562 }
6563 if (res < 0 || res >= (int) sizeof(buf)) {
6564 send_resp(dut, conn, SIGMA_ERROR,
6565 "ErrorCode,snprintf failed");
6566 goto close_mon_conn;
6567 }
6568 if (wpa_command(intf, buf) < 0) {
6569 sigma_dut_print(dut, DUT_MSG_INFO,
6570 "Failed to start scan");
6571 send_resp(dut, conn, SIGMA_ERROR,
6572 "ErrorCode,scan failed");
6573 goto close_mon_conn;
6574 }
6575
6576 res = get_wpa_cli_event(dut, ctrl, "CTRL-EVENT-SCAN-RESULTS",
6577 buf, sizeof(buf));
6578 if (res < 0) {
6579 sigma_dut_print(dut, DUT_MSG_INFO,
6580 "Scan did not complete");
6581 send_resp(dut, conn, SIGMA_ERROR,
6582 "ErrorCode,scan did not complete");
6583 goto close_mon_conn;
6584 }
6585
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006586 if (set_network(intf, dut->infra_network_id, "bssid", "any")
6587 < 0) {
6588 sigma_dut_print(dut, DUT_MSG_ERROR, "Failed to set "
6589 "bssid to any during FASTREASSOC");
Jouni Malinen6a7c9b42019-08-20 00:15:59 +03006590 status = ERROR_SEND_STATUS;
Ashwini Patil467efef2017-05-25 12:18:27 +05306591 goto close_mon_conn;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006592 }
Vinita Maloo54b78cf2020-03-30 12:18:19 +05306593 res = snprintf(buf, sizeof(buf), "FASTREASSOC %s %d",
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006594 bssid, chan);
Vinita Maloo54b78cf2020-03-30 12:18:19 +05306595 if (res < 0 || res >= (int) sizeof(buf) ||
6596 wcn_driver_cmd(intf, buf) < 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006597 send_resp(dut, conn, SIGMA_ERROR,
Vinita Maloo54b78cf2020-03-30 12:18:19 +05306598 "errorCode,Failed to run FASTREASSOC");
Ashwini Patil467efef2017-05-25 12:18:27 +05306599 goto close_mon_conn;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006600 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006601 sigma_dut_print(dut, DUT_MSG_INFO,
6602 "sta_reassoc: Run %s successful", buf);
6603 } else if (wpa_command(intf, "REASSOCIATE")) {
6604 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Failed to "
6605 "request reassociation");
Ashwini Patil467efef2017-05-25 12:18:27 +05306606 goto close_mon_conn;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006607 }
6608
6609 res = get_wpa_cli_event(dut, ctrl, "CTRL-EVENT-CONNECTED",
6610 buf, sizeof(buf));
Ashwini Patil467efef2017-05-25 12:18:27 +05306611 if (res < 0) {
Jouni Malinen6a7c9b42019-08-20 00:15:59 +03006612 send_resp(dut, conn, SIGMA_ERROR,
6613 "errorCode,Connection did not complete");
6614 status = STATUS_SENT_ERROR;
Ashwini Patil467efef2017-05-25 12:18:27 +05306615 goto close_mon_conn;
6616 }
Jouni Malinen6a7c9b42019-08-20 00:15:59 +03006617 status = SUCCESS_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006618
Ashwini Patil467efef2017-05-25 12:18:27 +05306619close_mon_conn:
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006620 wpa_ctrl_detach(ctrl);
6621 wpa_ctrl_close(ctrl);
Ashwini Patil467efef2017-05-25 12:18:27 +05306622 return status;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006623}
6624
6625
6626static void hs2_clear_credentials(const char *intf)
6627{
6628 wpa_command(intf, "REMOVE_CRED all");
6629}
6630
6631
Lior Davidcc88b562017-01-03 18:52:09 +02006632#ifdef __linux__
6633static int wil6210_get_aid(struct sigma_dut *dut, const char *bssid,
6634 unsigned int *aid)
6635{
Lior David0fe101e2017-03-09 16:09:50 +02006636 const char *pattern = "AID[ \t]+([0-9]+)";
Lior Davidcc88b562017-01-03 18:52:09 +02006637
Lior David0fe101e2017-03-09 16:09:50 +02006638 return wil6210_get_sta_info_field(dut, bssid, pattern, aid);
Lior Davidcc88b562017-01-03 18:52:09 +02006639}
6640#endif /* __linux__ */
6641
6642
6643static int sta_get_aid_60g(struct sigma_dut *dut, const char *bssid,
6644 unsigned int *aid)
6645{
Jouni Malinen016ae6c2019-11-04 17:00:01 +02006646 switch (get_driver_type(dut)) {
Lior Davidcc88b562017-01-03 18:52:09 +02006647#ifdef __linux__
6648 case DRIVER_WIL6210:
6649 return wil6210_get_aid(dut, bssid, aid);
6650#endif /* __linux__ */
6651 default:
6652 sigma_dut_print(dut, DUT_MSG_ERROR, "get AID not supported");
6653 return -1;
6654 }
6655}
6656
6657
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006658static int sta_get_parameter_60g(struct sigma_dut *dut, struct sigma_conn *conn,
6659 struct sigma_cmd *cmd)
6660{
6661 char buf[MAX_CMD_LEN];
6662 char bss_list[MAX_CMD_LEN];
6663 const char *parameter = get_param(cmd, "Parameter");
6664
6665 if (parameter == NULL)
6666 return -1;
6667
Lior Davidcc88b562017-01-03 18:52:09 +02006668 if (strcasecmp(parameter, "AID") == 0) {
6669 unsigned int aid = 0;
6670 char bssid[20];
6671
Jouni Malinen016ae6c2019-11-04 17:00:01 +02006672 if (get_wpa_status(get_station_ifname(dut), "bssid",
Lior Davidcc88b562017-01-03 18:52:09 +02006673 bssid, sizeof(bssid)) < 0) {
6674 sigma_dut_print(dut, DUT_MSG_ERROR,
6675 "could not get bssid");
6676 return -2;
6677 }
6678
6679 if (sta_get_aid_60g(dut, bssid, &aid))
6680 return -2;
6681
6682 snprintf(buf, sizeof(buf), "aid,%d", aid);
6683 sigma_dut_print(dut, DUT_MSG_INFO, "%s", buf);
6684 send_resp(dut, conn, SIGMA_COMPLETE, buf);
6685 return 0;
6686 }
6687
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006688 if (strcasecmp(parameter, "DiscoveredDevList") == 0) {
6689 char *bss_line;
6690 char *bss_id = NULL;
6691 const char *ifname = get_param(cmd, "Interface");
Pradeep Reddy POTTETIdbf7d712016-04-28 18:42:07 +05306692 char *saveptr;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006693
6694 if (ifname == NULL) {
6695 sigma_dut_print(dut, DUT_MSG_INFO,
6696 "For get DiscoveredDevList need Interface name.");
6697 return -1;
6698 }
6699
6700 /*
6701 * Use "BSS RANGE=ALL MASK=0x2" which provides a list
6702 * of BSSIDs in "bssid=<BSSID>\n"
6703 */
6704 if (wpa_command_resp(ifname, "BSS RANGE=ALL MASK=0x2",
6705 bss_list,
6706 sizeof(bss_list)) < 0) {
6707 sigma_dut_print(dut, DUT_MSG_ERROR,
6708 "Failed to get bss list");
6709 return -1;
6710 }
6711
6712 sigma_dut_print(dut, DUT_MSG_DEBUG,
6713 "bss list for ifname:%s is:%s",
6714 ifname, bss_list);
6715
6716 snprintf(buf, sizeof(buf), "DeviceList");
Pradeep Reddy POTTETIdbf7d712016-04-28 18:42:07 +05306717 bss_line = strtok_r(bss_list, "\n", &saveptr);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006718 while (bss_line) {
6719 if (sscanf(bss_line, "bssid=%ms", &bss_id) > 0 &&
6720 bss_id) {
6721 int len;
6722
6723 len = snprintf(buf + strlen(buf),
6724 sizeof(buf) - strlen(buf),
6725 ",%s", bss_id);
6726 free(bss_id);
6727 bss_id = NULL;
6728 if (len < 0) {
6729 sigma_dut_print(dut,
6730 DUT_MSG_ERROR,
6731 "Failed to read BSSID");
6732 send_resp(dut, conn, SIGMA_ERROR,
6733 "ErrorCode,Failed to read BSS ID");
6734 return 0;
6735 }
6736
6737 if ((size_t) len >= sizeof(buf) - strlen(buf)) {
6738 sigma_dut_print(dut,
6739 DUT_MSG_ERROR,
6740 "Response buf too small for list");
6741 send_resp(dut, conn,
6742 SIGMA_ERROR,
6743 "ErrorCode,Response buf too small for list");
6744 return 0;
6745 }
6746 }
6747
Pradeep Reddy POTTETIdbf7d712016-04-28 18:42:07 +05306748 bss_line = strtok_r(NULL, "\n", &saveptr);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02006749 }
6750
6751 sigma_dut_print(dut, DUT_MSG_INFO, "DiscoveredDevList is %s",
6752 buf);
6753 send_resp(dut, conn, SIGMA_COMPLETE, buf);
6754 return 0;
6755 }
6756
6757 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,Unsupported parameter");
6758 return 0;
6759}
6760
6761
Kiran Kumar Lokerec86d8022018-10-11 13:57:12 -07006762static int sta_get_parameter_he(struct sigma_dut *dut, struct sigma_conn *conn,
6763 struct sigma_cmd *cmd)
6764{
6765 char buf[MAX_CMD_LEN];
6766 const char *parameter = get_param(cmd, "Parameter");
6767
6768 if (!parameter)
6769 return -1;
6770
6771 if (strcasecmp(parameter, "RSSI") == 0) {
6772 char rssi[10];
6773
Jouni Malinen016ae6c2019-11-04 17:00:01 +02006774 if (get_wpa_signal_poll(dut, get_station_ifname(dut), "RSSI",
Kiran Kumar Lokerec86d8022018-10-11 13:57:12 -07006775 rssi, sizeof(rssi)) < 0) {
6776 sigma_dut_print(dut, DUT_MSG_ERROR,
6777 "Could not get RSSI");
6778 return -2;
6779 }
6780
6781 snprintf(buf, sizeof(buf), "rssi,%s", rssi);
6782 sigma_dut_print(dut, DUT_MSG_INFO, "RSSI %s", buf);
6783 send_resp(dut, conn, SIGMA_COMPLETE, buf);
6784 return 0;
6785 }
6786
6787 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,Unsupported parameter");
6788 return 0;
6789}
6790
6791
Veerendranath Jakkamd0ad6ef2020-05-21 17:09:26 +05306792#ifdef NL80211_SUPPORT
6793
6794struct station_info {
6795 uint64_t filled;
6796 uint32_t beacon_mic_error_count;
6797 uint32_t beacon_replay_count;
6798};
6799
6800
6801static int qca_get_sta_info_handler(struct nl_msg *msg, void *arg)
6802{
6803 struct nlattr *tb[NL80211_ATTR_MAX + 1];
6804 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
6805 struct station_info *data = arg;
6806 struct nlattr *info[QCA_WLAN_VENDOR_ATTR_GET_STA_INFO_MAX + 1];
6807 static struct nla_policy info_policy[
6808 QCA_WLAN_VENDOR_ATTR_GET_STA_INFO_MAX + 1] = {
6809 [QCA_WLAN_VENDOR_ATTR_GET_STA_INFO_BEACON_MIC_ERROR_COUNT] = {
6810 .type = NLA_U32
6811 },
6812 [QCA_WLAN_VENDOR_ATTR_GET_STA_INFO_BEACON_REPLAY_COUNT] = {
6813 .type = NLA_U32
6814 },
6815 };
6816
6817 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
6818 genlmsg_attrlen(gnlh, 0), NULL);
6819
6820 if (!tb[NL80211_ATTR_VENDOR_DATA])
6821 return NL_SKIP;
6822
6823 if (nla_parse_nested(info, QCA_WLAN_VENDOR_ATTR_GET_STA_INFO_MAX,
6824 tb[NL80211_ATTR_VENDOR_DATA], info_policy)) {
6825 return NL_SKIP;
6826 }
6827
6828 if (info[QCA_WLAN_VENDOR_ATTR_GET_STA_INFO_BEACON_MIC_ERROR_COUNT]) {
6829 data->filled |=
6830 BIT_ULL(QCA_WLAN_VENDOR_ATTR_GET_STA_INFO_BEACON_MIC_ERROR_COUNT);
6831 data->beacon_mic_error_count =
6832 nla_get_u32(info[QCA_WLAN_VENDOR_ATTR_GET_STA_INFO_BEACON_MIC_ERROR_COUNT]);
6833 }
6834
6835 if (info[QCA_WLAN_VENDOR_ATTR_GET_STA_INFO_BEACON_REPLAY_COUNT]) {
6836 data->filled |=
6837 BIT_ULL(QCA_WLAN_VENDOR_ATTR_GET_STA_INFO_BEACON_REPLAY_COUNT);
6838 data->beacon_replay_count =
6839 nla_get_u32(info[QCA_WLAN_VENDOR_ATTR_GET_STA_INFO_BEACON_REPLAY_COUNT]);
6840 }
6841
6842 return NL_SKIP;
6843}
6844
6845
6846static int qca_nl80211_get_sta_info(struct sigma_dut *dut, const char *intf,
6847 struct station_info *sta_data)
6848{
6849 struct nl_msg *msg;
6850 int ifindex, ret;
6851
6852 ifindex = if_nametoindex(intf);
6853 if (ifindex == 0) {
6854 sigma_dut_print(dut, DUT_MSG_ERROR,
6855 "%s: Index for interface %s not found",
6856 __func__, intf);
6857 return -1;
6858 }
6859
6860 if (!(msg = nl80211_drv_msg(dut, dut->nl_ctx, ifindex, 0,
6861 NL80211_CMD_VENDOR)) ||
6862 nla_put_u32(msg, NL80211_ATTR_IFINDEX, ifindex) ||
6863 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
6864 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
6865 QCA_NL80211_VENDOR_SUBCMD_GET_STA_INFO)) {
6866 sigma_dut_print(dut, DUT_MSG_ERROR,
6867 "%s: err in adding vendor_cmd", __func__);
6868 nlmsg_free(msg);
6869 return -1;
6870 }
6871
6872 ret = send_and_recv_msgs(dut, dut->nl_ctx, msg,
6873 qca_get_sta_info_handler, sta_data);
6874 if (ret) {
6875 sigma_dut_print(dut, DUT_MSG_ERROR,
6876 "%s: err in send_and_recv_msgs, ret=%d",
6877 __func__, ret);
6878 }
6879 return ret;
6880}
6881#endif /* NL80211_SUPPORT */
6882
6883
6884static int get_bip_mic_error_count(struct sigma_dut *dut,
6885 const char *ifname,
6886 unsigned int *count)
6887{
6888#ifdef NL80211_SUPPORT
6889 struct station_info sta_data;
6890#endif /* NL80211_SUPPORT */
6891
6892 if (get_driver_type(dut) != DRIVER_WCN) {
6893 sigma_dut_print(dut, DUT_MSG_ERROR,
6894 "BIP MIC error count not supported");
6895 return -1;
6896 }
6897
6898#ifdef NL80211_SUPPORT
6899 if (qca_nl80211_get_sta_info(dut, ifname, &sta_data) != 0 ||
6900 !(sta_data.filled &
6901 BIT_ULL(QCA_WLAN_VENDOR_ATTR_GET_STA_INFO_BEACON_MIC_ERROR_COUNT))) {
6902 sigma_dut_print(dut, DUT_MSG_ERROR,
6903 "BIP MIC error count fetching failed");
6904 return -1;
6905 }
6906
6907 *count = sta_data.beacon_mic_error_count;
6908 return 0;
6909#else /* NL80211_SUPPORT */
6910 sigma_dut_print(dut, DUT_MSG_ERROR,
6911 "BIP MIC error count cannot be fetched without NL80211_SUPPORT defined");
6912 return -1;
6913#endif /* NL80211_SUPPORT */
6914}
6915
6916
6917static int get_cmac_replay_count(struct sigma_dut *dut, const char *ifname,
6918 unsigned int *count)
6919{
6920#ifdef NL80211_SUPPORT
6921 struct station_info sta_data;
6922#endif /* NL80211_SUPPORT */
6923
6924 if (get_driver_type(dut) != DRIVER_WCN) {
6925 sigma_dut_print(dut, DUT_MSG_ERROR,
6926 "CMAC reply count not supported");
6927 return -1;
6928 }
6929
6930#ifdef NL80211_SUPPORT
6931 if (qca_nl80211_get_sta_info(dut, ifname, &sta_data) != 0 ||
6932 !(sta_data.filled &
6933 BIT_ULL(QCA_WLAN_VENDOR_ATTR_GET_STA_INFO_BEACON_REPLAY_COUNT))) {
6934 sigma_dut_print(dut, DUT_MSG_ERROR,
6935 "CMAC replay count fetching failed");
6936 return -1;
6937 }
6938
6939 *count = sta_data.beacon_replay_count;
6940 return 0;
6941#else /* NL80211_SUPPORT */
6942 sigma_dut_print(dut, DUT_MSG_ERROR,
6943 "CMAC replay count cannot be fetched without NL80211_SUPPORT defined");
6944 return -1;
6945#endif /* NL80211_SUPPORT */
6946}
6947
6948
6949static enum sigma_cmd_result sta_get_parameter_wpa3(struct sigma_dut *dut,
6950 struct sigma_conn *conn,
6951 struct sigma_cmd *cmd)
6952{
6953 char buf[MAX_CMD_LEN];
6954 const char *ifname = get_param(cmd, "interface");
6955 const char *parameter = get_param(cmd, "Parameter");
6956 unsigned int val;
6957
6958 if (!ifname || !parameter)
6959 return INVALID_SEND_STATUS;
6960
6961 if (strcasecmp(parameter, "BIPMICErrors") == 0) {
6962 if (get_bip_mic_error_count(dut, ifname, &val)) {
6963 send_resp(dut, conn, SIGMA_ERROR,
6964 "ErrorCode,Failed to get BIPMICErrors");
6965 return STATUS_SENT_ERROR;
6966 }
6967 snprintf(buf, sizeof(buf), "BIPMICErrors,%d", val);
6968 sigma_dut_print(dut, DUT_MSG_INFO, "BIPMICErrors %s", buf);
6969 send_resp(dut, conn, SIGMA_COMPLETE, buf);
6970 return STATUS_SENT;
6971 }
6972
6973 if (strcasecmp(parameter, "CMACReplays") == 0) {
6974 if (get_cmac_replay_count(dut, ifname, &val)) {
6975 send_resp(dut, conn, SIGMA_ERROR,
6976 "ErrorCode,Failed to get CMACReplays");
6977 return STATUS_SENT_ERROR;
6978 }
6979 snprintf(buf, sizeof(buf), "CMACReplays,%d", val);
6980 sigma_dut_print(dut, DUT_MSG_INFO, "CMACReplays %s", buf);
6981 send_resp(dut, conn, SIGMA_COMPLETE, buf);
6982 return STATUS_SENT;
6983 }
6984
6985 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,Unsupported parameter");
6986 return STATUS_SENT_ERROR;
6987}
6988
6989
Jouni Malinenca0abd32020-02-09 20:18:10 +02006990static enum sigma_cmd_result sta_get_pmk(struct sigma_dut *dut,
6991 struct sigma_conn *conn,
6992 struct sigma_cmd *cmd)
6993{
6994 const char *intf = get_param(cmd, "Interface");
6995 char buf[4096], bssid[20], resp[200], *pos, *tmp;
6996
6997 snprintf(buf, sizeof(buf), "PMKSA_GET %d", dut->infra_network_id);
6998 if (wpa_command_resp(intf, buf, buf, sizeof(buf)) < 0 ||
6999 strncmp(buf, "UNKNOWN COMMAND", 15) == 0) {
7000 send_resp(dut, conn, SIGMA_ERROR,
7001 "ErrorCode,PMKSA_GET not supported");
7002 return STATUS_SENT_ERROR;
7003 }
7004
7005 if (strncmp(buf, "FAIL", 4) == 0 ||
7006 get_wpa_status(intf, "bssid", bssid, sizeof(bssid)) < 0) {
7007 send_resp(dut, conn, SIGMA_ERROR,
7008 "ErrorCode,Could not find current network");
7009 return STATUS_SENT_ERROR;
7010 }
7011
7012 pos = buf;
7013 while (pos) {
7014 if (strncmp(pos, bssid, 17) == 0) {
7015 pos = strchr(pos, ' ');
7016 if (!pos)
Mohammad Asaad Akram956bfc32020-04-08 16:26:18 +05307017 break;
Jouni Malinenca0abd32020-02-09 20:18:10 +02007018 pos++;
7019 pos = strchr(pos, ' ');
7020 if (!pos)
Mohammad Asaad Akram956bfc32020-04-08 16:26:18 +05307021 break;
Jouni Malinenca0abd32020-02-09 20:18:10 +02007022 pos++;
7023 tmp = strchr(pos, ' ');
7024 if (!tmp)
Mohammad Asaad Akram956bfc32020-04-08 16:26:18 +05307025 break;
Jouni Malinenca0abd32020-02-09 20:18:10 +02007026 *tmp = '\0';
7027 break;
7028 }
Jouni Malinenca0abd32020-02-09 20:18:10 +02007029 pos = strchr(pos, '\n');
7030 if (pos)
7031 pos++;
7032 }
7033
7034 if (!pos) {
7035 send_resp(dut, conn, SIGMA_ERROR,
7036 "ErrorCode,PMK not available");
7037 return STATUS_SENT_ERROR;
7038 }
7039
7040 snprintf(resp, sizeof(resp), "PMK,%s", pos);
7041 send_resp(dut, conn, SIGMA_COMPLETE, resp);
7042 return STATUS_SENT;
7043}
7044
7045
Jouni Malinenf7222712019-06-13 01:50:21 +03007046static enum sigma_cmd_result cmd_sta_get_parameter(struct sigma_dut *dut,
7047 struct sigma_conn *conn,
7048 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007049{
7050 const char *program = get_param(cmd, "Program");
Jouni Malinenca0abd32020-02-09 20:18:10 +02007051 const char *parameter = get_param(cmd, "Parameter");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007052
Jouni Malinenca0abd32020-02-09 20:18:10 +02007053 if (!parameter)
7054 return INVALID_SEND_STATUS;
7055
7056 if (strcasecmp(parameter, "PMK") == 0)
7057 return sta_get_pmk(dut, conn, cmd);
7058
7059 if (!program)
7060 return INVALID_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007061
7062 if (strcasecmp(program, "P2PNFC") == 0)
7063 return p2p_cmd_sta_get_parameter(dut, conn, cmd);
7064
7065 if (strcasecmp(program, "60ghz") == 0)
7066 return sta_get_parameter_60g(dut, conn, cmd);
7067
Kiran Kumar Lokerec86d8022018-10-11 13:57:12 -07007068 if (strcasecmp(program, "he") == 0)
7069 return sta_get_parameter_he(dut, conn, cmd);
7070
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007071#ifdef ANDROID_NAN
7072 if (strcasecmp(program, "NAN") == 0)
Amarnath Hullur Subramanyam1854ec62016-08-11 19:29:35 -07007073 return nan_cmd_sta_get_parameter(dut, conn, cmd);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007074#endif /* ANDROID_NAN */
7075
Amarnath Hullur Subramanyam9c381f52017-03-17 00:04:41 -07007076#ifdef MIRACAST
7077 if (strcasecmp(program, "WFD") == 0 ||
7078 strcasecmp(program, "DisplayR2") == 0)
7079 return miracast_cmd_sta_get_parameter(dut, conn, cmd);
7080#endif /* MIRACAST */
Veerendranath Jakkamd0ad6ef2020-05-21 17:09:26 +05307081 if (strcasecmp(program, "WPA3") == 0)
7082 return sta_get_parameter_wpa3(dut, conn, cmd);
Amarnath Hullur Subramanyam9c381f52017-03-17 00:04:41 -07007083
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007084 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,Unsupported parameter");
7085 return 0;
7086}
7087
7088
7089static void sta_reset_default_ath(struct sigma_dut *dut, const char *intf,
7090 const char *type)
7091{
7092 char buf[100];
7093
7094 if (dut->program == PROGRAM_VHT) {
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07007095 run_iwpriv(dut, intf, "chwidth 2");
7096 run_iwpriv(dut, intf, "mode 11ACVHT80");
7097 run_iwpriv(dut, intf, "vhtmcs -1");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007098 }
7099
7100 if (dut->program == PROGRAM_HT) {
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07007101 run_iwpriv(dut, intf, "chwidth 0");
7102 run_iwpriv(dut, intf, "mode 11naht40");
7103 run_iwpriv(dut, intf, "set11NRates 0");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007104 }
7105
7106 if (dut->program == PROGRAM_VHT || dut->program == PROGRAM_HT) {
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07007107 run_iwpriv(dut, intf, "powersave 0");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007108
7109 /* Reset CTS width */
7110 snprintf(buf, sizeof(buf), "wifitool %s beeliner_fw_test 54 0",
7111 intf);
7112 if (system(buf) != 0) {
7113 sigma_dut_print(dut, DUT_MSG_ERROR,
7114 "wifitool %s beeliner_fw_test 54 0 failed",
7115 intf);
7116 }
7117
7118 /* Enable Dynamic Bandwidth signalling by default */
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07007119 run_iwpriv(dut, intf, "cwmenable 1");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007120
7121 snprintf(buf, sizeof(buf), "iwconfig %s rts 2347", intf);
7122 if (system(buf) != 0) {
7123 sigma_dut_print(dut, DUT_MSG_ERROR,
7124 "iwpriv rts failed");
7125 }
7126 }
7127
7128 if (type && strcasecmp(type, "Testbed") == 0) {
7129 dut->testbed_flag_txsp = 1;
7130 dut->testbed_flag_rxsp = 1;
7131 /* STA has to set spatial stream to 2 per Appendix H */
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07007132 run_iwpriv(dut, intf, "vht_mcsmap 0xfff0");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007133
7134 /* Disable LDPC per Appendix H */
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07007135 run_iwpriv(dut, intf, "ldpc 0");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007136
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07007137 run_iwpriv(dut, intf, "amsdu 1");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007138
7139 /* TODO: Disable STBC 2x1 transmit and receive */
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07007140 run_iwpriv(dut, intf, "tx_stbc 0");
7141 run_iwpriv(dut, intf, "rx_stbc 0");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007142
7143 /* STA has to disable Short GI per Appendix H */
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07007144 run_iwpriv(dut, intf, "shortgi 0");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007145 }
7146
7147 if (type && strcasecmp(type, "DUT") == 0) {
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07007148 run_iwpriv(dut, intf, "nss 3");
Arif Hussainac6c5112018-05-25 17:34:00 -07007149 dut->sta_nss = 3;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007150
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07007151 run_iwpriv(dut, intf, "shortgi 1");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007152 }
7153}
7154
7155
Amarnath Hullur Subramanyam2538acc2018-02-02 16:15:25 -08007156#ifdef NL80211_SUPPORT
7157static int sta_set_he_mcs(struct sigma_dut *dut, const char *intf,
7158 enum he_mcs_config mcs)
7159{
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05307160 return wcn_wifi_test_config_set_u8(
7161 dut, intf, QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_HE_MCS, mcs);
Amarnath Hullur Subramanyam2538acc2018-02-02 16:15:25 -08007162}
7163#endif /* NL80211_SUPPORT */
7164
7165
Kiran Kumar Lokere419f6962018-10-24 19:03:04 -07007166static int sta_set_action_tx_in_he_tb_ppdu(struct sigma_dut *dut,
7167 const char *intf, int enable)
7168{
7169#ifdef NL80211_SUPPORT
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05307170 return wcn_wifi_test_config_set_u8(
7171 dut, intf,
7172 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_HE_ACTION_TX_TB_PPDU,
7173 enable);
Kiran Kumar Lokere419f6962018-10-24 19:03:04 -07007174#else /* NL80211_SUPPORT */
7175 sigma_dut_print(dut, DUT_MSG_ERROR,
7176 "HE action Tx TB PPDU cannot be set without NL80211_SUPPORT defined");
7177 return -1;
7178#endif /* NL80211_SUPPORT */
7179}
7180
7181
Amarnath Hullur Subramanyam4622a212018-02-23 12:12:14 -08007182static int sta_set_heconfig_and_wep_tkip(struct sigma_dut *dut,
7183 const char *intf, int enable)
7184{
7185#ifdef NL80211_SUPPORT
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05307186 return wcn_wifi_test_config_set_u8(
7187 dut, intf, QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_WEP_TKIP_IN_HE,
7188 enable);
Amarnath Hullur Subramanyam4622a212018-02-23 12:12:14 -08007189#else /* NL80211_SUPPORT */
7190 sigma_dut_print(dut, DUT_MSG_ERROR,
7191 "HE config enablement cannot be changed without NL80211_SUPPORT defined");
7192 return -1;
7193#endif /* NL80211_SUPPORT */
7194}
7195
7196
Kiran Kumar Lokere765bdd82019-02-24 22:14:43 -08007197#ifdef NL80211_SUPPORT
Kiran Kumar Lokere642f7ce2019-02-25 18:28:10 -08007198
Kiran Kumar Lokere765bdd82019-02-24 22:14:43 -08007199static int sta_set_he_testbed_def(struct sigma_dut *dut,
7200 const char *intf, int cfg)
7201{
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05307202 return wcn_wifi_test_config_set_u8(
7203 dut, intf,
7204 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_SET_HE_TESTBED_DEFAULTS,
7205 cfg);
Kiran Kumar Lokere765bdd82019-02-24 22:14:43 -08007206}
Kiran Kumar Lokere642f7ce2019-02-25 18:28:10 -08007207
7208
7209static int sta_set_2g_vht_supp(struct sigma_dut *dut, const char *intf, int cfg)
7210{
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05307211 return wcn_wifi_test_config_set_u8(
7212 dut, intf, QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_ENABLE_2G_VHT,
7213 cfg);
Kiran Kumar Lokere642f7ce2019-02-25 18:28:10 -08007214}
7215
Kiran Kumar Lokere765bdd82019-02-24 22:14:43 -08007216#endif /* NL80211_SUPPORT */
7217
7218
Qiwei Caib6806972020-01-15 13:52:11 +08007219int sta_set_addba_buf_size(struct sigma_dut *dut,
7220 const char *intf, int bufsize)
Amarnath Hullur Subramanyam13215de2018-02-27 14:12:55 -08007221{
7222#ifdef NL80211_SUPPORT
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05307223 return wcn_wifi_test_config_set_u16(
7224 dut, intf,
7225 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_ADDBA_BUFF_SIZE, bufsize);
Amarnath Hullur Subramanyam13215de2018-02-27 14:12:55 -08007226#else /* NL80211_SUPPORT */
7227 sigma_dut_print(dut, DUT_MSG_ERROR,
7228 "AddBA bufsize cannot be changed without NL80211_SUPPORT defined");
7229 return -1;
7230#endif /* NL80211_SUPPORT */
7231}
7232
7233
Kiran Kumar Lokere69d89952021-08-08 23:41:46 -07007234static int sta_set_scan_unicast_probe(struct sigma_dut *dut,
7235 const char *intf, int val)
7236{
7237#ifdef NL80211_SUPPORT
7238 return wcn_wifi_test_config_set_u8(
7239 dut, intf,
7240 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_USE_BSSID_IN_PROBE_REQ_RA,
7241 val);
7242#else /* NL80211_SUPPORT */
7243 sigma_dut_print(dut, DUT_MSG_ERROR,
7244 "Unicast RA in Probe Request frame cannot be set without NL80211_SUPPORT defined");
7245 return -1;
7246#endif /* NL80211_SUPPORT */
7247}
7248
7249
Kiran Kumar Lokere09dbcef2021-08-09 00:01:41 -07007250static int sta_set_rx_ctrl_multi_bss(struct sigma_dut *dut, const char *intf,
7251 int enable)
7252{
7253#ifdef NL80211_SUPPORT
7254 return wcn_wifi_test_config_set_u8(
7255 dut, intf,
7256 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_RX_CTRL_FRAME_TO_MBSS,
7257 enable);
7258#else /* NL80211_SUPPORT */
7259 sigma_dut_print(dut, DUT_MSG_ERROR,
7260 "Rx ctrl frame to Multi-BSS cannot be changed without NL80211_SUPPORT defined");
7261 return -1;
7262#endif /* NL80211_SUPPORT */
7263}
7264
7265
7266static int sta_set_bcast_twt_support(struct sigma_dut *dut, const char *intf,
7267 int enable)
7268{
7269#ifdef NL80211_SUPPORT
7270 return wcn_wifi_test_config_set_u8(
7271 dut, intf,
7272 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_BCAST_TWT_SUPPORT,
7273 enable);
7274#else /* NL80211_SUPPORT */
7275 sigma_dut_print(dut, DUT_MSG_ERROR,
7276 "BCAST TWT cannot be changed without NL80211_SUPPORT defined");
7277 return -1;
7278#endif /* NL80211_SUPPORT */
7279}
7280
7281
Arif Hussain8d5b27b2018-05-14 14:31:03 -07007282static int sta_set_tx_beamformee(struct sigma_dut *dut, const char *intf,
7283 int enable)
7284{
7285#ifdef NL80211_SUPPORT
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05307286 return wcn_wifi_test_config_set_u8(
7287 dut, intf,
7288 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_ENABLE_TX_BEAMFORMEE,
7289 enable);
Arif Hussain8d5b27b2018-05-14 14:31:03 -07007290#else /* NL80211_SUPPORT */
7291 sigma_dut_print(dut, DUT_MSG_ERROR,
7292 "tx beamformee cannot be changed without NL80211_SUPPORT defined");
7293 return -1;
7294#endif /* NL80211_SUPPORT */
7295}
7296
7297
Arif Hussain9765f7d2018-07-03 08:28:26 -07007298static int sta_set_beamformee_sts(struct sigma_dut *dut, const char *intf,
7299 int val)
7300{
7301#ifdef NL80211_SUPPORT
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05307302 return wcn_wifi_test_config_set_u8(
7303 dut, intf,
7304 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_HE_TX_BEAMFORMEE_NSTS,
7305 val);
Arif Hussain9765f7d2018-07-03 08:28:26 -07007306#else /* NL80211_SUPPORT */
7307 sigma_dut_print(dut, DUT_MSG_ERROR,
7308 "beamformee sts cannot be changed without NL80211_SUPPORT defined");
7309 return -1;
7310#endif /* NL80211_SUPPORT */
7311}
7312
7313
Arif Hussain68d23f52018-07-11 13:39:08 -07007314#ifdef NL80211_SUPPORT
Kiran Kumar Lokere55eb5582018-08-19 20:03:26 -07007315static int sta_set_mac_padding_duration(struct sigma_dut *dut, const char *intf,
7316 enum qca_wlan_he_mac_padding_dur val)
7317{
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05307318 return wcn_wifi_test_config_set_u8(
7319 dut, intf,
7320 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_HE_MAC_PADDING_DUR, val);
Arif Hussain68d23f52018-07-11 13:39:08 -07007321}
Kiran Kumar Lokere55eb5582018-08-19 20:03:26 -07007322#endif /* NL80211_SUPPORT */
Arif Hussain68d23f52018-07-11 13:39:08 -07007323
7324
Kiran Kumar Lokere400d68f2018-08-29 18:45:11 -07007325static int sta_set_tx_su_ppdu_cfg(struct sigma_dut *dut, const char *intf,
7326 int val)
7327{
7328#ifdef NL80211_SUPPORT
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05307329 return wcn_wifi_test_config_set_u8(
7330 dut, intf, QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_HE_TX_SUPPDU,
7331 val);
Kiran Kumar Lokere400d68f2018-08-29 18:45:11 -07007332#else /* NL80211_SUPPORT */
7333 sigma_dut_print(dut, DUT_MSG_ERROR,
7334 "Tx SU PPDU cannot be set without NL80211_SUPPORT defined");
7335 return -1;
7336#endif /* NL80211_SUPPORT */
7337}
7338
7339
Kiran Kumar Lokere54b72522021-04-01 00:22:44 -07007340static int sta_set_mgmt_data_tx_disable_cfg(struct sigma_dut *dut,
7341 const char *intf, int val)
7342{
7343#ifdef NL80211_SUPPORT
7344 return wcn_wifi_test_config_set_u8(
7345 dut, intf,
7346 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_DISABLE_DATA_MGMT_RSP_TX,
7347 val);
7348#else /* NL80211_SUPPORT */
7349 sigma_dut_print(dut, DUT_MSG_ERROR,
7350 "Tx disable config cannot be set without NL80211_SUPPORT defined");
7351 return -1;
7352#endif /* NL80211_SUPPORT */
7353}
7354
7355
Kiran Kumar Lokere1809da12021-06-24 00:45:38 -07007356static int sta_set_keep_alive_data_cfg(struct sigma_dut *dut, const char *intf,
7357 int val)
7358{
7359#ifdef NL80211_SUPPORT
7360 return wcn_wifi_test_config_set_u8(
7361 dut, intf,
7362 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_KEEP_ALIVE_FRAME_TYPE,
7363 val);
7364#else /* NL80211_SUPPORT */
7365 sigma_dut_print(dut, DUT_MSG_ERROR,
7366 "Keep alive data type cannot be set without NL80211_SUPPORT defined");
7367 return -1;
7368#endif /* NL80211_SUPPORT */
7369}
7370
7371
Kiran Kumar Lokere29c1bb02018-10-08 17:41:02 -07007372#ifdef NL80211_SUPPORT
7373static int sta_set_he_om_ctrl_reset(struct sigma_dut *dut, const char *intf)
7374{
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05307375 return wcn_wifi_test_config_set_flag(
7376 dut, intf,
7377 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_CLEAR_HE_OM_CTRL_CONFIG);
Kiran Kumar Lokere29c1bb02018-10-08 17:41:02 -07007378}
7379#endif /* NL80211_SUPPORT */
7380
7381
Kiran Kumar Lokereb1012682018-08-08 17:48:32 -07007382static int sta_set_mu_edca_override(struct sigma_dut *dut, const char *intf,
7383 int val)
7384{
7385#ifdef NL80211_SUPPORT
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05307386 return wcn_wifi_test_config_set_u8(
7387 dut, intf,
7388 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_OVERRIDE_MU_EDCA, val);
Kiran Kumar Lokereb1012682018-08-08 17:48:32 -07007389#else /* NL80211_SUPPORT */
7390 sigma_dut_print(dut, DUT_MSG_ERROR,
7391 "MU EDCA override cannot be changed without NL80211_SUPPORT defined");
7392 return -1;
7393#endif /* NL80211_SUPPORT */
7394}
7395
7396
Kiran Kumar Lokerede33e372018-08-29 16:26:24 -07007397static int sta_set_om_ctrl_supp(struct sigma_dut *dut, const char *intf,
7398 int val)
7399{
7400#ifdef NL80211_SUPPORT
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05307401 return wcn_wifi_test_config_set_u8(
7402 dut, intf,
7403 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_HE_OM_CTRL_SUPP, val);
Kiran Kumar Lokerede33e372018-08-29 16:26:24 -07007404#else /* NL80211_SUPPORT */
7405 sigma_dut_print(dut, DUT_MSG_ERROR,
7406 "HE OM ctrl cannot be changed without NL80211_SUPPORT defined");
7407 return -1;
7408#endif /* NL80211_SUPPORT */
7409}
7410
7411
Kiran Kumar Lokeref61a7432021-06-24 00:19:19 -07007412#ifdef NL80211_SUPPORT
7413
7414struct features_info {
7415 unsigned char flags[8];
7416 size_t flags_len;
7417};
7418
7419static int features_info_handler(struct nl_msg *msg, void *arg)
7420{
7421 struct nlattr *tb[NL80211_ATTR_MAX + 1];
7422 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
7423 struct features_info *info = arg;
7424 struct nlattr *nl_vend, *attr;
7425
7426 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
7427 genlmsg_attrlen(gnlh, 0), NULL);
7428
7429 nl_vend = tb[NL80211_ATTR_VENDOR_DATA];
7430 if (nl_vend) {
7431 struct nlattr *tb_vendor[QCA_WLAN_VENDOR_ATTR_MAX + 1];
7432
7433 nla_parse(tb_vendor, QCA_WLAN_VENDOR_ATTR_MAX,
7434 nla_data(nl_vend), nla_len(nl_vend), NULL);
7435
7436 attr = tb_vendor[QCA_WLAN_VENDOR_ATTR_FEATURE_FLAGS];
7437 if (attr) {
7438 int len = nla_len(attr);
7439
Vamsi Krishna79a91132021-08-16 21:40:22 +05307440 if (info && len <= sizeof(info->flags)) {
Kiran Kumar Lokeref61a7432021-06-24 00:19:19 -07007441 memcpy(info->flags, nla_data(attr), len);
7442 info->flags_len = len;
7443 }
7444 }
7445 }
7446
7447 return NL_SKIP;
7448}
7449
7450
7451static int check_feature(enum qca_wlan_vendor_features feature,
7452 struct features_info *info)
7453{
7454 size_t idx = feature / 8;
7455
Vamsi Krishna79a91132021-08-16 21:40:22 +05307456 if (!info)
Kiran Kumar Lokeref61a7432021-06-24 00:19:19 -07007457 return 0;
7458
7459 return (idx < info->flags_len) &&
7460 (info->flags[idx] & BIT(feature % 8));
7461}
7462
7463#endif /* NL80211_SUPPORT */
7464
7465
7466static void sta_get_twt_feature_async_supp(struct sigma_dut *dut,
7467 const char *intf)
7468{
7469#ifdef NL80211_SUPPORT
7470 struct nl_msg *msg;
7471 struct features_info info = { 0 };
7472 int ifindex, ret;
7473
7474 ifindex = if_nametoindex(intf);
7475 if (ifindex == 0) {
7476 sigma_dut_print(dut, DUT_MSG_ERROR,
7477 "%s: Index for interface %s failed",
7478 __func__, intf);
7479 return;
7480 }
7481
7482 if (!(msg = nl80211_drv_msg(dut, dut->nl_ctx, ifindex, 0,
7483 NL80211_CMD_VENDOR)) ||
7484 nla_put_u32(msg, NL80211_ATTR_IFINDEX, ifindex) ||
7485 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
7486 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
7487 QCA_NL80211_VENDOR_SUBCMD_GET_FEATURES)) {
7488 sigma_dut_print(dut, DUT_MSG_ERROR,
7489 "%s: err in adding vendor_cmd and vendor_data",
7490 __func__);
7491 nlmsg_free(msg);
7492 return;
7493 }
7494
7495 ret = send_and_recv_msgs(dut, dut->nl_ctx, msg, features_info_handler,
7496 &info);
7497 if (ret) {
7498 sigma_dut_print(dut, DUT_MSG_ERROR,
7499 "%s: err in send_and_recv_msgs, ret=%d",
7500 __func__, ret);
7501 return;
7502 }
7503
7504 if (check_feature(QCA_WLAN_VENDOR_FEATURE_TWT_ASYNC_SUPPORT, &info))
7505 dut->sta_async_twt_supp = 1;
7506 else
7507 dut->sta_async_twt_supp = 0;
7508
7509 sigma_dut_print(dut, DUT_MSG_DEBUG,
7510 "%s: sta_async_twt_supp %d",
7511 __func__, dut->sta_async_twt_supp);
7512#else /* NL80211_SUPPORT */
7513 sigma_dut_print(dut, DUT_MSG_INFO,
7514 "TWT async supp get cannot be done without NL80211_SUPPORT defined");
7515 dut->sta_async_twt_supp = 0;
7516#endif /* NL80211_SUPPORT */
7517}
7518
7519
Arif Hussain480d5f42019-03-12 14:40:42 -07007520static int sta_set_twt_req_support(struct sigma_dut *dut, const char *intf,
7521 int val)
7522{
7523#ifdef NL80211_SUPPORT
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +05307524 return wcn_wifi_test_config_set_u8(
7525 dut, intf,
7526 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_HE_TWT_REQ_SUPPORT, val);
Arif Hussain480d5f42019-03-12 14:40:42 -07007527#else /* NL80211_SUPPORT */
7528 sigma_dut_print(dut, DUT_MSG_ERROR,
7529 "TWT Request cannot be changed without NL80211_SUPPORT defined");
7530 return -1;
7531#endif /* NL80211_SUPPORT */
7532}
7533
7534
Kiran Kumar Lokere4f2d4b02021-04-01 00:07:39 -07007535static int sta_set_bss_max_idle_period(struct sigma_dut *dut, const char *intf,
7536 int val)
7537{
7538#ifdef NL80211_SUPPORT
7539 return wcn_wifi_test_config_set_u16(
7540 dut, intf,
7541 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_BSS_MAX_IDLE_PERIOD, val);
7542#else /* NL80211_SUPPORT */
7543 sigma_dut_print(dut, DUT_MSG_ERROR,
7544 "BSS max idle period cannot be set without NL80211_SUPPORT defined");
7545 return -1;
7546#endif /* NL80211_SUPPORT */
7547}
7548
7549
Kiran Kumar Lokere07ad92b2021-08-09 00:27:14 -07007550static int sta_set_bss_max_idle_support(struct sigma_dut *dut, const char *intf,
7551 int val)
7552{
7553#ifdef NL80211_SUPPORT
7554 return wcn_wifi_test_config_set_u8(
7555 dut, intf,
7556 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_BSS_MAX_IDLE_PERIOD_ENABLE,
7557 val);
7558#else /* NL80211_SUPPORT */
7559 sigma_dut_print(dut, DUT_MSG_ERROR,
7560 "BSS max idle support cannot be set without NL80211_SUPPORT defined");
7561 return -1;
7562#endif /* NL80211_SUPPORT */
7563}
7564
7565
Srinivas Girigowda0525e292020-11-12 13:28:21 -08007566static int sta_set_fullbw_ulmumimo(struct sigma_dut *dut, const char *intf,
7567 int val)
7568{
7569#ifdef NL80211_SUPPORT
7570 return wcn_wifi_test_config_set_u8(
7571 dut, intf,
7572 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_FULL_BW_UL_MU_MIMO, val);
7573#else /* NL80211_SUPPORT */
7574 sigma_dut_print(dut, DUT_MSG_ERROR,
7575 "Full BW UL MU MIMO cannot be changed without NL80211_SUPPORT defined");
7576 return -1;
7577#endif /* NL80211_SUPPORT */
7578}
7579
7580
Kiran Kumar Lokered0ec5ed2021-04-01 00:15:04 -07007581static int sta_set_punctured_preamble_rx(struct sigma_dut *dut,
7582 const char *intf, int val)
7583{
7584#ifdef NL80211_SUPPORT
7585 return wcn_wifi_test_config_set_u8(
7586 dut, intf,
7587 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_PUNCTURED_PREAMBLE_RX,
7588 val);
7589#else /* NL80211_SUPPORT */
7590 sigma_dut_print(dut, DUT_MSG_ERROR,
7591 "Punctured preamble Rx cannot be set without NL80211_SUPPORT defined");
7592 return -1;
7593#endif /* NL80211_SUPPORT */
7594}
7595
7596
Amarnath Hullur Subramanyam58f2a6e2018-01-31 03:36:00 -08007597static void sta_reset_default_wcn(struct sigma_dut *dut, const char *intf,
7598 const char *type)
7599{
7600 char buf[60];
7601
7602 if (dut->program == PROGRAM_HE) {
7603 /* resetting phymode to auto in case of HE program */
Vinita S. Maloo13a5cf72020-05-22 14:45:06 +05307604 sta_set_phymode(dut, intf, "auto");
Amarnath Hullur Subramanyam58f2a6e2018-01-31 03:36:00 -08007605
Amarnath Hullur Subramanyam9cecb502018-04-25 13:26:30 -07007606 /* reset the rate to Auto rate */
7607 snprintf(buf, sizeof(buf), "iwpriv %s set_11ax_rate 0xff",
7608 intf);
7609 if (system(buf) != 0) {
7610 sigma_dut_print(dut, DUT_MSG_ERROR,
7611 "iwpriv %s set_11ax_rate 0xff failed",
7612 intf);
7613 }
7614
Kiran Kumar Lokere86cfe3a2018-06-01 11:55:15 -07007615 /* reset the LDPC setting */
7616 snprintf(buf, sizeof(buf), "iwpriv %s ldpc 1", intf);
7617 if (system(buf) != 0) {
7618 sigma_dut_print(dut, DUT_MSG_ERROR,
7619 "iwpriv %s ldpc 1 failed", intf);
7620 }
7621
Kiran Kumar Lokered6149ff2018-12-05 20:20:41 -08007622 /* reset the power save setting */
Vinita S. Malooa8b62722020-04-23 01:45:41 +05307623 set_power_save_wcn(dut, intf, 2);
Kiran Kumar Lokered6149ff2018-12-05 20:20:41 -08007624
Amarnath Hullur Subramanyam58f2a6e2018-01-31 03:36:00 -08007625 /* remove all network profiles */
7626 remove_wpa_networks(intf);
Amarnath Hullur Subramanyam2538acc2018-02-02 16:15:25 -08007627
Amarnath Hullur Subramanyam13215de2018-02-27 14:12:55 -08007628 /* Configure ADDBA Req/Rsp buffer size to be 64 */
7629 sta_set_addba_buf_size(dut, intf, 64);
7630
Kiran Kumar Lokeref61a7432021-06-24 00:19:19 -07007631 if (dut->sta_async_twt_supp == -1)
7632 sta_get_twt_feature_async_supp(dut, intf);
7633
Kiran Kumar Lokere69d89952021-08-08 23:41:46 -07007634 sta_set_scan_unicast_probe(dut, intf, 0);
7635
Amarnath Hullur Subramanyam5f32d572018-03-02 00:02:33 -08007636#ifdef NL80211_SUPPORT
Kiran Kumar Lokere765bdd82019-02-24 22:14:43 -08007637 /* Reset the device HE capabilities to its default supported
7638 * configuration. */
7639 sta_set_he_testbed_def(dut, intf, 0);
7640
Amarnath Hullur Subramanyam5f32d572018-03-02 00:02:33 -08007641 /* Disable noackpolicy for all AC */
7642 if (nlvendor_sta_set_noack(dut, intf, 0, QCA_WLAN_AC_ALL)) {
7643 sigma_dut_print(dut, DUT_MSG_ERROR,
7644 "Disable of noackpolicy for all AC failed");
7645 }
7646#endif /* NL80211_SUPPORT */
7647
Amarnath Hullur Subramanyamb1724a52018-03-07 14:31:46 -08007648 /* Enable WMM by default */
7649 if (wcn_sta_set_wmm(dut, intf, "on")) {
7650 sigma_dut_print(dut, DUT_MSG_ERROR,
7651 "Enable of WMM in sta_reset_default_wcn failed");
7652 }
7653
7654 /* Disable ADDBA_REJECT by default */
7655 if (nlvendor_sta_set_addba_reject(dut, intf, 0)) {
7656 sigma_dut_print(dut, DUT_MSG_ERROR,
7657 "Disable of addba_reject in sta_reset_default_wcn failed");
7658 }
7659
Amarnath Hullur Subramanyam1f65a672018-03-07 14:50:29 -08007660 /* Enable sending of ADDBA by default */
7661 if (nlvendor_config_send_addba(dut, intf, 1)) {
7662 sigma_dut_print(dut, DUT_MSG_ERROR,
7663 "Enable sending of ADDBA in sta_reset_default_wcn failed");
7664 }
7665
Amarnath Hullur Subramanyam63c590a2018-03-07 15:26:21 -08007666 /* Enable AMPDU by default */
7667 iwpriv_sta_set_ampdu(dut, intf, 1);
7668
Subhani Shaik8e7a3052018-04-24 14:03:00 -07007669#ifdef NL80211_SUPPORT
Kiran Kumar Lokere26c0f862020-01-22 11:15:59 -08007670 if (wcn_set_he_ltf(dut, intf, QCA_WLAN_HE_LTF_AUTO)) {
Subhani Shaik8e7a3052018-04-24 14:03:00 -07007671 sigma_dut_print(dut, DUT_MSG_ERROR,
7672 "Set LTF config to default in sta_reset_default_wcn failed");
7673 }
Arif Hussain9765f7d2018-07-03 08:28:26 -07007674
Kiran Kumar Lokerebad51122018-12-12 19:03:36 -08007675 /* set the beamformee NSTS(maximum number of
7676 * space-time streams) to default DUT config
7677 */
7678 if (sta_set_beamformee_sts(dut, intf, 7)) {
Arif Hussain9765f7d2018-07-03 08:28:26 -07007679 sigma_dut_print(dut, DUT_MSG_ERROR,
7680 "Failed to set BeamformeeSTS");
7681 }
Arif Hussain68d23f52018-07-11 13:39:08 -07007682
Kiran Kumar Lokere54b72522021-04-01 00:22:44 -07007683 if (sta_set_mgmt_data_tx_disable_cfg(dut, intf, 0)) {
7684 sigma_dut_print(dut, DUT_MSG_ERROR,
7685 "Failed to reset mgmt/data Tx disable config");
7686 }
7687
Kiran Kumar Lokere55eb5582018-08-19 20:03:26 -07007688 if (sta_set_mac_padding_duration(
7689 dut, intf,
7690 QCA_WLAN_HE_NO_ADDITIONAL_PROCESS_TIME)) {
Arif Hussain68d23f52018-07-11 13:39:08 -07007691 sigma_dut_print(dut, DUT_MSG_ERROR,
7692 "Failed to set MAC padding duration");
7693 }
Kiran Kumar Lokereb1012682018-08-08 17:48:32 -07007694
7695 if (sta_set_mu_edca_override(dut, intf, 0)) {
7696 sigma_dut_print(dut, DUT_MSG_ERROR,
7697 "ErrorCode,Failed to set MU EDCA override disable");
7698 }
Kiran Kumar Lokerede33e372018-08-29 16:26:24 -07007699
7700 if (sta_set_om_ctrl_supp(dut, intf, 1)) {
7701 sigma_dut_print(dut, DUT_MSG_ERROR,
7702 "Failed to set OM ctrl supp");
7703 }
Kiran Kumar Lokere400d68f2018-08-29 18:45:11 -07007704
7705 if (sta_set_tx_su_ppdu_cfg(dut, intf, 1)) {
7706 sigma_dut_print(dut, DUT_MSG_ERROR,
7707 "Failed to set Tx SU PPDU enable");
7708 }
Kiran Kumar Lokere29c1bb02018-10-08 17:41:02 -07007709
Kiran Kumar Lokere419f6962018-10-24 19:03:04 -07007710 if (sta_set_action_tx_in_he_tb_ppdu(dut, intf, 0)) {
7711 sigma_dut_print(dut, DUT_MSG_ERROR,
7712 "failed to send TB PPDU Tx cfg");
7713 }
7714
Kiran Kumar Lokere29c1bb02018-10-08 17:41:02 -07007715 if (sta_set_he_om_ctrl_reset(dut, intf)) {
7716 sigma_dut_print(dut, DUT_MSG_ERROR,
7717 "Failed to set OM ctrl reset");
7718 }
Kiran Kumar Lokeree5ed4422018-12-18 18:25:02 -08007719
7720 /* +HTC-HE support default on */
7721 if (sta_set_he_htc_supp(dut, intf, 1)) {
7722 sigma_dut_print(dut, DUT_MSG_ERROR,
7723 "Setting of +HTC-HE support failed");
7724 }
Subhani Shaik8e7a3052018-04-24 14:03:00 -07007725#endif /* NL80211_SUPPORT */
7726
Arif Hussain8d5b27b2018-05-14 14:31:03 -07007727 if (sta_set_tx_beamformee(dut, intf, 1)) {
7728 sigma_dut_print(dut, DUT_MSG_ERROR,
7729 "Set tx beamformee enable by default in sta_reset_default_wcn failed");
7730 }
7731
Kiran Kumar Lokereb55ff442020-07-15 00:20:40 -07007732 wpa_command(intf, "SET oce 1");
7733
Amarnath Hullur Subramanyam2538acc2018-02-02 16:15:25 -08007734 /* Set nss to 1 and MCS 0-7 in case of testbed */
7735 if (type && strcasecmp(type, "Testbed") == 0) {
7736#ifdef NL80211_SUPPORT
7737 int ret;
7738#endif /* NL80211_SUPPORT */
7739
Kiran Kumar Lokereb55ff442020-07-15 00:20:40 -07007740 wpa_command(intf, "SET oce 0");
7741
Amarnath Hullur Subramanyam2538acc2018-02-02 16:15:25 -08007742 snprintf(buf, sizeof(buf), "iwpriv %s nss 1", intf);
7743 if (system(buf) != 0) {
7744 sigma_dut_print(dut, DUT_MSG_ERROR,
7745 "iwpriv %s nss failed", intf);
7746 }
7747
7748#ifdef NL80211_SUPPORT
7749 ret = sta_set_he_mcs(dut, intf, HE_80_MCS0_7);
7750 if (ret) {
7751 sigma_dut_print(dut, DUT_MSG_ERROR,
7752 "Setting of MCS failed, ret:%d",
7753 ret);
7754 }
7755#endif /* NL80211_SUPPORT */
Amarnath Hullur Subramanyamc67621d2018-02-04 23:18:01 -08007756
7757 /* Disable STBC as default */
7758 wcn_sta_set_stbc(dut, intf, "0");
Amarnath Hullur Subramanyamd5bb5732018-02-22 15:50:38 -08007759
7760 /* Disable AMSDU as default */
7761 iwpriv_sta_set_amsdu(dut, intf, "0");
Amarnath Hullur Subramanyam474a17d2018-02-22 18:45:54 -08007762
7763#ifdef NL80211_SUPPORT
7764 /* HE fragmentation default off */
7765 if (sta_set_he_fragmentation(dut, intf,
7766 HE_FRAG_DISABLE)) {
7767 sigma_dut_print(dut, DUT_MSG_ERROR,
7768 "Setting of HE fragmentation failed");
7769 }
Kiran Kumar Lokerebad51122018-12-12 19:03:36 -08007770
7771 /* set the beamformee NSTS(maximum number of
7772 * space-time streams) to default testbed config
7773 */
7774 if (sta_set_beamformee_sts(dut, intf, 3)) {
7775 sigma_dut_print(dut, DUT_MSG_ERROR,
7776 "Failed to set BeamformeeSTS");
7777 }
7778
Kiran Kumar Lokered0ec5ed2021-04-01 00:15:04 -07007779 if (sta_set_punctured_preamble_rx(dut, intf, 0)) {
7780 sigma_dut_print(dut, DUT_MSG_ERROR,
7781 "Failed to reset PreamblePunctRx support");
7782 }
7783
Kiran Kumar Lokere727687f2021-06-24 00:35:49 -07007784 if (sta_set_bss_max_idle_period(dut, intf, 0)) {
7785 sigma_dut_print(dut, DUT_MSG_ERROR,
7786 "Failed to reset BSS max idle period");
7787 }
7788
Kiran Kumar Lokeree5ed4422018-12-18 18:25:02 -08007789 /* +HTC-HE support default off */
7790 if (sta_set_he_htc_supp(dut, intf, 0)) {
7791 sigma_dut_print(dut, DUT_MSG_ERROR,
7792 "Setting of +HTC-HE support failed");
7793 }
Kiran Kumar Lokere765bdd82019-02-24 22:14:43 -08007794
7795 /* Set device HE capabilities to testbed default
7796 * configuration. */
7797 if (sta_set_he_testbed_def(dut, intf, 1)) {
7798 sigma_dut_print(dut, DUT_MSG_DEBUG,
7799 "Failed to set HE defaults");
7800 }
Kiran Kumar Lokere642f7ce2019-02-25 18:28:10 -08007801
7802 /* Disable VHT support in 2.4 GHz for testbed */
7803 sta_set_2g_vht_supp(dut, intf, 0);
Amarnath Hullur Subramanyam474a17d2018-02-22 18:45:54 -08007804#endif /* NL80211_SUPPORT */
Amarnath Hullur Subramanyam4622a212018-02-23 12:12:14 -08007805
7806 /* Enable WEP/TKIP with HE capability in testbed */
7807 if (sta_set_heconfig_and_wep_tkip(dut, intf, 1)) {
7808 sigma_dut_print(dut, DUT_MSG_ERROR,
7809 "Enabling HE config with WEP/TKIP failed");
7810 }
Amarnath Hullur Subramanyam2538acc2018-02-02 16:15:25 -08007811 }
Amarnath Hullur Subramanyam0acce2c2018-03-06 06:05:17 -08007812
7813 /* Defaults in case of DUT */
7814 if (type && strcasecmp(type, "DUT") == 0) {
Arif Hussaind48fcc72018-05-01 18:34:18 -07007815 /* Enable STBC by default */
7816 wcn_sta_set_stbc(dut, intf, "1");
7817
Amarnath Hullur Subramanyam0acce2c2018-03-06 06:05:17 -08007818 /* set nss to 2 */
7819 snprintf(buf, sizeof(buf), "iwpriv %s nss 2", intf);
7820 if (system(buf) != 0) {
7821 sigma_dut_print(dut, DUT_MSG_ERROR,
7822 "iwpriv %s nss 2 failed", intf);
7823 }
Arif Hussainac6c5112018-05-25 17:34:00 -07007824 dut->sta_nss = 2;
Amarnath Hullur Subramanyam0acce2c2018-03-06 06:05:17 -08007825
7826#ifdef NL80211_SUPPORT
Arif Hussainae239842018-05-01 18:20:05 -07007827 /* Set HE_MCS to 0-11 */
7828 if (sta_set_he_mcs(dut, intf, HE_80_MCS0_11)) {
Amarnath Hullur Subramanyam0acce2c2018-03-06 06:05:17 -08007829 sigma_dut_print(dut, DUT_MSG_ERROR,
7830 "Setting of MCS failed");
7831 }
7832#endif /* NL80211_SUPPORT */
7833
7834 /* Disable WEP/TKIP with HE capability in DUT */
7835 if (sta_set_heconfig_and_wep_tkip(dut, intf, 0)) {
7836 sigma_dut_print(dut, DUT_MSG_ERROR,
7837 "Enabling HE config with WEP/TKIP failed");
7838 }
7839 }
Amarnath Hullur Subramanyam58f2a6e2018-01-31 03:36:00 -08007840 }
7841}
7842
7843
Veerendranath Jakkam47867202020-12-21 01:53:52 +05307844static int sta_set_client_privacy(struct sigma_dut *dut,
7845 struct sigma_conn *conn, const char *intf,
7846 int enable)
7847{
7848 if (enable &&
7849 (wpa_command(intf, "SET mac_addr 1") < 0 ||
7850 wpa_command(intf, "SET rand_addr_lifetime 1") < 0 ||
Veerendranath Jakkam39fd5c42020-12-21 02:02:21 +05307851 (wpa_command(intf, "MAC_RAND_SCAN enable=1 all") < 0 &&
7852 wpa_command(intf, "SET preassoc_mac_addr 1") < 0) ||
Veerendranath Jakkam47867202020-12-21 01:53:52 +05307853 wpa_command(intf, "SET gas_rand_mac_addr 1") < 0 ||
7854 wpa_command(intf, "SET gas_rand_addr_lifetime 1") < 0))
7855 return -1;
7856
7857 if (!enable &&
7858 (wpa_command(intf, "SET mac_addr 0") < 0 ||
Veerendranath Jakkam39fd5c42020-12-21 02:02:21 +05307859 (wpa_command(intf, "MAC_RAND_SCAN enable=0 all") < 0 &&
7860 wpa_command(intf, "SET preassoc_mac_addr 0") < 0) ||
Veerendranath Jakkam47867202020-12-21 01:53:52 +05307861 wpa_command(intf, "SET gas_rand_mac_addr 0") < 0))
7862 return -1;
7863
7864 dut->client_privacy = enable;
7865 return 0;
7866}
7867
7868
Jouni Malinenf7222712019-06-13 01:50:21 +03007869static enum sigma_cmd_result cmd_sta_reset_default(struct sigma_dut *dut,
7870 struct sigma_conn *conn,
7871 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007872{
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007873 const char *intf = get_param(cmd, "Interface");
Alexei Avshalom Lazar33f700c2018-12-18 16:00:39 +02007874 const char *band = get_param(cmd, "band");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007875 const char *type;
Amarnath Hullur Subramanyam9c381f52017-03-17 00:04:41 -07007876 const char *program = get_param(cmd, "program");
Ankita Bajaj0d5825b2017-10-25 16:20:17 +05307877 const char *dev_role = get_param(cmd, "DevRole");
Veerendranath Jakkamc1f71b62021-01-23 03:09:51 +05307878 char resp[20];
Veerendranath Jakkamea7f0692021-08-11 19:13:12 +05307879 char buf[100];
Veerendranath Jakkamc1f71b62021-01-23 03:09:51 +05307880 int ret;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007881
Jouni Malinenb21f0542019-11-04 17:53:38 +02007882 if (dut->station_ifname_2g &&
7883 strcmp(dut->station_ifname_2g, intf) == 0)
7884 dut->use_5g = 0;
7885 else if (dut->station_ifname_5g &&
7886 strcmp(dut->station_ifname_5g, intf) == 0)
7887 dut->use_5g = 1;
7888
Amarnath Hullur Subramanyam9c381f52017-03-17 00:04:41 -07007889 if (!program)
7890 program = get_param(cmd, "prog");
7891 dut->program = sigma_program_to_enum(program);
Vinita S. Maloof7a2cbf2020-11-18 19:29:44 +05307892
7893 if (dut->program == PROGRAM_WFD && dut->user_config_timeout)
7894 dut->default_timeout = dut->user_config_timeout;
7895
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007896 dut->device_type = STA_unknown;
7897 type = get_param(cmd, "type");
7898 if (type && strcasecmp(type, "Testbed") == 0)
7899 dut->device_type = STA_testbed;
7900 if (type && strcasecmp(type, "DUT") == 0)
7901 dut->device_type = STA_dut;
7902
7903 if (dut->program == PROGRAM_TDLS) {
7904 /* Clear TDLS testing mode */
7905 wpa_command(intf, "SET tdls_disabled 0");
7906 wpa_command(intf, "SET tdls_testing 0");
7907 dut->no_tpk_expiration = 0;
Jouni Malinen016ae6c2019-11-04 17:00:01 +02007908 if (get_driver_type(dut) == DRIVER_WCN) {
Pradeep Reddy POTTETI8ce2a232016-10-28 12:17:32 +05307909 /* Enable the WCN driver in TDLS Explicit trigger mode
7910 */
7911 wpa_command(intf, "SET tdls_external_control 0");
7912 wpa_command(intf, "SET tdls_trigger_control 0");
7913 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007914 }
7915
Amarnath Hullur Subramanyam9c381f52017-03-17 00:04:41 -07007916#ifdef MIRACAST
7917 if (dut->program == PROGRAM_WFD ||
7918 dut->program == PROGRAM_DISPLAYR2)
7919 miracast_sta_reset_default(dut, conn, cmd);
7920#endif /* MIRACAST */
7921
Jouni Malinen016ae6c2019-11-04 17:00:01 +02007922 switch (get_driver_type(dut)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007923 case DRIVER_ATHEROS:
7924 sta_reset_default_ath(dut, intf, type);
7925 break;
Amarnath Hullur Subramanyam58f2a6e2018-01-31 03:36:00 -08007926 case DRIVER_WCN:
7927 sta_reset_default_wcn(dut, intf, type);
7928 break;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007929 default:
7930 break;
7931 }
7932
7933#ifdef ANDROID_NAN
7934 if (dut->program == PROGRAM_NAN)
7935 nan_cmd_sta_reset_default(dut, conn, cmd);
7936#endif /* ANDROID_NAN */
7937
Vinay Gannevaram3b9fdd32019-06-14 17:55:44 +05307938 if (dut->program == PROGRAM_LOC &&
7939 lowi_cmd_sta_reset_default(dut, conn, cmd) < 0)
7940 return ERROR_SEND_STATUS;
7941
Jouni Malinenba630452018-06-22 11:49:59 +03007942 if (dut->program == PROGRAM_HS2_R2 || dut->program == PROGRAM_HS2_R3) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007943 unlink("SP/wi-fi.org/pps.xml");
7944 if (system("rm -r SP/*") != 0) {
7945 }
7946 unlink("next-client-cert.pem");
7947 unlink("next-client-key.pem");
7948 }
7949
Alexei Avshalom Lazar33f700c2018-12-18 16:00:39 +02007950 /* For WPS program of the 60 GHz band the band type needs to be saved */
7951 if (dut->program == PROGRAM_WPS) {
7952 if (band && strcasecmp(band, "60GHz") == 0) {
7953 dut->band = WPS_BAND_60G;
Alexei Avshalom Lazareee9ab02018-12-24 16:27:48 +02007954 /* For 60 GHz enable WPS for WPS TCs */
7955 dut->wps_disable = 0;
Alexei Avshalom Lazar33f700c2018-12-18 16:00:39 +02007956 } else {
7957 dut->band = WPS_BAND_NON_60G;
7958 }
Alexei Avshalom Lazareee9ab02018-12-24 16:27:48 +02007959 } else if (dut->program == PROGRAM_60GHZ) {
7960 /* For 60 GHz MAC/PHY TCs WPS must be disabled */
7961 dut->wps_disable = 1;
Alexei Avshalom Lazar33f700c2018-12-18 16:00:39 +02007962 }
7963
Alexei Avshalom Lazar157ba062018-12-23 16:15:26 +02007964 if (is_60g_sigma_dut(dut)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007965 const char *dev_role = get_param(cmd, "DevRole");
Alexei Avshalom Lazarc2a5bb12018-12-23 16:12:06 +02007966 char buf[256];
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007967
Alexei Avshalom Lazareee9ab02018-12-24 16:27:48 +02007968 sigma_dut_print(dut, DUT_MSG_INFO,
7969 "WPS 60 GHz program, wps_disable = %d",
7970 dut->wps_disable);
7971
Jouni Malinencd4e3c32015-10-29 12:39:56 +02007972 if (!dev_role) {
7973 send_resp(dut, conn, SIGMA_ERROR,
7974 "errorCode,Missing DevRole argument");
7975 return 0;
7976 }
7977
7978 if (strcasecmp(dev_role, "STA") == 0)
7979 dut->dev_role = DEVROLE_STA;
7980 else if (strcasecmp(dev_role, "PCP") == 0)
7981 dut->dev_role = DEVROLE_PCP;
7982 else {
7983 send_resp(dut, conn, SIGMA_ERROR,
7984 "errorCode,Unknown DevRole");
7985 return 0;
7986 }
7987
7988 if (dut->device_type == STA_unknown) {
7989 sigma_dut_print(dut, DUT_MSG_ERROR,
7990 "Device type is not STA testbed or DUT");
7991 send_resp(dut, conn, SIGMA_ERROR,
7992 "errorCode,Unknown device type");
7993 return 0;
7994 }
Alexei Avshalom Lazarc2a5bb12018-12-23 16:12:06 +02007995
7996 sigma_dut_print(dut, DUT_MSG_DEBUG,
7997 "Setting msdu_size to MAX: 7912");
7998 snprintf(buf, sizeof(buf), "ifconfig %s mtu 7912",
Jouni Malinen016ae6c2019-11-04 17:00:01 +02007999 get_station_ifname(dut));
Alexei Avshalom Lazarc2a5bb12018-12-23 16:12:06 +02008000
8001 if (system(buf) != 0) {
8002 sigma_dut_print(dut, DUT_MSG_ERROR, "Failed to set %s",
8003 buf);
Jouni Malinen0e29cf22019-02-19 01:13:21 +02008004 return ERROR_SEND_STATUS;
Alexei Avshalom Lazarc2a5bb12018-12-23 16:12:06 +02008005 }
Alexei Avshalom Lazaraad97b02018-12-18 16:01:23 +02008006
8007 if (sta_set_force_mcs(dut, 0, 1)) {
8008 sigma_dut_print(dut, DUT_MSG_ERROR,
8009 "Failed to reset force MCS");
Jouni Malinen0e29cf22019-02-19 01:13:21 +02008010 return ERROR_SEND_STATUS;
Alexei Avshalom Lazaraad97b02018-12-18 16:01:23 +02008011 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02008012 }
8013
8014 wpa_command(intf, "WPS_ER_STOP");
8015 wpa_command(intf, "FLUSH");
vamsi krishnaf39bc1e2017-08-23 17:37:53 +05308016 wpa_command(intf, "ERP_FLUSH");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02008017 wpa_command(intf, "SET radio_disabled 0");
8018
Alexei Avshalom Lazar744ae8a2019-01-31 17:26:46 +02008019 dut->wps_forced_version = 0;
8020
Alexei Avshalom Lazar33f700c2018-12-18 16:00:39 +02008021 if (dut->wsc_fragment) {
8022 dut->wsc_fragment = 0;
8023 wpa_command(intf, "SET device_name Test client");
8024 wpa_command(intf, "SET manufacturer ");
8025 wpa_command(intf, "SET model_name ");
8026 wpa_command(intf, "SET model_number ");
8027 wpa_command(intf, "SET serial_number ");
8028 }
Alexei Avshalom Lazarb094bf02018-12-18 16:00:53 +02008029 if (is_60g_sigma_dut(dut) && dut->force_rsn_ie) {
8030 dut->force_rsn_ie = FORCE_RSN_IE_NONE;
8031 sta_60g_force_rsn_ie(dut, FORCE_RSN_IE_NONE);
8032 }
Alexei Avshalom Lazar33f700c2018-12-18 16:00:39 +02008033
Jouni Malinencd4e3c32015-10-29 12:39:56 +02008034 if (dut->tmp_mac_addr && dut->set_macaddr) {
8035 dut->tmp_mac_addr = 0;
8036 if (system(dut->set_macaddr) != 0) {
8037 sigma_dut_print(dut, DUT_MSG_INFO, "Failed to clear "
8038 "temporary MAC address");
8039 }
8040 }
8041
8042 set_ps(intf, dut, 0);
8043
Jouni Malinenba630452018-06-22 11:49:59 +03008044 if (dut->program == PROGRAM_HS2 || dut->program == PROGRAM_HS2_R2 ||
8045 dut->program == PROGRAM_HS2_R3) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02008046 wpa_command(intf, "SET interworking 1");
8047 wpa_command(intf, "SET hs20 1");
8048 }
8049
Deepak Dhamdhere0fe0e452017-12-18 14:52:09 -08008050 if (dut->program == PROGRAM_HS2_R2 ||
Jouni Malinenba630452018-06-22 11:49:59 +03008051 dut->program == PROGRAM_HS2_R3 ||
Deepak Dhamdhere0fe0e452017-12-18 14:52:09 -08008052 dut->program == PROGRAM_OCE) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02008053 wpa_command(intf, "SET pmf 1");
8054 } else {
8055 wpa_command(intf, "SET pmf 0");
8056 }
8057
8058 hs2_clear_credentials(intf);
8059 wpa_command(intf, "SET hessid 00:00:00:00:00:00");
8060 wpa_command(intf, "SET access_network_type 15");
8061
8062 static_ip_file(0, NULL, NULL, NULL);
8063 kill_dhcp_client(dut, intf);
8064 clear_ip_addr(dut, intf);
8065
8066 dut->er_oper_performed = 0;
8067 dut->er_oper_bssid[0] = '\0';
8068
priyadharshini gowthamanad6cbba2016-10-04 10:39:58 -07008069 if (dut->program == PROGRAM_LOC) {
8070 /* Disable Interworking by default */
Jouni Malinen016ae6c2019-11-04 17:00:01 +02008071 wpa_command(get_station_ifname(dut), "SET interworking 0");
priyadharshini gowthamanad6cbba2016-10-04 10:39:58 -07008072 }
8073
Kiran Kumar Lokeredd086642020-06-04 00:29:26 -07008074 if (dut->program == PROGRAM_MBO || dut->program == PROGRAM_HE) {
Ashwini Patil00402582017-04-13 12:29:39 +05308075 free(dut->non_pref_ch_list);
8076 dut->non_pref_ch_list = NULL;
Ashwini Patil5acd7382017-04-13 15:55:04 +05308077 free(dut->btm_query_cand_list);
8078 dut->btm_query_cand_list = NULL;
Ashwini Patilc63161e2017-04-13 16:30:23 +05308079 wpa_command(intf, "SET reject_btm_req_reason 0");
Ashwini Patila75de5a2017-04-13 16:35:05 +05308080 wpa_command(intf, "SET ignore_assoc_disallow 0");
Ashwini Patild174f2c2017-04-13 16:49:46 +05308081 wpa_command(intf, "SET gas_address3 0");
Ashwini Patil9183fdb2017-04-13 16:58:25 +05308082 wpa_command(intf, "SET roaming 1");
Ankita Bajaj1d974552018-09-18 16:56:44 +05308083 wpa_command(intf, "SET interworking 1");
Ashwini Patil00402582017-04-13 12:29:39 +05308084 }
8085
Jouni Malinen3c367e82017-06-23 17:01:47 +03008086 free(dut->rsne_override);
8087 dut->rsne_override = NULL;
8088
Jouni Malinen68143132017-09-02 02:34:08 +03008089 free(dut->sae_commit_override);
8090 dut->sae_commit_override = NULL;
Jouni Malinen4b3769d2019-10-10 16:20:29 +03008091 wpa_command(intf, "SET sae_pmkid_in_assoc 0");
Jouni Malinen11e55212019-11-22 21:46:59 +02008092 dut->sae_pwe = SAE_PWE_DEFAULT;
Jouni Malinen68143132017-09-02 02:34:08 +03008093
Jouni Malinen134fe3c2019-06-12 04:16:49 +03008094 dut->sta_associate_wait_connect = 0;
8095 dut->server_cert_hash[0] = '\0';
Jouni Malinen37d5c692019-08-19 16:56:55 +03008096 dut->server_cert_tod = 0;
Jouni Malinen134fe3c2019-06-12 04:16:49 +03008097 dut->sta_tod_policy = 0;
8098
Jouni Malinend86e5822017-08-29 03:55:32 +03008099 dut->dpp_conf_id = -1;
Jouni Malinenb1dd21f2017-11-13 19:14:29 +02008100 free(dut->dpp_peer_uri);
8101 dut->dpp_peer_uri = NULL;
Jouni Malinen63d50412017-11-24 11:55:38 +02008102 dut->dpp_local_bootstrap = -1;
Jouni Malinen5011fb52017-12-05 21:00:15 +02008103 wpa_command(intf, "SET dpp_config_processing 2");
Jouni Malinen90776b12020-05-04 15:34:46 +03008104 wpa_command(intf, "SET dpp_mud_url ");
Jouni Malinend86e5822017-08-29 03:55:32 +03008105
Jouni Malinenfac9cad2017-10-10 18:35:55 +03008106 wpa_command(intf, "VENDOR_ELEM_REMOVE 13 *");
8107
vamsi krishnaa2799492017-12-05 14:28:01 +05308108 if (dut->program == PROGRAM_OCE) {
Ankita Bajaja2cb5672017-10-25 16:08:28 +05308109 wpa_command(intf, "SET oce 1");
vamsi krishnaa2799492017-12-05 14:28:01 +05308110 wpa_command(intf, "SET disable_fils 0");
Ankita Bajaj1bde7942018-01-09 19:15:01 +05308111 wpa_command(intf, "FILS_HLP_REQ_FLUSH");
8112 dut->fils_hlp = 0;
8113#ifdef ANDROID
8114 hlp_thread_cleanup(dut);
8115#endif /* ANDROID */
vamsi krishnaa2799492017-12-05 14:28:01 +05308116 }
Ankita Bajaja2cb5672017-10-25 16:08:28 +05308117
Veerendranath Jakkamea7f0692021-08-11 19:13:12 +05308118 if (dut->program == PROGRAM_QM) {
Vamsi Krishnaf642d6a2020-03-27 12:33:14 +05308119 wpa_command(intf, "SET interworking 1");
Veerendranath Jakkamea7f0692021-08-11 19:13:12 +05308120 snprintf(buf, sizeof(buf),
8121 "ip -6 route replace fe80::/64 dev %s table local",
8122 intf);
8123 if (system(buf) != 0)
8124 sigma_dut_print(dut, DUT_MSG_ERROR, "Failed to run: %s",
8125 buf);
8126 }
Vamsi Krishnaf642d6a2020-03-27 12:33:14 +05308127
Jouni Malinen8179fee2019-03-28 03:19:47 +02008128 dut->akm_values = 0;
Jouni Malinen6a7c9b42019-08-20 00:15:59 +03008129 dut->sta_ft_ds = 0;
Jouni Malinen8179fee2019-03-28 03:19:47 +02008130
Sunil Dutt076081f2018-02-05 19:45:50 +05308131#ifdef NL80211_SUPPORT
Jouni Malinen016ae6c2019-11-04 17:00:01 +02008132 if (get_driver_type(dut) == DRIVER_WCN &&
Sunil Dutt44595082018-02-12 19:41:45 +05308133 dut->config_rsnie == 1) {
8134 dut->config_rsnie = 0;
Mohammad Asaad Akram50848402020-05-28 14:10:24 +05308135 sta_config_params(dut, intf, STA_SET_RSNIE, 0);
Sunil Dutt076081f2018-02-05 19:45:50 +05308136 }
8137#endif /* NL80211_SUPPORT */
8138
Sunil Duttfebf8a82018-02-09 18:50:13 +05308139 if (dev_role && strcasecmp(dev_role, "STA-CFON") == 0) {
8140 dut->dev_role = DEVROLE_STA_CFON;
8141 return sta_cfon_reset_default(dut, conn, cmd);
8142 }
8143
Jouni Malinen439352d2018-09-13 03:42:23 +03008144 wpa_command(intf, "SET setband AUTO");
8145
Veerendranath Jakkamc1f71b62021-01-23 03:09:51 +05308146 ret = wpa_command_resp(intf, "GET_CAPABILITY ocv", resp, sizeof(resp));
8147 dut->ocvc = ret == 0 && strncmp(resp, "supported", 9) == 0;
8148
8149 ret = wpa_command_resp(intf, "GET_CAPABILITY beacon_prot", resp,
8150 sizeof(resp));
8151 dut->beacon_prot = ret == 0 && strncmp(resp, "supported", 9) == 0;
8152
Veerendranath Jakkam47867202020-12-21 01:53:52 +05308153 if (sta_set_client_privacy(dut, conn, intf,
8154 dut->program == PROGRAM_WPA3 &&
8155 dut->device_type == STA_dut &&
8156 dut->client_privacy_default)) {
8157 sigma_dut_print(dut, DUT_MSG_ERROR,
8158 "Failed to set client privacy functionality");
8159 /* sta_reset_default command is not really supposed to fail,
8160 * so allow this to continue. */
8161 }
8162
Veerendranath Jakkam54ddc352020-07-05 15:47:54 +05308163 dut->saquery_oci_freq = 0;
Vamsi Krishnac1633d22020-05-06 18:31:21 +05308164
Sunil Duttfebf8a82018-02-09 18:50:13 +05308165 if (dut->program != PROGRAM_VHT)
8166 return cmd_sta_p2p_reset(dut, conn, cmd);
8167
Priyadharshini Gowthamana7dfd492015-11-09 14:34:08 -08008168 return 1;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02008169}
8170
8171
Jouni Malinenf7222712019-06-13 01:50:21 +03008172static enum sigma_cmd_result cmd_sta_get_events(struct sigma_dut *dut,
8173 struct sigma_conn *conn,
8174 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02008175{
8176 const char *program = get_param(cmd, "Program");
8177
8178 if (program == NULL)
8179 return -1;
8180#ifdef ANDROID_NAN
8181 if (strcasecmp(program, "NAN") == 0)
8182 return nan_cmd_sta_get_events(dut, conn, cmd);
8183#endif /* ANDROID_NAN */
8184 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,Unsupported parameter");
8185 return 0;
8186}
8187
8188
Jouni Malinen82905202018-04-29 17:20:10 +03008189static int sta_exec_action_url(struct sigma_dut *dut, struct sigma_conn *conn,
8190 struct sigma_cmd *cmd)
8191{
8192 const char *url = get_param(cmd, "url");
8193 const char *method = get_param(cmd, "method");
8194 pid_t pid;
8195 int status;
8196
8197 if (!url || !method)
8198 return -1;
8199
8200 /* TODO: Add support for method,post */
8201 if (strcasecmp(method, "get") != 0) {
8202 send_resp(dut, conn, SIGMA_ERROR,
8203 "ErrorCode,Unsupported method");
8204 return 0;
8205 }
8206
8207 pid = fork();
8208 if (pid < 0) {
8209 perror("fork");
8210 return -1;
8211 }
8212
8213 if (pid == 0) {
8214 char * argv[5] = { "wget", "-O", "/dev/null",
8215 (char *) url, NULL };
8216
8217 execv("/usr/bin/wget", argv);
8218 perror("execv");
8219 exit(0);
8220 return -1;
8221 }
8222
8223 if (waitpid(pid, &status, 0) < 0) {
8224 perror("waitpid");
8225 return -1;
8226 }
8227
8228 if (WIFEXITED(status)) {
8229 const char *errmsg;
8230
8231 if (WEXITSTATUS(status) == 0)
8232 return 1;
8233 sigma_dut_print(dut, DUT_MSG_INFO, "wget exit status %d",
8234 WEXITSTATUS(status));
8235 switch (WEXITSTATUS(status)) {
8236 case 4:
8237 errmsg = "errmsg,Network failure";
8238 break;
8239 case 8:
8240 errmsg = "errmsg,Server issued an error response";
8241 break;
8242 default:
8243 errmsg = "errmsg,Unknown failure from wget";
8244 break;
8245 }
8246 send_resp(dut, conn, SIGMA_ERROR, errmsg);
8247 return 0;
8248 }
8249
8250 send_resp(dut, conn, SIGMA_ERROR, "errmsg,Unknown failure");
8251 return 0;
8252}
8253
8254
Jouni Malinenf7222712019-06-13 01:50:21 +03008255static enum sigma_cmd_result cmd_sta_exec_action(struct sigma_dut *dut,
8256 struct sigma_conn *conn,
8257 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02008258{
8259 const char *program = get_param(cmd, "Prog");
8260
Jouni Malinen82905202018-04-29 17:20:10 +03008261 if (program && !get_param(cmd, "interface"))
Jouni Malinencd4e3c32015-10-29 12:39:56 +02008262 return -1;
8263#ifdef ANDROID_NAN
Jouni Malinen82905202018-04-29 17:20:10 +03008264 if (program && strcasecmp(program, "NAN") == 0)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02008265 return nan_cmd_sta_exec_action(dut, conn, cmd);
8266#endif /* ANDROID_NAN */
Jouni Malinen82905202018-04-29 17:20:10 +03008267
8268 if (program && strcasecmp(program, "Loc") == 0)
priyadharshini gowthamand66913a2016-07-29 15:11:17 -07008269 return loc_cmd_sta_exec_action(dut, conn, cmd);
Jouni Malinen82905202018-04-29 17:20:10 +03008270
8271 if (get_param(cmd, "url"))
8272 return sta_exec_action_url(dut, conn, cmd);
8273
Jouni Malinencd4e3c32015-10-29 12:39:56 +02008274 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,Unsupported parameter");
8275 return 0;
8276}
8277
8278
Jouni Malinenf7222712019-06-13 01:50:21 +03008279static enum sigma_cmd_result cmd_sta_set_11n(struct sigma_dut *dut,
8280 struct sigma_conn *conn,
8281 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02008282{
8283 const char *intf = get_param(cmd, "Interface");
8284 const char *val, *mcs32, *rate;
8285
8286 val = get_param(cmd, "GREENFIELD");
8287 if (val) {
8288 if (strcmp(val, "1") == 0 || strcasecmp(val, "Enable") == 0) {
8289 /* Enable GD */
8290 send_resp(dut, conn, SIGMA_ERROR,
8291 "ErrorCode,GF not supported");
8292 return 0;
8293 }
8294 }
8295
8296 val = get_param(cmd, "SGI20");
8297 if (val) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02008298 switch (get_driver_type(dut)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02008299 case DRIVER_ATHEROS:
8300 ath_sta_set_sgi(dut, intf, val);
8301 break;
8302 default:
8303 send_resp(dut, conn, SIGMA_ERROR,
8304 "ErrorCode,SGI20 not supported");
8305 return 0;
8306 }
8307 }
8308
8309 mcs32 = get_param(cmd, "MCS32"); /* HT Duplicate Mode Enable/Disable */
8310 rate = get_param(cmd, "MCS_FIXEDRATE"); /* Fixed MCS rate (0..31) */
8311 if (mcs32 && rate) {
8312 /* TODO */
8313 send_resp(dut, conn, SIGMA_ERROR,
8314 "ErrorCode,MCS32,MCS_FIXEDRATE not supported");
8315 return 0;
8316 } else if (mcs32 && !rate) {
8317 /* TODO */
8318 send_resp(dut, conn, SIGMA_ERROR,
8319 "ErrorCode,MCS32 not supported");
8320 return 0;
8321 } else if (!mcs32 && rate) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02008322 switch (get_driver_type(dut)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02008323 case DRIVER_ATHEROS:
Priyadharshini Gowthaman8c5b9a42019-07-31 14:38:48 -07008324 novap_reset(dut, intf, 1);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02008325 ath_sta_set_11nrates(dut, intf, rate);
8326 break;
8327 default:
8328 send_resp(dut, conn, SIGMA_ERROR,
8329 "ErrorCode,MCS32_FIXEDRATE not supported");
8330 return 0;
8331 }
8332 }
8333
8334 return cmd_sta_set_wireless_common(intf, dut, conn, cmd);
8335}
8336
8337
Arif Hussain7b47d2d2018-05-09 10:44:02 -07008338static void cmd_set_max_he_mcs(struct sigma_dut *dut, const char *intf,
8339 int mcs_config)
8340{
8341#ifdef NL80211_SUPPORT
8342 int ret;
8343
8344 switch (mcs_config) {
8345 case HE_80_MCS0_7:
8346 case HE_80_MCS0_9:
8347 case HE_80_MCS0_11:
8348 ret = sta_set_he_mcs(dut, intf, mcs_config);
8349 if (ret) {
8350 sigma_dut_print(dut, DUT_MSG_ERROR,
8351 "cmd_set_max_he_mcs: Setting of MCS:%d failed, ret:%d",
8352 mcs_config, ret);
8353 }
8354 break;
8355 default:
8356 sigma_dut_print(dut, DUT_MSG_ERROR,
8357 "cmd_set_max_he_mcs: Invalid mcs %d",
8358 mcs_config);
8359 break;
8360 }
8361#else /* NL80211_SUPPORT */
8362 sigma_dut_print(dut, DUT_MSG_ERROR,
8363 "max HE MCS cannot be changed without NL80211_SUPPORT defined");
8364#endif /* NL80211_SUPPORT */
8365}
8366
8367
Kiran Kumar Lokeref61a7432021-06-24 00:19:19 -07008368struct wait_event {
8369 struct sigma_dut *dut;
8370 int cmd;
8371 unsigned int twt_op;
8372};
8373
8374#ifdef NL80211_SUPPORT
8375
8376static int twt_event_handler(struct nl_msg *msg, void *arg)
8377{
8378 struct wait_event *wait = arg;
8379 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
8380 struct nlattr *tb[NL80211_ATTR_MAX + 1];
8381 uint32_t subcmd;
8382 uint8_t *data = NULL;
8383 size_t len = 0;
8384 struct nlattr *twt_rsp[QCA_WLAN_VENDOR_ATTR_CONFIG_TWT_MAX + 1];
8385 struct nlattr *twt_status[QCA_WLAN_VENDOR_ATTR_TWT_SETUP_MAX + 1];
8386 int cmd_id;
8387 unsigned char val;
8388
8389 if (!wait)
8390 return NL_SKIP;
8391
8392 if (gnlh->cmd != NL80211_CMD_VENDOR) {
8393 sigma_dut_print(wait->dut, DUT_MSG_ERROR,
8394 "%s: NL cmd is not vendor %d", __func__,
8395 gnlh->cmd);
8396 return NL_SKIP;
8397 }
8398
8399 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
8400 genlmsg_attrlen(gnlh, 0), NULL);
8401
8402 if (!tb[NL80211_ATTR_VENDOR_ID] || !tb[NL80211_ATTR_VENDOR_SUBCMD]) {
8403 sigma_dut_print(wait->dut, DUT_MSG_ERROR,
8404 "%s: vendor ID not found", __func__);
8405 return NL_SKIP;
8406 }
8407 subcmd = nla_get_u32(tb[NL80211_ATTR_VENDOR_SUBCMD]);
8408
8409 if (subcmd != QCA_NL80211_VENDOR_SUBCMD_CONFIG_TWT) {
8410 sigma_dut_print(wait->dut, DUT_MSG_ERROR,
8411 "%s: Not a TWT_cmd %d", __func__, subcmd);
8412 return NL_SKIP;
8413 }
8414 if (tb[NL80211_ATTR_VENDOR_DATA]) {
8415 data = nla_data(tb[NL80211_ATTR_VENDOR_DATA]);
8416 len = nla_len(tb[NL80211_ATTR_VENDOR_DATA]);
8417 } else {
8418 sigma_dut_print(wait->dut, DUT_MSG_ERROR,
8419 "%s: vendor data not present", __func__);
8420 return NL_SKIP;
8421 }
8422 if (!data || !len) {
8423 sigma_dut_print(wait->dut, DUT_MSG_ERROR,
8424 "Invalid vendor data or len");
8425 return NL_SKIP;
8426 }
8427 sigma_dut_print(wait->dut, DUT_MSG_DEBUG,
8428 "event data len %ld", len);
8429 hex_dump(wait->dut, data, len);
8430 if (nla_parse(twt_rsp, QCA_WLAN_VENDOR_ATTR_CONFIG_TWT_MAX,
8431 (struct nlattr *) data, len, NULL)) {
8432 sigma_dut_print(wait->dut, DUT_MSG_ERROR,
8433 "vendor data parse error");
8434 return NL_SKIP;
8435 }
8436
8437 val = nla_get_u8(twt_rsp[QCA_WLAN_VENDOR_ATTR_CONFIG_TWT_OPERATION]);
8438 if (val != wait->twt_op) {
8439 sigma_dut_print(wait->dut, DUT_MSG_ERROR,
8440 "Invalid TWT operation, expected %d, rcvd %d",
8441 wait->twt_op, val);
8442 return NL_SKIP;
8443 }
8444 if (nla_parse_nested(twt_status, QCA_WLAN_VENDOR_ATTR_TWT_SETUP_MAX,
8445 twt_rsp[QCA_WLAN_VENDOR_ATTR_CONFIG_TWT_PARAMS],
8446 NULL)) {
8447 sigma_dut_print(wait->dut, DUT_MSG_ERROR,
8448 "nla_parse failed for TWT event");
8449 return NL_SKIP;
8450 }
8451
8452 cmd_id = QCA_WLAN_VENDOR_ATTR_TWT_SETUP_STATUS;
8453 if (!twt_status[cmd_id]) {
8454 sigma_dut_print(wait->dut, DUT_MSG_ERROR,
8455 "%s TWT resp status missing", __func__);
8456 wait->cmd = -1;
8457 } else {
8458 val = nla_get_u8(twt_status[cmd_id]);
8459 if (val != QCA_WLAN_VENDOR_TWT_STATUS_OK) {
8460 sigma_dut_print(wait->dut, DUT_MSG_ERROR,
8461 "%s TWT resp status %d", __func__, val);
8462 wait->cmd = -1;
8463 } else {
8464 wait->cmd = 1;
8465 }
8466 }
8467
8468 return NL_SKIP;
8469}
8470
8471
8472static int wait_on_nl_socket(struct nl_sock *sock, struct sigma_dut *dut,
8473 unsigned int timeout)
8474{
8475 fd_set read_fd_set;
8476 int retval;
8477 int sock_fd;
8478 struct timeval time_out;
8479
8480 time_out.tv_sec = timeout;
8481 time_out.tv_usec = 0;
8482
8483 FD_ZERO(&read_fd_set);
8484
8485 if (!sock)
8486 return -1;
8487
8488 sock_fd = nl_socket_get_fd(sock);
8489 FD_SET(sock_fd, &read_fd_set);
8490
8491 retval = select(sock_fd + 1, &read_fd_set, NULL, NULL, &time_out);
8492
8493 if (retval == 0)
8494 sigma_dut_print(dut, DUT_MSG_ERROR,
8495 "%s: TWT event response timedout", __func__);
8496
8497 if (retval < 0)
8498 sigma_dut_print(dut, DUT_MSG_ERROR, "%s:no NL msgs, ret=%d",
8499 __func__, retval);
8500
8501 return retval;
8502}
8503
8504
8505#define TWT_ASYNC_EVENT_WAIT_TIME_SEC 6
8506
8507static int twt_async_event_wait(struct sigma_dut *dut, unsigned int twt_op)
8508{
8509 struct nl_cb *cb;
8510 int err_code = 0, select_retval = 0;
8511 struct wait_event wait_info;
8512
8513 cb = nl_socket_get_cb(dut->nl_ctx->event_sock);
8514 if (!cb) {
8515 sigma_dut_print(dut, DUT_MSG_ERROR,
8516 "event callback not found");
8517 return ERROR_SEND_STATUS;
8518 }
8519
8520 wait_info.cmd = 0;
8521 wait_info.dut = dut;
8522 wait_info.twt_op = twt_op;
8523
8524 nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, twt_event_handler, &wait_info);
8525
8526 while (!wait_info.cmd) {
8527 select_retval = wait_on_nl_socket(
8528 dut->nl_ctx->event_sock, dut,
8529 TWT_ASYNC_EVENT_WAIT_TIME_SEC);
8530
8531 if (select_retval > 0) {
8532 err_code = nl_recvmsgs(dut->nl_ctx->event_sock, cb);
8533 if (err_code < 0) {
8534 sigma_dut_print(dut, DUT_MSG_ERROR,
8535 "%s: nl rcv failed, err_code %d",
8536 __func__, err_code);
8537 break;
8538 }
8539 } else {
8540 sigma_dut_print(dut, DUT_MSG_ERROR,
8541 "%s: wait on socket failed %d",
8542 __func__, select_retval);
8543 err_code = 1;
8544 break;
8545 }
8546
8547 }
8548 nl_cb_put(cb);
8549
8550 if (wait_info.cmd < 0)
8551 err_code = 1;
8552
8553 sigma_dut_print(dut, DUT_MSG_DEBUG,
8554 "%s: rcvd cmd %d, err_code %d, s_ret %d",
8555 __func__, wait_info.cmd, err_code, select_retval);
8556
8557 return err_code;
8558}
8559
8560#endif /* NL80211_SUPPORT */
8561
8562
Srinivas Girigowda6707f032020-10-26 15:24:46 -07008563static int sta_twt_send_suspend(struct sigma_dut *dut, struct sigma_conn *conn,
8564 struct sigma_cmd *cmd)
8565{
8566#ifdef NL80211_SUPPORT
8567 struct nlattr *attr, *attr1;
8568 struct nl_msg *msg;
8569 int ifindex, ret;
8570 const char *intf = get_param(cmd, "Interface");
8571
8572 ifindex = if_nametoindex(intf);
8573 if (ifindex == 0) {
8574 sigma_dut_print(dut, DUT_MSG_ERROR,
8575 "%s: Index for interface %s failed",
8576 __func__, intf);
8577 return ERROR_SEND_STATUS;
8578 }
8579
8580 if (!(msg = nl80211_drv_msg(dut, dut->nl_ctx, ifindex, 0,
8581 NL80211_CMD_VENDOR)) ||
8582 nla_put_u32(msg, NL80211_ATTR_IFINDEX, ifindex) ||
8583 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
8584 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
8585 QCA_NL80211_VENDOR_SUBCMD_CONFIG_TWT) ||
8586 !(attr = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA)) ||
8587 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_CONFIG_TWT_OPERATION,
8588 QCA_WLAN_TWT_SUSPEND) ||
8589 !(attr1 = nla_nest_start(msg,
8590 QCA_WLAN_VENDOR_ATTR_CONFIG_TWT_PARAMS)) ||
8591 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_TWT_NUDGE_FLOW_ID, 0)) {
8592 sigma_dut_print(dut, DUT_MSG_ERROR,
8593 "%s: err in adding vendor_cmd and vendor_data",
8594 __func__);
8595 nlmsg_free(msg);
8596 return ERROR_SEND_STATUS;
8597 }
8598 nla_nest_end(msg, attr1);
8599 nla_nest_end(msg, attr);
8600
8601 ret = send_and_recv_msgs(dut, dut->nl_ctx, msg, NULL, NULL);
8602 if (ret) {
8603 sigma_dut_print(dut, DUT_MSG_ERROR,
8604 "%s: err in send_and_recv_msgs, ret=%d",
8605 __func__, ret);
8606 }
8607
Kiran Kumar Lokeref61a7432021-06-24 00:19:19 -07008608 if (!dut->sta_async_twt_supp)
8609 return ret;
8610
8611 return twt_async_event_wait(dut, QCA_WLAN_TWT_SUSPEND);
Srinivas Girigowda6707f032020-10-26 15:24:46 -07008612#else /* NL80211_SUPPORT */
8613 sigma_dut_print(dut, DUT_MSG_ERROR,
8614 "TWT suspend cannot be done without NL80211_SUPPORT defined");
8615 return ERROR_SEND_STATUS;
8616#endif /* NL80211_SUPPORT */
8617}
8618
8619
8620static int sta_twt_send_nudge(struct sigma_dut *dut, struct sigma_conn *conn,
8621 struct sigma_cmd *cmd,
8622 unsigned int suspend_duration)
8623{
8624#ifdef NL80211_SUPPORT
8625 struct nlattr *attr, *attr1;
8626 struct nl_msg *msg;
8627 int ifindex, ret;
8628 const char *intf = get_param(cmd, "Interface");
8629 int next_twt_size = 1;
8630
8631 ifindex = if_nametoindex(intf);
8632 if (ifindex == 0) {
8633 sigma_dut_print(dut, DUT_MSG_ERROR,
8634 "%s: Index for interface %s failed",
8635 __func__, intf);
8636 return ERROR_SEND_STATUS;
8637 }
8638
8639 if (!(msg = nl80211_drv_msg(dut, dut->nl_ctx, ifindex, 0,
8640 NL80211_CMD_VENDOR)) ||
8641 nla_put_u32(msg, NL80211_ATTR_IFINDEX, ifindex) ||
8642 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
8643 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
8644 QCA_NL80211_VENDOR_SUBCMD_CONFIG_TWT) ||
8645 !(attr = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA)) ||
8646 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_CONFIG_TWT_OPERATION,
8647 QCA_WLAN_TWT_NUDGE) ||
8648 !(attr1 = nla_nest_start(msg,
8649 QCA_WLAN_VENDOR_ATTR_CONFIG_TWT_PARAMS)) ||
8650 (suspend_duration &&
8651 nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_TWT_NUDGE_WAKE_TIME,
8652 suspend_duration)) ||
8653 nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_TWT_NUDGE_NEXT_TWT_SIZE,
Kiran Kumar Lokere68c93de2021-06-24 01:06:47 -07008654 next_twt_size) ||
8655 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_TWT_NUDGE_FLOW_ID, 0)) {
Srinivas Girigowda6707f032020-10-26 15:24:46 -07008656 sigma_dut_print(dut, DUT_MSG_ERROR,
8657 "%s: err in adding vendor_cmd and vendor_data",
8658 __func__);
8659 nlmsg_free(msg);
8660 return ERROR_SEND_STATUS;
8661 }
8662 nla_nest_end(msg, attr1);
8663 nla_nest_end(msg, attr);
8664
8665 ret = send_and_recv_msgs(dut, dut->nl_ctx, msg, NULL, NULL);
8666 if (ret) {
8667 sigma_dut_print(dut, DUT_MSG_ERROR,
8668 "%s: err in send_and_recv_msgs, ret=%d",
8669 __func__, ret);
8670 }
8671
Kiran Kumar Lokeref61a7432021-06-24 00:19:19 -07008672 if (!dut->sta_async_twt_supp)
8673 return ret;
8674
8675 return twt_async_event_wait(dut, QCA_WLAN_TWT_NUDGE);
Srinivas Girigowda6707f032020-10-26 15:24:46 -07008676#else /* NL80211_SUPPORT */
8677 sigma_dut_print(dut, DUT_MSG_ERROR,
8678 "TWT suspend cannot be done without NL80211_SUPPORT defined");
8679 return ERROR_SEND_STATUS;
8680#endif /* NL80211_SUPPORT */
8681}
8682
8683
8684static int sta_twt_suspend_or_nudge(struct sigma_dut *dut,
8685 struct sigma_conn *conn,
8686 struct sigma_cmd *cmd)
8687{
8688 const char *val;
8689
8690 val = get_param(cmd, "TWT_SuspendDuration");
8691 if (val) {
8692 unsigned int suspend_duration;
8693
8694 suspend_duration = atoi(val);
8695 suspend_duration = suspend_duration * 1000 * 1000;
8696 return sta_twt_send_nudge(dut, conn, cmd, suspend_duration);
8697 }
8698
8699 return sta_twt_send_suspend(dut, conn, cmd);
8700}
8701
8702
8703static int sta_twt_resume(struct sigma_dut *dut, struct sigma_conn *conn,
8704 struct sigma_cmd *cmd)
8705{
8706#ifdef NL80211_SUPPORT
8707 struct nlattr *attr, *attr1;
8708 struct nl_msg *msg;
8709 int ifindex, ret;
8710 const char *intf = get_param(cmd, "Interface");
8711 int next2_twt_size = 1;
8712 unsigned int resume_duration = 0;
8713 const char *val;
8714
8715 ifindex = if_nametoindex(intf);
8716 if (ifindex == 0) {
8717 sigma_dut_print(dut, DUT_MSG_ERROR,
8718 "%s: Index for interface %s failed",
8719 __func__, intf);
8720 return ERROR_SEND_STATUS;
8721 }
8722
8723 val = get_param(cmd, "TWT_ResumeDuration");
8724 if (val) {
8725 resume_duration = atoi(val);
8726 resume_duration = resume_duration * 1000 * 1000;
8727 }
8728
8729 if (!(msg = nl80211_drv_msg(dut, dut->nl_ctx, ifindex, 0,
8730 NL80211_CMD_VENDOR)) ||
8731 nla_put_u32(msg, NL80211_ATTR_IFINDEX, ifindex) ||
8732 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
8733 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
8734 QCA_NL80211_VENDOR_SUBCMD_CONFIG_TWT) ||
8735 !(attr = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA)) ||
8736 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_CONFIG_TWT_OPERATION,
8737 QCA_WLAN_TWT_RESUME) ||
8738 !(attr1 = nla_nest_start(msg,
8739 QCA_WLAN_VENDOR_ATTR_CONFIG_TWT_PARAMS)) ||
8740 (resume_duration &&
8741 nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_TWT_RESUME_NEXT2_TWT,
8742 resume_duration)) ||
8743 nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_TWT_RESUME_NEXT_TWT_SIZE,
8744 next2_twt_size)) {
8745 sigma_dut_print(dut, DUT_MSG_ERROR,
8746 "%s: err in adding vendor_cmd and vendor_data",
8747 __func__);
8748 nlmsg_free(msg);
8749 return ERROR_SEND_STATUS;
8750 }
8751 nla_nest_end(msg, attr1);
8752 nla_nest_end(msg, attr);
8753
8754 ret = send_and_recv_msgs(dut, dut->nl_ctx, msg, NULL, NULL);
8755 if (ret) {
8756 sigma_dut_print(dut, DUT_MSG_ERROR,
8757 "%s: err in send_and_recv_msgs, ret=%d",
8758 __func__, ret);
8759 }
8760
Kiran Kumar Lokeref61a7432021-06-24 00:19:19 -07008761 if (!dut->sta_async_twt_supp)
8762 return ret;
8763
8764 return twt_async_event_wait(dut, QCA_WLAN_TWT_RESUME);
Srinivas Girigowda6707f032020-10-26 15:24:46 -07008765#else /* NL80211_SUPPORT */
8766 sigma_dut_print(dut, DUT_MSG_ERROR,
8767 "TWT resume cannot be done without NL80211_SUPPORT defined");
8768 return ERROR_SEND_STATUS;
8769#endif /* NL80211_SUPPORT */
8770}
8771
8772
Kiran Kumar Lokerebd396102020-04-27 12:01:09 -07008773#define TWT_REQUEST_CMD 0
8774#define TWT_SUGGEST_CMD 1
8775#define TWT_DEMAND_CMD 2
8776
Arif Hussain480d5f42019-03-12 14:40:42 -07008777static int sta_twt_request(struct sigma_dut *dut, struct sigma_conn *conn,
8778 struct sigma_cmd *cmd)
8779{
8780#ifdef NL80211_SUPPORT
8781 struct nlattr *params;
8782 struct nlattr *attr;
Arif Hussain480d5f42019-03-12 14:40:42 -07008783 struct nl_msg *msg;
8784 int ifindex, ret;
8785 const char *val;
8786 const char *intf = get_param(cmd, "Interface");
8787 int wake_interval_exp = 10, nominal_min_wake_dur = 255,
8788 wake_interval_mantissa = 512;
8789 int flow_type = 0, twt_trigger = 0, target_wake_time = 0,
Kiran Kumar Lokerebd396102020-04-27 12:01:09 -07008790 protection = 0, cmd_type = QCA_WLAN_VENDOR_TWT_SETUP_SUGGEST;
Kiran Kumar Lokere68c93de2021-06-24 01:06:47 -07008791 int bcast_twt = 0;
8792 int bcast_twt_id = 0, bcast_twt_recommdn = 0, bcast_twt_persis = 0;
Arif Hussain480d5f42019-03-12 14:40:42 -07008793
8794 ifindex = if_nametoindex(intf);
8795 if (ifindex == 0) {
8796 sigma_dut_print(dut, DUT_MSG_ERROR,
8797 "%s: Index for interface %s failed",
8798 __func__, intf);
8799 return -1;
8800 }
8801
8802 val = get_param(cmd, "FlowType");
8803 if (val) {
8804 flow_type = atoi(val);
8805 if (flow_type != 0 && flow_type != 1) {
8806 sigma_dut_print(dut, DUT_MSG_ERROR,
8807 "TWT: Invalid FlowType %d", flow_type);
8808 return -1;
8809 }
8810 }
8811
8812 val = get_param(cmd, "TWT_Trigger");
8813 if (val) {
8814 twt_trigger = atoi(val);
8815 if (twt_trigger != 0 && twt_trigger != 1) {
8816 sigma_dut_print(dut, DUT_MSG_ERROR,
8817 "TWT: Invalid TWT_Trigger %d",
8818 twt_trigger);
8819 return -1;
8820 }
8821 }
8822
8823 val = get_param(cmd, "Protection");
8824 if (val) {
8825 protection = atoi(val);
8826 if (protection != 0 && protection != 1) {
8827 sigma_dut_print(dut, DUT_MSG_ERROR,
8828 "TWT: Invalid Protection %d",
8829 protection);
8830 return -1;
8831 }
8832 }
8833
Kiran Kumar Lokerebd396102020-04-27 12:01:09 -07008834 val = get_param(cmd, "SetupCommand");
8835 if (val) {
8836 cmd_type = atoi(val);
8837 if (cmd_type == TWT_REQUEST_CMD)
8838 cmd_type = QCA_WLAN_VENDOR_TWT_SETUP_REQUEST;
8839 else if (cmd_type == TWT_SUGGEST_CMD)
8840 cmd_type = QCA_WLAN_VENDOR_TWT_SETUP_SUGGEST;
8841 else if (cmd_type == TWT_DEMAND_CMD)
8842 cmd_type = QCA_WLAN_VENDOR_TWT_SETUP_DEMAND;
8843 else
8844 sigma_dut_print(dut, DUT_MSG_ERROR,
8845 "Default suggest is used for cmd %d",
8846 cmd_type);
8847 }
8848
Arif Hussain480d5f42019-03-12 14:40:42 -07008849 val = get_param(cmd, "TargetWakeTime");
8850 if (val)
8851 target_wake_time = atoi(val);
8852
8853 val = get_param(cmd, "WakeIntervalMantissa");
8854 if (val)
8855 wake_interval_mantissa = atoi(val);
8856
8857 val = get_param(cmd, "WakeIntervalExp");
8858 if (val)
8859 wake_interval_exp = atoi(val);
8860
8861 val = get_param(cmd, "NominalMinWakeDur");
8862 if (val)
8863 nominal_min_wake_dur = atoi(val);
8864
Kiran Kumar Lokere68c93de2021-06-24 01:06:47 -07008865 val = get_param(cmd, "BTWT_ID");
8866 if (val) {
8867 bcast_twt_id = atoi(val);
8868 bcast_twt = 1;
8869 }
8870
8871 val = get_param(cmd, "BTWT_Persistence");
8872 if (val) {
8873 bcast_twt_persis = atoi(val);
8874 bcast_twt = 1;
8875 }
8876
8877 val = get_param(cmd, "BTWT_Recommendation");
8878 if (val) {
8879 bcast_twt_recommdn = atoi(val);
8880 bcast_twt = 1;
8881 }
8882
8883 if (bcast_twt)
8884 sigma_dut_print(dut, DUT_MSG_DEBUG,
8885 "BCAST_TWT: ID %d, RECOMM %d, PERSIS %d",
8886 bcast_twt_id, bcast_twt_recommdn,
8887 bcast_twt_persis);
8888
Arif Hussain480d5f42019-03-12 14:40:42 -07008889 if (!(msg = nl80211_drv_msg(dut, dut->nl_ctx, ifindex, 0,
8890 NL80211_CMD_VENDOR)) ||
8891 nla_put_u32(msg, NL80211_ATTR_IFINDEX, ifindex) ||
8892 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
8893 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
Srinivas Girigowda6707f032020-10-26 15:24:46 -07008894 QCA_NL80211_VENDOR_SUBCMD_CONFIG_TWT) ||
Arif Hussain480d5f42019-03-12 14:40:42 -07008895 !(attr = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA)) ||
Srinivas Girigowda6707f032020-10-26 15:24:46 -07008896 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_CONFIG_TWT_OPERATION,
8897 QCA_WLAN_TWT_SET) ||
Arif Hussain480d5f42019-03-12 14:40:42 -07008898 !(params = nla_nest_start(
Srinivas Girigowda6707f032020-10-26 15:24:46 -07008899 msg, QCA_WLAN_VENDOR_ATTR_CONFIG_TWT_PARAMS)) ||
Arif Hussain480d5f42019-03-12 14:40:42 -07008900 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_TWT_SETUP_WAKE_INTVL_EXP,
8901 wake_interval_exp) ||
Kiran Kumar Lokerebd396102020-04-27 12:01:09 -07008902 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_TWT_SETUP_REQ_TYPE, cmd_type) ||
Kiran Kumar Lokere2cffae52019-09-26 18:44:15 -07008903 (twt_trigger &&
8904 nla_put_flag(msg, QCA_WLAN_VENDOR_ATTR_TWT_SETUP_TRIGGER)) ||
Arif Hussain480d5f42019-03-12 14:40:42 -07008905 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_TWT_SETUP_FLOW_TYPE,
8906 flow_type) ||
Kiran Kumar Lokere2cffae52019-09-26 18:44:15 -07008907 (protection &&
8908 nla_put_flag(msg, QCA_WLAN_VENDOR_ATTR_TWT_SETUP_PROTECTION)) ||
Kiran Kumar Lokere68c93de2021-06-24 01:06:47 -07008909 (bcast_twt &&
8910 nla_put_flag(msg, QCA_WLAN_VENDOR_ATTR_TWT_SETUP_BCAST)) ||
8911 (bcast_twt &&
8912 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_TWT_SETUP_BCAST_ID,
8913 bcast_twt_id)) ||
8914 (bcast_twt &&
8915 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_TWT_SETUP_BCAST_PERSISTENCE,
8916 bcast_twt_persis)) ||
8917 (bcast_twt &&
8918 nla_put_u8(msg,
8919 QCA_WLAN_VENDOR_ATTR_TWT_SETUP_BCAST_RECOMMENDATION,
8920 bcast_twt_recommdn)) ||
Arif Hussain480d5f42019-03-12 14:40:42 -07008921 nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_TWT_SETUP_WAKE_TIME,
8922 target_wake_time) ||
8923 nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_TWT_SETUP_WAKE_DURATION,
8924 nominal_min_wake_dur) ||
8925 nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_TWT_SETUP_WAKE_INTVL_MANTISSA,
8926 wake_interval_mantissa)) {
8927 sigma_dut_print(dut, DUT_MSG_ERROR,
8928 "%s: err in adding vendor_cmd and vendor_data",
8929 __func__);
8930 nlmsg_free(msg);
8931 return -1;
8932 }
Arif Hussain480d5f42019-03-12 14:40:42 -07008933 nla_nest_end(msg, params);
8934 nla_nest_end(msg, attr);
8935
8936 ret = send_and_recv_msgs(dut, dut->nl_ctx, msg, NULL, NULL);
8937 if (ret) {
8938 sigma_dut_print(dut, DUT_MSG_ERROR,
8939 "%s: err in send_and_recv_msgs, ret=%d",
8940 __func__, ret);
8941 }
8942
Kiran Kumar Lokeref61a7432021-06-24 00:19:19 -07008943 if (!dut->sta_async_twt_supp)
8944 return ret;
8945
8946 return twt_async_event_wait(dut, QCA_WLAN_TWT_SET);
Arif Hussain480d5f42019-03-12 14:40:42 -07008947#else /* NL80211_SUPPORT */
8948 sigma_dut_print(dut, DUT_MSG_ERROR,
8949 "TWT request cannot be done without NL80211_SUPPORT defined");
8950 return -1;
8951#endif /* NL80211_SUPPORT */
8952}
8953
8954
8955static int sta_twt_teardown(struct sigma_dut *dut, struct sigma_conn *conn,
8956 struct sigma_cmd *cmd)
8957{
8958 #ifdef NL80211_SUPPORT
8959 struct nlattr *params;
8960 struct nlattr *attr;
Arif Hussain480d5f42019-03-12 14:40:42 -07008961 int ifindex, ret;
8962 struct nl_msg *msg;
8963 const char *intf = get_param(cmd, "Interface");
Kiran Kumar Lokere68c93de2021-06-24 01:06:47 -07008964 int bcast_twt = 0;
8965 int bcast_twt_id = 0;
8966 const char *val;
Arif Hussain480d5f42019-03-12 14:40:42 -07008967
8968 ifindex = if_nametoindex(intf);
8969 if (ifindex == 0) {
8970 sigma_dut_print(dut, DUT_MSG_ERROR,
8971 "%s: Index for interface %s failed",
8972 __func__, intf);
8973 return -1;
8974 }
8975
Kiran Kumar Lokere68c93de2021-06-24 01:06:47 -07008976 val = get_param(cmd, "BTWT_ID");
8977 if (val) {
8978 bcast_twt_id = atoi(val);
8979 bcast_twt = 1;
8980 }
8981
Arif Hussain480d5f42019-03-12 14:40:42 -07008982 if (!(msg = nl80211_drv_msg(dut, dut->nl_ctx, ifindex, 0,
8983 NL80211_CMD_VENDOR)) ||
8984 nla_put_u32(msg, NL80211_ATTR_IFINDEX, ifindex) ||
8985 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
8986 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
Srinivas Girigowda6707f032020-10-26 15:24:46 -07008987 QCA_NL80211_VENDOR_SUBCMD_CONFIG_TWT) ||
Arif Hussain480d5f42019-03-12 14:40:42 -07008988 !(attr = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA)) ||
Srinivas Girigowda6707f032020-10-26 15:24:46 -07008989 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_CONFIG_TWT_OPERATION,
8990 QCA_WLAN_TWT_TERMINATE) ||
Arif Hussain480d5f42019-03-12 14:40:42 -07008991 !(params = nla_nest_start(
8992 msg,
Srinivas Girigowda6707f032020-10-26 15:24:46 -07008993 QCA_WLAN_VENDOR_ATTR_CONFIG_TWT_PARAMS)) ||
Kiran Kumar Lokere68c93de2021-06-24 01:06:47 -07008994 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_TWT_SETUP_FLOW_TYPE, 0) ||
8995 (bcast_twt &&
8996 nla_put_flag(msg, QCA_WLAN_VENDOR_ATTR_TWT_SETUP_BCAST)) ||
8997 (bcast_twt &&
8998 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_TWT_SETUP_BCAST_ID,
8999 bcast_twt_id))) {
Arif Hussain480d5f42019-03-12 14:40:42 -07009000 sigma_dut_print(dut, DUT_MSG_ERROR,
9001 "%s: err in adding vendor_cmd and vendor_data",
9002 __func__);
9003 nlmsg_free(msg);
9004 return -1;
9005 }
Arif Hussain480d5f42019-03-12 14:40:42 -07009006 nla_nest_end(msg, params);
9007 nla_nest_end(msg, attr);
9008
9009 ret = send_and_recv_msgs(dut, dut->nl_ctx, msg, NULL, NULL);
9010 if (ret) {
9011 sigma_dut_print(dut, DUT_MSG_ERROR,
9012 "%s: err in send_and_recv_msgs, ret=%d",
9013 __func__, ret);
9014 }
9015
Kiran Kumar Lokeref61a7432021-06-24 00:19:19 -07009016 if (!dut->sta_async_twt_supp)
9017 return ret;
9018
9019 return twt_async_event_wait(dut, QCA_WLAN_TWT_TERMINATE);
Arif Hussain480d5f42019-03-12 14:40:42 -07009020#else /* NL80211_SUPPORT */
9021 sigma_dut_print(dut, DUT_MSG_ERROR,
9022 "TWT teardown cannot be done without NL80211_SUPPORT defined");
9023 return -1;
9024#endif /* NL80211_SUPPORT */
9025}
9026
9027
Kiran Kumar Lokere50eb2cd2018-12-18 18:31:28 -08009028static int sta_transmit_omi(struct sigma_dut *dut, struct sigma_conn *conn,
9029 struct sigma_cmd *cmd)
9030{
9031#ifdef NL80211_SUPPORT
9032 struct nlattr *params;
9033 struct nlattr *attr;
9034 struct nlattr *attr1;
9035 struct nl_msg *msg;
9036 int ifindex, ret;
9037 const char *val;
9038 const char *intf = get_param(cmd, "Interface");
9039 uint8_t rx_nss = 0xFF, ch_bw = 0xFF, tx_nsts = 0xFF, ulmu_dis = 0,
9040 ulmu_data_dis = 0;
9041
9042 ifindex = if_nametoindex(intf);
9043 if (ifindex == 0) {
9044 sigma_dut_print(dut, DUT_MSG_ERROR,
9045 "%s: Index for interface %s failed",
9046 __func__, intf);
9047 return -1;
9048 }
9049 val = get_param(cmd, "OMCtrl_RxNSS");
9050 if (val)
9051 rx_nss = atoi(val);
9052
9053 val = get_param(cmd, "OMCtrl_ChnlWidth");
9054 if (val)
9055 ch_bw = atoi(val);
9056
9057 val = get_param(cmd, "OMCtrl_ULMUDisable");
9058 if (val)
9059 ulmu_dis = atoi(val);
9060
9061 val = get_param(cmd, "OMCtrl_TxNSTS");
9062 if (val)
9063 tx_nsts = atoi(val);
9064
9065 val = get_param(cmd, "OMCtrl_ULMUDataDisable");
9066 if (val)
9067 ulmu_data_dis = atoi(val);
9068
9069 if (!(msg = nl80211_drv_msg(dut, dut->nl_ctx, ifindex, 0,
9070 NL80211_CMD_VENDOR)) ||
9071 nla_put_u32(msg, NL80211_ATTR_IFINDEX, ifindex) ||
9072 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
9073 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
9074 QCA_NL80211_VENDOR_SUBCMD_WIFI_TEST_CONFIGURATION) ||
9075 !(attr = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA)) ||
9076 !(params = nla_nest_start(
9077 msg, QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_HE_OMI_TX)) ||
9078 !(attr1 = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA)) ||
9079 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_HE_OMI_RX_NSS, rx_nss) ||
9080 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_HE_OMI_CH_BW, ch_bw) ||
9081 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_HE_OMI_TX_NSTS, tx_nsts) ||
9082 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_HE_OMI_ULMU_DATA_DISABLE,
9083 ulmu_data_dis) ||
9084 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_HE_OMI_ULMU_DISABLE,
9085 ulmu_dis)) {
9086 sigma_dut_print(dut, DUT_MSG_ERROR,
9087 "%s: err in adding vendor_cmd and vendor_data",
9088 __func__);
9089 nlmsg_free(msg);
9090 return -1;
9091 }
9092 nla_nest_end(msg, attr1);
9093 nla_nest_end(msg, params);
9094 nla_nest_end(msg, attr);
9095
9096 ret = send_and_recv_msgs(dut, dut->nl_ctx, msg, NULL, NULL);
9097 if (ret) {
9098 sigma_dut_print(dut, DUT_MSG_ERROR,
9099 "%s: err in send_and_recv_msgs, ret=%d",
9100 __func__, ret);
9101 }
9102
9103 return ret;
9104#else /* NL80211_SUPPORT */
9105 sigma_dut_print(dut, DUT_MSG_ERROR,
9106 "OMI TX cannot be processed without NL80211_SUPPORT defined");
9107 return -1;
9108#endif /* NL80211_SUPPORT */
9109}
9110
9111
Jouni Malinen224e3902021-06-09 16:41:27 +03009112static enum sigma_cmd_result
9113cmd_sta_set_wireless_vht(struct sigma_dut *dut, struct sigma_conn *conn,
9114 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009115{
9116 const char *intf = get_param(cmd, "Interface");
9117 const char *val;
Arif Hussaina37e9552018-06-20 17:05:59 -07009118 const char *program;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009119 int tkip = -1;
9120 int wep = -1;
Mohammad Asaad Akram50848402020-05-28 14:10:24 +05309121 int iwpriv_status;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009122
Arif Hussaina37e9552018-06-20 17:05:59 -07009123 program = get_param(cmd, "Program");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009124 val = get_param(cmd, "SGI80");
9125 if (val) {
9126 int sgi80;
9127
9128 sgi80 = strcmp(val, "1") == 0 || strcasecmp(val, "Enable") == 0;
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07009129 run_iwpriv(dut, intf, "shortgi %d", sgi80);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009130 }
9131
9132 val = get_param(cmd, "TxBF");
9133 if (val && (strcmp(val, "1") == 0 || strcasecmp(val, "Enable") == 0)) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02009134 switch (get_driver_type(dut)) {
Kiran Kumar Lokerecb57d822018-07-06 16:37:42 -07009135 case DRIVER_WCN:
9136 if (sta_set_tx_beamformee(dut, intf, 1)) {
9137 send_resp(dut, conn, SIGMA_ERROR,
9138 "ErrorCode,Failed to set TX beamformee enable");
Jouni Malinen224e3902021-06-09 16:41:27 +03009139 return STATUS_SENT_ERROR;
Kiran Kumar Lokerecb57d822018-07-06 16:37:42 -07009140 }
9141 break;
9142 case DRIVER_ATHEROS:
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07009143 if (run_iwpriv(dut, intf, "vhtsubfee 1") < 0) {
Kiran Kumar Lokerecb57d822018-07-06 16:37:42 -07009144 send_resp(dut, conn, SIGMA_ERROR,
9145 "ErrorCode,Setting vhtsubfee failed");
Jouni Malinen224e3902021-06-09 16:41:27 +03009146 return STATUS_SENT_ERROR;
Kiran Kumar Lokerecb57d822018-07-06 16:37:42 -07009147 }
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07009148 if (run_iwpriv(dut, intf, "vhtsubfer 1") < 0) {
Kiran Kumar Lokerecb57d822018-07-06 16:37:42 -07009149 send_resp(dut, conn, SIGMA_ERROR,
9150 "ErrorCode,Setting vhtsubfer failed");
Jouni Malinen224e3902021-06-09 16:41:27 +03009151 return STATUS_SENT_ERROR;
Kiran Kumar Lokerecb57d822018-07-06 16:37:42 -07009152 }
9153 break;
9154 default:
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009155 sigma_dut_print(dut, DUT_MSG_ERROR,
Kiran Kumar Lokerecb57d822018-07-06 16:37:42 -07009156 "Unsupported driver type");
9157 break;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009158 }
9159 }
9160
9161 val = get_param(cmd, "MU_TxBF");
9162 if (val && (strcmp(val, "1") == 0 || strcasecmp(val, "Enable") == 0)) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02009163 switch (get_driver_type(dut)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009164 case DRIVER_ATHEROS:
9165 ath_sta_set_txsp_stream(dut, intf, "1SS");
9166 ath_sta_set_rxsp_stream(dut, intf, "1SS");
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07009167 run_iwpriv(dut, intf, "vhtmubfee 1");
9168 run_iwpriv(dut, intf, "vhtmubfer 1");
Sunil Duttae9e5d12018-06-29 11:50:47 +05309169 break;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009170 case DRIVER_WCN:
9171 if (wcn_sta_set_sp_stream(dut, intf, "1SS") < 0) {
9172 send_resp(dut, conn, SIGMA_ERROR,
9173 "ErrorCode,Failed to set RX/TXSP_STREAM");
Jouni Malinen224e3902021-06-09 16:41:27 +03009174 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009175 }
Sunil Duttae9e5d12018-06-29 11:50:47 +05309176 break;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009177 default:
9178 sigma_dut_print(dut, DUT_MSG_ERROR,
9179 "Setting SP_STREAM not supported");
9180 break;
9181 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009182 }
9183
9184 val = get_param(cmd, "LDPC");
9185 if (val) {
9186 int ldpc;
9187
9188 ldpc = strcmp(val, "1") == 0 || strcasecmp(val, "Enable") == 0;
Mohammad Asaad Akram50848402020-05-28 14:10:24 +05309189 iwpriv_status = run_iwpriv(dut, intf, "ldpc %d", ldpc);
9190 if (iwpriv_status)
9191 sta_config_params(dut, intf, STA_SET_LDPC, ldpc);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009192 }
9193
Amarnath Hullur Subramanyam7bae60e2018-01-31 03:46:50 -08009194 val = get_param(cmd, "BCC");
9195 if (val) {
9196 int bcc;
9197
9198 bcc = strcmp(val, "1") == 0 || strcasecmp(val, "Enable") == 0;
9199 /* use LDPC iwpriv itself to set bcc coding, bcc coding
9200 * is mutually exclusive to bcc */
Mohammad Asaad Akram50848402020-05-28 14:10:24 +05309201 iwpriv_status = run_iwpriv(dut, intf, "ldpc %d", !bcc);
9202 if (iwpriv_status)
9203 sta_config_params(dut, intf, STA_SET_LDPC, !bcc);
Amarnath Hullur Subramanyam7bae60e2018-01-31 03:46:50 -08009204 }
9205
Arif Hussain7b47d2d2018-05-09 10:44:02 -07009206 val = get_param(cmd, "MaxHE-MCS_1SS_RxMapLTE80");
9207 if (val && dut->sta_nss == 1)
9208 cmd_set_max_he_mcs(dut, intf, atoi(val));
9209
9210 val = get_param(cmd, "MaxHE-MCS_2SS_RxMapLTE80");
9211 if (val && dut->sta_nss == 2)
9212 cmd_set_max_he_mcs(dut, intf, atoi(val));
9213
Arif Hussainac6c5112018-05-25 17:34:00 -07009214 val = get_param(cmd, "MCS_FixedRate");
9215 if (val) {
9216#ifdef NL80211_SUPPORT
9217 int mcs, ratecode = 0;
9218 enum he_mcs_config mcs_config;
9219 int ret;
Jouni Malinenb9b671d2019-04-26 13:23:17 +03009220 char buf[60];
Arif Hussainac6c5112018-05-25 17:34:00 -07009221
9222 ratecode = (0x07 & dut->sta_nss) << 5;
9223 mcs = atoi(val);
9224 /* Add the MCS to the ratecode */
9225 if (mcs >= 0 && mcs <= 11) {
9226 ratecode += mcs;
9227 if (dut->device_type == STA_testbed &&
9228 mcs > 7 && mcs <= 11) {
9229 if (mcs <= 9)
9230 mcs_config = HE_80_MCS0_9;
9231 else
9232 mcs_config = HE_80_MCS0_11;
9233 ret = sta_set_he_mcs(dut, intf, mcs_config);
9234 if (ret) {
9235 sigma_dut_print(dut, DUT_MSG_ERROR,
9236 "MCS_FixedRate: mcs setting failed, mcs:%d, mcs_config %d, ret:%d",
9237 mcs, mcs_config, ret);
9238 }
9239 }
9240 snprintf(buf, sizeof(buf),
9241 "iwpriv %s set_11ax_rate 0x%03x",
9242 intf, ratecode);
9243 if (system(buf) != 0) {
9244 sigma_dut_print(dut, DUT_MSG_ERROR,
9245 "MCS_FixedRate: iwpriv setting of 11ax rates 0x%03x failed",
9246 ratecode);
9247 }
9248 } else {
9249 sigma_dut_print(dut, DUT_MSG_ERROR,
9250 "MCS_FixedRate: HE MCS %d not supported",
9251 mcs);
9252 }
9253#else /* NL80211_SUPPORT */
9254 sigma_dut_print(dut, DUT_MSG_ERROR,
9255 "MCS_FixedRate cannot be changed without NL80211_SUPPORT defined");
9256#endif /* NL80211_SUPPORT */
9257 }
9258
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009259 val = get_param(cmd, "opt_md_notif_ie");
9260 if (val) {
9261 char *result = NULL;
9262 char delim[] = ";";
9263 char token[30];
9264 int value, config_val = 0;
Pradeep Reddy POTTETIdbf7d712016-04-28 18:42:07 +05309265 char *saveptr;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009266
Peng Xub8fc5cc2017-05-10 17:27:28 -07009267 strlcpy(token, val, sizeof(token));
Pradeep Reddy POTTETIdbf7d712016-04-28 18:42:07 +05309268 result = strtok_r(token, delim, &saveptr);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009269
9270 /* Extract the NSS information */
9271 if (result) {
9272 value = atoi(result);
9273 switch (value) {
9274 case 1:
9275 config_val = 1;
9276 break;
9277 case 2:
9278 config_val = 3;
9279 break;
9280 case 3:
9281 config_val = 7;
9282 break;
9283 case 4:
9284 config_val = 15;
9285 break;
9286 default:
9287 config_val = 3;
9288 break;
9289 }
9290
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07009291 run_iwpriv(dut, intf, "rxchainmask %d", config_val);
9292 run_iwpriv(dut, intf, "txchainmask %d", config_val);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009293
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009294 }
9295
9296 /* Extract the channel width information */
Pradeep Reddy POTTETIdbf7d712016-04-28 18:42:07 +05309297 result = strtok_r(NULL, delim, &saveptr);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009298 if (result) {
9299 value = atoi(result);
9300 switch (value) {
9301 case 20:
9302 config_val = 0;
9303 break;
9304 case 40:
9305 config_val = 1;
9306 break;
9307 case 80:
9308 config_val = 2;
9309 break;
9310 case 160:
9311 config_val = 3;
9312 break;
9313 default:
9314 config_val = 2;
9315 break;
9316 }
9317
9318 dut->chwidth = config_val;
9319
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07009320 run_iwpriv(dut, intf, "chwidth %d", config_val);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009321 }
9322
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07009323 run_iwpriv(dut, intf, "opmode_notify 1");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009324 }
9325
9326 val = get_param(cmd, "nss_mcs_cap");
9327 if (val) {
9328 int nss, mcs;
9329 char token[20];
9330 char *result = NULL;
9331 unsigned int vht_mcsmap = 0;
Pradeep Reddy POTTETIdbf7d712016-04-28 18:42:07 +05309332 char *saveptr;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009333
Peng Xub8fc5cc2017-05-10 17:27:28 -07009334 strlcpy(token, val, sizeof(token));
Pradeep Reddy POTTETIdbf7d712016-04-28 18:42:07 +05309335 result = strtok_r(token, ";", &saveptr);
Pradeep Reddy POTTETIcd649a22016-01-29 12:55:59 +05309336 if (!result) {
9337 sigma_dut_print(dut, DUT_MSG_ERROR,
Arif Hussaina37e9552018-06-20 17:05:59 -07009338 "NSS not specified");
9339 send_resp(dut, conn, SIGMA_ERROR,
9340 "errorCode,NSS not specified");
Jouni Malinen224e3902021-06-09 16:41:27 +03009341 return STATUS_SENT_ERROR;
Pradeep Reddy POTTETIcd649a22016-01-29 12:55:59 +05309342 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009343 nss = atoi(result);
9344
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07009345 run_iwpriv(dut, intf, "nss %d", nss);
Arif Hussainac6c5112018-05-25 17:34:00 -07009346 dut->sta_nss = nss;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009347
Pradeep Reddy POTTETIdbf7d712016-04-28 18:42:07 +05309348 result = strtok_r(NULL, ";", &saveptr);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009349 if (result == NULL) {
9350 sigma_dut_print(dut, DUT_MSG_ERROR,
Arif Hussaina37e9552018-06-20 17:05:59 -07009351 "MCS not specified");
9352 send_resp(dut, conn, SIGMA_ERROR,
9353 "errorCode,MCS not specified");
Jouni Malinen224e3902021-06-09 16:41:27 +03009354 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009355 }
Pradeep Reddy POTTETIdbf7d712016-04-28 18:42:07 +05309356 result = strtok_r(result, "-", &saveptr);
9357 result = strtok_r(NULL, "-", &saveptr);
Pradeep Reddy POTTETIcd649a22016-01-29 12:55:59 +05309358 if (!result) {
9359 sigma_dut_print(dut, DUT_MSG_ERROR,
Arif Hussaina37e9552018-06-20 17:05:59 -07009360 "MCS not specified");
9361 send_resp(dut, conn, SIGMA_ERROR,
9362 "errorCode,MCS not specified");
Jouni Malinen224e3902021-06-09 16:41:27 +03009363 return STATUS_SENT_ERROR;
Pradeep Reddy POTTETIcd649a22016-01-29 12:55:59 +05309364 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009365 mcs = atoi(result);
9366
Arif Hussaina37e9552018-06-20 17:05:59 -07009367 if (program && strcasecmp(program, "HE") == 0) {
9368#ifdef NL80211_SUPPORT
9369 enum he_mcs_config mcs_config;
9370 int ret;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009371
Arif Hussaina37e9552018-06-20 17:05:59 -07009372 if (mcs >= 0 && mcs <= 7) {
9373 mcs_config = HE_80_MCS0_7;
9374 } else if (mcs > 7 && mcs <= 9) {
9375 mcs_config = HE_80_MCS0_9;
9376 } else if (mcs > 9 && mcs <= 11) {
9377 mcs_config = HE_80_MCS0_11;
9378 } else {
9379 sigma_dut_print(dut, DUT_MSG_ERROR,
9380 "nss_mcs_cap: HE: Invalid mcs: %d",
9381 mcs);
9382 send_resp(dut, conn, SIGMA_ERROR,
9383 "errorCode,Invalid MCS");
Jouni Malinen224e3902021-06-09 16:41:27 +03009384 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009385 }
Arif Hussaina37e9552018-06-20 17:05:59 -07009386
9387 ret = sta_set_he_mcs(dut, intf, mcs_config);
9388 if (ret) {
9389 sigma_dut_print(dut, DUT_MSG_ERROR,
9390 "nss_mcs_cap: HE: Setting of MCS failed, mcs_config: %d, ret: %d",
9391 mcs_config, ret);
9392 send_resp(dut, conn, SIGMA_ERROR,
9393 "errorCode,Failed to set MCS");
Jouni Malinen224e3902021-06-09 16:41:27 +03009394 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009395 }
Arif Hussaina37e9552018-06-20 17:05:59 -07009396#else /* NL80211_SUPPORT */
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009397 sigma_dut_print(dut, DUT_MSG_ERROR,
Arif Hussaina37e9552018-06-20 17:05:59 -07009398 "nss_mcs_cap: HE: MCS cannot be changed without NL80211_SUPPORT defined");
9399#endif /* NL80211_SUPPORT */
9400 } else {
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07009401 run_iwpriv(dut, intf, "vhtmcs %d", mcs);
Arif Hussaina37e9552018-06-20 17:05:59 -07009402
9403 switch (nss) {
9404 case 1:
9405 switch (mcs) {
9406 case 7:
9407 vht_mcsmap = 0xfffc;
9408 break;
9409 case 8:
9410 vht_mcsmap = 0xfffd;
9411 break;
9412 case 9:
9413 vht_mcsmap = 0xfffe;
9414 break;
9415 default:
9416 vht_mcsmap = 0xfffe;
9417 break;
9418 }
9419 break;
9420 case 2:
9421 switch (mcs) {
9422 case 7:
9423 vht_mcsmap = 0xfff0;
9424 break;
9425 case 8:
9426 vht_mcsmap = 0xfff5;
9427 break;
9428 case 9:
9429 vht_mcsmap = 0xfffa;
9430 break;
9431 default:
9432 vht_mcsmap = 0xfffa;
9433 break;
9434 }
9435 break;
9436 case 3:
9437 switch (mcs) {
9438 case 7:
9439 vht_mcsmap = 0xffc0;
9440 break;
9441 case 8:
9442 vht_mcsmap = 0xffd5;
9443 break;
9444 case 9:
9445 vht_mcsmap = 0xffea;
9446 break;
9447 default:
9448 vht_mcsmap = 0xffea;
9449 break;
9450 }
9451 break;
9452 default:
9453 vht_mcsmap = 0xffea;
9454 break;
9455 }
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07009456 run_iwpriv(dut, intf, "vht_mcsmap 0x%04x", vht_mcsmap);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009457 }
9458 }
9459
9460 /* UNSUPPORTED: val = get_param(cmd, "Tx_lgi_rate"); */
9461
9462 val = get_param(cmd, "Vht_tkip");
9463 if (val)
9464 tkip = strcmp(val, "1") == 0 || strcasecmp(val, "Enable") == 0;
9465
9466 val = get_param(cmd, "Vht_wep");
9467 if (val)
9468 wep = strcmp(val, "1") == 0 || strcasecmp(val, "Enable") == 0;
9469
9470 if (tkip != -1 || wep != -1) {
9471 if ((tkip == 1 && wep != 0) || (wep == 1 && tkip != 0)) {
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07009472 run_iwpriv(dut, intf, "htweptkip 1");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009473 } else if ((tkip == 0 && wep != 1) || (wep == 0 && tkip != 1)) {
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07009474 run_iwpriv(dut, intf, "htweptkip 0");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009475 } else {
Jouni Malinen224e3902021-06-09 16:41:27 +03009476 send_resp(dut, conn, SIGMA_ERROR,
9477 "ErrorCode,mixed mode of VHT TKIP/WEP not supported");
9478 return STATUS_SENT_ERROR;
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009479 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009480 }
9481
Kiran Kumar Lokere09dbcef2021-08-09 00:01:41 -07009482 val = get_param(cmd, "TWTSchedSTASupport");
9483 if (val) {
9484 int set_val;
9485
9486 switch (get_driver_type(dut)) {
9487 case DRIVER_WCN:
9488 if (strcasecmp(val, "Enable") == 0) {
9489 set_val = 1;
9490 } else if (strcasecmp(val, "Disable") == 0) {
9491 set_val = 0;
9492 } else {
9493 send_resp(dut, conn, SIGMA_ERROR,
9494 "ErrorCode,Invalid TWTSchedSTASupport");
9495 return STATUS_SENT_ERROR;
9496 }
9497
9498 if (sta_set_bcast_twt_support(dut, intf, set_val)) {
9499 send_resp(dut, conn, SIGMA_ERROR,
9500 "ErrorCode,Failed to set TWTSchedSTASupport");
9501 return STATUS_SENT_ERROR;
9502 }
9503 break;
9504 default:
9505 sigma_dut_print(dut, DUT_MSG_ERROR,
9506 "Setting TWTSchedSTASupport not supported");
9507 break;
9508 }
9509 }
9510
9511 val = get_param(cmd, "MBSSID_RxCtrl");
9512 if (val) {
9513 int set_val;
9514
9515 switch (get_driver_type(dut)) {
9516 case DRIVER_WCN:
9517 if (strcasecmp(val, "Enable") == 0) {
9518 set_val = 1;
9519 } else if (strcasecmp(val, "Disable") == 0) {
9520 set_val = 0;
9521 } else {
9522 send_resp(dut, conn, SIGMA_ERROR,
9523 "ErrorCode,Invalid MBSSID_RxCtrl");
9524 return STATUS_SENT_ERROR;
9525 }
9526
9527 if (sta_set_rx_ctrl_multi_bss(dut, intf, set_val)) {
9528 send_resp(dut, conn, SIGMA_ERROR,
9529 "ErrorCode,Failed to set MBSSID_RxCtrl");
9530 return STATUS_SENT_ERROR;
9531 }
9532 break;
9533 default:
9534 sigma_dut_print(dut, DUT_MSG_ERROR,
9535 "Setting MBSSID_RxCtrl not supported");
9536 break;
9537 }
9538 }
9539
Arif Hussain55f00da2018-07-03 08:28:26 -07009540 val = get_param(cmd, "txBandwidth");
9541 if (val) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +02009542 switch (get_driver_type(dut)) {
Arif Hussain55f00da2018-07-03 08:28:26 -07009543 case DRIVER_WCN:
9544 if (wcn_sta_set_width(dut, intf, val) < 0) {
9545 send_resp(dut, conn, SIGMA_ERROR,
9546 "ErrorCode,Failed to set txBandwidth");
Jouni Malinen224e3902021-06-09 16:41:27 +03009547 return STATUS_SENT_ERROR;
Arif Hussain55f00da2018-07-03 08:28:26 -07009548 }
9549 break;
9550 case DRIVER_ATHEROS:
9551 if (ath_set_width(dut, conn, intf, val) < 0) {
9552 send_resp(dut, conn, SIGMA_ERROR,
9553 "ErrorCode,Failed to set txBandwidth");
Jouni Malinen224e3902021-06-09 16:41:27 +03009554 return STATUS_SENT_ERROR;
Arif Hussain55f00da2018-07-03 08:28:26 -07009555 }
9556 break;
9557 default:
9558 sigma_dut_print(dut, DUT_MSG_ERROR,
9559 "Setting txBandwidth not supported");
9560 break;
9561 }
9562 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009563
Arif Hussain9765f7d2018-07-03 08:28:26 -07009564 val = get_param(cmd, "BeamformeeSTS");
9565 if (val) {
Kiran Kumar Lokerebc89d432018-07-10 12:20:13 -07009566 if (sta_set_tx_beamformee(dut, intf, 1)) {
9567 send_resp(dut, conn, SIGMA_ERROR,
9568 "ErrorCode,Failed to set TX beamformee enable");
Jouni Malinen224e3902021-06-09 16:41:27 +03009569 return STATUS_SENT_ERROR;
Kiran Kumar Lokerebc89d432018-07-10 12:20:13 -07009570 }
9571
Arif Hussain9765f7d2018-07-03 08:28:26 -07009572 if (sta_set_beamformee_sts(dut, intf, atoi(val))) {
9573 send_resp(dut, conn, SIGMA_ERROR,
9574 "ErrorCode,Failed to set BeamformeeSTS");
Jouni Malinen224e3902021-06-09 16:41:27 +03009575 return STATUS_SENT_ERROR;
Arif Hussain9765f7d2018-07-03 08:28:26 -07009576 }
9577 }
9578
Arif Hussain68d23f52018-07-11 13:39:08 -07009579 val = get_param(cmd, "Trig_MAC_Padding_Dur");
9580 if (val) {
Kiran Kumar Lokere55eb5582018-08-19 20:03:26 -07009581#ifdef NL80211_SUPPORT
9582 enum qca_wlan_he_mac_padding_dur set_val;
9583
9584 switch (atoi(val)) {
9585 case 16:
9586 set_val = QCA_WLAN_HE_16US_OF_PROCESS_TIME;
9587 break;
9588 case 8:
9589 set_val = QCA_WLAN_HE_8US_OF_PROCESS_TIME;
9590 break;
9591 default:
9592 set_val = QCA_WLAN_HE_NO_ADDITIONAL_PROCESS_TIME;
9593 break;
9594 }
9595 if (sta_set_mac_padding_duration(dut, intf, set_val)) {
Arif Hussain68d23f52018-07-11 13:39:08 -07009596 send_resp(dut, conn, SIGMA_ERROR,
9597 "ErrorCode,Failed to set MAC padding duration");
Jouni Malinen224e3902021-06-09 16:41:27 +03009598 return STATUS_SENT_ERROR;
Arif Hussain68d23f52018-07-11 13:39:08 -07009599 }
Kiran Kumar Lokere55eb5582018-08-19 20:03:26 -07009600#else /* NL80211_SUPPORT */
9601 sigma_dut_print(dut, DUT_MSG_ERROR,
9602 "MAC padding duration cannot be changed without NL80211_SUPPORT defined");
9603#endif /* NL80211_SUPPORT */
Arif Hussain68d23f52018-07-11 13:39:08 -07009604 }
9605
Arif Hussain480d5f42019-03-12 14:40:42 -07009606 val = get_param(cmd, "TWT_ReqSupport");
9607 if (val) {
9608 int set_val;
9609
9610 if (strcasecmp(val, "Enable") == 0) {
9611 set_val = 1;
9612 } else if (strcasecmp(val, "Disable") == 0) {
9613 set_val = 0;
9614 } else {
9615 send_resp(dut, conn, SIGMA_ERROR,
9616 "ErrorCode,Invalid TWT_ReqSupport");
Jouni Malinen224e3902021-06-09 16:41:27 +03009617 return STATUS_SENT_ERROR;
Arif Hussain480d5f42019-03-12 14:40:42 -07009618 }
9619
9620 if (sta_set_twt_req_support(dut, intf, set_val)) {
9621 sigma_dut_print(dut, DUT_MSG_ERROR,
9622 "Failed to set TWT req support %d",
9623 set_val);
9624 send_resp(dut, conn, SIGMA_ERROR,
9625 "ErrorCode,Failed to set TWT_ReqSupport");
Jouni Malinen224e3902021-06-09 16:41:27 +03009626 return STATUS_SENT_ERROR;
Arif Hussain480d5f42019-03-12 14:40:42 -07009627 }
9628 }
9629
Kiran Kumar Lokered0ec5ed2021-04-01 00:15:04 -07009630 val = get_param(cmd, "PreamblePunctRx");
9631 if (val && get_driver_type(dut) == DRIVER_WCN) {
9632 int set_val;
9633
9634 if (strcasecmp(val, "Enable") == 0) {
9635 set_val = 1;
9636 } else if (strcasecmp(val, "Disable") == 0) {
9637 set_val = 0;
9638 } else {
9639 send_resp(dut, conn, SIGMA_ERROR,
9640 "ErrorCode,Invalid PreamblePunctRx");
9641 return STATUS_SENT_ERROR;
9642 }
9643
9644 if (sta_set_punctured_preamble_rx(dut, intf, set_val)) {
9645 sigma_dut_print(dut, DUT_MSG_ERROR,
9646 "Failed to set PreamblePunctRx support %d",
9647 set_val);
9648 send_resp(dut, conn, SIGMA_ERROR,
9649 "ErrorCode,Failed to set PreamblePunctRx");
9650 return STATUS_SENT_ERROR;
9651 }
9652 }
9653
Srinivas Girigowda0525e292020-11-12 13:28:21 -08009654 val = get_param(cmd, "FullBW_ULMUMIMO");
9655 if (val) {
9656 int set_val;
9657
9658 if (strcasecmp(val, "Enable") == 0) {
9659 set_val = 1;
9660 } else if (strcasecmp(val, "Disable") == 0) {
9661 set_val = 0;
9662 } else {
9663 send_resp(dut, conn, SIGMA_ERROR,
9664 "ErrorCode,Invalid FullBW_ULMUMIMO");
9665 return STATUS_SENT_ERROR;
9666 }
9667
9668 if (sta_set_fullbw_ulmumimo(dut, intf, set_val)) {
9669 sigma_dut_print(dut, DUT_MSG_ERROR,
9670 "Failed to set FullBW_ULMUMIMO %d",
9671 set_val);
9672 send_resp(dut, conn, SIGMA_ERROR,
9673 "ErrorCode,Failed to set FullBW_ULMUMIMO");
9674 return STATUS_SENT_ERROR;
9675 }
9676 }
9677
Srinivas Girigowda6707f032020-10-26 15:24:46 -07009678 val = get_param(cmd, "TWTInfoFrameTx");
9679 if (val) {
9680 if (strcasecmp(val, "Enable") == 0) {
9681 /* No-op */
9682 } else if (strcasecmp(val, "Disable") == 0) {
9683 /* No-op */
9684 } else {
9685 send_resp(dut, conn, SIGMA_ERROR,
9686 "ErrorCode,Invalid TWTInfoFrameTx");
9687 return STATUS_SENT_ERROR;
9688 }
9689 }
9690
Kiran Kumar Lokereb1012682018-08-08 17:48:32 -07009691 val = get_param(cmd, "MU_EDCA");
9692 if (val && (strcasecmp(val, "Override") == 0)) {
9693 if (sta_set_mu_edca_override(dut, intf, 1)) {
9694 send_resp(dut, conn, SIGMA_ERROR,
9695 "ErrorCode,Failed to set MU EDCA override");
Jouni Malinen224e3902021-06-09 16:41:27 +03009696 return STATUS_SENT_ERROR;
Kiran Kumar Lokereb1012682018-08-08 17:48:32 -07009697 }
9698 }
Kiran Kumar Lokerec6581822018-08-01 16:18:34 -07009699
Kiran Kumar Lokerede33e372018-08-29 16:26:24 -07009700 val = get_param(cmd, "OMControl");
9701 if (val) {
9702 int set_val = 1;
9703
9704 if (strcasecmp(val, "Enable") == 0)
9705 set_val = 1;
9706 else if (strcasecmp(val, "Disable") == 0)
9707 set_val = 0;
9708
9709 if (sta_set_om_ctrl_supp(dut, intf, set_val)) {
9710 send_resp(dut, conn, SIGMA_ERROR,
9711 "ErrorCode,Failed to set OM ctrl supp");
Jouni Malinen224e3902021-06-09 16:41:27 +03009712 return STATUS_SENT_ERROR;
Kiran Kumar Lokerede33e372018-08-29 16:26:24 -07009713 }
9714 }
9715
Kiran Kumar Lokere4f2d4b02021-04-01 00:07:39 -07009716 val = get_param(cmd, "BSSMaxIdlePeriod");
9717 if (val && sta_set_bss_max_idle_period(dut, intf, atoi(val))) {
9718 send_resp(dut, conn, SIGMA_ERROR,
9719 "ErrorCode,Failed to set BSS max idle period");
9720 return STATUS_SENT_ERROR;
9721 }
9722
Kiran Kumar Lokere07ad92b2021-08-09 00:27:14 -07009723 val = get_param(cmd, "BSS_max_idle");
9724 if (val) {
9725 int set_val = 0;
9726
9727 if (strcasecmp(val, "Enable") == 0)
9728 set_val = 1;
9729 else if (strcasecmp(val, "Disable") == 0)
9730 set_val = 0;
9731 if (sta_set_bss_max_idle_support(dut, intf, set_val)) {
9732 send_resp(dut, conn, SIGMA_ERROR,
9733 "ErrorCode,Failed to set BSS max idle support");
9734 return STATUS_SENT_ERROR;
9735 }
9736 }
9737
Kiran Kumar Lokerec6581822018-08-01 16:18:34 -07009738 val = get_param(cmd, "ADDBAResp_BufSize");
9739 if (val) {
9740 int buf_size;
9741
9742 if (strcasecmp(val, "gt64") == 0)
9743 buf_size = 256;
9744 else
9745 buf_size = 64;
Jouni Malinen016ae6c2019-11-04 17:00:01 +02009746 if (get_driver_type(dut) == DRIVER_WCN &&
Kiran Kumar Lokerec6581822018-08-01 16:18:34 -07009747 sta_set_addba_buf_size(dut, intf, buf_size)) {
9748 send_resp(dut, conn, SIGMA_ERROR,
9749 "ErrorCode,set addbaresp_buff_size failed");
Jouni Malinen224e3902021-06-09 16:41:27 +03009750 return STATUS_SENT_ERROR;
Kiran Kumar Lokerec6581822018-08-01 16:18:34 -07009751 }
9752 }
9753
9754 val = get_param(cmd, "ADDBAReq_BufSize");
9755 if (val) {
9756 int buf_size;
9757
9758 if (strcasecmp(val, "gt64") == 0)
9759 buf_size = 256;
9760 else
9761 buf_size = 64;
Jouni Malinen016ae6c2019-11-04 17:00:01 +02009762 if (get_driver_type(dut) == DRIVER_WCN &&
Kiran Kumar Lokerec6581822018-08-01 16:18:34 -07009763 sta_set_addba_buf_size(dut, intf, buf_size)) {
9764 send_resp(dut, conn, SIGMA_ERROR,
9765 "ErrorCode,set addbareq_buff_size failed");
Jouni Malinen224e3902021-06-09 16:41:27 +03009766 return STATUS_SENT_ERROR;
Kiran Kumar Lokerec6581822018-08-01 16:18:34 -07009767 }
9768 }
9769
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009770 return cmd_sta_set_wireless_common(intf, dut, conn, cmd);
9771}
9772
9773
9774static int sta_set_wireless_60g(struct sigma_dut *dut,
9775 struct sigma_conn *conn,
9776 struct sigma_cmd *cmd)
9777{
9778 const char *dev_role = get_param(cmd, "DevRole");
9779
9780 if (!dev_role) {
9781 send_resp(dut, conn, SIGMA_INVALID,
9782 "ErrorCode,DevRole not specified");
9783 return 0;
9784 }
9785
9786 if (strcasecmp(dev_role, "PCP") == 0)
9787 return sta_set_60g_pcp(dut, conn, cmd);
9788 if (strcasecmp(dev_role, "STA") == 0)
9789 return sta_set_60g_sta(dut, conn, cmd);
9790 send_resp(dut, conn, SIGMA_INVALID,
9791 "ErrorCode,DevRole not supported");
9792 return 0;
9793}
9794
9795
Ankita Bajaj0d5825b2017-10-25 16:20:17 +05309796static int sta_set_wireless_oce(struct sigma_dut *dut, struct sigma_conn *conn,
9797 struct sigma_cmd *cmd)
9798{
9799 int status;
9800 const char *intf = get_param(cmd, "Interface");
9801 const char *val = get_param(cmd, "DevRole");
9802
9803 if (val && strcasecmp(val, "STA-CFON") == 0) {
9804 status = sta_cfon_set_wireless(dut, conn, cmd);
9805 if (status)
9806 return status;
9807 }
9808 return cmd_sta_set_wireless_common(intf, dut, conn, cmd);
9809}
9810
9811
Jouni Malinen67433fc2020-06-26 22:50:33 +03009812static enum sigma_cmd_result
9813sta_set_wireless_wpa3(struct sigma_dut *dut, struct sigma_conn *conn,
9814 struct sigma_cmd *cmd)
Vamsi Krishnac1633d22020-05-06 18:31:21 +05309815{
9816 const char *intf = get_param(cmd, "Interface");
9817 const char *val;
9818
9819 val = get_param(cmd, "ocvc");
9820 if (val)
9821 dut->ocvc = atoi(val);
9822
Jouni Malinen67433fc2020-06-26 22:50:33 +03009823 val = get_param(cmd, "ClientPrivacy");
Veerendranath Jakkam47867202020-12-21 01:53:52 +05309824 if (val && dut->client_privacy != atoi(val) &&
9825 sta_set_client_privacy(dut, conn, intf, atoi(val))) {
9826 send_resp(dut, conn, SIGMA_ERROR,
9827 "errorCode,Failed to configure random MAC address use");
9828 return STATUS_SENT_ERROR;
Jouni Malinen67433fc2020-06-26 22:50:33 +03009829 }
9830
Vamsi Krishnac1633d22020-05-06 18:31:21 +05309831 return cmd_sta_set_wireless_common(intf, dut, conn, cmd);
9832}
9833
9834
Jouni Malinenf7222712019-06-13 01:50:21 +03009835static enum sigma_cmd_result cmd_sta_set_wireless(struct sigma_dut *dut,
9836 struct sigma_conn *conn,
9837 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009838{
9839 const char *val;
9840
9841 val = get_param(cmd, "Program");
9842 if (val) {
9843 if (strcasecmp(val, "11n") == 0)
9844 return cmd_sta_set_11n(dut, conn, cmd);
Amarnath Hullur Subramanyam4f860292018-01-31 03:49:35 -08009845 if (strcasecmp(val, "VHT") == 0 || strcasecmp(val, "HE") == 0)
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009846 return cmd_sta_set_wireless_vht(dut, conn, cmd);
9847 if (strcasecmp(val, "60ghz") == 0)
9848 return sta_set_wireless_60g(dut, conn, cmd);
Ankita Bajaj0d5825b2017-10-25 16:20:17 +05309849 if (strcasecmp(val, "OCE") == 0)
9850 return sta_set_wireless_oce(dut, conn, cmd);
Alexei Avshalom Lazar66bb9972018-12-18 16:01:43 +02009851 /* sta_set_wireless in WPS program is only used for 60G */
9852 if (is_60g_sigma_dut(dut))
9853 return sta_set_wireless_60g(dut, conn, cmd);
Vamsi Krishnac1633d22020-05-06 18:31:21 +05309854 if (strcasecmp(val, "WPA3") == 0)
9855 return sta_set_wireless_wpa3(dut, conn, cmd);
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009856 send_resp(dut, conn, SIGMA_ERROR,
9857 "ErrorCode,Program value not supported");
9858 } else {
9859 send_resp(dut, conn, SIGMA_ERROR,
9860 "ErrorCode,Program argument not available");
9861 }
9862
9863 return 0;
9864}
9865
9866
9867static void ath_sta_inject_frame(struct sigma_dut *dut, const char *intf,
9868 int tid)
9869{
9870 char buf[100];
9871 int tid_to_dscp [] = { 0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xc0, 0xe0 };
9872
Pradeep Reddy POTTETId31d1322016-10-13 17:22:03 +05309873 if (tid < 0 ||
9874 tid >= (int) (sizeof(tid_to_dscp) / sizeof(tid_to_dscp[0]))) {
9875 sigma_dut_print(dut, DUT_MSG_ERROR, "Unsupported TID: %d", tid);
9876 return;
9877 }
9878
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009879 /*
9880 * Two ways to ensure that addba request with a
9881 * non zero TID could be sent out. EV 117296
9882 */
9883 snprintf(buf, sizeof(buf),
9884 "ping -c 8 -Q %d `arp -a | grep wlan0 | awk '{print $2}' | tr -d '()'`",
9885 tid);
9886 if (system(buf) != 0) {
9887 sigma_dut_print(dut, DUT_MSG_ERROR,
9888 "Ping did not send out");
9889 }
9890
9891 snprintf(buf, sizeof(buf),
9892 "iwconfig %s | grep Access | awk '{print $6}' > %s",
9893 intf, VI_QOS_TMP_FILE);
9894 if (system(buf) != 0)
9895 return;
9896
9897 snprintf(buf, sizeof(buf),
9898 "ifconfig %s | grep HWaddr | cut -b 39-56 >> %s",
9899 intf, VI_QOS_TMP_FILE);
9900 if (system(buf) != 0)
9901 sigma_dut_print(dut, DUT_MSG_ERROR, "HWaddr matching failed");
9902
9903 snprintf(buf,sizeof(buf), "sed -n '3,$p' %s >> %s",
9904 VI_QOS_REFFILE, VI_QOS_TMP_FILE);
9905 if (system(buf) != 0) {
9906 sigma_dut_print(dut, DUT_MSG_ERROR,
9907 "VI_QOS_TEMP_FILE generation error failed");
9908 }
9909 snprintf(buf, sizeof(buf), "sed '5 c %x' %s > %s",
9910 tid_to_dscp[tid], VI_QOS_TMP_FILE, VI_QOS_FILE);
9911 if (system(buf) != 0) {
9912 sigma_dut_print(dut, DUT_MSG_ERROR,
9913 "VI_QOS_FILE generation failed");
9914 }
9915
9916 snprintf(buf, sizeof(buf), "sed '5 c %x' %s > %s",
9917 tid_to_dscp[tid], VI_QOS_TMP_FILE, VI_QOS_FILE);
9918 if (system(buf) != 0) {
9919 sigma_dut_print(dut, DUT_MSG_ERROR,
9920 "VI_QOS_FILE generation failed");
9921 }
9922
9923 snprintf(buf, sizeof(buf), "ethinject %s %s", intf, VI_QOS_FILE);
9924 if (system(buf) != 0) {
9925 }
9926}
9927
9928
9929static int ath_sta_send_addba(struct sigma_dut *dut, struct sigma_conn *conn,
9930 struct sigma_cmd *cmd)
9931{
9932 const char *intf = get_param(cmd, "Interface");
9933 const char *val;
9934 int tid = 0;
9935 char buf[100];
9936
9937 val = get_param(cmd, "TID");
9938 if (val) {
9939 tid = atoi(val);
9940 if (tid)
9941 ath_sta_inject_frame(dut, intf, tid);
9942 }
9943
9944 /* Command sequence for ADDBA request on Peregrine based devices */
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -07009945 run_iwpriv(dut, intf, "setaddbaoper 1");
Jouni Malinencd4e3c32015-10-29 12:39:56 +02009946
9947 snprintf(buf, sizeof(buf), "wifitool %s senddelba 1 %d 1 4", intf, tid);
9948 if (system(buf) != 0) {
9949 sigma_dut_print(dut, DUT_MSG_ERROR,
9950 "wifitool senddelba failed");
9951 }
9952
9953 snprintf(buf, sizeof(buf), "wifitool %s sendaddba 1 %d 64", intf, tid);
9954 if (system(buf) != 0) {
9955 sigma_dut_print(dut, DUT_MSG_ERROR,
9956 "wifitool sendaddba failed");
9957 }
9958
9959 /* UNSUPPORTED: val = get_param(cmd, "Dest_mac"); */
9960
9961 return 1;
9962}
9963
9964
Lior David9981b512017-01-20 13:16:40 +02009965#ifdef __linux__
9966
9967static int wil6210_send_addba(struct sigma_dut *dut, const char *dest_mac,
9968 int agg_size)
9969{
9970 char dir[128], buf[128];
9971 FILE *f;
9972 regex_t re;
9973 regmatch_t m[2];
Jouni Malinen3aa72862019-05-29 23:14:51 +03009974 int rc, ret = -1, vring_id, found, res;
Lior David9981b512017-01-20 13:16:40 +02009975
9976 if (wil6210_get_debugfs_dir(dut, dir, sizeof(dir))) {
9977 sigma_dut_print(dut, DUT_MSG_ERROR,
9978 "failed to get wil6210 debugfs dir");
9979 return -1;
9980 }
9981
Jouni Malinen3aa72862019-05-29 23:14:51 +03009982 res = snprintf(buf, sizeof(buf), "%s/vrings", dir);
9983 if (res < 0 || res >= sizeof(buf))
9984 return -1;
Lior David9981b512017-01-20 13:16:40 +02009985 f = fopen(buf, "r");
9986 if (!f) {
9987 sigma_dut_print(dut, DUT_MSG_ERROR, "failed to open: %s", buf);
Alexei Avshalom Lazar2af1d252018-11-13 14:10:13 +02009988 /* newer wil6210 driver renamed file to "rings" */
Jouni Malinen3aa72862019-05-29 23:14:51 +03009989 res = snprintf(buf, sizeof(buf), "%s/rings", dir);
9990 if (res < 0 || res >= sizeof(buf))
9991 return -1;
Alexei Avshalom Lazar2af1d252018-11-13 14:10:13 +02009992 f = fopen(buf, "r");
9993 if (!f) {
9994 sigma_dut_print(dut, DUT_MSG_ERROR,
9995 "failed to open: %s", buf);
9996 return -1;
9997 }
Lior David9981b512017-01-20 13:16:40 +02009998 }
9999
Alexei Avshalom Lazar2af1d252018-11-13 14:10:13 +020010000 /* can be either VRING tx... or RING... */
10001 if (regcomp(&re, "RING tx_[ \t]*([0-9]+)", REG_EXTENDED)) {
Lior David9981b512017-01-20 13:16:40 +020010002 sigma_dut_print(dut, DUT_MSG_ERROR, "regcomp failed");
10003 goto out;
10004 }
10005
10006 /* find TX VRING for the mac address */
10007 found = 0;
10008 while (fgets(buf, sizeof(buf), f)) {
10009 if (strcasestr(buf, dest_mac)) {
10010 found = 1;
10011 break;
10012 }
10013 }
10014
10015 if (!found) {
10016 sigma_dut_print(dut, DUT_MSG_ERROR,
10017 "no TX VRING for %s", dest_mac);
10018 goto out;
10019 }
10020
10021 /* extract VRING ID, "VRING tx_<id> = {" */
10022 if (!fgets(buf, sizeof(buf), f)) {
10023 sigma_dut_print(dut, DUT_MSG_ERROR,
10024 "no VRING start line for %s", dest_mac);
10025 goto out;
10026 }
10027
10028 rc = regexec(&re, buf, 2, m, 0);
10029 regfree(&re);
10030 if (rc || m[1].rm_so < 0) {
10031 sigma_dut_print(dut, DUT_MSG_ERROR,
10032 "no VRING TX ID for %s", dest_mac);
10033 goto out;
10034 }
10035 buf[m[1].rm_eo] = 0;
10036 vring_id = atoi(&buf[m[1].rm_so]);
10037
10038 /* send the addba command */
10039 fclose(f);
Jouni Malinen3aa72862019-05-29 23:14:51 +030010040 res = snprintf(buf, sizeof(buf), "%s/back", dir);
10041 if (res < 0 || res >= sizeof(buf))
10042 return -1;
Lior David9981b512017-01-20 13:16:40 +020010043 f = fopen(buf, "w");
10044 if (!f) {
10045 sigma_dut_print(dut, DUT_MSG_ERROR,
10046 "failed to open: %s", buf);
10047 return -1;
10048 }
10049
10050 fprintf(f, "add %d %d\n", vring_id, agg_size);
10051
10052 ret = 0;
10053
10054out:
10055 fclose(f);
10056
10057 return ret;
10058}
10059
10060
Alexei Avshalom Lazar79fa3fe2018-12-24 15:43:33 +020010061int send_addba_60g(struct sigma_dut *dut, struct sigma_conn *conn,
10062 struct sigma_cmd *cmd, const char *mac_param)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010063{
10064 const char *val;
10065 int tid = 0;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010066
10067 val = get_param(cmd, "TID");
10068 if (val) {
10069 tid = atoi(val);
10070 if (tid != 0) {
10071 sigma_dut_print(dut, DUT_MSG_ERROR,
10072 "Ignore TID %d for send_addba use TID 0 for 60g since only 0 required on TX",
10073 tid);
10074 }
10075 }
10076
Alexei Avshalom Lazar79fa3fe2018-12-24 15:43:33 +020010077 val = get_param(cmd, mac_param);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010078 if (!val) {
10079 sigma_dut_print(dut, DUT_MSG_ERROR,
10080 "Currently not supporting addba for 60G without Dest_mac");
Jouni Malinen0e29cf22019-02-19 01:13:21 +020010081 return ERROR_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010082 }
10083
Lior David9981b512017-01-20 13:16:40 +020010084 if (wil6210_send_addba(dut, val, dut->back_rcv_buf))
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010085 return -1;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010086
10087 return 1;
10088}
10089
Lior David9981b512017-01-20 13:16:40 +020010090#endif /* __linux__ */
10091
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010092
Amarnath Hullur Subramanyama72c0162018-02-27 14:49:09 -080010093static int wcn_sta_send_addba(struct sigma_dut *dut, struct sigma_conn *conn,
10094 struct sigma_cmd *cmd)
10095{
10096#ifdef NL80211_SUPPORT
10097 const char *intf = get_param(cmd, "Interface");
10098 const char *val;
10099 int tid = -1;
10100 int bufsize = 64;
10101 struct nl_msg *msg;
10102 int ret = 0;
10103 struct nlattr *params;
10104 int ifindex;
10105
10106 val = get_param(cmd, "TID");
10107 if (val)
10108 tid = atoi(val);
10109
10110 if (tid == -1) {
10111 send_resp(dut, conn, SIGMA_ERROR,
10112 "ErrorCode,sta_send_addba tid invalid");
10113 return 0;
10114 }
10115
10116 /* UNSUPPORTED: val = get_param(cmd, "Dest_mac"); */
10117
10118 ifindex = if_nametoindex(intf);
10119 if (ifindex == 0) {
10120 sigma_dut_print(dut, DUT_MSG_ERROR,
10121 "%s: Index for interface %s failed",
10122 __func__, intf);
10123 send_resp(dut, conn, SIGMA_ERROR,
10124 "ErrorCode,sta_send_addba interface invalid");
10125 return 0;
10126 }
10127
10128 if (!(msg = nl80211_drv_msg(dut, dut->nl_ctx, ifindex, 0,
10129 NL80211_CMD_VENDOR)) ||
10130 nla_put_u32(msg, NL80211_ATTR_IFINDEX, ifindex) ||
10131 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
10132 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
10133 QCA_NL80211_VENDOR_SUBCMD_WIFI_TEST_CONFIGURATION) ||
10134 !(params = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA)) ||
10135 nla_put_u8(msg,
10136 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_ADD_DEL_BA_SESSION,
10137 QCA_WLAN_ADD_BA) ||
10138 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_BA_TID,
10139 tid) ||
Kiran Kumar Lokere26e27582018-08-01 16:18:34 -070010140 nla_put_u16(msg,
10141 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_ADDBA_BUFF_SIZE,
10142 bufsize)) {
Amarnath Hullur Subramanyama72c0162018-02-27 14:49:09 -080010143 sigma_dut_print(dut, DUT_MSG_ERROR,
10144 "%s: err in adding vendor_cmd and vendor_data",
10145 __func__);
10146 nlmsg_free(msg);
10147 send_resp(dut, conn, SIGMA_ERROR,
10148 "ErrorCode,sta_send_addba err in adding vendor_cmd and vendor_data");
10149 return 0;
10150 }
10151 nla_nest_end(msg, params);
10152
10153 ret = send_and_recv_msgs(dut, dut->nl_ctx, msg, NULL, NULL);
10154 if (ret) {
10155 sigma_dut_print(dut, DUT_MSG_ERROR,
10156 "%s: err in send_and_recv_msgs, ret=%d",
10157 __func__, ret);
Sunil Dutt30605592018-05-04 20:35:50 +053010158 if (ret == -EOPNOTSUPP)
10159 return 1;
Amarnath Hullur Subramanyama72c0162018-02-27 14:49:09 -080010160 send_resp(dut, conn, SIGMA_ERROR,
10161 "ErrorCode,sta_send_addba err in send_and_recv_msgs");
10162 return 0;
10163 }
Amarnath Hullur Subramanyama72c0162018-02-27 14:49:09 -080010164#else /* NL80211_SUPPORT */
10165 sigma_dut_print(dut, DUT_MSG_ERROR,
10166 "sta_send_addba not supported without NL80211_SUPPORT defined");
Amarnath Hullur Subramanyama72c0162018-02-27 14:49:09 -080010167#endif /* NL80211_SUPPORT */
Sunil Dutt30605592018-05-04 20:35:50 +053010168
10169 return 1;
Amarnath Hullur Subramanyama72c0162018-02-27 14:49:09 -080010170}
10171
10172
Jouni Malinenf7222712019-06-13 01:50:21 +030010173static enum sigma_cmd_result cmd_sta_send_addba(struct sigma_dut *dut,
10174 struct sigma_conn *conn,
10175 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010176{
Jouni Malinen016ae6c2019-11-04 17:00:01 +020010177 switch (get_driver_type(dut)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010178 case DRIVER_ATHEROS:
10179 return ath_sta_send_addba(dut, conn, cmd);
Amarnath Hullur Subramanyama72c0162018-02-27 14:49:09 -080010180 case DRIVER_WCN:
10181 return wcn_sta_send_addba(dut, conn, cmd);
Lior David9981b512017-01-20 13:16:40 +020010182#ifdef __linux__
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010183 case DRIVER_WIL6210:
Alexei Avshalom Lazar79fa3fe2018-12-24 15:43:33 +020010184 return send_addba_60g(dut, conn, cmd, "Dest_mac");
Lior David9981b512017-01-20 13:16:40 +020010185#endif /* __linux__ */
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010186 default:
10187 /*
10188 * There is no driver specific implementation for other drivers.
10189 * Ignore the command and report COMPLETE since the following
10190 * throughput test operation will end up sending ADDBA anyway.
10191 */
10192 return 1;
10193 }
10194}
10195
10196
10197int inject_eth_frame(int s, const void *data, size_t len,
10198 unsigned short ethtype, char *dst, char *src)
10199{
10200 struct iovec iov[4] = {
10201 {
10202 .iov_base = dst,
10203 .iov_len = ETH_ALEN,
10204 },
10205 {
10206 .iov_base = src,
10207 .iov_len = ETH_ALEN,
10208 },
10209 {
10210 .iov_base = &ethtype,
10211 .iov_len = sizeof(unsigned short),
10212 },
10213 {
10214 .iov_base = (void *) data,
10215 .iov_len = len,
10216 }
10217 };
10218 struct msghdr msg = {
10219 .msg_name = NULL,
10220 .msg_namelen = 0,
10221 .msg_iov = iov,
10222 .msg_iovlen = 4,
10223 .msg_control = NULL,
10224 .msg_controllen = 0,
10225 .msg_flags = 0,
10226 };
10227
10228 return sendmsg(s, &msg, 0);
10229}
10230
10231#if defined(__linux__) || defined(__QNXNTO__)
10232
10233int inject_frame(int s, const void *data, size_t len, int encrypt)
10234{
10235#define IEEE80211_RADIOTAP_F_WEP 0x04
10236#define IEEE80211_RADIOTAP_F_FRAG 0x08
10237 unsigned char rtap_hdr[] = {
10238 0x00, 0x00, /* radiotap version */
10239 0x0e, 0x00, /* radiotap length */
10240 0x02, 0xc0, 0x00, 0x00, /* bmap: flags, tx and rx flags */
10241 IEEE80211_RADIOTAP_F_FRAG, /* F_FRAG (fragment if required) */
10242 0x00, /* padding */
10243 0x00, 0x00, /* RX and TX flags to indicate that */
10244 0x00, 0x00, /* this is the injected frame directly */
10245 };
10246 struct iovec iov[2] = {
10247 {
10248 .iov_base = &rtap_hdr,
10249 .iov_len = sizeof(rtap_hdr),
10250 },
10251 {
10252 .iov_base = (void *) data,
10253 .iov_len = len,
10254 }
10255 };
10256 struct msghdr msg = {
10257 .msg_name = NULL,
10258 .msg_namelen = 0,
10259 .msg_iov = iov,
10260 .msg_iovlen = 2,
10261 .msg_control = NULL,
10262 .msg_controllen = 0,
10263 .msg_flags = 0,
10264 };
10265
10266 if (encrypt)
10267 rtap_hdr[8] |= IEEE80211_RADIOTAP_F_WEP;
10268
10269 return sendmsg(s, &msg, 0);
10270}
10271
10272
10273int open_monitor(const char *ifname)
10274{
10275#ifdef __QNXNTO__
10276 struct sockaddr_dl ll;
10277 int s;
10278
10279 memset(&ll, 0, sizeof(ll));
10280 ll.sdl_family = AF_LINK;
10281 ll.sdl_index = if_nametoindex(ifname);
10282 if (ll.sdl_index == 0) {
10283 perror("if_nametoindex");
10284 return -1;
10285 }
10286 s = socket(PF_INET, SOCK_RAW, 0);
10287#else /* __QNXNTO__ */
10288 struct sockaddr_ll ll;
10289 int s;
10290
10291 memset(&ll, 0, sizeof(ll));
10292 ll.sll_family = AF_PACKET;
10293 ll.sll_ifindex = if_nametoindex(ifname);
10294 if (ll.sll_ifindex == 0) {
10295 perror("if_nametoindex");
10296 return -1;
10297 }
10298 s = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
10299#endif /* __QNXNTO__ */
10300 if (s < 0) {
10301 perror("socket[PF_PACKET,SOCK_RAW]");
10302 return -1;
10303 }
10304
10305 if (bind(s, (struct sockaddr *) &ll, sizeof(ll)) < 0) {
10306 perror("monitor socket bind");
10307 close(s);
10308 return -1;
10309 }
10310
10311 return s;
10312}
10313
10314
10315static int hex2num(char c)
10316{
10317 if (c >= '0' && c <= '9')
10318 return c - '0';
10319 if (c >= 'a' && c <= 'f')
10320 return c - 'a' + 10;
10321 if (c >= 'A' && c <= 'F')
10322 return c - 'A' + 10;
10323 return -1;
10324}
10325
10326
10327int hwaddr_aton(const char *txt, unsigned char *addr)
10328{
10329 int i;
10330
10331 for (i = 0; i < 6; i++) {
10332 int a, b;
10333
10334 a = hex2num(*txt++);
10335 if (a < 0)
10336 return -1;
10337 b = hex2num(*txt++);
10338 if (b < 0)
10339 return -1;
10340 *addr++ = (a << 4) | b;
10341 if (i < 5 && *txt++ != ':')
10342 return -1;
10343 }
10344
10345 return 0;
10346}
10347
10348#endif /* defined(__linux__) || defined(__QNXNTO__) */
10349
Veerendranath Jakkam49774122020-07-05 09:52:18 +053010350
10351#ifdef NL80211_SUPPORT
10352static int nl80211_send_frame_cmd(struct sigma_dut *dut, const char *intf,
10353 const u8 *data, size_t data_len, int freq)
10354{
10355 struct nl_msg *msg;
10356 int ret = 0;
10357 int ifindex;
10358
10359 ifindex = if_nametoindex(intf);
10360 if (ifindex == 0) {
10361 sigma_dut_print(dut, DUT_MSG_ERROR,
10362 "%s: Index for interface %s failed",
10363 __func__, intf);
10364 return -1;
10365 }
10366
10367 if (!(msg = nl80211_drv_msg(dut, dut->nl_ctx, ifindex, 0,
10368 NL80211_CMD_FRAME)) ||
10369 (freq && nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq)) ||
10370 nla_put(msg, NL80211_ATTR_FRAME, data_len, data)) {
10371 sigma_dut_print(dut, DUT_MSG_ERROR,
10372 "%s: Error in adding NL80211_CMD_FRAME",
10373 __func__);
10374 nlmsg_free(msg);
10375 return -1;
10376 }
10377
10378 ret = send_and_recv_msgs(dut, dut->nl_ctx, msg, NULL, NULL);
10379 if (ret) {
10380 sigma_dut_print(dut, DUT_MSG_ERROR,
10381 "nl80211: Frame command failed: ret=%d (%s) req=%u",
10382 ret, strerror(-ret), freq);
10383 return -1;
10384 }
10385
10386 return 0;
10387}
10388#endif /* NL80211_SUPPORT */
10389
10390
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010391enum send_frame_type {
10392 DISASSOC, DEAUTH, SAQUERY, AUTH, ASSOCREQ, REASSOCREQ, DLS_REQ
10393};
10394enum send_frame_protection {
10395 CORRECT_KEY, INCORRECT_KEY, UNPROTECTED
10396};
10397
10398
10399static int sta_inject_frame(struct sigma_dut *dut, struct sigma_conn *conn,
Veerendranath Jakkam49774122020-07-05 09:52:18 +053010400 const char *intf, enum send_frame_type frame,
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010401 enum send_frame_protection protected,
Veerendranath Jakkam49774122020-07-05 09:52:18 +053010402 const char *dest, int use_monitor)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010403{
10404#ifdef __linux__
10405 unsigned char buf[1000], *pos;
10406 int s, res;
10407 char bssid[20], addr[20];
10408 char result[32], ssid[100];
10409 size_t ssid_len;
10410
Jouni Malinen016ae6c2019-11-04 17:00:01 +020010411 if (get_wpa_status(get_station_ifname(dut), "wpa_state", result,
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010412 sizeof(result)) < 0 ||
10413 strncmp(result, "COMPLETED", 9) != 0) {
10414 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Not connected");
10415 return 0;
10416 }
10417
Jouni Malinen016ae6c2019-11-04 17:00:01 +020010418 if (get_wpa_status(get_station_ifname(dut), "bssid",
10419 bssid, sizeof(bssid)) < 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010420 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Could not get "
10421 "current BSSID");
10422 return 0;
10423 }
10424
Jouni Malinen016ae6c2019-11-04 17:00:01 +020010425 if (get_wpa_status(get_station_ifname(dut), "address",
10426 addr, sizeof(addr)) < 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010427 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Could not get "
10428 "own MAC address");
10429 return 0;
10430 }
10431
Jouni Malinen016ae6c2019-11-04 17:00:01 +020010432 if (get_wpa_status(get_station_ifname(dut), "ssid", ssid, sizeof(ssid))
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010433 < 0) {
10434 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Could not get "
10435 "current SSID");
10436 return 0;
10437 }
10438 ssid_len = strlen(ssid);
10439
10440 pos = buf;
10441
10442 /* Frame Control */
10443 switch (frame) {
10444 case DISASSOC:
10445 *pos++ = 0xa0;
10446 break;
10447 case DEAUTH:
10448 *pos++ = 0xc0;
10449 break;
10450 case SAQUERY:
10451 *pos++ = 0xd0;
10452 break;
10453 case AUTH:
10454 *pos++ = 0xb0;
10455 break;
10456 case ASSOCREQ:
10457 *pos++ = 0x00;
10458 break;
10459 case REASSOCREQ:
10460 *pos++ = 0x20;
10461 break;
10462 case DLS_REQ:
10463 *pos++ = 0xd0;
10464 break;
10465 }
10466
10467 if (protected == INCORRECT_KEY)
10468 *pos++ = 0x40; /* Set Protected field to 1 */
10469 else
10470 *pos++ = 0x00;
10471
10472 /* Duration */
10473 *pos++ = 0x00;
10474 *pos++ = 0x00;
10475
10476 /* addr1 = DA (current AP) */
10477 hwaddr_aton(bssid, pos);
10478 pos += 6;
10479 /* addr2 = SA (own address) */
10480 hwaddr_aton(addr, pos);
10481 pos += 6;
10482 /* addr3 = BSSID (current AP) */
10483 hwaddr_aton(bssid, pos);
10484 pos += 6;
10485
10486 /* Seq# (to be filled by driver/mac80211) */
10487 *pos++ = 0x00;
10488 *pos++ = 0x00;
10489
10490 if (protected == INCORRECT_KEY) {
10491 /* CCMP parameters */
10492 memcpy(pos, "\x61\x01\x00\x20\x00\x10\x00\x00", 8);
10493 pos += 8;
10494 }
10495
10496 if (protected == INCORRECT_KEY) {
10497 switch (frame) {
10498 case DEAUTH:
10499 /* Reason code (encrypted) */
10500 memcpy(pos, "\xa7\x39", 2);
10501 pos += 2;
10502 break;
10503 case DISASSOC:
10504 /* Reason code (encrypted) */
10505 memcpy(pos, "\xa7\x39", 2);
10506 pos += 2;
10507 break;
10508 case SAQUERY:
10509 /* Category|Action|TransID (encrypted) */
10510 memcpy(pos, "\x6f\xbd\xe9\x4d", 4);
10511 pos += 4;
10512 break;
10513 default:
10514 return -1;
10515 }
10516
10517 /* CCMP MIC */
10518 memcpy(pos, "\xc8\xd8\x3b\x06\x5d\xb7\x25\x68", 8);
10519 pos += 8;
10520 } else {
10521 switch (frame) {
10522 case DEAUTH:
10523 /* reason code = 8 */
10524 *pos++ = 0x08;
10525 *pos++ = 0x00;
10526 break;
10527 case DISASSOC:
10528 /* reason code = 8 */
10529 *pos++ = 0x08;
10530 *pos++ = 0x00;
10531 break;
10532 case SAQUERY:
10533 /* Category - SA Query */
10534 *pos++ = 0x08;
10535 /* SA query Action - Request */
10536 *pos++ = 0x00;
10537 /* Transaction ID */
10538 *pos++ = 0x12;
10539 *pos++ = 0x34;
Veerendranath Jakkam54ddc352020-07-05 15:47:54 +053010540 if (dut->saquery_oci_freq) {
10541 /* OCI IE - Extended ID */
10542 *pos++ = 0xFF;
10543 *pos++ = 0x04;
10544 *pos++ = 0x36;
10545 /* Operating Class */
10546 *pos++ = 0x74;
10547 /* Primary Channel */
10548 *pos++ = freq_to_channel(dut->saquery_oci_freq);
10549 /* Frequency Segment 1 Channel Number */
10550 *pos++ = 0x00;
10551 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010552 break;
10553 case AUTH:
10554 /* Auth Alg (Open) */
10555 *pos++ = 0x00;
10556 *pos++ = 0x00;
10557 /* Seq# */
10558 *pos++ = 0x01;
10559 *pos++ = 0x00;
10560 /* Status code */
10561 *pos++ = 0x00;
10562 *pos++ = 0x00;
10563 break;
10564 case ASSOCREQ:
10565 /* Capability Information */
10566 *pos++ = 0x31;
10567 *pos++ = 0x04;
10568 /* Listen Interval */
10569 *pos++ = 0x0a;
10570 *pos++ = 0x00;
10571 /* SSID */
10572 *pos++ = 0x00;
10573 *pos++ = ssid_len;
10574 memcpy(pos, ssid, ssid_len);
10575 pos += ssid_len;
10576 /* Supported Rates */
10577 memcpy(pos, "\x01\x08\x02\x04\x0b\x16\x0c\x12\x18\x24",
10578 10);
10579 pos += 10;
10580 /* Extended Supported Rates */
10581 memcpy(pos, "\x32\x04\x30\x48\x60\x6c", 6);
10582 pos += 6;
10583 /* RSN */
10584 memcpy(pos, "\x30\x1a\x01\x00\x00\x0f\xac\x04\x01\x00"
10585 "\x00\x0f\xac\x04\x01\x00\x00\x0f\xac\x02\xc0"
10586 "\x00\x00\x00\x00\x0f\xac\x06", 28);
10587 pos += 28;
10588 break;
10589 case REASSOCREQ:
10590 /* Capability Information */
10591 *pos++ = 0x31;
10592 *pos++ = 0x04;
10593 /* Listen Interval */
10594 *pos++ = 0x0a;
10595 *pos++ = 0x00;
10596 /* Current AP */
10597 hwaddr_aton(bssid, pos);
10598 pos += 6;
10599 /* SSID */
10600 *pos++ = 0x00;
10601 *pos++ = ssid_len;
10602 memcpy(pos, ssid, ssid_len);
10603 pos += ssid_len;
10604 /* Supported Rates */
10605 memcpy(pos, "\x01\x08\x02\x04\x0b\x16\x0c\x12\x18\x24",
10606 10);
10607 pos += 10;
10608 /* Extended Supported Rates */
10609 memcpy(pos, "\x32\x04\x30\x48\x60\x6c", 6);
10610 pos += 6;
Veerendranath Jakkam54ddc352020-07-05 15:47:54 +053010611 /* RSNE - Group and Pairwise ciphers */
10612 memcpy(pos,
10613 "\x30\x1a\x01\x00\x00\x0f\xac\x04\x01\x00\x00\x0f\xac\x04",
10614 14);
10615 pos += 14;
10616 /* RSNE - AKM Suite count */
10617 *pos++ = 0x01;
10618 *pos++ = 0x00;
10619 /* RSNE - AKM Suites */
10620 if (dut->program == PROGRAM_WPA3)
10621 memcpy(pos, "\x00\x0f\xac\x08", 4);
10622 else
10623 memcpy(pos, "\x00\x0f\xac\x02", 4);
10624 pos += 4;
10625 /* RSNE - Capabilities */
10626 *pos++ = 0xc0;
10627 if (dut->ocvc)
10628 *pos++ = 0x40;
10629 else
10630 *pos++ = 0x00;
10631 /* RSNE - PMKID list and Group Management Ciphers */
10632 memcpy(pos, "\x00\x00\x00\x0f\xac\x06", 6);
10633 pos += 6;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010634 break;
10635 case DLS_REQ:
10636 /* Category - DLS */
10637 *pos++ = 0x02;
10638 /* DLS Action - Request */
10639 *pos++ = 0x00;
10640 /* Destination MACAddress */
10641 if (dest)
10642 hwaddr_aton(dest, pos);
10643 else
10644 memset(pos, 0, 6);
10645 pos += 6;
10646 /* Source MACAddress */
10647 hwaddr_aton(addr, pos);
10648 pos += 6;
10649 /* Capability Information */
10650 *pos++ = 0x10; /* Privacy */
10651 *pos++ = 0x06; /* QoS */
10652 /* DLS Timeout Value */
10653 *pos++ = 0x00;
10654 *pos++ = 0x01;
10655 /* Supported rates */
10656 *pos++ = 0x01;
10657 *pos++ = 0x08;
10658 *pos++ = 0x0c; /* 6 Mbps */
10659 *pos++ = 0x12; /* 9 Mbps */
10660 *pos++ = 0x18; /* 12 Mbps */
10661 *pos++ = 0x24; /* 18 Mbps */
10662 *pos++ = 0x30; /* 24 Mbps */
10663 *pos++ = 0x48; /* 36 Mbps */
10664 *pos++ = 0x60; /* 48 Mbps */
10665 *pos++ = 0x6c; /* 54 Mbps */
10666 /* TODO: Extended Supported Rates */
10667 /* TODO: HT Capabilities */
10668 break;
10669 }
10670 }
10671
Veerendranath Jakkam49774122020-07-05 09:52:18 +053010672 if (use_monitor) {
10673 s = open_monitor("sigmadut");
10674 if (s < 0) {
10675 send_resp(dut, conn, SIGMA_ERROR,
10676 "errorCode,Failed to open monitor socket");
10677 return 0;
10678 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010679
Veerendranath Jakkam49774122020-07-05 09:52:18 +053010680 res = inject_frame(s, buf, pos - buf, protected == CORRECT_KEY);
10681 if (res < 0) {
10682 send_resp(dut, conn, SIGMA_ERROR,
10683 "errorCode,Failed to inject frame");
10684 close(s);
10685 return 0;
10686 }
10687 if (res < pos - buf) {
10688 send_resp(dut, conn, SIGMA_ERROR,
10689 "errorCode,Only partial frame sent");
10690 close(s);
10691 return 0;
10692 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010693
Veerendranath Jakkam49774122020-07-05 09:52:18 +053010694 close(s);
10695 } else {
10696#ifdef NL80211_SUPPORT
10697 int freq;
10698 char freq_str[10];
10699
10700 if (get_wpa_status(get_station_ifname(dut), "freq",
10701 freq_str, sizeof(freq_str)) < 0) {
10702 send_resp(dut, conn, SIGMA_ERROR,
10703 "errorCode,Could not get current operating frequency");
10704 return 0;
10705 }
10706 freq = atoi(freq_str);
10707
10708 if (nl80211_send_frame_cmd(dut, intf, buf, pos - buf, freq)) {
10709 send_resp(dut, conn, SIGMA_ERROR,
10710 "errorCode,Failed to inject frame");
10711 return 0;
10712 }
10713#else /* NL80211_SUPPORT */
10714 send_resp(dut, conn, SIGMA_ERROR,
10715 "errorCode,Failed to inject frame (no NL80211_SUPPORT)");
10716 return 0;
10717#endif /* NL80211_SUPPORT */
10718 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010719
10720 return 1;
10721#else /* __linux__ */
10722 send_resp(dut, conn, SIGMA_ERROR, "errorCode,sta_send_frame not "
10723 "yet supported");
10724 return 0;
10725#endif /* __linux__ */
10726}
10727
10728
10729static int cmd_sta_send_frame_tdls(struct sigma_dut *dut,
10730 struct sigma_conn *conn,
10731 struct sigma_cmd *cmd)
10732{
10733 const char *intf = get_param(cmd, "Interface");
10734 const char *sta, *val;
10735 unsigned char addr[ETH_ALEN];
10736 char buf[100];
10737
Alexei Avshalom Lazar4a3c2f82019-05-02 13:35:37 +030010738 if (!intf)
10739 return -1;
10740
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010741 sta = get_param(cmd, "peer");
10742 if (sta == NULL)
10743 sta = get_param(cmd, "station");
10744 if (sta == NULL) {
10745 send_resp(dut, conn, SIGMA_ERROR,
10746 "ErrorCode,Missing peer address");
10747 return 0;
10748 }
10749 if (hwaddr_aton(sta, addr) < 0) {
10750 send_resp(dut, conn, SIGMA_ERROR,
10751 "ErrorCode,Invalid peer address");
10752 return 0;
10753 }
10754
10755 val = get_param(cmd, "type");
10756 if (val == NULL)
10757 return -1;
10758
10759 if (strcasecmp(val, "DISCOVERY") == 0) {
10760 snprintf(buf, sizeof(buf), "TDLS_DISCOVER %s", sta);
10761 if (wpa_command(intf, buf) < 0) {
10762 send_resp(dut, conn, SIGMA_ERROR,
10763 "ErrorCode,Failed to send TDLS discovery");
10764 return 0;
10765 }
10766 return 1;
10767 }
10768
10769 if (strcasecmp(val, "SETUP") == 0) {
10770 int status = 0, timeout = 0;
10771
10772 val = get_param(cmd, "Status");
10773 if (val)
10774 status = atoi(val);
10775
10776 val = get_param(cmd, "Timeout");
10777 if (val)
10778 timeout = atoi(val);
10779
10780 if (status != 0 && status != 37) {
10781 send_resp(dut, conn, SIGMA_ERROR,
10782 "ErrorCode,Unsupported status value");
10783 return 0;
10784 }
10785
10786 if (timeout != 0 && timeout != 301) {
10787 send_resp(dut, conn, SIGMA_ERROR,
10788 "ErrorCode,Unsupported timeout value");
10789 return 0;
10790 }
10791
10792 if (status && timeout) {
10793 send_resp(dut, conn, SIGMA_ERROR,
10794 "ErrorCode,Unsupported timeout+status "
10795 "combination");
10796 return 0;
10797 }
10798
10799 if (status == 37 &&
10800 wpa_command(intf, "SET tdls_testing 0x200")) {
10801 send_resp(dut, conn, SIGMA_ERROR,
10802 "ErrorCode,Failed to enable "
10803 "decline setup response test mode");
10804 return 0;
10805 }
10806
10807 if (timeout == 301) {
10808 int res;
10809 if (dut->no_tpk_expiration)
10810 res = wpa_command(intf,
10811 "SET tdls_testing 0x108");
10812 else
10813 res = wpa_command(intf,
10814 "SET tdls_testing 0x8");
10815 if (res) {
10816 send_resp(dut, conn, SIGMA_ERROR,
10817 "ErrorCode,Failed to set short TPK "
10818 "lifetime");
10819 return 0;
10820 }
10821 }
10822
10823 snprintf(buf, sizeof(buf), "TDLS_SETUP %s", sta);
10824 if (wpa_command(intf, buf) < 0) {
10825 send_resp(dut, conn, SIGMA_ERROR,
10826 "ErrorCode,Failed to send TDLS setup");
10827 return 0;
10828 }
10829 return 1;
10830 }
10831
10832 if (strcasecmp(val, "TEARDOWN") == 0) {
10833 snprintf(buf, sizeof(buf), "TDLS_TEARDOWN %s", sta);
10834 if (wpa_command(intf, buf) < 0) {
10835 send_resp(dut, conn, SIGMA_ERROR,
10836 "ErrorCode,Failed to send TDLS teardown");
10837 return 0;
10838 }
10839 return 1;
10840 }
10841
10842 send_resp(dut, conn, SIGMA_ERROR,
10843 "ErrorCode,Unsupported TDLS frame");
10844 return 0;
10845}
10846
10847
10848static int sta_ap_known(const char *ifname, const char *bssid)
10849{
10850 char buf[4096];
10851
Jouni Malinendd32f192018-09-15 02:55:19 +030010852 snprintf(buf, sizeof(buf), "BSS MASK=1 %s", bssid);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010853 if (wpa_command_resp(ifname, buf, buf, sizeof(buf)) < 0)
10854 return 0;
10855 if (strncmp(buf, "id=", 3) != 0)
10856 return 0;
10857 return 1;
10858}
10859
10860
10861static int sta_scan_ap(struct sigma_dut *dut, const char *ifname,
10862 const char *bssid)
10863{
10864 int res;
10865 struct wpa_ctrl *ctrl;
10866 char buf[256];
10867
10868 if (sta_ap_known(ifname, bssid))
10869 return 0;
10870 sigma_dut_print(dut, DUT_MSG_DEBUG,
10871 "AP not in BSS table - start scan");
10872
10873 ctrl = open_wpa_mon(ifname);
10874 if (ctrl == NULL) {
10875 sigma_dut_print(dut, DUT_MSG_ERROR, "Failed to open "
10876 "wpa_supplicant monitor connection");
10877 return -1;
10878 }
10879
10880 if (wpa_command(ifname, "SCAN") < 0) {
10881 sigma_dut_print(dut, DUT_MSG_INFO, "Failed to start scan");
10882 wpa_ctrl_detach(ctrl);
10883 wpa_ctrl_close(ctrl);
10884 return -1;
10885 }
10886
10887 res = get_wpa_cli_event(dut, ctrl, "CTRL-EVENT-SCAN-RESULTS",
10888 buf, sizeof(buf));
10889
10890 wpa_ctrl_detach(ctrl);
10891 wpa_ctrl_close(ctrl);
10892
10893 if (res < 0) {
10894 sigma_dut_print(dut, DUT_MSG_INFO, "Scan did not complete");
10895 return -1;
10896 }
10897
10898 if (sta_ap_known(ifname, bssid))
10899 return 0;
10900 sigma_dut_print(dut, DUT_MSG_INFO, "AP not in BSS table");
10901 return -1;
10902}
10903
10904
10905static int cmd_sta_send_frame_hs2_neighadv(struct sigma_dut *dut,
10906 struct sigma_conn *conn,
10907 struct sigma_cmd *cmd,
10908 const char *intf)
10909{
10910 char buf[200];
10911
10912 snprintf(buf, sizeof(buf), "ndsend 2001:DB8::1 %s", intf);
10913 if (system(buf) != 0) {
10914 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,Failed to run "
10915 "ndsend");
10916 return 0;
10917 }
10918
10919 return 1;
10920}
10921
10922
10923static int cmd_sta_send_frame_hs2_neighsolreq(struct sigma_dut *dut,
10924 struct sigma_conn *conn,
10925 struct sigma_cmd *cmd,
10926 const char *intf)
10927{
10928 char buf[200];
10929 const char *ip = get_param(cmd, "SenderIP");
10930
Peng Xu26b356d2017-10-04 17:58:16 -070010931 if (!ip)
10932 return 0;
10933
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010934 snprintf(buf, sizeof(buf), "ndisc6 -nm %s %s -r 4", ip, intf);
10935 sigma_dut_print(dut, DUT_MSG_DEBUG, "Run: %s", buf);
10936 if (system(buf) == 0) {
10937 sigma_dut_print(dut, DUT_MSG_INFO,
10938 "Neighbor Solicitation got a response "
10939 "for %s@%s", ip, intf);
10940 }
10941
10942 return 1;
10943}
10944
10945
10946static int cmd_sta_send_frame_hs2_arpprobe(struct sigma_dut *dut,
10947 struct sigma_conn *conn,
10948 struct sigma_cmd *cmd,
10949 const char *ifname)
10950{
10951 char buf[200];
10952 const char *ip = get_param(cmd, "SenderIP");
10953
10954 if (ip == NULL) {
10955 send_resp(dut, conn, SIGMA_ERROR,
10956 "ErrorCode,Missing SenderIP parameter");
10957 return 0;
10958 }
10959 snprintf(buf, sizeof(buf), "arping -I %s -D %s -c 4", ifname, ip);
10960 sigma_dut_print(dut, DUT_MSG_DEBUG, "Run: %s", buf);
10961 if (system(buf) != 0) {
10962 sigma_dut_print(dut, DUT_MSG_INFO, "arping DAD got a response "
10963 "for %s@%s", ip, ifname);
10964 }
10965
10966 return 1;
10967}
10968
10969
10970static int cmd_sta_send_frame_hs2_arpannounce(struct sigma_dut *dut,
10971 struct sigma_conn *conn,
10972 struct sigma_cmd *cmd,
10973 const char *ifname)
10974{
10975 char buf[200];
10976 char ip[16];
10977 int s;
Peng Xub3756882017-10-04 14:39:09 -070010978 struct ifreq ifr;
10979 struct sockaddr_in saddr;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010980
10981 s = socket(PF_INET, SOCK_DGRAM, 0);
Peng Xub3756882017-10-04 14:39:09 -070010982 if (s < 0) {
10983 perror("socket");
10984 return -1;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020010985 }
10986
Peng Xub3756882017-10-04 14:39:09 -070010987 memset(&ifr, 0, sizeof(ifr));
10988 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
10989 if (ioctl(s, SIOCGIFADDR, &ifr) < 0) {
10990 sigma_dut_print(dut, DUT_MSG_INFO,
10991 "Failed to get %s IP address: %s",
10992 ifname, strerror(errno));
10993 close(s);
10994 return -1;
10995 }
10996 close(s);
10997
10998 memcpy(&saddr, &ifr.ifr_addr, sizeof(struct sockaddr_in));
10999 strlcpy(ip, inet_ntoa(saddr.sin_addr), sizeof(ip));
11000
Jouni Malinencd4e3c32015-10-29 12:39:56 +020011001 snprintf(buf, sizeof(buf), "arping -I %s -s %s %s -c 4", ifname, ip,
11002 ip);
11003 sigma_dut_print(dut, DUT_MSG_DEBUG, "Run: %s", buf);
11004 if (system(buf) != 0) {
11005 }
11006
11007 return 1;
11008}
11009
11010
11011static int cmd_sta_send_frame_hs2_arpreply(struct sigma_dut *dut,
11012 struct sigma_conn *conn,
11013 struct sigma_cmd *cmd,
11014 const char *ifname)
11015{
11016 char buf[200], addr[20];
11017 char dst[ETH_ALEN], src[ETH_ALEN];
11018 short ethtype = htons(ETH_P_ARP);
11019 char *pos;
11020 int s, res;
11021 const char *val;
11022 struct sockaddr_in taddr;
11023
11024 val = get_param(cmd, "dest");
11025 if (val)
11026 hwaddr_aton(val, (unsigned char *) dst);
11027
11028 val = get_param(cmd, "DestIP");
11029 if (val)
11030 inet_aton(val, &taddr.sin_addr);
Peng Xu151c9e12017-10-04 14:39:09 -070011031 else
11032 return -2;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020011033
Jouni Malinen016ae6c2019-11-04 17:00:01 +020011034 if (get_wpa_status(get_station_ifname(dut), "address", addr,
Jouni Malinencd4e3c32015-10-29 12:39:56 +020011035 sizeof(addr)) < 0)
11036 return -2;
11037 hwaddr_aton(addr, (unsigned char *) src);
11038
11039 pos = buf;
11040 *pos++ = 0x00;
11041 *pos++ = 0x01;
11042 *pos++ = 0x08;
11043 *pos++ = 0x00;
11044 *pos++ = 0x06;
11045 *pos++ = 0x04;
11046 *pos++ = 0x00;
11047 *pos++ = 0x02;
11048 memcpy(pos, src, ETH_ALEN);
11049 pos += ETH_ALEN;
11050 memcpy(pos, &taddr.sin_addr, 4);
11051 pos += 4;
11052 memcpy(pos, dst, ETH_ALEN);
11053 pos += ETH_ALEN;
11054 memcpy(pos, &taddr.sin_addr, 4);
11055 pos += 4;
11056
Jouni Malinen016ae6c2019-11-04 17:00:01 +020011057 s = open_monitor(get_station_ifname(dut));
Jouni Malinencd4e3c32015-10-29 12:39:56 +020011058 if (s < 0) {
11059 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Failed to open "
11060 "monitor socket");
11061 return 0;
11062 }
11063
11064 res = inject_eth_frame(s, buf, pos - buf, ethtype, dst, src);
11065 if (res < 0) {
11066 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Failed to "
11067 "inject frame");
Pradeep Reddy POTTETI673d85c2016-07-26 19:08:07 +053011068 close(s);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020011069 return 0;
11070 }
11071
11072 close(s);
11073
11074 return 1;
11075}
11076
11077
11078static int cmd_sta_send_frame_hs2_dls_req(struct sigma_dut *dut,
11079 struct sigma_conn *conn,
11080 struct sigma_cmd *cmd,
11081 const char *intf, const char *dest)
11082{
11083 char buf[100];
11084
11085 if (if_nametoindex("sigmadut") == 0) {
11086 snprintf(buf, sizeof(buf),
11087 "iw dev %s interface add sigmadut type monitor",
Jouni Malinen016ae6c2019-11-04 17:00:01 +020011088 get_station_ifname(dut));
Jouni Malinencd4e3c32015-10-29 12:39:56 +020011089 if (system(buf) != 0 ||
11090 if_nametoindex("sigmadut") == 0) {
11091 sigma_dut_print(dut, DUT_MSG_ERROR, "Failed to add "
11092 "monitor interface with '%s'", buf);
11093 return -2;
11094 }
11095 }
11096
11097 if (system("ifconfig sigmadut up") != 0) {
11098 sigma_dut_print(dut, DUT_MSG_ERROR, "Failed to set "
11099 "monitor interface up");
11100 return -2;
11101 }
11102
Veerendranath Jakkam49774122020-07-05 09:52:18 +053011103 return sta_inject_frame(dut, conn, intf, DLS_REQ, UNPROTECTED, dest, 1);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020011104}
11105
11106
11107static int cmd_sta_send_frame_hs2(struct sigma_dut *dut,
11108 struct sigma_conn *conn,
11109 struct sigma_cmd *cmd)
11110{
11111 const char *intf = get_param(cmd, "Interface");
11112 const char *dest = get_param(cmd, "Dest");
11113 const char *type = get_param(cmd, "FrameName");
11114 const char *val;
11115 char buf[200], *pos, *end;
11116 int count, count2;
11117
11118 if (type == NULL)
11119 type = get_param(cmd, "Type");
11120
11121 if (intf == NULL || dest == NULL || type == NULL)
11122 return -1;
11123
11124 if (strcasecmp(type, "NeighAdv") == 0)
11125 return cmd_sta_send_frame_hs2_neighadv(dut, conn, cmd, intf);
11126
11127 if (strcasecmp(type, "NeighSolicitReq") == 0)
11128 return cmd_sta_send_frame_hs2_neighsolreq(dut, conn, cmd, intf);
11129
11130 if (strcasecmp(type, "ARPProbe") == 0)
11131 return cmd_sta_send_frame_hs2_arpprobe(dut, conn, cmd, intf);
11132
11133 if (strcasecmp(type, "ARPAnnounce") == 0)
11134 return cmd_sta_send_frame_hs2_arpannounce(dut, conn, cmd, intf);
11135
11136 if (strcasecmp(type, "ARPReply") == 0)
11137 return cmd_sta_send_frame_hs2_arpreply(dut, conn, cmd, intf);
11138
11139 if (strcasecmp(type, "DLS-request") == 0 ||
11140 strcasecmp(type, "DLSrequest") == 0)
11141 return cmd_sta_send_frame_hs2_dls_req(dut, conn, cmd, intf,
11142 dest);
11143
11144 if (strcasecmp(type, "ANQPQuery") != 0 &&
11145 strcasecmp(type, "Query") != 0) {
11146 send_resp(dut, conn, SIGMA_ERROR,
11147 "ErrorCode,Unsupported HS 2.0 send frame type");
11148 return 0;
11149 }
11150
11151 if (sta_scan_ap(dut, intf, dest) < 0) {
11152 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,Could not find "
11153 "the requested AP");
11154 return 0;
11155 }
11156
11157 pos = buf;
11158 end = buf + sizeof(buf);
11159 count = 0;
11160 pos += snprintf(pos, end - pos, "ANQP_GET %s ", dest);
11161
11162 val = get_param(cmd, "ANQP_CAP_LIST");
11163 if (val && atoi(val)) {
11164 pos += snprintf(pos, end - pos, "%s257", count > 0 ? "," : "");
11165 count++;
11166 }
11167
11168 val = get_param(cmd, "VENUE_NAME");
11169 if (val && atoi(val)) {
11170 pos += snprintf(pos, end - pos, "%s258", count > 0 ? "," : "");
11171 count++;
11172 }
11173
11174 val = get_param(cmd, "NETWORK_AUTH_TYPE");
11175 if (val && atoi(val)) {
11176 pos += snprintf(pos, end - pos, "%s260", count > 0 ? "," : "");
11177 count++;
11178 }
11179
11180 val = get_param(cmd, "ROAMING_CONS");
11181 if (val && atoi(val)) {
11182 pos += snprintf(pos, end - pos, "%s261", count > 0 ? "," : "");
11183 count++;
11184 }
11185
11186 val = get_param(cmd, "IP_ADDR_TYPE_AVAILABILITY");
11187 if (val && atoi(val)) {
11188 pos += snprintf(pos, end - pos, "%s262", count > 0 ? "," : "");
11189 count++;
11190 }
11191
11192 val = get_param(cmd, "NAI_REALM_LIST");
11193 if (val && atoi(val)) {
11194 pos += snprintf(pos, end - pos, "%s263", count > 0 ? "," : "");
11195 count++;
11196 }
11197
11198 val = get_param(cmd, "3GPP_INFO");
11199 if (val && atoi(val)) {
11200 pos += snprintf(pos, end - pos, "%s264", count > 0 ? "," : "");
11201 count++;
11202 }
11203
11204 val = get_param(cmd, "DOMAIN_LIST");
11205 if (val && atoi(val)) {
11206 pos += snprintf(pos, end - pos, "%s268", count > 0 ? "," : "");
11207 count++;
11208 }
11209
Jouni Malinen34cf9532018-04-29 19:26:33 +030011210 val = get_param(cmd, "Venue_URL");
11211 if (val && atoi(val)) {
11212 pos += snprintf(pos, end - pos, "%s277", count > 0 ? "," : "");
11213 count++;
11214 }
11215
Jouni Malinend3bca5d2018-04-29 17:25:23 +030011216 val = get_param(cmd, "Advice_Of_Charge");
11217 if (val && atoi(val)) {
11218 pos += snprintf(pos, end - pos, "%s278", count > 0 ? "," : "");
11219 count++;
11220 }
11221
Jouni Malinencd4e3c32015-10-29 12:39:56 +020011222 if (count && wpa_command(intf, buf)) {
11223 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,ANQP_GET failed");
11224 return 0;
11225 }
11226
11227 pos = buf;
11228 end = buf + sizeof(buf);
11229 count2 = 0;
11230 pos += snprintf(pos, end - pos, "HS20_ANQP_GET %s ", dest);
11231
11232 val = get_param(cmd, "HS_CAP_LIST");
11233 if (val && atoi(val)) {
11234 pos += snprintf(pos, end - pos, "%s2", count2 > 0 ? "," : "");
11235 count2++;
11236 }
11237
11238 val = get_param(cmd, "OPER_NAME");
11239 if (val && atoi(val)) {
11240 pos += snprintf(pos, end - pos, "%s3", count2 > 0 ? "," : "");
11241 count2++;
11242 }
11243
11244 val = get_param(cmd, "WAN_METRICS");
11245 if (!val)
11246 val = get_param(cmd, "WAN_MAT");
11247 if (!val)
11248 val = get_param(cmd, "WAN_MET");
11249 if (val && atoi(val)) {
11250 pos += snprintf(pos, end - pos, "%s4", count2 > 0 ? "," : "");
11251 count2++;
11252 }
11253
11254 val = get_param(cmd, "CONNECTION_CAPABILITY");
11255 if (val && atoi(val)) {
11256 pos += snprintf(pos, end - pos, "%s5", count2 > 0 ? "," : "");
11257 count2++;
11258 }
11259
11260 val = get_param(cmd, "OP_CLASS");
11261 if (val && atoi(val)) {
11262 pos += snprintf(pos, end - pos, "%s7", count2 > 0 ? "," : "");
11263 count2++;
11264 }
11265
11266 val = get_param(cmd, "OSU_PROVIDER_LIST");
11267 if (val && atoi(val)) {
11268 pos += snprintf(pos, end - pos, "%s8", count2 > 0 ? "," : "");
11269 count2++;
11270 }
11271
Jouni Malinenf67afec2018-04-29 19:24:58 +030011272 val = get_param(cmd, "OPER_ICON_METADATA");
11273 if (!val)
11274 val = get_param(cmd, "OPERATOR_ICON_METADATA");
11275 if (val && atoi(val)) {
11276 pos += snprintf(pos, end - pos, "%s12", count2 > 0 ? "," : "");
11277 count2++;
11278 }
11279
Jouni Malinencd4e3c32015-10-29 12:39:56 +020011280 if (count && count2) {
11281 sigma_dut_print(dut, DUT_MSG_DEBUG, "Wait before sending out "
11282 "second query");
11283 sleep(1);
11284 }
11285
11286 if (count2 && wpa_command(intf, buf)) {
11287 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,HS20_ANQP_GET "
11288 "failed");
11289 return 0;
11290 }
11291
11292 val = get_param(cmd, "NAI_HOME_REALM_LIST");
11293 if (val) {
11294 if (count || count2) {
11295 sigma_dut_print(dut, DUT_MSG_DEBUG, "Wait before "
11296 "sending out second query");
11297 sleep(1);
11298 }
11299
11300 if (strcmp(val, "1") == 0)
11301 val = "mail.example.com";
11302 snprintf(buf, end - pos,
11303 "HS20_GET_NAI_HOME_REALM_LIST %s realm=%s",
11304 dest, val);
11305 if (wpa_command(intf, buf)) {
11306 send_resp(dut, conn, SIGMA_ERROR,
11307 "ErrorCode,HS20_GET_NAI_HOME_REALM_LIST "
11308 "failed");
11309 return 0;
11310 }
11311 }
11312
11313 val = get_param(cmd, "ICON_REQUEST");
11314 if (val) {
11315 if (count || count2) {
11316 sigma_dut_print(dut, DUT_MSG_DEBUG, "Wait before "
11317 "sending out second query");
11318 sleep(1);
11319 }
11320
11321 snprintf(buf, end - pos,
11322 "HS20_ICON_REQUEST %s %s", dest, val);
11323 if (wpa_command(intf, buf)) {
11324 send_resp(dut, conn, SIGMA_ERROR,
11325 "ErrorCode,HS20_ICON_REQUEST failed");
11326 return 0;
11327 }
11328 }
11329
11330 return 1;
11331}
11332
11333
11334static int ath_sta_send_frame_vht(struct sigma_dut *dut,
11335 struct sigma_conn *conn,
11336 struct sigma_cmd *cmd)
11337{
11338 const char *val;
Jouni Malinen016ae6c2019-11-04 17:00:01 +020011339 const char *ifname;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020011340 int chwidth, nss;
11341
11342 val = get_param(cmd, "framename");
11343 if (!val)
11344 return -1;
11345 sigma_dut_print(dut, DUT_MSG_DEBUG, "framename is %s", val);
11346
11347 /* Command sequence to generate Op mode notification */
11348 if (val && strcasecmp(val, "Op_md_notif_frm") == 0) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +020011349 ifname = get_station_ifname(dut);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020011350
11351 /* Disable STBC */
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -070011352 run_iwpriv(dut, ifname, "tx_stbc 0");
Jouni Malinencd4e3c32015-10-29 12:39:56 +020011353
11354 /* Extract Channel width */
11355 val = get_param(cmd, "Channel_width");
11356 if (val) {
11357 switch (atoi(val)) {
11358 case 20:
11359 chwidth = 0;
11360 break;
11361 case 40:
11362 chwidth = 1;
11363 break;
11364 case 80:
11365 chwidth = 2;
11366 break;
11367 case 160:
11368 chwidth = 3;
11369 break;
11370 default:
11371 chwidth = 2;
11372 break;
11373 }
11374
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -070011375 run_iwpriv(dut, ifname, "chwidth %d", chwidth);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020011376 }
11377
11378 /* Extract NSS */
11379 val = get_param(cmd, "NSS");
11380 if (val) {
11381 switch (atoi(val)) {
11382 case 1:
11383 nss = 1;
11384 break;
11385 case 2:
11386 nss = 3;
11387 break;
11388 case 3:
11389 nss = 7;
11390 break;
11391 default:
11392 /* We do not support NSS > 3 */
11393 nss = 3;
11394 break;
11395 }
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -070011396 run_iwpriv(dut, ifname, "rxchainmask %d", nss);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020011397 }
11398
11399 /* Opmode notify */
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -070011400 run_iwpriv(dut, ifname, "opmode_notify 1");
Jouni Malinencd4e3c32015-10-29 12:39:56 +020011401 }
11402
11403 return 1;
11404}
11405
11406
Kiran Kumar Lokere00d74412020-07-23 13:26:51 -070011407static int wcn_sta_set_pmf_config(struct sigma_dut *dut, const char *intf,
11408 enum send_frame_protection protected)
11409{
11410#ifdef NL80211_SUPPORT
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +053011411 return wcn_wifi_test_config_set_u8(
11412 dut, intf, QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_PMF_PROTECTION,
11413 protected);
Kiran Kumar Lokere00d74412020-07-23 13:26:51 -070011414#else /* NL80211_SUPPORT */
11415 sigma_dut_print(dut, DUT_MSG_ERROR,
11416 "PMF config cannot be set without NL80211_SUPPORT defined");
11417 return -1;
11418#endif /* NL80211_SUPPORT */
11419}
11420
11421
Jouni Malinencd4e3c32015-10-29 12:39:56 +020011422static int cmd_sta_send_frame_vht(struct sigma_dut *dut,
11423 struct sigma_conn *conn,
11424 struct sigma_cmd *cmd)
11425{
Jouni Malinen016ae6c2019-11-04 17:00:01 +020011426 switch (get_driver_type(dut)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +020011427 case DRIVER_ATHEROS:
11428 return ath_sta_send_frame_vht(dut, conn, cmd);
11429 default:
11430 send_resp(dut, conn, SIGMA_ERROR,
11431 "errorCode,Unsupported sta_set_frame(VHT) with the current driver");
11432 return 0;
11433 }
11434}
11435
11436
Kiran Kumar Lokerec2c3b412020-07-23 13:51:27 -070011437static int wcn_sta_send_disassoc(struct sigma_dut *dut, const char *intf)
11438{
11439#ifdef NL80211_SUPPORT
Veerendranath Jakkam050b85a2020-07-04 04:00:32 +053011440 return wcn_wifi_test_config_set_flag(
11441 dut, intf, QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_DISASSOC_TX);
Kiran Kumar Lokerec2c3b412020-07-23 13:51:27 -070011442#else /* NL80211_SUPPORT */
11443 sigma_dut_print(dut, DUT_MSG_ERROR,
11444 "Disassoc Tx cannot be done without NL80211_SUPPORT defined");
11445 return -1;
11446#endif /* NL80211_SUPPORT */
11447}
11448
11449
Kiran Kumar Lokere419f6962018-10-24 19:03:04 -070011450static int wcn_sta_send_frame_he(struct sigma_dut *dut, struct sigma_conn *conn,
11451 struct sigma_cmd *cmd)
11452{
11453 const char *val;
11454 const char *intf = get_param(cmd, "Interface");
Kiran Kumar Lokere00d74412020-07-23 13:26:51 -070011455 enum send_frame_protection protected;
11456 const char *pmf;
Kiran Kumar Lokere419f6962018-10-24 19:03:04 -070011457
Alexei Avshalom Lazar4a3c2f82019-05-02 13:35:37 +030011458 if (!intf)
11459 return -1;
11460
Kiran Kumar Lokere419f6962018-10-24 19:03:04 -070011461 val = get_param(cmd, "framename");
11462 if (!val)
11463 return -1;
11464 sigma_dut_print(dut, DUT_MSG_DEBUG, "framename is %s", val);
11465
Kiran Kumar Lokere00d74412020-07-23 13:26:51 -070011466 pmf = get_param(cmd, "PMFProtected");
11467 if (!pmf)
11468 pmf = get_param(cmd, "Protected");
11469 if (pmf) {
11470 if (strcasecmp(pmf, "Correct-key") == 0 ||
11471 strcasecmp(pmf, "CorrectKey") == 0) {
11472 protected = CORRECT_KEY;
11473 } else if (strcasecmp(pmf, "IncorrectKey") == 0) {
11474 protected = INCORRECT_KEY;
11475 } else if (strcasecmp(pmf, "Unprotected") == 0) {
11476 protected = UNPROTECTED;
11477 } else {
11478 send_resp(dut, conn, SIGMA_ERROR,
11479 "errorCode,Unsupported PMFProtected");
11480 return STATUS_SENT_ERROR;
11481 }
11482 sigma_dut_print(dut, DUT_MSG_DEBUG, "Config PMF protection %d",
11483 protected);
11484 wcn_sta_set_pmf_config(dut, intf, protected);
11485 }
11486
Kiran Kumar Lokere419f6962018-10-24 19:03:04 -070011487 /* Command sequence to generate Op mode notification */
11488 if (val && strcasecmp(val, "action") == 0) {
11489 val = get_param(cmd, "PPDUTxType");
11490 if (val && strcasecmp(val, "TB") == 0) {
11491 if (sta_set_action_tx_in_he_tb_ppdu(dut, intf, 1)) {
11492 sigma_dut_print(dut, DUT_MSG_ERROR,
11493 "failed to send TB PPDU Tx cfg");
11494 send_resp(dut, conn, SIGMA_ERROR,
11495 "ErrorCode,set TB PPDU Tx cfg failed");
11496 return 0;
11497 }
11498 return 1;
11499 }
11500
11501 sigma_dut_print(dut, DUT_MSG_ERROR,
11502 "Action Tx type is not defined");
Kiran Kumar Lokerec2c3b412020-07-23 13:51:27 -070011503
11504 return SUCCESS_SEND_STATUS;
Kiran Kumar Lokere419f6962018-10-24 19:03:04 -070011505 }
11506
Kiran Kumar Lokerec2c3b412020-07-23 13:51:27 -070011507 if (strcasecmp(val, "disassoc") == 0)
11508 wcn_sta_send_disassoc(dut, intf);
11509
Kiran Kumar Lokere419f6962018-10-24 19:03:04 -070011510 return 1;
11511}
11512
11513
11514static int cmd_sta_send_frame_he(struct sigma_dut *dut,
11515 struct sigma_conn *conn,
11516 struct sigma_cmd *cmd)
11517{
Jouni Malinen016ae6c2019-11-04 17:00:01 +020011518 switch (get_driver_type(dut)) {
Kiran Kumar Lokere419f6962018-10-24 19:03:04 -070011519 case DRIVER_WCN:
11520 return wcn_sta_send_frame_he(dut, conn, cmd);
11521 default:
11522 send_resp(dut, conn, SIGMA_ERROR,
11523 "errorCode,Unsupported sta_set_frame(HE) with the current driver");
11524 return 0;
11525 }
11526}
11527
11528
Lior David0fe101e2017-03-09 16:09:50 +020011529#ifdef __linux__
Alexei Avshalom Lazara90032d2019-05-02 13:34:02 +030011530
11531static int
11532wil6210_send_p2p_frame_60g(struct sigma_dut *dut, struct sigma_cmd *cmd,
11533 const char *frame_name, const char *dest_mac)
11534{
11535 int isprobereq = strcasecmp(frame_name, "probereq") == 0;
11536 const char *ssid = get_param(cmd, "ssid");
11537 const char *countstr = get_param(cmd, "count");
11538 const char *channelstr = get_param(cmd, "channel");
11539 const char *group_id = get_param(cmd, "groupid");
11540 const char *client_id = get_param(cmd, "clientmac");
11541 int count, channel, freq, i;
11542 const char *fname;
11543 char frame[1024], src_mac[20], group_id_attr[25],
11544 device_macstr[3 * ETH_ALEN], client_mac[ETH_ALEN];
11545 const char *group_ssid;
11546 const int group_ssid_prefix_len = 9;
11547 struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *) frame;
11548 size_t framelen = sizeof(frame);
11549 struct template_frame_tag tags[2];
11550 size_t tags_total = ARRAY_SIZE(tags);
11551 int tag_index, len, dst_len;
11552
11553 if (!countstr || !channelstr) {
11554 sigma_dut_print(dut, DUT_MSG_ERROR,
11555 "Missing argument: count, channel");
11556 return -1;
11557 }
11558 if (isprobereq && !ssid) {
11559 sigma_dut_print(dut, DUT_MSG_ERROR,
11560 "Missing argument: ssid");
11561 return -1;
11562 }
11563 if (!isprobereq && (!group_id || !client_id)) {
11564 sigma_dut_print(dut, DUT_MSG_ERROR,
11565 "Missing argument: group_id, client_id");
11566 return -1;
11567 }
11568
11569 count = atoi(countstr);
11570 channel = atoi(channelstr);
11571 freq = channel_to_freq(dut, channel);
11572
11573 if (!freq) {
11574 sigma_dut_print(dut, DUT_MSG_ERROR,
11575 "invalid channel: %s", channelstr);
11576 return -1;
11577 }
11578
11579 if (isprobereq) {
11580 if (strcasecmp(ssid, "wildcard") == 0) {
11581 fname = "probe_req_wildcard.txt";
11582 } else if (strcasecmp(ssid, "P2P_Wildcard") == 0) {
11583 fname = "probe_req_P2P_Wildcard.txt";
11584 } else {
11585 sigma_dut_print(dut, DUT_MSG_ERROR,
11586 "invalid probe request type");
11587 return -1;
11588 }
11589 } else {
11590 fname = "P2P_device_discovery_req.txt";
11591 }
11592
11593 if (parse_template_frame_file(dut, fname, frame, &framelen,
11594 tags, &tags_total)) {
11595 sigma_dut_print(dut, DUT_MSG_ERROR,
11596 "invalid frame template: %s", fname);
11597 return -1;
11598 }
11599
Jouni Malinen016ae6c2019-11-04 17:00:01 +020011600 if (get_wpa_status(get_station_ifname(dut), "address",
Alexei Avshalom Lazara90032d2019-05-02 13:34:02 +030011601 src_mac, sizeof(src_mac)) < 0 ||
11602 parse_mac_address(dut, src_mac, &hdr->addr2[0]) ||
11603 parse_mac_address(dut, dest_mac, &hdr->addr1[0]))
11604 return -1;
11605 /* Use wildcard BSSID, since we are in PBSS */
11606 memset(&hdr->addr3, 0xFF, ETH_ALEN);
11607
11608 if (!isprobereq) {
11609 tag_index = find_template_frame_tag(tags, tags_total, 1);
11610 if (tag_index < 0) {
11611 sigma_dut_print(dut, DUT_MSG_ERROR,
11612 "can't find device id attribute");
11613 return -1;
11614 }
11615 if (parse_mac_address(dut, client_id,
11616 (unsigned char *) client_mac)) {
11617 sigma_dut_print(dut, DUT_MSG_ERROR,
11618 "invalid client_id: %s", client_id);
11619 return -1;
11620 }
11621 if (replace_p2p_attribute(dut, &frame[tags[tag_index].offset],
11622 framelen - tags[tag_index].offset,
11623 IEEE80211_P2P_ATTR_DEVICE_ID,
11624 client_mac, ETH_ALEN)) {
11625 sigma_dut_print(dut, DUT_MSG_ERROR,
11626 "fail to replace device id attribute");
11627 return -1;
11628 }
11629
11630 /*
11631 * group_id arg contains device MAC address followed by
11632 * space and SSID (DIRECT-somessid).
11633 * group id attribute contains device address (6 bytes)
11634 * followed by SSID prefix DIRECT-XX (9 bytes)
11635 */
11636 if (strlen(group_id) < sizeof(device_macstr)) {
11637 sigma_dut_print(dut, DUT_MSG_ERROR,
11638 "group_id arg too short");
11639 return -1;
11640 }
11641 memcpy(device_macstr, group_id, sizeof(device_macstr));
11642 device_macstr[sizeof(device_macstr) - 1] = '\0';
11643 if (parse_mac_address(dut, device_macstr,
11644 (unsigned char *) group_id_attr)) {
11645 sigma_dut_print(dut, DUT_MSG_ERROR,
11646 "fail to parse device address from group_id");
11647 return -1;
11648 }
11649 group_ssid = strchr(group_id, ' ');
11650 if (!group_ssid) {
11651 sigma_dut_print(dut, DUT_MSG_ERROR,
11652 "invalid group_id arg, no ssid");
11653 return -1;
11654 }
11655 group_ssid++;
11656 len = strlen(group_ssid);
11657 if (len < group_ssid_prefix_len) {
11658 sigma_dut_print(dut, DUT_MSG_ERROR,
11659 "group_id SSID too short");
11660 return -1;
11661 }
11662 dst_len = sizeof(group_id_attr) - ETH_ALEN;
11663 if (len > dst_len) {
11664 sigma_dut_print(dut, DUT_MSG_ERROR,
11665 "group_id SSID (%s) too long",
11666 group_ssid);
11667 return -1;
11668 }
11669
11670 memcpy(group_id_attr + ETH_ALEN, group_ssid, len);
11671 tag_index = find_template_frame_tag(tags, tags_total, 2);
11672 if (tag_index < 0) {
11673 sigma_dut_print(dut, DUT_MSG_ERROR,
11674 "can't find group id attribute");
11675 return -1;
11676 }
11677 if (replace_p2p_attribute(dut, &frame[tags[tag_index].offset],
11678 framelen - tags[tag_index].offset,
11679 IEEE80211_P2P_ATTR_GROUP_ID,
11680 group_id_attr,
11681 sizeof(group_id_attr))) {
11682 sigma_dut_print(dut, DUT_MSG_ERROR,
11683 "fail to replace group id attribute");
11684 return -1;
11685 }
11686 }
11687
11688 for (i = 0; i < count; i++) {
11689 if (wil6210_transmit_frame(dut, freq,
11690 WIL_TRANSMIT_FRAME_DEFAULT_ROC,
11691 frame, framelen)) {
11692 sigma_dut_print(dut, DUT_MSG_ERROR,
11693 "fail to transmit probe request frame");
11694 return -1;
11695 }
11696 }
11697
11698 return 0;
11699}
11700
11701
Lior David0fe101e2017-03-09 16:09:50 +020011702int wil6210_send_frame_60g(struct sigma_dut *dut, struct sigma_conn *conn,
11703 struct sigma_cmd *cmd)
11704{
11705 const char *frame_name = get_param(cmd, "framename");
11706 const char *mac = get_param(cmd, "dest_mac");
11707
11708 if (!frame_name || !mac) {
11709 sigma_dut_print(dut, DUT_MSG_ERROR,
11710 "framename and dest_mac must be provided");
11711 return -1;
11712 }
11713
11714 if (strcasecmp(frame_name, "brp") == 0) {
11715 const char *l_rx = get_param(cmd, "L-RX");
11716 int l_rx_i;
11717
11718 if (!l_rx) {
11719 sigma_dut_print(dut, DUT_MSG_ERROR,
11720 "L-RX must be provided");
11721 return -1;
11722 }
11723 l_rx_i = atoi(l_rx);
11724
11725 sigma_dut_print(dut, DUT_MSG_INFO,
11726 "dev_send_frame: BRP-RX, dest_mac %s, L-RX %s",
11727 mac, l_rx);
11728 if (l_rx_i != 16) {
11729 sigma_dut_print(dut, DUT_MSG_ERROR,
11730 "unsupported L-RX: %s", l_rx);
11731 return -1;
11732 }
11733
11734 if (wil6210_send_brp_rx(dut, mac, l_rx_i))
11735 return -1;
11736 } else if (strcasecmp(frame_name, "ssw") == 0) {
11737 sigma_dut_print(dut, DUT_MSG_INFO,
11738 "dev_send_frame: SLS, dest_mac %s", mac);
11739 if (wil6210_send_sls(dut, mac))
11740 return -1;
Alexei Avshalom Lazara90032d2019-05-02 13:34:02 +030011741 } else if ((strcasecmp(frame_name, "probereq") == 0) ||
11742 (strcasecmp(frame_name, "devdiscreq") == 0)) {
11743 sigma_dut_print(dut, DUT_MSG_INFO,
11744 "dev_send_frame: %s, dest_mac %s", frame_name,
11745 mac);
11746 if (wil6210_send_p2p_frame_60g(dut, cmd, frame_name, mac))
11747 return -1;
Lior David0fe101e2017-03-09 16:09:50 +020011748 } else {
11749 sigma_dut_print(dut, DUT_MSG_ERROR,
11750 "unsupported frame type: %s", frame_name);
11751 return -1;
11752 }
11753
11754 return 1;
11755}
Alexei Avshalom Lazara90032d2019-05-02 13:34:02 +030011756
Lior David0fe101e2017-03-09 16:09:50 +020011757#endif /* __linux__ */
11758
11759
11760static int cmd_sta_send_frame_60g(struct sigma_dut *dut,
11761 struct sigma_conn *conn,
11762 struct sigma_cmd *cmd)
11763{
Jouni Malinen016ae6c2019-11-04 17:00:01 +020011764 switch (get_driver_type(dut)) {
Lior David0fe101e2017-03-09 16:09:50 +020011765#ifdef __linux__
11766 case DRIVER_WIL6210:
11767 return wil6210_send_frame_60g(dut, conn, cmd);
11768#endif /* __linux__ */
11769 default:
11770 send_resp(dut, conn, SIGMA_ERROR,
11771 "errorCode,Unsupported sta_set_frame(60G) with the current driver");
11772 return 0;
11773 }
11774}
11775
11776
Ashwini Patildb59b3c2017-04-13 15:19:23 +053011777static int mbo_send_anqp_query(struct sigma_dut *dut, struct sigma_conn *conn,
11778 const char *intf, struct sigma_cmd *cmd)
11779{
11780 const char *val, *addr;
11781 char buf[100];
11782
11783 addr = get_param(cmd, "DestMac");
11784 if (!addr) {
11785 send_resp(dut, conn, SIGMA_INVALID,
11786 "ErrorCode,AP MAC address is missing");
11787 return 0;
11788 }
11789
11790 val = get_param(cmd, "ANQPQuery_ID");
11791 if (!val) {
11792 send_resp(dut, conn, SIGMA_INVALID,
11793 "ErrorCode,Missing ANQPQuery_ID");
11794 return 0;
11795 }
11796
11797 if (strcasecmp(val, "NeighborReportReq") == 0) {
11798 snprintf(buf, sizeof(buf), "ANQP_GET %s 272", addr);
11799 } else if (strcasecmp(val, "QueryListWithCellPref") == 0) {
11800 snprintf(buf, sizeof(buf), "ANQP_GET %s 272,mbo:2", addr);
11801 } else {
11802 sigma_dut_print(dut, DUT_MSG_ERROR, "Invalid ANQPQuery_ID: %s",
11803 val);
11804 send_resp(dut, conn, SIGMA_INVALID,
11805 "ErrorCode,Invalid ANQPQuery_ID");
11806 return 0;
11807 }
11808
Ashwini Patild174f2c2017-04-13 16:49:46 +053011809 /* Set gas_address3 field to IEEE 802.11-2012 standard compliant form
11810 * (Address3 = Wildcard BSSID when sent to not-associated AP;
11811 * if associated, AP BSSID).
11812 */
11813 if (wpa_command(intf, "SET gas_address3 1") < 0) {
11814 send_resp(dut, conn, SIGMA_ERROR,
11815 "ErrorCode,Failed to set gas_address3");
11816 return 0;
11817 }
11818
Ashwini Patildb59b3c2017-04-13 15:19:23 +053011819 if (wpa_command(intf, buf) < 0) {
11820 send_resp(dut, conn, SIGMA_ERROR,
11821 "ErrorCode,Failed to send ANQP query");
11822 return 0;
11823 }
11824
11825 return 1;
11826}
11827
11828
11829static int mbo_cmd_sta_send_frame(struct sigma_dut *dut,
11830 struct sigma_conn *conn,
11831 const char *intf,
11832 struct sigma_cmd *cmd)
11833{
11834 const char *val = get_param(cmd, "FrameName");
11835
11836 if (val && strcasecmp(val, "ANQPQuery") == 0)
11837 return mbo_send_anqp_query(dut, conn, intf, cmd);
11838
11839 return 2;
11840}
11841
11842
Veerendranath Jakkam54ddc352020-07-05 15:47:54 +053011843static enum sigma_cmd_result cmd_sta_send_frame_wpa3(struct sigma_dut *dut,
11844 struct sigma_conn *conn,
11845 const char *intf,
11846 struct sigma_cmd *cmd)
11847{
11848 const char *val = get_param(cmd, "framename");
11849
11850 if (!val)
11851 return INVALID_SEND_STATUS;
11852
11853 if (strcasecmp(val, "SAQueryReq") == 0) {
11854 val = get_param(cmd, "OCIChannel");
11855
11856 if (!val) {
11857 send_resp(dut, conn, SIGMA_ERROR,
11858 "errorCode,OCIChannel not present");
11859 return STATUS_SENT_ERROR;
11860 }
11861
11862 dut->saquery_oci_freq = channel_to_freq(dut, atoi(val));
11863 if (!dut->saquery_oci_freq) {
11864 send_resp(dut, conn, SIGMA_ERROR,
11865 "errorCode,Invalid OCIChannel number");
11866 return STATUS_SENT_ERROR;
11867 }
11868
11869 return sta_inject_frame(dut, conn, intf, SAQUERY, CORRECT_KEY,
11870 NULL, 0);
11871 }
11872
11873 if (strcasecmp(val, "reassocreq") == 0)
11874 return sta_inject_frame(dut, conn, intf, REASSOCREQ,
11875 CORRECT_KEY, NULL, 0);
11876
Veerendranath9f81dfb2020-08-10 01:21:29 -070011877 if (strcasecmp(val, "ANQPQuery") == 0) {
11878 char buf[50];
11879 const char *dest = get_param(cmd, "DestMac");
11880 const char *chan = get_param(cmd, "channel");
Veerendranath Jakkam78862fc2020-11-19 21:23:27 +053011881 const char *freq_str = get_param(cmd, "ChnlFreq");
Veerendranath9f81dfb2020-08-10 01:21:29 -070011882 int len, freq;
11883
Veerendranath Jakkam78862fc2020-11-19 21:23:27 +053011884 if (freq_str)
11885 freq = atoi(freq_str);
11886 else
11887 freq = chan ? channel_to_freq(dut, atoi(chan)) : 0;
11888
Veerendranath9f81dfb2020-08-10 01:21:29 -070011889 if (!dest || !freq)
11890 return INVALID_SEND_STATUS;
11891
11892 len = snprintf(buf, sizeof(buf), "ANQP_GET %s freq=%d 257",
11893 dest, freq);
11894 if (len < 0 || len >= sizeof(buf)) {
11895 sigma_dut_print(dut, DUT_MSG_ERROR,
11896 "Failed to allocate buf");
11897 return ERROR_SEND_STATUS;
11898 }
11899
11900 if (wpa_command(intf, buf) != 0) {
11901 send_resp(dut, conn, SIGMA_ERROR,
11902 "ErrorCode,Failed to send ANQP Query frame");
11903 return STATUS_SENT_ERROR;
11904 }
11905
11906 sigma_dut_print(dut, DUT_MSG_DEBUG,
11907 "ANQP Query sent: %s", buf);
11908
11909 return SUCCESS_SEND_STATUS;
11910 }
11911
Veerendranath Jakkam54ddc352020-07-05 15:47:54 +053011912 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Unsupported framename");
11913 return STATUS_SENT_ERROR;
11914}
11915
11916
Vinita S. Malooee9e7e92020-04-28 16:26:50 +053011917static enum sigma_cmd_result
11918cmd_sta_send_frame_mscs(struct sigma_dut *dut, struct sigma_conn *conn,
11919 const char *intf, struct sigma_cmd *cmd)
11920{
11921 char buf[128], *pos;
11922 const char *val, *classifier_type = "04", *type;
11923 int len, rem_len;
11924 u8 up_bitmap;
11925
11926 val = get_param(cmd, "FrameName");
11927 type = get_param(cmd, "Request_Type");
11928 if (!val || !type || strcasecmp(val, "MSCSReq") != 0) {
11929 sigma_dut_print(dut, DUT_MSG_ERROR,
11930 "%s: frame name or type not valid", __func__);
11931 return INVALID_SEND_STATUS;
11932 }
11933
11934 rem_len = sizeof(buf);
11935 pos = buf;
11936 if (strcasecmp(type, "add") == 0) {
11937 len = snprintf(pos, rem_len, "MSCS add");
11938 } else if (strcasecmp(type, "update") == 0) {
11939 len = snprintf(pos, rem_len, "MSCS change");
11940 } else if (strcasecmp(type, "remove") == 0) {
11941 if (wpa_command(intf, "MSCS remove") != 0) {
11942 send_resp(dut, conn, SIGMA_ERROR,
11943 "ErrorCode,Failed to send MSCS frame req");
11944 return STATUS_SENT_ERROR;
11945 }
11946 return SUCCESS_SEND_STATUS;
11947 } else {
11948 sigma_dut_print(dut, DUT_MSG_ERROR,
11949 "%s: request type invalid", __func__);
11950 return INVALID_SEND_STATUS;
11951 }
11952
11953 if (len < 0 || len >= rem_len)
11954 goto fail;
11955
11956 pos += len;
11957 rem_len -= len;
11958
11959 val = get_param(cmd, "User_Priority_Bitmap");
11960 if (!val) {
11961 sigma_dut_print(dut, DUT_MSG_ERROR,
11962 "%s: user priority bitmap empty", __func__);
11963 return INVALID_SEND_STATUS;
11964 }
11965
11966 switch (atoi(val)) {
11967 case 0:
11968 up_bitmap = 0x00;
11969 break;
11970 case 1:
11971 up_bitmap = 0xF0;
11972 break;
11973 case 2:
11974 up_bitmap = 0xF6;
11975 break;
11976 default:
11977 sigma_dut_print(dut, DUT_MSG_ERROR,
11978 "%s: Unknown User_Priority_Bitmap value %d",
11979 __func__, atoi(val));
11980 return INVALID_SEND_STATUS;
11981 }
11982
11983 len = snprintf(pos, rem_len, " up_bitmap=%02x", up_bitmap);
11984 if (len < 0 || len >= rem_len)
11985 goto fail;
11986
11987 pos += len;
11988 rem_len -= len;
11989
11990 val = get_param(cmd, "User_Priority_Limit");
11991 if (!val) {
11992 sigma_dut_print(dut, DUT_MSG_ERROR,
11993 "%s: invalid user priority limit", __func__);
11994 return INVALID_SEND_STATUS;
11995 }
11996
11997 len = snprintf(pos, rem_len, " up_limit=%s", val);
11998 if (len < 0 || len >= rem_len)
11999 goto fail;
12000
12001 pos += len;
12002 rem_len -= len;
12003
12004 val = get_param(cmd, "Stream_Timeout");
12005 if (!val)
12006 val = get_param(cmd, "Stream_Timtout");
12007 if (!val) {
12008 sigma_dut_print(dut, DUT_MSG_ERROR,
12009 "%s: invalid stream timeout", __func__);
12010 return INVALID_SEND_STATUS;
12011 }
12012
12013 len = snprintf(pos, rem_len, " stream_timeout=%s", val);
12014 if (len < 0 || len >= rem_len)
12015 goto fail;
12016
12017 pos += len;
12018 rem_len -= len;
12019
12020 val = get_param(cmd, "TCLAS_Mask");
12021 if (!val) {
12022 sigma_dut_print(dut, DUT_MSG_ERROR,
12023 "%s: invalid tclas mask", __func__);
12024 return INVALID_SEND_STATUS;
12025 }
12026
12027 len = snprintf(pos, rem_len, " frame_classifier=%s%lx%032x",
12028 classifier_type, strtol(val, NULL, 2), 0);
12029 if (len < 0 || len >= rem_len)
12030 goto fail;
12031
12032 if (wpa_command(intf, buf) != 0) {
12033 send_resp(dut, conn, SIGMA_ERROR,
12034 "ErrorCode,Failed to send MSCS frame req");
12035 return STATUS_SENT_ERROR;
12036 }
12037
12038 sigma_dut_print(dut, DUT_MSG_DEBUG,
12039 "MSCS frame request sent: %s", buf);
12040
12041 return SUCCESS_SEND_STATUS;
12042fail:
12043 sigma_dut_print(dut, DUT_MSG_ERROR,
12044 "Failed to create MSCS frame req");
12045 return ERROR_SEND_STATUS;
12046}
12047
12048
Jouni Malinenf7222712019-06-13 01:50:21 +030012049enum sigma_cmd_result cmd_sta_send_frame(struct sigma_dut *dut,
12050 struct sigma_conn *conn,
12051 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012052{
12053 const char *intf = get_param(cmd, "Interface");
12054 const char *val;
12055 enum send_frame_type frame;
12056 enum send_frame_protection protected;
12057 char buf[100];
12058 unsigned char addr[ETH_ALEN];
12059 int res;
12060
Alexei Avshalom Lazar4a3c2f82019-05-02 13:35:37 +030012061 if (!intf)
12062 return -1;
12063
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012064 val = get_param(cmd, "program");
12065 if (val == NULL)
12066 val = get_param(cmd, "frame");
12067 if (val && strcasecmp(val, "TDLS") == 0)
12068 return cmd_sta_send_frame_tdls(dut, conn, cmd);
12069 if (val && (strcasecmp(val, "HS2") == 0 ||
Jouni Malinen1f6ae642018-06-07 23:56:13 +030012070 strcasecmp(val, "HS2-R2") == 0 ||
12071 strcasecmp(val, "HS2-R3") == 0))
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012072 return cmd_sta_send_frame_hs2(dut, conn, cmd);
12073 if (val && strcasecmp(val, "VHT") == 0)
12074 return cmd_sta_send_frame_vht(dut, conn, cmd);
Kiran Kumar Lokere419f6962018-10-24 19:03:04 -070012075 if (val && strcasecmp(val, "HE") == 0)
12076 return cmd_sta_send_frame_he(dut, conn, cmd);
priyadharshini gowthamand66913a2016-07-29 15:11:17 -070012077 if (val && strcasecmp(val, "LOC") == 0)
12078 return loc_cmd_sta_send_frame(dut, conn, cmd);
Lior David0fe101e2017-03-09 16:09:50 +020012079 if (val && strcasecmp(val, "60GHz") == 0)
12080 return cmd_sta_send_frame_60g(dut, conn, cmd);
Ashwini Patildb59b3c2017-04-13 15:19:23 +053012081 if (val && strcasecmp(val, "MBO") == 0) {
12082 res = mbo_cmd_sta_send_frame(dut, conn, intf, cmd);
12083 if (res != 2)
12084 return res;
12085 }
Veerendranath Jakkam54ddc352020-07-05 15:47:54 +053012086 if (val && strcasecmp(val, "WPA3") == 0)
12087 return cmd_sta_send_frame_wpa3(dut, conn, intf, cmd);
Vinita S. Malooee9e7e92020-04-28 16:26:50 +053012088 if (val && strcasecmp(val, "QM") == 0)
12089 return cmd_sta_send_frame_mscs(dut, conn, intf, cmd);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012090
12091 val = get_param(cmd, "TD_DISC");
12092 if (val) {
12093 if (hwaddr_aton(val, addr) < 0)
12094 return -1;
12095 snprintf(buf, sizeof(buf), "TDLS_DISCOVER %s", val);
12096 if (wpa_command(intf, buf) < 0) {
12097 send_resp(dut, conn, SIGMA_ERROR,
12098 "ErrorCode,Failed to send TDLS discovery");
12099 return 0;
12100 }
12101 return 1;
12102 }
12103
12104 val = get_param(cmd, "TD_Setup");
12105 if (val) {
12106 if (hwaddr_aton(val, addr) < 0)
12107 return -1;
12108 snprintf(buf, sizeof(buf), "TDLS_SETUP %s", val);
12109 if (wpa_command(intf, buf) < 0) {
12110 send_resp(dut, conn, SIGMA_ERROR,
12111 "ErrorCode,Failed to start TDLS setup");
12112 return 0;
12113 }
12114 return 1;
12115 }
12116
12117 val = get_param(cmd, "TD_TearDown");
12118 if (val) {
12119 if (hwaddr_aton(val, addr) < 0)
12120 return -1;
12121 snprintf(buf, sizeof(buf), "TDLS_TEARDOWN %s", val);
12122 if (wpa_command(intf, buf) < 0) {
12123 send_resp(dut, conn, SIGMA_ERROR,
12124 "ErrorCode,Failed to tear down TDLS link");
12125 return 0;
12126 }
12127 return 1;
12128 }
12129
12130 val = get_param(cmd, "TD_ChannelSwitch");
12131 if (val) {
12132 /* TODO */
12133 send_resp(dut, conn, SIGMA_ERROR,
12134 "ErrorCode,TD_ChannelSwitch not yet supported");
12135 return 0;
12136 }
12137
12138 val = get_param(cmd, "TD_NF");
12139 if (val) {
12140 /* TODO */
12141 send_resp(dut, conn, SIGMA_ERROR,
12142 "ErrorCode,TD_NF not yet supported");
12143 return 0;
12144 }
12145
12146 val = get_param(cmd, "PMFFrameType");
12147 if (val == NULL)
12148 val = get_param(cmd, "FrameName");
12149 if (val == NULL)
12150 val = get_param(cmd, "Type");
12151 if (val == NULL)
12152 return -1;
12153 if (strcasecmp(val, "disassoc") == 0)
12154 frame = DISASSOC;
12155 else if (strcasecmp(val, "deauth") == 0)
12156 frame = DEAUTH;
12157 else if (strcasecmp(val, "saquery") == 0)
12158 frame = SAQUERY;
12159 else if (strcasecmp(val, "auth") == 0)
12160 frame = AUTH;
12161 else if (strcasecmp(val, "assocreq") == 0)
12162 frame = ASSOCREQ;
12163 else if (strcasecmp(val, "reassocreq") == 0)
12164 frame = REASSOCREQ;
12165 else if (strcasecmp(val, "neigreq") == 0) {
12166 sigma_dut_print(dut, DUT_MSG_INFO, "Got neighbor request");
12167
12168 val = get_param(cmd, "ssid");
12169 if (val == NULL)
12170 return -1;
12171
12172 res = send_neighbor_request(dut, intf, val);
12173 if (res) {
12174 send_resp(dut, conn, SIGMA_ERROR, "errorCode,"
12175 "Failed to send neighbor report request");
12176 return 0;
12177 }
12178
12179 return 1;
Ashwini Patil5acd7382017-04-13 15:55:04 +053012180 } else if (strcasecmp(val, "transmgmtquery") == 0 ||
12181 strcasecmp(val, "BTMQuery") == 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012182 sigma_dut_print(dut, DUT_MSG_DEBUG,
12183 "Got Transition Management Query");
12184
Ashwini Patil5acd7382017-04-13 15:55:04 +053012185 res = send_trans_mgmt_query(dut, intf, cmd);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012186 if (res) {
12187 send_resp(dut, conn, SIGMA_ERROR, "errorCode,"
12188 "Failed to send Transition Management Query");
12189 return 0;
12190 }
12191
12192 return 1;
12193 } else {
12194 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Unsupported "
12195 "PMFFrameType");
12196 return 0;
12197 }
12198
12199 val = get_param(cmd, "PMFProtected");
12200 if (val == NULL)
12201 val = get_param(cmd, "Protected");
12202 if (val == NULL)
12203 return -1;
12204 if (strcasecmp(val, "Correct-key") == 0 ||
12205 strcasecmp(val, "CorrectKey") == 0)
12206 protected = CORRECT_KEY;
12207 else if (strcasecmp(val, "IncorrectKey") == 0)
12208 protected = INCORRECT_KEY;
12209 else if (strcasecmp(val, "Unprotected") == 0)
12210 protected = UNPROTECTED;
12211 else {
12212 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Unsupported "
12213 "PMFProtected");
12214 return 0;
12215 }
12216
12217 if (protected != UNPROTECTED &&
12218 (frame == AUTH || frame == ASSOCREQ || frame == REASSOCREQ)) {
12219 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Impossible "
12220 "PMFProtected for auth/assocreq/reassocreq");
12221 return 0;
12222 }
12223
12224 if (if_nametoindex("sigmadut") == 0) {
12225 snprintf(buf, sizeof(buf),
12226 "iw dev %s interface add sigmadut type monitor",
Jouni Malinen016ae6c2019-11-04 17:00:01 +020012227 get_station_ifname(dut));
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012228 if (system(buf) != 0 ||
12229 if_nametoindex("sigmadut") == 0) {
12230 sigma_dut_print(dut, DUT_MSG_ERROR, "Failed to add "
12231 "monitor interface with '%s'", buf);
12232 return -2;
12233 }
12234 }
12235
12236 if (system("ifconfig sigmadut up") != 0) {
12237 sigma_dut_print(dut, DUT_MSG_ERROR, "Failed to set "
12238 "monitor interface up");
12239 return -2;
12240 }
12241
Veerendranath Jakkam49774122020-07-05 09:52:18 +053012242 return sta_inject_frame(dut, conn, intf, frame, protected, NULL, 1);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012243}
12244
12245
12246static int cmd_sta_set_parameter_hs2(struct sigma_dut *dut,
12247 struct sigma_conn *conn,
12248 struct sigma_cmd *cmd,
12249 const char *ifname)
12250{
12251 char buf[200];
12252 const char *val;
12253
12254 val = get_param(cmd, "ClearARP");
12255 if (val && atoi(val) == 1) {
12256 snprintf(buf, sizeof(buf), "ip neigh flush dev %s", ifname);
12257 sigma_dut_print(dut, DUT_MSG_DEBUG, "Run: %s", buf);
12258 if (system(buf) != 0) {
12259 send_resp(dut, conn, SIGMA_ERROR,
12260 "errorCode,Failed to clear ARP cache");
12261 return 0;
12262 }
12263 }
12264
12265 return 1;
12266}
12267
12268
12269int cmd_sta_set_parameter(struct sigma_dut *dut, struct sigma_conn *conn,
12270 struct sigma_cmd *cmd)
12271{
12272 const char *intf = get_param(cmd, "Interface");
12273 const char *val;
12274
12275 if (intf == NULL)
12276 return -1;
12277
12278 val = get_param(cmd, "program");
12279 if (val && (strcasecmp(val, "HS2") == 0 ||
Jouni Malinen1f6ae642018-06-07 23:56:13 +030012280 strcasecmp(val, "HS2-R2") == 0 ||
12281 strcasecmp(val, "HS2-R3") == 0))
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012282 return cmd_sta_set_parameter_hs2(dut, conn, cmd, intf);
12283
12284 return -1;
12285}
12286
12287
Jouni Malinenf7222712019-06-13 01:50:21 +030012288static enum sigma_cmd_result cmd_sta_set_macaddr(struct sigma_dut *dut,
12289 struct sigma_conn *conn,
12290 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012291{
12292 const char *intf = get_param(cmd, "Interface");
12293 const char *mac = get_param(cmd, "MAC");
12294
12295 if (intf == NULL || mac == NULL)
12296 return -1;
12297
12298 sigma_dut_print(dut, DUT_MSG_INFO, "Change local MAC address for "
12299 "interface %s to %s", intf, mac);
12300
12301 if (dut->set_macaddr) {
12302 char buf[128];
12303 int res;
12304 if (strcasecmp(mac, "default") == 0) {
12305 res = snprintf(buf, sizeof(buf), "%s",
12306 dut->set_macaddr);
12307 dut->tmp_mac_addr = 0;
12308 } else {
12309 res = snprintf(buf, sizeof(buf), "%s %s",
12310 dut->set_macaddr, mac);
12311 dut->tmp_mac_addr = 1;
12312 }
12313 if (res < 0 || res >= (int) sizeof(buf))
12314 return -1;
12315 if (system(buf) != 0) {
12316 send_resp(dut, conn, SIGMA_ERROR,
12317 "errorCode,Failed to set MAC "
12318 "address");
12319 return 0;
12320 }
12321 return 1;
12322 }
12323
12324 if (strcasecmp(mac, "default") == 0)
12325 return 1;
12326
12327 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Unsupported "
12328 "command");
12329 return 0;
12330}
12331
12332
12333static int iwpriv_tdlsoffchnmode(struct sigma_dut *dut,
12334 struct sigma_conn *conn, const char *intf,
12335 int val)
12336{
12337 char buf[200];
12338 int res;
12339
12340 res = snprintf(buf, sizeof(buf), "iwpriv %s tdlsoffchnmode %d",
12341 intf, val);
12342 if (res < 0 || res >= (int) sizeof(buf))
12343 return -1;
12344 sigma_dut_print(dut, DUT_MSG_DEBUG, "Run: %s", buf);
12345 if (system(buf) != 0) {
12346 send_resp(dut, conn, SIGMA_ERROR,
12347 "errorCode,Failed to configure offchannel mode");
12348 return 0;
12349 }
12350
12351 return 1;
12352}
12353
12354
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012355static int off_chan_val(enum sec_ch_offset off)
12356{
12357 switch (off) {
12358 case SEC_CH_NO:
12359 return 0;
12360 case SEC_CH_40ABOVE:
12361 return 40;
12362 case SEC_CH_40BELOW:
12363 return -40;
12364 }
12365
12366 return 0;
12367}
12368
12369
12370static int iwpriv_set_offchan(struct sigma_dut *dut, struct sigma_conn *conn,
12371 const char *intf, int off_ch_num,
12372 enum sec_ch_offset sec)
12373{
12374 char buf[200];
12375 int res;
12376
12377 res = snprintf(buf, sizeof(buf), "iwpriv %s tdlsoffchan %d",
12378 intf, off_ch_num);
12379 if (res < 0 || res >= (int) sizeof(buf))
12380 return -1;
12381 sigma_dut_print(dut, DUT_MSG_DEBUG, "Run: %s", buf);
12382 if (system(buf) != 0) {
12383 send_resp(dut, conn, SIGMA_ERROR,
12384 "errorCode,Failed to set offchan");
12385 return 0;
12386 }
12387
12388 res = snprintf(buf, sizeof(buf), "iwpriv %s tdlsecchnoffst %d",
12389 intf, off_chan_val(sec));
12390 if (res < 0 || res >= (int) sizeof(buf))
12391 return -1;
12392 sigma_dut_print(dut, DUT_MSG_DEBUG, "Run: %s", buf);
12393 if (system(buf) != 0) {
12394 send_resp(dut, conn, SIGMA_ERROR,
12395 "errorCode,Failed to set sec chan offset");
12396 return 0;
12397 }
12398
12399 return 1;
12400}
12401
12402
12403static int tdls_set_offchannel_offset(struct sigma_dut *dut,
12404 struct sigma_conn *conn,
12405 const char *intf, int off_ch_num,
12406 enum sec_ch_offset sec)
12407{
12408 char buf[200];
12409 int res;
12410
12411 res = snprintf(buf, sizeof(buf), "DRIVER TDLSOFFCHANNEL %d",
12412 off_ch_num);
12413 if (res < 0 || res >= (int) sizeof(buf))
12414 return -1;
12415 sigma_dut_print(dut, DUT_MSG_DEBUG, "Run: %s", buf);
12416
12417 if (wpa_command(intf, buf) < 0) {
12418 send_resp(dut, conn, SIGMA_ERROR,
12419 "ErrorCode,Failed to set offchan");
12420 return 0;
12421 }
12422 res = snprintf(buf, sizeof(buf), "DRIVER TDLSSECONDARYCHANNELOFFSET %d",
12423 off_chan_val(sec));
12424 if (res < 0 || res >= (int) sizeof(buf))
12425 return -1;
12426
12427 sigma_dut_print(dut, DUT_MSG_DEBUG, "Run: %s", buf);
12428
12429 if (wpa_command(intf, buf) < 0) {
12430 send_resp(dut, conn, SIGMA_ERROR,
12431 "ErrorCode,Failed to set sec chan offset");
12432 return 0;
12433 }
12434
12435 return 1;
12436}
12437
12438
12439static int tdls_set_offchannel_mode(struct sigma_dut *dut,
12440 struct sigma_conn *conn,
12441 const char *intf, int val)
12442{
12443 char buf[200];
12444 int res;
12445
12446 res = snprintf(buf, sizeof(buf), "DRIVER TDLSOFFCHANNELMODE %d",
12447 val);
12448 if (res < 0 || res >= (int) sizeof(buf))
12449 return -1;
12450 sigma_dut_print(dut, DUT_MSG_DEBUG, "Run: %s", buf);
12451
12452 if (wpa_command(intf, buf) < 0) {
12453 send_resp(dut, conn, SIGMA_ERROR,
12454 "ErrorCode,Failed to configure offchannel mode");
12455 return 0;
12456 }
12457
12458 return 1;
12459}
12460
12461
12462static int cmd_sta_set_rfeature_tdls(const char *intf, struct sigma_dut *dut,
12463 struct sigma_conn *conn,
12464 struct sigma_cmd *cmd)
12465{
12466 const char *val;
12467 enum {
12468 CHSM_NOT_SET,
12469 CHSM_ENABLE,
12470 CHSM_DISABLE,
12471 CHSM_REJREQ,
12472 CHSM_UNSOLRESP
12473 } chsm = CHSM_NOT_SET;
12474 int off_ch_num = -1;
12475 enum sec_ch_offset sec_ch = SEC_CH_NO;
12476 int res;
12477
12478 val = get_param(cmd, "Uapsd");
12479 if (val) {
12480 char buf[100];
12481 if (strcasecmp(val, "Enable") == 0)
12482 snprintf(buf, sizeof(buf), "SET ps 99");
12483 else if (strcasecmp(val, "Disable") == 0)
12484 snprintf(buf, sizeof(buf), "SET ps 98");
12485 else {
12486 send_resp(dut, conn, SIGMA_ERROR, "errorCode,"
12487 "Unsupported uapsd parameter value");
12488 return 0;
12489 }
12490 if (wpa_command(intf, buf)) {
12491 send_resp(dut, conn, SIGMA_ERROR,
12492 "ErrorCode,Failed to change U-APSD "
12493 "powersave mode");
12494 return 0;
12495 }
12496 }
12497
12498 val = get_param(cmd, "TPKTIMER");
12499 if (val && strcasecmp(val, "DISABLE") == 0) {
12500 if (wpa_command(intf, "SET tdls_testing 0x100")) {
12501 send_resp(dut, conn, SIGMA_ERROR,
12502 "ErrorCode,Failed to enable no TPK "
12503 "expiration test mode");
12504 return 0;
12505 }
12506 dut->no_tpk_expiration = 1;
12507 }
12508
12509 val = get_param(cmd, "ChSwitchMode");
12510 if (val) {
12511 if (strcasecmp(val, "Enable") == 0 ||
12512 strcasecmp(val, "Initiate") == 0)
12513 chsm = CHSM_ENABLE;
12514 else if (strcasecmp(val, "Disable") == 0 ||
12515 strcasecmp(val, "passive") == 0)
12516 chsm = CHSM_DISABLE;
12517 else if (strcasecmp(val, "RejReq") == 0)
12518 chsm = CHSM_REJREQ;
12519 else if (strcasecmp(val, "UnSolResp") == 0)
12520 chsm = CHSM_UNSOLRESP;
12521 else {
12522 send_resp(dut, conn, SIGMA_ERROR,
12523 "ErrorCode,Unknown ChSwitchMode value");
12524 return 0;
12525 }
12526 }
12527
12528 val = get_param(cmd, "OffChNum");
12529 if (val) {
12530 off_ch_num = atoi(val);
12531 if (off_ch_num == 0) {
12532 send_resp(dut, conn, SIGMA_ERROR,
12533 "ErrorCode,Invalid OffChNum");
12534 return 0;
12535 }
12536 }
12537
12538 val = get_param(cmd, "SecChOffset");
12539 if (val) {
12540 if (strcmp(val, "20") == 0)
12541 sec_ch = SEC_CH_NO;
12542 else if (strcasecmp(val, "40above") == 0)
12543 sec_ch = SEC_CH_40ABOVE;
12544 else if (strcasecmp(val, "40below") == 0)
12545 sec_ch = SEC_CH_40BELOW;
12546 else {
12547 send_resp(dut, conn, SIGMA_ERROR,
12548 "ErrorCode,Unknown SecChOffset value");
12549 return 0;
12550 }
12551 }
12552
12553 if (chsm == CHSM_NOT_SET) {
12554 /* no offchannel changes requested */
12555 return 1;
12556 }
12557
Jouni Malinen016ae6c2019-11-04 17:00:01 +020012558 if (strcmp(intf, get_main_ifname(dut)) != 0 &&
12559 strcmp(intf, get_station_ifname(dut)) != 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012560 send_resp(dut, conn, SIGMA_ERROR,
12561 "ErrorCode,Unknown interface");
12562 return 0;
12563 }
12564
12565 switch (chsm) {
12566 case CHSM_NOT_SET:
Jouni Malinen280f5ba2016-08-29 21:33:10 +030012567 res = 1;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012568 break;
12569 case CHSM_ENABLE:
12570 if (off_ch_num < 0) {
12571 send_resp(dut, conn, SIGMA_ERROR,
12572 "ErrorCode,Missing OffChNum argument");
12573 return 0;
12574 }
12575 if (wifi_chip_type == DRIVER_WCN) {
12576 res = tdls_set_offchannel_offset(dut, conn, intf,
12577 off_ch_num, sec_ch);
12578 } else {
12579 res = iwpriv_set_offchan(dut, conn, intf, off_ch_num,
12580 sec_ch);
12581 }
12582 if (res != 1)
12583 return res;
12584 if (wifi_chip_type == DRIVER_WCN)
12585 res = tdls_set_offchannel_mode(dut, conn, intf, 1);
12586 else
12587 res = iwpriv_tdlsoffchnmode(dut, conn, intf, 1);
12588 break;
12589 case CHSM_DISABLE:
12590 if (wifi_chip_type == DRIVER_WCN)
12591 res = tdls_set_offchannel_mode(dut, conn, intf, 2);
12592 else
12593 res = iwpriv_tdlsoffchnmode(dut, conn, intf, 2);
12594 break;
12595 case CHSM_REJREQ:
12596 if (wifi_chip_type == DRIVER_WCN)
12597 res = tdls_set_offchannel_mode(dut, conn, intf, 3);
12598 else
12599 res = iwpriv_tdlsoffchnmode(dut, conn, intf, 3);
12600 break;
12601 case CHSM_UNSOLRESP:
12602 if (off_ch_num < 0) {
12603 send_resp(dut, conn, SIGMA_ERROR,
12604 "ErrorCode,Missing OffChNum argument");
12605 return 0;
12606 }
12607 if (wifi_chip_type == DRIVER_WCN) {
12608 res = tdls_set_offchannel_offset(dut, conn, intf,
12609 off_ch_num, sec_ch);
12610 } else {
12611 res = iwpriv_set_offchan(dut, conn, intf, off_ch_num,
12612 sec_ch);
12613 }
12614 if (res != 1)
12615 return res;
12616 if (wifi_chip_type == DRIVER_WCN)
12617 res = tdls_set_offchannel_mode(dut, conn, intf, 4);
12618 else
12619 res = iwpriv_tdlsoffchnmode(dut, conn, intf, 4);
12620 break;
12621 }
12622
12623 return res;
12624}
12625
12626
12627static int ath_sta_set_rfeature_vht(const char *intf, struct sigma_dut *dut,
12628 struct sigma_conn *conn,
12629 struct sigma_cmd *cmd)
12630{
12631 const char *val;
Srikanth Marepalli5415acf2018-08-27 12:53:11 +053012632 char *token = NULL, *result;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012633
Priyadharshini Gowthaman8c5b9a42019-07-31 14:38:48 -070012634 novap_reset(dut, intf, 1);
priyadharshini gowthamane5e25172015-12-08 14:53:48 -080012635
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012636 val = get_param(cmd, "nss_mcs_opt");
12637 if (val) {
12638 /* String (nss_operating_mode; mcs_operating_mode) */
12639 int nss, mcs;
Pradeep Reddy POTTETIdbf7d712016-04-28 18:42:07 +053012640 char *saveptr;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012641
12642 token = strdup(val);
12643 if (!token)
12644 return 0;
Pradeep Reddy POTTETIdbf7d712016-04-28 18:42:07 +053012645 result = strtok_r(token, ";", &saveptr);
Pradeep Reddy POTTETI41b8c542016-06-15 16:09:46 +053012646 if (!result) {
12647 sigma_dut_print(dut, DUT_MSG_ERROR,
12648 "VHT NSS not specified");
12649 goto failed;
12650 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012651 if (strcasecmp(result, "def") != 0) {
12652 nss = atoi(result);
12653 if (nss == 4)
12654 ath_disable_txbf(dut, intf);
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -070012655 if (run_iwpriv(dut, intf, "nss %d", nss) < 0)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012656 goto failed;
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -070012657
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012658 }
12659
Pradeep Reddy POTTETIdbf7d712016-04-28 18:42:07 +053012660 result = strtok_r(NULL, ";", &saveptr);
Pradeep Reddy POTTETI41b8c542016-06-15 16:09:46 +053012661 if (!result) {
12662 sigma_dut_print(dut, DUT_MSG_ERROR,
12663 "VHT MCS not specified");
12664 goto failed;
12665 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012666 if (strcasecmp(result, "def") == 0) {
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -070012667 if (run_iwpriv(dut, intf, "set11NRates 0") < 0)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012668 goto failed;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012669 } else {
12670 mcs = atoi(result);
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -070012671 if (run_iwpriv(dut, intf, "vhtmcs %d", mcs) < 0)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012672 goto failed;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012673 }
12674 /* Channel width gets messed up, fix this */
Priyadharshini Gowthamanb999e9e2019-04-22 15:45:55 -070012675 run_iwpriv(dut, intf, "chwidth %d", dut->chwidth);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012676 }
12677
Srikanth Marepalli5415acf2018-08-27 12:53:11 +053012678 free(token);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012679 return 1;
12680failed:
12681 free(token);
12682 return 0;
12683}
12684
12685
12686static int cmd_sta_set_rfeature_vht(const char *intf, struct sigma_dut *dut,
12687 struct sigma_conn *conn,
12688 struct sigma_cmd *cmd)
12689{
Jouni Malinen016ae6c2019-11-04 17:00:01 +020012690 switch (get_driver_type(dut)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +020012691 case DRIVER_ATHEROS:
12692 return ath_sta_set_rfeature_vht(intf, dut, conn, cmd);
12693 default:
12694 send_resp(dut, conn, SIGMA_ERROR,
12695 "errorCode,Unsupported sta_set_rfeature(VHT) with the current driver");
12696 return 0;
12697 }
12698}
12699
12700
Jouni Malinen1702fe32021-06-08 19:08:01 +030012701static enum sigma_cmd_result
12702wcn_sta_set_rfeature_he(const char *intf, struct sigma_dut *dut,
12703 struct sigma_conn *conn, struct sigma_cmd *cmd)
Amarnath Hullur Subramanyam42c25a02018-01-31 04:02:27 -080012704{
12705 const char *val;
12706 char *token = NULL, *result;
12707 char buf[60];
12708
12709 val = get_param(cmd, "nss_mcs_opt");
12710 if (val) {
12711 /* String (nss_operating_mode; mcs_operating_mode) */
12712 int nss, mcs, ratecode;
12713 char *saveptr;
12714
12715 token = strdup(val);
12716 if (!token)
Jouni Malinen1702fe32021-06-08 19:08:01 +030012717 return ERROR_SEND_STATUS;
Amarnath Hullur Subramanyam42c25a02018-01-31 04:02:27 -080012718
12719 result = strtok_r(token, ";", &saveptr);
12720 if (!result) {
12721 sigma_dut_print(dut, DUT_MSG_ERROR,
12722 "HE NSS not specified");
12723 goto failed;
12724 }
12725 nss = 1;
12726 if (strcasecmp(result, "def") != 0)
12727 nss = atoi(result);
12728
12729 result = strtok_r(NULL, ";", &saveptr);
12730 if (!result) {
12731 sigma_dut_print(dut, DUT_MSG_ERROR,
12732 "HE MCS not specified");
12733 goto failed;
12734 }
12735 mcs = 7;
12736 if (strcasecmp(result, "def") != 0)
12737 mcs = atoi(result);
12738
Arif Hussain557bf412018-05-25 17:29:36 -070012739 ratecode = 0x20; /* for nss:1 MCS 0 */
Amarnath Hullur Subramanyam42c25a02018-01-31 04:02:27 -080012740 if (nss == 2) {
Arif Hussain557bf412018-05-25 17:29:36 -070012741 ratecode = 0x40; /* for nss:2 MCS 0 */
Amarnath Hullur Subramanyam42c25a02018-01-31 04:02:27 -080012742 } else if (nss > 2) {
12743 sigma_dut_print(dut, DUT_MSG_ERROR,
12744 "HE NSS %d not supported", nss);
12745 goto failed;
12746 }
12747
Arif Hussain557bf412018-05-25 17:29:36 -070012748 snprintf(buf, sizeof(buf), "iwpriv %s nss %d", intf, nss);
12749 if (system(buf) != 0) {
12750 sigma_dut_print(dut, DUT_MSG_ERROR,
12751 "nss_mcs_opt: iwpriv %s nss %d failed",
12752 intf, nss);
12753 goto failed;
12754 }
Arif Hussainac6c5112018-05-25 17:34:00 -070012755 dut->sta_nss = nss;
Arif Hussain557bf412018-05-25 17:29:36 -070012756
Amarnath Hullur Subramanyam42c25a02018-01-31 04:02:27 -080012757 /* Add the MCS to the ratecode */
12758 if (mcs >= 0 && mcs <= 11) {
12759 ratecode += mcs;
Arif Hussain557bf412018-05-25 17:29:36 -070012760#ifdef NL80211_SUPPORT
12761 if (dut->device_type == STA_testbed) {
12762 enum he_mcs_config mcs_config;
12763 int ret;
12764
12765 if (mcs <= 7)
12766 mcs_config = HE_80_MCS0_7;
12767 else if (mcs <= 9)
12768 mcs_config = HE_80_MCS0_9;
12769 else
12770 mcs_config = HE_80_MCS0_11;
12771 ret = sta_set_he_mcs(dut, intf, mcs_config);
12772 if (ret) {
12773 sigma_dut_print(dut, DUT_MSG_ERROR,
12774 "nss_mcs_opt: mcs setting failed, mcs:%d, mcs_config %d, ret:%d",
12775 mcs, mcs_config, ret);
12776 goto failed;
12777 }
12778 }
12779#endif /* NL80211_SUPPORT */
Amarnath Hullur Subramanyam42c25a02018-01-31 04:02:27 -080012780 } else {
12781 sigma_dut_print(dut, DUT_MSG_ERROR,
12782 "HE MCS %d not supported", mcs);
12783 goto failed;
12784 }
12785 snprintf(buf, sizeof(buf), "iwpriv %s set_11ax_rate 0x%03x",
12786 intf, ratecode);
12787 if (system(buf) != 0) {
12788 sigma_dut_print(dut, DUT_MSG_ERROR,
12789 "iwpriv setting of 11ax rates failed");
12790 goto failed;
12791 }
12792 free(token);
12793 }
12794
12795 val = get_param(cmd, "GI");
12796 if (val) {
Kiran Kumar Lokeref6592d72019-01-16 18:44:00 -080012797 int fix_rate_sgi;
12798
Amarnath Hullur Subramanyam42c25a02018-01-31 04:02:27 -080012799 if (strcmp(val, "0.8") == 0) {
Kiran Kumar Lokereb8fec522018-05-01 14:26:00 -070012800 snprintf(buf, sizeof(buf), "iwpriv %s shortgi 9", intf);
Kiran Kumar Lokeref6592d72019-01-16 18:44:00 -080012801 fix_rate_sgi = 1;
Amarnath Hullur Subramanyam42c25a02018-01-31 04:02:27 -080012802 } else if (strcmp(val, "1.6") == 0) {
Kiran Kumar Lokereb8fec522018-05-01 14:26:00 -070012803 snprintf(buf, sizeof(buf), "iwpriv %s shortgi 10",
12804 intf);
Kiran Kumar Lokeref6592d72019-01-16 18:44:00 -080012805 fix_rate_sgi = 2;
Amarnath Hullur Subramanyam42c25a02018-01-31 04:02:27 -080012806 } else if (strcmp(val, "3.2") == 0) {
Kiran Kumar Lokereb8fec522018-05-01 14:26:00 -070012807 snprintf(buf, sizeof(buf), "iwpriv %s shortgi 11",
12808 intf);
Kiran Kumar Lokeref6592d72019-01-16 18:44:00 -080012809 fix_rate_sgi = 3;
Amarnath Hullur Subramanyam42c25a02018-01-31 04:02:27 -080012810 } else {
12811 send_resp(dut, conn, SIGMA_ERROR,
12812 "errorCode,GI value not supported");
Jouni Malinen1702fe32021-06-08 19:08:01 +030012813 return STATUS_SENT_ERROR;
Amarnath Hullur Subramanyam42c25a02018-01-31 04:02:27 -080012814 }
12815 if (system(buf) != 0) {
12816 send_resp(dut, conn, SIGMA_ERROR,
12817 "errorCode,Failed to set shortgi");
Jouni Malinen1702fe32021-06-08 19:08:01 +030012818 return STATUS_SENT_ERROR;
Amarnath Hullur Subramanyam42c25a02018-01-31 04:02:27 -080012819 }
Kiran Kumar Lokeref6592d72019-01-16 18:44:00 -080012820 snprintf(buf, sizeof(buf), "iwpriv %s shortgi %d",
12821 intf, fix_rate_sgi);
12822 if (system(buf) != 0) {
12823 send_resp(dut, conn, SIGMA_ERROR,
12824 "errorCode,Failed to set fix rate shortgi");
Jouni Malinen1702fe32021-06-08 19:08:01 +030012825 return STATUS_SENT_ERROR;
Kiran Kumar Lokeref6592d72019-01-16 18:44:00 -080012826 }
Amarnath Hullur Subramanyam42c25a02018-01-31 04:02:27 -080012827 }
12828
Subhani Shaik8e7a3052018-04-24 14:03:00 -070012829 val = get_param(cmd, "LTF");
12830 if (val) {
12831#ifdef NL80211_SUPPORT
12832 if (strcmp(val, "3.2") == 0) {
Kiran Kumar Lokere26c0f862020-01-22 11:15:59 -080012833 wcn_set_he_ltf(dut, intf, QCA_WLAN_HE_LTF_1X);
Subhani Shaik8e7a3052018-04-24 14:03:00 -070012834 } if (strcmp(val, "6.4") == 0) {
Kiran Kumar Lokere26c0f862020-01-22 11:15:59 -080012835 wcn_set_he_ltf(dut, intf, QCA_WLAN_HE_LTF_2X);
Subhani Shaik8e7a3052018-04-24 14:03:00 -070012836 } else if (strcmp(val, "12.8") == 0) {
Kiran Kumar Lokere26c0f862020-01-22 11:15:59 -080012837 wcn_set_he_ltf(dut, intf, QCA_WLAN_HE_LTF_4X);
Subhani Shaik8e7a3052018-04-24 14:03:00 -070012838 } else {
12839 send_resp(dut, conn, SIGMA_ERROR,
12840 "errorCode, LTF value not supported");
Jouni Malinen1702fe32021-06-08 19:08:01 +030012841 return STATUS_SENT_ERROR;
Subhani Shaik8e7a3052018-04-24 14:03:00 -070012842 }
12843#else /* NL80211_SUPPORT */
12844 sigma_dut_print(dut, DUT_MSG_ERROR,
12845 "LTF cannot be set without NL80211_SUPPORT defined");
Jouni Malinen1702fe32021-06-08 19:08:01 +030012846 return ERROR_SEND_STATUS;
Subhani Shaik8e7a3052018-04-24 14:03:00 -070012847#endif /* NL80211_SUPPORT */
12848 }
12849
Kiran Kumar Lokere1809da12021-06-24 00:45:38 -070012850 val = get_param(cmd, "KeepAlive");
12851 if (val) {
12852 int set_val = QCA_WLAN_KEEP_ALIVE_DEFAULT;
12853
12854 if (strcasecmp(val, "Data") == 0)
12855 set_val = QCA_WLAN_KEEP_ALIVE_DATA;
12856 else if (strcasecmp(val, "Mgmt") == 0)
12857 set_val = QCA_WLAN_KEEP_ALIVE_MGMT;
12858
12859 if (sta_set_keep_alive_data_cfg(dut, intf, set_val)) {
12860 send_resp(dut, conn, SIGMA_ERROR,
12861 "ErrorCode,Failed to set keep alive type config");
12862 return STATUS_SENT_ERROR;
12863 }
12864 }
12865
Kiran Kumar Lokere400d68f2018-08-29 18:45:11 -070012866 val = get_param(cmd, "TxSUPPDU");
12867 if (val) {
12868 int set_val = 1;
12869
12870 if (strcasecmp(val, "Enable") == 0)
12871 set_val = 1;
12872 else if (strcasecmp(val, "Disable") == 0)
12873 set_val = 0;
12874
12875 if (sta_set_tx_su_ppdu_cfg(dut, intf, set_val)) {
12876 send_resp(dut, conn, SIGMA_ERROR,
12877 "ErrorCode,Failed to set Tx SU PPDU config");
Jouni Malinen1702fe32021-06-08 19:08:01 +030012878 return STATUS_SENT_ERROR;
Kiran Kumar Lokere400d68f2018-08-29 18:45:11 -070012879 }
12880 }
12881
Kiran Kumar Lokere54b72522021-04-01 00:22:44 -070012882 val = get_param(cmd, "Mgmt_Data_TX_Resp_Frame");
12883 if (val) {
12884 int set_val = 0;
12885
12886 if (strcasecmp(val, "Enable") == 0)
12887 set_val = 0;
12888 else if (strcasecmp(val, "Disable") == 0)
12889 set_val = 1;
12890
12891 if (sta_set_mgmt_data_tx_disable_cfg(dut, intf, set_val)) {
12892 send_resp(dut, conn, SIGMA_ERROR,
12893 "ErrorCode,Failed to set mgmt/data Tx disable config");
12894 return STATUS_SENT_ERROR;
12895 }
12896 }
12897
Arif Hussain480d5f42019-03-12 14:40:42 -070012898 val = get_param(cmd, "TWT_Setup");
12899 if (val) {
12900 if (strcasecmp(val, "Request") == 0) {
12901 if (sta_twt_request(dut, conn, cmd)) {
12902 send_resp(dut, conn, SIGMA_ERROR,
Srinivas Girigowda6707f032020-10-26 15:24:46 -070012903 "ErrorCode,TWT setup failed");
Jouni Malinen1702fe32021-06-08 19:08:01 +030012904 return STATUS_SENT_ERROR;
Arif Hussain480d5f42019-03-12 14:40:42 -070012905 }
12906 } else if (strcasecmp(val, "Teardown") == 0) {
12907 if (sta_twt_teardown(dut, conn, cmd)) {
12908 send_resp(dut, conn, SIGMA_ERROR,
Srinivas Girigowda6707f032020-10-26 15:24:46 -070012909 "ErrorCode,TWT teardown failed");
Jouni Malinen1702fe32021-06-08 19:08:01 +030012910 return STATUS_SENT_ERROR;
Arif Hussain480d5f42019-03-12 14:40:42 -070012911 }
12912 }
12913 }
12914
Srinivas Girigowda6707f032020-10-26 15:24:46 -070012915 val = get_param(cmd, "TWT_Operation");
12916 if (val) {
12917 if (strcasecmp(val, "Suspend") == 0) {
12918 if (sta_twt_suspend_or_nudge(dut, conn, cmd)) {
12919 send_resp(dut, conn, SIGMA_ERROR,
12920 "ErrorCode,TWT suspend failed");
12921 return STATUS_SENT_ERROR;
12922 }
12923 } else if (strcasecmp(val, "Resume") == 0) {
12924 if (sta_twt_resume(dut, conn, cmd)) {
12925 send_resp(dut, conn, SIGMA_ERROR,
12926 "ErrorCode,TWT resume failed");
12927 return STATUS_SENT_ERROR;
12928 }
12929 }
12930 }
12931
Kiran Kumar Lokere50eb2cd2018-12-18 18:31:28 -080012932 val = get_param(cmd, "transmitOMI");
12933 if (val && sta_transmit_omi(dut, conn, cmd)) {
12934 send_resp(dut, conn, SIGMA_ERROR,
12935 "ErrorCode,sta_transmit_omi failed");
Jouni Malinen1702fe32021-06-08 19:08:01 +030012936 return STATUS_SENT_ERROR;
Kiran Kumar Lokere29c1bb02018-10-08 17:41:02 -070012937 }
12938
Kiran Kumar Lokerec310dcd2018-12-17 20:56:06 -080012939 val = get_param(cmd, "Powersave");
12940 if (val) {
Vinita S. Malooa8b62722020-04-23 01:45:41 +053012941 int ps;
Kiran Kumar Lokerec310dcd2018-12-17 20:56:06 -080012942
12943 if (strcasecmp(val, "off") == 0) {
Vinita S. Malooa8b62722020-04-23 01:45:41 +053012944 ps = 2;
Kiran Kumar Lokerec310dcd2018-12-17 20:56:06 -080012945 } else if (strcasecmp(val, "on") == 0) {
Vinita S. Malooa8b62722020-04-23 01:45:41 +053012946 ps = 1;
Kiran Kumar Lokerec310dcd2018-12-17 20:56:06 -080012947 } else {
12948 sigma_dut_print(dut, DUT_MSG_ERROR,
12949 "Unsupported Powersave value '%s'",
12950 val);
Jouni Malinen1702fe32021-06-08 19:08:01 +030012951 return INVALID_SEND_STATUS;
Kiran Kumar Lokerec310dcd2018-12-17 20:56:06 -080012952 }
Vinita S. Malooa8b62722020-04-23 01:45:41 +053012953 if (set_power_save_wcn(dut, intf, ps) < 0)
Jouni Malinen1702fe32021-06-08 19:08:01 +030012954 return ERROR_SEND_STATUS;
Kiran Kumar Lokerec310dcd2018-12-17 20:56:06 -080012955 }
12956
Kiran Kumar Lokere2c4b7ce2019-01-30 12:02:28 -080012957 val = get_param(cmd, "MU_EDCA");
12958 if (val) {
12959 if (strcasecmp(val, "Override") == 0) {
12960 if (sta_set_mu_edca_override(dut, intf, 1)) {
12961 send_resp(dut, conn, SIGMA_ERROR,
12962 "errorCode,MU EDCA override set failed");
12963 return STATUS_SENT;
12964 }
12965 } else if (strcasecmp(val, "Disable") == 0) {
12966 if (sta_set_mu_edca_override(dut, intf, 0)) {
12967 send_resp(dut, conn, SIGMA_ERROR,
12968 "errorCode,MU EDCA override disable failed");
12969 return STATUS_SENT;
12970 }
12971 }
12972 }
12973
Kiran Kumar Lokeredd086642020-06-04 00:29:26 -070012974 val = get_param(cmd, "Ch_Pref");
12975 if (val && mbo_set_non_pref_ch_list(dut, conn, intf, cmd) == 0)
12976 return STATUS_SENT;
12977
12978 val = get_param(cmd, "Cellular_Data_Cap");
12979 if (val && mbo_set_cellular_data_capa(dut, conn, intf, atoi(val)) == 0)
12980 return STATUS_SENT;
12981
Jouni Malinen1702fe32021-06-08 19:08:01 +030012982 return SUCCESS_SEND_STATUS;
Amarnath Hullur Subramanyam42c25a02018-01-31 04:02:27 -080012983
12984failed:
12985 free(token);
Jouni Malinen1702fe32021-06-08 19:08:01 +030012986 return ERROR_SEND_STATUS;
Amarnath Hullur Subramanyam42c25a02018-01-31 04:02:27 -080012987}
12988
12989
Jouni Malinen1702fe32021-06-08 19:08:01 +030012990static enum sigma_cmd_result
12991cmd_sta_set_rfeature_he(const char *intf, struct sigma_dut *dut,
12992 struct sigma_conn *conn, struct sigma_cmd *cmd)
Amarnath Hullur Subramanyam42c25a02018-01-31 04:02:27 -080012993{
Jouni Malinen016ae6c2019-11-04 17:00:01 +020012994 switch (get_driver_type(dut)) {
Amarnath Hullur Subramanyam42c25a02018-01-31 04:02:27 -080012995 case DRIVER_WCN:
12996 return wcn_sta_set_rfeature_he(intf, dut, conn, cmd);
12997 default:
12998 send_resp(dut, conn, SIGMA_ERROR,
12999 "errorCode,Unsupported sta_set_rfeature(HE) with the current driver");
Jouni Malinen1702fe32021-06-08 19:08:01 +030013000 return STATUS_SENT_ERROR;
Amarnath Hullur Subramanyam42c25a02018-01-31 04:02:27 -080013001 }
13002}
13003
13004
Kiran Kumar Lokeree580c012019-01-03 17:08:53 -080013005static int cmd_sta_set_power_save_he(const char *intf, struct sigma_dut *dut,
13006 struct sigma_conn *conn,
13007 struct sigma_cmd *cmd)
13008{
13009 const char *val;
13010
13011 val = get_param(cmd, "powersave");
13012 if (val) {
Vinita S. Malooa8b62722020-04-23 01:45:41 +053013013 int ps;
Kiran Kumar Lokeree580c012019-01-03 17:08:53 -080013014
13015 if (strcasecmp(val, "off") == 0) {
Vinita S. Malooa8b62722020-04-23 01:45:41 +053013016 ps = 2;
Kiran Kumar Lokeree580c012019-01-03 17:08:53 -080013017 } else if (strcasecmp(val, "on") == 0) {
Vinita S. Malooa8b62722020-04-23 01:45:41 +053013018 ps = 1;
Kiran Kumar Lokeree580c012019-01-03 17:08:53 -080013019 } else {
13020 sigma_dut_print(dut, DUT_MSG_ERROR,
13021 "Unsupported power save config");
13022 return -1;
13023 }
Vinita S. Malooa8b62722020-04-23 01:45:41 +053013024 if (set_power_save_wcn(dut, intf, ps) < 0)
13025 return 0;
Kiran Kumar Lokeree580c012019-01-03 17:08:53 -080013026 return 1;
13027 }
13028
13029 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Unsupported command");
13030
13031 return 0;
13032}
13033
13034
Ashwini Patil5acd7382017-04-13 15:55:04 +053013035static int btm_query_candidate_list(struct sigma_dut *dut,
13036 struct sigma_conn *conn,
13037 struct sigma_cmd *cmd)
13038{
13039 const char *bssid, *info, *op_class, *ch, *phy_type, *pref;
13040 int len, ret;
13041 char buf[10];
13042
13043 /*
13044 * Neighbor Report elements format:
13045 * neighbor=<BSSID>,<BSSID Information>,<Operating Class>,
13046 * <Channel Number>,<PHY Type>[,<hexdump of Optional Subelements>]
13047 * eg: neighbor=aa:bb:cc:dd:ee:ff,17,81,6,1,030101
13048 */
13049
13050 bssid = get_param(cmd, "Nebor_BSSID");
13051 if (!bssid) {
13052 send_resp(dut, conn, SIGMA_INVALID,
13053 "errorCode,Nebor_BSSID is missing");
13054 return 0;
13055 }
13056
13057 info = get_param(cmd, "Nebor_Bssid_Info");
13058 if (!info) {
13059 sigma_dut_print(dut, DUT_MSG_INFO,
13060 "Using default value for Nebor_Bssid_Info: %s",
13061 DEFAULT_NEIGHBOR_BSSID_INFO);
13062 info = DEFAULT_NEIGHBOR_BSSID_INFO;
13063 }
13064
13065 op_class = get_param(cmd, "Nebor_Op_Class");
13066 if (!op_class) {
13067 send_resp(dut, conn, SIGMA_INVALID,
13068 "errorCode,Nebor_Op_Class is missing");
13069 return 0;
13070 }
13071
13072 ch = get_param(cmd, "Nebor_Op_Ch");
13073 if (!ch) {
13074 send_resp(dut, conn, SIGMA_INVALID,
13075 "errorCode,Nebor_Op_Ch is missing");
13076 return 0;
13077 }
13078
13079 phy_type = get_param(cmd, "Nebor_Phy_Type");
13080 if (!phy_type) {
13081 sigma_dut_print(dut, DUT_MSG_INFO,
13082 "Using default value for Nebor_Phy_Type: %s",
13083 DEFAULT_NEIGHBOR_PHY_TYPE);
13084 phy_type = DEFAULT_NEIGHBOR_PHY_TYPE;
13085 }
13086
13087 /* Parse optional subelements */
13088 buf[0] = '\0';
13089 pref = get_param(cmd, "Nebor_Pref");
13090 if (pref) {
13091 /* hexdump for preferrence subelement */
13092 ret = snprintf(buf, sizeof(buf), ",0301%02x", atoi(pref));
13093 if (ret < 0 || ret >= (int) sizeof(buf)) {
13094 sigma_dut_print(dut, DUT_MSG_ERROR,
13095 "snprintf failed for optional subelement ret: %d",
13096 ret);
13097 send_resp(dut, conn, SIGMA_ERROR,
13098 "errorCode,snprintf failed for subelement");
13099 return 0;
13100 }
13101 }
13102
13103 if (!dut->btm_query_cand_list) {
13104 dut->btm_query_cand_list = calloc(1, NEIGHBOR_REPORT_SIZE);
13105 if (!dut->btm_query_cand_list) {
13106 send_resp(dut, conn, SIGMA_ERROR,
13107 "errorCode,Failed to allocate memory for btm_query_cand_list");
13108 return 0;
13109 }
13110 }
13111
13112 len = strlen(dut->btm_query_cand_list);
13113 ret = snprintf(dut->btm_query_cand_list + len,
13114 NEIGHBOR_REPORT_SIZE - len, " neighbor=%s,%s,%s,%s,%s%s",
13115 bssid, info, op_class, ch, phy_type, buf);
13116 if (ret < 0 || ret >= NEIGHBOR_REPORT_SIZE - len) {
13117 sigma_dut_print(dut, DUT_MSG_ERROR,
13118 "snprintf failed for neighbor report list ret: %d",
13119 ret);
13120 send_resp(dut, conn, SIGMA_ERROR,
13121 "errorCode,snprintf failed for neighbor report");
13122 free(dut->btm_query_cand_list);
13123 dut->btm_query_cand_list = NULL;
13124 return 0;
13125 }
13126
13127 return 1;
13128}
13129
13130
Alexei Avshalom Lazarbc180dc2018-12-18 16:01:14 +020013131int sta_extract_60g_ese(struct sigma_dut *dut, struct sigma_cmd *cmd,
13132 struct sigma_ese_alloc *allocs, int *allocs_size)
13133{
13134 int max_count = *allocs_size;
13135 int count = 0, i;
13136 const char *val;
13137
13138 do {
13139 val = get_param_indexed(cmd, "AllocID", count);
13140 if (val)
13141 count++;
13142 } while (val);
13143
13144 if (count == 0 || count > max_count) {
13145 sigma_dut_print(dut, DUT_MSG_ERROR,
13146 "Invalid number of allocations(%d)", count);
13147 return -1;
13148 }
13149
13150 for (i = 0; i < count; i++) {
13151 val = get_param_indexed(cmd, "PercentBI", i);
13152 if (!val) {
13153 sigma_dut_print(dut, DUT_MSG_ERROR,
13154 "Missing PercentBI parameter at index %d",
13155 i);
13156 return -1;
13157 }
13158 allocs[i].percent_bi = atoi(val);
13159
13160 val = get_param_indexed(cmd, "SrcAID", i);
13161 if (val)
13162 allocs[i].src_aid = strtol(val, NULL, 0);
13163 else
13164 allocs[i].src_aid = ESE_BCAST_AID;
13165
13166 val = get_param_indexed(cmd, "DestAID", i);
13167 if (val)
13168 allocs[i].dst_aid = strtol(val, NULL, 0);
13169 else
13170 allocs[i].dst_aid = ESE_BCAST_AID;
13171
13172 allocs[i].type = ESE_CBAP;
13173 sigma_dut_print(dut, DUT_MSG_INFO,
13174 "Alloc %d PercentBI %d SrcAID %d DstAID %d",
13175 i, allocs[i].percent_bi, allocs[i].src_aid,
13176 allocs[i].dst_aid);
13177 }
13178
13179 *allocs_size = count;
13180 return 0;
13181}
13182
13183
13184static int sta_set_60g_ese(struct sigma_dut *dut, int count,
13185 struct sigma_ese_alloc *allocs)
13186{
Jouni Malinen016ae6c2019-11-04 17:00:01 +020013187 switch (get_driver_type(dut)) {
Alexei Avshalom Lazarbc180dc2018-12-18 16:01:14 +020013188#ifdef __linux__
13189 case DRIVER_WIL6210:
13190 if (wil6210_set_ese(dut, count, allocs))
13191 return -1;
13192 return 1;
13193#endif /* __linux__ */
13194 default:
13195 sigma_dut_print(dut, DUT_MSG_ERROR,
13196 "Unsupported sta_set_60g_ese with the current driver");
13197 return -1;
13198 }
13199}
13200
13201
13202static int cmd_sta_set_rfeature_60g(const char *intf, struct sigma_dut *dut,
13203 struct sigma_conn *conn,
13204 struct sigma_cmd *cmd)
13205{
13206 const char *val;
13207
13208 val = get_param(cmd, "ExtSchIE");
13209 if (val && !strcasecmp(val, "Enable")) {
13210 struct sigma_ese_alloc allocs[MAX_ESE_ALLOCS];
13211 int count = MAX_ESE_ALLOCS;
13212
13213 if (sta_extract_60g_ese(dut, cmd, allocs, &count))
13214 return -1;
13215 return sta_set_60g_ese(dut, count, allocs);
13216 }
13217
Alexei Avshalom Lazaraad97b02018-12-18 16:01:23 +020013218 val = get_param(cmd, "MCS_FixedRate");
13219 if (val) {
13220 int sta_mcs = atoi(val);
13221
13222 sigma_dut_print(dut, DUT_MSG_INFO, "Force STA MCS to %d",
13223 sta_mcs);
13224 wil6210_set_force_mcs(dut, 1, sta_mcs);
13225
Jouni Malinen0e29cf22019-02-19 01:13:21 +020013226 return SUCCESS_SEND_STATUS;
Alexei Avshalom Lazaraad97b02018-12-18 16:01:23 +020013227 }
13228
Alexei Avshalom Lazarbc180dc2018-12-18 16:01:14 +020013229 send_resp(dut, conn, SIGMA_ERROR,
13230 "errorCode,Invalid sta_set_rfeature(60G)");
Jouni Malinen0e29cf22019-02-19 01:13:21 +020013231 return STATUS_SENT;
Alexei Avshalom Lazarbc180dc2018-12-18 16:01:14 +020013232}
13233
13234
Veerendranath Jakkam76a845c2020-07-14 13:19:40 +053013235static int wcn_sta_override_oci(struct sigma_dut *dut, const char *intf,
13236 const char *oci_frametype, uint32_t oci_freq)
13237{
13238#ifdef NL80211_SUPPORT
13239 struct nl_msg *msg;
13240 int ret = 0;
13241 struct nlattr *params;
13242 struct nlattr *attr;
13243 int ifindex;
13244 u8 frame_type;
13245
13246 ifindex = if_nametoindex(intf);
13247 if (ifindex == 0) {
13248 sigma_dut_print(dut, DUT_MSG_ERROR,
13249 "%s: Index for interface %s failed",
13250 __func__, intf);
13251 return -1;
13252 }
13253
13254 if (strcasecmp(oci_frametype, "SAQueryReq") == 0) {
13255 frame_type = QCA_WLAN_VENDOR_OCI_OVERRIDE_FRAME_SA_QUERY_REQ;
13256 } else if (strcasecmp(oci_frametype, "SAQueryResp") == 0) {
13257 frame_type = QCA_WLAN_VENDOR_OCI_OVERRIDE_FRAME_SA_QUERY_RESP;
13258 } else if (strcasecmp(oci_frametype, "Reassocreq") == 0) {
13259 frame_type = QCA_WLAN_VENDOR_OCI_OVERRIDE_FRAME_FT_REASSOC_REQ;
13260 } else {
13261 sigma_dut_print(dut, DUT_MSG_ERROR, "%s: Unknown frametype %s",
13262 __func__, oci_frametype);
13263 return -1;
13264 }
13265
13266
13267 if (!(msg = nl80211_drv_msg(dut, dut->nl_ctx, ifindex, 0,
13268 NL80211_CMD_VENDOR)) ||
13269 nla_put_u32(msg, NL80211_ATTR_IFINDEX, ifindex) ||
13270 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
13271 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
13272 QCA_NL80211_VENDOR_SUBCMD_WIFI_TEST_CONFIGURATION) ||
13273 !(attr = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA)) ||
13274 !(params = nla_nest_start(
13275 msg,
13276 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_OCI_OVERRIDE)) ||
13277 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_OCI_OVERRIDE_FRAME_TYPE,
13278 frame_type) ||
13279 nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_OCI_OVERRIDE_FREQUENCY,
13280 oci_freq)) {
13281 sigma_dut_print(dut, DUT_MSG_ERROR,
13282 "%s: err in adding vendor_cmd and vendor_data",
13283 __func__);
13284 nlmsg_free(msg);
13285 return -1;
13286 }
13287 nla_nest_end(msg, params);
13288 nla_nest_end(msg, attr);
13289
13290 ret = send_and_recv_msgs(dut, dut->nl_ctx, msg, NULL, NULL);
13291 if (ret) {
13292 sigma_dut_print(dut, DUT_MSG_ERROR,
13293 "%s: err in send_and_recv_msgs, ret=%d",
13294 __func__, ret);
13295 }
13296 return ret;
13297#else /* NL80211_SUPPORT */
13298 sigma_dut_print(dut, DUT_MSG_ERROR,
13299 "OCI override not possible without NL80211_SUPPORT defined");
13300 return -1;
13301#endif /* NL80211_SUPPORT */
13302}
13303
13304
Veerendranath Jakkam50d5c782020-07-22 01:59:01 +053013305static int wcn_sta_ignore_csa(struct sigma_dut *dut, const char *intf,
13306 uint8_t ignore_csa)
13307{
13308#ifdef NL80211_SUPPORT
13309 return wcn_wifi_test_config_set_u8(
13310 dut, intf,
13311 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_IGNORE_CSA, ignore_csa);
13312#else /* NL80211_SUPPORT */
13313 sigma_dut_print(dut, DUT_MSG_ERROR,
13314 "IgnoreCSA can't be set without NL80211_SUPPORT defined");
13315 return -1;
13316#endif /* NL80211_SUPPORT */
13317}
13318
13319
Veerendranath Jakkamc771fac2020-07-22 01:32:56 +053013320static int wcn_sta_set_rsnxe_used(struct sigma_dut *dut, const char *intf,
13321 uint8_t rsnxe_used)
13322{
13323#ifdef NL80211_SUPPORT
13324 return wcn_wifi_test_config_set_u8(
13325 dut, intf,
13326 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_FT_REASSOCREQ_RSNXE_USED,
13327 rsnxe_used);
13328#else /* NL80211_SUPPORT */
13329 sigma_dut_print(dut, DUT_MSG_ERROR,
13330 "RSNXE_Used can't be set without NL80211_SUPPORT defined");
13331 return -1;
13332#endif /* NL80211_SUPPORT */
13333}
13334
13335
Veerendranath Jakkam1e1e5fd2020-09-10 07:12:37 +053013336static int wcn_sta_ignore_sa_query_timeout(struct sigma_dut *dut,
13337 const char *intf,
13338 uint8_t ignore_sa_query_timeout)
13339{
13340#ifdef NL80211_SUPPORT
13341 return wcn_wifi_test_config_set_u8(
13342 dut, intf,
13343 QCA_WLAN_VENDOR_ATTR_WIFI_TEST_CONFIG_IGNORE_SA_QUERY_TIMEOUT,
13344 ignore_sa_query_timeout);
13345#else /* NL80211_SUPPORT */
13346 sigma_dut_print(dut, DUT_MSG_ERROR,
13347 "Ignore SA Query timeout can't be set without NL80211_SUPPORT defined");
13348 return -1;
13349#endif /* NL80211_SUPPORT */
13350}
13351
13352
Jouni Malinen6250cb02020-04-15 13:54:45 +030013353static enum sigma_cmd_result
13354cmd_sta_set_rfeature_wpa3(const char *intf, struct sigma_dut *dut,
13355 struct sigma_conn *conn,
13356 struct sigma_cmd *cmd)
13357{
Vamsi Krishnad29bc762020-05-08 23:23:30 +053013358 const char *val, *oci_chan, *oci_frametype;
Jouni Malinen6250cb02020-04-15 13:54:45 +030013359
Veerendranath Jakkam30bf9072020-04-16 14:37:57 +053013360 val = get_param(cmd, "ReassocReq_RSNXE_Used");
Jouni Malinen6250cb02020-04-15 13:54:45 +030013361 if (val && atoi(val) == 1) {
Veerendranath Jakkamc771fac2020-07-22 01:32:56 +053013362 if (wifi_chip_type == DRIVER_WCN) {
13363 if (wcn_sta_set_rsnxe_used(dut, intf, 1)) {
13364 send_resp(dut, conn, SIGMA_ERROR,
13365 "errorCode,Failed to set ft_rsnxe_used");
13366 return STATUS_SENT_ERROR;
13367 }
13368 return SUCCESS_SEND_STATUS;
13369 } else if (wpa_command(intf, "SET ft_rsnxe_used 1") < 0) {
Jouni Malinen6250cb02020-04-15 13:54:45 +030013370 send_resp(dut, conn, SIGMA_ERROR,
13371 "errorCode,Failed to set ft_rsnxe_used");
13372 return STATUS_SENT_ERROR;
13373 }
13374 return SUCCESS_SEND_STATUS;
13375 }
Vamsi Krishnad29bc762020-05-08 23:23:30 +053013376
13377 oci_chan = get_param(cmd, "OCIChannel");
13378 oci_frametype = get_param(cmd, "OCIFrameType");
13379 if (oci_chan && oci_frametype) {
13380 unsigned int oci_freq = channel_to_freq(dut, atoi(oci_chan));
13381 char buf[100];
13382
13383 if (!oci_freq) {
13384 send_resp(dut, conn, SIGMA_ERROR,
13385 "errorCode,Invalid OCIChannel number");
13386 return STATUS_SENT_ERROR;
13387 }
13388
Veerendranath Jakkam76a845c2020-07-14 13:19:40 +053013389 if (wifi_chip_type == DRIVER_WCN &&
13390 (strcasecmp(oci_frametype, "SAQueryReq") == 0 ||
13391 strcasecmp(oci_frametype, "SAQueryResp") == 0 ||
13392 strcasecmp(oci_frametype, "Reassocreq") == 0)) {
13393 if (wcn_sta_override_oci(dut, intf, oci_frametype,
13394 oci_freq)) {
13395 send_resp(dut, conn, SIGMA_ERROR,
13396 "errorCode,Failed to override OCI");
13397 return STATUS_SENT_ERROR;
13398 }
13399 return SUCCESS_SEND_STATUS;
13400 }
13401
Vamsi Krishnad29bc762020-05-08 23:23:30 +053013402 if (strcasecmp(oci_frametype, "eapolM2") == 0) {
13403 snprintf(buf, sizeof(buf),
13404 "SET oci_freq_override_eapol %d", oci_freq);
13405 } else if (strcasecmp(oci_frametype, "SAQueryReq") == 0) {
13406 snprintf(buf, sizeof(buf),
13407 "SET oci_freq_override_saquery_req %d",
13408 oci_freq);
13409 } else if (strcasecmp(oci_frametype, "SAQueryResp") == 0) {
13410 snprintf(buf, sizeof(buf),
13411 "SET oci_freq_override_saquery_resp %d",
13412 oci_freq);
Veerendranath Jakkam76a845c2020-07-14 13:19:40 +053013413 } else if (strcasecmp(oci_frametype, "GrpKeyM2") == 0) {
13414 snprintf(buf, sizeof(buf),
13415 "SET oci_freq_override_eapol_g2 %d",
13416 oci_freq);
13417 } else if (strcasecmp(oci_frametype, "Reassocreq") == 0) {
13418 snprintf(buf, sizeof(buf),
13419 "SET oci_freq_override_ft_assoc %d",
13420 oci_freq);
Vamsi Krishnad29bc762020-05-08 23:23:30 +053013421 } else {
13422 send_resp(dut, conn, SIGMA_ERROR,
13423 "errorCode,Unsupported OCIFrameType");
13424 return STATUS_SENT_ERROR;
13425 }
13426 if (wpa_command(intf, buf) < 0) {
13427 send_resp(dut, conn, SIGMA_ERROR,
13428 "errorCode,Failed to set oci_freq_override");
13429 return STATUS_SENT_ERROR;
13430 }
13431 return SUCCESS_SEND_STATUS;
13432 }
13433
Veerendranath Jakkam50d5c782020-07-22 01:59:01 +053013434 val = get_param(cmd, "IgnoreCSA");
13435 if (val && atoi(val) == 1) {
13436 if (wifi_chip_type == DRIVER_WCN) {
13437 if (wcn_sta_ignore_csa(dut, intf, 1)) {
13438 send_resp(dut, conn, SIGMA_ERROR,
13439 "errorCode,Failed to set ignore CSA");
13440 return STATUS_SENT_ERROR;
13441 }
13442 return SUCCESS_SEND_STATUS;
13443 }
13444 }
13445
Veerendranath Jakkam1e1e5fd2020-09-10 07:12:37 +053013446 val = get_param(cmd, "Deauth_Per_SAQueryResp");
13447 if (val && atoi(val) == 0) {
13448 if (wifi_chip_type == DRIVER_WCN) {
13449 if (wcn_sta_ignore_sa_query_timeout(dut, intf, 1)) {
13450 send_resp(dut, conn, SIGMA_ERROR,
13451 "errorCode,Failed to set ignore SA Query timeout");
13452 return STATUS_SENT_ERROR;
13453 }
13454 return SUCCESS_SEND_STATUS;
13455 }
13456 }
13457
Jouni Malinen6250cb02020-04-15 13:54:45 +030013458 send_resp(dut, conn, SIGMA_ERROR,
13459 "errorCode,Unsupported WPA3 rfeature");
13460 return STATUS_SENT_ERROR;
13461}
13462
13463
Jouni Malinenf7222712019-06-13 01:50:21 +030013464static enum sigma_cmd_result cmd_sta_set_rfeature(struct sigma_dut *dut,
13465 struct sigma_conn *conn,
13466 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020013467{
13468 const char *intf = get_param(cmd, "Interface");
13469 const char *prog = get_param(cmd, "Prog");
Ashwini Patil68d02cd2017-01-10 15:39:16 +053013470 const char *val;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020013471
13472 if (intf == NULL || prog == NULL)
13473 return -1;
13474
Ashwini Patil5acd7382017-04-13 15:55:04 +053013475 /* BSS Transition candidate list for BTM query */
13476 val = get_param(cmd, "Nebor_BSSID");
13477 if (val && btm_query_candidate_list(dut, conn, cmd) == 0)
13478 return 0;
13479
Jouni Malinencd4e3c32015-10-29 12:39:56 +020013480 if (strcasecmp(prog, "TDLS") == 0)
13481 return cmd_sta_set_rfeature_tdls(intf, dut, conn, cmd);
13482
13483 if (strcasecmp(prog, "VHT") == 0)
13484 return cmd_sta_set_rfeature_vht(intf, dut, conn, cmd);
13485
Amarnath Hullur Subramanyam42c25a02018-01-31 04:02:27 -080013486 if (strcasecmp(prog, "HE") == 0)
13487 return cmd_sta_set_rfeature_he(intf, dut, conn, cmd);
13488
Ashwini Patil68d02cd2017-01-10 15:39:16 +053013489 if (strcasecmp(prog, "MBO") == 0) {
13490 val = get_param(cmd, "Cellular_Data_Cap");
13491 if (val &&
13492 mbo_set_cellular_data_capa(dut, conn, intf, atoi(val)) == 0)
13493 return 0;
Ashwini Patil00402582017-04-13 12:29:39 +053013494
13495 val = get_param(cmd, "Ch_Pref");
13496 if (val && mbo_set_non_pref_ch_list(dut, conn, intf, cmd) == 0)
13497 return 0;
13498
Ashwini Patil68d02cd2017-01-10 15:39:16 +053013499 return 1;
13500 }
13501
Alexei Avshalom Lazarbc180dc2018-12-18 16:01:14 +020013502 if (strcasecmp(prog, "60GHz") == 0)
13503 return cmd_sta_set_rfeature_60g(intf, dut, conn, cmd);
13504
Jouni Malinen6250cb02020-04-15 13:54:45 +030013505 if (strcasecmp(prog, "WPA3") == 0)
13506 return cmd_sta_set_rfeature_wpa3(intf, dut, conn, cmd);
13507
Jouni Malinencd4e3c32015-10-29 12:39:56 +020013508 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Unsupported Prog");
13509 return 0;
13510}
13511
13512
Jouni Malinenf7222712019-06-13 01:50:21 +030013513static enum sigma_cmd_result cmd_sta_set_radio(struct sigma_dut *dut,
13514 struct sigma_conn *conn,
13515 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020013516{
13517 const char *intf = get_param(cmd, "Interface");
13518 const char *mode = get_param(cmd, "Mode");
13519 int res;
13520
13521 if (intf == NULL || mode == NULL)
13522 return -1;
13523
13524 if (strcasecmp(mode, "On") == 0)
13525 res = wpa_command(intf, "SET radio_disabled 0");
13526 else if (strcasecmp(mode, "Off") == 0)
13527 res = wpa_command(intf, "SET radio_disabled 1");
13528 else
13529 return -1;
13530
13531 if (res) {
13532 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Failed to change "
13533 "radio mode");
13534 return 0;
13535 }
13536
13537 return 1;
13538}
13539
13540
Jouni Malinenf7222712019-06-13 01:50:21 +030013541static enum sigma_cmd_result cmd_sta_set_pwrsave(struct sigma_dut *dut,
13542 struct sigma_conn *conn,
13543 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020013544{
13545 const char *intf = get_param(cmd, "Interface");
13546 const char *mode = get_param(cmd, "Mode");
Alexei Avshalom Lazare49e3872018-12-23 17:26:57 +020013547 const char *prog = get_param(cmd, "program");
13548 const char *powersave = get_param(cmd, "powersave");
13549 int res = 0;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020013550
Alexei Avshalom Lazare49e3872018-12-23 17:26:57 +020013551 if (intf == NULL)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020013552 return -1;
13553
Alexei Avshalom Lazare49e3872018-12-23 17:26:57 +020013554 if (prog && strcasecmp(prog, "60GHz") == 0) {
13555 /*
13556 * The CAPI mode parameter does not exist in 60G
13557 * unscheduled PS.
13558 */
Hu Wang5dc3ff12019-06-14 15:14:26 +080013559 if (powersave && strcasecmp(powersave, "unscheduled") == 0)
Alexei Avshalom Lazare49e3872018-12-23 17:26:57 +020013560 res = set_ps(intf, dut, 1);
Jouni Malinen016ae6c2019-11-04 17:00:01 +020013561 } else if (prog && get_driver_type(dut) == DRIVER_WCN &&
Alexei Avshalom Lazar2f6fdb42019-02-04 14:16:08 +020013562 strcasecmp(prog, "HE") == 0) {
13563 return cmd_sta_set_power_save_he(intf, dut, conn, cmd);
Alexei Avshalom Lazare49e3872018-12-23 17:26:57 +020013564 } else {
13565 if (mode == NULL)
13566 return -1;
13567
13568 if (strcasecmp(mode, "On") == 0)
13569 res = set_ps(intf, dut, 1);
13570 else if (strcasecmp(mode, "Off") == 0)
13571 res = set_ps(intf, dut, 0);
13572 else
13573 return -1;
13574 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +020013575
13576 if (res) {
13577 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Failed to change "
13578 "power save mode");
13579 return 0;
13580 }
13581
13582 return 1;
13583}
13584
13585
Jouni Malinenf7222712019-06-13 01:50:21 +030013586static enum sigma_cmd_result cmd_sta_bssid_pool(struct sigma_dut *dut,
13587 struct sigma_conn *conn,
13588 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020013589{
13590 const char *intf = get_param(cmd, "Interface");
13591 const char *val, *bssid;
13592 int res;
13593 char *buf;
13594 size_t buf_len;
13595
13596 val = get_param(cmd, "BSSID_FILTER");
13597 if (val == NULL)
13598 return -1;
13599
13600 bssid = get_param(cmd, "BSSID_List");
13601 if (atoi(val) == 0 || bssid == NULL) {
13602 /* Disable BSSID filter */
13603 if (wpa_command(intf, "SET bssid_filter ")) {
13604 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Failed "
13605 "to disable BSSID filter");
13606 return 0;
13607 }
13608
13609 return 1;
13610 }
13611
13612 buf_len = 100 + strlen(bssid);
13613 buf = malloc(buf_len);
13614 if (buf == NULL)
13615 return -1;
13616
13617 snprintf(buf, buf_len, "SET bssid_filter %s", bssid);
13618 res = wpa_command(intf, buf);
13619 free(buf);
13620 if (res) {
13621 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Failed to enable "
13622 "BSSID filter");
13623 return 0;
13624 }
13625
13626 return 1;
13627}
13628
13629
Jouni Malinenf7222712019-06-13 01:50:21 +030013630static enum sigma_cmd_result cmd_sta_reset_parm(struct sigma_dut *dut,
13631 struct sigma_conn *conn,
13632 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020013633{
13634 const char *intf = get_param(cmd, "Interface");
13635 const char *val;
13636
13637 /* TODO: ARP */
13638
13639 val = get_param(cmd, "HS2_CACHE_PROFILE");
13640 if (val && strcasecmp(val, "All") == 0)
13641 hs2_clear_credentials(intf);
13642
13643 return 1;
13644}
13645
13646
Jouni Malinenf7222712019-06-13 01:50:21 +030013647static enum sigma_cmd_result cmd_sta_get_key(struct sigma_dut *dut,
13648 struct sigma_conn *conn,
13649 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020013650{
13651 const char *intf = get_param(cmd, "Interface");
13652 const char *key_type = get_param(cmd, "KeyType");
13653 char buf[100], resp[200];
13654
13655 if (key_type == NULL)
13656 return -1;
13657
13658 if (strcasecmp(key_type, "GTK") == 0) {
13659 if (wpa_command_resp(intf, "GET gtk", buf, sizeof(buf)) < 0 ||
13660 strncmp(buf, "FAIL", 4) == 0) {
13661 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Could "
13662 "not fetch current GTK");
13663 return 0;
13664 }
13665 snprintf(resp, sizeof(resp), "KeyValue,%s", buf);
13666 send_resp(dut, conn, SIGMA_COMPLETE, resp);
13667 return 0;
13668 } else {
13669 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Unsupported "
13670 "KeyType");
13671 return 0;
13672 }
13673
13674 return 1;
13675}
13676
13677
13678static int hs2_set_policy(struct sigma_dut *dut)
13679{
13680#ifdef ANDROID
13681 system("ip rule del prio 23000");
13682 if (system("ip rule add from all lookup main prio 23000") != 0) {
13683 sigma_dut_print(dut, DUT_MSG_ERROR,
13684 "Failed to run:ip rule add from all lookup main prio");
13685 return -1;
13686 }
13687 if (system("ip route flush cache") != 0) {
13688 sigma_dut_print(dut, DUT_MSG_ERROR,
13689 "Failed to run ip route flush cache");
13690 return -1;
13691 }
13692 return 1;
13693#else /* ANDROID */
13694 return 0;
13695#endif /* ANDROID */
13696}
13697
13698
Jouni Malinenf7222712019-06-13 01:50:21 +030013699static enum sigma_cmd_result cmd_sta_hs2_associate(struct sigma_dut *dut,
13700 struct sigma_conn *conn,
13701 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020013702{
13703 const char *intf = get_param(cmd, "Interface");
13704 const char *val = get_param(cmd, "Ignore_blacklist");
Jouni Malinen439352d2018-09-13 03:42:23 +030013705 const char *band = get_param(cmd, "Band");
Jouni Malinencd4e3c32015-10-29 12:39:56 +020013706 struct wpa_ctrl *ctrl;
Jouni Malinen3aa72862019-05-29 23:14:51 +030013707 int res, r;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020013708 char bssid[20], ssid[40], resp[100], buf[100], blacklisted[100];
13709 int tries = 0;
13710 int ignore_blacklist = 0;
13711 const char *events[] = {
13712 "CTRL-EVENT-CONNECTED",
13713 "INTERWORKING-BLACKLISTED",
13714 "INTERWORKING-NO-MATCH",
13715 NULL
13716 };
13717
13718 start_sta_mode(dut);
13719
Jouni Malinen439352d2018-09-13 03:42:23 +030013720 if (band) {
13721 if (strcmp(band, "2.4") == 0) {
13722 wpa_command(intf, "SET setband 2G");
13723 } else if (strcmp(band, "5") == 0) {
13724 wpa_command(intf, "SET setband 5G");
13725 } else {
13726 send_resp(dut, conn, SIGMA_ERROR,
13727 "errorCode,Unsupported band");
13728 return 0;
13729 }
13730 }
13731
Jouni Malinencd4e3c32015-10-29 12:39:56 +020013732 blacklisted[0] = '\0';
13733 if (val && atoi(val))
13734 ignore_blacklist = 1;
13735
13736try_again:
13737 ctrl = open_wpa_mon(intf);
13738 if (ctrl == NULL) {
13739 sigma_dut_print(dut, DUT_MSG_ERROR, "Failed to open "
13740 "wpa_supplicant monitor connection");
13741 return -2;
13742 }
13743
13744 tries++;
13745 if (wpa_command(intf, "INTERWORKING_SELECT auto")) {
13746 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Failed to start "
13747 "Interworking connection");
13748 wpa_ctrl_detach(ctrl);
13749 wpa_ctrl_close(ctrl);
13750 return 0;
13751 }
13752
13753 buf[0] = '\0';
13754 while (1) {
13755 char *pos;
13756 res = get_wpa_cli_events(dut, ctrl, events, buf, sizeof(buf));
13757 pos = strstr(buf, "INTERWORKING-BLACKLISTED");
13758 if (!pos)
13759 break;
13760 pos += 25;
13761 sigma_dut_print(dut, DUT_MSG_DEBUG, "Found blacklisted AP: %s",
13762 pos);
13763 if (!blacklisted[0])
13764 memcpy(blacklisted, pos, strlen(pos) + 1);
13765 }
13766
13767 if (ignore_blacklist && blacklisted[0]) {
13768 char *end;
13769 end = strchr(blacklisted, ' ');
13770 if (end)
13771 *end = '\0';
13772 sigma_dut_print(dut, DUT_MSG_DEBUG, "Try to connect to a blacklisted network: %s",
13773 blacklisted);
Jouni Malinen3aa72862019-05-29 23:14:51 +030013774 r = snprintf(buf, sizeof(buf), "INTERWORKING_CONNECT %s",
13775 blacklisted);
13776 if (r < 0 || r >= sizeof(buf) || wpa_command(intf, buf)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +020013777 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Failed to start Interworking connection to blacklisted network");
13778 wpa_ctrl_detach(ctrl);
13779 wpa_ctrl_close(ctrl);
13780 return 0;
13781 }
13782 res = get_wpa_cli_event(dut, ctrl, "CTRL-EVENT-CONNECTED",
13783 buf, sizeof(buf));
13784 }
13785
13786 wpa_ctrl_detach(ctrl);
13787 wpa_ctrl_close(ctrl);
13788
13789 if (res < 0) {
13790 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,Could not "
13791 "connect");
13792 return 0;
13793 }
13794
13795 if (strstr(buf, "INTERWORKING-NO-MATCH") ||
13796 strstr(buf, "INTERWORKING-BLACKLISTED")) {
13797 if (tries < 2) {
13798 sigma_dut_print(dut, DUT_MSG_INFO, "No match found - try again to verify no APs were missed in the scan");
13799 goto try_again;
13800 }
13801 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,No network with "
13802 "matching credentials found");
13803 return 0;
13804 }
13805
13806 if (get_wpa_status(intf, "bssid", bssid, sizeof(bssid)) < 0 ||
13807 get_wpa_status(intf, "ssid", ssid, sizeof(ssid)) < 0) {
13808 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,Could not "
13809 "get current BSSID/SSID");
13810 return 0;
13811 }
13812
13813 snprintf(resp, sizeof(resp), "SSID,%s,BSSID,%s", ssid, bssid);
13814 send_resp(dut, conn, SIGMA_COMPLETE, resp);
13815 hs2_set_policy(dut);
13816 return 0;
13817}
13818
13819
Jouni Malinenf7222712019-06-13 01:50:21 +030013820static enum sigma_cmd_result cmd_sta_hs2_venue_info(struct sigma_dut *dut,
13821 struct sigma_conn *conn,
13822 struct sigma_cmd *cmd)
Jouni Malinenb639f1c2018-09-13 02:39:46 +030013823{
13824 const char *intf = get_param(cmd, "Interface");
13825 const char *display = get_param(cmd, "Display");
13826 struct wpa_ctrl *ctrl;
13827 char buf[300], params[400], *pos;
13828 char bssid[20];
13829 int info_avail = 0;
13830 unsigned int old_timeout;
13831 int res;
13832
13833 if (get_wpa_status(intf, "bssid", bssid, sizeof(bssid)) < 0) {
13834 send_resp(dut, conn, SIGMA_ERROR,
13835 "ErrorCode,Could not get current BSSID");
13836 return 0;
13837 }
13838 ctrl = open_wpa_mon(intf);
13839 if (!ctrl) {
13840 sigma_dut_print(dut, DUT_MSG_ERROR,
13841 "Failed to open wpa_supplicant monitor connection");
13842 return -2;
13843 }
13844
13845 snprintf(buf, sizeof(buf), "ANQP_GET %s 277", bssid);
13846 wpa_command(intf, buf);
13847
13848 res = get_wpa_cli_event(dut, ctrl, "GAS-QUERY-DONE", buf, sizeof(buf));
13849 if (res < 0) {
13850 send_resp(dut, conn, SIGMA_ERROR,
13851 "ErrorCode,Could not complete GAS query");
13852 goto fail;
13853 }
13854
13855 old_timeout = dut->default_timeout;
13856 dut->default_timeout = 2;
13857 res = get_wpa_cli_event(dut, ctrl, "RX-VENUE-URL", buf, sizeof(buf));
13858 dut->default_timeout = old_timeout;
13859 if (res < 0)
13860 goto done;
13861 pos = strchr(buf, ' ');
13862 if (!pos)
13863 goto done;
13864 pos++;
13865 pos = strchr(pos, ' ');
13866 if (!pos)
13867 goto done;
13868 pos++;
13869 info_avail = 1;
13870 snprintf(params, sizeof(params), "browser %s", pos);
13871
13872 if (display && strcasecmp(display, "Yes") == 0) {
13873 pid_t pid;
13874
13875 pid = fork();
13876 if (pid < 0) {
13877 perror("fork");
13878 return -1;
13879 }
13880
13881 if (pid == 0) {
13882 run_hs20_osu(dut, params);
13883 exit(0);
13884 }
13885 }
13886
13887done:
13888 snprintf(buf, sizeof(buf), "Info_available,%s",
13889 info_avail ? "Yes" : "No");
13890 send_resp(dut, conn, SIGMA_COMPLETE, buf);
13891fail:
13892 wpa_ctrl_detach(ctrl);
13893 wpa_ctrl_close(ctrl);
13894 return 0;
13895}
13896
13897
Jouni Malinencd4e3c32015-10-29 12:39:56 +020013898static int sta_add_credential_uname_pwd(struct sigma_dut *dut,
13899 struct sigma_conn *conn,
13900 const char *ifname,
13901 struct sigma_cmd *cmd)
13902{
13903 const char *val;
13904 int id;
13905
13906 id = add_cred(ifname);
13907 if (id < 0)
13908 return -2;
13909 sigma_dut_print(dut, DUT_MSG_DEBUG, "Adding credential %d", id);
13910
13911 val = get_param(cmd, "prefer");
13912 if (val && atoi(val) > 0)
13913 set_cred(ifname, id, "priority", "1");
13914
13915 val = get_param(cmd, "REALM");
13916 if (val && set_cred_quoted(ifname, id, "realm", val) < 0) {
13917 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Could not set "
13918 "realm");
13919 return 0;
13920 }
13921
13922 val = get_param(cmd, "HOME_FQDN");
13923 if (val && set_cred_quoted(ifname, id, "domain", val) < 0) {
13924 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Could not set "
13925 "home_fqdn");
13926 return 0;
13927 }
13928
13929 val = get_param(cmd, "Username");
13930 if (val && set_cred_quoted(ifname, id, "username", val) < 0) {
13931 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Could not set "
13932 "username");
13933 return 0;
13934 }
13935
13936 val = get_param(cmd, "Password");
13937 if (val && set_cred_quoted(ifname, id, "password", val) < 0) {
13938 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Could not set "
13939 "password");
13940 return 0;
13941 }
13942
13943 val = get_param(cmd, "ROOT_CA");
13944 if (val) {
13945 char fname[200];
13946 snprintf(fname, sizeof(fname), "%s/%s", sigma_cert_path, val);
13947#ifdef __linux__
13948 if (!file_exists(fname)) {
13949 char msg[300];
13950 snprintf(msg, sizeof(msg), "ErrorCode,ROOT_CA "
13951 "file (%s) not found", fname);
13952 send_resp(dut, conn, SIGMA_ERROR, msg);
13953 return 0;
13954 }
13955#endif /* __linux__ */
13956 if (set_cred_quoted(ifname, id, "ca_cert", fname) < 0) {
13957 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Could "
13958 "not set root CA");
13959 return 0;
13960 }
13961 }
13962
13963 return 1;
13964}
13965
13966
13967static int update_devdetail_imsi(struct sigma_dut *dut, const char *imsi)
13968{
13969 FILE *in, *out;
13970 char buf[500];
13971 int found = 0;
13972
13973 in = fopen("devdetail.xml", "r");
13974 if (in == NULL)
13975 return -1;
13976 out = fopen("devdetail.xml.tmp", "w");
13977 if (out == NULL) {
13978 fclose(in);
13979 return -1;
13980 }
13981
13982 while (fgets(buf, sizeof(buf), in)) {
13983 char *pos = strstr(buf, "<IMSI>");
13984 if (pos) {
13985 sigma_dut_print(dut, DUT_MSG_INFO, "Updated DevDetail IMSI to %s",
13986 imsi);
13987 pos += 6;
13988 *pos = '\0';
13989 fprintf(out, "%s%s</IMSI>\n", buf, imsi);
13990 found++;
13991 } else {
13992 fprintf(out, "%s", buf);
13993 }
13994 }
13995
13996 fclose(out);
13997 fclose(in);
13998 if (found)
13999 rename("devdetail.xml.tmp", "devdetail.xml");
14000 else
14001 unlink("devdetail.xml.tmp");
14002
14003 return 0;
14004}
14005
14006
14007static int sta_add_credential_sim(struct sigma_dut *dut,
14008 struct sigma_conn *conn,
14009 const char *ifname, struct sigma_cmd *cmd)
14010{
14011 const char *val, *imsi = NULL;
14012 int id;
14013 char buf[200];
14014 int res;
14015 const char *pos;
14016 size_t mnc_len;
14017 char plmn_mcc[4];
14018 char plmn_mnc[4];
14019
14020 id = add_cred(ifname);
14021 if (id < 0)
14022 return -2;
14023 sigma_dut_print(dut, DUT_MSG_DEBUG, "Adding credential %d", id);
14024
14025 val = get_param(cmd, "prefer");
14026 if (val && atoi(val) > 0)
14027 set_cred(ifname, id, "priority", "1");
14028
14029 val = get_param(cmd, "PLMN_MCC");
14030 if (val == NULL) {
14031 send_resp(dut, conn, SIGMA_ERROR,
14032 "errorCode,Missing PLMN_MCC");
14033 return 0;
14034 }
14035 if (strlen(val) != 3) {
14036 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,Invalid MCC");
14037 return 0;
14038 }
14039 snprintf(plmn_mcc, sizeof(plmn_mcc), "%s", val);
14040
14041 val = get_param(cmd, "PLMN_MNC");
14042 if (val == NULL) {
14043 send_resp(dut, conn, SIGMA_ERROR,
14044 "errorCode,Missing PLMN_MNC");
14045 return 0;
14046 }
14047 if (strlen(val) != 2 && strlen(val) != 3) {
14048 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,Invalid MNC");
14049 return 0;
14050 }
14051 snprintf(plmn_mnc, sizeof(plmn_mnc), "%s", val);
14052
14053 val = get_param(cmd, "IMSI");
14054 if (val == NULL) {
14055 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Missing SIM "
14056 "IMSI");
14057 return 0;
14058 }
14059
14060 imsi = pos = val;
14061
14062 if (strncmp(plmn_mcc, pos, 3) != 0) {
14063 send_resp(dut, conn, SIGMA_ERROR, "errorCode,MCC mismatch");
14064 return 0;
14065 }
14066 pos += 3;
14067
14068 mnc_len = strlen(plmn_mnc);
14069 if (mnc_len < 2) {
14070 send_resp(dut, conn, SIGMA_ERROR, "errorCode,MNC not set");
14071 return 0;
14072 }
14073
14074 if (strncmp(plmn_mnc, pos, mnc_len) != 0) {
14075 send_resp(dut, conn, SIGMA_ERROR, "errorCode,MNC mismatch");
14076 return 0;
14077 }
14078 pos += mnc_len;
14079
14080 res = snprintf(buf, sizeof(buf), "%s%s-%s",plmn_mcc, plmn_mnc, pos);
14081 if (res < 0 || res >= (int) sizeof(buf))
14082 return -1;
14083 if (set_cred_quoted(ifname, id, "imsi", buf) < 0) {
14084 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Could "
14085 "not set IMSI");
14086 return 0;
14087 }
14088
14089 val = get_param(cmd, "Password");
14090 if (val && set_cred_quoted(ifname, id, "milenage", val) < 0) {
14091 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Could "
14092 "not set password");
14093 return 0;
14094 }
14095
Jouni Malinenba630452018-06-22 11:49:59 +030014096 if (dut->program == PROGRAM_HS2_R2 || dut->program == PROGRAM_HS2_R3) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014097 /*
14098 * Set provisioning_sp for the test cases where SIM/USIM
14099 * provisioning is used.
14100 */
14101 if (val && set_cred_quoted(ifname, id, "provisioning_sp",
14102 "wi-fi.org") < 0) {
14103 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Could "
14104 "not set provisioning_sp");
14105 return 0;
14106 }
14107
14108 update_devdetail_imsi(dut, imsi);
14109 }
14110
14111 return 1;
14112}
14113
14114
14115static int sta_add_credential_cert(struct sigma_dut *dut,
14116 struct sigma_conn *conn,
14117 const char *ifname,
14118 struct sigma_cmd *cmd)
14119{
14120 const char *val;
14121 int id;
14122
14123 id = add_cred(ifname);
14124 if (id < 0)
14125 return -2;
14126 sigma_dut_print(dut, DUT_MSG_DEBUG, "Adding credential %d", id);
14127
14128 val = get_param(cmd, "prefer");
14129 if (val && atoi(val) > 0)
14130 set_cred(ifname, id, "priority", "1");
14131
14132 val = get_param(cmd, "REALM");
14133 if (val && set_cred_quoted(ifname, id, "realm", val) < 0) {
14134 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Could not set "
14135 "realm");
14136 return 0;
14137 }
14138
14139 val = get_param(cmd, "HOME_FQDN");
14140 if (val && set_cred_quoted(ifname, id, "domain", val) < 0) {
14141 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Could not set "
14142 "home_fqdn");
14143 return 0;
14144 }
14145
14146 val = get_param(cmd, "Username");
14147 if (val && set_cred_quoted(ifname, id, "username", val) < 0) {
14148 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Could not set "
14149 "username");
14150 return 0;
14151 }
14152
14153 val = get_param(cmd, "clientCertificate");
14154 if (val) {
14155 char fname[200];
14156 snprintf(fname, sizeof(fname), "%s/%s", sigma_cert_path, val);
14157#ifdef __linux__
14158 if (!file_exists(fname)) {
14159 char msg[300];
14160 snprintf(msg, sizeof(msg),
14161 "ErrorCode,clientCertificate "
14162 "file (%s) not found", fname);
14163 send_resp(dut, conn, SIGMA_ERROR, msg);
14164 return 0;
14165 }
14166#endif /* __linux__ */
14167 if (set_cred_quoted(ifname, id, "client_cert", fname) < 0) {
14168 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Could "
14169 "not set client_cert");
14170 return 0;
14171 }
14172 if (set_cred_quoted(ifname, id, "private_key", fname) < 0) {
14173 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Could "
14174 "not set private_key");
14175 return 0;
14176 }
14177 }
14178
14179 val = get_param(cmd, "ROOT_CA");
14180 if (val) {
14181 char fname[200];
14182 snprintf(fname, sizeof(fname), "%s/%s", sigma_cert_path, val);
14183#ifdef __linux__
14184 if (!file_exists(fname)) {
14185 char msg[300];
14186 snprintf(msg, sizeof(msg), "ErrorCode,ROOT_CA "
14187 "file (%s) not found", fname);
14188 send_resp(dut, conn, SIGMA_ERROR, msg);
14189 return 0;
14190 }
14191#endif /* __linux__ */
14192 if (set_cred_quoted(ifname, id, "ca_cert", fname) < 0) {
14193 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Could "
14194 "not set root CA");
14195 return 0;
14196 }
14197 }
14198
14199 return 1;
14200}
14201
14202
Jouni Malinenf7222712019-06-13 01:50:21 +030014203static enum sigma_cmd_result cmd_sta_add_credential(struct sigma_dut *dut,
14204 struct sigma_conn *conn,
14205 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014206{
14207 const char *intf = get_param(cmd, "Interface");
14208 const char *type;
14209
14210 start_sta_mode(dut);
14211
14212 type = get_param(cmd, "Type");
14213 if (!type)
14214 return -1;
14215
14216 if (strcasecmp(type, "uname_pwd") == 0)
14217 return sta_add_credential_uname_pwd(dut, conn, intf, cmd);
14218
14219 if (strcasecmp(type, "sim") == 0)
14220 return sta_add_credential_sim(dut, conn, intf, cmd);
14221
14222 if (strcasecmp(type, "cert") == 0)
14223 return sta_add_credential_cert(dut, conn, intf, cmd);
14224
14225 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,Unsupported credential "
14226 "type");
14227 return 0;
14228}
14229
14230
Jouni Malinenf7222712019-06-13 01:50:21 +030014231static enum sigma_cmd_result cmd_sta_scan(struct sigma_dut *dut,
14232 struct sigma_conn *conn,
14233 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014234{
14235 const char *intf = get_param(cmd, "Interface");
Kiran Kumar Lokere0044a872020-03-04 16:38:06 -080014236 const char *val, *bssid, *ssid, *scan_freq, *short_ssid;
Veerendranathdc581b52020-08-10 03:29:08 -070014237 char buf[4096], scan_res[20];
vamsi krishna89ad8c62017-09-19 12:51:18 +053014238 char ssid_hex[65];
Kiran Kumar Lokere3399af22020-03-04 16:31:56 -080014239 int wildcard_ssid = 0;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014240 int res;
Kiran Kumar Lokere0044a872020-03-04 16:38:06 -080014241 enum sigma_cmd_result status;
Jouni Malinen228a2fc2020-06-22 23:37:45 +030014242 struct wpa_ctrl *ctrl = NULL;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014243
Jouni Malinen8c1abeb2019-11-06 18:48:34 +020014244 start_sta_mode(dut);
14245
Arif Hussain66a4af02019-02-07 15:04:51 -080014246 val = get_param(cmd, "GetParameter");
14247 if (val && strcmp(val, "SSID_BSSID") == 0) {
Jouni Malinen016ae6c2019-11-04 17:00:01 +020014248 if (get_wpa_ssid_bssid(dut, get_station_ifname(dut),
Arif Hussain66a4af02019-02-07 15:04:51 -080014249 buf, sizeof(buf)) < 0) {
14250 sigma_dut_print(dut, DUT_MSG_ERROR,
14251 "Could not get ssid bssid");
14252 return ERROR_SEND_STATUS;
14253 }
14254
14255 sigma_dut_print(dut, DUT_MSG_INFO, "%s", buf);
14256 send_resp(dut, conn, SIGMA_COMPLETE, buf);
14257 return STATUS_SENT;
14258 }
14259
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014260 val = get_param(cmd, "HESSID");
14261 if (val) {
14262 res = snprintf(buf, sizeof(buf), "SET hessid %s", val);
14263 if (res < 0 || res >= (int) sizeof(buf))
14264 return -1;
14265 wpa_command(intf, buf);
14266 }
14267
14268 val = get_param(cmd, "ACCS_NET_TYPE");
14269 if (val) {
14270 res = snprintf(buf, sizeof(buf), "SET access_network_type %s",
14271 val);
14272 if (res < 0 || res >= (int) sizeof(buf))
14273 return -1;
14274 wpa_command(intf, buf);
14275 }
14276
Kiran Kumar Lokere69d89952021-08-08 23:41:46 -070014277 if (get_param(cmd, "RxMac"))
14278 sta_set_scan_unicast_probe(dut, intf, 1);
14279
vamsi krishna89ad8c62017-09-19 12:51:18 +053014280 bssid = get_param(cmd, "Bssid");
14281 ssid = get_param(cmd, "Ssid");
Kiran Kumar Lokere69d89952021-08-08 23:41:46 -070014282 if (!bssid)
14283 bssid = get_param(cmd, "RxMac");
vamsi krishna89ad8c62017-09-19 12:51:18 +053014284
Kiran Kumar Lokere3399af22020-03-04 16:31:56 -080014285 if (ssid && strcasecmp(ssid, "ZeroLength") == 0 &&
14286 dut->device_type == STA_testbed) {
14287 ssid = NULL;
14288 wildcard_ssid = 1;
14289 }
14290
vamsi krishna89ad8c62017-09-19 12:51:18 +053014291 if (ssid) {
14292 if (2 * strlen(ssid) >= sizeof(ssid_hex)) {
14293 send_resp(dut, conn, SIGMA_ERROR,
14294 "ErrorCode,Too long SSID");
14295 return 0;
14296 }
14297 ascii2hexstr(ssid, ssid_hex);
14298 }
14299
Kiran Kumar Lokere0044a872020-03-04 16:38:06 -080014300 short_ssid = get_param(cmd, "ShortSSID");
14301 if (short_ssid) {
14302 uint32_t short_ssid_hex;
14303
14304 short_ssid_hex = strtoul(short_ssid, NULL, 16);
14305 short_ssid_hex = ((short_ssid_hex & 0xFF) << 24) |
14306 (((short_ssid_hex >> 8) & 0xFF) << 16) |
14307 (((short_ssid_hex >> 16) & 0xFF) << 8) |
14308 ((short_ssid_hex >> 24) & 0xFF);
14309
14310 res = snprintf(buf, sizeof(buf),
14311 "VENDOR_ELEM_ADD 14 ff053a%08x",
14312 short_ssid_hex);
14313 if (res < 0 || res >= (int) sizeof(buf) ||
14314 wpa_command(intf, buf)) {
14315 send_resp(dut, conn, SIGMA_ERROR,
14316 "errorCode,Failed to add short SSID");
14317 return STATUS_SENT_ERROR;
14318 }
14319 }
14320
Kiran Kumar Lokerec0deb482020-03-04 16:35:06 -080014321 scan_freq = get_param(cmd, "ChnlFreq");
Veerendranath Jakkam132c4b42020-08-10 00:29:03 +053014322 if (scan_freq) {
14323 if (strcasecmp(scan_freq, "2G") == 0)
14324 scan_freq = "2412-2462";
14325 else if (strcasecmp(scan_freq, "5G") == 0)
14326 scan_freq = "5180-5925";
14327 }
Kiran Kumar Lokerec0deb482020-03-04 16:35:06 -080014328
Jouni Malinen228a2fc2020-06-22 23:37:45 +030014329 val = get_param(cmd, "WaitCompletion");
14330 if (val && atoi(val) == 1) {
14331 ctrl = open_wpa_mon(intf);
14332 if (!ctrl) {
14333 send_resp(dut, conn, SIGMA_ERROR,
14334 "errorCode,Failed to open monitor socket");
14335 return STATUS_SENT_ERROR;
14336 }
14337 }
14338
Kiran Kumar Lokerec0deb482020-03-04 16:35:06 -080014339 res = snprintf(buf, sizeof(buf), "SCAN%s%s%s%s%s%s%s",
vamsi krishna89ad8c62017-09-19 12:51:18 +053014340 bssid ? " bssid=": "",
14341 bssid ? bssid : "",
14342 ssid ? " ssid " : "",
Kiran Kumar Lokere3399af22020-03-04 16:31:56 -080014343 ssid ? ssid_hex : "",
Kiran Kumar Lokerec0deb482020-03-04 16:35:06 -080014344 wildcard_ssid ? " wildcard_ssid=1" : "",
14345 scan_freq ? " freq=" : "",
14346 scan_freq ? scan_freq : "");
Kiran Kumar Lokere0044a872020-03-04 16:38:06 -080014347 if (res < 0 || res >= (int) sizeof(buf)) {
14348 send_resp(dut, conn, SIGMA_ERROR,
14349 "errorCode,Could not build scan command");
14350 status = STATUS_SENT_ERROR;
14351 goto remove_s_ssid;
14352 }
vamsi krishna89ad8c62017-09-19 12:51:18 +053014353
Veerendranathdc581b52020-08-10 03:29:08 -070014354 res = wpa_command_resp(intf, buf, scan_res, sizeof(scan_res));
14355 if (strncmp(scan_res, "FAIL-BUSY", 9) == 0) {
14356 sigma_dut_print(dut, DUT_MSG_DEBUG,
14357 "Scan request rejected with busy status, abort ongoing scan and try again");
14358 wpa_command(intf, "ABORT_SCAN");
14359 res = wpa_command(intf, buf);
14360 }
14361
14362 if (res < 0) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014363 send_resp(dut, conn, SIGMA_ERROR, "errorCode,Could not start "
14364 "scan");
Kiran Kumar Lokere0044a872020-03-04 16:38:06 -080014365 status = STATUS_SENT_ERROR;
14366 } else {
14367 status = SUCCESS_SEND_STATUS;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014368 }
14369
Kiran Kumar Lokere0044a872020-03-04 16:38:06 -080014370remove_s_ssid:
14371 if (short_ssid && wpa_command(intf, "VENDOR_ELEM_REMOVE 14 *"))
14372 sigma_dut_print(dut, DUT_MSG_ERROR,
14373 "Failed to delete vendor element");
14374
Jouni Malinen228a2fc2020-06-22 23:37:45 +030014375 if (ctrl) {
14376 if (status == SUCCESS_SEND_STATUS) {
14377 res = get_wpa_cli_event(dut, ctrl,
14378 "CTRL-EVENT-SCAN-RESULTS",
14379 buf, sizeof(buf));
14380 if (res < 0) {
14381 send_resp(dut, conn, SIGMA_ERROR,
14382 "ErrorCode,scan did not complete");
14383 status = STATUS_SENT_ERROR;
14384 }
14385 }
14386
14387 wpa_ctrl_detach(ctrl);
14388 wpa_ctrl_close(ctrl);
14389 }
14390
Kiran Kumar Lokere0044a872020-03-04 16:38:06 -080014391 return status;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014392}
14393
14394
Jouni Malinenf7222712019-06-13 01:50:21 +030014395static enum sigma_cmd_result cmd_sta_scan_bss(struct sigma_dut *dut,
14396 struct sigma_conn *conn,
14397 struct sigma_cmd *cmd)
Jouni Malinen5e5d43d2018-01-10 17:29:33 +020014398{
14399 const char *intf = get_param(cmd, "Interface");
14400 const char *bssid;
14401 char buf[4096], *pos;
14402 int freq, chan;
14403 char *ssid;
14404 char resp[100];
14405 int res;
14406 struct wpa_ctrl *ctrl;
14407
14408 bssid = get_param(cmd, "BSSID");
14409 if (!bssid) {
14410 send_resp(dut, conn, SIGMA_INVALID,
14411 "errorCode,BSSID argument is missing");
14412 return 0;
14413 }
14414
14415 ctrl = open_wpa_mon(intf);
14416 if (!ctrl) {
14417 sigma_dut_print(dut, DUT_MSG_ERROR,
14418 "Failed to open wpa_supplicant monitor connection");
14419 return -1;
14420 }
14421
14422 if (wpa_command(intf, "SCAN TYPE=ONLY")) {
14423 send_resp(dut, conn, SIGMA_ERROR,
14424 "errorCode,Could not start scan");
14425 wpa_ctrl_detach(ctrl);
14426 wpa_ctrl_close(ctrl);
14427 return 0;
14428 }
14429
14430 res = get_wpa_cli_event(dut, ctrl, "CTRL-EVENT-SCAN-RESULTS",
14431 buf, sizeof(buf));
14432
14433 wpa_ctrl_detach(ctrl);
14434 wpa_ctrl_close(ctrl);
14435
14436 if (res < 0) {
14437 send_resp(dut, conn, SIGMA_ERROR,
14438 "errorCode,Scan did not complete");
14439 return 0;
14440 }
14441
14442 snprintf(buf, sizeof(buf), "BSS %s", bssid);
14443 if (wpa_command_resp(intf, buf, buf, sizeof(buf)) < 0 ||
14444 strncmp(buf, "id=", 3) != 0) {
14445 send_resp(dut, conn, SIGMA_ERROR,
14446 "errorCode,Specified BSSID not found");
14447 return 0;
14448 }
14449
14450 pos = strstr(buf, "\nfreq=");
14451 if (!pos) {
14452 send_resp(dut, conn, SIGMA_ERROR,
14453 "errorCode,Channel not found");
14454 return 0;
14455 }
14456 freq = atoi(pos + 6);
14457 chan = freq_to_channel(freq);
14458
14459 pos = strstr(buf, "\nssid=");
14460 if (!pos) {
14461 send_resp(dut, conn, SIGMA_ERROR,
14462 "errorCode,SSID not found");
14463 return 0;
14464 }
14465 ssid = pos + 6;
14466 pos = strchr(ssid, '\n');
14467 if (pos)
14468 *pos = '\0';
14469 snprintf(resp, sizeof(resp), "ssid,%s,bsschannel,%d", ssid, chan);
14470 send_resp(dut, conn, SIGMA_COMPLETE, resp);
14471 return 0;
14472}
14473
14474
Jouni Malinenf7222712019-06-13 01:50:21 +030014475static enum sigma_cmd_result cmd_sta_set_systime(struct sigma_dut *dut,
14476 struct sigma_conn *conn,
14477 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014478{
14479#ifdef __linux__
14480 struct timeval tv;
14481 struct tm tm;
14482 time_t t;
14483 const char *val;
Pradeep Reddy POTTETI429c69e2016-10-13 17:22:03 +053014484 int v;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014485
Jouni Malinen016ae6c2019-11-04 17:00:01 +020014486 wpa_command(get_station_ifname(dut), "PMKSA_FLUSH");
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014487
14488 memset(&tm, 0, sizeof(tm));
14489 val = get_param(cmd, "seconds");
14490 if (val)
14491 tm.tm_sec = atoi(val);
14492 val = get_param(cmd, "minutes");
14493 if (val)
14494 tm.tm_min = atoi(val);
14495 val = get_param(cmd, "hours");
14496 if (val)
14497 tm.tm_hour = atoi(val);
14498 val = get_param(cmd, "date");
14499 if (val)
14500 tm.tm_mday = atoi(val);
14501 val = get_param(cmd, "month");
Pradeep Reddy POTTETI429c69e2016-10-13 17:22:03 +053014502 if (val) {
14503 v = atoi(val);
14504 if (v < 1 || v > 12) {
14505 send_resp(dut, conn, SIGMA_INVALID,
14506 "errorCode,Invalid month");
14507 return 0;
14508 }
14509 tm.tm_mon = v - 1;
14510 }
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014511 val = get_param(cmd, "year");
14512 if (val) {
14513 int year = atoi(val);
14514#ifdef ANDROID
14515 if (year > 2035)
14516 year = 2035; /* years beyond 2035 not supported */
14517#endif /* ANDROID */
14518 tm.tm_year = year - 1900;
14519 }
14520 t = mktime(&tm);
14521 if (t == (time_t) -1) {
14522 send_resp(dut, conn, SIGMA_ERROR,
14523 "errorCode,Invalid date or time");
14524 return 0;
14525 }
14526
14527 memset(&tv, 0, sizeof(tv));
14528 tv.tv_sec = t;
14529
14530 if (settimeofday(&tv, NULL) < 0) {
14531 sigma_dut_print(dut, DUT_MSG_INFO, "settimeofday failed: %s",
14532 strerror(errno));
14533 send_resp(dut, conn, SIGMA_ERROR,
14534 "errorCode,Failed to set time");
14535 return 0;
14536 }
14537
14538 return 1;
14539#endif /* __linux__ */
14540
14541 return -1;
14542}
14543
14544
Jouni Malinenf7222712019-06-13 01:50:21 +030014545static enum sigma_cmd_result cmd_sta_osu(struct sigma_dut *dut,
14546 struct sigma_conn *conn,
14547 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014548{
14549 const char *intf = get_param(cmd, "Interface");
Jouni Malinen4c8681c2018-09-12 23:28:11 +030014550 const char *name, *osu_ssid, *val;
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014551 int prod_ess_assoc = 1;
Jouni Malinen4c8681c2018-09-12 23:28:11 +030014552 char buf[300], bssid[100], ssid[100];
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014553 int res;
14554 struct wpa_ctrl *ctrl;
14555
14556 name = get_param(cmd, "osuFriendlyName");
Jouni Malinen4c8681c2018-09-12 23:28:11 +030014557 osu_ssid = get_param(cmd, "osu_ssid");
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014558
14559 val = get_param(cmd, "ProdESSAssoc");
14560 if (val)
14561 prod_ess_assoc = atoi(val);
14562
14563 kill_dhcp_client(dut, intf);
14564 if (start_dhcp_client(dut, intf) < 0)
14565 return -2;
14566
14567 sigma_dut_print(dut, DUT_MSG_DEBUG, "Trigger OSU");
14568 mkdir("Logs", S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
14569 res = snprintf(buf, sizeof(buf),
Jouni Malinen4c8681c2018-09-12 23:28:11 +030014570 "%s %s%s%s %s%s%s signup osu-ca.pem",
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014571 prod_ess_assoc ? "" : "-N",
14572 name ? "-O'" : "", name ? name : "",
Jouni Malinen4c8681c2018-09-12 23:28:11 +030014573 name ? "'" : "",
14574 osu_ssid ? "-o'" : "", osu_ssid ? osu_ssid : "",
14575 osu_ssid ? "'" : "");
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014576
Kanchanapally, Vidyullatha12b66762015-12-31 16:46:42 +053014577 hs2_set_policy(dut);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014578 if (run_hs20_osu(dut, buf) < 0) {
14579 FILE *f;
14580
14581 sigma_dut_print(dut, DUT_MSG_INFO, "Failed to complete OSU");
14582
14583 f = fopen("hs20-osu-client.res", "r");
14584 if (f) {
14585 char resp[400], res[300], *pos;
14586 if (!fgets(res, sizeof(res), f))
14587 res[0] = '\0';
14588 pos = strchr(res, '\n');
14589 if (pos)
14590 *pos = '\0';
14591 fclose(f);
14592 sigma_dut_summary(dut, "hs20-osu-client provisioning failed: %s",
14593 res);
14594 snprintf(resp, sizeof(resp), "notify-send '%s'", res);
14595 if (system(resp) != 0) {
14596 }
14597 snprintf(resp, sizeof(resp),
14598 "SSID,,BSSID,,failureReason,%s", res);
14599 send_resp(dut, conn, SIGMA_COMPLETE, resp);
14600 return 0;
14601 }
14602
14603 send_resp(dut, conn, SIGMA_COMPLETE, "SSID,,BSSID,");
14604 return 0;
14605 }
14606
14607 if (!prod_ess_assoc)
14608 goto report;
14609
14610 ctrl = open_wpa_mon(intf);
14611 if (ctrl == NULL) {
14612 sigma_dut_print(dut, DUT_MSG_ERROR, "Failed to open "
14613 "wpa_supplicant monitor connection");
14614 return -1;
14615 }
14616
14617 res = get_wpa_cli_event(dut, ctrl, "CTRL-EVENT-CONNECTED",
14618 buf, sizeof(buf));
14619
14620 wpa_ctrl_detach(ctrl);
14621 wpa_ctrl_close(ctrl);
14622
14623 if (res < 0) {
14624 sigma_dut_print(dut, DUT_MSG_INFO, "Failed to connect to "
14625 "network after OSU");
14626 send_resp(dut, conn, SIGMA_COMPLETE, "SSID,,BSSID,");
14627 return 0;
14628 }
14629
14630report:
14631 if (get_wpa_status(intf, "bssid", bssid, sizeof(bssid)) < 0 ||
14632 get_wpa_status(intf, "ssid", ssid, sizeof(ssid)) < 0) {
14633 sigma_dut_print(dut, DUT_MSG_INFO, "Failed to get BSSID/SSID");
14634 send_resp(dut, conn, SIGMA_COMPLETE, "SSID,,BSSID,");
14635 return 0;
14636 }
14637
14638 snprintf(buf, sizeof(buf), "SSID,%s,BSSID,%s", ssid, bssid);
14639 send_resp(dut, conn, SIGMA_COMPLETE, buf);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014640 return 0;
14641}
14642
14643
Jouni Malinenf7222712019-06-13 01:50:21 +030014644static enum sigma_cmd_result cmd_sta_policy_update(struct sigma_dut *dut,
14645 struct sigma_conn *conn,
14646 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014647{
14648 const char *val;
14649 int timeout = 120;
14650
14651 val = get_param(cmd, "PolicyUpdate");
14652 if (val == NULL || atoi(val) == 0)
14653 return 1; /* No operation requested */
14654
14655 val = get_param(cmd, "Timeout");
14656 if (val)
14657 timeout = atoi(val);
14658
14659 if (timeout) {
14660 /* TODO: time out the command and return
14661 * PolicyUpdateStatus,TIMEOUT if needed. */
14662 }
14663
14664 sigma_dut_print(dut, DUT_MSG_DEBUG, "Trigger policy update");
14665 mkdir("Logs", S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
14666 if (run_hs20_osu(dut, "pol_upd fqdn=wi-fi.org") < 0) {
14667 send_resp(dut, conn, SIGMA_COMPLETE, "PolicyUpdateStatus,FAIL");
14668 return 0;
14669 }
14670
14671 send_resp(dut, conn, SIGMA_COMPLETE, "PolicyUpdateStatus,SUCCESS");
14672 return 0;
14673}
14674
14675
Jouni Malinenf7222712019-06-13 01:50:21 +030014676static enum sigma_cmd_result cmd_sta_er_config(struct sigma_dut *dut,
14677 struct sigma_conn *conn,
14678 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014679{
14680 struct wpa_ctrl *ctrl;
14681 const char *intf = get_param(cmd, "Interface");
14682 const char *bssid = get_param(cmd, "Bssid");
14683 const char *ssid = get_param(cmd, "SSID");
14684 const char *security = get_param(cmd, "Security");
14685 const char *passphrase = get_param(cmd, "Passphrase");
14686 const char *pin = get_param(cmd, "PIN");
14687 char buf[1000];
14688 char ssid_hex[200], passphrase_hex[200];
14689 const char *keymgmt, *cipher;
14690
14691 if (intf == NULL)
Jouni Malinen016ae6c2019-11-04 17:00:01 +020014692 intf = get_main_ifname(dut);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014693
14694 if (!bssid) {
14695 send_resp(dut, conn, SIGMA_ERROR,
14696 "ErrorCode,Missing Bssid argument");
14697 return 0;
14698 }
14699
14700 if (!ssid) {
14701 send_resp(dut, conn, SIGMA_ERROR,
14702 "ErrorCode,Missing SSID argument");
14703 return 0;
14704 }
14705
14706 if (!security) {
14707 send_resp(dut, conn, SIGMA_ERROR,
14708 "ErrorCode,Missing Security argument");
14709 return 0;
14710 }
14711
14712 if (!passphrase) {
14713 send_resp(dut, conn, SIGMA_ERROR,
14714 "ErrorCode,Missing Passphrase argument");
14715 return 0;
14716 }
14717
14718 if (!pin) {
14719 send_resp(dut, conn, SIGMA_ERROR,
14720 "ErrorCode,Missing PIN argument");
14721 return 0;
14722 }
14723
vamsi krishna8c9c1562017-05-12 15:51:46 +053014724 if (2 * strlen(ssid) >= sizeof(ssid_hex) ||
14725 2 * strlen(passphrase) >= sizeof(passphrase_hex)) {
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014726 send_resp(dut, conn, SIGMA_ERROR,
14727 "ErrorCode,Too long SSID/passphrase");
14728 return 0;
14729 }
14730
14731 ctrl = open_wpa_mon(intf);
14732 if (ctrl == NULL) {
14733 sigma_dut_print(dut, DUT_MSG_ERROR, "Failed to open "
14734 "wpa_supplicant monitor connection");
14735 return -2;
14736 }
14737
14738 if (strcasecmp(security, "wpa2-psk") == 0) {
14739 keymgmt = "WPA2PSK";
14740 cipher = "CCMP";
14741 } else {
14742 wpa_ctrl_detach(ctrl);
14743 wpa_ctrl_close(ctrl);
14744 send_resp(dut, conn, SIGMA_ERROR,
14745 "ErrorCode,Unsupported Security value");
14746 return 0;
14747 }
14748
14749 ascii2hexstr(ssid, ssid_hex);
14750 ascii2hexstr(passphrase, passphrase_hex);
14751 snprintf(buf, sizeof(buf), "WPS_REG %s %s %s %s %s %s",
14752 bssid, pin, ssid_hex, keymgmt, cipher, passphrase_hex);
14753
14754 if (wpa_command(intf, buf) < 0) {
14755 wpa_ctrl_detach(ctrl);
14756 wpa_ctrl_close(ctrl);
14757 send_resp(dut, conn, SIGMA_ERROR,
14758 "ErrorCode,Failed to start registrar");
14759 return 0;
14760 }
14761
14762 snprintf(dut->er_oper_bssid, sizeof(dut->er_oper_bssid), "%s", bssid);
14763 dut->er_oper_performed = 1;
14764
14765 return wps_connection_event(dut, conn, ctrl, intf, 0);
14766}
14767
14768
Jouni Malinenf7222712019-06-13 01:50:21 +030014769static enum sigma_cmd_result
14770cmd_sta_wps_connect_pw_token(struct sigma_dut *dut, struct sigma_conn *conn,
14771 struct sigma_cmd *cmd)
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014772{
14773 struct wpa_ctrl *ctrl;
14774 const char *intf = get_param(cmd, "Interface");
14775 const char *bssid = get_param(cmd, "Bssid");
14776 char buf[100];
14777
14778 if (!bssid) {
14779 send_resp(dut, conn, SIGMA_ERROR,
14780 "ErrorCode,Missing Bssid argument");
14781 return 0;
14782 }
14783
14784 ctrl = open_wpa_mon(intf);
14785 if (ctrl == NULL) {
14786 sigma_dut_print(dut, DUT_MSG_ERROR, "Failed to open "
14787 "wpa_supplicant monitor connection");
14788 return -2;
14789 }
14790
14791 snprintf(buf, sizeof(buf), "WPS_NFC %s", bssid);
14792
14793 if (wpa_command(intf, buf) < 0) {
14794 wpa_ctrl_detach(ctrl);
14795 wpa_ctrl_close(ctrl);
14796 send_resp(dut, conn, SIGMA_ERROR,
14797 "ErrorCode,Failed to start registrar");
14798 return 0;
14799 }
14800
14801 return wps_connection_event(dut, conn, ctrl, intf, 0);
14802}
14803
14804
Jouni Malinenf7222712019-06-13 01:50:21 +030014805static enum sigma_cmd_result cmd_start_wps_registration(struct sigma_dut *dut,
14806 struct sigma_conn *conn,
14807 struct sigma_cmd *cmd)
vamsi krishna9b144002017-09-20 13:28:13 +053014808{
14809 struct wpa_ctrl *ctrl;
14810 const char *intf = get_param(cmd, "Interface");
Alexei Avshalom Lazard596b512018-12-18 16:00:59 +020014811 const char *network_mode = get_param(cmd, "network_mode");
Alexei Avshalom Lazar043230b2019-02-04 14:11:24 +020014812 const char *config_method = get_param(cmd, "WPSConfigMethod");
14813 const char *role;
vamsi krishna9b144002017-09-20 13:28:13 +053014814 int res;
14815 char buf[256];
14816 const char *events[] = {
14817 "CTRL-EVENT-CONNECTED",
14818 "WPS-OVERLAP-DETECTED",
14819 "WPS-TIMEOUT",
14820 "WPS-FAIL",
14821 NULL
14822 };
Alexei Avshalom Lazard596b512018-12-18 16:00:59 +020014823 int id = 0;
vamsi krishna9b144002017-09-20 13:28:13 +053014824
Alexei Avshalom Lazar35ab3832018-12-23 16:49:49 +020014825 /* 60G WPS tests do not pass Interface parameter */
14826 if (!intf)
Jouni Malinen016ae6c2019-11-04 17:00:01 +020014827 intf = get_main_ifname(dut);
Alexei Avshalom Lazar35ab3832018-12-23 16:49:49 +020014828
Alexei Avshalom Lazar043230b2019-02-04 14:11:24 +020014829 if (dut->mode == SIGMA_MODE_AP)
14830 return ap_wps_registration(dut, conn, cmd);
14831
14832 if (config_method) {
14833 /* WFA_CS_WPS_PIN_KEYPAD mode is set when using the
14834 * sta_wps_enter_pin before calling start_wps_registration. */
14835 if (strcasecmp(config_method, "PBC") == 0)
14836 dut->wps_method = WFA_CS_WPS_PBC;
14837 }
14838 if (dut->wps_method == WFA_CS_WPS_NOT_READY) {
14839 send_resp(dut, conn, SIGMA_ERROR,
14840 "ErrorCode,WPS parameters not yet set");
14841 return STATUS_SENT;
14842 }
14843
14844 /* Make sure WPS is enabled (also for STA mode) */
14845 dut->wps_disable = 0;
14846
Alexei Avshalom Lazard596b512018-12-18 16:00:59 +020014847 if (dut->band == WPS_BAND_60G && network_mode &&
14848 strcasecmp(network_mode, "PBSS") == 0) {
14849 sigma_dut_print(dut, DUT_MSG_DEBUG,
14850 "Set PBSS network mode, network id %d", id);
Jouni Malinen016ae6c2019-11-04 17:00:01 +020014851 if (set_network(get_station_ifname(dut), id, "pbss", "1") < 0)
Alexei Avshalom Lazard596b512018-12-18 16:00:59 +020014852 return -2;
14853 }
14854
Alexei Avshalom Lazarb094bf02018-12-18 16:00:53 +020014855 if (dut->force_rsn_ie) {
14856 sigma_dut_print(dut, DUT_MSG_DEBUG, "Force RSN_IE: %d",
14857 dut->force_rsn_ie);
14858 if (sta_60g_force_rsn_ie(dut, dut->force_rsn_ie) < 0) {
14859 sigma_dut_print(dut, DUT_MSG_INFO,
14860 "Failed to force RSN_IE");
Jouni Malinen0e29cf22019-02-19 01:13:21 +020014861 return ERROR_SEND_STATUS;
Alexei Avshalom Lazarb094bf02018-12-18 16:00:53 +020014862 }
14863 }
14864
vamsi krishna9b144002017-09-20 13:28:13 +053014865 ctrl = open_wpa_mon(intf);
14866 if (!ctrl) {
14867 sigma_dut_print(dut, DUT_MSG_ERROR,
14868 "Failed to open wpa_supplicant monitor connection");
14869 return -2;
14870 }
14871
14872 role = get_param(cmd, "WpsRole");
14873 if (!role) {
14874 send_resp(dut, conn, SIGMA_INVALID,
14875 "ErrorCode,WpsRole not provided");
14876 goto fail;
14877 }
14878
Alexei Avshalom Lazar043230b2019-02-04 14:11:24 +020014879 if (strcasecmp(role, "Enrollee") != 0) {
14880 /* Registrar role for STA not supported */
14881 send_resp(dut, conn, SIGMA_ERROR,
14882 "ErrorCode,Unsupported WpsRole value");
14883 goto fail;
14884 }
14885
14886 if (is_60g_sigma_dut(dut)) {
14887 if (dut->wps_method == WFA_CS_WPS_PBC)
14888 snprintf(buf, sizeof(buf), "WPS_PBC");
14889 else /* WFA_CS_WPS_PIN_KEYPAD */
14890 snprintf(buf, sizeof(buf), "WPS_PIN any %s",
14891 dut->wps_pin);
14892 if (wpa_command(intf, buf) < 0) {
14893 send_resp(dut, conn, SIGMA_ERROR,
14894 "ErrorCode,Failed to start WPS");
vamsi krishna9b144002017-09-20 13:28:13 +053014895 goto fail;
14896 }
Alexei Avshalom Lazar043230b2019-02-04 14:11:24 +020014897 res = get_wpa_cli_events(dut, ctrl, events, buf, sizeof(buf));
14898 if (res < 0) {
14899 send_resp(dut, conn, SIGMA_ERROR,
14900 "ErrorCode,WPS connection did not complete");
14901 goto fail;
14902 }
14903 if (strstr(buf, "WPS-TIMEOUT")) {
14904 send_resp(dut, conn, SIGMA_COMPLETE, "WpsState,NoPeer");
14905 } else if (strstr(buf, "WPS-OVERLAP-DETECTED")) {
14906 send_resp(dut, conn, SIGMA_COMPLETE,
14907 "WpsState,OverlapSession");
14908 } else if (strstr(buf, "CTRL-EVENT-CONNECTED")) {
14909 send_resp(dut, conn, SIGMA_COMPLETE,
14910 "WpsState,Successful");
14911 } else {
14912 send_resp(dut, conn, SIGMA_COMPLETE,
14913 "WpsState,Failure");
14914 }
14915 } else {
14916 if (dut->wps_method == WFA_CS_WPS_PBC) {
vamsi krishna9b144002017-09-20 13:28:13 +053014917 if (wpa_command(intf, "WPS_PBC") < 0) {
14918 send_resp(dut, conn, SIGMA_ERROR,
14919 "ErrorCode,Failed to enable PBC");
14920 goto fail;
14921 }
14922 } else {
14923 /* TODO: PIN method */
14924 send_resp(dut, conn, SIGMA_ERROR,
14925 "ErrorCode,Unsupported WpsConfigMethod value");
14926 goto fail;
14927 }
14928 res = get_wpa_cli_events(dut, ctrl, events, buf, sizeof(buf));
14929 if (res < 0) {
14930 send_resp(dut, conn, SIGMA_ERROR,
14931 "ErrorCode,WPS connection did not complete");
14932 goto fail;
14933 }
14934 if (strstr(buf, "WPS-TIMEOUT")) {
14935 send_resp(dut, conn, SIGMA_ERROR, "ErrorCode,NoPeer");
14936 } else if (strstr(buf, "WPS-OVERLAP-DETECTED")) {
14937 send_resp(dut, conn, SIGMA_ERROR,
14938 "ErrorCode,OverlapSession");
14939 } else if (strstr(buf, "CTRL-EVENT-CONNECTED")) {
14940 send_resp(dut, conn, SIGMA_COMPLETE, "Successful");
14941 } else {
14942 send_resp(dut, conn, SIGMA_ERROR,
14943 "ErrorCode,WPS operation failed");
14944 }
vamsi krishna9b144002017-09-20 13:28:13 +053014945 }
14946
14947fail:
14948 wpa_ctrl_detach(ctrl);
14949 wpa_ctrl_close(ctrl);
14950 return 0;
14951}
14952
14953
Jouni Malinencd4e3c32015-10-29 12:39:56 +020014954static int req_intf(struct sigma_cmd *cmd)
14955{
14956 return get_param(cmd, "interface") == NULL ? -1 : 0;
14957}
14958
14959
14960void sta_register_cmds(void)
14961{
14962 sigma_dut_reg_cmd("sta_get_ip_config", req_intf,
14963 cmd_sta_get_ip_config);
14964 sigma_dut_reg_cmd("sta_set_ip_config", req_intf,
14965 cmd_sta_set_ip_config);
14966 sigma_dut_reg_cmd("sta_get_info", req_intf, cmd_sta_get_info);
14967 sigma_dut_reg_cmd("sta_get_mac_address", req_intf,
14968 cmd_sta_get_mac_address);
14969 sigma_dut_reg_cmd("sta_is_connected", req_intf, cmd_sta_is_connected);
14970 sigma_dut_reg_cmd("sta_verify_ip_connection", req_intf,
14971 cmd_sta_verify_ip_connection);
14972 sigma_dut_reg_cmd("sta_get_bssid", req_intf, cmd_sta_get_bssid);
14973 sigma_dut_reg_cmd("sta_set_encryption", req_intf,
14974 cmd_sta_set_encryption);
14975 sigma_dut_reg_cmd("sta_set_psk", req_intf, cmd_sta_set_psk);
14976 sigma_dut_reg_cmd("sta_set_eaptls", req_intf, cmd_sta_set_eaptls);
14977 sigma_dut_reg_cmd("sta_set_eapttls", req_intf, cmd_sta_set_eapttls);
14978 sigma_dut_reg_cmd("sta_set_eapsim", req_intf, cmd_sta_set_eapsim);
14979 sigma_dut_reg_cmd("sta_set_peap", req_intf, cmd_sta_set_peap);
14980 sigma_dut_reg_cmd("sta_set_eapfast", req_intf, cmd_sta_set_eapfast);
14981 sigma_dut_reg_cmd("sta_set_eapaka", req_intf, cmd_sta_set_eapaka);
14982 sigma_dut_reg_cmd("sta_set_eapakaprime", req_intf,
14983 cmd_sta_set_eapakaprime);
14984 sigma_dut_reg_cmd("sta_set_security", req_intf, cmd_sta_set_security);
14985 sigma_dut_reg_cmd("sta_set_uapsd", req_intf, cmd_sta_set_uapsd);
14986 /* TODO: sta_set_ibss */
14987 /* TODO: sta_set_mode */
14988 sigma_dut_reg_cmd("sta_set_wmm", req_intf, cmd_sta_set_wmm);
14989 sigma_dut_reg_cmd("sta_associate", req_intf, cmd_sta_associate);
14990 /* TODO: sta_up_load */
14991 sigma_dut_reg_cmd("sta_preset_testparameters", req_intf,
14992 cmd_sta_preset_testparameters);
14993 /* TODO: sta_set_system */
14994 sigma_dut_reg_cmd("sta_set_11n", req_intf, cmd_sta_set_11n);
14995 /* TODO: sta_set_rifs_test */
14996 sigma_dut_reg_cmd("sta_set_wireless", req_intf, cmd_sta_set_wireless);
14997 sigma_dut_reg_cmd("sta_send_addba", req_intf, cmd_sta_send_addba);
14998 /* TODO: sta_send_coexist_mgmt */
14999 sigma_dut_reg_cmd("sta_disconnect", req_intf, cmd_sta_disconnect);
15000 sigma_dut_reg_cmd("sta_reassoc", req_intf, cmd_sta_reassoc);
15001 sigma_dut_reg_cmd("sta_reassociate", req_intf, cmd_sta_reassoc);
15002 sigma_dut_reg_cmd("sta_reset_default", req_intf,
15003 cmd_sta_reset_default);
15004 sigma_dut_reg_cmd("sta_send_frame", req_intf, cmd_sta_send_frame);
15005 sigma_dut_reg_cmd("sta_set_macaddr", req_intf, cmd_sta_set_macaddr);
15006 sigma_dut_reg_cmd("sta_set_rfeature", req_intf, cmd_sta_set_rfeature);
15007 sigma_dut_reg_cmd("sta_set_radio", req_intf, cmd_sta_set_radio);
15008 sigma_dut_reg_cmd("sta_set_pwrsave", req_intf, cmd_sta_set_pwrsave);
Alexei Avshalom Lazare49e3872018-12-23 17:26:57 +020015009 sigma_dut_reg_cmd("sta_set_power_save", req_intf, cmd_sta_set_pwrsave);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020015010 sigma_dut_reg_cmd("sta_bssid_pool", req_intf, cmd_sta_bssid_pool);
15011 sigma_dut_reg_cmd("sta_reset_parm", req_intf, cmd_sta_reset_parm);
15012 sigma_dut_reg_cmd("sta_get_key", req_intf, cmd_sta_get_key);
15013 sigma_dut_reg_cmd("sta_hs2_associate", req_intf,
15014 cmd_sta_hs2_associate);
Jouni Malinenb639f1c2018-09-13 02:39:46 +030015015 sigma_dut_reg_cmd("sta_hs2_venue_info", req_intf,
15016 cmd_sta_hs2_venue_info);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020015017 sigma_dut_reg_cmd("sta_add_credential", req_intf,
15018 cmd_sta_add_credential);
15019 sigma_dut_reg_cmd("sta_scan", req_intf, cmd_sta_scan);
Jouni Malinen5e5d43d2018-01-10 17:29:33 +020015020 sigma_dut_reg_cmd("sta_scan_bss", req_intf, cmd_sta_scan_bss);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020015021 sigma_dut_reg_cmd("sta_set_systime", NULL, cmd_sta_set_systime);
15022 sigma_dut_reg_cmd("sta_osu", req_intf, cmd_sta_osu);
15023 sigma_dut_reg_cmd("sta_policy_update", req_intf, cmd_sta_policy_update);
15024 sigma_dut_reg_cmd("sta_er_config", NULL, cmd_sta_er_config);
15025 sigma_dut_reg_cmd("sta_wps_connect_pw_token", req_intf,
15026 cmd_sta_wps_connect_pw_token);
Jouni Malinen82905202018-04-29 17:20:10 +030015027 sigma_dut_reg_cmd("sta_exec_action", NULL, cmd_sta_exec_action);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020015028 sigma_dut_reg_cmd("sta_get_events", req_intf, cmd_sta_get_events);
15029 sigma_dut_reg_cmd("sta_get_parameter", req_intf, cmd_sta_get_parameter);
Alexei Avshalom Lazar35ab3832018-12-23 16:49:49 +020015030 sigma_dut_reg_cmd("start_wps_registration", NULL,
vamsi krishna9b144002017-09-20 13:28:13 +053015031 cmd_start_wps_registration);
Jouni Malinencd4e3c32015-10-29 12:39:56 +020015032}