#include <fcntl.h>
#include <unistd.h>
#include <stdbool.h>
+#include <linux/netlink.h>
#include <netlink/genl/genl.h>
#include <netlink/genl/family.h>
return -ENOMEM;
}
- nl_socket_set_buffer_size(state->nl_sock, 8192, 8192);
-
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");
static int cmd_size;
-extern struct cmd __start___cmd;
-extern struct cmd __stop___cmd;
+extern struct cmd *__start___cmd[];
+extern struct cmd *__stop___cmd;
-#define for_each_cmd(_cmd) \
- for (_cmd = &__start___cmd; _cmd < &__stop___cmd; \
- _cmd = (const struct cmd *)((char *)_cmd + cmd_size))
+#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)
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];
usage_options();
printf("\t--version\tshow version (%s)\n", iw_version);
printf("Commands:\n");
- for_each_cmd(section) {
+ for_each_cmd(section, i) {
if (section->parent)
continue;
if (section->handler && !section->hidden)
__usage_cmd(section, "\t", full);
- for_each_cmd(cmd) {
+ for_each_cmd(cmd, j) {
if (section != cmd->parent)
continue;
if (!cmd->handler || cmd->hidden)
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);
+
*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;
}
struct nl_cb *s_cb;
struct nl_msg *msg;
signed long long devidx = 0;
- int err, o_argc;
+ int err, o_argc, i;
const char *command, *section;
char *tmp, **o_argv;
enum command_identify_by command_idby = CIB_NONE;
argc--;
argv++;
- for_each_cmd(sectcmd) {
+ for_each_cmd(sectcmd, i) {
if (sectcmd->parent)
continue;
/* ok ... bit of a hack for the dupe 'info' section */
if (argc > 0) {
command = *argv;
- for_each_cmd(cmd) {
+ for_each_cmd(cmd, i) {
if (!cmd->handler)
continue;
if (cmd->parent != sectcmd)
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;
const struct cmd *cmd = NULL;
/* calculate command size including padding */
- cmd_size = abs((long)&__section_set - (long)&__section_get);
+ cmd_size = labs((long)&sizer2 - (long)&sizer1);
/* strip off self */
argc--;
argv0 = *argv++;
err = __handle_cmd(&nlstate, II_WDEV, argc, argv, &cmd);
} else {
int idx;
- enum id_input idby = II_NONE;
+ 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)
err = __handle_cmd(&nlstate, idby, argc, argv, &cmd);
}
- if (err == 1) {
+ if (err == HANDLER_RET_USAGE) {
if (cmd)
usage_cmd(cmd);
else