]> git.ipfire.org Git - thirdparty/iw.git/blob - info.c
projects / thirdparty / iw.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
iw: separate wait/print when waiting for an event
[thirdparty/iw.git] / info.c
1 #include <stdbool.h>
2
3 #include <netlink/genl/genl.h>
4 #include <netlink/genl/family.h>
5 #include <netlink/genl/ctrl.h>
6 #include <netlink/msg.h>
7 #include <netlink/attr.h>
8
9 #include "nl80211.h"
10 #include "iw.h"
11
12 static void print_flag(const char *name, int *open)
13 {
14 if (!*open)
15 printf(" (");
16 else
17 printf(", ");
18 printf("%s", name);
19 *open = 1;
20 }
21
22 static char *cipher_name(__u32 c)
23 {
24 static char buf[20];
25
26 switch (c) {
27 case 0x000fac01:
28 return "WEP40 (00-0f-ac:1)";
29 case 0x000fac05:
30 return "WEP104 (00-0f-ac:5)";
31 case 0x000fac02:
32 return "TKIP (00-0f-ac:2)";
33 case 0x000fac04:
34 return "CCMP-128 (00-0f-ac:4)";
35 case 0x000fac06:
36 return "CMAC (00-0f-ac:6)";
37 case 0x000fac08:
38 return "GCMP-128 (00-0f-ac:8)";
39 case 0x000fac09:
40 return "GCMP-256 (00-0f-ac:9)";
41 case 0x000fac0a:
42 return "CCMP-256 (00-0f-ac:10)";
43 case 0x000fac0b:
44 return "GMAC-128 (00-0f-ac:11)";
45 case 0x000fac0c:
46 return "GMAC-256 (00-0f-ac:12)";
47 case 0x000fac0d:
48 return "CMAC-256 (00-0f-ac:13)";
49 case 0x00147201:
50 return "WPI-SMS4 (00-14-72:1)";
51 default:
52 sprintf(buf, "%.2x-%.2x-%.2x:%d",
53 c >> 24, (c >> 16) & 0xff,
54 (c >> 8) & 0xff, c & 0xff);
55
56 return buf;
57 }
58 }
59
60 static int ext_feature_isset(const unsigned char *ext_features, int ext_features_len,
61 enum nl80211_ext_feature_index ftidx)
62 {
63 unsigned char ft_byte;
64
65 if ((int) ftidx / 8 >= ext_features_len)
66 return 0;
67
68 ft_byte = ext_features[ftidx / 8];
69 return (ft_byte & BIT(ftidx % 8)) != 0;
70 }
71
72 static void ext_feat_print(const struct nlattr *tb,
73 enum nl80211_ext_feature_index idx,
74 const char *feature_name, const char *feature_desc)
75 {
76 if (ext_feature_isset(nla_data(tb), nla_len(tb),idx))
77 printf("\t\t* [ %s ]: %s\n", feature_name, feature_desc);
78 }
79
80 static int print_phy_handler(struct nl_msg *msg, void *arg)
81 {
82 struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
83 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
84
85 struct nlattr *tb_band[NL80211_BAND_ATTR_MAX + 1];
86
87 struct nlattr *tb_freq[NL80211_FREQUENCY_ATTR_MAX + 1];
88 static struct nla_policy freq_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
89 [NL80211_FREQUENCY_ATTR_FREQ] = { .type = NLA_U32 },
90 [NL80211_FREQUENCY_ATTR_DISABLED] = { .type = NLA_FLAG },
91 [NL80211_FREQUENCY_ATTR_NO_IR] = { .type = NLA_FLAG },
92 [__NL80211_FREQUENCY_ATTR_NO_IBSS] = { .type = NLA_FLAG },
93 [NL80211_FREQUENCY_ATTR_RADAR] = { .type = NLA_FLAG },
94 [NL80211_FREQUENCY_ATTR_MAX_TX_POWER] = { .type = NLA_U32 },
95 };
96
97 struct nlattr *tb_rate[NL80211_BITRATE_ATTR_MAX + 1];
98 static struct nla_policy rate_policy[NL80211_BITRATE_ATTR_MAX + 1] = {
99 [NL80211_BITRATE_ATTR_RATE] = { .type = NLA_U32 },
100 [NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE] = { .type = NLA_FLAG },
101 };
102
103 struct nlattr *nl_band;
104 struct nlattr *nl_freq;
105 struct nlattr *nl_rate;
106 struct nlattr *nl_mode;
107 struct nlattr *nl_cmd;
108 struct nlattr *nl_if, *nl_ftype;
109 int rem_band, rem_freq, rem_rate, rem_mode, rem_cmd, rem_ftype, rem_if;
110 int open;
111 /*
112 * static variables only work here, other applications need to use the
113 * callback pointer and store them there so they can be multithreaded
114 * and/or have multiple netlink sockets, etc.
115 */
116 static int64_t phy_id = -1;
117 static int last_band = -1;
118 static bool band_had_freq = false;
119 bool print_name = true;
120
121 nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
122 genlmsg_attrlen(gnlh, 0), NULL);
123
124 if (tb_msg[NL80211_ATTR_WIPHY]) {
125 if (nla_get_u32(tb_msg[NL80211_ATTR_WIPHY]) == phy_id)
126 print_name = false;
127 else
128 last_band = -1;
129 phy_id = nla_get_u32(tb_msg[NL80211_ATTR_WIPHY]);
130 }
131 if (print_name && tb_msg[NL80211_ATTR_WIPHY_NAME])
132 printf("Wiphy %s\n", nla_get_string(tb_msg[NL80211_ATTR_WIPHY_NAME]));
133
134 /* needed for split dump */
135 if (tb_msg[NL80211_ATTR_WIPHY_BANDS]) {
136 nla_for_each_nested(nl_band, tb_msg[NL80211_ATTR_WIPHY_BANDS], rem_band) {
137 if (last_band != nl_band->nla_type) {
138 printf("\tBand %d:\n", nl_band->nla_type + 1);
139 band_had_freq = false;
140 }
141 last_band = nl_band->nla_type;
142
143 nla_parse(tb_band, NL80211_BAND_ATTR_MAX, nla_data(nl_band),
144 nla_len(nl_band), NULL);
145
146 if (tb_band[NL80211_BAND_ATTR_HT_CAPA]) {
147 __u16 cap = nla_get_u16(tb_band[NL80211_BAND_ATTR_HT_CAPA]);
148 print_ht_capability(cap);
149 }
150 if (tb_band[NL80211_BAND_ATTR_HT_AMPDU_FACTOR]) {
151 __u8 exponent = nla_get_u8(tb_band[NL80211_BAND_ATTR_HT_AMPDU_FACTOR]);
152 print_ampdu_length(exponent);
153 }
154 if (tb_band[NL80211_BAND_ATTR_HT_AMPDU_DENSITY]) {
155 __u8 spacing = nla_get_u8(tb_band[NL80211_BAND_ATTR_HT_AMPDU_DENSITY]);
156 print_ampdu_spacing(spacing);
157 }
158 if (tb_band[NL80211_BAND_ATTR_HT_MCS_SET] &&
159 nla_len(tb_band[NL80211_BAND_ATTR_HT_MCS_SET]) == 16)
160 print_ht_mcs(nla_data(tb_band[NL80211_BAND_ATTR_HT_MCS_SET]));
161 if (tb_band[NL80211_BAND_ATTR_VHT_CAPA] &&
162 tb_band[NL80211_BAND_ATTR_VHT_MCS_SET])
163 print_vht_info(nla_get_u32(tb_band[NL80211_BAND_ATTR_VHT_CAPA]),
164 nla_data(tb_band[NL80211_BAND_ATTR_VHT_MCS_SET]));
165
166 if (tb_band[NL80211_BAND_ATTR_FREQS]) {
167 if (!band_had_freq) {
168 printf("\t\tFrequencies:\n");
169 band_had_freq = true;
170 }
171 nla_for_each_nested(nl_freq, tb_band[NL80211_BAND_ATTR_FREQS], rem_freq) {
172 uint32_t freq;
173 nla_parse(tb_freq, NL80211_FREQUENCY_ATTR_MAX, nla_data(nl_freq),
174 nla_len(nl_freq), freq_policy);
175 if (!tb_freq[NL80211_FREQUENCY_ATTR_FREQ])
176 continue;
177 freq = nla_get_u32(tb_freq[NL80211_FREQUENCY_ATTR_FREQ]);
178 printf("\t\t\t* %d MHz [%d]", freq, ieee80211_frequency_to_channel(freq));
179
180 if (tb_freq[NL80211_FREQUENCY_ATTR_MAX_TX_POWER] &&
181 !tb_freq[NL80211_FREQUENCY_ATTR_DISABLED])
182 printf(" (%.1f dBm)", 0.01 * nla_get_u32(tb_freq[NL80211_FREQUENCY_ATTR_MAX_TX_POWER]));
183
184 open = 0;
185 if (tb_freq[NL80211_FREQUENCY_ATTR_DISABLED]) {
186 print_flag("disabled", &open);
187 goto next;
188 }
189
190 /* If both flags are set assume an new kernel */
191 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_IR] && tb_freq[__NL80211_FREQUENCY_ATTR_NO_IBSS]) {
192 print_flag("no IR", &open);
193 } else if (tb_freq[NL80211_FREQUENCY_ATTR_PASSIVE_SCAN]) {
194 print_flag("passive scan", &open);
195 } else if (tb_freq[__NL80211_FREQUENCY_ATTR_NO_IBSS]){
196 print_flag("no ibss", &open);
197 }
198
199 if (tb_freq[NL80211_FREQUENCY_ATTR_RADAR])
200 print_flag("radar detection", &open);
201 next:
202 if (open)
203 printf(")");
204 printf("\n");
205 }
206 }
207
208 if (tb_band[NL80211_BAND_ATTR_RATES]) {
209 printf("\t\tBitrates (non-HT):\n");
210 nla_for_each_nested(nl_rate, tb_band[NL80211_BAND_ATTR_RATES], rem_rate) {
211 nla_parse(tb_rate, NL80211_BITRATE_ATTR_MAX, nla_data(nl_rate),
212 nla_len(nl_rate), rate_policy);
213 if (!tb_rate[NL80211_BITRATE_ATTR_RATE])
214 continue;
215 printf("\t\t\t* %2.1f Mbps", 0.1 * nla_get_u32(tb_rate[NL80211_BITRATE_ATTR_RATE]));
216 open = 0;
217 if (tb_rate[NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE])
218 print_flag("short preamble supported", &open);
219 if (open)
220 printf(")");
221 printf("\n");
222 }
223 }
224 }
225 }
226
227 if (tb_msg[NL80211_ATTR_MAX_NUM_SCAN_SSIDS])
228 printf("\tmax # scan SSIDs: %d\n",
229 nla_get_u8(tb_msg[NL80211_ATTR_MAX_NUM_SCAN_SSIDS]));
230 if (tb_msg[NL80211_ATTR_MAX_SCAN_IE_LEN])
231 printf("\tmax scan IEs length: %d bytes\n",
232 nla_get_u16(tb_msg[NL80211_ATTR_MAX_SCAN_IE_LEN]));
233 if (tb_msg[NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS])
234 printf("\tmax # sched scan SSIDs: %d\n",
235 nla_get_u8(tb_msg[NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS]));
236 if (tb_msg[NL80211_ATTR_MAX_MATCH_SETS])
237 printf("\tmax # match sets: %d\n",
238 nla_get_u8(tb_msg[NL80211_ATTR_MAX_MATCH_SETS]));
239 if (tb_msg[NL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANS])
240 printf("\tmax # scan plans: %d\n",
241 nla_get_u32(tb_msg[NL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANS]));
242 if (tb_msg[NL80211_ATTR_MAX_SCAN_PLAN_INTERVAL])
243 printf("\tmax scan plan interval: %d\n",
244 nla_get_u32(tb_msg[NL80211_ATTR_MAX_SCAN_PLAN_INTERVAL]));
245 if (tb_msg[NL80211_ATTR_MAX_SCAN_PLAN_ITERATIONS])
246 printf("\tmax scan plan iterations: %d\n",
247 nla_get_u32(tb_msg[NL80211_ATTR_MAX_SCAN_PLAN_ITERATIONS]));
248
249 if (tb_msg[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
250 unsigned int frag;
251
252 frag = nla_get_u32(tb_msg[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
253 if (frag != (unsigned int)-1)
254 printf("\tFragmentation threshold: %d\n", frag);
255 }
256
257 if (tb_msg[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
258 unsigned int rts;
259
260 rts = nla_get_u32(tb_msg[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
261 if (rts != (unsigned int)-1)
262 printf("\tRTS threshold: %d\n", rts);
263 }
264
265 if (tb_msg[NL80211_ATTR_WIPHY_RETRY_SHORT] ||
266 tb_msg[NL80211_ATTR_WIPHY_RETRY_LONG]) {
267 unsigned char retry_short = 0, retry_long = 0;
268
269 if (tb_msg[NL80211_ATTR_WIPHY_RETRY_SHORT])
270 retry_short = nla_get_u8(tb_msg[NL80211_ATTR_WIPHY_RETRY_SHORT]);
271 if (tb_msg[NL80211_ATTR_WIPHY_RETRY_LONG])
272 retry_long = nla_get_u8(tb_msg[NL80211_ATTR_WIPHY_RETRY_LONG]);
273 if (retry_short == retry_long) {
274 printf("\tRetry short long limit: %d\n", retry_short);
275 } else {
276 printf("\tRetry short limit: %d\n", retry_short);
277 printf("\tRetry long limit: %d\n", retry_long);
278 }
279 }
280
281 if (tb_msg[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) {
282 unsigned char coverage;
283
284 coverage = nla_get_u8(tb_msg[NL80211_ATTR_WIPHY_COVERAGE_CLASS]);
285 /* See handle_distance() for an explanation where the '450' comes from */
286 printf("\tCoverage class: %d (up to %dm)\n", coverage, 450 * coverage);
287 }
288
289 if (tb_msg[NL80211_ATTR_CIPHER_SUITES]) {
290 int num = nla_len(tb_msg[NL80211_ATTR_CIPHER_SUITES]) / sizeof(__u32);
291 int i;
292 __u32 *ciphers = nla_data(tb_msg[NL80211_ATTR_CIPHER_SUITES]);
293 if (num > 0) {
294 printf("\tSupported Ciphers:\n");
295 for (i = 0; i < num; i++)
296 printf("\t\t* %s\n",
297 cipher_name(ciphers[i]));
298 }
299 }
300
301 if (tb_msg[NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX] &&
302 tb_msg[NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX])
303 printf("\tAvailable Antennas: TX %#x RX %#x\n",
304 nla_get_u32(tb_msg[NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX]),
305 nla_get_u32(tb_msg[NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX]));
306
307 if (tb_msg[NL80211_ATTR_WIPHY_ANTENNA_TX] &&
308 tb_msg[NL80211_ATTR_WIPHY_ANTENNA_RX])
309 printf("\tConfigured Antennas: TX %#x RX %#x\n",
310 nla_get_u32(tb_msg[NL80211_ATTR_WIPHY_ANTENNA_TX]),
311 nla_get_u32(tb_msg[NL80211_ATTR_WIPHY_ANTENNA_RX]));
312
313 if (tb_msg[NL80211_ATTR_SUPPORTED_IFTYPES]) {
314 printf("\tSupported interface modes:\n");
315 nla_for_each_nested(nl_mode, tb_msg[NL80211_ATTR_SUPPORTED_IFTYPES], rem_mode)
316 printf("\t\t * %s\n", iftype_name(nla_type(nl_mode)));
317 }
318
319 if (tb_msg[NL80211_ATTR_SOFTWARE_IFTYPES]) {
320 printf("\tsoftware interface modes (can always be added):\n");
321 nla_for_each_nested(nl_mode, tb_msg[NL80211_ATTR_SOFTWARE_IFTYPES], rem_mode)
322 printf("\t\t * %s\n", iftype_name(nla_type(nl_mode)));
323 }
324
325 if (tb_msg[NL80211_ATTR_INTERFACE_COMBINATIONS]) {
326 struct nlattr *nl_combi;
327 int rem_combi;
328 bool have_combinations = false;
329
330 nla_for_each_nested(nl_combi, tb_msg[NL80211_ATTR_INTERFACE_COMBINATIONS], rem_combi) {
331 static struct nla_policy iface_combination_policy[NUM_NL80211_IFACE_COMB] = {
332 [NL80211_IFACE_COMB_LIMITS] = { .type = NLA_NESTED },
333 [NL80211_IFACE_COMB_MAXNUM] = { .type = NLA_U32 },
334 [NL80211_IFACE_COMB_STA_AP_BI_MATCH] = { .type = NLA_FLAG },
335 [NL80211_IFACE_COMB_NUM_CHANNELS] = { .type = NLA_U32 },
336 [NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS] = { .type = NLA_U32 },
337 };
338 struct nlattr *tb_comb[NUM_NL80211_IFACE_COMB];
339 static struct nla_policy iface_limit_policy[NUM_NL80211_IFACE_LIMIT] = {
340 [NL80211_IFACE_LIMIT_TYPES] = { .type = NLA_NESTED },
341 [NL80211_IFACE_LIMIT_MAX] = { .type = NLA_U32 },
342 };
343 struct nlattr *tb_limit[NUM_NL80211_IFACE_LIMIT];
344 struct nlattr *nl_limit;
345 int err, rem_limit;
346 bool comma = false;
347
348 if (!have_combinations) {
349 printf("\tvalid interface combinations:\n");
350 have_combinations = true;
351 }
352
353 printf("\t\t * ");
354
355 err = nla_parse_nested(tb_comb, MAX_NL80211_IFACE_COMB,
356 nl_combi, iface_combination_policy);
357 if (err || !tb_comb[NL80211_IFACE_COMB_LIMITS] ||
358 !tb_comb[NL80211_IFACE_COMB_MAXNUM] ||
359 !tb_comb[NL80211_IFACE_COMB_NUM_CHANNELS]) {
360 printf(" <failed to parse>\n");
361 goto broken_combination;
362 }
363
364 nla_for_each_nested(nl_limit, tb_comb[NL80211_IFACE_COMB_LIMITS], rem_limit) {
365 bool ift_comma = false;
366
367 err = nla_parse_nested(tb_limit, MAX_NL80211_IFACE_LIMIT,
368 nl_limit, iface_limit_policy);
369 if (err || !tb_limit[NL80211_IFACE_LIMIT_TYPES]) {
370 printf("<failed to parse>\n");
371 goto broken_combination;
372 }
373
374 if (comma)
375 printf(", ");
376 comma = true;
377 printf("#{");
378
379 nla_for_each_nested(nl_mode, tb_limit[NL80211_IFACE_LIMIT_TYPES], rem_mode) {
380 printf("%s %s", ift_comma ? "," : "",
381 iftype_name(nla_type(nl_mode)));
382 ift_comma = true;
383 }
384 printf(" } <= %u", nla_get_u32(tb_limit[NL80211_IFACE_LIMIT_MAX]));
385 }
386 printf(",\n\t\t ");
387
388 printf("total <= %d, #channels <= %d%s",
389 nla_get_u32(tb_comb[NL80211_IFACE_COMB_MAXNUM]),
390 nla_get_u32(tb_comb[NL80211_IFACE_COMB_NUM_CHANNELS]),
391 tb_comb[NL80211_IFACE_COMB_STA_AP_BI_MATCH] ?
392 ", STA/AP BI must match" : "");
393 if (tb_comb[NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS]) {
394 unsigned long widths = nla_get_u32(tb_comb[NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS]);
395
396 if (widths) {
397 int width;
398 bool first = true;
399
400 printf(", radar detect widths: {");
401 for (width = 0; width < 32; width++)
402 if (widths & (1 << width)) {
403 printf("%s %s",
404 first ? "":",",
405 channel_width_name(width));
406 first = false;
407 }
408 printf(" }\n");
409 }
410 }
411 printf("\n");
412 broken_combination:
413 ;
414 }
415
416 if (!have_combinations)
417 printf("\tinterface combinations are not supported\n");
418 }
419
420 if (tb_msg[NL80211_ATTR_SUPPORTED_COMMANDS]) {
421 printf("\tSupported commands:\n");
422 nla_for_each_nested(nl_cmd, tb_msg[NL80211_ATTR_SUPPORTED_COMMANDS], rem_cmd)
423 printf("\t\t * %s\n", command_name(nla_get_u32(nl_cmd)));
424 }
425
426 if (tb_msg[NL80211_ATTR_TX_FRAME_TYPES]) {
427 printf("\tSupported TX frame types:\n");
428 nla_for_each_nested(nl_if, tb_msg[NL80211_ATTR_TX_FRAME_TYPES], rem_if) {
429 bool printed = false;
430 nla_for_each_nested(nl_ftype, nl_if, rem_ftype) {
431 if (!printed)
432 printf("\t\t * %s:", iftype_name(nla_type(nl_if)));
433 printed = true;
434 printf(" 0x%.2x", nla_get_u16(nl_ftype));
435 }
436 if (printed)
437 printf("\n");
438 }
439 }
440
441 if (tb_msg[NL80211_ATTR_RX_FRAME_TYPES]) {
442 printf("\tSupported RX frame types:\n");
443 nla_for_each_nested(nl_if, tb_msg[NL80211_ATTR_RX_FRAME_TYPES], rem_if) {
444 bool printed = false;
445 nla_for_each_nested(nl_ftype, nl_if, rem_ftype) {
446 if (!printed)
447 printf("\t\t * %s:", iftype_name(nla_type(nl_if)));
448 printed = true;
449 printf(" 0x%.2x", nla_get_u16(nl_ftype));
450 }
451 if (printed)
452 printf("\n");
453 }
454 }
455
456 if (tb_msg[NL80211_ATTR_SUPPORT_IBSS_RSN])
457 printf("\tDevice supports RSN-IBSS.\n");
458
459 if (tb_msg[NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED]) {
460 struct nlattr *tb_wowlan[NUM_NL80211_WOWLAN_TRIG];
461 static struct nla_policy wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = {
462 [NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG },
463 [NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG },
464 [NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG },
465 [NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .minlen = 12 },
466 [NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED] = { .type = NLA_FLAG },
467 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE] = { .type = NLA_FLAG },
468 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST] = { .type = NLA_FLAG },
469 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE] = { .type = NLA_FLAG },
470 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE] = { .type = NLA_FLAG },
471 [NL80211_WOWLAN_TRIG_NET_DETECT] = { .type = NLA_U32 },
472 [NL80211_WOWLAN_TRIG_TCP_CONNECTION] = { .type = NLA_NESTED },
473 };
474 struct nl80211_pattern_support *pat;
475 int err;
476
477 err = nla_parse_nested(tb_wowlan, MAX_NL80211_WOWLAN_TRIG,
478 tb_msg[NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED],
479 wowlan_policy);
480 printf("\tWoWLAN support:");
481 if (err) {
482 printf(" <failed to parse>\n");
483 } else {
484 printf("\n");
485 if (tb_wowlan[NL80211_WOWLAN_TRIG_ANY])
486 printf("\t\t * wake up on anything (device continues operating normally)\n");
487 if (tb_wowlan[NL80211_WOWLAN_TRIG_DISCONNECT])
488 printf("\t\t * wake up on disconnect\n");
489 if (tb_wowlan[NL80211_WOWLAN_TRIG_MAGIC_PKT])
490 printf("\t\t * wake up on magic packet\n");
491 if (tb_wowlan[NL80211_WOWLAN_TRIG_PKT_PATTERN]) {
492 unsigned int len = nla_len(tb_wowlan[NL80211_WOWLAN_TRIG_PKT_PATTERN]);
493
494 pat = nla_data(tb_wowlan[NL80211_WOWLAN_TRIG_PKT_PATTERN]);
495 printf("\t\t * wake up on pattern match, up to %u patterns of %u-%u bytes,\n"
496 "\t\t maximum packet offset %u bytes\n",
497 pat->max_patterns, pat->min_pattern_len, pat->max_pattern_len,
498 len < sizeof(*pat) ? 0 : pat->max_pkt_offset);
499 }
500 if (tb_wowlan[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED])
501 printf("\t\t * can do GTK rekeying\n");
502 if (tb_wowlan[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE])
503 printf("\t\t * wake up on GTK rekey failure\n");
504 if (tb_wowlan[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST])
505 printf("\t\t * wake up on EAP identity request\n");
506 if (tb_wowlan[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE])
507 printf("\t\t * wake up on 4-way handshake\n");
508 if (tb_wowlan[NL80211_WOWLAN_TRIG_RFKILL_RELEASE])
509 printf("\t\t * wake up on rfkill release\n");
510 if (tb_wowlan[NL80211_WOWLAN_TRIG_NET_DETECT])
511 printf("\t\t * wake up on network detection, up to %d match sets\n",
512 nla_get_u32(tb_wowlan[NL80211_WOWLAN_TRIG_NET_DETECT]));
513 if (tb_wowlan[NL80211_WOWLAN_TRIG_TCP_CONNECTION])
514 printf("\t\t * wake up on TCP connection\n");
515 }
516 }
517
518 if (tb_msg[NL80211_ATTR_ROAM_SUPPORT])
519 printf("\tDevice supports roaming.\n");
520
521 if (tb_msg[NL80211_ATTR_SUPPORT_AP_UAPSD])
522 printf("\tDevice supports AP-side u-APSD.\n");
523
524 if (tb_msg[NL80211_ATTR_HT_CAPABILITY_MASK]) {
525 struct ieee80211_ht_cap *cm;
526 unsigned int len = nla_len(tb_msg[NL80211_ATTR_HT_CAPABILITY_MASK]);
527
528 printf("\tHT Capability overrides:\n");
529 if (len >= sizeof(*cm)) {
530 cm = nla_data(tb_msg[NL80211_ATTR_HT_CAPABILITY_MASK]);
531 printf("\t\t * MCS: %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx"
532 " %02hhx %02hhx %02hhx %02hhx\n",
533 cm->mcs.rx_mask[0], cm->mcs.rx_mask[1],
534 cm->mcs.rx_mask[2], cm->mcs.rx_mask[3],
535 cm->mcs.rx_mask[4], cm->mcs.rx_mask[5],
536 cm->mcs.rx_mask[6], cm->mcs.rx_mask[7],
537 cm->mcs.rx_mask[8], cm->mcs.rx_mask[9]);
538 if (cm->cap_info & htole16(IEEE80211_HT_CAP_MAX_AMSDU))
539 printf("\t\t * maximum A-MSDU length\n");
540 if (cm->cap_info & htole16(IEEE80211_HT_CAP_SUP_WIDTH_20_40))
541 printf("\t\t * supported channel width\n");
542 if (cm->cap_info & htole16(IEEE80211_HT_CAP_SGI_40))
543 printf("\t\t * short GI for 40 MHz\n");
544 if (cm->ampdu_params_info & IEEE80211_HT_AMPDU_PARM_FACTOR)
545 printf("\t\t * max A-MPDU length exponent\n");
546 if (cm->ampdu_params_info & IEEE80211_HT_AMPDU_PARM_DENSITY)
547 printf("\t\t * min MPDU start spacing\n");
548 } else {
549 printf("\tERROR: capabilities mask is too short, expected: %d, received: %d\n",
550 (int)(sizeof(*cm)),
551 (int)(nla_len(tb_msg[NL80211_ATTR_HT_CAPABILITY_MASK])));
552 }
553 }
554
555 if (tb_msg[NL80211_ATTR_FEATURE_FLAGS]) {
556 unsigned int features = nla_get_u32(tb_msg[NL80211_ATTR_FEATURE_FLAGS]);
557
558 if (features & NL80211_FEATURE_SK_TX_STATUS)
559 printf("\tDevice supports TX status socket option.\n");
560 if (features & NL80211_FEATURE_HT_IBSS)
561 printf("\tDevice supports HT-IBSS.\n");
562 if (features & NL80211_FEATURE_INACTIVITY_TIMER)
563 printf("\tDevice has client inactivity timer.\n");
564 if (features & NL80211_FEATURE_CELL_BASE_REG_HINTS)
565 printf("\tDevice accepts cell base station regulatory hints.\n");
566 if (features & NL80211_FEATURE_P2P_DEVICE_NEEDS_CHANNEL)
567 printf("\tP2P Device uses a channel (of the concurrent ones)\n");
568 if (features & NL80211_FEATURE_SAE)
569 printf("\tDevice supports SAE with AUTHENTICATE command\n");
570 if (features & NL80211_FEATURE_LOW_PRIORITY_SCAN)
571 printf("\tDevice supports low priority scan.\n");
572 if (features & NL80211_FEATURE_SCAN_FLUSH)
573 printf("\tDevice supports scan flush.\n");
574 if (features & NL80211_FEATURE_AP_SCAN)
575 printf("\tDevice supports AP scan.\n");
576 if (features & NL80211_FEATURE_VIF_TXPOWER)
577 printf("\tDevice supports per-vif TX power setting\n");
578 if (features & NL80211_FEATURE_NEED_OBSS_SCAN)
579 printf("\tUserspace should do OBSS scan and generate 20/40 coex reports\n");
580 if (features & NL80211_FEATURE_P2P_GO_CTWIN)
581 printf("\tP2P GO supports CT window setting\n");
582 if (features & NL80211_FEATURE_P2P_GO_OPPPS)
583 printf("\tP2P GO supports opportunistic powersave setting\n");
584 if (features & NL80211_FEATURE_FULL_AP_CLIENT_STATE)
585 printf("\tDriver supports full state transitions for AP/GO clients\n");
586 if (features & NL80211_FEATURE_USERSPACE_MPM)
587 printf("\tDriver supports a userspace MPM\n");
588 if (features & NL80211_FEATURE_ACTIVE_MONITOR)
589 printf("\tDevice supports active monitor (which will ACK incoming frames)\n");
590 if (features & NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE)
591 printf("\tDriver/device bandwidth changes during BSS lifetime (AP/GO mode)\n");
592 if (features & NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES)
593 printf("\tDevice adds DS IE to probe requests\n");
594 if (features & NL80211_FEATURE_WFA_TPC_IE_IN_PROBES)
595 printf("\tDevice adds WFA TPC Report IE to probe requests\n");
596 if (features & NL80211_FEATURE_QUIET)
597 printf("\tDevice supports quiet requests from AP\n");
598 if (features & NL80211_FEATURE_TX_POWER_INSERTION)
599 printf("\tDevice can update TPC Report IE\n");
600 if (features & NL80211_FEATURE_ACKTO_ESTIMATION)
601 printf("\tDevice supports ACK timeout estimation.\n");
602 if (features & NL80211_FEATURE_STATIC_SMPS)
603 printf("\tDevice supports static SMPS\n");
604 if (features & NL80211_FEATURE_DYNAMIC_SMPS)
605 printf("\tDevice supports dynamic SMPS\n");
606 if (features & NL80211_FEATURE_SUPPORTS_WMM_ADMISSION)
607 printf("\tDevice supports WMM-AC admission (TSPECs)\n");
608 if (features & NL80211_FEATURE_MAC_ON_CREATE)
609 printf("\tDevice supports configuring vdev MAC-addr on create.\n");
610 if (features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH)
611 printf("\tDevice supports TDLS channel switching\n");
612 if (features & NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR)
613 printf("\tDevice supports randomizing MAC-addr in scans.\n");
614 if (features & NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR)
615 printf("\tDevice supports randomizing MAC-addr in sched scans.\n");
616 if (features & NL80211_FEATURE_ND_RANDOM_MAC_ADDR)
617 printf("\tDevice supports randomizing MAC-addr in net-detect scans.\n");
618 }
619
620 if (tb_msg[NL80211_ATTR_TDLS_SUPPORT])
621 printf("\tDevice supports T-DLS.\n");
622
623 if (tb_msg[NL80211_ATTR_EXT_FEATURES]) {
624 struct nlattr *tb = tb_msg[NL80211_ATTR_EXT_FEATURES];
625
626 printf("\tSupported extended features:\n");
627
628 ext_feat_print(tb, NL80211_EXT_FEATURE_VHT_IBSS,
629 "VHT_IBSS", "VHT-IBSS");
630 ext_feat_print(tb, NL80211_EXT_FEATURE_RRM,
631 "RRM", "RRM");
632 ext_feat_print(tb, NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER,
633 "MU_MIMO_AIR_SNIFFER", "MU-MIMO sniffer");
634 ext_feat_print(tb, NL80211_EXT_FEATURE_SCAN_START_TIME,
635 "SCAN_START_TIME", "scan start timestamp");
636 ext_feat_print(tb, NL80211_EXT_FEATURE_BSS_PARENT_TSF,
637 "BSS_PARENT_TSF", "BSS last beacon/probe TSF");
638 ext_feat_print(tb, NL80211_EXT_FEATURE_SET_SCAN_DWELL,
639 "SET_SCAN_DWELL", "scan dwell setting");
640 ext_feat_print(tb, NL80211_EXT_FEATURE_BEACON_RATE_LEGACY,
641 "BEACON_RATE_LEGACY", "legacy beacon rate setting");
642 ext_feat_print(tb, NL80211_EXT_FEATURE_BEACON_RATE_HT,
643 "BEACON_RATE_HT", "HT beacon rate setting");
644 ext_feat_print(tb, NL80211_EXT_FEATURE_BEACON_RATE_VHT,
645 "BEACON_RATE_VHT", "VHT beacon rate setting");
646 ext_feat_print(tb, NL80211_EXT_FEATURE_FILS_STA,
647 "FILS_STA", "STA FILS (Fast Initial Link Setup)");
648 ext_feat_print(tb, NL80211_EXT_FEATURE_MGMT_TX_RANDOM_TA,
649 "MGMT_TX_RANDOM_TA",
650 "randomized TA while not associated");
651 ext_feat_print(tb, NL80211_EXT_FEATURE_MGMT_TX_RANDOM_TA_CONNECTED,
652 "MGMT_TX_RANDOM_TA_CONNECTED",
653 "randomized TA while associated");
654 ext_feat_print(tb, NL80211_EXT_FEATURE_SCHED_SCAN_RELATIVE_RSSI,
655 "SCHED_SCAN_RELATIVE_RSSI",
656 "sched_scan for BSS with better RSSI report");
657 ext_feat_print(tb, NL80211_EXT_FEATURE_CQM_RSSI_LIST,
658 "CQM_RSSI_LIST",
659 "multiple CQM_RSSI_THOLD records");
660 ext_feat_print(tb, NL80211_EXT_FEATURE_FILS_SK_OFFLOAD,
661 "FILS_SK_OFFLOAD",
662 "FILS shared key authentication offload");
663 ext_feat_print(tb, NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_PSK,
664 "4WAY_HANDSHAKE_STA_PSK",
665 "4-way handshake with PSK in station mode");
666 ext_feat_print(tb, NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X,
667 "4WAY_HANDSHAKE_STA_1X",
668 "4-way handshake with 802.1X in station mode");
669 ext_feat_print(tb, NL80211_EXT_FEATURE_FILS_MAX_CHANNEL_TIME,
670 "FILS_MAX_CHANNEL_TIME",
671 "FILS max channel attribute override with dwell time");
672 ext_feat_print(tb, NL80211_EXT_FEATURE_ACCEPT_BCAST_PROBE_RESP,
673 "ACCEPT_BCAST_PROBE_RESP",
674 "accepts broadcast probe response");
675 ext_feat_print(tb, NL80211_EXT_FEATURE_OCE_PROBE_REQ_HIGH_TX_RATE,
676 "OCE_PROBE_REQ_HIGH_TX_RATE",
677 "probe request TX at high rate (at least 5.5Mbps)");
678 ext_feat_print(tb, NL80211_EXT_FEATURE_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION,
679 "OCE_PROBE_REQ_DEFERRAL_SUPPRESSION",
680 "probe request tx deferral and suppression");
681 ext_feat_print(tb, NL80211_EXT_FEATURE_MFP_OPTIONAL,
682 "MFP_OPTIONAL",
683 "MFP_OPTIONAL value in ATTR_USE_MFP");
684 ext_feat_print(tb, NL80211_EXT_FEATURE_LOW_SPAN_SCAN,
685 "LOW_SPAN_SCAN", "low span scan");
686 ext_feat_print(tb, NL80211_EXT_FEATURE_LOW_POWER_SCAN,
687 "LOW_POWER_SCAN", "low power scan");
688 ext_feat_print(tb, NL80211_EXT_FEATURE_HIGH_ACCURACY_SCAN,
689 "HIGH_ACCURACY_SCAN", "high accuracy scan");
690 ext_feat_print(tb, NL80211_EXT_FEATURE_DFS_OFFLOAD,
691 "DFS_OFFLOAD", "DFS offload");
692 ext_feat_print(tb, NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211,
693 "CONTROL_PORT_OVER_NL80211",
694 "control port over nl80211");
695 ext_feat_print(tb, NL80211_EXT_FEATURE_TXQS,
696 "TXQS", "FQ-CoDel-enabled intermediate TXQs");
697 }
698
699 if (tb_msg[NL80211_ATTR_COALESCE_RULE]) {
700 struct nl80211_coalesce_rule_support *rule;
701 struct nl80211_pattern_support *pat;
702
703 printf("\tCoalesce support:\n");
704 rule = nla_data(tb_msg[NL80211_ATTR_COALESCE_RULE]);
705 pat = &rule->pat;
706 printf("\t\t * Maximum %u coalesce rules supported\n"
707 "\t\t * Each rule contains upto %u patterns of %u-%u bytes,\n"
708 "\t\t maximum packet offset %u bytes\n"
709 "\t\t * Maximum supported coalescing delay %u msecs\n",
710 rule->max_rules, pat->max_patterns, pat->min_pattern_len,
711 pat->max_pattern_len, pat->max_pkt_offset, rule->max_delay);
712 }
713
714 return NL_SKIP;
715 }
716
717 static bool nl80211_has_split_wiphy = false;
718
719 static int handle_info(struct nl80211_state *state,
720 struct nl_msg *msg,
721 int argc, char **argv,
722 enum id_input id)
723 {
724 char *feat_args[] = { "features", "-q" };
725 int err;
726
727 err = handle_cmd(state, II_NONE, 2, feat_args);
728 if (!err && nl80211_has_split_wiphy) {
729 nla_put_flag(msg, NL80211_ATTR_SPLIT_WIPHY_DUMP);
730 nlmsg_hdr(msg)->nlmsg_flags |= NLM_F_DUMP;
731 }
732
733 register_handler(print_phy_handler, NULL);
734
735 return 0;
736 }
737 __COMMAND(NULL, info, "info", NULL, NL80211_CMD_GET_WIPHY, 0, 0, CIB_PHY, handle_info,
738 "Show capabilities for the specified wireless device.", NULL);
739 TOPLEVEL(list, NULL, NL80211_CMD_GET_WIPHY, NLM_F_DUMP, CIB_NONE, handle_info,
740 "List all wireless devices and their capabilities.");
741 TOPLEVEL(phy, NULL, NL80211_CMD_GET_WIPHY, NLM_F_DUMP, CIB_NONE, handle_info, NULL);
742
743 static int handle_commands(struct nl80211_state *state, struct nl_msg *msg,
744 int argc, char **argv, enum id_input id)
745 {
746 int i;
747 for (i = 1; i <= NL80211_CMD_MAX; i++)
748 printf("%d (0x%x): %s\n", i, i, command_name(i));
749 /* don't send netlink messages */
750 return 2;
751 }
752 TOPLEVEL(commands, NULL, NL80211_CMD_GET_WIPHY, 0, CIB_NONE, handle_commands,
753 "list all known commands and their decimal & hex value");
754
755 static int print_feature_handler(struct nl_msg *msg, void *arg)
756 {
757 struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
758 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
759 bool print = (unsigned long)arg;
760 #define maybe_printf(...) do { if (print) printf(__VA_ARGS__); } while (0)
761
762 nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
763 genlmsg_attrlen(gnlh, 0), NULL);
764
765 if (tb_msg[NL80211_ATTR_PROTOCOL_FEATURES]) {
766 uint32_t feat = nla_get_u32(tb_msg[NL80211_ATTR_PROTOCOL_FEATURES]);
767
768 maybe_printf("nl80211 features: 0x%x\n", feat);
769 if (feat & NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP) {
770 maybe_printf("\t* split wiphy dump\n");
771 nl80211_has_split_wiphy = true;
772 }
773 }
774
775 return NL_SKIP;
776 }
777
778 static int handle_features(struct nl80211_state *state, struct nl_msg *msg,
779 int argc, char **argv, enum id_input id)
780 {
781 unsigned long print = argc == 0 || strcmp(argv[0], "-q");
782 register_handler(print_feature_handler, (void *)print);
783 return 0;
784 }
785
786 TOPLEVEL(features, "", NL80211_CMD_GET_PROTOCOL_FEATURES, 0, CIB_NONE,
787 handle_features, "");
Mirror git://git.kernel.org/pub/scm/linux/kernel/git/jberg/iw.git