nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 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.");