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
  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>
  22
  23 #include "nl80211.h"
  24 #include "iw.h"
  25
  26 /* libnl 1.x compatibility code */
  27 #if !defined(CONFIG_LIBNL20) && !defined(CONFIG_LIBNL30)
  28 static inline struct nl_handle *nl_socket_alloc(void)
  29 {
  30         return nl_handle_alloc();
  31 }
  32
  33 static inline void nl_socket_free(struct nl_sock *h)
  34 {
  35         nl_handle_destroy(h);
  36 }
  37 #endif /* CONFIG_LIBNL20 && CONFIG_LIBNL30 */
  38
  39 int iw_debug = 0;
  40
  41 static int nl80211_init(struct nl80211_state *state)
  42 {
  43         int err;
  44
  45         state->nl_sock = nl_socket_alloc();
  46         if (!state->nl_sock) {
  47                 fprintf(stderr, "Failed to allocate netlink socket.\n");
  48                 return -ENOMEM;
  49         }
  50
  51         if (genl_connect(state->nl_sock)) {
  52                 fprintf(stderr, "Failed to connect to generic netlink.\n");
  53                 err = -ENOLINK;
  54                 goto out_handle_destroy;
  55         }
  56
  57         state->nl80211_id = genl_ctrl_resolve(state->nl_sock, "nl80211");
  58         if (state->nl80211_id < 0) {
  59                 fprintf(stderr, "nl80211 not found.\n");
  60                 err = -ENOENT;
  61                 goto out_handle_destroy;
  62         }
  63
  64         return 0;
  65
  66  out_handle_destroy:
  67         nl_socket_free(state->nl_sock);
  68         return err;
  69 }
  70
  71 static void nl80211_cleanup(struct nl80211_state *state)
  72 {
  73         nl_socket_free(state->nl_sock);
  74 }
  75
  76 static int cmd_size;
  77
  78 extern struct cmd __start___cmd;
  79 extern struct cmd __stop___cmd;
  80
  81 #define for_each_cmd(_cmd)                                      \
  82         for (_cmd = &__start___cmd; _cmd < &__stop___cmd;               \
  83              _cmd = (const struct cmd *)((char *)_cmd + cmd_size))
  84
  85
  86 static void __usage_cmd(const struct cmd *cmd, char *indent, bool full)
  87 {
  88         const char *start, *lend, *end;
  89
  90         printf("%s", indent);
  91
  92         switch (cmd->idby) {
  93         case CIB_NONE:
  94                 break;
  95         case CIB_PHY:
  96                 printf("phy <phyname> ");
  97                 break;
  98         case CIB_NETDEV:
  99                 printf("dev <devname> ");
 100                 break;
 101         case CIB_WDEV:
 102                 printf("wdev <idx> ");
 103                 break;
 104         }
 105         if (cmd->parent && cmd->parent->name)
 106                 printf("%s ", cmd->parent->name);
 107         printf("%s", cmd->name);
 108
 109         if (cmd->args) {
 110                 /* print line by line */
 111                 start = cmd->args;
 112                 end = strchr(start, '\0');
 113                 printf(" ");
 114                 do {
 115                         lend = strchr(start, '\n');
 116                         if (!lend)
 117                                 lend = end;
 118                         if (start != cmd->args) {
 119                                 printf("\t");
 120                                 switch (cmd->idby) {
 121                                 case CIB_NONE:
 122                                         break;
 123                                 case CIB_PHY:
 124                                         printf("phy <phyname> ");
 125                                         break;
 126                                 case CIB_NETDEV:
 127                                         printf("dev <devname> ");
 128                                         break;
 129                                 case CIB_WDEV:
 130                                         printf("wdev <idx> ");
 131                                         break;
 132                                 }
 133                                 if (cmd->parent && cmd->parent->name)
 134                                         printf("%s ", cmd->parent->name);
 135                                 printf("%s ", cmd->name);
 136                         }
 137                         printf("%.*s\n", (int)(lend - start), start);
 138                         start = lend + 1;
 139                 } while (end != lend);
 140         } else
 141                 printf("\n");
 142
 143         if (!full || !cmd->help)
 144                 return;
 145
 146         /* hack */
 147         if (strlen(indent))
 148                 indent = "\t\t";
 149         else
 150                 printf("\n");
 151
 152         /* print line by line */
 153         start = cmd->help;
 154         end = strchr(start, '\0');
 155         do {
 156                 lend = strchr(start, '\n');
 157                 if (!lend)
 158                         lend = end;
 159                 printf("%s", indent);
 160                 printf("%.*s\n", (int)(lend - start), start);
 161                 start = lend + 1;
 162         } while (end != lend);
 163
 164         printf("\n");
 165 }
 166
 167 static void usage_options(void)
 168 {
 169         printf("Options:\n");
 170         printf("\t--debug\t\tenable netlink debugging\n");
 171 }
 172
 173 static const char *argv0;
 174
 175 static void usage(int argc, char **argv)
 176 {
 177         const struct cmd *section, *cmd;
 178         bool full = argc >= 0;
 179         const char *sect_filt = NULL;
 180         const char *cmd_filt = NULL;
 181
 182         if (argc > 0)
 183                 sect_filt = argv[0];
 184
 185         if (argc > 1)
 186                 cmd_filt = argv[1];
 187
 188         printf("Usage:\t%s [options] command\n", argv0);
 189         usage_options();
 190         printf("\t--version\tshow version (%s)\n", iw_version);
 191         printf("Commands:\n");
 192         for_each_cmd(section) {
 193                 if (section->parent)
 194                         continue;
 195
 196                 if (sect_filt && strcmp(section->name, sect_filt))
 197                         continue;
 198
 199                 if (section->handler && !section->hidden)
 200                         __usage_cmd(section, "\t", full);
 201
 202                 for_each_cmd(cmd) {
 203                         if (section != cmd->parent)
 204                                 continue;
 205                         if (!cmd->handler || cmd->hidden)
 206                                 continue;
 207                         if (cmd_filt && strcmp(cmd->name, cmd_filt))
 208                                 continue;
 209                         __usage_cmd(cmd, "\t", full);
 210                 }
 211         }
 212         printf("\nCommands that use the netdev ('dev') can also be given the\n"
 213                "'wdev' instead to identify the device.\n");
 214         printf("\nYou can omit the 'phy' or 'dev' if "
 215                         "the identification is unique,\n"
 216                         "e.g. \"iw wlan0 info\" or \"iw phy0 info\". "
 217                         "(Don't when scripting.)\n\n"
 218                         "Do NOT screenscrape this tool, we don't "
 219                         "consider its output stable.\n\n");
 220 }
 221
 222 static int print_help(struct nl80211_state *state,
 223                       struct nl_cb *cb,
 224                       struct nl_msg *msg,
 225                       int argc, char **argv,
 226                       enum id_input id)
 227 {
 228         exit(3);
 229 }
 230 TOPLEVEL(help, "[command]", 0, 0, CIB_NONE, print_help,
 231          "Print usage for all or a specific command, e.g.\n"
 232          "\"help wowlan\" or \"help wowlan enable\".");
 233
 234 static void usage_cmd(const struct cmd *cmd)
 235 {
 236         printf("Usage:\t%s [options] ", argv0);
 237         __usage_cmd(cmd, "", true);
 238         usage_options();
 239 }
 240
 241 static void version(void)
 242 {
 243         printf("iw version %s\n", iw_version);
 244 }
 245
 246 static int phy_lookup(char *name)
 247 {
 248         char buf[200];
 249         int fd, pos;
 250
 251         snprintf(buf, sizeof(buf), "/sys/class/ieee80211/%s/index", name);
 252
 253         fd = open(buf, O_RDONLY);
 254         if (fd < 0)
 255                 return -1;
 256         pos = read(fd, buf, sizeof(buf) - 1);
 257         if (pos < 0) {
 258                 close(fd);
 259                 return -1;
 260         }
 261         buf[pos] = '\0';
 262         close(fd);
 263         return atoi(buf);
 264 }
 265
 266 static int error_handler(struct sockaddr_nl *nla, struct nlmsgerr *err,
 267                          void *arg)
 268 {
 269         int *ret = arg;
 270         *ret = err->error;
 271         return NL_STOP;
 272 }
 273
 274 static int finish_handler(struct nl_msg *msg, void *arg)
 275 {
 276         int *ret = arg;
 277         *ret = 0;
 278         return NL_SKIP;
 279 }
 280
 281 static int ack_handler(struct nl_msg *msg, void *arg)
 282 {
 283         int *ret = arg;
 284         *ret = 0;
 285         return NL_STOP;
 286 }
 287
 288 static int __handle_cmd(struct nl80211_state *state, enum id_input idby,
 289                         int argc, char **argv, const struct cmd **cmdout)
 290 {
 291         const struct cmd *cmd, *match = NULL, *sectcmd;
 292         struct nl_cb *cb;
 293         struct nl_cb *s_cb;
 294         struct nl_msg *msg;
 295         signed long long devidx = 0;
 296         int err, o_argc;
 297         const char *command, *section;
 298         char *tmp, **o_argv;
 299         enum command_identify_by command_idby = CIB_NONE;
 300
 301         if (argc <= 1 && idby != II_NONE)
 302                 return 1;
 303
 304         o_argc = argc;
 305         o_argv = argv;
 306
 307         switch (idby) {
 308         case II_PHY_IDX:
 309                 command_idby = CIB_PHY;
 310                 devidx = strtoul(*argv + 4, &tmp, 0);
 311                 if (*tmp != '\0')
 312                         return 1;
 313                 argc--;
 314                 argv++;
 315                 break;
 316         case II_PHY_NAME:
 317                 command_idby = CIB_PHY;
 318                 devidx = phy_lookup(*argv);
 319                 argc--;
 320                 argv++;
 321                 break;
 322         case II_NETDEV:
 323                 command_idby = CIB_NETDEV;
 324                 devidx = if_nametoindex(*argv);
 325                 if (devidx == 0)
 326                         devidx = -1;
 327                 argc--;
 328                 argv++;
 329                 break;
 330         case II_WDEV:
 331                 command_idby = CIB_WDEV;
 332                 devidx = strtoll(*argv, &tmp, 0);
 333                 if (*tmp != '\0')
 334                         return 1;
 335                 argc--;
 336                 argv++;
 337         default:
 338                 break;
 339         }
 340
 341         if (devidx < 0)
 342                 return -errno;
 343
 344         section = *argv;
 345         argc--;
 346         argv++;
 347
 348         for_each_cmd(sectcmd) {
 349                 if (sectcmd->parent)
 350                         continue;
 351                 /* ok ... bit of a hack for the dupe 'info' section */
 352                 if (match && sectcmd->idby != command_idby)
 353                         continue;
 354                 if (strcmp(sectcmd->name, section) == 0)
 355                         match = sectcmd;
 356         }
 357
 358         sectcmd = match;
 359         match = NULL;
 360         if (!sectcmd)
 361                 return 1;
 362
 363         if (argc > 0) {
 364                 command = *argv;
 365
 366                 for_each_cmd(cmd) {
 367                         if (!cmd->handler)
 368                                 continue;
 369                         if (cmd->parent != sectcmd)
 370                                 continue;
 371                         /*
 372                          * ignore mismatch id by, but allow WDEV
 373                          * in place of NETDEV
 374                          */
 375                         if (cmd->idby != command_idby &&
 376                             !(cmd->idby == CIB_NETDEV &&
 377                               command_idby == CIB_WDEV))
 378                                 continue;
 379                         if (strcmp(cmd->name, command))
 380                                 continue;
 381                         if (argc > 1 && !cmd->args)
 382                                 continue;
 383                         match = cmd;
 384                         break;
 385                 }
 386
 387                 if (match) {
 388                         argc--;
 389                         argv++;
 390                 }
 391         }
 392
 393         if (match)
 394                 cmd = match;
 395         else {
 396                 /* Use the section itself, if possible. */
 397                 cmd = sectcmd;
 398                 if (argc && !cmd->args)
 399                         return 1;
 400                 if (cmd->idby != command_idby &&
 401                     !(cmd->idby == CIB_NETDEV && command_idby == CIB_WDEV))
 402                         return 1;
 403                 if (!cmd->handler)
 404                         return 1;
 405         }
 406
 407         if (cmd->selector) {
 408                 cmd = cmd->selector(argc, argv);
 409                 if (!cmd)
 410                         return 1;
 411         }
 412
 413         if (cmdout)
 414                 *cmdout = cmd;
 415
 416         if (!cmd->cmd) {
 417                 argc = o_argc;
 418                 argv = o_argv;
 419                 return cmd->handler(state, NULL, NULL, argc, argv, idby);
 420         }
 421
 422         msg = nlmsg_alloc();
 423         if (!msg) {
 424                 fprintf(stderr, "failed to allocate netlink message\n");
 425                 return 2;
 426         }
 427
 428         cb = nl_cb_alloc(iw_debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
 429         s_cb = nl_cb_alloc(iw_debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
 430         if (!cb || !s_cb) {
 431                 fprintf(stderr, "failed to allocate netlink callbacks\n");
 432                 err = 2;
 433                 goto out_free_msg;
 434         }
 435
 436         genlmsg_put(msg, 0, 0, state->nl80211_id, 0,
 437                     cmd->nl_msg_flags, cmd->cmd, 0);
 438
 439         switch (command_idby) {
 440         case CIB_PHY:
 441                 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, devidx);
 442                 break;
 443         case CIB_NETDEV:
 444                 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, devidx);
 445                 break;
 446         case CIB_WDEV:
 447                 NLA_PUT_U64(msg, NL80211_ATTR_WDEV, devidx);
 448                 break;
 449         default:
 450                 break;
 451         }
 452
 453         err = cmd->handler(state, cb, msg, argc, argv, idby);
 454         if (err)
 455                 goto out;
 456
 457         nl_socket_set_cb(state->nl_sock, s_cb);
 458
 459         err = nl_send_auto_complete(state->nl_sock, msg);
 460         if (err < 0)
 461                 goto out;
 462
 463         err = 1;
 464
 465         nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &err);
 466         nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &err);
 467         nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &err);
 468
 469         while (err > 0)
 470                 nl_recvmsgs(state->nl_sock, cb);
 471  out:
 472         nl_cb_put(cb);
 473  out_free_msg:
 474         nlmsg_free(msg);
 475         return err;
 476  nla_put_failure:
 477         fprintf(stderr, "building message failed\n");
 478         return 2;
 479 }
 480
 481 int handle_cmd(struct nl80211_state *state, enum id_input idby,
 482                int argc, char **argv)
 483 {
 484         return __handle_cmd(state, idby, argc, argv, NULL);
 485 }
 486
 487 int main(int argc, char **argv)
 488 {
 489         struct nl80211_state nlstate;
 490         int err;
 491         const struct cmd *cmd = NULL;
 492
 493         /* calculate command size including padding */
 494         cmd_size = abs((long)&__section_set - (long)&__section_get);
 495         /* strip off self */
 496         argc--;
 497         argv0 = *argv++;
 498
 499         if (argc > 0 && strcmp(*argv, "--debug") == 0) {
 500                 iw_debug = 1;
 501                 argc--;
 502                 argv++;
 503         }
 504
 505         if (argc > 0 && strcmp(*argv, "--version") == 0) {
 506                 version();
 507                 return 0;
 508         }
 509
 510         /* need to treat "help" command specially so it works w/o nl80211 */
 511         if (argc == 0 || strcmp(*argv, "help") == 0) {
 512                 usage(argc - 1, argv + 1);
 513                 return 0;
 514         }
 515
 516         err = nl80211_init(&nlstate);
 517         if (err)
 518                 return 1;
 519
 520         if (strcmp(*argv, "dev") == 0 && argc > 1) {
 521                 argc--;
 522                 argv++;
 523                 err = __handle_cmd(&nlstate, II_NETDEV, argc, argv, &cmd);
 524         } else if (strncmp(*argv, "phy", 3) == 0 && argc > 1) {
 525                 if (strlen(*argv) == 3) {
 526                         argc--;
 527                         argv++;
 528                         err = __handle_cmd(&nlstate, II_PHY_NAME, argc, argv, &cmd);
 529                 } else if (*(*argv + 3) == '#')
 530                         err = __handle_cmd(&nlstate, II_PHY_IDX, argc, argv, &cmd);
 531                 else
 532                         goto detect;
 533         } else if (strcmp(*argv, "wdev") == 0 && argc > 1) {
 534                 argc--;
 535                 argv++;
 536                 err = __handle_cmd(&nlstate, II_WDEV, argc, argv, &cmd);
 537         } else {
 538                 int idx;
 539                 enum id_input idby = II_NONE;
 540  detect:
 541                 if ((idx = if_nametoindex(argv[0])) != 0)
 542                         idby = II_NETDEV;
 543                 else if ((idx = phy_lookup(argv[0])) >= 0)
 544                         idby = II_PHY_NAME;
 545                 err = __handle_cmd(&nlstate, idby, argc, argv, &cmd);
 546         }
 547
 548         if (err == 1) {
 549                 if (cmd)
 550                         usage_cmd(cmd);
 551                 else
 552                         usage(0, NULL);
 553         } else if (err < 0)
 554                 fprintf(stderr, "command failed: %s (%d)\n", strerror(-err), err);
 555
 556         nl80211_cleanup(&nlstate);
 557
 558         return err;
 559 }