]> git.ipfire.org Git - thirdparty/iw.git/blame - event.c
projects / thirdparty / iw.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
iw: make parse_he_gi static
[thirdparty/iw.git] / event.c
CommitLineData
957a0f07
JB		 1#include <stdint.h>
2#include <stdbool.h>
3#include <net/if.h>
4#include <errno.h>
7c4e86ca 5#include <inttypes.h>
c3df363e 6#include <time.h>
957a0f07
JB		 7#include "iw.h"
8
9static int no_seq_check(struct nl_msg *msg, void *arg)
10{
11 return NL_OK;
12}
13
0168589d
LR		 14struct ieee80211_beacon_channel {
15 __u16 center_freq;
f0c48e7b 16 bool no_ir;
0168589d
LR		 17 bool no_ibss;
18};
19
20static int parse_beacon_hint_chan(struct nlattr *tb,
21 struct ieee80211_beacon_channel *chan)
22{
23 struct nlattr *tb_freq[NL80211_FREQUENCY_ATTR_MAX + 1];
24 static struct nla_policy beacon_freq_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
25 [NL80211_FREQUENCY_ATTR_FREQ] = { .type = NLA_U32 },
f0c48e7b
IP		 26 [NL80211_FREQUENCY_ATTR_NO_IR] = { .type = NLA_FLAG },
27 [__NL80211_FREQUENCY_ATTR_NO_IBSS] = { .type = NLA_FLAG },
0168589d
LR		 28 };
29
30 if (nla_parse_nested(tb_freq,
31 NL80211_FREQUENCY_ATTR_MAX,
32 tb,
33 beacon_freq_policy))
34 return -EINVAL;
35
36 chan->center_freq = nla_get_u32(tb_freq[NL80211_FREQUENCY_ATTR_FREQ]);
37
f0c48e7b
IP		 38 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_IR])
39 chan->no_ir = true;
40 if (tb_freq[__NL80211_FREQUENCY_ATTR_NO_IBSS])
0168589d
LR		 41 chan->no_ibss = true;
42
43 return 0;
44}
45
957a0f07
JB		 46static void print_frame(struct print_event_args *args, struct nlattr *attr)
47{
48 uint8_t *frame;
49 size_t len;
0ee571d5 50 unsigned int i;
957a0f07
JB		 51 char macbuf[6*3];
52 uint16_t tmp;
53
572e47a3 54 if (!attr) {
957a0f07 55 printf(" [no frame]");
572e47a3
AK		 56 return;
57 }
957a0f07
JB		 58
59 frame = nla_data(attr);
60 len = nla_len(attr);
61
62 if (len < 26) {
63 printf(" [invalid frame: ");
64 goto print_frame;
65 }
66
67 mac_addr_n2a(macbuf, frame + 10);
68 printf(" %s -> ", macbuf);
69 mac_addr_n2a(macbuf, frame + 4);
70 printf("%s", macbuf);
71
72 switch (frame[0] & 0xfc) {
73 case 0x10: /* assoc resp */
74 case 0x30: /* reassoc resp */
75 /* status */
76 tmp = (frame[27] << 8) + frame[26];
77 printf(" status: %d: %s", tmp, get_status_str(tmp));
78 break;
79 case 0x00: /* assoc req */
80 case 0x20: /* reassoc req */
81 break;
82 case 0xb0: /* auth */
83 /* status */
84 tmp = (frame[29] << 8) + frame[28];
85 printf(" status: %d: %s", tmp, get_status_str(tmp));
86 break;
957a0f07
JB		 87 case 0xa0: /* disassoc */
88 case 0xc0: /* deauth */
89 /* reason */
90 tmp = (frame[25] << 8) + frame[24];
91 printf(" reason %d: %s", tmp, get_reason_str(tmp));
92 break;
93 }
94
95 if (!args->frame)
96 return;
97
98 printf(" [frame:");
99
100 print_frame:
101 for (i = 0; i < len; i++)
102 printf(" %.02x", frame[i]);
103 printf("]");
104}
105
f19444fe 106static void parse_cqm_event(struct nlattr **attrs)
7988b229
JO		 107{
108 static struct nla_policy cqm_policy[NL80211_ATTR_CQM_MAX + 1] = {
109 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_U32 },
110 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
111 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
112 };
113 struct nlattr *cqm[NL80211_ATTR_CQM_MAX + 1];
f19444fe 114 struct nlattr *cqm_attr = attrs[NL80211_ATTR_CQM];
7988b229 115
e5497f12 116 printf("CQM event: ");
7988b229 117
f19444fe
JB		 118 if (!cqm_attr ||
119 nla_parse_nested(cqm, NL80211_ATTR_CQM_MAX, cqm_attr, cqm_policy)) {
7988b229
JO		 120 printf("missing data!\n");
121 return;
122 }
123
124 if (cqm[NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT]) {
125 enum nl80211_cqm_rssi_threshold_event rssi_event;
19b80cd0 126 int32_t rssi_level = -1;
e5497f12
BG		 127 bool found_one = false;
128
7988b229 129 rssi_event = nla_get_u32(cqm[NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT]);
19b80cd0
MT		 130 if (cqm[NL80211_ATTR_CQM_RSSI_LEVEL])
131 rssi_level = nla_get_u32(cqm[NL80211_ATTR_CQM_RSSI_LEVEL]);
e5497f12
BG		 132
133 switch (rssi_event) {
134 case NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH:
19b80cd0 135 printf("RSSI (%i dBm) went above threshold\n", rssi_level);
e5497f12
BG		 136 found_one = true;
137 break;
138 case NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW:
19b80cd0 139 printf("RSSI (%i dBm) went below threshold\n", rssi_level);
e5497f12
BG		 140 found_one = true;
141 break;
142 case NL80211_CQM_RSSI_BEACON_LOSS_EVENT:
143 printf("Beacon loss detected\n");
144 found_one = true;
145 break;
146 }
147
148 if (!found_one)
149 printf("Unknown event type: %i\n", rssi_event);
a3ca7c69
BG		 150 } else if (cqm[NL80211_ATTR_CQM_PKT_LOSS_EVENT]) {
151 if (attrs[NL80211_ATTR_MAC]) {
152 uint32_t frames;
153 char buf[3*6];
154
155 frames = nla_get_u32(cqm[NL80211_ATTR_CQM_PKT_LOSS_EVENT]);
156 mac_addr_n2a(buf, nla_data(attrs[NL80211_ATTR_MAC]));
157 printf("peer %s didn't ACK %d packets\n", buf, frames);
158 } else {
159 printf("PKT-LOSS-EVENT did not have MAC attribute!\n");
160 }
161 } else if (cqm[NL80211_ATTR_CQM_BEACON_LOSS_EVENT]) {
162 printf("beacon loss\n");
163 } else {
f19444fe 164 printf("unknown event\n");
a3ca7c69 165 }
7988b229
JO		 166}
167
8612433d
JM		 168static const char * key_type_str(enum nl80211_key_type key_type)
169{
170 static char buf[30];
171 switch (key_type) {
172 case NL80211_KEYTYPE_GROUP:
173 return "Group";
174 case NL80211_KEYTYPE_PAIRWISE:
175 return "Pairwise";
176 case NL80211_KEYTYPE_PEERKEY:
177 return "PeerKey";
178 default:
179 snprintf(buf, sizeof(buf), "unknown(%d)", key_type);
180 return buf;
181 }
182}
183
184static void parse_mic_failure(struct nlattr **attrs)
185{
186 printf("Michael MIC failure event:");
187
188 if (attrs[NL80211_ATTR_MAC]) {
189 char addr[3 * ETH_ALEN];
190 mac_addr_n2a(addr, nla_data(attrs[NL80211_ATTR_MAC]));
191 printf(" source MAC address %s", addr);
192 }
193
194 if (attrs[NL80211_ATTR_KEY_SEQ] &&
195 nla_len(attrs[NL80211_ATTR_KEY_SEQ]) == 6) {
196 unsigned char *seq = nla_data(attrs[NL80211_ATTR_KEY_SEQ]);
197 printf(" seq=%02x%02x%02x%02x%02x%02x",
198 seq[0], seq[1], seq[2], seq[3], seq[4], seq[5]);
199 }
200 if (attrs[NL80211_ATTR_KEY_TYPE]) {
201 enum nl80211_key_type key_type =
202 nla_get_u32(attrs[NL80211_ATTR_KEY_TYPE]);
203 printf(" Key Type %s", key_type_str(key_type));
204 }
205
206 if (attrs[NL80211_ATTR_KEY_IDX]) {
207 __u8 key_id = nla_get_u8(attrs[NL80211_ATTR_KEY_IDX]);
208 printf(" Key Id %d", key_id);
209 }
210
211 printf("\n");
212}
7988b229 213
819b78cc
JB		 214static void parse_wowlan_wake_event(struct nlattr **attrs)
215{
d516c5bc
LC		 216 struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG],
217 *tb_match[NUM_NL80211_ATTR];
819b78cc
JB		 218
219 printf("WoWLAN wakeup\n");
220 if (!attrs[NL80211_ATTR_WOWLAN_TRIGGERS]) {
221 printf("\twakeup not due to WoWLAN\n");
222 return;
223 }
224
225 nla_parse(tb, MAX_NL80211_WOWLAN_TRIG,
226 nla_data(attrs[NL80211_ATTR_WOWLAN_TRIGGERS]),
227 nla_len(attrs[NL80211_ATTR_WOWLAN_TRIGGERS]), NULL);
228
229 if (tb[NL80211_WOWLAN_TRIG_DISCONNECT])
230 printf("\t* was disconnected\n");
231 if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT])
232 printf("\t* magic packet received\n");
233 if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN])
234 printf("\t* pattern index: %u\n",
235 nla_get_u32(tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]));
236 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE])
237 printf("\t* GTK rekey failure\n");
238 if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST])
239 printf("\t* EAP identity request\n");
240 if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE])
241 printf("\t* 4-way handshake\n");
242 if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE])
243 printf("\t* RF-kill released\n");
d516c5bc
LC		 244 if (tb[NL80211_WOWLAN_TRIG_NET_DETECT_RESULTS]) {
245 struct nlattr *match, *freq;
246 int rem_nst, rem_nst2;
247
248 printf("\t* network detected\n");
249 nla_for_each_nested(match,
250 tb[NL80211_WOWLAN_TRIG_NET_DETECT_RESULTS],
251 rem_nst) {
b7e8163a
DS		 252 nla_parse_nested(tb_match, NL80211_ATTR_MAX, match,
253 NULL);
d516c5bc
LC		 254 printf("\t\tSSID: \"");
255 print_ssid_escaped(nla_len(tb_match[NL80211_ATTR_SSID]),
256 nla_data(tb_match[NL80211_ATTR_SSID]));
257 printf("\"");
258 if (tb_match[NL80211_ATTR_SCAN_FREQUENCIES]) {
259 printf(" freq(s):");
260 nla_for_each_nested(freq,
261 tb_match[NL80211_ATTR_SCAN_FREQUENCIES],
262 rem_nst2)
263 printf(" %d", nla_get_u32(freq));
264 }
265 printf("\n");
266 }
267 }
819b78cc
JB		 268 if (tb[NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211]) {
269 uint8_t *d = nla_data(tb[NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211]);
270 int l = nla_len(tb[NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211]);
271 int i;
272 printf("\t* packet (might be truncated): ");
273 for (i = 0; i < l; i++) {
274 if (i > 0)
275 printf(":");
276 printf("%.2x", d[i]);
277 }
278 printf("\n");
279 }
280 if (tb[NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023]) {
281 uint8_t *d = nla_data(tb[NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023]);
282 int l = nla_len(tb[NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023]);
283 int i;
284 printf("\t* packet (might be truncated): ");
285 for (i = 0; i < l; i++) {
286 if (i > 0)
287 printf(":");
288 printf("%.2x", d[i]);
289 }
290 printf("\n");
291 }
292 if (tb[NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH])
293 printf("\t* TCP connection wakeup received\n");
294 if (tb[NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST])
295 printf("\t* TCP connection lost\n");
296 if (tb[NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS])
297 printf("\t* TCP connection ran out of tokens\n");
298}
299
8e58fe92
JB		 300extern struct vendor_event *__start_vendor_event[];
301extern struct vendor_event *__stop_vendor_event;
302
303// Dummy to force the section to exist
304VENDOR_EVENT(0xffffffff, 0xffffffff, NULL);
305
306static void parse_vendor_event(struct nlattr **attrs, bool dump)
307{
308 __u32 vendor_id, subcmd;
309 unsigned int i;
310
311 if (!attrs[NL80211_ATTR_VENDOR_ID] ||
312 !attrs[NL80211_ATTR_VENDOR_SUBCMD])
313 return;
314
315 vendor_id = nla_get_u32(attrs[NL80211_ATTR_VENDOR_ID]);
316 subcmd = nla_get_u32(attrs[NL80211_ATTR_VENDOR_SUBCMD]);
317
318 printf("vendor event %.6x:%d", vendor_id, subcmd);
319
320 for (i = 0; i < &__stop_vendor_event - __start_vendor_event; i++) {
321 struct vendor_event *ev = __start_vendor_event[i];
322
323 if (!ev)
324 continue;
325
326 if (ev->vendor_id != vendor_id)
327 continue;
328 if (ev->subcmd != subcmd)
329 continue;
330 if (!ev->callback)
331 continue;
332
333 ev->callback(vendor_id, subcmd, attrs[NL80211_ATTR_VENDOR_DATA]);
334 goto out;
335 }
336
337 if (dump && attrs[NL80211_ATTR_VENDOR_DATA])
338 iw_hexdump("vendor event",
339 nla_data(attrs[NL80211_ATTR_VENDOR_DATA]),
340 nla_len(attrs[NL80211_ATTR_VENDOR_DATA]));
341out:
342 printf("\n");
343}
344
7c4e86ca
RZ		 345static void parse_nan_term(struct nlattr **attrs)
346{
347 struct nlattr *func[NL80211_NAN_FUNC_ATTR_MAX + 1];
348
349 static struct nla_policy
350 nan_func_policy[NL80211_NAN_FUNC_ATTR_MAX + 1] = {
351 [NL80211_NAN_FUNC_TYPE] = { .type = NLA_U8 },
352 [NL80211_NAN_FUNC_SERVICE_ID] = { },
353 [NL80211_NAN_FUNC_PUBLISH_TYPE] = { .type = NLA_U8 },
354 [NL80211_NAN_FUNC_PUBLISH_BCAST] = { .type = NLA_FLAG },
355 [NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE] = { .type = NLA_FLAG },
356 [NL80211_NAN_FUNC_FOLLOW_UP_ID] = { .type = NLA_U8 },
357 [NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] = { .type = NLA_U8 },
358 [NL80211_NAN_FUNC_FOLLOW_UP_DEST] = { },
359 [NL80211_NAN_FUNC_CLOSE_RANGE] = { .type = NLA_FLAG },
360 [NL80211_NAN_FUNC_TTL] = { .type = NLA_U32 },
361 [NL80211_NAN_FUNC_SERVICE_INFO] = { },
362 [NL80211_NAN_FUNC_SRF] = { .type = NLA_NESTED },
363 [NL80211_NAN_FUNC_RX_MATCH_FILTER] = { .type = NLA_NESTED },
364 [NL80211_NAN_FUNC_TX_MATCH_FILTER] = { .type = NLA_NESTED },
365 [NL80211_NAN_FUNC_INSTANCE_ID] = { .type = NLA_U8},
366 };
367
368 if (!attrs[NL80211_ATTR_COOKIE]) {
369 printf("Bad NAN func termination format - cookie is missing\n");
370 return;
371 }
372
373 if (nla_parse_nested(func, NL80211_NAN_FUNC_ATTR_MAX,
374 attrs[NL80211_ATTR_NAN_FUNC],
375 nan_func_policy)) {
376 printf("NAN: failed to parse nan func\n");
377 return;
378 }
379
380 if (!func[NL80211_NAN_FUNC_INSTANCE_ID]) {
381 printf("Bad NAN func termination format-instance id missing\n");
382 return;
383 }
384
385 if (!func[NL80211_NAN_FUNC_TERM_REASON]) {
386 printf("Bad NAN func termination format - reason is missing\n");
387 return;
388 }
389 printf("NAN(cookie=0x%llx): Termination event: id = %d, reason = ",
390 (long long int)nla_get_u64(attrs[NL80211_ATTR_COOKIE]),
391 nla_get_u8(func[NL80211_NAN_FUNC_INSTANCE_ID]));
392 switch (nla_get_u8(func[NL80211_NAN_FUNC_TERM_REASON])) {
393 case NL80211_NAN_FUNC_TERM_REASON_USER_REQUEST:
394 printf("user request\n");
395 break;
396 case NL80211_NAN_FUNC_TERM_REASON_TTL_EXPIRED:
397 printf("expired\n");
398 break;
399 case NL80211_NAN_FUNC_TERM_REASON_ERROR:
400 printf("error\n");
401 break;
402 default:
403 printf("unknown\n");
404 }
405}
406
8ddb960e
JB		 407static const char *ftm_fail_reason(unsigned int reason)
408{
409#define FTM_FAIL_REASON(x) case NL80211_PMSR_FTM_FAILURE_##x: return #x
410 switch (reason) {
411 FTM_FAIL_REASON(UNSPECIFIED);
412 FTM_FAIL_REASON(NO_RESPONSE);
413 FTM_FAIL_REASON(REJECTED);
414 FTM_FAIL_REASON(WRONG_CHANNEL);
415 FTM_FAIL_REASON(PEER_NOT_CAPABLE);
416 FTM_FAIL_REASON(INVALID_TIMESTAMP);
417 FTM_FAIL_REASON(PEER_BUSY);
418 FTM_FAIL_REASON(BAD_CHANGED_PARAMS);
419 default:
420 return "unknown";
421 }
422}
423
424static void parse_pmsr_ftm_data(struct nlattr *data)
425{
426 struct nlattr *ftm[NL80211_PMSR_FTM_RESP_ATTR_MAX + 1];
427
428 printf(" FTM");
429 nla_parse_nested(ftm, NL80211_PMSR_FTM_RESP_ATTR_MAX, data, NULL);
430
431 if (ftm[NL80211_PMSR_FTM_RESP_ATTR_FAIL_REASON]) {
432 printf(" failed: %s (%d)",
433 ftm_fail_reason(nla_get_u32(ftm[NL80211_PMSR_FTM_RESP_ATTR_FAIL_REASON])),
434 nla_get_u32(ftm[NL80211_PMSR_FTM_RESP_ATTR_FAIL_REASON]));
435 if (ftm[NL80211_PMSR_FTM_RESP_ATTR_BUSY_RETRY_TIME])
436 printf(" retry after %us",
437 nla_get_u32(ftm[NL80211_PMSR_FTM_RESP_ATTR_BUSY_RETRY_TIME]));
438 printf("\n");
439 return;
440 }
441
442 printf("\n");
443
444#define PFTM(tp, attr, sign) \
445 do { \
446 if (ftm[NL80211_PMSR_FTM_RESP_ATTR_##attr]) \
447 printf(" " #attr ": %lld\n", \
448 (sign long long)nla_get_##tp( \
449 ftm[NL80211_PMSR_FTM_RESP_ATTR_##attr])); \
450 } while (0)
451
452 PFTM(u32, BURST_INDEX, unsigned);
453 PFTM(u32, NUM_FTMR_ATTEMPTS, unsigned);
454 PFTM(u32, NUM_FTMR_SUCCESSES, unsigned);
455 PFTM(u8, NUM_BURSTS_EXP, unsigned);
456 PFTM(u8, BURST_DURATION, unsigned);
457 PFTM(u8, FTMS_PER_BURST, unsigned);
458 PFTM(u32, RSSI_AVG, signed);
459 PFTM(u32, RSSI_SPREAD, unsigned);
460 PFTM(u64, RTT_AVG, signed);
461 PFTM(u64, RTT_VARIANCE, unsigned);
462 PFTM(u64, RTT_SPREAD, unsigned);
463 PFTM(u64, DIST_AVG, signed);
464 PFTM(u64, DIST_VARIANCE, unsigned);
465 PFTM(u64, DIST_SPREAD, unsigned);
466
467 if (ftm[NL80211_PMSR_FTM_RESP_ATTR_TX_RATE]) {
468 char buf[100];
469
470 parse_bitrate(ftm[NL80211_PMSR_FTM_RESP_ATTR_TX_RATE],
471 buf, sizeof(buf));
472 printf(" TX bitrate: %s\n", buf);
473 }
474
475 if (ftm[NL80211_PMSR_FTM_RESP_ATTR_RX_RATE]) {
476 char buf[100];
477
478 parse_bitrate(ftm[NL80211_PMSR_FTM_RESP_ATTR_RX_RATE],
479 buf, sizeof(buf));
480 printf(" RX bitrate: %s\n", buf);
481 }
482
483 if (ftm[NL80211_PMSR_FTM_RESP_ATTR_LCI])
484 iw_hexdump(" LCI",
485 nla_data(ftm[NL80211_PMSR_FTM_RESP_ATTR_LCI]),
486 nla_len(ftm[NL80211_PMSR_FTM_RESP_ATTR_LCI]));
487
488 if (ftm[NL80211_PMSR_FTM_RESP_ATTR_CIVICLOC])
489 iw_hexdump(" civic location",
490 nla_data(ftm[NL80211_PMSR_FTM_RESP_ATTR_CIVICLOC]),
491 nla_len(ftm[NL80211_PMSR_FTM_RESP_ATTR_CIVICLOC]));
492}
493
494static const char *pmsr_status(unsigned int status)
495{
496#define PMSR_STATUS(x) case NL80211_PMSR_STATUS_##x: return #x
497 switch (status) {
498 PMSR_STATUS(SUCCESS);
499 PMSR_STATUS(REFUSED);
500 PMSR_STATUS(TIMEOUT);
501 PMSR_STATUS(FAILURE);
502 default:
503 return "unknown";
504 }
505#undef PMSR_STATUS
506}
507
508static void parse_pmsr_peer(struct nlattr *peer)
509{
510 struct nlattr *tb[NL80211_PMSR_PEER_ATTR_MAX + 1];
511 struct nlattr *resp[NL80211_PMSR_RESP_ATTR_MAX + 1];
512 struct nlattr *data[NL80211_PMSR_TYPE_MAX + 1];
513 char macbuf[6*3];
514 int err;
515
516 err = nla_parse_nested(tb, NL80211_PMSR_PEER_ATTR_MAX, peer, NULL);
517 if (err) {
518 printf(" Peer: failed to parse!\n");
519 return;
520 }
521
522 if (!tb[NL80211_PMSR_PEER_ATTR_ADDR]) {
523 printf(" Peer: no MAC address\n");
524 return;
525 }
526
527 mac_addr_n2a(macbuf, nla_data(tb[NL80211_PMSR_PEER_ATTR_ADDR]));
528 printf(" Peer %s:", macbuf);
529
530 if (!tb[NL80211_PMSR_PEER_ATTR_RESP]) {
531 printf(" no response!\n");
532 return;
533 }
534
535 err = nla_parse_nested(resp, NL80211_PMSR_RESP_ATTR_MAX,
536 tb[NL80211_PMSR_PEER_ATTR_RESP], NULL);
537 if (err) {
538 printf(" failed to parse response!\n");
539 return;
540 }
541
542 if (resp[NL80211_PMSR_RESP_ATTR_STATUS])
543 printf(" status=%d (%s)",
544 nla_get_u32(resp[NL80211_PMSR_RESP_ATTR_STATUS]),
545 pmsr_status(nla_get_u32(resp[NL80211_PMSR_RESP_ATTR_STATUS])));
546 if (resp[NL80211_PMSR_RESP_ATTR_HOST_TIME])
547 printf(" @%llu",
548 (unsigned long long)nla_get_u64(resp[NL80211_PMSR_RESP_ATTR_HOST_TIME]));
549 if (resp[NL80211_PMSR_RESP_ATTR_AP_TSF])
550 printf(" tsf=%llu",
551 (unsigned long long)nla_get_u64(resp[NL80211_PMSR_RESP_ATTR_AP_TSF]));
552 if (resp[NL80211_PMSR_RESP_ATTR_FINAL])
553 printf(" (final)");
554
555 if (!resp[NL80211_PMSR_RESP_ATTR_DATA]) {
556 printf(" - no data!\n");
557 return;
558 }
559
560 printf("\n");
561
562 nla_parse_nested(data, NL80211_PMSR_TYPE_MAX,
563 resp[NL80211_PMSR_RESP_ATTR_DATA], NULL);
564
565 if (data[NL80211_PMSR_TYPE_FTM])
566 parse_pmsr_ftm_data(data[NL80211_PMSR_TYPE_FTM]);
567}
568
569static void parse_pmsr_result(struct nlattr **tb,
570 struct print_event_args *pargs)
571{
572 struct nlattr *pmsr[NL80211_PMSR_ATTR_MAX + 1];
573 struct nlattr *peer;
574 unsigned long long cookie;
575 int err, i;
576
577 if (!tb[NL80211_ATTR_COOKIE]) {
578 printf("Peer measurements: no cookie!\n");
579 return;
580 }
581 cookie = nla_get_u64(tb[NL80211_ATTR_COOKIE]);
582
583 if (!tb[NL80211_ATTR_PEER_MEASUREMENTS]) {
584 printf("Peer measurements: no measurement data!\n");
585 return;
586 }
587
588 err = nla_parse_nested(pmsr, NL80211_PMSR_ATTR_MAX,
589 tb[NL80211_ATTR_PEER_MEASUREMENTS], NULL);
590 if (err) {
591 printf("Peer measurements: failed to parse measurement data!\n");
592 return;
593 }
594
595 if (!pmsr[NL80211_PMSR_ATTR_PEERS]) {
596 printf("Peer measurements: no peer data!\n");
597 return;
598 }
599
600 printf("Peer measurements (cookie %llu):\n", cookie);
601
602 nla_for_each_nested(peer, pmsr[NL80211_PMSR_ATTR_PEERS], i)
603 parse_pmsr_peer(peer);
604}
605
7c4e86ca
RZ		 606static void parse_nan_match(struct nlattr **attrs)
607{
608 char macbuf[6*3];
609 __u64 cookie;
610 struct nlattr *match[NL80211_NAN_MATCH_ATTR_MAX + 1];
611 struct nlattr *local_func[NL80211_NAN_FUNC_ATTR_MAX + 1];
612 struct nlattr *peer_func[NL80211_NAN_FUNC_ATTR_MAX + 1];
613
614 static struct nla_policy
615 nan_match_policy[NL80211_NAN_MATCH_ATTR_MAX + 1] = {
616 [NL80211_NAN_MATCH_FUNC_LOCAL] = { .type = NLA_NESTED },
617 [NL80211_NAN_MATCH_FUNC_PEER] = { .type = NLA_NESTED },
618 };
619
620 static struct nla_policy
621 nan_func_policy[NL80211_NAN_FUNC_ATTR_MAX + 1] = {
622 [NL80211_NAN_FUNC_TYPE] = { .type = NLA_U8 },
623 [NL80211_NAN_FUNC_SERVICE_ID] = { },
624 [NL80211_NAN_FUNC_PUBLISH_TYPE] = { .type = NLA_U8 },
625 [NL80211_NAN_FUNC_PUBLISH_BCAST] = { .type = NLA_FLAG },
626 [NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE] = { .type = NLA_FLAG },
627 [NL80211_NAN_FUNC_FOLLOW_UP_ID] = { .type = NLA_U8 },
628 [NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] = { .type = NLA_U8 },
629 [NL80211_NAN_FUNC_FOLLOW_UP_DEST] = { },
630 [NL80211_NAN_FUNC_CLOSE_RANGE] = { .type = NLA_FLAG },
631 [NL80211_NAN_FUNC_TTL] = { .type = NLA_U32 },
632 [NL80211_NAN_FUNC_SERVICE_INFO] = { },
633 [NL80211_NAN_FUNC_SRF] = { .type = NLA_NESTED },
634 [NL80211_NAN_FUNC_RX_MATCH_FILTER] = { .type = NLA_NESTED },
635 [NL80211_NAN_FUNC_TX_MATCH_FILTER] = { .type = NLA_NESTED },
636 [NL80211_NAN_FUNC_INSTANCE_ID] = { .type = NLA_U8},
637 };
638
639 cookie = nla_get_u64(attrs[NL80211_ATTR_COOKIE]);
640 mac_addr_n2a(macbuf, nla_data(attrs[NL80211_ATTR_MAC]));
641
642 if (nla_parse_nested(match, NL80211_NAN_MATCH_ATTR_MAX,
643 attrs[NL80211_ATTR_NAN_MATCH],
644 nan_match_policy)) {
645 printf("NAN: failed to parse nan match event\n");
646 return;
647 }
648
649 if (nla_parse_nested(local_func, NL80211_NAN_FUNC_ATTR_MAX,
650 match[NL80211_NAN_MATCH_FUNC_LOCAL],
651 nan_func_policy)) {
652 printf("NAN: failed to parse nan local func\n");
653 return;
654 }
655
656 if (nla_parse_nested(peer_func, NL80211_NAN_FUNC_ATTR_MAX,
657 match[NL80211_NAN_MATCH_FUNC_PEER],
658 nan_func_policy)) {
659 printf("NAN: failed to parse nan local func\n");
660 return;
661 }
662
663 if (nla_get_u8(peer_func[NL80211_NAN_FUNC_TYPE]) ==
664 NL80211_NAN_FUNC_PUBLISH) {
665 printf(
adfc1022 666 "NAN(cookie=0x%llx): DiscoveryResult, peer_id=%d, local_id=%d, peer_mac=%s",
7c4e86ca
RZ		 667 cookie,
668 nla_get_u8(peer_func[NL80211_NAN_FUNC_INSTANCE_ID]),
669 nla_get_u8(local_func[NL80211_NAN_FUNC_INSTANCE_ID]),
670 macbuf);
671 if (peer_func[NL80211_NAN_FUNC_SERVICE_INFO])
adfc1022 672 printf(", info=%.*s",
7c4e86ca
RZ		 673 nla_len(peer_func[NL80211_NAN_FUNC_SERVICE_INFO]),
674 (char *)nla_data(peer_func[NL80211_NAN_FUNC_SERVICE_INFO]));
675 } else if (nla_get_u8(peer_func[NL80211_NAN_FUNC_TYPE]) ==
676 NL80211_NAN_FUNC_SUBSCRIBE) {
677 printf(
adfc1022 678 "NAN(cookie=0x%llx): Replied, peer_id=%d, local_id=%d, peer_mac=%s",
7c4e86ca
RZ		 679 cookie,
680 nla_get_u8(peer_func[NL80211_NAN_FUNC_INSTANCE_ID]),
681 nla_get_u8(local_func[NL80211_NAN_FUNC_INSTANCE_ID]),
682 macbuf);
683 } else if (nla_get_u8(peer_func[NL80211_NAN_FUNC_TYPE]) ==
684 NL80211_NAN_FUNC_FOLLOW_UP) {
685 printf(
adfc1022 686 "NAN(cookie=0x%llx): FollowUpReceive, peer_id=%d, local_id=%d, peer_mac=%s",
7c4e86ca
RZ		 687 cookie,
688 nla_get_u8(peer_func[NL80211_NAN_FUNC_INSTANCE_ID]),
689 nla_get_u8(local_func[NL80211_NAN_FUNC_INSTANCE_ID]),
690 macbuf);
691 if (peer_func[NL80211_NAN_FUNC_SERVICE_INFO])
adfc1022 692 printf(", info=%.*s",
7c4e86ca
RZ		 693 nla_len(peer_func[NL80211_NAN_FUNC_SERVICE_INFO]),
694 (char *)nla_data(peer_func[NL80211_NAN_FUNC_SERVICE_INFO]));
695 } else {
adfc1022 696 printf("NaN: Malformed event");
7c4e86ca 697 }
adfc1022
AO		 698
699 printf("\n");
7c4e86ca
RZ		 700}
701
d98f794f
MT		 702static void parse_new_peer_candidate(struct nlattr **attrs)
703{
704 char macbuf[ETH_ALEN * 3];
705 int32_t sig_dbm;
706
707 printf("new peer candidate");
708 if (attrs[NL80211_ATTR_MAC]) {
709 mac_addr_n2a(macbuf, nla_data(attrs[NL80211_ATTR_MAC]));
710 printf(" %s", macbuf);
711 }
712 if (attrs[NL80211_ATTR_RX_SIGNAL_DBM]) {
713 sig_dbm = nla_get_u32(attrs[NL80211_ATTR_RX_SIGNAL_DBM]);
714 printf(" %d dBm", sig_dbm);
715 }
716
717 printf("\n");
718}
719
51bfd5a0 720static void parse_recv_interface(struct nlattr **attrs, int command)
7d17ba94 721{
51bfd5a0
MT		 722 switch (command) {
723 case NL80211_CMD_NEW_INTERFACE:
724 printf("new interface");
725 break;
726 case NL80211_CMD_DEL_INTERFACE:
727 printf("del interface");
728 break;
729 case NL80211_CMD_SET_INTERFACE:
730 printf("set interface");
731 break;
732 default:
733 printf("unknown interface command (%i) received\n", command);
734 return;
735 }
7d17ba94
MT		 736
737 if (attrs[NL80211_ATTR_IFTYPE]) {
738 printf(" type ");
739 switch (nla_get_u32(attrs[NL80211_ATTR_IFTYPE])) {
740 case NL80211_IFTYPE_STATION:
741 printf("station");
742 break;
743 case NL80211_IFTYPE_AP:
744 printf("access point");
745 break;
746 case NL80211_IFTYPE_MESH_POINT:
747 printf("mesh point");
748 break;
749 case NL80211_IFTYPE_ADHOC:
750 printf("IBSS");
751 break;
752 case NL80211_IFTYPE_MONITOR:
753 printf("monitor");
754 break;
755 case NL80211_IFTYPE_AP_VLAN:
756 printf("AP-VLAN");
757 break;
758 case NL80211_IFTYPE_WDS:
759 printf("WDS");
760 break;
761 case NL80211_IFTYPE_P2P_CLIENT:
762 printf("P2P-client");
763 break;
764 case NL80211_IFTYPE_P2P_GO:
765 printf("P2P-GO");
766 break;
767 case NL80211_IFTYPE_P2P_DEVICE:
768 printf("P2P-Device");
769 break;
770 case NL80211_IFTYPE_OCB:
771 printf("OCB");
772 break;
773 case NL80211_IFTYPE_NAN:
774 printf("NAN");
775 break;
776 default:
777 printf("unknown (%d)",
778 nla_get_u32(attrs[NL80211_ATTR_IFTYPE]));
779 break;
780 }
781 }
782
783 if (attrs[NL80211_ATTR_MESH_ID]) {
784 printf(" meshid ");
785 print_ssid_escaped(nla_len(attrs[NL80211_ATTR_MESH_ID]),
786 nla_data(attrs[NL80211_ATTR_MESH_ID]));
787 }
788
789 if (attrs[NL80211_ATTR_4ADDR]) {
790 printf(" use 4addr %d", nla_get_u8(attrs[NL80211_ATTR_4ADDR]));
791 }
792
793 printf("\n");
794}
795
47650ff8
MT		 796static void parse_sta_opmode_changed(struct nlattr **attrs)
797{
798 char macbuf[ETH_ALEN*3];
799
800 printf("sta opmode changed");
801
802 if (attrs[NL80211_ATTR_MAC]) {
803 mac_addr_n2a(macbuf, nla_data(attrs[NL80211_ATTR_MAC]));
804 printf(" %s", macbuf);
805 }
806
807 if (attrs[NL80211_ATTR_SMPS_MODE])
808 printf(" smps mode %d", nla_get_u8(attrs[NL80211_ATTR_SMPS_MODE]));
809
810 if (attrs[NL80211_ATTR_CHANNEL_WIDTH])
811 printf(" chan width %d", nla_get_u8(attrs[NL80211_ATTR_CHANNEL_WIDTH]));
812
813 if (attrs[NL80211_ATTR_NSS])
814 printf(" nss %d", nla_get_u8(attrs[NL80211_ATTR_NSS]));
815
816 printf("\n");
817}
818
bb391d28
MT		 819static void parse_ch_switch_notify(struct nlattr **attrs, int command)
820{
821 switch (command) {
822 case NL80211_CMD_CH_SWITCH_STARTED_NOTIFY:
823 printf("channel switch started");
824 break;
825 case NL80211_CMD_CH_SWITCH_NOTIFY:
826 printf("channel switch");
827 break;
828 default:
829 printf("unknown channel switch command (%i) received\n", command);
830 return;
831 }
832
833 if (attrs[NL80211_ATTR_CH_SWITCH_COUNT])
834 printf(" (count=%d)", nla_get_u32(attrs[NL80211_ATTR_CH_SWITCH_COUNT]));
835
836 if (attrs[NL80211_ATTR_WIPHY_FREQ])
837 printf(" freq=%d", nla_get_u32(attrs[NL80211_ATTR_WIPHY_FREQ]));
838
839 if (attrs[NL80211_ATTR_CHANNEL_WIDTH]) {
840 printf(" width=");
841 switch(nla_get_u32(attrs[NL80211_ATTR_CHANNEL_WIDTH])) {
842 case NL80211_CHAN_WIDTH_20_NOHT:
843 case NL80211_CHAN_WIDTH_20:
844 printf("\"20 MHz\"");
845 break;
846 case NL80211_CHAN_WIDTH_40:
847 printf("\"40 MHz\"");
848 break;
849 case NL80211_CHAN_WIDTH_80:
850 printf("\"80 MHz\"");
851 break;
852 case NL80211_CHAN_WIDTH_80P80:
853 printf("\"80+80 MHz\"");
854 break;
855 case NL80211_CHAN_WIDTH_160:
856 printf("\"160 MHz\"");
857 break;
858 case NL80211_CHAN_WIDTH_5:
859 printf("\"5 MHz\"");
860 break;
861 case NL80211_CHAN_WIDTH_10:
862 printf("\"10 MHz\"");
863 break;
864 default:
865 printf("\"unknown\"");
866 }
867 }
868
869 if (attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
870 printf(" type=");
871 switch(nla_get_u32(attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE])) {
872 case NL80211_CHAN_NO_HT:
873 printf("\"No HT\"");
874 break;
875 case NL80211_CHAN_HT20:
876 printf("\"HT20\"");
877 break;
878 case NL80211_CHAN_HT40MINUS:
879 printf("\"HT40-\"");
880 break;
881 case NL80211_CHAN_HT40PLUS:
882 printf("\"HT40+\"");
883 break;
884 }
885 }
886
887 if (attrs[NL80211_ATTR_CENTER_FREQ1])
888 printf(" freq1=%d", nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ1]));
889
890 if (attrs[NL80211_ATTR_CENTER_FREQ2])
891 printf(" freq2=%d", nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ2]));
892
893 printf("\n");
894}
895
957a0f07
JB		 896static int print_event(struct nl_msg *msg, void *arg)
897{
898 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
748f8489 899 struct nlattr *tb[NL80211_ATTR_MAX + 1], *nst;
957a0f07
JB		 900 struct print_event_args *args = arg;
901 char ifname[100];
902 char macbuf[6*3];
903 __u8 reg_type;
0168589d
LR		 904 struct ieee80211_beacon_channel chan_before_beacon, chan_after_beacon;
905 __u32 wiphy_idx = 0;
748f8489 906 int rem_nst;
f1a666a6 907 __u16 status;
957a0f07 908
c3df363e 909 if (args->time || args->reltime || args->ctime) {
981b21ad
JB		 910 unsigned long long usecs, previous;
911
912 previous = 1000000ULL * args->ts.tv_sec + args->ts.tv_usec;
913 gettimeofday(&args->ts, NULL);
914 usecs = 1000000ULL * args->ts.tv_sec + args->ts.tv_usec;
c3df363e 915
981b21ad
JB		 916 if (args->reltime) {
917 if (!args->have_ts) {
918 usecs = 0;
919 args->have_ts = true;
920 } else
921 usecs -= previous;
922 }
c3df363e
MT		 923
924 if (args->ctime) {
925 struct tm *tm = localtime(&args->ts.tv_sec);
926 char buf[255];
927
928 memset(buf, 0, 255);
929 strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", tm);
930 printf("[%s.%06lu]: ", buf, args->ts.tv_usec);
931 } else {
932 printf("%llu.%06llu: ", usecs/1000000, usecs % 1000000);
933 }
957a0f07
JB		 934 }
935
936 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
937 genlmsg_attrlen(gnlh, 0), NULL);
938
939 if (tb[NL80211_ATTR_IFINDEX] && tb[NL80211_ATTR_WIPHY]) {
51bfd5a0 940 /* if_indextoname may fails on delete interface/wiphy event */
88f9e988 941 if (if_indextoname(nla_get_u32(tb[NL80211_ATTR_IFINDEX]), ifname))
51bfd5a0
MT		 942 printf("%s (phy #%d): ", ifname, nla_get_u32(tb[NL80211_ATTR_WIPHY]));
943 else
944 printf("phy #%d: ", nla_get_u32(tb[NL80211_ATTR_WIPHY]));
d8880179
JB		 945 } else if (tb[NL80211_ATTR_WDEV] && tb[NL80211_ATTR_WIPHY]) {
946 printf("wdev 0x%llx (phy #%d): ",
947 (unsigned long long)nla_get_u64(tb[NL80211_ATTR_WDEV]),
948 nla_get_u32(tb[NL80211_ATTR_WIPHY]));
957a0f07
JB		 949 } else if (tb[NL80211_ATTR_IFINDEX]) {
950 if_indextoname(nla_get_u32(tb[NL80211_ATTR_IFINDEX]), ifname);
951 printf("%s: ", ifname);
d8880179
JB		 952 } else if (tb[NL80211_ATTR_WDEV]) {
953 printf("wdev 0x%llx: ", (unsigned long long)nla_get_u64(tb[NL80211_ATTR_WDEV]));
957a0f07
JB		 954 } else if (tb[NL80211_ATTR_WIPHY]) {
955 printf("phy #%d: ", nla_get_u32(tb[NL80211_ATTR_WIPHY]));
956 }
957
958 switch (gnlh->cmd) {
959 case NL80211_CMD_NEW_WIPHY:
960 printf("renamed to %s\n", nla_get_string(tb[NL80211_ATTR_WIPHY_NAME]));
961 break;
e67be815
JB		 962 case NL80211_CMD_TRIGGER_SCAN:
963 printf("scan started\n");
964 break;
957a0f07 965 case NL80211_CMD_NEW_SCAN_RESULTS:
748f8489 966 printf("scan finished:");
6ab936f0 967 /* fall through */
957a0f07 968 case NL80211_CMD_SCAN_ABORTED:
748f8489
JB		 969 if (gnlh->cmd == NL80211_CMD_SCAN_ABORTED)
970 printf("scan aborted:");
971 if (tb[NL80211_ATTR_SCAN_FREQUENCIES]) {
972 nla_for_each_nested(nst, tb[NL80211_ATTR_SCAN_FREQUENCIES], rem_nst)
973 printf(" %d", nla_get_u32(nst));
974 printf(",");
975 }
976 if (tb[NL80211_ATTR_SCAN_SSIDS]) {
977 nla_for_each_nested(nst, tb[NL80211_ATTR_SCAN_SSIDS], rem_nst) {
978 printf(" \"");
979 print_ssid_escaped(nla_len(nst), nla_data(nst));
980 printf("\"");
981 }
982 }
983 printf("\n");
957a0f07 984 break;
3fce58aa
LC		 985 case NL80211_CMD_START_SCHED_SCAN:
986 printf("scheduled scan started\n");
987 break;
988 case NL80211_CMD_SCHED_SCAN_STOPPED:
989 printf("sched scan stopped\n");
990 break;
991 case NL80211_CMD_SCHED_SCAN_RESULTS:
992 printf("got scheduled scan results\n");
993 break;
02503184 994 case NL80211_CMD_WIPHY_REG_CHANGE:
957a0f07 995 case NL80211_CMD_REG_CHANGE:
88f9e988 996 if (gnlh->cmd == NL80211_CMD_WIPHY_REG_CHANGE)
02503184
MT		 997 printf("regulatory domain change (phy): ");
998 else
999 printf("regulatory domain change: ");
957a0f07
JB		 1000
1001 reg_type = nla_get_u8(tb[NL80211_ATTR_REG_TYPE]);
1002
1003 switch (reg_type) {
1004 case NL80211_REGDOM_TYPE_COUNTRY:
1005 printf("set to %s by %s request",
1006 nla_get_string(tb[NL80211_ATTR_REG_ALPHA2]),
1007 reg_initiator_to_string(nla_get_u8(tb[NL80211_ATTR_REG_INITIATOR])));
1008 if (tb[NL80211_ATTR_WIPHY])
1009 printf(" on phy%d", nla_get_u32(tb[NL80211_ATTR_WIPHY]));
1010 break;
1011 case NL80211_REGDOM_TYPE_WORLD:
1012 printf("set to world roaming by %s request",
1013 reg_initiator_to_string(nla_get_u8(tb[NL80211_ATTR_REG_INITIATOR])));
1014 break;
1015 case NL80211_REGDOM_TYPE_CUSTOM_WORLD:
1016 printf("custom world roaming rules in place on phy%d by %s request",
1017 nla_get_u32(tb[NL80211_ATTR_WIPHY]),
1018 reg_initiator_to_string(nla_get_u32(tb[NL80211_ATTR_REG_INITIATOR])));
1019 break;
1020 case NL80211_REGDOM_TYPE_INTERSECTION:
1021 printf("intersection used due to a request made by %s",
1022 reg_initiator_to_string(nla_get_u32(tb[NL80211_ATTR_REG_INITIATOR])));
1023 if (tb[NL80211_ATTR_WIPHY])
1024 printf(" on phy%d", nla_get_u32(tb[NL80211_ATTR_WIPHY]));
1025 break;
1026 default:
1027 printf("unknown source (upgrade this utility)");
1028 break;
1029 }
1030
1031 printf("\n");
0168589d
LR		 1032 break;
1033 case NL80211_CMD_REG_BEACON_HINT:
1034
1035 wiphy_idx = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
1036
1037 memset(&chan_before_beacon, 0, sizeof(chan_before_beacon));
1038 memset(&chan_after_beacon, 0, sizeof(chan_after_beacon));
1039
ce3b2ed9
JB		 1040 if (parse_beacon_hint_chan(tb[NL80211_ATTR_FREQ_BEFORE],
1041 &chan_before_beacon))
1042 break;
1043 if (parse_beacon_hint_chan(tb[NL80211_ATTR_FREQ_AFTER],
1044 &chan_after_beacon))
1045 break;
0168589d
LR		 1046
1047 if (chan_before_beacon.center_freq != chan_after_beacon.center_freq)
1048 break;
1049
1050 /* A beacon hint is sent _only_ if something _did_ change */
1051 printf("beacon hint:\n");
1052
1053 printf("phy%d %d MHz [%d]:\n",
1054 wiphy_idx,
1055 chan_before_beacon.center_freq,
1056 ieee80211_frequency_to_channel(chan_before_beacon.center_freq));
1057
f0c48e7b
IP		 1058 if (chan_before_beacon.no_ir && !chan_after_beacon.no_ir) {
1059 if (chan_before_beacon.no_ibss && !chan_after_beacon.no_ibss)
1060 printf("\to Initiating radiation enabled\n");
1061 else
1062 printf("\to active scan enabled\n");
1063 } else if (chan_before_beacon.no_ibss && !chan_after_beacon.no_ibss) {
1064 printf("\to ibss enabled\n");
1065 }
0168589d 1066
cec6d6a7
JB		 1067 break;
1068 case NL80211_CMD_NEW_STATION:
1069 mac_addr_n2a(macbuf, nla_data(tb[NL80211_ATTR_MAC]));
1070 printf("new station %s\n", macbuf);
957a0f07 1071 break;
27bf109b
AQ		 1072 case NL80211_CMD_DEL_STATION:
1073 mac_addr_n2a(macbuf, nla_data(tb[NL80211_ATTR_MAC]));
1074 printf("del station %s\n", macbuf);
1075 break;
957a0f07
JB		 1076 case NL80211_CMD_JOIN_IBSS:
1077 mac_addr_n2a(macbuf, nla_data(tb[NL80211_ATTR_MAC]));
1078 printf("IBSS %s joined\n", macbuf);
1079 break;
1080 case NL80211_CMD_AUTHENTICATE:
1081 printf("auth");
aea5dbd2
JB		 1082 if (tb[NL80211_ATTR_FRAME])
1083 print_frame(args, tb[NL80211_ATTR_FRAME]);
1084 else if (tb[NL80211_ATTR_TIMED_OUT])
1085 printf(": timed out");
1086 else
1087 printf(": unknown event");
957a0f07
JB		 1088 printf("\n");
1089 break;
1090 case NL80211_CMD_ASSOCIATE:
1091 printf("assoc");
aea5dbd2
JB		 1092 if (tb[NL80211_ATTR_FRAME])
1093 print_frame(args, tb[NL80211_ATTR_FRAME]);
1094 else if (tb[NL80211_ATTR_TIMED_OUT])
1095 printf(": timed out");
1096 else
1097 printf(": unknown event");
957a0f07
JB		 1098 printf("\n");
1099 break;
1100 case NL80211_CMD_DEAUTHENTICATE:
1101 printf("deauth");
1102 print_frame(args, tb[NL80211_ATTR_FRAME]);
1103 printf("\n");
1104 break;
1105 case NL80211_CMD_DISASSOCIATE:
1106 printf("disassoc");
1107 print_frame(args, tb[NL80211_ATTR_FRAME]);
1108 printf("\n");
1109 break;
99802e56
JB		 1110 case NL80211_CMD_UNPROT_DEAUTHENTICATE:
1111 printf("unprotected deauth");
1112 print_frame(args, tb[NL80211_ATTR_FRAME]);
1113 printf("\n");
1114 break;
1115 case NL80211_CMD_UNPROT_DISASSOCIATE:
1116 printf("unprotected disassoc");
1117 print_frame(args, tb[NL80211_ATTR_FRAME]);
1118 printf("\n");
1119 break;
f1a666a6
JB		 1120 case NL80211_CMD_CONNECT:
1121 status = 0;
27ea56b6
JB		 1122 if (tb[NL80211_ATTR_TIMED_OUT])
1123 printf("timed out");
1124 else if (!tb[NL80211_ATTR_STATUS_CODE])
f1a666a6
JB		 1125 printf("unknown connect status");
1126 else if (nla_get_u16(tb[NL80211_ATTR_STATUS_CODE]) == 0)
1127 printf("connected");
1128 else {
1129 status = nla_get_u16(tb[NL80211_ATTR_STATUS_CODE]);
1130 printf("failed to connect");
1131 }
1132 if (tb[NL80211_ATTR_MAC]) {
1133 mac_addr_n2a(macbuf, nla_data(tb[NL80211_ATTR_MAC]));
1134 printf(" to %s", macbuf);
1135 }
1136 if (status)
1137 printf(", status: %d: %s", status, get_status_str(status));
1138 printf("\n");
1139 break;
1140 case NL80211_CMD_ROAM:
1141 printf("roamed");
1142 if (tb[NL80211_ATTR_MAC]) {
1143 mac_addr_n2a(macbuf, nla_data(tb[NL80211_ATTR_MAC]));
1144 printf(" to %s", macbuf);
1145 }
1146 printf("\n");
1147 break;
1148 case NL80211_CMD_DISCONNECT:
1149 printf("disconnected");
1150 if (tb[NL80211_ATTR_DISCONNECTED_BY_AP])
1151 printf(" (by AP)");
1152 else
1153 printf(" (local request)");
1154 if (tb[NL80211_ATTR_REASON_CODE])
1155 printf(" reason: %d: %s", nla_get_u16(tb[NL80211_ATTR_REASON_CODE]),
1156 get_reason_str(nla_get_u16(tb[NL80211_ATTR_REASON_CODE])));
1157 printf("\n");
1158 break;
6829308d
JB		 1159 case NL80211_CMD_REMAIN_ON_CHANNEL:
1160 printf("remain on freq %d (%dms, cookie %llx)\n",
1161 nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]),
1162 nla_get_u32(tb[NL80211_ATTR_DURATION]),
1163 (unsigned long long)nla_get_u64(tb[NL80211_ATTR_COOKIE]));
1164 break;
1165 case NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL:
1166 printf("done with remain on freq %d (cookie %llx)\n",
1167 nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]),
1168 (unsigned long long)nla_get_u64(tb[NL80211_ATTR_COOKIE]));
1169 break;
ce87a25d
MT		 1170 case NL80211_CMD_FRAME_WAIT_CANCEL:
1171 printf("frame wait cancel on freq %d (cookie %llx)\n",
1172 nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]),
1173 (unsigned long long)nla_get_u64(tb[NL80211_ATTR_COOKIE]));
1174 break;
7988b229 1175 case NL80211_CMD_NOTIFY_CQM:
f19444fe 1176 parse_cqm_event(tb);
7988b229 1177 break;
8612433d
JM		 1178 case NL80211_CMD_MICHAEL_MIC_FAILURE:
1179 parse_mic_failure(tb);
1180 break;
cbff7089
JB		 1181 case NL80211_CMD_FRAME_TX_STATUS:
1182 printf("mgmt TX status (cookie %llx): %s\n",
1183 (unsigned long long)nla_get_u64(tb[NL80211_ATTR_COOKIE]),
1184 tb[NL80211_ATTR_ACK] ? "acked" : "no ack");
1185 break;
cd64525e
MT		 1186 case NL80211_CMD_CONTROL_PORT_FRAME_TX_STATUS:
1187 printf("ctrl. port TX status (cookie %llx): %s\n",
1188 (unsigned long long)nla_get_u64(tb[NL80211_ATTR_COOKIE]),
1189 tb[NL80211_ATTR_ACK] ? "acked" : "no ack");
1190 break;
0bf2c6a0 1191 case NL80211_CMD_PMKSA_CANDIDATE:
b6688cb8
JB		 1192 printf("PMKSA candidate found\n");
1193 break;
819b78cc
JB		 1194 case NL80211_CMD_SET_WOWLAN:
1195 parse_wowlan_wake_event(tb);
1196 break;
4310994d
BG		 1197 case NL80211_CMD_PROBE_CLIENT:
1198 if (tb[NL80211_ATTR_MAC])
1199 mac_addr_n2a(macbuf, nla_data(tb[NL80211_ATTR_MAC]));
1200 else
1201 strcpy(macbuf, "??");
1202 printf("probe client %s (cookie %llx): %s\n",
1203 macbuf,
1204 (unsigned long long)nla_get_u64(tb[NL80211_ATTR_COOKIE]),
1205 tb[NL80211_ATTR_ACK] ? "acked" : "no ack");
1206 break;
e8b3b312 1207 case NL80211_CMD_VENDOR:
8e58fe92 1208 parse_vendor_event(tb, args->frame);
e8b3b312 1209 break;
03fb59d0
BB		 1210 case NL80211_CMD_RADAR_DETECT: {
1211 enum nl80211_radar_event event_type;
1212 uint32_t freq;
1213
1214 if (!tb[NL80211_ATTR_RADAR_EVENT] ||
1215 !tb[NL80211_ATTR_WIPHY_FREQ]) {
1216 printf("BAD radar event\n");
1217 break;
1218 }
1219
1220 freq = nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]);
1221 event_type = nla_get_u32(tb[NL80211_ATTR_RADAR_EVENT]);
1222
1223 switch (event_type) {
1224 case NL80211_RADAR_DETECTED:
1225 printf("%d MHz: radar detected\n", freq);
1226 break;
1227 case NL80211_RADAR_CAC_FINISHED:
1228 printf("%d MHz: CAC finished\n", freq);
1229 break;
1230 case NL80211_RADAR_CAC_ABORTED:
1231 printf("%d MHz: CAC was aborted\n", freq);
1232 break;
1233 case NL80211_RADAR_NOP_FINISHED:
1234 printf("%d MHz: NOP finished\n", freq);
1235 break;
1236 default:
1237 printf("%d MHz: unknown radar event\n", freq);
1238 }
085f4f08 1239 }
085f4f08 1240 break;
a3ca7c69
BG		 1241 case NL80211_CMD_DEL_WIPHY:
1242 printf("delete wiphy\n");
1243 break;
8ddb960e
JB		 1244 case NL80211_CMD_PEER_MEASUREMENT_RESULT:
1245 parse_pmsr_result(tb, args);
1246 break;
1247 case NL80211_CMD_PEER_MEASUREMENT_COMPLETE:
1248 printf("peer measurement complete\n");
1249 break;
7c4e86ca
RZ		 1250 case NL80211_CMD_DEL_NAN_FUNCTION:
1251 parse_nan_term(tb);
1252 break;
68257d0f 1253 case NL80211_CMD_NAN_MATCH:
7c4e86ca
RZ		 1254 parse_nan_match(tb);
1255 break;
d98f794f
MT		 1256 case NL80211_CMD_NEW_PEER_CANDIDATE:
1257 parse_new_peer_candidate(tb);
1258 break;
51bfd5a0 1259 case NL80211_CMD_NEW_INTERFACE:
7d17ba94 1260 case NL80211_CMD_SET_INTERFACE:
51bfd5a0
MT		 1261 case NL80211_CMD_DEL_INTERFACE:
1262 parse_recv_interface(tb, gnlh->cmd);
7d17ba94 1263 break;
47650ff8
MT		 1264 case NL80211_CMD_STA_OPMODE_CHANGED:
1265 parse_sta_opmode_changed(tb);
1266 break;
ce87a25d
MT		 1267 case NL80211_CMD_STOP_AP:
1268 printf("stop ap\n");
1269 break;
bb391d28
MT		 1270 case NL80211_CMD_CH_SWITCH_STARTED_NOTIFY:
1271 case NL80211_CMD_CH_SWITCH_NOTIFY:
1272 parse_ch_switch_notify(tb, gnlh->cmd);
1273 break;
957a0f07 1274 default:
7c712c89
JB		 1275 printf("unknown event %d (%s)\n",
1276 gnlh->cmd, command_name(gnlh->cmd));
957a0f07
JB		 1277 break;
1278 }
1279
374e8a26 1280 fflush(stdout);
957a0f07
JB		 1281 return NL_SKIP;
1282}
1283
1284struct wait_event {
2e192cea 1285 int n_cmds, n_prints;
957a0f07 1286 const __u32 *cmds;
2e192cea 1287 const __u32 *prints;
957a0f07 1288 __u32 cmd;
7fabd346 1289 struct print_event_args *pargs;
957a0f07
JB		 1290};
1291
1292static int wait_event(struct nl_msg *msg, void *arg)
1293{
1294 struct wait_event *wait = arg;
1295 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
1296 int i;
1297
2e192cea
JB		 1298 if (wait->pargs) {
1299 for (i = 0; i < wait->n_prints; i++) {
1300 if (gnlh->cmd == wait->prints[i])
7e7c544f 1301 print_event(msg, wait->pargs);
957a0f07
JB		 1302 }
1303 }
1304
2e192cea
JB		 1305 for (i = 0; i < wait->n_cmds; i++) {
1306 if (gnlh->cmd == wait->cmds[i])
1307 wait->cmd = gnlh->cmd;
1308 }
1309
957a0f07
JB		 1310 return NL_SKIP;
1311}
1312
ee374e4d 1313int __prepare_listen_events(struct nl80211_state *state)
957a0f07
JB		 1314{
1315 int mcid, ret;
957a0f07
JB		 1316
1317 /* Configuration multicast group */
1318 mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "config");
1319 if (mcid < 0)
1320 return mcid;
1321
1322 ret = nl_socket_add_membership(state->nl_sock, mcid);
1323 if (ret)
1324 return ret;
1325
1326 /* Scan multicast group */
1327 mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "scan");
1328 if (mcid >= 0) {
1329 ret = nl_socket_add_membership(state->nl_sock, mcid);
1330 if (ret)
1331 return ret;
1332 }
1333
1334 /* Regulatory multicast group */
1335 mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "regulatory");
1336 if (mcid >= 0) {
1337 ret = nl_socket_add_membership(state->nl_sock, mcid);
1338 if (ret)
1339 return ret;
1340 }
1341
1342 /* MLME multicast group */
1343 mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "mlme");
1344 if (mcid >= 0) {
1345 ret = nl_socket_add_membership(state->nl_sock, mcid);
1346 if (ret)
1347 return ret;
1348 }
1349
e8b3b312
JB		 1350 mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "vendor");
1351 if (mcid >= 0) {
1352 ret = nl_socket_add_membership(state->nl_sock, mcid);
1353 if (ret)
1354 return ret;
1355 }
1356
7c4e86ca
RZ		 1357 mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "nan");
1358 if (mcid >= 0) {
1359 ret = nl_socket_add_membership(state->nl_sock, mcid);
1360 if (ret)
1361 return ret;
1362 }
1363
105aed57
JB		 1364 return 0;
1365}
1366
ee374e4d
JB		 1367__u32 __do_listen_events(struct nl80211_state *state,
1368 const int n_waits, const __u32 *waits,
2e192cea 1369 const int n_prints, const __u32 *prints,
ee374e4d 1370 struct print_event_args *args)
105aed57
JB		 1371{
1372 struct nl_cb *cb = nl_cb_alloc(iw_debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
1373 struct wait_event wait_ev;
105aed57
JB		 1374
1375 if (!cb) {
1376 fprintf(stderr, "failed to allocate netlink callbacks\n");
1377 return -ENOMEM;
1378 }
1379
957a0f07
JB		 1380 /* no sequence checking for multicast messages */
1381 nl_cb_set(cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, no_seq_check, NULL);
34b23014 1382 nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, valid_handler, NULL);
957a0f07
JB		 1383
1384 if (n_waits && waits) {
1385 wait_ev.cmds = waits;
1386 wait_ev.n_cmds = n_waits;
2e192cea
JB		 1387 wait_ev.prints = prints;
1388 wait_ev.n_prints = n_prints;
7fabd346 1389 wait_ev.pargs = args;
34b23014 1390 register_handler(wait_event, &wait_ev);
7fabd346 1391 } else
34b23014 1392 register_handler(print_event, args);
957a0f07
JB		 1393
1394 wait_ev.cmd = 0;
1395
1396 while (!wait_ev.cmd)
1397 nl_recvmsgs(state->nl_sock, cb);
1398
1399 nl_cb_put(cb);
1400
1401 return wait_ev.cmd;
1402}
1403
1404__u32 listen_events(struct nl80211_state *state,
1405 const int n_waits, const __u32 *waits)
1406{
ee374e4d
JB		 1407 int ret;
1408
1409 ret = __prepare_listen_events(state);
1410 if (ret)
1411 return ret;
1412
2e192cea 1413 return __do_listen_events(state, n_waits, waits, 0, NULL, NULL);
957a0f07
JB		 1414}
1415
1416static int print_events(struct nl80211_state *state,
957a0f07 1417 struct nl_msg *msg,
05514f95
JB		 1418 int argc, char **argv,
1419 enum id_input id)
957a0f07
JB		 1420{
1421 struct print_event_args args;
c3df363e 1422 int num_time_formats = 0;
ee374e4d 1423 int ret;
957a0f07
JB		 1424
1425 memset(&args, 0, sizeof(args));
1426
1427 argc--;
1428 argv++;
1429
1430 while (argc > 0) {
1431 if (strcmp(argv[0], "-f") == 0)
1432 args.frame = true;
c3df363e
MT		 1433 else if (strcmp(argv[0], "-t") == 0) {
1434 num_time_formats++;
957a0f07 1435 args.time = true;
c3df363e
MT		 1436 } else if (strcmp(argv[0], "-T") == 0) {
1437 num_time_formats++;
1438 args.ctime = true;
1439 } else if (strcmp(argv[0], "-r") == 0) {
1440 num_time_formats++;
981b21ad 1441 args.reltime = true;
c3df363e 1442 } else
957a0f07
JB		 1443 return 1;
1444 argc--;
1445 argv++;
1446 }
1447
c3df363e 1448 if (num_time_formats > 1)
981b21ad
JB		 1449 return 1;
1450
957a0f07
JB		 1451 if (argc)
1452 return 1;
1453
ee374e4d
JB		 1454 ret = __prepare_listen_events(state);
1455 if (ret)
1456 return ret;
1457
2e192cea 1458 return __do_listen_events(state, 0, NULL, 0, NULL, &args);
957a0f07 1459}
ef65e9cc 1460TOPLEVEL(event, "[-t|-r] [-f]", 0, 0, CIB_NONE, print_events,
01ae06f9
JB		 1461 "Monitor events from the kernel.\n"
1462 "-t - print timestamp\n"
c3df363e 1463 "-T - print absolute, human-readable timestamp\n"
68dd562b 1464 "-r - print relative timestamp\n"
01ae06f9 1465 "-f - print full frame for auth/assoc etc.");
Mirror git://git.kernel.org/pub/scm/linux/kernel/git/jberg/iw.git