phy.c

   1 #include <stdbool.h>
   2 #include <errno.h>
   3 #include <net/if.h>
   4 #include <strings.h>
   5
   6 #include <netlink/genl/genl.h>
   7 #include <netlink/genl/family.h>
   8 #include <netlink/genl/ctrl.h>
   9 #include <netlink/msg.h>
  10 #include <netlink/attr.h>
  11
  12 #include "nl80211.h"
  13 #include "iw.h"
  14
  15 static int handle_name(struct nl80211_state *state,
  16                        struct nl_cb *cb,
  17                        struct nl_msg *msg,
  18                        int argc, char **argv,
  19                        enum id_input id)
  20 {
  21         if (argc != 1)
  22                 return 1;
  23
  24         NLA_PUT_STRING(msg, NL80211_ATTR_WIPHY_NAME, *argv);
  25
  26         return 0;
  27  nla_put_failure:
  28         return -ENOBUFS;
  29 }
  30 COMMAND(set, name, "<new name>", NL80211_CMD_SET_WIPHY, 0, CIB_PHY, handle_name,
  31         "Rename this wireless device.");
  32
  33 static int handle_freqs(struct nl_msg *msg, int argc, char **argv)
  34 {
  35         static const struct {
  36                 const char *name;
  37                 unsigned int val;
  38         } bwmap[] = {
  39                 { .name = "20", .val = NL80211_CHAN_WIDTH_20, },
  40                 { .name = "40", .val = NL80211_CHAN_WIDTH_40, },
  41                 { .name = "80", .val = NL80211_CHAN_WIDTH_80, },
  42                 { .name = "80+80", .val = NL80211_CHAN_WIDTH_80P80, },
  43                 { .name = "160", .val = NL80211_CHAN_WIDTH_160, },
  44         };
  45         uint32_t freq;
  46         int i, bwval = NL80211_CHAN_WIDTH_20_NOHT;
  47         char *end;
  48
  49         if (argc < 1)
  50                 return 1;
  51
  52         for (i = 0; i < ARRAY_SIZE(bwmap); i++) {
  53                 if (strcasecmp(bwmap[i].name, argv[0]) == 0) {
  54                         bwval = bwmap[i].val;
  55                         break;
  56                 }
  57         }
  58
  59         if (bwval == NL80211_CHAN_WIDTH_20_NOHT)
  60                 return 1;
  61
  62         NLA_PUT_U32(msg, NL80211_ATTR_CHANNEL_WIDTH, bwval);
  63
  64         if (argc == 1)
  65                 return 0;
  66
  67         /* center freq 1 */
  68         if (!*argv[1])
  69                 return 1;
  70         freq = strtoul(argv[1], &end, 10);
  71         if (*end)
  72                 return 1;
  73         NLA_PUT_U32(msg, NL80211_ATTR_CENTER_FREQ1, freq);
  74
  75         if (argc == 2)
  76                 return 0;
  77
  78         /* center freq 2 */
  79         if (!*argv[2])
  80                 return 1;
  81         freq = strtoul(argv[2], &end, 10);
  82         if (*end)
  83                 return 1;
  84         NLA_PUT_U32(msg, NL80211_ATTR_CENTER_FREQ2, freq);
  85
  86         return 0;
  87  nla_put_failure:
  88         return -ENOBUFS;
  89 }
  90
  91 static int handle_freqchan(struct nl_msg *msg, bool chan,
  92                            int argc, char **argv)
  93 {
  94         char *end;
  95         static const struct {
  96                 const char *name;
  97                 unsigned int val;
  98         } htmap[] = {
  99                 { .name = "HT20", .val = NL80211_CHAN_HT20, },
 100                 { .name = "HT40+", .val = NL80211_CHAN_HT40PLUS, },
 101                 { .name = "HT40-", .val = NL80211_CHAN_HT40MINUS, },
 102         };
 103         unsigned int htval = NL80211_CHAN_NO_HT;
 104         unsigned int freq;
 105         int i;
 106
 107         if (!argc || argc > 4)
 108                 return 1;
 109
 110         if (!*argv[0])
 111                 return 1;
 112         freq = strtoul(argv[0], &end, 10);
 113         if (*end)
 114                 return 1;
 115
 116         if (chan) {
 117                 enum nl80211_band band;
 118                 band = freq <= 14 ? NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
 119                 freq = ieee80211_channel_to_frequency(freq, band);
 120         }
 121
 122         NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FREQ, freq);
 123
 124         if (argc > 2) {
 125                 return handle_freqs(msg, argc - 1, argv + 1);
 126         } else if (argc == 2) {
 127                 for (i = 0; i < ARRAY_SIZE(htmap); i++) {
 128                         if (strcasecmp(htmap[i].name, argv[1]) == 0) {
 129                                 htval = htmap[i].val;
 130                                 break;
 131                         }
 132                 }
 133                 if (htval == NL80211_CHAN_NO_HT)
 134                         return handle_freqs(msg, argc - 1, argv + 1);
 135         }
 136
 137         NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE, htval);
 138
 139         return 0;
 140  nla_put_failure:
 141         return -ENOBUFS;
 142 }
 143
 144 static int handle_freq(struct nl80211_state *state,
 145                        struct nl_cb *cb, struct nl_msg *msg,
 146                        int argc, char **argv,
 147                        enum id_input id)
 148 {
 149         return handle_freqchan(msg, false, argc, argv);
 150 }
 151 COMMAND(set, freq, "<freq> [HT20|HT40+|HT40-]",
 152         NL80211_CMD_SET_WIPHY, 0, CIB_PHY, handle_freq,
 153         "Set frequency/channel the hardware is using, including HT\n"
 154         "configuration.");
 155 COMMAND(set, freq, "<freq> [HT20|HT40+|HT40-]\n"
 156                    "<control freq> [20|40|80|80+80|160] [<center freq 1>] [<center freq 2>]",
 157         NL80211_CMD_SET_WIPHY, 0, CIB_NETDEV, handle_freq, NULL);
 158
 159 static int handle_chan(struct nl80211_state *state,
 160                        struct nl_cb *cb, struct nl_msg *msg,
 161                        int argc, char **argv,
 162                        enum id_input id)
 163 {
 164         return handle_freqchan(msg, true, argc, argv);
 165 }
 166 COMMAND(set, channel, "<channel> [HT20|HT40+|HT40-]",
 167         NL80211_CMD_SET_WIPHY, 0, CIB_PHY, handle_chan, NULL);
 168 COMMAND(set, channel, "<channel> [HT20|HT40+|HT40-]",
 169         NL80211_CMD_SET_WIPHY, 0, CIB_NETDEV, handle_chan, NULL);
 170
 171 static int handle_fragmentation(struct nl80211_state *state,
 172                                 struct nl_cb *cb, struct nl_msg *msg,
 173                                 int argc, char **argv,
 174                                 enum id_input id)
 175 {
 176         unsigned int frag;
 177
 178         if (argc != 1)
 179                 return 1;
 180
 181         if (strcmp("off", argv[0]) == 0)
 182                 frag = -1;
 183         else {
 184                 char *end;
 185
 186                 if (!*argv[0])
 187                         return 1;
 188                 frag = strtoul(argv[0], &end, 10);
 189                 if (*end != '\0')
 190                         return 1;
 191         }
 192
 193         NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD, frag);
 194
 195         return 0;
 196  nla_put_failure:
 197         return -ENOBUFS;
 198 }
 199 COMMAND(set, frag, "<fragmentation threshold|off>",
 200         NL80211_CMD_SET_WIPHY, 0, CIB_PHY, handle_fragmentation,
 201         "Set fragmentation threshold.");
 202
 203 static int handle_rts(struct nl80211_state *state,
 204                       struct nl_cb *cb, struct nl_msg *msg,
 205                       int argc, char **argv,
 206                       enum id_input id)
 207 {
 208         unsigned int rts;
 209
 210         if (argc != 1)
 211                 return 1;
 212
 213         if (strcmp("off", argv[0]) == 0)
 214                 rts = -1;
 215         else {
 216                 char *end;
 217
 218                 if (!*argv[0])
 219                         return 1;
 220                 rts = strtoul(argv[0], &end, 10);
 221                 if (*end != '\0')
 222                         return 1;
 223         }
 224
 225         NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD, rts);
 226
 227         return 0;
 228  nla_put_failure:
 229         return -ENOBUFS;
 230 }
 231 COMMAND(set, rts, "<rts threshold|off>",
 232         NL80211_CMD_SET_WIPHY, 0, CIB_PHY, handle_rts,
 233         "Set rts threshold.");
 234
 235 static int handle_netns(struct nl80211_state *state,
 236                         struct nl_cb *cb,
 237                         struct nl_msg *msg,
 238                         int argc, char **argv,
 239                         enum id_input id)
 240 {
 241         char *end;
 242
 243         if (argc != 1)
 244                 return 1;
 245
 246         if (!*argv[0])
 247                 return 1;
 248
 249         NLA_PUT_U32(msg, NL80211_ATTR_PID,
 250                     strtoul(argv[0], &end, 10));
 251
 252         if (*end != '\0')
 253                 return 1;
 254
 255         return 0;
 256  nla_put_failure:
 257         return -ENOBUFS;
 258 }
 259 COMMAND(set, netns, "<pid>",
 260         NL80211_CMD_SET_WIPHY_NETNS, 0, CIB_PHY, handle_netns,
 261         "Put this wireless device into a different network namespace");
 262
 263 static int handle_coverage(struct nl80211_state *state,
 264                         struct nl_cb *cb,
 265                         struct nl_msg *msg,
 266                         int argc, char **argv,
 267                         enum id_input id)
 268 {
 269         char *end;
 270         unsigned int coverage;
 271
 272         if (argc != 1)
 273                 return 1;
 274
 275         if (!*argv[0])
 276                 return 1;
 277         coverage = strtoul(argv[0], &end, 10);
 278         if (coverage > 255)
 279                 return 1;
 280
 281         if (*end)
 282                 return 1;
 283
 284         NLA_PUT_U8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS, coverage);
 285
 286         return 0;
 287  nla_put_failure:
 288         return -ENOBUFS;
 289 }
 290 COMMAND(set, coverage, "<coverage class>",
 291         NL80211_CMD_SET_WIPHY, 0, CIB_PHY, handle_coverage,
 292         "Set coverage class (1 for every 3 usec of air propagation time).\n"
 293         "Valid values: 0 - 255.");
 294
 295 static int handle_distance(struct nl80211_state *state,
 296                         struct nl_cb *cb,
 297                         struct nl_msg *msg,
 298                         int argc, char **argv,
 299                         enum id_input id)
 300 {
 301         char *end;
 302         unsigned int distance, coverage;
 303
 304         if (argc != 1)
 305                 return 1;
 306
 307         if (!*argv[0])
 308                 return 1;
 309
 310         distance = strtoul(argv[0], &end, 10);
 311
 312         if (*end)
 313                 return 1;
 314
 315         /*
 316          * Divide double the distance by the speed of light in m/usec (300) to
 317          * get round-trip time in microseconds and then divide the result by
 318          * three to get coverage class as specified in IEEE 802.11-2007 table
 319          * 7-27. Values are rounded upwards.
 320          */
 321         coverage = (distance + 449) / 450;
 322         if (coverage > 255)
 323                 return 1;
 324
 325         NLA_PUT_U8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS, coverage);
 326
 327         return 0;
 328  nla_put_failure:
 329         return -ENOBUFS;
 330 }
 331 COMMAND(set, distance, "<distance>",
 332         NL80211_CMD_SET_WIPHY, 0, CIB_PHY, handle_distance,
 333         "Set appropriate coverage class for given link distance in meters.\n"
 334         "Valid values: 0 - 114750");
 335
 336 static int handle_txpower(struct nl80211_state *state,
 337                           struct nl_cb *cb,
 338                           struct nl_msg *msg,
 339                           int argc, char **argv,
 340                           enum id_input id)
 341 {
 342         enum nl80211_tx_power_setting type;
 343         int mbm;
 344
 345         /* get the required args */
 346         if (argc != 1 && argc != 2)
 347                 return 1;
 348
 349         if (!strcmp(argv[0], "auto"))
 350                 type = NL80211_TX_POWER_AUTOMATIC;
 351         else if (!strcmp(argv[0], "fixed"))
 352                 type = NL80211_TX_POWER_FIXED;
 353         else if (!strcmp(argv[0], "limit"))
 354                 type = NL80211_TX_POWER_LIMITED;
 355         else {
 356                 printf("Invalid parameter: %s\n", argv[0]);
 357                 return 2;
 358         }
 359
 360         NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_TX_POWER_SETTING, type);
 361
 362         if (type != NL80211_TX_POWER_AUTOMATIC) {
 363                 char *endptr;
 364                 if (argc != 2) {
 365                         printf("Missing TX power level argument.\n");
 366                         return 2;
 367                 }
 368
 369                 mbm = strtol(argv[1], &endptr, 10);
 370                 if (*endptr)
 371                         return 2;
 372                 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_TX_POWER_LEVEL, mbm);
 373         } else if (argc != 1)
 374                 return 1;
 375
 376         return 0;
 377
 378  nla_put_failure:
 379         return -ENOBUFS;
 380 }
 381 COMMAND(set, txpower, "<auto|fixed|limit> [<tx power in mBm>]",
 382         NL80211_CMD_SET_WIPHY, 0, CIB_PHY, handle_txpower,
 383         "Specify transmit power level and setting type.");
 384 COMMAND(set, txpower, "<auto|fixed|limit> [<tx power in mBm>]",
 385         NL80211_CMD_SET_WIPHY, 0, CIB_NETDEV, handle_txpower,
 386         "Specify transmit power level and setting type.");
 387
 388 static int handle_antenna(struct nl80211_state *state,
 389                           struct nl_cb *cb,
 390                           struct nl_msg *msg,
 391                           int argc, char **argv,
 392                           enum id_input id)
 393 {
 394         char *end;
 395         uint32_t tx_ant = 0, rx_ant = 0;
 396
 397         if (argc == 1 && strcmp(argv[0], "all") == 0) {
 398                 tx_ant = 0xffffffff;
 399                 rx_ant = 0xffffffff;
 400         } else if (argc == 1) {
 401                 tx_ant = rx_ant = strtoul(argv[0], &end, 0);
 402                 if (*end)
 403                         return 1;
 404         }
 405         else if (argc == 2) {
 406                 tx_ant = strtoul(argv[0], &end, 0);
 407                 if (*end)
 408                         return 1;
 409                 rx_ant = strtoul(argv[1], &end, 0);
 410                 if (*end)
 411                         return 1;
 412         } else
 413                 return 1;
 414
 415         NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_ANTENNA_TX, tx_ant);
 416         NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_ANTENNA_RX, rx_ant);
 417
 418         return 0;
 419
 420  nla_put_failure:
 421         return -ENOBUFS;
 422 }
 423 COMMAND(set, antenna, "<bitmap> | all | <tx bitmap> <rx bitmap>",
 424         NL80211_CMD_SET_WIPHY, 0, CIB_PHY, handle_antenna,
 425         "Set a bitmap of allowed antennas to use for TX and RX.\n"
 426         "The driver may reject antenna configurations it cannot support.");