[thirdparty/iw.git] / iw.c

/*
 * nl80211 userspace tool
 *
 * Copyright 2007, 2008	Johannes Berg <johannes@sipsolutions.net>
 */

#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <net/if.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
                     
#include <netlink/genl/genl.h>
#include <netlink/genl/family.h>
#include <netlink/genl/ctrl.h>  
#include <netlink/msg.h>
#include <netlink/attr.h>

#include "nl80211.h"
#include "iw.h"
#include "version.h"

#ifndef CONFIG_LIBNL20
/* libnl 2.0 compatibility code */

static inline struct nl_handle *nl_socket_alloc(void)
{
	return nl_handle_alloc();
}

static inline void nl_socket_free(struct nl_sock *h)
{
	nl_handle_destroy(h);
}

static inline int __genl_ctrl_alloc_cache(struct nl_sock *h, struct nl_cache **cache)
{
	struct nl_cache *tmp = genl_ctrl_alloc_cache(h);
	if (!tmp)
		return -ENOMEM;
	*cache = tmp;
	return 0;
}
#define genl_ctrl_alloc_cache __genl_ctrl_alloc_cache
#endif /* CONFIG_LIBNL20 */

static int debug = 0;

static int nl80211_init(struct nl80211_state *state)
{
	int err;

	state->nl_sock = nl_socket_alloc();
	if (!state->nl_sock) {
		fprintf(stderr, "Failed to allocate netlink socket.\n");
		return -ENOMEM;
	}

	if (genl_connect(state->nl_sock)) {
		fprintf(stderr, "Failed to connect to generic netlink.\n");
		err = -ENOLINK;
		goto out_handle_destroy;
	}

	if (genl_ctrl_alloc_cache(state->nl_sock, &state->nl_cache)) {
		fprintf(stderr, "Failed to allocate generic netlink cache.\n");
		err = -ENOMEM;
		goto out_handle_destroy;
	}

	state->nl80211 = genl_ctrl_search_by_name(state->nl_cache, "nl80211");
	if (!state->nl80211) {
		fprintf(stderr, "nl80211 not found.\n");
		err = -ENOENT;
		goto out_cache_free;
	}

	return 0;

 out_cache_free:
	nl_cache_free(state->nl_cache);
 out_handle_destroy:
	nl_socket_free(state->nl_sock);
	return err;
}

static void nl80211_cleanup(struct nl80211_state *state)
{
	genl_family_put(state->nl80211);
	nl_cache_free(state->nl_cache);
	nl_socket_free(state->nl_sock);
}

__COMMAND(NULL, NULL, NULL, 0, 0, 0, CIB_NONE, NULL);
__COMMAND(NULL, NULL, NULL, 1, 0, 0, CIB_NONE, NULL);

static int cmd_size;

static void usage(const char *argv0)
{
	struct cmd *cmd;

	fprintf(stderr, "Usage:\t%s [options] command\n", argv0);
	fprintf(stderr, "Options:\n");
	fprintf(stderr, "\t--debug\t\tenable netlink debugging\n");
	fprintf(stderr, "\t--version\tshow version\n");
	fprintf(stderr, "Commands:\n");
	fprintf(stderr, "\thelp\n");
	fprintf(stderr, "\tevent\n");
	for (cmd = &__start___cmd; cmd < &__stop___cmd;
	     cmd = (struct cmd *)((char *)cmd + cmd_size)) {
		if (!cmd->handler || cmd->hidden)
			continue;
		switch (cmd->idby) {
		case CIB_NONE:
			fprintf(stderr, "\t");
			/* fall through */
		case CIB_PHY:
			if (cmd->idby == CIB_PHY)
				fprintf(stderr, "\tphy <phyname> ");
			/* fall through */
		case CIB_NETDEV:
			if (cmd->idby == CIB_NETDEV)
				fprintf(stderr, "\tdev <devname> ");
			if (cmd->section)
				fprintf(stderr, "%s ", cmd->section);
			fprintf(stderr, "%s", cmd->name);
			if (cmd->args)
				fprintf(stderr, " %s", cmd->args);
			fprintf(stderr, "\n");
			break;
		}
	}
}

static void version(void)
{
	printf("iw version " IW_VERSION "\n");
}

static int phy_lookup(char *name)
{
	char buf[200];
	int fd, pos;

	snprintf(buf, sizeof(buf), "/sys/class/ieee80211/%s/index", name);

	fd = open(buf, O_RDONLY);
	if (fd < 0)
		return -1;
	pos = read(fd, buf, sizeof(buf) - 1);
	if (pos < 0)
		return -1;
	buf[pos] = '\0';
	return atoi(buf);
}

static int error_handler(struct sockaddr_nl *nla, struct nlmsgerr *err,
			 void *arg)
{
	int *ret = arg;
	*ret = err->error;
	return NL_STOP;
}

static int finish_handler(struct nl_msg *msg, void *arg)
{
	int *ret = arg;
	*ret = 0;
	return NL_SKIP;
}

static int ack_handler(struct nl_msg *msg, void *arg)
{
	int *ret = arg;
	*ret = 0;
	return NL_STOP;
}

enum id_input {
	II_NONE,
	II_NETDEV,
	II_PHY_NAME,
	II_PHY_IDX,
};

static int handle_cmd(struct nl80211_state *state,
		      enum id_input idby,
		      int argc, char **argv)
{
	struct cmd *cmd;
	struct nl_cb *cb = NULL;
	struct nl_msg *msg;
	int devidx = 0;
	int err;
	const char *command, *section;
	char *tmp;
	enum command_identify_by command_idby = CIB_NONE;

	if (argc <= 1 && idby != II_NONE)
		return 1;

	switch (idby) {
	case II_PHY_IDX:
		command_idby = CIB_PHY;
		devidx = strtoul(*argv + 4, &tmp, 0);
		if (*tmp != '\0')
			return 1;
		argc--;
		argv++;
		break;
	case II_PHY_NAME:
		command_idby = CIB_PHY;
		devidx = phy_lookup(*argv);
		argc--;
		argv++;
		break;
	case II_NETDEV:
		command_idby = CIB_NETDEV;
		devidx = if_nametoindex(*argv);
		if (devidx == 0)
			devidx = -1;
		argc--;
		argv++;
		break;
	default:
		break;
	}

	if (devidx < 0)
		return -errno;

	section = command = *argv;
	argc--;
	argv++;

	for (cmd = &__start___cmd; cmd < &__stop___cmd;
	     cmd = (struct cmd *)((char *)cmd + cmd_size)) {
		if (!cmd->handler)
			continue;
		if (cmd->idby != command_idby)
			continue;
		if (cmd->section) {
			if (strcmp(cmd->section, section))
				continue;
			/* this is a bit icky ... */
			if (command == section) {
				if (argc <= 0)
					return 1;
				command = *argv;
				argc--;
				argv++;
			}
		} else if (section != command)
			continue;
		if (strcmp(cmd->name, command))
			continue;
		if (argc && !cmd->args)
			continue;
		break;
	}

	if (cmd >= &__stop___cmd)
		return 1;

	msg = nlmsg_alloc();
	if (!msg) {
		fprintf(stderr, "failed to allocate netlink message\n");
		return 2;
	}

	cb = nl_cb_alloc(debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
	if (!cb) {
		fprintf(stderr, "failed to allocate netlink callbacks\n");
		err = 2;
		goto out_free_msg;
	}

	genlmsg_put(msg, 0, 0, genl_family_get_id(state->nl80211), 0,
		    cmd->nl_msg_flags, cmd->cmd, 0);

	switch (command_idby) {
	case CIB_PHY:
		NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, devidx);
		break;
	case CIB_NETDEV:
		NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, devidx);
		break;
	default:
		break;
	}

	err = cmd->handler(cb, msg, argc, argv);
	if (err)
		goto out;

	err = nl_send_auto_complete(state->nl_sock, msg);
	if (err < 0)
		goto out;

	err = 1;

	nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &err);
	nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &err);
	nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &err);

	while (err > 0)
		nl_recvmsgs(state->nl_sock, cb);
 out:
	nl_cb_put(cb);
 out_free_msg:
	nlmsg_free(msg);
	return err;
 nla_put_failure:
	fprintf(stderr, "building message failed\n");
	return 2;
}

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

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];
	char ifname[100];
	__u8 reg_type;

	nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
		  genlmsg_attrlen(gnlh, 0), NULL);
                          
	switch (gnlh->cmd) {
	case NL80211_CMD_NEW_WIPHY:
		printf("wiphy rename: phy #%d to %s\n",
		       nla_get_u32(tb[NL80211_ATTR_WIPHY]),
		       nla_get_string(tb[NL80211_ATTR_WIPHY_NAME]));
		break;
	case NL80211_CMD_NEW_SCAN_RESULTS:
		if_indextoname(nla_get_u32(tb[NL80211_ATTR_IFINDEX]), ifname);
		printf("scan finished on %s (phy #%d)\n",
		       ifname, nla_get_u32(tb[NL80211_ATTR_WIPHY]));
		break;
	case NL80211_CMD_SCAN_ABORTED:
		if_indextoname(nla_get_u32(tb[NL80211_ATTR_IFINDEX]), ifname);
		printf("scan aborted on %s (phy #%d)\n",
		       ifname, nla_get_u32(tb[NL80211_ATTR_WIPHY]));
		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;
	default:
		printf("unknown event: %d\n", gnlh->cmd);
		break;
	}

	return NL_SKIP;
}

static int listen_events(struct nl80211_state *state,
			 int argc, char **argv)
{
	int mcid, ret;
	struct nl_cb *cb = nl_cb_alloc(debug ? NL_CB_DEBUG : NL_CB_DEFAULT);

	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;
	}

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

	while (1)
		nl_recvmsgs(state->nl_sock, cb);

	nl_cb_put(cb);

	return 0;
}

int main(int argc, char **argv)
{
	struct nl80211_state nlstate;
	int err;
	const char *argv0;

	/* calculate command size including padding */
	cmd_size = abs((long)&__cmd_NULL_1_CIB_NONE_0
	             - (long)&__cmd_NULL_0_CIB_NONE_0);
	/* strip off self */
	argc--;
	argv0 = *argv++;

	if (argc > 0 && strcmp(*argv, "--debug") == 0) {
		debug = 1;
		argc--;
		argv++;
	}

	if (argc > 0 && strcmp(*argv, "--version") == 0) {
		version();
		return 0;
	}

	if (argc == 0 || strcmp(*argv, "help") == 0) {
		usage(argv0);
		return 0;
	}

	err = nl80211_init(&nlstate);
	if (err)
		return 1;

	if (strcmp(*argv, "event") == 0) {
		err = listen_events(&nlstate, argc, argv);
	} else if (strcmp(*argv, "dev") == 0) {
		argc--;
		argv++;
		err = handle_cmd(&nlstate, II_NETDEV, argc, argv);
	} else if (strncmp(*argv, "phy", 3) == 0) {
		if (strlen(*argv) == 3) {
			argc--;
			argv++;
			err = handle_cmd(&nlstate, II_PHY_NAME, argc, argv);
		} else if (*(*argv + 3) == '#')
			err = handle_cmd(&nlstate, II_PHY_IDX, argc, argv);
		else
			err = 1;
	} else
		err = handle_cmd(&nlstate, II_NONE, argc, argv);

	if (err == 1)
		usage(argv0);
	if (err < 0)
		fprintf(stderr, "command failed: %s (%d)\n", strerror(-err), err);

	nl80211_cleanup(&nlstate);

	return err;
}
Commit	Line	Data
cad53b3f JB	1	/*
	2	* nl80211 userspace tool
	3	*
2a1fced2	4	* Copyright 2007, 2008 Johannes Berg <johannes@sipsolutions.net>
cad53b3f JB	5	*/
	6
	7	#include <errno.h>
	8	#include <stdio.h>
d5ac8ad3	9	#include <string.h>
bd396f2a JB	10	#include <net/if.h>
	11	#include <sys/types.h>
	12	#include <sys/stat.h>
	13	#include <fcntl.h>
	14	#include <unistd.h>
	15
cad53b3f JB	16	#include <netlink/genl/genl.h>
	17	#include <netlink/genl/family.h>
	18	#include <netlink/genl/ctrl.h>
	19	#include <netlink/msg.h>
	20	#include <netlink/attr.h>
cad53b3f	21
f408e01b	22	#include "nl80211.h"
cad53b3f	23	#include "iw.h"
d711f013	24	#include "version.h"
cad53b3f	25
dfd13ee5 PE	26	#ifndef CONFIG_LIBNL20
	27	/* libnl 2.0 compatibility code */
	28
	29	static inline struct nl_handle *nl_socket_alloc(void)
	30	{
	31	return nl_handle_alloc();
	32	}
	33
57077d64	34	static inline void nl_socket_free(struct nl_sock *h)
dfd13ee5 PE	35	{
	36	nl_handle_destroy(h);
	37	}
	38
57077d64	39	static inline int __genl_ctrl_alloc_cache(struct nl_sock h, struct nl_cache *cache)
dfd13ee5 PE	40	{
	41	struct nl_cache *tmp = genl_ctrl_alloc_cache(h);
	42	if (!tmp)
	43	return -ENOMEM;
	44	*cache = tmp;
	45	return 0;
	46	}
	47	#define genl_ctrl_alloc_cache __genl_ctrl_alloc_cache
	48	#endif /* CONFIG_LIBNL20 */
	49
656aa246	50	static int debug = 0;
cad53b3f JB	51
	52	static int nl80211_init(struct nl80211_state *state)
	53	{
	54	int err;
	55
57077d64 PE	56	state->nl_sock = nl_socket_alloc();
	57	if (!state->nl_sock) {
	58	fprintf(stderr, "Failed to allocate netlink socket.\n");
cad53b3f JB	59	return -ENOMEM;
	60	}
	61
57077d64	62	if (genl_connect(state->nl_sock)) {
cad53b3f JB	63	fprintf(stderr, "Failed to connect to generic netlink.\n");
	64	err = -ENOLINK;
	65	goto out_handle_destroy;
	66	}
	67
57077d64	68	if (genl_ctrl_alloc_cache(state->nl_sock, &state->nl_cache)) {
cad53b3f JB	69	fprintf(stderr, "Failed to allocate generic netlink cache.\n");
	70	err = -ENOMEM;
	71	goto out_handle_destroy;
	72	}
	73
	74	state->nl80211 = genl_ctrl_search_by_name(state->nl_cache, "nl80211");
	75	if (!state->nl80211) {
	76	fprintf(stderr, "nl80211 not found.\n");
	77	err = -ENOENT;
	78	goto out_cache_free;
	79	}
	80
	81	return 0;
	82
	83	out_cache_free:
	84	nl_cache_free(state->nl_cache);
	85	out_handle_destroy:
57077d64	86	nl_socket_free(state->nl_sock);
cad53b3f JB	87	return err;
	88	}
	89
	90	static void nl80211_cleanup(struct nl80211_state *state)
	91	{
	92	genl_family_put(state->nl80211);
	93	nl_cache_free(state->nl_cache);
57077d64	94	nl_socket_free(state->nl_sock);
cad53b3f JB	95	}
cad53b3f JB	96
ce5af55c JB	97	__COMMAND(NULL, NULL, NULL, 0, 0, 0, CIB_NONE, NULL);
ce5af55c JB	98	__COMMAND(NULL, NULL, NULL, 1, 0, 0, CIB_NONE, NULL);
403b9c83 JB	99
	100	static int cmd_size;
	101
bd396f2a JB	102	static void usage(const char *argv0)
	103	{
	104	struct cmd *cmd;
	105
59c49f09 JB	106	fprintf(stderr, "Usage:\t%s [options] command\n", argv0);
59c49f09 JB	107	fprintf(stderr, "Options:\n");
d711f013 JB	108	fprintf(stderr, "\t--debug\t\tenable netlink debugging\n");
d711f013 JB	109	fprintf(stderr, "\t--version\tshow version\n");
59c49f09	110	fprintf(stderr, "Commands:\n");
2c61ba61 JB	111	fprintf(stderr, "\thelp\n");
2c61ba61 JB	112	fprintf(stderr, "\tevent\n");
403b9c83 JB	113	for (cmd = &__start___cmd; cmd < &__stop___cmd;
403b9c83 JB	114	cmd = (struct cmd )((char )cmd + cmd_size)) {
ce5af55c	115	if (!cmd->handler \|\| cmd->hidden)
403b9c83	116	continue;
bd396f2a JB	117	switch (cmd->idby) {
bd396f2a JB	118	case CIB_NONE:
59c49f09	119	fprintf(stderr, "\t");
d631650b	120	/* fall through */
bd396f2a	121	case CIB_PHY:
d631650b	122	if (cmd->idby == CIB_PHY)
59c49f09	123	fprintf(stderr, "\tphy <phyname> ");
bd396f2a JB	124	/* fall through */
	125	case CIB_NETDEV:
	126	if (cmd->idby == CIB_NETDEV)
59c49f09	127	fprintf(stderr, "\tdev <devname> ");
bd396f2a JB	128	if (cmd->section)
	129	fprintf(stderr, "%s ", cmd->section);
	130	fprintf(stderr, "%s", cmd->name);
	131	if (cmd->args)
	132	fprintf(stderr, " %s", cmd->args);
	133	fprintf(stderr, "\n");
	134	break;
	135	}
	136	}
	137	}
	138
d711f013 JB	139	static void version(void)
d711f013 JB	140	{
2dc285b7	141	printf("iw version " IW_VERSION "\n");
d711f013 JB	142	}
d711f013 JB	143
bd396f2a JB	144	static int phy_lookup(char *name)
	145	{
	146	char buf[200];
	147	int fd, pos;
	148
	149	snprintf(buf, sizeof(buf), "/sys/class/ieee80211/%s/index", name);
	150
	151	fd = open(buf, O_RDONLY);
989e97c2 JB	152	if (fd < 0)
989e97c2 JB	153	return -1;
bd396f2a JB	154	pos = read(fd, buf, sizeof(buf) - 1);
	155	if (pos < 0)
	156	return -1;
	157	buf[pos] = '\0';
	158	return atoi(buf);
	159	}
	160
70391ccf JB	161	static int error_handler(struct sockaddr_nl nla, struct nlmsgerr err,
	162	void *arg)
	163	{
	164	int *ret = arg;
	165	*ret = err->error;
	166	return NL_STOP;
	167	}
	168
561c5b7e JB	169	static int finish_handler(struct nl_msg msg, void arg)
561c5b7e JB	170	{
59c418c0 JB	171	int *ret = arg;
59c418c0 JB	172	*ret = 0;
561c5b7e JB	173	return NL_SKIP;
	174	}
	175
	176	static int ack_handler(struct nl_msg msg, void arg)
70391ccf JB	177	{
	178	int *ret = arg;
	179	*ret = 0;
	180	return NL_STOP;
	181	}
	182
9927363c JB	183	enum id_input {
	184	II_NONE,
	185	II_NETDEV,
	186	II_PHY_NAME,
	187	II_PHY_IDX,
	188	};
	189
d631650b	190	static int handle_cmd(struct nl80211_state *state,
9927363c	191	enum id_input idby,
d631650b	192	int argc, char **argv)
45c7212c	193	{
bd396f2a	194	struct cmd *cmd;
70391ccf	195	struct nl_cb *cb = NULL;
bd396f2a JB	196	struct nl_msg *msg;
bd396f2a JB	197	int devidx = 0;
70391ccf	198	int err;
bd396f2a	199	const char command, section;
9927363c JB	200	char *tmp;
9927363c JB	201	enum command_identify_by command_idby = CIB_NONE;
45c7212c	202
9927363c	203	if (argc <= 1 && idby != II_NONE)
5e75fd04	204	return 1;
45c7212c	205
bd396f2a	206	switch (idby) {
9927363c JB	207	case II_PHY_IDX:
	208	command_idby = CIB_PHY;
	209	devidx = strtoul(*argv + 4, &tmp, 0);
	210	if (*tmp != '\0')
	211	return 1;
	212	argc--;
	213	argv++;
	214	break;
	215	case II_PHY_NAME:
	216	command_idby = CIB_PHY;
bd396f2a JB	217	devidx = phy_lookup(*argv);
	218	argc--;
	219	argv++;
	220	break;
9927363c JB	221	case II_NETDEV:
9927363c JB	222	command_idby = CIB_NETDEV;
bd396f2a	223	devidx = if_nametoindex(*argv);
989e97c2 JB	224	if (devidx == 0)
989e97c2 JB	225	devidx = -1;
bd396f2a JB	226	argc--;
	227	argv++;
	228	break;
	229	default:
	230	break;
	231	}
	232
989e97c2 JB	233	if (devidx < 0)
	234	return -errno;
	235
bd396f2a JB	236	section = command = *argv;
	237	argc--;
	238	argv++;
	239
403b9c83 JB	240	for (cmd = &__start___cmd; cmd < &__stop___cmd;
	241	cmd = (struct cmd )((char )cmd + cmd_size)) {
	242	if (!cmd->handler)
	243	continue;
9927363c	244	if (cmd->idby != command_idby)
bd396f2a JB	245	continue;
	246	if (cmd->section) {
	247	if (strcmp(cmd->section, section))
	248	continue;
	249	/* this is a bit icky ... */
	250	if (command == section) {
	251	if (argc <= 0)
5e75fd04	252	return 1;
bd396f2a JB	253	command = *argv;
	254	argc--;
	255	argv++;
	256	}
	257	} else if (section != command)
	258	continue;
	259	if (strcmp(cmd->name, command))
	260	continue;
	261	if (argc && !cmd->args)
	262	continue;
	263	break;
	264	}
45c7212c	265
74701031	266	if (cmd >= &__stop___cmd)
5e75fd04	267	return 1;
45c7212c	268
bd396f2a JB	269	msg = nlmsg_alloc();
bd396f2a JB	270	if (!msg) {
70391ccf JB	271	fprintf(stderr, "failed to allocate netlink message\n");
	272	return 2;
	273	}
	274
59c49f09	275	cb = nl_cb_alloc(debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
70391ccf JB	276	if (!cb) {
	277	fprintf(stderr, "failed to allocate netlink callbacks\n");
	278	err = 2;
	279	goto out_free_msg;
bd396f2a	280	}
45c7212c	281
bd396f2a JB	282	genlmsg_put(msg, 0, 0, genl_family_get_id(state->nl80211), 0,
	283	cmd->nl_msg_flags, cmd->cmd, 0);
	284
9927363c	285	switch (command_idby) {
bd396f2a JB	286	case CIB_PHY:
	287	NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, devidx);
	288	break;
	289	case CIB_NETDEV:
	290	NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, devidx);
	291	break;
	292	default:
	293	break;
	294	}
	295
70391ccf JB	296	err = cmd->handler(cb, msg, argc, argv);
	297	if (err)
	298	goto out;
	299
57077d64	300	err = nl_send_auto_complete(state->nl_sock, msg);
70391ccf JB	301	if (err < 0)
	302	goto out;
	303
c5c4471a JB	304	err = 1;
c5c4471a JB	305
70391ccf	306	nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &err);
59c418c0	307	nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &err);
561c5b7e	308	nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &err);
70391ccf	309
c5c4471a	310	while (err > 0)
57077d64	311	nl_recvmsgs(state->nl_sock, cb);
70391ccf JB	312	out:
	313	nl_cb_put(cb);
	314	out_free_msg:
	315	nlmsg_free(msg);
	316	return err;
bd396f2a JB	317	nla_put_failure:
bd396f2a JB	318	fprintf(stderr, "building message failed\n");
70391ccf	319	return 2;
45c7212c JB	320	}
45c7212c JB	321
2c61ba61 JB	322	static int no_seq_check(struct nl_msg msg, void arg)
	323	{
	324	return NL_OK;
	325	}
	326
	327	static int print_event(struct nl_msg msg, void arg)
	328	{
	329	struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
	330	struct nlattr *tb[NL80211_ATTR_MAX + 1];
99f46802	331	char ifname[100];
601c6ab2	332	__u8 reg_type;
2c61ba61 JB	333
	334	nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
	335	genlmsg_attrlen(gnlh, 0), NULL);
	336
	337	switch (gnlh->cmd) {
03109dcb	338	case NL80211_CMD_NEW_WIPHY:
2c61ba61 JB	339	printf("wiphy rename: phy #%d to %s\n",
	340	nla_get_u32(tb[NL80211_ATTR_WIPHY]),
	341	nla_get_string(tb[NL80211_ATTR_WIPHY_NAME]));
	342	break;
99f46802 JB	343	case NL80211_CMD_NEW_SCAN_RESULTS:
	344	if_indextoname(nla_get_u32(tb[NL80211_ATTR_IFINDEX]), ifname);
	345	printf("scan finished on %s (phy #%d)\n",
	346	ifname, nla_get_u32(tb[NL80211_ATTR_WIPHY]));
	347	break;
	348	case NL80211_CMD_SCAN_ABORTED:
	349	if_indextoname(nla_get_u32(tb[NL80211_ATTR_IFINDEX]), ifname);
	350	printf("scan aborted on %s (phy #%d)\n",
	351	ifname, nla_get_u32(tb[NL80211_ATTR_WIPHY]));
	352	break;
601c6ab2 LR	353	case NL80211_CMD_REG_CHANGE:
	354
	355	printf("regulatory domain change: ");
	356
	357	reg_type = nla_get_u8(tb[NL80211_ATTR_REG_TYPE]);
	358
	359	switch (reg_type) {
	360	case NL80211_REGDOM_TYPE_COUNTRY:
	361	printf("set to %s by %s request",
	362	nla_get_string(tb[NL80211_ATTR_REG_ALPHA2]),
	363	reg_initiator_to_string(nla_get_u8(tb[NL80211_ATTR_REG_INITIATOR])));
	364	if (tb[NL80211_ATTR_WIPHY])
	365	printf(" on phy%d", nla_get_u32(tb[NL80211_ATTR_WIPHY]));
	366	break;
	367	case NL80211_REGDOM_TYPE_WORLD:
	368	printf("set to world roaming by %s request",
	369	reg_initiator_to_string(nla_get_u8(tb[NL80211_ATTR_REG_INITIATOR])));
	370	break;
	371	case NL80211_REGDOM_TYPE_CUSTOM_WORLD:
	372	printf("custom world roaming rules in place on phy%d by %s request",
	373	nla_get_u32(tb[NL80211_ATTR_WIPHY]),
	374	reg_initiator_to_string(nla_get_u32(tb[NL80211_ATTR_REG_INITIATOR])));
	375	break;
	376	case NL80211_REGDOM_TYPE_INTERSECTION:
	377	printf("intersection used due to a request made by %s",
	378	reg_initiator_to_string(nla_get_u32(tb[NL80211_ATTR_REG_INITIATOR])));
	379	if (tb[NL80211_ATTR_WIPHY])
	380	printf(" on phy%d", nla_get_u32(tb[NL80211_ATTR_WIPHY]));
	381	break;
	382	default:
	383	printf("unknown source (upgrade this utility)");
	384	break;
	385	}
	386
	387	printf("\n");
	388	break;
03109dcb JB	389	default:
	390	printf("unknown event: %d\n", gnlh->cmd);
	391	break;
2c61ba61 JB	392	}
	393
	394	return NL_SKIP;
	395	}
	396
	397	static int listen_events(struct nl80211_state *state,
	398	int argc, char **argv)
	399	{
	400	int mcid, ret;
	401	struct nl_cb *cb = nl_cb_alloc(debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
	402
	403	if (!cb) {
	404	fprintf(stderr, "failed to allocate netlink callbacks\n");
	405	return -ENOMEM;
	406	}
	407
601c6ab2	408	/* Configuration multicast group */
57077d64	409	mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "config");
2c61ba61 JB	410	if (mcid < 0)
	411	return mcid;
	412
57077d64	413	ret = nl_socket_add_membership(state->nl_sock, mcid);
2c61ba61 JB	414	if (ret)
2c61ba61 JB	415	return ret;
99f46802	416
601c6ab2	417	/* Scan multicast group */
99f46802	418	mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "scan");
5406d9e4 JB	419	if (mcid >= 0) {
	420	ret = nl_socket_add_membership(state->nl_sock, mcid);
	421	if (ret)
	422	return ret;
	423	}
99f46802	424
601c6ab2 LR	425	/* Regulatory multicast group */
	426	mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "regulatory");
	427	if (mcid >= 0) {
	428	ret = nl_socket_add_membership(state->nl_sock, mcid);
	429	if (ret)
	430	return ret;
	431	}
	432
2c61ba61 JB	433	/* no sequence checking for multicast messages */
	434	nl_cb_set(cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, no_seq_check, NULL);
	435	nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, print_event, NULL);
	436
	437	while (1)
57077d64	438	nl_recvmsgs(state->nl_sock, cb);
2c61ba61 JB	439
	440	nl_cb_put(cb);
	441
	442	return 0;
	443	}
	444
cad53b3f JB	445	int main(int argc, char **argv)
	446	{
	447	struct nl80211_state nlstate;
bd396f2a JB	448	int err;
bd396f2a JB	449	const char *argv0;
cad53b3f	450
f408e01b	451	/* calculate command size including padding */
ce5af55c JB	452	cmd_size = abs((long)&__cmd_NULL_1_CIB_NONE_0
ce5af55c JB	453	- (long)&__cmd_NULL_0_CIB_NONE_0);
45c7212c JB	454	/* strip off self */
45c7212c JB	455	argc--;
1cdd9016 MK	456	argv0 = *argv++;
1cdd9016 MK	457
59c49f09 JB	458	if (argc > 0 && strcmp(*argv, "--debug") == 0) {
	459	debug = 1;
	460	argc--;
	461	argv++;
	462	}
	463
d711f013 JB	464	if (argc > 0 && strcmp(*argv, "--version") == 0) {
	465	version();
	466	return 0;
	467	}
	468
bd396f2a	469	if (argc == 0 \|\| strcmp(*argv, "help") == 0) {
1cdd9016	470	usage(argv0);
4a972f80	471	return 0;
1cdd9016	472	}
45c7212c	473
2bdb6bd1 JB	474	err = nl80211_init(&nlstate);
	475	if (err)
	476	return 1;
	477
2c61ba61 JB	478	if (strcmp(*argv, "event") == 0) {
	479	err = listen_events(&nlstate, argc, argv);
	480	} else if (strcmp(*argv, "dev") == 0) {
14a0380d LR	481	argc--;
14a0380d LR	482	argv++;
9927363c JB	483	err = handle_cmd(&nlstate, II_NETDEV, argc, argv);
	484	} else if (strncmp(*argv, "phy", 3) == 0) {
	485	if (strlen(*argv) == 3) {
	486	argc--;
	487	argv++;
	488	err = handle_cmd(&nlstate, II_PHY_NAME, argc, argv);
	489	} else if ((argv + 3) == '#')
	490	err = handle_cmd(&nlstate, II_PHY_IDX, argc, argv);
	491	else
	492	err = 1;
bd396f2a	493	} else
9927363c	494	err = handle_cmd(&nlstate, II_NONE, argc, argv);
45c7212c	495
5e75fd04	496	if (err == 1)
bd396f2a	497	usage(argv0);
5e75fd04	498	if (err < 0)
b49be3e1	499	fprintf(stderr, "command failed: %s (%d)\n", strerror(-err), err);
cad53b3f JB	500
	501	nl80211_cleanup(&nlstate);
	502
45c7212c	503	return err;
cad53b3f	504	}