[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 <stdbool.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"

#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 */

int iw_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, NULL);
__COMMAND(NULL, NULL, "", NULL, 1, 0, 0, CIB_NONE, NULL, NULL);

static int cmd_size;

static void __usage_cmd(struct cmd *cmd, char *indent, bool full)
{
	const char *start, *lend, *end;

	fprintf(stderr, "%s", indent);

	switch (cmd->idby) {
	case CIB_NONE:
		break;
	case CIB_PHY:
		fprintf(stderr, "phy <phyname> ");
		break;
	case CIB_NETDEV:
		fprintf(stderr, "dev <devname> ");
		break;
	}
	if (cmd->section)
		fprintf(stderr, "%s ", cmd->section);
	fprintf(stderr, "%s", cmd->name);
	if (cmd->args)
		fprintf(stderr, " %s", cmd->args);
	fprintf(stderr, "\n");

	if (!full || !cmd->help)
		return;

	/* hack */
	if (strlen(indent))
		indent = "\t\t";
	else
		fprintf(stderr, "\n");

	/* print line by line */
	start = cmd->help;
	end = strchr(start, '\0');
	do {
		lend = strchr(start, '\n');
		if (!lend)
			lend = end;
		fprintf(stderr, "%s", indent);
		fprintf(stderr, "%.*s\n", (int)(lend - start), start);
		start = lend + 1;
	} while (end != lend);

	fprintf(stderr, "\n");
}

static void usage_options(void)
{
	fprintf(stderr, "Options:\n");
	fprintf(stderr, "\t--debug\t\tenable netlink debugging\n");
}

static const char *argv0;

static void usage(bool full)
{
	struct cmd *cmd;

	fprintf(stderr, "Usage:\t%s [options] command\n", argv0);
	usage_options();
	fprintf(stderr, "\t--version\tshow version (%s)\n", iw_version);
	fprintf(stderr, "Commands:\n");
	for (cmd = &__start___cmd; cmd < &__stop___cmd;
	     cmd = (struct cmd *)((char *)cmd + cmd_size)) {
		if (!cmd->handler || cmd->hidden)
			continue;
		__usage_cmd(cmd, "\t", full);
	}
}

static int print_help(struct nl80211_state *state,
		      struct nl_cb *cb,
		      struct nl_msg *msg,
		      int argc, char **argv)
{
	exit(3);
}
TOPLEVEL(help, NULL, 0, 0, CIB_NONE, print_help,
	 "Print usage for each command.");

static void usage_cmd(struct cmd *cmd)
{
	fprintf(stderr, "Usage:\t%s [options] ", argv0);
	__usage_cmd(cmd, "", true);
	usage_options();
}

static void version(void)
{
	printf("iw version %s\n", iw_version);
}

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

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

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

	o_argc = argc;
	o_argv = argv;

	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) {
					if (match)
						break;
					return 1;
				}
				command = *argv;
				argc--;
				argv++;
			}
		} else if (section != command)
			continue;
		if (strcmp(cmd->name, command))
			continue;
		if (argc && !cmd->args)
			continue;

		match = cmd;
	}

	cmd = match;

	if (!cmd)
		return 1;

	if (cmdout)
		*cmdout = cmd;

	if (!cmd->cmd) {
		argc = o_argc;
		argv = o_argv;
		return cmd->handler(state, NULL, NULL, argc, argv);
	}

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

	cb = nl_cb_alloc(iw_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(state, 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;
}

int handle_cmd(struct nl80211_state *state, enum id_input idby,
	       int argc, char **argv)
{
	return __handle_cmd(state, idby, argc, argv, NULL);
}

int main(int argc, char **argv)
{
	struct nl80211_state nlstate;
	int err;
	struct cmd *cmd = NULL;

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

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

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

	/* need to treat "help" command specially so it works w/o nl80211 */
	if (argc == 0 || strcmp(*argv, "help") == 0) {
		usage(argc != 0);
		return 0;
	}

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

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

	if (err == 1) {
		if (cmd)
			usage_cmd(cmd);
		else
			usage(false);
	} else 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>
27c49ed6	15	#include <stdbool.h>
bd396f2a	16
cad53b3f JB	17	#include <netlink/genl/genl.h>
	18	#include <netlink/genl/family.h>
	19	#include <netlink/genl/ctrl.h>
	20	#include <netlink/msg.h>
	21	#include <netlink/attr.h>
cad53b3f	22
f408e01b	23	#include "nl80211.h"
cad53b3f JB	24	#include "iw.h"
cad53b3f JB	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
957a0f07	50	int iw_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
01ae06f9 JB	97	__COMMAND(NULL, NULL, "", NULL, 0, 0, 0, CIB_NONE, NULL, NULL);
01ae06f9 JB	98	__COMMAND(NULL, NULL, "", NULL, 1, 0, 0, CIB_NONE, NULL, NULL);
403b9c83 JB	99
	100	static int cmd_size;
	101
01ae06f9	102	static void __usage_cmd(struct cmd cmd, char indent, bool full)
3bb116da	103	{
01ae06f9 JB	104	const char start, lend, *end;
01ae06f9 JB	105
4f0cae73 JB	106	fprintf(stderr, "%s", indent);
4f0cae73 JB	107
3bb116da JB	108	switch (cmd->idby) {
3bb116da JB	109	case CIB_NONE:
3bb116da JB	110	break;
3bb116da JB	111	case CIB_PHY:
4f0cae73	112	fprintf(stderr, "phy <phyname> ");
3bb116da JB	113	break;
3bb116da JB	114	case CIB_NETDEV:
4f0cae73	115	fprintf(stderr, "dev <devname> ");
3bb116da JB	116	break;
	117	}
	118	if (cmd->section)
	119	fprintf(stderr, "%s ", cmd->section);
	120	fprintf(stderr, "%s", cmd->name);
	121	if (cmd->args)
	122	fprintf(stderr, " %s", cmd->args);
	123	fprintf(stderr, "\n");
01ae06f9 JB	124
	125	if (!full \|\| !cmd->help)
	126	return;
	127
	128	/* hack */
	129	if (strlen(indent))
	130	indent = "\t\t";
	131	else
	132	fprintf(stderr, "\n");
	133
	134	/* print line by line */
	135	start = cmd->help;
	136	end = strchr(start, '\0');
	137	do {
	138	lend = strchr(start, '\n');
	139	if (!lend)
	140	lend = end;
	141	fprintf(stderr, "%s", indent);
	142	fprintf(stderr, "%.*s\n", (int)(lend - start), start);
	143	start = lend + 1;
	144	} while (end != lend);
	145
	146	fprintf(stderr, "\n");
3bb116da JB	147	}
3bb116da JB	148
4f0cae73 JB	149	static void usage_options(void)
	150	{
	151	fprintf(stderr, "Options:\n");
	152	fprintf(stderr, "\t--debug\t\tenable netlink debugging\n");
	153	}
	154
01ae06f9 JB	155	static const char *argv0;
	156
	157	static void usage(bool full)
bd396f2a JB	158	{
	159	struct cmd *cmd;
	160
59c49f09	161	fprintf(stderr, "Usage:\t%s [options] command\n", argv0);
4f0cae73	162	usage_options();
21e708e5	163	fprintf(stderr, "\t--version\tshow version (%s)\n", iw_version);
59c49f09	164	fprintf(stderr, "Commands:\n");
403b9c83 JB	165	for (cmd = &__start___cmd; cmd < &__stop___cmd;
403b9c83 JB	166	cmd = (struct cmd )((char )cmd + cmd_size)) {
ce5af55c	167	if (!cmd->handler \|\| cmd->hidden)
403b9c83	168	continue;
01ae06f9	169	__usage_cmd(cmd, "\t", full);
bd396f2a JB	170	}
	171	}
	172
01ae06f9 JB	173	static int print_help(struct nl80211_state *state,
	174	struct nl_cb *cb,
	175	struct nl_msg *msg,
	176	int argc, char **argv)
	177	{
	178	exit(3);
	179	}
	180	TOPLEVEL(help, NULL, 0, 0, CIB_NONE, print_help,
	181	"Print usage for each command.");
	182
	183	static void usage_cmd(struct cmd *cmd)
4f0cae73 JB	184	{
4f0cae73 JB	185	fprintf(stderr, "Usage:\t%s [options] ", argv0);
01ae06f9	186	__usage_cmd(cmd, "", true);
4f0cae73 JB	187	usage_options();
	188	}
	189
d711f013 JB	190	static void version(void)
d711f013 JB	191	{
133b069f	192	printf("iw version %s\n", iw_version);
d711f013 JB	193	}
d711f013 JB	194
bd396f2a JB	195	static int phy_lookup(char *name)
	196	{
	197	char buf[200];
	198	int fd, pos;
	199
	200	snprintf(buf, sizeof(buf), "/sys/class/ieee80211/%s/index", name);
	201
	202	fd = open(buf, O_RDONLY);
989e97c2 JB	203	if (fd < 0)
989e97c2 JB	204	return -1;
bd396f2a JB	205	pos = read(fd, buf, sizeof(buf) - 1);
	206	if (pos < 0)
	207	return -1;
	208	buf[pos] = '\0';
	209	return atoi(buf);
	210	}
	211
70391ccf JB	212	static int error_handler(struct sockaddr_nl nla, struct nlmsgerr err,
	213	void *arg)
	214	{
	215	int *ret = arg;
	216	*ret = err->error;
	217	return NL_STOP;
	218	}
	219
561c5b7e JB	220	static int finish_handler(struct nl_msg msg, void arg)
561c5b7e JB	221	{
59c418c0 JB	222	int *ret = arg;
59c418c0 JB	223	*ret = 0;
561c5b7e JB	224	return NL_SKIP;
	225	}
	226
	227	static int ack_handler(struct nl_msg msg, void arg)
70391ccf JB	228	{
	229	int *ret = arg;
	230	*ret = 0;
	231	return NL_STOP;
	232	}
	233
4f0cae73 JB	234	static int __handle_cmd(struct nl80211_state *state, enum id_input idby,
4f0cae73 JB	235	int argc, char argv, struct cmd cmdout)
45c7212c	236	{
bb60b4ae	237	struct cmd cmd, match = NULL;
7c37a24d	238	struct nl_cb *cb;
bd396f2a JB	239	struct nl_msg *msg;
bd396f2a JB	240	int devidx = 0;
bb60b4ae	241	int err, o_argc;
bd396f2a	242	const char command, section;
bb60b4ae	243	char tmp, *o_argv;
9927363c	244	enum command_identify_by command_idby = CIB_NONE;
45c7212c	245
9927363c	246	if (argc <= 1 && idby != II_NONE)
5e75fd04	247	return 1;
45c7212c	248
bb60b4ae JB	249	o_argc = argc;
	250	o_argv = argv;
	251
bd396f2a	252	switch (idby) {
9927363c JB	253	case II_PHY_IDX:
	254	command_idby = CIB_PHY;
	255	devidx = strtoul(*argv + 4, &tmp, 0);
	256	if (*tmp != '\0')
	257	return 1;
	258	argc--;
	259	argv++;
	260	break;
	261	case II_PHY_NAME:
	262	command_idby = CIB_PHY;
bd396f2a JB	263	devidx = phy_lookup(*argv);
	264	argc--;
	265	argv++;
	266	break;
9927363c JB	267	case II_NETDEV:
9927363c JB	268	command_idby = CIB_NETDEV;
bd396f2a	269	devidx = if_nametoindex(*argv);
989e97c2 JB	270	if (devidx == 0)
989e97c2 JB	271	devidx = -1;
bd396f2a JB	272	argc--;
	273	argv++;
	274	break;
	275	default:
	276	break;
	277	}
	278
989e97c2 JB	279	if (devidx < 0)
	280	return -errno;
	281
bd396f2a JB	282	section = command = *argv;
	283	argc--;
	284	argv++;
	285
403b9c83 JB	286	for (cmd = &__start___cmd; cmd < &__stop___cmd;
	287	cmd = (struct cmd )((char )cmd + cmd_size)) {
	288	if (!cmd->handler)
	289	continue;
9927363c	290	if (cmd->idby != command_idby)
bd396f2a JB	291	continue;
	292	if (cmd->section) {
	293	if (strcmp(cmd->section, section))
	294	continue;
	295	/* this is a bit icky ... */
	296	if (command == section) {
bb60b4ae JB	297	if (argc <= 0) {
	298	if (match)
	299	break;
5e75fd04	300	return 1;
bb60b4ae	301	}
bd396f2a JB	302	command = *argv;
	303	argc--;
	304	argv++;
	305	}
	306	} else if (section != command)
	307	continue;
	308	if (strcmp(cmd->name, command))
	309	continue;
	310	if (argc && !cmd->args)
	311	continue;
bb60b4ae JB	312
bb60b4ae JB	313	match = cmd;
bd396f2a	314	}
45c7212c	315
bb60b4ae JB	316	cmd = match;
	317
	318	if (!cmd)
5e75fd04	319	return 1;
45c7212c	320
4f0cae73 JB	321	if (cmdout)
	322	*cmdout = cmd;
	323
bb60b4ae JB	324	if (!cmd->cmd) {
	325	argc = o_argc;
	326	argv = o_argv;
	327	return cmd->handler(state, NULL, NULL, argc, argv);
	328	}
	329
bd396f2a JB	330	msg = nlmsg_alloc();
bd396f2a JB	331	if (!msg) {
70391ccf JB	332	fprintf(stderr, "failed to allocate netlink message\n");
	333	return 2;
	334	}
	335
957a0f07	336	cb = nl_cb_alloc(iw_debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
70391ccf JB	337	if (!cb) {
	338	fprintf(stderr, "failed to allocate netlink callbacks\n");
	339	err = 2;
	340	goto out_free_msg;
bd396f2a	341	}
45c7212c	342
bd396f2a JB	343	genlmsg_put(msg, 0, 0, genl_family_get_id(state->nl80211), 0,
	344	cmd->nl_msg_flags, cmd->cmd, 0);
	345
9927363c	346	switch (command_idby) {
bd396f2a JB	347	case CIB_PHY:
	348	NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, devidx);
	349	break;
	350	case CIB_NETDEV:
	351	NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, devidx);
	352	break;
	353	default:
	354	break;
	355	}
	356
7c37a24d	357	err = cmd->handler(state, cb, msg, argc, argv);
70391ccf JB	358	if (err)
	359	goto out;
	360
57077d64	361	err = nl_send_auto_complete(state->nl_sock, msg);
70391ccf JB	362	if (err < 0)
	363	goto out;
	364
c5c4471a JB	365	err = 1;
c5c4471a JB	366
70391ccf	367	nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &err);
59c418c0	368	nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &err);
561c5b7e	369	nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &err);
70391ccf	370
c5c4471a	371	while (err > 0)
57077d64	372	nl_recvmsgs(state->nl_sock, cb);
70391ccf JB	373	out:
	374	nl_cb_put(cb);
	375	out_free_msg:
	376	nlmsg_free(msg);
	377	return err;
bd396f2a JB	378	nla_put_failure:
bd396f2a JB	379	fprintf(stderr, "building message failed\n");
70391ccf	380	return 2;
45c7212c JB	381	}
45c7212c JB	382
4f0cae73 JB	383	int handle_cmd(struct nl80211_state *state, enum id_input idby,
	384	int argc, char **argv)
	385	{
	386	return __handle_cmd(state, idby, argc, argv, NULL);
	387	}
	388
cad53b3f JB	389	int main(int argc, char **argv)
	390	{
	391	struct nl80211_state nlstate;
bd396f2a	392	int err;
4f0cae73	393	struct cmd *cmd = NULL;
cad53b3f	394
f408e01b	395	/* calculate command size including padding */
811ec68f JB	396	cmd_size = abs((long)&__cmd_NULL_NULL_1_CIB_NONE_0
811ec68f JB	397	- (long)&__cmd_NULL_NULL_0_CIB_NONE_0);
45c7212c JB	398	/* strip off self */
45c7212c JB	399	argc--;
1cdd9016 MK	400	argv0 = *argv++;
1cdd9016 MK	401
59c49f09	402	if (argc > 0 && strcmp(*argv, "--debug") == 0) {
957a0f07	403	iw_debug = 1;
59c49f09 JB	404	argc--;
	405	argv++;
	406	}
	407
d711f013 JB	408	if (argc > 0 && strcmp(*argv, "--version") == 0) {
	409	version();
	410	return 0;
	411	}
	412
01ae06f9	413	/* need to treat "help" command specially so it works w/o nl80211 */
bd396f2a	414	if (argc == 0 \|\| strcmp(*argv, "help") == 0) {
01ae06f9	415	usage(argc != 0);
4a972f80	416	return 0;
1cdd9016	417	}
45c7212c	418
2bdb6bd1 JB	419	err = nl80211_init(&nlstate);
	420	if (err)
	421	return 1;
	422
957a0f07	423	if (strcmp(*argv, "dev") == 0 && argc > 1) {
14a0380d LR	424	argc--;
14a0380d LR	425	argv++;
4f0cae73	426	err = __handle_cmd(&nlstate, II_NETDEV, argc, argv, &cmd);
811ec68f	427	} else if (strncmp(*argv, "phy", 3) == 0 && argc > 1) {
9927363c JB	428	if (strlen(*argv) == 3) {
	429	argc--;
	430	argv++;
4f0cae73	431	err = __handle_cmd(&nlstate, II_PHY_NAME, argc, argv, &cmd);
9927363c	432	} else if ((argv + 3) == '#')
4f0cae73	433	err = __handle_cmd(&nlstate, II_PHY_IDX, argc, argv, &cmd);
9927363c JB	434	else
9927363c JB	435	err = 1;
bd396f2a	436	} else
4f0cae73	437	err = __handle_cmd(&nlstate, II_NONE, argc, argv, &cmd);
45c7212c	438
4f0cae73 JB	439	if (err == 1) {
4f0cae73 JB	440	if (cmd)
01ae06f9	441	usage_cmd(cmd);
4f0cae73	442	else
01ae06f9	443	usage(false);
4f0cae73	444	} else if (err < 0)
b49be3e1	445	fprintf(stderr, "command failed: %s (%d)\n", strerror(-err), err);
cad53b3f JB	446
	447	nl80211_cleanup(&nlstate);
	448
45c7212c	449	return err;
cad53b3f	450	}