]> 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: nan: fix warning of uninitialized variable
[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>
957a0f07
JB		 6#include "iw.h"
7
8static int no_seq_check(struct nl_msg *msg, void *arg)
9{
10 return NL_OK;
11}
12
0168589d
LR		 13struct ieee80211_beacon_channel {
14 __u16 center_freq;
f0c48e7b 15 bool no_ir;
0168589d
LR		 16 bool no_ibss;
17};
18
19static int parse_beacon_hint_chan(struct nlattr *tb,
20 struct ieee80211_beacon_channel *chan)
21{
22 struct nlattr *tb_freq[NL80211_FREQUENCY_ATTR_MAX + 1];
23 static struct nla_policy beacon_freq_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
24 [NL80211_FREQUENCY_ATTR_FREQ] = { .type = NLA_U32 },
f0c48e7b
IP		 25 [NL80211_FREQUENCY_ATTR_NO_IR] = { .type = NLA_FLAG },
26 [__NL80211_FREQUENCY_ATTR_NO_IBSS] = { .type = NLA_FLAG },
0168589d
LR		 27 };
28
29 if (nla_parse_nested(tb_freq,
30 NL80211_FREQUENCY_ATTR_MAX,
31 tb,
32 beacon_freq_policy))
33 return -EINVAL;
34
35 chan->center_freq = nla_get_u32(tb_freq[NL80211_FREQUENCY_ATTR_FREQ]);
36
f0c48e7b
IP		 37 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_IR])
38 chan->no_ir = true;
39 if (tb_freq[__NL80211_FREQUENCY_ATTR_NO_IBSS])
0168589d
LR		 40 chan->no_ibss = true;
41
42 return 0;
43}
44
957a0f07
JB		 45static void print_frame(struct print_event_args *args, struct nlattr *attr)
46{
47 uint8_t *frame;
48 size_t len;
0ee571d5 49 unsigned int i;
957a0f07
JB		 50 char macbuf[6*3];
51 uint16_t tmp;
52
572e47a3 53 if (!attr) {
957a0f07 54 printf(" [no frame]");
572e47a3
AK		 55 return;
56 }
957a0f07
JB		 57
58 frame = nla_data(attr);
59 len = nla_len(attr);
60
61 if (len < 26) {
62 printf(" [invalid frame: ");
63 goto print_frame;
64 }
65
66 mac_addr_n2a(macbuf, frame + 10);
67 printf(" %s -> ", macbuf);
68 mac_addr_n2a(macbuf, frame + 4);
69 printf("%s", macbuf);
70
71 switch (frame[0] & 0xfc) {
72 case 0x10: /* assoc resp */
73 case 0x30: /* reassoc resp */
74 /* status */
75 tmp = (frame[27] << 8) + frame[26];
76 printf(" status: %d: %s", tmp, get_status_str(tmp));
77 break;
78 case 0x00: /* assoc req */
79 case 0x20: /* reassoc req */
80 break;
81 case 0xb0: /* auth */
82 /* status */
83 tmp = (frame[29] << 8) + frame[28];
84 printf(" status: %d: %s", tmp, get_status_str(tmp));
85 break;
957a0f07
JB		 86 case 0xa0: /* disassoc */
87 case 0xc0: /* deauth */
88 /* reason */
89 tmp = (frame[25] << 8) + frame[24];
90 printf(" reason %d: %s", tmp, get_reason_str(tmp));
91 break;
92 }
93
94 if (!args->frame)
95 return;
96
97 printf(" [frame:");
98
99 print_frame:
100 for (i = 0; i < len; i++)
101 printf(" %.02x", frame[i]);
102 printf("]");
103}
104
f19444fe 105static void parse_cqm_event(struct nlattr **attrs)
7988b229
JO		 106{
107 static struct nla_policy cqm_policy[NL80211_ATTR_CQM_MAX + 1] = {
108 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_U32 },
109 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
110 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
111 };
112 struct nlattr *cqm[NL80211_ATTR_CQM_MAX + 1];
f19444fe 113 struct nlattr *cqm_attr = attrs[NL80211_ATTR_CQM];
7988b229 114
e5497f12 115 printf("CQM event: ");
7988b229 116
f19444fe
JB		 117 if (!cqm_attr ||
118 nla_parse_nested(cqm, NL80211_ATTR_CQM_MAX, cqm_attr, cqm_policy)) {
7988b229
JO		 119 printf("missing data!\n");
120 return;
121 }
122
123 if (cqm[NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT]) {
124 enum nl80211_cqm_rssi_threshold_event rssi_event;
e5497f12
BG		 125 bool found_one = false;
126
7988b229 127 rssi_event = nla_get_u32(cqm[NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT]);
e5497f12
BG		 128
129 switch (rssi_event) {
130 case NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH:
f19444fe 131 printf("RSSI went above threshold\n");
e5497f12
BG		 132 found_one = true;
133 break;
134 case NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW:
f19444fe 135 printf("RSSI went below threshold\n");
e5497f12
BG		 136 found_one = true;
137 break;
138 case NL80211_CQM_RSSI_BEACON_LOSS_EVENT:
139 printf("Beacon loss detected\n");
140 found_one = true;
141 break;
142 }
143
144 if (!found_one)
145 printf("Unknown event type: %i\n", rssi_event);
a3ca7c69
BG		 146 } else if (cqm[NL80211_ATTR_CQM_PKT_LOSS_EVENT]) {
147 if (attrs[NL80211_ATTR_MAC]) {
148 uint32_t frames;
149 char buf[3*6];
150
151 frames = nla_get_u32(cqm[NL80211_ATTR_CQM_PKT_LOSS_EVENT]);
152 mac_addr_n2a(buf, nla_data(attrs[NL80211_ATTR_MAC]));
153 printf("peer %s didn't ACK %d packets\n", buf, frames);
154 } else {
155 printf("PKT-LOSS-EVENT did not have MAC attribute!\n");
156 }
157 } else if (cqm[NL80211_ATTR_CQM_BEACON_LOSS_EVENT]) {
158 printf("beacon loss\n");
159 } else {
f19444fe 160 printf("unknown event\n");
a3ca7c69 161 }
7988b229
JO		 162}
163
8612433d
JM		 164static const char * key_type_str(enum nl80211_key_type key_type)
165{
166 static char buf[30];
167 switch (key_type) {
168 case NL80211_KEYTYPE_GROUP:
169 return "Group";
170 case NL80211_KEYTYPE_PAIRWISE:
171 return "Pairwise";
172 case NL80211_KEYTYPE_PEERKEY:
173 return "PeerKey";
174 default:
175 snprintf(buf, sizeof(buf), "unknown(%d)", key_type);
176 return buf;
177 }
178}
179
180static void parse_mic_failure(struct nlattr **attrs)
181{
182 printf("Michael MIC failure event:");
183
184 if (attrs[NL80211_ATTR_MAC]) {
185 char addr[3 * ETH_ALEN];
186 mac_addr_n2a(addr, nla_data(attrs[NL80211_ATTR_MAC]));
187 printf(" source MAC address %s", addr);
188 }
189
190 if (attrs[NL80211_ATTR_KEY_SEQ] &&
191 nla_len(attrs[NL80211_ATTR_KEY_SEQ]) == 6) {
192 unsigned char *seq = nla_data(attrs[NL80211_ATTR_KEY_SEQ]);
193 printf(" seq=%02x%02x%02x%02x%02x%02x",
194 seq[0], seq[1], seq[2], seq[3], seq[4], seq[5]);
195 }
196 if (attrs[NL80211_ATTR_KEY_TYPE]) {
197 enum nl80211_key_type key_type =
198 nla_get_u32(attrs[NL80211_ATTR_KEY_TYPE]);
199 printf(" Key Type %s", key_type_str(key_type));
200 }
201
202 if (attrs[NL80211_ATTR_KEY_IDX]) {
203 __u8 key_id = nla_get_u8(attrs[NL80211_ATTR_KEY_IDX]);
204 printf(" Key Id %d", key_id);
205 }
206
207 printf("\n");
208}
7988b229 209
819b78cc
JB		 210static void parse_wowlan_wake_event(struct nlattr **attrs)
211{
d516c5bc
LC		 212 struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG],
213 *tb_match[NUM_NL80211_ATTR];
819b78cc
JB		 214
215 printf("WoWLAN wakeup\n");
216 if (!attrs[NL80211_ATTR_WOWLAN_TRIGGERS]) {
217 printf("\twakeup not due to WoWLAN\n");
218 return;
219 }
220
221 nla_parse(tb, MAX_NL80211_WOWLAN_TRIG,
222 nla_data(attrs[NL80211_ATTR_WOWLAN_TRIGGERS]),
223 nla_len(attrs[NL80211_ATTR_WOWLAN_TRIGGERS]), NULL);
224
225 if (tb[NL80211_WOWLAN_TRIG_DISCONNECT])
226 printf("\t* was disconnected\n");
227 if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT])
228 printf("\t* magic packet received\n");
229 if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN])
230 printf("\t* pattern index: %u\n",
231 nla_get_u32(tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]));
232 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE])
233 printf("\t* GTK rekey failure\n");
234 if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST])
235 printf("\t* EAP identity request\n");
236 if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE])
237 printf("\t* 4-way handshake\n");
238 if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE])
239 printf("\t* RF-kill released\n");
d516c5bc
LC		 240 if (tb[NL80211_WOWLAN_TRIG_NET_DETECT_RESULTS]) {
241 struct nlattr *match, *freq;
242 int rem_nst, rem_nst2;
243
244 printf("\t* network detected\n");
245 nla_for_each_nested(match,
246 tb[NL80211_WOWLAN_TRIG_NET_DETECT_RESULTS],
247 rem_nst) {
b7e8163a
DS		 248 nla_parse_nested(tb_match, NL80211_ATTR_MAX, match,
249 NULL);
d516c5bc
LC		 250 printf("\t\tSSID: \"");
251 print_ssid_escaped(nla_len(tb_match[NL80211_ATTR_SSID]),
252 nla_data(tb_match[NL80211_ATTR_SSID]));
253 printf("\"");
254 if (tb_match[NL80211_ATTR_SCAN_FREQUENCIES]) {
255 printf(" freq(s):");
256 nla_for_each_nested(freq,
257 tb_match[NL80211_ATTR_SCAN_FREQUENCIES],
258 rem_nst2)
259 printf(" %d", nla_get_u32(freq));
260 }
261 printf("\n");
262 }
263 }
819b78cc
JB		 264 if (tb[NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211]) {
265 uint8_t *d = nla_data(tb[NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211]);
266 int l = nla_len(tb[NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211]);
267 int i;
268 printf("\t* packet (might be truncated): ");
269 for (i = 0; i < l; i++) {
270 if (i > 0)
271 printf(":");
272 printf("%.2x", d[i]);
273 }
274 printf("\n");
275 }
276 if (tb[NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023]) {
277 uint8_t *d = nla_data(tb[NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023]);
278 int l = nla_len(tb[NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023]);
279 int i;
280 printf("\t* packet (might be truncated): ");
281 for (i = 0; i < l; i++) {
282 if (i > 0)
283 printf(":");
284 printf("%.2x", d[i]);
285 }
286 printf("\n");
287 }
288 if (tb[NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH])
289 printf("\t* TCP connection wakeup received\n");
290 if (tb[NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST])
291 printf("\t* TCP connection lost\n");
292 if (tb[NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS])
293 printf("\t* TCP connection ran out of tokens\n");
294}
295
7c4e86ca
RZ		 296static void parse_nan_term(struct nlattr **attrs)
297{
298 struct nlattr *func[NL80211_NAN_FUNC_ATTR_MAX + 1];
299
300 static struct nla_policy
301 nan_func_policy[NL80211_NAN_FUNC_ATTR_MAX + 1] = {
302 [NL80211_NAN_FUNC_TYPE] = { .type = NLA_U8 },
303 [NL80211_NAN_FUNC_SERVICE_ID] = { },
304 [NL80211_NAN_FUNC_PUBLISH_TYPE] = { .type = NLA_U8 },
305 [NL80211_NAN_FUNC_PUBLISH_BCAST] = { .type = NLA_FLAG },
306 [NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE] = { .type = NLA_FLAG },
307 [NL80211_NAN_FUNC_FOLLOW_UP_ID] = { .type = NLA_U8 },
308 [NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] = { .type = NLA_U8 },
309 [NL80211_NAN_FUNC_FOLLOW_UP_DEST] = { },
310 [NL80211_NAN_FUNC_CLOSE_RANGE] = { .type = NLA_FLAG },
311 [NL80211_NAN_FUNC_TTL] = { .type = NLA_U32 },
312 [NL80211_NAN_FUNC_SERVICE_INFO] = { },
313 [NL80211_NAN_FUNC_SRF] = { .type = NLA_NESTED },
314 [NL80211_NAN_FUNC_RX_MATCH_FILTER] = { .type = NLA_NESTED },
315 [NL80211_NAN_FUNC_TX_MATCH_FILTER] = { .type = NLA_NESTED },
316 [NL80211_NAN_FUNC_INSTANCE_ID] = { .type = NLA_U8},
317 };
318
319 if (!attrs[NL80211_ATTR_COOKIE]) {
320 printf("Bad NAN func termination format - cookie is missing\n");
321 return;
322 }
323
324 if (nla_parse_nested(func, NL80211_NAN_FUNC_ATTR_MAX,
325 attrs[NL80211_ATTR_NAN_FUNC],
326 nan_func_policy)) {
327 printf("NAN: failed to parse nan func\n");
328 return;
329 }
330
331 if (!func[NL80211_NAN_FUNC_INSTANCE_ID]) {
332 printf("Bad NAN func termination format-instance id missing\n");
333 return;
334 }
335
336 if (!func[NL80211_NAN_FUNC_TERM_REASON]) {
337 printf("Bad NAN func termination format - reason is missing\n");
338 return;
339 }
340 printf("NAN(cookie=0x%llx): Termination event: id = %d, reason = ",
341 (long long int)nla_get_u64(attrs[NL80211_ATTR_COOKIE]),
342 nla_get_u8(func[NL80211_NAN_FUNC_INSTANCE_ID]));
343 switch (nla_get_u8(func[NL80211_NAN_FUNC_TERM_REASON])) {
344 case NL80211_NAN_FUNC_TERM_REASON_USER_REQUEST:
345 printf("user request\n");
346 break;
347 case NL80211_NAN_FUNC_TERM_REASON_TTL_EXPIRED:
348 printf("expired\n");
349 break;
350 case NL80211_NAN_FUNC_TERM_REASON_ERROR:
351 printf("error\n");
352 break;
353 default:
354 printf("unknown\n");
355 }
356}
357
358static void parse_nan_match(struct nlattr **attrs)
359{
360 char macbuf[6*3];
361 __u64 cookie;
362 struct nlattr *match[NL80211_NAN_MATCH_ATTR_MAX + 1];
363 struct nlattr *local_func[NL80211_NAN_FUNC_ATTR_MAX + 1];
364 struct nlattr *peer_func[NL80211_NAN_FUNC_ATTR_MAX + 1];
365
366 static struct nla_policy
367 nan_match_policy[NL80211_NAN_MATCH_ATTR_MAX + 1] = {
368 [NL80211_NAN_MATCH_FUNC_LOCAL] = { .type = NLA_NESTED },
369 [NL80211_NAN_MATCH_FUNC_PEER] = { .type = NLA_NESTED },
370 };
371
372 static struct nla_policy
373 nan_func_policy[NL80211_NAN_FUNC_ATTR_MAX + 1] = {
374 [NL80211_NAN_FUNC_TYPE] = { .type = NLA_U8 },
375 [NL80211_NAN_FUNC_SERVICE_ID] = { },
376 [NL80211_NAN_FUNC_PUBLISH_TYPE] = { .type = NLA_U8 },
377 [NL80211_NAN_FUNC_PUBLISH_BCAST] = { .type = NLA_FLAG },
378 [NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE] = { .type = NLA_FLAG },
379 [NL80211_NAN_FUNC_FOLLOW_UP_ID] = { .type = NLA_U8 },
380 [NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] = { .type = NLA_U8 },
381 [NL80211_NAN_FUNC_FOLLOW_UP_DEST] = { },
382 [NL80211_NAN_FUNC_CLOSE_RANGE] = { .type = NLA_FLAG },
383 [NL80211_NAN_FUNC_TTL] = { .type = NLA_U32 },
384 [NL80211_NAN_FUNC_SERVICE_INFO] = { },
385 [NL80211_NAN_FUNC_SRF] = { .type = NLA_NESTED },
386 [NL80211_NAN_FUNC_RX_MATCH_FILTER] = { .type = NLA_NESTED },
387 [NL80211_NAN_FUNC_TX_MATCH_FILTER] = { .type = NLA_NESTED },
388 [NL80211_NAN_FUNC_INSTANCE_ID] = { .type = NLA_U8},
389 };
390
391 cookie = nla_get_u64(attrs[NL80211_ATTR_COOKIE]);
392 mac_addr_n2a(macbuf, nla_data(attrs[NL80211_ATTR_MAC]));
393
394 if (nla_parse_nested(match, NL80211_NAN_MATCH_ATTR_MAX,
395 attrs[NL80211_ATTR_NAN_MATCH],
396 nan_match_policy)) {
397 printf("NAN: failed to parse nan match event\n");
398 return;
399 }
400
401 if (nla_parse_nested(local_func, NL80211_NAN_FUNC_ATTR_MAX,
402 match[NL80211_NAN_MATCH_FUNC_LOCAL],
403 nan_func_policy)) {
404 printf("NAN: failed to parse nan local func\n");
405 return;
406 }
407
408 if (nla_parse_nested(peer_func, NL80211_NAN_FUNC_ATTR_MAX,
409 match[NL80211_NAN_MATCH_FUNC_PEER],
410 nan_func_policy)) {
411 printf("NAN: failed to parse nan local func\n");
412 return;
413 }
414
415 if (nla_get_u8(peer_func[NL80211_NAN_FUNC_TYPE]) ==
416 NL80211_NAN_FUNC_PUBLISH) {
417 printf(
418 "NAN(cookie=0x%llx): DiscoveryResult, peer_id=%d, local_id=%d, peer_mac=%s, ",
419 cookie,
420 nla_get_u8(peer_func[NL80211_NAN_FUNC_INSTANCE_ID]),
421 nla_get_u8(local_func[NL80211_NAN_FUNC_INSTANCE_ID]),
422 macbuf);
423 if (peer_func[NL80211_NAN_FUNC_SERVICE_INFO])
424 printf("info=%.*s",
425 nla_len(peer_func[NL80211_NAN_FUNC_SERVICE_INFO]),
426 (char *)nla_data(peer_func[NL80211_NAN_FUNC_SERVICE_INFO]));
427 } else if (nla_get_u8(peer_func[NL80211_NAN_FUNC_TYPE]) ==
428 NL80211_NAN_FUNC_SUBSCRIBE) {
429 printf(
430 "NAN(cookie=0x%llx): Replied, peer_id=%d, local_id=%d, peer_mac=%s\n",
431 cookie,
432 nla_get_u8(peer_func[NL80211_NAN_FUNC_INSTANCE_ID]),
433 nla_get_u8(local_func[NL80211_NAN_FUNC_INSTANCE_ID]),
434 macbuf);
435 } else if (nla_get_u8(peer_func[NL80211_NAN_FUNC_TYPE]) ==
436 NL80211_NAN_FUNC_FOLLOW_UP) {
437 printf(
438 "NAN(cookie=0x%llx): FollowUpReceive, peer_id=%d, local_id=%d, peer_mac=%s, ",
439 cookie,
440 nla_get_u8(peer_func[NL80211_NAN_FUNC_INSTANCE_ID]),
441 nla_get_u8(local_func[NL80211_NAN_FUNC_INSTANCE_ID]),
442 macbuf);
443 if (peer_func[NL80211_NAN_FUNC_SERVICE_INFO])
444 printf("info=%.*s",
445 nla_len(peer_func[NL80211_NAN_FUNC_SERVICE_INFO]),
446 (char *)nla_data(peer_func[NL80211_NAN_FUNC_SERVICE_INFO]));
447 } else {
448 printf("NaN: Malformed event\n");
449 }
450}
451
957a0f07
JB		 452static int print_event(struct nl_msg *msg, void *arg)
453{
454 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
748f8489 455 struct nlattr *tb[NL80211_ATTR_MAX + 1], *nst;
957a0f07
JB		 456 struct print_event_args *args = arg;
457 char ifname[100];
458 char macbuf[6*3];
459 __u8 reg_type;
0168589d
LR		 460 struct ieee80211_beacon_channel chan_before_beacon, chan_after_beacon;
461 __u32 wiphy_idx = 0;
748f8489 462 int rem_nst;
f1a666a6 463 __u16 status;
957a0f07 464
981b21ad
JB		 465 if (args->time || args->reltime) {
466 unsigned long long usecs, previous;
467
468 previous = 1000000ULL * args->ts.tv_sec + args->ts.tv_usec;
469 gettimeofday(&args->ts, NULL);
470 usecs = 1000000ULL * args->ts.tv_sec + args->ts.tv_usec;
471 if (args->reltime) {
472 if (!args->have_ts) {
473 usecs = 0;
474 args->have_ts = true;
475 } else
476 usecs -= previous;
477 }
478 printf("%llu.%06llu: ", usecs/1000000, usecs % 1000000);
957a0f07
JB		 479 }
480
481 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
482 genlmsg_attrlen(gnlh, 0), NULL);
483
484 if (tb[NL80211_ATTR_IFINDEX] && tb[NL80211_ATTR_WIPHY]) {
485 if_indextoname(nla_get_u32(tb[NL80211_ATTR_IFINDEX]), ifname);
486 printf("%s (phy #%d): ", ifname, nla_get_u32(tb[NL80211_ATTR_WIPHY]));
d8880179
JB		 487 } else if (tb[NL80211_ATTR_WDEV] && tb[NL80211_ATTR_WIPHY]) {
488 printf("wdev 0x%llx (phy #%d): ",
489 (unsigned long long)nla_get_u64(tb[NL80211_ATTR_WDEV]),
490 nla_get_u32(tb[NL80211_ATTR_WIPHY]));
957a0f07
JB		 491 } else if (tb[NL80211_ATTR_IFINDEX]) {
492 if_indextoname(nla_get_u32(tb[NL80211_ATTR_IFINDEX]), ifname);
493 printf("%s: ", ifname);
d8880179
JB		 494 } else if (tb[NL80211_ATTR_WDEV]) {
495 printf("wdev 0x%llx: ", (unsigned long long)nla_get_u64(tb[NL80211_ATTR_WDEV]));
957a0f07
JB		 496 } else if (tb[NL80211_ATTR_WIPHY]) {
497 printf("phy #%d: ", nla_get_u32(tb[NL80211_ATTR_WIPHY]));
498 }
499
500 switch (gnlh->cmd) {
501 case NL80211_CMD_NEW_WIPHY:
502 printf("renamed to %s\n", nla_get_string(tb[NL80211_ATTR_WIPHY_NAME]));
503 break;
e67be815
JB		 504 case NL80211_CMD_TRIGGER_SCAN:
505 printf("scan started\n");
506 break;
957a0f07 507 case NL80211_CMD_NEW_SCAN_RESULTS:
748f8489 508 printf("scan finished:");
6ab936f0 509 /* fall through */
957a0f07 510 case NL80211_CMD_SCAN_ABORTED:
748f8489
JB		 511 if (gnlh->cmd == NL80211_CMD_SCAN_ABORTED)
512 printf("scan aborted:");
513 if (tb[NL80211_ATTR_SCAN_FREQUENCIES]) {
514 nla_for_each_nested(nst, tb[NL80211_ATTR_SCAN_FREQUENCIES], rem_nst)
515 printf(" %d", nla_get_u32(nst));
516 printf(",");
517 }
518 if (tb[NL80211_ATTR_SCAN_SSIDS]) {
519 nla_for_each_nested(nst, tb[NL80211_ATTR_SCAN_SSIDS], rem_nst) {
520 printf(" \"");
521 print_ssid_escaped(nla_len(nst), nla_data(nst));
522 printf("\"");
523 }
524 }
525 printf("\n");
957a0f07 526 break;
3fce58aa
LC		 527 case NL80211_CMD_START_SCHED_SCAN:
528 printf("scheduled scan started\n");
529 break;
530 case NL80211_CMD_SCHED_SCAN_STOPPED:
531 printf("sched scan stopped\n");
532 break;
533 case NL80211_CMD_SCHED_SCAN_RESULTS:
534 printf("got scheduled scan results\n");
535 break;
957a0f07
JB		 536 case NL80211_CMD_REG_CHANGE:
537 printf("regulatory domain change: ");
538
539 reg_type = nla_get_u8(tb[NL80211_ATTR_REG_TYPE]);
540
541 switch (reg_type) {
542 case NL80211_REGDOM_TYPE_COUNTRY:
543 printf("set to %s by %s request",
544 nla_get_string(tb[NL80211_ATTR_REG_ALPHA2]),
545 reg_initiator_to_string(nla_get_u8(tb[NL80211_ATTR_REG_INITIATOR])));
546 if (tb[NL80211_ATTR_WIPHY])
547 printf(" on phy%d", nla_get_u32(tb[NL80211_ATTR_WIPHY]));
548 break;
549 case NL80211_REGDOM_TYPE_WORLD:
550 printf("set to world roaming by %s request",
551 reg_initiator_to_string(nla_get_u8(tb[NL80211_ATTR_REG_INITIATOR])));
552 break;
553 case NL80211_REGDOM_TYPE_CUSTOM_WORLD:
554 printf("custom world roaming rules in place on phy%d by %s request",
555 nla_get_u32(tb[NL80211_ATTR_WIPHY]),
556 reg_initiator_to_string(nla_get_u32(tb[NL80211_ATTR_REG_INITIATOR])));
557 break;
558 case NL80211_REGDOM_TYPE_INTERSECTION:
559 printf("intersection used due to a request made by %s",
560 reg_initiator_to_string(nla_get_u32(tb[NL80211_ATTR_REG_INITIATOR])));
561 if (tb[NL80211_ATTR_WIPHY])
562 printf(" on phy%d", nla_get_u32(tb[NL80211_ATTR_WIPHY]));
563 break;
564 default:
565 printf("unknown source (upgrade this utility)");
566 break;
567 }
568
569 printf("\n");
0168589d
LR		 570 break;
571 case NL80211_CMD_REG_BEACON_HINT:
572
573 wiphy_idx = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
574
575 memset(&chan_before_beacon, 0, sizeof(chan_before_beacon));
576 memset(&chan_after_beacon, 0, sizeof(chan_after_beacon));
577
ce3b2ed9
JB		 578 if (parse_beacon_hint_chan(tb[NL80211_ATTR_FREQ_BEFORE],
579 &chan_before_beacon))
580 break;
581 if (parse_beacon_hint_chan(tb[NL80211_ATTR_FREQ_AFTER],
582 &chan_after_beacon))
583 break;
0168589d
LR		 584
585 if (chan_before_beacon.center_freq != chan_after_beacon.center_freq)
586 break;
587
588 /* A beacon hint is sent _only_ if something _did_ change */
589 printf("beacon hint:\n");
590
591 printf("phy%d %d MHz [%d]:\n",
592 wiphy_idx,
593 chan_before_beacon.center_freq,
594 ieee80211_frequency_to_channel(chan_before_beacon.center_freq));
595
f0c48e7b
IP		 596 if (chan_before_beacon.no_ir && !chan_after_beacon.no_ir) {
597 if (chan_before_beacon.no_ibss && !chan_after_beacon.no_ibss)
598 printf("\to Initiating radiation enabled\n");
599 else
600 printf("\to active scan enabled\n");
601 } else if (chan_before_beacon.no_ibss && !chan_after_beacon.no_ibss) {
602 printf("\to ibss enabled\n");
603 }
0168589d 604
cec6d6a7
JB		 605 break;
606 case NL80211_CMD_NEW_STATION:
607 mac_addr_n2a(macbuf, nla_data(tb[NL80211_ATTR_MAC]));
608 printf("new station %s\n", macbuf);
957a0f07 609 break;
27bf109b
AQ		 610 case NL80211_CMD_DEL_STATION:
611 mac_addr_n2a(macbuf, nla_data(tb[NL80211_ATTR_MAC]));
612 printf("del station %s\n", macbuf);
613 break;
957a0f07
JB		 614 case NL80211_CMD_JOIN_IBSS:
615 mac_addr_n2a(macbuf, nla_data(tb[NL80211_ATTR_MAC]));
616 printf("IBSS %s joined\n", macbuf);
617 break;
618 case NL80211_CMD_AUTHENTICATE:
619 printf("auth");
aea5dbd2
JB		 620 if (tb[NL80211_ATTR_FRAME])
621 print_frame(args, tb[NL80211_ATTR_FRAME]);
622 else if (tb[NL80211_ATTR_TIMED_OUT])
623 printf(": timed out");
624 else
625 printf(": unknown event");
957a0f07
JB		 626 printf("\n");
627 break;
628 case NL80211_CMD_ASSOCIATE:
629 printf("assoc");
aea5dbd2
JB		 630 if (tb[NL80211_ATTR_FRAME])
631 print_frame(args, tb[NL80211_ATTR_FRAME]);
632 else if (tb[NL80211_ATTR_TIMED_OUT])
633 printf(": timed out");
634 else
635 printf(": unknown event");
957a0f07
JB		 636 printf("\n");
637 break;
638 case NL80211_CMD_DEAUTHENTICATE:
639 printf("deauth");
640 print_frame(args, tb[NL80211_ATTR_FRAME]);
641 printf("\n");
642 break;
643 case NL80211_CMD_DISASSOCIATE:
644 printf("disassoc");
645 print_frame(args, tb[NL80211_ATTR_FRAME]);
646 printf("\n");
647 break;
99802e56
JB		 648 case NL80211_CMD_UNPROT_DEAUTHENTICATE:
649 printf("unprotected deauth");
650 print_frame(args, tb[NL80211_ATTR_FRAME]);
651 printf("\n");
652 break;
653 case NL80211_CMD_UNPROT_DISASSOCIATE:
654 printf("unprotected disassoc");
655 print_frame(args, tb[NL80211_ATTR_FRAME]);
656 printf("\n");
657 break;
f1a666a6
JB		 658 case NL80211_CMD_CONNECT:
659 status = 0;
27ea56b6
JB		 660 if (tb[NL80211_ATTR_TIMED_OUT])
661 printf("timed out");
662 else if (!tb[NL80211_ATTR_STATUS_CODE])
f1a666a6
JB		 663 printf("unknown connect status");
664 else if (nla_get_u16(tb[NL80211_ATTR_STATUS_CODE]) == 0)
665 printf("connected");
666 else {
667 status = nla_get_u16(tb[NL80211_ATTR_STATUS_CODE]);
668 printf("failed to connect");
669 }
670 if (tb[NL80211_ATTR_MAC]) {
671 mac_addr_n2a(macbuf, nla_data(tb[NL80211_ATTR_MAC]));
672 printf(" to %s", macbuf);
673 }
674 if (status)
675 printf(", status: %d: %s", status, get_status_str(status));
676 printf("\n");
677 break;
678 case NL80211_CMD_ROAM:
679 printf("roamed");
680 if (tb[NL80211_ATTR_MAC]) {
681 mac_addr_n2a(macbuf, nla_data(tb[NL80211_ATTR_MAC]));
682 printf(" to %s", macbuf);
683 }
684 printf("\n");
685 break;
686 case NL80211_CMD_DISCONNECT:
687 printf("disconnected");
688 if (tb[NL80211_ATTR_DISCONNECTED_BY_AP])
689 printf(" (by AP)");
690 else
691 printf(" (local request)");
692 if (tb[NL80211_ATTR_REASON_CODE])
693 printf(" reason: %d: %s", nla_get_u16(tb[NL80211_ATTR_REASON_CODE]),
694 get_reason_str(nla_get_u16(tb[NL80211_ATTR_REASON_CODE])));
695 printf("\n");
696 break;
6829308d
JB		 697 case NL80211_CMD_REMAIN_ON_CHANNEL:
698 printf("remain on freq %d (%dms, cookie %llx)\n",
699 nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]),
700 nla_get_u32(tb[NL80211_ATTR_DURATION]),
701 (unsigned long long)nla_get_u64(tb[NL80211_ATTR_COOKIE]));
702 break;
703 case NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL:
704 printf("done with remain on freq %d (cookie %llx)\n",
705 nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]),
706 (unsigned long long)nla_get_u64(tb[NL80211_ATTR_COOKIE]));
707 break;
7988b229 708 case NL80211_CMD_NOTIFY_CQM:
f19444fe 709 parse_cqm_event(tb);
7988b229 710 break;
8612433d
JM		 711 case NL80211_CMD_MICHAEL_MIC_FAILURE:
712 parse_mic_failure(tb);
713 break;
cbff7089
JB		 714 case NL80211_CMD_FRAME_TX_STATUS:
715 printf("mgmt TX status (cookie %llx): %s\n",
716 (unsigned long long)nla_get_u64(tb[NL80211_ATTR_COOKIE]),
717 tb[NL80211_ATTR_ACK] ? "acked" : "no ack");
718 break;
0bf2c6a0 719 case NL80211_CMD_PMKSA_CANDIDATE:
b6688cb8
JB		 720 printf("PMKSA candidate found\n");
721 break;
819b78cc
JB		 722 case NL80211_CMD_SET_WOWLAN:
723 parse_wowlan_wake_event(tb);
724 break;
4310994d
BG		 725 case NL80211_CMD_PROBE_CLIENT:
726 if (tb[NL80211_ATTR_MAC])
727 mac_addr_n2a(macbuf, nla_data(tb[NL80211_ATTR_MAC]));
728 else
729 strcpy(macbuf, "??");
730 printf("probe client %s (cookie %llx): %s\n",
731 macbuf,
732 (unsigned long long)nla_get_u64(tb[NL80211_ATTR_COOKIE]),
733 tb[NL80211_ATTR_ACK] ? "acked" : "no ack");
734 break;
e8b3b312
JB		 735 case NL80211_CMD_VENDOR:
736 printf("vendor event %.6x:%d\n",
737 nla_get_u32(tb[NL80211_ATTR_VENDOR_ID]),
738 nla_get_u32(tb[NL80211_ATTR_VENDOR_SUBCMD]));
492354de
JD		 739 if (args->frame && tb[NL80211_ATTR_VENDOR_DATA])
740 iw_hexdump("vendor event",
741 nla_data(tb[NL80211_ATTR_VENDOR_DATA]),
742 nla_len(tb[NL80211_ATTR_VENDOR_DATA]));
e8b3b312 743 break;
03fb59d0
BB		 744 case NL80211_CMD_RADAR_DETECT: {
745 enum nl80211_radar_event event_type;
746 uint32_t freq;
747
748 if (!tb[NL80211_ATTR_RADAR_EVENT] ||
749 !tb[NL80211_ATTR_WIPHY_FREQ]) {
750 printf("BAD radar event\n");
751 break;
752 }
753
754 freq = nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]);
755 event_type = nla_get_u32(tb[NL80211_ATTR_RADAR_EVENT]);
756
757 switch (event_type) {
758 case NL80211_RADAR_DETECTED:
759 printf("%d MHz: radar detected\n", freq);
760 break;
761 case NL80211_RADAR_CAC_FINISHED:
762 printf("%d MHz: CAC finished\n", freq);
763 break;
764 case NL80211_RADAR_CAC_ABORTED:
765 printf("%d MHz: CAC was aborted\n", freq);
766 break;
767 case NL80211_RADAR_NOP_FINISHED:
768 printf("%d MHz: NOP finished\n", freq);
769 break;
770 default:
771 printf("%d MHz: unknown radar event\n", freq);
772 }
085f4f08 773 }
085f4f08 774 break;
a3ca7c69
BG		 775 case NL80211_CMD_DEL_WIPHY:
776 printf("delete wiphy\n");
777 break;
7c4e86ca
RZ		 778 case NL80211_CMD_DEL_NAN_FUNCTION:
779 parse_nan_term(tb);
780 break;
781 case NL80211_CMD_NAN_MATCH: {
782 parse_nan_match(tb);
783 break;
784 }
957a0f07 785 default:
7c712c89
JB		 786 printf("unknown event %d (%s)\n",
787 gnlh->cmd, command_name(gnlh->cmd));
957a0f07
JB		 788 break;
789 }
790
374e8a26 791 fflush(stdout);
957a0f07
JB		 792 return NL_SKIP;
793}
794
795struct wait_event {
796 int n_cmds;
797 const __u32 *cmds;
798 __u32 cmd;
7fabd346 799 struct print_event_args *pargs;
957a0f07
JB		 800};
801
802static int wait_event(struct nl_msg *msg, void *arg)
803{
804 struct wait_event *wait = arg;
805 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
806 int i;
807
808 for (i = 0; i < wait->n_cmds; i++) {
809 if (gnlh->cmd == wait->cmds[i]) {
810 wait->cmd = gnlh->cmd;
7e7c544f
JB		 811 if (wait->pargs)
812 print_event(msg, wait->pargs);
957a0f07
JB		 813 }
814 }
815
816 return NL_SKIP;
817}
818
ee374e4d 819int __prepare_listen_events(struct nl80211_state *state)
957a0f07
JB		 820{
821 int mcid, ret;
957a0f07
JB		 822
823 /* Configuration multicast group */
824 mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "config");
825 if (mcid < 0)
826 return mcid;
827
828 ret = nl_socket_add_membership(state->nl_sock, mcid);
829 if (ret)
830 return ret;
831
832 /* Scan multicast group */
833 mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "scan");
834 if (mcid >= 0) {
835 ret = nl_socket_add_membership(state->nl_sock, mcid);
836 if (ret)
837 return ret;
838 }
839
840 /* Regulatory multicast group */
841 mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "regulatory");
842 if (mcid >= 0) {
843 ret = nl_socket_add_membership(state->nl_sock, mcid);
844 if (ret)
845 return ret;
846 }
847
848 /* MLME multicast group */
849 mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "mlme");
850 if (mcid >= 0) {
851 ret = nl_socket_add_membership(state->nl_sock, mcid);
852 if (ret)
853 return ret;
854 }
855
e8b3b312
JB		 856 mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "vendor");
857 if (mcid >= 0) {
858 ret = nl_socket_add_membership(state->nl_sock, mcid);
859 if (ret)
860 return ret;
861 }
862
7c4e86ca
RZ		 863 mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "nan");
864 if (mcid >= 0) {
865 ret = nl_socket_add_membership(state->nl_sock, mcid);
866 if (ret)
867 return ret;
868 }
869
105aed57
JB		 870 return 0;
871}
872
ee374e4d
JB		 873__u32 __do_listen_events(struct nl80211_state *state,
874 const int n_waits, const __u32 *waits,
875 struct print_event_args *args)
105aed57
JB		 876{
877 struct nl_cb *cb = nl_cb_alloc(iw_debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
878 struct wait_event wait_ev;
105aed57
JB		 879
880 if (!cb) {
881 fprintf(stderr, "failed to allocate netlink callbacks\n");
882 return -ENOMEM;
883 }
884
957a0f07
JB		 885 /* no sequence checking for multicast messages */
886 nl_cb_set(cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, no_seq_check, NULL);
34b23014 887 nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, valid_handler, NULL);
957a0f07
JB		 888
889 if (n_waits && waits) {
890 wait_ev.cmds = waits;
891 wait_ev.n_cmds = n_waits;
7fabd346 892 wait_ev.pargs = args;
34b23014 893 register_handler(wait_event, &wait_ev);
7fabd346 894 } else
34b23014 895 register_handler(print_event, args);
957a0f07
JB		 896
897 wait_ev.cmd = 0;
898
899 while (!wait_ev.cmd)
900 nl_recvmsgs(state->nl_sock, cb);
901
902 nl_cb_put(cb);
903
904 return wait_ev.cmd;
905}
906
907__u32 listen_events(struct nl80211_state *state,
908 const int n_waits, const __u32 *waits)
909{
ee374e4d
JB		 910 int ret;
911
912 ret = __prepare_listen_events(state);
913 if (ret)
914 return ret;
915
916 return __do_listen_events(state, n_waits, waits, NULL);
957a0f07
JB		 917}
918
919static int print_events(struct nl80211_state *state,
957a0f07 920 struct nl_msg *msg,
05514f95
JB		 921 int argc, char **argv,
922 enum id_input id)
957a0f07
JB		 923{
924 struct print_event_args args;
ee374e4d 925 int ret;
957a0f07
JB		 926
927 memset(&args, 0, sizeof(args));
928
929 argc--;
930 argv++;
931
932 while (argc > 0) {
933 if (strcmp(argv[0], "-f") == 0)
934 args.frame = true;
935 else if (strcmp(argv[0], "-t") == 0)
936 args.time = true;
981b21ad
JB		 937 else if (strcmp(argv[0], "-r") == 0)
938 args.reltime = true;
957a0f07
JB		 939 else
940 return 1;
941 argc--;
942 argv++;
943 }
944
981b21ad
JB		 945 if (args.time && args.reltime)
946 return 1;
947
957a0f07
JB		 948 if (argc)
949 return 1;
950
ee374e4d
JB		 951 ret = __prepare_listen_events(state);
952 if (ret)
953 return ret;
954
955 return __do_listen_events(state, 0, NULL, &args);
957a0f07 956}
ef65e9cc 957TOPLEVEL(event, "[-t|-r] [-f]", 0, 0, CIB_NONE, print_events,
01ae06f9
JB		 958 "Monitor events from the kernel.\n"
959 "-t - print timestamp\n"
981b21ad 960 "-r - print relative timstamp\n"
01ae06f9 961 "-f - print full frame for auth/assoc etc.");
Mirror git://git.kernel.org/pub/scm/linux/kernel/git/jberg/iw.git