text: /*
   * 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 <linux/netlink.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"
  
  /* libnl 1.x compatibility code */
  #if !defined(CONFIG_LIBNL20) && !defined(CONFIG_LIBNL30)
  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 nl_socket_set_buffer_size(struct nl_sock *sk,
  					    int rxbuf, int txbuf)
  {
  	return nl_set_buffer_size(sk, rxbuf, txbuf);
  }
  #endif /* CONFIG_LIBNL20 && CONFIG_LIBNL30 */
  
  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;
  	}
  
  	nl_socket_set_buffer_size(state->nl_sock, 8192, 8192);
  
  	/* try to set NETLINK_EXT_ACK to 1, ignoring errors */
  	err = 1;
  	setsockopt(nl_socket_get_fd(state->nl_sock), SOL_NETLINK,
  		   NETLINK_EXT_ACK, &err, sizeof(err));
  
  	state->nl80211_id = genl_ctrl_resolve(state->nl_sock, "nl80211");
  	if (state->nl80211_id < 0) {
  		fprintf(stderr, "nl80211 not found.\n");
  		err = -ENOENT;
  		goto out_handle_destroy;
  	}
  
  	return 0;
  
   out_handle_destroy:
  	nl_socket_free(state->nl_sock);
  	return err;
  }
  
  static void nl80211_cleanup(struct nl80211_state *state)
  {
  	nl_socket_free(state->nl_sock);
  }
  
  static int cmd_size;
  
  extern struct cmd *__start___cmd[];
  extern struct cmd *__stop___cmd;
  
  #define for_each_cmd(_cmd, i)					\
  	for (i = 0; i < &__stop___cmd - __start___cmd; i++)	\
  		if ((_cmd = __start___cmd[i]))
  
  
  static void __usage_cmd(const struct cmd *cmd, char *indent, bool full)
  {
  	const char *start, *lend, *end;
  
  	printf("%s", indent);
  
  	switch (cmd->idby) {
  	case CIB_NONE:
  		break;
  	case CIB_PHY:
  		printf("phy <phyname> ");
  		break;
  	case CIB_NETDEV:
  		printf("dev <devname> ");
  		break;
  	case CIB_WDEV:
  		printf("wdev <idx> ");
  		break;
  	}
  	if (cmd->parent && cmd->parent->name)
  		printf("%s ", cmd->parent->name);
  	printf("%s", cmd->name);
  
  	if (cmd->args) {
  		/* print line by line */
  		start = cmd->args;
  		end = strchr(start, '\0');
  		printf(" ");
  		do {
  			lend = strchr(start, '\n');
  			if (!lend)
  				lend = end;
  			if (start != cmd->args) {
  				printf("\t");
  				switch (cmd->idby) {
  				case CIB_NONE:
  					break;
  				case CIB_PHY:
  					printf("phy <phyname> ");
  					break;
  				case CIB_NETDEV:
  					printf("dev <devname> ");
  					break;
  				case CIB_WDEV:
  					printf("wdev <idx> ");
  					break;
  				}
  				if (cmd->parent && cmd->parent->name)
  					printf("%s ", cmd->parent->name);
  				printf("%s ", cmd->name);
  			}
  			printf("%.*s\n", (int)(lend - start), start);
  			start = lend + 1;
  		} while (end != lend);
  	} else
  		printf("\n");
  
  	if (!full || !cmd->help)
  		return;
  
  	/* hack */
  	if (strlen(indent))
  		indent = "\t\t";
  	else
  		printf("\n");
  
  	/* print line by line */
  	start = cmd->help;
  	end = strchr(start, '\0');
  	do {
  		lend = strchr(start, '\n');
  		if (!lend)
  			lend = end;
  		printf("%s", indent);
  		printf("%.*s\n", (int)(lend - start), start);
  		start = lend + 1;
  	} while (end != lend);
  
  	printf("\n");
  }
  
  static void usage_options(void)
  {
  	printf("Options:\n");
  	printf("\t--debug\t\tenable netlink debugging\n");
  }
  
  static const char *argv0;
  
  static void usage(int argc, char **argv)
  {
  	const struct cmd *section, *cmd;
  	bool full = argc >= 0;
  	const char *sect_filt = NULL;
  	const char *cmd_filt = NULL;
  	unsigned int i, j;
  
  	if (argc > 0)
  		sect_filt = argv[0];
  
  	if (argc > 1)
  		cmd_filt = argv[1];
  
  	printf("Usage:\t%s [options] command\n", argv0);
  	usage_options();
  	printf("\t--version\tshow version (%s)\n", iw_version);
  	printf("Commands:\n");
  	for_each_cmd(section, i) {
  		if (section->parent)
  			continue;
  
  		if (sect_filt && strcmp(section->name, sect_filt))
  			continue;
  
  		if (section->handler && !section->hidden)
  			__usage_cmd(section, "\t", full);
  
  		for_each_cmd(cmd, j) {
  			if (section != cmd->parent)
  				continue;
  			if (!cmd->handler || cmd->hidden)
  				continue;
  			if (cmd_filt && strcmp(cmd->name, cmd_filt))
  				continue;
  			__usage_cmd(cmd, "\t", full);
  		}
  	}
  	printf("\nCommands that use the netdev ('dev') can also be given the\n"
  	       "'wdev' instead to identify the device.\n");
  	printf("\nYou can omit the 'phy' or 'dev' if "
  			"the identification is unique,\n"
  			"e.g. \"iw wlan0 info\" or \"iw phy0 info\". "
  			"(Don't when scripting.)\n\n"
  			"Do NOT screenscrape this tool, we don't "
  			"consider its output stable.\n\n");
  }
  
  static int print_help(struct nl80211_state *state,
  		      struct nl_msg *msg,
  		      int argc, char **argv,
  		      enum id_input id)
  {
  	exit(3);
  }
  TOPLEVEL(help, "[command]", 0, 0, CIB_NONE, print_help,
  	 "Print usage for all or a specific command, e.g.\n"
  	 "\"help wowlan\" or \"help wowlan enable\".");
  
  static void usage_cmd(const struct cmd *cmd)
  {
  	printf("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) {
  		close(fd);
  		return -1;
  	}
  	buf[pos] = '\0';
  	close(fd);
  	return atoi(buf);
  }
  
  static int error_handler(struct sockaddr_nl *nla, struct nlmsgerr *err,
  			 void *arg)
  {
  	struct nlmsghdr *nlh = (struct nlmsghdr *)err - 1;
  	int len = nlh->nlmsg_len;
  	struct nlattr *attrs;
  	struct nlattr *tb[NLMSGERR_ATTR_MAX + 1];
  	int *ret = arg;
  	int ack_len = sizeof(*nlh) + sizeof(int) + sizeof(*nlh);
  
  	if (err->error > 0) {
  		/*
  		 * This is illegal, per netlink(7), but not impossible (think
  		 * "vendor commands"). Callers really expect negative error
  		 * codes, so make that happen.
  		 */
  		fprintf(stderr,
  			"ERROR: received positive netlink error code %d\n",
  			err->error);
  		*ret = -EPROTO;
  	} else {
  		*ret = err->error;
  	}
  
  	if (!(nlh->nlmsg_flags & NLM_F_ACK_TLVS))
  		return NL_STOP;
  
  	if (!(nlh->nlmsg_flags & NLM_F_CAPPED))
  		ack_len += err->msg.nlmsg_len - sizeof(*nlh);
  
  	if (len <= ack_len)
  		return NL_STOP;
  
  	attrs = (void *)((unsigned char *)nlh + ack_len);
  	len -= ack_len;
  
  	nla_parse(tb, NLMSGERR_ATTR_MAX, attrs, len, NULL);
  	if (tb[NLMSGERR_ATTR_MSG]) {
  		len = strnlen((char *)nla_data(tb[NLMSGERR_ATTR_MSG]),
  			      nla_len(tb[NLMSGERR_ATTR_MSG]));
  		fprintf(stderr, "kernel reports: %*s\n", len,
  			(char *)nla_data(tb[NLMSGERR_ATTR_MSG]));
  	}
  
  	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 (*registered_handler)(struct nl_msg *, void *);
  static void *registered_handler_data;
  
  void register_handler(int (*handler)(struct nl_msg *, void *), void *data)
  {
  	registered_handler = handler;
  	registered_handler_data = data;
  }
  
  int valid_handler(struct nl_msg *msg, void *arg)
  {
  	if (registered_handler)
  		return registered_handler(msg, registered_handler_data);
  
  	return NL_OK;
  }
  
  static int __handle_cmd(struct nl80211_state *state, enum id_input idby,
  			int argc, char **argv, const struct cmd **cmdout)
  {
  	const struct cmd *cmd, *match = NULL, *sectcmd;
  	struct nl_cb *cb;
  	struct nl_cb *s_cb;
  	struct nl_msg *msg;
  	signed long long devidx = 0;
  	int err, o_argc, i;
  	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;
  	case II_WDEV:
  		command_idby = CIB_WDEV;
  		devidx = strtoll(*argv, &tmp, 0);
  		if (*tmp != '\0')
  			return 1;
  		argc--;
  		argv++;
  	default:
  		break;
  	}
  
  	if (devidx < 0)
  		return -errno;
  
  	section = *argv;
  	argc--;
  	argv++;
  
  	for_each_cmd(sectcmd, i) {
  		if (sectcmd->parent)
  			continue;
  		/* ok ... bit of a hack for the dupe 'info' section */
  		if (match && sectcmd->idby != command_idby)
  			continue;
  		if (strcmp(sectcmd->name, section) == 0)
  			match = sectcmd;
  	}
  
  	sectcmd = match;
  	match = NULL;
  	if (!sectcmd)
  		return 1;
  
  	if (argc > 0) {
  		command = *argv;
  
  		for_each_cmd(cmd, i) {
  			if (!cmd->handler)
  				continue;
  			if (cmd->parent != sectcmd)
  				continue;
  			/*
  			 * ignore mismatch id by, but allow WDEV
  			 * in place of NETDEV
  			 */
  			if (cmd->idby != command_idby &&
  			    !(cmd->idby == CIB_NETDEV &&
  			      command_idby == CIB_WDEV))
  				continue;
  			if (strcmp(cmd->name, command))
  				continue;
  			if (argc > 1 && !cmd->args)
  				continue;
  			match = cmd;
  			break;
  		}
  
  		if (match) {
  			argc--;
  			argv++;
  		}
  	}
  
  	if (match)
  		cmd = match;
  	else {
  		/* Use the section itself, if possible. */
  		cmd = sectcmd;
  		if (argc && !cmd->args)
  			return 1;
  		if (cmd->idby != command_idby &&
  		    !(cmd->idby == CIB_NETDEV && command_idby == CIB_WDEV))
  			return 1;
  		if (!cmd->handler)
  			return 1;
  	}
  
  	if (cmd->selector) {
  		cmd = cmd->selector(argc, argv);
  		if (!cmd)
  			return 1;
  	}
  
  	if (cmdout)
  		*cmdout = cmd;
  
  	if (!cmd->cmd) {
  		argc = o_argc;
  		argv = o_argv;
  		return cmd->handler(state, NULL, argc, argv, idby);
  	}
  
  	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);
  	s_cb = nl_cb_alloc(iw_debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
  	if (!cb || !s_cb) {
  		fprintf(stderr, "failed to allocate netlink callbacks\n");
  		err = 2;
  		goto out;
  	}
  
  	genlmsg_put(msg, 0, 0, state->nl80211_id, 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;
  	case CIB_WDEV:
  		NLA_PUT_U64(msg, NL80211_ATTR_WDEV, devidx);
  		break;
  	default:
  		break;
  	}
  
  	err = cmd->handler(state, msg, argc, argv, idby);
  	if (err)
  		goto out;
  
  	nl_socket_set_cb(state->nl_sock, s_cb);
  
  	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);
  	nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, valid_handler, NULL);
  
  	while (err > 0)
  		nl_recvmsgs(state->nl_sock, cb);
   out:
  	nl_cb_put(cb);
  	nl_cb_put(s_cb);
  	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);
  }
  
  /*
   * Unfortunately, I don't know how densely the linker packs the struct cmd.
   * For example, if you have a 72-byte struct cmd, the linker will pad each
   * out to 96 bytes before putting them together in the section. There must
   * be some algorithm, but I haven't found it yet.
   *
   * We used to calculate this by taking the (abs value of) the difference
   * between __section_get and __section_set, but if LTO is enabled then this
   * stops working because the entries of the "__cmd" section get rearranged
   * freely by the compiler/linker.
   *
   * Fix this by using yet another "__sizer" section that only contains these
   * two entries - then the (abs value of) the difference between them will
   * be how they get packed and that can be used to iterate the __cmd section
   * as well.
   */
  static struct cmd sizer1 __attribute__((section("__sizer"))) = {};
  static struct cmd sizer2 __attribute__((section("__sizer"))) = {};
  
  int main(int argc, char **argv)
  {
  	struct nl80211_state nlstate;
  	int err;
  	const struct cmd *cmd = NULL;
  
  	/* calculate command size including padding */
  	cmd_size = labs((long)&sizer2 - (long)&sizer1);
  	/* 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 - 1, argv + 1);
  		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
  			goto detect;
  	} else if (strcmp(*argv, "wdev") == 0 && argc > 1) {
  		argc--;
  		argv++;
  		err = __handle_cmd(&nlstate, II_WDEV, argc, argv, &cmd);
  	} else {
  		int idx;
  		enum id_input idby;
   detect:
  		idby = II_NONE;
  		if ((idx = if_nametoindex(argv[0])) != 0)
  			idby = II_NETDEV;
  		else if ((idx = phy_lookup(argv[0])) >= 0)
  			idby = II_PHY_NAME;
  		err = __handle_cmd(&nlstate, idby, argc, argv, &cmd);
  	}
  
  	if (err == HANDLER_RET_USAGE) {
  		if (cmd)
  			usage_cmd(cmd);
  		else
  			usage(0, NULL);
  	} else if (err == HANDLER_RET_DONE) {
  		err = 0;
  	} else if (err < 0)
  		fprintf(stderr, "command failed: %s (%d)\n", strerror(-err), err);
  
  	nl80211_cleanup(&nlstate);
  
  	return err;
  }
  