Johannes Berg | 379f839 | 2008-12-08 12:53:58 +0100 | [diff] [blame] | 1 | #include <stdbool.h> |
Johannes Berg | 0f55e0b | 2008-09-16 17:40:48 +0200 | [diff] [blame] | 2 | #include <errno.h> |
Johannes Berg | 0f55e0b | 2008-09-16 17:40:48 +0200 | [diff] [blame] | 3 | #include <net/if.h> |
| 4 | |
| 5 | #include <netlink/genl/genl.h> |
| 6 | #include <netlink/genl/family.h> |
| 7 | #include <netlink/genl/ctrl.h> |
| 8 | #include <netlink/msg.h> |
| 9 | #include <netlink/attr.h> |
| 10 | |
Johannes Berg | f408e01 | 2008-09-18 19:32:11 +0200 | [diff] [blame] | 11 | #include "nl80211.h" |
Johannes Berg | 0f55e0b | 2008-09-16 17:40:48 +0200 | [diff] [blame] | 12 | #include "iw.h" |
| 13 | |
Johannes Berg | 7c37a24 | 2009-04-08 13:13:28 +0200 | [diff] [blame] | 14 | static int handle_name(struct nl80211_state *state, |
| 15 | struct nl_cb *cb, |
Johannes Berg | 0f55e0b | 2008-09-16 17:40:48 +0200 | [diff] [blame] | 16 | struct nl_msg *msg, |
| 17 | int argc, char **argv) |
| 18 | { |
Johannes Berg | 0f55e0b | 2008-09-16 17:40:48 +0200 | [diff] [blame] | 19 | if (argc != 1) |
Johannes Berg | 5e75fd0 | 2008-09-16 18:13:12 +0200 | [diff] [blame] | 20 | return 1; |
Johannes Berg | 0f55e0b | 2008-09-16 17:40:48 +0200 | [diff] [blame] | 21 | |
| 22 | NLA_PUT_STRING(msg, NL80211_ATTR_WIPHY_NAME, *argv); |
| 23 | |
Johannes Berg | 70391cc | 2008-09-16 18:35:06 +0200 | [diff] [blame] | 24 | return 0; |
Johannes Berg | 0f55e0b | 2008-09-16 17:40:48 +0200 | [diff] [blame] | 25 | nla_put_failure: |
Johannes Berg | 70391cc | 2008-09-16 18:35:06 +0200 | [diff] [blame] | 26 | return -ENOBUFS; |
Johannes Berg | 0f55e0b | 2008-09-16 17:40:48 +0200 | [diff] [blame] | 27 | } |
Johannes Berg | cea8fa1 | 2009-05-05 15:05:10 +0200 | [diff] [blame] | 28 | COMMAND(set, name, "<new name>", NL80211_CMD_SET_WIPHY, 0, CIB_PHY, handle_name, |
| 29 | "Rename this wireless device."); |
Johannes Berg | b822cda | 2008-12-08 12:43:42 +0100 | [diff] [blame] | 30 | |
Johannes Berg | 379f839 | 2008-12-08 12:53:58 +0100 | [diff] [blame] | 31 | static int handle_freqchan(struct nl_msg *msg, bool chan, |
| 32 | int argc, char **argv) |
Johannes Berg | b822cda | 2008-12-08 12:43:42 +0100 | [diff] [blame] | 33 | { |
Johannes Berg | e86b7e0 | 2010-04-01 18:49:21 +0200 | [diff] [blame] | 34 | char *end; |
Johannes Berg | b822cda | 2008-12-08 12:43:42 +0100 | [diff] [blame] | 35 | static const struct { |
| 36 | const char *name; |
| 37 | unsigned int val; |
| 38 | } htmap[] = { |
Johannes Berg | 68632dc | 2008-12-12 22:40:45 +0100 | [diff] [blame] | 39 | { .name = "HT20", .val = NL80211_CHAN_HT20, }, |
| 40 | { .name = "HT40+", .val = NL80211_CHAN_HT40PLUS, }, |
| 41 | { .name = "HT40-", .val = NL80211_CHAN_HT40MINUS, }, |
Johannes Berg | b822cda | 2008-12-08 12:43:42 +0100 | [diff] [blame] | 42 | }; |
Johannes Berg | 68632dc | 2008-12-12 22:40:45 +0100 | [diff] [blame] | 43 | unsigned int htval = NL80211_CHAN_NO_HT; |
Johannes Berg | b822cda | 2008-12-08 12:43:42 +0100 | [diff] [blame] | 44 | unsigned int freq; |
| 45 | int i; |
| 46 | |
| 47 | if (!argc || argc > 2) |
| 48 | return 1; |
| 49 | |
| 50 | if (argc == 2) { |
Johannes Berg | 7d73601 | 2008-12-08 12:59:16 +0100 | [diff] [blame] | 51 | for (i = 0; i < ARRAY_SIZE(htmap); i++) { |
Johannes Berg | b822cda | 2008-12-08 12:43:42 +0100 | [diff] [blame] | 52 | if (strcasecmp(htmap[i].name, argv[1]) == 0) { |
| 53 | htval = htmap[i].val; |
| 54 | break; |
| 55 | } |
| 56 | } |
Johannes Berg | 68632dc | 2008-12-12 22:40:45 +0100 | [diff] [blame] | 57 | if (htval == NL80211_CHAN_NO_HT) |
Johannes Berg | b822cda | 2008-12-08 12:43:42 +0100 | [diff] [blame] | 58 | return 1; |
| 59 | } |
| 60 | |
Johannes Berg | e86b7e0 | 2010-04-01 18:49:21 +0200 | [diff] [blame] | 61 | if (!*argv[0]) |
| 62 | return 1; |
| 63 | freq = strtoul(argv[0], &end, 10); |
| 64 | if (*end) |
| 65 | return 1; |
| 66 | |
Johannes Berg | 379f839 | 2008-12-08 12:53:58 +0100 | [diff] [blame] | 67 | if (chan) |
| 68 | freq = ieee80211_channel_to_frequency(freq); |
Johannes Berg | b822cda | 2008-12-08 12:43:42 +0100 | [diff] [blame] | 69 | |
| 70 | NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FREQ, freq); |
Johannes Berg | 68632dc | 2008-12-12 22:40:45 +0100 | [diff] [blame] | 71 | NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE, htval); |
Johannes Berg | b822cda | 2008-12-08 12:43:42 +0100 | [diff] [blame] | 72 | |
| 73 | return 0; |
| 74 | nla_put_failure: |
| 75 | return -ENOBUFS; |
| 76 | } |
Johannes Berg | 379f839 | 2008-12-08 12:53:58 +0100 | [diff] [blame] | 77 | |
Johannes Berg | 7c37a24 | 2009-04-08 13:13:28 +0200 | [diff] [blame] | 78 | static int handle_freq(struct nl80211_state *state, |
| 79 | struct nl_cb *cb, struct nl_msg *msg, |
Johannes Berg | 379f839 | 2008-12-08 12:53:58 +0100 | [diff] [blame] | 80 | int argc, char **argv) |
| 81 | { |
| 82 | return handle_freqchan(msg, false, argc, argv); |
| 83 | } |
Johannes Berg | b822cda | 2008-12-08 12:43:42 +0100 | [diff] [blame] | 84 | COMMAND(set, freq, "<freq> [HT20|HT40+|HT40-]", |
Johannes Berg | 00c448b | 2009-05-05 15:04:19 +0200 | [diff] [blame] | 85 | NL80211_CMD_SET_WIPHY, 0, CIB_PHY, handle_freq, |
| 86 | "Set frequency/channel the hardware is using, including HT\n" |
| 87 | "configuration."); |
Johannes Berg | b822cda | 2008-12-08 12:43:42 +0100 | [diff] [blame] | 88 | COMMAND(set, freq, "<freq> [HT20|HT40+|HT40-]", |
Johannes Berg | 01ae06f | 2009-05-05 14:48:16 +0200 | [diff] [blame] | 89 | NL80211_CMD_SET_WIPHY, 0, CIB_NETDEV, handle_freq, NULL); |
Johannes Berg | 379f839 | 2008-12-08 12:53:58 +0100 | [diff] [blame] | 90 | |
Johannes Berg | 7c37a24 | 2009-04-08 13:13:28 +0200 | [diff] [blame] | 91 | static int handle_chan(struct nl80211_state *state, |
| 92 | struct nl_cb *cb, struct nl_msg *msg, |
Johannes Berg | 379f839 | 2008-12-08 12:53:58 +0100 | [diff] [blame] | 93 | int argc, char **argv) |
| 94 | { |
| 95 | return handle_freqchan(msg, true, argc, argv); |
| 96 | } |
| 97 | COMMAND(set, channel, "<channel> [HT20|HT40+|HT40-]", |
Johannes Berg | 01ae06f | 2009-05-05 14:48:16 +0200 | [diff] [blame] | 98 | NL80211_CMD_SET_WIPHY, 0, CIB_PHY, handle_chan, NULL); |
Johannes Berg | 379f839 | 2008-12-08 12:53:58 +0100 | [diff] [blame] | 99 | COMMAND(set, channel, "<channel> [HT20|HT40+|HT40-]", |
Johannes Berg | 01ae06f | 2009-05-05 14:48:16 +0200 | [diff] [blame] | 100 | NL80211_CMD_SET_WIPHY, 0, CIB_NETDEV, handle_chan, NULL); |
Johannes Berg | 625aa4a | 2009-08-11 11:26:42 +0200 | [diff] [blame] | 101 | |
| 102 | static int handle_fragmentation(struct nl80211_state *state, |
| 103 | struct nl_cb *cb, struct nl_msg *msg, |
| 104 | int argc, char **argv) |
| 105 | { |
| 106 | unsigned int frag; |
| 107 | |
| 108 | if (argc != 1) |
| 109 | return 1; |
| 110 | |
| 111 | if (strcmp("off", argv[0]) == 0) |
| 112 | frag = -1; |
Johannes Berg | e86b7e0 | 2010-04-01 18:49:21 +0200 | [diff] [blame] | 113 | else { |
| 114 | char *end; |
| 115 | |
| 116 | if (!*argv[0]) |
| 117 | return 1; |
| 118 | frag = strtoul(argv[0], &end, 10); |
| 119 | if (*end != '\0') |
| 120 | return 1; |
| 121 | } |
Johannes Berg | 625aa4a | 2009-08-11 11:26:42 +0200 | [diff] [blame] | 122 | |
| 123 | NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD, frag); |
| 124 | |
| 125 | return 0; |
| 126 | nla_put_failure: |
| 127 | return -ENOBUFS; |
| 128 | } |
| 129 | COMMAND(set, frag, "<fragmentation threshold|off>", |
| 130 | NL80211_CMD_SET_WIPHY, 0, CIB_PHY, handle_fragmentation, |
| 131 | "Set fragmentation threshold."); |
| 132 | |
| 133 | static int handle_rts(struct nl80211_state *state, |
| 134 | struct nl_cb *cb, struct nl_msg *msg, |
| 135 | int argc, char **argv) |
| 136 | { |
| 137 | unsigned int rts; |
| 138 | |
| 139 | if (argc != 1) |
| 140 | return 1; |
| 141 | |
| 142 | if (strcmp("off", argv[0]) == 0) |
| 143 | rts = -1; |
Johannes Berg | e86b7e0 | 2010-04-01 18:49:21 +0200 | [diff] [blame] | 144 | else { |
| 145 | char *end; |
| 146 | |
| 147 | if (!*argv[0]) |
| 148 | return 1; |
| 149 | rts = strtoul(argv[0], &end, 10); |
| 150 | if (*end != '\0') |
| 151 | return 1; |
| 152 | } |
Johannes Berg | 625aa4a | 2009-08-11 11:26:42 +0200 | [diff] [blame] | 153 | |
| 154 | NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD, rts); |
| 155 | |
| 156 | return 0; |
| 157 | nla_put_failure: |
| 158 | return -ENOBUFS; |
| 159 | } |
| 160 | COMMAND(set, rts, "<rts threshold|off>", |
| 161 | NL80211_CMD_SET_WIPHY, 0, CIB_PHY, handle_rts, |
| 162 | "Set rts threshold."); |
Johannes Berg | e960e06 | 2009-09-24 20:18:47 +0200 | [diff] [blame] | 163 | |
| 164 | static int handle_netns(struct nl80211_state *state, |
| 165 | struct nl_cb *cb, |
| 166 | struct nl_msg *msg, |
| 167 | int argc, char **argv) |
| 168 | { |
| 169 | char *end; |
| 170 | |
| 171 | if (argc != 1) |
| 172 | return 1; |
| 173 | |
Johannes Berg | e86b7e0 | 2010-04-01 18:49:21 +0200 | [diff] [blame] | 174 | if (!*argv[0]) |
| 175 | return 1; |
| 176 | |
Johannes Berg | e960e06 | 2009-09-24 20:18:47 +0200 | [diff] [blame] | 177 | NLA_PUT_U32(msg, NL80211_ATTR_PID, |
| 178 | strtoul(argv[0], &end, 10)); |
| 179 | |
| 180 | if (*end != '\0') |
| 181 | return 1; |
| 182 | |
| 183 | return 0; |
| 184 | nla_put_failure: |
| 185 | return -ENOBUFS; |
| 186 | } |
| 187 | COMMAND(set, netns, "<pid>", |
| 188 | NL80211_CMD_SET_WIPHY_NETNS, 0, CIB_PHY, handle_netns, |
| 189 | "Put this wireless device into a different network namespace"); |
Lukáš Turek | b2f92dd | 2010-02-17 21:13:23 -0500 | [diff] [blame] | 190 | |
| 191 | static int handle_coverage(struct nl80211_state *state, |
| 192 | struct nl_cb *cb, |
| 193 | struct nl_msg *msg, |
| 194 | int argc, char **argv) |
| 195 | { |
Johannes Berg | e86b7e0 | 2010-04-01 18:49:21 +0200 | [diff] [blame] | 196 | char *end; |
Lukáš Turek | b2f92dd | 2010-02-17 21:13:23 -0500 | [diff] [blame] | 197 | unsigned int coverage; |
| 198 | |
| 199 | if (argc != 1) |
| 200 | return 1; |
| 201 | |
Johannes Berg | e86b7e0 | 2010-04-01 18:49:21 +0200 | [diff] [blame] | 202 | if (!*argv[0]) |
| 203 | return 1; |
| 204 | coverage = strtoul(argv[0], &end, 10); |
Lukáš Turek | b2f92dd | 2010-02-17 21:13:23 -0500 | [diff] [blame] | 205 | if (coverage > 255) |
| 206 | return 1; |
| 207 | |
Johannes Berg | e86b7e0 | 2010-04-01 18:49:21 +0200 | [diff] [blame] | 208 | if (*end) |
| 209 | return 1; |
| 210 | |
Lukáš Turek | b2f92dd | 2010-02-17 21:13:23 -0500 | [diff] [blame] | 211 | NLA_PUT_U8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS, coverage); |
| 212 | |
| 213 | return 0; |
| 214 | nla_put_failure: |
| 215 | return -ENOBUFS; |
| 216 | } |
| 217 | COMMAND(set, coverage, "<coverage class>", |
| 218 | NL80211_CMD_SET_WIPHY, 0, CIB_PHY, handle_coverage, |
| 219 | "Set coverage class (1 for every 3 usec of air propagation time).\n" |
| 220 | "Valid values: 0 - 255."); |
| 221 | |
| 222 | static int handle_distance(struct nl80211_state *state, |
| 223 | struct nl_cb *cb, |
| 224 | struct nl_msg *msg, |
| 225 | int argc, char **argv) |
| 226 | { |
Johannes Berg | e86b7e0 | 2010-04-01 18:49:21 +0200 | [diff] [blame] | 227 | char *end; |
Lukáš Turek | b2f92dd | 2010-02-17 21:13:23 -0500 | [diff] [blame] | 228 | unsigned int distance, coverage; |
| 229 | |
| 230 | if (argc != 1) |
| 231 | return 1; |
| 232 | |
Johannes Berg | e86b7e0 | 2010-04-01 18:49:21 +0200 | [diff] [blame] | 233 | if (!*argv[0]) |
| 234 | return 1; |
| 235 | |
| 236 | distance = strtoul(argv[0], &end, 10); |
| 237 | |
| 238 | if (*end) |
| 239 | return 1; |
Lukáš Turek | b2f92dd | 2010-02-17 21:13:23 -0500 | [diff] [blame] | 240 | |
| 241 | /* |
| 242 | * Divide double the distance by the speed of light in m/usec (300) to |
| 243 | * get round-trip time in microseconds and then divide the result by |
| 244 | * three to get coverage class as specified in IEEE 802.11-2007 table |
| 245 | * 7-27. Values are rounded upwards. |
| 246 | */ |
| 247 | coverage = (distance + 449) / 450; |
| 248 | if (coverage > 255) |
| 249 | return 1; |
| 250 | |
| 251 | NLA_PUT_U8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS, coverage); |
| 252 | |
| 253 | return 0; |
| 254 | nla_put_failure: |
| 255 | return -ENOBUFS; |
| 256 | } |
| 257 | COMMAND(set, distance, "<distance>", |
| 258 | NL80211_CMD_SET_WIPHY, 0, CIB_PHY, handle_distance, |
| 259 | "Set appropriate coverage class for given link distance in meters.\n" |
| 260 | "Valid values: 0 - 114750"); |
Juuso Oikarinen | a0b1f57 | 2010-06-23 12:12:57 +0300 | [diff] [blame^] | 261 | |
| 262 | static int handle_txpower(struct nl80211_state *state, |
| 263 | struct nl_cb *cb, |
| 264 | struct nl_msg *msg, |
| 265 | int argc, char **argv) |
| 266 | { |
| 267 | enum nl80211_tx_power_setting type; |
| 268 | int mbm; |
| 269 | |
| 270 | /* get the required args */ |
| 271 | if (argc != 1 && argc != 2) |
| 272 | return 1; |
| 273 | |
| 274 | if (!strcmp(argv[0], "auto")) |
| 275 | type = NL80211_TX_POWER_AUTOMATIC; |
| 276 | else if (!strcmp(argv[0], "fixed")) |
| 277 | type = NL80211_TX_POWER_FIXED; |
| 278 | else if (!strcmp(argv[0], "limit")) |
| 279 | type = NL80211_TX_POWER_LIMITED; |
| 280 | else { |
| 281 | printf("Invalid parameter: %s\n", argv[0]); |
| 282 | return 2; |
| 283 | } |
| 284 | |
| 285 | NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_TX_POWER_SETTING, type); |
| 286 | |
| 287 | if (type != NL80211_TX_POWER_AUTOMATIC) { |
| 288 | if (argc != 2) { |
| 289 | printf("Missing TX power level argument.\n"); |
| 290 | return 2; |
| 291 | } |
| 292 | |
| 293 | mbm = atoi(argv[1]); |
| 294 | NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_TX_POWER_LEVEL, mbm); |
| 295 | } else if (argc != 1) |
| 296 | return 1; |
| 297 | |
| 298 | return 0; |
| 299 | |
| 300 | nla_put_failure: |
| 301 | return -ENOBUFS; |
| 302 | } |
| 303 | COMMAND(set, txpower, "<auto|fixed|limit> [<tx power in mBm>]", |
| 304 | NL80211_CMD_SET_WIPHY, 0, CIB_PHY, handle_txpower, |
| 305 | "Specify transmit power level and setting type."); |
| 306 | COMMAND(set, txpower, "<auto|fixed|limit> [<tx power in mBm>]", |
| 307 | NL80211_CMD_SET_WIPHY, 0, CIB_NETDEV, handle_txpower, |
| 308 | "Specify transmit power level and setting type."); |