[thirdparty/iw.git] / event.c

#include <stdint.h>
#include <stdbool.h>
#include <net/if.h>
#include <errno.h>
#include "iw.h"

static int no_seq_check(struct nl_msg *msg, void *arg)
{
	return NL_OK;
}

struct print_event_args {
	bool frame, time;
};

static void print_frame(struct print_event_args *args, struct nlattr *attr)
{
	uint8_t *frame;
	size_t len;
	int i;
	char macbuf[6*3];
	uint16_t tmp;

	if (!attr)
		printf(" [no frame]");

	frame = nla_data(attr);
	len = nla_len(attr);

	if (len < 26) {
		printf(" [invalid frame: ");
		goto print_frame;
	}

	mac_addr_n2a(macbuf, frame + 10);
	printf(" %s -> ", macbuf);
	mac_addr_n2a(macbuf, frame + 4);
	printf("%s", macbuf);

	switch (frame[0] & 0xfc) {
	case 0x10: /* assoc resp */
	case 0x30: /* reassoc resp */
		/* status */
		tmp = (frame[27] << 8) + frame[26];
		printf(" status: %d: %s", tmp, get_status_str(tmp));
		break;
	case 0x00: /* assoc req */
	case 0x20: /* reassoc req */
		break;
	case 0xb0: /* auth */
		/* status */
		tmp = (frame[29] << 8) + frame[28];
		printf(" status: %d: %s", tmp, get_status_str(tmp));
		break;
		break;
	case 0xa0: /* disassoc */
	case 0xc0: /* deauth */
		/* reason */
		tmp = (frame[25] << 8) + frame[24];
		printf(" reason %d: %s", tmp, get_reason_str(tmp));
		break;
	}

	if (!args->frame)
		return;

	printf(" [frame:");

 print_frame:
	for (i = 0; i < len; i++)
		printf(" %.02x", frame[i]);
	printf("]");
}

static int print_event(struct nl_msg *msg, void *arg)
{
	struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
	struct nlattr *tb[NL80211_ATTR_MAX + 1], *nst;
	struct print_event_args *args = arg;
	char ifname[100];
	char macbuf[6*3];
	__u8 reg_type;
	int rem_nst;

	if (args->time) {
		struct timeval tv;
		gettimeofday(&tv, NULL);
		printf("%ld.%06u: ", (long) tv.tv_sec, (unsigned int) tv.tv_usec);
	}

	nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
		  genlmsg_attrlen(gnlh, 0), NULL);

	if (tb[NL80211_ATTR_IFINDEX] && tb[NL80211_ATTR_WIPHY]) {
		if_indextoname(nla_get_u32(tb[NL80211_ATTR_IFINDEX]), ifname);
		printf("%s (phy #%d): ", ifname, nla_get_u32(tb[NL80211_ATTR_WIPHY]));
	} else if (tb[NL80211_ATTR_IFINDEX]) {
		if_indextoname(nla_get_u32(tb[NL80211_ATTR_IFINDEX]), ifname);
		printf("%s: ", ifname);
	} else if (tb[NL80211_ATTR_WIPHY]) {
		printf("phy #%d: ", nla_get_u32(tb[NL80211_ATTR_WIPHY]));
	}

	switch (gnlh->cmd) {
	case NL80211_CMD_NEW_WIPHY:
		printf("renamed to %s\n", nla_get_string(tb[NL80211_ATTR_WIPHY_NAME]));
		break;
	case NL80211_CMD_NEW_SCAN_RESULTS:
		printf("scan finished:");
	case NL80211_CMD_SCAN_ABORTED:
		if (gnlh->cmd == NL80211_CMD_SCAN_ABORTED)
			printf("scan aborted:");
		if (tb[NL80211_ATTR_SCAN_FREQUENCIES]) {
			nla_for_each_nested(nst, tb[NL80211_ATTR_SCAN_FREQUENCIES], rem_nst)
				printf(" %d", nla_get_u32(nst));
			printf(",");
		}
		if (tb[NL80211_ATTR_SCAN_SSIDS]) {
			nla_for_each_nested(nst, tb[NL80211_ATTR_SCAN_SSIDS], rem_nst) {
				printf(" \"");
				print_ssid_escaped(nla_len(nst), nla_data(nst));
				printf("\"");
			}
		}
		printf("\n");
		break;
	case NL80211_CMD_REG_CHANGE:
		printf("regulatory domain change: ");

		reg_type = nla_get_u8(tb[NL80211_ATTR_REG_TYPE]);

		switch (reg_type) {
		case NL80211_REGDOM_TYPE_COUNTRY:
			printf("set to %s by %s request",
			       nla_get_string(tb[NL80211_ATTR_REG_ALPHA2]),
			       reg_initiator_to_string(nla_get_u8(tb[NL80211_ATTR_REG_INITIATOR])));
			if (tb[NL80211_ATTR_WIPHY])
				printf(" on phy%d", nla_get_u32(tb[NL80211_ATTR_WIPHY]));
			break;
		case NL80211_REGDOM_TYPE_WORLD:
			printf("set to world roaming by %s request",
			       reg_initiator_to_string(nla_get_u8(tb[NL80211_ATTR_REG_INITIATOR])));
			break;
		case NL80211_REGDOM_TYPE_CUSTOM_WORLD:
			printf("custom world roaming rules in place on phy%d by %s request",
			       nla_get_u32(tb[NL80211_ATTR_WIPHY]),
			       reg_initiator_to_string(nla_get_u32(tb[NL80211_ATTR_REG_INITIATOR])));
			break;
		case NL80211_REGDOM_TYPE_INTERSECTION:
			printf("intersection used due to a request made by %s",
			       reg_initiator_to_string(nla_get_u32(tb[NL80211_ATTR_REG_INITIATOR])));
			if (tb[NL80211_ATTR_WIPHY])
				printf(" on phy%d", nla_get_u32(tb[NL80211_ATTR_WIPHY]));
			break;
		default:
			printf("unknown source (upgrade this utility)");
			break;
		}

		printf("\n");
		break;
	case NL80211_CMD_JOIN_IBSS:
		mac_addr_n2a(macbuf, nla_data(tb[NL80211_ATTR_MAC]));
		printf("IBSS %s joined\n", macbuf);
		break;
	case NL80211_CMD_AUTHENTICATE:
		printf("auth");
		print_frame(args, tb[NL80211_ATTR_FRAME]);
		printf("\n");
		break;
	case NL80211_CMD_ASSOCIATE:
		printf("assoc");
		print_frame(args, tb[NL80211_ATTR_FRAME]);
		printf("\n");
		break;
	case NL80211_CMD_DEAUTHENTICATE:
		printf("deauth");
		print_frame(args, tb[NL80211_ATTR_FRAME]);
		printf("\n");
		break;
	case NL80211_CMD_DISASSOCIATE:
		printf("disassoc");
		print_frame(args, tb[NL80211_ATTR_FRAME]);
		printf("\n");
		break;
	default:
		printf("unknown event %d\n", gnlh->cmd);
		break;
	}

	return NL_SKIP;
}

struct wait_event {
	int n_cmds;
	const __u32 *cmds;
	__u32 cmd;
};

static int wait_event(struct nl_msg *msg, void *arg)
{
	struct wait_event *wait = arg;
	struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
	int i;

	for (i = 0; i < wait->n_cmds; i++) {
		if (gnlh->cmd == wait->cmds[i]) {
			wait->cmd = gnlh->cmd;
		}
	}

	return NL_SKIP;
}

static __u32 __listen_events(struct nl80211_state *state,
			     const int n_waits, const __u32 *waits,
			     struct print_event_args *args)
{
	int mcid, ret;
	struct nl_cb *cb = nl_cb_alloc(iw_debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
	struct wait_event wait_ev;

	if (!cb) {
		fprintf(stderr, "failed to allocate netlink callbacks\n");
		return -ENOMEM;
	}

	/* Configuration multicast group */
	mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "config");
	if (mcid < 0)
		return mcid;

	ret = nl_socket_add_membership(state->nl_sock, mcid);
	if (ret)
		return ret;

	/* Scan multicast group */
	mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "scan");
	if (mcid >= 0) {
		ret = nl_socket_add_membership(state->nl_sock, mcid);
		if (ret)
			return ret;
	}

	/* Regulatory multicast group */
	mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "regulatory");
	if (mcid >= 0) {
		ret = nl_socket_add_membership(state->nl_sock, mcid);
		if (ret)
			return ret;
	}

	/* MLME multicast group */
	mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "mlme");
	if (mcid >= 0) {
		ret = nl_socket_add_membership(state->nl_sock, mcid);
		if (ret)
			return ret;
	}

	/* no sequence checking for multicast messages */
	nl_cb_set(cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, no_seq_check, NULL);

	if (n_waits && waits) {
		wait_ev.cmds = waits;
		wait_ev.n_cmds = n_waits;
		nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, wait_event, &wait_ev);
	} else {
		nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, print_event, args);
	}

	wait_ev.cmd = 0;

	while (!wait_ev.cmd)
		nl_recvmsgs(state->nl_sock, cb);

	nl_cb_put(cb);

	return wait_ev.cmd;
}

__u32 listen_events(struct nl80211_state *state,
		    const int n_waits, const __u32 *waits)
{
	return __listen_events(state, n_waits, waits, NULL);
}

static int print_events(struct nl80211_state *state,
			struct nl_cb *cb,
			struct nl_msg *msg,
			int argc, char **argv)
{
	struct print_event_args args;

	memset(&args, 0, sizeof(args));

	argc--;
	argv++;

	while (argc > 0) {
		if (strcmp(argv[0], "-f") == 0)
			args.frame = true;
		else if (strcmp(argv[0], "-t") == 0)
			args.time = true;
		else
			return 1;
		argc--;
		argv++;
	}

	if (argc)
		return 1;

	return __listen_events(state, 0, NULL, &args);
}
TOPLEVEL(event, "[-t] [-f]", 0, 0, CIB_NONE, print_events,
	"Monitor events from the kernel.\n"
	"-t - print timestamp\n"
	"-f - print full frame for auth/assoc etc.");
Commit	Line	Data
957a0f07 JB	1	#include <stdint.h>
	2	#include <stdbool.h>
	3	#include <net/if.h>
	4	#include <errno.h>
	5	#include "iw.h"
	6
	7	static int no_seq_check(struct nl_msg msg, void arg)
	8	{
	9	return NL_OK;
	10	}
	11
	12	struct print_event_args {
	13	bool frame, time;
	14	};
	15
	16	static void print_frame(struct print_event_args args, struct nlattr attr)
	17	{
	18	uint8_t *frame;
	19	size_t len;
	20	int i;
	21	char macbuf[6*3];
	22	uint16_t tmp;
	23
	24	if (!attr)
	25	printf(" [no frame]");
	26
	27	frame = nla_data(attr);
	28	len = nla_len(attr);
	29
	30	if (len < 26) {
	31	printf(" [invalid frame: ");
	32	goto print_frame;
	33	}
	34
	35	mac_addr_n2a(macbuf, frame + 10);
	36	printf(" %s -> ", macbuf);
	37	mac_addr_n2a(macbuf, frame + 4);
	38	printf("%s", macbuf);
	39
	40	switch (frame[0] & 0xfc) {
	41	case 0x10: /* assoc resp */
	42	case 0x30: /* reassoc resp */
	43	/* status */
	44	tmp = (frame[27] << 8) + frame[26];
	45	printf(" status: %d: %s", tmp, get_status_str(tmp));
	46	break;
	47	case 0x00: /* assoc req */
	48	case 0x20: /* reassoc req */
	49	break;
	50	case 0xb0: /* auth */
	51	/* status */
	52	tmp = (frame[29] << 8) + frame[28];
	53	printf(" status: %d: %s", tmp, get_status_str(tmp));
	54	break;
	55	break;
	56	case 0xa0: /* disassoc */
	57	case 0xc0: /* deauth */
	58	/* reason */
	59	tmp = (frame[25] << 8) + frame[24];
	60	printf(" reason %d: %s", tmp, get_reason_str(tmp));
	61	break;
	62	}
	63
	64	if (!args->frame)
65	return;
66
67	printf(" [frame:");
68
69	print_frame:
70	for (i = 0; i < len; i++)
71	printf(" %.02x", frame[i]);
72	printf("]");
73	}
74
75	static int print_event(struct nl_msg msg, void arg)
76	{
77	struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
748f8489	78	struct nlattr tb[NL80211_ATTR_MAX + 1], nst;
957a0f07 JB	79	struct print_event_args *args = arg;
	80	char ifname[100];
	81	char macbuf[6*3];
	82	__u8 reg_type;
748f8489	83	int rem_nst;
957a0f07 JB	84
	85	if (args->time) {
	86	struct timeval tv;
	87	gettimeofday(&tv, NULL);
	88	printf("%ld.%06u: ", (long) tv.tv_sec, (unsigned int) tv.tv_usec);
	89	}
	90
	91	nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
	92	genlmsg_attrlen(gnlh, 0), NULL);
	93
	94	if (tb[NL80211_ATTR_IFINDEX] && tb[NL80211_ATTR_WIPHY]) {
	95	if_indextoname(nla_get_u32(tb[NL80211_ATTR_IFINDEX]), ifname);
	96	printf("%s (phy #%d): ", ifname, nla_get_u32(tb[NL80211_ATTR_WIPHY]));
	97	} else if (tb[NL80211_ATTR_IFINDEX]) {
	98	if_indextoname(nla_get_u32(tb[NL80211_ATTR_IFINDEX]), ifname);
	99	printf("%s: ", ifname);
	100	} else if (tb[NL80211_ATTR_WIPHY]) {
	101	printf("phy #%d: ", nla_get_u32(tb[NL80211_ATTR_WIPHY]));
	102	}
	103
	104	switch (gnlh->cmd) {
	105	case NL80211_CMD_NEW_WIPHY:
	106	printf("renamed to %s\n", nla_get_string(tb[NL80211_ATTR_WIPHY_NAME]));
	107	break;
	108	case NL80211_CMD_NEW_SCAN_RESULTS:
748f8489	109	printf("scan finished:");
957a0f07	110	case NL80211_CMD_SCAN_ABORTED:
748f8489 JB	111	if (gnlh->cmd == NL80211_CMD_SCAN_ABORTED)
	112	printf("scan aborted:");
	113	if (tb[NL80211_ATTR_SCAN_FREQUENCIES]) {
	114	nla_for_each_nested(nst, tb[NL80211_ATTR_SCAN_FREQUENCIES], rem_nst)
	115	printf(" %d", nla_get_u32(nst));
	116	printf(",");
	117	}
	118	if (tb[NL80211_ATTR_SCAN_SSIDS]) {
	119	nla_for_each_nested(nst, tb[NL80211_ATTR_SCAN_SSIDS], rem_nst) {
	120	printf(" \"");
	121	print_ssid_escaped(nla_len(nst), nla_data(nst));
	122	printf("\"");
	123	}
	124	}
	125	printf("\n");
957a0f07 JB	126	break;
	127	case NL80211_CMD_REG_CHANGE:
	128	printf("regulatory domain change: ");
	129
	130	reg_type = nla_get_u8(tb[NL80211_ATTR_REG_TYPE]);
	131
	132	switch (reg_type) {
	133	case NL80211_REGDOM_TYPE_COUNTRY:
	134	printf("set to %s by %s request",
	135	nla_get_string(tb[NL80211_ATTR_REG_ALPHA2]),
	136	reg_initiator_to_string(nla_get_u8(tb[NL80211_ATTR_REG_INITIATOR])));
	137	if (tb[NL80211_ATTR_WIPHY])
	138	printf(" on phy%d", nla_get_u32(tb[NL80211_ATTR_WIPHY]));
	139	break;
	140	case NL80211_REGDOM_TYPE_WORLD:
	141	printf("set to world roaming by %s request",
	142	reg_initiator_to_string(nla_get_u8(tb[NL80211_ATTR_REG_INITIATOR])));
	143	break;
	144	case NL80211_REGDOM_TYPE_CUSTOM_WORLD:
	145	printf("custom world roaming rules in place on phy%d by %s request",
	146	nla_get_u32(tb[NL80211_ATTR_WIPHY]),
	147	reg_initiator_to_string(nla_get_u32(tb[NL80211_ATTR_REG_INITIATOR])));
	148	break;
	149	case NL80211_REGDOM_TYPE_INTERSECTION:
	150	printf("intersection used due to a request made by %s",
	151	reg_initiator_to_string(nla_get_u32(tb[NL80211_ATTR_REG_INITIATOR])));
	152	if (tb[NL80211_ATTR_WIPHY])
	153	printf(" on phy%d", nla_get_u32(tb[NL80211_ATTR_WIPHY]));
	154	break;
	155	default:
	156	printf("unknown source (upgrade this utility)");
	157	break;
	158	}
	159
	160	printf("\n");
	161	break;
	162	case NL80211_CMD_JOIN_IBSS:
	163	mac_addr_n2a(macbuf, nla_data(tb[NL80211_ATTR_MAC]));
	164	printf("IBSS %s joined\n", macbuf);
	165	break;
	166	case NL80211_CMD_AUTHENTICATE:
	167	printf("auth");
	168	print_frame(args, tb[NL80211_ATTR_FRAME]);
	169	printf("\n");
	170	break;
	171	case NL80211_CMD_ASSOCIATE:
	172	printf("assoc");
	173	print_frame(args, tb[NL80211_ATTR_FRAME]);
	174	printf("\n");
	175	break;
	176	case NL80211_CMD_DEAUTHENTICATE:
	177	printf("deauth");
	178	print_frame(args, tb[NL80211_ATTR_FRAME]);
	179	printf("\n");
	180	break;
	181	case NL80211_CMD_DISASSOCIATE:
	182	printf("disassoc");
	183	print_frame(args, tb[NL80211_ATTR_FRAME]);
	184	printf("\n");
	185	break;
	186	default:
	187	printf("unknown event %d\n", gnlh->cmd);
	188	break;
	189	}
190
191	return NL_SKIP;
192	}
193
194	struct wait_event {
195	int n_cmds;
196	const __u32 *cmds;
197	__u32 cmd;
198	};
199
200	static int wait_event(struct nl_msg msg, void arg)
201	{
202	struct wait_event *wait = arg;
203	struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
204	int i;
205
206	for (i = 0; i < wait->n_cmds; i++) {
207	if (gnlh->cmd == wait->cmds[i]) {
208	wait->cmd = gnlh->cmd;
209	}
210	}
211
212	return NL_SKIP;
213	}
214
215	static __u32 __listen_events(struct nl80211_state *state,
216	const int n_waits, const __u32 *waits,
217	struct print_event_args *args)
218	{
219	int mcid, ret;
220	struct nl_cb *cb = nl_cb_alloc(iw_debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
221	struct wait_event wait_ev;
222
223	if (!cb) {
224	fprintf(stderr, "failed to allocate netlink callbacks\n");
225	return -ENOMEM;
226	}
227
228	/* Configuration multicast group */
229	mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "config");
230	if (mcid < 0)
231	return mcid;
232
233	ret = nl_socket_add_membership(state->nl_sock, mcid);
234	if (ret)
235	return ret;
236
237	/* Scan multicast group */
238	mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "scan");
239	if (mcid >= 0) {
240	ret = nl_socket_add_membership(state->nl_sock, mcid);
241	if (ret)
242	return ret;
243	}
244
245	/* Regulatory multicast group */
246	mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "regulatory");
247	if (mcid >= 0) {
248	ret = nl_socket_add_membership(state->nl_sock, mcid);
249	if (ret)
250	return ret;
251	}
252
253	/* MLME multicast group */
254	mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "mlme");
255	if (mcid >= 0) {
256	ret = nl_socket_add_membership(state->nl_sock, mcid);
257	if (ret)
258	return ret;
259	}
260
261	/* no sequence checking for multicast messages */
262	nl_cb_set(cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, no_seq_check, NULL);
263
264	if (n_waits && waits) {
265	wait_ev.cmds = waits;
266	wait_ev.n_cmds = n_waits;
267	nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, wait_event, &wait_ev);
268	} else {
269	nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, print_event, args);
270	}
271
272	wait_ev.cmd = 0;
273
274	while (!wait_ev.cmd)
275	nl_recvmsgs(state->nl_sock, cb);
276
277	nl_cb_put(cb);
278
279	return wait_ev.cmd;
280	}
281
282	__u32 listen_events(struct nl80211_state *state,
283	const int n_waits, const __u32 *waits)
284	{
285	return __listen_events(state, n_waits, waits, NULL);
286	}
287
288	static int print_events(struct nl80211_state *state,
289	struct nl_cb *cb,
290	struct nl_msg *msg,
291	int argc, char **argv)
292	{
293	struct print_event_args args;
294
295	memset(&args, 0, sizeof(args));
296
297	argc--;
298	argv++;
299
300	while (argc > 0) {
301	if (strcmp(argv[0], "-f") == 0)
302	args.frame = true;
303	else if (strcmp(argv[0], "-t") == 0)
304	args.time = true;
305	else
306	return 1;
307	argc--;
308	argv++;
309	}
310
311	if (argc)
312	return 1;
313
314	return __listen_events(state, 0, NULL, &args);
315	}
01ae06f9 JB	316	TOPLEVEL(event, "[-t] [-f]", 0, 0, CIB_NONE, print_events,
	317	"Monitor events from the kernel.\n"
	318	"-t - print timestamp\n"
	319	"-f - print full frame for auth/assoc etc.");