]> git.ipfire.org Git - thirdparty/iw.git/blame - scan.c
projects / thirdparty / iw.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
iw: scan: add missing word for rm capabilities
[thirdparty/iw.git] / scan.c
CommitLineData
3563f4c5
JB		 1#include <net/if.h>
2#include <errno.h>
3#include <string.h>
764fe753 4#include <stdbool.h>
3563f4c5
JB		 5
6#include <netlink/genl/genl.h>
7#include <netlink/genl/family.h>
8#include <netlink/genl/ctrl.h>
9#include <netlink/msg.h>
10#include <netlink/attr.h>
11
12#include "nl80211.h"
13#include "iw.h"
14
92a04ecd
MH		 15#define WLAN_CAPABILITY_ESS (1<<0)
16#define WLAN_CAPABILITY_IBSS (1<<1)
17#define WLAN_CAPABILITY_CF_POLLABLE (1<<2)
18#define WLAN_CAPABILITY_CF_POLL_REQUEST (1<<3)
19#define WLAN_CAPABILITY_PRIVACY (1<<4)
20#define WLAN_CAPABILITY_SHORT_PREAMBLE (1<<5)
21#define WLAN_CAPABILITY_PBCC (1<<6)
22#define WLAN_CAPABILITY_CHANNEL_AGILITY (1<<7)
23#define WLAN_CAPABILITY_SPECTRUM_MGMT (1<<8)
24#define WLAN_CAPABILITY_QOS (1<<9)
25#define WLAN_CAPABILITY_SHORT_SLOT_TIME (1<<10)
26#define WLAN_CAPABILITY_APSD (1<<11)
2e8b82c1 27#define WLAN_CAPABILITY_RADIO_MEASURE (1<<12)
92a04ecd 28#define WLAN_CAPABILITY_DSSS_OFDM (1<<13)
2e8b82c1
VK		 29#define WLAN_CAPABILITY_DEL_BACK (1<<14)
30#define WLAN_CAPABILITY_IMM_BACK (1<<15)
31/* DMG (60gHz) 802.11ad */
32/* type - bits 0..1 */
33#define WLAN_CAPABILITY_DMG_TYPE_MASK (3<<0)
34
35#define WLAN_CAPABILITY_DMG_TYPE_IBSS (1<<0) /* Tx by: STA */
36#define WLAN_CAPABILITY_DMG_TYPE_PBSS (2<<0) /* Tx by: PCP */
37#define WLAN_CAPABILITY_DMG_TYPE_AP (3<<0) /* Tx by: AP */
38
39#define WLAN_CAPABILITY_DMG_CBAP_ONLY (1<<2)
40#define WLAN_CAPABILITY_DMG_CBAP_SOURCE (1<<3)
41#define WLAN_CAPABILITY_DMG_PRIVACY (1<<4)
42#define WLAN_CAPABILITY_DMG_ECPAC (1<<5)
43
44#define WLAN_CAPABILITY_DMG_SPECTRUM_MGMT (1<<8)
45#define WLAN_CAPABILITY_DMG_RADIO_MEASURE (1<<12)
92a04ecd 46
3bd60ef1
JB		 47static unsigned char ms_oui[3] = { 0x00, 0x50, 0xf2 };
48static unsigned char ieee80211_oui[3] = { 0x00, 0x0f, 0xac };
9a22374a 49static unsigned char wfa_oui[3] = { 0x50, 0x6f, 0x9a };
857d966e 50
764fe753
JB		 51struct scan_params {
52 bool unknown;
febeb0c0 53 enum print_ie_type type;
575280cc 54 bool show_both_ie_sets;
764fe753
JB		 55};
56
2b690f0a
LR		 57#define IEEE80211_COUNTRY_EXTENSION_ID 201
58
72725719
JB		 59union ieee80211_country_ie_triplet {
60 struct {
61 __u8 first_channel;
62 __u8 num_channels;
63 __s8 max_power;
64 } __attribute__ ((packed)) chans;
65 struct {
66 __u8 reg_extension_id;
67 __u8 reg_class;
68 __u8 coverage_class;
69 } __attribute__ ((packed)) ext;
2b690f0a
LR		 70} __attribute__ ((packed));
71
b1622287
LC		 72int parse_sched_scan(struct nl_msg *msg, int *argc, char ***argv)
73{
302a378a 74 struct nl_msg *matchset = NULL, *freqs = NULL, *ssids = NULL;
9ae0d103
AS		 75 struct nl_msg *scan_plans = NULL;
76 struct nlattr *match = NULL, *plan = NULL;
b1622287
LC		 77 enum {
78 ND_TOPLEVEL,
79 ND_MATCH,
80 ND_FREQS,
302a378a 81 ND_ACTIVE,
9ae0d103 82 ND_PLANS,
b1622287
LC		 83 } parse_state = ND_TOPLEVEL;
84 int c = *argc;
85 char *end, **v = *argv;
86 int err = 0, i = 0;
9ae0d103 87 unsigned int freq, interval = 0, delay = 0, iterations = 0;
302a378a 88 bool have_matchset = false, have_freqs = false, have_ssids = false;
9ae0d103 89 bool have_active = false, have_passive = false, have_plans = false;
5130bba0 90 uint32_t flags = 0;
b1622287
LC		 91
92 matchset = nlmsg_alloc();
93 if (!matchset) {
94 err = -ENOBUFS;
95 goto out;
96 }
97
98 freqs = nlmsg_alloc();
99 if (!freqs) {
100 err = -ENOBUFS;
101 goto out;
102 }
103
302a378a
LC		 104 ssids = nlmsg_alloc();
105 if (!ssids) {
106 err = -ENOMEM;
107 goto out;
108 }
109
9ae0d103
AS		 110 scan_plans = nlmsg_alloc();
111 if (!scan_plans) {
112 err = -ENOBUFS;
113 goto out;
114 }
115
b1622287
LC		 116 while (c) {
117 switch (parse_state) {
118 case ND_TOPLEVEL:
119 if (!strcmp(v[0], "interval")) {
120 c--; v++;
121 if (c == 0) {
122 err = -EINVAL;
123 goto nla_put_failure;
124 }
125
9ae0d103 126 if (interval || have_plans) {
b1622287
LC		 127 err = -EINVAL;
128 goto nla_put_failure;
129 }
130 interval = strtoul(v[0], &end, 10);
131 if (*end || !interval) {
132 err = -EINVAL;
133 goto nla_put_failure;
134 }
135 NLA_PUT_U32(msg,
136 NL80211_ATTR_SCHED_SCAN_INTERVAL,
137 interval);
9ae0d103
AS		 138 } else if (!strcmp(v[0], "scan_plans")) {
139 parse_state = ND_PLANS;
140 if (have_plans || interval) {
141 err = -EINVAL;
142 goto nla_put_failure;
143 }
144
145 have_plans = true;
146 i = 0;
b1622287
LC		 147 } else if (!strcmp(v[0], "delay")) {
148 c--; v++;
149 if (c == 0) {
150 err = -EINVAL;
151 goto nla_put_failure;
152 }
153
154 if (delay) {
155 err = -EINVAL;
156 goto nla_put_failure;
157 }
158 delay = strtoul(v[0], &end, 10);
159 if (*end) {
160 err = -EINVAL;
161 goto nla_put_failure;
162 }
163 NLA_PUT_U32(msg,
164 NL80211_ATTR_SCHED_SCAN_DELAY,
165 delay);
166 } else if (!strcmp(v[0], "matches")) {
167 parse_state = ND_MATCH;
168 if (have_matchset) {
169 err = -EINVAL;
170 goto nla_put_failure;
171 }
172
173 i = 0;
174 } else if (!strcmp(v[0], "freqs")) {
175 parse_state = ND_FREQS;
176 if (have_freqs) {
177 err = -EINVAL;
178 goto nla_put_failure;
179 }
180
181 have_freqs = true;
182 i = 0;
302a378a
LC		 183 } else if (!strcmp(v[0], "active")) {
184 parse_state = ND_ACTIVE;
185 if (have_active || have_passive) {
186 err = -EINVAL;
187 goto nla_put_failure;
188 }
189
190 have_active = true;
191 i = 0;
192 } else if (!strcmp(v[0], "passive")) {
193 if (have_active || have_passive) {
194 err = -EINVAL;
195 goto nla_put_failure;
196 }
197
198 have_passive = true;
5130bba0
LC		 199 } else if (!strncmp(v[0], "randomise", 9) ||
200 !strncmp(v[0], "randomize", 9)) {
201 flags |= NL80211_SCAN_FLAG_RANDOM_ADDR;
3c0117c1
JB		 202 err = parse_random_mac_addr(msg, v[0] + 9);
203 if (err)
204 goto nla_put_failure;
b1622287
LC		 205 } else {
206 /* this element is not for us, so
207 * return to continue parsing.
208 */
209 goto nla_put_failure;
210 }
211 c--; v++;
212
213 break;
214 case ND_MATCH:
215 if (!strcmp(v[0], "ssid")) {
216 c--; v++;
217 if (c == 0) {
218 err = -EINVAL;
219 goto nla_put_failure;
220 }
221
222 /* TODO: for now we can only have an
223 * SSID in the match, so we can start
224 * the match nest here.
225 */
226 match = nla_nest_start(matchset, i);
227 if (!match) {
228 err = -ENOBUFS;
229 goto nla_put_failure;
230 }
231
232 NLA_PUT(matchset,
233 NL80211_SCHED_SCAN_MATCH_ATTR_SSID,
234 strlen(v[0]), v[0]);
235 nla_nest_end(matchset, match);
236 match = NULL;
237
238 have_matchset = true;
239 i++;
240 c--; v++;
241 } else {
242 /* other element that cannot be part
243 * of a match indicates the end of the
244 * match. */
245 /* need at least one match in the matchset */
246 if (i == 0) {
247 err = -EINVAL;
248 goto nla_put_failure;
249 }
250
251 parse_state = ND_TOPLEVEL;
252 }
253
254 break;
255 case ND_FREQS:
256 freq = strtoul(v[0], &end, 10);
257 if (*end) {
258 if (i == 0) {
259 err = -EINVAL;
260 goto nla_put_failure;
261 }
262
263 parse_state = ND_TOPLEVEL;
264 } else {
265 NLA_PUT_U32(freqs, i, freq);
266 i++;
267 c--; v++;
268 }
269 break;
302a378a
LC		 270 case ND_ACTIVE:
271 if (!strcmp(v[0], "ssid")) {
272 c--; v++;
273 if (c == 0) {
274 err = -EINVAL;
275 goto nla_put_failure;
276 }
277
278 NLA_PUT(ssids,
279 NL80211_SCHED_SCAN_MATCH_ATTR_SSID,
280 strlen(v[0]), v[0]);
281
282 have_ssids = true;
283 i++;
284 c--; v++;
285 } else {
286 /* other element that cannot be part
287 * of a match indicates the end of the
288 * active set. */
289 /* need at least one item in the set */
290 if (i == 0) {
291 err = -EINVAL;
292 goto nla_put_failure;
293 }
294
295 parse_state = ND_TOPLEVEL;
296 }
297 break;
9ae0d103
AS		 298 case ND_PLANS:
299 iterations = 0;
300 interval = strtoul(v[0], &end, 10);
301 if (*end) {
302 char *iter;
303
304 if (*end != ':') {
305 err = -EINVAL;
306 goto nla_put_failure;
307 }
308
309 iter = ++end;
310 iterations = strtoul(iter, &end, 10);
311 if (*end || !iterations) {
312 err = -EINVAL;
313 goto nla_put_failure;
314 }
315 }
316
317 plan = nla_nest_start(scan_plans, i + 1);
318 if (!plan) {
319 err = -ENOBUFS;
320 goto nla_put_failure;
321 }
322
323 NLA_PUT_U32(scan_plans,
324 NL80211_SCHED_SCAN_PLAN_INTERVAL,
325 interval);
326
327 if (iterations)
328 NLA_PUT_U32(scan_plans,
329 NL80211_SCHED_SCAN_PLAN_ITERATIONS,
330 iterations);
331 else
332 parse_state = ND_TOPLEVEL;
333
334 nla_nest_end(scan_plans, plan);
335 plan = NULL;
336 i++;
337 c--; v++;
338 break;
b1622287
LC		 339 }
340 }
341
302a378a
LC		 342 if (!have_ssids)
343 NLA_PUT(ssids, 1, 0, "");
344 if (!have_passive)
345 nla_put_nested(msg, NL80211_ATTR_SCAN_SSIDS, ssids);
b1622287
LC		 346 if (have_freqs)
347 nla_put_nested(msg, NL80211_ATTR_SCAN_FREQUENCIES, freqs);
348 if (have_matchset)
349 nla_put_nested(msg, NL80211_ATTR_SCHED_SCAN_MATCH, matchset);
9ae0d103
AS		 350 if (have_plans)
351 nla_put_nested(msg, NL80211_ATTR_SCHED_SCAN_PLANS, scan_plans);
5130bba0
LC		 352 if (flags)
353 NLA_PUT_U32(msg, NL80211_ATTR_SCAN_FLAGS, flags);
b1622287
LC		 354
355nla_put_failure:
356 if (match)
357 nla_nest_end(msg, match);
edb5f4f0 358out:
b1622287
LC		 359 nlmsg_free(freqs);
360 nlmsg_free(matchset);
9ae0d103 361 nlmsg_free(scan_plans);
edb5f4f0 362 nlmsg_free(ssids);
b1622287 363
b1622287
LC		 364 *argc = c;
365 *argv = v;
366 return err;
367}
368
7c37a24d 369static int handle_scan(struct nl80211_state *state,
3563f4c5 370 struct nl_msg *msg,
05514f95
JB		 371 int argc, char **argv,
372 enum id_input id)
3563f4c5 373{
559a1713
JB		 374 struct nl_msg *ssids = NULL, *freqs = NULL;
375 char *eptr;
3563f4c5 376 int err = -ENOBUFS;
559a1713
JB		 377 int i;
378 enum {
379 NONE,
380 FREQ,
64797a7f 381 IES,
559a1713 382 SSID,
851d35c2 383 MESHID,
3a99ff6d 384 DURATION,
559a1713
JB		 385 DONE,
386 } parse = NONE;
387 int freq;
3a99ff6d 388 unsigned int duration = 0;
559a1713 389 bool passive = false, have_ssids = false, have_freqs = false;
3a99ff6d 390 bool duration_mandatory = false;
851d35c2 391 size_t ies_len = 0, meshid_len = 0;
2f74c59c 392 unsigned char *ies = NULL, *meshid = NULL, *tmpies = NULL;
5085aa2b 393 unsigned int flags = 0;
3563f4c5
JB		 394
395 ssids = nlmsg_alloc();
396 if (!ssids)
397 return -ENOMEM;
559a1713
JB		 398
399 freqs = nlmsg_alloc();
400 if (!freqs) {
401 nlmsg_free(ssids);
402 return -ENOMEM;
403 }
404
405 for (i = 0; i < argc; i++) {
559a1713
JB		 406 switch (parse) {
407 case NONE:
64797a7f
JB		 408 if (strcmp(argv[i], "freq") == 0) {
409 parse = FREQ;
410 have_freqs = true;
411 break;
412 } else if (strcmp(argv[i], "ies") == 0) {
413 parse = IES;
414 break;
fe862239 415 } else if (strcmp(argv[i], "lowpri") == 0) {
fe862239
SL		 416 flags |= NL80211_SCAN_FLAG_LOW_PRIORITY;
417 break;
418 } else if (strcmp(argv[i], "flush") == 0) {
fe862239
SL		 419 flags |= NL80211_SCAN_FLAG_FLUSH;
420 break;
ced94d5f 421 } else if (strcmp(argv[i], "ap-force") == 0) {
ced94d5f
AQ		 422 flags |= NL80211_SCAN_FLAG_AP;
423 break;
3a99ff6d
PKC		 424 } else if (strcmp(argv[i], "duration-mandatory") == 0) {
425 duration_mandatory = true;
426 break;
5085aa2b
JB		 427 } else if (strncmp(argv[i], "randomise", 9) == 0 ||
428 strncmp(argv[i], "randomize", 9) == 0) {
429 flags |= NL80211_SCAN_FLAG_RANDOM_ADDR;
3c0117c1 430 err = parse_random_mac_addr(msg, argv[i] + 9);
5085aa2b
JB		 431 if (err)
432 goto nla_put_failure;
433 break;
64797a7f
JB		 434 } else if (strcmp(argv[i], "ssid") == 0) {
435 parse = SSID;
436 have_ssids = true;
437 break;
438 } else if (strcmp(argv[i], "passive") == 0) {
439 parse = DONE;
440 passive = true;
441 break;
851d35c2 442 } else if (strcmp(argv[i], "meshid") == 0) {
443 parse = MESHID;
444 break;
3a99ff6d
PKC		 445 } else if (strcmp(argv[i], "duration") == 0) {
446 parse = DURATION;
447 break;
64797a7f 448 }
6ab936f0 449 /* fall through - this is an error */
559a1713 450 case DONE:
2f74c59c
JC		 451 err = 1;
452 goto nla_put_failure;
559a1713
JB		 453 case FREQ:
454 freq = strtoul(argv[i], &eptr, 10);
cc12e895
JB		 455 if (eptr != argv[i] + strlen(argv[i])) {
456 /* failed to parse as number -- maybe a tag? */
457 i--;
458 parse = NONE;
459 continue;
460 }
559a1713 461 NLA_PUT_U32(freqs, i, freq);
64797a7f
JB		 462 break;
463 case IES:
2f74c59c
JC		 464 if (ies)
465 free(ies);
851d35c2 466 ies = parse_hex(argv[i], &ies_len);
64797a7f
JB		 467 if (!ies)
468 goto nla_put_failure;
64797a7f 469 parse = NONE;
559a1713
JB		 470 break;
471 case SSID:
472 NLA_PUT(ssids, i, strlen(argv[i]), argv[i]);
473 break;
851d35c2 474 case MESHID:
475 meshid_len = strlen(argv[i]);
476 meshid = (unsigned char *) malloc(meshid_len + 2);
477 if (!meshid)
478 goto nla_put_failure;
479 meshid[0] = 114; /* mesh element id */
480 meshid[1] = meshid_len;
481 memcpy(&meshid[2], argv[i], meshid_len);
482 meshid_len += 2;
483 parse = NONE;
484 break;
3a99ff6d
PKC		 485 case DURATION:
486 duration = strtoul(argv[i], &eptr, 10);
487 parse = NONE;
488 break;
851d35c2 489 }
490 }
491
492 if (ies || meshid) {
493 tmpies = (unsigned char *) malloc(ies_len + meshid_len);
2f74c59c 494 if (!tmpies)
851d35c2 495 goto nla_put_failure;
2f74c59c 496 if (ies)
851d35c2 497 memcpy(tmpies, ies, ies_len);
2f74c59c 498 if (meshid)
851d35c2 499 memcpy(&tmpies[ies_len], meshid, meshid_len);
2f74c59c 500 if (nla_put(msg, NL80211_ATTR_IE, ies_len + meshid_len, tmpies) < 0)
ab65a092 501 goto nla_put_failure;
559a1713
JB		 502 }
503
504 if (!have_ssids)
505 NLA_PUT(ssids, 1, 0, "");
506 if (!passive)
507 nla_put_nested(msg, NL80211_ATTR_SCAN_SSIDS, ssids);
508
509 if (have_freqs)
510 nla_put_nested(msg, NL80211_ATTR_SCAN_FREQUENCIES, freqs);
fe862239
SL		 511 if (flags)
512 NLA_PUT_U32(msg, NL80211_ATTR_SCAN_FLAGS, flags);
3a99ff6d
PKC		 513 if (duration)
514 NLA_PUT_U16(msg, NL80211_ATTR_MEASUREMENT_DURATION, duration);
515 if (duration_mandatory) {
516 if (duration) {
517 NLA_PUT_FLAG(msg,
518 NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY);
519 } else {
520 err = -EINVAL;
521 goto nla_put_failure;
522 }
523 }
3563f4c5
JB		 524
525 err = 0;
526 nla_put_failure:
527 nlmsg_free(ssids);
559a1713 528 nlmsg_free(freqs);
2f74c59c
JC		 529 if (meshid)
530 free(meshid);
531 if (ies)
532 free(ies);
533 if (tmpies)
534 free(tmpies);
3563f4c5
JB		 535 return err;
536}
3563f4c5 537
857d966e
MH		 538static void tab_on_first(bool *first)
539{
540 if (!*first)
541 printf("\t");
542 else
543 *first = false;
544}
545
5f310d83
SM		 546struct print_ies_data {
547 unsigned char *ie;
548 int ielen;
549};
550
551static void print_ssid(const uint8_t type, uint8_t len, const uint8_t *data,
552 const struct print_ies_data *ie_buffer)
3563f4c5 553{
83b4934c 554 printf(" ");
748f8489 555 print_ssid_escaped(len, data);
3563f4c5
JB		 556 printf("\n");
557}
558
ca159934 559#define BSS_MEMBERSHIP_SELECTOR_VHT_PHY 126
1fd19c39
CL		 560#define BSS_MEMBERSHIP_SELECTOR_HT_PHY 127
561
5f310d83
SM		 562static void print_supprates(const uint8_t type, uint8_t len,
563 const uint8_t *data,
564 const struct print_ies_data *ie_buffer)
3563f4c5
JB		 565{
566 int i;
567
83b4934c 568 printf(" ");
3563f4c5 569
83b4934c 570 for (i = 0; i < len; i++) {
3563f4c5 571 int r = data[i] & 0x7f;
1fd19c39 572
ca159934
JB		 573 if (r == BSS_MEMBERSHIP_SELECTOR_VHT_PHY && data[i] & 0x80)
574 printf("VHT");
575 else if (r == BSS_MEMBERSHIP_SELECTOR_HT_PHY && data[i] & 0x80)
1fd19c39
CL		 576 printf("HT");
577 else
578 printf("%d.%d", r/2, 5*(r&1));
579
580 printf("%s ", data[i] & 0x80 ? "*" : "");
3563f4c5
JB		 581 }
582 printf("\n");
583}
584
4d72d1d2
MT		 585static void print_rm_enabled_capabilities(const uint8_t type, uint8_t len,
586 const uint8_t *data,
587 const struct print_ies_data *ie_buffer)
588{
589 __u64 capa = data[0] |
590 data[1] << 8 |
591 data[2] << 16 |
592 data[3] << 24 |
593 ((__u64) data[4]) << 32;
594
595 printf("\n");
596 printf("\t\tCapabilities: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
597 data[0], data[1],
598 data[2], data[3],
599 data[4]);
600
601#define PRINT_RM_CAPA(_bit, _str) \
602 do { \
603 if (capa & BIT(_bit)) \
604 printf("\t\t\t" _str "\n"); \
605 } while (0)
606
607 PRINT_RM_CAPA(0, "Link Measurement");
608 PRINT_RM_CAPA(1, "Neighbor Report");
609 PRINT_RM_CAPA(2, "Parallel Measurements");
610 PRINT_RM_CAPA(3, "Repeated Measurements");
611 PRINT_RM_CAPA(4, "Beacon Passive Measurement");
a532a81b 612 PRINT_RM_CAPA(5, "Beacon Active Measurement");
4d72d1d2
MT		 613 PRINT_RM_CAPA(6, "Beacon Table Measurement");
614 PRINT_RM_CAPA(7, "Beacon Measurement Reporting Conditions");
615 PRINT_RM_CAPA(8, "Frame Measurement");
616 PRINT_RM_CAPA(9, "Channel Load");
617 PRINT_RM_CAPA(10, "Noise Histogram Measurement");
618 PRINT_RM_CAPA(11, "Statistics Measurement");
619 PRINT_RM_CAPA(12, "LCI Measurement");
620 PRINT_RM_CAPA(13, "LCI Azimuth");
621 PRINT_RM_CAPA(14, "Transmit Stream/Category Measurement");
622 PRINT_RM_CAPA(15, "Triggered Transmit Stream/Category");
623 PRINT_RM_CAPA(16, "AP Channel Report");
624 PRINT_RM_CAPA(17, "RM MIB Capability");
625
626 PRINT_RM_CAPA(27, "Measurement Pilot Transmission Information");
627 PRINT_RM_CAPA(28, "Neighbor Report TSF Offset");
628 PRINT_RM_CAPA(29, "RCPI Measurement");
629 PRINT_RM_CAPA(30, "RSNI Measurement");
630 PRINT_RM_CAPA(31, "BSS Average Access Delay");
631 PRINT_RM_CAPA(32, "BSS Available Admission");
632 PRINT_RM_CAPA(33, "Antenna");
633 PRINT_RM_CAPA(34, "FTM Range Report");
634 PRINT_RM_CAPA(35, "Civic Location Measurement");
635
636 printf("\t\tNonoperating Channel Max Measurement Duration: %i\n", data[3] >> 5);
637 printf("\t\tMeasurement Pilot Capability: %i\n", data[4] & 7);
638}
639
5f310d83
SM		 640static void print_ds(const uint8_t type, uint8_t len, const uint8_t *data,
641 const struct print_ies_data *ie_buffer)
3563f4c5 642{
83b4934c 643 printf(" channel %d\n", data[0]);
3563f4c5
JB		 644}
645
2b690f0a 646static const char *country_env_str(char environment)
b7e8fa37 647{
2b690f0a 648 switch (environment) {
b7e8fa37 649 case 'I':
2b690f0a 650 return "Indoor only";
b7e8fa37 651 case 'O':
2b690f0a 652 return "Outdoor only";
b6c0d634 653 case ' ':
2b690f0a 654 return "Indoor/Outdoor";
b6c0d634 655 default:
2b690f0a 656 return "bogus";
b7e8fa37 657 }
2b690f0a
LR		 658}
659
5f310d83
SM		 660static void print_country(const uint8_t type, uint8_t len, const uint8_t *data,
661 const struct print_ies_data *ie_buffer)
2b690f0a
LR		 662{
663 printf(" %.*s", 2, data);
664
665 printf("\tEnvironment: %s\n", country_env_str(data[2]));
666
667 data += 3;
668 len -= 3;
669
670 if (len < 3) {
671 printf("\t\tNo country IE triplets present\n");
672 return;
673 }
674
675 while (len >= 3) {
676 int end_channel;
72725719 677 union ieee80211_country_ie_triplet *triplet = (void *) data;
2b690f0a
LR		 678
679 if (triplet->ext.reg_extension_id >= IEEE80211_COUNTRY_EXTENSION_ID) {
680 printf("\t\tExtension ID: %d Regulatory Class: %d Coverage class: %d (up to %dm)\n",
681 triplet->ext.reg_extension_id,
682 triplet->ext.reg_class,
683 triplet->ext.coverage_class,
684 triplet->ext.coverage_class * 450);
685
686 data += 3;
687 len -= 3;
688 continue;
689 }
690
691 /* 2 GHz */
692 if (triplet->chans.first_channel <= 14)
693 end_channel = triplet->chans.first_channel + (triplet->chans.num_channels - 1);
694 else
695 end_channel = triplet->chans.first_channel + (4 * (triplet->chans.num_channels - 1));
696
a9859d30 697 printf("\t\tChannels [%d - %d] @ %d dBm\n", triplet->chans.first_channel, end_channel, triplet->chans.max_power);
2b690f0a
LR		 698
699 data += 3;
700 len -= 3;
701 }
702
703 return;
b7e8fa37
MH		 704}
705
5f310d83
SM		 706static void print_powerconstraint(const uint8_t type, uint8_t len,
707 const uint8_t *data,
708 const struct print_ies_data *ie_buffer)
d1563a1b
MH		 709{
710 printf(" %d dB\n", data[0]);
711}
712
5f310d83
SM		 713static void print_tpcreport(const uint8_t type, uint8_t len,
714 const uint8_t *data,
715 const struct print_ies_data *ie_buffer)
792172b0
JM		 716{
717 printf(" TX power: %d dBm\n", data[0]);
718 /* printf(" Link Margin (%d dB) is reserved in Beacons\n", data[1]); */
719}
720
5f310d83
SM		 721static void print_erp(const uint8_t type, uint8_t len, const uint8_t *data,
722 const struct print_ies_data *ie_buffer)
fc4d1484
MH		 723{
724 if (data[0] == 0x00)
83b4934c 725 printf(" <no flags>");
fc4d1484
MH		 726 if (data[0] & 0x01)
727 printf(" NonERP_Present");
728 if (data[0] & 0x02)
729 printf(" Use_Protection");
730 if (data[0] & 0x04)
731 printf(" Barker_Preamble_Mode");
732 printf("\n");
733}
734
83b4934c 735static void print_cipher(const uint8_t *data)
857d966e 736{
3bd60ef1 737 if (memcmp(data, ms_oui, 3) == 0) {
857d966e 738 switch (data[3]) {
510e0e2f 739 case 0:
857d966e
MH		 740 printf("Use group cipher suite");
741 break;
510e0e2f 742 case 1:
857d966e
MH		 743 printf("WEP-40");
744 break;
510e0e2f 745 case 2:
857d966e
MH		 746 printf("TKIP");
747 break;
510e0e2f 748 case 4:
857d966e
MH		 749 printf("CCMP");
750 break;
510e0e2f 751 case 5:
857d966e
MH		 752 printf("WEP-104");
753 break;
754 default:
332769c6 755 printf("%.02x-%.02x-%.02x:%d",
5594fd23 756 data[0], data[1] ,data[2], data[3]);
857d966e
MH		 757 break;
758 }
759 } else if (memcmp(data, ieee80211_oui, 3) == 0) {
760 switch (data[3]) {
510e0e2f 761 case 0:
857d966e
MH		 762 printf("Use group cipher suite");
763 break;
510e0e2f 764 case 1:
857d966e
MH		 765 printf("WEP-40");
766 break;
510e0e2f 767 case 2:
857d966e
MH		 768 printf("TKIP");
769 break;
510e0e2f 770 case 4:
857d966e
MH		 771 printf("CCMP");
772 break;
510e0e2f 773 case 5:
857d966e
MH		 774 printf("WEP-104");
775 break;
510e0e2f 776 case 6:
857d966e
MH		 777 printf("AES-128-CMAC");
778 break;
f188ab67
BG		 779 case 7:
780 printf("NO-GROUP");
781 break;
a8b3da9d
VK		 782 case 8:
783 printf("GCMP");
784 break;
857d966e 785 default:
332769c6 786 printf("%.02x-%.02x-%.02x:%d",
5594fd23 787 data[0], data[1] ,data[2], data[3]);
857d966e
MH		 788 break;
789 }
790 } else
332769c6 791 printf("%.02x-%.02x-%.02x:%d",
5594fd23 792 data[0], data[1] ,data[2], data[3]);
857d966e
MH		 793}
794
83b4934c 795static void print_auth(const uint8_t *data)
857d966e 796{
3bd60ef1 797 if (memcmp(data, ms_oui, 3) == 0) {
857d966e 798 switch (data[3]) {
510e0e2f 799 case 1:
857d966e
MH		 800 printf("IEEE 802.1X");
801 break;
510e0e2f 802 case 2:
857d966e
MH		 803 printf("PSK");
804 break;
805 default:
332769c6 806 printf("%.02x-%.02x-%.02x:%d",
5594fd23 807 data[0], data[1] ,data[2], data[3]);
857d966e
MH		 808 break;
809 }
810 } else if (memcmp(data, ieee80211_oui, 3) == 0) {
811 switch (data[3]) {
510e0e2f 812 case 1:
857d966e
MH		 813 printf("IEEE 802.1X");
814 break;
510e0e2f 815 case 2:
857d966e
MH		 816 printf("PSK");
817 break;
0fe1c415
JB		 818 case 3:
819 printf("FT/IEEE 802.1X");
820 break;
821 case 4:
822 printf("FT/PSK");
823 break;
824 case 5:
825 printf("IEEE 802.1X/SHA-256");
826 break;
827 case 6:
828 printf("PSK/SHA-256");
829 break;
4361eef3
JM		 830 case 7:
831 printf("TDLS/TPK");
832 break;
a58f492d
HM		 833 case 8:
834 printf("SAE");
835 break;
836 case 9:
837 printf("FT/SAE");
838 break;
839 case 11:
840 printf("IEEE 802.1X/SUITE-B");
841 break;
842 case 12:
843 printf("IEEE 802.1X/SUITE-B-192");
844 break;
845 case 13:
846 printf("FT/IEEE 802.1X/SHA-384");
847 break;
848 case 14:
849 printf("FILS/SHA-256");
850 break;
851 case 15:
852 printf("FILS/SHA-384");
853 break;
854 case 16:
855 printf("FT/FILS/SHA-256");
856 break;
857 case 17:
858 printf("FT/FILS/SHA-384");
859 break;
860 case 18:
861 printf("OWE");
862 break;
857d966e 863 default:
332769c6 864 printf("%.02x-%.02x-%.02x:%d",
5594fd23 865 data[0], data[1] ,data[2], data[3]);
857d966e
MH		 866 break;
867 }
f188ab67
BG		 868 } else if (memcmp(data, wfa_oui, 3) == 0) {
869 switch (data[3]) {
870 case 1:
871 printf("OSEN");
872 break;
a58f492d
HM		 873 case 2:
874 printf("DPP");
875 break;
f188ab67
BG		 876 default:
877 printf("%.02x-%.02x-%.02x:%d",
878 data[0], data[1] ,data[2], data[3]);
879 break;
880 }
857d966e 881 } else
332769c6 882 printf("%.02x-%.02x-%.02x:%d",
5594fd23 883 data[0], data[1] ,data[2], data[3]);
857d966e
MH		 884}
885
f188ab67
BG		 886static void _print_rsn_ie(const char *defcipher, const char *defauth,
887 uint8_t len, const uint8_t *data, int is_osen)
857d966e
MH		 888{
889 bool first = true;
f188ab67 890 __u16 count, capa;
857d966e
MH		 891 int i;
892
f188ab67
BG		 893 if (!is_osen) {
894 __u16 version;
895 version = data[0] + (data[1] << 8);
896 tab_on_first(&first);
897 printf("\t * Version: %d\n", version);
857d966e 898
f188ab67
BG		 899 data += 2;
900 len -= 2;
901 }
857d966e
MH		 902
903 if (len < 4) {
904 tab_on_first(&first);
905 printf("\t * Group cipher: %s\n", defcipher);
906 printf("\t * Pairwise ciphers: %s\n", defcipher);
907 return;
908 }
909
910 tab_on_first(&first);
911 printf("\t * Group cipher: ");
912 print_cipher(data);
913 printf("\n");
914
915 data += 4;
916 len -= 4;
917
918 if (len < 2) {
919 tab_on_first(&first);
920 printf("\t * Pairwise ciphers: %s\n", defcipher);
921 return;
922 }
923
924 count = data[0] | (data[1] << 8);
31d477fb
MH		 925 if (2 + (count * 4) > len)
926 goto invalid;
927
857d966e
MH		 928 tab_on_first(&first);
929 printf("\t * Pairwise ciphers:");
31d477fb 930 for (i = 0; i < count; i++) {
857d966e
MH		 931 printf(" ");
932 print_cipher(data + 2 + (i * 4));
933 }
934 printf("\n");
935
936 data += 2 + (count * 4);
937 len -= 2 + (count * 4);
938
939 if (len < 2) {
940 tab_on_first(&first);
941 printf("\t * Authentication suites: %s\n", defauth);
942 return;
943 }
944
945 count = data[0] | (data[1] << 8);
31d477fb
MH		 946 if (2 + (count * 4) > len)
947 goto invalid;
948
857d966e
MH		 949 tab_on_first(&first);
950 printf("\t * Authentication suites:");
83b4934c 951 for (i = 0; i < count; i++) {
857d966e
MH		 952 printf(" ");
953 print_auth(data + 2 + (i * 4));
954 }
955 printf("\n");
956
957 data += 2 + (count * 4);
958 len -= 2 + (count * 4);
959
6a4f24e8
JB		 960 if (len >= 2) {
961 capa = data[0] | (data[1] << 8);
962 tab_on_first(&first);
cadbe89a
JB		 963 printf("\t * Capabilities:");
964 if (capa & 0x0001)
965 printf(" PreAuth");
966 if (capa & 0x0002)
967 printf(" NoPairwise");
968 switch ((capa & 0x000c) >> 2) {
969 case 0:
4361eef3 970 printf(" 1-PTKSA-RC");
cadbe89a
JB		 971 break;
972 case 1:
973 printf(" 2-PTKSA-RC");
974 break;
975 case 2:
976 printf(" 4-PTKSA-RC");
977 break;
978 case 3:
979 printf(" 16-PTKSA-RC");
980 break;
981 }
982 switch ((capa & 0x0030) >> 4) {
983 case 0:
4361eef3 984 printf(" 1-GTKSA-RC");
cadbe89a
JB		 985 break;
986 case 1:
987 printf(" 2-GTKSA-RC");
988 break;
989 case 2:
990 printf(" 4-GTKSA-RC");
991 break;
992 case 3:
993 printf(" 16-GTKSA-RC");
994 break;
995 }
996 if (capa & 0x0040)
997 printf(" MFP-required");
998 if (capa & 0x0080)
999 printf(" MFP-capable");
1000 if (capa & 0x0200)
1001 printf(" Peerkey-enabled");
1002 if (capa & 0x0400)
1003 printf(" SPP-AMSDU-capable");
1004 if (capa & 0x0800)
1005 printf(" SPP-AMSDU-required");
1006 printf(" (0x%.4x)\n", capa);
6a4f24e8
JB		 1007 data += 2;
1008 len -= 2;
1009 }
31d477fb 1010
5ba3f523
JB		 1011 if (len >= 2) {
1012 int pmkid_count = data[0] | (data[1] << 8);
1013
1014 if (len >= 2 + 16 * pmkid_count) {
1015 tab_on_first(&first);
1016 printf("\t * %d PMKIDs\n", pmkid_count);
1017 /* not printing PMKID values */
1018 data += 2 + 16 * pmkid_count;
1019 len -= 2 + 16 * pmkid_count;
1020 } else
1021 goto invalid;
1022 }
1023
1024 if (len >= 4) {
1025 tab_on_first(&first);
1026 printf("\t * Group mgmt cipher suite: ");
1027 print_cipher(data);
1028 printf("\n");
1029 data += 4;
1030 len -= 4;
1031 }
1032
cadbe89a 1033 invalid:
31d477fb
MH		 1034 if (len != 0) {
1035 printf("\t\t * bogus tail data (%d):", len);
1036 while (len) {
1037 printf(" %.2x", *data);
1038 data++;
1039 len--;
1040 }
1041 printf("\n");
1042 }
857d966e
MH		 1043}
1044
f188ab67
BG		 1045static void print_rsn_ie(const char *defcipher, const char *defauth,
1046 uint8_t len, const uint8_t *data)
1047{
1048 _print_rsn_ie(defcipher, defauth, len, data, 0);
1049}
1050
1051static void print_osen_ie(const char *defcipher, const char *defauth,
1052 uint8_t len, const uint8_t *data)
1053{
1054 printf("\n\t");
1055 _print_rsn_ie(defcipher, defauth, len, data, 1);
1056}
1057
5f310d83
SM		 1058static void print_rsn(const uint8_t type, uint8_t len, const uint8_t *data,
1059 const struct print_ies_data *ie_buffer)
857d966e 1060{
83b4934c 1061 print_rsn_ie("CCMP", "IEEE 802.1X", len, data);
857d966e
MH		 1062}
1063
5f310d83
SM		 1064static void print_ht_capa(const uint8_t type, uint8_t len, const uint8_t *data,
1065 const struct print_ies_data *ie_buffer)
0c445c24 1066{
357c1a5d 1067 printf("\n");
7ddfb679
JB		 1068 print_ht_capability(data[0] | (data[1] << 8));
1069 print_ampdu_length(data[2] & 3);
c79c7464 1070 print_ampdu_spacing((data[2] >> 2) & 7);
7ddfb679 1071 print_ht_mcs(data + 3);
0c445c24
LR		 1072}
1073
489f0ea9
BG		 1074static const char* ntype_11u(uint8_t t)
1075{
1076 switch (t) {
1077 case 0: return "Private";
1078 case 1: return "Private with Guest";
1079 case 2: return "Chargeable Public";
1080 case 3: return "Free Public";
1081 case 4: return "Personal Device";
1082 case 5: return "Emergency Services Only";
1083 case 14: return "Test or Experimental";
1084 case 15: return "Wildcard";
1085 default: return "Reserved";
1086 }
1087}
1088
1089static const char* vgroup_11u(uint8_t t)
1090{
1091 switch (t) {
1092 case 0: return "Unspecified";
1093 case 1: return "Assembly";
1094 case 2: return "Business";
1095 case 3: return "Educational";
1096 case 4: return "Factory and Industrial";
1097 case 5: return "Institutional";
1098 case 6: return "Mercantile";
1099 case 7: return "Residential";
1100 case 8: return "Storage";
1101 case 9: return "Utility and Miscellaneous";
1102 case 10: return "Vehicular";
1103 case 11: return "Outdoor";
1104 default: return "Reserved";
1105 }
1106}
1107
5f310d83
SM		 1108static void print_interworking(const uint8_t type, uint8_t len,
1109 const uint8_t *data,
1110 const struct print_ies_data *ie_buffer)
489f0ea9
BG		 1111{
1112 /* See Section 7.3.2.92 in the 802.11u spec. */
1113 printf("\n");
1114 if (len >= 1) {
1115 uint8_t ano = data[0];
1116 printf("\t\tNetwork Options: 0x%hx\n", (unsigned short)(ano));
1117 printf("\t\t\tNetwork Type: %i (%s)\n",
1118 (int)(ano & 0xf), ntype_11u(ano & 0xf));
1119 if (ano & (1<<4))
1120 printf("\t\t\tInternet\n");
1121 if (ano & (1<<5))
1122 printf("\t\t\tASRA\n");
1123 if (ano & (1<<6))
1124 printf("\t\t\tESR\n");
1125 if (ano & (1<<7))
1126 printf("\t\t\tUESA\n");
1127 }
1128 if ((len == 3) || (len == 9)) {
1129 printf("\t\tVenue Group: %i (%s)\n",
1130 (int)(data[1]), vgroup_11u(data[1]));
1131 printf("\t\tVenue Type: %i\n", (int)(data[2]));
1132 }
1133 if (len == 9)
1134 printf("\t\tHESSID: %02hx:%02hx:%02hx:%02hx:%02hx:%02hx\n",
1135 data[3], data[4], data[5], data[6], data[7], data[8]);
1136 else if (len == 7)
1137 printf("\t\tHESSID: %02hx:%02hx:%02hx:%02hx:%02hx:%02hx\n",
1138 data[1], data[2], data[3], data[4], data[5], data[6]);
1139}
1140
5f310d83
SM		 1141static void print_11u_advert(const uint8_t type, uint8_t len,
1142 const uint8_t *data,
1143 const struct print_ies_data *ie_buffer)
3f818f6d
BG		 1144{
1145 /* See Section 7.3.2.93 in the 802.11u spec. */
1146 /* TODO: This code below does not decode private protocol IDs */
1147 int idx = 0;
1148 printf("\n");
1149 while (idx < (len - 1)) {
1150 uint8_t qri = data[idx];
1151 uint8_t proto_id = data[idx + 1];
1152 printf("\t\tQuery Response Info: 0x%hx\n", (unsigned short)(qri));
1153 printf("\t\t\tQuery Response Length Limit: %i\n",
1154 (qri & 0x7f));
1155 if (qri & (1<<7))
1156 printf("\t\t\tPAME-BI\n");
1157 switch(proto_id) {
1158 case 0:
1159 printf("\t\t\tANQP\n"); break;
1160 case 1:
1161 printf("\t\t\tMIH Information Service\n"); break;
1162 case 2:
1163 printf("\t\t\tMIH Command and Event Services Capability Discovery\n"); break;
1164 case 3:
1165 printf("\t\t\tEmergency Alert System (EAS)\n"); break;
1166 case 221:
1167 printf("\t\t\tVendor Specific\n"); break;
1168 default:
1169 printf("\t\t\tReserved: %i\n", proto_id); break;
1170 }
1171 idx += 2;
1172 }
1173}
1174
5f310d83
SM		 1175static void print_11u_rcon(const uint8_t type, uint8_t len, const uint8_t *data,
1176 const struct print_ies_data *ie_buffer)
bc9e14f1
BG		 1177{
1178 /* See Section 7.3.2.96 in the 802.11u spec. */
1179 int idx = 0;
1180 int ln0 = data[1] & 0xf;
1181 int ln1 = ((data[1] & 0xf0) >> 4);
1182 int ln2 = 0;
1183 printf("\n");
1184
1185 if (ln1)
1186 ln2 = len - 2 - ln0 - ln1;
1187
1188 printf("\t\tANQP OIs: %i\n", data[0]);
1189
1190 if (ln0 > 0) {
1191 printf("\t\tOI 1: ");
1192 if (2 + ln0 > len) {
1193 printf("Invalid IE length.\n");
1194 } else {
1195 for (idx = 0; idx < ln0; idx++) {
1196 printf("%02hx", data[2 + idx]);
1197 }
1198 printf("\n");
1199 }
1200 }
1201
1202 if (ln1 > 0) {
1203 printf("\t\tOI 2: ");
1204 if (2 + ln0 + ln1 > len) {
1205 printf("Invalid IE length.\n");
1206 } else {
1207 for (idx = 0; idx < ln1; idx++) {
1208 printf("%02hx", data[2 + ln0 + idx]);
1209 }
1210 printf("\n");
1211 }
1212 }
1213
1214 if (ln2 > 0) {
1215 printf("\t\tOI 3: ");
1216 if (2 + ln0 + ln1 + ln2 > len) {
1217 printf("Invalid IE length.\n");
1218 } else {
1219 for (idx = 0; idx < ln2; idx++) {
1220 printf("%02hx", data[2 + ln0 + ln1 + idx]);
1221 }
1222 printf("\n");
1223 }
1224 }
1225}
1226
29f7579e
JB		 1227static const char *ht_secondary_offset[4] = {
1228 "no secondary",
1229 "above",
1230 "[reserved!]",
1231 "below",
1232};
1233
5f310d83
SM		 1234static void print_ht_op(const uint8_t type, uint8_t len, const uint8_t *data,
1235 const struct print_ies_data *ie_buffer)
be7602fb 1236{
be7602fb
JB		 1237 static const char *protection[4] = {
1238 "no",
1239 "nonmember",
1240 "20 MHz",
1241 "non-HT mixed",
1242 };
1243 static const char *sta_chan_width[2] = {
1244 "20 MHz",
1245 "any",
1246 };
1247
1248 printf("\n");
1249 printf("\t\t * primary channel: %d\n", data[0]);
1250 printf("\t\t * secondary channel offset: %s\n",
29f7579e 1251 ht_secondary_offset[data[1] & 0x3]);
be7602fb
JB		 1252 printf("\t\t * STA channel width: %s\n", sta_chan_width[(data[1] & 0x4)>>2]);
1253 printf("\t\t * RIFS: %d\n", (data[1] & 0x8)>>3);
1254 printf("\t\t * HT protection: %s\n", protection[data[2] & 0x3]);
1255 printf("\t\t * non-GF present: %d\n", (data[2] & 0x4) >> 2);
1256 printf("\t\t * OBSS non-GF present: %d\n", (data[2] & 0x10) >> 4);
1257 printf("\t\t * dual beacon: %d\n", (data[4] & 0x40) >> 6);
1258 printf("\t\t * dual CTS protection: %d\n", (data[4] & 0x80) >> 7);
1259 printf("\t\t * STBC beacon: %d\n", data[5] & 0x1);
1260 printf("\t\t * L-SIG TXOP Prot: %d\n", (data[5] & 0x2) >> 1);
1261 printf("\t\t * PCO active: %d\n", (data[5] & 0x4) >> 2);
1262 printf("\t\t * PCO phase: %d\n", (data[5] & 0x8) >> 3);
1263}
1264
5f310d83
SM		 1265static void print_capabilities(const uint8_t type, uint8_t len,
1266 const uint8_t *data,
1267 const struct print_ies_data *ie_buffer)
9b880b00 1268{
5f310d83
SM		 1269 int i, base, bit, si_duration = 0, max_amsdu = 0;
1270 bool s_psmp_support = false, is_vht_cap = false;
1271 unsigned char *ie = ie_buffer->ie;
1272 int ielen = ie_buffer->ielen;
31d2d259 1273
5f310d83
SM		 1274 while (ielen >= 2 && ielen >= ie[1]) {
1275 if (ie[0] == 191) {
1276 is_vht_cap = true;
1277 break;
1278 }
1279 ielen -= ie[1] + 2;
1280 ie += ie[1] + 2;
1281 }
31d2d259
JB		 1282
1283 for (i = 0; i < len; i++) {
1284 base = i * 8;
1285
1286 for (bit = 0; bit < 8; bit++) {
1287 if (!(data[i] & (1 << bit)))
1288 continue;
1289
5f310d83 1290 printf("\n\t\t *");
31d2d259 1291
70c649d2
JB		 1292#define CAPA(bit, name) case bit: printf(" " name); break
1293
5f310d83
SM		 1294/* if the capability 'cap' exists add 'val' to 'sum'
1295 * otherwise print 'Reserved' */
1296#define ADD_BIT_VAL(bit, cap, sum, val) case (bit): do { \
1297 if (!(cap)) { \
1298 printf(" Reserved"); \
1299 break; \
1300 } \
1301 sum += val; \
1302 break; \
1303} while (0)
1304
31d2d259 1305 switch (bit + base) {
70c649d2
JB		 1306 CAPA(0, "HT Information Exchange Supported");
1307 CAPA(1, "reserved (On-demand Beacon)");
1308 CAPA(2, "Extended Channel Switching");
1309 CAPA(3, "reserved (Wave Indication)");
1310 CAPA(4, "PSMP Capability");
1311 CAPA(5, "reserved (Service Interval Granularity)");
5f310d83
SM		 1312
1313 case 6:
1314 s_psmp_support = true;
1315 printf(" S-PSMP Capability");
1316 break;
1317
70c649d2
JB		 1318 CAPA(7, "Event");
1319 CAPA(8, "Diagnostics");
1320 CAPA(9, "Multicast Diagnostics");
1321 CAPA(10, "Location Tracking");
1322 CAPA(11, "FMS");
1323 CAPA(12, "Proxy ARP Service");
1324 CAPA(13, "Collocated Interference Reporting");
1325 CAPA(14, "Civic Location");
1326 CAPA(15, "Geospatial Location");
1327 CAPA(16, "TFS");
1328 CAPA(17, "WNM-Sleep Mode");
1329 CAPA(18, "TIM Broadcast");
1330 CAPA(19, "BSS Transition");
1331 CAPA(20, "QoS Traffic Capability");
1332 CAPA(21, "AC Station Count");
1333 CAPA(22, "Multiple BSSID");
1334 CAPA(23, "Timing Measurement");
1335 CAPA(24, "Channel Usage");
1336 CAPA(25, "SSID List");
1337 CAPA(26, "DMS");
1338 CAPA(27, "UTC TSF Offset");
1339 CAPA(28, "TDLS Peer U-APSD Buffer STA Support");
1340 CAPA(29, "TDLS Peer PSM Support");
1341 CAPA(30, "TDLS channel switching");
1342 CAPA(31, "Interworking");
1343 CAPA(32, "QoS Map");
1344 CAPA(33, "EBR");
1345 CAPA(34, "SSPN Interface");
1346 CAPA(35, "Reserved");
1347 CAPA(36, "MSGCF Capability");
1348 CAPA(37, "TDLS Support");
1349 CAPA(38, "TDLS Prohibited");
1350 CAPA(39, "TDLS Channel Switching Prohibited");
1351 CAPA(40, "Reject Unadmitted Frame");
5f310d83
SM		 1352
1353 ADD_BIT_VAL(41, s_psmp_support, si_duration, 1);
1354 ADD_BIT_VAL(42, s_psmp_support, si_duration, 2);
1355 ADD_BIT_VAL(43, s_psmp_support, si_duration, 4);
1356
70c649d2
JB		 1357 CAPA(44, "Identifier Location");
1358 CAPA(45, "U-APSD Coexistence");
1359 CAPA(46, "WNM-Notification");
1360 CAPA(47, "Reserved");
1361 CAPA(48, "UTF-8 SSID");
5f310d83
SM		 1362 CAPA(49, "QMFActivated");
1363 CAPA(50, "QMFReconfigurationActivated");
1364 CAPA(51, "Robust AV Streaming");
1365 CAPA(52, "Advanced GCR");
1366 CAPA(53, "Mesh GCR");
1367 CAPA(54, "SCS");
1368 CAPA(55, "QLoad Report");
1369 CAPA(56, "Alternate EDCA");
1370 CAPA(57, "Unprotected TXOP Negotiation");
1371 CAPA(58, "Protected TXOP egotiation");
1372 CAPA(59, "Reserved");
1373 CAPA(60, "Protected QLoad Report");
1374 CAPA(61, "TDLS Wider Bandwidth");
1375 CAPA(62, "Operating Mode Notification");
1376
1377 ADD_BIT_VAL(63, is_vht_cap, max_amsdu, 1);
1378 ADD_BIT_VAL(64, is_vht_cap, max_amsdu, 2);
1379
1380 CAPA(65, "Channel Schedule Management");
1381 CAPA(66, "Geodatabase Inband Enabling Signal");
1382 CAPA(67, "Network Channel Control");
1383 CAPA(68, "White Space Map");
1384 CAPA(69, "Channel Availability Query");
d06cda9e
AK		 1385 CAPA(70, "FTM Responder");
1386 CAPA(71, "FTM Initiator");
5f310d83
SM		 1387 CAPA(72, "Reserved");
1388 CAPA(73, "Extended Spectrum Management Capable");
1389 CAPA(74, "Reserved");
31d2d259
JB		 1390 default:
1391 printf(" %d", bit);
1392 break;
1393 }
5f310d83 1394#undef ADD_BIT_VAL
70c649d2 1395#undef CAPA
31d2d259
JB		 1396 }
1397 }
9b880b00 1398
5f310d83
SM		 1399 if (s_psmp_support)
1400 printf("\n\t\t * Service Interval Granularity is %d ms",
1401 (si_duration + 1) * 5);
1402
1403 if (is_vht_cap) {
1404 printf("\n\t\t * Max Number Of MSDUs In A-MSDU is ");
1405 switch (max_amsdu) {
1406 case 0:
1407 printf("unlimited");
1408 break;
1409 case 1:
1410 printf("32");
1411 break;
1412 case 2:
1413 printf("16");
1414 break;
1415 case 3:
1416 printf("8");
1417 break;
1418 default:
1419 break;
1420 }
1421 }
1422
9b880b00
MH		 1423 printf("\n");
1424}
1425
5f310d83
SM		 1426static void print_tim(const uint8_t type, uint8_t len, const uint8_t *data,
1427 const struct print_ies_data *ie_buffer)
575280cc
JM		 1428{
1429 printf(" DTIM Count %u DTIM Period %u Bitmap Control 0x%x "
1430 "Bitmap[0] 0x%x",
1431 data[0], data[1], data[2], data[3]);
1432 if (len - 4)
1433 printf(" (+ %u octet%s)", len - 4, len - 4 == 1 ? "" : "s");
1434 printf("\n");
1435}
1436
5f310d83
SM		 1437static void print_ibssatim(const uint8_t type, uint8_t len, const uint8_t *data,
1438 const struct print_ies_data *ie_buffer)
792172b0 1439{
08c3f7d3 1440 printf(" %d TUs\n", (data[1] << 8) + data[0]);
792172b0
JM		 1441}
1442
5f310d83
SM		 1443static void print_vht_capa(const uint8_t type, uint8_t len, const uint8_t *data,
1444 const struct print_ies_data *ie_buffer)
54eb1613
JB		 1445{
1446 printf("\n");
1447 print_vht_info(data[0] | (data[1] << 8) |
1448 (data[2] << 16) | (data[3] << 24),
1449 data + 4);
1450}
1451
5f310d83
SM		 1452static void print_vht_oper(const uint8_t type, uint8_t len, const uint8_t *data,
1453 const struct print_ies_data *ie_buffer)
ca159934
JB		 1454{
1455 const char *chandwidths[] = {
1456 [0] = "20 or 40 MHz",
1457 [1] = "80 MHz",
1458 [3] = "80+80 MHz",
1459 [2] = "160 MHz",
1460 };
1461
1462 printf("\n");
1463 printf("\t\t * channel width: %d (%s)\n", data[0],
1464 data[0] < ARRAY_SIZE(chandwidths) ? chandwidths[data[0]] : "unknown");
1465 printf("\t\t * center freq segment 1: %d\n", data[1]);
1466 printf("\t\t * center freq segment 2: %d\n", data[2]);
1467 printf("\t\t * VHT basic MCS set: 0x%.2x%.2x\n", data[4], data[3]);
1468}
1469
5f310d83
SM		 1470static void print_obss_scan_params(const uint8_t type, uint8_t len,
1471 const uint8_t *data,
1472 const struct print_ies_data *ie_buffer)
29f7579e
JB		 1473{
1474 printf("\n");
1475 printf("\t\t * passive dwell: %d TUs\n", (data[1] << 8) | data[0]);
1476 printf("\t\t * active dwell: %d TUs\n", (data[3] << 8) | data[2]);
1477 printf("\t\t * channel width trigger scan interval: %d s\n", (data[5] << 8) | data[4]);
1478 printf("\t\t * scan passive total per channel: %d TUs\n", (data[7] << 8) | data[6]);
1479 printf("\t\t * scan active total per channel: %d TUs\n", (data[9] << 8) | data[8]);
1480 printf("\t\t * BSS width channel transition delay factor: %d\n", (data[11] << 8) | data[10]);
1481 printf("\t\t * OBSS Scan Activity Threshold: %d.%02d %%\n",
1482 ((data[13] << 8) | data[12]) / 100, ((data[13] << 8) | data[12]) % 100);
1483}
1484
5f310d83
SM		 1485static void print_secchan_offs(const uint8_t type, uint8_t len,
1486 const uint8_t *data,
1487 const struct print_ies_data *ie_buffer)
29f7579e
JB		 1488{
1489 if (data[0] < ARRAY_SIZE(ht_secondary_offset))
1490 printf(" %s (%d)\n", ht_secondary_offset[data[0]], data[0]);
1491 else
1492 printf(" %d\n", data[0]);
1493}
1494
5f310d83
SM		 1495static void print_bss_load(const uint8_t type, uint8_t len, const uint8_t *data,
1496 const struct print_ies_data *ie_buffer)
29f7579e
JB		 1497{
1498 printf("\n");
1499 printf("\t\t * station count: %d\n", (data[1] << 8) | data[0]);
1500 printf("\t\t * channel utilisation: %d/255\n", data[2]);
1501 printf("\t\t * available admission capacity: %d [*32us]\n", (data[4] << 8) | data[3]);
1502}
1503
5f310d83
SM		 1504static void print_mesh_conf(const uint8_t type, uint8_t len,
1505 const uint8_t *data,
1506 const struct print_ies_data *ie_buffer)
2d86b0f3
CYY		 1507{
1508 printf("\n");
1509 printf("\t\t * Active Path Selection Protocol ID: %d\n", data[0]);
1510 printf("\t\t * Active Path Selection Metric ID: %d\n", data[1]);
1511 printf("\t\t * Congestion Control Mode ID: %d\n", data[2]);
1512 printf("\t\t * Synchronization Method ID: %d\n", data[3]);
1513 printf("\t\t * Authentication Protocol ID: %d\n", data[4]);
1514 printf("\t\t * Mesh Formation Info:\n");
1515 printf("\t\t\t Number of Peerings: %d\n", (data[5] & 0x7E) >> 1);
1516 if (data[5] & 0x01)
1517 printf("\t\t\t Connected to Mesh Gate\n");
1518 if (data[5] & 0x80)
1519 printf("\t\t\t Connected to AS\n");
1520 printf("\t\t * Mesh Capability\n");
1521 if (data[6] & 0x01)
1522 printf("\t\t\t Accepting Additional Mesh Peerings\n");
1523 if (data[6] & 0x02)
1524 printf("\t\t\t MCCA Supported\n");
1525 if (data[6] & 0x04)
1526 printf("\t\t\t MCCA Enabled\n");
1527 if (data[6] & 0x08)
1528 printf("\t\t\t Forwarding\n");
1529 if (data[6] & 0x10)
1530 printf("\t\t\t MBCA Supported\n");
1531 if (data[6] & 0x20)
1532 printf("\t\t\t TBTT Adjusting\n");
1533 if (data[6] & 0x40)
1534 printf("\t\t\t Mesh Power Save Level\n");
1535}
1536
83b4934c
JB		 1537struct ie_print {
1538 const char *name;
5f310d83
SM		 1539 void (*print)(const uint8_t type, uint8_t len, const uint8_t *data,
1540 const struct print_ies_data *ie_buffer);
83b4934c 1541 uint8_t minlen, maxlen;
febeb0c0 1542 uint8_t flags;
764fe753
JB		 1543};
1544
5f310d83
SM		 1545static void print_ie(const struct ie_print *p, const uint8_t type, uint8_t len,
1546 const uint8_t *data,
1547 const struct print_ies_data *ie_buffer)
4673a894 1548{
83b4934c
JB		 1549 int i;
1550
1551 if (!p->print)
1552 return;
1553
1554 printf("\t%s:", p->name);
1555 if (len < p->minlen || len > p->maxlen) {
1556 if (len > 1) {
1557 printf(" <invalid: %d bytes:", len);
1558 for (i = 0; i < len; i++)
1559 printf(" %.02x", data[i]);
1560 printf(">\n");
1561 } else if (len)
1562 printf(" <invalid: 1 byte: %.02x>\n", data[0]);
1563 else
1564 printf(" <invalid: no data>\n");
1565 return;
1566 }
1567
5f310d83 1568 p->print(type, len, data, ie_buffer);
83b4934c
JB		 1569}
1570
1571#define PRINT_IGN { \
1572 .name = "IGNORE", \
1573 .print = NULL, \
1574 .minlen = 0, \
1575 .maxlen = 255, \
4673a894
JB		 1576}
1577
83b4934c 1578static const struct ie_print ieprinters[] = {
febeb0c0
JB		 1579 [0] = { "SSID", print_ssid, 0, 32, BIT(PRINT_SCAN) | BIT(PRINT_LINK), },
1580 [1] = { "Supported rates", print_supprates, 0, 255, BIT(PRINT_SCAN), },
014d581a 1581 [3] = { "DS Parameter set", print_ds, 1, 1, BIT(PRINT_SCAN), },
575280cc 1582 [5] = { "TIM", print_tim, 4, 255, BIT(PRINT_SCAN), },
792172b0 1583 [6] = { "IBSS ATIM window", print_ibssatim, 2, 2, BIT(PRINT_SCAN), },
febeb0c0 1584 [7] = { "Country", print_country, 3, 255, BIT(PRINT_SCAN), },
29f7579e 1585 [11] = { "BSS Load", print_bss_load, 5, 5, BIT(PRINT_SCAN), },
febeb0c0 1586 [32] = { "Power constraint", print_powerconstraint, 1, 1, BIT(PRINT_SCAN), },
792172b0 1587 [35] = { "TPC report", print_tpcreport, 2, 2, BIT(PRINT_SCAN), },
febeb0c0 1588 [42] = { "ERP", print_erp, 1, 255, BIT(PRINT_SCAN), },
a2e61861 1589 [45] = { "HT capabilities", print_ht_capa, 26, 26, BIT(PRINT_SCAN), },
792172b0 1590 [47] = { "ERP D4.0", print_erp, 1, 255, BIT(PRINT_SCAN), },
29f7579e 1591 [74] = { "Overlapping BSS scan params", print_obss_scan_params, 14, 255, BIT(PRINT_SCAN), },
be7602fb 1592 [61] = { "HT operation", print_ht_op, 22, 22, BIT(PRINT_SCAN), },
29f7579e 1593 [62] = { "Secondary Channel Offset", print_secchan_offs, 1, 1, BIT(PRINT_SCAN), },
54eb1613 1594 [191] = { "VHT capabilities", print_vht_capa, 12, 255, BIT(PRINT_SCAN), },
ca159934 1595 [192] = { "VHT operation", print_vht_oper, 5, 255, BIT(PRINT_SCAN), },
febeb0c0
JB		 1596 [48] = { "RSN", print_rsn, 2, 255, BIT(PRINT_SCAN), },
1597 [50] = { "Extended supported rates", print_supprates, 0, 255, BIT(PRINT_SCAN), },
4d72d1d2 1598 [70] = { "RM enabled capabilities", print_rm_enabled_capabilities, 5, 5, BIT(PRINT_SCAN), },
2d86b0f3 1599 [113] = { "MESH Configuration", print_mesh_conf, 7, 7, BIT(PRINT_SCAN), },
720583e9 1600 [114] = { "MESH ID", print_ssid, 0, 32, BIT(PRINT_SCAN) | BIT(PRINT_LINK), },
febeb0c0 1601 [127] = { "Extended capabilities", print_capabilities, 0, 255, BIT(PRINT_SCAN), },
489f0ea9 1602 [107] = { "802.11u Interworking", print_interworking, 0, 255, BIT(PRINT_SCAN), },
3f818f6d 1603 [108] = { "802.11u Advertisement", print_11u_advert, 0, 255, BIT(PRINT_SCAN), },
bc9e14f1 1604 [111] = { "802.11u Roaming Consortium", print_11u_rcon, 0, 255, BIT(PRINT_SCAN), },
83b4934c
JB		 1605};
1606
5f310d83
SM		 1607static void print_wifi_wpa(const uint8_t type, uint8_t len, const uint8_t *data,
1608 const struct print_ies_data *ie_buffer)
83b4934c
JB		 1609{
1610 print_rsn_ie("TKIP", "IEEE 802.1X", len, data);
1611}
1612
5f310d83
SM		 1613static void print_wifi_osen(const uint8_t type, uint8_t len,
1614 const uint8_t *data,
1615 const struct print_ies_data *ie_buffer)
f188ab67
BG		 1616{
1617 print_osen_ie("OSEN", "OSEN", len, data);
1618}
1619
1cab57eb
JB		 1620static bool print_wifi_wmm_param(const uint8_t *data, uint8_t len)
1621{
1622 int i;
1623 static const char *aci_tbl[] = { "BE", "BK", "VI", "VO" };
1624
1625 if (len < 19)
1626 goto invalid;
1627
1628 if (data[0] != 1) {
cee4fe20 1629 printf("Parameter: not version 1: ");
1cab57eb
JB		 1630 return false;
1631 }
1632
89ea706f 1633 printf("\t * Parameter version 1");
1cab57eb
JB		 1634
1635 data++;
1636
1637 if (data[0] & 0x80)
89ea706f 1638 printf("\n\t\t * u-APSD");
1cab57eb
JB		 1639
1640 data += 2;
1641
1642 for (i = 0; i < 4; i++) {
89ea706f 1643 printf("\n\t\t * %s:", aci_tbl[(data[0] >> 5) & 3]);
87181516 1644 if (data[0] & 0x10)
1cab57eb
JB		 1645 printf(" acm");
1646 printf(" CW %d-%d", (1 << (data[1] & 0xf)) - 1,
1647 (1 << (data[1] >> 4)) - 1);
a2a4c265 1648 printf(", AIFSN %d", data[0] & 0xf);
1cab57eb 1649 if (data[2] | data[3])
cee4fe20 1650 printf(", TXOP %d usec", (data[2] + (data[3] << 8)) * 32);
1cab57eb
JB		 1651 data += 4;
1652 }
1653
1654 printf("\n");
1655 return true;
1656
1657 invalid:
1658 printf("invalid: ");
1659 return false;
1660}
1661
5f310d83
SM		 1662static void print_wifi_wmm(const uint8_t type, uint8_t len, const uint8_t *data,
1663 const struct print_ies_data *ie_buffer)
6ff0c93a
MH		 1664{
1665 int i;
1666
6ff0c93a
MH		 1667 switch (data[0]) {
1668 case 0x00:
83b4934c 1669 printf(" information:");
6ff0c93a
MH		 1670 break;
1671 case 0x01:
1cab57eb
JB		 1672 if (print_wifi_wmm_param(data + 1, len - 1))
1673 return;
6ff0c93a
MH		 1674 break;
1675 default:
83b4934c 1676 printf(" type %d:", data[0]);
6ff0c93a
MH		 1677 break;
1678 }
1679
1cab57eb
JB		 1680 for(i = 1; i < len; i++)
1681 printf(" %.02x", data[i]);
6ff0c93a
MH		 1682 printf("\n");
1683}
1684
a6816965
JM		 1685static const char * wifi_wps_dev_passwd_id(uint16_t id)
1686{
1687 switch (id) {
1688 case 0:
1689 return "Default (PIN)";
1690 case 1:
1691 return "User-specified";
1692 case 2:
1693 return "Machine-specified";
1694 case 3:
1695 return "Rekey";
1696 case 4:
1697 return "PushButton";
1698 case 5:
1699 return "Registrar-specified";
1700 default:
1701 return "??";
1702 }
1703}
1704
5f310d83
SM		 1705static void print_wifi_wps(const uint8_t type, uint8_t len, const uint8_t *data,
1706 const struct print_ies_data *ie_buffer)
4673a894
JB		 1707{
1708 bool first = true;
1709 __u16 subtype, sublen;
1710
4673a894
JB		 1711 while (len >= 4) {
1712 subtype = (data[0] << 8) + data[1];
1713 sublen = (data[2] << 8) + data[3];
1714 if (sublen > len)
1715 break;
1716
1717 switch (subtype) {
1718 case 0x104a:
1719 tab_on_first(&first);
dffc6750 1720 printf("\t * Version: %d.%d\n", data[4] >> 4, data[4] & 0xF);
4673a894
JB		 1721 break;
1722 case 0x1011:
1723 tab_on_first(&first);
1724 printf("\t * Device name: %.*s\n", sublen, data + 4);
1725 break;
a6816965
JM		 1726 case 0x1012: {
1727 uint16_t id;
1728 tab_on_first(&first);
1729 if (sublen != 2) {
1730 printf("\t * Device Password ID: (invalid "
1731 "length %d)\n", sublen);
1732 break;
1733 }
1734 id = data[4] << 8 | data[5];
1735 printf("\t * Device Password ID: %u (%s)\n",
1736 id, wifi_wps_dev_passwd_id(id));
1737 break;
1738 }
4673a894
JB		 1739 case 0x1021:
1740 tab_on_first(&first);
1741 printf("\t * Manufacturer: %.*s\n", sublen, data + 4);
1742 break;
1743 case 0x1023:
1744 tab_on_first(&first);
1745 printf("\t * Model: %.*s\n", sublen, data + 4);
1746 break;
a6816965
JM		 1747 case 0x1024:
1748 tab_on_first(&first);
1749 printf("\t * Model Number: %.*s\n", sublen, data + 4);
1750 break;
1751 case 0x103b: {
1752 __u8 val = data[4];
1753 tab_on_first(&first);
1754 printf("\t * Response Type: %d%s\n",
1755 val, val == 3 ? " (AP)" : "");
1756 break;
1757 }
1758 case 0x103c: {
1759 __u8 val = data[4];
1760 tab_on_first(&first);
1761 printf("\t * RF Bands: 0x%x\n", val);
1762 break;
1763 }
1764 case 0x1041: {
1765 __u8 val = data[4];
1766 tab_on_first(&first);
1767 printf("\t * Selected Registrar: 0x%x\n", val);
1768 break;
1769 }
1770 case 0x1042:
1771 tab_on_first(&first);
1772 printf("\t * Serial Number: %.*s\n", sublen, data + 4);
1773 break;
1774 case 0x1044: {
1775 __u8 val = data[4];
1776 tab_on_first(&first);
1777 printf("\t * Wi-Fi Protected Setup State: %d%s%s\n",
1778 val,
1779 val == 1 ? " (Unconfigured)" : "",
1780 val == 2 ? " (Configured)" : "");
1781 break;
1782 }
09fe09dc
JB		 1783 case 0x1047:
1784 tab_on_first(&first);
1785 printf("\t * UUID: ");
1786 if (sublen != 16) {
1787 printf("(invalid, length=%d)\n", sublen);
1788 break;
1789 }
1790 printf("%02x%02x%02x%02x-%02x%02x-%02x%02x-"
1791 "%02x%02x-%02x%02x%02x%02x%02x%02x\n",
1792 data[4], data[5], data[6], data[7],
1793 data[8], data[9], data[10], data[11],
1794 data[12], data[13], data[14], data[15],
1795 data[16], data[17], data[18], data[19]);
1796 break;
a6816965
JM		 1797 case 0x1054: {
1798 tab_on_first(&first);
1799 if (sublen != 8) {
1800 printf("\t * Primary Device Type: (invalid "
1801 "length %d)\n", sublen);
1802 break;
1803 }
1804 printf("\t * Primary Device Type: "
1805 "%u-%02x%02x%02x%02x-%u\n",
1806 data[4] << 8 | data[5],
1807 data[6], data[7], data[8], data[9],
1808 data[10] << 8 | data[11]);
1809 break;
1810 }
7ee5a865 1811 case 0x1057: {
fe31a22e 1812 __u8 val = data[4];
7ee5a865 1813 tab_on_first(&first);
fe31a22e 1814 printf("\t * AP setup locked: 0x%.2x\n", val);
7ee5a865
JB		 1815 break;
1816 }
a6816965
JM		 1817 case 0x1008:
1818 case 0x1053: {
4673a894
JB		 1819 __u16 meth = (data[4] << 8) + data[5];
1820 bool comma = false;
1821 tab_on_first(&first);
a6816965
JM		 1822 printf("\t * %sConfig methods:",
1823 subtype == 0x1053 ? "Selected Registrar ": "");
4673a894
JB		 1824#define T(bit, name) do { \
1825 if (meth & (1<<bit)) { \
1826 if (comma) \
1827 printf(","); \
1828 comma = true; \
1829 printf(" " name); \
1830 } } while (0)
1831 T(0, "USB");
1832 T(1, "Ethernet");
1833 T(2, "Label");
1834 T(3, "Display");
1835 T(4, "Ext. NFC");
1836 T(5, "Int. NFC");
1837 T(6, "NFC Intf.");
1838 T(7, "PBC");
1839 T(8, "Keypad");
1840 printf("\n");
1841 break;
1842#undef T
1843 }
2650d46b
JB		 1844 default: {
1845 const __u8 *subdata = data + 4;
1846 __u16 tmplen = sublen;
1847
1848 tab_on_first(&first);
1849 printf("\t * Unknown TLV (%#.4x, %d bytes):",
1850 subtype, tmplen);
1851 while (tmplen) {
1852 printf(" %.2x", *subdata);
1853 subdata++;
1854 tmplen--;
1855 }
1856 printf("\n");
4673a894
JB		 1857 break;
1858 }
2650d46b 1859 }
4673a894
JB		 1860
1861 data += sublen + 4;
1862 len -= sublen + 4;
1863 }
1864
1865 if (len != 0) {
1866 printf("\t\t * bogus tail data (%d):", len);
1867 while (len) {
1868 printf(" %.2x", *data);
1869 data++;
1870 len--;
1871 }
1872 printf("\n");
1873 }
1874}
1875
83b4934c 1876static const struct ie_print wifiprinters[] = {
febeb0c0
JB		 1877 [1] = { "WPA", print_wifi_wpa, 2, 255, BIT(PRINT_SCAN), },
1878 [2] = { "WMM", print_wifi_wmm, 1, 255, BIT(PRINT_SCAN), },
1879 [4] = { "WPS", print_wifi_wps, 0, 255, BIT(PRINT_SCAN), },
4673a894
JB		 1880};
1881
5f310d83
SM		 1882static inline void print_p2p(const uint8_t type, uint8_t len,
1883 const uint8_t *data,
1884 const struct print_ies_data *ie_buffer)
9a22374a
JB		 1885{
1886 bool first = true;
1887 __u8 subtype;
1888 __u16 sublen;
1889
1890 while (len >= 3) {
1891 subtype = data[0];
1892 sublen = (data[2] << 8) + data[1];
1893
1894 if (sublen > len - 3)
1895 break;
1896
1897 switch (subtype) {
1898 case 0x02: /* capability */
1899 tab_on_first(&first);
1900 if (sublen < 2) {
1901 printf("\t * malformed capability\n");
1902 break;
1903 }
1904 printf("\t * Group capa: 0x%.2x, Device capa: 0x%.2x\n",
1905 data[3], data[4]);
1906 break;
1907 case 0x0d: /* device info */
1908 if (sublen < 6 + 2 + 8 + 1) {
1909 printf("\t * malformed device info\n");
1910 break;
1911 }
c8edf8f5 1912 /* fall through */
9a22374a
JB		 1913 case 0x00: /* status */
1914 case 0x01: /* minor reason */
1915 case 0x03: /* device ID */
1916 case 0x04: /* GO intent */
1917 case 0x05: /* configuration timeout */
1918 case 0x06: /* listen channel */
1919 case 0x07: /* group BSSID */
1920 case 0x08: /* ext listen timing */
1921 case 0x09: /* intended interface address */
1922 case 0x0a: /* manageability */
1923 case 0x0b: /* channel list */
1924 case 0x0c: /* NoA */
1925 case 0x0e: /* group info */
1926 case 0x0f: /* group ID */
1927 case 0x10: /* interface */
1928 case 0x11: /* operating channel */
1929 case 0x12: /* invitation flags */
1930 case 0xdd: /* vendor specific */
1931 default: {
1932 const __u8 *subdata = data + 4;
1933 __u16 tmplen = sublen;
1934
1935 tab_on_first(&first);
1936 printf("\t * Unknown TLV (%#.2x, %d bytes):",
1937 subtype, tmplen);
1938 while (tmplen) {
1939 printf(" %.2x", *subdata);
1940 subdata++;
1941 tmplen--;
1942 }
1943 printf("\n");
1944 break;
1945 }
1946 }
1947
1948 data += sublen + 3;
1949 len -= sublen + 3;
1950 }
1951
1952 if (len != 0) {
1953 tab_on_first(&first);
1954 printf("\t * bogus tail data (%d):", len);
1955 while (len) {
1956 printf(" %.2x", *data);
1957 data++;
1958 len--;
1959 }
1960 printf("\n");
1961 }
1962}
1963
5f310d83
SM		 1964static inline void print_hs20_ind(const uint8_t type, uint8_t len,
1965 const uint8_t *data,
1966 const struct print_ies_data *ie_buffer)
7e10c4ab
BG		 1967{
1968 /* I can't find the spec for this...just going off what wireshark uses. */
1969 printf("\n");
1970 if (len > 0)
1971 printf("\t\tDGAF: %i\n", (int)(data[0] & 0x1));
1972 else
1973 printf("\t\tUnexpected length: %i\n", len);
1974}
1975
fc166079
HM		 1976static void print_wifi_owe_tarns(const uint8_t type, uint8_t len,
1977 const uint8_t *data,
1978 const struct print_ies_data *ie_buffer)
1979{
1980 char mac_addr[20];
1981 int ssid_len;
1982
1983 printf("\n");
1984 if (len < 7)
1985 return;
1986
1987 mac_addr_n2a(mac_addr, data);
1988 printf("\t\tBSSID: %s\n", mac_addr);
1989
1990 ssid_len = data[6];
1991 if (ssid_len > len - 7)
1992 return;
1993 printf("\t\tSSID: ");
1994 print_ssid_escaped(ssid_len, data + 7);
1995 printf("\n");
1996
1997 /* optional elements */
1998 if (len >= ssid_len + 9) {
1999 printf("\t\tBand Info: %u\n", data[ssid_len + 7]);
2000 printf("\t\tChannel Info: %u\n", data[ssid_len + 8]);
2001 }
2002}
2003
9a22374a
JB		 2004static const struct ie_print wfa_printers[] = {
2005 [9] = { "P2P", print_p2p, 2, 255, BIT(PRINT_SCAN), },
7e10c4ab 2006 [16] = { "HotSpot 2.0 Indication", print_hs20_ind, 1, 255, BIT(PRINT_SCAN), },
f188ab67 2007 [18] = { "HotSpot 2.0 OSEN", print_wifi_osen, 1, 255, BIT(PRINT_SCAN), },
fc166079 2008 [28] = { "OWE Transition Mode", print_wifi_owe_tarns, 7, 255, BIT(PRINT_SCAN), },
9a22374a
JB		 2009};
2010
764fe753 2011static void print_vendor(unsigned char len, unsigned char *data,
febeb0c0 2012 bool unknown, enum print_ie_type ptype)
3563f4c5
JB		 2013{
2014 int i;
2015
fbf80af5 2016 if (len < 3) {
4673a894 2017 printf("\tVendor specific: <too short> data:");
fbf80af5
JB		 2018 for(i = 0; i < len; i++)
2019 printf(" %.02x", data[i]);
2020 printf("\n");
2021 return;
2022 }
2023
3bd60ef1 2024 if (len >= 4 && memcmp(data, ms_oui, 3) == 0) {
febeb0c0
JB		 2025 if (data[3] < ARRAY_SIZE(wifiprinters) &&
2026 wifiprinters[data[3]].name &&
2027 wifiprinters[data[3]].flags & BIT(ptype)) {
5f310d83 2028 print_ie(&wifiprinters[data[3]],
bcdceae1
JB		 2029 data[3], len - 4, data + 4,
2030 NULL);
83b4934c
JB		 2031 return;
2032 }
febeb0c0 2033 if (!unknown)
4673a894 2034 return;
3bd60ef1 2035 printf("\tMS/WiFi %#.2x, data:", data[3]);
4673a894
JB		 2036 for(i = 0; i < len - 4; i++)
2037 printf(" %.02x", data[i + 4]);
2038 printf("\n");
2039 return;
2040 }
2041
9a22374a
JB		 2042 if (len >= 4 && memcmp(data, wfa_oui, 3) == 0) {
2043 if (data[3] < ARRAY_SIZE(wfa_printers) &&
2044 wfa_printers[data[3]].name &&
2045 wfa_printers[data[3]].flags & BIT(ptype)) {
5f310d83 2046 print_ie(&wfa_printers[data[3]],
bcdceae1
JB		 2047 data[3], len - 4, data + 4,
2048 NULL);
9a22374a
JB		 2049 return;
2050 }
2051 if (!unknown)
2052 return;
2053 printf("\tWFA %#.2x, data:", data[3]);
2054 for(i = 0; i < len - 4; i++)
2055 printf(" %.02x", data[i + 4]);
2056 printf("\n");
2057 return;
2058 }
2059
febeb0c0 2060 if (!unknown)
764fe753
JB		 2061 return;
2062
fbf80af5 2063 printf("\tVendor specific: OUI %.2x:%.2x:%.2x, data:",
3563f4c5 2064 data[0], data[1], data[2]);
fbf80af5
JB		 2065 for (i = 3; i < len; i++)
2066 printf(" %.2x", data[i]);
3563f4c5
JB		 2067 printf("\n");
2068}
2069
febeb0c0
JB		 2070void print_ies(unsigned char *ie, int ielen, bool unknown,
2071 enum print_ie_type ptype)
3563f4c5 2072{
5f310d83
SM		 2073 struct print_ies_data ie_buffer = {
2074 .ie = ie,
2075 .ielen = ielen };
2076
3563f4c5 2077 while (ielen >= 2 && ielen >= ie[1]) {
febeb0c0
JB		 2078 if (ie[0] < ARRAY_SIZE(ieprinters) &&
2079 ieprinters[ie[0]].name &&
2080 ieprinters[ie[0]].flags & BIT(ptype)) {
5f310d83
SM		 2081 print_ie(&ieprinters[ie[0]],
2082 ie[0], ie[1], ie + 2, &ie_buffer);
764fe753 2083 } else if (ie[0] == 221 /* vendor */) {
febeb0c0
JB		 2084 print_vendor(ie[1], ie + 2, unknown, ptype);
2085 } else if (unknown) {
3563f4c5
JB		 2086 int i;
2087
8086b700 2088 printf("\tUnknown IE (%d):", ie[0]);
3563f4c5 2089 for (i=0; i<ie[1]; i++)
8086b700 2090 printf(" %.2x", ie[2+i]);
3563f4c5
JB		 2091 printf("\n");
2092 }
2093 ielen -= ie[1] + 2;
2094 ie += ie[1] + 2;
2095 }
2096}
2097
2e8b82c1
VK		 2098static void print_capa_dmg(__u16 capa)
2099{
2100 switch (capa & WLAN_CAPABILITY_DMG_TYPE_MASK) {
2101 case WLAN_CAPABILITY_DMG_TYPE_AP:
2102 printf(" DMG_ESS");
2103 break;
2104 case WLAN_CAPABILITY_DMG_TYPE_PBSS:
2105 printf(" DMG_PCP");
2106 break;
2107 case WLAN_CAPABILITY_DMG_TYPE_IBSS:
2108 printf(" DMG_IBSS");
2109 break;
2110 }
2111
2112 if (capa & WLAN_CAPABILITY_DMG_CBAP_ONLY)
2113 printf(" CBAP_Only");
2114 if (capa & WLAN_CAPABILITY_DMG_CBAP_SOURCE)
2115 printf(" CBAP_Src");
2116 if (capa & WLAN_CAPABILITY_DMG_PRIVACY)
2117 printf(" Privacy");
2118 if (capa & WLAN_CAPABILITY_DMG_ECPAC)
2119 printf(" ECPAC");
2120 if (capa & WLAN_CAPABILITY_DMG_SPECTRUM_MGMT)
2121 printf(" SpectrumMgmt");
2122 if (capa & WLAN_CAPABILITY_DMG_RADIO_MEASURE)
2123 printf(" RadioMeasure");
2124}
2125
2126static void print_capa_non_dmg(__u16 capa)
2127{
2128 if (capa & WLAN_CAPABILITY_ESS)
2129 printf(" ESS");
2130 if (capa & WLAN_CAPABILITY_IBSS)
2131 printf(" IBSS");
2132 if (capa & WLAN_CAPABILITY_CF_POLLABLE)
2133 printf(" CfPollable");
2134 if (capa & WLAN_CAPABILITY_CF_POLL_REQUEST)
2135 printf(" CfPollReq");
2136 if (capa & WLAN_CAPABILITY_PRIVACY)
2137 printf(" Privacy");
2138 if (capa & WLAN_CAPABILITY_SHORT_PREAMBLE)
2139 printf(" ShortPreamble");
2140 if (capa & WLAN_CAPABILITY_PBCC)
2141 printf(" PBCC");
2142 if (capa & WLAN_CAPABILITY_CHANNEL_AGILITY)
2143 printf(" ChannelAgility");
2144 if (capa & WLAN_CAPABILITY_SPECTRUM_MGMT)
2145 printf(" SpectrumMgmt");
2146 if (capa & WLAN_CAPABILITY_QOS)
2147 printf(" QoS");
2148 if (capa & WLAN_CAPABILITY_SHORT_SLOT_TIME)
2149 printf(" ShortSlotTime");
2150 if (capa & WLAN_CAPABILITY_APSD)
2151 printf(" APSD");
2152 if (capa & WLAN_CAPABILITY_RADIO_MEASURE)
2153 printf(" RadioMeasure");
2154 if (capa & WLAN_CAPABILITY_DSSS_OFDM)
2155 printf(" DSSS-OFDM");
2156 if (capa & WLAN_CAPABILITY_DEL_BACK)
2157 printf(" DelayedBACK");
2158 if (capa & WLAN_CAPABILITY_IMM_BACK)
2159 printf(" ImmediateBACK");
2160}
2161
3563f4c5
JB		 2162static int print_bss_handler(struct nl_msg *msg, void *arg)
2163{
2164 struct nlattr *tb[NL80211_ATTR_MAX + 1];
2165 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
2166 struct nlattr *bss[NL80211_BSS_MAX + 1];
2167 char mac_addr[20], dev[20];
2168 static struct nla_policy bss_policy[NL80211_BSS_MAX + 1] = {
2169 [NL80211_BSS_TSF] = { .type = NLA_U64 },
2170 [NL80211_BSS_FREQUENCY] = { .type = NLA_U32 },
2171 [NL80211_BSS_BSSID] = { },
2172 [NL80211_BSS_BEACON_INTERVAL] = { .type = NLA_U16 },
2173 [NL80211_BSS_CAPABILITY] = { .type = NLA_U16 },
2174 [NL80211_BSS_INFORMATION_ELEMENTS] = { },
f2e17e1f
JB		 2175 [NL80211_BSS_SIGNAL_MBM] = { .type = NLA_U32 },
2176 [NL80211_BSS_SIGNAL_UNSPEC] = { .type = NLA_U8 },
a56117a6 2177 [NL80211_BSS_STATUS] = { .type = NLA_U32 },
c04a78df 2178 [NL80211_BSS_SEEN_MS_AGO] = { .type = NLA_U32 },
575280cc 2179 [NL80211_BSS_BEACON_IES] = { },
3563f4c5 2180 };
febeb0c0 2181 struct scan_params *params = arg;
1c5bcd9c 2182 int show = params->show_both_ie_sets ? 2 : 1;
2e8b82c1 2183 bool is_dmg = false;
3563f4c5
JB		 2184
2185 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
2186 genlmsg_attrlen(gnlh, 0), NULL);
2187
2188 if (!tb[NL80211_ATTR_BSS]) {
5fe70c0e 2189 fprintf(stderr, "bss info missing!\n");
3563f4c5
JB		 2190 return NL_SKIP;
2191 }
2192 if (nla_parse_nested(bss, NL80211_BSS_MAX,
2193 tb[NL80211_ATTR_BSS],
2194 bss_policy)) {
5fe70c0e 2195 fprintf(stderr, "failed to parse nested attributes!\n");
3563f4c5
JB		 2196 return NL_SKIP;
2197 }
2198
2199 if (!bss[NL80211_BSS_BSSID])
2200 return NL_SKIP;
2201
2202 mac_addr_n2a(mac_addr, nla_data(bss[NL80211_BSS_BSSID]));
00889fb2
JB		 2203 printf("BSS %s", mac_addr);
2204 if (tb[NL80211_ATTR_IFINDEX]) {
2205 if_indextoname(nla_get_u32(tb[NL80211_ATTR_IFINDEX]), dev);
2206 printf("(on %s)", dev);
2207 }
a56117a6
JB		 2208
2209 if (bss[NL80211_BSS_STATUS]) {
2210 switch (nla_get_u32(bss[NL80211_BSS_STATUS])) {
2211 case NL80211_BSS_STATUS_AUTHENTICATED:
2212 printf(" -- authenticated");
2213 break;
2214 case NL80211_BSS_STATUS_ASSOCIATED:
2215 printf(" -- associated");
2216 break;
2217 case NL80211_BSS_STATUS_IBSS_JOINED:
2218 printf(" -- joined");
2219 break;
2220 default:
2221 printf(" -- unknown status: %d",
2222 nla_get_u32(bss[NL80211_BSS_STATUS]));
2223 break;
2224 }
2225 }
2226 printf("\n");
3563f4c5 2227
f6fca12c
JB		 2228 if (bss[NL80211_BSS_LAST_SEEN_BOOTTIME]) {
2229 unsigned long long bt;
2230 bt = (unsigned long long)nla_get_u64(bss[NL80211_BSS_LAST_SEEN_BOOTTIME]);
2231 printf("\tlast seen: %llu.%.3llus [boottime]\n", bt/1000000000, (bt%1000000000)/1000000);
2232 }
2233
e7109a8a
JB		 2234 if (bss[NL80211_BSS_TSF]) {
2235 unsigned long long tsf;
2236 tsf = (unsigned long long)nla_get_u64(bss[NL80211_BSS_TSF]);
2237 printf("\tTSF: %llu usec (%llud, %.2lld:%.2llu:%.2llu)\n",
2238 tsf, tsf/1000/1000/60/60/24, (tsf/1000/1000/60/60) % 24,
2239 (tsf/1000/1000/60) % 60, (tsf/1000/1000) % 60);
2240 }
2e8b82c1
VK		 2241 if (bss[NL80211_BSS_FREQUENCY]) {
2242 int freq = nla_get_u32(bss[NL80211_BSS_FREQUENCY]);
2243 printf("\tfreq: %d\n", freq);
2244 if (freq > 45000)
2245 is_dmg = true;
2246 }
3563f4c5 2247 if (bss[NL80211_BSS_BEACON_INTERVAL])
792172b0 2248 printf("\tbeacon interval: %d TUs\n",
3563f4c5 2249 nla_get_u16(bss[NL80211_BSS_BEACON_INTERVAL]));
92a04ecd
MH		 2250 if (bss[NL80211_BSS_CAPABILITY]) {
2251 __u16 capa = nla_get_u16(bss[NL80211_BSS_CAPABILITY]);
2252 printf("\tcapability:");
2e8b82c1
VK		 2253 if (is_dmg)
2254 print_capa_dmg(capa);
2255 else
2256 print_capa_non_dmg(capa);
92a04ecd
MH		 2257 printf(" (0x%.4x)\n", capa);
2258 }
f2e17e1f
JB		 2259 if (bss[NL80211_BSS_SIGNAL_MBM]) {
2260 int s = nla_get_u32(bss[NL80211_BSS_SIGNAL_MBM]);
2261 printf("\tsignal: %d.%.2d dBm\n", s/100, s%100);
2262 }
2263 if (bss[NL80211_BSS_SIGNAL_UNSPEC]) {
2264 unsigned char s = nla_get_u8(bss[NL80211_BSS_SIGNAL_UNSPEC]);
2265 printf("\tsignal: %d/100\n", s);
2266 }
c04a78df
HS		 2267 if (bss[NL80211_BSS_SEEN_MS_AGO]) {
2268 int age = nla_get_u32(bss[NL80211_BSS_SEEN_MS_AGO]);
2269 printf("\tlast seen: %d ms ago\n", age);
2270 }
c551449a 2271
1c5bcd9c 2272 if (bss[NL80211_BSS_INFORMATION_ELEMENTS] && show--) {
b50d1456
JB		 2273 struct nlattr *ies = bss[NL80211_BSS_INFORMATION_ELEMENTS];
2274 struct nlattr *bcnies = bss[NL80211_BSS_BEACON_IES];
2275
2276 if (bss[NL80211_BSS_PRESP_DATA] ||
86d907a3 2277 (bcnies && (nla_len(ies) != nla_len(bcnies) ||
c9c3b69d
JB		 2278 memcmp(nla_data(ies), nla_data(bcnies),
2279 nla_len(ies)))))
575280cc
JM		 2280 printf("\tInformation elements from Probe Response "
2281 "frame:\n");
b50d1456 2282 print_ies(nla_data(ies), nla_len(ies),
febeb0c0 2283 params->unknown, params->type);
575280cc 2284 }
1c5bcd9c 2285 if (bss[NL80211_BSS_BEACON_IES] && show--) {
575280cc
JM		 2286 printf("\tInformation elements from Beacon frame:\n");
2287 print_ies(nla_data(bss[NL80211_BSS_BEACON_IES]),
2288 nla_len(bss[NL80211_BSS_BEACON_IES]),
2289 params->unknown, params->type);
2290 }
3563f4c5
JB		 2291
2292 return NL_SKIP;
2293}
2294
764fe753 2295static struct scan_params scan_params;
3563f4c5 2296
7c37a24d 2297static int handle_scan_dump(struct nl80211_state *state,
3563f4c5 2298 struct nl_msg *msg,
05514f95
JB		 2299 int argc, char **argv,
2300 enum id_input id)
3563f4c5 2301{
764fe753
JB		 2302 if (argc > 1)
2303 return 1;
2304
1c5bcd9c
JB		 2305 memset(&scan_params, 0, sizeof(scan_params));
2306
764fe753
JB		 2307 if (argc == 1 && !strcmp(argv[0], "-u"))
2308 scan_params.unknown = true;
575280cc
JM		 2309 else if (argc == 1 && !strcmp(argv[0], "-b"))
2310 scan_params.show_both_ie_sets = true;
764fe753 2311
febeb0c0
JB		 2312 scan_params.type = PRINT_SCAN;
2313
f3c96669 2314 register_handler(print_bss_handler, &scan_params);
3563f4c5
JB		 2315 return 0;
2316}
a5fe4ef2
JB		 2317
2318static int handle_scan_combined(struct nl80211_state *state,
a5fe4ef2 2319 struct nl_msg *msg,
05514f95
JB		 2320 int argc, char **argv,
2321 enum id_input id)
a5fe4ef2 2322{
559a1713 2323 char **trig_argv;
a5fe4ef2
JB		 2324 static char *dump_argv[] = {
2325 NULL,
2326 "scan",
2327 "dump",
92649eab 2328 NULL,
a5fe4ef2
JB		 2329 };
2330 static const __u32 cmds[] = {
2331 NL80211_CMD_NEW_SCAN_RESULTS,
2332 NL80211_CMD_SCAN_ABORTED,
2333 };
559a1713 2334 int trig_argc, dump_argc, err;
7d19e35d 2335 int i;
a5fe4ef2 2336
559a1713
JB		 2337 if (argc >= 3 && !strcmp(argv[2], "-u")) {
2338 dump_argc = 4;
2339 dump_argv[3] = "-u";
575280cc
JM		 2340 } else if (argc >= 3 && !strcmp(argv[2], "-b")) {
2341 dump_argc = 4;
2342 dump_argv[3] = "-b";
559a1713
JB		 2343 } else
2344 dump_argc = 3;
2345
2346 trig_argc = 3 + (argc - 2) + (3 - dump_argc);
2347 trig_argv = calloc(trig_argc, sizeof(*trig_argv));
2348 if (!trig_argv)
2349 return -ENOMEM;
a5fe4ef2 2350 trig_argv[0] = argv[0];
559a1713
JB		 2351 trig_argv[1] = "scan";
2352 trig_argv[2] = "trigger";
7d19e35d 2353
559a1713
JB		 2354 for (i = 0; i < argc - 2 - (dump_argc - 3); i++)
2355 trig_argv[i + 3] = argv[i + 2 + (dump_argc - 3)];
75f4204c 2356 err = handle_cmd(state, id, trig_argc, trig_argv);
559a1713 2357 free(trig_argv);
a5fe4ef2
JB		 2358 if (err)
2359 return err;
2360
61725dbe
JB		 2361 /*
2362 * WARNING: DO NOT COPY THIS CODE INTO YOUR APPLICATION
2363 *
2364 * This code has a bug, which requires creating a separate
2365 * nl80211 socket to fix:
2366 * It is possible for a NL80211_CMD_NEW_SCAN_RESULTS or
2367 * NL80211_CMD_SCAN_ABORTED message to be sent by the kernel
2368 * before (!) we listen to it, because we only start listening
2369 * after we send our scan request.
2370 *
2371 * Doing it the other way around has a race condition as well,
2372 * if you first open the events socket you may get a notification
2373 * for a previous scan.
2374 *
2375 * The only proper way to fix this would be to listen to events
2376 * before sending the command, and for the kernel to send the
2377 * scan request along with the event, so that you can match up
2378 * whether the scan you requested was finished or aborted (this
2379 * may result in processing a scan that another application
2380 * requested, but that doesn't seem to be a problem).
2381 *
2382 * Alas, the kernel doesn't do that (yet).
2383 */
2384
a5fe4ef2
JB		 2385 if (listen_events(state, ARRAY_SIZE(cmds), cmds) ==
2386 NL80211_CMD_SCAN_ABORTED) {
2387 printf("scan aborted!\n");
2388 return 0;
2389 }
2390
2391 dump_argv[0] = argv[0];
75f4204c 2392 return handle_cmd(state, id, dump_argc, dump_argv);
a5fe4ef2 2393}
3a99ff6d 2394TOPLEVEL(scan, "[-u] [freq <freq>*] [duration <dur>] [ies <hex as 00:11:..>] [meshid <meshid>] [lowpri,flush,ap-force,duration-mandatory] [randomise[=<addr>/<mask>]] [ssid <ssid>*|passive]", 0, 0,
6ca98d28
JB		 2395 CIB_NETDEV, handle_scan_combined,
2396 "Scan on the given frequencies and probe for the given SSIDs\n"
2397 "(or wildcard if not given) unless passive scanning is requested.\n"
64797a7f
JB		 2398 "If -u is specified print unknown data in the scan results.\n"
2399 "Specified (vendor) IEs must be well-formed.");
4698bfc2
JB		 2400COMMAND(scan, dump, "[-u]",
2401 NL80211_CMD_GET_SCAN, NLM_F_DUMP, CIB_NETDEV, handle_scan_dump,
2402 "Dump the current scan results. If -u is specified, print unknown\n"
2403 "data in scan results.");
3a99ff6d 2404COMMAND(scan, trigger, "[freq <freq>*] [duration <dur>] [ies <hex as 00:11:..>] [meshid <meshid>] [lowpri,flush,ap-force,duration-mandatory] [randomise[=<addr>/<mask>]] [ssid <ssid>*|passive]",
4698bfc2
JB		 2405 NL80211_CMD_TRIGGER_SCAN, 0, CIB_NETDEV, handle_scan,
2406 "Trigger a scan on the given frequencies with probing for the given\n"
3a99ff6d
PKC		 2407 "SSIDs (or wildcard if not given) unless passive scanning is requested.\n"
2408 "Duration(in TUs), if specified, will be used to set dwell times.\n");
3fce58aa
LC		 2409
2410
0a12cf8d
EP		 2411static int handle_scan_abort(struct nl80211_state *state,
2412 struct nl_msg *msg,
2413 int argc, char **argv,
2414 enum id_input id)
2415{
2416 return 0;
2417}
2418COMMAND(scan, abort, "",
2419 NL80211_CMD_ABORT_SCAN, 0, CIB_NETDEV, handle_scan_abort,
2420 "Abort ongoing scan");
2421
3fce58aa 2422static int handle_start_sched_scan(struct nl80211_state *state,
34b23014 2423 struct nl_msg *msg,
3fce58aa
LC		 2424 int argc, char **argv, enum id_input id)
2425{
2426 return parse_sched_scan(msg, &argc, &argv);
2427}
2428
34b23014 2429static int handle_stop_sched_scan(struct nl80211_state *state,
3fce58aa
LC		 2430 struct nl_msg *msg, int argc, char **argv,
2431 enum id_input id)
2432{
2433 if (argc != 0)
2434 return 1;
2435
2436 return 0;
2437}
2438
2439COMMAND(scan, sched_start,
2440 SCHED_SCAN_OPTIONS,
2441 NL80211_CMD_START_SCHED_SCAN, 0, CIB_NETDEV, handle_start_sched_scan,
2442 "Start a scheduled scan at the specified interval on the given frequencies\n"
2443 "with probing for the given SSIDs (or wildcard if not given) unless passive\n"
2444 "scanning is requested. If matches are specified, only matching results\n"
2445 "will be returned.");
2446COMMAND(scan, sched_stop, "",
2447 NL80211_CMD_STOP_SCHED_SCAN, 0, CIB_NETDEV, handle_stop_sched_scan,
2448 "Stop an ongoing scheduled scan.");
Mirror git://git.kernel.org/pub/scm/linux/kernel/git/jberg/iw.git