iw.c

   1 /*
   2  * nl80211 userspace tool
   3  *
   4  * Copyright 2007, 2008 Johannes Berg <johannes@sipsolutions.net>
   5  */
   6
   7 #include <errno.h>
   8 #include <stdio.h>
   9 #include <string.h>
  10 #include <net/if.h>
  11 #include <sys/types.h>
  12 #include <sys/stat.h>
  13 #include <fcntl.h>
  14 #include <unistd.h>
  15 #include <stdbool.h>
  16 #include <linux/netlink.h>
  17
  18 #include <netlink/genl/genl.h>
  19 #include <netlink/genl/family.h>
  20 #include <netlink/genl/ctrl.h>
  21 #include <netlink/msg.h>
  22 #include <netlink/attr.h>
  23
  24 #include "nl80211.h"
  25 #include "iw.h"
  26
  27 /* libnl 1.x compatibility code */
  28 #if !defined(CONFIG_LIBNL20) && !defined(CONFIG_LIBNL30)
  29 static inline struct nl_handle *nl_socket_alloc(void)
  30 {
  31         return nl_handle_alloc();
  32 }
  33
  34 static inline void nl_socket_free(struct nl_sock *h)
  35 {
  36         nl_handle_destroy(h);
  37 }
  38
  39 static inline int nl_socket_set_buffer_size(struct nl_sock *sk,
  40                                             int rxbuf, int txbuf)
  41 {
  42         return nl_set_buffer_size(sk, rxbuf, txbuf);
  43 }
  44 #endif /* CONFIG_LIBNL20 && CONFIG_LIBNL30 */
  45
  46 int iw_debug = 0;
  47
  48 static int nl80211_init(struct nl80211_state *state)
  49 {
  50         int err;
  51
  52         state->nl_sock = nl_socket_alloc();
  53         if (!state->nl_sock) {
  54                 fprintf(stderr, "Failed to allocate netlink socket.\n");
  55                 return -ENOMEM;
  56         }
  57
  58         if (genl_connect(state->nl_sock)) {
  59                 fprintf(stderr, "Failed to connect to generic netlink.\n");
  60                 err = -ENOLINK;
  61                 goto out_handle_destroy;
  62         }
  63
  64         nl_socket_set_buffer_size(state->nl_sock, 8192, 8192);
  65
  66         /* try to set NETLINK_EXT_ACK to 1, ignoring errors */
  67         err = 1;
  68         setsockopt(nl_socket_get_fd(state->nl_sock), SOL_NETLINK,
  69                    NETLINK_EXT_ACK, &err, sizeof(err));
  70
  71         state->nl80211_id = genl_ctrl_resolve(state->nl_sock, "nl80211");
  72         if (state->nl80211_id < 0) {
  73                 fprintf(stderr, "nl80211 not found.\n");
  74                 err = -ENOENT;
  75                 goto out_handle_destroy;
  76         }
  77
  78         return 0;
  79
  80  out_handle_destroy:
  81         nl_socket_free(state->nl_sock);
  82         return err;
  83 }
  84
  85 static void nl80211_cleanup(struct nl80211_state *state)
  86 {
  87         nl_socket_free(state->nl_sock);
  88 }
  89
  90 static int cmd_size;
  91
  92 extern struct cmd *__start___cmd[];
  93 extern struct cmd *__stop___cmd;
  94
  95 #define for_each_cmd(_cmd, i)                                   \
  96         for (i = 0; i < &__stop___cmd - __start___cmd; i++)     \
  97                 if ((_cmd = __start___cmd[i]))
  98
  99
 100 static void __usage_cmd(const struct cmd *cmd, char *indent, bool full)
 101 {
 102         const char *start, *lend, *end;
 103
 104         printf("%s", indent);
 105
 106         switch (cmd->idby) {
 107         case CIB_NONE:
 108                 break;
 109         case CIB_PHY:
 110                 printf("phy <phyname> ");
 111                 break;
 112         case CIB_NETDEV:
 113                 printf("dev <devname> ");
 114                 break;
 115         case CIB_WDEV:
 116                 printf("wdev <idx> ");
 117                 break;
 118         }
 119         if (cmd->parent && cmd->parent->name)
 120                 printf("%s ", cmd->parent->name);
 121         printf("%s", cmd->name);
 122
 123         if (cmd->args) {
 124                 /* print line by line */
 125                 start = cmd->args;
 126                 end = strchr(start, '\0');
 127                 printf(" ");
 128                 do {
 129                         lend = strchr(start, '\n');
 130                         if (!lend)
 131                                 lend = end;
 132                         if (start != cmd->args) {
 133                                 printf("\t");
 134                                 switch (cmd->idby) {
 135                                 case CIB_NONE:
 136                                         break;
 137                                 case CIB_PHY:
 138                                         printf("phy <phyname> ");
 139                                         break;
 140                                 case CIB_NETDEV:
 141                                         printf("dev <devname> ");
 142                                         break;
 143                                 case CIB_WDEV:
 144                                         printf("wdev <idx> ");
 145                                         break;
 146                                 }
 147                                 if (cmd->parent && cmd->parent->name)
 148                                         printf("%s ", cmd->parent->name);
 149                                 printf("%s ", cmd->name);
 150                         }
 151                         printf("%.*s\n", (int)(lend - start), start);
 152                         start = lend + 1;
 153                 } while (end != lend);
 154         } else
 155                 printf("\n");
 156
 157         if (!full || !cmd->help)
 158                 return;
 159
 160         /* hack */
 161         if (strlen(indent))
 162                 indent = "\t\t";
 163         else
 164                 printf("\n");
 165
 166         /* print line by line */
 167         start = cmd->help;
 168         end = strchr(start, '\0');
 169         do {
 170                 lend = strchr(start, '\n');
 171                 if (!lend)
 172                         lend = end;
 173                 printf("%s", indent);
 174                 printf("%.*s\n", (int)(lend - start), start);
 175                 start = lend + 1;
 176         } while (end != lend);
 177
 178         printf("\n");
 179 }
 180
 181 static void usage_options(void)
 182 {
 183         printf("Options:\n");
 184         printf("\t--debug\t\tenable netlink debugging\n");
 185 }
 186
 187 static const char *argv0;
 188
 189 static void usage(int argc, char **argv)
 190 {
 191         const struct cmd *section, *cmd;
 192         bool full = argc >= 0;
 193         const char *sect_filt = NULL;
 194         const char *cmd_filt = NULL;
 195         unsigned int i, j;
 196
 197         if (argc > 0)
 198                 sect_filt = argv[0];
 199
 200         if (argc > 1)
 201                 cmd_filt = argv[1];
 202
 203         printf("Usage:\t%s [options] command\n", argv0);
 204         usage_options();
 205         printf("\t--version\tshow version (%s)\n", iw_version);
 206         printf("Commands:\n");
 207         for_each_cmd(section, i) {
 208                 if (section->parent)
 209                         continue;
 210
 211                 if (sect_filt && strcmp(section->name, sect_filt))
 212                         continue;
 213
 214                 if (section->handler && !section->hidden)
 215                         __usage_cmd(section, "\t", full);
 216
 217                 for_each_cmd(cmd, j) {
 218                         if (section != cmd->parent)
 219                                 continue;
 220                         if (!cmd->handler || cmd->hidden)
 221                                 continue;
 222                         if (cmd_filt && strcmp(cmd->name, cmd_filt))
 223                                 continue;
 224                         __usage_cmd(cmd, "\t", full);
 225                 }
 226         }
 227         printf("\nCommands that use the netdev ('dev') can also be given the\n"
 228                "'wdev' instead to identify the device.\n");
 229         printf("\nYou can omit the 'phy' or 'dev' if "
 230                         "the identification is unique,\n"
 231                         "e.g. \"iw wlan0 info\" or \"iw phy0 info\". "
 232                         "(Don't when scripting.)\n\n"
 233                         "Do NOT screenscrape this tool, we don't "
 234                         "consider its output stable.\n\n");
 235 }
 236
 237 static int print_help(struct nl80211_state *state,
 238                       struct nl_msg *msg,
 239                       int argc, char **argv,
 240                       enum id_input id)
 241 {
 242         exit(3);
 243 }
 244 TOPLEVEL(help, "[command]", 0, 0, CIB_NONE, print_help,
 245          "Print usage for all or a specific command, e.g.\n"
 246          "\"help wowlan\" or \"help wowlan enable\".");
 247
 248 static void usage_cmd(const struct cmd *cmd)
 249 {
 250         printf("Usage:\t%s [options] ", argv0);
 251         __usage_cmd(cmd, "", true);
 252         usage_options();
 253 }
 254
 255 static void version(void)
 256 {
 257         printf("iw version %s\n", iw_version);
 258 }
 259
 260 static int phy_lookup(char *name)
 261 {
 262         char buf[200];
 263         int fd, pos;
 264
 265         snprintf(buf, sizeof(buf), "/sys/class/ieee80211/%s/index", name);
 266
 267         fd = open(buf, O_RDONLY);
 268         if (fd < 0)
 269                 return -1;
 270         pos = read(fd, buf, sizeof(buf) - 1);
 271         if (pos < 0) {
 272                 close(fd);
 273                 return -1;
 274         }
 275         buf[pos] = '\0';
 276         close(fd);
 277         return atoi(buf);
 278 }
 279
 280 static int error_handler(struct sockaddr_nl *nla, struct nlmsgerr *err,
 281                          void *arg)
 282 {
 283         struct nlmsghdr *nlh = (struct nlmsghdr *)err - 1;
 284         int len = nlh->nlmsg_len;
 285         struct nlattr *attrs;
 286         struct nlattr *tb[NLMSGERR_ATTR_MAX + 1];
 287         int *ret = arg;
 288         int ack_len = sizeof(*nlh) + sizeof(int) + sizeof(*nlh);
 289
 290         if (err->error > 0) {
 291                 /*
 292                  * This is illegal, per netlink(7), but not impossible (think
 293                  * "vendor commands"). Callers really expect negative error
 294                  * codes, so make that happen.
 295                  */
 296                 fprintf(stderr,
 297                         "ERROR: received positive netlink error code %d\n",
 298                         err->error);
 299                 *ret = -EPROTO;
 300         } else {
 301                 *ret = err->error;
 302         }
 303
 304         if (!(nlh->nlmsg_flags & NLM_F_ACK_TLVS))
 305                 return NL_STOP;
 306
 307         if (!(nlh->nlmsg_flags & NLM_F_CAPPED))
 308                 ack_len += err->msg.nlmsg_len - sizeof(*nlh);
 309
 310         if (len <= ack_len)
 311                 return NL_STOP;
 312
 313         attrs = (void *)((unsigned char *)nlh + ack_len);
 314         len -= ack_len;
 315
 316         nla_parse(tb, NLMSGERR_ATTR_MAX, attrs, len, NULL);
 317         if (tb[NLMSGERR_ATTR_MSG]) {
 318                 len = strnlen((char *)nla_data(tb[NLMSGERR_ATTR_MSG]),
 319                               nla_len(tb[NLMSGERR_ATTR_MSG]));
 320                 fprintf(stderr, "kernel reports: %*s\n", len,
 321                         (char *)nla_data(tb[NLMSGERR_ATTR_MSG]));
 322         }
 323
 324         return NL_STOP;
 325 }
 326
 327 static int finish_handler(struct nl_msg *msg, void *arg)
 328 {
 329         int *ret = arg;
 330         *ret = 0;
 331         return NL_SKIP;
 332 }
 333
 334 static int ack_handler(struct nl_msg *msg, void *arg)
 335 {
 336         int *ret = arg;
 337         *ret = 0;
 338         return NL_STOP;
 339 }
 340
 341 static int (*registered_handler)(struct nl_msg *, void *);
 342 static void *registered_handler_data;
 343
 344 void register_handler(int (*handler)(struct nl_msg *, void *), void *data)
 345 {
 346         registered_handler = handler;
 347         registered_handler_data = data;
 348 }
 349
 350 int valid_handler(struct nl_msg *msg, void *arg)
 351 {
 352         if (registered_handler)
 353                 return registered_handler(msg, registered_handler_data);
 354
 355         return NL_OK;
 356 }
 357
 358 static int __handle_cmd(struct nl80211_state *state, enum id_input idby,
 359                         int argc, char **argv, const struct cmd **cmdout)
 360 {
 361         const struct cmd *cmd, *match = NULL, *sectcmd;
 362         struct nl_cb *cb;
 363         struct nl_cb *s_cb;
 364         struct nl_msg *msg;
 365         signed long long devidx = 0;
 366         int err, o_argc, i;
 367         const char *command, *section;
 368         char *tmp, **o_argv;
 369         enum command_identify_by command_idby = CIB_NONE;
 370
 371         if (argc <= 1 && idby != II_NONE)
 372                 return 1;
 373
 374         o_argc = argc;
 375         o_argv = argv;
 376
 377         switch (idby) {
 378         case II_PHY_IDX:
 379                 command_idby = CIB_PHY;
 380                 devidx = strtoul(*argv + 4, &tmp, 0);
 381                 if (*tmp != '\0')
 382                         return 1;
 383                 argc--;
 384                 argv++;
 385                 break;
 386         case II_PHY_NAME:
 387                 command_idby = CIB_PHY;
 388                 devidx = phy_lookup(*argv);
 389                 argc--;
 390                 argv++;
 391                 break;
 392         case II_NETDEV:
 393                 command_idby = CIB_NETDEV;
 394                 devidx = if_nametoindex(*argv);
 395                 if (devidx == 0)
 396                         devidx = -1;
 397                 argc--;
 398                 argv++;
 399                 break;
 400         case II_WDEV:
 401                 command_idby = CIB_WDEV;
 402                 devidx = strtoll(*argv, &tmp, 0);
 403                 if (*tmp != '\0')
 404                         return 1;
 405                 argc--;
 406                 argv++;
 407         default:
 408                 break;
 409         }
 410
 411         if (devidx < 0)
 412                 return -errno;
 413
 414         section = *argv;
 415         argc--;
 416         argv++;
 417
 418         for_each_cmd(sectcmd, i) {
 419                 if (sectcmd->parent)
 420                         continue;
 421                 /* ok ... bit of a hack for the dupe 'info' section */
 422                 if (match && sectcmd->idby != command_idby)
 423                         continue;
 424                 if (strcmp(sectcmd->name, section) == 0)
 425                         match = sectcmd;
 426         }
 427
 428         sectcmd = match;
 429         match = NULL;
 430         if (!sectcmd)
 431                 return 1;
 432
 433         if (argc > 0) {
 434                 command = *argv;
 435
 436                 for_each_cmd(cmd, i) {
 437                         if (!cmd->handler)
 438                                 continue;
 439                         if (cmd->parent != sectcmd)
 440                                 continue;
 441                         /*
 442                          * ignore mismatch id by, but allow WDEV
 443                          * in place of NETDEV
 444                          */
 445                         if (cmd->idby != command_idby &&
 446                             !(cmd->idby == CIB_NETDEV &&
 447                               command_idby == CIB_WDEV))
 448                                 continue;
 449                         if (strcmp(cmd->name, command))
 450                                 continue;
 451                         if (argc > 1 && !cmd->args)
 452                                 continue;
 453                         match = cmd;
 454                         break;
 455                 }
 456
 457                 if (match) {
 458                         argc--;
 459                         argv++;
 460                 }
 461         }
 462
 463         if (match)
 464                 cmd = match;
 465         else {
 466                 /* Use the section itself, if possible. */
 467                 cmd = sectcmd;
 468                 if (argc && !cmd->args)
 469                         return 1;
 470                 if (cmd->idby != command_idby &&
 471                     !(cmd->idby == CIB_NETDEV && command_idby == CIB_WDEV))
 472                         return 1;
 473                 if (!cmd->handler)
 474                         return 1;
 475         }
 476
 477         if (cmd->selector) {
 478                 cmd = cmd->selector(argc, argv);
 479                 if (!cmd)
 480                         return 1;
 481         }
 482
 483         if (cmdout)
 484                 *cmdout = cmd;
 485
 486         if (!cmd->cmd) {
 487                 argc = o_argc;
 488                 argv = o_argv;
 489                 return cmd->handler(state, NULL, argc, argv, idby);
 490         }
 491
 492         msg = nlmsg_alloc();
 493         if (!msg) {
 494                 fprintf(stderr, "failed to allocate netlink message\n");
 495                 return 2;
 496         }
 497
 498         cb = nl_cb_alloc(iw_debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
 499         s_cb = nl_cb_alloc(iw_debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
 500         if (!cb || !s_cb) {
 501                 fprintf(stderr, "failed to allocate netlink callbacks\n");
 502                 err = 2;
 503                 goto out;
 504         }
 505
 506         genlmsg_put(msg, 0, 0, state->nl80211_id, 0,
 507                     cmd->nl_msg_flags, cmd->cmd, 0);
 508
 509         switch (command_idby) {
 510         case CIB_PHY:
 511                 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, devidx);
 512                 break;
 513         case CIB_NETDEV:
 514                 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, devidx);
 515                 break;
 516         case CIB_WDEV:
 517                 NLA_PUT_U64(msg, NL80211_ATTR_WDEV, devidx);
 518                 break;
 519         default:
 520                 break;
 521         }
 522
 523         err = cmd->handler(state, msg, argc, argv, idby);
 524         if (err)
 525                 goto out;
 526
 527         nl_socket_set_cb(state->nl_sock, s_cb);
 528
 529         err = nl_send_auto_complete(state->nl_sock, msg);
 530         if (err < 0)
 531                 goto out;
 532
 533         err = 1;
 534
 535         nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &err);
 536         nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &err);
 537         nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &err);
 538         nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, valid_handler, NULL);
 539
 540         while (err > 0)
 541                 nl_recvmsgs(state->nl_sock, cb);
 542  out:
 543         nl_cb_put(cb);
 544         nl_cb_put(s_cb);
 545         nlmsg_free(msg);
 546         return err;
 547  nla_put_failure:
 548         fprintf(stderr, "building message failed\n");
 549         return 2;
 550 }
 551
 552 int handle_cmd(struct nl80211_state *state, enum id_input idby,
 553                int argc, char **argv)
 554 {
 555         return __handle_cmd(state, idby, argc, argv, NULL);
 556 }
 557
 558 /*
 559  * Unfortunately, I don't know how densely the linker packs the struct cmd.
 560  * For example, if you have a 72-byte struct cmd, the linker will pad each
 561  * out to 96 bytes before putting them together in the section. There must
 562  * be some algorithm, but I haven't found it yet.
 563  *
 564  * We used to calculate this by taking the (abs value of) the difference
 565  * between __section_get and __section_set, but if LTO is enabled then this
 566  * stops working because the entries of the "__cmd" section get rearranged
 567  * freely by the compiler/linker.
 568  *
 569  * Fix this by using yet another "__sizer" section that only contains these
 570  * two entries - then the (abs value of) the difference between them will
 571  * be how they get packed and that can be used to iterate the __cmd section
 572  * as well.
 573  */
 574 static struct cmd sizer1 __attribute__((section("__sizer"))) = {};
 575 static struct cmd sizer2 __attribute__((section("__sizer"))) = {};
 576
 577 int main(int argc, char **argv)
 578 {
 579         struct nl80211_state nlstate;
 580         int err;
 581         const struct cmd *cmd = NULL;
 582
 583         /* calculate command size including padding */
 584         cmd_size = labs((long)&sizer2 - (long)&sizer1);
 585         /* strip off self */
 586         argc--;
 587         argv0 = *argv++;
 588
 589         if (argc > 0 && strcmp(*argv, "--debug") == 0) {
 590                 iw_debug = 1;
 591                 argc--;
 592                 argv++;
 593         }
 594
 595         if (argc > 0 && strcmp(*argv, "--version") == 0) {
 596                 version();
 597                 return 0;
 598         }
 599
 600         /* need to treat "help" command specially so it works w/o nl80211 */
 601         if (argc == 0 || strcmp(*argv, "help") == 0) {
 602                 usage(argc - 1, argv + 1);
 603                 return 0;
 604         }
 605
 606         err = nl80211_init(&nlstate);
 607         if (err)
 608                 return 1;
 609
 610         if (strcmp(*argv, "dev") == 0 && argc > 1) {
 611                 argc--;
 612                 argv++;
 613                 err = __handle_cmd(&nlstate, II_NETDEV, argc, argv, &cmd);
 614         } else if (strncmp(*argv, "phy", 3) == 0 && argc > 1) {
 615                 if (strlen(*argv) == 3) {
 616                         argc--;
 617                         argv++;
 618                         err = __handle_cmd(&nlstate, II_PHY_NAME, argc, argv, &cmd);
 619                 } else if (*(*argv + 3) == '#')
 620                         err = __handle_cmd(&nlstate, II_PHY_IDX, argc, argv, &cmd);
 621                 else
 622                         goto detect;
 623         } else if (strcmp(*argv, "wdev") == 0 && argc > 1) {
 624                 argc--;
 625                 argv++;
 626                 err = __handle_cmd(&nlstate, II_WDEV, argc, argv, &cmd);
 627         } else {
 628                 int idx;
 629                 enum id_input idby;
 630  detect:
 631                 idby = II_NONE;
 632                 if ((idx = if_nametoindex(argv[0])) != 0)
 633                         idby = II_NETDEV;
 634                 else if ((idx = phy_lookup(argv[0])) >= 0)
 635                         idby = II_PHY_NAME;
 636                 err = __handle_cmd(&nlstate, idby, argc, argv, &cmd);
 637         }
 638
 639         if (err == HANDLER_RET_USAGE) {
 640                 if (cmd)
 641                         usage_cmd(cmd);
 642                 else
 643                         usage(0, NULL);
 644         } else if (err == HANDLER_RET_DONE) {
 645                 err = 0;
 646         } else if (err < 0)
 647                 fprintf(stderr, "command failed: %s (%d)\n", strerror(-err), err);
 648
 649         nl80211_cleanup(&nlstate);
 650
 651         return err;
 652 }