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         *ret = err->error;
 291
 292         if (!(nlh->nlmsg_flags & NLM_F_ACK_TLVS))
 293                 return NL_STOP;
 294
 295         if (!(nlh->nlmsg_flags & NLM_F_CAPPED))
 296                 ack_len += err->msg.nlmsg_len - sizeof(*nlh);
 297
 298         if (len <= ack_len)
 299                 return NL_STOP;
 300
 301         attrs = (void *)((unsigned char *)nlh + ack_len);
 302         len -= ack_len;
 303
 304         nla_parse(tb, NLMSGERR_ATTR_MAX, attrs, len, NULL);
 305         if (tb[NLMSGERR_ATTR_MSG]) {
 306                 len = strnlen((char *)nla_data(tb[NLMSGERR_ATTR_MSG]),
 307                               nla_len(tb[NLMSGERR_ATTR_MSG]));
 308                 fprintf(stderr, "kernel reports: %*s\n", len,
 309                         (char *)nla_data(tb[NLMSGERR_ATTR_MSG]));
 310         }
 311
 312         return NL_STOP;
 313 }
 314
 315 static int finish_handler(struct nl_msg *msg, void *arg)
 316 {
 317         int *ret = arg;
 318         *ret = 0;
 319         return NL_SKIP;
 320 }
 321
 322 static int ack_handler(struct nl_msg *msg, void *arg)
 323 {
 324         int *ret = arg;
 325         *ret = 0;
 326         return NL_STOP;
 327 }
 328
 329 static int (*registered_handler)(struct nl_msg *, void *);
 330 static void *registered_handler_data;
 331
 332 void register_handler(int (*handler)(struct nl_msg *, void *), void *data)
 333 {
 334         registered_handler = handler;
 335         registered_handler_data = data;
 336 }
 337
 338 int valid_handler(struct nl_msg *msg, void *arg)
 339 {
 340         if (registered_handler)
 341                 return registered_handler(msg, registered_handler_data);
 342
 343         return NL_OK;
 344 }
 345
 346 static int __handle_cmd(struct nl80211_state *state, enum id_input idby,
 347                         int argc, char **argv, const struct cmd **cmdout)
 348 {
 349         const struct cmd *cmd, *match = NULL, *sectcmd;
 350         struct nl_cb *cb;
 351         struct nl_cb *s_cb;
 352         struct nl_msg *msg;
 353         signed long long devidx = 0;
 354         int err, o_argc, i;
 355         const char *command, *section;
 356         char *tmp, **o_argv;
 357         enum command_identify_by command_idby = CIB_NONE;
 358
 359         if (argc <= 1 && idby != II_NONE)
 360                 return 1;
 361
 362         o_argc = argc;
 363         o_argv = argv;
 364
 365         switch (idby) {
 366         case II_PHY_IDX:
 367                 command_idby = CIB_PHY;
 368                 devidx = strtoul(*argv + 4, &tmp, 0);
 369                 if (*tmp != '\0')
 370                         return 1;
 371                 argc--;
 372                 argv++;
 373                 break;
 374         case II_PHY_NAME:
 375                 command_idby = CIB_PHY;
 376                 devidx = phy_lookup(*argv);
 377                 argc--;
 378                 argv++;
 379                 break;
 380         case II_NETDEV:
 381                 command_idby = CIB_NETDEV;
 382                 devidx = if_nametoindex(*argv);
 383                 if (devidx == 0)
 384                         devidx = -1;
 385                 argc--;
 386                 argv++;
 387                 break;
 388         case II_WDEV:
 389                 command_idby = CIB_WDEV;
 390                 devidx = strtoll(*argv, &tmp, 0);
 391                 if (*tmp != '\0')
 392                         return 1;
 393                 argc--;
 394                 argv++;
 395         default:
 396                 break;
 397         }
 398
 399         if (devidx < 0)
 400                 return -errno;
 401
 402         section = *argv;
 403         argc--;
 404         argv++;
 405
 406         for_each_cmd(sectcmd, i) {
 407                 if (sectcmd->parent)
 408                         continue;
 409                 /* ok ... bit of a hack for the dupe 'info' section */
 410                 if (match && sectcmd->idby != command_idby)
 411                         continue;
 412                 if (strcmp(sectcmd->name, section) == 0)
 413                         match = sectcmd;
 414         }
 415
 416         sectcmd = match;
 417         match = NULL;
 418         if (!sectcmd)
 419                 return 1;
 420
 421         if (argc > 0) {
 422                 command = *argv;
 423
 424                 for_each_cmd(cmd, i) {
 425                         if (!cmd->handler)
 426                                 continue;
 427                         if (cmd->parent != sectcmd)
 428                                 continue;
 429                         /*
 430                          * ignore mismatch id by, but allow WDEV
 431                          * in place of NETDEV
 432                          */
 433                         if (cmd->idby != command_idby &&
 434                             !(cmd->idby == CIB_NETDEV &&
 435                               command_idby == CIB_WDEV))
 436                                 continue;
 437                         if (strcmp(cmd->name, command))
 438                                 continue;
 439                         if (argc > 1 && !cmd->args)
 440                                 continue;
 441                         match = cmd;
 442                         break;
 443                 }
 444
 445                 if (match) {
 446                         argc--;
 447                         argv++;
 448                 }
 449         }
 450
 451         if (match)
 452                 cmd = match;
 453         else {
 454                 /* Use the section itself, if possible. */
 455                 cmd = sectcmd;
 456                 if (argc && !cmd->args)
 457                         return 1;
 458                 if (cmd->idby != command_idby &&
 459                     !(cmd->idby == CIB_NETDEV && command_idby == CIB_WDEV))
 460                         return 1;
 461                 if (!cmd->handler)
 462                         return 1;
 463         }
 464
 465         if (cmd->selector) {
 466                 cmd = cmd->selector(argc, argv);
 467                 if (!cmd)
 468                         return 1;
 469         }
 470
 471         if (cmdout)
 472                 *cmdout = cmd;
 473
 474         if (!cmd->cmd) {
 475                 argc = o_argc;
 476                 argv = o_argv;
 477                 return cmd->handler(state, NULL, argc, argv, idby);
 478         }
 479
 480         msg = nlmsg_alloc();
 481         if (!msg) {
 482                 fprintf(stderr, "failed to allocate netlink message\n");
 483                 return 2;
 484         }
 485
 486         cb = nl_cb_alloc(iw_debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
 487         s_cb = nl_cb_alloc(iw_debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
 488         if (!cb || !s_cb) {
 489                 fprintf(stderr, "failed to allocate netlink callbacks\n");
 490                 err = 2;
 491                 goto out;
 492         }
 493
 494         genlmsg_put(msg, 0, 0, state->nl80211_id, 0,
 495                     cmd->nl_msg_flags, cmd->cmd, 0);
 496
 497         switch (command_idby) {
 498         case CIB_PHY:
 499                 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, devidx);
 500                 break;
 501         case CIB_NETDEV:
 502                 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, devidx);
 503                 break;
 504         case CIB_WDEV:
 505                 NLA_PUT_U64(msg, NL80211_ATTR_WDEV, devidx);
 506                 break;
 507         default:
 508                 break;
 509         }
 510
 511         err = cmd->handler(state, msg, argc, argv, idby);
 512         if (err)
 513                 goto out;
 514
 515         nl_socket_set_cb(state->nl_sock, s_cb);
 516
 517         err = nl_send_auto_complete(state->nl_sock, msg);
 518         if (err < 0)
 519                 goto out;
 520
 521         err = 1;
 522
 523         nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &err);
 524         nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &err);
 525         nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &err);
 526         nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, valid_handler, NULL);
 527
 528         while (err > 0)
 529                 nl_recvmsgs(state->nl_sock, cb);
 530  out:
 531         nl_cb_put(cb);
 532         nl_cb_put(s_cb);
 533         nlmsg_free(msg);
 534         return err;
 535  nla_put_failure:
 536         fprintf(stderr, "building message failed\n");
 537         return 2;
 538 }
 539
 540 int handle_cmd(struct nl80211_state *state, enum id_input idby,
 541                int argc, char **argv)
 542 {
 543         return __handle_cmd(state, idby, argc, argv, NULL);
 544 }
 545
 546 /*
 547  * Unfortunately, I don't know how densely the linker packs the struct cmd.
 548  * For example, if you have a 72-byte struct cmd, the linker will pad each
 549  * out to 96 bytes before putting them together in the section. There must
 550  * be some algorithm, but I haven't found it yet.
 551  *
 552  * We used to calculate this by taking the (abs value of) the difference
 553  * between __section_get and __section_set, but if LTO is enabled then this
 554  * stops working because the entries of the "__cmd" section get rearranged
 555  * freely by the compiler/linker.
 556  *
 557  * Fix this by using yet another "__sizer" section that only contains these
 558  * two entries - then the (abs value of) the difference between them will
 559  * be how they get packed and that can be used to iterate the __cmd section
 560  * as well.
 561  */
 562 static struct cmd sizer1 __attribute__((section("__sizer"))) = {};
 563 static struct cmd sizer2 __attribute__((section("__sizer"))) = {};
 564
 565 int main(int argc, char **argv)
 566 {
 567         struct nl80211_state nlstate;
 568         int err;
 569         const struct cmd *cmd = NULL;
 570
 571         /* calculate command size including padding */
 572         cmd_size = labs((long)&sizer2 - (long)&sizer1);
 573         /* strip off self */
 574         argc--;
 575         argv0 = *argv++;
 576
 577         if (argc > 0 && strcmp(*argv, "--debug") == 0) {
 578                 iw_debug = 1;
 579                 argc--;
 580                 argv++;
 581         }
 582
 583         if (argc > 0 && strcmp(*argv, "--version") == 0) {
 584                 version();
 585                 return 0;
 586         }
 587
 588         /* need to treat "help" command specially so it works w/o nl80211 */
 589         if (argc == 0 || strcmp(*argv, "help") == 0) {
 590                 usage(argc - 1, argv + 1);
 591                 return 0;
 592         }
 593
 594         err = nl80211_init(&nlstate);
 595         if (err)
 596                 return 1;
 597
 598         if (strcmp(*argv, "dev") == 0 && argc > 1) {
 599                 argc--;
 600                 argv++;
 601                 err = __handle_cmd(&nlstate, II_NETDEV, argc, argv, &cmd);
 602         } else if (strncmp(*argv, "phy", 3) == 0 && argc > 1) {
 603                 if (strlen(*argv) == 3) {
 604                         argc--;
 605                         argv++;
 606                         err = __handle_cmd(&nlstate, II_PHY_NAME, argc, argv, &cmd);
 607                 } else if (*(*argv + 3) == '#')
 608                         err = __handle_cmd(&nlstate, II_PHY_IDX, argc, argv, &cmd);
 609                 else
 610                         goto detect;
 611         } else if (strcmp(*argv, "wdev") == 0 && argc > 1) {
 612                 argc--;
 613                 argv++;
 614                 err = __handle_cmd(&nlstate, II_WDEV, argc, argv, &cmd);
 615         } else {
 616                 int idx;
 617                 enum id_input idby;
 618  detect:
 619                 idby = II_NONE;
 620                 if ((idx = if_nametoindex(argv[0])) != 0)
 621                         idby = II_NETDEV;
 622                 else if ((idx = phy_lookup(argv[0])) >= 0)
 623                         idby = II_PHY_NAME;
 624                 err = __handle_cmd(&nlstate, idby, argc, argv, &cmd);
 625         }
 626
 627         if (err == HANDLER_RET_USAGE) {
 628                 if (cmd)
 629                         usage_cmd(cmd);
 630                 else
 631                         usage(0, NULL);
 632         } else if (err == HANDLER_RET_DONE) {
 633                 err = 0;
 634         } else if (err < 0)
 635                 fprintf(stderr, "command failed: %s (%d)\n", strerror(-err), err);
 636
 637         nl80211_cleanup(&nlstate);
 638
 639         return err;
 640 }