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